@afora/core 0.0.6 → 0.0.8

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

@@ -11,6 +11,9 @@ import {
   recordFieldOf2,
   recordNameOf2,
   declaredRecordNameOf,
+  fieldsOf,
+  isPlainObject,
+  listOf2,
   isBlueprintList2,
   UNEXPECTED_ERROR2,
   Exception2,
@@ -27,22 +30,25 @@ import {
   storeRecordValue,
   runRecordEffects,
   AbstractRecord2,
+  InvalidPropertyValue2,
+  exports_exceptions2,
+  propertyOf2,
+  exports_exceptions3,
+  optionalOf2,
+  blueprintBuilderOf2,
+  blueprintFromProperties,
   IdentifiedRecord,
   isVersion,
-  versionParts,
+  satisfies,
   pluginsOf2,
   isRecordPlugin2,
+  hasPlugin2,
   recordPluginOf2,
   recordBuilderOf2,
   pluginContextOf,
   recordOf3,
-  declareRecord,
-  exports_exceptions2,
-  InvalidPropertyValue2,
-  exports_exceptions3,
-  propertyOf2,
-  blueprintBuilderOf2
-} from "./index-3nd9bjnc.js";
+  declareRecord
+} from "./index-qxfkyd6k.js";
 
 // src/core/environment/environment.ts
 var exports_environment = {};
@@ -68,30 +74,54 @@ __export(exports_exceptions4, {
   UnregisteredUseCaseDependency: () => UnregisteredUseCaseDependency2
 });
 
-// src/core/logger/exceptions.ts
+// src/core/event-policy/exceptions.ts
 var exports_exceptions5 = {};
 __export(exports_exceptions5, {
-  InvalidLogDeclaration: () => InvalidLogDeclaration2
+  InvalidEventPolicy: () => InvalidEventPolicy2,
+  PublisherNotBound: () => PublisherNotBound2
 });
 
-// src/core/entity/exceptions.ts
+// src/core/logger/exceptions.ts
 var exports_exceptions6 = {};
 __export(exports_exceptions6, {
+  InvalidLogDeclaration: () => InvalidLogDeclaration2
+});
+
+// src/core/entity/exceptions.ts
+var exports_exceptions7 = {};
+__export(exports_exceptions7, {
   DeletedEntity: () => DeletedEntity2,
   ImmutableEntityKey: () => ImmutableEntityKey2,
+  InvalidEntityExpiry: () => InvalidEntityExpiry2,
   ReservedEntityKey: () => ReservedEntityKey2
 });
 
 // src/core/repository/exceptions.ts
