@afora/core 0.0.5 → 0.0.7

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

@@ -9,6 +9,9 @@ import {
   isBlueprint2,
   isRecordClass2,
   recordFieldOf2,
+  recordNameOf2,
+  declaredRecordNameOf,
+  listOf2,
   isBlueprintList2,
   UNEXPECTED_ERROR2,
   Exception2,
@@ -27,20 +30,22 @@ import {
   AbstractRecord2,
   IdentifiedRecord,
   isVersion,
-  versionParts,
+  satisfies,
   pluginsOf2,
   isRecordPlugin2,
+  hasPlugin2,
   recordPluginOf2,
   recordBuilderOf2,
   pluginContextOf,
   recordOf3,
   declareRecord,
+  optionalOf2,
   exports_exceptions2,
   InvalidPropertyValue2,
   exports_exceptions3,
   propertyOf2,
   blueprintBuilderOf2
-} from "./index-hn82hm31.js";
+} from "./index-r78dsvtc.js";
 
 // src/core/environment/environment.ts
 var exports_environment = {};
@@ -83,6 +88,7 @@ __export(exports_exceptions6, {
 // src/core/repository/exceptions.ts
 var exports_exceptions7 = {};
 __export(exports_exceptions7, {
+  InvalidRepositoryCursor: () => InvalidRepositoryCursor2,
   InvalidRepositoryData: () => InvalidRepositoryData2,
   InvalidRepositoryDeclaration: () => InvalidRepositoryDeclaration2,
   InvalidRepositoryEntity: () => InvalidRepositoryEntity2,
@@ -91,6 +97,19 @@ __export(exports_exceptions7, {
   RepositoryUniqueViolation: () => RepositoryUniqueViolation2
 });
 
+// src/core/use-case/exceptions.ts
+var exports_exceptions8 = {};
+__export(exports_exceptions8, {
+  IncompatibleUseCasePlugin: () => IncompatibleUseCasePlugin2,
+  InvalidUseCasePlugin: () => InvalidUseCasePlugin2,
+  InvalidUseCaseStep: () => InvalidUseCaseStep2,
+  UnknownUseCasePlugin: () => UnknownUseCasePlugin2,
+  UseCaseEntityConflict: () => UseCaseEntityConflict2,
+  UseCaseEntityNotFound: () => UseCaseEntityNotFound2,
+  UseCaseInvalidCredentials: () => UseCaseInvalidCredentials2,
+  UseCaseUnavailable: () => UseCaseUnavailable2
+});
+
 // src/core/use-case/use-case.ts
 var exports_use_case = {};
 __export(exports_use_case, {
@@ -103,12 +122,6 @@ __export(exports_use_case, {
   useCaseOf: () => useCaseOf2
 });
 
-// src/core/use-case/exceptions.ts
-var exports_exceptions8 = {};
-__export(exports_exceptions8, {
-  InvalidUseCaseStep: () => InvalidUseCaseStep2
-});
-
 // src/core/command/exceptions.ts
 var exports_exceptions9 = {};
 __export(exports_exceptions9, {
@@ -640,7 +653,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 }
     });
   }
@@ -690,7 +703,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 }
       });
     }
@@ -715,6 +728,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",
@@ -741,6 +761,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")
@@ -798,7 +902,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,
@@ -808,7 +913,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) => {
@@ -890,26 +995,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);
 }
@@ -961,7 +1072,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,
@@ -1091,6 +1202,14 @@ var origins = new WeakMap;
 function declarationOf(state) {
   return origins.get(state) ?? state;
 }
