@afora/core 0.0.4 → 0.0.5

package/dist/core/application/exceptions.d.ts

@@ -40,6 +40,15 @@ export declare const ApplicationNotStarted: import("../../index.js").DeclaredExc
     /** The application, or none when `useApplication()` found none started. */
     readonly application?: string;
 }>;
+/**
+ * A repository read or wrote through a provider of `providersOf` made by
+ * `providerFrom` outside an application: an application that registers the
+ * storage makes it on start, and its bound repositories use it.
+ */
+export declare const ProviderNotBound: import("../../index.js").DeclaredExceptionClass<{
+    /** The key of the provider in its storage. */
+    readonly provider: string;
+}>;
 /**
  * `app.start()` was called while another application is the started one of
  * the process; `start({ replace: true })` stops it and takes its place.

package/dist/core/application/providers.d.ts

@@ -0,0 +1,46 @@
+import type { IRepositoryProvider } from "../repository/types/repository.interface.js";
+import { Kind } from "../symbols/kind.js";
+import { type ProviderFactory } from "./start.js";
+/**
+ * One provider of a storage made by `providersOf`, e.g. `Providers.audit`:
+ * what a repository (`repositoryOf({ provider: Providers.audit })`) or an
+ * application (`provider: Providers.main`) names. Each application that
+ * registers the storage reads and writes through its own instance of it.
+ */
+export type ProviderSlot<Key extends string = string> = IRepositoryProvider & {
+    readonly [Kind]: "provider-slot";
+    /** Its key in the storage. */
+    readonly key: Key;
+};
+/** The providers of `providersOf`, by key. */
+export type ProviderStorage<Keys extends string = string> = {
+    readonly [Key in Keys]: ProviderSlot<Key>;
+} & {
+    readonly [Kind]: "provider-storage";
+};
+/** What a slot stands for. */
+interface SlotEntry {
+    readonly key: string;
+    readonly storage: object;
+    readonly value: IRepositoryProvider | ProviderFactory;
+}
+/**
+ * Named providers, declared once in a module of their own so that
+ * repositories can name one before any application exists, e.g.
+ * `const Providers = providersOf({ main: providerFrom(Database, ...), audit: auditProvider() })`,
+ * then `repositoryOf({ ..., provider: Providers.audit })` and
+ * `applicationOf({ providers: Providers, provider: Providers.main, ... })`.
+ * Each value is a provider or a factory of `providerFrom`; an application
+ * that registers the storage makes each factory on `start()`, its own
+ * instance (an application that extends it shares them).
+ */
+export declare function providersOf<const Entries extends Readonly<Record<string, IRepositoryProvider | ProviderFactory>>>(entries: Entries): ProviderStorage<keyof Entries & string>;
+/** Whether `value` is a provider of a storage made by `providersOf`. */
+export declare function isProviderSlot(value: unknown): value is ProviderSlot;
+/** Whether `value` is a storage made by `providersOf`. */
+export declare function isProviderStorage(value: unknown): value is ProviderStorage;
+/** The slots of `storage`, in the order of its keys. @internal */
+export declare function slotsOf(storage: ProviderStorage): readonly ProviderSlot[];
+/** What `slot` stands for. @internal */
+export declare function slotEntry(slot: ProviderSlot): SlotEntry;
+export {};

package/dist/core/application/types/application.interface.d.ts

@@ -9,6 +9,7 @@ import type { AnyRepository, IRepositoryProvider } from "../../repository/types/
 import type { Kind } from "../../symbols/kind.js";
 import type { UseCaseStepDescription } from "../../use-case/steps/types/steps.interface.js";
 import type { AnyExceptionClass, AnyUseCaseClass } from "../../use-case/use-case.js";
+import type { ProviderSlot, ProviderStorage } from "../providers.js";
 import type { LogFactory, ProviderFactory } from "../start.js";
 type Named<Value> = Readonly<Record<string, Value>>;
 /** The declarations of an application, by name, one collection for each kind. */