-var exports_exceptions7 = {};
-__export(exports_exceptions7, {
+var exports_exceptions8 = {};
+__export(exports_exceptions8, {
   InvalidRepositoryCursor: () => InvalidRepositoryCursor2,
   InvalidRepositoryData: () => InvalidRepositoryData2,
   InvalidRepositoryDeclaration: () => InvalidRepositoryDeclaration2,
   InvalidRepositoryEntity: () => InvalidRepositoryEntity2,
+  InvalidRepositoryIncrement: () => InvalidRepositoryIncrement2,
   InvalidRepositoryQuery: () => InvalidRepositoryQuery2,
+  RepositoryConcurrencyConflict: () => RepositoryConcurrencyConflict2,
   RepositoryEntityNotFound: () => RepositoryEntityNotFound2,
-  RepositoryUniqueViolation: () => RepositoryUniqueViolation2
+  RepositoryUniqueViolation: () => RepositoryUniqueViolation2,
+  RepositoryUsedOutsideApplication: () => RepositoryUsedOutsideApplication2
+});
+
+// src/core/use-case/exceptions.ts
+var exports_exceptions9 = {};
+__export(exports_exceptions9, {
+  IncompatibleUseCasePlugin: () => IncompatibleUseCasePlugin2,
+  InvalidUseCasePlugin: () => InvalidUseCasePlugin2,
+  InvalidUseCaseStep: () => InvalidUseCaseStep2,
+  UnknownUseCasePlugin: () => UnknownUseCasePlugin2,
+  UseCaseEntityConflict: () => UseCaseEntityConflict2,
+  UseCaseEntityNotFound: () => UseCaseEntityNotFound2,
+  UseCaseInvalidCredentials: () => UseCaseInvalidCredentials2,
+  UseCaseUnavailable: () => UseCaseUnavailable2
 });
 
 // src/core/use-case/use-case.ts
@@ -106,15 +136,9 @@ __export(exports_use_case, {
   useCaseOf: () => useCaseOf2
 });
 
-// src/core/use-case/exceptions.ts
-var exports_exceptions8 = {};
-__export(exports_exceptions8, {
-  InvalidUseCaseStep: () => InvalidUseCaseStep2
-});
-
 // src/core/command/exceptions.ts
-var exports_exceptions9 = {};
-__export(exports_exceptions9, {
+var exports_exceptions10 = {};
+__export(exports_exceptions10, {
   CommandEventFailed: () => CommandEventFailed2,
   InvalidCommandContext: () => InvalidCommandContext2,
   InvalidCommandDeclaration: () => InvalidCommandDeclaration2,
@@ -123,14 +147,14 @@ __export(exports_exceptions9, {
 });
 
 // src/core/openapi/exceptions.ts
-var exports_exceptions10 = {};
-__export(exports_exceptions10, {
+var exports_exceptions11 = {};
+__export(exports_exceptions11, {
   InvalidOpenAPIModel: () => InvalidOpenAPIModel2
 });
 
 // src/core/output/exceptions.ts
-var exports_exceptions11 = {};
-__export(exports_exceptions11, {
+var exports_exceptions12 = {};
+__export(exports_exceptions12, {
   DuplicateOperation: () => DuplicateOperation2,
   InvalidOutputStage: () => InvalidOutputStage2
 });
@@ -203,23 +227,6 @@ function isEnvironment2(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "environment";
 }
 
-// src/core/exception/guard.ts
-function guard2(scope, run, resolve) {
-  const handle = (error) => {
-    const exception = Exception2.from(error, scope);
-    const pass = () => {
-      throw exception === error ? exception.propagate(scope) : exception;
-    };
-    return resolve ? resolve(exception, pass) : pass();
-  };
-  try {
-    const result = run();
-    return result instanceof Promise ? result.catch(handle) : result;
-  } catch (error) {
-    return handle(error);
-  }
-}
-
 // src/core/application/exceptions.ts
 var InvalidApplicationDeclaration2 = exceptionOf2({
   layer: "application" /* Application */,
@@ -319,6 +326,53 @@ function setStartedApplication(application) {
   slot().current = application;
 }
 
+// src/core/event-policy/exceptions.ts
+var InvalidEventPolicy2 = exceptionOf2({
+  layer: "event" /* Event */,
+  name: "InvalidEventPolicy",
+  message: ({ reason }) => reason
+});
+var PublisherNotBound2 = exceptionOf2({
+  layer: "application" /* Application */,
+  name: "PublisherNotBound",
+  message: ({ publisher }) => `No publisher "${publisher}" is declared: add it to applicationOf({ publishers }).`
+});
+
+// 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/exception/guard.ts
+function guard2(scope, run, resolve) {
+  const handle = (error) => {
+    const exception = Exception2.from(error, scope);
+    const pass = () => {
+      throw exception === error ? exception.propagate(scope) : exception;
+    };
+    return resolve ? resolve(exception, pass) : pass();
+  };
+  try {
+    const result = run();
+    return result instanceof Promise ? result.catch(handle) : result;
+  } catch (error) {
+    return handle(error);
+  }
+}
+
 // src/core/logger/exceptions.ts
 var InvalidLogDeclaration2 = exceptionOf2({
   layer: "application" /* Application */,
@@ -518,34 +572,81 @@ var DeletedEntity2 = exceptionOf2({
   name: "DeletedEntity",
   message: ({ id }, source) => `Entity "${source}" of id "${id}" was destroyed and cannot change.`
 });
+var InvalidEntityExpiry2 = exceptionOf2({
+  layer: "entity" /* Entity */,
+  name: "InvalidEntityExpiry",
+  message: ({ reason }, source) => `Invalid expires of entity "${source}": ${reason}`
+});
+
+// src/core/entity/version.ts
+import { Type } from "typebox";
+class EntityVersion2 extends propertyOf2({
+  name: "version",
+  schema: Type.Integer({ minimum: 1 }),
+  default: 1
+}) {
+}
+var VersionIdentity = blueprintBuilderOf2()(() => ({
+  version: EntityVersion2
+}));
 
 // src/core/entity/entity.ts
 function entityBuilderOf2({
   identity,
   generateId,
   now,
+  expiresAt,
   plugins: catalogs
 }) {
   const clock = Object.freeze({ generateId, now });
   const context = pluginContextOf(catalogs ?? []);
   return (blueprint, options = {}) => {
+    const lifetime = lifetimeOf(blueprint, options);
+    const expiring = lifetime !== undefined;
+    const versioned = options.versioned === true;
+    const added = [
+      ...versioned ? [ENTITY_VERSION_KEY] : [],
+      ...expiring ? [EXPIRES_AT] : []
+    ];
+    if (expiring && expiresAt === undefined) {
+      throw new InvalidEntityExpiry2({
+        source: options.name ?? "entity",
+        details: {
+          reason: "the entity builder has no expiresAt field, which expires: { after } needs."
+        }
+      });
+    }
     for (const key of Object.keys(blueprint.properties)) {
-      if (RESERVED_ENTITY_KEYS2.includes(key)) {
+      if (RESERVED_ENTITY_KEYS2.includes(key) || added.includes(key)) {
         throw new ReservedEntityKey2({ source: "entity", details: { key } });
       }
     }
     for (const key of options.change ?? []) {
-      if (ENTITY_IDENTITY_KEYS2.includes(key)) {
+      if (ENTITY_IDENTITY_KEYS2.includes(key) || added.includes(key)) {
         throw new ImmutableEntityKey2({ source: "entity", details: { key } });
       }
     }
-    const DeclaredEntity = declareRecord(AbstractEntity2, identity.join(blueprint), { ...options, unique: ["id", ...options.unique ?? []] }, "entity", ENTITY_MEMBERS, context);
+    const DeclaredEntity = declareRecord(AbstractEntity2, identity.join(...versioned ? [VersionIdentity] : [], ...expiring ? [
+      blueprintFromProperties([], {
+        [EXPIRES_AT]: expiresAt
+      })
+    ] : [], blueprint), {
+      ...withoutStorage(options),
+      unique: ["id", ...options.unique ?? []]
+    }, "entity", ENTITY_MEMBERS, context);
     Object.defineProperty(DeclaredEntity, IdentifiedRecord, { value: true });
     Object.defineProperty(DeclaredEntity, EntityClock, { value: clock });
     Object.defineProperty(DeclaredEntity, EntityClassBrand, { value: true });
     Object.defineProperty(DeclaredEntity, EntityUniqueKeys2, {
       value: DeclaredEntity.options.unique
     });
+    Object.defineProperty(DeclaredEntity, EntityLifetime, { value: lifetime });
+    Object.defineProperty(DeclaredEntity, EntitySettings2, {
+      value: Object.freeze({
+        versioned,
+        expires: options.expires
+      })
+    });
     Object.defineProperty(DeclaredEntity, EntityEventSettings, {
       value: Object.freeze({
         onCreate: options.onCreate,
@@ -562,6 +663,59 @@ function isEntityClass2(value) {
 function isEntity2(value) {
   return value instanceof AbstractEntity2;
 }
+function withoutStorage(options) {
+  const { versioned: _versioned, expires: _expires, ...rest } = options;
+  return rest;
+}
+var DURATION_UNITS = {
+  days: 86400000,
+  hours: 3600000,
+  minutes: 60000,
+  seconds: 1000
+};
+function isDateField(field) {
+  if (!isProperty2(field))
+    return false;
+  const schema = field.type.schema.type.Type();
+  return schema.type === "string" && (schema.format === "date-time" || schema.format === "date");
+}
+function lifetimeOf(blueprint, options) {
+  const { expires } = options;
+  if (expires === undefined)
+    return;
+  const fail = (reason) => {
+    throw new InvalidEntityExpiry2({
+      source: options.name ?? "entity",
+      details: { reason }
+    });
+  };
+  const plain = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  if (!plain(expires) || Object.keys(expires).length !== 1)
+    return fail("expected { after: duration } or { at: key }.");
+  if ("at" in expires) {
+    const { at } = expires;
+    if (typeof at !== "string" || !Object.hasOwn(blueprint.properties, at))
+      return fail(`"${String(at)}" is not a key of the blueprint.`);
+    if (!isDateField(blueprint.properties[at]))
+      return fail(`"${at}" does not hold a date.`);
+    return;
+  }
+  if (!("after" in expires)) {
+    return fail("expected { after: duration } or { at: key }.");
+  }
+  const { after } = expires;
+  if (!plain(after) || Object.keys(after).length === 0)
+    return fail("after must be a non-empty duration, e.g. { days: 400 }.");
+  let total = 0;
+  for (const [unit, amount] of Object.entries(after)) {
+    if (!Object.hasOwn(DURATION_UNITS, unit))
+      return fail(`"${unit}" is not a unit of a duration (days, hours, minutes, seconds).`);
+    if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0)
+      return fail(`${unit} must be a positive finite number.`);
+    total += amount * DURATION_UNITS[unit];
+  }
+  return total;
+}
 
 // src/core/entity/event.ts
 var EntityClassBrand = Symbol("entityClass");
@@ -569,14 +723,20 @@ var EventBrand = Symbol("event");
 var EntityEventSettings = Symbol("entityEvents");
 var definitions = new WeakMap;
 var queues = new WeakMap;
+var withHandler = new WeakSet;
 function eventOf2(name, entityClass, handler) {
   if (!isEntityClass2(entityClass)) {
     throw new TypeError("An event requires an entity class");
   }
+  if (handler !== undefined && typeof handler !== "function") {
+    throw new TypeError(`The handler of event ${name} must be a function`);
+  }
   const event = Object.freeze({
     name,
     [EventBrand]: true
   });
+  if (handler)
+    withHandler.add(event);
   definitions.set(event, (entity) => {
     if (!(entity instanceof entityClass)) {
       throw new TypeError(`Incompatible entity for event ${name}`);
@@ -585,6 +745,8 @@ function eventOf2(name, entityClass, handler) {
       name,
       entity,
       async handle(context) {
+        if (!handler)
+          return;
         await handler(entity, {
           logger: context?.logger ?? resolveLogger(undefined, undefined) ?? silentLogger
         });
@@ -593,6 +755,23 @@ function eventOf2(name, entityClass, handler) {
   });
   return event;
 }
+function eventHasHandler(event) {
+  return withHandler.has(event);
+}
+function lifecycleEventsOf(entityClass) {
+  const settings = entityClass[EntityEventSettings];
+  const found = {};
+  for (const cycle of ["onCreate", "onUpdate", "onDelete"]) {
+    const reference = settings?.[cycle];
+    if (reference === undefined)
+      continue;
+    const events = typeof reference === "function" ? reference() : reference;
+    const list = Array.isArray(events) ? events : [events];
+    if (list.length > 0)
+      found[cycle] = list;
+  }
+  return found;
+}
 function enqueueEvent(entity, event) {
   const bind = definitions.get(event);
   if (!bind)
@@ -634,6 +813,30 @@ var RESERVED_ENTITY_KEYS2 = Object.freeze([
 ]);
 var EntityClock = Symbol("entityClock");
 var EntityUniqueKeys2 = Symbol("entityUniqueKeys");
+var EntitySettings2 = Symbol("entitySettings");
+var EntityLifetime = Symbol("entityLifetime");
+var EXPIRES_AT = "expiresAt";
+var ENTITY_VERSION_KEY = "version";
+function isVersionedEntityClass(entityClass) {
+  if (typeof entityClass !== "function")
+    return false;
+  return entityClass[EntitySettings2]?.versioned === true;
+}
+function identityKeysOf(entityClass) {
+  const keys = [...ENTITY_IDENTITY_KEYS2];
+  if (isVersionedEntityClass(entityClass))
+    keys.push(ENTITY_VERSION_KEY);
+  if (typeof entityClass === "function" && entityClass[EntityLifetime] !== undefined) {
+    keys.push(EXPIRES_AT);
+  }
+  return keys;
+}
+function isIdentityKey(Entity, key) {
+  return identityKeysOf(Entity).includes(key);
+}
+function storeEntityVersion(entity, version) {
+  storeRecordValue(entity, ENTITY_VERSION_KEY, version);
+}
 function identityOf(entity) {
   return entity;
 }
@@ -648,23 +851,34 @@ function assertAlive(entity) {
     });
   }
 }
-function withIdentity(value, clock) {
+function withIdentity(value, clock, lifetime, versioned) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return value;
   }
-  const { id, createdAt } = value;
-  if (id !== undefined && createdAt !== undefined)
+  const { id, createdAt, expiresAt, version } = value;
+  const expiring = lifetime !== undefined && expiresAt === undefined;
+  const unversioned = versioned && version === undefined;
+  if (id !== undefined && createdAt !== undefined && !expiring && !unversioned)
     return value;
-  return {
+  const created = createdAt === undefined ? clock.now() : createdAt;
+  const identity = {
     ...value,
     id: id === undefined ? clock.generateId() : id,
-    createdAt: createdAt === undefined ? clock.now() : createdAt
+    createdAt: created,
+    ...unversioned ? { [ENTITY_VERSION_KEY]: 1 } : {}
   };
+  if (expiring) {
+    const start = typeof created === "string" ? Date.parse(created) : NaN;
+    if (!Number.isNaN(start)) {
+      identity[EXPIRES_AT] = new Date(start + lifetime).toISOString();
+    }
+  }
+  return identity;
 }
 
 class AbstractEntity2 extends AbstractRecord2 {
   constructor(value) {
-    super(withIdentity(value, new.target[EntityClock]));
+    super(withIdentity(value, new.target[EntityClock], new.target[EntityLifetime], isVersionedEntityClass(new.target)));
     const input = value;
     if (input.id === undefined && input.createdAt === undefined) {
       enqueueLifecycle(this, "onCreate");
@@ -691,7 +905,7 @@ class AbstractEntity2 extends AbstractRecord2 {
   }
   set(key, value) {
     const name = String(key);
-    if (ENTITY_IDENTITY_KEYS2.includes(name)) {
+    if (isIdentityKey(this.constructor, name)) {
       throw new ImmutableEntityKey2({
         source: recordNameOf2(this.constructor),
         details: { key: name }
@@ -745,11 +959,34 @@ var RepositoryUniqueViolation2 = exceptionOf2({
   name: "RepositoryUniqueViolation",
   message: ({ key }, source) => `"${source}" already holds an entity with this "${key}".`
 });
+var RepositoryUsedOutsideApplication2 = exceptionOf2({
+  layer: "repository" /* Repository */,
+  name: "RepositoryUsedOutsideApplication",
+  message: ({
+    application,
+    repository
+  }, source) => `"${source}" is bound to the application "${application}", and its declaration no longer reads or writes: use app.repositories.${repository}, run its use cases with app.run, or give the repository of the application to execute.`
+});
 var RepositoryEntityNotFound2 = exceptionOf2({
   layer: "repository" /* Repository */,
   name: "RepositoryEntityNotFound",
   message: ({ id }, source) => `"${source}" holds no entity of id "${id}".`
 });
+var RepositoryConcurrencyConflict2 = exceptionOf2({
+  layer: "repository" /* Repository */,
+  name: "RepositoryConcurrencyConflict",
+  message: ({
+    id,
+    expected
+  }, source) => `"${source}" holds another version of "${id}" than ${expected}: it changed since it was read.`
+});
+var InvalidRepositoryIncrement2 = exceptionOf2({
+  layer: "repository" /* Repository */,
+  name: "InvalidRepositoryIncrement",
+  message: ({
+    reason
+  }) => reason
+});
 
 // src/core/repository/cursor.ts
 var VERSION = 1;
@@ -892,7 +1129,14 @@ function plain(value) {
 function isMembership(value) {
   return plain(value) && Object.keys(value).length === 1 && Array.isArray(value.in);
 }
-var QUERY_OPTIONS = ["where", "orderBy", "limit", "offset", "withDeleted"];
+var QUERY_OPTIONS = [
+  "where",
+  "orderBy",
+  "limit",
+  "offset",
+  "withDeleted",
+  "withExpired"
+];
 function prepareQuery(context, input = {}, map = (_key, value) => value, options = QUERY_OPTIONS) {
   const fail = (reason) => {
     throw new InvalidRepositoryQuery2({
@@ -917,6 +1161,8 @@ function prepareQuery(context, input = {}, map = (_key, value) => value, options
   }
   if (input.withDeleted !== undefined && typeof input.withDeleted !== "boolean")
     fail("Expected withDeleted to be boolean.");
+  if (input.withExpired !== undefined && typeof input.withExpired !== "boolean")
+    fail("Expected withExpired to be boolean.");
   let where;
   if (input.where !== undefined) {
     if (!plain(input.where))
@@ -957,8 +1203,18 @@ function sameValue(a, b) {
   const keys = Object.keys(a);
   return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && sameValue(a[key], b[key]));
 }
-function matchesQuery(data, query) {
-  return (query.withDeleted === true || data.deletedAt === undefined) && Object.entries(query.where ?? {}).every(([key, value]) => isMembership(value) ? value.in.some((candidate) => sameValue(data[key], candidate)) : sameValue(data[key], value));
+function isExpired(value, now) {
+  if (value === undefined || value === null)
+    return false;
+  const at = value instanceof Date ? value.getTime() : typeof value === "string" ? Date.parse(value) : Number.NaN;
+  return !Number.isNaN(at) && at <= now;
+}
+function nowOf(query) {
+  const now = query.now === undefined ? Number.NaN : Date.parse(query.now);
+  return Number.isNaN(now) ? Date.now() : now;
+}
+function matchesQuery(data, query, expiry, now = expiry === undefined ? 0 : nowOf(query)) {
+  return (query.withDeleted === true || data.deletedAt === undefined) && (expiry === undefined || query.withExpired === true || !isExpired(data[expiry], now)) && Object.entries(query.where ?? {}).every(([key, value]) => isMembership(value) ? value.in.some((candidate) => sameValue(data[key], candidate)) : sameValue(data[key], value));
 }
 function codePoints(text) {
   return Array.from(text, (char) => char.codePointAt(0));
@@ -1008,8 +1264,9 @@ function rowsAfter(rows, orders, after) {
   const position = Object.fromEntries(orders.map(({ key }, index) => [key, after[index]]));
   return rows.filter((row) => compareRows(orders, row, position) > 0);
 }
-function selectRows(rows, query) {
-  const ordered = orderRows([...rows].filter((data) => matchesQuery(data, query)), query);
+function selectRows(rows, query, expiry) {
+  const now = expiry === undefined ? 0 : nowOf(query);
+  const ordered = orderRows([...rows].filter((data) => matchesQuery(data, query, expiry, now)), query);
   const matched = query.after === undefined ? ordered : rowsAfter(ordered, query.orderBy ?? [], query.after);
   const start = query.offset ?? 0;
   return matched.slice(start, query.limit === undefined ? undefined : start + query.limit);
@@ -1062,15 +1319,18 @@ function scopeOf(initial, root) {
     }
   };
   const provider = {
-    capabilities: Object.freeze({ transactions: true, keyset: true }),
+    capabilities: Object.freeze({
+      transactions: true,
+      keyset: true,
+      versioning: true,
+      atomic: true,
+      expiry: true
+    }),
     findOne: (context, query = {}) => whenIdle(() => {
-      const [first] = selectRows(tableOf(context).values(), {
-        ...query,
-        limit: Math.min(query.limit ?? 1, 1)
-      });
+      const [first] = selectRows(tableOf(context).values(), { ...query, limit: Math.min(query.limit ?? 1, 1) }, context.expiry?.key);
       return first === undefined ? undefined : copy(first);
     }),
-    findMany: (context, query = {}) => whenIdle(() => selectRows(tableOf(context).values(), query).map(copy)),
+    findMany: (context, query = {}) => whenIdle(() => selectRows(tableOf(context).values(), query, context.expiry?.key).map(copy)),
     insert: (context, data) => whenIdle(() => {
       const table = tableOf(context);
       if (table.has(idOf(data))) {
@@ -1082,17 +1342,61 @@ function scopeOf(initial, root) {
       assertUnique(context, data);
       table.set(idOf(data), copy(data));
     }),
-    update: (context, data) => whenIdle(() => {
+    update: (context, data, options = {}) => whenIdle(() => {
       const table = tableOf(context);
-      if (!table.has(idOf(data))) {
+      const stored = table.get(idOf(data));
+      if (!stored) {
         throw new RepositoryEntityNotFound2({
           source: context.name,
           details: { id: idOf(data) }
         });
       }
+      const { expectedVersion: expected } = options;
+      if (expected !== undefined && stored.version !== expected) {
+        throw new RepositoryConcurrencyConflict2({
+          source: context.name,
+          details: {
+            id: idOf(data),
+            expected,
+            ...typeof stored.version === "number" ? { actual: stored.version } : {}
+          }
+        });
+      }
       assertUnique(context, data);
       table.set(idOf(data), copy(data));
     }),
+    increment: (context, id, deltas, options = {}) => whenIdle(() => {
+      const table = tableOf(context);
+      const found = table.get(id);
+      const expiry = context.expiry?.key;
+      const expired = found !== undefined && expiry !== undefined && !matchesQuery(found, { withDeleted: true, now: options.now }, expiry);
+      const stored = expired ? undefined : found;
+      if (!stored || stored.deletedAt != null) {
+        if (!options.create) {
+          throw new RepositoryEntityNotFound2({
+            source: context.name,
+            details: { id }
+          });
+        }
+        if (stored) {
+          throw new RepositoryUniqueViolation2({
+            source: context.name,
+            details: { key: "id" }
+          });
+        }
+        const created = { ...options.create, id };
+        assertUnique(context, created);
+        table.set(id, copy(created));
+        return copy(created);
+      }
+      const next = { ...stored, ...options.set };
+      for (const [key, delta] of Object.entries(deltas)) {
+        const value = stored[key];
+        next[key] = (typeof value === "number" ? value : 0) + delta;
+      }
+      table.set(id, copy(next));
+      return copy(next);
+    }),
     remove: (context, id) => whenIdle(() => {
       if (!tableOf(context).delete(id)) {
         throw new RepositoryEntityNotFound2({
@@ -1102,9 +1406,11 @@ function scopeOf(initial, root) {
       }
     }),
     count: (context, query = {}) => whenIdle(() => {
+      const expiry = context.expiry?.key;
+      const now = expiry === undefined ? 0 : nowOf(query);
       let total = 0;
       for (const data of tableOf(context).values()) {
-        if (matchesQuery(data, query))
+        if (matchesQuery(data, query, expiry, now))
           total++;
       }
       return total;
@@ -1145,6 +1451,35 @@ function inMemoryProvider2() {
   });
 }
 
+// src/core/repository/plan.ts
+var ID = Object.freeze({ access: "id" });
+var UNIQUE = Object.freeze({ access: "unique" });
+var SCAN = Object.freeze({ access: "scan" });
+function isMembership2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 1 && Array.isArray(value.in);
+}
+function planQuery(repository, query = {}) {
+  const where = query.where ?? {};
+  const keys = Object.keys(where);
+  if (keys.includes("id"))
+    return ID;
+  if (keys.some((key) => repository.unique.includes(key)))
+    return UNIQUE;
+  const equal = new Set(keys.filter((key) => !isMembership2(where[key])));
+  const first = query.orderBy?.[0]?.key;
+  let best;
+  for (const entry of Object.entries(repository.indexes ?? {})) {
+    const [, index] = entry;
+    if (!index.where.every((key) => equal.has(key)))
+      continue;
+    if (first !== undefined && index.orderBy !== first)
+      continue;
+    if (best === undefined || index.where.length > best[1].where.length)
+      best = entry;
+  }
+  return best === undefined ? SCAN : Object.freeze({ access: "index", index: best[0] });
+}
+
 // src/core/repository/state.ts
 var states = new WeakMap;
 function findState(repository) {
@@ -1163,11 +1498,22 @@ function stateOf(repository) {
     throw new TypeError("Expected a repository made by repositoryOf");
   return state;
 }
+function expiryKeyOf(entity) {
+  const expires = entity[EntitySettings2]?.expires;
+  if (expires === undefined)
+    return;
+  return "at" in expires ? expires.at : EXPIRES_AT;
+}
 function contextOf(state) {
-  state.context ??= Object.freeze({
+  if (state.context)
+    return state.context;
+  const key = expiryKeyOf(state.entity);
+  state.context = Object.freeze({
     entity: state.entity,
     name: state.name,
     unique: state.entity[EntityUniqueKeys2],
+    indexes: state.indexes,
+    ...key === undefined ? {} : { expiry: Object.freeze({ key }) },
     env: loadEnvironments(state.environment)
   });
   return state.context;
@@ -1181,6 +1527,8 @@ function inspectRepository(repository) {
     entity: state.entity,
     actions: state.actions,
     deletion: state.deletion,
+    indexes: state.indexes,
+    scans: state.scans,
     explicitProvider: state.explicitProvider,
     provider: state.explicitProvider ? state.provider : undefined,
     environments: environment === undefined ? [] : Array.isArray(environment) ? environment : [environment],
@@ -1192,33 +1540,61 @@ var origins = new WeakMap;
 function declarationOf(state) {
   return origins.get(state) ?? state;
 }
-function bindState(state, provider, instances, bound = new Map) {
+var declared = new WeakMap;
+function declareRepository(state, repository) {
+  declared.set(state, repository);
+}
+function relatedRepositoryOf(repository, Entity) {
+  const related = findState(repository)?.relations.get(Entity);
+  return related ? declared.get(declarationOf(related)) : undefined;
+}
+function bindState(state, provider, instances, logger, bound = new Map) {
   const done = bound.get(state);
   if (done)
     return done;
   const copy = {
     ...state,
+    logger,
     provider: state.explicitProvider ? instances?.get(state.provider) ?? state.provider : provider ?? state.provider,
     context: undefined,
     relations: new Map([...state.relations].map(([target, related]) => [
       target,
-      bindState(related, provider, instances, bound)
+      bindState(related, provider, instances, logger, bound)
     ]))
   };
   origins.set(copy, declarationOf(state));
   bound.set(state, copy);
   return copy;
 }
-function bindRepository(repository, provider, instances) {
+var owners = new WeakMap;
+function assertUnbound(state) {
+  const owner = owners.get(state);
+  if (owner) {
+    throw new RepositoryUsedOutsideApplication2({
+      source: state.name,
+      details: owner
+    });
+  }
+}
+function bindRepository(repository, provider, instances, binding) {
   const state = stateOf(repository);
   const Declared = repository.constructor;
 
   class Bound extends Declared {
   }
   Object.defineProperty(Bound, "name", { value: Declared.name });
-  states.set(Bound, bindState(state, provider, instances));
+  states.set(Bound, bindState(state, provider, instances, binding?.logger));
+  if (binding) {
+    owners.set(declarationOf(state), {
+      application: binding.application,
+      repository: binding.key
+    });
+  }
   return Object.freeze(new Bound);
 }
+function providerOfRepository(repository) {
+  return findState(repository)?.provider;
+}
 
 // src/core/repository/references.ts
 function isPlain(value) {
@@ -1336,7 +1712,8 @@ function parseEntity(state, data) {
 function loadByIds(state, ids, scope) {
   return scopedProvider(scope, state.provider).findMany(contextOf(state), {
     where: { id: { in: ids } },
-    withDeleted: true
+    withDeleted: true,
+    withExpired: true
   });
 }
 async function resolveReferences(state, datas, session, scope) {
@@ -1427,50 +1804,125 @@ class AbstractRepository2 {
 }
 function action(method) {
   return function(...args) {
-    return guard2({ layer: "repository" /* Repository */, source: stateOf(this).name }, () => method(this, ...args));
+    const state = stateOf(this);
+    return guard2({ layer: "repository" /* Repository */, source: state.name }, async () => {
+      assertUnbound(state);
+      return method(this, ...args);
+    });
   };
 }
 function queryValueOf(context, key, value) {
   const properties = context.entity.blueprint.properties;
   return recordFieldDataOf(properties[key], value, REFERENCES);
 }
+function expiryOf(self, withExpired) {
+  const { context, provider } = self;
+  if (context.expiry === undefined)
+    return {};
+  if (provider.capabilities?.expiry !== true) {
+    throw new InvalidRepositoryQuery2({
+      source: context.name,
+      details: {
+        reason: "The provider does not leave expired records out (capabilities.expiry), which an entity with expires needs."
+      }
+    });
+  }
+  const clock = context.entity[EntityClock];
+  return { withExpired: withExpired ?? false, now: clock.now() };
+}
 function queryOf(self, query) {
   const prepared = prepareQuery(self.context, query, (key, value) => queryValueOf(self.context, key, value));
   return {
     ...prepared,
-    withDeleted: prepared.withDeleted ?? stateOf(self).deletion === "hard"
+    withDeleted: prepared.withDeleted ?? stateOf(self).deletion === "hard",
+    ...expiryOf(self, prepared.withExpired)
   };
 }
 var equals = (self, key, value) => queryOf(self, { where: { [key]: value } });
+function planned(self, method, query, orderBy = query.orderBy) {
+  const state = stateOf(self);
+  const plan = planQuery(self.context, { where: query.where, orderBy });
+  if (plan.access === "scan" && state.scans !== "allow") {
+    const fields = {
+      repository: state.name,
+      method,
+      where: Object.keys(query.where ?? {}),
+      orderBy: (orderBy ?? []).map(({ key }) => key)
+    };
+    if (state.scans === "reject") {
+      throw new InvalidRepositoryQuery2({
+        source: state.name,
+        details: {
+          reason: `"${method}" matches no index of ${state.name} and would read every row (scans: "reject").`,
+          scan: true,
+          ...fields
+        }
+      });
+    }
+    const scope = self[ScopeKey];
+    writeLog(resolveLogger(scope?.logger ?? state.logger, undefined), "warn", "repository-scan", fields);
+  }
+  return plan.index === undefined ? query : { ...query, index: plan.index };
+}
 var findBy = (key) => action(async (self, value) => {
   const data = await self.provider.findOne(self.context, equals(self, key, value));
   return data === undefined ? undefined : await self.hydrate(data);
 });
-var findManyBy = (key) => action(async (self, value) => self.hydrateMany(await self.provider.findMany(self.context, equals(self, key, value))));
-var findMany = action(async (self, query) => self.hydrateMany(await self.provider.findMany(self.context, queryOf(self, query))));
-var exists = action(async (self, query) => await self.provider.findOne(self.context, queryOf(self, query)) !== undefined);
+var findManyBy = (key) => action(async (self, value) => self.hydrateMany(await self.provider.findMany(self.context, planned(self, `findManyBy${capitalize(key)}`, equals(self, key, value)))));
+var findMany = action(async (self, query) => self.hydrateMany(await self.provider.findMany(self.context, planned(self, "findMany", queryOf(self, query)))));
+var exists = action(async (self, query) => await self.provider.findOne(self.context, planned(self, "exists", queryOf(self, query))) !== undefined);
+var EXPLAIN_OPTIONS = [
+  "where",
+  "orderBy",
+  "limit",
+  "offset",
+  "withDeleted",
+  "after"
+];
+var explain = action(async (self, query = {}) => {
+  const prepared = prepareQuery(self.context, query, (key, value) => queryValueOf(self.context, key, value), EXPLAIN_OPTIONS);
+  return planQuery(self.context, prepared);
+});
 var findPage = action(async (self, query) => {
   const {
     orderBy,
     where,
     withDeleted,
+    withExpired,
+    now,
     limit = 20,
-    offset = 0
-  } = queryOf(self, query);
+    offset = 0,
+    index
+  } = planned(self, "findPage", queryOf(self, query));
+  const expiry = withExpired === undefined ? {} : { withExpired, now };
   const [rows, total] = await Promise.all([
     self.provider.findMany(self.context, {
       where,
       orderBy,
       withDeleted,
+      ...expiry,
       limit,
-      offset
+      offset,
+      ...index === undefined ? {} : { index }
     }),
-    self.provider.count(self.context, { where, withDeleted })
+    self.provider.count(self.context, {
+      where,
+      withDeleted,
+      ...expiry,
+      ...index === undefined ? {} : { index }
+    })
   ]);
   return { items: await self.hydrateMany(rows), total, limit, offset };
 });
-var CURSOR_OPTIONS = ["where", "orderBy", "limit", "withDeleted", "after"];
-var findCursor = action(async (self, query = {}) => {
+var CURSOR_OPTIONS = [
+  "where",
+  "orderBy",
+  "limit",
+  "withDeleted",
+  "withExpired",
+  "after"
+];
+function cursorReadOf(self, query) {
   const { context } = self;
   const fail = (reason) => {
     throw new InvalidRepositoryQuery2({
@@ -1479,7 +1931,6 @@ var findCursor = action(async (self, query = {}) => {
     });
   };
   const prepared = prepareQuery(context, query, (key, value) => queryValueOf(context, key, value), CURSOR_OPTIONS);
-  const { after } = query;
   const { where, limit = 20 } = prepared;
   if (limit < 1)
     fail("Expected a positive integer for limit.");
@@ -1492,11 +1943,27 @@ var findCursor = action(async (self, query = {}) => {
   }
   if (self.provider.capabilities?.keyset !== true)
     fail("The provider does not read by cursor (capabilities.keyset).");
+  const { index } = planned(self, "findCursor", { where }, declared);
+  expiryOf(self, prepared.withExpired);
+  return {
+    where,
+    orderBy,
+    withDeleted,
+    withExpired: prepared.withExpired,
+    limit,
+    ...index === undefined ? {} : { index }
+  };
+}
+async function readCursor(self, read, after) {
+  const { context } = self;
+  const { where, orderBy, withDeleted, limit, index } = read;
   const rows = await self.provider.findMany(context, {
     where,
     orderBy,
     withDeleted,
+    ...expiryOf(self, read.withExpired),
     limit: limit + 1,
+    ...index === undefined ? {} : { index },
     ...after === undefined ? {} : { after: decodeCursor(context.name, orderBy, after) }
   });
   const page = rows.slice(0, limit);
@@ -1506,6 +1973,49 @@ var findCursor = action(async (self, query = {}) => {
     limit,
     next: rows.length > limit && last !== undefined ? encodeCursor(orderBy, last) : undefined
   };
+}
+var findCursor = action(async (self, query = {}) => readCursor(self, cursorReadOf(self, query), query.after));
+function stopperOf(source, until) {
+  if (until === undefined)
+    return () => false;
+  if (typeof until === "function")
+    return () => Boolean(until());
+  const deadline = until instanceof Date ? until.getTime() : typeof until === "number" ? until : Number.NaN;
+  if (Number.isNaN(deadline)) {
+    throw new InvalidRepositoryQuery2({
+      source,
+      details: {
+        reason: "Expected until to be a Date, epoch milliseconds or a function."
+      }
+    });
+  }
+  return () => Date.now() >= deadline;
+}
+var forEachPage = action(async (self, query, fn, options) => {
+  const { context } = self;
+  if (typeof fn !== "function") {
+    throw new InvalidRepositoryQuery2({
+      source: context.name,
+      details: { reason: "Expected a function to run on each page." }
+    });
+  }
+  const read = cursorReadOf(self, query ?? {});
+  const stop = stopperOf(context.name, options?.until);
+  let after = query?.after;
+  let pages = 0;
+  let items = 0;
+  while (!stop()) {
+    const page = await readCursor(self, read, after);
+    if (page.items.length > 0) {
+      await fn(page.items, { index: pages, next: page.next });
+      pages += 1;
+      items += page.items.length;
+    }
+    if (page.next === undefined)
+      return { done: true, pages, items };
+    after = page.next;
+  }
+  return { done: false, next: after, pages, items };
 });
 var create = action(async (self, input) => {
   const { entity: Entity } = self.context;
@@ -1513,46 +2023,183 @@ var create = action(async (self, input) => {
   await self.provider.insert(self.context, self.dataOf(entity));
   return entity;
 });
+function nowOf2(context) {
+  return context.entity[EntityClock].now();
+}
+function assertVersioning(self) {
+  if (self.provider.capabilities?.versioning === true)
+    return;
+  invalid3(self.context.name, `${recordNameOf2(self.context.entity)} is versioned, and the provider does not check versions (capabilities.versioning).`);
+}
+async function write(self, data) {
+  if (!isVersionedEntityClass(self.context.entity)) {
+    await self.provider.update(self.context, data);
+    return data;
+  }
+  assertVersioning(self);
+  const expected = data.version;
+  const next = { ...data, version: expected + 1 };
+  await self.provider.update(self.context, next, {
+    expectedVersion: expected
+  });
+  return next;
+}
+async function writeEntity(self, entity) {
+  const written = await write(self, self.dataOf(entity));
+  if (written.version !== undefined && isEntity2(entity)) {
+    storeEntityVersion(entity, written.version);
+  }
+}
 var update = action(async (self, entity) => {
-  await self.provider.update(self.context, self.dataOf(entity));
+  await writeEntity(self, entity);
   return entity;
 });
-var remove = action(async (self, target) => {
-  const { context } = self;
-  let entity = target;
-  if (typeof target === "string") {
-    const data = await self.provider.findOne(context, equals(self, "id", target));
-    if (data === undefined) {
-      throw new RepositoryEntityNotFound2({
-        source: context.name,
-        details: { id: target }
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNumericField(field) {
+  if (field === undefined)
+    return false;
+  const property = fieldOf(field);
+  if (!isProperty2(property))
+    return false;
+  const { type } = property.type.schema.type.Type();
+  return type === "number" || type === "integer";
+}
+function deltasOf(context, deltas) {
+  const { name: source } = context;
+  const fail = (reason, issues) => {
+    throw new InvalidRepositoryIncrement2({
+      source,
+      details: { reason, issues }
+    });
+  };
+  if (!isPlainObject2(deltas) || Object.keys(deltas).length === 0) {
+    const message = "Expected an object of the numbers to add, by key.";
+    fail(message, [{ code: "invalid_type", path: [], message, source }]);
+  }
+  const { change } = context.entity.options;
+  const properties = context.entity.blueprint.properties;
+  const issues = [];
+  for (const [key, value] of Object.entries(deltas)) {
+    if (!change.includes(key) || !isNumericField(properties[key])) {
+      issues.push({
+        code: "undeclared_key",
+        path: [key],
+        message: `"${key}" is not a number in the change list of ${recordNameOf2(context.entity)}.`,
+        source
+      });
+    } else if (typeof value !== "number" || !Number.isFinite(value)) {
+      issues.push({
+        code: "invalid_value",
+        path: [key],
+        message: "Expected a finite number.",
+        source
       });
     }
-    entity = await self.hydrate(data);
   }
-  const data = self.dataOf(entity);
+  if (issues.length > 0) {
+    fail(`"${source}" cannot increment ${issues.map((issue) => `"${issue.path[0]}"`).join(", ")}.`, issues);
+  }
+  return deltas;
+}
+function createdOf(context, id, input, deltas) {
+  const identity = identityKeysOf(context.entity);
+  const value = isPlainObject2(input) ? Object.fromEntries(Object.entries(input).filter(([key]) => !identity.includes(key))) : {};
+  for (const [key, delta] of Object.entries(deltas)) {
+    const base = value[key];
+    value[key] = (typeof base === "number" ? base : 0) + delta;
+  }
+  const Entity = context.entity;
+  const entity = new Entity({ ...value, id });
+  enqueueLifecycle(entity, "onCreate");
+  return entity;
+}
+var increment = action(async (self, target, deltas, options) => {
+  const { context } = self;
+  const id = typeof target === "string" ? target : self.dataOf(target).id;
+  const checked = deltasOf(context, deltas);
+  if (options !== undefined && !isPlainObject2(options)) {
+    invalid3(context.name, "Expected the options of increment as an object.");
+  }
+  const versioned = isVersionedEntityClass(context.entity);
+  if (versioned)
+    assertVersioning(self);
+  const { create } = options ?? {};
+  const created = create === undefined ? undefined : createdOf(context, id, create, checked);
+  const stored = await self.provider.increment(context, id, versioned ? { ...checked, version: 1 } : checked, {
+    set: { updatedAt: nowOf2(context) },
+    ...created === undefined ? {} : { create: self.dataOf(created) },
+    ...context.expiry === undefined ? {} : { now: expiryOf(self, false).now }
+  });
+  if (created !== undefined && stored.updatedAt === undefined)
+    return created;
+  const entity = await self.hydrate(stored);
+  enqueueLifecycle(entity, "onUpdate");
+  return entity;
+});
+var remove = action(async (self, target) => {
+  const { context } = self;
+  let entity = target;
+  if (typeof target === "string") {
+    const data = await self.provider.findOne(context, equals(self, "id", target));
+    if (data === undefined) {
+      throw new RepositoryEntityNotFound2({
+        source: context.name,
+        details: { id: target }
+      });
+    }
+    entity = await self.hydrate(data);
+  }
+  const data = self.dataOf(entity);
   const destroyable = entity;
   if (!destroyable.isDeleted)
     destroyable.destroy();
   if (stateOf(self).deletion === "soft") {
-    await self.provider.update(context, self.dataOf(entity));
+    await writeEntity(self, entity);
   } else {
     await self.provider.remove(context, data.id);
   }
   return entity;
 });
-var count = action(async (self, query) => self.provider.count(self.context, queryOf(self, query)));
+var restore = action(async (self, target) => {
+  const { context } = self;
+  const id = typeof target === "string" ? target : self.dataOf(target).id;
+  const data = await self.provider.findOne(context, {
+    ...equals(self, "id", id),
+    withDeleted: true
+  });
+  if (data === undefined) {
+    throw new RepositoryEntityNotFound2({
+      source: context.name,
+      details: { id }
+    });
+  }
+  if (data.deletedAt === undefined)
+    return self.hydrate(data);
+  const { deletedAt: _deletedAt, ...alive } = data;
+  const restored = { ...alive, updatedAt: nowOf2(context) };
+  return self.hydrate(await write(self, restored));
+});
+var count = action(async (self, query) => {
+  const prepared = queryOf(self, query);
+  return self.provider.count(self.context, planned(self, "count", prepared, []));
+});
 var NEEDS = {
   findBy: ["findOne"],
   findManyBy: ["findMany"],
   create: ["insert"],
   update: ["update"],
   delete: ["findOne", "remove"],
+  restore: ["findOne", "update"],
   count: ["count"],
   findMany: ["findMany"],
   exists: ["findOne"],
   findPage: ["findMany", "count"],
-  findCursor: ["findMany"]
+  findCursor: ["findMany"],
+  explain: [],
+  increment: ["increment"],
+  forEachPage: ["findMany"]
 };
 function capitalize(key) {
   return `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
@@ -1573,6 +2220,57 @@ function unknownAction(entity, action, methods) {
 function invalid3(source, reason) {
   throw new InvalidRepositoryDeclaration2({ source, details: { reason } });
 }
+var INDEX_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function indexesOf(name, entity, declared) {
+  if (declared === undefined)
+    return Object.freeze({});
+  if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
+    invalid3(name, "Expected indexes to be an object of indexes by name.");
+  }
+  const properties = entity.blueprint.properties;
+  const sensitive = entity.options.sensitive;
+  const keyOf = (index, key) => {
+    if (typeof key !== "string" || !Object.hasOwn(properties, key)) {
+      invalid3(name, `The index "${index}" names "${String(key)}", which is not a key of ${recordNameOf2(entity)}.`);
+    }
+    if (sensitive.includes(key)) {
+      invalid3(name, `The index "${index}" names "${key}", which is sensitive and cannot be indexed.`);
+    }
+    return key;
+  };
+  const seen = new Map;
+  const indexes = {};
+  for (const [index, value] of Object.entries(declared)) {
+    if (!INDEX_NAME.test(index) || index === "__proto__") {
+      invalid3(name, `Expected the index "${index}" to be named by an identifier.`);
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value) || Object.keys(value).some((key) => key !== "where" && key !== "orderBy") || !Array.isArray(value.where) || value.where.length === 0) {
+      invalid3(name, `Expected the index "${index}" to be { where: [keys], orderBy?: key }.`);
+    }
+    const where = value.where.map((key) => keyOf(index, key));
+    if (new Set(where).size !== where.length) {
+      invalid3(name, `The index "${index}" names a key twice in where.`);
+    }
+    const orderBy = value.orderBy === undefined ? undefined : keyOf(index, value.orderBy);
+    if (orderBy !== undefined) {
+      const field = properties[orderBy];
+      if (isBlueprint2(field) || isBlueprintList2(field) || recordFieldOf2(field)) {
+        invalid3(name, `The index "${index}" orders by "${orderBy}", which is not scalar.`);
+      }
+    }
+    const signature = JSON.stringify([[...where].sort(), orderBy ?? null]);
+    const other = seen.get(signature);
+    if (other !== undefined) {
+      invalid3(name, `The indexes "${other}" and "${index}" are the same.`);
+    }
+    seen.set(signature, index);
+    indexes[index] = Object.freeze({
+      where: Object.freeze(where),
+      ...orderBy === undefined ? {} : { orderBy }
+    });
+  }
+  return Object.freeze(indexes);
+}
 function repositoryOf2(settings) {
   const { entity, actions, environmentDependencies } = settings ?? {};
   if (!isEntityClass2(entity) || !(EntityUniqueKeys2 in entity)) {
@@ -1583,6 +2281,10 @@ function repositoryOf2(settings) {
   if (deletion !== "hard" && deletion !== "soft") {
     invalid3(name, 'Expected deletion to be "hard" or "soft".');
   }
+  const scans = settings.scans ?? "allow";
+  if (scans !== "allow" && scans !== "warn" && scans !== "reject") {
+    invalid3(name, 'Expected scans to be "allow", "warn" or "reject".');
+  }
   const provider = settings.provider ?? inMemoryProvider2();
   if (!Array.isArray(actions) || actions.length === 0) {
     invalid3(name, "Expected a list of actions.");
@@ -1591,6 +2293,7 @@ function repositoryOf2(settings) {
     invalid3(name, "Expected environments made by environmentOf.");
   }
   const relations = relationsOf(name, entity, settings.relations);
+  const indexes = indexesOf(name, entity, settings.indexes);
   const unique = entity[EntityUniqueKeys2];
   const methods = new Map;
   for (const key of Object.keys(entity.blueprint.properties)) {
@@ -1604,11 +2307,15 @@ function repositoryOf2(settings) {
   methods.set("create", ["create", create]);
   methods.set("update", ["update", update]);
   methods.set("delete", ["delete", remove]);
+  methods.set("restore", ["restore", restore]);
   methods.set("count", ["count", count]);
   methods.set("findMany", ["findMany", findMany]);
   methods.set("exists", ["exists", exists]);
   methods.set("findPage", ["findPage", findPage]);
   methods.set("findCursor", ["findCursor", findCursor]);
+  methods.set("explain", ["explain", explain]);
+  methods.set("increment", ["increment", increment]);
+  methods.set("forEachPage", ["forEachPage", forEachPage]);
 
   class DeclaredRepository extends AbstractRepository2 {
   }
@@ -1617,6 +2324,12 @@ function repositoryOf2(settings) {
     if (!method)
       invalid3(name, unknownAction(recordNameOf2(entity), String(name_), methods));
     const [kind, implementation] = method;
+    if (kind === "restore" && deletion !== "soft") {
+      invalid3(name, '"restore" needs deletion to be "soft".');
+    }
+    if (kind === "findCursor" && settings.provider !== undefined && provider[Kind2] !== "provider-slot" && provider.capabilities?.keyset !== true) {
+      invalid3(name, '"findCursor" needs a provider that reads by cursor (capabilities.keyset).');
+    }
     const needs = deletion === "soft" && kind === "delete" ? ["findOne", "update"] : NEEDS[kind] ?? [];
     for (const need of needs) {
       if (typeof provider?.[need] !== "function") {
@@ -1630,7 +2343,7 @@ function repositoryOf2(settings) {
     });
   }
   Object.defineProperty(DeclaredRepository, "name", { value: name });
-  states.set(DeclaredRepository, {
+  const state = {
     name,
     entity,
     actions: Object.freeze([...new Set(actions)]),
@@ -1638,9 +2351,14 @@ function repositoryOf2(settings) {
     provider,
     explicitProvider: settings.provider !== undefined,
     environment: environmentDependencies,
-    relations
-  });
-  return Object.freeze(new DeclaredRepository);
+    relations,
+    indexes,
+    scans
+  };
+  states.set(DeclaredRepository, state);
+  const repository = Object.freeze(new DeclaredRepository);
+  declareRepository(state, repository);
+  return repository;
 }
 function RepositoryOf2(repository) {
   if (!isRepository2(repository)) {
@@ -1652,6 +2370,54 @@ function isRepository2(value) {
   return value instanceof AbstractRepository2;
 }
 
+// src/core/use-case/exceptions.ts
+var InvalidUseCaseStep2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "InvalidUseCaseStep",
+  message: ({
+    index,
+    reason
+  }) => `Invalid step ${index}: ${reason}`
+});
+var InvalidUseCasePlugin2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "InvalidUseCasePlugin",
+  message: ({ reason }, source) => `Invalid use case plugin "${source}": ${reason}.`
+});
+var UnknownUseCasePlugin2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UnknownUseCasePlugin",
+  message: ({ name }) => `No use case plugin "${name}" in the catalog.`
+});
+var IncompatibleUseCasePlugin2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "IncompatibleUseCasePlugin",
+  message: ({ reason }, source) => `Incompatible use case plugin "${source}": ${reason}.`
+});
+var UseCaseUnavailable2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UseCaseUnavailable",
+  message: ({
+    repository,
+    reason
+  }, source) => `The use case "${source}" is not available for "${repository}": ${reason}.`
+});
+var UseCaseEntityNotFound2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UseCaseEntityNotFound",
+  message: "The entity was not found."
+});
+var UseCaseEntityConflict2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UseCaseEntityConflict",
+  message: "The entity already exists."
+});
+var UseCaseInvalidCredentials2 = exceptionOf2({
+  layer: "use-case" /* UseCase */,
+  name: "UseCaseInvalidCredentials",
+  message: "Invalid credentials."
+});
+
 // src/core/use-case/steps/references.ts
 var RESERVED_NAMES = [
   "input",
@@ -1759,15 +2525,103 @@ function freezeData(value) {
   return value;
 }
 
-// src/core/use-case/exceptions.ts
-var InvalidUseCaseStep2 = exceptionOf2({
-  layer: "use-case" /* UseCase */,
-  name: "InvalidUseCaseStep",
-  message: ({
-    index,
-    reason
-  }) => `Invalid step ${index}: ${reason}`
-});
+// src/core/property/input.ts
+var PropertyInput2 = Symbol("propertyInput");
+function propertyInputOf2(field) {
+  const property = fieldOf(field);
+  if (!isProperty2(property))
+    return;
+  const declared = property[PropertyInput2];
+  return typeof declared === "object" && declared !== null && isProperty2(declared.accepts) && typeof declared.convert === "function" ? declared : undefined;
+}
+
+// src/core/use-case/target.ts
+function isOptionalField(field) {
+  if (isProperty2(field))
+    return field.type.optional === true;
+  const record = recordFieldOf2(field);
+  if (record)
+    return record.optional;
+  return field.optional === true;
+}
+function planOf(entity, key, owners) {
+  const field = fieldOf(entity.blueprint.properties[key]);
+  const optional = isOptionalField(field);
+  const record = recordFieldOf2(field);
+  const item = isBlueprintList2(field) ? recordFieldOf2(field.item) : undefined;
+  const related = [record?.record, item?.record].find(isEntityClass2);
+  const kind = record ? related ? "entity" : "record" : isBlueprintList2(field) ? related ? "entity-list" : "list" : isBlueprint2(field) ? "blueprint" : "property";
+  let input = { key, field };
+  if (kind === "entity" && related) {
+    const id = related.blueprint.properties.id;
+    input = { key: `${key}Id`, field: optional ? optionalOf2(id) : id };
+  }
+  const declared = kind === "property" ? propertyInputOf2(field) : undefined;
+  if (declared) {
+    input = {
+      key,
+      field: optional ? optionalOf2(declared.accepts) : declared.accepts
+    };
+  }
+  return Object.freeze({
+    key,
+    field,
+    identity: identityKeysOf(entity).includes(key),
+    plugin: owners.get(key),
+    sensitive: entity.options.sensitive.includes(key),
+    unique: entity.options.unique.includes(key),
+    optional,
+    change: entity.options.change.includes(key),
+    kind,
+    related,
+    input: Object.freeze(input),
+    convert: declared ? (value) => value === undefined ? undefined : declared.convert(value) : undefined
+  });
+}
+function useCaseTargetOf2(repository, source = "useCaseTargetOf") {
+  const state = findState(repository);
+  if (!state)
+    throw new TypeError("Expected a repository made by repositoryOf");
+  const { entity } = state;
+  const unavailable = (reason) => {
+    throw new UseCaseUnavailable2({
+      source,
+      details: { repository: state.name, reason }
+    });
+  };
+  const owners = new Map;
+  for (const plugin of pluginsOf2(entity)) {
+    for (const key of plugin.keys)
+      owners.set(key, plugin.name);
+  }
+  const fields = Object.freeze(Object.keys(entity.blueprint.properties).map((key) => planOf(entity, key, owners)));
+  const field = (key) => fields.find((plan) => plan.key === key) ?? unavailable(`the entity has no key "${key}"`);
+  return Object.freeze({
+    repository,
+    repositoryName: state.name,
+    entity,
+    entityName: recordNameOf2(entity),
+    actions: state.actions,
+    deletion: state.deletion,
+    fields,
+    changeKeys: entity.options.change,
+    uniqueKeys: entity.options.unique,
+    field,
+    relation(key, actions = []) {
+      const { related } = field(key);
+      const found = related ? relatedRepositoryOf(repository, related) : undefined;
+      if (!found) {
+        return unavailable(`the repository has no relation for the entity of "${key}"`);
+      }
+      const missing = actions.filter((action) => !found.actions.includes(action));
+      if (missing.length > 0) {
+        unavailable(`the repository of "${key}" lacks the action ${missing.map((action) => `"${action}"`).join(", ")}`);
+      }
+      return found;
+    },
+    unavailable
+  });
+}
 
 // src/core/use-case/steps/run.ts
 var FORBIDDEN_METHODS = new Set([
@@ -1801,7 +2655,6 @@ async function executeSteps(dependencies = {}) {
     return followPath(named.get(root), path);
   };
   const value = (raw) => resolveValue(raw, lookup);
-  const list = (raw) => raw === undefined ? [] : value(raw);
   for (const [index, step] of steps.entries()) {
     const invalid = (reason) => {
       throw new InvalidUseCaseStep2({
@@ -1809,6 +2662,14 @@ async function executeSteps(dependencies = {}) {
         details: { index, reason, code: "invalid_target" }
       });
     };
+    const list = (raw) => {
+      if (raw === undefined)
+        return [];
+      const resolved = value(raw);
+      if (!Array.isArray(resolved))
+        invalid("args must resolve to a list.");
+      return resolved;
+    };
     const bind = (result) => {
       if (typeof step.as === "string")
         named.set(step.as, result);
@@ -1853,7 +2714,10 @@ async function executeSteps(dependencies = {}) {
       if (typeof namespace !== "object" || namespace === null || typeof namespace[key] !== "function") {
         invalid(`"${key}" is not a change key of the record.`);
       }
-      await namespace[key]?.(value(step.value));
+      const changed = value(step.value);
+      if (step.ifPresent !== true || changed !== undefined) {
+        await namespace[key]?.(changed);
+      }
       bind(record);
     } else if (Object.hasOwn(step, "invoke")) {
       const record = target("invoke");
@@ -1867,9 +2731,9 @@ async function executeSteps(dependencies = {}) {
       bind(await child(value(step.input)));
     } else if (Object.hasOwn(step, "run")) {
       const fn = step.fn;
-      bind(await fn(...list(step.args), { context: this.context }));
+      bind(await fn(...list(step.args), { context: this.context, dependencies }));
     } else {
-      const action = ["create", "update", "delete"].find((kind) => Object.hasOwn(step, kind));
+      const action = ["create", "update", "delete", "restore"].find((kind) => Object.hasOwn(step, kind));
       const methods = dependencies[step[action]];
       bind(await methods[action].call(methods, value(step.value)));
     }
@@ -1889,11 +2753,15 @@ var SHAPES = {
     optional: ["other", "details"]
   },
   build: { required: ["build", "values", "as"], optional: [] },
-  change: { required: ["change", "key", "value"], optional: ["as"] },
+  change: {
+    required: ["change", "key", "value"],
+    optional: ["ifPresent", "as"]
+  },
   invoke: { required: ["invoke", "method"], optional: ["args", "as"] },
   create: { required: ["create", "value"], optional: ["as"] },
   update: { required: ["update", "value"], optional: ["as"] },
   delete: { required: ["delete", "value"], optional: ["as"] },
+  restore: { required: ["restore", "value"], optional: ["as"] },
   call: { required: ["call", "input"], optional: ["as"] },
   run: { required: ["run", "fn"], optional: ["args", "as"] },
   return: { required: ["return"], optional: [] }
@@ -1908,7 +2776,13 @@ var ENSURE_KINDS = new Set([
   "false"
 ]);
 var READ_ACTION = /^(?:findBy.+|findManyBy.+|findMany|exists|findPage|findCursor|count)$/;
-var WRITE_ACTIONS = new Set(["create", "update", "delete"]);
+var WRITE_ACTIONS = new Set([
+  "create",
+  "update",
+  "delete",
+  "restore",
+  "increment"
+]);
 function validateSteps(declaration, steps) {
   const { name } = declaration;
   const fail = (index, code, reason) => {
@@ -1964,8 +2838,12 @@ function validateSteps(declaration, steps) {
   const checkArgs = (index, args) => {
     if (args === undefined)
       return;
+    if (typeof args === "string" && args.startsWith("$")) {
+      checkReference(index, args);
+      return;
+    }
     if (!Array.isArray(args)) {
-      fail(index, "invalid_step", "args must be a list of values.");
+      fail(index, "invalid_step", "args must be a list of values or a reference to one.");
     }
     checkValue(index, args, "args");
   };
@@ -2026,6 +2904,9 @@ function validateSteps(declaration, steps) {
         if (WRITE_ACTIONS.has(action)) {
           fail(index, "write_in_find", `find cannot call "${action}".`);
         }
+        if (action === "forEachPage") {
+          fail(index, "unknown_action", '"forEachPage" runs a function on each page and cannot be a step; call it from a use case written in TypeScript.');
+        }
         if (!READ_ACTION.test(action)) {
           fail(index, "unknown_action", `"${action}" is not a read action.`);
         }
@@ -2072,6 +2953,9 @@ function validateSteps(declaration, steps) {
         if (typeof record.key !== "string" || record.key === "") {
           fail(index, "invalid_step", "change.key must be a string.");
         }
+        if (record.ifPresent !== undefined && typeof record.ifPresent !== "boolean") {
+          fail(index, "invalid_step", "change.ifPresent must be a boolean.");
+        }
         const reference = parseReference(record.change);
         const known = reference && reference.path.length === 0 ? bound.get(reference.root)?.record : undefined;
         if (known) {
@@ -2094,7 +2978,8 @@ function validateSteps(declaration, steps) {
       }
       case "create":
       case "update":
-      case "delete": {
+      case "delete":
+      case "restore": {
         repositoryOf(index, record[kind], kind);
         checkValue(index, record.value, "value");
         break;
@@ -2513,6 +3398,195 @@ function isUseCase2(value) {
   return value instanceof AbstractUseCase2;
 }
 
+// src/core/use-case/plugin.ts
+var UseCaseOrigin = Symbol("useCaseOrigin");
+var NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var identities = new WeakMap;
+var nextIdentity = 0;
+function keyOf(value) {
+  if (typeof value === "function" || typeof value === "object" && value) {
+    if (Array.isArray(value))
+      return `[${value.map(keyOf).join(",")}]`;
+    if (isPlain2(value)) {
+      return `{${Object.keys(value).sort().filter((key) => value[key] !== undefined).map((key) => `${JSON.stringify(key)}:${keyOf(value[key])}`).join(",")}}`;
+    }
+    let identity = identities.get(value);
+    if (identity === undefined) {
+      identity = nextIdentity++;
+      identities.set(value, identity);
+    }
+    return `#${identity}`;
+  }
+  return value === undefined ? "undefined" : JSON.stringify(value);
+}
+function isUseCasePlugin2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "use-case-plugin";
+}
+function useCaseOriginOf2(UseCase) {
+  return typeof UseCase === "function" ? UseCase[UseCaseOrigin] : undefined;
+}
+function useCasePluginOf2(name, settings) {
+  const source = typeof name === "string" ? name : "useCasePluginOf";
+  const invalid = (reason) => {
+    throw new InvalidUseCasePlugin2({ source, details: { reason } });
+  };
+  if (typeof name !== "string" || !NAME.test(name)) {
+    invalid("its name must be an identifier");
+  }
+  if (!isPlain2(settings) || typeof settings.compile !== "function") {
+    invalid("it needs a compile function");
+  }
+  const { version = "1.0.0", description, compile } = settings;
+  if (!isVersion(version)) {
+    invalid(`"${String(version)}" is not a semantic version`);
+  }
+  if (description !== undefined && typeof description !== "string") {
+    invalid("its description must be a string");
+  }
+  const names = (list, what) => {
+    if (list === undefined)
+      return Object.freeze([]);
+    if (!Array.isArray(list) || list.some((item) => typeof item !== "string" || item === "")) {
+      invalid(`requires.${what} must be a list of names`);
+    }
+    return Object.freeze([...new Set(list)]);
+  };
+  if (settings.requires !== undefined && !isPlain2(settings.requires)) {
+    invalid("requires must be an object of actions and plugins");
+  }
+  const requires = Object.freeze({
+    actions: names(settings.requires?.actions, "actions"),
+    plugins: names(settings.requires?.plugins, "plugins")
+  });
+  const made = new WeakMap;
+  const make = (repository, given) => {
+    if (!isRepository2(repository)) {
+      return invalid("it makes a use case for a repository of repositoryOf");
+    }
+    if (given !== undefined && !isPlain2(given)) {
+      return invalid("its options must be a plain object");
+    }
+    const options = Object.freeze({ ...given });
+    const info = inspectRepository(repository);
+    let classes = made.get(info.state);
+    if (!classes) {
+      classes = new Map;
+      made.set(info.state, classes);
+    }
+    const key = keyOf(options);
+    const known = classes.get(key);
+    if (known)
+      return known;
+    const target = useCaseTargetOf2(repository, name);
+    const missing = {
+      actions: requires.actions.filter((action) => !info.actions.includes(action)),
+      plugins: requires.plugins.filter((plugin) => !hasPlugin2(info.entity, plugin))
+    };
+    if (missing.actions.length > 0 || missing.plugins.length > 0) {
+      const quoted = (list) => list.map((item) => `"${item}"`).join(", ");
+      throw new UseCaseUnavailable2({
+        source: name,
+        details: {
+          repository: target.repositoryName,
+          reason: [
+            missing.actions.length > 0 ? `the repository lacks the action ${quoted(missing.actions)}` : undefined,
+            missing.plugins.length > 0 ? `the entity lacks the plugin ${quoted(missing.plugins)}` : undefined
+          ].filter(Boolean).join(" and "),
+          missing
+        }
+      });
+    }
+    const UseCase = useCaseOf2(compile(target, options));
+    Object.defineProperty(UseCase, UseCaseOrigin, {
+      value: Object.freeze({
+        plugin,
+        repository,
+        options
+      })
+    });
+    classes.set(key, UseCase);
+    return UseCase;
+  };
+  const plugin = Object.freeze({
+    [Kind2]: "use-case-plugin",
+    name,
+    version,
+    ...description === undefined ? {} : { description },
+    requires,
+    make,
+    toJSON: () => ({
+      kind: "use-case-plugin",
+      name,
+      version,
+      ...description === undefined ? {} : { description },
+      requires
+    })
+  });
+  return plugin;
+}
+
+// src/core/use-case/plugin-catalog.ts
+function isUseCaseCatalog2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "use-case-catalog";
+}
+function useCaseCatalogOf2(...plugins) {
+  const byName = {};
+  const context = {};
+  for (const plugin of plugins) {
+    if (!isUseCasePlugin2(plugin)) {
+      throw new InvalidUseCasePlugin2({
+        source: "catalog",
+        details: {
+          reason: "a catalog takes plugins made by `useCasePluginOf`"
+        }
+      });
+    }
+    if (Object.hasOwn(byName, plugin.name)) {
+      throw new InvalidUseCasePlugin2({
+        source: plugin.name,
+        details: { reason: "the catalog has another plugin with its name" }
+      });
+    }
+    byName[plugin.name] = plugin;
+    context[plugin.name] = plugin.make;
+  }
+  const find = (name) => {
+    const plugin = Object.hasOwn(byName, name) ? byName[name] : undefined;
+    if (!plugin) {
+      throw new UnknownUseCasePlugin2({ source: "catalog", details: { name } });
+    }
+    return plugin;
+  };
+  return Object.freeze({
+    [Kind2]: "use-case-catalog",
+    plugins: Object.freeze(byName),
+    list: Object.freeze([...plugins]),
+    context: Object.freeze(context),
+    resolve(reference) {
+      const at = typeof reference === "string" ? reference.lastIndexOf("@") : -1;
+      if (at <= 0)
+        return find(String(reference));
+      const plugin = find(reference.slice(0, at));
+      const version = reference.slice(at + 1);
+      if (!isVersion(version)) {
+        throw new IncompatibleUseCasePlugin2({
+          source: plugin.name,
+          details: { reason: `"${version}" is not a semantic version` }
+        });
+      }
+      if (!satisfies(plugin.version, version)) {
+        throw new IncompatibleUseCasePlugin2({
+          source: plugin.name,
+          details: {
+            reason: `version ${plugin.version} does not satisfy ${version}`
+          }
+        });
+      }
+      return plugin;
+    }
+  });
+}
+
 // src/core/command/exceptions.ts
 var InvalidCommandDeclaration2 = exceptionOf2({
   layer: "command" /* Command */,
@@ -2667,9 +3741,12 @@ function callEnvironment(source, environments, given) {
   }
   return { byEnvironment, merged: Object.freeze(merged) };
 }
-function commandOf2(settings) {
-  const { name, description, context, useCases, onEventError } = settings;
+function declareCommand(given, generics) {
+  const { name, description, context, onEventError } = given;
   const source = typeof name === "string" ? name : "commandOf";
+  const picked = given.useCases;
+  const useCases = typeof picked === "function" && !isUseCaseClass2(picked) ? guard2({ layer: "command" /* Command */, source }, () => picked(generics)) : picked;
+  const settings = given;
   const invalid = (reason) => {
     throw new InvalidCommandDeclaration2({ source, details: { reason } });
   };
@@ -2687,7 +3764,7 @@ function commandOf2(settings) {
     invalid("Expected context to be a non-optional blueprint.");
   }
   if (typeof useCases !== "object" || useCases === null || Array.isArray(useCases) || Reflect.ownKeys(useCases).length === 0) {
-    invalid("Expected useCases to be a non-empty object of use case classes.");
+    invalid("Expected useCases to be a non-empty object of use case classes, or a function returning one.");
   }
   for (const key of Reflect.ownKeys(useCases)) {
     if (typeof key !== "string" || !IDENTIFIER2.test(key) || !isUseCaseClass2(useCases[key])) {
@@ -2825,6 +3902,19 @@ function commandOf2(settings) {
   verifiers.set(command, providerOfCall);
   return command;
 }
+function commandBuilderOf2(...catalogs) {
+  if (!catalogs.every(isUseCaseCatalog2)) {
+    throw new InvalidCommandDeclaration2({
+      source: "commandBuilderOf",
+      details: {
+        reason: "Expected catalogs made by useCaseCatalogOf."
+      }
+    });
+  }
+  const generics = Object.freeze(Object.assign({}, ...catalogs.map((catalog) => catalog.context)));
+  return (settings) => declareCommand(settings, generics);
+}
+var commandOf = commandBuilderOf2();
 async function applyPolicy(command, policy, onEventError, call) {
   const { operation, raised } = call;
   const source = `${command.commandName}.${operation}`;
@@ -2837,12 +3927,16 @@ async function applyPolicy(command, policy, onEventError, call) {
     get env() {
       return call.env();
     },
-    logger: call.logger
+    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,
@@ -2888,6 +3982,81 @@ function isCommand2(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "command";
 }
 
+// src/core/event-policy/event-policy.ts
+var described = new WeakMap;
+var factories = new WeakMap;
+function invalid4(source, reason) {
+  throw new InvalidEventPolicy2({ source, details: { reason } });
+}
+function optionsOf(name, given, validate) {
+  const options = frozenJson(given ?? {}, "Event policy options", (reason) => invalid4(name, reason));
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    invalid4(name, "Event policy options must be an object.");
+  }
+  const reason = validate?.(options);
+  if (reason !== undefined)
+    invalid4(name, reason);
+  return options;
+}
+function eventPolicyOf2(settings) {
+  const name = settings?.name;
+  if (typeof name !== "string" || !/^[A-Za-z_$][\w$]*$/.test(name)) {
+    invalid4("eventPolicyOf", "Expected the policy name to be an identifier.");
+  }
+  if (typeof settings.handle !== "function") {
+    invalid4(name, "Expected handle to be a function.");
+  }
+  if (settings.publishers !== undefined && typeof settings.publishers !== "function") {
+    invalid4(name, "Expected publishers to be a function.");
+  }
+  const { handle, validate, publishers } = settings;
+  const factory = (given) => {
+    const options = optionsOf(name, given, validate);
+    const handler = (events, info) => handle(events, info, options);
+    Object.defineProperty(handler, "name", { value: name });
+    described.set(handler, {
+      description: Object.freeze({
+        kind: "policy",
+        name,
+        options
+      }),
+      publishers: Object.freeze([...publishers?.(options) ?? []])
+    });
+    return handler;
+  };
+  factories.set(factory, name);
+  return factory;
+}
+function eventPolicyDescriptionOf2(handler) {
+  return typeof handler === "function" ? described.get(handler)?.description : undefined;
+}
+function eventPolicyPublishersOf(handler) {
+  return typeof handler === "function" ? described.get(handler)?.publishers ?? [] : [];
+}
+function eventPolicyCatalogOf2(...policies) {
+  const byName = {};
+  for (const factory of policies) {
+    const name = factories.get(factory);
+    if (name === undefined) {
+      invalid4("catalog", "A catalog takes factories made by `eventPolicyOf`.");
+    }
+    if (Object.hasOwn(byName, name)) {
+      invalid4(name, "The catalog has another event policy with its name.");
+    }
+    byName[name] = factory;
+  }
+  return Object.freeze({
+    [Kind2]: "event-policy-catalog",
+    policies: Object.freeze(byName),
+    resolve(name, options) {
+      const factory = Object.hasOwn(byName, name) ? byName[name] : undefined;
+      if (!factory)
+        invalid4("catalog", `Unknown event policy "${name}".`);
+      return factory(options);
+    }
+  });
+}
+
 // src/core/openapi/exceptions.ts
 var InvalidOpenAPIModel2 = exceptionOf2({
   layer: "output" /* Output */,
@@ -2921,18 +4090,19 @@ function isExportedException(Declared) {
     collected = true;
     for (const module of [
       exports_exceptions4,
-      exports_exceptions2,
-      exports_exceptions9,
-      exports_exceptions6,
+      exports_exceptions3,
+      exports_exceptions10,
+      exports_exceptions7,
       exports_environment,
       exports_exceptions5,
-      exports_exceptions10,
+      exports_exceptions6,
       exports_exceptions11,
-      exports_exceptions3,
+      exports_exceptions12,
+      exports_exceptions2,
       exports_exceptions,
-      exports_exceptions7,
+      exports_exceptions8,
       exports_use_case,
-      exports_exceptions8
+      exports_exceptions9
     ]) {
       markExported(...Object.values(module));
     }
@@ -2991,7 +4161,7 @@ function recordSchemaOf(record, scope) {
   const { sensitive = [] } = record.options ?? {};
   return objectOf(record.blueprint.properties, scope, {
     writeOnly: sensitive,
-    readOnly: isEntityClass2(record) ? ENTITY_IDENTITY_KEYS2 : []
+    readOnly: isEntityClass2(record) ? identityKeysOf(record) : []
   });
 }
 function schemaOf(field, scope) {
@@ -3052,34 +4222,34 @@ function toOpenAPI2(modelOrModels, { refPrefix = "#/components/schemas/" } = {})
 
 // src/core/output/stage.ts
 var descriptions2 = new WeakMap;
-var factories = new WeakMap;
+var factories2 = new WeakMap;
 var opaque2 = Object.freeze({ kind: "opaque" });
-function invalid4(source, reason) {
+function invalid5(source, reason) {
   throw new InvalidOutputStage2({ source, details: { reason } });
 }
-function optionsOf(name, given, validate) {
-  const options = frozenJson(given ?? {}, "Stage options", (reason) => invalid4(name, reason));
+function optionsOf2(name, given, validate) {
+  const options = frozenJson(given ?? {}, "Stage options", (reason) => invalid5(name, reason));
   if (options === null || typeof options !== "object" || Array.isArray(options)) {
-    invalid4(name, "Stage options must be an object.");
+    invalid5(name, "Stage options must be an object.");
   }
   const reason = validate?.(options);
   if (reason !== undefined)
-    invalid4(name, reason);
+    invalid5(name, reason);
   return options;
 }
 function checkName(source, name) {
   if (typeof name !== "string" || !name.trim()) {
-    invalid4(source, "Expected the stage name to be a non-empty string.");
+    invalid5(source, "Expected the stage name to be a non-empty string.");
   }
 }
 function transformOf2(settings) {
   checkName("transformOf", settings?.name);
   if (typeof settings.apply !== "function") {
-    invalid4(settings.name, "Expected apply to be a function.");
+    invalid5(settings.name, "Expected apply to be a function.");
   }
   const { name, apply, validate } = settings;
   const factory = (given) => {
-    const options = optionsOf(name, given, validate);
+    const options = optionsOf2(name, given, validate);
     const stage = Object.freeze({
       kind: "transform",
       name,
@@ -3093,17 +4263,17 @@ function transformOf2(settings) {
     }));
     return stage;
   };
-  factories.set(factory, { kind: "transform", name });
+  factories2.set(factory, { kind: "transform", name });
   return factory;
 }
 function sinkOf2(settings) {
   checkName("sinkOf", settings?.name);
   if (typeof settings.build !== "function") {
-    invalid4(settings.name, "Expected build to be a function.");
+    invalid5(settings.name, "Expected build to be a function.");
   }
   const { name, build, validate } = settings;
   const factory = (given) => {
-    const options = optionsOf(name, given, validate);
+    const options = optionsOf2(name, given, validate);
     const stage = Object.freeze({
       kind: "sink",
       name,
@@ -3117,14 +4287,14 @@ function sinkOf2(settings) {
     }));
     return stage;
   };
-  factories.set(factory, { kind: "sink", name });
+  factories2.set(factory, { kind: "sink", name });
   return factory;
 }
 function stageDescriptionOf2(stage) {
   return descriptions2.get(stage) ?? opaque2;
 }
 function stageKindOf2(factory) {
-  return factories.get(factory)?.kind;
+  return factories2.get(factory)?.kind;
 }
 function isStage(value) {
   if (typeof value !== "object" || value === null)
@@ -3135,12 +4305,12 @@ function isStage(value) {
 function stageCatalogOf2(...stages) {
   const byName = {};
   for (const factory of stages) {
-    const known = factories.get(factory);
+    const known = factories2.get(factory);
     if (!known) {
-      invalid4("catalog", "A catalog takes factories made by `transformOf` or `sinkOf`.");
+      invalid5("catalog", "A catalog takes factories made by `transformOf` or `sinkOf`.");
     }
     if (Object.hasOwn(byName, known.name)) {
-      invalid4(known.name, "The catalog has another stage with its name.");
+      invalid5(known.name, "The catalog has another stage with its name.");
     }
     byName[known.name] = factory;
   }
@@ -3151,7 +4321,7 @@ function stageCatalogOf2(...stages) {
     resolve(name, options) {
       const factory = Object.hasOwn(byName, name) ? byName[name] : undefined;
       if (!factory)
-        invalid4("catalog", `Unknown stage "${name}".`);
+        invalid5("catalog", `Unknown stage "${name}".`);
       return factory(options);
     }
   });
@@ -3161,38 +4331,38 @@ function stageCatalogOf2(...stages) {
 function isApplicationLike(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "application";
 }
-function invalid5(source, reason) {
+function invalid6(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) {
-    invalid5(source, "Expected an operation descriptor.");
+    invalid6(source, "Expected an operation descriptor.");
   }
   if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
-    invalid5(source, "Expected the patch to be an object.");
+    invalid6(source, "Expected the patch to be an object.");
   }
   for (const key of Reflect.ownKeys(patch)) {
     if (typeof key !== "string" || !PATCHABLE.includes(key)) {
-      invalid5(source, `"${String(key)}" cannot be patched; only ${PATCHABLE.join(", ")} can.`);
+      invalid6(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))) {
-    invalid5(source, "Expected meta to be an object.");
+    invalid6(source, "Expected meta to be an object.");
   }
   if ("tags" in patch && (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string"))) {
-    invalid5(source, "Expected tags to be a list of strings.");
+    invalid6(source, "Expected tags to be a list of strings.");
   }
   if ("description" in patch && description !== undefined && typeof description !== "string") {
-    invalid5(source, "Expected description to be a string.");
+    invalid6(source, "Expected description to be a string.");
   }
   if ("deprecated" in patch && typeof deprecated !== "boolean") {
-    invalid5(source, "Expected deprecated to be a boolean.");
+    invalid6(source, "Expected deprecated to be a boolean.");
   }
   if ("invoke" in patch && typeof invoke !== "function") {
-    invalid5(source, "Expected invoke to be a function.");
+    invalid6(source, "Expected invoke to be a function.");
   }
   return Object.freeze({
     ...operation,
@@ -3233,25 +4403,25 @@ function statusesOf(name, statuses) {
   if (statuses === undefined)
     return Object.freeze({});
   if (typeof statuses !== "object" || statuses === null || Array.isArray(statuses)) {
-    invalid5(name, "Expected statuses to be a map of exception names to statuses.");
+    invalid6(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) {
-      invalid5(name, `Expected the status of "${exception}" to be an integer between 400 and 599.`);
+      invalid6(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))
-    invalid5(name, "Expected pipe to be a list of stages.");
+    invalid6(name, "Expected pipe to be a list of stages.");
   const stages = pipe;
   stages.forEach((stage, index) => {
     if (!isStage(stage)) {
-      invalid5(name, `Expected pipe[${index}] to be a transform or sink stage.`);
+      invalid6(name, `Expected pipe[${index}] to be a transform or sink stage.`);
     }
     if (stage.kind === "sink" && index !== stages.length - 1) {
-      invalid5(name, `The sink at pipe[${index}] must be the last stage.`);
+      invalid6(name, `The sink at pipe[${index}] must be the last stage.`);
     }
   });
   return Object.freeze([...stages]);
@@ -3267,7 +4437,7 @@ function transformed(name, operations, transforms, context) {
       if (result === null)
         continue;
       if (typeof result !== "object" || result?.kind !== "operation" || result.id !== operation.id) {
-        invalid5(name, `A transform must return the operation "${operation.id}" or null.`);
+        invalid6(name, `A transform must return the operation "${operation.id}" or null.`);
       }
       next.push(result);
     }
@@ -3292,7 +4462,7 @@ function make(name, commands, operations, stages, statuses) {
         return built.value;
       const sink = stages.at(-1);
       if (sink?.kind !== "sink") {
-        invalid5(name || "output", "The pipe has no sink to build.");
+        invalid6(name || "output", "The pipe has no sink to build.");
       }
       built = { value: sink.build(operations, context) };
       return built.value;
@@ -3301,7 +4471,7 @@ function make(name, commands, operations, stages, statuses) {
       const next = checkPipe(name || "output", more);
       const last = next.at(-1);
       if (stages.at(-1)?.kind === "sink") {
-        invalid5(name || "output", "Cannot add stages after the sink.");
+        invalid6(name || "output", "Cannot add stages after the sink.");
       }
       const ops = transformed(name, operations, next, context);
       if (last?.kind === "sink") {
@@ -3315,11 +4485,11 @@ function make(name, commands, operations, stages, statuses) {
 function outputOf2(settings) {
   const { name, commands } = settings ?? {};
   if (typeof name !== "string" || !name.trim()) {
-    invalid5("outputOf", "Expected name to be a non-empty string.");
+    invalid6("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))) {
-    invalid5(name, "Expected commands to be a list of commands made by commandOf or applications.");
+    invalid6(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)))
@@ -3439,7 +4609,7 @@ function deferredProvider(factory, application) {
     return provider;
   };
   const proxy = {};
-  for (const method of METHODS) {
+  for (const method of [...METHODS, "increment"]) {
     proxy[method] = (...args) => real(method)[method]?.(...args);
   }
   proxy.transaction = (run) => real("transaction").transaction(run);
@@ -3500,6 +4670,16 @@ function checkTransactions(source, provider, commands) {
     });
   }
 }
+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;
@@ -3514,7 +4694,7 @@ var METHODS2 = [
 ];
 var KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 var RESERVED = new Set(["inMemory", "__proto__", "constructor", "prototype"]);
-function invalid6(reason) {
+function invalid7(reason) {
   throw new InvalidApplicationDeclaration2({
     source: "providersOf",
     details: { reason }
@@ -3535,6 +4715,7 @@ function slotOf(key, storage, value) {
     for (const method of METHODS2)
       slot[method] = unbound;
     slot.transaction = unbound;
+    slot.increment = unbound;
     Object.defineProperty(slot, "capabilities", {
       get: () => {
         return;
@@ -3543,7 +4724,7 @@ function slotOf(key, storage, value) {
     });
   } else {
     const target = value;
-    for (const method of [...METHODS2, "transaction", "close"]) {
+    for (const method of [...METHODS2, "increment", "transaction", "close"]) {
       if (typeof target[method] === "function") {
         slot[method] = (...args) => target[method]?.(...args);
       }
@@ -3559,7 +4740,7 @@ function slotOf(key, storage, value) {
 }
 function providersOf2(entries) {
   if (typeof entries !== "object" || entries === null || Array.isArray(entries) || Object.keys(entries).length === 0) {
-    invalid6("Expected an object of providers by key.");
+    invalid7("Expected an object of providers by key.");
   }
   const storage = Object.create(null);
   storage[Kind2] = "provider-storage";
@@ -3567,17 +4748,17 @@ function providersOf2(entries) {
   const list = [];
   for (const [key, value] of Object.entries(entries)) {
     if (!KEY.test(key) || RESERVED.has(key)) {
-      invalid6(key === "inMemory" ? `"inMemory" is the built-in provider; choose another key.` : `Expected "${key}" to be an identifier that is not reserved.`);
+      invalid7(key === "inMemory" ? `"inMemory" is the built-in provider; choose another key.` : `Expected "${key}" to be an identifier that is not reserved.`);
     }
     if (isProviderSlot2(value)) {
-      invalid6(`"${key}" holds a provider of another storage; a storage holds providers, not slots.`);
+      invalid7(`"${key}" holds a provider of another storage; a storage holds providers, not slots.`);
     }
     if (!isProviderFactory2(value) && !isProviderObject(value)) {
-      invalid6(`Expected "${key}" to be a repository provider or a factory of providerFrom.`);
+      invalid7(`Expected "${key}" to be a repository provider or a factory of providerFrom.`);
     }
     const other = seen.get(value);
     if (other !== undefined) {
-      invalid6(`"${other}" and "${key}" hold the same provider.`);
+      invalid7(`"${other}" and "${key}" hold the same provider.`);
     }
     seen.set(value, key);
     const slot = slotOf(key, storage, value);
@@ -3636,9 +4817,34 @@ var KIND_OF = {
 function isApplication2(value) {
   return typeof value === "object" && value !== null && value[Kind2] === "application";
 }
-function invalid7(source, reason) {
+function invalid8(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)) {
+      invalid8(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)) {
+        invalid8(name, `Expected the publisher key "${key}" to be an identifier.`);
+      }
+      if (!isEventPublisher(publisher)) {
+        invalid8(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":
@@ -3663,7 +4869,7 @@ function isOfKind(collection, value) {
       return isDeclaredException(value);
   }
 }
-function keyOf(collection, value) {
+function keyOf2(collection, value) {
   switch (collection) {
     case "properties":
       return fieldOf(value);
@@ -3721,7 +4927,7 @@ function resolve(settings) {
   for (const other of settings.extends ?? []) {
     const resolved = internals.get(other);
     if (!resolved)
-      invalid7(source, "Expected `extends` to hold applications.");
+      invalid8(source, "Expected `extends` to hold applications.");
     for (const key of KEYS) {
       for (const entry of resolved[key].values())
         add(entry);
@@ -3732,25 +4938,39 @@ function resolve(settings) {
     if (declared === undefined)
       continue;
     if (typeof declared !== "object" || declared === null || Array.isArray(declared)) {
-      invalid7(source, `Expected ${collection} to be an object of declarations.`);
+      invalid8(source, `Expected ${collection} to be an object of declarations.`);
     }
     for (const [name, value] of Object.entries(declared)) {
       if (!isOfKind(collection, value)) {
-        invalid7(source, `${collection}.${name} is not a ${KIND_OF[collection]} (${collection} takes ${KIND_OF[collection]} declarations).`);
+        invalid8(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) {
-        invalid7(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
+        invalid8(source, `${collection}.${name} must be keyed by its name, "${declaredName}".`);
       }
       add({
         collection,
         name,
         value,
-        key: keyOf(collection, value),
+        key: keyOf2(collection, value),
         from: source
       });
     }
   }
+  for (const entry of [...registry.commands.values()]) {
+    for (const UseCase of Object.values(entry.value.useCases)) {
+      if (useCaseOriginOf2(UseCase) === undefined || byKey.has(UseCase)) {
+        continue;
+      }
+      add({
+        collection: "useCases",
+        name: UseCase.useCaseName,
+        value: UseCase,
+        key: UseCase,
+        from: entry.from
+      });
+    }
+  }
   return registry;
 }
 function recordsIn(properties) {
@@ -3861,7 +5081,7 @@ function validateOutputs(source, registry) {
   for (const entry of registry.outputs.values()) {
     const output = entry.value;
     if (!output.outputName) {
-      invalid7(source, `outputs.${entry.name} has no name (an output made by pipe cannot be registered).`);
+      invalid8(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))
@@ -4042,8 +5262,9 @@ 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 expires = entry.collection === "entities" ? Record[EntitySettings2]?.expires : undefined;
   if (entry.collection === "entities") {
-    for (const key of ENTITY_IDENTITY_KEYS2)
+    for (const key of identityKeysOf(Record))
       skip.add(key);
   }
   const own = (keys, flag) => keys.filter((key) => {
@@ -4052,6 +5273,14 @@ function recordDescriptionOf(entry, scope) {
     const field = Record.blueprint.properties[key];
     return !(flag && isProperty2(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),
@@ -4060,10 +5289,13 @@ function recordDescriptionOf(entry, scope) {
       unique: own(Record.options.unique, "unique"),
       change: own(Record.options.change)
     },
-    plugins
+    plugins,
+    ...Object.keys(events).length > 0 ? { events } : {},
+    ...expires === undefined ? {} : { expires },
+    ...entry.collection === "entities" && isVersionedEntityClass(Record) ? { versioned: true } : {}
   };
 }
-function describeRegistry(name, extended, registry, provider, named, log) {
+function describeRegistry(name, extended, registry, provider, named, log, publishers) {
   const scope = {
     properties: referencesOf(registry, "properties"),
     blueprints: referencesOf(registry, "blueprints"),
@@ -4087,6 +5319,45 @@ function describeRegistry(name, extended, registry, provider, named, log) {
       })
     };
   };
+  const describeOption = (value) => {
+    if (isLoggerDeclaration(value))
+      return "Logger";
+    if (isUseCaseClass2(value))
+      return useCaseRefs.get(value);
+    if (isEnvironment2(value))
+      return environmentRefs.get(value);
+    if (isRepository2(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)) {
@@ -4125,6 +5396,9 @@ function describeRegistry(name, extended, registry, provider, named, log) {
         })
       }
     },
+    ...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)
@@ -4146,6 +5420,8 @@ function describeRegistry(name, extended, registry, provider, named, log) {
         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 ? {} : {
@@ -4188,7 +5464,8 @@ function describeRegistry(name, extended, registry, provider, named, log) {
             ref: repositories.get(inspectRepository(dependency).state)
           }
         ])),
-        implementation: describeImplementation(UseCase)
+        implementation: describeImplementation(UseCase),
+        ...describeGeneric(UseCase)
       };
     }),
     commands: each("commands", (entry) => {
@@ -4210,7 +5487,7 @@ function describeRegistry(name, extended, registry, provider, named, log) {
         ...command.environments.length === 0 ? {} : {
           environments: command.environments.map((environment) => environmentRefs.get(environment))
         },
-        events: typeof command.events === "function" ? { kind: "opaque" } : command.events,
+        events: typeof command.events === "function" ? eventPolicyDescriptionOf2(command.events) ?? { kind: "opaque" } : command.events,
         ...command.onEventError === undefined ? {} : { onEventError: { kind: "opaque" } }
       };
     }),
@@ -4238,11 +5515,11 @@ function describeRegistry(name, extended, registry, provider, named, log) {
 function applicationOf2(settings) {
   const { name } = settings ?? {};
   if (typeof name !== "string" || name === "") {
-    invalid7("applicationOf", "Expected a name.");
+    invalid8("applicationOf", "Expected a name.");
   }
   const extended = settings.extends ?? [];
   if (!Array.isArray(extended) || !extended.every(isApplication2)) {
-    invalid7(name, "Expected `extends` to be a list of applications.");
+    invalid8(name, "Expected `extends` to be a list of applications.");
   }
   const registry = resolve(settings);
   validate(name, registry);
@@ -4250,7 +5527,7 @@ function applicationOf2(settings) {
   validateCommands(name, registry);
   validateOutputs(name, registry);
   if (settings.providers !== undefined && !isProviderStorage2(settings.providers)) {
-    invalid7(name, "Expected `providers` to be a storage made by providersOf.");
+    invalid8(name, "Expected `providers` to be a storage made by providersOf.");
   }
   const named = new Map;
   const addNamed = (entry) => {
@@ -4307,7 +5584,7 @@ function applicationOf2(settings) {
   const inheritedFrom = settings.provider === undefined ? [...extended].reverse().find((other) => other.provider) : undefined;
   const declaredProvider = settings.provider ?? inheritedFrom?.provider;
   if (declaredProvider !== undefined && typeof declaredProvider !== "object") {
-    invalid7(name, "Expected `provider` to be a repository provider.");
+    invalid8(name, "Expected `provider` to be a repository provider.");
   }
   const defaultSlot = isProviderSlot2(declaredProvider) ? declaredProvider : inheritedFrom === undefined ? undefined : defaultSlots.get(inheritedFrom);
   const provider = defaultSlot !== undefined ? instanceOf(defaultSlot, "the application") : isProviderFactory2(declaredProvider) ? deferredProvider(declaredProvider, name) : declaredProvider;
@@ -4340,14 +5617,33 @@ function applicationOf2(settings) {
     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;
+  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) : entry.value;
+    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;
@@ -4387,7 +5683,7 @@ function applicationOf2(settings) {
   const boundCommandOf = new Map;
   for (const entry of registry.commands.values()) {
     const declared = entry.value;
-    const rebuilt = !rebinds ? declared : commandOf2({
+    const rebuilt = !rebinds ? declared : commandOf({
       name: declared.commandName,
       description: declared.description,
       tags: declared.tags,
@@ -4403,6 +5699,8 @@ function applicationOf2(settings) {
     });
     if (bindsProviders)
       verifyCommand(rebuilt);
+    if (hasPublishers)
+      bindPublishers(rebuilt, publishers);
     boundCommandOf.set(entry.value, rebuilt);
     commands[entry.name] = rebuilt;
   }
@@ -4467,6 +5765,7 @@ function applicationOf2(settings) {
         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;
   };
@@ -4478,6 +5777,7 @@ function applicationOf2(settings) {
     logger: logger ?? silentLogger,
     context,
     ...logger ? { [ApplicationLoggerKey]: logger } : {},
+    ...hasPublishers ? { [ApplicationPublishersKey]: publishers } : {},
     properties: collection("properties"),
     blueprints: collection("blueprints"),
     records: collection("records"),
@@ -4490,13 +5790,13 @@ function applicationOf2(settings) {
     exceptions: collection("exceptions"),
     useCase(useCase) {
       if (!boundUseCaseOf.has(useCase)) {
-        invalid7(name, "Expected a use case registered in the application.");
+        invalid8(name, "Expected a use case registered in the application.");
       }
       return boundUseCaseOf.get(useCase);
     },
     async run(useCase, input = {}, options) {
       if (!boundUseCaseOf.has(useCase)) {
-        invalid7(name, "Expected a use case registered in the application.");
+        invalid8(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 });
@@ -4504,19 +5804,19 @@ function applicationOf2(settings) {
     },
     command(command) {
       if (!boundCommandOf.has(command)) {
-        invalid7(name, "Expected a command registered in the application.");
+        invalid8(name, "Expected a command registered in the application.");
       }
       return boundCommandOf.get(command);
     },
     output(output) {
       if (!boundOutputOf.has(output)) {
-        invalid7(name, "Expected an output registered in the application.");
+        invalid8(name, "Expected an output registered in the application.");
       }
       return boundOutputOf.get(output);
     },
     repository(repository) {
       if (!bound.has(repository)) {
-        invalid7(name, "Expected a repository registered in the application.");
+        invalid8(name, "Expected a repository registered in the application.");
       }
       return bound.get(repository);
     },
@@ -4528,7 +5828,7 @@ function applicationOf2(settings) {
         ...declaredLog === undefined ? {} : { log: declaredLog }
       });
     },
-    describe: () => describeRegistry(name, extended, registry, defaultSlot !== undefined ? referenceOf(defaultSlot) : provider === undefined ? undefined : providerDescriptionOf2(provider), named, isLogFactory2(declaredLog) ? "opaque" : log?.settings),
+    describe: () => describeRegistry(name, extended, registry, defaultSlot !== undefined ? referenceOf(defaultSlot) : provider === undefined ? undefined : providerDescriptionOf2(provider), named, isLogFactory2(declaredLog) ? "opaque" : log?.settings, origins),
     get started() {
       return started;
     },
@@ -4581,7 +5881,7 @@ function applicationOf2(settings) {
     get(declaration) {
       if (isEnvironment2(declaration)) {
         if (!registeredEnvironments.has(declaration)) {
-          invalid7(name, "Expected an environment registered in the application.");
+          invalid8(name, "Expected an environment registered in the application.");
         }
         return declaration.load();
       }
@@ -4597,11 +5897,11 @@ function applicationOf2(settings) {
       if (isProviderSlot2(declaration)) {
         const instance = instances.get(declaration);
         if (instance === undefined) {
-          invalid7(name, "Expected a provider of a storage registered in the application.");
+          invalid8(name, "Expected a provider of a storage registered in the application.");
         }
         return instance;
       }
-      return invalid7(name, "Expected a repository, use case, command, output, environment or provider registered in the application.");
+      return invalid8(name, "Expected a repository, use case, command, output, environment or provider registered in the application.");
     }
   });
   internals.set(application, registry);
@@ -4610,6 +5910,7 @@ function applicationOf2(settings) {
     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
@@ -4620,6 +5921,140 @@ function blueprintPluginOf2(name, properties, factories = {}) {
     factories: Object.freeze({ ...factories })
   });
 }
+// src/core/event-policy/publish.ts
+var KEYS2 = ["publisher", "topic", "events", "handle", "onPublishError"];
+var IDENTIFIER3 = /^[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" || !IDENTIFIER3.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/coerce.ts
+var scalarTypes = new WeakMap;
+function scalarTypesOf(blueprint) {
+  let types = scalarTypes.get(blueprint);
+  if (!types) {
+    const schema = toOpenAPI2(blueprint);
+    const found = {};
+    for (const [key, property] of Object.entries(schema.properties ?? {})) {
+      found[key] = [property.type ?? []].flat();
+    }
+    types = Object.freeze(found);
+    scalarTypes.set(blueprint, types);
+  }
+  return types;
+}
+function coerce(text, types) {
+  if (!types || types.includes("string"))
+    return text;
+  const trimmed = text.trim();
+  if (types.includes("boolean") && (trimmed === "true" || trimmed === "false")) {
+    return trimmed === "true";
+  }
+  if (types.includes("integer") || types.includes("number")) {
+    const number = trimmed === "" ? Number.NaN : Number(trimmed);
+    if (Number.isFinite(number))
+      return number;
+  }
+  return text;
+}
+function coerceTextValues2(blueprint, texts) {
+  const types = scalarTypesOf(blueprint);
+  const out = {};
+  for (const [key, value] of Object.entries(texts)) {
+    if (value !== undefined)
+      out[key] = coerce(value, types[key]);
+  }
+  return out;
+}
 // src/core/output/status.ts
 var INVALID_INPUT = new Set([
   "InvalidUseCaseInput",
@@ -4629,7 +6064,13 @@ var INVALID_INPUT = new Set([
 var CONFIGURATION = new Set(["InvalidCommandEnvironment"]);
 var NOT_FOUND = new Set([
   "RepositoryEntityNotFound",
-  "UnknownCommandOperation"
+  "UnknownCommandOperation",
+  "UseCaseEntityNotFound"
+]);
+var CONFLICT = new Set([
+  "RepositoryUniqueViolation",
+  "RepositoryConcurrencyConflict",
+  "UseCaseEntityConflict"
 ]);
 function raisedOf(error) {
   let raised = error;
@@ -4654,8 +6095,10 @@ function statusOf2(error, operation, statuses) {
   }
   if (NOT_FOUND.has(name))
     return 404;
-  if (name === "RepositoryUniqueViolation")
+  if (CONFLICT.has(name))
     return 409;
+  if (name === "UseCaseInvalidCredentials")
+    return 401;
   if (operation?.errors.some((Declared) => error.is(Declared) || Declared.name === name)) {
     return 422;
   }
@@ -4694,6 +6137,8 @@ function outputValueOf2(value) {
 
 // src/core/output/openapi-sink.ts
 var METHODS3 = ["get", "post", "put", "patch", "delete"];
+var SUCCESS_STATUSES = [200, 201, 202, 204];
+var REQUEST_ID_HEADER = "x-request-id";
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4704,36 +6149,199 @@ function onlyKeys(value, allowed, where) {
   }
   return;
 }
-function isPath(value) {
-  return typeof value === "string" && value.startsWith("/") && !/[{}?#\s]/.test(value);
+var PARAMETER = /^\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
+var HEADER_NAME = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
+var COMPONENT_NAME = /^[A-Za-z0-9._-]+$/;
+function isPath(value, parameters = true) {
+  if (typeof value !== "string" || !value.startsWith("/"))
+    return false;
+  return value.split("/").every((segment) => parameters && PARAMETER.test(segment) || !/[{}?#\s:*]/.test(segment));
 }
+function parametersOfPath(path) {
+  const names = [];
+  for (const segment of path.split("/")) {
+    const name = PARAMETER.exec(segment)?.[1];
+    if (name)
+      names.push(name);
+  }
+  return names;
+}
+function isHeaderValue(value) {
+  if (typeof value !== "string")
+    return false;
+  for (let i = 0;i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 32 && code !== 9 || code === 127)
+      return false;
+  }
+  return true;
+}
+function isScopes(value) {
+  return value === undefined || Array.isArray(value) && value.every((scope) => typeof scope === "string" && scope !== "");
+}
+var SCHEME_KEYS = {
+  http: ["scheme", "bearerFormat"],
+  apiKey: ["name", "in"],
+  oauth2: ["flows"],
+  openIdConnect: ["openIdConnectUrl"],
+  mutualTLS: []
+};
+function schemeIssue(scheme, where) {
+  if (!isObject(scheme) || typeof scheme.type !== "string") {
+    return `Expected ${where} to be a security scheme with a "type".`;
+  }
+  const keys = Object.hasOwn(SCHEME_KEYS, scheme.type) ? SCHEME_KEYS[scheme.type] : undefined;
+  if (!keys) {
+    return `Expected ${where}.type to be one of ${Object.keys(SCHEME_KEYS).join(", ")}.`;
+  }
+  const bad = onlyKeys(scheme, ["type", "description", ...keys], where);
+  if (bad)
+    return bad;
+  if (scheme.description !== undefined && typeof scheme.description !== "string") {
+    return `Expected ${where}.description to be a string.`;
+  }
+  switch (scheme.type) {
+    case "http":
+      if (typeof scheme.scheme !== "string" || !scheme.scheme) {
+        return `Expected ${where}.scheme to be a scheme such as "bearer".`;
+      }
+      if (scheme.bearerFormat !== undefined && typeof scheme.bearerFormat !== "string") {
+        return `Expected ${where}.bearerFormat to be a string.`;
+      }
+      return;
+    case "apiKey":
+      if (typeof scheme.name !== "string" || !scheme.name) {
+        return `Expected ${where}.name to be a non-empty string.`;
+      }
+      if (!["header", "query", "cookie"].includes(scheme.in)) {
+        return `Expected ${where}.in to be "header", "query" or "cookie".`;
+      }
+      return;
+    case "oauth2":
+      return isObject(scheme.flows) ? undefined : `Expected ${where}.flows to be an object.`;
+    case "openIdConnect":
+      return typeof scheme.openIdConnectUrl === "string" && scheme.openIdConnectUrl ? undefined : `Expected ${where}.openIdConnectUrl to be a URL.`;
+    default:
+      return;
+  }
+}
+function requirementIssue(requirement, schemes, where) {
+  if (!isObject(requirement) || onlyKeys(requirement, ["scheme", "scopes"], where) || typeof requirement.scheme !== "string" || !isScopes(requirement.scopes)) {
+    return `Expected ${where} to be { scheme, scopes? }.`;
+  }
+  if (!Object.hasOwn(schemes, requirement.scheme)) {
+    return `${where}.scheme names the unknown security scheme "${requirement.scheme}".`;
+  }
+  return;
+}
+function securityIssue(security, where) {
+  if (!isObject(security))
+    return `Expected ${where} to be an object.`;
+  const bad = onlyKeys(security, ["schemes", "operations", "default"], where);
+  if (bad)
+    return bad;
+  const { schemes, operations } = security;
+  if (!isObject(schemes))
+    return `Expected ${where}.schemes to be an object.`;
+  for (const [name, scheme] of Object.entries(schemes)) {
+    if (!COMPONENT_NAME.test(name)) {
+      return `Expected the security scheme "${name}" to be named with letters, digits, ".", "_" or "-".`;
+    }
+    const schemeBad = schemeIssue(scheme, `${where}.schemes["${name}"]`);
+    if (schemeBad)
+      return schemeBad;
+  }
+  if (operations !== undefined) {
+    if (!isObject(operations)) {
+      return `Expected ${where}.operations to be an object.`;
+    }
+    for (const [id, requirement] of Object.entries(operations)) {
+      if (requirement === false)
+        continue;
+      const requirementBad = requirementIssue(requirement, schemes, `${where}.operations["${id}"]`);
+      if (requirementBad)
+        return requirementBad;
+    }
+  }
+  if (security.default !== undefined) {
+    return requirementIssue(security.default, schemes, `${where}.default`);
+  }
+  return;
+}
+var ROUTE_OPTION_KEYS2 = [
+  "basePath",
+  "route",
+  "responses",
+  "requestId",
+  "security"
+];
 function routeOptionsIssue2(options, where) {
-  const { basePath, route } = options;
-  if (basePath !== undefined && (typeof basePath !== "string" || basePath !== "" && !isPath(basePath))) {
+  const { basePath, route, responses, requestId, security } = options;
+  if (basePath !== undefined && (typeof basePath !== "string" || basePath !== "" && !isPath(basePath, false))) {
     return `Expected ${where}.basePath to be "" or a path such as "/api".`;
   }
   if (route !== undefined) {
     if (!isObject(route))
       return `Expected ${where}.route to be an object.`;
     for (const [id, entry] of Object.entries(route)) {
-      if (!isObject(entry) || onlyKeys(entry, ["method", "path"], "route")) {
-        return `Expected ${where}.route["${id}"] to be { method?, path? }.`;
+      if (!isObject(entry) || onlyKeys(entry, ["method", "path", "status"], "route")) {
+        return `Expected ${where}.route["${id}"] to be { method?, path?, status? }.`;
       }
       if (entry.method !== undefined && !METHODS3.includes(entry.method)) {
         return `Expected ${where}.route["${id}"].method to be one of ${METHODS3.join(", ")}.`;
       }
-      if (entry.path !== undefined && !isPath(entry.path)) {
-        return `Expected ${where}.route["${id}"].path to start with "/" and have no parameters or query.`;
+      if (entry.path !== undefined) {
+        if (!isPath(entry.path)) {
+          return `Expected ${where}.route["${id}"].path to start with "/", with parameters only as whole "{name}" segments and no query.`;
+        }
+        const names = parametersOfPath(entry.path);
+        if (new Set(names).size !== names.length) {
+          return `Expected ${where}.route["${id}"].path to name each parameter once.`;
+        }
+      }
+      if (entry.status !== undefined && !SUCCESS_STATUSES.includes(entry.status)) {
+        return `Expected ${where}.route["${id}"].status to be one of ${SUCCESS_STATUSES.join(", ")}.`;
+      }
+    }
+  }
+  if (responses !== undefined) {
+    if (!isObject(responses)) {
+      return `Expected ${where}.responses to be an object.`;
+    }
+    for (const [id, entry] of Object.entries(responses)) {
+      const at = `${where}.responses["${id}"]`;
+      if (!isObject(entry) || onlyKeys(entry, ["headers"], at) || entry.headers !== undefined && !isObject(entry.headers)) {
+        return `Expected ${at} to be { headers?: { name: value } }.`;
+      }
+      for (const [name, value] of Object.entries(entry.headers ?? {})) {
+        if (!HEADER_NAME.test(name)) {
+          return `Expected ${at}.headers to be named by header names, not "${name}".`;
+        }
+        if (name.toLowerCase() === "content-type") {
+          return `${at}.headers cannot set "content-type": the sink sets it.`;
+        }
+        if (!isHeaderValue(value)) {
+          return `Expected ${at}.headers["${name}"] to be text without line breaks.`;
+        }
       }
     }
   }
+  if (requestId !== undefined && requestId !== true && (typeof requestId !== "string" || !HEADER_NAME.test(requestId))) {
+    return `Expected ${where}.requestId to be true or a header name.`;
+  }
+  if (security !== undefined) {
+    return securityIssue(security, `${where}.security`);
+  }
   return;
 }
-function validate2(options) {
-  const bad = onlyKeys(options, ["info", "servers", "basePath", "route"], "openapi");
+function requestIdHeaderOf2(options) {
+  return options.requestId === true ? REQUEST_ID_HEADER : options.requestId ?? undefined;
+}
+function validate3(options) {
+  const bad = onlyKeys(options, ["info", "servers", ...ROUTE_OPTION_KEYS2], "openapi");
   if (bad)
     return bad;
-  const { info, servers, basePath, route } = options;
+  const { info, servers } = options;
   if (!isObject(info))
     return "Expected openapi.info to be an object.";
   const infoBad = onlyKeys(info, ["title", "version", "description"], "info");
@@ -4756,21 +6364,38 @@ function validate2(options) {
       }
     }
   }
-  return routeOptionsIssue2({ basePath, route }, "openapi");
+  return routeOptionsIssue2(options, "openapi");
 }
-function invalid8(reason, source = "openapi") {
+function invalid9(reason, source = "openapi") {
   throw new InvalidOutputStage2({ source, details: { reason } });
 }
 function kebab(text) {
   return text.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
+function isScalarSchema(schema) {
+  const types = [schema.type ?? []].flat();
+  return !types.some((type) => type === "object" || type === "array");
+}
+function isScalarKey(operation, name) {
+  if (!Object.hasOwn(operation.input.properties, name))
+    return false;
+  const field = operation.input.properties[name];
+  return isProperty2(field) && isScalarSchema(toOpenAPI2(field));
+}
 function operationRoutes2(operations, options, source = "openapi") {
   const base = options.basePath ?? "";
   const route = options.route ?? {};
+  const responses = options.responses ?? {};
   const ids = new Set(operations.map(({ id }) => id));
-  for (const id of Object.keys(route)) {
-    if (!ids.has(id)) {
-      invalid8(`${source}.route names the unknown operation "${id}".`, source);
+  for (const [where, entries] of [
+    ["route", route],
+    ["responses", responses],
+    ["security.operations", options.security?.operations ?? {}]
+  ]) {
+    for (const id of Object.keys(entries)) {
+      if (!ids.has(id)) {
+        invalid9(`${source}.${where} names the unknown operation "${id}".`, source);
+      }
     }
   }
   const routes = new Map;
@@ -4779,12 +6404,24 @@ function operationRoutes2(operations, options, source = "openapi") {
     const chosen = route[operation.id] ?? {};
     const method = chosen.method ?? "post";
     const path = base + (chosen.path ?? `/${kebab(operation.command)}/${kebab(operation.name)}`);
-    const key = `${method} ${path}`;
+    const parameters = parametersOfPath(path);
+    for (const name of parameters) {
+      if (!isScalarKey(operation, name)) {
+        invalid9(`${source}.route["${operation.id}"].path has the parameter "{${name}}", which is not a scalar key of the input of ${operation.id}.`, source);
+      }
+    }
+    const key = `${method} ${path.replace(/\{[^}]*\}/g, "{}")}`;
     if (taken.has(key)) {
-      invalid8(`Two operations are routed to ${method.toUpperCase()} ${path}.`, source);
+      invalid9(`Two operations are routed to ${method.toUpperCase()} ${path}.`, source);
     }
     taken.add(key);
-    routes.set(operation.id, { method, path });
+    routes.set(operation.id, {
+      method,
+      path,
+      parameters,
+      status: chosen.status ?? 200,
+      headers: { ...responses[operation.id]?.headers ?? {} }
+    });
   }
   return routes;
 }
@@ -4847,7 +6484,13 @@ var STATUS_TEXT = {
   422: "Declared error of the operation.",
   500: "Internal error."
 };
-function responsesOf(operation, statuses, response) {
+var SUCCESS_TEXT = {
+  200: "Success.",
+  201: "Created.",
+  202: "Accepted.",
+  204: "No content."
+};
+function responsesOf(operation, statuses, response, route, requestIdHeader) {
   const names = new Map([
     [400, []],
     [500, []]
@@ -4865,10 +6508,22 @@ function responsesOf(operation, statuses, response) {
       list.push(Declared.name);
     names.set(status, list);
   }
+  const idHeaders = requestIdHeader ? {
+    [requestIdHeader]: {
+      description: "The id of the request: the one it sent in this header, else a new one.",
+      schema: { type: "string" }
+    }
+  } : {};
+  const successHeaders = { ...idHeaders };
+  for (const [name, value] of Object.entries(route.headers)) {
+    successHeaders[name] = { schema: { type: "string", const: value } };
+  }
+  const withHeaders = (headers) => Object.keys(headers).length > 0 ? { headers } : {};
   const responses = {
-    "200": {
-      description: "Success.",
-      content: { "application/json": { schema: response } }
+    [String(route.status)]: {
+      description: SUCCESS_TEXT[route.status],
+      ...withHeaders(successHeaders),
+      ...route.status === 204 ? {} : { content: { "application/json": { schema: response } } }
     }
   };
   for (const status of [...names.keys()].sort((a, b) => a - b)) {
@@ -4876,34 +6531,55 @@ function responsesOf(operation, statuses, response) {
     const text = STATUS_TEXT[status] ?? `Error ${status}.`;
     responses[String(status)] = {
       description: declared.length > 0 ? `${text} Declared: ${declared.join(", ")}.` : text,
+      ...withHeaders(idHeaders),
       content: problemContent
     };
   }
   return responses;
 }
-function parametersOf(operation, schema) {
+function parameterOf(name, property, where, required) {
+  const { description, ...rest } = property;
+  return {
+    name,
+    in: where,
+    required: where === "path" || required,
+    ...typeof description === "string" ? { description } : {},
+    schema: rest
+  };
+}
+function queryParametersOf(operation, schema) {
   const required = new Set(schema.required ?? []);
   return Object.entries(schema.properties ?? {}).map(([name, property]) => {
-    const field = operation.input.properties[name];
-    const type = property.type;
-    if (!isProperty2(field) || type === "object" || type === "array" || Array.isArray(type) && type.some((t) => t === "object" || t === "array")) {
-      invalid8(`${operation.id} uses a ${"get/delete"} route, whose input becomes query parameters, but "${name}" is not a scalar; route it with method "post".`);
+    if (!isProperty2(operation.input.properties[name]) || !isScalarSchema(property)) {
+      invalid9(`${operation.id} uses a get/delete route, whose input becomes query parameters, but "${name}" is not a scalar; route it with method "post".`);
     }
-    const { description, ...rest } = property;
-    return {
-      name,
-      in: "query",
-      required: required.has(name),
-      ...typeof description === "string" ? { description } : {},
-      schema: rest
-    };
+    return parameterOf(name, property, "query", required.has(name));
   });
 }
+function withoutKeys(schema, keys) {
+  if (keys.length === 0)
+    return schema;
+  const properties = { ...schema.properties ?? {} };
+  for (const key of keys)
+    delete properties[key];
+  const required = (schema.required ?? []).filter((key) => !keys.includes(key));
+  const { required: _, ...rest } = schema;
+  return {
+    ...rest,
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function requirementOf(requirement) {
+  return { [requirement.scheme]: [...requirement.scopes ?? []] };
+}
 var openapi2 = sinkOf2({
   name: "openapi",
-  validate: validate2,
+  validate: validate3,
   build: (operations, options, { output }) => {
     const routes = operationRoutes2(operations, options);
+    const requestIdHeader = requestIdHeaderOf2(options);
+    const security = options.security;
     const records = new Set;
     for (const operation of operations) {
       collectRecords(operation.input.properties, records);
@@ -4913,11 +6589,11 @@ var openapi2 = sinkOf2({
     const classes = new Map;
     for (const record of records) {
       const name = recordNameOf2(record);
-      if (!/^[A-Za-z0-9._-]+$/.test(name) || name === "Problem") {
-        invalid8(`The record class "${name}" cannot be a component name; give the class a name that is not "Problem".`);
+      if (!COMPONENT_NAME.test(name) || name === "Problem") {
+        invalid9(`The record class "${name}" cannot be a component name; give the class a name that is not "Problem".`);
       }
       if (classes.has(name)) {
-        invalid8(`Two record classes are named "${name}"; rename one.`);
+        invalid9(`Two record classes are named "${name}"; rename one.`);
       }
       classes.set(name, record);
       models[name] = record;
@@ -4934,40 +6610,52 @@ var openapi2 = sinkOf2({
       components[name] = schemas[name];
     components.Problem = problemSchema();
     for (const operation of operations) {
-      const { method, path } = routes.get(operation.id);
+      const route = routes.get(operation.id);
+      const { method, path } = route;
       const operationId = operation.id.replaceAll(".", "_");
       if (operationIds.has(operationId)) {
-        invalid8(`The operationId "${operationId}" is produced twice.`);
+        invalid9(`The operationId "${operationId}" is produced twice.`);
       }
       operationIds.add(operationId);
       const slot = paths[path] ?? {};
       paths[path] = slot;
-      const input = schemas[`${operation.id}#input`];
+      const full = schemas[`${operation.id}#input`];
+      const input = withoutKeys(full, route.parameters);
       const response = schemas[`${operation.id}#response`];
       const hasBody = method !== "get" && method !== "delete";
       const hasInput = Object.keys(input.properties ?? {}).length > 0;
+      const parameters = [
+        ...route.parameters.map((name) => parameterOf(name, full.properties?.[name], "path", true)),
+        ...hasBody ? [] : queryParametersOf(operation, input)
+      ];
+      const requirement = security?.operations?.[operation.id];
       slot[method] = {
         operationId,
         summary: operation.id,
         ...operation.description ? { description: operation.description } : {},
         ...operation.tags.length > 0 ? { tags: [...operation.tags] } : {},
         ...operation.deprecated ? { deprecated: true } : {},
-        ...!hasBody ? { parameters: parametersOf(operation, input) } : {},
+        ...!hasBody || parameters.length > 0 ? { parameters } : {},
         ...hasBody && hasInput ? {
           requestBody: {
             required: true,
             content: { "application/json": { schema: input } }
           }
         } : {},
-        responses: responsesOf(operation, output.statuses, response)
+        responses: responsesOf(operation, output.statuses, response, route, requestIdHeader),
+        ...requirement === false ? { security: [] } : requirement ? { security: [requirementOf(requirement)] } : {}
       };
     }
     return {
       openapi: "3.1.0",
       info: options.info,
       ...options.servers ? { servers: options.servers } : {},
+      ...security?.default ? { security: [requirementOf(security.default)] } : {},
       paths,
-      components: { schemas: components }
+      components: {
+        schemas: components,
+        ...security ? { securitySchemes: security.schemes } : {}
+      }
     };
   }
 });
@@ -4999,18 +6687,42 @@ var select2 = transformOf2({
     return operation;
   }
 });
-// src/core/record/plugin-catalog.ts
-function satisfies(available, requested) {
-  const [major, minor, patch] = versionParts(available);
-  const [wantedMajor, wantedMinor, wantedPatch] = versionParts(requested);
-  if (major !== wantedMajor)
-    return false;
-  if (major === 0 && minor !== wantedMinor)
-    return false;
-  if (minor !== wantedMinor)
-    return minor > wantedMinor;
-  return patch >= wantedPatch;
+// 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 (isBlueprintList2(field)) {
+    return Array.isArray(value) ? value.map((item) => fieldOf2(field.item, item)) : value;
+  }
+  if (isBlueprint2(field))
+    return collectionOf(field.properties, value);
+  const record = recordFieldOf2(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)
@@ -5120,37 +6832,37 @@ function recordPluginCatalogOf2(...plugins) {
   });
 }
 // src/std/properties/contact.ts
-import { Type } from "typebox";
+import { Type as Type2 } from "typebox";
 var Email2 = propertyOf2({
   name: "email",
-  schema: Type.String({ format: "email", maxLength: 254 }),
+  schema: Type2.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}$" }),
+  schema: Type2.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 }),
+  schema: Type2.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" })
+  schema: Type2.Union([
+    Type2.String({ format: "ipv4" }),
+    Type2.String({ format: "ipv6" })
   ]),
   default: "127.0.0.1",
   preHandle: (value) => value.trim()
 });
 
 // src/std/properties/enum.ts
-import { Type as Type2 } from "typebox";
+import { Type as Type3 } from "typebox";
 function enumOf2(values, {
   name = "enum",
   optional,
@@ -5158,7 +6870,7 @@ function enumOf2(values, {
 } = {}) {
   const Enum = propertyOf2({
     name,
-    schema: Type2.Enum(values),
+    schema: Type3.Enum(values),
     optional,
     default: _default
   });
@@ -5176,9 +6888,9 @@ function enumOf2(values, {
 }
 
 // src/std/properties/headless.ts
-import { Type as Type3 } from "typebox";
+import { Type as Type4 } from "typebox";
 import { Meta } from "typebox/schema";
-var JSON_SCHEMA = Type3.Unsafe({
+var JSON_SCHEMA = Type4.Unsafe({
   type: "object",
   allOf: [Meta["https://json-schema.org/draft/2020-12/schema"]]
 });
@@ -5186,7 +6898,7 @@ var JSON_SCHEMA = Type3.Unsafe({
 class SchemaProperty2 extends propertyOf2({
   name: "schema",
   schema: JSON_SCHEMA,
-  default: Type3.String()
+  default: Type4.String()
 }) {
   compiled;
   static deserialize(json) {
@@ -5221,7 +6933,7 @@ class SchemaProperty2 extends propertyOf2({
 
 // src/std/properties/identity.ts
 import slugify from "slugify";
-import { Type as Type4 } from "typebox";
+import { Type as Type5 } from "typebox";
 
 // src/std/runtime.ts
 var PasswordHasherRequired2 = exceptionOf2({
@@ -5417,7 +7129,7 @@ var UUID_V7 = "^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{
 
 class Id2 extends propertyOf2({
   name: "id",
-  schema: Type4.String({ pattern: UUID_V7 }),
+  schema: Type5.String({ pattern: UUID_V7 }),
   default: "01a173d2-051c-77bb-8166-a371e999573e",
   preHandle: (value) => value.toLowerCase()
 }) {
@@ -5428,7 +7140,7 @@ class Id2 extends propertyOf2({
 
 class Slug2 extends propertyOf2({
   name: "slug",
-  schema: Type4.String({
+  schema: Type5.String({
     pattern: "^[a-z0-9]+(?:-[a-z0-9]+)*$",
     maxLength: 255
   }),
@@ -5438,8 +7150,183 @@ class Slug2 extends propertyOf2({
 }) {
 }
 
+// src/std/properties/json.ts
+import { Type as Type6 } from "typebox";
+import { Meta as Meta3 } 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 = Type6.Unsafe({
+  type: "object",
+  allOf: [Meta3["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: Type6.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 Type5 } from "typebox";
+import { Type as Type7 } from "typebox";
 var PASSWORD_MIN_LENGTH2 = 7;
 var PASSWORD_MAX_LENGTH2 = 128;
 var PASSWORD_SPECIAL_CHARACTERS2 = "!@#$%^&*()-_=+[]{}|\\;:'\",.<>/?`~";
@@ -5467,13 +7354,30 @@ function passwordIssues2(value) {
   }
   return issues;
 }
+var escaped = PASSWORD_SPECIAL_CHARACTERS2.replace(/[\\\]^-]/g, "\\$&");
+
+class PlainPassword2 extends propertyOf2({
+  name: "plainPassword",
+  schema: Type7.String({
+    minLength: PASSWORD_MIN_LENGTH2,
+    maxLength: PASSWORD_MAX_LENGTH2,
+    pattern: `^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[${escaped}])`
+  }),
+  default: "Demo@123",
+  sensitive: true
+}) {
+}
 
 class Password2 extends propertyOf2({
   name: "password",
-  schema: Type5.String({ pattern: ARGON2_HASH }),
+  schema: Type7.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 = passwordIssues2(plain);
     if (issues.length > 0) {
@@ -5499,36 +7403,36 @@ class Password2 extends propertyOf2({
 }
 
 // src/std/properties/primitives.ts
-import { Type as Type6 } from "typebox";
+import { Type as Type8 } from "typebox";
 var StringProperty2 = propertyOf2({
   name: "string",
-  schema: Type6.String(),
+  schema: Type8.String(),
   default: "demo"
 });
 var Text2 = propertyOf2({
   name: "text",
-  schema: Type6.String({ minLength: 1 }),
+  schema: Type8.String({ minLength: 1 }),
   default: "Demo",
   preHandle: (value) => value.trim()
 });
 var NumberProperty2 = propertyOf2({
   name: "number",
-  schema: Type6.Number(),
+  schema: Type8.Number(),
   default: 0
 });
 var Integer2 = propertyOf2({
   name: "integer",
-  schema: Type6.Integer(),
+  schema: Type8.Integer(),
   default: 0
 });
 var BooleanProperty2 = propertyOf2({
   name: "boolean",
-  schema: Type6.Boolean(),
+  schema: Type8.Boolean(),
   default: false
 });
 
 // src/std/properties/time.ts
-import { Type as Type7 } from "typebox";
+import { Type as Type9 } from "typebox";
 var DEMO_DATE_TIME = "2026-01-01T00:00:00.000Z";
 function dateTimeOf({
   name,
@@ -5537,7 +7441,7 @@ function dateTimeOf({
 }) {
   return class extends propertyOf2({
     name,
-    schema: Type7.String({ format: "date-time" }),
+    schema: Type9.String({ format: "date-time" }),
     optional,
     default: _default
   }) {
@@ -5554,7 +7458,7 @@ class DateTime2 extends dateTimeOf({
 }
 var DateProperty2 = propertyOf2({
   name: "date",
-  schema: Type7.String({ format: "date" }),
+  schema: Type9.String({ format: "date" }),
   default: "2026-01-01"
 });
 
@@ -5577,6 +7481,12 @@ class DeletedAt2 extends dateTimeOf({
 }) {
 }
 
+class ExpiresAt2 extends dateTimeOf({
+  name: "expiresAt",
+  default: DEMO_DATE_TIME
+}) {
+}
+
 // src/std/blueprint-plugin.ts
 var Std2 = blueprintPluginOf2("std", {
   id: Id2,
@@ -5596,11 +7506,601 @@ var Std2 = blueprintPluginOf2("std", {
   createdAt: CreatedAt2,
   updatedAt: UpdatedAt2,
   deletedAt: DeletedAt2,
-  schema: SchemaProperty2
-}, { enumOf: enumOf2 });
+  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 IDENTIFIER4 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var capitalize2 = (key) => `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+function literal(value) {
+  if (typeof value === "string") {
+    return value.startsWith("$") ? { literal: value } : value;
+  }
+  if (Array.isArray(value))
+    return value.map(literal);
+  if (isPlain2(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, literal(item)]));
+  }
+  return value;
+}
+function checkOptions(target, options, allowed) {
+  const known = [...COMMON, ...allowed];
+  for (const key of Object.keys(options)) {
+    if (!known.includes(key)) {
+      target.unavailable(`it has no option "${key}" (options: ${known.join(", ")})`);
+    }
+  }
+}
+var COMMON = ["name", "description", "tags", "deprecated", "errors"];
+var HOOKS = ["before", "after", "dependencies", "throws"];
+function metaOf(target, options, verb) {
+  const { name, description, tags, deprecated } = options;
+  if (name !== undefined && (typeof name !== "string" || name === "")) {
+    target.unavailable("the option name must be a non-empty string");
+  }
+  return {
+    name: name ?? `${verb}${target.entityName}`,
+    ...description === undefined ? {} : { description },
+    ...tags === undefined ? {} : { tags },
+    ...deprecated === undefined ? {} : { deprecated }
+  };
+}
+function asOf(target, options) {
+  const { as = "item" } = options;
+  if (typeof as !== "string" || !IDENTIFIER4.test(as)) {
+    target.unavailable("the option as must be an identifier");
+  }
+  return as;
+}
+function errorOf(target, options, kind, fallback) {
+  const { errors } = options;
+  if (errors === undefined)
+    return fallback;
+  if (!isPlain2(errors)) {
+    return target.unavailable("the option errors must be an object of exception classes");
+  }
+  const given = errors[kind];
+  if (given === undefined)
+    return fallback;
+  if (!isDeclaredException(given)) {
+    return target.unavailable(`errors.${kind} must be a class made by exceptionOf`);
+  }
+  return given;
+}
+function keysOf(target, options, option) {
+  const given = options[option];
+  if (given === undefined)
+    return [];
+  if (!Array.isArray(given) || given.some((key) => typeof key !== "string")) {
+    return target.unavailable(`the option ${option} must be a list of keys`);
+  }
+  return given.map((key) => target.field(key));
+}
+function valuesOf(target, options, option) {
+  const given = options[option];
+  if (given === undefined)
+    return {};
+  if (!isPlain2(given)) {
+    return target.unavailable(`the option ${option} must be an object`);
+  }
+  for (const key of Object.keys(given)) {
+    if (target.field(key).identity) {
+      target.unavailable(`${option}.${key} is an identity key`);
+    }
+  }
+  return given;
+}
+function ownerOf(target, options) {
+  const { owner } = options;
+  if (owner === undefined)
+    return;
+  if (!isPlain2(owner) || typeof owner.context !== "string" || !IDENTIFIER4.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 (!isPlain2(dependencies) || Object.keys(dependencies).some((key) => !IDENTIFIER4.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 idOf2 = (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: idOf2(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${capitalize2(key)}`,
+        fn: plan.convert,
+        args: [given],
+        as: `${key}Converted`
+      });
+      values[key] = `$${key}Converted`;
+    } else {
+      values[key] = given;
+    }
+  }
+  return {
+    ...metaOf(target, options, verb),
+    blueprint: fields(() => input),
+    response: fields(() => ({ [asOf(target, options)]: target.entity })),
+    ...contextOf2(owner),
+    dependencies: 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 create2 = useCasePluginOf2("create", {
+  description: "Builds an entity from the input (its keys, less the identity; an entity it holds by id) and stores it.",
+  requires: { actions: ["create"] },
+  compile: (target, options) => createCompilation(target, options, "Create")
+});
+var get = useCasePluginOf2("get", {
+  description: "Gives the entity of an id.",
+  requires: { actions: ["findById"] },
+  compile: (target, options) => entityUseCase(target, options, "Get", [], () => ({
+    steps: [],
+    result: "$item"
+  }))
+});
+var list = useCasePluginOf2("list", {
+  description: "Gives a page of entities: { items, total, limit, offset }.",
+  requires: { actions: ["findPage"] },
+  compile: (target, options) => {
+    checkOptions(target, options, ["owner", "orderBy"]);
+    const owner = ownerOf(target, options);
+    const { orderBy = [{ key: "createdAt", direction: "desc" }] } = options;
+    if (!Array.isArray(orderBy)) {
+      target.unavailable("the option orderBy must be a list of orders");
+    }
+    for (const order of orderBy) {
+      target.field(String(order?.key));
+    }
+    return {
+      ...metaOf(target, options, "List"),
+      blueprint: fields(() => ({
+        limit: optionalOf2(Integer2),
+        offset: optionalOf2(Integer2)
+      })),
+      response: fields(() => ({
+        items: listOf2(target.entity),
+        total: Integer2,
+        limit: Integer2,
+        offset: Integer2
+      })),
+      ...contextOf2(owner),
+      dependencies: { repository: target.repository },
+      steps: [
+        {
+          find: "repository.findPage",
+          args: [
+            {
+              ...owner ? {
+                where: {
+                  [owner.plan.key]: `$context.${owner.context}`
+                }
+              } : {},
+              orderBy: literal(orderBy),
+              limit: "$input.limit",
+              offset: "$input.offset"
+            }
+          ],
+          as: "page"
+        },
+        {
+          return: {
+            items: "$page.items",
+            total: "$page.total",
+            limit: "$page.limit",
+            offset: "$page.offset"
+          }
+        }
+      ]
+    };
+  }
+});
+var update2 = useCasePluginOf2("update", {
+  description: "Changes the change keys the input gives, leaving the others as they are, and stores the entity.",
+  requires: { actions: ["findById", "update"] },
+  compile: (target, options) => {
+    checkOptions(target, options, ["as", "owner", ...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${capitalize2(plan.key)}`,
+          fn: plan.convert,
+          args: [given],
+          as: `${plan.key}Converted`
+        });
+        value = `$${plan.key}Converted`;
+      }
+      steps.push({ change: "$item", key: plan.key, value, ifPresent: true });
+    }
+    return {
+      ...metaOf(target, options, "Update"),
+      blueprint: fields(() => ({
+        id: idOf2(target),
+        ...Object.fromEntries(plans.map((plan) => [plan.input.key, optionalOf2(plan.input.field)]))
+      })),
+      response: fields(() => ({ [asOf(target, options)]: target.entity })),
+      ...contextOf2(owner),
+      dependencies: 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 remove2 = useCasePluginOf2("delete", {
+  description: "Deletes the entity of an id, hard or soft as the repository declares, and gives it.",
+  requires: { actions: ["findById", "delete"] },
+  compile: (target, options) => entityUseCase(target, options, "Delete", [], () => ({
+    steps: [{ delete: "repository", value: "$item", as: "deleted" }],
+    result: "$deleted"
+  }), true)
+});
+var restore2 = useCasePluginOf2("restore", {
+  description: "Brings back the soft-deleted entity of an id; for a repository with soft deletion and the restore action.",
+  requires: { actions: ["restore"] },
+  compile: (target, options) => {
+    checkOptions(target, options, ["as", ...HOOKS]);
+    const hooks = hooksOf(target, options);
+    return {
+      ...metaOf(target, options, "Restore"),
+      blueprint: fields(() => ({ id: idOf2(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 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; issues no token.",
+  ...authenticatable(["findByEmail"]),
+  compile: (target, options) => {
+    checkOptions(target, options, ["as"]);
+    const invalid = errorOf(target, options, "invalid", UseCaseInvalidCredentials2);
+    return {
+      ...metaOf(target, options, "Login"),
+      blueprint: fields(() => ({
+        email: target.field("email").field,
+        password: StringProperty2
+      })),
+      response: fields(() => ({ [asOf(target, options)]: target.entity })),
+      dependencies: { repository: target.repository },
+      errors: [invalid],
+      steps: [
+        { find: "repository.findByEmail", args: ["$input.email"], as: "item" },
+        { ensure: "exists", value: "$item", error: invalid },
+        {
+          invoke: "$item",
+          method: "verifyPassword",
+          args: ["$input.password"],
+          as: "matches"
+        },
+        { ensure: "true", value: "$matches", error: invalid },
+        { return: { [asOf(target, options)]: "$item" } }
+      ]
+    };
+  }
+});
+
+// src/std/use-cases/lifecycle.ts
+function invoking(target, options, verb, method) {
+  const set = valuesOf(target, options, "set");
+  const changes = Object.entries(set).map(([key, value]) => {
+    if (!target.changeKeys.includes(key)) {
+      target.unavailable(`set.${key} is not a change key of the entity`);
+    }
+    return { change: "$item", key, value: literal(value) };
+  });
+  return entityUseCase(target, options, verb, ["set"], () => ({
+    steps: [
+      ...changes,
+      { invoke: "$item", method },
+      { update: "repository", value: "$item", as: "saved" }
+    ],
+    result: "$saved"
+  }), 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: idOf2(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(create2, get, list, update2, remove2, restore2, publish, unpublish, archive, unarchive, tag, untag, register, login);
+
+// src/std/command.ts
+var commandOf2 = commandBuilderOf2(StdUseCases2);
 // src/std/record-plugins.ts
 var now = () => new Date().toISOString();
 
@@ -5682,10 +8182,13 @@ var entityOf2 = entityBuilderOf2({
   identity: Identity,
   generateId,
   now: () => new Date().toISOString(),
+  expiresAt: ExpiresAt2,
   plugins: [StdRecordPlugins2]
 });
+// src/std/event-policies.ts
+var StdEventPolicies2 = eventPolicyCatalogOf2(publishEvents2);
 // src/std/record.ts
 var recordOf2 = recordBuilderOf2(StdRecordPlugins2);
 // src/std/stages.ts
 var StdStages2 = stageCatalogOf2(select2, openapi2);
-export { InvalidEnvironment2, environmentOf2, isEnvironment2, guard2, InvalidApplicationDeclaration2, DuplicateApplicationDeclaration2, ApplicationConflict2, UnregisteredApplicationReference2, UnregisteredRepositoryDependency2, UnregisteredUseCaseDependency2, ApplicationNotStarted2, ProviderNotBound2, ApplicationAlreadyStarted2, InvalidApplicationEnvironment2, useApplication2, resetApplication2, InvalidLogDeclaration2, LogLevels2, logProviderOf2, consoleLogProvider2, jsonLogProvider2, memoryLogProvider2, Logger2, ReservedEntityKey2, ImmutableEntityKey2, DeletedEntity2, entityBuilderOf2, isEntityClass2, isEntity2, eventOf2, ENTITY_IDENTITY_KEYS2, RESERVED_ENTITY_KEYS2, EntityUniqueKeys2, AbstractEntity2, InvalidRepositoryQuery2, InvalidRepositoryCursor2, InvalidRepositoryDeclaration2, InvalidRepositoryEntity2, InvalidRepositoryData2, RepositoryUniqueViolation2, RepositoryEntityNotFound2, providerOf2, providerDescriptionOf2, inMemoryProvider2, AbstractRepository2, repositoryOf2, RepositoryOf2, isRepository2, InvalidUseCaseStep2, InvalidUseCaseDeclaration2, UseCaseAlreadyExecuted2, InvalidUseCaseDependencies2, AbstractUseCase2, useCaseOf2, isUseCaseClass2, isUseCase2, InvalidCommandDeclaration2, UnknownCommandOperation2, InvalidCommandContext2, InvalidCommandEnvironment2, CommandEventFailed2, commandOf2, isCommand2, InvalidOpenAPIModel2, InvalidOutputStage2, DuplicateOperation2, toOpenAPI2, transformOf2, sinkOf2, stageDescriptionOf2, stageKindOf2, stageCatalogOf2, operationOf2, outputOf2, isOutput2, providerFrom2, logFrom2, isLogFactory2, isProviderFactory2, providersOf2, isProviderSlot2, isProviderStorage2, isApplication2, applicationOf2, blueprintPluginOf2, statusOf2, PROBLEM_MEDIA_TYPE2, problemOf2, outputValueOf2, routeOptionsIssue2, operationRoutes2, openapi2, select2, recordPluginCatalogOf2, Email2, Phone2, Url2, Ip2, enumOf2, SchemaProperty2, PasswordHasherRequired2, SyncVerifyUnsupported2, configure2, resetRuntime2, Id2, Slug2, PASSWORD_MIN_LENGTH2, PASSWORD_MAX_LENGTH2, PASSWORD_SPECIAL_CHARACTERS2, isPasswordHash2, passwordIssues2, Password2, StringProperty2, Text2, NumberProperty2, Integer2, BooleanProperty2, DateTime2, DateProperty2, CreatedAt2, UpdatedAt2, DeletedAt2, Std2, blueprintOf2, Publishable2, Archivable2, Taggable2, Ownable2, Authenticatable2, StdRecordPlugins2, entityOf2, recordOf2, StdStages2 };
+export { InvalidEnvironment2, environmentOf2, isEnvironment2, InvalidApplicationDeclaration2, DuplicateApplicationDeclaration2, ApplicationConflict2, UnregisteredApplicationReference2, UnregisteredRepositoryDependency2, UnregisteredUseCaseDependency2, ApplicationNotStarted2, ProviderNotBound2, ApplicationAlreadyStarted2, InvalidApplicationEnvironment2, useApplication2, resetApplication2, InvalidEventPolicy2, PublisherNotBound2, guard2, InvalidLogDeclaration2, LogLevels2, logProviderOf2, consoleLogProvider2, jsonLogProvider2, memoryLogProvider2, Logger2, ReservedEntityKey2, ImmutableEntityKey2, DeletedEntity2, InvalidEntityExpiry2, EntityVersion2, entityBuilderOf2, isEntityClass2, isEntity2, eventOf2, ENTITY_IDENTITY_KEYS2, RESERVED_ENTITY_KEYS2, EntityUniqueKeys2, EntitySettings2, AbstractEntity2, InvalidRepositoryQuery2, InvalidRepositoryCursor2, InvalidRepositoryDeclaration2, InvalidRepositoryEntity2, InvalidRepositoryData2, RepositoryUniqueViolation2, RepositoryUsedOutsideApplication2, RepositoryEntityNotFound2, RepositoryConcurrencyConflict2, InvalidRepositoryIncrement2, providerOf2, providerDescriptionOf2, inMemoryProvider2, AbstractRepository2, repositoryOf2, RepositoryOf2, isRepository2, InvalidUseCaseStep2, InvalidUseCasePlugin2, UnknownUseCasePlugin2, IncompatibleUseCasePlugin2, UseCaseUnavailable2, UseCaseEntityNotFound2, UseCaseEntityConflict2, UseCaseInvalidCredentials2, PropertyInput2, propertyInputOf2, useCaseTargetOf2, InvalidUseCaseDeclaration2, UseCaseAlreadyExecuted2, InvalidUseCaseDependencies2, AbstractUseCase2, useCaseOf2, isUseCaseClass2, isUseCase2, isUseCasePlugin2, useCaseOriginOf2, useCasePluginOf2, isUseCaseCatalog2, useCaseCatalogOf2, InvalidCommandDeclaration2, UnknownCommandOperation2, InvalidCommandContext2, InvalidCommandEnvironment2, CommandEventFailed2, commandBuilderOf2, isCommand2, eventPolicyOf2, eventPolicyDescriptionOf2, eventPolicyCatalogOf2, InvalidOpenAPIModel2, InvalidOutputStage2, DuplicateOperation2, toOpenAPI2, transformOf2, sinkOf2, stageDescriptionOf2, stageKindOf2, stageCatalogOf2, operationOf2, outputOf2, isOutput2, providerFrom2, logFrom2, isLogFactory2, isProviderFactory2, providersOf2, isProviderSlot2, isProviderStorage2, isApplication2, applicationOf2, blueprintPluginOf2, publishEvents2, coerceTextValues2, statusOf2, PROBLEM_MEDIA_TYPE2, problemOf2, outputValueOf2, ROUTE_OPTION_KEYS2, routeOptionsIssue2, requestIdHeaderOf2, operationRoutes2, openapi2, select2, stripUndeclared2, recordPluginCatalogOf2, Email2, Phone2, Url2, Ip2, enumOf2, SchemaProperty2, PasswordHasherRequired2, SyncVerifyUnsupported2, configure2, resetRuntime2, Id2, Slug2, InvalidJsonData2, InvalidJsonSchema2, jsonSchemaIssues2, checkJsonSchema2, JsonProperty2, jsonOf2, PASSWORD_MIN_LENGTH2, PASSWORD_MAX_LENGTH2, PASSWORD_SPECIAL_CHARACTERS2, isPasswordHash2, passwordIssues2, 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, StdStages2 };