@jantstack/adonis-authz 2.5.0-alpha.2 → 2.5.0-alpha.4

package/build/src/relations/manager.js

@@ -26,8 +26,9 @@ import { assertPartition, assertSubject, assertRelationId, assertExpiresAt, scop
 import { isClock, systemClock } from '../clock.js';
 import { assertNotFrozenRow } from '../freeze.js';
 import { isRelUserset, normalizeRelationsCapabilities } from '../types.js';
-import { assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject } from './define_relations_config.js';
+import { assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject, assertRelationDenyable, assertDenySubject, assertDenyNoExpiry, } from './define_relations_config.js';
 import { assertCheckManyObjects } from './check_many.js';
+import { assertEnumeratePage, assertNoListPage } from './page.js';
 /**
  * ¿Cada POSICIÓN del array es un boolean? Por índice, nunca con `some`/`every`
  * (que saltan los huecos de un array disperso: 🟡 A3 del auditor del lote A).
@@ -39,6 +40,27 @@ function everyPositionBoolean(answers) {
     }
     return true;
 }
+const DECISIONS = new Set(['allow', 'deny', 'none']);
+/** ¿Cada POSICIÓN es una decisión (`'allow'|'deny'|'none'`)? Por índice (los huecos de un array disperso cuentan). */
+function everyPositionDecision(answers) {
+    for (let i = 0; i < answers.length; i++) {
+        if (!DECISIONS.has(answers[i]))
+            return false;
+    }
+    return true;
+}
+/** Descripción corta de una respuesta inválida de `decideMany`, para el mensaje del 500. */
+function describeDecisions(answer) {
+    if (!Array.isArray(answer))
+        return `${answer === null ? 'null' : typeof answer} (no es un array)`;
+    for (let i = 0; i < answer.length; i++) {
+        if (!(i in answer))
+            return `un array de ${answer.length} con un HUECO en la posición ${i}`;
+        if (!DECISIONS.has(answer[i]))
+            return `un array de ${answer.length} con ${JSON.stringify(answer[i])} en la posición ${i}`;
+    }
+    return `un array de ${answer.length}`;
+}
 /** Descripción corta de una respuesta inválida de `checkMany`, para el mensaje del 500. */
 function describeManyAnswer(answer) {
     if (!Array.isArray(answer))
@@ -120,7 +142,7 @@ export class RelationsManager {
      * la escritura no ocurrió y se propaga SIN evento. Con `{ transaction }` el
      * evento lleva además `transactional: true` (el rollback del llamante
      * determina el resultado, pero es suyo y el paquete no lo ve). Envuelve las
-     * CUATRO escrituras.
+     * SEIS escrituras (desde el lote D también `deny`/`removeDeny`).
      *
      * **Y una escritura PARCIAL también es indeterminada** (cierre del 🟡 6 del
      * auditor de alpha.3): la purga de `openfga` es multi-request (ortografías
@@ -306,7 +328,8 @@ export class RelationsManager {
             timeoutMs: this.#options.freezeTimeoutMs,
         });
     }
-    async relate(subject, relation, object, partition, options) {
+    async relate(subject, relation, object, partition, rawOptions) {
+        const options = knownWriteOptions(rawOptions);
         this.#assertTransactional(options, 'relate');
         await this.#assertNotFrozen('relate');
         this.#assertDeclared(object, relation);
@@ -325,7 +348,8 @@ export class RelationsManager {
         await this.#write(event, () => this.#driver.relate(subject, relation, object, partition, options));
         await this.#notify(event);
     }
-    async unrelate(subject, relation, object, partition, options) {
+    async unrelate(subject, relation, object, partition, rawOptions) {
+        const options = knownWriteOptions(rawOptions);
         this.#assertTransactional(options, 'unrelate');
         await this.#assertNotFrozen('unrelate');
         this.#assertDeclared(object, relation);
@@ -403,17 +427,127 @@ export class RelationsManager {
         }
         return answers;
     }
-    async listObjects(subject, relation, objectType, partition, page) {
+    /**
+     * **El deny de relación** (plan 2.5 · lote D · D1; D3/D5/D8/D10). El MISMO embudo que `relate`, en este orden:
+     * puerta 1 de `{ transaction }`, barrera del freeze, F-05 (sobre el nombre PÚBLICO), la capacidad
+     * `relationDenies` (500 `E_AUTHZ_UNSUPPORTED` con cero llamadas, como `membersOf`: D-28), la puerta del opt-in
+     * (solo un tipo en fase `'write'`; sin opt-in, en `'read'` o sobre `group` ⇒ 422 `E_AUTHZ_RELATION_NOT_DENYABLE`,
+     * D-17), sin caducidad (D3: `expiresAt` ⇒ 422), id, actor, partición (D4), sujeto (`*` ⇒ 422, userset solo
+     * `group#member`), `assertWrite` con `operation: 'deny'`, `#write` (invariante 13) y `#notify`. **Corte de camino**
+     * (D5): un deny en `editor` anula entero un grant de `owner` sobre ese objeto; solo sobrevive un `viewer` directo.
+     */
+    async deny(subject, relation, object, partition, options) {
+        this.#assertTransactional(options, 'deny');
+        await this.#assertNotFrozen('deny');
+        this.#assertDeclared(object, relation);
+        this.#assertDenies('deny');
+        assertRelationDenyable(this.#config, object, relation);
+        assertDenyNoExpiry(options);
+        this.#assertObjectId(object);
+        this.#assertActor(options, 'deny');
+        assertPartition(partition);
+        assertDenySubject(subject);
+        this.#assertSubject(subject, partition);
+        const ref = { operation: 'deny', subject, relation, object, partition };
+        this.#assertWrite(ref, 'deny');
+        const event = this.#copyEvent({ ...ref, ...this.#actorOf(options), ...this.#transactional(options) });
+        await this.#write(event, () => this.#driver.deny(subject, relation, object, partition, options));
+        await this.#notify(event);
+    }
+    /**
+     * **Retira un deny** (lote D). El embudo de `deny` SIN la puerta del opt-in: acepta CUALQUIER tipo declarado
+     * (D8/R2-4 b: retirar el opt-in de un tipo con denies vivos tiene que ser reversible, y los denies se tienen que
+     * poder borrar). Ojo, fila declarada (S8–S10 del tester): quitar un deny CONCEDE — `assertWrite` lo ve con
+     * `operation: 'removeDeny'`.
+     */
+    async removeDeny(subject, relation, object, partition, options) {
+        this.#assertTransactional(options, 'removeDeny');
+        await this.#assertNotFrozen('removeDeny');
+        this.#assertDeclared(object, relation);
+        this.#assertDenies('removeDeny');
+        assertDenyNoExpiry(options);
+        this.#assertObjectId(object);
+        this.#assertActor(options, 'removeDeny');
+        assertPartition(partition);
+        this.#assertSubject(subject, partition);
+        const ref = { operation: 'removeDeny', subject, relation, object, partition };
+        this.#assertWrite(ref, 'removeDeny');
+        const event = this.#copyEvent({ ...ref, ...this.#actorOf(options), ...this.#transactional(options) });
+        await this.#write(event, () => this.#driver.removeDeny(subject, relation, object, partition, options));
+        await this.#notify(event);
+    }
+    /** Los sujetos con deny DIRECTO de `relation` sobre `object` (hechos: no resta ni deriva). Cualquier tipo declarado (D8). */
+    async listDenies(relation, object, partition) {
+        this.#assertDeclared(object, relation);
+        this.#assertDenies('listDenies');
+        assertPartition(partition);
+        this.#assertObjectId(object);
+        assertNoListPage('listDenies', arguments[3], this.#driverLabel());
+        return this.#driver.listDenies(relation, object, partition);
+    }
+    /**
+     * **La primitiva de CADENA** (lote D · D9, decisión del dueño 2026-10-14): una decisión por objeto, POR POSICIÓN —
+     * `allow` si `check` concede aquí; si no, `deny` si el sujeto tiene un deny vivo (directo o por grupo, anidado)
+     * sobre ALGUNA relación de `up*(down*(R))` en el objeto; si no, `none`—. Recorre la cadena de la hoja hacia arriba
+     * y para en el primer valor que no sea `none`. Las MISMAS garantías que `checkMany`: tope
+     * `RELATIONS_CHECK_MANY_MAX` (50) y `[]` ⇒ 422 `E_AUTHZ_CHECK_MANY_BATCH` con cero llamadas, F-05 y el id POR
+     * ÍTEM, un `now` por lote en el driver, orden de salida = orden de entrada, y un error en UN ítem ⇒ 503 para todo
+     * el lote (nunca `none` por ítem: `none` en vez de `deny` dejaría que la cadena del llamante siguiera subiendo, S15).
+     * La respuesta del driver se valida (una decisión por posición, sin huecos, o 500 `E_AUTHZ_INTERNAL`). Sin
+     * `relationDenies` ⇒ 500 `E_AUTHZ_UNSUPPORTED` (D-28): sin deny no hay tri-estado que prometer.
+     */
+    async decideMany(subject, relation, objects, partition) {
+        assertCheckManyObjects(objects, 'decideMany');
+        for (const object of objects) {
+            this.#assertDeclared(object, relation);
+            this.#assertObjectId(object);
+        }
+        this.#assertDenies('decideMany');
+        assertPartition(partition);
+        this.#assertSubject(subject, partition);
+        const answers = await this.#driver.decideMany(subject, relation, objects, partition);
+        if (!Array.isArray(answers) || answers.length !== objects.length || !everyPositionDecision(answers)) {
+            throw new AuthorizationInternalError(`decideMany: el driver de relaciones '${this.#options.driverName ?? 'relations'}' respondió ` +
+                `${describeDecisions(answers)} para ${objects.length} objeto(s). ` +
+                "La respuesta es un ('allow'|'deny'|'none')[] POR POSICIÓN, exactamente uno por objeto (sin huecos): no se adivina.");
+        }
+        return answers;
+    }
+    /** El nombre del driver en los mensajes (la clave en `relations.drivers`, como en las puertas de `{ transaction }`). */
+    #driverLabel() {
+        return this.#options.driverName ?? 'relations';
+    }
+    /**
+     * **D-28 · la capacidad `relationDenies`** (regla D15: opcional, normalizada a `false`): sin ella, o sin el método
+     * del puerto, las cuatro operaciones del deny son 500 `E_AUTHZ_UNSUPPORTED` nombrándose, con CERO llamadas al
+     * driver — después de F-05 (un tipo no declarado sigue siendo 422), como `membersOf`.
+     */
+    #assertDenies(operation) {
+        if (this.#driver.capabilities?.relationDenies === true && typeof this.#driver[operation] === 'function')
+            return;
+        throw new UnsupportedOperationError(operation, 'el deny de relaciones', this.#options.driverName ?? 'relations', `El driver no declara relationDenies: true (o no trae '${operation}'): no sabe escribir ni honrar un deny. ` +
+            `Los dos drivers del paquete (database, openfga) lo traen desde 2.5.0-alpha.3.`);
+    }
+    /**
+     * **Los cuatro listados no paginan en 2.5** (lote «antes de RC» · 7.4, opción 4 del juez): `page` salió de la firma
+     * de `listObjects`/`listSubjects`/`listDenies`/`membersOf` (nunca hizo nada) y un valor distinto de `undefined` que
+     * llegue por JS o `as any` es 500 `E_AUTHZ_UNSUPPORTED` con CERO llamadas al driver (`assertNoListPage`), DESPUÉS de
+     * F-05 y de la partición (RC74-5: primero la identidad de la pregunta). Sin página, la lista es completa o lleva
+     * `truncated`; nunca un cursor.
+     */
+    async listObjects(subject, relation, objectType, partition) {
         this.#assertDeclared({ type: objectType }, relation);
         assertPartition(partition);
         this.#assertSubject(subject, partition);
-        return this.#driver.listObjects(subject, relation, objectType, partition, page);
+        assertNoListPage('listObjects', arguments[4], this.#driverLabel());
+        return this.#driver.listObjects(subject, relation, objectType, partition);
     }
-    async listSubjects(relation, object, partition, page) {
+    async listSubjects(relation, object, partition) {
         this.#assertDeclared(object, relation);
         assertPartition(partition);
         this.#assertObjectId(object);
-        return this.#driver.listSubjects(relation, object, partition, page);
+        assertNoListPage('listSubjects', arguments[3], this.#driverLabel());
+        return this.#driver.listSubjects(relation, object, partition);
     }
     /**
      * **Las purgas notifican** (2.4.0-alpha.3 · E, hallazgo #4; D-1/D-3): UN
@@ -426,7 +560,7 @@ export class RelationsManager {
      * notifica también cuando no borra nada: el hecho auditable es «alguien
      * pidió borrar las llaves de X». Sujeta a `requireActor` (D-3, breaking) y
      * al actor validado; NO pasa por `assertWrite` (su `RelationRef.operation`
-     * es `'relate' | 'unrelate'`, tipo publicado de R-13). Mismo `#write`
+     * es `'relate' | 'unrelate' | 'deny' | 'removeDeny'`, tipo publicado de R-13). Mismo `#write`
      * (invariante 13) y mismo `#notify` que `relate`/`unrelate`.
      *
      * **Y pasan por F-05** (cierre del 🔴 1 del auditor de alpha.3): el mismo
@@ -475,7 +609,7 @@ export class RelationsManager {
      * `E_AUTHZ_UNSUPPORTED` nombrándola (la transitiva sería `ListUsers`, que
      * trunca), jamás un `skip`.
      */
-    async membersOf(object, relation, partition, page) {
+    async membersOf(object, relation, partition) {
         // Cierre-2 · 🟡 3: `membersOf` toma `(object, relation)` —la forma exacta
         // que F-05 guarda— y era la octava operación fuera de «las siete»; un
         // driver de terceros con `membersOfNative: true` sobre un store compartido
@@ -488,7 +622,8 @@ export class RelationsManager {
             throw new UnsupportedOperationError('membersOf', 'la membresía transitiva de un grupo', 'relations', `Solo el driver 'database' la resuelve (CTE recursiva); en 'openfga' la transitiva sería ` +
                 `'ListUsers', que trunca. Usa 'listSubjects' para los hechos directos.`);
         }
-        return this.#driver.membersOf(object, relation, partition, page);
+        assertNoListPage('membersOf', arguments[3], this.#driverLabel());
+        return this.#driver.membersOf(object, relation, partition);
     }
     /** ORIGEN de `authz:reconcile` de relaciones. 500 `E_AUTHZ_UNSUPPORTED` si el driver no lo trae. */
     async enumerateRelations(partition, page) {
@@ -496,7 +631,10 @@ export class RelationsManager {
         if (!this.#driver.enumerateRelations || !this.#driver.capabilities?.enumerateRelations) {
             throw new UnsupportedOperationError('enumerateRelations', 'ser origen de authz:reconcile de relaciones', 'relations');
         }
-        return this.#driver.enumerateRelations(partition, page);
+        // 7.4 (injerto 4): la FORMA de la página (limit entero ≥ 1, after cadena no vacía) ⇒ 422 sin tocar el driver; qué
+        // cursor es legítimo lo decide el driver (el manager no sabe qué emite).
+        const checked = assertEnumeratePage('enumerateRelations', page, 'opaque', this.#driverLabel());
+        return this.#driver.enumerateRelations(partition, checked);
     }
     /**
      * **K particiones en UN barrido** (2.4.0-alpha.6) si el driver trae
@@ -529,9 +667,10 @@ export class RelationsManager {
         if (!this.#driver.enumerateRelations || !this.#driver.capabilities?.enumerateRelations) {
             throw new UnsupportedOperationError('enumerateRelationsMany', 'ser origen de authz:reconcile de relaciones', 'relations');
         }
+        const checked = assertEnumeratePage('enumerateRelationsMany', page, 'opaque', this.#driverLabel());
         if (typeof this.#driver.enumerateRelationsMany === 'function')
-            return this.#driver.enumerateRelationsMany(partitions, page);
-        if (page?.after !== undefined) {
+            return this.#driver.enumerateRelationsMany(partitions, checked);
+        if (checked?.after !== undefined) {
             throw new AuthorizationConfigError('enumerateRelationsMany: el driver de relaciones no implementa enumerateRelationsMany y el respaldo del manager (K llamadas ' +
                 'a enumerateRelations) no sabe reanudar con un cursor: `after` no se acepta aquí (reanudar aplicaría el cursor de UNA ' +
                 'partición a todas y perdería tuplas en silencio). Implementa enumerateRelationsMany en el driver, o pagina partición a ' +
@@ -539,7 +678,7 @@ export class RelationsManager {
         }
         const tuples = [];
         for (const partition of partitions) {
-            const one = await this.#driver.enumerateRelations(partition, page);
+            const one = await this.#driver.enumerateRelations(partition, checked);
             if (one.cursor !== undefined) {
                 throw new AuthorizationConfigError(`enumerateRelationsMany: la partición ${scopeKey(partition)} tiene más tuplas de las que caben en una página y el driver ` +
                     'de relaciones no implementa enumerateRelationsMany: el respaldo del manager (K llamadas a enumerateRelations) no ' +
@@ -564,4 +703,27 @@ export class RelationsManager {
         assertSubject(subject);
     }
 }
-//# sourceMappingURL=manager.js.map
+/**
+ * **Las opciones de `relate`/`unrelate` que cruzan al driver** (cierre de R1 · 🟡 2 del auditor + 🟠 C del tester): un
+ * objeto NUEVO con SOLO las claves conocidas (`transaction`, `actor`, `expiresAt`, con su presencia: «omitido» ≠
+ * `undefined` explícito no importa al driver, pero `'expiresAt' in options` sí al evento), leídas UNA vez — un `Proxy`
+ * de la app no llega al driver, ni sus símbolos, ni respuestas distintas entre la validación y la escritura. Lo que no
+ * es un objeto pasa tal cual (las validaciones de siempre lo juzgan).
+ */
+function knownWriteOptions(options) {
+    if (options === undefined || options === null || typeof options !== 'object')
+        return options;
+    const out = {};
+    for (const key of KNOWN_WRITE_OPTION_KEYS)
+        if (key in options)
+            out[key] = options[key];
+    return out;
+}
+/**
+ * **La lista de claves que cruzan, EXHAUSTIVA por tipo** (cierre-2 de R1 · D3 (b), injerto del analista y del auditor):
+ * el `satisfies` exige UNA entrada por cada clave de `RelationWriteOptions` (y ninguna más). Una clave nueva del tipo —una
+ * de seguridad, por ejemplo— que no se decida aquí NO COMPILA: hasta el cierre-2 se perdía en silencio en el manager
+ * (fallo abierto si la clave era una guarda). Decidir = `true` (cruza al driver) o sacarla del tipo.
+ */
+const KNOWN_WRITE_OPTIONS = { transaction: true, actor: true, expiresAt: true };
+export const KNOWN_WRITE_OPTION_KEYS = Object.freeze(Object.keys(KNOWN_WRITE_OPTIONS));

package/build/src/relations/page.d.ts

@@ -0,0 +1,19 @@
+import type { RelationPage } from '../types.js';
+/** Tamaño de página de `enumerate*` en `database` cuando no se pide `limit`. */
+export declare const RELATIONS_ENUMERATE_DEFAULT_LIMIT = 100;
+/** Techo de `limit` en `enumerate*` de `database`: por encima se RECORTA (con cursor, sin pérdida), no es un error. */
+export declare const RELATIONS_ENUMERATE_MAX_LIMIT = 1000;
+/** Regla 1: un `list*` de relaciones con página (cualquier valor distinto de `undefined`) ⇒ 500 sin tocar el backend. */
+export declare function assertNoListPage(operation: string, page: unknown, driver: string): void;
+/** Qué cursor emite quien valida: `uuid` (database), `none` (openfga, el doble), `opaque` (el manager). */
+export type EnumerateCursorKind = 'uuid' | 'none' | 'opaque';
+/**
+ * Regla 2: la forma de la página de `enumerate*`. `undefined` = sin página. Devuelve una COPIA de lo validado (cada campo
+ * se lee UNA vez: un getter que cambia entre la validación y el uso no cuela un `NaN` como `limit`, ⚪ 1 del auditor 7.x);
+ * quien consulta usa la copia, jamás la página original.
+ */
+export declare function assertEnumeratePage(operation: string, page: unknown, cursor: EnumerateCursorKind, driver: string): RelationPage | undefined;
+/** El `limit` efectivo de `enumerate*` (tras `assertEnumeratePage`): el default, o el pedido recortado al techo. */
+export declare function enumerateLimit(page: {
+    limit?: number;
+} | undefined): number;

package/build/src/relations/page.js

@@ -0,0 +1,74 @@
+/**
+ * **La página de relaciones, en UN sitio** (lote «antes de RC» · 7.4, opción 4 del juez —`loteRC-74-paginacion-juez.md`,
+ * 88,5/100—, decisión del dueño 2026-10-17 (7.4)). Dos reglas, compartidas por el manager, los dos drivers y el doble:
+ *
+ *  1. **Los `list*` no paginan en 2.5.** `listObjects`/`listSubjects`/`listDenies`/`membersOf` ya no tienen `page` en
+ *     la firma. `undefined` (ausente o explícito) es «sin página»; CUALQUIER otro valor —`null`, `{}`, `{ after: '' }`,
+ *     `{ limit: 0 }`…— que llegue por JS o `as any` ⇒ 500 `E_AUTHZ_UNSUPPORTED` nombrando la operación, con CERO
+ *     llamadas al backend (`assertNoListPage`). Se mira `!== undefined`, jamás `arguments.length` (RC74-3: quien reenvía
+ *     un opcional vacío no se rompe). Orden de las guardas (RC74-5): F-05 y partición ANTES; la página, la última.
+ *  2. **`enumerate*` valida su página** (`assertEnumeratePage`): `limit` entero ≥ 1 o 422 `E_AUTHZ_INVALID_PAGE`
+ *     (`NaN` generaba una consulta SIN `LIMIT`, tester H2), por encima de `RELATIONS_ENUMERATE_MAX_LIMIT` se RECORTA
+ *     (`enumerateLimit`: con cursor, sin pérdida; declarado en «Limits»); `after` cadena no vacía o 422, y según el
+ *     cursor que el driver emite: `uuid` (`database`: el uuid canónico de la fila; un cursor ajeno era un 503 en PG y
+ *     un fin silencioso en MySQL/SQLite, H3), `none` (`openfga` y el doble no emiten cursor ⇒ 500) u `opaque` (el
+ *     manager, que no sabe qué emite el driver: solo la forma).
+ *
+ * Lo que NO hace (H3 a medias, a propósito): atar el cursor a su partición —un cursor de A reutilizado en B salta
+ * filas— exige un sobre de cursor; es del lote C / 2.6.
+ */
+import { InvalidRelationPageError, UnsupportedOperationError } from '../errors.js';
+import { isCanonicalUuid } from '../identity.js';
+/** Tamaño de página de `enumerate*` en `database` cuando no se pide `limit`. */
+export const RELATIONS_ENUMERATE_DEFAULT_LIMIT = 100;
+/** Techo de `limit` en `enumerate*` de `database`: por encima se RECORTA (con cursor, sin pérdida), no es un error. */
+export const RELATIONS_ENUMERATE_MAX_LIMIT = 1_000;
+/** Regla 1: un `list*` de relaciones con página (cualquier valor distinto de `undefined`) ⇒ 500 sin tocar el backend. */
+export function assertNoListPage(operation, page, driver) {
+    if (page !== undefined)
+        throw UnsupportedOperationError.listPage(operation, driver);
+}
+/**
+ * Regla 2: la forma de la página de `enumerate*`. `undefined` = sin página. Devuelve una COPIA de lo validado (cada campo
+ * se lee UNA vez: un getter que cambia entre la validación y el uso no cuela un `NaN` como `limit`, ⚪ 1 del auditor 7.x);
+ * quien consulta usa la copia, jamás la página original.
+ */
+export function assertEnumeratePage(operation, page, cursor, driver) {
+    if (page === undefined)
+        return undefined;
+    if (page === null || typeof page !== 'object' || Array.isArray(page)) {
+        throw new InvalidRelationPageError(`${operation}: la página tiene que ser un objeto { limit?, after? } (llegó ${describe(page)}).`);
+    }
+    const { limit, after } = page;
+    if (limit !== undefined && !(typeof limit === 'number' && Number.isInteger(limit) && limit >= 1)) {
+        throw new InvalidRelationPageError(`${operation}: page.limit tiene que ser un entero ≥ 1 (llegó ${describe(limit)}); por encima de ` +
+            `${RELATIONS_ENUMERATE_MAX_LIMIT} se recorta, no es un error.`);
+    }
+    if (after === undefined)
+        return limit === undefined ? {} : { limit };
+    if (typeof after !== 'string' || after.length === 0) {
+        throw new InvalidRelationPageError(`${operation}: page.after tiene que ser el cursor que devolvió la página anterior (llegó ${describe(after)}).`);
+    }
+    if (cursor === 'none')
+        throw UnsupportedOperationError.enumerateCursor(operation, driver);
+    if (cursor === 'uuid' && !isCanonicalUuid(after)) {
+        throw new InvalidRelationPageError(`${operation}: page.after no es un cursor de este driver ('${driver}' emite el uuid canónico de la última fila leída); ` +
+            `pasa el cursor que devolvió la página anterior, sin tocarlo.`);
+    }
+    return limit === undefined ? { after } : { limit, after };
+}
+/** El `limit` efectivo de `enumerate*` (tras `assertEnumeratePage`): el default, o el pedido recortado al techo. */
+export function enumerateLimit(page) {
+    return Math.min(page?.limit ?? RELATIONS_ENUMERATE_DEFAULT_LIMIT, RELATIONS_ENUMERATE_MAX_LIMIT);
+}
+function describe(value) {
+    if (typeof value === 'string')
+        return `'${value.slice(0, 40)}'`;
+    if (typeof value === 'number')
+        return String(value);
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'un array';
+    return typeof value;
+}