@afora/core 0.0.6 → 0.0.7

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

@@ -11,6 +11,7 @@ import {
   recordFieldOf2,
   recordNameOf2,
   declaredRecordNameOf,
+  listOf2,
   isBlueprintList2,
   UNEXPECTED_ERROR2,
   Exception2,
@@ -29,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-3nd9bjnc.js";
+} from "./index-r78dsvtc.js";
 
 // src/core/environment/environment.ts
 var exports_environment = {};
@@ -94,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, {
@@ -106,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, {
@@ -1192,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)
@@ -1541,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"],
@@ -1548,6 +1589,7 @@ var NEEDS = {
   create: ["insert"],
   update: ["update"],
   delete: ["findOne", "remove"],
+  restore: ["findOne", "update"],
   count: ["count"],
   findMany: ["findMany"],
   exists: ["findOne"],
@@ -1604,6 +1646,7 @@ 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]);
@@ -1617,6 +1660,9 @@ function repositoryOf2(settings) {
     if (!method)
       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") {
@@ -1630,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)]),
@@ -1639,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)) {
@@ -1652,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",
@@ -1759,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([
@@ -1801,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({
@@ -1809,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);
@@ -1853,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");
@@ -1869,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)));
     }
@@ -1889,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: [] }
@@ -1908,7 +2108,7 @@ var ENSURE_KINDS = new Set([
   "false"
 ]);
 var READ_ACTION = /^(?:findBy.+|findManyBy.+|findMany|exists|findPage|findCursor|count)$/;
-var WRITE_ACTIONS = new Set(["create", "update", "delete"]);
+var WRITE_ACTIONS = new Set(["create", "update", "delete", "restore"]);
 function validateSteps(declaration, steps) {
   const { name } = declaration;
   const fail = (index, code, reason) => {
@@ -1964,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");
   };
@@ -2072,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) {
@@ -2094,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;
@@ -2513,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 */,
@@ -2667,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 } });
   };
@@ -2687,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])) {
@@ -2825,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}`;
@@ -3663,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);
@@ -3746,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) {
@@ -4087,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)) {
@@ -4188,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) => {
@@ -4387,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,
@@ -4629,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;
@@ -4654,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;
   }
@@ -5000,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)
@@ -5467,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",
@@ -5474,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) {
@@ -5601,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();
 
@@ -5688,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, 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 };
+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 };