@afora/core 0.0.4 → 0.0.6

package/dist/{index-ewm6r4nw.js → index-gbgc40xe.js}

@@ -9,6 +9,8 @@ import {
   isBlueprint2,
   isRecordClass2,
   recordFieldOf2,
+  recordNameOf2,
+  declaredRecordNameOf,
   isBlueprintList2,
   UNEXPECTED_ERROR2,
   Exception2,
@@ -40,7 +42,7 @@ import {
   exports_exceptions3,
   propertyOf2,
   blueprintBuilderOf2
-} from "./index-hn82hm31.js";
+} from "./index-3nd9bjnc.js";
 
 // src/core/environment/environment.ts
 var exports_environment = {};
@@ -60,6 +62,7 @@ __export(exports_exceptions4, {
   DuplicateApplicationDeclaration: () => DuplicateApplicationDeclaration2,
   InvalidApplicationDeclaration: () => InvalidApplicationDeclaration2,
   InvalidApplicationEnvironment: () => InvalidApplicationEnvironment2,
+  ProviderNotBound: () => ProviderNotBound2,
   UnregisteredApplicationReference: () => UnregisteredApplicationReference2,
   UnregisteredRepositoryDependency: () => UnregisteredRepositoryDependency2,
   UnregisteredUseCaseDependency: () => UnregisteredUseCaseDependency2
@@ -82,6 +85,7 @@ __export(exports_exceptions6, {
 // src/core/repository/exceptions.ts
 var exports_exceptions7 = {};
 __export(exports_exceptions7, {
+  InvalidRepositoryCursor: () => InvalidRepositoryCursor2,
   InvalidRepositoryData: () => InvalidRepositoryData2,
   InvalidRepositoryDeclaration: () => InvalidRepositoryDeclaration2,
   InvalidRepositoryEntity: () => InvalidRepositoryEntity2,
@@ -268,6 +272,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",
@@ -632,7 +643,7 @@ function clockOf(entity) {
 function assertAlive(entity) {
   if (entity.isDeleted) {
     throw new DeletedEntity2({
-      source: entity.constructor.name,
+      source: recordNameOf2(entity.constructor),
       details: { id: identityOf(entity).id }
     });
   }
@@ -682,7 +693,7 @@ class AbstractEntity2 extends AbstractRecord2 {
     const name = String(key);
     if (ENTITY_IDENTITY_KEYS2.includes(name)) {
       throw new ImmutableEntityKey2({
-        source: this.constructor.name,
+        source: recordNameOf2(this.constructor),
         details: { key: name }
       });
     }
@@ -707,6 +718,13 @@ var InvalidRepositoryQuery2 = exceptionOf2({
   name: "InvalidRepositoryQuery",
   message: ({ reason }) => reason
 });
+var InvalidRepositoryCursor2 = exceptionOf2({
+  layer: "repository" /* Repository */,
+  name: "InvalidRepositoryCursor",
+  message: ({
+    reason
+  }) => reason
+});
 var InvalidRepositoryDeclaration2 = exceptionOf2({
   layer: "repository" /* Repository */,
   name: "InvalidRepositoryDeclaration",
@@ -733,6 +751,90 @@ var RepositoryEntityNotFound2 = exceptionOf2({
   message: ({ id }, source) => `"${source}" holds no entity of id "${id}".`
 });
 
+// src/core/repository/cursor.ts
+var VERSION = 1;
+var signatureOf = (orders) => orders.map(({ key, direction = "asc" }) => `${key}:${direction}`);
+function pack(value) {
+  if (value === undefined || value === null)
+    return null;
+  if (value instanceof Date)
+    return { d: value.toISOString() };
+  if (typeof value === "bigint")
+    return { b: value.toString() };
+  return value;
+}
+function unpack(value) {
+  if (value === null)
+    return;
+  if (["string", "number", "boolean"].includes(typeof value))
+    return value;
+  if (typeof value === "object") {
+    const { d, b } = value;
+    const keys = Object.keys(value);
+    if (keys.length === 1 && typeof d === "string") {
+      const date = new Date(d);
+      if (!Number.isNaN(date.getTime()))
+        return date;
+    }
+    if (keys.length === 1 && typeof b === "string" && /^-?\d+$/.test(b))
+      return BigInt(b);
+  }
+  throw new SyntaxError("value");
+}
+function encodeText(text) {
+  let binary = "";
+  for (const byte of new TextEncoder().encode(text))
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function decodeText(encoded) {
+  if (!/^[A-Za-z0-9_-]+$/.test(encoded))
+    throw new SyntaxError("alphabet");
+  const binary = atob(encoded.replaceAll("-", "+").replaceAll("_", "/"));
+  return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+}
+function encodeCursor(orders, row) {
+  const payload = {
+    v: VERSION,
+    k: signatureOf(orders),
+    a: orders.map(({ key }) => pack(row[key]))
+  };
+  return encodeText(JSON.stringify(payload));
+}
+function decodeCursor(source, orders, cursor) {
+  const fail = (reason) => {
+    throw new InvalidRepositoryCursor2({
+      source,
+      details: {
+        reason,
+        issues: [
+          { code: "invalid_value", path: ["after"], message: reason, source }
+        ]
+      }
+    });
+  };
+  if (typeof cursor !== "string" || cursor === "")
+    return fail("Expected a cursor given by findCursor.");
+  let payload;
+  let values;
+  try {
+    payload = JSON.parse(decodeText(cursor));
+    if (typeof payload !== "object" || payload === null)
+      throw new SyntaxError;
+    if (!Array.isArray(payload.k) || !Array.isArray(payload.a))
+      throw new SyntaxError;
+    values = payload.a.map(unpack);
+  } catch {
+    return fail("The cursor is not one given by findCursor.");
+  }
+  if (payload.v !== VERSION)
+    return fail("The cursor was made by another version.");
+  const expected = signatureOf(orders);
+  if (payload.k?.length !== expected.length || values.length !== expected.length || expected.some((key, index) => payload.k?.[index] !== key))
+    return fail("The cursor was made for another orderBy.");
+  return values;
+}
+
 // src/core/json.ts
 function frozenJson(value, subject, fail, seen = new Set) {
   if (value === null || typeof value === "string" || typeof value === "boolean")
@@ -790,7 +892,8 @@ function plain(value) {
 function isMembership(value) {
   return plain(value) && Object.keys(value).length === 1 && Array.isArray(value.in);
 }
-function prepareQuery(context, input = {}, map = (_key, value) => value) {
+var QUERY_OPTIONS = ["where", "orderBy", "limit", "offset", "withDeleted"];
+function prepareQuery(context, input = {}, map = (_key, value) => value, options = QUERY_OPTIONS) {
   const fail = (reason) => {
     throw new InvalidRepositoryQuery2({
       source: context.name,
@@ -800,7 +903,7 @@ function prepareQuery(context, input = {}, map = (_key, value) => value) {
   if (!plain(input))
     return fail("Expected a query object.");
   for (const key of Object.keys(input))
-    if (!["where", "orderBy", "limit", "offset", "withDeleted"].includes(key))
+    if (!options.includes(key))
       fail(`Unknown query option "${key}".`);
   const properties = context.entity.blueprint.properties;
   const keyOf = (key) => {
@@ -882,26 +985,32 @@ function compareScalars(a, b) {
   ];
   return x < y ? -1 : x > y ? 1 : 0;
 }
+function compareRows(orders, a, b) {
+  for (const { key, direction } of orders) {
+    const [x, y] = [a[key], b[key]];
+    const [missingX, missingY] = [
+      x === undefined || x === null,
+      y === undefined || y === null
+    ];
+    let result = missingX || missingY ? Number(!missingX) - Number(!missingY) : compareScalars(x, y);
+    if (direction === "desc")
+      result = -result;
+    if (result !== 0)
+      return result;
+  }
+  return 0;
+}
 function orderRows(rows, query) {
   const orders = query.orderBy ?? [];
-  return [...rows].sort((a, b) => {
-    for (const { key, direction } of orders) {
-      const [x, y] = [a[key], b[key]];
-      const [missingX, missingY] = [
-        x === undefined || x === null,
-        y === undefined || y === null
-      ];
-      let result = missingX || missingY ? Number(!missingX) - Number(!missingY) : compareScalars(x, y);
-      if (direction === "desc")
-        result = -result;
-      if (result !== 0)
-        return result;
-    }
-    return 0;
-  });
+  return [...rows].sort((a, b) => compareRows(orders, a, b));
+}
+function rowsAfter(rows, orders, after) {
+  const position = Object.fromEntries(orders.map(({ key }, index) => [key, after[index]]));
+  return rows.filter((row) => compareRows(orders, row, position) > 0);
 }
 function selectRows(rows, query) {
-  const matched = orderRows([...rows].filter((data) => matchesQuery(data, query)), query);
+  const ordered = orderRows([...rows].filter((data) => matchesQuery(data, query)), query);
+  const matched = query.after === undefined ? ordered : rowsAfter(ordered, query.orderBy ?? [], query.after);
   const start = query.offset ?? 0;
   return matched.slice(start, query.limit === undefined ? undefined : start + query.limit);
 }
@@ -953,7 +1062,7 @@ function scopeOf(initial, root) {
     }
   };
   const provider = {
-    capabilities: Object.freeze({ transactions: true }),
+    capabilities: Object.freeze({ transactions: true, keyset: true }),
     findOne: (context, query = {}) => whenIdle(() => {
       const [first] = selectRows(tableOf(context).values(), {
         ...query,
@@ -1083,31 +1192,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);
 }
 
@@ -1185,7 +1294,7 @@ function relationsOf(name, entity, relations) {
     if (!state)
       return invalid("Expected relations made by repositoryOf.");
     if (related.some((other) => other.entity === state.entity)) {
-      return invalid(`Relation "${state.entity.name}" is duplicated.`);
+      return invalid(`Relation "${recordNameOf2(state.entity)}" is duplicated.`);
     }
     if (typeof state.provider.findMany !== "function") {
       return invalid(`The provider of "${state.name}" has no "findMany" to load it.`);
@@ -1198,10 +1307,10 @@ function relationsOf(name, entity, relations) {
     const matches = related.filter((state) => state.entity === target || state.entity.prototype instanceof target);
     const exact = matches.find((state) => state.entity === target);
     if (!exact && matches.length === 0) {
-      return invalid(`Missing relation: no repository of "${target.name}".`);
+      return invalid(`Missing relation: no repository of "${recordNameOf2(target)}".`);
     }
     if (!exact && matches.length > 1) {
-      return invalid(`Relation "${target.name}" matches more than one repository.`);
+      return invalid(`Relation "${recordNameOf2(target)}" matches more than one repository.`);
     }
     const state = exact ?? matches[0];
     map.set(target, state);
@@ -1209,7 +1318,7 @@ function relationsOf(name, entity, relations) {
   }
   for (const state of related) {
     if (!used.has(state)) {
-      return invalid(`Relation "${state.entity.name}" is not held by ${entity.name}.`);
+      return invalid(`Relation "${recordNameOf2(state.entity)}" is not held by ${recordNameOf2(entity)}.`);
     }
   }
   return map;
@@ -1360,6 +1469,44 @@ var findPage = action(async (self, query) => {
   ]);
   return { items: await self.hydrateMany(rows), total, limit, offset };
 });
+var CURSOR_OPTIONS = ["where", "orderBy", "limit", "withDeleted", "after"];
+var findCursor = action(async (self, query = {}) => {
+  const { context } = self;
+  const fail = (reason) => {
+    throw new InvalidRepositoryQuery2({
+      source: context.name,
+      details: { reason }
+    });
+  };
+  const prepared = prepareQuery(context, query, (key, value) => queryValueOf(context, key, value), CURSOR_OPTIONS);
+  const { after } = query;
+  const { where, limit = 20 } = prepared;
+  if (limit < 1)
+    fail("Expected a positive integer for limit.");
+  const withDeleted = prepared.withDeleted ?? stateOf(self).deletion === "hard";
+  const declared = prepared.orderBy ?? [];
+  const orderBy = declared.some(({ key }) => key === "id") ? declared : [...declared, { key: "id", direction: "asc" }];
+  for (const { key } of orderBy) {
+    if (context.entity.options.sensitive.includes(key))
+      fail(`"${key}" is sensitive and cannot order a cursor.`);
+  }
+  if (self.provider.capabilities?.keyset !== true)
+    fail("The provider does not read by cursor (capabilities.keyset).");
+  const rows = await self.provider.findMany(context, {
+    where,
+    orderBy,
+    withDeleted,
+    limit: limit + 1,
+    ...after === undefined ? {} : { after: decodeCursor(context.name, orderBy, after) }
+  });
+  const page = rows.slice(0, limit);
+  const last = page.at(-1);
+  return {
+    items: await self.hydrateMany(page),
+    limit,
+    next: rows.length > limit && last !== undefined ? encodeCursor(orderBy, last) : undefined
+  };
+});
 var create = action(async (self, input) => {
   const { entity: Entity } = self.context;
   const entity = input instanceof Entity ? input : new Entity(input);
@@ -1404,7 +1551,8 @@ var NEEDS = {
   count: ["count"],
   findMany: ["findMany"],
   exists: ["findOne"],
-  findPage: ["findMany", "count"]
+  findPage: ["findMany", "count"],
+  findCursor: ["findMany"]
 };
 function capitalize(key) {
   return `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
@@ -1430,7 +1578,7 @@ function repositoryOf2(settings) {
   if (!isEntityClass2(entity) || !(EntityUniqueKeys2 in entity)) {
     invalid3("repositoryOf", "Expected an entity class made by entityOf.");
   }
-  const name = `${entity.name}Repository`;
+  const name = `${recordNameOf2(entity)}Repository`;
   const deletion = settings.deletion ?? "hard";
   if (deletion !== "hard" && deletion !== "soft") {
     invalid3(name, 'Expected deletion to be "hard" or "soft".');
@@ -1460,13 +1608,14 @@ function repositoryOf2(settings) {
   methods.set("findMany", ["findMany", findMany]);
   methods.set("exists", ["exists", exists]);
   methods.set("findPage", ["findPage", findPage]);
+  methods.set("findCursor", ["findCursor", findCursor]);
 
   class DeclaredRepository extends AbstractRepository2 {
   }
   for (const name_ of new Set(actions)) {
     const method = typeof name_ === "string" ? methods.get(name_) : undefined;
     if (!method)
-      invalid3(name, unknownAction(entity.name, String(name_), methods));
+      invalid3(name, unknownAction(recordNameOf2(entity), String(name_), methods));
     const [kind, implementation] = method;
     const needs = deletion === "soft" && kind === "delete" ? ["findOne", "update"] : NEEDS[kind] ?? [];
     for (const need of needs) {
@@ -1758,7 +1907,7 @@ var ENSURE_KINDS = new Set([
   "true",
   "false"
 ]);
-var READ_ACTION = /^(?:findBy.+|findManyBy.+|findMany|exists|findPage|count)$/;
+var READ_ACTION = /^(?:findBy.+|findManyBy.+|findMany|exists|findPage|findCursor|count)$/;
 var WRITE_ACTIONS = new Set(["create", "update", "delete"]);
 function validateSteps(declaration, steps) {
   const { name } = declaration;
@@ -2060,7 +2209,7 @@ function methodNamesOf(repository) {
 }
 function bindRepository2(repository, overrides, state, source) {
   const Entity = repository.entity;
-  const repositoryName = Entity.name;
+  const repositoryName = recordNameOf2(Entity);
   const bound = Object.create(null);
   const view = new Proxy(Object.create(repository), {
     get: (_target, key, receiver) => {
@@ -2403,7 +2552,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 +2586,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 +3501,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 +3616,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 +3636,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 +3721,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 +3732,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;
+      const declaredName = collection === "useCases" ? value.useCaseName : collection === "commands" ? value.commandName : collection === "outputs" ? value.outputName : collection === "exceptions" ? value.name : collection === "records" || collection === "entities" ? declaredRecordNameOf(value) ?? name : name;
       if (declaredName !== name) {
-        invalid6(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
+        invalid7(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
       }
       add({
         collection,
@@ -3539,7 +3793,7 @@ function validate(source, registry) {
           source,
           details: {
             holder: `${KIND_OF[collection]} "${entry.name}"`,
-            reference: `${isEntityClass2(record) ? "entity" : "record"} "${record.name}"`
+            reference: `${isEntityClass2(record) ? "entity" : "record"} "${recordNameOf2(record)}"`
           }
         });
       }
@@ -3560,7 +3814,7 @@ function validate(source, registry) {
     }
     for (const relation of info.relations) {
       if (!repositories.has(relation)) {
-        unregistered(entry.name, `the repository of "${relation.entity.name}"`);
+        unregistered(entry.name, `the repository of "${recordNameOf2(relation.entity)}"`);
       }
     }
     for (const environment of info.environments) {
@@ -3607,7 +3861,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))
@@ -3659,7 +3913,7 @@ function validateUseCases(source, registry) {
           source,
           details: {
             holder: `the ${part} of use case "${entry.name}"`,
-            reference: `${isEntityClass2(record) ? "entity" : "record"} "${record.name}"`
+            reference: `${isEntityClass2(record) ? "entity" : "record"} "${recordNameOf2(record)}"`
           }
         });
       }
@@ -3682,7 +3936,7 @@ function validateUseCases(source, registry) {
           source,
           details: {
             holder,
-            reference: `${isEntityClass2(step.build) ? "entity" : "record"} "${step.build.name}"`
+            reference: `${isEntityClass2(step.build) ? "entity" : "record"} "${recordNameOf2(step.build)}"`
           }
         });
       }
@@ -3768,7 +4022,7 @@ function fieldDescriptionOf(field, scope) {
     const ref = entity ?? scope.records.get(record.record);
     return {
       kind: entity === undefined ? "record" : "entity",
-      ref: ref ?? record.record.name,
+      ref: ref ?? recordNameOf2(record.record),
       optional: record.optional
     };
   }
@@ -3809,7 +4063,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 +4103,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 +4148,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 +4238,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 +4340,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 +4401,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 +4462,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 +4490,33 @@ 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);
     },
+    async run(useCase, input = {}, options) {
+      if (!boundUseCaseOf.has(useCase)) {
+        invalid7(name, "Expected a use case registered in the application.");
+      }
+      const Bound = boundUseCaseOf.get(useCase);
+      const instance = options?.context === undefined ? new Bound(input) : new Bound(input, { context: options.context });
+      return instance.execute(options?.dependencies);
+    },
     command(command) {
       if (!boundCommandOf.has(command)) {
-        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 +4524,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 +4552,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 +4572,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 +4581,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 +4594,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 +4693,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 +4719,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 +4758,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 +4770,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 +4781,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 +4887,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 {
@@ -4556,12 +4912,12 @@ var openapi2 = sinkOf2({
     const models = {};
     const classes = new Map;
     for (const record of records) {
-      const name = record.name;
+      const name = recordNameOf2(record);
       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 +4937,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 +5688,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, InvalidRepositoryCursor2, 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 };