@@ -53,9 +54,18 @@ export interface ApplicationSettings<Name extends string, Extended extends reado
      * The provider of the repositories that did not declare one; the
      * repositories of the application read and write through it. With
      * `providerFrom`, it is made by `app.start()` from the variables of its
-     * environments, and calls before that throw `ApplicationNotStarted`.
+     * environments, and calls before that throw `ApplicationNotStarted`. A
+     * provider of `providers` (`Providers.main`) names the instance this
+     * application makes of it.
      */
     readonly provider?: IRepositoryProvider | ProviderFactory;
+    /**
+     * Named providers made by `providersOf`, which repositories name
+     * (`repositoryOf({ provider: Providers.audit })`). The application makes
+     * its own instance of each `providerFrom` on `start()` and binds the
+     * repositories to it; an application that extends it shares them.
+     */
+    readonly providers?: ProviderStorage;
     /**
      * How it logs: the providers its lines go to and the lowest level kept.
      * Use cases, commands and repository calls of the application are logged
@@ -163,6 +173,8 @@ export interface IApplication<Name extends string, Collections extends Applicati
     get<UseCase extends AnyUseCaseClass>(useCase: UseCase): UseCase;
     /** The bound version of a repository registered in the application. */
     get<Repository extends AnyRepository>(repository: Repository): Repository;
+    /** The instance this application reads and writes through for a provider of its `providers`. */
+    get(provider: ProviderSlot): IRepositoryProvider;
     /** Whether `start()` completed and `stop()` was not called since. */
     readonly started: boolean;
 }
@@ -345,13 +357,22 @@ export interface LogDescription {
         readonly kind: "opaque";
     })[];
 }
