@afora/core 0.0.9 → 0.0.11

package/dist/core/application/application.js

@@ -0,0 +1,1291 @@
+import { fieldOf } from "../blueprint/callable.js";
+import { isBlueprint } from "../blueprint/is-blueprint.js";
+import { isBlueprintList } from "../blueprint/list.js";
+import { isRecordClass, recordFieldOf } from "../blueprint/record-field.js";
+import { isBlueprintVariant } from "../blueprint/variant.js";
+import {
+  commandOf,
+  commandTransactionProvider,
+  isCommand,
+  verifyCommand
+} from "../command/command.js";
+import {
+  EntitySettings,
+  identityKeysOf,
+  isVersionedEntityClass
+} from "../entity/abstract-entity.js";
+import { isEntityClass } from "../entity/entity.js";
+import { eventHasHandler, lifecycleEventsOf } from "../entity/event.js";
+import {
+  InvalidEnvironment,
+  isEnvironment
+} from "../environment/environment.js";
+import {
+  eventPolicyDescriptionOf,
+  eventPolicyPublishersOf
+} from "../event-policy/event-policy.js";
+import {
+  ApplicationPublishersKey,
+  bindPublishers,
+  isEventPublisher
+} from "../event-policy/publishers.js";
+import {
+  declaredMessageOf,
+  Exception,
+  isDeclaredException
+} from "../exception/exception.js";
+import { isExportedException } from "../exception/exported.js";
+import {
+  ApplicationLoggerKey,
+  applicationLogger,
+  checkLogSettings,
+  isLoggerDeclaration,
+  logProviderNameOf,
+  silentLogger
+} from "../logger/logger.js";
+import { plainOf } from "../openapi/openapi.js";
+import { isOutput, outputOf } from "../output/output.js";
+import { stageDescriptionOf } from "../output/stage.js";
+import { isProperty } from "../property/is-property.js";
+import { propertyLineageOf } from "../property/lineage.js";
+import { declaredRecordNameOf, recordNameOf } from "../record/name.js";
+import { pluginsOf } from "../record/plugin.js";
+import { providerDescriptionOf } from "../repository/provider.js";
+import { isRepository } from "../repository/repository.js";
+import {
+  bindRepository,
+  inspectRepository,
+  providerOfRepository
+} from "../repository/state.js";
+import { rawTypeOf } from "../schema/schema.js";
+import { Kind } from "../symbols/kind.js";
+import {
+  ApplicationTracerKey,
+  checkTracer
+} from "../tracing/tracing.js";
+import { useCaseOriginOf } from "../use-case/plugin.js";
+import { describeSteps } from "../use-case/steps/describe.js";
+import { interpretedStepsOf } from "../use-case/steps/run.js";
+import { isUseCaseClass } from "../use-case/use-case.js";
+import {
+  ApplicationAlreadyStarted,
+  ApplicationConflict,
+  DuplicateApplicationDeclaration,
+  InvalidApplicationDeclaration,
+  InvalidApplicationEnvironment,
+  SchemaLockMismatch,
+  UnregisteredApplicationReference,
+  UnregisteredRepositoryDependency,
+  UnregisteredUseCaseDependency
+} from "./exceptions.js";
+import { isLock, migrateApplication } from "./migrate.js";
+import {
+  isProviderSlot,
+  isProviderStorage,
+  slotEntry,
+  slotsOf
+} from "./providers.js";
+import { setStartedApplication, startedApplication } from "./registry.js";
+import { schemaLockOf, schemaLockProblemsOf } from "./schema.js";
+import {
+  checkCapabilities,
+  checkTransactions,
+  deferredEnvironments,
+  deferredProvider,
+  isDeferredProvider,
+  isLogFactory,
+  isProviderFactory,
+  startDeferred,
+  stopProvider
+} from "./start.js";
+const KEYS = [
+  "properties",
+  "blueprints",
+  "records",
+  "entities",
+  "environments",
+  "repositories",
+  "useCases",
+  "commands",
+  "outputs",
+  "exceptions"
+];
+const internals = new WeakMap;
+const logSettings = new WeakMap;
+const traceSettings = new WeakMap;
+function inherited(extended, settings) {
+  for (let index = extended.length - 1;index >= 0; index--) {
+    const value = settings.get(extended[index]);
+    if (value !== undefined)
+      return value;
+  }
+  return;
+}
+const namedProviders = new WeakMap;
+const defaultSlots = new WeakMap;
+function referenceOf(slot) {
+  return { kind: "ref", key: slotEntry(slot).key };
+}
+const KIND_OF = {
+  properties: "property",
+  blueprints: "blueprint",
+  records: "record",
+  entities: "entity",
+  environments: "environment",
+  repositories: "repository",
+  useCases: "use case",
+  commands: "command",
+  outputs: "output",
+  exceptions: "exception"
+};
+export function isApplication(value) {
+  return typeof value === "object" && value !== null && value[Kind] === "application";
+}
+function invalid(source, reason) {
+  throw new InvalidApplicationDeclaration({ source, details: { reason } });
+}
+const publisherOrigins = new WeakMap;
+function publishersOf(name, declared, extended) {
+  const merged = {};
+  const origins = {};
+  for (const other of extended) {
+    Object.assign(merged, other[ApplicationPublishersKey]);
+    Object.assign(origins, publisherOrigins.get(other));
+  }
+  if (declared !== undefined) {
+    if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
+      invalid(name, "Expected `publishers` to be an object of publishers by key.");
+    }
+    for (const [key, publisher] of Object.entries(declared)) {
+      if (!/^[A-Za-z_$][\w$]*$/.test(key)) {
+        invalid(name, `Expected the publisher key "${key}" to be an identifier.`);
+      }
+      if (!isEventPublisher(publisher)) {
+        invalid(name, `Expected the publisher "${key}" to be an object with a publish(topic, event) method.`);
+      }
+      merged[key] = publisher;
+      origins[key] = name;
+    }
+  }
+  return { publishers: Object.freeze(merged), origins };
+}
+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;
+    case "useCases":
+      return isUseCaseClass(value);
+    case "commands":
+      return isCommand(value);
+    case "outputs":
+      return isOutput(value);
+    case "exceptions":
+      return isDeclaredException(value);
+  }
+}
+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 = internals.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).`);
+      }
+      const declaredName = collection === "useCases" ? value.useCaseName : collection === "commands" ? value.commandName : collection === "outputs" ? value.outputName : collection === "exceptions" ? value.name : collection === "records" || collection === "entities" ? declaredRecordNameOf(value) ?? name : name;
+      if (declaredName !== name) {
+        invalid(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
+      }
+      add({
+        collection,
+        name,
+        value,
+        key: keyOf(collection, value),
+        from: source
+      });
+    }
+  }
+  for (const entry of [...registry.commands.values()]) {
+    for (const UseCase of Object.values(entry.value.useCases)) {
+      if (useCaseOriginOf(UseCase) === undefined || byKey.has(UseCase)) {
+        continue;
+      }
+      add({
+        collection: "useCases",
+        name: UseCase.useCaseName,
+        value: UseCase,
+        key: UseCase,
+        from: entry.from
+      });
+    }
+  }
+  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 if (isBlueprintVariant(field)) {
+      for (const variant of Object.values(field.variants)) {
+        visit(variant);
+      }
+    } 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"} "${recordNameOf(record)}"`
+          }
+        });
+      }
+    }
+  }
+  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 "${recordNameOf(relation.entity)}"`);
+      }
+    }
+    for (const environment of info.environments) {
+      if (!environments.has(environment)) {
+        unregistered(entry.name, "an environment");
+      }
+    }
+  }
+}
+function validateCommands(source, registry) {
+  const useCases = new Set([...registry.useCases.values()].map((entry) => entry.key));
+  const environments = new Set([...registry.environments.values()].map((entry) => entry.key));
+  for (const entry of registry.commands.values()) {
+    const command = entry.value;
+    for (const environment of command.environments) {
+      if (environments.has(environment))
+        continue;
+      throw new UnregisteredApplicationReference({
+        source,
+        details: {
+          holder: `command "${entry.name}"`,
+          reference: "an environment",
+          command: entry.name
+        }
+      });
+    }
+    for (const UseCase of Object.values(command.useCases)) {
+      if (useCases.has(UseCase))
+        continue;
+      throw new UnregisteredApplicationReference({
+        source,
+        details: {
+          holder: `command "${entry.name}"`,
+          reference: `use case "${UseCase.useCaseName}"`,
+          command: entry.name,
+          useCase: UseCase.useCaseName
+        }
+      });
+    }
+  }
+}
+function validateOutputs(source, registry) {
+  const commands = new Set([...registry.commands.values()].map((entry) => entry.key));
+  for (const entry of registry.outputs.values()) {
+    const output = entry.value;
+    if (!output.outputName) {
+      invalid(source, `outputs.${entry.name} has no name (an output made by pipe cannot be registered).`);
+    }
+    for (const command of output.commands) {
+      if (commands.has(command))
+        continue;
+      throw new UnregisteredApplicationReference({
+        source,
+        details: {
+          holder: `output "${entry.name}"`,
+          reference: `command "${command.commandName}"`,
+          output: entry.name,
+          command: command.commandName
+        }
+      });
+    }
+  }
+}
+function validateUseCases(source, registry) {
+  const registered = new Set([
+    ...[...registry.records.values()].map((entry) => entry.key),
+    ...[...registry.entities.values()].map((entry) => entry.key)
+  ]);
+  const known = (collection) => new Set([...registry[collection].values()].map((entry) => entry.key));
+  const useCases = known("useCases");
+  const repositories = known("repositories");
+  const environments = known("environments");
+  const exceptions = known("exceptions");
+  for (const entry of registry.useCases.values()) {
+    const UseCase = entry.value;
+    for (const [key, dependency] of Object.entries(UseCase.dependencies)) {
+      const found = isLoggerDeclaration(dependency) ? true : isUseCaseClass(dependency) ? useCases.has(dependency) : isEnvironment(dependency) ? environments.has(dependency) : repositories.has(inspectRepository(dependency).state);
+      if (!found) {
+        throw new UnregisteredUseCaseDependency({
+          source,
+          details: { useCase: `"${entry.name}"`, dependency: `"${key}"` }
+        });
+      }
+    }
+    for (const [part, blueprint] of [
+      ["blueprint", UseCase.blueprint],
+      ["response", UseCase.response],
+      ["context", UseCase.context]
+    ]) {
+      if (blueprint === undefined)
+        continue;
+      for (const record of recordsIn(blueprint.properties)) {
+        if (registered.has(record))
+          continue;
+        throw new UnregisteredApplicationReference({
+          source,
+          details: {
+            holder: `the ${part} of use case "${entry.name}"`,
+            reference: `${isEntityClass(record) ? "entity" : "record"} "${recordNameOf(record)}"`
+          }
+        });
+      }
+    }
+    for (const Thrown of UseCase.errors) {
+      if (exceptions.has(Thrown) || isExportedException(Thrown))
+        continue;
+      throw new UnregisteredApplicationReference({
+        source,
+        details: {
+          holder: `use case "${entry.name}"`,
+          reference: `exception "${Thrown.name}"`
+        }
+      });
+    }
+    for (const [index, step] of (interpretedStepsOf(UseCase) ?? []).entries()) {
+      const holder = `step ${index} of use case "${entry.name}"`;
+      if (step.build !== undefined && !registered.has(step.build)) {
+        throw new UnregisteredApplicationReference({
+          source,
+          details: {
+            holder,
+            reference: `${isEntityClass(step.build) ? "entity" : "record"} "${recordNameOf(step.build)}"`
+          }
+        });
+      }
+      const Thrown = step.error;
+      if (Thrown !== undefined && !exceptions.has(Thrown) && !isExportedException(Thrown)) {
+        throw new UnregisteredApplicationReference({
+          source,
+          details: { holder, reference: `exception "${Thrown.name}"` }
+        });
+      }
+    }
+  }
+}
+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(rawTypeOf(type.schema)),
+    ...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 };
+  }
+  if (isBlueprintVariant(field)) {
+    const variants = field.variants;
+    return {
+      kind: "variant",
+      key: field.key,
+      optional: field.optional,
+      variants: Object.fromEntries(Object.entries(variants).map(([tag, variant]) => [
+        tag,
+        fieldDescriptionOf(variant, scope)
+      ]))
+    };
+  }
+  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 ?? recordNameOf(record.record),
+      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));
+  const settings = entry.collection === "entities" ? Record[EntitySettings] : undefined;
+  const expires = settings?.expires;
+  const upgrade = Object.keys(settings?.upgrade ?? {}).map(Number).sort((a, b) => a - b);
+  if (entry.collection === "entities") {
+    for (const key of identityKeysOf(Record))
+      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);
+  });
+  const lifecycle = entry.collection === "entities" ? lifecycleEventsOf(Record) : {};
+  const events = Object.fromEntries(Object.entries(lifecycle).map(([cycle, list]) => [
+    cycle,
+    list.map((event) => ({
+      name: event.name,
+      handler: eventHasHandler(event)
+    }))
+  ]));
+  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,
+    ...Object.keys(events).length > 0 ? { events } : {},
+    ...expires === undefined ? {} : { expires },
+    ...entry.collection === "entities" && isVersionedEntityClass(Record) ? { versioned: true } : {},
+    ...settings?.schemaVersioned ? { schemaVersion: settings.schemaVersion } : {},
+    ...upgrade.length > 0 ? { upgrade } : {},
+    ...settings !== undefined && settings.previousNames.length > 0 ? { previousNames: [...settings.previousNames] } : {}
+  };
+}
+function describeRegistry(name, extended, registry, provider, named, log, publishers, traced) {
+  const scope = {
+    properties: referencesOf(registry, "properties"),
+    blueprints: referencesOf(registry, "blueprints"),
+    records: referencesOf(registry, "records"),
+    entities: referencesOf(registry, "entities")
+  };
+  const repositories = referencesOf(registry, "repositories");
+  const environmentRefs = referencesOf(registry, "environments");
+  const useCaseRefs = referencesOf(registry, "useCases");
+  const exceptionRefs = referencesOf(registry, "exceptions");
+  const describeImplementation = (UseCase) => {
+    const steps = interpretedStepsOf(UseCase);
+    return steps === undefined ? { kind: "opaque" } : {
+      kind: "steps",
+      steps: describeSteps(steps, {
+        record: (Class) => scope.entities.get(Class) ?? scope.records.get(Class),
+        error: (Class) => {
+          const ref = exceptionRefs.get(Class);
+          return ref === undefined ? { core: Class.name } : ref;
+        },
+        params: (blueprint) => fieldsDescriptionOf(blueprint.properties, scope)
+      })
+    };
+  };
+  const describeOption = (value) => {
+    if (isLoggerDeclaration(value))
+      return "Logger";
+    if (isUseCaseClass(value))
+      return useCaseRefs.get(value);
+    if (isEnvironment(value))
+      return environmentRefs.get(value);
+    if (isRepository(value)) {
+      return repositories.get(inspectRepository(value).state);
+    }
+    if (typeof value === "function") {
+      if (isDeclaredException(value)) {
+        return exceptionRefs.get(value) ?? { core: value.name };
+      }
+      return scope.entities.get(value) ?? scope.records.get(value) ?? { kind: "opaque" };
+    }
+    if (Array.isArray(value))
+      return value.map(describeOption);
+    if (typeof value === "object" && value !== null) {
+      return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined).map(([key, item]) => [key, describeOption(item)]));
+    }
+    return value;
+  };
+  const describeGeneric = (UseCase) => {
+    const origin = useCaseOriginOf(UseCase);
+    if (!origin || interpretedStepsOf(UseCase) === undefined)
+      return {};
+    const repository = repositories.get(inspectRepository(origin.repository).state);
+    if (repository === undefined)
+      return {};
+    return {
+      generic: {
+        name: origin.plugin.name,
+        version: origin.plugin.version,
+        repository,
+        options: describeOption(origin.options)
+      }
+    };
+  };
+  const refsOf = (blueprints) => {
+    const refs = {};
+    for (const [key, blueprint] of Object.entries(blueprints)) {
+      const ref = blueprint === undefined ? undefined : scope.blueprints.get(blueprint.properties);
+      if (ref !== undefined)
+        refs[key] = ref;
+    }
+    return Object.keys(refs).length === 0 ? {} : { refs };
+  };
+  const each = (collection, describe) => Object.fromEntries([...registry[collection].values()].map((entry) => [
+    entry.name,
+    describe(entry)
+  ]));
+  return {
+    name,
+    extends: extended.map((other) => other.name),
+    ...provider === undefined ? {} : { provider },
+    ...named.size === 0 ? {} : {
+      providers: Object.fromEntries([...named].map(([key, { slot, from }]) => {
+        const { value } = slotEntry(slot);
+        return [
+          key,
+          {
+            from,
+            ...isProviderFactory(value) ? { kind: "opaque" } : providerDescriptionOf(value)
+          }
+        ];
+      }))
+    },
+    ...log === undefined ? {} : log === "opaque" ? { log: { kind: "opaque" } } : {
+      log: {
+        level: log.level,
+        providers: log.providers.map((logProvider) => {
+          const providerName = logProviderNameOf(logProvider);
+          return providerName === undefined ? { kind: "opaque" } : { kind: "log-provider", name: providerName };
+        })
+      }
+    },
+    ...traced ? { trace: { kind: "opaque" } } : {},
+    ...Object.keys(publishers).length === 0 ? {} : {
+      publishers: Object.fromEntries(Object.entries(publishers).map(([key, from]) => [key, { from }]))
+    },
+    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,
+        deletion: info.deletion,
+        indexes: info.indexes,
+        scans: info.scans,
+        relations: info.relations.map((relation) => repositories.get(relation)),
+        environments: info.environments.map((environment) => environmentRefs.get(environment)),
+        ...info.provider === undefined ? {} : {
+          provider: isProviderSlot(info.provider) ? referenceOf(info.provider) : providerDescriptionOf(info.provider)
+        }
+      };
+    }),
+    useCases: each("useCases", (entry) => {
+      const UseCase = entry.value;
+      return {
+        from: entry.from,
+        name: UseCase.useCaseName,
+        ...UseCase.description === undefined ? {} : { description: UseCase.description },
+        tags: UseCase.tags,
+        deprecated: UseCase.deprecated,
+        ...UseCase.route === undefined ? {} : { route: UseCase.route },
+        ...UseCase.access === undefined ? {} : { access: UseCase.access },
+        input: fieldsDescriptionOf(UseCase.blueprint.properties, scope),
+        response: fieldsDescriptionOf(UseCase.response.properties, scope),
+        ...UseCase.context === undefined ? {} : {
+          context: fieldsDescriptionOf(UseCase.context.properties, scope)
+        },
+        ...refsOf({
+          input: UseCase.blueprint,
+          response: UseCase.response,
+          context: UseCase.context
+        }),
+        errors: UseCase.errors.map((Thrown) => {
+          const ref = exceptionRefs.get(Thrown);
+          return ref === undefined ? { kind: "core", name: Thrown.name } : { kind: "exception", ref };
+        }),
+        dependencies: Object.fromEntries(Object.entries(UseCase.dependencies).map(([key, dependency]) => [
+          key,
+          isLoggerDeclaration(dependency) ? { kind: "logger", ref: "Logger" } : isUseCaseClass(dependency) ? {
+            kind: "use-case",
+            ref: useCaseRefs.get(dependency)
+          } : isEnvironment(dependency) ? {
+            kind: "environment",
+            ref: environmentRefs.get(dependency)
+          } : {
+            kind: "repository",
+            ref: repositories.get(inspectRepository(dependency).state)
+          }
+        ])),
+        implementation: describeImplementation(UseCase),
+        ...describeGeneric(UseCase)
+      };
+    }),
+    commands: each("commands", (entry) => {
+      const command = entry.value;
+      return {
+        from: entry.from,
+        name: command.commandName,
+        ...command.description === undefined ? {} : { description: command.description },
+        tags: command.tags,
+        ...command.context === undefined ? {} : {
+          context: fieldsDescriptionOf(command.context.properties, scope)
+        },
+        ...refsOf({ context: command.context }),
+        operations: Object.fromEntries(Object.entries(command.useCases).map(([op, UseCase]) => [
+          op,
+          { ref: useCaseRefs.get(UseCase) }
+        ])),
+        transaction: command.transaction,
+        ...command.environments.length === 0 ? {} : {
+          environments: command.environments.map((environment) => environmentRefs.get(environment))
+        },
+        events: typeof command.events === "function" ? eventPolicyDescriptionOf(command.events) ?? { kind: "opaque" } : command.events,
+        ...command.onEventError === undefined ? {} : { onEventError: { kind: "opaque" } }
+      };
+    }),
+    outputs: each("outputs", (entry) => {
+      const output = entry.value;
+      return {
+        from: entry.from,
+        name: output.outputName,
+        commands: output.commands.map((command) => command.commandName),
+        statuses: output.statuses,
+        pipe: output.stages.map((stage) => stageDescriptionOf(stage))
+      };
+    }),
+    exceptions: each("exceptions", (entry) => {
+      const Declared = entry.value;
+      const message = declaredMessageOf(Declared);
+      return {
+        from: entry.from,
+        layer: Declared.layer,
+        ...message === undefined ? {} : { message }
+      };
+    })
+  };
+}
+export 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);
+  validateUseCases(name, registry);
+  validateCommands(name, registry);
+  validateOutputs(name, registry);
+  if (settings.providers !== undefined && !isProviderStorage(settings.providers)) {
+    invalid(name, "Expected `providers` to be a storage made by providersOf.");
+  }
+  const named = new Map;
+  const addNamed = (entry) => {
+    const { key } = slotEntry(entry.slot);
+    const current = named.get(key);
+    if (current !== undefined && current.slot !== entry.slot) {
+      throw new ApplicationConflict({
+        source: name,
+        details: {
+          reason: `The provider "${key}" is declared by different storages, in "${current.from}" and "${entry.from}".`,
+          origins: [current.from, entry.from],
+          declarations: [`provider ${key}`, `provider ${key}`]
+        }
+      });
+    }
+    named.set(key, entry);
+  };
+  for (const other of extended) {
+    for (const entry of namedProviders.get(other)?.values() ?? []) {
+      addNamed(entry);
+    }
+  }
+  for (const slot of settings.providers ? slotsOf(settings.providers) : []) {
+    const inherited = named.get(slotEntry(slot).key);
+    if (inherited?.slot === slot)
+      continue;
+    const { value } = slotEntry(slot);
+    addNamed({
+      slot,
+      from: name,
+      instance: isProviderFactory(value) ? deferredProvider(value, name) : value
+    });
+  }
+  const instances = new Map([...named.values()].map((entry) => [entry.slot, entry.instance]));
+  const instanceOf = (slot, holder) => {
+    const instance = instances.get(slot);
+    if (instance === undefined) {
+      throw new UnregisteredApplicationReference({
+        source: name,
+        details: {
+          holder,
+          reference: `provider "${slotEntry(slot).key}"`
+        }
+      });
+    }
+    return instance;
+  };
+  for (const entry of registry.repositories.values()) {
+    const declared = inspectRepository(entry.value).provider;
+    if (isProviderSlot(declared)) {
+      instanceOf(declared, `repository "${entry.name}"`);
+    }
+  }
+  const inheritedFrom = settings.provider === undefined ? [...extended].reverse().find((other) => other.provider) : undefined;
+  const declaredProvider = settings.provider ?? inheritedFrom?.provider;
+  if (declaredProvider !== undefined && typeof declaredProvider !== "object") {
+    invalid(name, "Expected `provider` to be a repository provider.");
+  }
+  const defaultSlot = isProviderSlot(declaredProvider) ? declaredProvider : inheritedFrom === undefined ? undefined : defaultSlots.get(inheritedFrom);
+  const provider = defaultSlot !== undefined ? instanceOf(defaultSlot, "the application") : isProviderFactory(declaredProvider) ? deferredProvider(declaredProvider, name) : declaredProvider;
+  const allProviders = [
+    ...new Set([provider, ...instances.values()].filter((value) => value !== undefined))
+  ];
+  {
+    const registered = new Set([...registry.environments.values()].map((entry) => entry.key));
+    const holderOf = (instance) => {
+      const entry = [...named.values()].find((candidate) => candidate.instance === instance);
+      return entry === undefined || instance === provider ? "the provider" : `provider "${slotEntry(entry.slot).key}"`;
+    };
+    for (const instance of allProviders) {
+      for (const environment of deferredEnvironments(instance)) {
+        if (registered.has(environment))
+          continue;
+        throw new UnregisteredApplicationReference({
+          source: name,
+          details: {
+            holder: holderOf(instance),
+            reference: "an environment"
+          }
+        });
+      }
+    }
+  }
+  const declaredLog = settings.log ?? inherited(extended, logSettings);
+  const log = declaredLog === undefined ? undefined : applicationLogger(name);
+  if (declaredLog !== undefined && !isLogFactory(declaredLog)) {
+    log?.set(checkLogSettings(declaredLog));
+  }
+  const logger = log?.logger;
+  const tracer = settings.trace === undefined ? inherited(extended, traceSettings) : checkTracer(settings.trace);
+  const { publishers, origins } = publishersOf(name, settings.publishers, extended);
+  const hasPublishers = Object.keys(publishers).length > 0;
+  for (const entry of registry.commands.values()) {
+    for (const key of eventPolicyPublishersOf(entry.value.events)) {
+      if (!Object.hasOwn(publishers, key)) {
+        throw new UnregisteredApplicationReference({
+          source: name,
+          details: {
+            holder: `command "${entry.name}"`,
+            reference: `publisher "${key}"`
+          }
+        });
+      }
+    }
+  }
+  const bindsProviders = provider !== undefined || instances.size > 0;
+  const rebinds = bindsProviders || logger !== undefined || tracer !== undefined || hasPublishers;
+  const collection = (key) => Object.freeze(Object.fromEntries([...registry[key].values()].map((entry) => [entry.name, entry.value])));
+  const bound = new Map;
+  const boundByState = new Map;
+  const repositories = {};
+  for (const entry of registry.repositories.values()) {
+    const repository = bindsProviders ? bindRepository(entry.value, provider, instances, {
+      application: name,
+      key: entry.name,
+      logger
+    }) : entry.value;
+    bound.set(entry.value, repository);
+    boundByState.set(entry.key, repository);
+    repositories[entry.name] = repository;
+  }
+  const boundUseCases = new Map;
+  const bindUseCase = (UseCase) => {
+    if (!rebinds)
+      return UseCase;
+    const done = boundUseCases.get(UseCase);
+    if (done)
+      return done;
+    const Declared = UseCase;
+
+    class Bound extends Declared {
+    }
+    Object.defineProperty(Bound, "name", { value: Declared.name });
+    boundUseCases.set(UseCase, Bound);
+    const dependencies = Object.fromEntries(Object.entries(UseCase.dependencies).map(([key, dependency]) => [
+      key,
+      isUseCaseClass(dependency) ? bindUseCase(dependency) : isEnvironment(dependency) || isLoggerDeclaration(dependency) ? dependency : boundByState.get(inspectRepository(dependency).state) ?? dependency
+    ]));
+    Object.defineProperty(Bound, "dependencies", {
+      value: Object.freeze(dependencies)
+    });
+    if (logger)
+      Object.defineProperty(Bound, ApplicationLoggerKey, { value: logger });
+    if (tracer)
+      Object.defineProperty(Bound, ApplicationTracerKey, { value: tracer });
+    return Bound;
+  };
+  const useCases = {};
+  const boundUseCaseOf = new Map;
+  for (const entry of registry.useCases.values()) {
+    const bound = bindUseCase(entry.value);
+    boundUseCaseOf.set(entry.value, bound);
+    useCases[entry.name] = bound;
+  }
+  const commands = {};
+  const boundCommandOf = new Map;
+  for (const entry of registry.commands.values()) {
+    const declared = entry.value;
+    const rebuilt = !rebinds ? declared : commandOf({
+      name: declared.commandName,
+      description: declared.description,
+      tags: declared.tags,
+      context: declared.context,
+      useCases: Object.fromEntries(Object.entries(declared.useCases).map(([op, UseCase]) => [
+        op,
+        boundUseCaseOf.get(UseCase)
+      ])),
+      transaction: declared.transaction,
+      environmentDependencies: declared.environments,
+      events: declared.events,
+      onEventError: declared.onEventError
+    });
+    if (bindsProviders)
+      verifyCommand(rebuilt);
+    if (hasPublishers)
+      bindPublishers(rebuilt, publishers);
+    boundCommandOf.set(entry.value, rebuilt);
+    commands[entry.name] = rebuilt;
+  }
+  const outputs = {};
+  const boundOutputOf = new Map;
+  for (const entry of registry.outputs.values()) {
+    const declared = entry.value;
+    const rebuilt = !rebinds ? declared : outputOf({
+      name: declared.outputName,
+      commands: declared.commands.map((command) => boundCommandOf.get(command)),
+      statuses: declared.statuses,
+      pipe: declared.stages
+    });
+    boundOutputOf.set(entry.value, rebuilt);
+    outputs[entry.name] = rebuilt;
+  }
+  const environmentEntries = [...registry.environments.values()];
+  const registeredEnvironments = new Set(environmentEntries.map((entry) => entry.value));
+  const context = Object.freeze({
+    name,
+    env(environment) {
+      if (!registeredEnvironments.has(environment)) {
+        throw new UnregisteredApplicationReference({
+          source: name,
+          details: { holder: "the context", reference: "an environment" }
+        });
+      }
+      return environment.load();
+    },
+    logger: logger ?? silentLogger
+  });
+  let starting;
+  let started = false;
+  const start = async (lock) => {
+    if (lock !== undefined) {
+      if (!isLock(lock)) {
+        invalid(name, "Expected lock to be a schema lock ({ lockVersion: 1, entities }).");
+      }
+      const problems = schemaLockProblemsOf(lock, schemaLockOf(application.describe()));
+      if (problems.length > 0) {
+        throw new SchemaLockMismatch({ source: name, details: { problems } });
+      }
+    }
+    const failures = {};
+    let cause;
+    for (const entry of environmentEntries) {
+      try {
+        entry.value.load();
+      } catch (error) {
+        if (!(error instanceof Exception) || !error.is(InvalidEnvironment)) {
+          throw error;
+        }
+        cause ??= error;
+        failures[entry.name] = [
+          ...error.details?.keys ?? []
+        ];
+      }
+    }
+    if (Object.keys(failures).length > 0) {
+      throw new InvalidApplicationEnvironment({
+        source: name,
+        details: { environments: failures },
+        cause
+      });
+    }
+    if (isLogFactory(declaredLog)) {
+      log?.set(checkLogSettings(await declaredLog.create(context)));
+    }
+    for (const instance of allProviders) {
+      if (!isDeferredProvider(instance))
+        continue;
+      const made = await startDeferred(instance, context);
+      checkTransactions(name, made, Object.entries(commands).filter(([, command]) => command.transaction && commandTransactionProvider(command) === instance).map(([key]) => key));
+      checkCapabilities(name, made, Object.entries(repositories).filter(([, repository]) => providerOfRepository(repository) === instance && inspectRepository(repository).actions.includes("findCursor")).map(([key]) => key));
+    }
+    started = true;
+  };
+  const application = Object.freeze({
+    [Kind]: "application",
+    name,
+    extends: Object.freeze([...extended]),
+    provider,
+    logger: logger ?? silentLogger,
+    context,
+    ...logger ? { [ApplicationLoggerKey]: logger } : {},
+    ...tracer ? { [ApplicationTracerKey]: tracer } : {},
+    ...hasPublishers ? { [ApplicationPublishersKey]: publishers } : {},
+    properties: collection("properties"),
+    blueprints: collection("blueprints"),
+    records: collection("records"),
+    entities: collection("entities"),
+    environments: collection("environments"),
+    repositories: Object.freeze(repositories),
+    useCases: Object.freeze(useCases),
+    commands: Object.freeze(commands),
+    outputs: Object.freeze(outputs),
+    exceptions: collection("exceptions"),
+    useCase(useCase) {
+      if (!boundUseCaseOf.has(useCase)) {
+        invalid(name, "Expected a use case registered in the application.");
+      }
+      return boundUseCaseOf.get(useCase);
+    },
+    async run(useCase, input = {}, options) {
+      if (!boundUseCaseOf.has(useCase)) {
+        invalid(name, "Expected a use case registered in the application.");
+      }
+      const Bound = boundUseCaseOf.get(useCase);
+      const instance = options?.context === undefined ? new Bound(input) : new Bound(input, { context: options.context });
+      return instance.execute(options?.dependencies);
+    },
+    command(command) {
+      if (!boundCommandOf.has(command)) {
+        invalid(name, "Expected a command registered in the application.");
+      }
+      return boundCommandOf.get(command);
+    },
+    output(output) {
+      if (!boundOutputOf.has(output)) {
+        invalid(name, "Expected an output registered in the application.");
+      }
+      return boundOutputOf.get(output);
+    },
+    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: defaultSlot ?? provider },
+        ...declaredLog === undefined ? {} : { log: declaredLog },
+        ...tracer === undefined ? {} : { trace: tracer }
+      });
+    },
+    describe: () => describeRegistry(name, extended, registry, defaultSlot !== undefined ? referenceOf(defaultSlot) : provider === undefined ? undefined : providerDescriptionOf(provider), named, isLogFactory(declaredLog) ? "opaque" : log?.settings, origins, tracer !== undefined),
+    get started() {
+      return started;
+    },
+    migrate(options) {
+      return migrateApplication({
+        name,
+        entities: new Map([...registry.entities.values()].map((entry) => [
+          entry.name,
+          entry.value
+        ])),
+        repositories: Object.values(repositories),
+        describe: () => application.describe()
+      }, options);
+    },
+    start(options = {}) {
+      const { replace = false, register = true, lock } = options ?? {};
+      starting ??= (async () => {
+        if (register) {
+          const current = startedApplication();
+          if (current !== undefined && current !== application) {
+            if (!replace) {
+              throw new ApplicationAlreadyStarted({
+                source: name,
+                details: { current: current.name, attempted: name }
+              });
+            }
+            await current.stop();
+          }
+        }
+        await start(lock);
+        if (register)
+          setStartedApplication(application);
+      })().then(() => application, async (error) => {
+        starting = undefined;
+        for (const instance of allProviders) {
+          if (isDeferredProvider(instance))
+            await stopProvider(instance);
+        }
+        if (isLogFactory(declaredLog))
+          log?.set(undefined);
+        throw error;
+      });
+      return starting;
+    },
+    async stop() {
+      const wasStarting = starting;
+      starting = undefined;
+      started = false;
+      if (wasStarting)
+        await wasStarting.catch(() => {
+          return;
+        });
+      if (startedApplication() === application)
+        setStartedApplication(undefined);
+      for (const instance of allProviders)
+        await stopProvider(instance);
+      await log?.flush();
+      if (isLogFactory(declaredLog))
+        log?.set(undefined);
+    },
+    get(declaration) {
+      if (isEnvironment(declaration)) {
+        if (!registeredEnvironments.has(declaration)) {
+          invalid(name, "Expected an environment registered in the application.");
+        }
+        return declaration.load();
+      }
+      if (isCommand(declaration))
+        return application.command(declaration);
+      if (isOutput(declaration))
+        return application.output(declaration);
+      if (isUseCaseClass(declaration))
+        return application.useCase(declaration);
+      if (isRepository(declaration)) {
+        return application.repository(declaration);
+      }
+      if (isProviderSlot(declaration)) {
+        const instance = instances.get(declaration);
+        if (instance === undefined) {
+          invalid(name, "Expected a provider of a storage registered in the application.");
+        }
+        return instance;
+      }
+      return invalid(name, "Expected a repository, use case, command, output, environment or provider registered in the application.");
+    }
+  });
+  internals.set(application, registry);
+  namedProviders.set(application, named);
+  if (defaultSlot !== undefined)
+    defaultSlots.set(application, defaultSlot);
+  if (declaredLog !== undefined)
+    logSettings.set(application, declaredLog);
+  if (tracer !== undefined)
+    traceSettings.set(application, tracer);
+  publisherOrigins.set(application, Object.freeze(origins));
+  return application;
+}