+var declared = new WeakMap;
+function declareRepository(state, repository) {
+  declared.set(state, repository);
+}
+function relatedRepositoryOf(repository, Entity) {
+  const related = findState(repository)?.relations.get(Entity);
+  return related ? declared.get(declarationOf(related)) : undefined;
+}
 function bindState(state, provider, instances, bound = new Map) {
   const done = bound.get(state);
   if (done)
@@ -1193,7 +1312,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.`);
@@ -1206,10 +1325,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);
@@ -1217,7 +1336,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;
@@ -1368,6 +1487,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);
@@ -1402,6 +1559,29 @@ var remove = action(async (self, target) => {
   }
   return entity;
 });
+var restore = action(async (self, target) => {
+  const { context } = self;
+  const id = typeof target === "string" ? target : self.dataOf(target).id;
+  const data = await self.provider.findOne(context, {
+    ...equals(self, "id", id),
+    withDeleted: true
+  });
+  if (data === undefined) {
+    throw new RepositoryEntityNotFound2({
+      source: context.name,
+      details: { id }
+    });
+  }
+  if (data.deletedAt === undefined)
+    return self.hydrate(data);
+  const { deletedAt: _deletedAt, ...alive } = data;
+  const restored = {
+    ...alive,
+    updatedAt: context.entity[EntityClock].now()
+  };
+  await self.provider.update(context, restored);
+  return self.hydrate(restored);
+});
 var count = action(async (self, query) => self.provider.count(self.context, queryOf(self, query)));
 var NEEDS = {
   findBy: ["findOne"],
@@ -1409,10 +1589,12 @@ var NEEDS = {
   create: ["insert"],
   update: ["update"],
   delete: ["findOne", "remove"],
+  restore: ["findOne", "update"],
   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)}`;
@@ -1438,7 +1620,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".');
@@ -1464,18 +1646,23 @@ function repositoryOf2(settings) {
   methods.set("create", ["create", create]);
   methods.set("update", ["update", update]);
   methods.set("delete", ["delete", remove]);
+  methods.set("restore", ["restore", restore]);
   methods.set("count", ["count", count]);
   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;
+    if (kind === "restore" && deletion !== "soft") {
+      invalid3(name, '"restore" needs deletion to be "soft".');
+    }
     const needs = deletion === "soft" && kind === "delete" ? ["findOne", "update"] : NEEDS[kind] ?? [];
     for (const need of needs) {
       if (typeof provider?.[need] !== "function") {
@@ -1489,7 +1676,7 @@ function repositoryOf2(settings) {
     });
   }
   Object.defineProperty(DeclaredRepository, "name", { value: name });
-  states.set(DeclaredRepository, {
+  const state = {
     name,
     entity,
     actions: Object.freeze([...new Set(actions)]),
@@ -1498,8 +1685,11 @@ function repositoryOf2(settings) {
     explicitProvider: settings.provider !== undefined,
     environment: environmentDependencies,
     relations
-  });
-  return Object.freeze(new DeclaredRepository);
+  };
+  states.set(DeclaredRepository, state);
+  const repository = Object.freeze(new DeclaredRepository);
+  declareRepository(state, repository);
+  return repository;
 }
 function RepositoryOf2(repository) {
   if (!isRepository2(repository)) {
@@ -1511,6 +1701,54 @@ function isRepository2(value) {
   return value instanceof AbstractRepository2;
 }
 
+// src/core/use-case/exceptions.ts
+var InvalidUseCaseStep2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "InvalidUseCaseStep",
+  message: ({
+    index,
+    reason
+  }) => `Invalid step ${index}: ${reason}`
+});
+var InvalidUseCasePlugin2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "InvalidUseCasePlugin",
+  message: ({ reason }, source) => `Invalid use case plugin "${source}": ${reason}.`
+});
+var UnknownUseCasePlugin2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UnknownUseCasePlugin",
+  message: ({ name }) => `No use case plugin "${name}" in the catalog.`
+});
+var IncompatibleUseCasePlugin2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "IncompatibleUseCasePlugin",
+  message: ({ reason }, source) => `Incompatible use case plugin "${source}": ${reason}.`
+});
+var UseCaseUnavailable2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UseCaseUnavailable",
+  message: ({
+    repository,
+    reason
+  }, source) => `The use case "${source}" is not available for "${repository}": ${reason}.`
+});
+var UseCaseEntityNotFound2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UseCaseEntityNotFound",
+  message: "The entity was not found."
+});
+var UseCaseEntityConflict2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UseCaseEntityConflict",
+  message: "The entity already exists."
+});
+var UseCaseInvalidCredentials2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UseCaseInvalidCredentials",
+  message: "Invalid credentials."
+});
+
 // src/core/use-case/steps/references.ts
 var RESERVED_NAMES = [
   "input",
@@ -1618,15 +1856,104 @@ function freezeData(value) {
   return value;
 }
 
-// src/core/use-case/exceptions.ts
-var InvalidUseCaseStep2 = exceptionOf2({
-  layer: "use-case" /* UseCase */,
-  name: "InvalidUseCaseStep",
-  message: ({
-    index,
-    reason
-  }) => `Invalid step ${index}: ${reason}`
-});
+// src/core/property/input.ts
+var PropertyInput2 = Symbol("propertyInput");
+function propertyInputOf2(field) {
+  const property = fieldOf(field);
+  if (!isProperty2(property))
+    return;
+  const declared = property[PropertyInput2];
+  return typeof declared === "object" && declared !== null && isProperty2(declared.accepts) && typeof declared.convert === "function" ? declared : undefined;
+}
+
+// src/core/use-case/target.ts
+var IDENTITY = ENTITY_IDENTITY_KEYS2;
+function isOptionalField(field) {
+  if (isProperty2(field))
+    return field.type.optional === true;
+  const record = recordFieldOf2(field);
+  if (record)
+    return record.optional;
+  return field.optional === true;
+}
+function planOf(entity, key, owners) {
+  const field = fieldOf(entity.blueprint.properties[key]);
+  const optional = isOptionalField(field);
+  const record = recordFieldOf2(field);
+  const item = isBlueprintList2(field) ? recordFieldOf2(field.item) : undefined;
+  const related = [record?.record, item?.record].find(isEntityClass2);
+  const kind = record ? related ? "entity" : "record" : isBlueprintList2(field) ? related ? "entity-list" : "list" : isBlueprint2(field) ? "blueprint" : "property";
+  let input = { key, field };
+  if (kind === "entity" && related) {
+    const id = related.blueprint.properties.id;
+    input = { key: `${key}Id`, field: optional ? optionalOf2(id) : id };
+  }
+  const declared = kind === "property" ? propertyInputOf2(field) : undefined;
+  if (declared) {
+    input = {
+      key,
+      field: optional ? optionalOf2(declared.accepts) : declared.accepts
+    };
+  }
+  return Object.freeze({
+    key,
+    field,
+    identity: IDENTITY.includes(key),
+    plugin: owners.get(key),
+    sensitive: entity.options.sensitive.includes(key),
+    unique: entity.options.unique.includes(key),
+    optional,
+    change: entity.options.change.includes(key),
+    kind,
+    related,
+    input: Object.freeze(input),
+    convert: declared ? (value) => value === undefined ? undefined : declared.convert(value) : undefined
+  });
+}
+function useCaseTargetOf2(repository, source = "useCaseTargetOf") {
+  const state = findState(repository);
+  if (!state)
+    throw new TypeError("Expected a repository made by repositoryOf");
+  const { entity } = state;
+  const unavailable = (reason) => {
+    throw new UseCaseUnavailable2({
+      source,
+      details: { repository: state.name, reason }
+    });
+  };
+  const owners = new Map;
+  for (const plugin of pluginsOf2(entity)) {
+    for (const key of plugin.keys)
+      owners.set(key, plugin.name);
+  }
+  const fields = Object.freeze(Object.keys(entity.blueprint.properties).map((key) => planOf(entity, key, owners)));
+  const field = (key) => fields.find((plan) => plan.key === key) ?? unavailable(`the entity has no key "${key}"`);
+  return Object.freeze({
+    repository,
+    repositoryName: state.name,
+    entity,
+    entityName: recordNameOf2(entity),
+    actions: state.actions,
+    deletion: state.deletion,
+    fields,
+    changeKeys: entity.options.change,
+    uniqueKeys: entity.options.unique,
+    field,
+    relation(key, actions = []) {
+      const { related } = field(key);
+      const found = related ? relatedRepositoryOf(repository, related) : undefined;
+      if (!found) {
+        return unavailable(`the repository has no relation for the entity of "${key}"`);
+      }
+      const missing = actions.filter((action) => !found.actions.includes(action));
+      if (missing.length > 0) {
+        unavailable(`the repository of "${key}" lacks the action ${missing.map((action) => `"${action}"`).join(", ")}`);
+      }
+      return found;
+    },
+    unavailable
+  });
+}
 
 // src/core/use-case/steps/run.ts
 var FORBIDDEN_METHODS = new Set([
@@ -1660,7 +1987,6 @@ async function executeSteps(dependencies = {}) {
     return followPath(named.get(root), path);
   };
   const value = (raw) => resolveValue(raw, lookup);
-  const list = (raw) => raw === undefined ? [] : value(raw);
   for (const [index, step] of steps.entries()) {
     const invalid = (reason) => {
       throw new InvalidUseCaseStep2({
@@ -1668,6 +1994,14 @@ async function executeSteps(dependencies = {}) {
         details: { index, reason, code: "invalid_target" }
       });
     };
+    const list = (raw) => {
+      if (raw === undefined)
+        return [];
+      const resolved = value(raw);
+      if (!Array.isArray(resolved))
+        invalid("args must resolve to a list.");
+      return resolved;
+    };
     const bind = (result) => {
       if (typeof step.as === "string")
         named.set(step.as, result);
@@ -1712,7 +2046,10 @@ async function executeSteps(dependencies = {}) {
       if (typeof namespace !== "object" || namespace === null || typeof namespace[key] !== "function") {
         invalid(`"${key}" is not a change key of the record.`);
       }
-      await namespace[key]?.(value(step.value));
+      const changed = value(step.value);
+      if (step.ifPresent !== true || changed !== undefined) {
+        await namespace[key]?.(changed);
+      }
       bind(record);
     } else if (Object.hasOwn(step, "invoke")) {
       const record = target("invoke");
@@ -1728,7 +2065,7 @@ async function executeSteps(dependencies = {}) {
       const fn = step.fn;
       bind(await fn(...list(step.args), { context: this.context }));
     } else {
-      const action = ["create", "update", "delete"].find((kind) => Object.hasOwn(step, kind));
+      const action = ["create", "update", "delete", "restore"].find((kind) => Object.hasOwn(step, kind));
       const methods = dependencies[step[action]];
       bind(await methods[action].call(methods, value(step.value)));
     }
@@ -1748,11 +2085,15 @@ var SHAPES = {
     optional: ["other", "details"]
   },
   build: { required: ["build", "values", "as"], optional: [] },
-  change: { required: ["change", "key", "value"], optional: ["as"] },
+  change: {
+    required: ["change", "key", "value"],
+    optional: ["ifPresent", "as"]
+  },
   invoke: { required: ["invoke", "method"], optional: ["args", "as"] },
   create: { required: ["create", "value"], optional: ["as"] },
   update: { required: ["update", "value"], optional: ["as"] },
   delete: { required: ["delete", "value"], optional: ["as"] },
+  restore: { required: ["restore", "value"], optional: ["as"] },
   call: { required: ["call", "input"], optional: ["as"] },
   run: { required: ["run", "fn"], optional: ["args", "as"] },
   return: { required: ["return"], optional: [] }
@@ -1766,8 +2107,8 @@ var ENSURE_KINDS = new Set([
   "true",
   "false"
 ]);
-var READ_ACTION = /^(?:findBy.+|findManyBy.+|findMany|exists|findPage|count)$/;
-var WRITE_ACTIONS = new Set(["create", "update", "delete"]);
+var READ_ACTION = /^(?:findBy.+|findManyBy.+|findMany|exists|findPage|findCursor|count)$/;
+var WRITE_ACTIONS = new Set(["create", "update", "delete", "restore"]);
 function validateSteps(declaration, steps) {
   const { name } = declaration;
   const fail = (index, code, reason) => {
@@ -1823,8 +2164,12 @@ function validateSteps(declaration, steps) {
   const checkArgs = (index, args) => {
     if (args === undefined)
       return;
+    if (typeof args === "string" && args.startsWith("$")) {
+      checkReference(index, args);
+      return;
+    }
     if (!Array.isArray(args)) {
-      fail(index, "invalid_step", "args must be a list of values.");
+      fail(index, "invalid_step", "args must be a list of values or a reference to one.");
     }
     checkValue(index, args, "args");
   };
@@ -1931,6 +2276,9 @@ function validateSteps(declaration, steps) {
         if (typeof record.key !== "string" || record.key === "") {
           fail(index, "invalid_step", "change.key must be a string.");
         }
+        if (record.ifPresent !== undefined && typeof record.ifPresent !== "boolean") {
+          fail(index, "invalid_step", "change.ifPresent must be a boolean.");
+        }
         const reference = parseReference(record.change);
         const known = reference && reference.path.length === 0 ? bound.get(reference.root)?.record : undefined;
         if (known) {
@@ -1953,7 +2301,8 @@ function validateSteps(declaration, steps) {
       }
       case "create":
       case "update":
-      case "delete": {
+      case "delete":
+      case "restore": {
         repositoryOf(index, record[kind], kind);
         checkValue(index, record.value, "value");
         break;
@@ -2068,7 +2417,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) => {
@@ -2372,6 +2721,195 @@ function isUseCase2(value) {
   return value instanceof AbstractUseCase2;
 }
 
+// src/core/use-case/plugin.ts
+var UseCaseOrigin = Symbol("useCaseOrigin");
+var NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var identities = new WeakMap;
+var nextIdentity = 0;
+function keyOf(value) {
+  if (typeof value === "function" || typeof value === "object" && value) {
+    if (Array.isArray(value))
+      return `[${value.map(keyOf).join(",")}]`;
+    if (isPlain2(value)) {
+      return `{${Object.keys(value).sort().filter((key) => value[key] !== undefined).map((key) => `${JSON.stringify(key)}:${keyOf(value[key])}`).join(",")}}`;
+    }
+    let identity = identities.get(value);
+    if (identity === undefined) {
+      identity = nextIdentity++;
+      identities.set(value, identity);
+    }
+    return `#${identity}`;
+  }
+  return value === undefined ? "undefined" : JSON.stringify(value);
+}
+function isUseCasePlugin2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "use-case-plugin";
+}
+function useCaseOriginOf2(UseCase) {
+  return typeof UseCase === "function" ? UseCase[UseCaseOrigin] : undefined;
+}
+function useCasePluginOf2(name, settings) {
+  const source = typeof name === "string" ? name : "useCasePluginOf";
+  const invalid = (reason) => {
+    throw new InvalidUseCasePlugin2({ source, details: { reason } });
+  };
+  if (typeof name !== "string" || !NAME.test(name)) {
+    invalid("its name must be an identifier");
+  }
+  if (!isPlain2(settings) || typeof settings.compile !== "function") {
+    invalid("it needs a compile function");
+  }
+  const { version = "1.0.0", description, compile } = settings;
+  if (!isVersion(version)) {
+    invalid(`"${String(version)}" is not a semantic version`);
+  }
+  if (description !== undefined && typeof description !== "string") {
+    invalid("its description must be a string");
+  }
+  const names = (list, what) => {
+    if (list === undefined)
+      return Object.freeze([]);
+    if (!Array.isArray(list) || list.some((item) => typeof item !== "string" || item === "")) {
+      invalid(`requires.${what} must be a list of names`);
+    }
+    return Object.freeze([...new Set(list)]);
+  };
+  if (settings.requires !== undefined && !isPlain2(settings.requires)) {
+    invalid("requires must be an object of actions and plugins");
+  }
+  const requires = Object.freeze({
+    actions: names(settings.requires?.actions, "actions"),
+    plugins: names(settings.requires?.plugins, "plugins")
+  });
+  const made = new WeakMap;
+  const make = (repository, given) => {
+    if (!isRepository2(repository)) {
+      return invalid("it makes a use case for a repository of repositoryOf");
+    }
+    if (given !== undefined && !isPlain2(given)) {
+      return invalid("its options must be a plain object");
+    }
+    const options = Object.freeze({ ...given });
+    const info = inspectRepository(repository);
+    let classes = made.get(info.state);
+    if (!classes) {
+      classes = new Map;
+      made.set(info.state, classes);
+    }
+    const key = keyOf(options);
+    const known = classes.get(key);
+    if (known)
+      return known;
+    const target = useCaseTargetOf2(repository, name);
+    const missing = {
+      actions: requires.actions.filter((action) => !info.actions.includes(action)),
+      plugins: requires.plugins.filter((plugin) => !hasPlugin2(info.entity, plugin))
+    };
+    if (missing.actions.length > 0 || missing.plugins.length > 0) {
+      const quoted = (list) => list.map((item) => `"${item}"`).join(", ");
+      throw new UseCaseUnavailable2({
+        source: name,
+        details: {
+          repository: target.repositoryName,
+          reason: [
+            missing.actions.length > 0 ? `the repository lacks the action ${quoted(missing.actions)}` : undefined,
+            missing.plugins.length > 0 ? `the entity lacks the plugin ${quoted(missing.plugins)}` : undefined
+          ].filter(Boolean).join(" and "),
+          missing
+        }
+      });
+    }
+    const UseCase = useCaseOf2(compile(target, options));
+    Object.defineProperty(UseCase, UseCaseOrigin, {
+      value: Object.freeze({
+        plugin,
+        repository,
+        options
+      })
+    });
+    classes.set(key, UseCase);
+    return UseCase;
+  };
+  const plugin = Object.freeze({
+    [Kind2]: "use-case-plugin",
+    name,
+    version,
+    ...description === undefined ? {} : { description },
+    requires,
+    make,
+    toJSON: () => ({
+      kind: "use-case-plugin",
+      name,
+      version,
+      ...description === undefined ? {} : { description },
+      requires
+    })
+  });
+  return plugin;
+}
+
+// src/core/use-case/plugin-catalog.ts
+function isUseCaseCatalog2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "use-case-catalog";
+}
+function useCaseCatalogOf2(...plugins) {
+  const byName = {};
+  const context = {};
+  for (const plugin of plugins) {
+    if (!isUseCasePlugin2(plugin)) {
+      throw new InvalidUseCasePlugin2({
+        source: "catalog",
+        details: {
+          reason: "a catalog takes plugins made by `useCasePluginOf`"
+        }
+      });
+    }
+    if (Object.hasOwn(byName, plugin.name)) {
+      throw new InvalidUseCasePlugin2({
+        source: plugin.name,
+        details: { reason: "the catalog has another plugin with its name" }
+      });
+    }
+    byName[plugin.name] = plugin;
+    context[plugin.name] = plugin.make;
+  }
+  const find = (name) => {
+    const plugin = Object.hasOwn(byName, name) ? byName[name] : undefined;
+    if (!plugin) {
+      throw new UnknownUseCasePlugin2({ source: "catalog", details: { name } });
+    }
+    return plugin;
+  };
+  return Object.freeze({
+    [Kind2]: "use-case-catalog",
+    plugins: Object.freeze(byName),
+    list: Object.freeze([...plugins]),
+    context: Object.freeze(context),
+    resolve(reference) {
+      const at = typeof reference === "string" ? reference.lastIndexOf("@") : -1;
+      if (at <= 0)
+        return find(String(reference));
+      const plugin = find(reference.slice(0, at));
+      const version = reference.slice(at + 1);
+      if (!isVersion(version)) {
+        throw new IncompatibleUseCasePlugin2({
+          source: plugin.name,
+          details: { reason: `"${version}" is not a semantic version` }
+        });
+      }
+      if (!satisfies(plugin.version, version)) {
+        throw new IncompatibleUseCasePlugin2({
+          source: plugin.name,
+          details: {
+            reason: `version ${plugin.version} does not satisfy ${version}`
+          }
+        });
+      }
+      return plugin;
+    }
+  });
+}
+
 // src/core/command/exceptions.ts
 var InvalidCommandDeclaration2 = exceptionOf2({
   layer: "command" /* Command */,
@@ -2526,9 +3064,12 @@ function callEnvironment(source, environments, given) {
   }
   return { byEnvironment, merged: Object.freeze(merged) };
 }
-function commandOf2(settings) {
-  const { name, description, context, useCases, onEventError } = settings;
+function declareCommand(given, generics) {
+  const { name, description, context, onEventError } = given;
   const source = typeof name === "string" ? name : "commandOf";
+  const picked = given.useCases;
+  const useCases = typeof picked === "function" && !isUseCaseClass2(picked) ? guard2({ layer: "command" /* Command */, source }, () => picked(generics)) : picked;
+  const settings = given;
   const invalid = (reason) => {
     throw new InvalidCommandDeclaration2({ source, details: { reason } });
   };
@@ -2546,7 +3087,7 @@ function commandOf2(settings) {
     invalid("Expected context to be a non-optional blueprint.");
   }
   if (typeof useCases !== "object" || useCases === null || Array.isArray(useCases) || Reflect.ownKeys(useCases).length === 0) {
-    invalid("Expected useCases to be a non-empty object of use case classes.");
+    invalid("Expected useCases to be a non-empty object of use case classes, or a function returning one.");
   }
   for (const key of Reflect.ownKeys(useCases)) {
     if (typeof key !== "string" || !IDENTIFIER2.test(key) || !isUseCaseClass2(useCases[key])) {
@@ -2684,6 +3225,19 @@ function commandOf2(settings) {
   verifiers.set(command, providerOfCall);
   return command;
 }
+function commandBuilderOf2(...catalogs) {
+  if (!catalogs.every(isUseCaseCatalog2)) {
+    throw new InvalidCommandDeclaration2({
+      source: "commandBuilderOf",
+      details: {
+        reason: "Expected catalogs made by useCaseCatalogOf."
+      }
+    });
+  }
+  const generics = Object.freeze(Object.assign({}, ...catalogs.map((catalog) => catalog.context)));
+  return (settings) => declareCommand(settings, generics);
+}
+var commandOf = commandBuilderOf2();
 async function applyPolicy(command, policy, onEventError, call) {
   const { operation, raised } = call;
   const source = `${command.commandName}.${operation}`;
@@ -3522,7 +4076,7 @@ function isOfKind(collection, value) {
       return isDeclaredException(value);
   }
 }
-function keyOf(collection, value) {
+function keyOf2(collection, value) {
   switch (collection) {
     case "properties":
       return fieldOf(value);
@@ -3597,7 +4151,7 @@ function resolve(settings) {
       if (!isOfKind(collection, value)) {
         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) {
         invalid7(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
       }
@@ -3605,11 +4159,25 @@ function resolve(settings) {
         collection,
         name,
         value,
-        key: keyOf(collection, value),
+        key: keyOf2(collection, value),
         from: source
       });
     }
   }
+  for (const entry of [...registry.commands.values()]) {
+    for (const UseCase of Object.values(entry.value.useCases)) {
+      if (useCaseOriginOf2(UseCase) === undefined || byKey.has(UseCase)) {
+        continue;
+      }
+      add({
+        collection: "useCases",
+        name: UseCase.useCaseName,
+        value: UseCase,
+        key: UseCase,
+        from: entry.from
+      });
+    }
+  }
   return registry;
 }
 function recordsIn(properties) {
@@ -3652,7 +4220,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)}"`
           }
         });
       }
@@ -3673,7 +4241,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) {
@@ -3772,7 +4340,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)}"`
           }
         });
       }
@@ -3795,7 +4363,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)}"`
           }
         });
       }
@@ -3881,7 +4449,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
     };
   }