+/** How `describe` names a provider of `providersOf`: by its key. */
+export interface ProviderReference {
+    readonly kind: "ref";
+    readonly key: string;
+}
 /** The graph `describe` gives: every declaration by name, with its origin in `from`. */
 export interface ApplicationDescription {
     readonly name: string;
     /** The names of the applications it extends directly. */
     readonly extends: readonly string[];
     /** The provider of the application (or of the last extended one), present only when configured. */
-    readonly provider?: ProviderDescription;
+    readonly provider?: ProviderDescription | ProviderReference;
+    /** Its providers of `providersOf` (inherited ones included), by key; present only when it has some. */
+    readonly providers?: Readonly<Record<string, ProviderDescription & {
+        readonly from: string;
+    }>>;
     /** Its `log` (or the one of the last extended application), present only when configured. */
     readonly log?: LogDescription | {
         readonly kind: "opaque";
@@ -378,8 +399,8 @@ export interface ApplicationDescription {
         readonly relations: readonly string[];
         /** The names of its `environmentDependencies`. */
         readonly environments: readonly string[];
-        /** Its own provider, present only when it declared one. */
-        readonly provider?: ProviderDescription;
+        /** Its own provider, present only when it declared one; a provider of `providersOf` by its key. */
+        readonly provider?: ProviderDescription | ProviderReference;
     }>>;
     readonly useCases: Readonly<Record<string, UseCaseDescription>>;
     readonly commands: Readonly<Record<string, CommandDescription>>;

package/dist/core/repository/state.d.ts

@@ -39,6 +39,7 @@ export interface RepositoryInspection {
 export declare function inspectRepository(repository: unknown): RepositoryInspection | undefined;
 /**
  * A repository sharing the declaration of `repository` that reads and writes
- * through `provider`, unless it declared a provider of its own.
+ * through `provider`, unless it declared a provider of its own; a declared
+ * provider found in `instances` is replaced by its value.
  */
-export declare function bindRepository<Repository extends object>(repository: Repository, provider: IRepositoryProvider): Repository;
+export declare function bindRepository<Repository extends object>(repository: Repository, provider: IRepositoryProvider | undefined, instances?: ReadonlyMap<object, IRepositoryProvider>): Repository;

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

@@ -60,6 +60,7 @@ __export(exports_exceptions4, {
   DuplicateApplicationDeclaration: () => DuplicateApplicationDeclaration2,
   InvalidApplicationDeclaration: () => InvalidApplicationDeclaration2,
   InvalidApplicationEnvironment: () => InvalidApplicationEnvironment2,
+  ProviderNotBound: () => ProviderNotBound2,
   UnregisteredApplicationReference: () => UnregisteredApplicationReference2,
   UnregisteredRepositoryDependency: () => UnregisteredRepositoryDependency2,
   UnregisteredUseCaseDependency: () => UnregisteredUseCaseDependency2
@@ -268,6 +269,13 @@ var ApplicationNotStarted2 = exceptionOf2({
     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",
@@ -1083,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);
 }
 
@@ -2403,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) => {
@@ -2437,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,
@@ -3352,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",
@@ -3367,6 +3475,11 @@ var KEYS = [
 ];
 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",
@@ -3382,7 +3495,7 @@ var KIND_OF = {
 function isApplication2(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "application";
 }
-function invalid6(source, reason) {
+function invalid7(source, reason) {
   throw new InvalidApplicationDeclaration2({ source, details: { reason } });
 }
 function isOfKind(collection, value) {
@@ -3467,7 +3580,7 @@ function resolve(settings) {
   for (const other of settings.extends ?? []) {
     const resolved = internals.get(other);
     if (!resolved)
-      invalid6(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);
@@ -3478,15 +3591,15 @@ function resolve(settings) {
     if (declared === undefined)
       continue;
     if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
-      invalid6(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)) {
-        invalid6(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) {
-        invalid6(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
+        invalid7(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
       }
       add({
         collection,
@@ -3607,7 +3720,7 @@ function validateOutputs(source, registry) {
   for (const entry of registry.outputs.values()) {
     const output = entry.value;
     if (!output.outputName) {
-      invalid6(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))
@@ -3809,7 +3922,7 @@ function recordDescriptionOf(entry, scope) {
     plugins
   };
 }
-function describeRegistry(name, extended, registry, provider, log) {
+function describeRegistry(name, extended, registry, provider, named, log) {
   const scope = {
     properties: referencesOf(registry, "properties"),
     blueprints: referencesOf(registry, "blueprints"),
@@ -3849,7 +3962,19 @@ function describeRegistry(name, extended, registry, provider, log) {
   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,
@@ -3882,7 +4007,9 @@ function describeRegistry(name, extended, registry, provider, log) {
         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) => {
@@ -3970,35 +4097,101 @@ function describeRegistry(name, extended, registry, provider, log) {
 function applicationOf2(settings) {
   const { name } = settings ?? {};
   if (typeof name !== "string" || name === "") {
-    invalid6("applicationOf", "Expected a name.");
+    invalid7("applicationOf", "Expected a name.");
   }
   const extended = settings.extends ?? [];
   if (!Array.isArray(extended) || !extended.every(isApplication2)) {
-    invalid6(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") {
-    invalid6(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);
@@ -4006,13 +4199,14 @@ function applicationOf2(settings) {
     log?.set(checkLogSettings(declaredLog));
   }
   const logger = log?.logger;
-  const rebinds = provider !== undefined || logger !== undefined;
+  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;
@@ -4066,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;
@@ -4127,9 +4321,11 @@ function applicationOf2(settings) {
     if (isLogFactory2(declaredLog)) {
       log?.set(checkLogSettings(await declaredLog.create(context)));
     }
-    if (provider !== undefined && isDeferredProvider(provider)) {
-      const made = await startDeferred(provider, context);
-      checkTransactions(name, made, Object.entries(commands).filter(([, command]) => command.transaction && commandTransactionProvider(command) === provider).map(([key]) => key));
+    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;
   };
@@ -4153,25 +4349,25 @@ function applicationOf2(settings) {
     exceptions: collection("exceptions"),
     useCase(useCase) {
       if (!boundUseCaseOf.has(useCase)) {
-        invalid6(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)) {
-        invalid6(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)) {
-        invalid6(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)) {
-        invalid6(name, "Expected a repository registered in the application.");
+        invalid7(name, "Expected a repository registered in the application.");
       }
       return bound.get(repository);
     },
@@ -4179,11 +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, isLogFactory2(declaredLog) ? "opaque" : log?.settings),
+    describe: () => describeRegistry(name, extended, registry, defaultSlot !== undefined ? referenceOf(defaultSlot) : provider === undefined ? undefined : providerDescriptionOf2(provider), named, isLogFactory2(declaredLog) ? "opaque" : log?.settings),
     get started() {
       return started;
     },
@@ -4207,8 +4403,9 @@ 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);
@@ -4226,8 +4423,8 @@ 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);
@@ -4235,7 +4432,7 @@ function applicationOf2(settings) {
     get(declaration) {
       if (isEnvironment2(declaration)) {
         if (!registeredEnvironments.has(declaration)) {
-          invalid6(name, "Expected an environment registered in the application.");
+          invalid7(name, "Expected an environment registered in the application.");
         }
         return declaration.load();
       }
@@ -4248,10 +4445,20 @@ function applicationOf2(settings) {
       if (isRepository2(declaration)) {
         return application.repository(declaration);
       }
-      return invalid6(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;
@@ -4337,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);
 }
@@ -4363,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.`;
@@ -4402,7 +4609,7 @@ function validate2(options) {
   }
   return routeOptionsIssue2({ basePath, route }, "openapi");
 }
-function invalid7(reason, source = "openapi") {
+function invalid8(reason, source = "openapi") {
   throw new InvalidOutputStage2({ source, details: { reason } });
 }
 function kebab(text) {
@@ -4414,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)) {
-      invalid7(`${source}.route names the unknown operation "${id}".`, source);
+      invalid8(`${source}.route names the unknown operation "${id}".`, source);
     }
   }
   const routes = new Map;
@@ -4425,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)) {
-      invalid7(`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 });
@@ -4531,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")) {
-      invalid7(`${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 {
@@ -4558,10 +4765,10 @@ var openapi2 = sinkOf2({
     for (const record of records) {
       const name = record.name;
       if (!/^[A-Za-z0-9._-]+$/.test(name) || name === "Problem") {
-        invalid7(`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)) {
-        invalid7(`Two record classes are named "${name}"; rename one.`);
+        invalid8(`Two record classes are named "${name}"; rename one.`);
       }
       classes.set(name, record);
       models[name] = record;
@@ -4581,7 +4788,7 @@ var openapi2 = sinkOf2({
       const { method, path } = routes.get(operation.id);
       const operationId = operation.id.replaceAll(".", "_");
       if (operationIds.has(operationId)) {
-        invalid7(`The operationId "${operationId}" is produced twice.`);
+        invalid8(`The operationId "${operationId}" is produced twice.`);
       }
       operationIds.add(operationId);
       const slot = paths[path] ?? {};
@@ -5332,4 +5539,4 @@ var entityOf2 = entityBuilderOf2({
 var recordOf2 = recordBuilderOf2(StdRecordPlugins2);
 // src/std/stages.ts
 var StdStages2 = stageCatalogOf2(select2, openapi2);
-export { InvalidEnvironment2, environmentOf2, isEnvironment2, guard2, InvalidApplicationDeclaration2, DuplicateApplicationDeclaration2, ApplicationConflict2, UnregisteredApplicationReference2, UnregisteredRepositoryDependency2, UnregisteredUseCaseDependency2, ApplicationNotStarted2, ApplicationAlreadyStarted2, InvalidApplicationEnvironment2, useApplication2, resetApplication2, InvalidLogDeclaration2, LogLevels2, logProviderOf2, consoleLogProvider2, jsonLogProvider2, memoryLogProvider2, Logger2, ReservedEntityKey2, ImmutableEntityKey2, DeletedEntity2, entityBuilderOf2, isEntityClass2, isEntity2, eventOf2, ENTITY_IDENTITY_KEYS2, RESERVED_ENTITY_KEYS2, EntityUniqueKeys2, AbstractEntity2, InvalidRepositoryQuery2, InvalidRepositoryDeclaration2, InvalidRepositoryEntity2, InvalidRepositoryData2, RepositoryUniqueViolation2, RepositoryEntityNotFound2, providerOf2, providerDescriptionOf2, inMemoryProvider2, AbstractRepository2, repositoryOf2, RepositoryOf2, isRepository2, InvalidUseCaseStep2, InvalidUseCaseDeclaration2, UseCaseAlreadyExecuted2, InvalidUseCaseDependencies2, AbstractUseCase2, useCaseOf2, isUseCaseClass2, isUseCase2, InvalidCommandDeclaration2, UnknownCommandOperation2, InvalidCommandContext2, InvalidCommandEnvironment2, CommandEventFailed2, commandOf2, isCommand2, InvalidOpenAPIModel2, InvalidOutputStage2, DuplicateOperation2, toOpenAPI2, transformOf2, sinkOf2, stageDescriptionOf2, stageKindOf2, stageCatalogOf2, operationOf2, outputOf2, isOutput2, providerFrom2, logFrom2, isLogFactory2, isProviderFactory2, isApplication2, applicationOf2, blueprintPluginOf2, statusOf2, PROBLEM_MEDIA_TYPE2, problemOf2, outputValueOf2, routeOptionsIssue2, operationRoutes2, openapi2, select2, recordPluginCatalogOf2, Email2, Phone2, Url2, Ip2, enumOf2, SchemaProperty2, PasswordHasherRequired2, SyncVerifyUnsupported2, configure2, resetRuntime2, Id2, Slug2, PASSWORD_MIN_LENGTH2, PASSWORD_MAX_LENGTH2, PASSWORD_SPECIAL_CHARACTERS2, isPasswordHash2, passwordIssues2, Password2, StringProperty2, Text2, NumberProperty2, Integer2, BooleanProperty2, DateTime2, DateProperty2, CreatedAt2, UpdatedAt2, DeletedAt2, Std2, blueprintOf2, Publishable2, Archivable2, Taggable2, Ownable2, Authenticatable2, StdRecordPlugins2, entityOf2, recordOf2, StdStages2 };
+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 };

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 export { applicationOf, isApplication } from "./core/application/application.js";
-export { ApplicationAlreadyStarted, ApplicationConflict, ApplicationNotStarted, DuplicateApplicationDeclaration, InvalidApplicationDeclaration, InvalidApplicationEnvironment, UnregisteredApplicationReference, UnregisteredRepositoryDependency, UnregisteredUseCaseDependency, } from "./core/application/exceptions.js";
+export { ApplicationAlreadyStarted, ApplicationConflict, ApplicationNotStarted, DuplicateApplicationDeclaration, InvalidApplicationDeclaration, InvalidApplicationEnvironment, ProviderNotBound, UnregisteredApplicationReference, UnregisteredRepositoryDependency, UnregisteredUseCaseDependency, } from "./core/application/exceptions.js";
+export { isProviderSlot, isProviderStorage, type ProviderSlot, type ProviderStorage, providersOf, } from "./core/application/providers.js";
 export { type Register, type RegisteredApplication, resetApplication, useApplication, } from "./core/application/registry.js";
 export { isLogFactory, isProviderFactory, type LogFactory, logFrom, type ProviderFactory, providerFrom, } from "./core/application/start.js";
-export type { AnyApplication, ApplicationCollections, ApplicationContext, ApplicationDescription, ApplicationSettings, ApplicationStartOptions, CommandDescription, ExceptionDescription, FieldDescription, FieldsDescription, IApplication, LogDescription, OutputDescription, PropertyDescription, PropertyLineageDescription, PropertyReference, RecordDescription, UseCaseDependencyDescription, UseCaseDescription, } from "./core/application/types/application.interface.js";
+export type { AnyApplication, ApplicationCollections, ApplicationContext, ApplicationDescription, ApplicationSettings, ApplicationStartOptions, CommandDescription, ExceptionDescription, FieldDescription, FieldsDescription, IApplication, LogDescription, OutputDescription, PropertyDescription, PropertyLineageDescription, PropertyReference, ProviderReference, RecordDescription, UseCaseDependencyDescription, UseCaseDescription, } from "./core/application/types/application.interface.js";
 export { blueprintBuilderOf } from "./core/blueprint/blueprint.js";
 export { blueprintPluginOf } from "./core/blueprint/blueprint-plugin.js";
 export { ReservedBlueprintKey, UndeclaredBlueprintProperty, } from "./core/blueprint/exceptions.js";

package/dist/index.js

@@ -10,6 +10,7 @@ import {
   UnregisteredRepositoryDependency2,
   UnregisteredUseCaseDependency2,
   ApplicationNotStarted2,
+  ProviderNotBound2,
   ApplicationAlreadyStarted2,
   InvalidApplicationEnvironment2,
   useApplication2,
@@ -76,6 +77,9 @@ import {
   logFrom2,
   isLogFactory2,
   isProviderFactory2,
+  providersOf2,
+  isProviderSlot2,
+  isProviderStorage2,
   isApplication2,
   applicationOf2,
   blueprintPluginOf2,
@@ -127,7 +131,7 @@ import {
   entityOf2,
   recordOf2,
   StdStages2
-} from "./index-ewm6r4nw.js";
+} from "./index-8m80wjzf.js";
 import {
   isProperty2,
   schemaOf2,
@@ -239,6 +243,7 @@ export {
   Phone2 as Phone,
   PropertyRequired2 as PropertyRequired,
   PropertyStates2 as PropertyStates,
+  ProviderNotBound2 as ProviderNotBound,
   Publishable2 as Publishable,
   RESERVED_ENTITY_KEYS2 as RESERVED_ENTITY_KEYS,
   RESERVED_RECORD_KEYS2 as RESERVED_RECORD_KEYS,
@@ -299,6 +304,8 @@ export {
   isPasswordHash2 as isPasswordHash,
   isProperty2 as isProperty,
   isProviderFactory2 as isProviderFactory,
+  isProviderSlot2 as isProviderSlot,
+  isProviderStorage2 as isProviderStorage,
   isRecordClass2 as isRecordClass,
   isRecordPlugin2 as isRecordPlugin,
   isRepository2 as isRepository,
@@ -323,6 +330,7 @@ export {
   providerDescriptionOf2 as providerDescriptionOf,
   providerFrom2 as providerFrom,
   providerOf2 as providerOf,
+  providersOf2 as providersOf,
   recordBuilderOf2 as recordBuilderOf,
   recordFieldOf2 as recordFieldOf,
   recordOf2 as recordOf,

package/dist/testing/index.js

@@ -4,7 +4,7 @@ import {
   RepositoryEntityNotFound2,
   blueprintOf2,
   entityOf2
-} from "../index-ewm6r4nw.js";
+} from "../index-8m80wjzf.js";
 
 // src/testing/provider-contract.ts
 function contextOf(name = "Accounts") {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@afora/core",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"description": "Domain modeling on TypeBox: entities with invariants, repositories, use cases, sensitive data masking and layered exceptions, usable by any Standard Schema consumer.",
 	"keywords": [
 		"domain-driven-design",