@afora/core 0.0.7 → 0.0.9

package/dist/index-ny3as79r.js

@@ -0,0 +1,4567 @@
+import {
+  __export,
+  isProperty,
+  schemaOf,
+  recordPropertyLineage,
+  propertyLineageOf2,
+  fieldOf,
+  Kind2,
+  isBlueprint,
+  isRecordClass,
+  recordFieldOf,
+  Exception2,
+  isDeclaredException,
+  declaredMessageOf,
+  exceptionOf2,
+  exports_exceptions3,
+  variantOfValue,
+  isBlueprintVariant,
+  InvalidPropertyValue2,
+  exports_exceptions4,
+  recordNameOf2,
+  declaredRecordNameOf,
+  fieldsOf,
+  isPlainObject,
+  listOf2,
+  isBlueprintList,
+  InvalidEnvironment2,
+  loadEnvironments,
+  isEnvironment,
+  exports_environment,
+  InvalidApplicationDeclaration2,
+  DuplicateApplicationDeclaration2,
+  ApplicationConflict2,
+  UnregisteredApplicationReference2,
+  UnregisteredRepositoryDependency2,
+  UnregisteredUseCaseDependency2,
+  ApplicationNotStarted2,
+  ProviderNotBound2,
+  ApplicationAlreadyStarted2,
+  SchemaLockMismatch2,
+  InvalidSchemaMigration2,
+  InvalidApplicationEnvironment2,
+  exports_exceptions5,
+  startedApplication,
+  setStartedApplication,
+  exports_exceptions6,
+  logProviderNameOf,
+  checkLogSettings,
+  silentLogger,
+  applicationLogger,
+  isLoggerDeclaration,
+  ApplicationLoggerKey,
+  resolveLogger,
+  clock,
+  elapsed,
+  logFailure,
+  writeLog,
+  InvalidRecordPlugin2,
+  UnknownRecordPlugin2,
+  IncompatibleRecordPlugin2,
+  exports_exceptions7,
+  propertyOf2,
+  optionalOf2,
+  blueprintBuilderOf2,
+  isVersion,
+  satisfies,
+  pluginsOf2,
+  isRecordPlugin,
+  recordPluginOf2,
+  recordBuilderOf2,
+  recordOf3,
+  exports_exceptions8,
+  vouching,
+  entityBuilderOf2,
+  isEntityClass2,
+  eventHasHandler,
+  lifecycleEventsOf,
+  EntitySettings2,
+  SCHEMA_VERSION_KEY2,
+  isVersionedEntityClass,
+  identityKeysOf,
+  InvalidRepositoryDeclaration2,
+  InvalidRepositoryData2,
+  RepositoryConcurrencyConflict2,
+  exports_exceptions9,
+  findState,
+  contextOf,
+  inspectRepository,
+  bindRepository,
+  providerOfRepository,
+  exports_exceptions10,
+  plainOf,
+  routeDeclarationOf,
+  InvalidOutputStage2,
+  DuplicateOperation2,
+  Unauthenticated2,
+  Forbidden2,
+  exports_exceptions11,
+  transformOf2,
+  stageDescriptionOf2,
+  isStage,
+  stageCatalogOf2,
+  jwtOptionsIssue,
+  jwtOf2
+} from "./index-xegv6a1p.js";
+import {
+  PublisherNotBound2,
+  exports_exceptions,
+  guard2,
+  ScopeKey,
+  providerDescriptionOf2,
+  fullUpcastPlanOf,
+  upcast,
+  resolveReferences,
+  isRepository,
+  InvalidUseCasePlugin2,
+  UnknownUseCasePlugin2,
+  IncompatibleUseCasePlugin2,
+  UseCaseEntityNotFound2,
+  UseCaseEntityConflict2,
+  UseCaseInvalidCredentials2,
+  exports_exceptions2,
+  isPlain,
+  PropertyInput2,
+  isPublicAccess,
+  accessDeclarationOf,
+  interpretedStepsOf,
+  InvalidUseCaseDeclaration2,
+  isUseCaseClass2,
+  exports_use_case,
+  isUseCasePlugin2,
+  useCaseOriginOf2,
+  useCasePluginOf2,
+  eventPolicyOf2,
+  eventPolicyDescriptionOf2,
+  eventPolicyPublishersOf,
+  eventPolicyCatalogOf2
+} from "./index-3aae5jfq.js";
+import {
+  schemaLockOf2,
+  diffSchemas2,
+  schemaLockProblemsOf2,
+  outputValueOf2,
+  openapi2
+} from "./index-hg1z2s2v.js";
+
+// src/core/command/exceptions.ts
+var exports_exceptions12 = {};
+__export(exports_exceptions12, {
+  CommandEventFailed: () => CommandEventFailed2,
+  InvalidCommandContext: () => InvalidCommandContext2,
+  InvalidCommandDeclaration: () => InvalidCommandDeclaration2,
+  InvalidCommandEnvironment: () => InvalidCommandEnvironment2,
+  UnknownCommandOperation: () => UnknownCommandOperation2
+});
+
+// src/core/event-policy/publishers.ts
+var ApplicationPublishersKey = Symbol("afora.application.publishers");
+var boundPublishers = new WeakMap;
+function bindPublishers(command, publishers) {
+  boundPublishers.set(command, publishers);
+}
+function isEventPublisher(value) {
+  return typeof value === "object" && value !== null && typeof value.publish === "function";
+}
+function resolvePublisher(command, name, source) {
+  const publishers = boundPublishers.get(command) ?? startedApplication()?.[ApplicationPublishersKey];
+  const publisher = publishers && Object.hasOwn(publishers, name) ? publishers[name] : undefined;
+  if (!publisher) {
+    throw new PublisherNotBound2({ source, details: { publisher: name } });
+  }
+  return publisher;
+}
+
+// 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 */,
+  name: "InvalidCommandDeclaration",
+  message: ({ reason }) => reason
+});
+var UnknownCommandOperation2 = exceptionOf2({
+  layer: "command" /* Command */,
+  name: "UnknownCommandOperation",
+  message: ({ operation }) => `Unknown command operation "${operation}".`
+});
+var InvalidCommandContext2 = exceptionOf2({
+  layer: "command" /* Command */,
+  name: "InvalidCommandContext",
+  message: (_details) => "Invalid Command context."
+});
+var InvalidCommandEnvironment2 = exceptionOf2({
+  layer: "command" /* Command */,
+  name: "InvalidCommandEnvironment",
+  message: (_details) => "Invalid Command environment."
+});
+var CommandEventFailed2 = exceptionOf2({
+  layer: "command" /* Command */,
+  name: "CommandEventFailed",
+  message: ({
+    operation,
+    event
+  }) => event === undefined ? `The event handler of "${operation}" failed after the call succeeded.` : `The event "${event}" of "${operation}" failed after the call succeeded.`
+});
+
+// src/core/command/command.ts
+var verifiers = new WeakMap;
+function verifyCommand(command) {
+  verifiers.get(command)?.();
+}
+function commandTransactionProvider(command) {
+  return verifiers.get(command)?.();
+}
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function repositoryProvidersOf(useCases, declared) {
+  const providers = new Map;
+  const seen = new Set;
+  const add = (state) => {
+    if (declared && !state.explicitProvider)
+      return;
+    const { provider, name } = state;
+    const names = providers.get(provider) ?? [];
+    if (!names.includes(name))
+      names.push(name);
+    providers.set(provider, names);
+  };
+  const visit = (UseCase) => {
+    if (seen.has(UseCase))
+      return;
+    seen.add(UseCase);
+    for (const dependency of Object.values(UseCase.dependencies)) {
+      if (isUseCaseClass2(dependency)) {
+        visit(dependency);
+      } else if (isRepository(dependency)) {
+        const state = findState(dependency);
+        if (!state)
+          continue;
+        add(state);
+        for (const related of state.relations.values())
+          add(related);
+      }
+    }
+  };
+  for (const UseCase of Object.values(useCases))
+    visit(UseCase);
+  return providers;
+}
+function transactionProviderOf(name, useCases, declared = false) {
+  const providers = repositoryProvidersOf(useCases, declared);
+  const invalid = (reason, repositories) => {
+    throw new InvalidCommandDeclaration2({
+      source: name,
+      details: { reason, repositories }
+    });
+  };
+  if (providers.size > 1) {
+    const repositories = [...providers.values()].flat();
+    invalid(`A transaction needs every repository to share one provider; found ${providers.size} (${repositories.join(", ")}).`, repositories);
+  }
+  const [entry] = providers;
+  if (!entry)
+    return;
+  const [provider, repositories] = entry;
+  if (typeof provider.transaction !== "function" || provider.capabilities?.transactions === false) {
+    invalid(`The provider of ${repositories.join(", ")} does not support transactions.`, repositories);
+  }
+  return provider;
+}
+function narrowed(UseCase, context) {
+  if (!UseCase.context || typeof context !== "object" || context === null) {
+    return;
+  }
+  const picked = {};
+  for (const key of Object.keys(UseCase.context.properties)) {
+    if (Object.hasOwn(context, key)) {
+      picked[key] = context[key];
+    }
+  }
+  return picked;
+}
+function callEnvironment(source, environments, given) {
+  if (typeof given !== "object" || given === null || Array.isArray(given)) {
+    throw new InvalidCommandEnvironment2({
+      source,
+      details: { keys: [], issues: [] }
+    });
+  }
+  const values = given;
+  const unknownKeys = Object.keys(values).filter((key) => !environments.some((environment) => Object.hasOwn(environment.blueprint.properties, key)));
+  if (unknownKeys.length > 0) {
+    throw new InvalidCommandEnvironment2({
+      source,
+      details: { keys: unknownKeys, issues: [] }
+    });
+  }
+  const byEnvironment = new Map;
+  const merged = {};
+  for (const environment of environments) {
+    const keys = Object.keys(environment.blueprint.properties);
+    const picked = {};
+    for (const key of keys) {
+      if (Object.hasOwn(values, key))
+        picked[key] = values[key];
+    }
+    const complete = keys.every((key) => Object.hasOwn(picked, key));
+    const base = Object.keys(picked).length === 0 || !complete ? environment.load() : {};
+    if (Object.keys(picked).length === 0) {
+      Object.assign(merged, base);
+      continue;
+    }
+    const parsed = environment.blueprint.safeParse({ ...base, ...picked });
+    if (parsed.issues) {
+      throw new InvalidCommandEnvironment2({
+        source,
+        details: {
+          keys: [
+            ...new Set(parsed.issues.map((issue) => String(issue.path[0] ?? "")))
+          ],
+          issues: parsed.issues
+        },
+        cause: parsed.issues.find((issue) => issue.cause)?.cause
+      });
+    }
+    const value = Object.freeze(parsed.value);
+    byEnvironment.set(environment, value);
+    Object.assign(merged, value);
+  }
+  return { byEnvironment, merged: Object.freeze(merged) };
+}
+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 } });
+  };
+  if (typeof name !== "string" || !name.trim()) {
+    invalid("Expected name to be a non-empty string.");
+  }
+  if (description !== undefined && typeof description !== "string") {
+    invalid("Expected description to be a string.");
+  }
+  const tags = settings.tags === undefined ? [] : settings.tags;
+  if (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string") || new Set(tags).size !== tags.length) {
+    invalid("Expected tags to be distinct strings.");
+  }
+  if (context !== undefined && (!isBlueprint(context) || context.optional)) {
+    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, or a function returning one.");
+  }
+  for (const key of Reflect.ownKeys(useCases)) {
+    if (typeof key !== "string" || !IDENTIFIER.test(key) || !isUseCaseClass2(useCases[key])) {
+      invalid("Expected the operations to be identifiers holding use case classes.");
+    }
+  }
+  const transaction = settings.transaction === undefined ? false : settings.transaction;
+  if (typeof transaction !== "boolean") {
+    invalid("Expected transaction to be a boolean.");
+  }
+  const declaredEnvironments = settings.environmentDependencies;
+  const environments = Object.freeze(declaredEnvironments === undefined ? [] : isEnvironment(declaredEnvironments) ? [declaredEnvironments] : Array.isArray(declaredEnvironments) ? [...declaredEnvironments] : [null]);
+  if (!environments.every(isEnvironment) || new Set(environments).size !== environments.length) {
+    invalid("Expected environmentDependencies to be distinct environments made by environmentOf.");
+  }
+  const events = settings.events === undefined ? "after-commit" : settings.events;
+  if (events !== "after-commit" && events !== "manual" && typeof events !== "function") {
+    invalid('Expected events to be "after-commit", "manual" or a function.');
+  }
+  if (onEventError !== undefined) {
+    if (typeof onEventError !== "function") {
+      invalid("Expected onEventError to be a function.");
+    }
+    if (events !== "after-commit") {
+      invalid('onEventError only applies to the "after-commit" policy.');
+    }
+  }
+  if (transaction)
+    transactionProviderOf(source, useCases, true);
+  let resolved;
+  const providerOfCall = () => {
+    if (!transaction)
+      return;
+    resolved ??= { provider: transactionProviderOf(source, useCases) };
+    return resolved.provider;
+  };
+  const operations = Object.freeze(Object.keys(useCases));
+  const frozenUseCases = Object.freeze({ ...useCases });
+  const perform = async (op, input, options) => {
+    if (typeof op !== "string" || !Object.hasOwn(frozenUseCases, op)) {
+      throw new UnknownCommandOperation2({
+        source,
+        details: { operation: String(op) }
+      });
+    }
+    const where = `${source}.${op}`;
+    const UseCase = frozenUseCases[op];
+    let callContext = options?.context;
+    let given = callContext;
+    if (context) {
+      const checked = context.safeParse(callContext);
+      if (checked.issues) {
+        throw new InvalidCommandContext2({
+          source: where,
+          details: { issues: checked.issues },
+          cause: checked.issues.find((issue) => issue.cause)?.cause
+        });
+      }
+      callContext = checked.value;
+      given = narrowed(UseCase, callContext);
+    }
+    const overrides = options?.env === undefined ? undefined : callEnvironment(where, environments, options.env);
+    const logger = resolveLogger(undefined, UseCase);
+    const withEnvironments = (scope) => {
+      const environmentsOfCall = overrides === undefined || overrides.byEnvironment.size === 0 ? scope?.environments : overrides.byEnvironment;
+      if (!environmentsOfCall && !logger)
+        return scope;
+      return {
+        providers: scope?.providers ?? new Map,
+        ...environmentsOfCall ? { environments: environmentsOfCall } : {},
+        ...logger ? { logger } : {}
+      };
+    };
+    const run = async (declared) => {
+      const scope = withEnvironments(declared);
+      const useCase = new UseCase(input, { context: given, [ScopeKey]: scope });
+      const value = await useCase.execute();
+      return { value, events: useCase.pullEvents() };
+    };
+    const provider = providerOfCall();
+    const started = clock();
+    const outcome = await guard2({ layer: "command" /* Command */, source: where }, () => provider?.transaction ? provider.transaction((scoped) => run({ providers: new Map([[provider, scoped]]) })) : run(undefined)).catch((error) => {
+      logFailure(logger, "command-failed", { command: where, ms: elapsed(started) }, error);
+      throw error;
+    });
+    writeLog(logger, "debug", "command", {
+      command: where,
+      ms: elapsed(started)
+    });
+    return {
+      ...outcome,
+      context: callContext,
+      env: () => overrides?.merged ?? loadEnvironments(environments),
+      logger: logger ?? silentLogger
+    };
+  };
+  const command = {
+    [Kind2]: "command",
+    commandName: name,
+    description,
+    tags: Object.freeze([...tags]),
+    context,
+    useCases: frozenUseCases,
+    transaction,
+    environments,
+    get env() {
+      return loadEnvironments(environments);
+    },
+    events,
+    onEventError,
+    operations,
+    async execute(op, input, options) {
+      const { value, events } = await perform(op, input, options);
+      return { value, events };
+    },
+    async run(op, input, options) {
+      const {
+        value,
+        events: raised,
+        context: callContext,
+        env,
+        logger
+      } = await perform(op, input, options);
+      await applyPolicy(command, events, onEventError, {
+        operation: op,
+        raised,
+        context: callContext,
+        env,
+        logger
+      });
+      return value;
+    }
+  };
+  Object.freeze(command);
+  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}`;
+  if (policy === "manual")
+    return;
+  const info = {
+    command,
+    operation,
+    context: call.context,
+    get env() {
+      return call.env();
+    },
+    logger: call.logger,
+    publisher: (name) => resolvePublisher(command, name, source)
+  };
+  if (typeof policy === "function") {
+    try {
+      await policy(raised, info);
+    } catch (cause) {
+      if (cause instanceof Exception2 && cause.name === "CommandEventFailed") {
+        throw cause;
+      }
+      throw new CommandEventFailed2({
+        source,
+        cause,
+        details: { operation, handled: 0, remaining: raised.length }
+      });
+    }
+    return;
+  }
+  for (const [index, event] of raised.entries()) {
+    try {
+      await event.handle({ logger: call.logger });
+    } catch (cause) {
+      if (!onEventError) {
+        throw new CommandEventFailed2({
+          source,
+          cause,
+          details: {
+            operation,
+            event: event.name,
+            handled: index,
+            remaining: raised.length - index - 1
+          }
+        });
+      }
+      try {
+        await onEventError(cause, event, info);
+      } catch (failure) {
+        throw new CommandEventFailed2({
+          source,
+          cause: failure,
+          details: {
+            operation,
+            event: event.name,
+            handled: index,
+            remaining: raised.length - index - 1
+          }
+        });
+      }
+    }
+  }
+}
+function isCommand2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "command";
+}
+
+// src/core/exception/exported.ts
+var exported = new WeakSet;
+var collected = false;
+function markExported(...classes) {
+  for (const Declared of classes) {
+    if (isDeclaredException(Declared))
+      exported.add(Declared);
+  }
+}
+function isExportedException(Declared) {
+  if (!collected) {
+    collected = true;
+    for (const module of [
+      exports_exceptions5,
+      exports_exceptions3,
+      exports_exceptions12,
+      exports_exceptions8,
+      exports_environment,
+      exports_exceptions,
+      exports_exceptions6,
+      exports_exceptions10,
+      exports_exceptions11,
+      exports_exceptions4,
+      exports_exceptions7,
+      exports_exceptions9,
+      exports_use_case,
+      exports_exceptions2
+    ]) {
+      markExported(...Object.values(module));
+    }
+  }
+  return typeof Declared === "function" && exported.has(Declared);
+}
+
+// src/core/output/access.ts
+function readerOf(path) {
+  if (path === "subject")
+    return (principal) => principal.subject;
+  if (path === "scopes")
+    return (principal) => [...principal.scopes];
+  const claim = path.slice("claims.".length);
+  return (principal) => principal.claims && Object.hasOwn(principal.claims, claim) ? principal.claims[claim] : undefined;
+}
+function accessGuardOf(id, access, context) {
+  if (isPublicAccess(access)) {
+    return (_input, options) => options === undefined ? undefined : { context: options.context };
+  }
+  const scopes = access.scopes ?? [];
+  const owner = access.owner;
+  const ownerOf = owner ? readerOf(owner.claim === undefined ? "subject" : `claims.${owner.claim}`) : undefined;
+  const fills = Object.entries(access.context ?? {}).map(([key, path]) => [key, readerOf(path)]);
+  for (const [key] of fills) {
+    if (!context || !Object.hasOwn(context.properties, key)) {
+      throw new InvalidOutputStage2({
+        source: id,
+        details: {
+          reason: `The access of ${id} fills the context key "${key}", which the context of the operation does not declare.`
+        }
+      });
+    }
+  }
+  return (input, options) => {
+    const principal = options?.principal;
+    if (principal === undefined || principal === null || typeof principal.subject !== "string" || !Array.isArray(principal.scopes)) {
+      throw new Unauthenticated2({ source: id });
+    }
+    if (scopes.length > 0) {
+      const missing = scopes.filter((scope) => !principal.scopes.includes(scope));
+      if (missing.length > 0) {
+        throw new Forbidden2({
+          source: id,
+          details: { reason: "scope", scopes: missing }
+        });
+      }
+    }
+    if (owner && ownerOf) {
+      const expected = ownerOf(principal);
+      const given = typeof input === "object" && input !== null ? input[owner.input] : undefined;
+      if (given === undefined || given === null || expected === undefined || expected === null || String(given) !== String(expected)) {
+        throw new Forbidden2({ source: id, details: { reason: "owner" } });
+      }
+    }
+    if (fills.length === 0) {
+      return options?.context === undefined ? undefined : { context: options.context };
+    }
+    const given = options?.context;
+    const filled = {
+      ...typeof given === "object" && given !== null ? given : {}
+    };
+    for (const [key, read] of fills) {
+      const value = read(principal);
+      if (value === undefined)
+        delete filled[key];
+      else
+        filled[key] = value;
+    }
+    return { context: filled };
+  };
+}
+
+// src/core/output/output.ts
+function isApplicationLike(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "application";
+}
+function invalid(source, reason) {
+  throw new InvalidOutputStage2({ source, details: { reason } });
+}
+var PATCHABLE = ["meta", "tags", "description", "deprecated", "invoke"];
+function operationOf2(operation, patch) {
+  const source = operation?.id ?? "operationOf";
+  if (operation?.kind !== "operation" || operation.version !== 1) {
+    invalid(source, "Expected an operation descriptor.");
+  }
+  if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
+    invalid(source, "Expected the patch to be an object.");
+  }
+  for (const key of Reflect.ownKeys(patch)) {
+    if (typeof key !== "string" || !PATCHABLE.includes(key)) {
+      invalid(source, `"${String(key)}" cannot be patched; only ${PATCHABLE.join(", ")} can.`);
+    }
+  }
+  const { meta, tags, description, deprecated, invoke } = patch;
+  if ("meta" in patch && (typeof meta !== "object" || meta === null || Array.isArray(meta))) {
+    invalid(source, "Expected meta to be an object.");
+  }
+  if ("tags" in patch && (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string"))) {
+    invalid(source, "Expected tags to be a list of strings.");
+  }
+  if ("description" in patch && description !== undefined && typeof description !== "string") {
+    invalid(source, "Expected description to be a string.");
+  }
+  if ("deprecated" in patch && typeof deprecated !== "boolean") {
+    invalid(source, "Expected deprecated to be a boolean.");
+  }
+  if ("invoke" in patch && typeof invoke !== "function") {
+    invalid(source, "Expected invoke to be a function.");
+  }
+  return Object.freeze({
+    ...operation,
+    ..."meta" in patch ? { meta: Object.freeze({ ...meta }) } : {},
+    ..."tags" in patch ? { tags: Object.freeze([...tags ?? []]) } : {},
+    ..."description" in patch ? { description } : {},
+    ..."deprecated" in patch ? { deprecated } : {},
+    ..."invoke" in patch ? { invoke } : {}
+  });
+}
+function operationsOfCommand(command) {
+  return command.operations.map((name) => {
+    const UseCase = command.useCases[name];
+    const context = command.context ?? UseCase.context;
+    const description = UseCase.description ?? command.description;
+    const id = `${command.commandName}.${name}`;
+    const run = command.run;
+    const guard = UseCase.access === undefined ? undefined : accessGuardOf(id, UseCase.access, context);
+    return Object.freeze({
+      kind: "operation",
+      version: 1,
+      id,
+      command: command.commandName,
+      name,
+      useCase: UseCase.useCaseName,
+      ...description === undefined ? {} : { description },
+      tags: Object.freeze([
+        ...new Set([...command.tags, ...UseCase.tags])
+      ]),
+      deprecated: UseCase.deprecated,
+      input: UseCase.blueprint,
+      response: UseCase.response,
+      ...context ? { context } : {},
+      errors: UseCase.errors,
+      ...UseCase.route === undefined ? {} : { route: UseCase.route },
+      ...UseCase.access === undefined ? {} : { access: UseCase.access },
+      meta: Object.freeze({}),
+      invoke: guard ? async (input, options) => run(name, input, guard(input, options)) : (input, options) => run(name, input, options && "principal" in options ? { context: options.context } : options)
+    });
+  });
+}
+function statusesOf(name, statuses) {
+  if (statuses === undefined)
+    return Object.freeze({});
+  if (typeof statuses !== "object" || statuses === null || Array.isArray(statuses)) {
+    invalid(name, "Expected statuses to be a map of exception names to statuses.");
+  }
+  for (const [exception, status] of Object.entries(statuses)) {
+    if (!exception || typeof status !== "number" || !Number.isInteger(status) || status < 400 || status > 599) {
+      invalid(name, `Expected the status of "${exception}" to be an integer between 400 and 599.`);
+    }
+  }
+  return Object.freeze({ ...statuses });
+}
+function checkPipe(name, pipe) {
+  if (!Array.isArray(pipe))
+    invalid(name, "Expected pipe to be a list of stages.");
+  const stages = pipe;
+  stages.forEach((stage, index) => {
+    if (!isStage(stage)) {
+      invalid(name, `Expected pipe[${index}] to be a transform or sink stage.`);
+    }
+    if (stage.kind === "sink" && index !== stages.length - 1) {
+      invalid(name, `The sink at pipe[${index}] must be the last stage.`);
+    }
+  });
+  return Object.freeze([...stages]);
+}
+function transformed(name, operations, transforms, context) {
+  let current = operations;
+  for (const stage of transforms) {
+    if (stage.kind !== "transform")
+      continue;
+    const next = [];
+    for (const operation of current) {
+      const result = stage.apply(operation, context);
+      if (result === null)
+        continue;
+      if (typeof result !== "object" || result?.kind !== "operation" || result.id !== operation.id) {
+        invalid(name, `A transform must return the operation "${operation.id}" or null.`);
+      }
+      next.push(result);
+    }
+    current = next;
+  }
+  return Object.freeze([...current]);
+}
+function make(name, commands, operations, stages, statuses) {
+  const context = Object.freeze({
+    output: Object.freeze({ name, statuses })
+  });
+  let built;
+  const output = {
+    [Kind2]: "output",
+    outputName: name,
+    commands,
+    operations,
+    stages,
+    statuses,
+    build() {
+      if (built)
+        return built.value;
+      const sink = stages.at(-1);
+      if (sink?.kind !== "sink") {
+        invalid(name || "output", "The pipe has no sink to build.");
+      }
+      built = { value: sink.build(operations, context) };
+      return built.value;
+    },
+    pipe(...more) {
+      const next = checkPipe(name || "output", more);
+      const last = next.at(-1);
+      if (stages.at(-1)?.kind === "sink") {
+        invalid(name || "output", "Cannot add stages after the sink.");
+      }
+      const ops = transformed(name, operations, next, context);
+      if (last?.kind === "sink") {
+        return last.build(ops, context);
+      }
+      return make("", commands, ops, Object.freeze([...stages, ...next]), statuses);
+    }
+  };
+  return Object.freeze(output);
+}
+function outputOf2(settings) {
+  const { name, commands } = settings ?? {};
+  if (typeof name !== "string" || !name.trim()) {
+    invalid("outputOf", "Expected name to be a non-empty string.");
+  }
+  const sources = Array.isArray(commands) ? commands : [commands];
+  if (!Array.isArray(commands) && isCommand2(commands) || sources.some((entry) => !isCommand2(entry) && !isApplicationLike(entry))) {
+    invalid(name, "Expected commands to be a list of commands made by commandOf or applications.");
+  }
+  const flat = [
+    ...new Set(sources.flatMap((entry) => isCommand2(entry) ? [entry] : Object.values(entry.commands)))
+  ];
+  const statuses = statusesOf(name, settings.statuses);
+  const stages = checkPipe(name, settings.pipe ?? []);
+  const all = flat.flatMap(operationsOfCommand);
+  const ids = new Set;
+  for (const { id } of all) {
+    if (ids.has(id))
+      throw new DuplicateOperation2({ source: name, details: { id } });
+    ids.add(id);
+  }
+  const context = { output: { name, statuses } };
+  const operations = transformed(name, all, stages, context);
+  return make(name, Object.freeze(flat), operations, stages, statuses);
+}
+function isOutput2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "output";
+}
+
+// src/core/use-case/steps/describe.ts
+function cloneData(value) {
+  if (Array.isArray(value))
+    return value.map(cloneData);
+  if (isPlain(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, cloneData(item)]));
+  }
+  return value;
+}
+function describeSteps(steps, names) {
+  return steps.map((step) => {
+    const copy = cloneData({ ...step });
+    if (Object.hasOwn(step, "build"))
+      copy.build = names.record(step.build);
+    if (Object.hasOwn(step, "ensure"))
+      copy.error = names.error(step.error);
+    if (Object.hasOwn(step, "run"))
+      copy.fn = { kind: "opaque" };
+    return copy;
+  });
+}
+
+// src/core/repository/migrate.ts
+var aliases = new WeakMap;
+function aliasOf(entity, name) {
+  let byName = aliases.get(entity);
+  if (!byName) {
+    byName = new Map;
+    aliases.set(entity, byName);
+  }
+  let alias = byName.get(name);
+  if (!alias) {
+    const Entity = entity;
+    alias = class extends Entity {
+    };
+    Object.defineProperty(alias, "name", { value: name });
+    Object.defineProperty(alias, "recordName", { value: name });
+    byName.set(name, alias);
+  }
+  return alias;
+}
+function previousContextOf(context, name) {
+  return Object.freeze({
+    ...context,
+    entity: aliasOf(context.entity, name),
+    name: `${name}Repository`
+  });
+}
+async function walk(provider, context, pageSize, visit) {
+  const keyset = provider.capabilities?.keyset === true;
+  let after;
+  let offset = 0;
+  for (;; ) {
+    const query = {
+      orderBy: [{ key: "id", direction: "asc" }],
+      withDeleted: true,
+      ...context.expiry === undefined ? {} : { withExpired: true },
+      limit: pageSize,
+      ...keyset ? after === undefined ? {} : { after } : offset === 0 ? {} : { offset }
+    };
+    const rows = await provider.findMany(context, query);
+    if (rows.length === 0)
+      return;
+    const removed = await visit(rows);
+    after = [rows.at(-1).id];
+    offset += rows.length - removed;
+    if (rows.length < pageSize)
+      return;
+  }
+}
+function issuesOf(source, error) {
+  const issues = error?.details?.issues;
+  if (Array.isArray(issues))
+    return issues;
+  const cause = error instanceof Exception2 && error.is(InvalidRepositoryData2) ? error.cause ?? error : error;
+  return [
+    {
+      code: "invalid_value",
+      path: [],
+      message: cause instanceof Error ? cause.message : String(cause),
+      source,
+      ...cause instanceof Exception2 ? { cause } : {}
+    }
+  ];
+}
+async function upcastPage(state, plan, rows) {
+  const brought = rows.map((row) => {
+    const report = {
+      from: 1,
+      renamed: [],
+      filled: [],
+      removed: []
+    };
+    try {
+      return {
+        row,
+        current: upcast(state.name, plan, row, true, report),
+        report
+      };
+    } catch (error) {
+      return { row, invalid: issuesOf(state.name, error) };
+    }
+  });
+  const valid = brought.filter((item) => ("current" in item));
+  const parse = (data) => state.entity.safeParse(data);
+  const resolvedOf = async (items) => resolveReferences(state, items.map((item) => item.current), new Map);
+  let resolved;
+  try {
+    resolved = await resolvedOf(valid);
+  } catch {
+    resolved = await Promise.all(valid.map(async (item) => {
+      try {
+        return (await resolvedOf([item]))[0];
+      } catch (error) {
+        return issuesOf(state.name, error);
+      }
+    }));
+  }
+  const checked = new Map;
+  valid.forEach((item, index) => {
+    const data = resolved[index];
+    if (Array.isArray(data)) {
+      checked.set(item.row, data);
+      return;
+    }
+    const parsed = parse(data);
+    if (parsed.issues)
+      checked.set(item.row, parsed.issues);
+  });
+  return brought.map((item) => {
+    const issues = checked.get(item.row);
+    return issues === undefined ? item : { row: item.row, invalid: issues };
+  });
+}
+function writtenOf(state, plan, item, destructive) {
+  const data = destructive ? item.current : upcast(state.name, plan, item.row, false);
+  return plan.versioned ? { ...data, [SCHEMA_VERSION_KEY2]: plan.version } : data;
+}
+async function migrateRepository(state, options) {
+  const { mode, destructive, pageSize } = options;
+  const apply = mode === "apply";
+  const { provider } = state;
+  const context = contextOf(state);
+  const plan = fullUpcastPlanOf(state.entity);
+  const versioned = isVersionedEntityClass(state.entity) && provider.capabilities?.versioning === true;
+  const own = recordNameOf2(state.entity);
+  const previousNames = (state.entity[EntitySettings2]?.previousNames ?? []).filter((previous) => previous !== own && `${previous}Repository` !== context.name);
+  const needs = ["findMany"];
+  if (apply)
+    needs.push("update");
+  if (apply && previousNames.length > 0)
+    needs.push("insert");
+  if (apply && destructive && previousNames.length > 0)
+    needs.push("remove");
+  for (const need of needs) {
+    if (typeof provider[need] !== "function") {
+      throw new InvalidRepositoryDeclaration2({
+        source: state.name,
+        details: { reason: `The provider has no "${need}" to migrate.` }
+      });
+    }
+  }
+  const tally = {
+    scanned: 0,
+    upToDate: 0,
+    upgraded: 0,
+    removalPending: 0,
+    movedFromPreviousNames: 0,
+    invalid: [],
+    removedKeys: new Set
+  };
+  if (apply) {
+    const migrated = await provider.migrate?.(context, options.plan);
+    if (typeof migrated === "object" && migrated !== null && migrated.deferred === true) {
+      return { ...reportOf(tally), deferred: true };
+    }
+  }
+  await walk(provider, context, pageSize, async (rows) => {
+    for (const item of await upcastPage(state, plan, rows)) {
+      tally.scanned += 1;
+      if ("invalid" in item) {
+        tally.invalid.push({ id: String(item.row.id), issues: item.invalid });
+        continue;
+      }
+      const { report } = item;
+      for (const key of report.removed)
+        tally.removedKeys.add(key);
+      const pending = plan.versioned && report.from < plan.version || report.renamed.length > 0 || report.filled.length > 0;
+      const removal = report.removed.length > 0;
+      if (pending || removal && destructive) {
+        tally.upgraded += 1;
+        if (apply) {
+          const expected = item.row.version;
+          try {
+            await provider.update(context, writtenOf(state, plan, item, destructive), versioned && typeof expected === "number" ? { expectedVersion: expected } : undefined);
+          } catch (error) {
+            if (!(error instanceof Exception2) || !error.is(RepositoryConcurrencyConflict2)) {
+              throw error;
+            }
+            tally.upgraded -= 1;
+            tally.upToDate += 1;
+          }
+        }
+      } else if (removal) {
+        tally.removalPending += 1;
+      } else {
+        tally.upToDate += 1;
+      }
+    }
+    return 0;
+  });
+  for (const previous of previousNames) {
+    const old = previousContextOf(context, previous);
+    await walk(provider, old, pageSize, async (rows) => {
+      let removed = 0;
+      const moved = new Set((await provider.findMany(context, {
+        where: { id: { in: rows.map((row) => row.id) } },
+        withDeleted: true,
+        ...context.expiry === undefined ? {} : { withExpired: true }
+      })).map((row) => String(row.id)));
+      for (const item of await upcastPage(state, plan, rows)) {
+        tally.scanned += 1;
+        if ("invalid" in item) {
+          tally.invalid.push({
+            id: String(item.row.id),
+            issues: item.invalid
+          });
+          continue;
+        }
+        for (const key of item.report.removed)
+          tally.removedKeys.add(key);
+        const id = String(item.row.id);
+        if (!moved.has(id)) {
+          tally.movedFromPreviousNames += 1;
+          if (apply) {
+            await provider.insert(context, writtenOf(state, plan, item, destructive));
+          }
+        }
+        if (apply && destructive) {
+          await provider.remove(old, id);
+          removed += 1;
+        }
+      }
+      return removed;
+    });
+  }
+  return { ...reportOf(tally), deferred: false };
+}
+function reportOf(tally) {
+  return {
+    scanned: tally.scanned,
+    upToDate: tally.upToDate,
+    upgraded: tally.upgraded,
+    removalPending: tally.removalPending,
+    invalid: tally.invalid,
+    movedFromPreviousNames: tally.movedFromPreviousNames,
+    removedKeys: [...tally.removedKeys].sort()
+  };
+}
+
+// src/core/application/migrate.ts
+async function migrateApplication(source, options) {
+  const fail = (reason) => {
+    throw new InvalidSchemaMigration2({
+      source: source.name,
+      details: { reason }
+    });
+  };
+  if (typeof options !== "object" || options === null) {
+    fail('Expected the options of migrate, e.g. { mode: "check" }.');
+  }
+  const { mode, destructive = false, pageSize = 100, lock } = options;
+  if (mode !== "check" && mode !== "apply") {
+    fail('Expected mode to be "check" or "apply".');
+  }
+  if (typeof destructive !== "boolean") {
+    fail("Expected destructive to be a boolean.");
+  }
+  if (!Number.isSafeInteger(pageSize) || pageSize < 1) {
+    fail("Expected pageSize to be a positive integer.");
+  }
+  if (lock !== undefined && !isLock(lock)) {
+    fail("Expected lock to be a schema lock ({ lockVersion: 1, entities }).");
+  }
+  const byEntity = new Map;
+  for (const repository of source.repositories) {
+    const state = findState(repository);
+    if (state && !byEntity.has(state.entity))
+      byEntity.set(state.entity, state);
+  }
+  const names = options.entities ?? [...source.entities].filter(([, entity]) => byEntity.has(entity)).map(([name]) => name);
+  if (!Array.isArray(names))
+    fail("Expected entities to be a list of names.");
+  const targets = [];
+  for (const name of names) {
+    const entity = source.entities.get(name);
+    if (entity === undefined) {
+      fail(`"${name}" is not an entity of the application.`);
+    }
+    const state = byEntity.get(entity);
+    if (state === undefined) {
+      fail(`The entity "${name}" has no repository to migrate it through.`);
+    }
+    targets.push([name, state]);
+  }
+  const changes = lock === undefined ? [] : diffSchemas2(lock, schemaLockOf2(source.describe()));
+  const entities = {};
+  for (const [name, state] of targets) {
+    entities[name] = await migrateRepository(state, {
+      mode,
+      destructive,
+      pageSize,
+      plan: Object.freeze({
+        entity: name,
+        changes: changes.filter((change) => change.entity === name),
+        destructive
+      })
+    });
+  }
+  return { mode, destructive, entities };
+}
+function isLock(value) {
+  return typeof value === "object" && value !== null && value.lockVersion === 1 && typeof value.entities === "object" && value.entities !== null;
+}
+
+// src/core/application/start.ts
+function providerFrom2(environmentDependencies, create) {
+  if (typeof environmentDependencies === "function" && create === undefined) {
+    return Object.freeze({
+      [Kind2]: "provider-factory",
+      environments: Object.freeze([]),
+      create: environmentDependencies,
+      withContext: true
+    });
+  }
+  const list = isEnvironment(environmentDependencies) ? [environmentDependencies] : Array.isArray(environmentDependencies) ? [...environmentDependencies] : [null];
+  if (!list.every(isEnvironment) || new Set(list).size !== list.length || typeof create !== "function") {
+    throw new InvalidApplicationDeclaration2({
+      source: "providerFrom",
+      details: {
+        reason: "Expected distinct environments made by environmentOf and a create function."
+      }
+    });
+  }
+  return Object.freeze({
+    [Kind2]: "provider-factory",
+    environments: Object.freeze(list),
+    create,
+    withContext: false
+  });
+}
+function logFrom2(create) {
+  if (typeof create !== "function") {
+    throw new InvalidApplicationDeclaration2({
+      source: "logFrom",
+      details: { reason: "Expected logFrom to take a create function." }
+    });
+  }
+  return Object.freeze({ [Kind2]: "log-factory", create });
+}
+function isLogFactory(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "log-factory";
+}
+function isProviderFactory2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "provider-factory";
+}
+var deferred = new WeakMap;
+var METHODS = [
+  "findOne",
+  "findMany",
+  "insert",
+  "update",
+  "remove",
+  "count"
+];
+function deferredProvider(factory, application) {
+  const state = {
+    factory,
+    application,
+    provider: undefined,
+    starting: undefined
+  };
+  const real = (method) => {
+    const { provider } = state;
+    if (!provider) {
+      throw new ApplicationNotStarted2({
+        source: application,
+        details: { application }
+      });
+    }
+    if (typeof provider[method] !== "function") {
+      throw new InvalidApplicationDeclaration2({
+        source: application,
+        details: {
+          reason: `The provider made on start has no "${method}".`
+        }
+      });
+    }
+    return provider;
+  };
+  const proxy = {};
+  for (const method of [...METHODS, "increment"]) {
+    proxy[method] = (...args) => real(method)[method]?.(...args);
+  }
+  proxy.transaction = (run) => real("transaction").transaction(run);
+  proxy.migrate = async (...args) => {
+    const { provider } = state;
+    if (!provider)
+      real("migrate");
+    return provider?.migrate?.(...args);
+  };
+  Object.defineProperty(proxy, "capabilities", {
+    get: () => state.provider?.capabilities,
+    enumerable: true
+  });
+  Object.freeze(proxy);
+  deferred.set(proxy, state);
+  return proxy;
+}
+function isDeferredProvider(provider) {
+  return typeof provider === "object" && provider !== null && deferred.has(provider);
+}
+function deferredEnvironments(provider) {
+  return (typeof provider === "object" && provider !== null ? deferred.get(provider)?.factory.environments : undefined) ?? [];
+}
+function startDeferred(provider, context) {
+  const state = deferred.get(provider);
+  if (!state)
+    return;
+  state.starting ??= (async () => {
+    const made = await state.factory.create(state.factory.withContext ? context : loadEnvironments(state.factory.environments));
+    if (typeof made !== "object" || made === null) {
+      state.starting = undefined;
+      throw new InvalidApplicationDeclaration2({
+        source: state.application,
+        details: {
+          reason: "Expected providerFrom's create to give a repository provider."
+        }
+      });
+    }
+    state.provider = made;
+    return made;
+  })();
+  return state.starting;
+}
+async function stopProvider(provider) {
+  const state = deferred.get(provider);
+  if (!state) {
+    await provider.close?.();
+    return;
+  }
+  const made = state.provider;
+  state.provider = undefined;
+  state.starting = undefined;
+  await made?.close?.();
+}
+function checkTransactions(source, provider, commands) {
+  if (commands.length === 0)
+    return;
+  if (typeof provider.transaction !== "function" || provider.capabilities?.transactions === false) {
+    throw new InvalidCommandDeclaration2({
+      source,
+      details: {
+        reason: `The provider made on start does not support transactions, which ${commands.join(", ")} declare.`
+      }
+    });
+  }
+}
+function checkCapabilities(source, provider, repositories) {
+  if (repositories.length === 0 || provider.capabilities?.keyset === true)
+    return;
+  throw new InvalidApplicationDeclaration2({
+    source,
+    details: {
+      reason: `The provider made on start does not read by cursor (capabilities.keyset), which the findCursor of ${repositories.join(", ")} needs.`
+    }
+  });
+}
+
+// src/core/application/providers.ts
+var slots = new WeakMap;
+var storages = new WeakMap;
+var METHODS2 = [
+  "findOne",
+  "findMany",
+  "insert",
+  "update",
+  "remove",
+  "count"
+];
+var KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RESERVED = new Set(["inMemory", "__proto__", "constructor", "prototype"]);
+function invalid2(reason) {
+  throw new InvalidApplicationDeclaration2({
+    source: "providersOf",
+    details: { reason }
+  });
+}
+function isProviderObject(value) {
+  return typeof value === "object" && value !== null && !isProviderFactory2(value) && METHODS2.some((method) => typeof value[method] === "function");
+}
+function slotOf(key, storage, value) {
+  const slot = {
+    [Kind2]: "provider-slot",
+    key
+  };
+  if (isProviderFactory2(value)) {
+    const unbound = () => {
+      throw new ProviderNotBound2({ source: key, details: { provider: key } });
+    };
+    for (const method of METHODS2)
+      slot[method] = unbound;
+    slot.transaction = unbound;
+    slot.increment = unbound;
+    Object.defineProperty(slot, "capabilities", {
+      get: () => {
+        return;
+      },
+      enumerable: true
+    });
+  } else {
+    const target = value;
+    for (const method of [
+      ...METHODS2,
+      "increment",
+      "transaction",
+      "close",
+      "migrate"
+    ]) {
+      if (typeof target[method] === "function") {
+        slot[method] = (...args) => target[method]?.(...args);
+      }
+    }
+    Object.defineProperty(slot, "capabilities", {
+      get: () => value.capabilities,
+      enumerable: true
+    });
+  }
+  Object.freeze(slot);
+  slots.set(slot, { key, storage, value });
+  return slot;
+}
+function providersOf2(entries) {
+  if (typeof entries !== "object" || entries === null || Array.isArray(entries) || Object.keys(entries).length === 0) {
+    invalid2("Expected an object of providers by key.");
+  }
+  const storage = Object.create(null);
+  storage[Kind2] = "provider-storage";
+  const seen = new Map;
+  const list = [];
+  for (const [key, value] of Object.entries(entries)) {
+    if (!KEY.test(key) || RESERVED.has(key)) {
+      invalid2(key === "inMemory" ? `"inMemory" is the built-in provider; choose another key.` : `Expected "${key}" to be an identifier that is not reserved.`);
+    }
+    if (isProviderSlot(value)) {
+      invalid2(`"${key}" holds a provider of another storage; a storage holds providers, not slots.`);
+    }
+    if (!isProviderFactory2(value) && !isProviderObject(value)) {
+      invalid2(`Expected "${key}" to be a repository provider or a factory of providerFrom.`);
+    }
+    const other = seen.get(value);
+    if (other !== undefined) {
+      invalid2(`"${other}" and "${key}" hold the same provider.`);
+    }
+    seen.set(value, key);
+    const slot = slotOf(key, storage, value);
+    storage[key] = slot;
+    list.push(slot);
+  }
+  Object.freeze(storage);
+  storages.set(storage, Object.freeze(list));
+  return storage;
+}
+function isProviderSlot(value) {
+  return typeof value === "object" && value !== null && slots.has(value);
+}
+function isProviderStorage(value) {
+  return typeof value === "object" && value !== null && storages.has(value);
+}
+function slotsOf(storage) {
+  return storages.get(storage) ?? [];
+}
+function slotEntry(slot) {
+  return slots.get(slot);
+}
+
+// src/core/application/application.ts
+var KEYS = [
+  "properties",
+  "blueprints",
+  "records",
+  "entities",
+  "environments",
+  "repositories",
+  "useCases",
+  "commands",
+  "outputs",
+  "exceptions"
+];
+var internals = new WeakMap;
+var logSettings = new WeakMap;
+var namedProviders = new WeakMap;
+var defaultSlots = new WeakMap;
+function referenceOf(slot) {
+  return { kind: "ref", key: slotEntry(slot).key };
+}
+var KIND_OF = {
+  properties: "property",
+  blueprints: "blueprint",
+  records: "record",
+  entities: "entity",
+  environments: "environment",
+  repositories: "repository",
+  useCases: "use case",
+  commands: "command",
+  outputs: "output",
+  exceptions: "exception"
+};
+function isApplication(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "application";
+}
+function invalid3(source, reason) {
+  throw new InvalidApplicationDeclaration2({ source, details: { reason } });
+}
+var publisherOrigins = new WeakMap;
+function publishersOf(name, declared, extended) {
+  const merged = {};
+  const origins = {};
+  for (const other of extended) {
+    Object.assign(merged, other[ApplicationPublishersKey]);
+    Object.assign(origins, publisherOrigins.get(other));
+  }
+  if (declared !== undefined) {
+    if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
+      invalid3(name, "Expected `publishers` to be an object of publishers by key.");
+    }
+    for (const [key, publisher] of Object.entries(declared)) {
+      if (!/^[A-Za-z_$][\w$]*$/.test(key)) {
+        invalid3(name, `Expected the publisher key "${key}" to be an identifier.`);
+      }
+      if (!isEventPublisher(publisher)) {
+        invalid3(name, `Expected the publisher "${key}" to be an object with a publish(topic, event) method.`);
+      }
+      merged[key] = publisher;
+      origins[key] = name;
+    }
+  }
+  return { publishers: Object.freeze(merged), origins };
+}
+function isOfKind(collection, value) {
+  switch (collection) {
+    case "properties":
+      return isProperty(value);
+    case "blueprints":
+      return isBlueprint(value);
+    case "records":
+      return isRecordClass(value) && !isEntityClass2(value);
+    case "entities":
+      return isEntityClass2(value);
+    case "environments":
+      return isEnvironment(value);
+    case "repositories":
+      return inspectRepository(value) !== undefined;
+    case "useCases":
+      return isUseCaseClass2(value);
+    case "commands":
+      return isCommand2(value);
+    case "outputs":
+      return isOutput2(value);
+    case "exceptions":
+      return isDeclaredException(value);
+  }
+}
+function keyOf(collection, value) {
+  switch (collection) {
+    case "properties":
+      return fieldOf(value);
+    case "blueprints":
+      return value.properties;
+    case "repositories":
+      return inspectRepository(value).state;
+    default:
+      return value;
+  }
+}
+function emptyRegistry() {
+  return Object.fromEntries(KEYS.map((key) => [key, new Map]));
+}
+function resolve(settings) {
+  const registry = emptyRegistry();
+  const byKey = new Map;
+  const source = settings.name;
+  const add = (entry) => {
+    const same = registry[entry.collection].get(entry.name);
+    if (same) {
+      if (same.key === entry.key)
+        return;
+      conflict(`${KIND_OF[entry.collection]} "${entry.name}" is declared as different objects by "${same.from}" and by "${entry.from}".`, same, entry);
+    }
+    const other = byKey.get(entry.key);
+    if (other) {
+      if (other.from === entry.from) {
+        throw new DuplicateApplicationDeclaration2({
+          source,
+          details: {
+            first: `${KIND_OF[other.collection]} "${other.name}"`,
+            second: `${KIND_OF[entry.collection]} "${entry.name}"`
+          }
+        });
+      }
+      conflict(`The same ${KIND_OF[entry.collection]} is ${KIND_OF[other.collection]} "${other.name}" in "${other.from}" and ${KIND_OF[entry.collection]} "${entry.name}" in "${entry.from}".`, other, entry);
+    }
+    registry[entry.collection].set(entry.name, entry);
+    byKey.set(entry.key, entry);
+  };
+  const conflict = (reason, first, second) => {
+    throw new ApplicationConflict2({
+      source,
+      details: {
+        reason,
+        origins: [first.from, second.from],
+        declarations: [
+          `${KIND_OF[first.collection]} ${first.name}`,
+          `${KIND_OF[second.collection]} ${second.name}`
+        ]
+      }
+    });
+  };
+  for (const other of settings.extends ?? []) {
+    const resolved = internals.get(other);
+    if (!resolved)
+      invalid3(source, "Expected `extends` to hold applications.");
+    for (const key of KEYS) {
+      for (const entry of resolved[key].values())
+        add(entry);
+    }
+  }
+  for (const collection of KEYS) {
+    const declared = settings[collection];
+    if (declared === undefined)
+      continue;
+    if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
+      invalid3(source, `Expected ${collection} to be an object of declarations.`);
+    }
+    for (const [name, value] of Object.entries(declared)) {
+      if (!isOfKind(collection, value)) {
+        invalid3(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 : collection === "records" || collection === "entities" ? declaredRecordNameOf(value) ?? name : name;
+      if (declaredName !== name) {
+        invalid3(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
+      }
+      add({
+        collection,
+        name,
+        value,
+        key: keyOf(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) {
+  const found = new Set;
+  const visit = (field) => {
+    if (isBlueprintList(field))
+      visit(field.item);
+    else if (isBlueprint(field))
+      walk(field.properties);
+    else if (isBlueprintVariant(field)) {
+      for (const variant of Object.values(field.variants)) {
+        visit(variant);
+      }
+    } else {
+      const record = recordFieldOf(field)?.record;
+      if (record)
+        found.add(record);
+    }
+  };
+  const walk = (collection) => {
+    for (const field of Object.values(collection))
+      visit(field);
+  };
+  walk(properties);
+  return found;
+}
+function validate(source, registry) {
+  const registered = new Set([
+    ...[...registry.records.values()].map((entry) => entry.key),
+    ...[...registry.entities.values()].map((entry) => entry.key)
+  ]);
+  const holders = [
+    ["blueprints", "properties"],
+    ["records", "blueprint.properties"],
+    ["entities", "blueprint.properties"]
+  ];
+  for (const [collection] of holders) {
+    for (const entry of registry[collection].values()) {
+      const properties = collection === "blueprints" ? entry.value.properties : entry.value.blueprint.properties;
+      for (const record of recordsIn(properties)) {
+        if (registered.has(record))
+          continue;
+        throw new UnregisteredApplicationReference2({
+          source,
+          details: {
+            holder: `${KIND_OF[collection]} "${entry.name}"`,
+            reference: `${isEntityClass2(record) ? "entity" : "record"} "${recordNameOf2(record)}"`
+          }
+        });
+      }
+    }
+  }
+  const repositories = new Set([...registry.repositories.values()].map((entry) => entry.key));
+  const environments = new Set([...registry.environments.values()].map((entry) => entry.key));
+  const unregistered = (repository, dependency) => {
+    throw new UnregisteredRepositoryDependency2({
+      source,
+      details: { repository, dependency }
+    });
+  };
+  for (const entry of registry.repositories.values()) {
+    const info = inspectRepository(entry.value);
+    if (!registered.has(info.entity)) {
+      unregistered(entry.name, `entity "${info.entity.name}"`);
+    }
+    for (const relation of info.relations) {
+      if (!repositories.has(relation)) {
+        unregistered(entry.name, `the repository of "${recordNameOf2(relation.entity)}"`);
+      }
+    }
+    for (const environment of info.environments) {
+      if (!environments.has(environment)) {
+        unregistered(entry.name, "an environment");
+      }
+    }
+  }
+}
+function validateCommands(source, registry) {
+  const useCases = new Set([...registry.useCases.values()].map((entry) => entry.key));
+  const environments = new Set([...registry.environments.values()].map((entry) => entry.key));
+  for (const entry of registry.commands.values()) {
+    const command = entry.value;
+    for (const environment of command.environments) {
+      if (environments.has(environment))
+        continue;
+      throw new UnregisteredApplicationReference2({
+        source,
+        details: {
+          holder: `command "${entry.name}"`,
+          reference: "an environment",
+          command: entry.name
+        }
+      });
+    }
+    for (const UseCase of Object.values(command.useCases)) {
+      if (useCases.has(UseCase))
+        continue;
+      throw new UnregisteredApplicationReference2({
+        source,
+        details: {
+          holder: `command "${entry.name}"`,
+          reference: `use case "${UseCase.useCaseName}"`,
+          command: entry.name,
+          useCase: UseCase.useCaseName
+        }
+      });
+    }
+  }
+}
+function validateOutputs(source, registry) {
+  const commands = new Set([...registry.commands.values()].map((entry) => entry.key));
+  for (const entry of registry.outputs.values()) {
+    const output = entry.value;
+    if (!output.outputName) {
+      invalid3(source, `outputs.${entry.name} has no name (an output made by pipe cannot be registered).`);
+    }
+    for (const command of output.commands) {
+      if (commands.has(command))
+        continue;
+      throw new UnregisteredApplicationReference2({
+        source,
+        details: {
+          holder: `output "${entry.name}"`,
+          reference: `command "${command.commandName}"`,
+          output: entry.name,
+          command: command.commandName
+        }
+      });
+    }
+  }
+}
+function validateUseCases(source, registry) {
+  const registered = new Set([
+    ...[...registry.records.values()].map((entry) => entry.key),
+    ...[...registry.entities.values()].map((entry) => entry.key)
+  ]);
+  const known = (collection) => new Set([...registry[collection].values()].map((entry) => entry.key));
+  const useCases = known("useCases");
+  const repositories = known("repositories");
+  const environments = known("environments");
+  const exceptions = known("exceptions");
+  for (const entry of registry.useCases.values()) {
+    const UseCase = entry.value;
+    for (const [key, dependency] of Object.entries(UseCase.dependencies)) {
+      const found = isLoggerDeclaration(dependency) ? true : isUseCaseClass2(dependency) ? useCases.has(dependency) : isEnvironment(dependency) ? environments.has(dependency) : repositories.has(inspectRepository(dependency).state);
+      if (!found) {
+        throw new UnregisteredUseCaseDependency2({
+          source,
+          details: { useCase: `"${entry.name}"`, dependency: `"${key}"` }
+        });
+      }
+    }
+    for (const [part, blueprint] of [
+      ["blueprint", UseCase.blueprint],
+      ["response", UseCase.response],
+      ["context", UseCase.context]
+    ]) {
+      if (blueprint === undefined)
+        continue;
+      for (const record of recordsIn(blueprint.properties)) {
+        if (registered.has(record))
+          continue;
+        throw new UnregisteredApplicationReference2({
+          source,
+          details: {
+            holder: `the ${part} of use case "${entry.name}"`,
+            reference: `${isEntityClass2(record) ? "entity" : "record"} "${recordNameOf2(record)}"`
+          }
+        });
+      }
+    }
+    for (const Thrown of UseCase.errors) {
+      if (exceptions.has(Thrown) || isExportedException(Thrown))
+        continue;
+      throw new UnregisteredApplicationReference2({
+        source,
+        details: {
+          holder: `use case "${entry.name}"`,
+          reference: `exception "${Thrown.name}"`
+        }
+      });
+    }
+    for (const [index, step] of (interpretedStepsOf(UseCase) ?? []).entries()) {
+      const holder = `step ${index} of use case "${entry.name}"`;
+      if (step.build !== undefined && !registered.has(step.build)) {
+        throw new UnregisteredApplicationReference2({
+          source,
+          details: {
+            holder,
+            reference: `${isEntityClass2(step.build) ? "entity" : "record"} "${recordNameOf2(step.build)}"`
+          }
+        });
+      }
+      const Thrown = step.error;
+      if (Thrown !== undefined && !exceptions.has(Thrown) && !isExportedException(Thrown)) {
+        throw new UnregisteredApplicationReference2({
+          source,
+          details: { holder, reference: `exception "${Thrown.name}"` }
+        });
+      }
+    }
+  }
+}
+function jsonOf(value) {
+  return JSON.parse(JSON.stringify(value, (_key, item) => item instanceof RegExp ? item.source : item));
+}
+function referencesOf(registry, collection) {
+  return new Map([...registry[collection].values()].map((entry) => [entry.key, entry.name]));
+}
+function propertyReferenceOf(Property, scope) {
+  const ref = scope.properties.get(fieldOf(Property));
+  return ref === undefined ? propertyDescriptionOf(Property, scope) : { ref };
+}
+function lineageDescriptionOf(lineage, scope) {
+  switch (lineage.kind) {
+    case "refined":
+      return {
+        kind: "refined",
+        base: propertyReferenceOf(lineage.base, scope),
+        options: jsonOf(lineage.options)
+      };
+    case "optional":
+      return {
+        kind: "optional",
+        base: propertyReferenceOf(lineage.base, scope)
+      };
+    case "factory":
+      return {
+        kind: "factory",
+        factory: lineage.factory,
+        args: jsonOf(lineage.args)
+      };
+  }
+}
+function propertyDescriptionOf(Property, scope) {
+  const { type } = Property;
+  const lineage = propertyLineageOf2(Property);
+  return {
+    name: type.name,
+    optional: type.optional === true,
+    sensitive: type.sensitive === true,
+    unique: type.unique === true,
+    schema: plainOf(type.schema.type.Type()),
+    ...lineage ? { lineage: lineageDescriptionOf(lineage, scope) } : {}
+  };
+}
+function fieldDescriptionOf(field, scope) {
+  if (isProperty(field)) {
+    const real = fieldOf(field);
+    const ref = scope.properties.get(real);
+    return ref === undefined ? { kind: "property", ...propertyDescriptionOf(real, scope) } : { kind: "property", ref, optional: real.type.optional === true };
+  }
+  if (isBlueprintList(field)) {
+    return {
+      kind: "list",
+      item: fieldDescriptionOf(field.item, scope),
+      optional: field.optional,
+      ...field.minItems === undefined ? {} : { minItems: field.minItems },
+      ...field.maxItems === undefined ? {} : { maxItems: field.maxItems }
+    };
+  }
+  if (isBlueprint(field)) {
+    const ref = scope.blueprints.get(field.properties);
+    return ref === undefined ? {
+      kind: "blueprint",
+      optional: field.optional,
+      fields: fieldsDescriptionOf(field.properties, scope)
+    } : { kind: "blueprint", ref, optional: field.optional };
+  }
+  if (isBlueprintVariant(field)) {
+    const variants = field.variants;
+    return {
+      kind: "variant",
+      key: field.key,
+      optional: field.optional,
+      variants: Object.fromEntries(Object.entries(variants).map(([tag, variant]) => [
+        tag,
+        fieldDescriptionOf(variant, scope)
+      ]))
+    };
+  }
+  const record = recordFieldOf(field);
+  if (record) {
+    const entity = scope.entities.get(record.record);
+    const ref = entity ?? scope.records.get(record.record);
+    return {
+      kind: entity === undefined ? "record" : "entity",
+      ref: ref ?? recordNameOf2(record.record),
+      optional: record.optional
+    };
+  }
+  return {
+    kind: "property",
+    name: "unknown",
+    optional: false,
+    sensitive: false,
+    unique: false,
+    schema: {}
+  };
+}
+function fieldsDescriptionOf(properties, scope, skip = new Set) {
+  return Object.fromEntries(Object.entries(properties).filter(([key]) => !skip.has(key)).map(([key, field]) => [key, fieldDescriptionOf(field, scope)]));
+}
+function recordDescriptionOf(entry, scope) {
+  const Record = entry.value;
+  const plugins = pluginsOf2(Record).map((plugin) => plugin.toJSON());
+  const skip = new Set(plugins.flatMap((plugin) => plugin.keys));
+  const settings = entry.collection === "entities" ? Record[EntitySettings2] : undefined;
+  const expires = settings?.expires;
+  const upgrade = Object.keys(settings?.upgrade ?? {}).map(Number).sort((a, b) => a - b);
+  if (entry.collection === "entities") {
+    for (const key of identityKeysOf(Record))
+      skip.add(key);
+  }
+  const own = (keys, flag) => keys.filter((key) => {
+    if (skip.has(key))
+      return false;
+    const field = Record.blueprint.properties[key];
+    return !(flag && isProperty(field) && field.type[flag] === true);
+  });
+  const lifecycle = entry.collection === "entities" ? lifecycleEventsOf(Record) : {};
+  const events = Object.fromEntries(Object.entries(lifecycle).map(([cycle, list]) => [
+    cycle,
+    list.map((event) => ({
+      name: event.name,
+      handler: eventHasHandler(event)
+    }))
+  ]));
+  return {
+    from: entry.from,
+    fields: fieldsDescriptionOf(Record.blueprint.properties, scope, skip),
+    options: {
+      sensitive: own(Record.options.sensitive, "sensitive"),
+      unique: own(Record.options.unique, "unique"),
+      change: own(Record.options.change)
+    },
+    plugins,
+    ...Object.keys(events).length > 0 ? { events } : {},
+    ...expires === undefined ? {} : { expires },
+    ...entry.collection === "entities" && isVersionedEntityClass(Record) ? { versioned: true } : {},
+    ...settings?.schemaVersioned ? { schemaVersion: settings.schemaVersion } : {},
+    ...upgrade.length > 0 ? { upgrade } : {},
+    ...settings !== undefined && settings.previousNames.length > 0 ? { previousNames: [...settings.previousNames] } : {}
+  };
+}
+function describeRegistry(name, extended, registry, provider, named, log, publishers) {
+  const scope = {
+    properties: referencesOf(registry, "properties"),
+    blueprints: referencesOf(registry, "blueprints"),
+    records: referencesOf(registry, "records"),
+    entities: referencesOf(registry, "entities")
+  };
+  const repositories = referencesOf(registry, "repositories");
+  const environmentRefs = referencesOf(registry, "environments");
+  const useCaseRefs = referencesOf(registry, "useCases");
+  const exceptionRefs = referencesOf(registry, "exceptions");
+  const describeImplementation = (UseCase) => {
+    const steps = interpretedStepsOf(UseCase);
+    return steps === undefined ? { kind: "opaque" } : {
+      kind: "steps",
+      steps: describeSteps(steps, {
+        record: (Class) => scope.entities.get(Class) ?? scope.records.get(Class),
+        error: (Class) => {
+          const ref = exceptionRefs.get(Class);
+          return ref === undefined ? { core: Class.name } : ref;
+        }
+      })
+    };
+  };
+  const describeOption = (value) => {
+    if (isLoggerDeclaration(value))
+      return "Logger";
+    if (isUseCaseClass2(value))
+      return useCaseRefs.get(value);
+    if (isEnvironment(value))
+      return environmentRefs.get(value);
+    if (isRepository(value)) {
+      return repositories.get(inspectRepository(value).state);
+    }
+    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)) {
+      const ref = blueprint === undefined ? undefined : scope.blueprints.get(blueprint.properties);
+      if (ref !== undefined)
+        refs[key] = ref;
+    }
+    return Object.keys(refs).length === 0 ? {} : { refs };
+  };
+  const each = (collection, describe) => Object.fromEntries([...registry[collection].values()].map((entry) => [
+    entry.name,
+    describe(entry)
+  ]));
+  return {
+    name,
+    extends: extended.map((other) => other.name),
+    ...provider === undefined ? {} : { provider },
+    ...named.size === 0 ? {} : {
+      providers: Object.fromEntries([...named].map(([key, { slot, from }]) => {
+        const { value } = slotEntry(slot);
+        return [
+          key,
+          {
+            from,
+            ...isProviderFactory2(value) ? { kind: "opaque" } : providerDescriptionOf2(value)
+          }
+        ];
+      }))
+    },
+    ...log === undefined ? {} : log === "opaque" ? { log: { kind: "opaque" } } : {
+      log: {
+        level: log.level,
+        providers: log.providers.map((logProvider) => {
+          const providerName = logProviderNameOf(logProvider);
+          return providerName === undefined ? { kind: "opaque" } : { kind: "log-provider", name: providerName };
+        })
+      }
+    },
+    ...Object.keys(publishers).length === 0 ? {} : {
+      publishers: Object.fromEntries(Object.entries(publishers).map(([key, from]) => [key, { from }]))
+    },
+    properties: each("properties", (entry) => ({
+      from: entry.from,
+      ...propertyDescriptionOf(entry.value, scope)
+    })),
+    blueprints: each("blueprints", (entry) => ({
+      from: entry.from,
+      fields: fieldsDescriptionOf(entry.value.properties, scope)
+    })),
+    records: each("records", (entry) => recordDescriptionOf(entry, scope)),
+    entities: each("entities", (entry) => recordDescriptionOf(entry, scope)),
+    environments: each("environments", (entry) => ({
+      from: entry.from,
+      fields: fieldsDescriptionOf(entry.value.blueprint.properties, scope)
+    })),
+    repositories: each("repositories", (entry) => {
+      const info = inspectRepository(entry.value);
+      return {
+        from: entry.from,
+        entity: scope.entities.get(info.entity),
+        actions: info.actions,
+        deletion: info.deletion,
+        indexes: info.indexes,
+        scans: info.scans,
+        relations: info.relations.map((relation) => repositories.get(relation)),
+        environments: info.environments.map((environment) => environmentRefs.get(environment)),
+        ...info.provider === undefined ? {} : {
+          provider: isProviderSlot(info.provider) ? referenceOf(info.provider) : providerDescriptionOf2(info.provider)
+        }
+      };
+    }),
+    useCases: each("useCases", (entry) => {
+      const UseCase = entry.value;
+      return {
+        from: entry.from,
+        name: UseCase.useCaseName,
+        ...UseCase.description === undefined ? {} : { description: UseCase.description },
+        tags: UseCase.tags,
+        deprecated: UseCase.deprecated,
+        ...UseCase.route === undefined ? {} : { route: UseCase.route },
+        ...UseCase.access === undefined ? {} : { access: UseCase.access },
+        input: fieldsDescriptionOf(UseCase.blueprint.properties, scope),
+        response: fieldsDescriptionOf(UseCase.response.properties, scope),
+        ...UseCase.context === undefined ? {} : {
+          context: fieldsDescriptionOf(UseCase.context.properties, scope)
+        },
+        ...refsOf({
+          input: UseCase.blueprint,
+          response: UseCase.response,
+          context: UseCase.context
+        }),
+        errors: UseCase.errors.map((Thrown) => {
+          const ref = exceptionRefs.get(Thrown);
+          return ref === undefined ? { kind: "core", name: Thrown.name } : { kind: "exception", ref };
+        }),
+        dependencies: Object.fromEntries(Object.entries(UseCase.dependencies).map(([key, dependency]) => [
+          key,
+          isLoggerDeclaration(dependency) ? { kind: "logger", ref: "Logger" } : isUseCaseClass2(dependency) ? {
+            kind: "use-case",
+            ref: useCaseRefs.get(dependency)
+          } : isEnvironment(dependency) ? {
+            kind: "environment",
+            ref: environmentRefs.get(dependency)
+          } : {
+            kind: "repository",
+            ref: repositories.get(inspectRepository(dependency).state)
+          }
+        ])),
+        implementation: describeImplementation(UseCase),
+        ...describeGeneric(UseCase)
+      };
+    }),
+    commands: each("commands", (entry) => {
+      const command = entry.value;
+      return {
+        from: entry.from,
+        name: command.commandName,
+        ...command.description === undefined ? {} : { description: command.description },
+        tags: command.tags,
+        ...command.context === undefined ? {} : {
+          context: fieldsDescriptionOf(command.context.properties, scope)
+        },
+        ...refsOf({ context: command.context }),
+        operations: Object.fromEntries(Object.entries(command.useCases).map(([op, UseCase]) => [
+          op,
+          { ref: useCaseRefs.get(UseCase) }
+        ])),
+        transaction: command.transaction,
+        ...command.environments.length === 0 ? {} : {
+          environments: command.environments.map((environment) => environmentRefs.get(environment))
+        },
+        events: typeof command.events === "function" ? eventPolicyDescriptionOf2(command.events) ?? { kind: "opaque" } : command.events,
+        ...command.onEventError === undefined ? {} : { onEventError: { kind: "opaque" } }
+      };
+    }),
+    outputs: each("outputs", (entry) => {
+      const output = entry.value;
+      return {
+        from: entry.from,
+        name: output.outputName,
+        commands: output.commands.map((command) => command.commandName),
+        statuses: output.statuses,
+        pipe: output.stages.map((stage) => stageDescriptionOf2(stage))
+      };
+    }),
+    exceptions: each("exceptions", (entry) => {
+      const Declared = entry.value;
+      const message = declaredMessageOf(Declared);
+      return {
+        from: entry.from,
+        layer: Declared.layer,
+        ...message === undefined ? {} : { message }
+      };
+    })
+  };
+}
+function applicationOf2(settings) {
+  const { name } = settings ?? {};
+  if (typeof name !== "string" || name === "") {
+    invalid3("applicationOf", "Expected a name.");
+  }
+  const extended = settings.extends ?? [];
+  if (!Array.isArray(extended) || !extended.every(isApplication)) {
+    invalid3(name, "Expected `extends` to be a list of applications.");
+  }
+  const registry = resolve(settings);
+  validate(name, registry);
+  validateUseCases(name, registry);
+  validateCommands(name, registry);
+  validateOutputs(name, registry);
+  if (settings.providers !== undefined && !isProviderStorage(settings.providers)) {
+    invalid3(name, "Expected `providers` to be a storage made by providersOf.");
+  }
+  const named = new Map;
+  const addNamed = (entry) => {
+    const { key } = slotEntry(entry.slot);
+    const current = named.get(key);
+    if (current !== undefined && current.slot !== entry.slot) {
+      throw new ApplicationConflict2({
+        source: name,
+        details: {
+          reason: `The provider "${key}" is declared by different storages, in "${current.from}" and "${entry.from}".`,
+          origins: [current.from, entry.from],
+          declarations: [`provider ${key}`, `provider ${key}`]
+        }
+      });
+    }
+    named.set(key, entry);
+  };
+  for (const other of extended) {
+    for (const entry of namedProviders.get(other)?.values() ?? []) {
+      addNamed(entry);
+    }
+  }
+  for (const slot of settings.providers ? slotsOf(settings.providers) : []) {
+    const inherited = named.get(slotEntry(slot).key);
+    if (inherited?.slot === slot)
+      continue;
+    const { value } = slotEntry(slot);
+    addNamed({
+      slot,
+      from: name,
+      instance: isProviderFactory2(value) ? deferredProvider(value, name) : value
+    });
+  }
+  const instances = new Map([...named.values()].map((entry) => [entry.slot, entry.instance]));
+  const instanceOf = (slot, holder) => {
+    const instance = instances.get(slot);
+    if (instance === undefined) {
+      throw new UnregisteredApplicationReference2({
+        source: name,
+        details: {
+          holder,
+          reference: `provider "${slotEntry(slot).key}"`
+        }
+      });
+    }
+    return instance;
+  };
+  for (const entry of registry.repositories.values()) {
+    const declared = inspectRepository(entry.value).provider;
+    if (isProviderSlot(declared)) {
+      instanceOf(declared, `repository "${entry.name}"`);
+    }
+  }
+  const inheritedFrom = settings.provider === undefined ? [...extended].reverse().find((other) => other.provider) : undefined;
+  const declaredProvider = settings.provider ?? inheritedFrom?.provider;
+  if (declaredProvider !== undefined && typeof declaredProvider !== "object") {
+    invalid3(name, "Expected `provider` to be a repository provider.");
+  }
+  const defaultSlot = isProviderSlot(declaredProvider) ? declaredProvider : inheritedFrom === undefined ? undefined : defaultSlots.get(inheritedFrom);
+  const provider = defaultSlot !== undefined ? instanceOf(defaultSlot, "the application") : isProviderFactory2(declaredProvider) ? deferredProvider(declaredProvider, name) : declaredProvider;
+  const allProviders = [
+    ...new Set([provider, ...instances.values()].filter((value) => value !== undefined))
+  ];
+  {
+    const registered = new Set([...registry.environments.values()].map((entry) => entry.key));
+    const holderOf = (instance) => {
+      const entry = [...named.values()].find((candidate) => candidate.instance === instance);
+      return entry === undefined || instance === provider ? "the provider" : `provider "${slotEntry(entry.slot).key}"`;
+    };
+    for (const instance of allProviders) {
+      for (const environment of deferredEnvironments(instance)) {
+        if (registered.has(environment))
+          continue;
+        throw new UnregisteredApplicationReference2({
+          source: name,
+          details: {
+            holder: holderOf(instance),
+            reference: "an environment"
+          }
+        });
+      }
+    }
+  }
+  const declaredLog = settings.log ?? [...extended].reverse().map((other) => logSettings.get(other)).find((log) => log !== undefined);
+  const log = declaredLog === undefined ? undefined : applicationLogger(name);
+  if (declaredLog !== undefined && !isLogFactory(declaredLog)) {
+    log?.set(checkLogSettings(declaredLog));
+  }
+  const logger = log?.logger;
+  const { publishers, origins } = publishersOf(name, settings.publishers, extended);
+  const hasPublishers = Object.keys(publishers).length > 0;
+  for (const entry of registry.commands.values()) {
+    for (const key of eventPolicyPublishersOf(entry.value.events)) {
+      if (!Object.hasOwn(publishers, key)) {
+        throw new UnregisteredApplicationReference2({
+          source: name,
+          details: {
+            holder: `command "${entry.name}"`,
+            reference: `publisher "${key}"`
+          }
+        });
+      }
+    }
+  }
+  const bindsProviders = provider !== undefined || instances.size > 0;
+  const rebinds = bindsProviders || logger !== undefined || hasPublishers;
+  const collection = (key) => Object.freeze(Object.fromEntries([...registry[key].values()].map((entry) => [entry.name, entry.value])));
+  const bound = new Map;
+  const boundByState = new Map;
+  const repositories = {};
+  for (const entry of registry.repositories.values()) {
+    const repository = bindsProviders ? bindRepository(entry.value, provider, instances, {
+      application: name,
+      key: entry.name,
+      logger
+    }) : entry.value;
+    bound.set(entry.value, repository);
+    boundByState.set(entry.key, repository);
+    repositories[entry.name] = repository;
+  }
+  const boundUseCases = new Map;
+  const bindUseCase = (UseCase) => {
+    if (!rebinds)
+      return UseCase;
+    const done = boundUseCases.get(UseCase);
+    if (done)
+      return done;
+    const Declared = UseCase;
+
+    class Bound extends Declared {
+    }
+    Object.defineProperty(Bound, "name", { value: Declared.name });
+    boundUseCases.set(UseCase, Bound);
+    const dependencies = Object.fromEntries(Object.entries(UseCase.dependencies).map(([key, dependency]) => [
+      key,
+      isUseCaseClass2(dependency) ? bindUseCase(dependency) : isEnvironment(dependency) || isLoggerDeclaration(dependency) ? dependency : boundByState.get(inspectRepository(dependency).state) ?? dependency
+    ]));
+    Object.defineProperty(Bound, "dependencies", {
+      value: Object.freeze(dependencies)
+    });
+    if (logger)
+      Object.defineProperty(Bound, ApplicationLoggerKey, { value: logger });
+    return Bound;
+  };
+  const useCases = {};
+  const boundUseCaseOf = new Map;
+  for (const entry of registry.useCases.values()) {
+    const bound = bindUseCase(entry.value);
+    boundUseCaseOf.set(entry.value, bound);
+    useCases[entry.name] = bound;
+  }
+  const commands = {};
+  const boundCommandOf = new Map;
+  for (const entry of registry.commands.values()) {
+    const declared = entry.value;
+    const rebuilt = !rebinds ? declared : commandOf({
+      name: declared.commandName,
+      description: declared.description,
+      tags: declared.tags,
+      context: declared.context,
+      useCases: Object.fromEntries(Object.entries(declared.useCases).map(([op, UseCase]) => [
+        op,
+        boundUseCaseOf.get(UseCase)
+      ])),
+      transaction: declared.transaction,
+      environmentDependencies: declared.environments,
+      events: declared.events,
+      onEventError: declared.onEventError
+    });
+    if (bindsProviders)
+      verifyCommand(rebuilt);
+    if (hasPublishers)
+      bindPublishers(rebuilt, publishers);
+    boundCommandOf.set(entry.value, rebuilt);
+    commands[entry.name] = rebuilt;
+  }
+  const outputs = {};
+  const boundOutputOf = new Map;
+  for (const entry of registry.outputs.values()) {
+    const declared = entry.value;
+    const rebuilt = !rebinds ? declared : outputOf2({
+      name: declared.outputName,
+      commands: declared.commands.map((command) => boundCommandOf.get(command)),
+      statuses: declared.statuses,
+      pipe: declared.stages
+    });
+    boundOutputOf.set(entry.value, rebuilt);
+    outputs[entry.name] = rebuilt;
+  }
+  const environmentEntries = [...registry.environments.values()];
+  const registeredEnvironments = new Set(environmentEntries.map((entry) => entry.value));
+  const context = Object.freeze({
+    name,
+    env(environment) {
+      if (!registeredEnvironments.has(environment)) {
+        throw new UnregisteredApplicationReference2({
+          source: name,
+          details: { holder: "the context", reference: "an environment" }
+        });
+      }
+      return environment.load();
+    },
+    logger: logger ?? silentLogger
+  });
+  let starting;
+  let started = false;
+  const start = async (lock) => {
+    if (lock !== undefined) {
+      if (!isLock(lock)) {
+        invalid3(name, "Expected lock to be a schema lock ({ lockVersion: 1, entities }).");
+      }
+      const problems = schemaLockProblemsOf2(lock, schemaLockOf2(application.describe()));
+      if (problems.length > 0) {
+        throw new SchemaLockMismatch2({ source: name, details: { problems } });
+      }
+    }
+    const failures = {};
+    let cause;
+    for (const entry of environmentEntries) {
+      try {
+        entry.value.load();
+      } catch (error) {
+        if (!(error instanceof Exception2) || !error.is(InvalidEnvironment2)) {
+          throw error;
+        }
+        cause ??= error;
+        failures[entry.name] = [
+          ...error.details?.keys ?? []
+        ];
+      }
+    }
+    if (Object.keys(failures).length > 0) {
+      throw new InvalidApplicationEnvironment2({
+        source: name,
+        details: { environments: failures },
+        cause
+      });
+    }
+    if (isLogFactory(declaredLog)) {
+      log?.set(checkLogSettings(await declaredLog.create(context)));
+    }
+    for (const instance of allProviders) {
+      if (!isDeferredProvider(instance))
+        continue;
+      const made = await startDeferred(instance, context);
+      checkTransactions(name, made, Object.entries(commands).filter(([, command]) => command.transaction && commandTransactionProvider(command) === instance).map(([key]) => key));
+      checkCapabilities(name, made, Object.entries(repositories).filter(([, repository]) => providerOfRepository(repository) === instance && inspectRepository(repository).actions.includes("findCursor")).map(([key]) => key));
+    }
+    started = true;
+  };
+  const application = Object.freeze({
+    [Kind2]: "application",
+    name,
+    extends: Object.freeze([...extended]),
+    provider,
+    logger: logger ?? silentLogger,
+    context,
+    ...logger ? { [ApplicationLoggerKey]: logger } : {},
+    ...hasPublishers ? { [ApplicationPublishersKey]: publishers } : {},
+    properties: collection("properties"),
+    blueprints: collection("blueprints"),
+    records: collection("records"),
+    entities: collection("entities"),
+    environments: collection("environments"),
+    repositories: Object.freeze(repositories),
+    useCases: Object.freeze(useCases),
+    commands: Object.freeze(commands),
+    outputs: Object.freeze(outputs),
+    exceptions: collection("exceptions"),
+    useCase(useCase) {
+      if (!boundUseCaseOf.has(useCase)) {
+        invalid3(name, "Expected a use case registered in the application.");
+      }
+      return boundUseCaseOf.get(useCase);
+    },
+    async run(useCase, input = {}, options) {
+      if (!boundUseCaseOf.has(useCase)) {
+        invalid3(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)) {
+        invalid3(name, "Expected a command registered in the application.");
+      }
+      return boundCommandOf.get(command);
+    },
+    output(output) {
+      if (!boundOutputOf.has(output)) {
+        invalid3(name, "Expected an output registered in the application.");
+      }
+      return boundOutputOf.get(output);
+    },
+    repository(repository) {
+      if (!bound.has(repository)) {
+        invalid3(name, "Expected a repository registered in the application.");
+      }
+      return bound.get(repository);
+    },
+    extend(...others) {
+      return applicationOf2({
+        name,
+        extends: [application, ...others],
+        ...provider === undefined ? {} : { provider: defaultSlot ?? provider },
+        ...declaredLog === undefined ? {} : { log: declaredLog }
+      });
+    },
+    describe: () => describeRegistry(name, extended, registry, defaultSlot !== undefined ? referenceOf(defaultSlot) : provider === undefined ? undefined : providerDescriptionOf2(provider), named, isLogFactory(declaredLog) ? "opaque" : log?.settings, origins),
+    get started() {
+      return started;
+    },
+    migrate(options) {
+      return migrateApplication({
+        name,
+        entities: new Map([...registry.entities.values()].map((entry) => [
+          entry.name,
+          entry.value
+        ])),
+        repositories: Object.values(repositories),
+        describe: () => application.describe()
+      }, options);
+    },
+    start(options = {}) {
+      const { replace = false, register = true, lock } = options ?? {};
+      starting ??= (async () => {
+        if (register) {
+          const current = startedApplication();
+          if (current !== undefined && current !== application) {
+            if (!replace) {
+              throw new ApplicationAlreadyStarted2({
+                source: name,
+                details: { current: current.name, attempted: name }
+              });
+            }
+            await current.stop();
+          }
+        }
+        await start(lock);
+        if (register)
+          setStartedApplication(application);
+      })().then(() => application, async (error) => {
+        starting = undefined;
+        for (const instance of allProviders) {
+          if (isDeferredProvider(instance))
+            await stopProvider(instance);
+        }
+        if (isLogFactory(declaredLog))
+          log?.set(undefined);
+        throw error;
+      });
+      return starting;
+    },
+    async stop() {
+      const wasStarting = starting;
+      starting = undefined;
+      started = false;
+      if (wasStarting)
+        await wasStarting.catch(() => {
+          return;
+        });
+      if (startedApplication() === application)
+        setStartedApplication(undefined);
+      for (const instance of allProviders)
+        await stopProvider(instance);
+      await log?.flush();
+      if (isLogFactory(declaredLog))
+        log?.set(undefined);
+    },
+    get(declaration) {
+      if (isEnvironment(declaration)) {
+        if (!registeredEnvironments.has(declaration)) {
+          invalid3(name, "Expected an environment registered in the application.");
+        }
+        return declaration.load();
+      }
+      if (isCommand2(declaration))
+        return application.command(declaration);
+      if (isOutput2(declaration))
+        return application.output(declaration);
+      if (isUseCaseClass2(declaration))
+        return application.useCase(declaration);
+      if (isRepository(declaration)) {
+        return application.repository(declaration);
+      }
+      if (isProviderSlot(declaration)) {
+        const instance = instances.get(declaration);
+        if (instance === undefined) {
+          invalid3(name, "Expected a provider of a storage registered in the application.");
+        }
+        return instance;
+      }
+      return invalid3(name, "Expected a repository, use case, command, output, environment or provider registered in the application.");
+    }
+  });
+  internals.set(application, registry);
+  namedProviders.set(application, named);
+  if (defaultSlot !== undefined)
+    defaultSlots.set(application, defaultSlot);
+  if (declaredLog !== undefined)
+    logSettings.set(application, declaredLog);
+  publisherOrigins.set(application, Object.freeze(origins));
+  return application;
+}
+// src/core/blueprint/blueprint-plugin.ts
+function blueprintPluginOf2(name, properties, factories = {}) {
+  return Object.freeze({
+    name,
+    properties: Object.freeze({ ...properties }),
+    factories: Object.freeze({ ...factories })
+  });
+}
+// src/core/event-policy/publish.ts
+var KEYS2 = ["publisher", "topic", "events", "handle", "onPublishError"];
+var IDENTIFIER2 = /^[A-Za-z_$][\w$]*$/;
+var PLACEHOLDER = /\{(event|command|operation|id)\}/g;
+function validate2(options) {
+  const given = options;
+  for (const key of Object.keys(given)) {
+    if (!KEYS2.includes(key))
+      return `publishEvents has no option "${key}".`;
+  }
+  const { publisher, topic, events, handle, onPublishError } = given;
+  if (typeof publisher !== "string" || !IDENTIFIER2.test(publisher)) {
+    return "Expected publishEvents.publisher to be the key of a publisher of the application.";
+  }
+  if (typeof topic !== "string" || topic === "") {
+    return 'Expected publishEvents.topic to be a non-empty string, such as "posts/{id}".';
+  }
+  const unknown = topic.replaceAll(PLACEHOLDER, "").match(/\{[^}]*\}/);
+  if (unknown) {
+    return `publishEvents.topic has an unknown placeholder ${unknown[0]}: use {event}, {command}, {operation} or {id}.`;
+  }
+  if (events !== undefined && (!Array.isArray(events) || events.some((name) => typeof name !== "string" || name === ""))) {
+    return "Expected publishEvents.events to be a list of event names.";
+  }
+  if (handle !== undefined && typeof handle !== "boolean") {
+    return "Expected publishEvents.handle to be a boolean.";
+  }
+  if (onPublishError !== undefined && onPublishError !== "log" && onPublishError !== "throw") {
+    return 'Expected publishEvents.onPublishError to be "log" or "throw".';
+  }
+  return;
+}
+function entityJson(event) {
+  const text = JSON.stringify(event.entity);
+  return text === undefined ? null : JSON.parse(text);
+}
+var publishEvents2 = eventPolicyOf2({
+  name: "publishEvents",
+  validate: validate2,
+  publishers: (options) => [options.publisher],
+  handle: async (events, info, options) => {
+    const { command, operation, logger } = info;
+    const commandName = command.commandName;
+    const source = `${commandName}.${operation}`;
+    const only = options.events ? new Set(options.events) : undefined;
+    const failed = (cause, event, index) => new CommandEventFailed2({
+      source,
+      cause,
+      details: {
+        operation,
+        event: event.name,
+        handled: index,
+        remaining: events.length - index - 1
+      }
+    });
+    for (const [index, event] of events.entries()) {
+      if (options.handle !== false) {
+        try {
+          await event.handle({ logger });
+        } catch (cause) {
+          throw failed(cause, event, index);
+        }
+      }
+      if (only && !only.has(event.name))
+        continue;
+      let publisher;
+      try {
+        publisher = info.publisher(options.publisher);
+      } catch (cause) {
+        throw failed(cause, event, index);
+      }
+      const entity = entityJson(event);
+      const id = entity?.id;
+      const topic = options.topic.replaceAll(PLACEHOLDER, (_, key) => key === "event" ? event.name : key === "command" ? commandName : key === "operation" ? operation : id === undefined ? "" : String(id));
+      const published = Object.freeze({
+        name: event.name,
+        command: commandName,
+        operation,
+        entity
+      });
+      try {
+        await publisher.publish(topic, published);
+      } catch (cause) {
+        if (options.onPublishError === "throw")
+          throw failed(cause, event, index);
+        logFailure(logger, "event-publish-failed", {
+          command: commandName,
+          operation,
+          event: event.name,
+          publisher: options.publisher,
+          topic
+        }, cause);
+      }
+    }
+  }
+});
+// src/core/output/select.ts
+var LISTS = ["tags", "operations", "exclude"];
+var select2 = transformOf2({
+  name: "select",
+  validate: (options) => {
+    for (const key of Object.keys(options)) {
+      if (!LISTS.includes(key)) {
+        return `select has no option "${key}".`;
+      }
+    }
+    for (const key of LISTS) {
+      const list = options[key];
+      if (list !== undefined && (!Array.isArray(list) || list.some((item) => typeof item !== "string"))) {
+        return `Expected select.${key} to be a list of strings.`;
+      }
+    }
+    return;
+  },
+  apply: (operation, { tags, operations, exclude }) => {
+    if (tags && !tags.some((tag) => operation.tags.includes(tag)))
+      return null;
+    if (operations && !operations.includes(operation.id))
+      return null;
+    if (exclude?.includes(operation.id))
+      return null;
+    return operation;
+  }
+});
+// src/core/parse/strip.ts
+function collectionOf(properties, value) {
+  if (!isPlainObject(value))
+    return value;
+  const kept = {};
+  for (const [name, field] of fieldsOf(properties)) {
+    if (!Object.hasOwn(value, name))
+      continue;
+    const item = fieldOf2(field, value[name]);
+    if (item === undefined)
+      continue;
+    Object.defineProperty(kept, name, {
+      value: item,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  return kept;
+}
+function fieldOf2(field, value) {
+  if (isBlueprintList(field)) {
+    return Array.isArray(value) ? value.map((item) => fieldOf2(field.item, item)) : value;
+  }
+  if (isBlueprint(field))
+    return collectionOf(field.properties, value);
+  if (isBlueprintVariant(field)) {
+    const variant = variantOfValue(field, value);
+    if (!variant || !isPlainObject(value))
+      return value;
+    return {
+      [field.key]: value[field.key],
+      ...collectionOf(variant.properties, value)
+    };
+  }
+  const record = recordFieldOf(field);
+  if (record) {
+    return collectionOf(record.record.blueprint.properties, value);
+  }
+  return value;
+}
+function stripUndeclared2(shape, value) {
+  return fieldOf2(shape, value);
+}
+// src/core/record/plugin-catalog.ts
+var LISTS2 = ["keys", "sensitive", "unique", "change", "members"];
+function isDescriptor(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const descriptor = value;
+  const isList = (list) => Array.isArray(list) && list.every((item) => typeof item === "string");
+  return descriptor.kind === "record-plugin" && typeof descriptor.name === "string" && isVersion(descriptor.version) && LISTS2.every((list) => isList(descriptor[list])) && Array.isArray(descriptor.requires) && descriptor.requires.every((required) => typeof required === "object" && required !== null && typeof required.name === "string" && isVersion(required.version));
+}
+function mismatchOf(plugin, descriptor) {
+  if (!satisfies(plugin.version, descriptor.version)) {
+    return `version ${plugin.version} does not satisfy ${descriptor.version}`;
+  }
+  const current = {
+    keys: plugin.keys,
+    sensitive: plugin.options.sensitive,
+    unique: plugin.options.unique,
+    change: plugin.options.change,
+    members: plugin.members
+  };
+  for (const list of LISTS2) {
+    const missing = descriptor[list].find((item) => !current[list].includes(item));
+    if (missing !== undefined)
+      return `"${missing}" is not in its ${list}`;
+  }
+  for (const required of descriptor.requires) {
+    const found = plugin.requires.find(({ name }) => name === required.name);
+    if (!found)
+      return `it does not require "${required.name}"`;
+    if (!satisfies(found.version, required.version)) {
+      return `its "${required.name}" ${found.version} does not satisfy ${required.version}`;
+    }
+  }
+  return;
+}
+function recordPluginCatalogOf2(...plugins) {
+  const byName = {};
+  for (const plugin of plugins) {
+    if (!isRecordPlugin(plugin)) {
+      throw new InvalidRecordPlugin2({
+        source: "catalog",
+        details: {
+          reason: "a catalog takes plugins made by `recordPluginOf`"
+        }
+      });
+    }
+    if (Object.hasOwn(byName, plugin.name)) {
+      throw new InvalidRecordPlugin2({
+        source: plugin.name,
+        details: { reason: "the catalog has another plugin with its name" }
+      });
+    }
+    byName[plugin.name] = plugin;
+  }
+  const find = (name) => {
+    const plugin = Object.hasOwn(byName, name) ? byName[name] : undefined;
+    if (!plugin) {
+      throw new UnknownRecordPlugin2({ source: "catalog", details: { name } });
+    }
+    return plugin;
+  };
+  const resolve = (reference) => {
+    if (typeof reference === "string") {
+      const at = reference.lastIndexOf("@");
+      if (at <= 0)
+        return find(reference);
+      const plugin = find(reference.slice(0, at));
+      const version = reference.slice(at + 1);
+      if (!isVersion(version)) {
+        throw new IncompatibleRecordPlugin2({
+          source: plugin.name,
+          details: { reason: `"${version}" is not a semantic version` }
+        });
+      }
+      if (!satisfies(plugin.version, version)) {
+        throw new IncompatibleRecordPlugin2({
+          source: plugin.name,
+          details: {
+            reason: `version ${plugin.version} does not satisfy ${version}`
+          }
+        });
+      }
+      return plugin;
+    }
+    if (!isDescriptor(reference)) {
+      const name = reference?.name;
+      throw new IncompatibleRecordPlugin2({
+        source: typeof name === "string" ? name : "unknown",
+        details: { reason: "it is not a record plugin descriptor" }
+      });
+    }
+    const plugin = find(reference.name);
+    const reason = mismatchOf(plugin, reference);
+    if (reason !== undefined) {
+      throw new IncompatibleRecordPlugin2({
+        source: plugin.name,
+        details: { reason }
+      });
+    }
+    return plugin;
+  };
+  return Object.freeze({
+    [Kind2]: "record-plugin-catalog",
+    plugins: Object.freeze(byName),
+    list: Object.freeze([...plugins]),
+    resolve,
+    resolveAll: (references) => Object.freeze(references.map(resolve))
+  });
+}
+// src/core/use-case/decorators.ts
+function sameData(a, b) {
+  if (a === b)
+    return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null || Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  const left = Object.keys(a);
+  return left.length === Object.keys(b).length && left.every((key) => Object.hasOwn(b, key) && sameData(a[key], b[key]));
+}
+function decoratedUseCase(value, decorator) {
+  if (typeof value !== "function" || value[Kind2] !== "use-case") {
+    throw new InvalidUseCaseDeclaration2({
+      source: decorator,
+      details: {
+        reason: `${decorator} decorates a class that extends useCaseOf(...).`
+      }
+    });
+  }
+  return value;
+}
+function Route2(method, pathOrOptions, options) {
+  const settings = typeof pathOrOptions === "string" ? { ...options, method, path: pathOrOptions } : { ...pathOrOptions, method };
+  return (value) => {
+    const UseCase = decoratedUseCase(value, "@Route");
+    const invalid = (reason) => {
+      throw new InvalidUseCaseDeclaration2({
+        source: UseCase.useCaseName,
+        details: { reason }
+      });
+    };
+    const declared = routeDeclarationOf(settings, UseCase.blueprint, UseCase.response);
+    if (typeof declared === "string")
+      return invalid(declared);
+    if (UseCase.route !== undefined) {
+      if (sameData(UseCase.route, declared))
+        return;
+      invalid("The use case already has another route: declare it once, with the route setting or with @Route.");
+    }
+    Object.defineProperty(UseCase, "route", { value: declared });
+  };
+}
+function Access2(access) {
+  return (value) => {
+    const UseCase = decoratedUseCase(value, "@Access");
+    const invalid = (reason) => {
+      throw new InvalidUseCaseDeclaration2({
+        source: UseCase.useCaseName,
+        details: { reason }
+      });
+    };
+    const declared = accessDeclarationOf(access, UseCase.blueprint);
+    if (typeof declared === "string")
+      return invalid(declared);
+    if (UseCase.access !== undefined) {
+      if (sameData(UseCase.access, declared))
+        return;
+      invalid("The use case already declares another access: declare it once, with the access setting or with @Access.");
+    }
+    Object.defineProperty(UseCase, "access", { value: declared });
+  };
+}
+// src/std/properties/contact.ts
+import { Type } from "typebox";
+var Email2 = propertyOf2({
+  name: "email",
+  schema: Type.String({ format: "email", maxLength: 254 }),
+  default: "demo@example.com",
+  preHandle: (value) => value.trim().toLowerCase()
+});
+var Phone2 = propertyOf2({
+  name: "phone",
+  schema: Type.String({ pattern: "^\\+[1-9]\\d{1,14}$" }),
+  default: "+5511999999999",
+  preHandle: (value) => value.replace(/[\s().-]/g, "")
+});
+var Url2 = propertyOf2({
+  name: "url",
+  schema: Type.String({ format: "url", maxLength: 2048 }),
+  default: "https://example.com",
+  preHandle: (value) => value.trim()
+});
+var Ip2 = propertyOf2({
+  name: "ip",
+  schema: Type.Union([
+    Type.String({ format: "ipv4" }),
+    Type.String({ format: "ipv6" })
+  ]),
+  default: "127.0.0.1",
+  preHandle: (value) => value.trim()
+});
+
+// src/std/properties/enum.ts
+import { Type as Type2 } from "typebox";
+function enumOf2(values, {
+  name = "enum",
+  optional,
+  default: _default = values[0]
+} = {}) {
+  const Enum = propertyOf2({
+    name,
+    schema: Type2.Enum(values),
+    optional,
+    default: _default
+  });
+  recordPropertyLineage(Enum, {
+    kind: "factory",
+    factory: "enumOf",
+    args: Object.freeze({
+      values: Object.freeze([...values]),
+      ...name === "enum" ? {} : { name },
+      ...optional ? { optional: true } : {},
+      ..._default === values[0] ? {} : { default: _default }
+    })
+  });
+  return Enum;
+}
+
+// src/std/properties/headless.ts
+import { Type as Type3 } from "typebox";
+import { Meta } from "typebox/schema";
+var JSON_SCHEMA = Type3.Unsafe({
+  type: "object",
+  allOf: [Meta["https://json-schema.org/draft/2020-12/schema"]]
+});
+
+class SchemaProperty2 extends propertyOf2({
+  name: "schema",
+  schema: JSON_SCHEMA,
+  default: Type3.String()
+}) {
+  compiled;
+  static deserialize(json) {
+    let value;
+    try {
+      value = JSON.parse(json);
+    } catch (error) {
+      throw new InvalidPropertyValue2({
+        source: "schema",
+        details: { errors: [error.message] }
+      });
+    }
+    return new SchemaProperty2(value);
+  }
+  serialize() {
+    return JSON.stringify(this.value);
+  }
+  match(data) {
+    return this.toSchema().match(data);
+  }
+  errors(data) {
+    return this.toSchema().errors(data);
+  }
+  toSchema() {
+    if (!this.compiled) {
+      const Schema = schemaOf("schema", this.value);
+      this.compiled = new Schema;
+    }
+    return this.compiled;
+  }
+}
+
+// src/std/properties/identity.ts
+import slugify from "slugify";
+import { Type as Type4 } from "typebox";
+
+// src/std/runtime.ts
+var PasswordHasherRequired2 = exceptionOf2({
+  layer: "property" /* Property */,
+  name: "PasswordHasherRequired",
+  message: "No password hasher is available: this runtime has neither Bun.password nor native argon2 (node:crypto, Node >= 24.7). Call configure({ hasher }) with your own PasswordHasher."
+});
+var SyncVerifyUnsupported2 = exceptionOf2({
+  layer: "property" /* Property */,
+  name: "SyncVerifyUnsupported",
+  message: "The configured password hasher has no verifySync. Use verify, or configure a hasher that provides verifySync."
+});
+var UnsupportedPasswordHash = exceptionOf2({
+  layer: "property" /* Property */,
+  name: "UnsupportedPasswordHash",
+  message: ({ version }) => `The password hash uses argon2 version ${version}, but native argon2 (node:crypto) only derives version ${ARGON2_VERSION}. Verify it with Bun.password or configure({ hasher }).`
+});
+markExported(PasswordHasherRequired2, SyncVerifyUnsupported2);
+var ARGON2_VERSION = 19;
+var ARGON2_PARAMS = {
+  memory: 65536,
+  passes: 2,
+  parallelism: 1,
+  tagLength: 32,
+  saltLength: 32,
+  version: ARGON2_VERSION
+};
+var toBase64 = (bytes) => btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join("")).replace(/=+$/, "");
+var fromBase64 = (text) => Uint8Array.from(atob(text), (char) => char.charCodeAt(0));
+function encodePhc(salt, tag) {
+  const { memory, passes, parallelism, version } = ARGON2_PARAMS;
+  return `$argon2id$v=${version}$m=${memory},t=${passes},p=${parallelism}$${toBase64(salt)}$${toBase64(tag)}`;
+}
+var PHC = /^\$argon2id\$v=(\d+)\$m=(\d+),t=(\d+),p=(\d+)\$([A-Za-z0-9+/]+)\$([A-Za-z0-9+/]+)$/;
+function decodePhc(phc) {
+  const match = PHC.exec(phc);
+  if (!match)
+    return;
+  return {
+    version: Number(match[1]),
+    memory: Number(match[2]),
+    passes: Number(match[3]),
+    parallelism: Number(match[4]),
+    salt: fromBase64(match[5]),
+    tag: fromBase64(match[6])
+  };
+}
+function nodeHasherOf(crypto) {
+  const { argon2, argon2Sync, randomBytes, timingSafeEqual } = crypto;
+  if (!argon2 || !argon2Sync || !randomBytes || !timingSafeEqual) {
+    return;
+  }
+  const derive = (parameters) => new Promise((resolve, reject) => {
+    argon2("argon2id", parameters, (error, key) => error ? reject(error) : resolve(key));
+  });
+  const parametersOf = (plain, parsed) => ({
+    message: plain,
+    nonce: parsed.salt,
+    parallelism: parsed.parallelism,
+    tagLength: parsed.tag.length,
+    memory: parsed.memory,
+    passes: parsed.passes
+  });
+  const decode = (hash) => {
+    const parsed = decodePhc(hash);
+    if (parsed && parsed.version !== ARGON2_VERSION) {
+      throw new UnsupportedPasswordHash({
+        source: "password",
+        details: { version: parsed.version }
+      });
+    }
+    return parsed;
+  };
+  const matches = (tag, expected) => tag.length === expected.length && timingSafeEqual(tag, expected);
+  return {
+    async hash(plain) {
+      const salt = randomBytes(ARGON2_PARAMS.saltLength);
+      const tag = await derive({
+        message: plain,
+        nonce: salt,
+        parallelism: ARGON2_PARAMS.parallelism,
+        tagLength: ARGON2_PARAMS.tagLength,
+        memory: ARGON2_PARAMS.memory,
+        passes: ARGON2_PARAMS.passes
+      });
+      return encodePhc(salt, tag);
+    },
+    async verify(plain, hash) {
+      const parsed = decode(hash);
+      if (!parsed)
+        return false;
+      return matches(await derive(parametersOf(plain, parsed)), parsed.tag);
+    },
+    verifySync(plain, hash) {
+      const parsed = decode(hash);
+      if (!parsed)
+        return false;
+      const tag = argon2Sync("argon2id", parametersOf(plain, parsed));
+      return matches(tag, parsed.tag);
+    }
+  };
+}
+function bunHasherOf(password) {
+  return {
+    hash: (plain) => password.hash(plain, { algorithm: "argon2id" }),
+    verify: (plain, hash) => password.verify(plain, hash),
+    verifySync: (plain, hash) => password.verifySync(plain, hash)
+  };
+}
+function missingHasher() {
+  return {
+    hash: () => Promise.reject(new PasswordHasherRequired2({ source: "password" })),
+    verify: () => Promise.reject(new PasswordHasherRequired2({ source: "password" })),
+    verifySync: () => {
+      throw new PasswordHasherRequired2({ source: "password" });
+    }
+  };
+}
+function defaultHasherOf(environment) {
+  if (environment.bun?.password) {
+    return bunHasherOf(environment.bun.password);
+  }
+  const node = environment.crypto && nodeHasherOf(environment.crypto);
+  return node ?? missingHasher();
+}
+var lastTimestamp = 0;
+var sequence = 0;
+var HEX = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"));
+var RANDOM_PER_ID = 10;
+var randomPool = new Uint8Array(RANDOM_PER_ID * 64);
+var randomAt = randomPool.length;
+function uuidv7(now = Date.now()) {
+  if (randomAt === randomPool.length) {
+    globalThis.crypto.getRandomValues(randomPool);
+    randomAt = 0;
+  }
+  const at = randomAt;
+  randomAt += RANDOM_PER_ID;
+  const random = randomPool;
+  const start = random[at + 8] << 8 | random[at + 9];
+  if (now > lastTimestamp) {
+    lastTimestamp = now;
+    sequence = start & 2047;
+  } else if (sequence < 4095) {
+    sequence++;
+  } else {
+    lastTimestamp++;
+    sequence = start & 2047;
+  }
+  const high = Math.floor(lastTimestamp / 2 ** 32);
+  const low = lastTimestamp % 2 ** 32;
+  const hex = (byte) => HEX[byte & 255];
+  return hex(high >>> 8) + hex(high) + hex(low >>> 24) + hex(low >>> 16) + "-" + hex(low >>> 8) + hex(low) + "-" + hex(112 | sequence >>> 8) + hex(sequence) + "-" + hex(random[at] & 63 | 128) + hex(random[at + 1]) + "-" + hex(random[at + 2]) + hex(random[at + 3]) + hex(random[at + 4]) + hex(random[at + 5]) + hex(random[at + 6]) + hex(random[at + 7]);
+}
+var hasher;
+var defaultIdGenerator = () => uuidv7();
+var idGenerator = defaultIdGenerator;
+function configure2(services) {
+  if (services.hasher)
+    hasher = services.hasher;
+  if (services.idGenerator)
+    idGenerator = services.idGenerator;
+}
+function resetRuntime2() {
+  hasher = undefined;
+  idGenerator = defaultIdGenerator;
+  lastTimestamp = 0;
+  sequence = 0;
+}
+function nodeCryptoOf() {
+  const process = globalThis.process;
+  return process?.getBuiltinModule?.("node:crypto");
+}
+function currentHasher() {
+  hasher ??= defaultHasherOf({
+    bun: globalThis.Bun,
+    crypto: nodeCryptoOf()
+  });
+  return hasher;
+}
+function makesDefaultIds() {
+  return idGenerator === defaultIdGenerator;
+}
+function generateId() {
+  return idGenerator();
+}
+function verifySyncWithCurrent(plain, hash) {
+  const current = currentHasher();
+  if (!current.verifySync)
+    throw new SyncVerifyUnsupported2({ source: "password" });
+  return current.verifySync(plain, hash);
+}
+
+// src/std/properties/identity.ts
+var UUID_V7 = "^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$";
+
+class Id2 extends propertyOf2({
+  name: "id",
+  schema: Type4.String({ pattern: UUID_V7 }),
+  default: "01a173d2-051c-77bb-8166-a371e999573e",
+  preHandle: (value) => value.toLowerCase()
+}) {
+  static generate() {
+    return new Id2(generateId());
+  }
+}
+
+class Slug2 extends propertyOf2({
+  name: "slug",
+  schema: Type4.String({
+    pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$",
+    maxLength: 255
+  }),
+  default: "demo-slug",
+  unique: true,
+  preHandle: (value) => slugify(value, { lower: true, strict: true, trim: true })
+}) {
+}
+
+// src/std/properties/json.ts
+import { Type as Type5 } from "typebox";
+import { Meta as Meta2 } from "typebox/schema";
+import Value from "typebox/value";
+
+// src/std/properties/exceptions.ts
+var InvalidJsonData2 = exceptionOf2({
+  layer: "property" /* Property */,
+  name: "InvalidJsonData",
+  message: ({ issues }, source) => `Invalid JSON data for "${source}": ${issues.map((issue) => `${issue.path.length === 0 ? "/" : `/${issue.path.join("/")}`}: ${issue.message}`).join("; ")}`
+});
+var InvalidJsonSchema2 = exceptionOf2({
+  layer: "schema" /* Schema */,
+  name: "InvalidJsonSchema",
+  message: (_, source) => `The schema of "${source}" is not a JSON Schema.`
+});
+markExported(InvalidJsonData2, InvalidJsonSchema2);
+
+// src/std/properties/json.ts
+function notJson(value, path = [], ancestors = []) {
+  if (value === null)
+    return;
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return;
+    case "number":
+      return Number.isFinite(value) ? undefined : { path, message: `is not JSON (${value})` };
+    case "object":
+      break;
+    default:
+      return { path, message: `is not JSON (${typeof value})` };
+  }
+  if (ancestors.includes(value))
+    return { path, message: "is circular" };
+  const inner = [...ancestors, value];
+  if (Array.isArray(value)) {
+    for (let index = 0;index < value.length; index++) {
+      const found = notJson(value[index], [...path, index], inner);
+      if (found)
+        return found;
+    }
+    return;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return {
+      path,
+      message: `is not JSON (an instance of ${prototype?.constructor?.name ?? "a class"})`
+    };
+  }
+  for (const [key, item] of Object.entries(value)) {
+    const found = notJson(item, [...path, key], inner);
+    if (found)
+      return found;
+  }
+  return;
+}
+var JSON_SCHEMA2 = Type5.Unsafe({
+  type: "object",
+  allOf: [Meta2["https://json-schema.org/draft/2020-12/schema"]]
+});
+var checked = new WeakSet;
+function assertJsonSchema(schema, source) {
+  if (typeof schema === "object" && schema !== null && checked.has(schema)) {
+    return schema;
+  }
+  if (!Value.Check(JSON_SCHEMA2, schema)) {
+    throw new InvalidJsonSchema2({ source });
+  }
+  checked.add(schema);
+  return schema;
+}
+function pathOf(pointer) {
+  if (pointer === "")
+    return [];
+  return pointer.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~")).map((segment) => /^(?:0|[1-9][0-9]*)$/.test(segment) ? +segment : segment);
+}
+function issuesOfErrors(errors, source) {
+  const issues = [];
+  const add = (path, code, message) => {
+    issues.push({ path, code, message, source });
+  };
+  for (const error of errors) {
+    const path = pathOf(error.instancePath);
+    const keys = (name) => Array.isArray(error.params[name]) ? error.params[name] : [];
+    if (error.keyword === "required") {
+      for (const key of keys("requiredProperties")) {
+        add([...path, key], "required", "is required");
+      }
+    } else if (error.keyword === "additionalProperties") {
+      for (const key of keys("additionalProperties")) {
+        add([...path, key], "undeclared_key", "is not declared");
+      }
+    } else if (!(error.keyword === "boolean" && error.schemaPath.endsWith("/additionalProperties"))) {
+      add(path, error.keyword === "type" ? "invalid_type" : "invalid_value", error.message);
+    }
+  }
+  return issues;
+}
+function jsonSchemaIssues2(schema, value, { source = "json" } = {}) {
+  const checkedSchema = assertJsonSchema(schema, source);
+  const found = notJson(value);
+  if (found) {
+    return [
+      {
+        path: found.path,
+        code: "invalid_value",
+        message: found.message,
+        source
+      }
+    ];
+  }
+  if (Value.Check(checkedSchema, value))
+    return [];
+  return issuesOfErrors(Value.Errors(checkedSchema, value), source);
+}
+function checkJsonSchema2(schema, value, options = {}) {
+  const issues = jsonSchemaIssues2(schema, value, options);
+  if (issues.length > 0) {
+    throw new InvalidJsonData2({
+      source: options.source ?? "json",
+      details: { issues }
+    });
+  }
+  return value;
+}
+function demoOf(schema) {
+  try {
+    return Value.Create(schema);
+  } catch {
+    return;
+  }
+}
+function assertJson(value) {
+  const found = notJson(value);
+  if (found) {
+    throw new Error(`${found.path.length === 0 ? "" : `/${found.path.join("/")}: `}${found.message}`);
+  }
+  return value;
+}
+var JsonProperty2 = propertyOf2({
+  name: "json",
+  schema: Type5.Unsafe({}),
+  default: {},
+  preHandle: assertJson
+});
+function jsonOf2({
+  schema,
+  name = "json",
+  optional,
+  default: _default
+}) {
+  assertJsonSchema(schema, name);
+  const made = _default ?? demoOf(schema);
+  const Json = propertyOf2({
+    name,
+    schema,
+    optional,
+    ...made !== undefined && Value.Check(schema, made) ? { default: made } : {},
+    preHandle: assertJson
+  });
+  recordPropertyLineage(Json, {
+    kind: "factory",
+    factory: "jsonOf",
+    args: Object.freeze({
+      schema,
+      ...name === "json" ? {} : { name },
+      ...optional ? { optional: true } : {},
+      ..._default === undefined ? {} : { default: _default }
+    })
+  });
+  return Json;
+}
+
+// src/std/properties/password.ts
+import { Type as Type6 } from "typebox";
+var PASSWORD_MIN_LENGTH = 7;
+var PASSWORD_MAX_LENGTH = 128;
+var PASSWORD_SPECIAL_CHARACTERS = "!@#$%^&*()-_=+[]{}|\\;:'\",.<>/?`~";
+var ARGON2_HASH = "^\\$argon2(id|i|d)\\$v=\\d+\\$m=\\d+,t=\\d+,p=\\d+\\$[A-Za-z0-9+/]+\\$[A-Za-z0-9+/]+$";
+var DEMO_HASH = "$argon2id$v=19$m=65536,t=2,p=1$YO5NNmxyK9+adO95GxWsAaUX4TULmT3IGhTYfpshXl0$/C89OCh7bhDY2cR2UkgvOV3dPlkghNLhv/DJsdopwMo";
+function passwordIssues(value) {
+  const issues = [];
+  if (value.length < PASSWORD_MIN_LENGTH) {
+    issues.push(`must have at least ${PASSWORD_MIN_LENGTH} characters`);
+  }
+  if (value.length > PASSWORD_MAX_LENGTH) {
+    issues.push(`must have at most ${PASSWORD_MAX_LENGTH} characters`);
+  }
+  if (!/[a-z]/.test(value))
+    issues.push("must contain a lowercase letter");
+  if (!/[A-Z]/.test(value))
+    issues.push("must contain an uppercase letter");
+  if (!/\d/.test(value))
+    issues.push("must contain a number");
+  if (![...value].some((char) => PASSWORD_SPECIAL_CHARACTERS.includes(char))) {
+    issues.push(`must contain a special character (${PASSWORD_SPECIAL_CHARACTERS})`);
+  }
+  return issues;
+}
+var escaped = PASSWORD_SPECIAL_CHARACTERS.replace(/[\\\]^-]/g, "\\$&");
+
+class PlainPassword2 extends propertyOf2({
+  name: "plainPassword",
+  schema: Type6.String({
+    minLength: PASSWORD_MIN_LENGTH,
+    maxLength: PASSWORD_MAX_LENGTH,
+    pattern: `^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[${escaped}])`
+  }),
+  default: "Demo@123",
+  sensitive: true
+}) {
+}
+
+class Password2 extends propertyOf2({
+  name: "password",
+  schema: Type6.String({ pattern: ARGON2_HASH }),
+  default: DEMO_HASH,
+  sensitive: true
+}) {
+  static [PropertyInput2] = {
+    accepts: PlainPassword2,
+    convert: async (plain) => (await Password2.hash(plain)).value
+  };
+  static async hash(plain) {
+    const issues = passwordIssues(plain);
+    if (issues.length > 0) {
+      throw new InvalidPropertyValue2({
+        source: "password",
+        details: { errors: issues }
+      });
+    }
+    return new Password2(await currentHasher().hash(plain));
+  }
+  verify(input) {
+    const hash = this.value;
+    if (hash === undefined)
+      return Promise.resolve(false);
+    return currentHasher().verify(input, hash);
+  }
+  verifySync(input) {
+    const hash = this.value;
+    if (hash === undefined)
+      return false;
+    return verifySyncWithCurrent(input, hash);
+  }
+}
+
+// src/std/properties/primitives.ts
+import { Type as Type7 } from "typebox";
+var StringProperty2 = propertyOf2({
+  name: "string",
+  schema: Type7.String(),
+  default: "demo"
+});
+var Text2 = propertyOf2({
+  name: "text",
+  schema: Type7.String({ minLength: 1 }),
+  default: "Demo",
+  preHandle: (value) => value.trim()
+});
+var NumberProperty2 = propertyOf2({
+  name: "number",
+  schema: Type7.Number(),
+  default: 0
+});
+var Integer2 = propertyOf2({
+  name: "integer",
+  schema: Type7.Integer(),
+  default: 0
+});
+var BooleanProperty2 = propertyOf2({
+  name: "boolean",
+  schema: Type7.Boolean(),
+  default: false
+});
+
+// src/std/properties/time.ts
+import { Type as Type8 } from "typebox";
+var DEMO_DATE_TIME = "2026-01-01T00:00:00.000Z";
+function dateTimeOf({
+  name,
+  optional,
+  default: _default
+}) {
+  return class extends propertyOf2({
+    name,
+    schema: Type8.String({ format: "date-time" }),
+    optional,
+    default: _default
+  }) {
+    static now() {
+      return new this(new Date().toISOString());
+    }
+  };
+}
+
+class DateTime2 extends dateTimeOf({
+  name: "dateTime",
+  default: DEMO_DATE_TIME
+}) {
+}
+var DateProperty2 = propertyOf2({
+  name: "date",
+  schema: Type8.String({ format: "date" }),
+  default: "2026-01-01"
+});
+
+class CreatedAt2 extends dateTimeOf({
+  name: "createdAt",
+  default: DEMO_DATE_TIME
+}) {
+}
+
+class UpdatedAt2 extends dateTimeOf({
+  name: "updatedAt",
+  optional: true,
+  default: DEMO_DATE_TIME
+}) {
+}
+
+class DeletedAt2 extends dateTimeOf({
+  name: "deletedAt",
+  optional: true
+}) {
+}
+
+class ExpiresAt2 extends dateTimeOf({
+  name: "expiresAt",
+  default: DEMO_DATE_TIME
+}) {
+}
+
+// src/std/blueprint-plugin.ts
+var Std2 = blueprintPluginOf2("std", {
+  id: Id2,
+  slug: Slug2,
+  email: Email2,
+  phone: Phone2,
+  url: Url2,
+  ip: Ip2,
+  password: Password2,
+  string: StringProperty2,
+  text: Text2,
+  number: NumberProperty2,
+  integer: Integer2,
+  boolean: BooleanProperty2,
+  date: DateProperty2,
+  dateTime: DateTime2,
+  createdAt: CreatedAt2,
+  updatedAt: UpdatedAt2,
+  deletedAt: DeletedAt2,
+  schema: SchemaProperty2,
+  json: JsonProperty2
+}, { enumOf: enumOf2, jsonOf: jsonOf2 });
+
+// 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 capitalize = (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 (isPlain(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",
+  "route",
+  "access"
+];
+var HOOKS = ["before", "after", "dependencies", "throws"];
+function metaOf(target, options, verb) {
+  const { name, description, tags, deprecated, route, access } = 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 },
+    ...route === undefined ? {} : { route },
+    ...access === undefined ? {} : { access }
+  };
+}
+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 (!isPlain(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 (!isPlain(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 (!isPlain(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
+      }
+    ] : []
+  ];
+}
+function hooksOf(target, options) {
+  const { before, after, dependencies = {}, throws = [] } = options;
+  for (const [key, hook] of [
+    ["before", before],
+    ["after", after]
+  ]) {
+    if (hook !== undefined && typeof hook !== "function") {
+      target.unavailable(`the option ${key} must be a function`);
+    }
+  }
+  if (!isPlain(dependencies) || Object.keys(dependencies).some((key) => !IDENTIFIER3.test(key))) {
+    target.unavailable("the option dependencies must be an object of repositories, use cases or environments by name");
+  }
+  if (!Array.isArray(throws) || throws.some((error) => !isDeclaredException(error))) {
+    target.unavailable("the option throws must be a list of classes made by exceptionOf");
+  }
+  const input = before === undefined ? "$input" : "$prepared";
+  return {
+    input,
+    dependencies,
+    throws,
+    before: (entity) => before === undefined ? [] : [
+      {
+        run: "before",
+        fn: async (given, ...rest) => {
+          const { context, dependencies } = rest.at(-1);
+          const replaced = await before({
+            input: given,
+            ...entity === undefined ? {} : { entity: rest[0] },
+            dependencies,
+            context
+          });
+          return replaced === undefined ? given : replaced;
+        },
+        args: entity === undefined ? ["$input"] : ["$input", entity],
+        as: "prepared"
+      }
+    ],
+    after: (entity) => after === undefined ? [] : [
+      {
+        run: "after",
+        fn: async (written, given, { context, dependencies }) => {
+          await after({
+            entity: written,
+            input: given,
+            dependencies,
+            context
+          });
+        },
+        args: [entity, input]
+      }
+    ]
+  };
+}
+function joinDependencies(target, made, hooks) {
+  for (const key of Object.keys(hooks.dependencies)) {
+    if (Object.hasOwn(made, key)) {
+      target.unavailable(`dependencies.${key} is a name the use case gives its own dependency`);
+    }
+  }
+  return { ...made, ...hooks.dependencies };
+}
+var idOf = (target) => target.field("id").field;
+var distinct = (...errors) => [...new Set(errors)];
+function entityUseCase(target, options, verb, allowed, steps, hooks = false) {
+  checkOptions(target, options, [
+    "as",
+    "owner",
+    ...allowed,
+    ...hooks ? HOOKS : []
+  ]);
+  const owner = ownerOf(target, options);
+  const notFound = errorOf(target, options, "notFound", UseCaseEntityNotFound2);
+  const hooked = hooksOf(target, options);
+  const body = steps({ owner, input: hooked.input });
+  return {
+    ...metaOf(target, options, verb),
+    blueprint: fields(() => ({ id: idOf(target) })),
+    response: fields(() => ({ [asOf(target, options)]: target.entity })),
+    ...contextOf2(owner),
+    dependencies: joinDependencies(target, { repository: target.repository }, hooked),
+    errors: distinct(notFound, ...hooked.throws),
+    steps: [
+      ...loadSteps(owner, notFound),
+      ...hooked.before("$item"),
+      ...body.steps,
+      ...hooked.after(body.result),
+      { return: { [asOf(target, options)]: body.result } }
+    ]
+  };
+}
+
+// src/std/use-cases/crud.ts
+function createCompilation(target, options, verb, checks = () => [], errors = []) {
+  checkOptions(target, options, ["as", "owner", "omit", "values", ...HOOKS]);
+  const owner = ownerOf(target, options);
+  const hooks = hooksOf(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, ...hooks.throws]);
+  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 = `${hooks.input}.${plan.input.key}`;
+    if (plan.kind === "entity") {
+      values[key] = load(key, given, notFound);
+    } else if (plan.convert) {
+      steps.push({
+        run: `convert${capitalize(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: joinDependencies(target, dependencies, hooks),
+    errors: distinct(...used),
+    steps: [
+      ...hooks.before(),
+      ...checks(hooks.input),
+      ...steps,
+      { build: target.entity, values, as: "built" },
+      { create: "repository", value: "$built", as: "item" },
+      ...hooks.after("$item"),
+      { return: { [asOf(target, options)]: "$item" } }
+    ]
+  };
+}
+var create = 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 update = 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", ...HOOKS]);
+    const owner = ownerOf(target, options);
+    const hooks = hooksOf(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 = `${hooks.input}.${plan.input.key}`;
+      let value = given;
+      if (plan.convert) {
+        steps.push({
+          run: `convert${capitalize(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: idOf(target),
+        ...Object.fromEntries(plans.map((plan) => [plan.input.key, optionalOf2(plan.input.field)]))
+      })),
+      response: fields(() => ({ [asOf(target, options)]: target.entity })),
+      ...contextOf2(owner),
+      dependencies: joinDependencies(target, { repository: target.repository }, hooks),
+      errors: distinct(notFound, ...hooks.throws),
+      steps: [
+        ...loadSteps(owner, notFound),
+        ...hooks.before("$item"),
+        ...steps,
+        { update: "repository", value: "$item", as: "saved" },
+        ...hooks.after("$saved"),
+        { return: { [asOf(target, options)]: "$saved" } }
+      ]
+    };
+  }
+});
+var remove = 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"
+  }), true)
+});
+var restore = 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", ...HOOKS]);
+    const hooks = hooksOf(target, options);
+    return {
+      ...metaOf(target, options, "Restore"),
+      blueprint: fields(() => ({ id: idOf(target) })),
+      response: fields(() => ({ [asOf(target, options)]: target.entity })),
+      dependencies: joinDependencies(target, { repository: target.repository }, hooks),
+      errors: distinct(...hooks.throws),
+      steps: [
+        ...hooks.before(),
+        { restore: "repository", value: `${hooks.input}.id`, as: "item" },
+        ...hooks.after("$item"),
+        { return: { [asOf(target, options)]: "$item" } }
+      ]
+    };
+  }
+});
+
+// src/std/use-cases/auth.ts
+var TOKEN_KEYS = ["refresh", "scopes", "scopesFrom", "claims"];
+var isTexts = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function tokensOf(target, options) {
+  const given = options.token;
+  if (given === undefined)
+    return;
+  const bad = jwtOptionsIssue(given, "the option token", TOKEN_KEYS, true);
+  if (bad)
+    return target.unavailable(bad);
+  const { refresh, scopes, scopesFrom, claims, ...jwtOptions } = given;
+  if (refresh !== undefined && (typeof refresh !== "object" || refresh === null || Object.keys(refresh).join() !== "expiresIn" || !Number.isInteger(refresh.expiresIn) || refresh.expiresIn <= 0)) {
+    return target.unavailable("the option token.refresh must be { expiresIn }, a whole number of seconds above 0");
+  }
+  if (scopes !== undefined && !isTexts(scopes)) {
+    return target.unavailable("the option token.scopes must be a list of scopes");
+  }
+  if (scopesFrom !== undefined)
+    target.field(scopesFrom);
+  if (claims !== undefined && (typeof claims !== "object" || claims === null || Array.isArray(claims))) {
+    return target.unavailable("the option token.claims must map claims to keys of the entity");
+  }
+  const claimKeys = Object.entries(claims ?? {});
+  for (const [, key] of claimKeys)
+    target.field(key);
+  const jwt = jwtOf2(jwtOptions);
+  const issue = async (entity) => {
+    const held = scopesFrom === undefined ? [] : entity[scopesFrom];
+    const subject = {
+      subject: String(entity.id),
+      scopes: [...new Set([...scopes ?? [], ...isTexts(held) ? held : []])],
+      ...claimKeys.length > 0 ? {
+        claims: Object.fromEntries(claimKeys.map(([claim, key]) => [
+          claim,
+          outputValueOf2(entity[key])
+        ]))
+      } : {}
+    };
+    return {
+      token: await jwt.sign(subject),
+      ...refresh ? {
+        refreshToken: await jwt.sign({ subject: subject.subject }, { expiresIn: refresh.expiresIn, use: "refresh" })
+      } : {}
+    };
+  };
+  const verifyRefresh = (token) => jwt.verify(token, { use: "refresh" });
+  return { issue, verifyRefresh, refresh: refresh !== undefined };
+}
+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", (input) => [
+      {
+        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, with a token (and a refresh token) for it when the option token is given.",
+  ...authenticatable(["findByEmail"]),
+  compile: (target, options) => {
+    checkOptions(target, options, ["as", "token"]);
+    const tokens = tokensOf(target, options);
+    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,
+        ...tokens ? { token: StringProperty2 } : {},
+        ...tokens?.refresh ? { refreshToken: StringProperty2 } : {}
+      })),
+      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 },
+        ...tokens ? [
+          {
+            run: "issueTokens",
+            fn: tokens.issue,
+            args: ["$item"],
+            as: "tokens"
+          }
+        ] : [],
+        {
+          return: {
+            [asOf(target, options)]: "$item",
+            ...tokens ? { token: "$tokens.token" } : {},
+            ...tokens?.refresh ? { refreshToken: "$tokens.refreshToken" } : {}
+          }
+        }
+      ]
+    };
+  }
+});
+var refresh = useCasePluginOf2("refresh", {
+  description: "Exchanges a refresh token issued by login for a new token and a new refresh token, for the entity it names, if it still exists. Experimental.",
+  requires: { actions: ["findById"] },
+  compile: (target, options) => {
+    checkOptions(target, options, ["token"]);
+    const tokens = tokensOf(target, options);
+    if (!tokens?.refresh) {
+      return target.unavailable("it needs the option token with refresh, the same login was given");
+    }
+    const invalid = errorOf(target, options, "invalid", UseCaseInvalidCredentials2);
+    return {
+      ...metaOf(target, options, "Refresh"),
+      blueprint: fields(() => ({ refreshToken: StringProperty2 })),
+      response: fields(() => ({
+        token: StringProperty2,
+        refreshToken: StringProperty2
+      })),
+      dependencies: { repository: target.repository },
+      errors: [invalid],
+      steps: [
+        {
+          run: "verifyRefreshToken",
+          fn: tokens.verifyRefresh,
+          args: ["$input.refreshToken"],
+          as: "caller"
+        },
+        {
+          find: "repository.findById",
+          args: ["$caller.subject"],
+          as: "item"
+        },
+        { ensure: "exists", value: "$item", error: invalid },
+        {
+          run: "issueTokens",
+          fn: tokens.issue,
+          args: ["$item"],
+          as: "tokens"
+        },
+        {
+          return: {
+            token: "$tokens.token",
+            refreshToken: "$tokens.refreshToken"
+          }
+        }
+      ]
+    };
+  }
+});
+var logout = useCasePluginOf2("logout", {
+  description: "Gives an empty token and refresh token: a route whose setCookie sends them removes the cookies. Tokens are not stored, so one already issued stays valid until it expires. Experimental.",
+  compile: (target, options) => {
+    checkOptions(target, options, []);
+    return {
+      ...metaOf(target, options, "Logout"),
+      blueprint: fields(() => ({})),
+      response: fields(() => ({
+        token: StringProperty2,
+        refreshToken: StringProperty2
+      })),
+      steps: [{ return: { token: "", refreshToken: "" } }]
+    };
+  }
+});
+
+// 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"
+  }), true);
+}
+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", ...HOOKS]);
+  const owner = ownerOf(target, options);
+  const hooks = hooksOf(target, options);
+  const notFound = errorOf(target, options, "notFound", UseCaseEntityNotFound2);
+  const { item } = target.field("tags").field;
+  return {
+    ...metaOf(target, options, verb),
+    blueprint: fields(() => ({
+      id: idOf(target),
+      tags: listOf2(item, { minItems: 1 })
+    })),
+    response: fields(() => ({ [asOf(target, options)]: target.entity })),
+    ...contextOf2(owner),
+    dependencies: joinDependencies(target, { repository: target.repository }, hooks),
+    errors: distinct(notFound, ...hooks.throws),
+    steps: [
+      ...loadSteps(owner, notFound),
+      ...hooks.before("$item"),
+      { invoke: "$item", method, args: `${hooks.input}.tags` },
+      { update: "repository", value: "$item", as: "saved" },
+      ...hooks.after("$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(create, get, list, update, remove, restore, publish, unpublish, archive, unarchive, tag, untag, register, login, refresh, logout);
+
+// src/std/command.ts
+var commandOf2 = commandBuilderOf2(StdUseCases2);
+// src/std/record-plugins.ts
+var now = () => new Date().toISOString();
+
+class PublishableRecord extends recordOf3(blueprintOf2((ctx) => ({ publishedAt: ctx.optional.dateTime }))) {
+  get isPublished() {
+    return this.publishedAt !== undefined;
+  }
+  publish(at = now()) {
+    return this.set("publishedAt", at);
+  }
+  unpublish() {
+    return this.set("publishedAt", undefined);
+  }
+}
+var Publishable2 = recordPluginOf2("publishable", PublishableRecord, {
+  description: "A publication date, with publish, unpublish and isPublished."
+});
+
+class ArchivableRecord extends recordOf3(blueprintOf2((ctx) => ({ archivedAt: ctx.optional.dateTime }))) {
+  get isArchived() {
+    return this.archivedAt !== undefined;
+  }
+  archive(at = now()) {
+    return this.set("archivedAt", at);
+  }
+  restore() {
+    return this.set("archivedAt", undefined);
+  }
+}
+var Archivable2 = recordPluginOf2("archivable", ArchivableRecord, {
+  description: "An archive date, with archive, restore and isArchived."
+});
+
+class TaggableRecord extends recordOf3(blueprintOf2((ctx) => ({ tags: ctx.list.optional.string }))) {
+  hasTag(tag) {
+    return this.tags?.includes(tag) ?? false;
+  }
+  tag(...tags) {
+    return this.set("tags", [...new Set([...this.tags ?? [], ...tags])]);
+  }
+  untag(...tags) {
+    return this.set("tags", (this.tags ?? []).filter((tag) => !tags.includes(tag)));
+  }
+}
+var Taggable2 = recordPluginOf2("taggable", TaggableRecord, {
+  description: "A list of tags, with tag, untag and hasTag."
+});
+
+class OwnableRecord extends recordOf3(blueprintOf2((ctx) => ({ ownerId: ctx.id }))) {
+  isOwnedBy(id) {
+    return this.ownerId === id.toLowerCase();
+  }
+  transferTo(id) {
+    return this.set("ownerId", id);
+  }
+}
+var Ownable2 = recordPluginOf2("ownable", OwnableRecord, {
+  description: "The id of the owner, with isOwnedBy and transferTo."
+});
+
+class AuthenticatableRecord extends recordOf3(blueprintOf2((ctx) => ({ email: ctx.email, password: ctx.password })), { unique: ["email"], change: ["password"] }) {
+  verifyPassword(plain) {
+    return new Password2(this.password).verify(plain);
+  }
+}
+var Authenticatable2 = recordPluginOf2("authenticatable", AuthenticatableRecord, {
+  description: "A unique email and a sensitive password hash, with change.password and verifyPassword."
+});
+var StdRecordPlugins2 = recordPluginCatalogOf2(Publishable2, Archivable2, Taggable2, Ownable2, Authenticatable2);
+
+// src/std/entity.ts
+var Identity = blueprintBuilderOf2()(() => ({
+  id: Id2,
+  createdAt: CreatedAt2,
+  updatedAt: UpdatedAt2,
+  deletedAt: DeletedAt2
+}));
+var entityOf2 = entityBuilderOf2(vouching({
+  identity: Identity,
+  generateId,
+  now: () => new Date().toISOString(),
+  expiresAt: ExpiresAt2,
+  plugins: [StdRecordPlugins2]
+}, { id: makesDefaultIds, createdAt: () => true }));
+// src/std/event-policies.ts
+var StdEventPolicies2 = eventPolicyCatalogOf2(publishEvents2);
+// src/std/record.ts
+var recordOf2 = recordBuilderOf2(StdRecordPlugins2);
+// src/std/resource.ts
+var ACTIONS = [
+  "create",
+  "get",
+  "list",
+  "update",
+  "delete"
+];
+function routeOf(action, path) {
+  switch (action) {
+    case "create":
+      return { method: "post", path, status: 201 };
+    case "list":
+      return { method: "get", path };
+    case "get":
+      return { method: "get", path: `${path}/{id}` };
+    case "update":
+      return { method: "patch", path: `${path}/{id}` };
+    default:
+      return { method: "delete", path: `${path}/{id}` };
+  }
+}
+function resourceOf2(repository, options) {
+  const actions = options.actions ?? ACTIONS;
+  const { access } = options;
+  const byAction = access !== undefined && Object.keys(access).some((key) => ACTIONS.includes(key));
+  const accessOf = (action) => byAction ? access[action] : access;
+  return (ctx) => {
+    const useCases = {};
+    for (const action of actions) {
+      const declared = accessOf(action);
+      const make = ctx[action];
+      useCases[action] = make(repository, {
+        route: routeOf(action, options.path),
+        ...declared === undefined ? {} : { access: declared }
+      });
+    }
+    return useCases;
+  };
+}
+// src/std/stages.ts
+var StdStages2 = stageCatalogOf2(select2, openapi2);
+export { isUseCaseCatalog2, useCaseCatalogOf2, InvalidCommandDeclaration2, UnknownCommandOperation2, InvalidCommandContext2, InvalidCommandEnvironment2, CommandEventFailed2, commandBuilderOf2, isCommand2, operationOf2, outputOf2, isOutput2, providerFrom2, logFrom2, isProviderFactory2, providersOf2, applicationOf2, blueprintPluginOf2, publishEvents2, select2, stripUndeclared2, recordPluginCatalogOf2, Route2, Access2, Email2, Phone2, Url2, Ip2, enumOf2, SchemaProperty2, PasswordHasherRequired2, SyncVerifyUnsupported2, configure2, resetRuntime2, Id2, Slug2, InvalidJsonData2, InvalidJsonSchema2, jsonSchemaIssues2, checkJsonSchema2, JsonProperty2, jsonOf2, PlainPassword2, Password2, StringProperty2, Text2, NumberProperty2, Integer2, BooleanProperty2, DateTime2, DateProperty2, CreatedAt2, UpdatedAt2, DeletedAt2, ExpiresAt2, Std2, blueprintOf2, StdUseCases2, commandOf2, Publishable2, Archivable2, Taggable2, Ownable2, Authenticatable2, StdRecordPlugins2, entityOf2, StdEventPolicies2, recordOf2, resourceOf2, StdStages2 };