@afora/core 0.0.9 → 0.0.12

package/dist/index-3aae5jfq.js

@@ -1,2997 +0,0 @@
-import {
-  __export,
-  isProperty,
-  fieldOf,
-  Kind2,
-  isBlueprint,
-  isRecordClass,
-  recordFieldOf,
-  Exception2,
-  isDeclaredException,
-  exceptionOf2,
-  blueprintOfVariant,
-  namedVariantOf,
-  variantOfValue,
-  isBlueprintVariant,
-  recordNameOf2,
-  declaredRecordNameOf,
-  isBlueprintList,
-  isEnvironment,
-  silentLogger,
-  isLoggerDeclaration,
-  isLogger,
-  resolveLogger,
-  clock,
-  elapsed,
-  logFailure,
-  writeLog,
-  recordDataOf,
-  recordFieldDataOf,
-  optionalOf2,
-  isVersion,
-  pluginsOf2,
-  hasPlugin2,
-  InvalidEntitySchemaVersion2,
-  isEntityClass2,
-  isEntity2,
-  enqueueLifecycle,
-  EntityClock,
-  EntityUniqueKeys2,
-  EntitySettings2,
-  SCHEMA_VERSION_KEY2,
-  isVersionedEntityClass,
-  identityKeysOf,
-  storeEntityVersion,
-  InvalidRepositoryQuery2,
-  InvalidRepositoryCursor2,
-  InvalidRepositoryDeclaration2,
-  InvalidRepositoryEntity2,
-  InvalidStoredSchemaVersion2,
-  InvalidRepositoryData2,
-  RepositoryUniqueViolation2,
-  RepositoryEntityNotFound2,
-  RepositoryConcurrencyConflict2,
-  InvalidRepositoryIncrement2,
-  frozenJson,
-  states,
-  findState,
-  stateOf,
-  contextOf,
-  inspectRepository,
-  declareRepository,
-  relatedRepositoryOf,
-  assertUnbound,
-  isScalarKey,
-  routeDeclarationOf
-} from "./index-xegv6a1p.js";
-
-// src/core/event-policy/exceptions.ts
-var exports_exceptions = {};
-__export(exports_exceptions, {
-  InvalidEventPolicy: () => InvalidEventPolicy2,
-  PublisherNotBound: () => PublisherNotBound2
-});
-
-// src/core/use-case/exceptions.ts
-var exports_exceptions2 = {};
-__export(exports_exceptions2, {
-  IncompatibleUseCasePlugin: () => IncompatibleUseCasePlugin2,
-  InvalidUseCasePlugin: () => InvalidUseCasePlugin2,
-  InvalidUseCaseStep: () => InvalidUseCaseStep2,
-  UnknownUseCasePlugin: () => UnknownUseCasePlugin2,
-  UseCaseEntityConflict: () => UseCaseEntityConflict2,
-  UseCaseEntityNotFound: () => UseCaseEntityNotFound2,
-  UseCaseInvalidCredentials: () => UseCaseInvalidCredentials2,
-  UseCaseUnavailable: () => UseCaseUnavailable2
-});
-
-// src/core/use-case/use-case.ts
-var exports_use_case = {};
-__export(exports_use_case, {
-  AbstractUseCase: () => AbstractUseCase,
-  InvalidUseCaseDeclaration: () => InvalidUseCaseDeclaration2,
-  InvalidUseCaseDependencies: () => InvalidUseCaseDependencies2,
-  UseCaseAlreadyExecuted: () => UseCaseAlreadyExecuted2,
-  isUseCase: () => isUseCase2,
-  isUseCaseClass: () => isUseCaseClass2,
-  useCaseOf: () => useCaseOf2
-});
-
-// 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/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/use-case/scope.ts
-var ScopeKey = Symbol("afora.use-case.scope");
-function scopedProvider(scope, provider) {
-  return scope?.providers.get(provider) ?? provider;
-}
-
-// src/core/repository/cursor.ts
-var VERSION = 1;
-var signatureOf = (orders) => orders.map(({ key, direction = "asc" }) => `${key}:${direction}`);
-function pack(value) {
-  if (value === undefined || value === null)
-    return null;
-  if (value instanceof Date)
-    return { d: value.toISOString() };
-  if (typeof value === "bigint")
-    return { b: value.toString() };
-  return value;
-}
-function unpack(value) {
-  if (value === null)
-    return;
-  if (["string", "number", "boolean"].includes(typeof value))
-    return value;
-  if (typeof value === "object") {
-    const { d, b } = value;
-    const keys = Object.keys(value);
-    if (keys.length === 1 && typeof d === "string") {
-      const date = new Date(d);
-      if (!Number.isNaN(date.getTime()))
-        return date;
-    }
-    if (keys.length === 1 && typeof b === "string" && /^-?\d+$/.test(b))
-      return BigInt(b);
-  }
-  throw new SyntaxError("value");
-}
-function encodeText(text) {
-  let binary = "";
-  for (const byte of new TextEncoder().encode(text))
-    binary += String.fromCharCode(byte);
-  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
-}
-function decodeText(encoded) {
-  if (!/^[A-Za-z0-9_-]+$/.test(encoded))
-    throw new SyntaxError("alphabet");
-  const binary = atob(encoded.replaceAll("-", "+").replaceAll("_", "/"));
-  return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
-}
-function encodeCursor(orders, row) {
-  const payload = {
-    v: VERSION,
-    k: signatureOf(orders),
-    a: orders.map(({ key }) => pack(row[key]))
-  };
-  return encodeText(JSON.stringify(payload));
-}
-function decodeCursor(source, orders, cursor) {
-  const fail = (reason) => {
-    throw new InvalidRepositoryCursor2({
-      source,
-      details: {
-        reason,
-        issues: [
-          { code: "invalid_value", path: ["after"], message: reason, source }
-        ]
-      }
-    });
-  };
-  if (typeof cursor !== "string" || cursor === "")
-    return fail("Expected a cursor given by findCursor.");
-  let payload;
-  let values;
-  try {
-    payload = JSON.parse(decodeText(cursor));
-    if (typeof payload !== "object" || payload === null)
-      throw new SyntaxError;
-    if (!Array.isArray(payload.k) || !Array.isArray(payload.a))
-      throw new SyntaxError;
-    values = payload.a.map(unpack);
-  } catch {
-    return fail("The cursor is not one given by findCursor.");
-  }
-  if (payload.v !== VERSION)
-    return fail("The cursor was made by another version.");
-  const expected = signatureOf(orders);
-  if (payload.k?.length !== expected.length || values.length !== expected.length || expected.some((key, index) => payload.k?.[index] !== key))
-    return fail("The cursor was made for another orderBy.");
-  return values;
-}
-
-// src/core/repository/provider.ts
-var descriptions = new WeakMap;
-var opaque = Object.freeze({ kind: "opaque" });
-function invalid(reason) {
-  throw new InvalidRepositoryDeclaration2({
-    source: "providerOf",
-    details: { reason }
-  });
-}
-function providerOf2(settings) {
-  if (!settings || typeof settings.name !== "string" || settings.name.trim().length === 0 || typeof settings.create !== "function")
-    invalid("Expected a provider name and create function.");
-  const options = frozenJson(settings.options ?? {}, "Provider options", invalid);
-  if (options === null || typeof options !== "object" || Array.isArray(options))
-    invalid("Provider options must be an object.");
-  const provider = settings.create(options);
-  if (!provider || typeof provider !== "object" || ["findOne", "findMany", "insert", "update", "remove", "count"].some((key) => typeof provider[key] !== "function"))
-    invalid("Expected a repository provider from create.");
-  descriptions.set(provider, Object.freeze({
-    kind: "provider",
-    name: settings.name,
-    options
-  }));
-  return provider;
-}
-function providerDescriptionOf2(provider) {
-  return descriptions.get(provider) ?? opaque;
-}
-
-// src/core/repository/query.ts
-function plain(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
-}
-function isMembership(value) {
-  return plain(value) && Object.keys(value).length === 1 && Array.isArray(value.in);
-}
-var QUERY_OPTIONS = [
-  "where",
-  "orderBy",
-  "limit",
-  "offset",
-  "withDeleted",
-  "withExpired"
-];
-function prepareQuery2(context, input = {}, map = (_key, value) => value, options = QUERY_OPTIONS) {
-  const fail = (reason) => {
-    throw new InvalidRepositoryQuery2({
-      source: context.name,
-      details: { reason }
-    });
-  };
-  if (!plain(input))
-    return fail("Expected a query object.");
-  for (const key of Object.keys(input))
-    if (!options.includes(key))
-      fail(`Unknown query option "${key}".`);
-  const properties = context.entity.blueprint.properties;
-  const keyOf = (key) => {
-    if (!Object.hasOwn(properties, key))
-      fail(`Unknown query field "${key}".`);
-  };
-  for (const name of ["limit", "offset"]) {
-    const value = input[name];
-    if (value !== undefined && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0))
-      fail(`Expected a nonnegative integer for ${name}.`);
-  }
-  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))
-      return fail("Expected where to be an object.");
-    where = Object.fromEntries(Object.entries(input.where).map(([key, value]) => {
-      keyOf(key);
-      return [
-        key,
-        isMembership(value) ? { in: value.in.map((item) => map(key, item)) } : map(key, value)
-      ];
-    }));
-  }
-  if (input.orderBy !== undefined) {
-    if (!Array.isArray(input.orderBy))
-      return fail("Expected orderBy to be an array.");
-    for (const order of input.orderBy) {
-      if (!plain(order) || typeof order.key !== "string" || Object.keys(order).some((key) => key !== "key" && key !== "direction"))
-        return fail("Expected an order with key and optional direction.");
-      keyOf(order.key);
-      if (order.direction !== undefined && order.direction !== "asc" && order.direction !== "desc")
-        fail("Expected order direction asc or desc.");
-      const field = properties[order.key];
-      if (isBlueprint(field) || isBlueprintList(field) || isBlueprintVariant(field) || recordFieldOf(field))
-        fail("Only scalar fields may be ordered.");
-    }
-  }
-  return { ...input, ...where ? { where } : {} };
-}
-function sameValue2(a, b) {
-  if (a === b)
-    return true;
-  if (a instanceof Date || b instanceof Date)
-    return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
-  if (Array.isArray(a) || Array.isArray(b))
-    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((value, index) => sameValue2(value, b[index]));
-  if (!plain(a) || !plain(b))
-    return false;
-  const keys = Object.keys(a);
-  return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && sameValue2(a[key], b[key]));
-}
-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 matchesQuery2(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) => sameValue2(data[key], candidate)) : sameValue2(data[key], value));
-}
-function codePoints(text) {
-  return Array.from(text, (char) => char.codePointAt(0));
-}
-function rank(value) {
-  return value instanceof Date ? 1 : { number: 0, bigint: 0, string: 2, boolean: 3 }[typeof value] ?? 4;
-}
-function compareScalars(a, b) {
-  const [left, right] = [rank(a), rank(b)];
-  if (left !== right)
-    return left - right;
-  if (typeof a === "string" && typeof b === "string") {
-    const [x, y] = [codePoints(a), codePoints(b)];
-    for (let index = 0;index < Math.min(x.length, y.length); index++) {
-      const difference = x[index] - y[index];
-      if (difference !== 0)
-        return difference;
-    }
-    return x.length - y.length;
-  }
-  const [x, y] = [
-    a instanceof Date ? a.getTime() : Number(a),
-    b instanceof Date ? b.getTime() : Number(b)
-  ];
-  return x < y ? -1 : x > y ? 1 : 0;
-}
-function compareRows(orders, a, b) {
-  for (const { key, direction } of orders) {
-    const [x, y] = [a[key], b[key]];
-    const [missingX, missingY] = [
-      x === undefined || x === null,
-      y === undefined || y === null
-    ];
-    let result = missingX || missingY ? Number(!missingX) - Number(!missingY) : compareScalars(x, y);
-    if (direction === "desc")
-      result = -result;
-    if (result !== 0)
-      return result;
-  }
-  return 0;
-}
-function orderRows(rows, query) {
-  const orders = query.orderBy ?? [];
-  return [...rows].sort((a, b) => compareRows(orders, a, b));
-}
-function rowsAfter(rows, orders, after) {
-  const position = Object.fromEntries(orders.map(({ key }, index) => [key, after[index]]));
-  return rows.filter((row) => compareRows(orders, row, position) > 0);
-}
-function selectRows2(rows, query, expiry) {
-  const now = expiry === undefined ? 0 : nowOf(query);
-  const ordered = orderRows([...rows].filter((data) => matchesQuery2(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);
-}
-
-// src/core/repository/in-memory.ts
-var tableKeys = new WeakMap;
-function tableKeyOf(entity) {
-  let key = tableKeys.get(entity);
-  if (key === undefined) {
-    key = declaredRecordNameOf(entity) ?? entity;
-    tableKeys.set(entity, key);
-  }
-  return key;
-}
-function idOf(data) {
-  return data.id;
-}
-function snapshotOf(tables) {
-  return new Map([...tables].map(([key, table]) => [key, new Map(table)]));
-}
-var copy = (data) => structuredClone(data);
-function scopeOf(initial, root) {
-  let tables = initial;
-  let held;
-  let closed = false;
-  const tableOf = (context) => {
-    const key = tableKeyOf(context.entity);
-    let table = tables.get(key);
-    if (!table) {
-      table = new Map;
-      tables.set(key, table);
-    }
-    return table;
-  };
-  const whenIdle = async (work) => {
-    while (held)
-      await held;
-    if (closed) {
-      throw new InvalidRepositoryDeclaration2({
-        source: "inMemory",
-        details: {
-          reason: "The transaction has ended; its provider cannot be used."
-        }
-      });
-    }
-    return work();
-  };
-  const assertUnique = (context, data) => {
-    for (const stored of tableOf(context).values()) {
-      if (idOf(stored) === idOf(data))
-        continue;
-      const key = context.unique.find((key) => data[key] !== undefined && sameValue2(stored[key], data[key]));
-      if (key !== undefined) {
-        throw new RepositoryUniqueViolation2({
-          source: context.name,
-          details: { key }
-        });
-      }
-    }
-  };
-  const provider = {
-    capabilities: Object.freeze({
-      transactions: true,
-      keyset: true,
-      versioning: true,
-      atomic: true,
-      expiry: true
-    }),
-    findOne: (context, query = {}) => whenIdle(() => {
-      const [first] = selectRows2(tableOf(context).values(), { ...query, limit: Math.min(query.limit ?? 1, 1) }, context.expiry?.key);
-      return first === undefined ? undefined : copy(first);
-    }),
-    findMany: (context, query = {}) => whenIdle(() => selectRows2(tableOf(context).values(), query, context.expiry?.key).map(copy)),
-    insert: (context, data) => whenIdle(() => {
-      const table = tableOf(context);
-      if (table.has(idOf(data))) {
-        throw new RepositoryUniqueViolation2({
-          source: context.name,
-          details: { key: "id" }
-        });
-      }
-      assertUnique(context, data);
-      table.set(idOf(data), copy(data));
-    }),
-    update: (context, data, options = {}) => whenIdle(() => {
-      const table = tableOf(context);
-      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 && !matchesQuery2(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({
-          source: context.name,
-          details: { id }
-        });
-      }
-    }),
-    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 (matchesQuery2(data, query, expiry, now))
-          total++;
-      }
-      return total;
-    }),
-    async transaction(run) {
-      let release;
-      const child = await whenIdle(() => {
-        held = new Promise((resolve) => {
-          release = resolve;
-        });
-        return scopeOf(snapshotOf(tables), false);
-      });
-      try {
-        const result = await run(child.provider);
-        tables = child.close();
-        return result;
-      } finally {
-        child.close();
-        held = undefined;
-        release();
-      }
-    }
-  };
-  return {
-    provider,
-    close() {
-      if (!root)
-        closed = true;
-      return tables;
-    }
-  };
-}
-function inMemoryProvider2() {
-  return providerOf2({
-    name: "inMemory",
-    options: {},
-    create: () => scopeOf(new Map, true).provider
-  });
-}
-
-// 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/upcast.ts
-var isPlain2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function stepOf(field) {
-  if (field === undefined)
-    return { kind: "opaque" };
-  if (isBlueprintList(field))
-    return { kind: "list", item: stepOf(field.item) };
-  if (isBlueprint(field)) {
-    return { kind: "collection", fields: stepsOf(field.properties) };
-  }
-  const record = recordFieldOf(field);
-  if (record) {
-    if (isEntityClass2(record.record))
-      return { kind: "opaque" };
-    return {
-      kind: "collection",
-      fields: stepsOf(record.record.blueprint.properties)
-    };
-  }
-  const property = fieldOf(field);
-  if (!isProperty(property))
-    return { kind: "opaque" };
-  const { fill, renamedFrom } = property.type;
-  return {
-    kind: "property",
-    ...fill === undefined ? {} : { fill },
-    ...renamedFrom === undefined ? {} : { renamedFrom }
-  };
-}
-function stepsOf(properties) {
-  return {
-    fields: new Map(Object.entries(properties).map(([key, field]) => [key, stepOf(field)]))
-  };
-}
-function declaresSteps(steps) {
-  const visit = (step) => {
-    switch (step.kind) {
-      case "property":
-        return step.fill !== undefined || step.renamedFrom !== undefined;
-      case "collection":
-        return declaresSteps(step.fields);
-      case "list":
-        return visit(step.item);
-      case "opaque":
-        return false;
-    }
-  };
-  for (const step of steps.fields.values())
-    if (visit(step))
-      return true;
-  return false;
-}
-var plans = new WeakMap;
-function upcastPlanOf(entity) {
-  const cached = plans.get(entity);
-  if (cached !== undefined)
-    return cached ?? undefined;
-  const plan = fullUpcastPlanOf(entity);
-  const needed = plan.versioned || plan.renamed || declaresSteps(plan.fields) ? plan : null;
-  plans.set(entity, needed);
-  return needed ?? undefined;
-}
-function fullUpcastPlanOf(entity) {
-  const settings = entity[EntitySettings2];
-  return {
-    versioned: settings?.schemaVersioned === true,
-    version: settings?.schemaVersion ?? 1,
-    renamed: (settings?.previousNames.length ?? 0) > 0,
-    upgrade: settings?.upgrade ?? {},
-    fields: stepsOf(entity.blueprint.properties)
-  };
-}
-var join = (path, key) => path ? `${path}.${key}` : key;
-var fillOf = (value) => typeof value === "object" && value !== null ? structuredClone(value) : value;
-function applySteps(steps, value, drop, path, report) {
-  const result = { ...value };
-  for (const [key, step] of steps.fields) {
-    if (step.kind !== "property" || step.renamedFrom === undefined)
-      continue;
-    const from = step.renamedFrom;
-    if (result[key] === undefined && Object.hasOwn(result, from)) {
-      result[key] = result[from];
-      delete result[from];
-      report?.renamed.push(join(path, key));
-    }
-  }
-  for (const [key, step] of steps.fields) {
-    const current = result[key];
-    if (current === undefined || current === null) {
-      if (step.kind === "property" && step.fill !== undefined && current === undefined) {
-        result[key] = fillOf(step.fill);
-        report?.filled.push(join(path, key));
-      }
-      continue;
-    }
-    result[key] = applyField(step, current, drop, join(path, key), report);
-  }
-  for (const key of Object.keys(result)) {
-    if (steps.fields.has(key))
-      continue;
-    if (result[key] !== undefined)
-      report?.removed.push(join(path, key));
-    if (drop)
-      delete result[key];
-  }
-  return result;
-}
-function applyField(step, value, drop, path, report) {
-  switch (step.kind) {
-    case "collection":
-      return isPlain2(value) ? applySteps(step.fields, value, drop, path, report) : value;
-    case "list":
-      return Array.isArray(value) ? value.map((item) => item === undefined || item === null ? item : applyField(step.item, item, drop, `${path}[]`, report)) : value;
-    default:
-      return value;
-  }
-}
-function storedVersionOf(data) {
-  return Object.hasOwn(data, SCHEMA_VERSION_KEY2) ? data[SCHEMA_VERSION_KEY2] : 1;
-}
-function upcast(source, plan, data, drop = true, report) {
-  const stored = storedVersionOf(data);
-  if (typeof stored !== "number" || !Number.isSafeInteger(stored) || stored < 1 || stored > plan.version) {
-    throw new InvalidStoredSchemaVersion2({
-      source,
-      details: { id: String(data.id), stored, current: plan.version }
-    });
-  }
-  if (report)
-    report.from = stored;
-  let value = { ...data };
-  delete value[SCHEMA_VERSION_KEY2];
-  for (let version = stored + 1;version <= plan.version; version++) {
-    const step = plan.upgrade[version];
-    if (step === undefined)
-      continue;
-    const next = step(Object.freeze(value));
-    if (!isPlain2(next)) {
-      throw new InvalidStoredSchemaVersion2({
-        source,
-        details: {
-          id: String(data.id),
-          stored,
-          current: plan.version,
-          reason: `The upgrade step ${version} did not give an object.`
-        }
-      });
-    }
-    value = { ...next };
-    delete value[SCHEMA_VERSION_KEY2];
-  }
-  return applySteps(plan.fields, value, drop, "", report);
-}
-function upcastRows(state, rows) {
-  const plan = upcastPlanOf(state.entity);
-  if (plan === undefined)
-    return rows;
-  return rows.map((row) => {
-    try {
-      return upcast(state.name, plan, row);
-    } catch (error) {
-      throw new InvalidRepositoryData2({ source: state.name, cause: error });
-    }
-  });
-}
-function withSchemaVersion(entity, data) {
-  const plan = upcastPlanOf(entity);
-  return plan?.versioned ? { ...data, [SCHEMA_VERSION_KEY2]: plan.version } : data;
-}
-
-// src/core/repository/references.ts
-function isPlain3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function recordClassOf(field) {
-  return recordFieldOf(field)?.record;
-}
-function entityClassesOf(properties) {
-  const found = new Set;
-  function visit(field) {
-    if (isBlueprintList(field)) {
-      visit(field.item);
-    } else if (isBlueprint(field)) {
-      walk(field.properties);
-    } else if (isBlueprintVariant(field)) {
-      for (const variant of Object.values(field.variants)) {
-        visit(variant);
-      }
-    } else {
-      const record = recordClassOf(field);
-      if (!record)
-        return;
-      if (isEntityClass2(record))
-        found.add(record);
-      else
-        walk(record.blueprint.properties);
-    }
-  }
-  function walk(properties) {
-    for (const field of Object.values(properties))
-      visit(field);
-  }
-  walk(properties);
-  return found;
-}
-function mapReferences(properties, data, visit) {
-  function mapField(field, value) {
-    if (value === undefined || value === null)
-      return value;
-    if (isBlueprintList(field)) {
-      return Array.isArray(value) ? Object.freeze(value.map((item) => mapField(field.item, item))) : value;
-    }
-    if (isBlueprint(field)) {
-      return isPlain3(value) ? mapCollection(field.properties, value) : value;
-    }
-    if (isBlueprintVariant(field)) {
-      const variant = namedVariantOf(field, value);
-      if (!variant || !isPlain3(value))
-        return value;
-      if (isEntityClass2(variant)) {
-        const mapped = visit(variant, value.id);
-        return mapped === value.id ? value : mapped;
-      }
-      return mapCollection(blueprintOfVariant(variant).properties, value);
-    }
-    const record = recordClassOf(field);
-    if (!record)
-      return value;
-    if (isEntityClass2(record))
-      return visit(record, value);
-    return isPlain3(value) ? mapCollection(record.blueprint.properties, value) : value;
-  }
-  function mapCollection(properties, value) {
-    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [
-      key,
-      mapField(properties[key], item)
-    ])));
-  }
-  return mapCollection(properties, data);
-}
-function relationsOf(name, entity, relations) {
-  const invalid = (reason) => {
-    throw new InvalidRepositoryDeclaration2({
-      source: name,
-      details: { reason }
-    });
-  };
-  if (relations === undefined)
-    relations = [];
-  if (!Array.isArray(relations)) {
-    return invalid("Expected relations to be a list of repositories.");
-  }
-  const related = [];
-  for (const relation of relations) {
-    const state = findState(relation);
-    if (!state)
-      return invalid("Expected relations made by repositoryOf.");
-    if (related.some((other) => other.entity === state.entity)) {
-      return invalid(`Relation "${recordNameOf2(state.entity)}" is duplicated.`);
-    }
-    if (typeof state.provider.findMany !== "function") {
-      return invalid(`The provider of "${state.name}" has no "findMany" to load it.`);
-    }
-    related.push(state);
-  }
-  const used = new Set;
-  const map = new Map;
-  for (const target of entityClassesOf(entity.blueprint.properties)) {
-    const matches = related.filter((state) => state.entity === target || state.entity.prototype instanceof target);
-    const exact = matches.find((state) => state.entity === target);
-    if (!exact && matches.length === 0) {
-      return invalid(`Missing relation: no repository of "${recordNameOf2(target)}".`);
-    }
-    if (!exact && matches.length > 1) {
-      return invalid(`Relation "${recordNameOf2(target)}" matches more than one repository.`);
-    }
-    const state = exact ?? matches[0];
-    map.set(target, state);
-    used.add(state);
-  }
-  for (const state of related) {
-    if (!used.has(state)) {
-      return invalid(`Relation "${recordNameOf2(state.entity)}" is not held by ${recordNameOf2(entity)}.`);
-    }
-  }
-  return map;
-}
-function parseEntity(state, data) {
-  const parsed = state.entity.safeParse(data);
-  if (parsed.issues) {
-    throw new InvalidRepositoryData2({
-      source: state.name,
-      cause: parsed.issues.find((issue) => issue.cause)?.cause
-    });
-  }
-  return parsed.value;
-}
-function loadByIds(state, ids, scope) {
-  return scopedProvider(scope, state.provider).findMany(contextOf(state), {
-    where: { id: { in: ids } },
-    withDeleted: true,
-    withExpired: true
-  });
-}
-async function resolveReferences(state, datas, session, scope) {
-  if (state.relations.size === 0)
-    return datas;
-  const { properties } = state.entity.blueprint;
-  const wanted = new Map;
-  for (const data of datas) {
-    mapReferences(properties, data, (target, value) => {
-      const relation = state.relations.get(target);
-      if (relation && typeof value === "string") {
-        const ids = wanted.get(relation) ?? new Set;
-        wanted.set(relation, ids.add(value));
-      }
-      return value;
-    });
-  }
-  for (const [relation, ids] of wanted) {
-    const loaded = session.get(relation) ?? new Map;
-    session.set(relation, loaded);
-    const missing = [...ids].filter((id) => !loaded.has(id));
-    if (missing.length === 0)
-      continue;
-    const found = upcastRows(relation, await loadByIds(relation, missing, scope));
-    const resolved = await resolveReferences(relation, found, session, scope);
-    for (const data of resolved) {
-      const id = data.id;
-      if (!loaded.has(id))
-        loaded.set(id, parseEntity(relation, data));
-    }
-    for (const id of missing) {
-      if (loaded.has(id))
-        continue;
-      throw new InvalidRepositoryData2({
-        source: state.name,
-        cause: new RepositoryEntityNotFound2({
-          source: relation.name,
-          details: { id }
-        })
-      });
-    }
-  }
-  return datas.map((data) => mapReferences(properties, data, (target, value) => {
-    const relation = state.relations.get(target);
-    return relation && typeof value === "string" ? session.get(relation)?.get(value) ?? value : value;
-  }));
-}
-
-// src/core/repository/repository.ts
-var REFERENCES = {
-  reference: (record) => isEntity2(record) ? record.id : undefined
-};
-
-class AbstractRepository {
-  get [Kind2]() {
-    return "repository";
-  }
-  get entity() {
-    return stateOf(this).entity;
-  }
-  get actions() {
-    return stateOf(this).actions;
-  }
-  get provider() {
-    return stateOf(this).provider;
-  }
-  get context() {
-    return contextOf(stateOf(this));
-  }
-  get env() {
-    return this.context.env;
-  }
-  async hydrate(data) {
-    return (await this.hydrateMany([data]))[0];
-  }
-  async hydrateMany(list) {
-    const state = stateOf(this);
-    const scope = this[ScopeKey];
-    const resolved = await resolveReferences(state, upcastRows(state, list), new Map, scope);
-    return resolved.map((data) => parseEntity(state, data));
-  }
-  dataOf(entity) {
-    if (!(entity instanceof stateOf(this).entity)) {
-      throw new InvalidRepositoryEntity2({ source: stateOf(this).name });
-    }
-    return withSchemaVersion(stateOf(this).entity, recordDataOf(entity, REFERENCES));
-  }
-}
-function action(method) {
-  return function(...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 = prepareQuery2(self.context, query, (key, value) => queryValueOf(self.context, key, value));
-  return {
-    ...prepared,
-    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, 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 = prepareQuery2(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,
-    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,
-      ...index === undefined ? {} : { index }
-    }),
-    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",
-  "withExpired",
-  "after"
-];
-function cursorReadOf(self, query) {
-  const { context } = self;
-  const fail = (reason) => {
-    throw new InvalidRepositoryQuery2({
-      source: context.name,
-      details: { reason }
-    });
-  };
-  const prepared = prepareQuery2(context, query, (key, value) => queryValueOf(context, key, value), CURSOR_OPTIONS);
-  const { where, limit = 20 } = prepared;
-  if (limit < 1)
-    fail("Expected a positive integer for limit.");
-  const withDeleted = prepared.withDeleted ?? stateOf(self).deletion === "hard";
-  const declared = prepared.orderBy ?? [];
-  const orderBy = declared.some(({ key }) => key === "id") ? declared : [...declared, { key: "id", direction: "asc" }];
-  for (const { key } of orderBy) {
-    if (context.entity.options.sensitive.includes(key))
-      fail(`"${key}" is sensitive and cannot order a cursor.`);
-  }
-  if (self.provider.capabilities?.keyset !== true)
-    fail("The provider does not read by cursor (capabilities.keyset).");
-  const { 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);
-  const last = page.at(-1);
-  return {
-    items: await self.hydrateMany(page),
-    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;
-  const entity = input instanceof Entity ? input : new Entity(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;
-  invalid2(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 writeEntity(self, entity);
-  return entity;
-});
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isNumericField(field) {
-  if (field === undefined)
-    return false;
-  const property = fieldOf(field);
-  if (!isProperty(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 (!isPlainObject(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
-      });
-    }
-  }
-  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 = isPlainObject(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;
-}
-function renamedFromOf(field) {
-  if (field === undefined)
-    return;
-  const property = fieldOf(field);
-  if (!isProperty(property))
-    return;
-  const { renamedFrom } = property.type;
-  return typeof renamedFrom === "string" ? renamedFrom : undefined;
-}
-async function bringUpRenamed(self, id, deltas) {
-  const { context } = self;
-  const properties = context.entity.blueprint.properties;
-  const renamed = [];
-  for (const key of Object.keys(deltas)) {
-    const from = renamedFromOf(properties[key]);
-    if (from !== undefined)
-      renamed.push([key, from]);
-  }
-  if (renamed.length === 0)
-    return;
-  const stored = await self.provider.findOne(context, {
-    where: { id },
-    withDeleted: true,
-    ...context.expiry === undefined ? {} : { withExpired: true }
-  });
-  if (stored === undefined || !renamed.some(([key, from]) => stored[key] === undefined && Object.hasOwn(stored, from))) {
-    return;
-  }
-  const data = withSchemaVersion(context.entity, upcast(context.name, fullUpcastPlanOf(context.entity), stored, false));
-  const expected = stored.version;
-  try {
-    await self.provider.update(context, data, isVersionedEntityClass(context.entity) && typeof expected === "number" ? { expectedVersion: expected } : undefined);
-  } catch (error) {
-    if (!(error instanceof Exception2) || !error.is(RepositoryConcurrencyConflict2)) {
-      throw error;
-    }
-  }
-}
-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 && !isPlainObject(options)) {
-    invalid2(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);
-  await bringUpRenamed(self, id, 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 writeEntity(self, entity);
-  } else {
-    await self.provider.remove(context, data.id);
-  }
-  return entity;
-});
-var restore = action(async (self, target) => {
-  const { context } = self;
-  const id = typeof target === "string" ? target : self.dataOf(target).id;
-  const data = await self.provider.findOne(context, {
-    ...equals(self, "id", id),
-    withDeleted: true
-  });
-  if (data === undefined) {
-    throw new RepositoryEntityNotFound2({
-      source: context.name,
-      details: { id }
-    });
-  }
-  if (data.deletedAt === undefined)
-    return self.hydrate(data);
-  const [current] = upcastRows(stateOf(self), [data]);
-  const { deletedAt: _deletedAt, ...alive } = current;
-  const restored = withSchemaVersion(context.entity, {
-    ...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"],
-  explain: [],
-  increment: ["increment"],
-  forEachPage: ["findMany"]
-};
-function capitalize(key) {
-  return `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
-}
-function unknownAction(entity, action, methods) {
-  const many = /^findManyBy(.+)$/.exec(action)?.[1];
-  const one = many === undefined ? /^findBy(.+)$/.exec(action)?.[1] : undefined;
-  const suffix = many ?? one;
-  const key = suffix === undefined ? undefined : `${suffix.charAt(0).toLowerCase()}${suffix.slice(1)}`;
-  if (one !== undefined && methods.has(`findManyBy${one}`)) {
-    return `"${action}" requires "${key}" to be a unique key of ${entity}.`;
-  }
-  if (many !== undefined && methods.has(`findBy${many}`)) {
-    return `"${action}" is not available for the unique key "${key}" of ${entity}; use "findBy${many}".`;
-  }
-  return `"${action}" is not an action of ${entity}.`;
-}
-function invalid2(source, reason) {
-  throw new InvalidRepositoryDeclaration2({ source, details: { reason } });
-}
-function assertPreviousNames(entity) {
-  const own = recordNameOf2(entity);
-  const previous = entity[EntitySettings2]?.previousNames ?? [];
-  if (!previous.includes(own))
-    return;
-  throw new InvalidEntitySchemaVersion2({
-    source: own,
-    details: {
-      reason: `"${own}" cannot be a previous name: expected an identifier other than the name of the entity.`
-    }
-  });
-}
-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)) {
-    invalid2(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)) {
-      invalid2(name, `The index "${index}" names "${String(key)}", which is not a key of ${recordNameOf2(entity)}.`);
-    }
-    if (sensitive.includes(key)) {
-      invalid2(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__") {
-      invalid2(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) {
-      invalid2(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) {
-      invalid2(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 (isBlueprint(field) || isBlueprintList(field) || isBlueprintVariant(field) || recordFieldOf(field)) {
-        invalid2(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) {
-      invalid2(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)) {
-    invalid2("repositoryOf", "Expected an entity class made by entityOf.");
-  }
-  const name = `${recordNameOf2(entity)}Repository`;
-  assertPreviousNames(entity);
-  const deletion = settings.deletion ?? "hard";
-  if (deletion !== "hard" && deletion !== "soft") {
-    invalid2(name, 'Expected deletion to be "hard" or "soft".');
-  }
-  const scans = settings.scans ?? "allow";
-  if (scans !== "allow" && scans !== "warn" && scans !== "reject") {
-    invalid2(name, 'Expected scans to be "allow", "warn" or "reject".');
-  }
-  const provider = settings.provider ?? inMemoryProvider2();
-  if (!Array.isArray(actions) || actions.length === 0) {
-    invalid2(name, "Expected a list of actions.");
-  }
-  if (environmentDependencies !== undefined && !isEnvironment(environmentDependencies) && !(Array.isArray(environmentDependencies) && environmentDependencies.every(isEnvironment))) {
-    invalid2(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)) {
-    const suffix = capitalize(key);
-    if (unique.includes(key)) {
-      methods.set(`findBy${suffix}`, ["findBy", findBy(key)]);
-    } else {
-      methods.set(`findManyBy${suffix}`, ["findManyBy", findManyBy(key)]);
-    }
-  }
-  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 AbstractRepository {
-  }
-  for (const name_ of new Set(actions)) {
-    const method = typeof name_ === "string" ? methods.get(name_) : undefined;
-    if (!method)
-      invalid2(name, unknownAction(recordNameOf2(entity), String(name_), methods));
-    const [kind, implementation] = method;
-    if (kind === "restore" && deletion !== "soft") {
-      invalid2(name, '"restore" needs deletion to be "soft".');
-    }
-    if (kind === "findCursor" && settings.provider !== undefined && provider[Kind2] !== "provider-slot" && provider.capabilities?.keyset !== true) {
-      invalid2(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") {
-        invalid2(name, `The provider has no "${need}" for "${name_}".`);
-      }
-    }
-    Object.defineProperty(DeclaredRepository.prototype, name_, {
-      value: implementation,
-      writable: true,
-      configurable: true
-    });
-  }
-  Object.defineProperty(DeclaredRepository, "name", { value: name });
-  const state = {
-    name,
-    entity,
-    actions: Object.freeze([...new Set(actions)]),
-    deletion,
-    provider,
-    explicitProvider: settings.provider !== undefined,
-    environment: environmentDependencies,
-    relations,
-    indexes,
-    scans
-  };
-  states.set(DeclaredRepository, state);
-  const repository = Object.freeze(new DeclaredRepository);
-  declareRepository(state, repository);
-  return repository;
-}
-function RepositoryOf2(repository) {
-  if (!isRepository(repository)) {
-    invalid2("RepositoryOf", "Expected a repository made by repositoryOf.");
-  }
-  return repository.constructor;
-}
-function isRepository(value) {
-  return value instanceof AbstractRepository;
-}
-
-// 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",
-  "context",
-  "env",
-  "literal"
-];
-var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
-var SEGMENT = /^(?:[A-Za-z_][A-Za-z0-9_]*|0|[1-9][0-9]*)$/;
-var BLOCKED = new Set(["__proto__", "constructor", "prototype"]);
-function isStepName(value) {
-  return typeof value === "string" && IDENTIFIER.test(value);
-}
-var parsed = new Map;
-function parseReference(text) {
-  const cached = parsed.get(text);
-  if (cached !== undefined)
-    return cached ?? undefined;
-  let result = null;
-  if (text.startsWith("$")) {
-    const [root, ...path] = text.slice(1).split(".");
-    if (root !== undefined && IDENTIFIER.test(root) && path.every((segment) => SEGMENT.test(segment))) {
-      result = Object.freeze({ root, path: Object.freeze(path) });
-    }
-  }
-  if (parsed.size < 4096)
-    parsed.set(text, result);
-  return result ?? undefined;
-}
-function isPlain(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isLiteralEscape(value) {
-  return isPlain(value) && Object.keys(value).length === 1 && Object.hasOwn(value, "literal");
-}
-function walkValue(value, onReference, onIssue) {
-  if (typeof value === "string") {
-    if (!value.startsWith("$"))
-      return;
-    const reference = parseReference(value);
-    if (!reference)
-      onIssue("invalid_reference", value);
-    else
-      onReference(reference, value);
-    return;
-  }
-  if (value === null || typeof value === "number" || typeof value === "boolean") {
-    return;
-  }
-  if (isLiteralEscape(value)) {
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value)
-      walkValue(item, onReference, onIssue);
-    return;
-  }
-  if (isPlain(value)) {
-    for (const item of Object.values(value)) {
-      walkValue(item, onReference, onIssue);
-    }
-    return;
-  }
-  onIssue("invalid_value", String(value));
-}
-function followPath(from, path) {
-  let current = from;
-  for (const segment of path) {
-    if (typeof current !== "object" && typeof current !== "function" || current === null || BLOCKED.has(segment)) {
-      return;
-    }
-    current = current[segment];
-  }
-  return current;
-}
-function resolveValue(value, lookup) {
-  if (typeof value === "string") {
-    if (!value.startsWith("$"))
-      return value;
-    const reference = parseReference(value);
-    return reference ? lookup(reference) : undefined;
-  }
-  if (isLiteralEscape(value))
-    return value.literal;
-  if (Array.isArray(value))
-    return value.map((item) => resolveValue(item, lookup));
-  if (isPlain(value)) {
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-      key,
-      resolveValue(item, lookup)
-    ]));
-  }
-  return value;
-}
-function freezeData(value) {
-  if (Array.isArray(value)) {
-    return Object.freeze(value.map(freezeData));
-  }
-  if (isPlain(value)) {
-    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freezeData(item)])));
-  }
-  return value;
-}
-
-// src/core/property/input.ts
-var PropertyInput2 = Symbol("propertyInput");
-function propertyInputOf2(field) {
-  const property = fieldOf(field);
-  if (!isProperty(property))
-    return;
-  const declared = property[PropertyInput2];
-  return typeof declared === "object" && declared !== null && isProperty(declared.accepts) && typeof declared.convert === "function" ? declared : undefined;
-}
-
-// src/core/use-case/target.ts
-function isOptionalField(field) {
-  if (isProperty(field))
-    return field.type.optional === true;
-  const record = recordFieldOf(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 = recordFieldOf(field);
-  const item = isBlueprintList(field) ? recordFieldOf(field.item) : undefined;
-  const related = [record?.record, item?.record].find(isEntityClass2);
-  const kind = record ? related ? "entity" : "record" : isBlueprintList(field) ? related ? "entity-list" : "list" : isBlueprint(field) || isBlueprintVariant(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/access.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var ACCESS_KEYS = ["public", "scopes", "owner", "context"];
-var PRINCIPAL_VALUE = /^(subject|scopes|claims\.[^.]+)$/;
-function isPublicAccess(access) {
-  return access.public === true;
-}
-function accessDeclarationOf(access, blueprint) {
-  if (!isObject(access)) {
-    return "Expected access to be { public: true } or { scopes?, owner?, context? }.";
-  }
-  for (const key of Object.keys(access)) {
-    if (!ACCESS_KEYS.includes(key))
-      return `access has no option "${key}".`;
-  }
-  const { scopes, owner, context } = access;
-  if (access.public !== undefined && typeof access.public !== "boolean") {
-    return "Expected access.public to be a boolean.";
-  }
-  if (access.public === true) {
-    if (Object.keys(access).length > 1) {
-      return "access.public leaves no room for scopes, owner or context: anyone may call.";
-    }
-    return Object.freeze({ public: true });
-  }
-  if (scopes !== undefined) {
-    if (!Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string" || scope === "") || new Set(scopes).size !== scopes.length) {
-      return "Expected access.scopes to be distinct, non-empty strings.";
-    }
-  }
-  if (owner !== undefined) {
-    if (!isObject(owner) || Object.keys(owner).some((key) => key !== "input" && key !== "claim") || typeof owner.input !== "string" || owner.claim !== undefined && (typeof owner.claim !== "string" || owner.claim === "")) {
-      return "Expected access.owner to be { input, claim? }.";
-    }
-    if (!isScalarKey(blueprint, owner.input)) {
-      return `access.owner compares "${owner.input}", which is not a scalar key of the input.`;
-    }
-  }
-  if (context !== undefined) {
-    if (!isObject(context)) {
-      return "Expected access.context to map context keys to values of the caller.";
-    }
-    for (const [key, value] of Object.entries(context)) {
-      if (typeof value !== "string" || !PRINCIPAL_VALUE.test(value)) {
-        return `Expected access.context["${key}"] to be "subject", "scopes" or "claims.<name>".`;
-      }
-    }
-  }
-  return Object.freeze({
-    ...scopes === undefined ? {} : { scopes: Object.freeze([...scopes]) },
-    ...owner === undefined ? {} : { owner: Object.freeze({ ...owner }) },
-    ...context === undefined ? {} : { context: Object.freeze({ ...context }) }
-  });
-}
-
-// src/core/use-case/steps/run.ts
-var FORBIDDEN_METHODS = new Set([
-  "set",
-  "emit",
-  "constructor",
-  "__proto__",
-  "hasOwnProperty",
-  "isPrototypeOf",
-  "propertyIsEnumerable",
-  "toLocaleString",
-  "valueOf",
-  "__defineGetter__",
-  "__defineSetter__",
-  "__lookupGetter__",
-  "__lookupSetter__"
-]);
-function isRecordInstance(value) {
-  return typeof value === "object" && value !== null && isRecordClass(value.constructor);
-}
-async function executeSteps(dependencies = {}) {
-  const { useCaseName, steps = [] } = this.constructor;
-  const named = new Map;
-  const lookup = ({ root, path }) => {
-    if (root === "input")
-      return followPath(this.input, path);
-    if (root === "context")
-      return followPath(this.context, path);
-    if (root === "env")
-      return followPath(dependencies[path[0]], path.slice(1));
-    return followPath(named.get(root), path);
-  };
-  const value = (raw) => resolveValue(raw, lookup);
-  for (const [index, step] of steps.entries()) {
-    const invalid = (reason) => {
-      throw new InvalidUseCaseStep2({
-        source: useCaseName,
-        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);
-    };
-    const target = (field) => {
-      const resolved = value(step[field]);
-      if (!isRecordInstance(resolved)) {
-        invalid(`${field} must reference a record or entity.`);
-      }
-      return resolved;
-    };
-    if (Object.hasOwn(step, "return"))
-      return value(step.return);
-    if (Object.hasOwn(step, "find")) {
-      const [repository, action] = step.find.split(".");
-      const methods = dependencies[repository];
-      bind(await methods[action].call(methods, ...list(step.args)));
-    } else if (Object.hasOwn(step, "ensure")) {
-      const subject = value(step.value);
-      const passed = {
-        exists: subject !== undefined && subject !== null,
-        absent: subject === undefined || subject === null,
-        equals: sameValue2(subject, value(step.other)),
-        notEquals: !sameValue2(subject, value(step.other)),
-        true: subject === true,
-        false: subject === false
-      }[step.ensure];
-      if (!passed) {
-        const Thrown = step.error;
-        throw new Thrown({
-          source: useCaseName,
-          ...step.details === undefined ? {} : { details: value(step.details) }
-        });
-      }
-    } else if (Object.hasOwn(step, "build")) {
-      const Built = step.build;
-      bind(new Built(value(step.values)));
-    } else if (Object.hasOwn(step, "change")) {
-      const record = target("change");
-      const namespace = record.change;
-      const key = step.key;
-      if (typeof namespace !== "object" || namespace === null || typeof namespace[key] !== "function") {
-        invalid(`"${key}" is not a change key of the record.`);
-      }
-      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");
-      const method = step.method;
-      if (FORBIDDEN_METHODS.has(method) || typeof record[method] !== "function") {
-        invalid(`"${method}" is not a public method of the record.`);
-      }
-      bind(await record[method].apply(record, list(step.args)));
-    } else if (Object.hasOwn(step, "call")) {
-      const child = dependencies[step.call];
-      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, dependencies }));
-    } else {
-      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)));
-    }
-  }
-  return;
-}
-function interpretedStepsOf(UseCase) {
-  const Declared = UseCase;
-  return Declared.prototype.execute === executeSteps ? Declared.steps : undefined;
-}
-
-// src/core/use-case/steps/validate.ts
-var SHAPES = {
-  find: { required: ["find"], optional: ["args", "as"] },
-  ensure: {
-    required: ["ensure", "value", "error"],
-    optional: ["other", "details"]
-  },
-  build: { required: ["build", "values", "as"], optional: [] },
-  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: [] }
-};
-var KINDS = Object.keys(SHAPES);
-var ENSURE_KINDS = new Set([
-  "exists",
-  "absent",
-  "equals",
-  "notEquals",
-  "true",
-  "false"
-]);
-var READ_ACTION = /^(?:findBy.+|findManyBy.+|findMany|exists|findPage|findCursor|count)$/;
-var WRITE_ACTIONS = new Set([
-  "create",
-  "update",
-  "delete",
-  "restore",
-  "increment"
-]);
-var INDEX = /^(?:0|[1-9][0-9]*)$/;
-var LENGTH = Symbol("length");
-var PRIMITIVE_SCHEMA_TYPES = new Set([
-  "string",
-  "number",
-  "integer",
-  "boolean",
-  "null"
-]);
-function isPrimitiveProperty(field) {
-  const schema = field?.type?.schema;
-  if (typeof field !== "function" || schema === undefined)
-    return false;
-  try {
-    const type = JSON.parse(schema.toString()).type;
-    return typeof type === "string" && PRIMITIVE_SCHEMA_TYPES.has(type);
-  } catch {
-    return false;
-  }
-}
-function missingSegment(field, path) {
-  let current = field;
-  for (const segment of path) {
-    if (current === LENGTH)
-      return segment;
-    if (isBlueprint(current)) {
-      if (!Object.hasOwn(current.properties, segment))
-        return segment;
-      current = current.properties[segment];
-      continue;
-    }
-    if (isBlueprintList(current)) {
-      if (segment === "length") {
-        current = LENGTH;
-        continue;
-      }
-      if (!INDEX.test(segment))
-        return segment;
-      current = current.item;
-      continue;
-    }
-    if (isBlueprintVariant(current)) {
-      if (segment === current.key)
-        return;
-      const variants = current.variants;
-      const holder = Object.values(variants).map(blueprintOfVariant).find((variant) => Object.hasOwn(variant.properties, segment));
-      if (!holder)
-        return segment;
-      current = holder.properties[segment];
-      continue;
-    }
-    const record = recordFieldOf(current)?.record;
-    if (record) {
-      const { properties } = record.blueprint;
-      if (Object.hasOwn(properties, segment)) {
-        current = properties[segment];
-        continue;
-      }
-      return segment in record.prototype ? undefined : segment;
-    }
-    return isPrimitiveProperty(current) ? segment : undefined;
-  }
-  return;
-}
-function validateSteps(declaration, steps) {
-  const { name } = declaration;
-  const fail = (index, code, reason) => {
-    throw new InvalidUseCaseStep2({
-      source: name,
-      details: { index, reason, code }
-    });
-  };
-  if (!Array.isArray(steps) || steps.length === 0) {
-    fail(0, "missing_return", "Expected steps to be a list ending in return.");
-  }
-  const list = steps;
-  const bound = new Map;
-  const runs = new Set;
-  let returned = false;
-  const useCaseDependency = (key) => typeof key === "string" && Object.hasOwn(declaration.dependencies, key) ? declaration.dependencies[key] : undefined;
-  const checkReference = (index, text) => {
-    const reference = parseReference(text);
-    if (!reference) {
-      fail(index, "invalid_reference", `"${text}" is not a valid reference.`);
-      return;
-    }
-    const { root, path } = reference;
-    const firstKey = path[0];
-    if (root === "input" || root === "context") {
-      const blueprint = root === "input" ? declaration.blueprint : declaration.context;
-      if (blueprint === undefined) {
-        fail(index, "invalid_reference", `"${text}" uses $context, but the use case declares no context.`);
-        return;
-      }
-      const missing = missingSegment(blueprint, path);
-      if (missing !== undefined) {
-        fail(index, "unknown_key", `"${text}" names "${missing}", which the ${root} does not declare.`);
-      }
-      return;
-    }
-    if (root === "env") {
-      if (firstKey === undefined || !isEnvironment(useCaseDependency(firstKey))) {
-        fail(index, "unknown_dependency", `"${text}" must name an environment dependency.`);
-      }
-      return;
-    }
-    if (RESERVED_NAMES.includes(root)) {
-      fail(index, "invalid_reference", `"${root}" is reserved.`);
-      return;
-    }
-    if (!bound.has(root)) {
-      fail(index, "unbound_reference", `"${text}" uses "${root}", which no earlier step binds.`);
-    }
-  };
-  const checkValue = (index, value, field) => {
-    walkValue(value, (_reference, text) => checkReference(index, text), (issue, text) => fail(index, issue, issue === "invalid_reference" ? `"${text}" is not a valid reference.` : `${field} must hold only JSON values and references.`));
-  };
-  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 or a reference to one.");
-    }
-    checkValue(index, args, "args");
-  };
-  const checkTarget = (index, target, kind) => {
-    if (typeof target !== "string" || !target.startsWith("$")) {
-      fail(index, "invalid_reference", `${kind} must be a reference.`);
-      return;
-    }
-    checkReference(index, target);
-  };
-  const repositoryOf = (index, key, action) => {
-    const dependency = useCaseDependency(key);
-    if (!isRepository(dependency)) {
-      return fail(index, "unknown_dependency", `"${String(key)}" is not a repository dependency.`);
-    }
-    const actions = dependency.actions;
-    if (!actions.includes(action)) {
-      fail(index, "unknown_action", `The repository "${String(key)}" has no "${action}" action.`);
-    }
-    return { actions };
-  };
-  for (const [index, step] of list.entries()) {
-    if (!isPlain(step) || Array.isArray(step)) {
-      fail(index, "unknown_step", "A step must be an object.");
-    }
-    const record = step;
-    const kinds = KINDS.filter((kind) => Object.hasOwn(record, kind));
-    if (kinds.length !== 1) {
-      fail(index, "unknown_step", kinds.length === 0 ? `Unknown step; expected one of ${KINDS.join(", ")}.` : `A step has one kind, found ${kinds.join(" and ")}.`);
-    }
-    const kind = kinds[0];
-    const shape = SHAPES[kind];
-    for (const key of shape.required) {
-      if (!Object.hasOwn(record, key) || record[key] === undefined) {
-        fail(index, "invalid_step", `A ${kind} step needs "${key}".`);
-      }
-    }
-    for (const key of Object.keys(record)) {
-      if (!shape.required.includes(key) && !shape.optional.includes(key)) {
-        fail(index, "invalid_step", `A ${kind} step has no "${key}".`);
-      }
-    }
-    const as = record.as;
-    if (as !== undefined) {
-      if (!isStepName(as) || RESERVED_NAMES.includes(as) || bound.has(as)) {
-        fail(index, "invalid_step_name", `"${String(as)}" must be an identifier, not reserved, bound once.`);
-      }
-    }
-    let knownRecord;
-    switch (kind) {
-      case "find": {
-        const target = record.find;
-        const parts = typeof target === "string" ? target.split(".") : [];
-        const [repository, action] = parts;
-        if (parts.length !== 2 || !repository || !action) {
-          fail(index, "invalid_step", 'find must be "<repository>.<action>".');
-        }
-        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.`);
-        }
-        repositoryOf(index, repository, action);
-        checkArgs(index, record.args);
-        break;
-      }
-      case "ensure": {
-        if (!ENSURE_KINDS.has(record.ensure)) {
-          fail(index, "invalid_step", `ensure must be one of ${[...ENSURE_KINDS].join(", ")}.`);
-        }
-        const compares = record.ensure === "equals" || record.ensure === "notEquals";
-        if (compares && record.other === undefined) {
-          fail(index, "invalid_step", `ensure "${record.ensure}" needs other.`);
-        }
-        if (!compares && record.other !== undefined) {
-          fail(index, "invalid_step", `ensure "${String(record.ensure)}" has no other.`);
-        }
-        if (!isDeclaredException(record.error) || !declaration.errors.includes(record.error)) {
-          fail(index, "undeclared_error", "ensure.error must be a class made by exceptionOf, listed in errors.");
-        }
-        checkValue(index, record.value, "value");
-        if (record.other !== undefined)
-          checkValue(index, record.other, "other");
-        if (record.details !== undefined) {
-          checkValue(index, record.details, "details");
-        }
-        break;
-      }
-      case "build": {
-        if (!isRecordClass(record.build)) {
-          fail(index, "invalid_class", "build must be a record or entity class.");
-        }
-        const values = record.values;
-        if (!(typeof values === "string" && values.startsWith("$")) && !isPlain(values)) {
-          fail(index, "invalid_step", "build.values must be a mapping or a reference.");
-        }
-        checkValue(index, values, "values");
-        knownRecord = record.build;
-        break;
-      }
-      case "change": {
-        checkTarget(index, record.change, "change");
-        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) {
-          const keys = known.options?.change ?? [];
-          if (!keys.includes(record.key)) {
-            fail(index, "invalid_change_key", `"${String(record.key)}" is not a change key of ${known.name}.`);
-          }
-        }
-        checkValue(index, record.value, "value");
-        knownRecord = known;
-        break;
-      }
-      case "invoke": {
-        checkTarget(index, record.invoke, "invoke");
-        if (typeof record.method !== "string" || record.method === "") {
-          fail(index, "invalid_step", "invoke.method must be a string.");
-        }
-        checkArgs(index, record.args);
-        break;
-      }
-      case "create":
-      case "update":
-      case "delete":
-      case "restore": {
-        repositoryOf(index, record[kind], kind);
-        checkValue(index, record.value, "value");
-        break;
-      }
-      case "call": {
-        const dependency = useCaseDependency(record.call);
-        if (typeof dependency !== "function" || dependency[Kind2] !== "use-case") {
-          fail(index, "unknown_dependency", `"${String(record.call)}" is not a use case dependency.`);
-        }
-        checkValue(index, record.input, "input");
-        break;
-      }
-      case "run": {
-        const runName = record.run;
-        if (!isStepName(runName) || runs.has(runName)) {
-          fail(index, "invalid_step_name", `run "${String(runName)}" must be an identifier, unique in the use case.`);
-        }
-        if (typeof record.fn !== "function") {
-          fail(index, "invalid_step", "run.fn must be a function.");
-        }
-        runs.add(runName);
-        checkArgs(index, record.args);
-        break;
-      }
-      case "return": {
-        checkValue(index, record.return, "return");
-        returned = true;
-        if (index !== list.length - 1) {
-          fail(index, "misplaced_return", "return must be the last step, exactly once.");
-        }
-        break;
-      }
-    }
-    if (typeof as === "string")
-      bound.set(as, { record: knownRecord });
-  }
-  if (!returned) {
-    fail(list.length, "missing_return", "The steps must end with return.");
-  }
-}
-
-// src/core/use-case/use-case.ts
-var InvalidUseCaseDeclaration2 = exceptionOf2({
-  layer: "use-case" /* UseCase */,
-  name: "InvalidUseCaseDeclaration",
-  message: ({ reason }) => reason
-});
-var UseCaseAlreadyExecuted2 = exceptionOf2({
-  layer: "use-case" /* UseCase */,
-  name: "UseCaseAlreadyExecuted",
-  message: "A UseCase instance can execute only once."
-});
-var InvalidUseCaseDependencies2 = exceptionOf2({
-  layer: "use-case" /* UseCase */,
-  name: "InvalidUseCaseDependencies",
-  message: "Dependency overrides must contain only declared names: functions for use cases, objects of methods for repositories, and valid variables for environments."
-});
-function loggerOfCall(state) {
-  return resolveLogger(state.scope?.logger, state.owner);
-}
-var states2 = new WeakMap;
-function invalidValue(issues, source, phase) {
-  throw new Exception2({
-    layer: "use-case" /* UseCase */,
-    name: phase === "input" ? "InvalidUseCaseInput" : phase === "context" ? "InvalidUseCaseContext" : "InvalidUseCaseResponse",
-    source,
-    message: `Invalid UseCase ${phase}.`,
-    details: { issues },
-    cause: issues.find((issue) => issue.cause)?.cause
-  });
-}
-function collectEvents(blueprint, value, events) {
-  const visited = new WeakSet;
-  const visit = (field, current) => {
-    if (typeof current !== "object" || current === null || visited.has(current))
-      return;
-    visited.add(current);
-    if (isEntity2(current))
-      events.push(...current.pullEvents());
-    if (isBlueprintList(field)) {
-      for (const item of current)
-        visit(field.item, item);
-      return;
-    }
-    const shape = isBlueprint(field) ? field : isBlueprintVariant(field) ? isRecordClass(current.constructor) ? current.constructor.blueprint : variantOfValue(field, current) : recordFieldOf(field)?.record.blueprint;
-    if (!shape)
-      return;
-    for (const [key, child] of Object.entries(shape.properties)) {
-      visit(child, current[key]);
-    }
-  };
-  visit(blueprint, value);
-}
-function pullEntities(value, Entity, events) {
-  for (const item of Array.isArray(value) ? value : [value]) {
-    if (isEntity2(item) && item instanceof Entity) {
-      events.push(...item.pullEvents());
-    }
-  }
-}
-function methodNamesOf(repository) {
-  const names = new Set;
-  for (let current = repository;current !== null && current !== AbstractRepository.prototype && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
-    for (const name of Object.getOwnPropertyNames(current)) {
-      const descriptor = Object.getOwnPropertyDescriptor(current, name);
-      if (name !== "constructor" && typeof descriptor?.value === "function") {
-        names.add(name);
-      }
-    }
-  }
-  return [...names];
-}
-function bindRepository(repository, overrides, state, source) {
-  const Entity = repository.entity;
-  const repositoryName = recordNameOf2(Entity);
-  const bound = Object.create(null);
-  const view = new Proxy(Object.create(repository), {
-    get: (_target, key, receiver) => {
-      if (typeof key === "string" && Object.hasOwn(bound, key)) {
-        return bound[key];
-      }
-      if (key === ScopeKey)
-        return state.scope;
-      const value = Reflect.get(repository, key, receiver);
-      return key === "provider" && state.scope ? state.scope.providers.get(value) ?? value : value;
-    },
-    set: (_target, key, value) => Reflect.set(repository, key, value),
-    defineProperty: (_target, key, descriptor) => Reflect.defineProperty(repository, key, descriptor),
-    deleteProperty: (_target, key) => Reflect.deleteProperty(repository, key)
-  });
-  const bind = (target, name, receiver) => {
-    const method = target[name];
-    bound[name] = async (...args) => {
-      if (!state.active)
-        throw new InvalidUseCaseDependencies2({ source });
-      const started = clock();
-      const result = await method.apply(receiver, args);
-      writeLog(loggerOfCall(state), "debug", "repository", {
-        repository: repositoryName,
-        method: name,
-        useCase: source,
-        ms: elapsed(started)
-      });
-      for (const arg of args)
-        pullEntities(arg, Entity, state.events);
-      pullEntities(result, Entity, state.events);
-      return result;
-    };
-  };
-  for (const name of methodNamesOf(repository))
-    bind(repository, name, view);
-  if (overrides) {
-    for (const name of new Set([
-      ...methodNamesOf(repository),
-      ...methodNamesOf(overrides)
-    ])) {
-      if (typeof overrides[name] === "function") {
-        bind(overrides, name, overrides);
-      }
-    }
-  }
-  bound.entity = Entity;
-  bound.actions = repository.actions;
-  return Object.freeze(bound);
-}
-function narrowedContext(Child, parent) {
-  if (!Child.context || parent === undefined)
-    return;
-  const picked = {};
-  for (const key of Object.keys(Child.context.properties)) {
-    if (Object.hasOwn(parent, key)) {
-      picked[key] = parent[key];
-    }
-  }
-  return picked;
-}
-function isOverrideOf(dependency, value) {
-  if (isLoggerDeclaration(dependency))
-    return isLogger(value);
-  if (isRepository(dependency) || isEnvironment(dependency)) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-  }
-  return typeof value === "function";
-}
-
-class AbstractUseCase {
-  input;
-  constructor(input, ...args) {
-    const declaration = this.constructor;
-    const source = declaration.useCaseName;
-    const parsed = declaration.blueprint.safeParse(input);
-    if (parsed.issues)
-      invalidValue(parsed.issues, source, "input");
-    this.input = parsed.value;
-    const options = args[0];
-    const scope = options?.[ScopeKey];
-    let context;
-    if (declaration.context) {
-      const checked = declaration.context.safeParse(options?.context);
-      if (checked.issues)
-        invalidValue(checked.issues, source, "context");
-      context = Object.freeze(checked.value);
-    }
-    Object.defineProperty(this, "context", {
-      value: context,
-      enumerable: true
-    });
-    Object.defineProperty(this, "input", {
-      writable: false,
-      configurable: false
-    });
-    const implementation = this.execute;
-    if (typeof implementation !== "function") {
-      throw new InvalidUseCaseDeclaration2({
-        source,
-        details: { reason: "Implement execute as a prototype method." }
-      });
-    }
-    const state = {
-      context,
-      scope,
-      started: false,
-      active: false,
-      events: [],
-      dependencies: Object.create(null),
-      owner: this.constructor
-    };
-    states2.set(this, state);
-    for (const [key, dependency] of Object.entries(declaration.dependencies)) {
-      if (isRepository(dependency)) {
-        state.dependencies[key] = bindRepository(dependency, undefined, state, source);
-        continue;
-      }
-      if (isLoggerDeclaration(dependency)) {
-        Object.defineProperty(state.dependencies, key, {
-          get: () => loggerOfCall(state) ?? silentLogger,
-          enumerable: true
-        });
-        continue;
-      }
-      if (isEnvironment(dependency)) {
-        Object.defineProperty(state.dependencies, key, {
-          get: () => state.scope?.environments?.get(dependency) ?? dependency.load(),
-          enumerable: true
-        });
-        continue;
-      }
-      const Child = dependency;
-      state.dependencies[key] = async (value) => {
-        if (!state.active)
-          throw new InvalidUseCaseDependencies2({ source });
-        const child = new Child(value, {
-          context: narrowedContext(Child, state.context),
-          [ScopeKey]: state.scope
-        });
-        try {
-          return await child.execute();
-        } finally {
-          state.events.push(...child.pullEvents());
-        }
-      };
-    }
-    Object.freeze(state.dependencies);
-    Object.defineProperty(this, "execute", {
-      value: async (overrides = {}) => {
-        if (state.started)
-          throw new UseCaseAlreadyExecuted2({ source });
-        state.started = true;
-        if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides) || Reflect.ownKeys(overrides).some((key) => typeof key !== "string" || !Object.hasOwn(declaration.dependencies, key) || !isOverrideOf(declaration.dependencies[key], overrides[key]))) {
-          throw new InvalidUseCaseDependencies2({ source });
-        }
-        const replaced = overrides;
-        const dependencies = {};
-        for (const key of Object.keys(declaration.dependencies)) {
-          if (!Object.hasOwn(replaced, key)) {
-            dependencies[key] = state.dependencies[key];
-          }
-        }
-        for (const [key, substitute] of Object.entries(replaced)) {
-          const dependency = declaration.dependencies[key];
-          if (isRepository(dependency)) {
-            dependencies[key] = bindRepository(dependency, substitute, state, source);
-            continue;
-          }
-          if (isLoggerDeclaration(dependency)) {
-            dependencies[key] = substitute;
-            continue;
-          }
-          if (isEnvironment(dependency)) {
-            const parsed = dependency.blueprint.safeParse(substitute);
-            if (parsed.issues)
-              throw new InvalidUseCaseDependencies2({ source });
-            dependencies[key] = Object.freeze(parsed.value);
-            continue;
-          }
-          const Child = dependency;
-          dependencies[key] = async (value) => {
-            if (!state.active)
-              throw new InvalidUseCaseDependencies2({ source });
-            const childSource = Child.useCaseName;
-            const input = Child.blueprint.safeParse(value);
-            if (input.issues)
-              invalidValue(input.issues, childSource, "input");
-            const output = Child.response.safeParse(await guard2({ layer: "use-case" /* UseCase */, source: childSource }, () => substitute(input.value)));
-            if (output.issues)
-              invalidValue(output.issues, childSource, "response");
-            collectEvents(Child.response, output.value, state.events);
-            return output.value;
-          };
-        }
-        state.resolved = Object.freeze(dependencies);
-        state.active = true;
-        const started = clock();
-        try {
-          const result = await guard2({ layer: "use-case" /* UseCase */, source }, () => implementation.call(this, state.resolved));
-          const parsed = declaration.response.safeParse(result);
-          if (parsed.issues)
-            invalidValue(parsed.issues, source, "response");
-          collectEvents(declaration.response, parsed.value, state.events);
-          writeLog(loggerOfCall(state), "debug", "use-case", {
-            useCase: source,
-            outcome: "ok",
-            ms: elapsed(started)
-          });
-          return parsed.value;
-        } catch (error) {
-          logFailure(loggerOfCall(state), "use-case-failed", { useCase: source, ms: elapsed(started) }, error);
-          throw error;
-        } finally {
-          state.active = false;
-          state.resolved = undefined;
-        }
-      }
-    });
-  }
-  get dependencies() {
-    const state = states2.get(this);
-    return state?.resolved ?? state?.dependencies;
-  }
-  pullEvents() {
-    return states2.get(this)?.events.splice(0) ?? [];
-  }
-}
-function useCaseOf2(settings) {
-  const { name, blueprint, response, context } = settings;
-  const { description, deprecated = false } = settings;
-  const tags = settings.tags === undefined ? [] : settings.tags;
-  const errors = settings.errors === undefined ? [] : settings.errors;
-  const dependencies = settings.dependencies === undefined ? {} : settings.dependencies;
-  if (typeof name !== "string" || !name.trim() || !isBlueprint(blueprint) || blueprint.optional || !isBlueprint(response) || response.optional || typeof dependencies !== "object" || dependencies === null || Array.isArray(dependencies) || Reflect.ownKeys(dependencies).some((key) => typeof key !== "string" || !isDependency(dependencies[key]))) {
-    throw new InvalidUseCaseDeclaration2({
-      source: typeof name === "string" ? name : "useCaseOf",
-      details: {
-        reason: "Expected a name, input and response blueprints, and UseCase classes, repositories, environments or Logger as dependencies."
-      }
-    });
-  }
-  const invalidSetting = (reason) => {
-    throw new InvalidUseCaseDeclaration2({ source: name, details: { reason } });
-  };
-  if (context !== undefined && (!isBlueprint(context) || context.optional)) {
-    invalidSetting("Expected context to be a non-optional blueprint.");
-  }
-  if (description !== undefined && typeof description !== "string") {
-    invalidSetting("Expected description to be a string.");
-  }
-  if (typeof deprecated !== "boolean") {
-    invalidSetting("Expected deprecated to be a boolean.");
-  }
-  if (settings.strictSteps !== undefined && typeof settings.strictSteps !== "boolean") {
-    invalidSetting("Expected strictSteps to be a boolean.");
-  }
-  if (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string" || tag === "") || new Set(tags).size !== tags.length) {
-    invalidSetting("Expected tags to be distinct, non-empty strings.");
-  }
-  if (!Array.isArray(errors) || !errors.every(isDeclaredException) || new Set(errors).size !== errors.length) {
-    invalidSetting("Expected errors to be distinct classes made by exceptionOf.");
-  }
-  let route;
-  if (settings.route !== undefined) {
-    const declared = routeDeclarationOf(settings.route, blueprint, response);
-    route = typeof declared === "string" ? invalidSetting(declared) : declared;
-  }
-  let access;
-  if (settings.access !== undefined) {
-    const declared = accessDeclarationOf(settings.access, blueprint);
-    access = typeof declared === "string" ? invalidSetting(declared) : declared;
-  }
-  if (settings.steps !== undefined) {
-    validateSteps({ name, blueprint, context, dependencies, errors }, settings.steps);
-  }
-
-  class DeclaredUseCase extends AbstractUseCase {
-    static [Kind2] = "use-case";
-    static useCaseName = name;
-    static blueprint = blueprint;
-    static response = response;
-    static dependencies = Object.freeze({
-      ...dependencies
-    });
-    static context = context;
-    static description = description;
-    static tags = Object.freeze([...tags]);
-    static deprecated = deprecated;
-    static errors = Object.freeze([
-      ...errors
-    ]);
-    static route = route;
-    static access = access;
-  }
-  Object.defineProperty(DeclaredUseCase, "name", { value: name });
-  if (settings.steps !== undefined) {
-    Object.defineProperty(DeclaredUseCase, "steps", {
-      value: freezeData(settings.steps)
-    });
-    Object.defineProperty(DeclaredUseCase.prototype, "execute", {
-      value: executeSteps,
-      writable: true,
-      configurable: true
-    });
-  }
-  return DeclaredUseCase;
-}
-function isDependency(value) {
-  return isUseCaseClass2(value) || isRepository(value) || isEnvironment(value) || isLoggerDeclaration(value);
-}
-function isUseCaseClass2(value) {
-  return typeof value === "function" && value.prototype instanceof AbstractUseCase && value[Kind2] === "use-case" && typeof value.prototype.execute === "function";
-}
-function isUseCase2(value) {
-  return value instanceof AbstractUseCase;
-}
-
-// 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 (isPlain(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 (!isPlain(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 && !isPlain(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 (!isRepository(repository)) {
-      return invalid("it makes a use case for a repository of repositoryOf");
-    }
-    if (given !== undefined && !isPlain(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/event-policy/event-policy.ts
-var described = new WeakMap;
-var factories = new WeakMap;
-function invalid3(source, reason) {
-  throw new InvalidEventPolicy2({ source, details: { reason } });
-}
-function optionsOf(name, given, validate) {
-  const options = frozenJson(given ?? {}, "Event policy options", (reason) => invalid3(name, reason));
-  if (options === null || typeof options !== "object" || Array.isArray(options)) {
-    invalid3(name, "Event policy options must be an object.");
-  }
-  const reason = validate?.(options);
-  if (reason !== undefined)
-    invalid3(name, reason);
-  return options;
-}
-function eventPolicyOf2(settings) {
-  const name = settings?.name;
-  if (typeof name !== "string" || !/^[A-Za-z_$][\w$]*$/.test(name)) {
-    invalid3("eventPolicyOf", "Expected the policy name to be an identifier.");
-  }
-  if (typeof settings.handle !== "function") {
-    invalid3(name, "Expected handle to be a function.");
-  }
-  if (settings.publishers !== undefined && typeof settings.publishers !== "function") {
-    invalid3(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) {
-      invalid3("catalog", "A catalog takes factories made by `eventPolicyOf`.");
-    }
-    if (Object.hasOwn(byName, name)) {
-      invalid3(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)
-        invalid3("catalog", `Unknown event policy "${name}".`);
-      return factory(options);
-    }
-  });
-}
-
-export { InvalidEventPolicy2, PublisherNotBound2, exports_exceptions, guard2, ScopeKey, providerOf2, providerDescriptionOf2, prepareQuery2, sameValue2, matchesQuery2, selectRows2, inMemoryProvider2, fullUpcastPlanOf, upcast, resolveReferences, repositoryOf2, RepositoryOf2, isRepository, InvalidUseCaseStep2, InvalidUseCasePlugin2, UnknownUseCasePlugin2, IncompatibleUseCasePlugin2, UseCaseUnavailable2, UseCaseEntityNotFound2, UseCaseEntityConflict2, UseCaseInvalidCredentials2, exports_exceptions2, isPlain, PropertyInput2, propertyInputOf2, useCaseTargetOf2, isPublicAccess, accessDeclarationOf, interpretedStepsOf, InvalidUseCaseDeclaration2, UseCaseAlreadyExecuted2, InvalidUseCaseDependencies2, useCaseOf2, isUseCaseClass2, isUseCase2, exports_use_case, isUseCasePlugin2, useCaseOriginOf2, useCasePluginOf2, eventPolicyOf2, eventPolicyDescriptionOf2, eventPolicyPublishersOf, eventPolicyCatalogOf2 };