@afora/core 0.0.3 → 0.0.5

package/dist/{index-sw2b9ehx.js → index-8m80wjzf.js}

@@ -10,6 +10,7 @@ import {
   isRecordClass2,
   recordFieldOf2,
   isBlueprintList2,
+  UNEXPECTED_ERROR2,
   Exception2,
   isDeclaredException,
   declaredMessageOf,
@@ -50,17 +51,38 @@ __export(exports_environment, {
   loadEnvironments: () => loadEnvironments
 });
 
-// src/core/entity/exceptions.ts
+// src/core/application/exceptions.ts
 var exports_exceptions4 = {};
 __export(exports_exceptions4, {
+  ApplicationAlreadyStarted: () => ApplicationAlreadyStarted2,
+  ApplicationConflict: () => ApplicationConflict2,
+  ApplicationNotStarted: () => ApplicationNotStarted2,
+  DuplicateApplicationDeclaration: () => DuplicateApplicationDeclaration2,
+  InvalidApplicationDeclaration: () => InvalidApplicationDeclaration2,
+  InvalidApplicationEnvironment: () => InvalidApplicationEnvironment2,
+  ProviderNotBound: () => ProviderNotBound2,
+  UnregisteredApplicationReference: () => UnregisteredApplicationReference2,
+  UnregisteredRepositoryDependency: () => UnregisteredRepositoryDependency2,
+  UnregisteredUseCaseDependency: () => UnregisteredUseCaseDependency2
+});
+
+// src/core/logger/exceptions.ts
+var exports_exceptions5 = {};
+__export(exports_exceptions5, {
+  InvalidLogDeclaration: () => InvalidLogDeclaration2
+});
+
+// src/core/entity/exceptions.ts
+var exports_exceptions6 = {};
+__export(exports_exceptions6, {
   DeletedEntity: () => DeletedEntity2,
   ImmutableEntityKey: () => ImmutableEntityKey2,
   ReservedEntityKey: () => ReservedEntityKey2
 });
 
 // src/core/repository/exceptions.ts
-var exports_exceptions5 = {};
-__export(exports_exceptions5, {
+var exports_exceptions7 = {};
+__export(exports_exceptions7, {
   InvalidRepositoryData: () => InvalidRepositoryData2,
   InvalidRepositoryDeclaration: () => InvalidRepositoryDeclaration2,
   InvalidRepositoryEntity: () => InvalidRepositoryEntity2,
@@ -82,14 +104,14 @@ __export(exports_use_case, {
 });
 
 // src/core/use-case/exceptions.ts
-var exports_exceptions6 = {};
-__export(exports_exceptions6, {
+var exports_exceptions8 = {};
+__export(exports_exceptions8, {
   InvalidUseCaseStep: () => InvalidUseCaseStep2
 });
 
 // src/core/command/exceptions.ts
-var exports_exceptions7 = {};
-__export(exports_exceptions7, {
+var exports_exceptions9 = {};
+__export(exports_exceptions9, {
   CommandEventFailed: () => CommandEventFailed2,
   InvalidCommandContext: () => InvalidCommandContext2,
   InvalidCommandDeclaration: () => InvalidCommandDeclaration2,
@@ -97,29 +119,15 @@ __export(exports_exceptions7, {
   UnknownCommandOperation: () => UnknownCommandOperation2
 });
 
-// src/core/application/exceptions.ts
-var exports_exceptions8 = {};
-__export(exports_exceptions8, {
-  ApplicationAlreadyStarted: () => ApplicationAlreadyStarted2,
-  ApplicationConflict: () => ApplicationConflict2,
-  ApplicationNotStarted: () => ApplicationNotStarted2,
-  DuplicateApplicationDeclaration: () => DuplicateApplicationDeclaration2,
-  InvalidApplicationDeclaration: () => InvalidApplicationDeclaration2,
-  InvalidApplicationEnvironment: () => InvalidApplicationEnvironment2,
-  UnregisteredApplicationReference: () => UnregisteredApplicationReference2,
-  UnregisteredRepositoryDependency: () => UnregisteredRepositoryDependency2,
-  UnregisteredUseCaseDependency: () => UnregisteredUseCaseDependency2
-});
-
 // src/core/openapi/exceptions.ts
-var exports_exceptions9 = {};
-__export(exports_exceptions9, {
+var exports_exceptions10 = {};
+__export(exports_exceptions10, {
   InvalidOpenAPIModel: () => InvalidOpenAPIModel2
 });
 
 // src/core/output/exceptions.ts
-var exports_exceptions10 = {};
-__export(exports_exceptions10, {
+var exports_exceptions11 = {};
+__export(exports_exceptions11, {
   DuplicateOperation: () => DuplicateOperation2,
   InvalidOutputStage: () => InvalidOutputStage2
 });
@@ -209,6 +217,288 @@ function guard2(scope, run, resolve) {
   }
 }
 
+// src/core/application/exceptions.ts
+var InvalidApplicationDeclaration2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "InvalidApplicationDeclaration",
+  message: ({ reason }) => reason
+});
+var DuplicateApplicationDeclaration2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "DuplicateApplicationDeclaration",
+  message: ({
+    first,
+    second
+  }) => `The same object is registered as ${first} and as ${second}.`
+});
+var ApplicationConflict2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "ApplicationConflict",
+  message: ({
+    reason
+  }) => reason
+});
+var UnregisteredApplicationReference2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "UnregisteredApplicationReference",
+  message: ({
+    holder,
+    reference
+  }) => `${holder} holds ${reference}, which is not registered in the application.`
+});
+var UnregisteredRepositoryDependency2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "UnregisteredRepositoryDependency",
+  message: ({
+    repository,
+    dependency
+  }) => `Repository ${repository} depends on ${dependency}, which is not registered in the application.`
+});
+var UnregisteredUseCaseDependency2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "UnregisteredUseCaseDependency",
+  message: ({
+    useCase,
+    dependency
+  }) => `Use case ${useCase} depends on ${dependency}, which is not registered in the application.`
+});
+var ApplicationNotStarted2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "ApplicationNotStarted",
+  message: ({
+    application
+  }) => application === undefined ? "No application is started: call await app.start() first." : `The application "${application}" is not started: call await app.start() first.`
+});
+var ProviderNotBound2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "ProviderNotBound",
+  message: ({
+    provider
+  }) => `The provider "${provider}" is made by an application: register its storage in applicationOf({ providers }) and call the repository through the application.`
+});
+var ApplicationAlreadyStarted2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "ApplicationAlreadyStarted",
+  message: ({
+    current,
+    attempted
+  }) => `The application "${current}" is already started, so "${attempted}" cannot be: stop it, or call start({ replace: true }).`
+});
+var InvalidApplicationEnvironment2 = exceptionOf2({
+  layer: "environment" /* Environment */,
+  name: "InvalidApplicationEnvironment",
+  message: ({
+    environments
+  }) => `Invalid environment variables: ${Object.entries(environments).map(([name, keys]) => `${name} (${keys.join(", ")})`).join("; ")}.`
+});
+
+// src/core/application/registry.ts
+var SLOT = Symbol.for("afora.application");
+function slot() {
+  const global = globalThis;
+  global[SLOT] ??= { current: undefined };
+  return global[SLOT];
+}
+function useApplication2() {
+  const { current } = slot();
+  if (current === undefined) {
+    throw new ApplicationNotStarted2({ source: "useApplication", details: {} });
+  }
+  return current;
+}
+function resetApplication2() {
+  slot().current = undefined;
+}
+function startedApplication() {
+  return slot().current;
+}
+function setStartedApplication(application) {
+  slot().current = application;
+}
+
+// src/core/logger/exceptions.ts
+var InvalidLogDeclaration2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "InvalidLogDeclaration",
+  message: ({ reason }) => reason
+});
+
+// src/core/logger/logger.ts
+var LogLevels2 = Object.freeze([
+  "debug",
+  "info",
+  "warn",
+  "error"
+]);
+var names = new WeakMap;
+var invalid = (reason) => {
+  throw new InvalidLogDeclaration2({ source: "log", details: { reason } });
+};
+function logProviderOf2(settings) {
+  if (!settings || typeof settings.write !== "function") {
+    invalid("Expected a log provider with a write function.");
+  }
+  if (settings.flush !== undefined && typeof settings.flush !== "function") {
+    invalid("Expected flush to be a function.");
+  }
+  if (settings.name !== undefined && (typeof settings.name !== "string" || settings.name.trim() === "")) {
+    invalid("Expected the name of a log provider to be a non-empty string.");
+  }
+  const provider = Object.freeze({
+    write: settings.write,
+    ...settings.flush ? { flush: settings.flush } : {}
+  });
+  if (settings.name)
+    names.set(provider, settings.name);
+  return provider;
+}
+function logProviderNameOf(provider) {
+  return names.get(provider);
+}
+var fieldsText = (fields) => Object.keys(fields).length > 0 ? ` ${JSON.stringify(fields)}` : "";
+function consoleLogProvider2() {
+  return logProviderOf2({
+    name: "console",
+    write: ({ at, level, event, fields, application }) => {
+      const line = `${at} ${level.toUpperCase()} [${application}] ${event}${fieldsText(fields)}`;
+      (level === "debug" ? console.debug : level === "info" ? console.info : level === "warn" ? console.warn : console.error)(line);
+    }
+  });
+}
+function jsonLogProvider2() {
+  return logProviderOf2({
+    name: "json",
+    write: (entry) => {
+      console.log(JSON.stringify({
+        at: entry.at,
+        level: entry.level,
+        application: entry.application,
+        event: entry.event,
+        ...entry.fields
+      }));
+    }
+  });
+}
+function memoryLogProvider2() {
+  const entries = [];
+  const provider = Object.freeze({
+    write: (entry) => {
+      entries.push(entry);
+    },
+    entries,
+    clear: () => {
+      entries.length = 0;
+    }
+  });
+  names.set(provider, "memory");
+  return provider;
+}
+function checkLogSettings(settings) {
+  if (typeof settings !== "object" || settings === null) {
+    return invalid("Expected `log` to be { level?, providers }.");
+  }
+  const { level = "info", providers } = settings;
+  if (!LogLevels2.includes(level)) {
+    invalid(`Expected the log level to be one of ${LogLevels2.join(", ")}.`);
+  }
+  if (!Array.isArray(providers) || providers.some((provider) => typeof provider !== "object" || provider === null || typeof provider.write !== "function")) {
+    invalid("Expected `log.providers` to be a list of log providers.");
+  }
+  return Object.freeze({ level, providers: Object.freeze([...providers]) });
+}
+var silentLogger = Object.freeze({
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+});
+var rank = (level) => LogLevels2.indexOf(level);
+function applicationLogger(application) {
+  let current;
+  const write = (level) => (event, fields = {}) => {
+    if (!current || rank(level) < rank(current.level))
+      return;
+    const entry = Object.freeze({
+      at: new Date().toISOString(),
+      level,
+      event,
+      fields,
+      application
+    });
+    for (const provider of current.providers) {
+      try {
+        const written = provider.write(entry);
+        if (written && typeof written.catch === "function") {
+          written.catch(() => {});
+        }
+      } catch {}
+    }
+  };
+  const logger = Object.freeze({
+    debug: write("debug"),
+    info: write("info"),
+    warn: write("warn"),
+    error: write("error")
+  });
+  return {
+    logger,
+    get settings() {
+      return current;
+    },
+    set(settings) {
+      current = settings;
+    },
+    async flush() {
+      await Promise.all((current?.providers ?? []).map((provider) => Promise.resolve().then(() => provider.flush?.()).catch(() => {})));
+    }
+  };
+}
+var Logger2 = Object.freeze({
+  [Kind2]: "logger"
+});
+function isLoggerDeclaration(value) {
+  return value === Logger2;
+}
+function isLogger(value) {
+  return typeof value === "object" && value !== null && ["debug", "info", "warn", "error"].every((level) => typeof value[level] === "function");
+}
+var ApplicationLoggerKey = Symbol("afora.application.logger");
+function resolveLogger(scoped, owner) {
+  return scoped ?? owner?.[ApplicationLoggerKey] ?? startedApplication()?.[ApplicationLoggerKey];
+}
+function clock() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function elapsed(since) {
+  return Math.round(clock() - since);
+}
+var logged = new WeakSet;
+function logFailure(logger, event, fields, error) {
+  if (!logger)
+    return;
+  const exception = error instanceof Exception2 ? error : undefined;
+  const key = exception?.origin ?? error;
+  if (typeof key === "object" && key !== null) {
+    if (logged.has(key))
+      return;
+    logged.add(key);
+  }
+  const unexpected = !exception || exception.origin.name === UNEXPECTED_ERROR2;
+  try {
+    logger[unexpected ? "error" : "warn"](event, {
+      ...fields,
+      exception: exception ? exception.toJSON() : { message: error instanceof Error ? error.message : String(error) }
+    });
+  } catch {}
+}
+function writeLog(logger, level, event, fields) {
+  if (!logger)
+    return;
+  try {
+    logger[level](event, fields);
+  } catch {}
+}
+
 // src/core/entity/exceptions.ts
 var ReservedEntityKey2 = exceptionOf2({
   layer: "entity" /* Entity */,
@@ -291,8 +581,10 @@ function eventOf2(name, entityClass, handler) {
     return Object.freeze({
       name,
       entity,
-      async handle() {
-        await handler(entity);
+      async handle(context) {
+        await handler(entity, {
+          logger: context?.logger ?? resolveLogger(undefined, undefined) ?? silentLogger
+        });
       }
     });
   });
@@ -473,7 +765,7 @@ function frozenJson(value, subject, fail, seen = new Set) {
 // src/core/repository/provider.ts
 var descriptions = new WeakMap;
 var opaque = Object.freeze({ kind: "opaque" });
-function invalid(reason) {
+function invalid2(reason) {
   throw new InvalidRepositoryDeclaration2({
     source: "providerOf",
     details: { reason }
@@ -481,13 +773,13 @@ function invalid(reason) {
 }
 function providerOf2(settings) {
   if (!settings || typeof settings.name !== "string" || settings.name.trim().length === 0 || typeof settings.create !== "function")
-    invalid("Expected a provider name and create function.");
-  const options = frozenJson(settings.options ?? {}, "Provider options", invalid);
+    invalid2("Expected a provider name and create function.");
+  const options = frozenJson(settings.options ?? {}, "Provider options", invalid2);
   if (options === null || typeof options !== "object" || Array.isArray(options))
-    invalid("Provider options must be an object.");
+    invalid2("Provider options must be an object.");
   const provider = settings.create(options);
   if (!provider || typeof provider !== "object" || ["findOne", "findMany", "insert", "update", "remove", "count"].some((key) => typeof provider[key] !== "function"))
-    invalid("Expected a repository provider from create.");
+    invalid2("Expected a repository provider from create.");
   descriptions.set(provider, Object.freeze({
     kind: "provider",
     name: settings.name,
@@ -576,11 +868,11 @@ function matchesQuery(data, query) {
 function codePoints(text) {
   return Array.from(text, (char) => char.codePointAt(0));
 }
-function rank(value) {
+function rank2(value) {
   return value instanceof Date ? 1 : { number: 0, bigint: 0, string: 2, boolean: 3 }[typeof value] ?? 4;
 }
 function compareScalars(a, b) {
-  const [left, right] = [rank(a), rank(b)];
+  const [left, right] = [rank2(a), rank2(b)];
   if (left !== right)
     return left - right;
   if (typeof a === "string" && typeof b === "string") {
@@ -799,31 +1091,31 @@ var origins = new WeakMap;
 function declarationOf(state) {
   return origins.get(state) ?? state;
 }
-function bindState(state, provider, bound = new Map) {
+function bindState(state, provider, instances, bound = new Map) {
   const done = bound.get(state);
   if (done)
     return done;
   const copy = {
     ...state,
-    provider: state.explicitProvider ? state.provider : provider,
+    provider: state.explicitProvider ? instances?.get(state.provider) ?? state.provider : provider ?? state.provider,
     context: undefined,
     relations: new Map([...state.relations].map(([target, related]) => [
       target,
-      bindState(related, provider, bound)
+      bindState(related, provider, instances, bound)
     ]))
   };
   origins.set(copy, declarationOf(state));
   bound.set(state, copy);
   return copy;
 }
-function bindRepository(repository, provider) {
+function bindRepository(repository, provider, instances) {
   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));
+  states.set(Bound, bindState(state, provider, instances));
   return Object.freeze(new Bound);
 }
 
@@ -1138,25 +1430,25 @@ function unknownAction(entity, action, methods) {
   }
   return `"${action}" is not an action of ${entity}.`;
 }
-function invalid2(source, reason) {
+function invalid3(source, reason) {
   throw new InvalidRepositoryDeclaration2({ source, details: { reason } });
 }
 function repositoryOf2(settings) {
   const { entity, actions, environmentDependencies } = settings ?? {};
   if (!isEntityClass2(entity) || !(EntityUniqueKeys2 in entity)) {
-    invalid2("repositoryOf", "Expected an entity class made by entityOf.");
+    invalid3("repositoryOf", "Expected an entity class made by entityOf.");
   }
   const name = `${entity.name}Repository`;
   const deletion = settings.deletion ?? "hard";
   if (deletion !== "hard" && deletion !== "soft") {
-    invalid2(name, 'Expected deletion to be "hard" or "soft".');
+    invalid3(name, 'Expected deletion to be "hard" or "soft".');
   }
   const provider = settings.provider ?? inMemoryProvider2();
   if (!Array.isArray(actions) || actions.length === 0) {
-    invalid2(name, "Expected a list of actions.");
+    invalid3(name, "Expected a list of actions.");
   }
   if (environmentDependencies !== undefined && !isEnvironment2(environmentDependencies) && !(Array.isArray(environmentDependencies) && environmentDependencies.every(isEnvironment2))) {
-    invalid2(name, "Expected environments made by environmentOf.");
+    invalid3(name, "Expected environments made by environmentOf.");
   }
   const relations = relationsOf(name, entity, settings.relations);
   const unique = entity[EntityUniqueKeys2];
@@ -1182,12 +1474,12 @@ function repositoryOf2(settings) {
   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));
+      invalid3(name, unknownAction(entity.name, String(name_), methods));
     const [kind, implementation] = method;
     const needs = deletion === "soft" && kind === "delete" ? ["findOne", "update"] : NEEDS[kind] ?? [];
     for (const need of needs) {
       if (typeof provider?.[need] !== "function") {
-        invalid2(name, `The provider has no "${need}" for "${name_}".`);
+        invalid3(name, `The provider has no "${need}" for "${name_}".`);
       }
     }
     Object.defineProperty(DeclaredRepository.prototype, name_, {
@@ -1211,7 +1503,7 @@ function repositoryOf2(settings) {
 }
 function RepositoryOf2(repository) {
   if (!isRepository2(repository)) {
-    invalid2("RepositoryOf", "Expected a repository made by repositoryOf.");
+    invalid3("RepositoryOf", "Expected a repository made by repositoryOf.");
   }
   return repository.constructor;
 }
@@ -1719,6 +2011,9 @@ var InvalidUseCaseDependencies2 = exceptionOf2({
   name: "InvalidUseCaseDependencies",
   message: "Dependency overrides must contain only declared names: functions for use cases, objects of methods for repositories, and valid variables for environments."
 });
+function loggerOfCall(state) {
+  return resolveLogger(state.scope?.logger, state.owner);
+}
 var states2 = new WeakMap;
 function invalidValue(issues, source, phase) {
   throw new Exception2({
@@ -1773,6 +2068,7 @@ function methodNamesOf(repository) {
 }
 function bindRepository2(repository, overrides, state, source) {
   const Entity = repository.entity;
+  const repositoryName = Entity.name;
   const bound = Object.create(null);
   const view = new Proxy(Object.create(repository), {
     get: (_target, key, receiver) => {
@@ -1793,7 +2089,14 @@ function bindRepository2(repository, overrides, state, source) {
     bound[name] = async (...args) => {
       if (!state.active)
         throw new InvalidUseCaseDependencies2({ source });
+      const started = clock();
       const result = await method.apply(receiver, args);
+      writeLog(loggerOfCall(state), "debug", "repository", {
+        repository: repositoryName,
+        method: name,
+        useCase: source,
+        ms: elapsed(started)
+      });
       for (const arg of args)
         pullEntities(arg, Entity, state.events);
       pullEntities(result, Entity, state.events);
@@ -1828,6 +2131,8 @@ function narrowedContext(Child, parent) {
   return picked;
 }
 function isOverrideOf(dependency, value) {
+  if (isLoggerDeclaration(dependency))
+    return isLogger(value);
   if (isRepository2(dependency) || isEnvironment2(dependency)) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
@@ -1873,7 +2178,8 @@ class AbstractUseCase2 {
       started: false,
       active: false,
       events: [],
-      dependencies: Object.create(null)
+      dependencies: Object.create(null),
+      owner: this.constructor
     };
     states2.set(this, state);
     for (const [key, dependency] of Object.entries(declaration.dependencies)) {
@@ -1881,6 +2187,13 @@ class AbstractUseCase2 {
         state.dependencies[key] = bindRepository2(dependency, undefined, state, source);
         continue;
       }
+      if (isLoggerDeclaration(dependency)) {
+        Object.defineProperty(state.dependencies, key, {
+          get: () => loggerOfCall(state) ?? silentLogger,
+          enumerable: true
+        });
+        continue;
+      }
       if (isEnvironment2(dependency)) {
         Object.defineProperty(state.dependencies, key, {
           get: () => state.scope?.environments?.get(dependency) ?? dependency.load(),
@@ -1925,6 +2238,10 @@ class AbstractUseCase2 {
             dependencies[key] = bindRepository2(dependency, substitute, state, source);
             continue;
           }
+          if (isLoggerDeclaration(dependency)) {
+            dependencies[key] = substitute;
+            continue;
+          }
           if (isEnvironment2(dependency)) {
             const parsed = dependency.blueprint.safeParse(substitute);
             if (parsed.issues)
@@ -1949,13 +2266,22 @@ class AbstractUseCase2 {
         }
         state.resolved = Object.freeze(dependencies);
         state.active = true;
+        const started = clock();
         try {
           const result = await guard2({ 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);
+          writeLog(loggerOfCall(state), "debug", "use-case", {
+            useCase: source,
+            outcome: "ok",
+            ms: elapsed(started)
+          });
           return parsed.value;
+        } catch (error) {
+          logFailure(loggerOfCall(state), "use-case-failed", { useCase: source, ms: elapsed(started) }, error);
+          throw error;
         } finally {
           state.active = false;
           state.resolved = undefined;
@@ -1981,7 +2307,7 @@ function useCaseOf2(settings) {
     throw new InvalidUseCaseDeclaration2({
       source: typeof name === "string" ? name : "useCaseOf",
       details: {
-        reason: "Expected a name, input and response blueprints, and UseCase classes, repositories or environments as dependencies."
+        reason: "Expected a name, input and response blueprints, and UseCase classes, repositories, environments or Logger as dependencies."
       }
     });
   }
@@ -2037,7 +2363,7 @@ function useCaseOf2(settings) {
   return DeclaredUseCase;
 }
 function isDependency(value) {
-  return isUseCaseClass2(value) || isRepository2(value) || isEnvironment2(value);
+  return isUseCaseClass2(value) || isRepository2(value) || isEnvironment2(value) || isLoggerDeclaration(value);
 }
 function isUseCaseClass2(value) {
   return typeof value === "function" && value.prototype instanceof AbstractUseCase2 && value[Kind2] === "use-case" && typeof value.prototype.execute === "function";
@@ -2085,7 +2411,7 @@ function commandTransactionProvider(command) {
   return verifiers.get(command)?.();
 }
 var IDENTIFIER2 = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-function providersOf(useCases, declared) {
+function repositoryProvidersOf(useCases, declared) {
   const providers = new Map;
   const seen = new Set;
   const add = (state) => {
@@ -2119,7 +2445,7 @@ function providersOf(useCases, declared) {
   return providers;
 }
 function transactionProviderOf(name, useCases, declared = false) {
-  const providers = providersOf(useCases, declared);
+  const providers = repositoryProvidersOf(useCases, declared);
   const invalid = (reason, repositories) => {
     throw new InvalidCommandDeclaration2({
       source: name,
@@ -2283,9 +2609,16 @@ function commandOf2(settings) {
       given = narrowed(UseCase, callContext);
     }
     const overrides = options?.env === undefined ? undefined : callEnvironment(where, environments, options.env);
-    const withEnvironments = (scope) => overrides === undefined || overrides.byEnvironment.size === 0 ? scope : {
-      providers: scope?.providers ?? new Map,
-      environments: overrides.byEnvironment
+    const logger = resolveLogger(undefined, UseCase);
+    const withEnvironments = (scope) => {
+      const environmentsOfCall = overrides === undefined || overrides.byEnvironment.size === 0 ? scope?.environments : overrides.byEnvironment;
+      if (!environmentsOfCall && !logger)
+        return scope;
+      return {
+        providers: scope?.providers ?? new Map,
+        ...environmentsOfCall ? { environments: environmentsOfCall } : {},
+        ...logger ? { logger } : {}
+      };
     };
     const run = async (declared) => {
       const scope = withEnvironments(declared);
@@ -2294,11 +2627,20 @@ function commandOf2(settings) {
       return { value, events: useCase.pullEvents() };
     };
     const provider = providerOfCall();
-    const outcome = await guard2({ layer: "command" /* Command */, source: where }, () => provider?.transaction ? provider.transaction((scoped) => run({ providers: new Map([[provider, scoped]]) })) : run(undefined));
+    const started = clock();
+    const outcome = await guard2({ layer: "command" /* Command */, source: where }, () => provider?.transaction ? provider.transaction((scoped) => run({ providers: new Map([[provider, scoped]]) })) : run(undefined)).catch((error) => {
+      logFailure(logger, "command-failed", { command: where, ms: elapsed(started) }, error);
+      throw error;
+    });
+    writeLog(logger, "debug", "command", {
+      command: where,
+      ms: elapsed(started)
+    });
     return {
       ...outcome,
       context: callContext,
-      env: () => overrides?.merged ?? loadEnvironments(environments)
+      env: () => overrides?.merged ?? loadEnvironments(environments),
+      logger: logger ?? silentLogger
     };
   };
   const command = {
@@ -2325,13 +2667,15 @@ function commandOf2(settings) {
         value,
         events: raised,
         context: callContext,
-        env
+        env,
+        logger
       } = await perform(op, input, options);
       await applyPolicy(command, events, onEventError, {
         operation: op,
         raised,
         context: callContext,
-        env
+        env,
+        logger
       });
       return value;
     }
@@ -2351,7 +2695,8 @@ async function applyPolicy(command, policy, onEventError, call) {
     context: call.context,
     get env() {
       return call.env();
-    }
+    },
+    logger: call.logger
   };
   if (typeof policy === "function") {
     try {
@@ -2367,7 +2712,7 @@ async function applyPolicy(command, policy, onEventError, call) {
   }
   for (const [index, event] of raised.entries()) {
     try {
-      await event.handle();
+      await event.handle({ logger: call.logger });
     } catch (cause) {
       if (!onEventError) {
         throw new CommandEventFailed2({
@@ -2402,74 +2747,6 @@ function isCommand2(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "command";
 }
 
-// src/core/application/exceptions.ts
-var InvalidApplicationDeclaration2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "InvalidApplicationDeclaration",
-  message: ({ reason }) => reason
-});
-var DuplicateApplicationDeclaration2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "DuplicateApplicationDeclaration",
-  message: ({
-    first,
-    second
-  }) => `The same object is registered as ${first} and as ${second}.`
-});
-var ApplicationConflict2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "ApplicationConflict",
-  message: ({
-    reason
-  }) => reason
-});
-var UnregisteredApplicationReference2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "UnregisteredApplicationReference",
-  message: ({
-    holder,
-    reference
-  }) => `${holder} holds ${reference}, which is not registered in the application.`
-});
-var UnregisteredRepositoryDependency2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "UnregisteredRepositoryDependency",
-  message: ({
-    repository,
-    dependency
-  }) => `Repository ${repository} depends on ${dependency}, which is not registered in the application.`
-});
-var UnregisteredUseCaseDependency2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "UnregisteredUseCaseDependency",
-  message: ({
-    useCase,
-    dependency
-  }) => `Use case ${useCase} depends on ${dependency}, which is not registered in the application.`
-});
-var ApplicationNotStarted2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "ApplicationNotStarted",
-  message: ({
-    application
-  }) => application === undefined ? "No application is started: call await app.start() first." : `The application "${application}" is not started: call await app.start() first.`
-});
-var ApplicationAlreadyStarted2 = exceptionOf2({
-  layer: "application" /* Application */,
-  name: "ApplicationAlreadyStarted",
-  message: ({
-    current,
-    attempted
-  }) => `The application "${current}" is already started, so "${attempted}" cannot be: stop it, or call start({ replace: true }).`
-});
-var InvalidApplicationEnvironment2 = exceptionOf2({
-  layer: "environment" /* Environment */,
-  name: "InvalidApplicationEnvironment",
-  message: ({
-    environments
-  }) => `Invalid environment variables: ${Object.entries(environments).map(([name, keys]) => `${name} (${keys.join(", ")})`).join("; ")}.`
-});
-
 // src/core/openapi/exceptions.ts
 var InvalidOpenAPIModel2 = exceptionOf2({
   layer: "output" /* Output */,
@@ -2502,18 +2779,19 @@ function isExportedException(Declared) {
   if (!collected) {
     collected = true;
     for (const module of [
-      exports_exceptions8,
-      exports_exceptions2,
-      exports_exceptions7,
       exports_exceptions4,
-      exports_environment,
+      exports_exceptions2,
       exports_exceptions9,
+      exports_exceptions6,
+      exports_environment,
+      exports_exceptions5,
       exports_exceptions10,
+      exports_exceptions11,
       exports_exceptions3,
       exports_exceptions,
-      exports_exceptions5,
+      exports_exceptions7,
       exports_use_case,
-      exports_exceptions6
+      exports_exceptions8
     ]) {
       markExported(...Object.values(module));
     }
@@ -2635,28 +2913,28 @@ function toOpenAPI2(modelOrModels, { refPrefix = "#/components/schemas/" } = {})
 var descriptions2 = new WeakMap;
 var factories = new WeakMap;
 var opaque2 = Object.freeze({ kind: "opaque" });
-function invalid3(source, reason) {
+function invalid4(source, reason) {
   throw new InvalidOutputStage2({ source, details: { reason } });
 }
 function optionsOf(name, given, validate) {
-  const options = frozenJson(given ?? {}, "Stage options", (reason) => invalid3(name, reason));
+  const options = frozenJson(given ?? {}, "Stage options", (reason) => invalid4(name, reason));
   if (options === null || typeof options !== "object" || Array.isArray(options)) {
-    invalid3(name, "Stage options must be an object.");
+    invalid4(name, "Stage options must be an object.");
   }
   const reason = validate?.(options);
   if (reason !== undefined)
-    invalid3(name, reason);
+    invalid4(name, reason);
   return options;
 }
 function checkName(source, name) {
   if (typeof name !== "string" || !name.trim()) {
-    invalid3(source, "Expected the stage name to be a non-empty string.");
+    invalid4(source, "Expected the stage name to be a non-empty string.");
   }
 }
 function transformOf2(settings) {
   checkName("transformOf", settings?.name);
   if (typeof settings.apply !== "function") {
-    invalid3(settings.name, "Expected apply to be a function.");
+    invalid4(settings.name, "Expected apply to be a function.");
   }
   const { name, apply, validate } = settings;
   const factory = (given) => {
@@ -2680,7 +2958,7 @@ function transformOf2(settings) {
 function sinkOf2(settings) {
   checkName("sinkOf", settings?.name);
   if (typeof settings.build !== "function") {
-    invalid3(settings.name, "Expected build to be a function.");
+    invalid4(settings.name, "Expected build to be a function.");
   }
   const { name, build, validate } = settings;
   const factory = (given) => {
@@ -2718,10 +2996,10 @@ function stageCatalogOf2(...stages) {
   for (const factory of stages) {
     const known = factories.get(factory);
     if (!known) {
-      invalid3("catalog", "A catalog takes factories made by `transformOf` or `sinkOf`.");
+      invalid4("catalog", "A catalog takes factories made by `transformOf` or `sinkOf`.");
     }
     if (Object.hasOwn(byName, known.name)) {
-      invalid3(known.name, "The catalog has another stage with its name.");
+      invalid4(known.name, "The catalog has another stage with its name.");
     }
     byName[known.name] = factory;
   }
@@ -2732,7 +3010,7 @@ function stageCatalogOf2(...stages) {
     resolve(name, options) {
       const factory = Object.hasOwn(byName, name) ? byName[name] : undefined;
       if (!factory)
-        invalid3("catalog", `Unknown stage "${name}".`);
+        invalid4("catalog", `Unknown stage "${name}".`);
       return factory(options);
     }
   });
@@ -2742,38 +3020,38 @@ function stageCatalogOf2(...stages) {
 function isApplicationLike(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "application";
 }
-function invalid4(source, reason) {
+function invalid5(source, reason) {
   throw new InvalidOutputStage2({ source, details: { reason } });
 }
 var PATCHABLE = ["meta", "tags", "description", "deprecated", "invoke"];
 function operationOf2(operation, patch) {
   const source = operation?.id ?? "operationOf";
   if (operation?.kind !== "operation" || operation.version !== 1) {
-    invalid4(source, "Expected an operation descriptor.");
+    invalid5(source, "Expected an operation descriptor.");
   }
   if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
-    invalid4(source, "Expected the patch to be an object.");
+    invalid5(source, "Expected the patch to be an object.");
   }
   for (const key of Reflect.ownKeys(patch)) {
     if (typeof key !== "string" || !PATCHABLE.includes(key)) {
-      invalid4(source, `"${String(key)}" cannot be patched; only ${PATCHABLE.join(", ")} can.`);
+      invalid5(source, `"${String(key)}" cannot be patched; only ${PATCHABLE.join(", ")} can.`);
     }
   }
   const { meta, tags, description, deprecated, invoke } = patch;
   if ("meta" in patch && (typeof meta !== "object" || meta === null || Array.isArray(meta))) {
-    invalid4(source, "Expected meta to be an object.");
+    invalid5(source, "Expected meta to be an object.");
   }
   if ("tags" in patch && (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string"))) {
-    invalid4(source, "Expected tags to be a list of strings.");
+    invalid5(source, "Expected tags to be a list of strings.");
   }
   if ("description" in patch && description !== undefined && typeof description !== "string") {
-    invalid4(source, "Expected description to be a string.");
+    invalid5(source, "Expected description to be a string.");
   }
   if ("deprecated" in patch && typeof deprecated !== "boolean") {
-    invalid4(source, "Expected deprecated to be a boolean.");
+    invalid5(source, "Expected deprecated to be a boolean.");
   }
   if ("invoke" in patch && typeof invoke !== "function") {
-    invalid4(source, "Expected invoke to be a function.");
+    invalid5(source, "Expected invoke to be a function.");
   }
   return Object.freeze({
     ...operation,
@@ -2814,25 +3092,25 @@ function statusesOf(name, statuses) {
   if (statuses === undefined)
     return Object.freeze({});
   if (typeof statuses !== "object" || statuses === null || Array.isArray(statuses)) {
-    invalid4(name, "Expected statuses to be a map of exception names to statuses.");
+    invalid5(name, "Expected statuses to be a map of exception names to statuses.");
   }
   for (const [exception, status] of Object.entries(statuses)) {
     if (!exception || typeof status !== "number" || !Number.isInteger(status) || status < 400 || status > 599) {
-      invalid4(name, `Expected the status of "${exception}" to be an integer between 400 and 599.`);
+      invalid5(name, `Expected the status of "${exception}" to be an integer between 400 and 599.`);
     }
   }
   return Object.freeze({ ...statuses });
 }
 function checkPipe(name, pipe) {
   if (!Array.isArray(pipe))
-    invalid4(name, "Expected pipe to be a list of stages.");
+    invalid5(name, "Expected pipe to be a list of stages.");
   const stages = pipe;
   stages.forEach((stage, index) => {
     if (!isStage(stage)) {
-      invalid4(name, `Expected pipe[${index}] to be a transform or sink stage.`);
+      invalid5(name, `Expected pipe[${index}] to be a transform or sink stage.`);
     }
     if (stage.kind === "sink" && index !== stages.length - 1) {
-      invalid4(name, `The sink at pipe[${index}] must be the last stage.`);
+      invalid5(name, `The sink at pipe[${index}] must be the last stage.`);
     }
   });
   return Object.freeze([...stages]);
@@ -2848,7 +3126,7 @@ function transformed(name, operations, transforms, context) {
       if (result === null)
         continue;
       if (typeof result !== "object" || result?.kind !== "operation" || result.id !== operation.id) {
-        invalid4(name, `A transform must return the operation "${operation.id}" or null.`);
+        invalid5(name, `A transform must return the operation "${operation.id}" or null.`);
       }
       next.push(result);
     }
@@ -2873,7 +3151,7 @@ function make(name, commands, operations, stages, statuses) {
         return built.value;
       const sink = stages.at(-1);
       if (sink?.kind !== "sink") {
-        invalid4(name || "output", "The pipe has no sink to build.");
+        invalid5(name || "output", "The pipe has no sink to build.");
       }
       built = { value: sink.build(operations, context) };
       return built.value;
@@ -2882,7 +3160,7 @@ function make(name, commands, operations, stages, statuses) {
       const next = checkPipe(name || "output", more);
       const last = next.at(-1);
       if (stages.at(-1)?.kind === "sink") {
-        invalid4(name || "output", "Cannot add stages after the sink.");
+        invalid5(name || "output", "Cannot add stages after the sink.");
       }
       const ops = transformed(name, operations, next, context);
       if (last?.kind === "sink") {
@@ -2896,11 +3174,11 @@ function make(name, commands, operations, stages, statuses) {
 function outputOf2(settings) {
   const { name, commands } = settings ?? {};
   if (typeof name !== "string" || !name.trim()) {
-    invalid4("outputOf", "Expected name to be a non-empty string.");
+    invalid5("outputOf", "Expected name to be a non-empty string.");
   }
   const sources = Array.isArray(commands) ? commands : [commands];
   if (!Array.isArray(commands) && isCommand2(commands) || sources.some((entry) => !isCommand2(entry) && !isApplicationLike(entry))) {
-    invalid4(name, "Expected commands to be a list of commands made by commandOf or applications.");
+    invalid5(name, "Expected commands to be a list of commands made by commandOf or applications.");
   }
   const flat = [
     ...new Set(sources.flatMap((entry) => isCommand2(entry) ? [entry] : Object.values(entry.commands)))
@@ -2944,32 +3222,16 @@ function describeSteps(steps, names) {
   });
 }
 
-// src/core/application/registry.ts
-var SLOT = Symbol.for("afora.application");
-function slot() {
-  const global = globalThis;
-  global[SLOT] ??= { current: undefined };
-  return global[SLOT];
-}
-function useApplication2() {
-  const { current } = slot();
-  if (current === undefined) {
-    throw new ApplicationNotStarted2({ source: "useApplication", details: {} });
-  }
-  return current;
-}
-function resetApplication2() {
-  slot().current = undefined;
-}
-function startedApplication() {
-  return slot().current;
-}
-function setStartedApplication(application) {
-  slot().current = application;
-}
-
 // src/core/application/start.ts
 function providerFrom2(environmentDependencies, create) {
+  if (typeof environmentDependencies === "function" && create === undefined) {
+    return Object.freeze({
+      [Kind2]: "provider-factory",
+      environments: Object.freeze([]),
+      create: environmentDependencies,
+      withContext: true
+    });
+  }
   const list = isEnvironment2(environmentDependencies) ? [environmentDependencies] : Array.isArray(environmentDependencies) ? [...environmentDependencies] : [null];
   if (!list.every(isEnvironment2) || new Set(list).size !== list.length || typeof create !== "function") {
     throw new InvalidApplicationDeclaration2({
@@ -2982,9 +3244,22 @@ function providerFrom2(environmentDependencies, create) {
   return Object.freeze({
     [Kind2]: "provider-factory",
     environments: Object.freeze(list),
-    create
+    create,
+    withContext: false
   });
 }
+function logFrom2(create) {
+  if (typeof create !== "function") {
+    throw new InvalidApplicationDeclaration2({
+      source: "logFrom",
+      details: { reason: "Expected logFrom to take a create function." }
+    });
+  }
+  return Object.freeze({ [Kind2]: "log-factory", create });
+}
+function isLogFactory2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "log-factory";
+}
 function isProviderFactory2(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "provider-factory";
 }
@@ -3041,12 +3316,12 @@ function isDeferredProvider(provider) {
 function deferredEnvironments(provider) {
   return (typeof provider === "object" && provider !== null ? deferred.get(provider)?.factory.environments : undefined) ?? [];
 }
-function startDeferred(provider) {
+function startDeferred(provider, context) {
   const state = deferred.get(provider);
   if (!state)
     return;
   state.starting ??= (async () => {
-    const made = await state.factory.create(loadEnvironments(state.factory.environments));
+    const made = await state.factory.create(state.factory.withContext ? context : loadEnvironments(state.factory.environments));
     if (typeof made !== "object" || made === null) {
       state.starting = undefined;
       throw new InvalidApplicationDeclaration2({
@@ -3085,6 +3360,106 @@ function checkTransactions(source, provider, commands) {
   }
 }
 
+// src/core/application/providers.ts
+var slots = new WeakMap;
+var storages = new WeakMap;
+var METHODS2 = [
+  "findOne",
+  "findMany",
+  "insert",
+  "update",
+  "remove",
+  "count"
+];
+var KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RESERVED = new Set(["inMemory", "__proto__", "constructor", "prototype"]);
+function invalid6(reason) {
+  throw new InvalidApplicationDeclaration2({
+    source: "providersOf",
+    details: { reason }
+  });
+}
+function isProviderObject(value) {
+  return typeof value === "object" && value !== null && !isProviderFactory2(value) && METHODS2.some((method) => typeof value[method] === "function");
+}
+function slotOf(key, storage, value) {
+  const slot = {
+    [Kind2]: "provider-slot",
+    key
+  };
+  if (isProviderFactory2(value)) {
+    const unbound = () => {
+      throw new ProviderNotBound2({ source: key, details: { provider: key } });
+    };
+    for (const method of METHODS2)
+      slot[method] = unbound;
+    slot.transaction = unbound;
+    Object.defineProperty(slot, "capabilities", {
+      get: () => {
+        return;
+      },
+      enumerable: true
+    });
+  } else {
+    const target = value;
+    for (const method of [...METHODS2, "transaction", "close"]) {
+      if (typeof target[method] === "function") {
+        slot[method] = (...args) => target[method]?.(...args);
+      }
+    }
+    Object.defineProperty(slot, "capabilities", {
+      get: () => value.capabilities,
+      enumerable: true
+    });
+  }
+  Object.freeze(slot);
+  slots.set(slot, { key, storage, value });
+  return slot;
+}
+function providersOf2(entries) {
+  if (typeof entries !== "object" || entries === null || Array.isArray(entries) || Object.keys(entries).length === 0) {
+    invalid6("Expected an object of providers by key.");
+  }
+  const storage = Object.create(null);
+  storage[Kind2] = "provider-storage";
+  const seen = new Map;
+  const list = [];
+  for (const [key, value] of Object.entries(entries)) {
+    if (!KEY.test(key) || RESERVED.has(key)) {
+      invalid6(key === "inMemory" ? `"inMemory" is the built-in provider; choose another key.` : `Expected "${key}" to be an identifier that is not reserved.`);
+    }
+    if (isProviderSlot2(value)) {
+      invalid6(`"${key}" holds a provider of another storage; a storage holds providers, not slots.`);
+    }
+    if (!isProviderFactory2(value) && !isProviderObject(value)) {
+      invalid6(`Expected "${key}" to be a repository provider or a factory of providerFrom.`);
+    }
+    const other = seen.get(value);
+    if (other !== undefined) {
+      invalid6(`"${other}" and "${key}" hold the same provider.`);
+    }
+    seen.set(value, key);
+    const slot = slotOf(key, storage, value);
+    storage[key] = slot;
+    list.push(slot);
+  }
+  Object.freeze(storage);
+  storages.set(storage, Object.freeze(list));
+  return storage;
+}
+function isProviderSlot2(value) {
+  return typeof value === "object" && value !== null && slots.has(value);
+}
+function isProviderStorage2(value) {
+  return typeof value === "object" && value !== null && storages.has(value);
+}
+function slotsOf(storage) {
+  return storages.get(storage) ?? [];
+}
+function slotEntry(slot) {
+  return slots.get(slot);
+}
+
 // src/core/application/application.ts
 var KEYS = [
   "properties",
@@ -3099,6 +3474,12 @@ var KEYS = [
   "exceptions"
 ];
 var internals = new WeakMap;
+var logSettings = new WeakMap;
+var namedProviders = new WeakMap;
+var defaultSlots = new WeakMap;
+function referenceOf(slot) {
+  return { kind: "ref", key: slotEntry(slot).key };
+}
 var KIND_OF = {
   properties: "property",
   blueprints: "blueprint",
@@ -3114,7 +3495,7 @@ var KIND_OF = {
 function isApplication2(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "application";
 }
-function invalid5(source, reason) {
+function invalid7(source, reason) {
   throw new InvalidApplicationDeclaration2({ source, details: { reason } });
 }
 function isOfKind(collection, value) {
@@ -3199,7 +3580,7 @@ function resolve(settings) {
   for (const other of settings.extends ?? []) {
     const resolved = internals.get(other);
     if (!resolved)
-      invalid5(source, "Expected `extends` to hold applications.");
+      invalid7(source, "Expected `extends` to hold applications.");
     for (const key of KEYS) {
       for (const entry of resolved[key].values())
         add(entry);
@@ -3210,15 +3591,15 @@ function resolve(settings) {
     if (declared === undefined)
       continue;
     if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
-      invalid5(source, `Expected ${collection} to be an object of declarations.`);
+      invalid7(source, `Expected ${collection} to be an object of declarations.`);
     }
     for (const [name, value] of Object.entries(declared)) {
       if (!isOfKind(collection, value)) {
-        invalid5(source, `${collection}.${name} is not a ${KIND_OF[collection]} (${collection} takes ${KIND_OF[collection]} declarations).`);
+        invalid7(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 : name;
       if (declaredName !== name) {
-        invalid5(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
+        invalid7(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
       }
       add({
         collection,
@@ -3339,7 +3720,7 @@ function validateOutputs(source, registry) {
   for (const entry of registry.outputs.values()) {
     const output = entry.value;
     if (!output.outputName) {
-      invalid5(source, `outputs.${entry.name} has no name (an output made by pipe cannot be registered).`);
+      invalid7(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))
@@ -3369,7 +3750,7 @@ function validateUseCases(source, registry) {
   for (const entry of registry.useCases.values()) {
     const UseCase = entry.value;
     for (const [key, dependency] of Object.entries(UseCase.dependencies)) {
-      const found = isUseCaseClass2(dependency) ? useCases.has(dependency) : isEnvironment2(dependency) ? environments.has(dependency) : repositories.has(inspectRepository(dependency).state);
+      const found = isLoggerDeclaration(dependency) ? true : isUseCaseClass2(dependency) ? useCases.has(dependency) : isEnvironment2(dependency) ? environments.has(dependency) : repositories.has(inspectRepository(dependency).state);
       if (!found) {
         throw new UnregisteredUseCaseDependency2({
           source,
@@ -3541,7 +3922,7 @@ function recordDescriptionOf(entry, scope) {
     plugins
   };
 }
-function describeRegistry(name, extended, registry, provider) {
+function describeRegistry(name, extended, registry, provider, named, log) {
   const scope = {
     properties: referencesOf(registry, "properties"),
     blueprints: referencesOf(registry, "blueprints"),
@@ -3581,7 +3962,28 @@ function describeRegistry(name, extended, registry, provider) {
   return {
     name,
     extends: extended.map((other) => other.name),
-    ...provider === undefined ? {} : { provider: providerDescriptionOf2(provider) },
+    ...provider === undefined ? {} : { provider },
+    ...named.size === 0 ? {} : {
+      providers: Object.fromEntries([...named].map(([key, { slot, from }]) => {
+        const { value } = slotEntry(slot);
+        return [
+          key,
+          {
+            from,
+            ...isProviderFactory2(value) ? { kind: "opaque" } : providerDescriptionOf2(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 };
+        })
+      }
+    },
     properties: each("properties", (entry) => ({
       from: entry.from,
       ...propertyDescriptionOf(entry.value, scope)
@@ -3605,7 +4007,9 @@ function describeRegistry(name, extended, registry, provider) {
         deletion: info.deletion,
         relations: info.relations.map((relation) => repositories.get(relation)),
         environments: info.environments.map((environment) => environmentRefs.get(environment)),
-        ...info.provider === undefined ? {} : { provider: providerDescriptionOf2(info.provider) }
+        ...info.provider === undefined ? {} : {
+          provider: isProviderSlot2(info.provider) ? referenceOf(info.provider) : providerDescriptionOf2(info.provider)
+        }
       };
     }),
     useCases: each("useCases", (entry) => {
@@ -3632,7 +4036,10 @@ function describeRegistry(name, extended, registry, provider) {
         }),
         dependencies: Object.fromEntries(Object.entries(UseCase.dependencies).map(([key, dependency]) => [
           key,
-          isUseCaseClass2(dependency) ? { kind: "use-case", ref: useCaseRefs.get(dependency) } : isEnvironment2(dependency) ? {
+          isLoggerDeclaration(dependency) ? { kind: "logger", ref: "Logger" } : isUseCaseClass2(dependency) ? {
+            kind: "use-case",
+            ref: useCaseRefs.get(dependency)
+          } : isEnvironment2(dependency) ? {
             kind: "environment",
             ref: environmentRefs.get(dependency)
           } : {
@@ -3690,49 +4097,123 @@ function describeRegistry(name, extended, registry, provider) {
 function applicationOf2(settings) {
   const { name } = settings ?? {};
   if (typeof name !== "string" || name === "") {
-    invalid5("applicationOf", "Expected a name.");
+    invalid7("applicationOf", "Expected a name.");
   }
   const extended = settings.extends ?? [];
   if (!Array.isArray(extended) || !extended.every(isApplication2)) {
-    invalid5(name, "Expected `extends` to be a list of applications.");
+    invalid7(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);
-  const declaredProvider = settings.provider ?? [...extended].reverse().find((other) => other.provider)?.provider;
-  if (declaredProvider !== undefined && typeof declaredProvider !== "object") {
-    invalid5(name, "Expected `provider` to be a repository provider.");
+  if (settings.providers !== undefined && !isProviderStorage2(settings.providers)) {
+    invalid7(name, "Expected `providers` to be a storage made by providersOf.");
   }
-  const provider = isProviderFactory2(declaredProvider) ? deferredProvider(declaredProvider, name) : declaredProvider;
-  {
-    const registered = new Set([...registry.environments.values()].map((entry) => entry.key));
-    for (const environment of deferredEnvironments(provider)) {
-      if (registered.has(environment))
-        continue;
+  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 ApplicationConflict2({
+        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: isProviderFactory2(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 UnregisteredApplicationReference2({
         source: name,
         details: {
-          holder: "the provider",
-          reference: "an environment"
+          holder,
+          reference: `provider "${slotEntry(slot).key}"`
         }
       });
     }
+    return instance;
+  };
+  for (const entry of registry.repositories.values()) {
+    const declared = inspectRepository(entry.value).provider;
+    if (isProviderSlot2(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") {
+    invalid7(name, "Expected `provider` to be a repository provider.");
+  }
+  const defaultSlot = isProviderSlot2(declaredProvider) ? declaredProvider : inheritedFrom === undefined ? undefined : defaultSlots.get(inheritedFrom);
+  const provider = defaultSlot !== undefined ? instanceOf(defaultSlot, "the application") : isProviderFactory2(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 UnregisteredApplicationReference2({
+          source: name,
+          details: {
+            holder: holderOf(instance),
+            reference: "an environment"
+          }
+        });
+      }
+    }
+  }
+  const declaredLog = settings.log ?? [...extended].reverse().map((other) => logSettings.get(other)).find((log) => log !== undefined);
+  const log = declaredLog === undefined ? undefined : applicationLogger(name);
+  if (declaredLog !== undefined && !isLogFactory2(declaredLog)) {
+    log?.set(checkLogSettings(declaredLog));
+  }
+  const logger = log?.logger;
+  const bindsProviders = provider !== undefined || instances.size > 0;
+  const rebinds = bindsProviders || logger !== undefined;
   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 = provider === undefined ? entry.value : bindRepository(entry.value, provider);
+    const repository = bindsProviders ? bindRepository(entry.value, provider, instances) : entry.value;
     bound.set(entry.value, repository);
     boundByState.set(entry.key, repository);
     repositories[entry.name] = repository;
   }
   const boundUseCases = new Map;
   const bindUseCase = (UseCase) => {
-    if (provider === undefined)
+    if (!rebinds)
       return UseCase;
     const done = boundUseCases.get(UseCase);
     if (done)
@@ -3745,11 +4226,13 @@ function applicationOf2(settings) {
     boundUseCases.set(UseCase, Bound);
     const dependencies = Object.fromEntries(Object.entries(UseCase.dependencies).map(([key, dependency]) => [
       key,
-      isUseCaseClass2(dependency) ? bindUseCase(dependency) : isEnvironment2(dependency) ? dependency : boundByState.get(inspectRepository(dependency).state) ?? dependency
+      isUseCaseClass2(dependency) ? bindUseCase(dependency) : isEnvironment2(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 });
     return Bound;
   };
   const useCases = {};
@@ -3763,7 +4246,7 @@ function applicationOf2(settings) {
   const boundCommandOf = new Map;
   for (const entry of registry.commands.values()) {
     const declared = entry.value;
-    const rebuilt = provider === undefined ? declared : commandOf2({
+    const rebuilt = !rebinds ? declared : commandOf2({
       name: declared.commandName,
       description: declared.description,
       tags: declared.tags,
@@ -3777,7 +4260,7 @@ function applicationOf2(settings) {
       events: declared.events,
       onEventError: declared.onEventError
     });
-    if (provider !== undefined)
+    if (bindsProviders)
       verifyCommand(rebuilt);
     boundCommandOf.set(entry.value, rebuilt);
     commands[entry.name] = rebuilt;
@@ -3786,7 +4269,7 @@ function applicationOf2(settings) {
   const boundOutputOf = new Map;
   for (const entry of registry.outputs.values()) {
     const declared = entry.value;
-    const rebuilt = provider === undefined ? declared : outputOf2({
+    const rebuilt = !rebinds ? declared : outputOf2({
       name: declared.outputName,
       commands: declared.commands.map((command) => boundCommandOf.get(command)),
       statuses: declared.statuses,
@@ -3797,6 +4280,19 @@ function applicationOf2(settings) {
   }
   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 UnregisteredApplicationReference2({
+          source: name,
+          details: { holder: "the context", reference: "an environment" }
+        });
+      }
+      return environment.load();
+    },
+    logger: logger ?? silentLogger
+  });
   let starting;
   let started = false;
   const start = async () => {
@@ -3822,9 +4318,14 @@ function applicationOf2(settings) {
         cause
       });
     }
-    if (provider !== undefined && isDeferredProvider(provider)) {
-      const made = await startDeferred(provider);
-      checkTransactions(name, made, Object.entries(commands).filter(([, command]) => command.transaction && commandTransactionProvider(command) === provider).map(([key]) => key));
+    if (isLogFactory2(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));
     }
     started = true;
   };
@@ -3833,6 +4334,9 @@ function applicationOf2(settings) {
     name,
     extends: Object.freeze([...extended]),
     provider,
+    logger: logger ?? silentLogger,
+    context,
+    ...logger ? { [ApplicationLoggerKey]: logger } : {},
     properties: collection("properties"),
     blueprints: collection("blueprints"),
     records: collection("records"),
@@ -3845,25 +4349,25 @@ function applicationOf2(settings) {
     exceptions: collection("exceptions"),
     useCase(useCase) {
       if (!boundUseCaseOf.has(useCase)) {
-        invalid5(name, "Expected a use case registered in the application.");
+        invalid7(name, "Expected a use case registered in the application.");
       }
       return boundUseCaseOf.get(useCase);
     },
     command(command) {
       if (!boundCommandOf.has(command)) {
-        invalid5(name, "Expected a command registered in the application.");
+        invalid7(name, "Expected a command registered in the application.");
       }
       return boundCommandOf.get(command);
     },
     output(output) {
       if (!boundOutputOf.has(output)) {
-        invalid5(name, "Expected an output registered in the application.");
+        invalid7(name, "Expected an output registered in the application.");
       }
       return boundOutputOf.get(output);
     },
     repository(repository) {
       if (!bound.has(repository)) {
-        invalid5(name, "Expected a repository registered in the application.");
+        invalid7(name, "Expected a repository registered in the application.");
       }
       return bound.get(repository);
     },
@@ -3871,10 +4375,11 @@ function applicationOf2(settings) {
       return applicationOf2({
         name,
         extends: [application, ...others],
-        ...provider === undefined ? {} : { provider }
+        ...provider === undefined ? {} : { provider: defaultSlot ?? provider },
+        ...declaredLog === undefined ? {} : { log: declaredLog }
       });
     },
-    describe: () => describeRegistry(name, extended, registry, provider),
+    describe: () => describeRegistry(name, extended, registry, defaultSlot !== undefined ? referenceOf(defaultSlot) : provider === undefined ? undefined : providerDescriptionOf2(provider), named, isLogFactory2(declaredLog) ? "opaque" : log?.settings),
     get started() {
       return started;
     },
@@ -3898,9 +4403,12 @@ function applicationOf2(settings) {
           setStartedApplication(application);
       })().then(() => application, async (error) => {
         starting = undefined;
-        if (provider !== undefined && isDeferredProvider(provider)) {
-          await stopProvider(provider);
+        for (const instance of allProviders) {
+          if (isDeferredProvider(instance))
+            await stopProvider(instance);
         }
+        if (isLogFactory2(declaredLog))
+          log?.set(undefined);
         throw error;
       });
       return starting;
@@ -3915,13 +4423,16 @@ function applicationOf2(settings) {
         });
       if (startedApplication() === application)
         setStartedApplication(undefined);
-      if (provider !== undefined)
-        await stopProvider(provider);
+      for (const instance of allProviders)
+        await stopProvider(instance);
+      await log?.flush();
+      if (isLogFactory2(declaredLog))
+        log?.set(undefined);
     },
     get(declaration) {
       if (isEnvironment2(declaration)) {
         if (!registeredEnvironments.has(declaration)) {
-          invalid5(name, "Expected an environment registered in the application.");
+          invalid7(name, "Expected an environment registered in the application.");
         }
         return declaration.load();
       }
@@ -3934,10 +4445,22 @@ function applicationOf2(settings) {
       if (isRepository2(declaration)) {
         return application.repository(declaration);
       }
-      return invalid5(name, "Expected a repository, use case, command, output or environment registered in the application.");
+      if (isProviderSlot2(declaration)) {
+        const instance = instances.get(declaration);
+        if (instance === undefined) {
+          invalid7(name, "Expected a provider of a storage registered in the application.");
+        }
+        return instance;
+      }
+      return invalid7(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);
   return application;
 }
 // src/core/blueprint/blueprint-plugin.ts
@@ -4021,7 +4544,7 @@ function outputValueOf2(value) {
 }
 
 // src/core/output/openapi-sink.ts
-var METHODS2 = ["get", "post", "put", "patch", "delete"];
+var METHODS3 = ["get", "post", "put", "patch", "delete"];
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4047,8 +4570,8 @@ function routeOptionsIssue2(options, where) {
       if (!isObject(entry) || onlyKeys(entry, ["method", "path"], "route")) {
         return `Expected ${where}.route["${id}"] to be { method?, path? }.`;
       }
-      if (entry.method !== undefined && !METHODS2.includes(entry.method)) {
-        return `Expected ${where}.route["${id}"].method to be one of ${METHODS2.join(", ")}.`;
+      if (entry.method !== undefined && !METHODS3.includes(entry.method)) {
+        return `Expected ${where}.route["${id}"].method to be one of ${METHODS3.join(", ")}.`;
       }
       if (entry.path !== undefined && !isPath(entry.path)) {
         return `Expected ${where}.route["${id}"].path to start with "/" and have no parameters or query.`;
@@ -4086,7 +4609,7 @@ function validate2(options) {
   }
   return routeOptionsIssue2({ basePath, route }, "openapi");
 }
-function invalid6(reason, source = "openapi") {
+function invalid8(reason, source = "openapi") {
   throw new InvalidOutputStage2({ source, details: { reason } });
 }
 function kebab(text) {
@@ -4098,7 +4621,7 @@ function operationRoutes2(operations, options, source = "openapi") {
   const ids = new Set(operations.map(({ id }) => id));
   for (const id of Object.keys(route)) {
     if (!ids.has(id)) {
-      invalid6(`${source}.route names the unknown operation "${id}".`, source);
+      invalid8(`${source}.route names the unknown operation "${id}".`, source);
     }
   }
   const routes = new Map;
@@ -4109,7 +4632,7 @@ function operationRoutes2(operations, options, source = "openapi") {
     const path = base + (chosen.path ?? `/${kebab(operation.command)}/${kebab(operation.name)}`);
     const key = `${method} ${path}`;
     if (taken.has(key)) {
-      invalid6(`Two operations are routed to ${method.toUpperCase()} ${path}.`, source);
+      invalid8(`Two operations are routed to ${method.toUpperCase()} ${path}.`, source);
     }
     taken.add(key);
     routes.set(operation.id, { method, path });
@@ -4215,7 +4738,7 @@ function parametersOf(operation, schema) {
     const field = operation.input.properties[name];
     const type = property.type;
     if (!isProperty2(field) || type === "object" || type === "array" || Array.isArray(type) && type.some((t) => t === "object" || t === "array")) {
-      invalid6(`${operation.id} uses a ${"get/delete"} route, whose input becomes query parameters, but "${name}" is not a scalar; route it with method "post".`);
+      invalid8(`${operation.id} uses a ${"get/delete"} route, whose input becomes query parameters, but "${name}" is not a scalar; route it with method "post".`);
     }
     const { description, ...rest } = property;
     return {
@@ -4242,10 +4765,10 @@ var openapi2 = sinkOf2({
     for (const record of records) {
       const name = record.name;
       if (!/^[A-Za-z0-9._-]+$/.test(name) || name === "Problem") {
-        invalid6(`The record class "${name}" cannot be a component name; give the class a name that is not "Problem".`);
+        invalid8(`The record class "${name}" cannot be a component name; give the class a name that is not "Problem".`);
       }
       if (classes.has(name)) {
-        invalid6(`Two record classes are named "${name}"; rename one.`);
+        invalid8(`Two record classes are named "${name}"; rename one.`);
       }
       classes.set(name, record);
       models[name] = record;
@@ -4265,7 +4788,7 @@ var openapi2 = sinkOf2({
       const { method, path } = routes.get(operation.id);
       const operationId = operation.id.replaceAll(".", "_");
       if (operationIds.has(operationId)) {
-        invalid6(`The operationId "${operationId}" is produced twice.`);
+        invalid8(`The operationId "${operationId}" is produced twice.`);
       }
       operationIds.add(operationId);
       const slot = paths[path] ?? {};
@@ -5016,4 +5539,4 @@ var entityOf2 = entityBuilderOf2({
 var recordOf2 = recordBuilderOf2(StdRecordPlugins2);
 // src/std/stages.ts
 var StdStages2 = stageCatalogOf2(select2, openapi2);
-export { InvalidEnvironment2, environmentOf2, isEnvironment2, guard2, 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, InvalidApplicationDeclaration2, DuplicateApplicationDeclaration2, ApplicationConflict2, UnregisteredApplicationReference2, UnregisteredRepositoryDependency2, UnregisteredUseCaseDependency2, ApplicationNotStarted2, ApplicationAlreadyStarted2, InvalidApplicationEnvironment2, InvalidOpenAPIModel2, InvalidOutputStage2, DuplicateOperation2, toOpenAPI2, transformOf2, sinkOf2, stageDescriptionOf2, stageKindOf2, stageCatalogOf2, operationOf2, outputOf2, isOutput2, useApplication2, resetApplication2, providerFrom2, 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 };
+export { InvalidEnvironment2, environmentOf2, isEnvironment2, guard2, InvalidApplicationDeclaration2, DuplicateApplicationDeclaration2, ApplicationConflict2, UnregisteredApplicationReference2, UnregisteredRepositoryDependency2, UnregisteredUseCaseDependency2, ApplicationNotStarted2, ProviderNotBound2, 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, providersOf2, isProviderSlot2, isProviderStorage2, 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 };