@@ -3946,6 +4514,36 @@ function describeRegistry(name, extended, registry, provider, named, log) {
       })
     };
   };
+  const describeOption = (value) => {
+    if (typeof value === "function") {
+      if (isDeclaredException(value)) {
+        return exceptionRefs.get(value) ?? { core: value.name };
+      }
+      return scope.entities.get(value) ?? scope.records.get(value) ?? { kind: "opaque" };
+    }
+    if (Array.isArray(value))
+      return value.map(describeOption);
+    if (typeof value === "object" && value !== null) {
+      return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined).map(([key, item]) => [key, describeOption(item)]));
+    }
+    return value;
+  };
+  const describeGeneric = (UseCase) => {
+    const origin = useCaseOriginOf2(UseCase);
+    if (!origin || interpretedStepsOf(UseCase) === undefined)
+      return {};
+    const repository = repositories.get(inspectRepository(origin.repository).state);
+    if (repository === undefined)
+      return {};
+    return {
+      generic: {
+        name: origin.plugin.name,
+        version: origin.plugin.version,
+        repository,
+        options: describeOption(origin.options)
+      }
+    };
+  };
   const refsOf = (blueprints) => {
     const refs = {};
     for (const [key, blueprint] of Object.entries(blueprints)) {
@@ -4047,7 +4645,8 @@ function describeRegistry(name, extended, registry, provider, named, log) {
             ref: repositories.get(inspectRepository(dependency).state)
           }
         ])),
