@afora/core 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,4145 +1,346 @@
-// 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";
-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}`;
-}
-
-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);
-  }
-  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 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 Demo = Symbol("demo");
-
-// src/core/property/lineage.ts
-var lineages = new WeakMap;
-function recordPropertyLineage(Property, lineage) {
-  if (!lineages.has(Property))
-    lineages.set(Property, lineage);
-}
-function propertyLineageOf(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,
-    [Demo]: settings.default ?? examples?.[0] ?? base[Demo],
-    schema: new SchemaConstructor
-  };
-  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 Kind = Symbol("kind");
-
-// src/core/blueprint/is-blueprint.ts
-function isBlueprint(value) {
-  return typeof value === "object" && value !== null && value[Kind] === "blueprint";
-}
-
-// src/core/blueprint/record-field.ts
-function isRecordClass(value) {
-  return typeof value === "function" && value[Kind] === "record";
-}
-function isOptionalRecord(value) {
-  return typeof value === "object" && value !== null && value[Kind] === "record";
-}
-function recordFieldOf(field) {
-  if (isRecordClass(field))
-    return { record: field, optional: false };
-  if (isOptionalRecord(field))
-    return field;
-  return;
-}
-
-// src/core/parse/issue.ts
-function withLazyCause(issue, build) {
-  let cause;
-  return Object.defineProperty(issue, "cause", {
-    get: () => {
-      cause ??= build();
-      return cause;
-    },
-    enumerable: false,
-    configurable: true
-  });
-}
-function movedIssue(issue, path) {
-  const moved = { ...issue, path };
-  const cause = Object.getOwnPropertyDescriptor(issue, "cause");
-  if (cause && !cause.enumerable)
-    Object.defineProperty(moved, "cause", cause);
-  return moved;
-}
-
-// src/core/parse/parse.ts
-var NO_KEY = Symbol("no key");
-function pathAt(parent, key) {
-  return key === NO_KEY ? parent : [...parent, key];
-}
-function rejection(code, message, path, source) {
-  return { issues: [{ code, message, path, source }] };
-}
-function underPath(result, path) {
-  if (!result.issues)
-    return result;
-  return {
-    issues: result.issues.map((issue) => movedIssue(issue, [...path, ...issue.path]))
-  };
-}
-function ownIssuesUnderPath(result, path) {
-  if (!result.issues)
-    return result;
-  if (result.issues.some((issue) => Object.isFrozen(issue))) {
-    return underPath(result, path);
-  }
-  for (const issue of result.issues) {
-    issue.path = [...path, ...issue.path];
-  }
-  return result;
-}
-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;
-}
-function parseCollection(properties, value, path, source) {
-  return collectionAt(properties, value, path, NO_KEY, source);
-}
-function collectionAt(properties, value, parent, key, source) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return rejection("invalid_type", "must be an object", pathAt(parent, key), source);
-  }
-  let issues;
-  const path = pathAt(parent, key);
-  for (const name of Object.keys(value)) {
-    if (Object.hasOwn(properties, name))
-      continue;
-    issues ??= [];
-    issues.push({
-      code: "undeclared_key",
-      message: "is not declared",
-      path: [...path, name],
-      source
-    });
-  }
-  const handled = {};
-  for (const [name, field] of fieldsOf(properties)) {
-    const result = fieldAt(field, value[name], path, name, source);
-    if (result.issues) {
-      issues ??= [];
-      issues.push(...result.issues);
-    } else if (result.value !== undefined)
-      handled[name] = result.value;
-  }
-  return issues ? { issues } : { value: Object.freeze(handled) };
-}
-function parseField(field, value, path, source) {
-  return fieldAt(field, value, path, NO_KEY, source);
-}
-function fieldAt(field, value, parent, key, source) {
-  const required = () => rejection("required", "is required", pathAt(parent, key), source);
-  if (isBlueprintList(field)) {
-    if (value === undefined)
-      return field.optional ? { value } : required();
-    if (!Array.isArray(value)) {
-      return rejection("invalid_type", "must be an array", pathAt(parent, key), source);
-    }
-    const { minItems, maxItems } = field;
-    const path = pathAt(parent, key);
-    let issues;
-    if (minItems !== undefined && value.length < minItems) {
-      issues ??= [];
-      issues.push({
-        code: "too_few_items",
-        message: `must have at least ${minItems} items`,
-        path,
-        source
-      });
-    }
-    if (maxItems !== undefined && value.length > maxItems) {
-      issues ??= [];
-      issues.push({
-        code: "too_many_items",
-        message: `must have at most ${maxItems} items`,
-        path,
-        source
-      });
-    }
-    const items = [];
-    for (const [index, item] of value.entries()) {
-      const result = fieldAt(field.item, item, path, index, source);
-      if (result.issues) {
-        issues ??= [];
-        issues.push(...result.issues);
-      } else
-        items.push(result.value);
-    }
-    return issues ? { issues } : { value: Object.freeze(items) };
-  }
-  if (isBlueprint(field)) {
-    if (value === undefined)
-      return field.optional ? { value } : required();
-    return collectionAt(field.properties, value, parent, key, source);
-  }
-  const record = recordFieldOf(field);
-  if (record) {
-    if (value === undefined)
-      return record.optional ? { value } : required();
-    if (value instanceof record.record)
-      return { value };
-    if (!isPlainObject(value)) {
-      return rejection("not_record", `must be an instance of record "${record.record.name}"`, pathAt(parent, key), source);
-    }
-    const result = record.record.safeParse(value);
-    return result.issues ? underPath(result, pathAt(parent, key)) : result;
-  }
-  if (isProperty(field)) {
-    const result = field.safeParse(value);
-    return result.issues ? ownIssuesUnderPath(result, pathAt(parent, key)) : result;
-  }
-  return rejection("undeclared_key", "is not declared", pathAt(parent, key), source);
-}
-
-// 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: (value) => parse(value)
-  });
-}
-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/blueprint/list.ts
-function listOf(item, { minItems, maxItems } = {}) {
-  return standardListOf({
-    [Kind]: "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[Kind] === "list";
-}
-
-// src/core/exception/enums/exception-layers.ts
-var ExceptionLayers;
-((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";
-})(ExceptionLayers ||= {});
-
-// src/core/exception/exception.ts
-var UNEXPECTED_ERROR = "UnexpectedError";
-
-class Exception 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 Exception)
-      return error;
-    return new Exception({
-      ...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
-  }) {
-    return new Exception({
-      layer,
-      source,
-      name,
-      message,
-      details,
-      cause: this
-    });
-  }
-  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 Exception; current = current.cause) {
-      chain.push(current);
-    }
-    return chain;
-  }
-}
-function exceptionOf({
-  layer,
-  name,
-  message
-}) {
-
-  class DeclaredException extends Exception {
-    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 });
-  return DeclaredException;
-}
-
-// src/core/record/exceptions.ts
-var InvalidRecordValue = exceptionOf({
-  layer: "record" /* Record */,
-  name: "InvalidRecordValue",
-  message: ({
-    key,
-    errors
-  }, source) => `Invalid value for ${key ? `"${key}" of ` : ""}record "${source}": ${errors.join("; ")}`
-});
-var UndeclaredRecordProperty = exceptionOf({
-  layer: "record" /* Record */,
-  name: "UndeclaredRecordProperty",
-  message: ({ key }, source) => `Property "${key}" is not declared in record "${source}".`
-});
-var ReservedRecordKey = exceptionOf({
-  layer: "record" /* Record */,
-  name: "ReservedRecordKey",
-  message: ({ key }, source) => `"${key}" is a member of record "${source}" and cannot be a key of its blueprint.`
-});
-var InvalidRecordPlugin = exceptionOf({
-  layer: "record" /* Record */,
-  name: "InvalidRecordPlugin",
-  message: ({ reason }, source) => `Invalid record plugin "${source}": ${reason}.`
-});
-var RecordPluginConflict = exceptionOf({
-  layer: "record" /* Record */,
-  name: "RecordPluginConflict",
-  message: ({
-    plugin,
-    key,
-    owner
-  }, source) => `Plugin "${plugin}" of record "${source}" adds "${key}", which ${owner} already has.`
-});
-var UnknownRecordPlugin = exceptionOf({
-  layer: "record" /* Record */,
-  name: "UnknownRecordPlugin",
-  message: ({ name }) => `No record plugin named "${name}" in the catalog.`
-});
-var IncompatibleRecordPlugin = exceptionOf({
-  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 MASK = "********";
-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 MASK;
-}
-function maskField(field, value, sensitive) {
-  if (value === undefined)
-    return value;
-  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);
-  }
-  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 RESERVED_RECORD_KEYS = Object.freeze([
-  "blueprint",
-  "options",
-  "onSet",
-  "onSetAll",
-  "set",
-  "toJSON",
-  ...Object.getOwnPropertyNames(Object.prototype)
-]);
-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, keys) {
-  const Class = record.constructor;
-  if (checked.has(Class))
-    return;
-  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 ReservedRecordKey({ source: Class.name, details: { key } });
-    }
-  }
-  checked.add(Class);
-}
-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 UndeclaredRecordProperty({
-      source,
-      details: withIssues({ key }, issues)
-    });
-  }
-  return new InvalidRecordValue({
-    source,
-    details: withIssues({ key, errors: [first.message] }, issues)
-  });
-}
-function issuesOfError(error, source) {
-  const issues = error?.details?.issues;
-  if (error instanceof Exception && issues)
-    return issues;
-  const cause = Exception.from(error, {
-    layer: "record" /* Record */,
-    source
-  });
-  return [
-    {
-      code: "invalid_value",
-      message: cause.message,
-      path: [],
-      source,
-      cause
-    }
-  ];
-}
-function parseRecord(Class, value) {
-  if (value instanceof Class)
-    return { value };
-  try {
-    return { value: new Class(value) };
-  } catch (error) {
-    return { issues: issuesOfError(error, Class.name) };
-  }
-}
-function recordValue(record) {
-  return values.get(record);
-}
-function recordDataOf(record, options) {
-  const { properties } = record.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 (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);
-  }
-  return value;
-}
-function storeRecordValue(record, key, value) {
-  const source = record.constructor.name;
-  const { properties } = record.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 {
-  blueprint;
-  options;
-  constructor(value) {
-    ({ blueprint: this.blueprint, options: this.options } = this.constructor);
-    checkMembers(this, Object.keys(this.blueprint.properties));
-    const source = this.constructor.name;
-    const result = parseCollection(this.blueprint.properties, value, [], source);
-    if (result.issues)
-      throw exceptionOfIssues(result.issues, source);
-    values.set(this, result.value);
-  }
-  static safeParse(value) {
-    return parseRecord(this, value);
-  }
-  static get "~standard"() {
-    return standardOfClass(this);
-  }
-  toJSON() {
-    return maskCollection(this.blueprint.properties, recordValue(this), this.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/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)];
-}
-var HOOKS = ["onSet", "onSetAll"];
-var internals = new WeakMap;
-function pluginsOf(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[Kind] === "record-plugin";
-}
-function hasPlugin(value, plugin) {
-  const plugins = pluginsOf(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_KEYS.includes(member)) {
-        throw new InvalidRecordPlugin({
-          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 recordPluginOf(name, Record, { version = "1.0.0", description } = {}) {
-  if (typeof name !== "string" || name.length === 0) {
-    throw new InvalidRecordPlugin({
-      source: String(name),
-      details: { reason: "its name must be a non-empty string" }
-    });
-  }
-  if (!isRecordClass(Record)) {
-    throw new InvalidRecordPlugin({
-      source: name,
-      details: { reason: "it must be made from a class of `recordOf`" }
-    });
-  }
-  if (Record[IdentifiedRecord]) {
-    throw new InvalidRecordPlugin({
-      source: name,
-      details: {
-        reason: "it must be made from a record, not an entity: plugins have no identity"
-      }
-    });
-  }
-  if (!isVersion(version)) {
-    throw new InvalidRecordPlugin({
-      source: name,
-      details: { reason: `"${version}" is not a semantic version` }
-    });
-  }
-  const requires = pluginsOf(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({
-    [Kind]: "record-plugin",
-    name,
-    version,
-    ...description === undefined ? {} : { description },
-    record: Record,
-    keys,
-    members: Object.freeze(Object.keys(own.descriptors)),
-    options: declaration.options,
-    requires,
-    is: (value) => hasPlugin(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 InvalidRecordPlugin({
-        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 RecordPluginConflict({
-          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 RecordPluginConflict({
-        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 recordBuilderOf(...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 recordOf = recordBuilderOf();
-function declareRecord(Base, declared, { plugins = [], ...declaredOptions }, name, reserved = [], context = {}) {
-  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 UndeclaredRecordProperty({
-        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 RecordPluginConflict({
-        source: name,
-        details: {
-          plugin: plugin.name,
-          key: member,
-          owner: `record "${name}" (the \`change\` namespace)`
-        }
-      });
-    }
-  }
-  for (const key of keys) {
-    if (RESERVED_RECORD_KEYS.includes(key) || reserved.includes(key) || methods.includes(key)) {
-      throw new ReservedRecordKey({ 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 [Kind] = "record";
-    static blueprint = blueprint;
-    static options = options;
-    static plugins = applied.plugins;
-    static [RecordPlugins] = applied.plugins;
-    static [RecordPluginHooks] = applied.hooks;
-  }
-  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 ReservedEntityKey = exceptionOf({
-  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 ImmutableEntityKey = exceptionOf({
-  layer: "entity" /* Entity */,
-  name: "ImmutableEntityKey",
-  message: ({ key }, source) => `"${key}" of entity "${source}" cannot be changed.`
-});
-var DeletedEntity = exceptionOf({
-  layer: "entity" /* Entity */,
-  name: "DeletedEntity",
-  message: ({ id }, source) => `Entity "${source}" of id "${id}" was destroyed and cannot change.`
-});
-
-// src/core/entity/entity.ts
-function entityBuilderOf({
-  identity,
-  generateId,
-  now,
-  plugins: catalogs
-}) {
-  const clock = Object.freeze({ generateId, now });
-  const context = pluginContextOf(catalogs ?? []);
-  return (blueprint, options = {}) => {
-    for (const key of Object.keys(blueprint.properties)) {
-      if (RESERVED_ENTITY_KEYS.includes(key)) {
-        throw new ReservedEntityKey({ source: "entity", details: { key } });
-      }
-    }
-    for (const key of options.change ?? []) {
-      if (ENTITY_IDENTITY_KEYS.includes(key)) {
-        throw new ImmutableEntityKey({ source: "entity", details: { key } });
-      }
-    }
-    const DeclaredEntity = declareRecord(AbstractEntity, identity.join(blueprint), { ...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, EntityUniqueKeys, {
-      value: DeclaredEntity.options.unique
-    });
-    Object.defineProperty(DeclaredEntity, EntityEventSettings, {
-      value: Object.freeze({
-        onCreate: options.onCreate,
-        onUpdate: options.onUpdate,
-        onDelete: options.onDelete
-      })
-    });
-    return DeclaredEntity;
-  };
-}
-function isEntityClass(value) {
-  return isRecordClass(value) && value.prototype instanceof AbstractEntity;
-}
-function isEntity(value) {
-  return value instanceof AbstractEntity;
-}
-
-// 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;
-function eventOf(name, entityClass, handler) {
-  if (!isEntityClass(entityClass)) {
-    throw new TypeError("An event requires an entity class");
-  }
-  const event = Object.freeze({
-    name,
-    [EventBrand]: true
-  });
-  definitions.set(event, (entity) => {
-    if (!(entity instanceof entityClass)) {
-      throw new TypeError(`Incompatible entity for event ${name}`);
-    }
-    return Object.freeze({
-      name,
-      entity,
-      async handle() {
-        await handler(entity);
-      }
-    });
-  });
-  return event;
-}
-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_KEYS = Object.freeze(["id", "createdAt", "updatedAt", "deletedAt"]);
-var ENTITY_MEMBERS = Object.freeze([
-  "destroy",
-  "isDeleted",
-  "equals",
-  "onDestroy",
-  "emit",
-  "pullEvents"
-]);
-var RESERVED_ENTITY_KEYS = Object.freeze([
-  ...ENTITY_IDENTITY_KEYS,
-  ...ENTITY_MEMBERS
-]);
-var EntityClock = Symbol("entityClock");
-var EntityUniqueKeys = Symbol("entityUniqueKeys");
-function identityOf(entity) {
-  return entity;
-}
-function clockOf(entity) {
-  return entity.constructor[EntityClock];
-}
-function assertAlive(entity) {
-  if (entity.isDeleted) {
-    throw new DeletedEntity({
-      source: entity.constructor.name,
-      details: { id: identityOf(entity).id }
-    });
-  }
-}
-function withIdentity(value, clock) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return value;
-  }
-  const { id, createdAt } = value;
-  if (id !== undefined && createdAt !== undefined)
-    return value;
-  return {
-    ...value,
-    id: id === undefined ? clock.generateId() : id,
-    createdAt: createdAt === undefined ? clock.now() : createdAt
-  };
-}
-
-class AbstractEntity extends AbstractRecord {
-  constructor(value) {
-    super(withIdentity(value, new.target[EntityClock]));
-    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.blueprint === this.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 (ENTITY_IDENTITY_KEYS.includes(name)) {
-      throw new ImmutableEntityKey({
-        source: this.constructor.name,
-        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/environment/environment.ts
-var InvalidEnvironment = exceptionOf({
-  layer: "environment" /* Environment */,
-  name: "InvalidEnvironment",
-  message: ({ keys }) => `Invalid environment variables: ${keys.join(", ")}.`
-});
-var processEnv = () => globalThis.process?.env ?? {};
-function environmentOf(blueprint, { source = processEnv } = {}) {
-  if (!isBlueprint(blueprint) || blueprint.optional) {
-    throw new TypeError("An environment requires a blueprint");
-  }
-  let value;
-  return Object.freeze({
-    [Kind]: "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 InvalidEnvironment({
-    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[Kind] === "environment";
-}
-
-// src/core/openapi/exceptions.ts
-var InvalidOpenAPIModel = exceptionOf({
-  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) || recordFieldOf(value) !== undefined;
-}
-function isOptional(field) {
-  if (isProperty(field))
-    return field.type.optional === true;
-  if (isBlueprint(field) || isBlueprintList(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 = schemaOf2(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: isEntityClass(record) ? ENTITY_IDENTITY_KEYS : []
-  });
-}
-function schemaOf2(field, scope) {
-  if (isBlueprintList(field)) {
-    const { item, minItems, maxItems } = field;
-    return {
-      type: "array",
-      items: schemaOf2(item, scope),
-      ...minItems === undefined ? {} : { minItems },
-      ...maxItems === undefined ? {} : { maxItems }
-    };
-  }
-  if (isBlueprint(field))
-    return objectOf(field.properties, scope, NO_MARKS);
-  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 InvalidOpenAPIModel({
-      source: "openapi",
-      details: { name: String(field) }
-    });
-  }
-  const schema = plainOf(field.type.schema.type.Type());
-  if (field.type.sensitive)
-    schema.writeOnly = true;
-  return schema;
-}
-function toOpenAPI(modelOrModels, { refPrefix = "#/components/schemas/" } = {}) {
-  if (isField(modelOrModels)) {
-    return schemaOf2(modelOrModels, { names: new Map, prefix: refPrefix });
-  }
-  if (typeof modelOrModels !== "object" || modelOrModels === null) {
-    throw new InvalidOpenAPIModel({
-      source: "openapi",
-      details: { name: String(modelOrModels) }
-    });
-  }
-  const names = new Map;
-  for (const [name, model] of Object.entries(modelOrModels)) {
-    if (!isField(model)) {
-      throw new InvalidOpenAPIModel({ 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) : schemaOf2(model, scope);
-  }
-  return { schemas };
-}
-
-// 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 contextOf(state) {
-  state.context ??= Object.freeze({
-    entity: state.entity,
-    name: state.name,
-    unique: state.entity[EntityUniqueKeys],
-    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,
-    explicitProvider: state.explicitProvider,
-    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;
-}
-function bindState(state, provider, bound = new Map) {
-  const done = bound.get(state);
-  if (done)
-    return done;
-  const copy = {
-    ...state,
-    provider: state.explicitProvider ? state.provider : provider,
-    context: undefined,
-    relations: new Map([...state.relations].map(([target, related]) => [
-      target,
-      bindState(related, provider, bound)
-    ]))
-  };
-  origins.set(copy, declarationOf(state));
-  bound.set(state, copy);
-  return copy;
-}
-function bindRepository(repository, provider) {
-  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));
-  return Object.freeze(new Bound);
-}
-
-// src/core/application/exceptions.ts
-var InvalidApplicationDeclaration = exceptionOf({
-  layer: "application" /* Application */,
-  name: "InvalidApplicationDeclaration",
-  message: ({ reason }) => reason
-});
-var DuplicateApplicationDeclaration = exceptionOf({
-  layer: "application" /* Application */,
-  name: "DuplicateApplicationDeclaration",
-  message: ({
-    first,
-    second
-  }) => `The same object is registered as ${first} and as ${second}.`
-});
-var ApplicationConflict = exceptionOf({
-  layer: "application" /* Application */,
-  name: "ApplicationConflict",
-  message: ({
-    reason
-  }) => reason
-});
-var UnregisteredApplicationReference = exceptionOf({
-  layer: "application" /* Application */,
-  name: "UnregisteredApplicationReference",
-  message: ({
-    holder,
-    reference
-  }) => `${holder} holds ${reference}, which is not registered in the application.`
-});
-var UnregisteredRepositoryDependency = exceptionOf({
-  layer: "application" /* Application */,
-  name: "UnregisteredRepositoryDependency",
-  message: ({
-    repository,
-    dependency
-  }) => `Repository ${repository} depends on ${dependency}, which is not registered in the application.`
-});
-
-// src/core/application/application.ts
-var KEYS = [
-  "properties",
-  "blueprints",
-  "records",
-  "entities",
-  "environments",
-  "repositories"
-];
-var internals2 = new WeakMap;
-var KIND_OF = {
-  properties: "property",
-  blueprints: "blueprint",
-  records: "record",
-  entities: "entity",
-  environments: "environment",
-  repositories: "repository"
-};
-function isApplication(value) {
-  return typeof value === "object" && value !== null && value[Kind] === "application";
-}
-function invalid(source, reason) {
-  throw new InvalidApplicationDeclaration({ source, details: { reason } });
-}
-function isOfKind(collection, value) {
-  switch (collection) {
-    case "properties":
-      return isProperty(value);
-    case "blueprints":
-      return isBlueprint(value);
-    case "records":
-      return isRecordClass(value) && !isEntityClass(value);
-    case "entities":
-      return isEntityClass(value);
-    case "environments":
-      return isEnvironment(value);
-    case "repositories":
-      return inspectRepository(value) !== undefined;
-  }
-}
-function keyOf(collection, value) {
-  switch (collection) {
-    case "properties":
-      return fieldOf(value);
-    case "blueprints":
-      return value.properties;
-    case "repositories":
-      return inspectRepository(value).state;
-    default:
-      return value;
-  }
-}
-function emptyRegistry() {
-  return Object.fromEntries(KEYS.map((key) => [key, new Map]));
-}
-function resolve(settings) {
-  const registry = emptyRegistry();
-  const byKey = new Map;
-  const source = settings.name;
-  const add = (entry) => {
-    const same = registry[entry.collection].get(entry.name);
-    if (same) {
-      if (same.key === entry.key)
-        return;
-      conflict(`${KIND_OF[entry.collection]} "${entry.name}" is declared as different objects by "${same.from}" and by "${entry.from}".`, same, entry);
-    }
-    const other = byKey.get(entry.key);
-    if (other) {
-      if (other.from === entry.from) {
-        throw new DuplicateApplicationDeclaration({
-          source,
-          details: {
-            first: `${KIND_OF[other.collection]} "${other.name}"`,
-            second: `${KIND_OF[entry.collection]} "${entry.name}"`
-          }
-        });
-      }
-      conflict(`The same ${KIND_OF[entry.collection]} is ${KIND_OF[other.collection]} "${other.name}" in "${other.from}" and ${KIND_OF[entry.collection]} "${entry.name}" in "${entry.from}".`, other, entry);
-    }
-    registry[entry.collection].set(entry.name, entry);
-    byKey.set(entry.key, entry);
-  };
-  const conflict = (reason, first, second) => {
-    throw new ApplicationConflict({
-      source,
-      details: {
-        reason,
-        origins: [first.from, second.from],
-        declarations: [
-          `${KIND_OF[first.collection]} ${first.name}`,
-          `${KIND_OF[second.collection]} ${second.name}`
-        ]
-      }
-    });
-  };
-  for (const other of settings.extends ?? []) {
-    const resolved = internals2.get(other);
-    if (!resolved)
-      invalid(source, "Expected `extends` to hold applications.");
-    for (const key of KEYS) {
-      for (const entry of resolved[key].values())
-        add(entry);
-    }
-  }
-  for (const collection of KEYS) {
-    const declared = settings[collection];
-    if (declared === undefined)
-      continue;
-    if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
-      invalid(source, `Expected ${collection} to be an object of declarations.`);
-    }
-    for (const [name, value] of Object.entries(declared)) {
-      if (!isOfKind(collection, value)) {
-        invalid(source, `${collection}.${name} is not a ${KIND_OF[collection]} (${collection} takes ${KIND_OF[collection]} declarations).`);
-      }
-      add({
-        collection,
-        name,
-        value,
-        key: keyOf(collection, value),
-        from: source
-      });
-    }
-  }
-  return registry;
-}
-function recordsIn(properties) {
-  const found = new Set;
-  const visit = (field) => {
-    if (isBlueprintList(field))
-      visit(field.item);
-    else if (isBlueprint(field))
-      walk(field.properties);
-    else {
-      const record = recordFieldOf(field)?.record;
-      if (record)
-        found.add(record);
-    }
-  };
-  const walk = (collection) => {
-    for (const field of Object.values(collection))
-      visit(field);
-  };
-  walk(properties);
-  return found;
-}
-function validate(source, registry) {
-  const registered = new Set([
-    ...[...registry.records.values()].map((entry) => entry.key),
-    ...[...registry.entities.values()].map((entry) => entry.key)
-  ]);
-  const holders = [
-    ["blueprints", "properties"],
-    ["records", "blueprint.properties"],
-    ["entities", "blueprint.properties"]
-  ];
-  for (const [collection] of holders) {
-    for (const entry of registry[collection].values()) {
-      const properties = collection === "blueprints" ? entry.value.properties : entry.value.blueprint.properties;
-      for (const record of recordsIn(properties)) {
-        if (registered.has(record))
-          continue;
-        throw new UnregisteredApplicationReference({
-          source,
-          details: {
-            holder: `${KIND_OF[collection]} "${entry.name}"`,
-            reference: `${isEntityClass(record) ? "entity" : "record"} "${record.name}"`
-          }
-        });
-      }
-    }
-  }
-  const repositories = new Set([...registry.repositories.values()].map((entry) => entry.key));
-  const environments = new Set([...registry.environments.values()].map((entry) => entry.key));
-  const unregistered = (repository, dependency) => {
-    throw new UnregisteredRepositoryDependency({
-      source,
-      details: { repository, dependency }
-    });
-  };
-  for (const entry of registry.repositories.values()) {
-    const info = inspectRepository(entry.value);
-    if (!registered.has(info.entity)) {
-      unregistered(entry.name, `entity "${info.entity.name}"`);
-    }
-    for (const relation of info.relations) {
-      if (!repositories.has(relation)) {
-        unregistered(entry.name, `the repository of "${relation.entity.name}"`);
-      }
-    }
-    for (const environment of info.environments) {
-      if (!environments.has(environment)) {
-        unregistered(entry.name, "an environment");
-      }
-    }
-  }
-}
-function jsonOf(value) {
-  return JSON.parse(JSON.stringify(value, (_key, item) => item instanceof RegExp ? item.source : item));
-}
-function referencesOf(registry, collection) {
-  return new Map([...registry[collection].values()].map((entry) => [entry.key, entry.name]));
-}
-function propertyReferenceOf(Property, scope) {
-  const ref = scope.properties.get(fieldOf(Property));
-  return ref === undefined ? propertyDescriptionOf(Property, scope) : { ref };
-}
-function lineageDescriptionOf(lineage, scope) {
-  switch (lineage.kind) {
-    case "refined":
-      return {
-        kind: "refined",
-        base: propertyReferenceOf(lineage.base, scope),
-        options: jsonOf(lineage.options)
-      };
-    case "optional":
-      return {
-        kind: "optional",
-        base: propertyReferenceOf(lineage.base, scope)
-      };
-    case "factory":
-      return {
-        kind: "factory",
-        factory: lineage.factory,
-        args: jsonOf(lineage.args)
-      };
-  }
-}
-function propertyDescriptionOf(Property, scope) {
-  const { type } = Property;
-  const lineage = propertyLineageOf(Property);
-  return {
-    name: type.name,
-    optional: type.optional === true,
-    sensitive: type.sensitive === true,
-    unique: type.unique === true,
-    schema: plainOf(type.schema.type.Type()),
-    ...lineage ? { lineage: lineageDescriptionOf(lineage, scope) } : {}
-  };
-}
-function fieldDescriptionOf(field, scope) {
-  if (isProperty(field)) {
-    const real = fieldOf(field);
-    const ref = scope.properties.get(real);
-    return ref === undefined ? { kind: "property", ...propertyDescriptionOf(real, scope) } : { kind: "property", ref, optional: real.type.optional === true };
-  }
-  if (isBlueprintList(field)) {
-    return {
-      kind: "list",
-      item: fieldDescriptionOf(field.item, scope),
-      optional: field.optional,
-      ...field.minItems === undefined ? {} : { minItems: field.minItems },
-      ...field.maxItems === undefined ? {} : { maxItems: field.maxItems }
-    };
-  }
-  if (isBlueprint(field)) {
-    const ref = scope.blueprints.get(field.properties);
-    return ref === undefined ? {
-      kind: "blueprint",
-      optional: field.optional,
-      fields: fieldsDescriptionOf(field.properties, scope)
-    } : { kind: "blueprint", ref, optional: field.optional };
-  }
-  const record = recordFieldOf(field);
-  if (record) {
-    const entity = scope.entities.get(record.record);
-    const ref = entity ?? scope.records.get(record.record);
-    return {
-      kind: entity === undefined ? "record" : "entity",
-      ref: ref ?? record.record.name,
-      optional: record.optional
-    };
-  }
-  return {
-    kind: "property",
-    name: "unknown",
-    optional: false,
-    sensitive: false,
-    unique: false,
-    schema: {}
-  };
-}
-function fieldsDescriptionOf(properties, scope, skip = new Set) {
-  return Object.fromEntries(Object.entries(properties).filter(([key]) => !skip.has(key)).map(([key, field]) => [key, fieldDescriptionOf(field, scope)]));
-}
-function recordDescriptionOf(entry, scope) {
-  const Record = entry.value;
-  const plugins = pluginsOf(Record).map((plugin) => plugin.toJSON());
-  const skip = new Set(plugins.flatMap((plugin) => plugin.keys));
-  if (entry.collection === "entities") {
-    for (const key of ENTITY_IDENTITY_KEYS)
-      skip.add(key);
-  }
-  const own = (keys, flag) => keys.filter((key) => {
-    if (skip.has(key))
-      return false;
-    const field = Record.blueprint.properties[key];
-    return !(flag && isProperty(field) && field.type[flag] === true);
-  });
-  return {
-    from: entry.from,
-    fields: fieldsDescriptionOf(Record.blueprint.properties, scope, skip),
-    options: {
-      sensitive: own(Record.options.sensitive, "sensitive"),
-      unique: own(Record.options.unique, "unique"),
-      change: own(Record.options.change)
-    },
-    plugins
-  };
-}
-function describeRegistry(name, extended, registry) {
-  const scope = {
-    properties: referencesOf(registry, "properties"),
-    blueprints: referencesOf(registry, "blueprints"),
-    records: referencesOf(registry, "records"),
-    entities: referencesOf(registry, "entities")
-  };
-  const repositories = referencesOf(registry, "repositories");
-  const each = (collection, describe) => Object.fromEntries([...registry[collection].values()].map((entry) => [
-    entry.name,
-    describe(entry)
-  ]));
-  return {
-    name,
-    extends: extended.map((other) => other.name),
-    properties: each("properties", (entry) => ({
-      from: entry.from,
-      ...propertyDescriptionOf(entry.value, scope)
-    })),
-    blueprints: each("blueprints", (entry) => ({
-      from: entry.from,
-      fields: fieldsDescriptionOf(entry.value.properties, scope)
-    })),
-    records: each("records", (entry) => recordDescriptionOf(entry, scope)),
-    entities: each("entities", (entry) => recordDescriptionOf(entry, scope)),
-    environments: each("environments", (entry) => ({
-      from: entry.from,
-      fields: fieldsDescriptionOf(entry.value.blueprint.properties, scope)
-    })),
-    repositories: each("repositories", (entry) => {
-      const info = inspectRepository(entry.value);
-      return {
-        from: entry.from,
-        entity: scope.entities.get(info.entity),
-        actions: info.actions,
-        relations: info.relations.map((relation) => repositories.get(relation)),
-        environments: info.environments.map((environment) => referencesOf(registry, "environments").get(environment)),
-        provider: info.explicitProvider
-      };
-    })
-  };
-}
-function applicationOf(settings) {
-  const { name } = settings ?? {};
-  if (typeof name !== "string" || name === "") {
-    invalid("applicationOf", "Expected a name.");
-  }
-  const extended = settings.extends ?? [];
-  if (!Array.isArray(extended) || !extended.every(isApplication)) {
-    invalid(name, "Expected `extends` to be a list of applications.");
-  }
-  const registry = resolve(settings);
-  validate(name, registry);
-  const provider = settings.provider ?? [...extended].reverse().find((other) => other.provider)?.provider;
-  if (provider !== undefined && typeof provider !== "object") {
-    invalid(name, "Expected `provider` to be a repository provider.");
-  }
-  const collection = (key) => Object.freeze(Object.fromEntries([...registry[key].values()].map((entry) => [entry.name, entry.value])));
-  const bound = new Map;
-  const repositories = {};
-  for (const entry of registry.repositories.values()) {
-    const repository = provider === undefined ? entry.value : bindRepository(entry.value, provider);
-    bound.set(entry.value, repository);
-    repositories[entry.name] = repository;
-  }
-  const application = Object.freeze({
-    [Kind]: "application",
-    name,
-    extends: Object.freeze([...extended]),
-    provider,
-    properties: collection("properties"),
-    blueprints: collection("blueprints"),
-    records: collection("records"),
-    entities: collection("entities"),
-    environments: collection("environments"),
-    repositories: Object.freeze(repositories),
-    repository(repository) {
-      if (!bound.has(repository)) {
-        invalid(name, "Expected a repository registered in the application.");
-      }
-      return bound.get(repository);
-    },
-    extend(...others) {
-      return applicationOf({
-        name,
-        extends: [application, ...others],
-        ...provider === undefined ? {} : { provider }
-      });
-    },
-    describe: () => describeRegistry(name, extended, registry)
-  });
-  internals2.set(application, registry);
-  return application;
-}
-// src/core/blueprint/blueprint.ts
-import { Type as Type3 } from "typebox";
-
-// src/core/property/property.ts
-import { Type } from "typebox";
-
-// src/core/symbols/state.ts
-var State = 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 [State]() {
-    return this.definition[State];
-  }
-  definition;
-  value;
-  constructor(value) {
-    this.definition = this.createDefinition();
-    this.value = this.definition.make(value === Demo ? this.definition.type[Demo] : value);
-  }
-  static demo() {
-    return new this(Demo);
-  }
-  static safeParse(value) {
-    return parsingDefinitionOf(this).parse(value);
-  }
-  static with(options) {
-    return refinePropertyOf(this, options);
-  }
-  static get "~standard"() {
-    return standardOfClass(this);
-  }
-}
-
-// src/core/property/enums/property-states.ts
-var PropertyStates;
-((PropertyStates) => {
-  PropertyStates[PropertyStates["Declared"] = 0] = "Declared";
-  PropertyStates[PropertyStates["PreHandling"] = 1] = "PreHandling";
-  PropertyStates[PropertyStates["Handling"] = 2] = "Handling";
-  PropertyStates[PropertyStates["AfterHandling"] = 3] = "AfterHandling";
-  PropertyStates[PropertyStates["Done"] = 4] = "Done";
-})(PropertyStates ||= {});
-
-// src/core/property/exceptions.ts
-var PropertyRequired = exceptionOf({
-  layer: "property" /* Property */,
-  name: "PropertyRequired",
-  message: (_, source) => `Property "${source}" is required.`
-});
-var InvalidPropertyValue = exceptionOf({
-  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");
-function once(build) {
-  let result;
-  return () => {
-    result ??= build();
-    return result;
-  };
-}
-function segmentsOf(pointer) {
-  if (pointer === "")
-    return [];
-  return pointer.slice(1).split("/").map((segment) => {
-    const key = segment.replaceAll("~1", "/").replaceAll("~0", "~");
-    return /^(0|[1-9]\d*)$/.test(key) ? Number(key) : key;
-  });
-}
-
-class AbstractDefineProperty {
-  [State] = 0 /* Declared */;
-  make(value) {
-    const attempt = this.attempt(value);
-    if ("failure" in attempt)
-      throw attempt.failure.exception();
-    return attempt.value;
-  }
-  parse(value) {
-    const attempt = this.attemptWithoutThrowing(value);
-    if (!("failure" in attempt))
-      return { value: attempt.value };
-    const { exception, raised, issues } = attempt.failure;
-    return {
-      issues: issues.map((issue) => raised ? { ...issue, cause: exception() } : withLazyCause(issue, exception))
-    };
-  }
-  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 {
-        failure: this.raise(error instanceof Exception ? error : this.invalidValue(error))
-      };
-    }
-  }
-  attempt(value) {
-    const { name, optional } = this.type;
-    this[State] = 0 /* Declared */;
-    if (value === undefined) {
-      if (!optional) {
-        return {
-          failure: {
-            exception: () => new PropertyRequired({ source: name }),
-            raised: false,
-            issues: [
-              {
-                message: "is required",
-                path: [],
-                code: "required",
-                source: name
-              }
-            ]
-          }
-        };
-      }
-      this[State] = 4 /* Done */;
-      return { value };
-    }
-    if (!this.type.schema.matchShape(value)) {
-      return { failure: this.mismatch(value) };
-    }
-    try {
-      this[State] = 1 /* PreHandling */;
-      value = this.runHandler(() => this.preHandle(value));
-      this[State] = 2 /* Handling */;
-      const handled = this.handle(value);
-      if (handled === MISMATCH) {
-        return { failure: this.mismatch(value) };
-      }
-      value = handled;
-      this[State] = 3 /* AfterHandling */;
-      value = this.runHandler(() => this.afterHandle(value));
-    } catch (error) {
-      if (error instanceof Exception)
-        return { failure: this.raise(error) };
-      throw error;
-    }
-    this[State] = 4 /* Done */;
-    return { value };
-  }
-  runHandler(handler) {
-    try {
-      return handler();
-    } catch (error) {
-      if (error instanceof Exception)
-        throw error;
-      throw this.invalidValue(error);
-    }
-  }
-  invalidValue(error) {
-    return new InvalidPropertyValue({
-      source: this.type.name,
-      details: {
-        errors: [error instanceof Error ? error.message : String(error)]
-      },
-      cause: error
-    });
-  }
-  raise(exception) {
-    return {
-      exception: () => exception,
-      raised: true,
-      issues: [
-        {
-          message: exception.message,
-          path: [],
-          code: "invalid_value",
-          source: this.type.name
-        }
-      ]
-    };
-  }
-  mismatch(value) {
-    const { name, schema } = this.type;
-    const errors = schema.type.Errors(value);
-    const issues = errors.map((error) => ({
-      message: error.message,
-      path: segmentsOf(error.instancePath),
-      code: "invalid_value",
-      source: name
-    }));
-    return {
-      exception: once(() => new InvalidPropertyValue({
-        source: name,
-        details: { errors: errors.map(describeError) }
-      })),
-      raised: false,
-      issues: issues.length > 0 ? issues : [
-        {
-          message: "is invalid",
-          path: [],
-          code: "invalid_value",
-          source: name
-        }
-      ]
-    };
-  }
-}
-
-// src/core/property/property.ts
-function propertyOf({
-  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 = {
-    [Demo]: _default,
-    name,
-    schema: new SchemaConstructor,
-    optional: optional ?? false,
-    sensitive,
-    unique
-  };
-
-  class DefineProperty extends AbstractDefineProperty {
-    get type() {
-      return type;
-    }
-    preHandle(value) {
-      return onPreHandle ? onPreHandle(value) : value;
-    }
-    afterHandle(value) {
-      return onAfterHandle ? onAfterHandle(value) : value;
-    }
-  }
-
-  class Property extends AbstractProperty {
-    static type = type;
-    createDefinition() {
-      return new DefineProperty;
-    }
-  }
-  return Property;
-}
-
-// src/core/blueprint/exceptions.ts
-var ReservedBlueprintKey = exceptionOf({
-  layer: "blueprint" /* Blueprint */,
-  name: "ReservedBlueprintKey",
-  message: ({ key }) => `"${key}" is reserved and cannot be a plugin property.`
-});
-var UndeclaredBlueprintProperty = exceptionOf({
-  layer: "blueprint" /* Blueprint */,
-  name: "UndeclaredBlueprintProperty",
-  message: ({ key }) => `Property "${key}" of the blueprint is not declared.`
-});
-
-// src/core/blueprint/optional.ts
-import { Type as Type2 } from "typebox";
-var cache2 = new WeakMap;
-function optionalOf(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({
-      [Kind]: "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;
-  }
-  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 blueprintBuilderOf(...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 blueprint = {
-    [Kind]: "blueprint",
-    plugins: Object.freeze([...new Set(plugins)]),
-    properties: Object.freeze(properties),
-    schema: new SchemaConstructor,
-    optional: false,
-    safeParse: (value) => parseCollection(properties, value, [], "blueprint"),
-    join: (...others) => create([blueprint, ...others].flatMap((source) => source.plugins), Object.assign({}, ...[blueprint, ...others].map((source) => source.properties)))
-  };
-  return Object.freeze(withStandard(blueprint, (value) => blueprint.safeParse(value)));
-}
-var HELPERS = { listOf, optionalOf, propertyOf };
-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 ReservedBlueprintKey({
-        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 ReservedBlueprintKey({
-        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) => listOf(field));
-  const callable = (field) => isProperty(field) ? callableOf(field) : field;
-  return Object.freeze({
-    ...mirror(available, callable),
-    ...factories,
-    ...HELPERS,
-    optional: Object.freeze(mirror(available, (field) => callable(optionalOf(field)))),
-    list: Object.freeze({
-      ...list,
-      optional: Object.freeze(mirror(list, optionalOf))
-    })
-  });
-}
-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;
-  }
-  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 UndeclaredBlueprintProperty({
-    source: "blueprint",
-    details: { key }
-  });
-}
-// src/core/blueprint/blueprint-plugin.ts
-function blueprintPluginOf(name, properties, factories = {}) {
-  return Object.freeze({
-    name,
-    properties: Object.freeze({ ...properties }),
-    factories: Object.freeze({ ...factories })
-  });
-}
-// src/core/blueprint/slice.ts
-function propertiesOfField(field) {
-  if (field === undefined)
-    return;
-  if (isBlueprintList(field))
-    return propertiesOfField(field.item);
-  const record = recordFieldOf(field);
-  if (record)
-    return record.record.blueprint.properties;
-  return isBlueprint(field) ? field.properties : undefined;
-}
-function maskOf(selector, against) {
-  if (isRecordClass(selector))
-    return maskOf(selector.blueprint, against);
-  if (isBlueprint(selector)) {
-    return Object.fromEntries(Object.entries(selector.properties).map(([key, field]) => [key, fieldMaskOf(field, against?.[key])]));
-  }
-  return selector;
-}
-function fieldMaskOf(field, other) {
-  if (isBlueprintList(field)) {
-    return fieldMaskOf(field.item, isBlueprintList(other) ? other.item : other);
-  }
-  const record = recordFieldOf(field);
-  if (record) {
-    if (record.record === recordFieldOf(other)?.record)
-      return true;
-    return maskOf(record.record, propertiesOfField(other));
-  }
-  if (isBlueprint(field)) {
-    return field === other ? true : maskOf(field, propertiesOfField(other));
-  }
-  return true;
-}
-function sliceCollection(properties, mask, path) {
-  const sliced = {};
-  for (const [key, selected] of Object.entries(mask)) {
-    if (!selected)
-      continue;
-    if (!Object.hasOwn(properties, key)) {
-      throw new UndeclaredBlueprintProperty({
-        source: "blueprint",
-        details: { key: path + key }
-      });
-    }
-    sliced[key] = sliceField(properties[key], selected, path + key);
-  }
-  return sliced;
-}
-function slicedRecordOf(Original, mask, path) {
-  const source = Original.blueprint;
-  const blueprint = blueprintFromProperties(source.plugins, sliceCollection(source.properties, mask, `${path}.`));
-  const kept = (keys) => keys.filter((key) => Object.hasOwn(blueprint.properties, key));
-  const { sensitive, unique, change } = Original.options;
-  const Sliced = declareRecord(AbstractRecord, blueprint, {
-    sensitive: kept(sensitive),
-    unique: kept(unique),
-    change: kept(change)
-  }, Original.name);
-  Object.defineProperty(Sliced, Symbol.hasInstance, {
-    value(value) {
-      return Function.prototype[Symbol.hasInstance].call(this, value) || value instanceof Original;
-    }
-  });
-  return Sliced;
-}
-function sliceField(field, selected, path) {
-  if (selected === true)
-    return field;
-  if (isBlueprintList(field)) {
-    const list = listOf(sliceField(field.item, selected, path), {
-      minItems: field.minItems,
-      maxItems: field.maxItems
-    });
-    return field.optional ? optionalOf(list) : list;
-  }
-  const record = recordFieldOf(field);
-  if (record) {
-    const sliced = slicedRecordOf(record.record, selected, path);
-    return record.optional ? optionalOf(sliced) : sliced;
-  }
-  if (isBlueprint(field)) {
-    const sliced = blueprintFromProperties(field.plugins, sliceCollection(field.properties, selected, `${path}.`));
-    return field.optional ? optionalOf(sliced) : sliced;
-  }
-  throw new UndeclaredBlueprintProperty({
-    source: "blueprint",
-    details: { key: `${path}.${Object.keys(selected)[0] ?? ""}` }
-  });
-}
-var sliceOf = (blueprint, selector) => blueprintFromProperties(blueprint.plugins, sliceCollection(blueprint.properties, maskOf(selector, blueprint.properties), ""));
-var sliceValue = (value, selector) => pick(value, maskOf(selector));
-function pick(value, mask) {
-  if (Array.isArray(value))
-    return value.map((item) => pick(item, mask));
-  if (typeof value !== "object" || value === null)
-    return value;
-  const source = isRecordClass(value.constructor) ? value.toJSON() : value;
-  const picked = {};
-  for (const [key, selected] of Object.entries(mask)) {
-    if (!selected || !Object.hasOwn(source, key))
-      continue;
-    picked[key] = selected === true ? source[key] : pick(source[key], selected);
-  }
-  return picked;
-}
-// src/core/exception/guard.ts
-function guard(scope, run, resolve) {
-  const handle = (error) => {
-    const exception = Exception.from(error, scope);
-    const pass = () => {
-      throw exception === error ? exception.propagate(scope) : exception;
-    };
-    return resolve ? resolve(exception, pass) : pass();
-  };
-  try {
-    const result = run();
-    return result instanceof Promise ? result.catch(handle) : result;
-  } catch (error) {
-    return handle(error);
-  }
-}
-// src/core/record/plugin-catalog.ts
-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 LISTS = ["keys", "sensitive", "unique", "change", "members"];
-function isDescriptor(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const descriptor = value;
-  const isList = (list) => Array.isArray(list) && list.every((item) => typeof item === "string");
-  return descriptor.kind === "record-plugin" && typeof descriptor.name === "string" && isVersion(descriptor.version) && LISTS.every((list) => isList(descriptor[list])) && Array.isArray(descriptor.requires) && descriptor.requires.every((required) => typeof required === "object" && required !== null && typeof required.name === "string" && isVersion(required.version));
-}
-function mismatchOf(plugin, descriptor) {
-  if (!satisfies(plugin.version, descriptor.version)) {
-    return `version ${plugin.version} does not satisfy ${descriptor.version}`;
-  }
-  const current = {
-    keys: plugin.keys,
-    sensitive: plugin.options.sensitive,
-    unique: plugin.options.unique,
-    change: plugin.options.change,
-    members: plugin.members
-  };
-  for (const list of LISTS) {
-    const missing = descriptor[list].find((item) => !current[list].includes(item));
-    if (missing !== undefined)
-      return `"${missing}" is not in its ${list}`;
-  }
-  for (const required of descriptor.requires) {
-    const found = plugin.requires.find(({ name }) => name === required.name);
-    if (!found)
-      return `it does not require "${required.name}"`;
-    if (!satisfies(found.version, required.version)) {
-      return `its "${required.name}" ${found.version} does not satisfy ${required.version}`;
-    }
-  }
-  return;
-}
-function recordPluginCatalogOf(...plugins) {
-  const byName = {};
-  for (const plugin of plugins) {
-    if (!isRecordPlugin(plugin)) {
-      throw new InvalidRecordPlugin({
-        source: "catalog",
-        details: {
-          reason: "a catalog takes plugins made by `recordPluginOf`"
-        }
-      });
-    }
-    if (Object.hasOwn(byName, plugin.name)) {
-      throw new InvalidRecordPlugin({
-        source: plugin.name,
-        details: { reason: "the catalog has another plugin with its name" }
-      });
-    }
-    byName[plugin.name] = plugin;
-  }
-  const find = (name) => {
-    const plugin = Object.hasOwn(byName, name) ? byName[name] : undefined;
-    if (!plugin) {
-      throw new UnknownRecordPlugin({ source: "catalog", details: { name } });
-    }
-    return plugin;
-  };
-  const resolve = (reference) => {
-    if (typeof reference === "string") {
-      const at = reference.lastIndexOf("@");
-      if (at <= 0)
-        return find(reference);
-      const plugin = find(reference.slice(0, at));
-      const version = reference.slice(at + 1);
-      if (!isVersion(version)) {
-        throw new IncompatibleRecordPlugin({
-          source: plugin.name,
-          details: { reason: `"${version}" is not a semantic version` }
-        });
-      }
-      if (!satisfies(plugin.version, version)) {
-        throw new IncompatibleRecordPlugin({
-          source: plugin.name,
-          details: {
-            reason: `version ${plugin.version} does not satisfy ${version}`
-          }
-        });
-      }
-      return plugin;
-    }
-    if (!isDescriptor(reference)) {
-      const name = reference?.name;
-      throw new IncompatibleRecordPlugin({
-        source: typeof name === "string" ? name : "unknown",
-        details: { reason: "it is not a record plugin descriptor" }
-      });
-    }
-    const plugin = find(reference.name);
-    const reason = mismatchOf(plugin, reference);
-    if (reason !== undefined) {
-      throw new IncompatibleRecordPlugin({
-        source: plugin.name,
-        details: { reason }
-      });
-    }
-    return plugin;
-  };
-  return Object.freeze({
-    [Kind]: "record-plugin-catalog",
-    plugins: Object.freeze(byName),
-    list: Object.freeze([...plugins]),
-    resolve,
-    resolveAll: (references) => Object.freeze(references.map(resolve))
-  });
-}
-// src/core/repository/exceptions.ts
-var InvalidRepositoryDeclaration = exceptionOf({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryDeclaration",
-  message: ({ reason }) => reason
-});
-var InvalidRepositoryEntity = exceptionOf({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryEntity",
-  message: (_details, source) => `"${source}" expected an entity of its own class.`
-});
-var InvalidRepositoryData = exceptionOf({
-  layer: "repository" /* Repository */,
-  name: "InvalidRepositoryData",
-  message: (_details, source) => `"${source}" read a value that its entity rejects.`
-});
-var RepositoryUniqueViolation = exceptionOf({
-  layer: "repository" /* Repository */,
-  name: "RepositoryUniqueViolation",
-  message: ({ key }, source) => `"${source}" already holds an entity with this "${key}".`
-});
-var RepositoryEntityNotFound = exceptionOf({
-  layer: "repository" /* Repository */,
-  name: "RepositoryEntityNotFound",
-  message: ({ id }, source) => `"${source}" holds no entity of id "${id}".`
-});
-// src/core/repository/in-memory.ts
-function same(a, b) {
-  if (a === b)
-    return true;
-  return typeof a === "object" && typeof b === "object" && a !== null && b !== null && JSON.stringify(a) === JSON.stringify(b);
-}
-function idOf(data) {
-  return data.id;
-}
-function inMemoryProvider() {
-  const tables = new WeakMap;
-  const tableOf = (context) => {
-    let table = tables.get(context.entity);
-    if (!table) {
-      table = new Map;
-      tables.set(context.entity, table);
-    }
-    return table;
-  };
-  const assertUnique = (context, data) => {
-    for (const stored of tableOf(context).values()) {
-      if (idOf(stored) === idOf(data))
-        continue;
-      const key = context.unique.find((key) => data[key] !== undefined && same(stored[key], data[key]));
-      if (key !== undefined) {
-        throw new RepositoryUniqueViolation({
-          source: context.name,
-          details: { key }
-        });
-      }
-    }
-  };
-  return Object.freeze({
-    async findOne(context, key, value) {
-      for (const data of tableOf(context).values()) {
-        if (same(data[key], value))
-          return data;
-      }
-      return;
-    },
-    async findMany(context, key, value) {
-      return [...tableOf(context).values()].filter((data) => same(data[key], value));
-    },
-    async findIn(context, key, values) {
-      return [...tableOf(context).values()].filter((data) => values.some((value) => same(data[key], value)));
-    },
-    async insert(context, data) {
-      const table = tableOf(context);
-      if (table.has(idOf(data))) {
-        throw new RepositoryUniqueViolation({
-          source: context.name,
-          details: { key: "id" }
-        });
-      }
-      assertUnique(context, data);
-      table.set(idOf(data), data);
-    },
-    async update(context, data) {
-      const table = tableOf(context);
-      if (!table.has(idOf(data))) {
-        throw new RepositoryEntityNotFound({
-          source: context.name,
-          details: { id: idOf(data) }
-        });
-      }
-      assertUnique(context, data);
-      table.set(idOf(data), data);
-    },
-    async remove(context, id) {
-      if (!tableOf(context).delete(id)) {
-        throw new RepositoryEntityNotFound({
-          source: context.name,
-          details: { id }
-        });
-      }
-    },
-    async count(context) {
-      return tableOf(context).size;
-    }
-  });
-}
-// src/core/repository/references.ts
-function isPlain(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function recordClassOf(field) {
-  return recordFieldOf(field)?.record;
-}
-function entityClassesOf(properties) {
-  const found = new Set;
-  function visit(field) {
-    if (isBlueprintList(field)) {
-      visit(field.item);
-    } else if (isBlueprint(field)) {
-      walk(field.properties);
-    } else {
-      const record = recordClassOf(field);
-      if (!record)
-        return;
-      if (isEntityClass(record))
-        found.add(record);
-      else
-        walk(record.blueprint.properties);
-    }
-  }
-  function walk(properties) {
-    for (const field of Object.values(properties))
-      visit(field);
-  }
-  walk(properties);
-  return found;
-}
-function mapReferences(properties, data, visit) {
-  function mapField(field, value) {
-    if (value === undefined || value === null)
-      return value;
-    if (isBlueprintList(field)) {
-      return Array.isArray(value) ? Object.freeze(value.map((item) => mapField(field.item, item))) : value;
-    }
-    if (isBlueprint(field)) {
-      return isPlain(value) ? mapCollection(field.properties, value) : value;
-    }
-    const record = recordClassOf(field);
-    if (!record)
-      return value;
-    if (isEntityClass(record))
-      return visit(record, value);
-    return isPlain(value) ? mapCollection(record.blueprint.properties, value) : value;
-  }
-  function mapCollection(properties, value) {
-    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [
-      key,
-      mapField(properties[key], item)
-    ])));
-  }
-  return mapCollection(properties, data);
-}
-function relationsOf(name, entity, relations) {
-  const invalid = (reason) => {
-    throw new InvalidRepositoryDeclaration({
-      source: name,
-      details: { reason }
-    });
-  };
-  if (relations === undefined)
-    relations = [];
-  if (!Array.isArray(relations)) {
-    return invalid("Expected relations to be a list of repositories.");
-  }
-  const related = [];
-  for (const relation of relations) {
-    const state = findState(relation);
-    if (!state)
-      return invalid("Expected relations made by repositoryOf.");
-    if (related.some((other) => other.entity === state.entity)) {
-      return invalid(`Relation "${state.entity.name}" is duplicated.`);
-    }
-    const { provider } = state;
-    if (typeof provider.findIn !== "function" && typeof provider.findOne !== "function") {
-      return invalid(`The provider of "${state.name}" has no "findIn" or "findOne" to load it.`);
-    }
-    related.push(state);
-  }
-  const used = new Set;
-  const map = new Map;
-  for (const target of entityClassesOf(entity.blueprint.properties)) {
-    const matches = related.filter((state) => state.entity === target || state.entity.prototype instanceof target);
-    const exact = matches.find((state) => state.entity === target);
-    if (!exact && matches.length === 0) {
-      return invalid(`Missing relation: no repository of "${target.name}".`);
-    }
-    if (!exact && matches.length > 1) {
-      return invalid(`Relation "${target.name}" matches more than one repository.`);
-    }
-    const state = exact ?? matches[0];
-    map.set(target, state);
-    used.add(state);
-  }
-  for (const state of related) {
-    if (!used.has(state)) {
-      return invalid(`Relation "${state.entity.name}" is not held by ${entity.name}.`);
-    }
-  }
-  return map;
-}
-function parseEntity(state, data) {
-  const parsed = state.entity.safeParse(data);
-  if (parsed.issues) {
-    throw new InvalidRepositoryData({
-      source: state.name,
-      cause: parsed.issues.find((issue) => issue.cause)?.cause
-    });
-  }
-  return parsed.value;
-}
-async function loadByIds(state, ids) {
-  const context = contextOf(state);
-  const { provider } = state;
-  if (typeof provider.findIn === "function") {
-    return provider.findIn(context, "id", ids);
-  }
-  const found = await Promise.all(ids.map((id) => provider.findOne(context, "id", id)));
-  return found.filter((data) => data !== undefined);
-}
-async function resolveReferences(state, datas, session) {
-  if (state.relations.size === 0)
-    return datas;
-  const { properties } = state.entity.blueprint;
-  const wanted = new Map;
-  for (const data of datas) {
-    mapReferences(properties, data, (target, value) => {
-      const relation = state.relations.get(target);
-      if (relation && typeof value === "string") {
-        const ids = wanted.get(relation) ?? new Set;
-        wanted.set(relation, ids.add(value));
-      }
-      return value;
-    });
-  }
-  for (const [relation, ids] of wanted) {
-    const loaded = session.get(relation) ?? new Map;
-    session.set(relation, loaded);
-    const missing = [...ids].filter((id) => !loaded.has(id));
-    if (missing.length === 0)
-      continue;
-    const found = await loadByIds(relation, missing);
-    const resolved = await resolveReferences(relation, found, session);
-    for (const data of resolved) {
-      const id = data.id;
-      if (!loaded.has(id))
-        loaded.set(id, parseEntity(relation, data));
-    }
-    for (const id of missing) {
-      if (loaded.has(id))
-        continue;
-      throw new InvalidRepositoryData({
-        source: state.name,
-        cause: new RepositoryEntityNotFound({
-          source: relation.name,
-          details: { id }
-        })
-      });
-    }
-  }
-  return datas.map((data) => mapReferences(properties, data, (target, value) => {
-    const relation = state.relations.get(target);
-    return relation && typeof value === "string" ? session.get(relation)?.get(value) ?? value : value;
-  }));
-}
-
-// src/core/repository/repository.ts
-var REFERENCES = {
-  reference: (record) => isEntity(record) ? record.id : undefined
-};
-
-class AbstractRepository {
-  get [Kind]() {
-    return "repository";
-  }
-  get entity() {
-    return stateOf(this).entity;
-  }
-  get actions() {
-    return stateOf(this).actions;
-  }
-  get provider() {
-    return stateOf(this).provider;
-  }
-  get context() {
-    return contextOf(stateOf(this));
-  }
-  get env() {
-    return this.context.env;
-  }
-  async hydrate(data) {
-    return (await this.hydrateMany([data]))[0];
-  }
-  async hydrateMany(list) {
-    const state = stateOf(this);
-    const resolved = await resolveReferences(state, list, new Map);
-    return resolved.map((data) => parseEntity(state, data));
-  }
-  dataOf(entity) {
-    if (!(entity instanceof stateOf(this).entity)) {
-      throw new InvalidRepositoryEntity({ source: stateOf(this).name });
-    }
-    return recordDataOf(entity, REFERENCES);
-  }
-}
-function action(method) {
-  return function(...args) {
-    return guard({ layer: "repository" /* Repository */, source: stateOf(this).name }, () => method(this, ...args));
-  };
-}
-function queryOf(context, key, value) {
-  const properties = context.entity.blueprint.properties;
-  return recordFieldDataOf(properties[key], value, REFERENCES);
-}
-var findBy = (key) => action(async (self, value) => {
-  const data = await self.provider.findOne(self.context, key, queryOf(self.context, key, value));
-  return data === undefined ? undefined : await self.hydrate(data);
-});
-var findManyBy = (key) => action(async (self, value) => {
-  const list = await self.provider.findMany(self.context, key, queryOf(self.context, key, value));
-  return self.hydrateMany(list);
-});
-var create2 = action(async (self, input) => {
-  const { entity: Entity } = self.context;
-  const entity = input instanceof Entity ? input : new Entity(input);
-  await self.provider.insert(self.context, self.dataOf(entity));
-  return entity;
-});
-var update = action(async (self, entity) => {
-  await self.provider.update(self.context, self.dataOf(entity));
-  return entity;
-});
-var remove = action(async (self, target) => {
-  const { context } = self;
-  let entity = target;
-  if (typeof target === "string") {
-    const data = await self.provider.findOne(context, "id", target);
-    if (data === undefined) {
-      throw new RepositoryEntityNotFound({
-        source: context.name,
-        details: { id: target }
-      });
-    }
-    entity = await self.hydrate(data);
-  }
-  const data = self.dataOf(entity);
-  const destroyable = entity;
-  if (!destroyable.isDeleted)
-    destroyable.destroy();
-  await self.provider.remove(context, data.id);
-  return entity;
-});
-var count = action(async (self) => self.provider.count(self.context));
-var NEEDS = {
-  findBy: ["findOne"],
-  findManyBy: ["findMany"],
-  create: ["insert"],
-  update: ["update"],
-  delete: ["findOne", "remove"],
-  count: ["count"]
-};
-function capitalize(key) {
-  return `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-}
-function unknownAction(entity, action, methods) {
-  const many = /^findManyBy(.+)$/.exec(action)?.[1];
-  const one = many === undefined ? /^findBy(.+)$/.exec(action)?.[1] : undefined;
-  const suffix = many ?? one;
-  const key = suffix === undefined ? undefined : `${suffix.charAt(0).toLowerCase()}${suffix.slice(1)}`;
-  if (one !== undefined && methods.has(`findManyBy${one}`)) {
-    return `"${action}" requires "${key}" to be a unique key of ${entity}.`;
-  }
-  if (many !== undefined && methods.has(`findBy${many}`)) {
-    return `"${action}" is not available for the unique key "${key}" of ${entity}; use "findBy${many}".`;
-  }
-  return `"${action}" is not an action of ${entity}.`;
-}
-function invalid2(source, reason) {
-  throw new InvalidRepositoryDeclaration({ source, details: { reason } });
-}
-function repositoryOf(settings) {
-  const { entity, actions, environmentDependencies } = settings ?? {};
-  if (!isEntityClass(entity) || !(EntityUniqueKeys in entity)) {
-    invalid2("repositoryOf", "Expected an entity class made by entityOf.");
-  }
-  const name = `${entity.name}Repository`;
-  const provider = settings.provider ?? inMemoryProvider();
-  if (!Array.isArray(actions) || actions.length === 0) {
-    invalid2(name, "Expected a list of actions.");
-  }
-  if (environmentDependencies !== undefined && !isEnvironment(environmentDependencies) && !(Array.isArray(environmentDependencies) && environmentDependencies.every(isEnvironment))) {
-    invalid2(name, "Expected environments made by environmentOf.");
-  }
-  const relations = relationsOf(name, entity, settings.relations);
-  const unique = entity[EntityUniqueKeys];
-  const methods = new Map;
-  for (const key of Object.keys(entity.blueprint.properties)) {
-    const suffix = capitalize(key);
-    if (unique.includes(key)) {
-      methods.set(`findBy${suffix}`, ["findBy", findBy(key)]);
-    } else {
-      methods.set(`findManyBy${suffix}`, ["findManyBy", findManyBy(key)]);
-    }
-  }
-  methods.set("create", ["create", create2]);
-  methods.set("update", ["update", update]);
-  methods.set("delete", ["delete", remove]);
-  methods.set("count", ["count", count]);
-
-  class DeclaredRepository extends AbstractRepository {
-  }
-  for (const name_ of new Set(actions)) {
-    const method = typeof name_ === "string" ? methods.get(name_) : undefined;
-    if (!method)
-      invalid2(name, unknownAction(entity.name, String(name_), methods));
-    const [kind, implementation] = method;
-    for (const need of NEEDS[kind] ?? []) {
-      if (typeof provider?.[need] !== "function") {
-        invalid2(name, `The provider has no "${need}" for "${name_}".`);
-      }
-    }
-    Object.defineProperty(DeclaredRepository.prototype, name_, {
-      value: implementation,
-      writable: true,
-      configurable: true
-    });
-  }
-  Object.defineProperty(DeclaredRepository, "name", { value: name });
-  states.set(DeclaredRepository, {
-    name,
-    entity,
-    actions: Object.freeze([...new Set(actions)]),
-    provider,
-    explicitProvider: settings.provider !== undefined,
-    environment: environmentDependencies,
-    relations
-  });
-  return Object.freeze(new DeclaredRepository);
-}
-function RepositoryOf(repository) {
-  if (!isRepository(repository)) {
-    invalid2("RepositoryOf", "Expected a repository made by repositoryOf.");
-  }
-  return repository.constructor;
-}
-function isRepository(value) {
-  return value instanceof AbstractRepository;
-}
-// src/core/use-case/use-case.ts
-var InvalidUseCaseDeclaration = exceptionOf({
-  layer: "use-case" /* UseCase */,
-  name: "InvalidUseCaseDeclaration",
-  message: ({ reason }) => reason
-});
-var UseCaseAlreadyExecuted = exceptionOf({
-  layer: "use-case" /* UseCase */,
-  name: "UseCaseAlreadyExecuted",
-  message: "A UseCase instance can execute only once."
-});
-var InvalidUseCaseDependencies = exceptionOf({
-  layer: "use-case" /* UseCase */,
-  name: "InvalidUseCaseDependencies",
-  message: "Dependency overrides must contain only declared names: functions for use cases, objects of methods for repositories, and valid variables for environments."
-});
-var states2 = new WeakMap;
-function invalidValue(issues, source, phase) {
-  throw new Exception({
-    layer: "use-case" /* UseCase */,
-    name: phase === "input" ? "InvalidUseCaseInput" : "InvalidUseCaseResponse",
-    source,
-    message: `Invalid UseCase ${phase}.`,
-    details: { issues },
-    cause: issues.find((issue) => issue.cause)?.cause
-  });
-}
-function collectEvents(blueprint, value, events) {
-  const visited = new WeakSet;
-  const visit = (field, current) => {
-    if (typeof current !== "object" || current === null || visited.has(current))
-      return;
-    visited.add(current);
-    if (isEntity(current))
-      events.push(...current.pullEvents());
-    if (isBlueprintList(field)) {
-      for (const item of current)
-        visit(field.item, item);
-      return;
-    }
-    const shape = isBlueprint(field) ? field : recordFieldOf(field)?.record.blueprint;
-    if (!shape)
-      return;
-    for (const [key, child] of Object.entries(shape.properties)) {
-      visit(child, current[key]);
-    }
-  };
-  visit(blueprint, value);
-}
-function pullEntities(value, Entity, events) {
-  for (const item of Array.isArray(value) ? value : [value]) {
-    if (isEntity(item) && item instanceof Entity) {
-      events.push(...item.pullEvents());
-    }
-  }
-}
-function methodNamesOf(repository) {
-  const names = new Set;
-  for (let current = repository;current !== null && current !== AbstractRepository.prototype && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
-    for (const name of Object.getOwnPropertyNames(current)) {
-      const descriptor = Object.getOwnPropertyDescriptor(current, name);
-      if (name !== "constructor" && typeof descriptor?.value === "function") {
-        names.add(name);
-      }
-    }
-  }
-  return [...names];
-}
-function bindRepository2(repository, overrides, state, source) {
-  const Entity = repository.entity;
-  const bound = Object.create(null);
-  const view = new Proxy(Object.create(repository), {
-    get: (_target, key, receiver) => typeof key === "string" && Object.hasOwn(bound, key) ? bound[key] : Reflect.get(repository, key, receiver),
-    set: (_target, key, value) => Reflect.set(repository, key, value),
-    defineProperty: (_target, key, descriptor) => Reflect.defineProperty(repository, key, descriptor),
-    deleteProperty: (_target, key) => Reflect.deleteProperty(repository, key)
-  });
-  const bind = (target, name, receiver) => {
-    const method = target[name];
-    bound[name] = async (...args) => {
-      if (!state.active)
-        throw new InvalidUseCaseDependencies({ source });
-      const result = await method.apply(receiver, args);
-      for (const arg of args)
-        pullEntities(arg, Entity, state.events);
-      pullEntities(result, Entity, state.events);
-      return result;
-    };
-  };
-  for (const name of methodNamesOf(repository))
-    bind(repository, name, view);
-  if (overrides) {
-    for (const name of new Set([
-      ...methodNamesOf(repository),
-      ...methodNamesOf(overrides)
-    ])) {
-      if (typeof overrides[name] === "function") {
-        bind(overrides, name, overrides);
-      }
-    }
-  }
-  bound.entity = Entity;
-  bound.actions = repository.actions;
-  return Object.freeze(bound);
-}
-function isOverrideOf(dependency, value) {
-  if (isRepository(dependency) || isEnvironment(dependency)) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-  return typeof value === "function";
-}
-
-class AbstractUseCase {
-  input;
-  constructor(input) {
-    const declaration = this.constructor;
-    const source = declaration.useCaseName;
-    const parsed = declaration.blueprint.safeParse(input);
-    if (parsed.issues)
-      invalidValue(parsed.issues, source, "input");
-    this.input = parsed.value;
-    Object.defineProperty(this, "input", {
-      writable: false,
-      configurable: false
-    });
-    const implementation = this.execute;
-    if (typeof implementation !== "function") {
-      throw new InvalidUseCaseDeclaration({
-        source,
-        details: { reason: "Implement execute as a prototype method." }
-      });
-    }
-    const state = {
-      started: false,
-      active: false,
-      events: [],
-      dependencies: Object.create(null)
-    };
-    states2.set(this, state);
-    for (const [key, dependency] of Object.entries(declaration.dependencies)) {
-      if (isRepository(dependency)) {
-        state.dependencies[key] = bindRepository2(dependency, undefined, state, source);
-        continue;
-      }
-      if (isEnvironment(dependency)) {
-        Object.defineProperty(state.dependencies, key, {
-          get: () => dependency.load(),
-          enumerable: true
-        });
-        continue;
-      }
-      const Child = dependency;
-      state.dependencies[key] = async (value) => {
-        if (!state.active)
-          throw new InvalidUseCaseDependencies({ source });
-        const child = new Child(value);
-        try {
-          return await child.execute();
-        } finally {
-          state.events.push(...child.pullEvents());
-        }
-      };
-    }
-    Object.freeze(state.dependencies);
-    Object.defineProperty(this, "execute", {
-      value: async (overrides = {}) => {
-        if (state.started)
-          throw new UseCaseAlreadyExecuted({ source });
-        state.started = true;
-        if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides) || Reflect.ownKeys(overrides).some((key) => typeof key !== "string" || !Object.hasOwn(declaration.dependencies, key) || !isOverrideOf(declaration.dependencies[key], overrides[key]))) {
-          throw new InvalidUseCaseDependencies({ source });
-        }
-        const replaced = overrides;
-        const dependencies = {};
-        for (const key of Object.keys(declaration.dependencies)) {
-          if (!Object.hasOwn(replaced, key)) {
-            dependencies[key] = state.dependencies[key];
-          }
-        }
-        for (const [key, substitute] of Object.entries(replaced)) {
-          const dependency = declaration.dependencies[key];
-          if (isRepository(dependency)) {
-            dependencies[key] = bindRepository2(dependency, substitute, state, source);
-            continue;
-          }
-          if (isEnvironment(dependency)) {
-            const parsed = dependency.blueprint.safeParse(substitute);
-            if (parsed.issues)
-              throw new InvalidUseCaseDependencies({ source });
-            dependencies[key] = Object.freeze(parsed.value);
-            continue;
-          }
-          const Child = dependency;
-          dependencies[key] = async (value) => {
-            if (!state.active)
-              throw new InvalidUseCaseDependencies({ source });
-            const childSource = Child.useCaseName;
-            const input = Child.blueprint.safeParse(value);
-            if (input.issues)
-              invalidValue(input.issues, childSource, "input");
-            const output = Child.response.safeParse(await guard({ layer: "use-case" /* UseCase */, source: childSource }, () => substitute(input.value)));
-            if (output.issues)
-              invalidValue(output.issues, childSource, "response");
-            collectEvents(Child.response, output.value, state.events);
-            return output.value;
-          };
-        }
-        state.resolved = Object.freeze(dependencies);
-        state.active = true;
-        try {
-          const result = await guard({ layer: "use-case" /* UseCase */, source }, () => implementation.call(this, state.resolved));
-          const parsed = declaration.response.safeParse(result);
-          if (parsed.issues)
-            invalidValue(parsed.issues, source, "response");
-          collectEvents(declaration.response, parsed.value, state.events);
-          return parsed.value;
-        } finally {
-          state.active = false;
-          state.resolved = undefined;
-        }
-      }
-    });
-  }
-  get dependencies() {
-    const state = states2.get(this);
-    return state?.resolved ?? state?.dependencies;
-  }
-  pullEvents() {
-    return states2.get(this)?.events.splice(0) ?? [];
-  }
-}
-function useCaseOf(settings) {
-  const { name, blueprint, response } = settings;
-  const dependencies = settings.dependencies === undefined ? {} : settings.dependencies;
-  if (typeof name !== "string" || !name.trim() || !isBlueprint(blueprint) || blueprint.optional || !isBlueprint(response) || response.optional || typeof dependencies !== "object" || dependencies === null || Array.isArray(dependencies) || Reflect.ownKeys(dependencies).some((key) => typeof key !== "string" || !isDependency(dependencies[key]))) {
-    throw new InvalidUseCaseDeclaration({
-      source: typeof name === "string" ? name : "useCaseOf",
-      details: {
-        reason: "Expected a name, input and response blueprints, and UseCase classes, repositories or environments as dependencies."
-      }
-    });
-  }
-
-  class DeclaredUseCase extends AbstractUseCase {
-    static [Kind] = "use-case";
-    static useCaseName = name;
-    static blueprint = blueprint;
-    static response = response;
-    static dependencies = Object.freeze({
-      ...dependencies
-    });
-  }
-  Object.defineProperty(DeclaredUseCase, "name", { value: name });
-  return DeclaredUseCase;
-}
-function isDependency(value) {
-  return isUseCaseClass(value) || isRepository(value) || isEnvironment(value);
-}
-function isUseCaseClass(value) {
-  return typeof value === "function" && value.prototype instanceof AbstractUseCase && value[Kind] === "use-case" && typeof value.prototype.execute === "function";
-}
-function isUseCase(value) {
-  return value instanceof AbstractUseCase;
-}
-// src/std/properties/contact.ts
-import { Type as Type4 } from "typebox";
-var Email = propertyOf({
-  name: "email",
-  schema: Type4.String({ format: "email", maxLength: 254 }),
-  default: "demo@example.com",
-  preHandle: (value) => value.trim().toLowerCase()
-});
-var Phone = propertyOf({
-  name: "phone",
-  schema: Type4.String({ pattern: "^\\+[1-9]\\d{1,14}$" }),
-  default: "+5511999999999",
-  preHandle: (value) => value.replace(/[\s().-]/g, "")
-});
-var Url = propertyOf({
-  name: "url",
-  schema: Type4.String({ format: "url", maxLength: 2048 }),
-  default: "https://example.com",
-  preHandle: (value) => value.trim()
-});
-var Ip = propertyOf({
-  name: "ip",
-  schema: Type4.Union([
-    Type4.String({ format: "ipv4" }),
-    Type4.String({ format: "ipv6" })
-  ]),
-  default: "127.0.0.1",
-  preHandle: (value) => value.trim()
-});
-
-// src/std/properties/enum.ts
-import { Type as Type5 } from "typebox";
-function enumOf(values, {
-  name = "enum",
-  optional,
-  default: _default = values[0]
-} = {}) {
-  const Enum = propertyOf({
-    name,
-    schema: Type5.Enum(values),
-    optional,
-    default: _default
-  });
-  recordPropertyLineage(Enum, {
-    kind: "factory",
-    factory: "enumOf",
-    args: Object.freeze({
-      values: Object.freeze([...values]),
-      ...name === "enum" ? {} : { name },
-      ...optional ? { optional: true } : {},
-      ..._default === values[0] ? {} : { default: _default }
-    })
-  });
-  return Enum;
-}
-
-// src/std/properties/headless.ts
-import { Type as Type6 } from "typebox";
-import { Meta } from "typebox/schema";
-var JSON_SCHEMA = Type6.Unsafe({
-  type: "object",
-  allOf: [Meta["https://json-schema.org/draft/2020-12/schema"]]
-});
-
-class SchemaProperty extends propertyOf({
-  name: "schema",
-  schema: JSON_SCHEMA,
-  default: Type6.String()
-}) {
-  compiled;
-  static deserialize(json) {
-    let value;
-    try {
-      value = JSON.parse(json);
-    } catch (error) {
-      throw new InvalidPropertyValue({
-        source: "schema",
-        details: { errors: [error.message] }
-      });
-    }
-    return new SchemaProperty(value);
-  }
-  serialize() {
-    return JSON.stringify(this.value);
-  }
-  match(data) {
-    return this.toSchema().match(data);
-  }
-  errors(data) {
-    return this.toSchema().errors(data);
-  }
-  toSchema() {
-    if (!this.compiled) {
-      const Schema = schemaOf("schema", this.value);
-      this.compiled = new Schema;
-    }
-    return this.compiled;
-  }
-}
-
-// src/std/properties/identity.ts
-import slugify from "slugify";
-import { Type as Type7 } from "typebox";
-
-// src/std/runtime.ts
-var PasswordHasherRequired = exceptionOf({
-  layer: "property" /* Property */,
-  name: "PasswordHasherRequired",
-  message: "No password hasher is available: this runtime has neither Bun.password nor native argon2 (node:crypto, Node >= 24.7). Call configure({ hasher }) with your own PasswordHasher."
-});
-var SyncVerifyUnsupported = exceptionOf({
-  layer: "property" /* Property */,
-  name: "SyncVerifyUnsupported",
-  message: "The configured password hasher has no verifySync. Use verify, or configure a hasher that provides verifySync."
-});
-var UnsupportedPasswordHash = exceptionOf({
-  layer: "property" /* Property */,
-  name: "UnsupportedPasswordHash",
-  message: ({ version }) => `The password hash uses argon2 version ${version}, but native argon2 (node:crypto) only derives version ${ARGON2_VERSION}. Verify it with Bun.password or configure({ hasher }).`
-});
-var ARGON2_VERSION = 19;
-var ARGON2_PARAMS = {
-  memory: 65536,
-  passes: 2,
-  parallelism: 1,
-  tagLength: 32,
-  saltLength: 32,
-  version: ARGON2_VERSION
-};
-var toBase64 = (bytes) => btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join("")).replace(/=+$/, "");
-var fromBase64 = (text) => Uint8Array.from(atob(text), (char) => char.charCodeAt(0));
-function encodePhc(salt, tag) {
-  const { memory, passes, parallelism, version } = ARGON2_PARAMS;
-  return `$argon2id$v=${version}$m=${memory},t=${passes},p=${parallelism}$${toBase64(salt)}$${toBase64(tag)}`;
-}
-var PHC = /^\$argon2id\$v=(\d+)\$m=(\d+),t=(\d+),p=(\d+)\$([A-Za-z0-9+/]+)\$([A-Za-z0-9+/]+)$/;
-function decodePhc(phc) {
-  const match = PHC.exec(phc);
-  if (!match)
-    return;
-  return {
-    version: Number(match[1]),
-    memory: Number(match[2]),
-    passes: Number(match[3]),
-    parallelism: Number(match[4]),
-    salt: fromBase64(match[5]),
-    tag: fromBase64(match[6])
-  };
-}
-function nodeHasherOf(crypto) {
-  const { argon2, argon2Sync, randomBytes, timingSafeEqual } = crypto;
-  if (!argon2 || !argon2Sync || !randomBytes || !timingSafeEqual) {
-    return;
-  }
-  const derive = (parameters) => new Promise((resolve, reject) => {
-    argon2("argon2id", parameters, (error, key) => error ? reject(error) : resolve(key));
-  });
-  const parametersOf = (plain, parsed) => ({
-    message: plain,
-    nonce: parsed.salt,
-    parallelism: parsed.parallelism,
-    tagLength: parsed.tag.length,
-    memory: parsed.memory,
-    passes: parsed.passes
-  });
-  const decode = (hash) => {
-    const parsed = decodePhc(hash);
-    if (parsed && parsed.version !== ARGON2_VERSION) {
-      throw new UnsupportedPasswordHash({
-        source: "password",
-        details: { version: parsed.version }
-      });
-    }
-    return parsed;
-  };
-  const matches = (tag, expected) => tag.length === expected.length && timingSafeEqual(tag, expected);
-  return {
-    async hash(plain) {
-      const salt = randomBytes(ARGON2_PARAMS.saltLength);
-      const tag = await derive({
-        message: plain,
-        nonce: salt,
-        parallelism: ARGON2_PARAMS.parallelism,
-        tagLength: ARGON2_PARAMS.tagLength,
-        memory: ARGON2_PARAMS.memory,
-        passes: ARGON2_PARAMS.passes
-      });
-      return encodePhc(salt, tag);
-    },
-    async verify(plain, hash) {
-      const parsed = decode(hash);
-      if (!parsed)
-        return false;
-      return matches(await derive(parametersOf(plain, parsed)), parsed.tag);
-    },
-    verifySync(plain, hash) {
-      const parsed = decode(hash);
-      if (!parsed)
-        return false;
-      const tag = argon2Sync("argon2id", parametersOf(plain, parsed));
-      return matches(tag, parsed.tag);
-    }
-  };
-}
-function bunHasherOf(password) {
-  return {
-    hash: (plain) => password.hash(plain, { algorithm: "argon2id" }),
-    verify: (plain, hash) => password.verify(plain, hash),
-    verifySync: (plain, hash) => password.verifySync(plain, hash)
-  };
-}
-function missingHasher() {
-  return {
-    hash: () => Promise.reject(new PasswordHasherRequired({ source: "password" })),
-    verify: () => Promise.reject(new PasswordHasherRequired({ source: "password" })),
-    verifySync: () => {
-      throw new PasswordHasherRequired({ source: "password" });
-    }
-  };
-}
-function defaultHasherOf(environment) {
-  if (environment.bun?.password) {
-    return bunHasherOf(environment.bun.password);
-  }
-  const node = environment.crypto && nodeHasherOf(environment.crypto);
-  return node ?? missingHasher();
-}
-var lastTimestamp = 0;
-var sequence = 0;
-function uuidv7(now = Date.now()) {
-  const random = globalThis.crypto.getRandomValues(new Uint8Array(10));
-  const start = random[8] << 8 | random[9];
-  if (now > lastTimestamp) {
-    lastTimestamp = now;
-    sequence = start & 2047;
-  } else if (sequence < 4095) {
-    sequence++;
-  } else {
-    lastTimestamp++;
-    sequence = start & 2047;
-  }
-  const bytes = new Uint8Array(16);
-  const view = new DataView(bytes.buffer);
-  view.setUint16(0, Math.floor(lastTimestamp / 2 ** 32));
-  view.setUint32(2, lastTimestamp % 2 ** 32);
-  view.setUint16(6, 28672 | sequence);
-  bytes.set(random.subarray(0, 8), 8);
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
-  return [
-    hex.slice(0, 4),
-    hex.slice(4, 6),
-    hex.slice(6, 8),
-    hex.slice(8, 10),
-    hex.slice(10)
-  ].map((part) => part.join("")).join("-");
-}
-var hasher;
-var idGenerator = () => uuidv7();
-function configure(services) {
-  if (services.hasher)
-    hasher = services.hasher;
-  if (services.idGenerator)
-    idGenerator = services.idGenerator;
-}
-function resetRuntime() {
-  hasher = undefined;
-  idGenerator = () => uuidv7();
-  lastTimestamp = 0;
-  sequence = 0;
-}
-function nodeCryptoOf() {
-  const process = globalThis.process;
-  return process?.getBuiltinModule?.("node:crypto");
-}
-function currentHasher() {
-  hasher ??= defaultHasherOf({
-    bun: globalThis.Bun,
-    crypto: nodeCryptoOf()
-  });
-  return hasher;
-}
-function generateId() {
-  return idGenerator();
-}
-function verifySyncWithCurrent(plain, hash) {
-  const current = currentHasher();
-  if (!current.verifySync)
-    throw new SyncVerifyUnsupported({ source: "password" });
-  return current.verifySync(plain, hash);
-}
-
-// src/std/properties/identity.ts
-var UUID_V7 = "^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$";
-
-class Id extends propertyOf({
-  name: "id",
-  schema: Type7.String({ pattern: UUID_V7 }),
-  default: "01a173d2-051c-77bb-8166-a371e999573e",
-  preHandle: (value) => value.toLowerCase()
-}) {
-  static generate() {
-    return new Id(generateId());
-  }
-}
-
-class Slug extends propertyOf({
-  name: "slug",
-  schema: Type7.String({
-    pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$",
-    maxLength: 255
-  }),
-  default: "demo-slug",
-  unique: true,
-  preHandle: (value) => slugify(value, { lower: true, strict: true, trim: true })
-}) {
-}
-
-// src/std/properties/password.ts
-import { Type as Type8 } from "typebox";
-var PASSWORD_MIN_LENGTH = 7;
-var PASSWORD_MAX_LENGTH = 128;
-var PASSWORD_SPECIAL_CHARACTERS = "!@#$%^&*()-_=+[]{}|\\;:'\",.<>/?`~";
-var ARGON2_HASH = "^\\$argon2(id|i|d)\\$v=\\d+\\$m=\\d+,t=\\d+,p=\\d+\\$[A-Za-z0-9+/]+\\$[A-Za-z0-9+/]+$";
-var DEMO_HASH = "$argon2id$v=19$m=65536,t=2,p=1$YO5NNmxyK9+adO95GxWsAaUX4TULmT3IGhTYfpshXl0$/C89OCh7bhDY2cR2UkgvOV3dPlkghNLhv/DJsdopwMo";
-function isPasswordHash(value) {
-  return new RegExp(ARGON2_HASH).test(value);
-}
-function passwordIssues(value) {
-  const issues = [];
-  if (value.length < PASSWORD_MIN_LENGTH) {
-    issues.push(`must have at least ${PASSWORD_MIN_LENGTH} characters`);
-  }
-  if (value.length > PASSWORD_MAX_LENGTH) {
-    issues.push(`must have at most ${PASSWORD_MAX_LENGTH} characters`);
-  }
-  if (!/[a-z]/.test(value))
-    issues.push("must contain a lowercase letter");
-  if (!/[A-Z]/.test(value))
-    issues.push("must contain an uppercase letter");
-  if (!/\d/.test(value))
-    issues.push("must contain a number");
-  if (![...value].some((char) => PASSWORD_SPECIAL_CHARACTERS.includes(char))) {
-    issues.push(`must contain a special character (${PASSWORD_SPECIAL_CHARACTERS})`);
-  }
-  return issues;
-}
-
-class Password extends propertyOf({
-  name: "password",
-  schema: Type8.String({ pattern: ARGON2_HASH }),
-  default: DEMO_HASH,
-  sensitive: true
-}) {
-  static async hash(plain) {
-    const issues = passwordIssues(plain);
-    if (issues.length > 0) {
-      throw new InvalidPropertyValue({
-        source: "password",
-        details: { errors: issues }
-      });
-    }
-    return new Password(await currentHasher().hash(plain));
-  }
-  verify(input) {
-    const hash = this.value;
-    if (hash === undefined)
-      return Promise.resolve(false);
-    return currentHasher().verify(input, hash);
-  }
-  verifySync(input) {
-    const hash = this.value;
-    if (hash === undefined)
-      return false;
-    return verifySyncWithCurrent(input, hash);
-  }
-}
-
-// src/std/properties/primitives.ts
-import { Type as Type9 } from "typebox";
-var StringProperty = propertyOf({
-  name: "string",
-  schema: Type9.String(),
-  default: "demo"
-});
-var Text = propertyOf({
-  name: "text",
-  schema: Type9.String({ minLength: 1 }),
-  default: "Demo",
-  preHandle: (value) => value.trim()
-});
-var NumberProperty = propertyOf({
-  name: "number",
-  schema: Type9.Number(),
-  default: 0
-});
-var Integer = propertyOf({
-  name: "integer",
-  schema: Type9.Integer(),
-  default: 0
-});
-var BooleanProperty = propertyOf({
-  name: "boolean",
-  schema: Type9.Boolean(),
-  default: false
-});
-
-// src/std/properties/time.ts
-import { Type as Type10 } from "typebox";
-var DEMO_DATE_TIME = "2026-01-01T00:00:00.000Z";
-function dateTimeOf({
-  name,
-  optional,
-  default: _default
-}) {
-  return class extends propertyOf({
-    name,
-    schema: Type10.String({ format: "date-time" }),
-    optional,
-    default: _default
-  }) {
-    static now() {
-      return new this(new Date().toISOString());
-    }
-  };
-}
-
-class DateTime extends dateTimeOf({
-  name: "dateTime",
-  default: DEMO_DATE_TIME
-}) {
-}
-var DateProperty = propertyOf({
-  name: "date",
-  schema: Type10.String({ format: "date" }),
-  default: "2026-01-01"
-});
-
-class CreatedAt extends dateTimeOf({
-  name: "createdAt",
-  default: DEMO_DATE_TIME
-}) {
-}
-
-class UpdatedAt extends dateTimeOf({
-  name: "updatedAt",
-  optional: true,
-  default: DEMO_DATE_TIME
-}) {
-}
-
-class DeletedAt extends dateTimeOf({
-  name: "deletedAt",
-  optional: true
-}) {
-}
-
-// src/std/blueprint-plugin.ts
-var Std = blueprintPluginOf("std", {
-  id: Id,
-  slug: Slug,
-  email: Email,
-  phone: Phone,
-  url: Url,
-  ip: Ip,
-  password: Password,
-  string: StringProperty,
-  text: Text,
-  number: NumberProperty,
-  integer: Integer,
-  boolean: BooleanProperty,
-  date: DateProperty,
-  dateTime: DateTime,
-  createdAt: CreatedAt,
-  updatedAt: UpdatedAt,
-  deletedAt: DeletedAt,
-  schema: SchemaProperty
-}, { enumOf });
-
-// src/std/blueprint.ts
-var blueprintOf = blueprintBuilderOf(Std);
-// src/std/record-plugins.ts
-var now = () => new Date().toISOString();
-
-class PublishableRecord extends recordOf(blueprintOf((ctx) => ({ publishedAt: ctx.optional.dateTime }))) {
-  get isPublished() {
-    return this.publishedAt !== undefined;
-  }
-  publish(at = now()) {
-    return this.set("publishedAt", at);
-  }
-  unpublish() {
-    return this.set("publishedAt", undefined);
-  }
-}
-var Publishable = recordPluginOf("publishable", PublishableRecord, {
-  description: "A publication date, with publish, unpublish and isPublished."
-});
-
-class ArchivableRecord extends recordOf(blueprintOf((ctx) => ({ archivedAt: ctx.optional.dateTime }))) {
-  get isArchived() {
-    return this.archivedAt !== undefined;
-  }
-  archive(at = now()) {
-    return this.set("archivedAt", at);
-  }
-  restore() {
-    return this.set("archivedAt", undefined);
-  }
-}
-var Archivable = recordPluginOf("archivable", ArchivableRecord, {
-  description: "An archive date, with archive, restore and isArchived."
-});
-
-class TaggableRecord extends recordOf(blueprintOf((ctx) => ({ tags: ctx.list.optional.string }))) {
-  hasTag(tag) {
-    return this.tags?.includes(tag) ?? false;
-  }
-  tag(...tags) {
-    return this.set("tags", [...new Set([...this.tags ?? [], ...tags])]);
-  }
-  untag(...tags) {
-    return this.set("tags", (this.tags ?? []).filter((tag) => !tags.includes(tag)));
-  }
-}
-var Taggable = recordPluginOf("taggable", TaggableRecord, {
-  description: "A list of tags, with tag, untag and hasTag."
-});
-
-class OwnableRecord extends recordOf(blueprintOf((ctx) => ({ ownerId: ctx.id }))) {
-  isOwnedBy(id) {
-    return this.ownerId === id.toLowerCase();
-  }
-  transferTo(id) {
-    return this.set("ownerId", id);
-  }
-}
-var Ownable = recordPluginOf("ownable", OwnableRecord, {
-  description: "The id of the owner, with isOwnedBy and transferTo."
-});
-
-class AuthenticatableRecord extends recordOf(blueprintOf((ctx) => ({ email: ctx.email, password: ctx.password })), { unique: ["email"], change: ["password"] }) {
-  verifyPassword(plain) {
-    return new Password(this.password).verify(plain);
-  }
-}
-var Authenticatable = recordPluginOf("authenticatable", AuthenticatableRecord, {
-  description: "A unique email and a sensitive password hash, with change.password and verifyPassword."
-});
-var StdRecordPlugins = recordPluginCatalogOf(Publishable, Archivable, Taggable, Ownable, Authenticatable);
-
-// src/std/entity.ts
-var Identity = blueprintBuilderOf()(() => ({
-  id: Id,
-  createdAt: CreatedAt,
-  updatedAt: UpdatedAt,
-  deletedAt: DeletedAt
-}));
-var entityOf = entityBuilderOf({
-  identity: Identity,
-  generateId,
-  now: () => new Date().toISOString(),
-  plugins: [StdRecordPlugins]
-});
-// src/std/record.ts
-var recordOf2 = recordBuilderOf(StdRecordPlugins);
+import {
+  InvalidEnvironment2,
+  environmentOf2,
+  isEnvironment2,
+  guard2,
+  InvalidApplicationDeclaration2,
+  DuplicateApplicationDeclaration2,
+  ApplicationConflict2,
+  UnregisteredApplicationReference2,
+  UnregisteredRepositoryDependency2,
+  UnregisteredUseCaseDependency2,
+  ApplicationNotStarted2,
+  ApplicationAlreadyStarted2,
+  InvalidApplicationEnvironment2,
+  useApplication2,
+  resetApplication2,
+  InvalidLogDeclaration2,
+  LogLevels2,
+  logProviderOf2,
+  consoleLogProvider2,
+  jsonLogProvider2,
+  memoryLogProvider2,
+  Logger2,
+  ReservedEntityKey2,
+  ImmutableEntityKey2,
+  DeletedEntity2,
+  entityBuilderOf2,
+  isEntityClass2,
+  isEntity2,
+  eventOf2,
+  ENTITY_IDENTITY_KEYS2,
+  RESERVED_ENTITY_KEYS2,
+  EntityUniqueKeys2,
+  AbstractEntity2,
+  InvalidRepositoryQuery2,
+  InvalidRepositoryDeclaration2,
+  InvalidRepositoryEntity2,
+  InvalidRepositoryData2,
+  RepositoryUniqueViolation2,
+  RepositoryEntityNotFound2,
+  providerOf2,
+  providerDescriptionOf2,
+  inMemoryProvider2,
+  AbstractRepository2,
+  repositoryOf2,
+  RepositoryOf2,
+  isRepository2,
+  InvalidUseCaseStep2,
+  InvalidUseCaseDeclaration2,
+  UseCaseAlreadyExecuted2,
+  InvalidUseCaseDependencies2,
+  AbstractUseCase2,
+  useCaseOf2,
+  isUseCaseClass2,
+  isUseCase2,
+  InvalidCommandDeclaration2,
+  UnknownCommandOperation2,
+  InvalidCommandContext2,
+  InvalidCommandEnvironment2,
+  CommandEventFailed2,
+  commandOf2,
+  isCommand2,
+  InvalidOpenAPIModel2,
+  InvalidOutputStage2,
+  DuplicateOperation2,
+  toOpenAPI2,
+  transformOf2,
+  sinkOf2,
+  stageDescriptionOf2,
+  stageKindOf2,
+  stageCatalogOf2,
+  operationOf2,
+  outputOf2,
+  isOutput2,
+  providerFrom2,
+  logFrom2,
+  isLogFactory2,
+  isProviderFactory2,
+  isApplication2,
+  applicationOf2,
+  blueprintPluginOf2,
+  statusOf2,
+  PROBLEM_MEDIA_TYPE2,
+  problemOf2,
+  outputValueOf2,
+  routeOptionsIssue2,
+  operationRoutes2,
+  openapi2,
+  select2,
+  recordPluginCatalogOf2,
+  Email2,
+  Phone2,
+  Url2,
+  Ip2,
+  enumOf2,
+  SchemaProperty2,
+  PasswordHasherRequired2,
+  SyncVerifyUnsupported2,
+  configure2,
+  resetRuntime2,
+  Id2,
+  Slug2,
+  PASSWORD_MIN_LENGTH2,
+  PASSWORD_MAX_LENGTH2,
+  PASSWORD_SPECIAL_CHARACTERS2,
+  isPasswordHash2,
+  passwordIssues2,
+  Password2,
+  StringProperty2,
+  Text2,
+  NumberProperty2,
+  Integer2,
+  BooleanProperty2,
+  DateTime2,
+  DateProperty2,
+  CreatedAt2,
+  UpdatedAt2,
+  DeletedAt2,
+  Std2,
+  blueprintOf2,
+  Publishable2,
+  Archivable2,
+  Taggable2,
+  Ownable2,
+  Authenticatable2,
+  StdRecordPlugins2,
+  entityOf2,
+  recordOf2,
+  StdStages2
+} from "./index-ewm6r4nw.js";
+import {
+  isProperty2,
+  schemaOf2,
+  Demo2,
+  propertyLineageOf2,
+  Kind2,
+  isBlueprint2,
+  isRecordClass2,
+  isOptionalRecord2,
+  recordFieldOf2,
+  listOf2,
+  isBlueprintList2,
+  ExceptionLayers2,
+  UNEXPECTED_ERROR2,
+  Exception2,
+  exceptionOf2,
+  Meta2,
+  InvalidRecordValue2,
+  UndeclaredRecordProperty2,
+  ReservedRecordKey2,
+  InvalidRecordPlugin2,
+  RecordPluginConflict2,
+  UnknownRecordPlugin2,
+  IncompatibleRecordPlugin2,
+  MASK2,
+  RESERVED_RECORD_KEYS2,
+  AbstractRecord2,
+  pluginsOf2,
+  isRecordPlugin2,
+  hasPlugin2,
+  recordPluginOf2,
+  recordBuilderOf2,
+  ReservedBlueprintKey2,
+  UndeclaredBlueprintProperty2,
+  PropertyRequired2,
+  InvalidPropertyValue2,
+  State2,
+  AbstractProperty2,
+  PropertyStates2,
+  AbstractDefineProperty2,
+  propertyOf2,
+  optionalOf2,
+  blueprintBuilderOf2
+} from "./index-hn82hm31.js";
 export {
-  AbstractDefineProperty,
-  AbstractEntity,
-  AbstractProperty,
-  AbstractRecord,
-  AbstractRepository,
-  AbstractUseCase,
-  ApplicationConflict,
-  Archivable,
-  Authenticatable,
-  BooleanProperty,
-  CreatedAt,
-  DateProperty,
-  DateTime,
-  DeletedAt,
-  DeletedEntity,
-  Demo,
-  DuplicateApplicationDeclaration,
-  ENTITY_IDENTITY_KEYS,
-  Email,
-  EntityUniqueKeys,
-  Exception,
-  ExceptionLayers,
-  Id,
-  ImmutableEntityKey,
-  IncompatibleRecordPlugin,
-  Integer,
-  InvalidApplicationDeclaration,
-  InvalidEnvironment,
-  InvalidOpenAPIModel,
-  InvalidPropertyValue,
-  InvalidRecordPlugin,
-  InvalidRecordValue,
-  InvalidRepositoryData,
-  InvalidRepositoryDeclaration,
-  InvalidRepositoryEntity,
-  InvalidUseCaseDeclaration,
-  InvalidUseCaseDependencies,
-  Ip,
-  Kind,
-  MASK,
-  NumberProperty,
-  Ownable,
-  PASSWORD_MAX_LENGTH,
-  PASSWORD_MIN_LENGTH,
-  PASSWORD_SPECIAL_CHARACTERS,
-  Password,
-  PasswordHasherRequired,
-  Phone,
-  PropertyRequired,
-  PropertyStates,
-  Publishable,
-  RESERVED_ENTITY_KEYS,
-  RESERVED_RECORD_KEYS,
-  RecordPluginConflict,
-  RepositoryEntityNotFound,
-  RepositoryOf,
-  RepositoryUniqueViolation,
-  ReservedBlueprintKey,
-  ReservedEntityKey,
-  ReservedRecordKey,
-  SchemaProperty,
-  Slug,
-  State,
-  Std,
-  StdRecordPlugins,
-  StringProperty,
-  SyncVerifyUnsupported,
-  Taggable,
-  Text,
-  UNEXPECTED_ERROR,
-  UndeclaredBlueprintProperty,
-  UndeclaredRecordProperty,
-  UnknownRecordPlugin,
-  UnregisteredApplicationReference,
-  UnregisteredRepositoryDependency,
-  UpdatedAt,
-  Url,
-  UseCaseAlreadyExecuted,
-  applicationOf,
-  blueprintBuilderOf,
-  blueprintOf,
-  blueprintPluginOf,
-  configure,
-  entityBuilderOf,
-  entityOf,
-  enumOf,
-  environmentOf,
-  eventOf,
-  exceptionOf,
-  guard,
-  hasPlugin,
-  inMemoryProvider,
-  isApplication,
-  isBlueprint,
-  isBlueprintList,
-  isEntity,
-  isEntityClass,
-  isEnvironment,
-  isOptionalRecord,
-  isPasswordHash,
-  isProperty,
-  isRecordClass,
-  isRecordPlugin,
-  isRepository,
-  isUseCase,
-  isUseCaseClass,
-  listOf,
-  optionalOf,
-  passwordIssues,
-  pluginsOf,
-  propertyLineageOf,
-  propertyOf,
-  recordBuilderOf,
-  recordFieldOf,
+  AbstractDefineProperty2 as AbstractDefineProperty,
+  AbstractEntity2 as AbstractEntity,
+  AbstractProperty2 as AbstractProperty,
+  AbstractRecord2 as AbstractRecord,
+  AbstractRepository2 as AbstractRepository,
+  AbstractUseCase2 as AbstractUseCase,
+  ApplicationAlreadyStarted2 as ApplicationAlreadyStarted,
+  ApplicationConflict2 as ApplicationConflict,
+  ApplicationNotStarted2 as ApplicationNotStarted,
+  Archivable2 as Archivable,
+  Authenticatable2 as Authenticatable,
+  BooleanProperty2 as BooleanProperty,
+  CommandEventFailed2 as CommandEventFailed,
+  CreatedAt2 as CreatedAt,
+  DateProperty2 as DateProperty,
+  DateTime2 as DateTime,
+  DeletedAt2 as DeletedAt,
+  DeletedEntity2 as DeletedEntity,
+  Demo2 as Demo,
+  DuplicateApplicationDeclaration2 as DuplicateApplicationDeclaration,
+  DuplicateOperation2 as DuplicateOperation,
+  ENTITY_IDENTITY_KEYS2 as ENTITY_IDENTITY_KEYS,
+  Email2 as Email,
+  EntityUniqueKeys2 as EntityUniqueKeys,
+  Exception2 as Exception,
+  ExceptionLayers2 as ExceptionLayers,
+  Id2 as Id,
+  ImmutableEntityKey2 as ImmutableEntityKey,
+  IncompatibleRecordPlugin2 as IncompatibleRecordPlugin,
+  Integer2 as Integer,
+  InvalidApplicationDeclaration2 as InvalidApplicationDeclaration,
+  InvalidApplicationEnvironment2 as InvalidApplicationEnvironment,
+  InvalidCommandContext2 as InvalidCommandContext,
+  InvalidCommandDeclaration2 as InvalidCommandDeclaration,
+  InvalidCommandEnvironment2 as InvalidCommandEnvironment,
+  InvalidEnvironment2 as InvalidEnvironment,
+  InvalidLogDeclaration2 as InvalidLogDeclaration,
+  InvalidOpenAPIModel2 as InvalidOpenAPIModel,
+  InvalidOutputStage2 as InvalidOutputStage,
+  InvalidPropertyValue2 as InvalidPropertyValue,
+  InvalidRecordPlugin2 as InvalidRecordPlugin,
+  InvalidRecordValue2 as InvalidRecordValue,
+  InvalidRepositoryData2 as InvalidRepositoryData,
+  InvalidRepositoryDeclaration2 as InvalidRepositoryDeclaration,
+  InvalidRepositoryEntity2 as InvalidRepositoryEntity,
+  InvalidRepositoryQuery2 as InvalidRepositoryQuery,
+  InvalidUseCaseDeclaration2 as InvalidUseCaseDeclaration,
+  InvalidUseCaseDependencies2 as InvalidUseCaseDependencies,
+  InvalidUseCaseStep2 as InvalidUseCaseStep,
+  Ip2 as Ip,
+  Kind2 as Kind,
+  LogLevels2 as LogLevels,
+  Logger2 as Logger,
+  MASK2 as MASK,
+  Meta2 as Meta,
+  NumberProperty2 as NumberProperty,
+  Ownable2 as Ownable,
+  PASSWORD_MAX_LENGTH2 as PASSWORD_MAX_LENGTH,
+  PASSWORD_MIN_LENGTH2 as PASSWORD_MIN_LENGTH,
+  PASSWORD_SPECIAL_CHARACTERS2 as PASSWORD_SPECIAL_CHARACTERS,
+  PROBLEM_MEDIA_TYPE2 as PROBLEM_MEDIA_TYPE,
+  Password2 as Password,
+  PasswordHasherRequired2 as PasswordHasherRequired,
+  Phone2 as Phone,
+  PropertyRequired2 as PropertyRequired,
+  PropertyStates2 as PropertyStates,
+  Publishable2 as Publishable,
+  RESERVED_ENTITY_KEYS2 as RESERVED_ENTITY_KEYS,
+  RESERVED_RECORD_KEYS2 as RESERVED_RECORD_KEYS,
+  RecordPluginConflict2 as RecordPluginConflict,
+  RepositoryEntityNotFound2 as RepositoryEntityNotFound,
+  RepositoryOf2 as RepositoryOf,
+  RepositoryUniqueViolation2 as RepositoryUniqueViolation,
+  ReservedBlueprintKey2 as ReservedBlueprintKey,
+  ReservedEntityKey2 as ReservedEntityKey,
+  ReservedRecordKey2 as ReservedRecordKey,
+  SchemaProperty2 as SchemaProperty,
+  Slug2 as Slug,
+  State2 as State,
+  Std2 as Std,
+  StdRecordPlugins2 as StdRecordPlugins,
+  StdStages2 as StdStages,
+  StringProperty2 as StringProperty,
+  SyncVerifyUnsupported2 as SyncVerifyUnsupported,
+  Taggable2 as Taggable,
+  Text2 as Text,
+  UNEXPECTED_ERROR2 as UNEXPECTED_ERROR,
+  UndeclaredBlueprintProperty2 as UndeclaredBlueprintProperty,
+  UndeclaredRecordProperty2 as UndeclaredRecordProperty,
+  UnknownCommandOperation2 as UnknownCommandOperation,
+  UnknownRecordPlugin2 as UnknownRecordPlugin,
+  UnregisteredApplicationReference2 as UnregisteredApplicationReference,
+  UnregisteredRepositoryDependency2 as UnregisteredRepositoryDependency,
+  UnregisteredUseCaseDependency2 as UnregisteredUseCaseDependency,
+  UpdatedAt2 as UpdatedAt,
+  Url2 as Url,
+  UseCaseAlreadyExecuted2 as UseCaseAlreadyExecuted,
+  applicationOf2 as applicationOf,
+  blueprintBuilderOf2 as blueprintBuilderOf,
+  blueprintOf2 as blueprintOf,
+  blueprintPluginOf2 as blueprintPluginOf,
+  commandOf2 as commandOf,
+  configure2 as configure,
+  consoleLogProvider2 as consoleLogProvider,
+  entityBuilderOf2 as entityBuilderOf,
+  entityOf2 as entityOf,
+  enumOf2 as enumOf,
+  environmentOf2 as environmentOf,
+  eventOf2 as eventOf,
+  exceptionOf2 as exceptionOf,
+  guard2 as guard,
+  hasPlugin2 as hasPlugin,
+  inMemoryProvider2 as inMemoryProvider,
+  isApplication2 as isApplication,
+  isBlueprint2 as isBlueprint,
+  isBlueprintList2 as isBlueprintList,
+  isCommand2 as isCommand,
+  isEntity2 as isEntity,
+  isEntityClass2 as isEntityClass,
+  isEnvironment2 as isEnvironment,
+  isLogFactory2 as isLogFactory,
+  isOptionalRecord2 as isOptionalRecord,
+  isOutput2 as isOutput,
+  isPasswordHash2 as isPasswordHash,
+  isProperty2 as isProperty,
+  isProviderFactory2 as isProviderFactory,
+  isRecordClass2 as isRecordClass,
+  isRecordPlugin2 as isRecordPlugin,
+  isRepository2 as isRepository,
+  isUseCase2 as isUseCase,
+  isUseCaseClass2 as isUseCaseClass,
+  jsonLogProvider2 as jsonLogProvider,
+  listOf2 as listOf,
+  logFrom2 as logFrom,
+  logProviderOf2 as logProviderOf,
+  memoryLogProvider2 as memoryLogProvider,
+  openapi2 as openapi,
+  operationOf2 as operationOf,
+  operationRoutes2 as operationRoutes,
+  optionalOf2 as optionalOf,
+  outputOf2 as outputOf,
+  outputValueOf2 as outputValueOf,
+  passwordIssues2 as passwordIssues,
+  pluginsOf2 as pluginsOf,
+  problemOf2 as problemOf,
+  propertyLineageOf2 as propertyLineageOf,
+  propertyOf2 as propertyOf,
+  providerDescriptionOf2 as providerDescriptionOf,
+  providerFrom2 as providerFrom,
+  providerOf2 as providerOf,
+  recordBuilderOf2 as recordBuilderOf,
+  recordFieldOf2 as recordFieldOf,
   recordOf2 as recordOf,
-  recordPluginCatalogOf,
-  recordPluginOf,
-  repositoryOf,
-  resetRuntime,
-  schemaOf,
-  sliceOf,
-  sliceValue,
-  toOpenAPI,
-  useCaseOf
+  recordPluginCatalogOf2 as recordPluginCatalogOf,
+  recordPluginOf2 as recordPluginOf,
+  repositoryOf2 as repositoryOf,
+  resetApplication2 as resetApplication,
+  resetRuntime2 as resetRuntime,
+  routeOptionsIssue2 as routeOptionsIssue,
+  schemaOf2 as schemaOf,
+  select2 as select,
+  sinkOf2 as sinkOf,
+  stageCatalogOf2 as stageCatalogOf,
+  stageDescriptionOf2 as stageDescriptionOf,
+  stageKindOf2 as stageKindOf,
+  statusOf2 as statusOf,
+  toOpenAPI2 as toOpenAPI,
+  transformOf2 as transformOf,
+  useApplication2 as useApplication,
+  useCaseOf2 as useCaseOf
 };