-        implementation: describeImplementation(UseCase)
+        implementation: describeImplementation(UseCase),
+        ...describeGeneric(UseCase)
       };
     }),
     commands: each("commands", (entry) => {
@@ -4246,7 +4845,7 @@ function applicationOf2(settings) {
   const boundCommandOf = new Map;
   for (const entry of registry.commands.values()) {
     const declared = entry.value;
-    const rebuilt = !rebinds ? declared : commandOf2({
+    const rebuilt = !rebinds ? declared : commandOf({
       name: declared.commandName,
       description: declared.description,
       tags: declared.tags,
@@ -4353,6 +4952,14 @@ function applicationOf2(settings) {
       }
       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)) {
         invalid7(name, "Expected a command registered in the application.");
@@ -4480,7 +5087,12 @@ var INVALID_INPUT = new Set([
 var CONFIGURATION = new Set(["InvalidCommandEnvironment"]);
 var NOT_FOUND = new Set([
   "RepositoryEntityNotFound",
-  "UnknownCommandOperation"
+  "UnknownCommandOperation",
+  "UseCaseEntityNotFound"
+]);
+var CONFLICT = new Set([
+  "RepositoryUniqueViolation",
+  "UseCaseEntityConflict"
 ]);
 function raisedOf(error) {
   let raised = error;
@@ -4505,8 +5117,10 @@ function statusOf2(error, operation, statuses) {
   }
   if (NOT_FOUND.has(name))
     return 404;
-  if (name === "RepositoryUniqueViolation")
+  if (CONFLICT.has(name))
     return 409;
+  if (name === "UseCaseInvalidCredentials")
+    return 401;
   if (operation?.errors.some((Declared) => error.is(Declared) || Declared.name === name)) {
     return 422;
   }
@@ -4763,7 +5377,7 @@ 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") {
         invalid8(`The record class "${name}" cannot be a component name; give the class a name that is not "Problem".`);
       }
@@ -4851,17 +5465,6 @@ var select2 = transformOf2({
   }
 });
 // src/core/record/plugin-catalog.ts
-function satisfies(available, requested) {
-  const [major, minor, patch] = versionParts(available);
-  const [wantedMajor, wantedMinor, wantedPatch] = versionParts(requested);
-  if (major !== wantedMajor)
-    return false;
-  if (major === 0 && minor !== wantedMinor)
-    return false;
-  if (minor !== wantedMinor)
-    return minor > wantedMinor;
-  return patch >= wantedPatch;
-}
 var LISTS2 = ["keys", "sensitive", "unique", "change", "members"];
 function isDescriptor(value) {
   if (typeof value !== "object" || value === null)
@@ -5318,6 +5921,19 @@ function passwordIssues2(value) {
   }
   return issues;
 }
+var escaped = PASSWORD_SPECIAL_CHARACTERS2.replace(/[\\\]^-]/g, "\\$&");
+
+class PlainPassword2 extends propertyOf2({
+  name: "plainPassword",
+  schema: Type5.String({
+    minLength: PASSWORD_MIN_LENGTH2,
+    maxLength: PASSWORD_MAX_LENGTH2,
+    pattern: `^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[${escaped}])`
+  }),
+  default: "Demo@123",
+  sensitive: true
+}) {
+}
 
 class Password2 extends propertyOf2({
   name: "password",
@@ -5325,6 +5941,10 @@ class Password2 extends propertyOf2({
   default: DEMO_HASH,
   sensitive: true
 }) {
+  static [PropertyInput2] = {
+    accepts: PlainPassword2,
+    convert: async (plain) => (await Password2.hash(plain)).value
+  };
   static async hash(plain) {
     const issues = passwordIssues2(plain);
     if (issues.length > 0) {
@@ -5452,6 +6072,511 @@ var Std2 = blueprintPluginOf2("std", {
 
 // src/std/blueprint.ts
 var blueprintOf2 = blueprintBuilderOf2(Std2);
+// src/std/use-cases/shared.ts
+var fields = blueprintBuilderOf2();
+var IDENTIFIER3 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var capitalize2 = (key) => `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+function literal(value) {
+  if (typeof value === "string") {
+    return value.startsWith("$") ? { literal: value } : value;
+  }
+  if (Array.isArray(value))
+    return value.map(literal);
+  if (isPlain2(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, literal(item)]));
+  }
+  return value;
+}
+function checkOptions(target, options, allowed) {
+  const known = [...COMMON, ...allowed];
+  for (const key of Object.keys(options)) {
+    if (!known.includes(key)) {
+      target.unavailable(`it has no option "${key}" (options: ${known.join(", ")})`);
+    }
+  }
+}
+var COMMON = ["name", "description", "tags", "deprecated", "errors"];
+function metaOf(target, options, verb) {
+  const { name, description, tags, deprecated } = options;
+  if (name !== undefined && (typeof name !== "string" || name === "")) {
+    target.unavailable("the option name must be a non-empty string");
+  }
+  return {
+    name: name ?? `${verb}${target.entityName}`,
+    ...description === undefined ? {} : { description },
+    ...tags === undefined ? {} : { tags },
+    ...deprecated === undefined ? {} : { deprecated }
+  };
+}
+function asOf(target, options) {
+  const { as = "item" } = options;
+  if (typeof as !== "string" || !IDENTIFIER3.test(as)) {
+    target.unavailable("the option as must be an identifier");
+  }
+  return as;
+}
+function errorOf(target, options, kind, fallback) {
+  const { errors } = options;
+  if (errors === undefined)
+    return fallback;
+  if (!isPlain2(errors)) {
+    return target.unavailable("the option errors must be an object of exception classes");
+  }
+  const given = errors[kind];
+  if (given === undefined)
+    return fallback;
+  if (!isDeclaredException(given)) {
+    return target.unavailable(`errors.${kind} must be a class made by exceptionOf`);
+  }
+  return given;
+}
+function keysOf(target, options, option) {
+  const given = options[option];
+  if (given === undefined)
+    return [];
+  if (!Array.isArray(given) || given.some((key) => typeof key !== "string")) {
+    return target.unavailable(`the option ${option} must be a list of keys`);
+  }
+  return given.map((key) => target.field(key));
+}
+function valuesOf(target, options, option) {
+  const given = options[option];
+  if (given === undefined)
+    return {};
+  if (!isPlain2(given)) {
+    return target.unavailable(`the option ${option} must be an object`);
+  }
+  for (const key of Object.keys(given)) {
+    if (target.field(key).identity) {
+      target.unavailable(`${option}.${key} is an identity key`);
+    }
+  }
+  return given;
+}
+function ownerOf(target, options) {
+  const { owner } = options;
+  if (owner === undefined)
+    return;
+  if (!isPlain2(owner) || typeof owner.context !== "string" || !IDENTIFIER3.test(owner.context) || owner.key !== undefined && typeof owner.key !== "string") {
+    return target.unavailable("the option owner must be { key?, context }, context naming a context key");
+  }
+  const plan = target.field(owner.key ?? "ownerId");
+  if (plan.identity || plan.optional) {
+    target.unavailable(`owner.key "${plan.key}" must be a required key`);
+  }
+  if (plan.kind === "entity" && plan.related) {
+    return {
+      plan,
+      context: owner.context,
+      field: plan.related.blueprint.properties.id,
+      reference: `$item.${plan.key}.id`
+    };
+  }
+  if (plan.kind !== "property") {
+    target.unavailable(`owner.key "${plan.key}" must hold an id or an entity`);
+  }
+  return {
+    plan,
+    context: owner.context,
+    field: plan.field,
+    reference: `$item.${plan.key}`
+  };
+}
+function contextOf2(owner) {
+  return owner ? { context: fields(() => ({ [owner.context]: owner.field })) } : {};
+}
+function loadSteps(owner, notFound) {
+  return [
+    { find: "repository.findById", args: ["$input.id"], as: "item" },
+    { ensure: "exists", value: "$item", error: notFound },
+    ...owner ? [
+      {
+        ensure: "equals",
+        value: owner.reference,
+        other: `$context.${owner.context}`,
+        error: notFound
+      }
+    ] : []
+  ];
+}
+var idOf2 = (target) => target.field("id").field;
+var distinct = (...errors) => [...new Set(errors)];
+function entityUseCase(target, options, verb, allowed, steps) {
+  checkOptions(target, options, ["as", "owner", ...allowed]);
+  const owner = ownerOf(target, options);
+  const notFound = errorOf(target, options, "notFound", UseCaseEntityNotFound2);
+  const body = steps({ owner });
+  return {
+    ...metaOf(target, options, verb),
+    blueprint: fields(() => ({ id: idOf2(target) })),
+    response: fields(() => ({ [asOf(target, options)]: target.entity })),
+    ...contextOf2(owner),
+    dependencies: { repository: target.repository },
+    errors: [notFound],
+    steps: [
+      ...loadSteps(owner, notFound),
+      ...body.steps,
+      { return: { [asOf(target, options)]: body.result } }
+    ]
+  };
+}
+
+// src/std/use-cases/crud.ts
+function createCompilation(target, options, verb, before = [], errors = []) {
+  checkOptions(target, options, ["as", "owner", "omit", "values"]);
+  const owner = ownerOf(target, options);
+  const omitted = keysOf(target, options, "omit");
+  const constants = valuesOf(target, options, "values");
+  const notFound = errorOf(target, options, "notFound", UseCaseEntityNotFound2);
+  const ownerError = errorOf(target, options, "owner", notFound);
+  const input = {};
+  const values = {};
+  const dependencies = {
+    repository: target.repository
+  };
+  const steps = [];
+  const used = new Set(errors);
+  const take = (key, field) => {
+    if (Object.hasOwn(input, key)) {
+      target.unavailable(`two keys of the entity take the input "${key}"`);
+    }
+    input[key] = field;
+  };
+  const load = (key, reference, error) => {
+    const dependency = `${key}Repository`;
+    dependencies[dependency] = target.relation(key, ["findById"]);
+    used.add(error);
+    steps.push({
+      find: `${dependency}.findById`,
+      args: [reference],
+      as: `${key}Found`
+    }, { ensure: "exists", value: `$${key}Found`, error });
+    return `$${key}Found`;
+  };
+  for (const plan of target.fields) {
+    const { key } = plan;
+    if (plan.identity)
+      continue;
+    if (Object.hasOwn(constants, key)) {
+      values[key] = literal(constants[key]);
+      continue;
+    }
+    if (owner?.plan.key === key) {
+      values[key] = plan.kind === "entity" ? load(key, `$context.${owner.context}`, ownerError) : `$context.${owner.context}`;
+      continue;
+    }
+    const unloadable = plan.kind === "entity-list" || plan.kind === "entity" && plan.optional;
+    if (omitted.includes(plan) || unloadable) {
+      if (!plan.optional) {
+        target.unavailable(unloadable ? `"${key}" holds a list of entities, which the input cannot take; give it in values` : `"${key}" is required and cannot be omitted`);
+      }
+      continue;
+    }
+    take(plan.input.key, plan.input.field);
+    const given = `$input.${plan.input.key}`;
+    if (plan.kind === "entity") {
+      values[key] = load(key, given, notFound);
+    } else if (plan.convert) {
+      steps.push({
+        run: `convert${capitalize2(key)}`,
+        fn: plan.convert,
+        args: [given],
+        as: `${key}Converted`
+      });
+      values[key] = `$${key}Converted`;
+    } else {
+      values[key] = given;
+    }
+  }
+  return {
+    ...metaOf(target, options, verb),
+    blueprint: fields(() => input),
+    response: fields(() => ({ [asOf(target, options)]: target.entity })),
+    ...contextOf2(owner),
+    dependencies,
+    errors: distinct(...used),
+    steps: [
+      ...before,
+      ...steps,
+      { build: target.entity, values, as: "built" },
+      { create: "repository", value: "$built", as: "item" },
+      { return: { [asOf(target, options)]: "$item" } }
+    ]
+  };
+}
+var create2 = useCasePluginOf2("create", {
+  description: "Builds an entity from the input (its keys, less the identity; an entity it holds by id) and stores it.",
+  requires: { actions: ["create"] },
+  compile: (target, options) => createCompilation(target, options, "Create")
+});
+var get = useCasePluginOf2("get", {
+  description: "Gives the entity of an id.",
+  requires: { actions: ["findById"] },
+  compile: (target, options) => entityUseCase(target, options, "Get", [], () => ({
+    steps: [],
+    result: "$item"
+  }))
+});
+var list = useCasePluginOf2("list", {
+  description: "Gives a page of entities: { items, total, limit, offset }.",
+  requires: { actions: ["findPage"] },
+  compile: (target, options) => {
+    checkOptions(target, options, ["owner", "orderBy"]);
+    const owner = ownerOf(target, options);
+    const { orderBy = [{ key: "createdAt", direction: "desc" }] } = options;
+    if (!Array.isArray(orderBy)) {
+      target.unavailable("the option orderBy must be a list of orders");
+    }
+    for (const order of orderBy) {
+      target.field(String(order?.key));
+    }
+    return {
+      ...metaOf(target, options, "List"),
+      blueprint: fields(() => ({
+        limit: optionalOf2(Integer2),
+        offset: optionalOf2(Integer2)
+      })),
+      response: fields(() => ({
+        items: listOf2(target.entity),
+        total: Integer2,
+        limit: Integer2,
+        offset: Integer2
+      })),
+      ...contextOf2(owner),
+      dependencies: { repository: target.repository },
+      steps: [
+        {
+          find: "repository.findPage",
+          args: [
+            {
+              ...owner ? {
+                where: {
+                  [owner.plan.key]: `$context.${owner.context}`
+                }
+              } : {},
+              orderBy: literal(orderBy),
+              limit: "$input.limit",
+              offset: "$input.offset"
+            }
+          ],
+          as: "page"
+        },
+        {
+          return: {
+            items: "$page.items",
+            total: "$page.total",
+            limit: "$page.limit",
+            offset: "$page.offset"
+          }
+        }
+      ]
+    };
+  }
+});
+var update2 = useCasePluginOf2("update", {
+  description: "Changes the change keys the input gives, leaving the others as they are, and stores the entity.",
+  requires: { actions: ["findById", "update"] },
+  compile: (target, options) => {
+    checkOptions(target, options, ["as", "owner"]);
+    const owner = ownerOf(target, options);
+    const notFound = errorOf(target, options, "notFound", UseCaseEntityNotFound2);
+    const plans = target.changeKeys.map((key) => target.field(key)).filter((plan) => plan.kind !== "entity" && plan.kind !== "entity-list");
+    if (plans.length === 0) {
+      target.unavailable("the entity has no change key an input can take");
+    }
+    if (plans.some((plan) => plan.key === "id")) {
+      target.unavailable('"id" cannot be a change key');
+    }
+    const steps = [];
+    for (const plan of plans) {
+      const given = `$input.${plan.input.key}`;
+      let value = given;
+      if (plan.convert) {
+        steps.push({
+          run: `convert${capitalize2(plan.key)}`,
+          fn: plan.convert,
+          args: [given],
+          as: `${plan.key}Converted`
+        });
+        value = `$${plan.key}Converted`;
+      }
+      steps.push({ change: "$item", key: plan.key, value, ifPresent: true });
+    }
+    return {
+      ...metaOf(target, options, "Update"),
+      blueprint: fields(() => ({
+        id: idOf2(target),
+        ...Object.fromEntries(plans.map((plan) => [plan.input.key, optionalOf2(plan.input.field)]))
+      })),
+      response: fields(() => ({ [asOf(target, options)]: target.entity })),
+      ...contextOf2(owner),
+      dependencies: { repository: target.repository },
+      errors: [notFound],
+      steps: [
+        ...loadSteps(owner, notFound),
+        ...steps,
+        { update: "repository", value: "$item", as: "saved" },
+        { return: { [asOf(target, options)]: "$saved" } }
+      ]
+    };
+  }
+});
+var remove2 = useCasePluginOf2("delete", {
+  description: "Deletes the entity of an id, hard or soft as the repository declares, and gives it.",
+  requires: { actions: ["findById", "delete"] },
+  compile: (target, options) => entityUseCase(target, options, "Delete", [], () => ({
+    steps: [{ delete: "repository", value: "$item", as: "deleted" }],
+    result: "$deleted"
+  }))
+});
+var restore2 = useCasePluginOf2("restore", {
+  description: "Brings back the soft-deleted entity of an id; for a repository with soft deletion and the restore action.",
+  requires: { actions: ["restore"] },
+  compile: (target, options) => {
+    checkOptions(target, options, ["as"]);
+    return {
+      ...metaOf(target, options, "Restore"),
+      blueprint: fields(() => ({ id: idOf2(target) })),
+      response: fields(() => ({ [asOf(target, options)]: target.entity })),
+      dependencies: { repository: target.repository },
+      steps: [
+        { restore: "repository", value: "$input.id", as: "item" },
+        { return: { [asOf(target, options)]: "$item" } }
+      ]
+    };
+  }
+});
+
+// src/std/use-cases/auth.ts
+var authenticatable = (actions) => ({
+  requires: { actions, plugins: ["authenticatable"] }
+});
+var register = useCasePluginOf2("register", {
+  description: "Stores an authenticatable entity built from the input, its password given plain and stored as a hash, unless the email is taken.",
+  ...authenticatable(["findByEmail", "create"]),
+  compile: (target, options) => {
+    const conflict = errorOf(target, options, "conflict", UseCaseEntityConflict2);
+    return createCompilation(target, options, "Register", [
+      {
+        find: "repository.findByEmail",
+        args: ["$input.email"],
+        as: "existing"
+      },
+      { ensure: "absent", value: "$existing", error: conflict }
+    ], [conflict]);
+  }
+});
+var login = useCasePluginOf2("login", {
+  description: "Gives the authenticatable entity of an email when the password matches; issues no token.",
+  ...authenticatable(["findByEmail"]),
+  compile: (target, options) => {
+    checkOptions(target, options, ["as"]);
+    const invalid = errorOf(target, options, "invalid", UseCaseInvalidCredentials2);
+    return {
+      ...metaOf(target, options, "Login"),
+      blueprint: fields(() => ({
+        email: target.field("email").field,
+        password: StringProperty2
+      })),
+      response: fields(() => ({ [asOf(target, options)]: target.entity })),
+      dependencies: { repository: target.repository },
+      errors: [invalid],
+      steps: [
+        { find: "repository.findByEmail", args: ["$input.email"], as: "item" },
+        { ensure: "exists", value: "$item", error: invalid },
+        {
+          invoke: "$item",
+          method: "verifyPassword",
+          args: ["$input.password"],
+          as: "matches"
+        },
+        { ensure: "true", value: "$matches", error: invalid },
+        { return: { [asOf(target, options)]: "$item" } }
+      ]
+    };
+  }
+});
+
+// src/std/use-cases/lifecycle.ts
+function invoking(target, options, verb, method) {
+  const set = valuesOf(target, options, "set");
+  const changes = Object.entries(set).map(([key, value]) => {
+    if (!target.changeKeys.includes(key)) {
+      target.unavailable(`set.${key} is not a change key of the entity`);
+    }
+    return { change: "$item", key, value: literal(value) };
+  });
+  return entityUseCase(target, options, verb, ["set"], () => ({
+    steps: [
+      ...changes,
+      { invoke: "$item", method },
+      { update: "repository", value: "$item", as: "saved" }
+    ],
+    result: "$saved"
+  }));
+}
+var lifecycle = (plugin) => ({
+  requires: { actions: ["findById", "update"], plugins: [plugin] }
+});
+var publish = useCasePluginOf2("publish", {
+  description: "Publishes the publishable entity of an id and stores it.",
+  ...lifecycle("publishable"),
+  compile: (target, options) => invoking(target, options, "Publish", "publish")
+});
+var unpublish = useCasePluginOf2("unpublish", {
+  description: "Makes the publishable entity of an id a draft again and stores it.",
+  ...lifecycle("publishable"),
+  compile: (target, options) => invoking(target, options, "Unpublish", "unpublish")
+});
+var archive = useCasePluginOf2("archive", {
+  description: "Archives the archivable entity of an id and stores it.",
+  ...lifecycle("archivable"),
+  compile: (target, options) => invoking(target, options, "Archive", "archive")
+});
+var unarchive = useCasePluginOf2("unarchive", {
+  description: "Makes the archived entity of an id active again and stores it.",
+  ...lifecycle("archivable"),
+  compile: (target, options) => invoking(target, options, "Unarchive", "restore")
+});
+function tagging(target, options, verb, method) {
+  checkOptions(target, options, ["as", "owner"]);
+  const owner = ownerOf(target, options);
+  const notFound = errorOf(target, options, "notFound", UseCaseEntityNotFound2);
+  const { item } = target.field("tags").field;
+  return {
+    ...metaOf(target, options, verb),
+    blueprint: fields(() => ({
+      id: idOf2(target),
+      tags: listOf2(item, { minItems: 1 })
+    })),
+    response: fields(() => ({ [asOf(target, options)]: target.entity })),
+    ...contextOf2(owner),
+    dependencies: { repository: target.repository },
+    errors: [notFound],
+    steps: [
+      ...loadSteps(owner, notFound),
+      { invoke: "$item", method, args: "$input.tags" },
+      { update: "repository", value: "$item", as: "saved" },
+      { return: { [asOf(target, options)]: "$saved" } }
+    ]
+  };
+}
+var tag = useCasePluginOf2("tag", {
+  description: "Adds tags to the taggable entity of an id and stores it.",
+  ...lifecycle("taggable"),
+  compile: (target, options) => tagging(target, options, "Tag", "tag")
+});
+var untag = useCasePluginOf2("untag", {
+  description: "Removes tags from the taggable entity of an id and stores it.",
+  ...lifecycle("taggable"),
+  compile: (target, options) => tagging(target, options, "Untag", "untag")
+});
+
+// src/std/use-cases/index.ts
+var StdUseCases2 = useCaseCatalogOf2(create2, get, list, update2, remove2, restore2, publish, unpublish, archive, unarchive, tag, untag, register, login);
+
+// src/std/command.ts
+var commandOf2 = commandBuilderOf2(StdUseCases2);
 // src/std/record-plugins.ts
 var now = () => new Date().toISOString();
 
@@ -5539,4 +6664,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, 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 };
+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, InvalidUseCasePlugin2, UnknownUseCasePlugin2, IncompatibleUseCasePlugin2, UseCaseUnavailable2, UseCaseEntityNotFound2, UseCaseEntityConflict2, UseCaseInvalidCredentials2, PropertyInput2, propertyInputOf2, useCaseTargetOf2, InvalidUseCaseDeclaration2, UseCaseAlreadyExecuted2, InvalidUseCaseDependencies2, AbstractUseCase2, useCaseOf2, isUseCaseClass2, isUseCase2, isUseCasePlugin2, useCaseOriginOf2, useCasePluginOf2, isUseCaseCatalog2, useCaseCatalogOf2, InvalidCommandDeclaration2, UnknownCommandOperation2, InvalidCommandContext2, InvalidCommandEnvironment2, CommandEventFailed2, commandBuilderOf2, 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, PlainPassword2, Password2, StringProperty2, Text2, NumberProperty2, Integer2, BooleanProperty2, DateTime2, DateProperty2, CreatedAt2, UpdatedAt2, DeletedAt2, Std2, blueprintOf2, StdUseCases2, commandOf2, Publishable2, Archivable2, Taggable2, Ownable2, Authenticatable2, StdRecordPlugins2, entityOf2, recordOf2, StdStages2 };