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

package/build/src/catalog/catalog_cache.js

@@ -420,6 +420,31 @@ export class CatalogCache {
         }
         return this.#reload();
     }
+    /**
+     * **La foto para una ESCRITURA** (lote C · carreras, resolución 2 del juez = K4): contrasta la versión con la fila
+     * SIEMPRE, ignore o no la ventana `{ everyMs }`. Con `'always'` es exactamente `view()`. La ventana es para DECIDIR
+     * (invariante 14: una pregunta puede responder con un catálogo de hasta `everyMs` de antigüedad); una escritura del driver
+     * deja ESTADO en el store que no caduca —el barrido de `moved`, el settle, la proyección—, y con un memo rancio un rol
+     * recién definido en otro proceso no se barre (fail-open persistente medido, K4). Coste: el SELECT por PK de `'always'`.
+     *
+     * **Nunca se suma a una comprobación ni a una carga EN VUELO** (asentar · cierre 2, ⚪ 6 / O-6 del auditor): la que ya
+     * estaba en marcha pudo leer la fila ANTES de la escritura que precede a esta llamada (la propia, o la de otro proceso
+     * que la escritura acaba de observar) y serviría esa foto. Se espera la carga en vuelo y se lee la versión otra vez;
+     * una carga que arranca DESPUÉS de esta llamada sí se comparte (ya es posterior).
+     */
+    async freshView() {
+        if (this.#loading)
+            await this.#loading.catch(() => undefined);
+        const current = this.#view;
+        if (!current || !this.#isFresh())
+            return this.#reload();
+        const dbVersion = await this.#readVersion();
+        if (this.#view === current && this.#isFresh() && dbVersion === current.version) {
+            this.#checkedAt = this.#now();
+            return current;
+        }
+        return this.#reload(dbVersion);
+    }
     /** Una carga compartida; `knownVersion` es la fila recién leída por una revalidación (se ahorra releerla). */
     #reload(knownVersion) {
         if (!this.#loading) {
@@ -663,4 +688,3 @@ function buildCatalogView(permissions, roles, links, loadedAt, version) {
         version,
     };
 }
-//# sourceMappingURL=catalog_cache.js.map

package/build/src/clock.d.ts

@@ -21,4 +21,3 @@ export type Clock = () => Date;
 export declare const systemClock: Clock;
 /** `now` tiene que ser una función; se valida al construir (500 `E_AUTHZ_CONFIG` es del llamante). */
 export declare function isClock(value: unknown): value is Clock;
-//# sourceMappingURL=clock.d.ts.map

package/build/src/clock.js

@@ -4,4 +4,3 @@ export const systemClock = () => new Date();
 export function isClock(value) {
     return typeof value === 'function';
 }
-//# sourceMappingURL=clock.js.map

package/build/src/define_config.d.ts

@@ -381,4 +381,3 @@ export declare function defineConfig<T extends AuthorizationConfig>(config: T):
  * barata (claves, no valores).
  */
 export declare function assertAuthorizationConfigShape(config: unknown): void;
-//# sourceMappingURL=define_config.d.ts.map

package/build/src/define_config.js

@@ -77,12 +77,36 @@ function assertConfigBlock(value, path) {
             `una clave conocida no es «nada»: se ignoraría en silencio (plan 2.5 · B2).`);
     }
 }
+/**
+ * **Lápidas: claves que NO existen aquí pero que la letra de una decisión firmada nombra así** (cierre-2 de R1 · D1 (a),
+ * decisión del dueño 2026-10-20: «`relations.maxGroupDepth` ⇒ 500 con mensaje que apunta a `defineRelationsConfig`»).
+ * La decisión (5) escribió `relations.maxGroupDepth`; el mando vive en `defineRelationsConfig` (la config que capturan
+ * las factories de los drivers, `manager.driver()` y `runRelationsReconcile`) y se lee como `relations.config.maxGroupDepth`.
+ * Sin alias (una clave hermana se validaría y no gobernaría tres de las cuatro rutas): la ruta literal es el MISMO 500
+ * de clave desconocida, con la receta del sitio bueno en vez de la lista de claves.
+ */
+const MISPLACED_CONFIG_KEYS = Object.freeze({
+    'relations.maxGroupDepth': "defineConfig: la clave 'relations.maxGroupDepth' no existe. El techo de anidación de grupos va en la config de " +
+        'RELACIONES: defineRelationsConfig({ objectTypes, maxGroupDepth, database: { enforceGroupDepth } }), y ese objeto en ' +
+        'relations.config. Es la config que capturan los drivers (las factories de relations.drivers), manager.driver() y ' +
+        'runRelationsReconcile (authz:relations:reconcile): una clave hermana de relations no llegaría a ninguno y el límite ' +
+        'no se aplicaría.',
+    'relations.enforceGroupDepth': "defineConfig: la clave 'relations.enforceGroupDepth' no existe. El opt-in del techo de anidación de grupos en " +
+        'database va en la config de RELACIONES: defineRelationsConfig({ objectTypes, maxGroupDepth, database: { ' +
+        'enforceGroupDepth: true } }), y ese objeto en relations.config (la que capturan los drivers).',
+});
 function assertKnownConfigKeys(value, known, path) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return;
     for (const key of Object.keys(value)) {
         if (known.includes(key))
             continue;
+        // Cierre-3 · R-6: `Object.hasOwn` — una clave `constructor`/`toString` (o un `__proto__` propio de un JSON) leía el
+        // prototipo de la tabla y el 500 llevaba de mensaje `function Object() { [native code] }`.
+        const dotted = path === '' ? key : `${path}.${key}`;
+        const tombstone = Object.hasOwn(MISPLACED_CONFIG_KEYS, dotted) ? MISPLACED_CONFIG_KEYS[dotted] : undefined;
+        if (tombstone !== undefined)
+            throw new AuthorizationConfigError(tombstone);
         const where = path === '' ? `'${key}' en la raíz` : `'${path}.${key}'`;
         throw new AuthorizationConfigError(`defineConfig: la clave ${where} no existe (claves válidas en ${path === '' ? 'la raíz' : path}: ${known.join(', ')}). ` +
             `Ninguna clave del config se descarta en silencio (plan 2.5 · B2): un typo ('requireWithing') sería una ` +
@@ -121,4 +145,3 @@ export function assertAuthorizationConfigShape(config) {
         assertKnownConfigKeys(c[block], AUTHORIZATION_CONFIG_KEYS[block], block);
     }
 }
-//# sourceMappingURL=define_config.js.map

package/build/src/drivers/database_driver.d.ts

@@ -204,6 +204,12 @@ export declare class DatabaseAuthorizationDriver implements AuthorizationDriver
      */
     readonly catalog: CatalogCache;
     constructor(options?: DatabaseDriverOptions);
+    /**
+     * **El catálogo de una ESCRITURA** (K4; asentar · cierre 2, D-1): con la versión contrastada en fresco SIEMPRE
+     * (`CatalogCache.freshView`), ignore o no la ventana `{ everyMs }`. Un `catalog` inyectado que no lo traiga cae en
+     * `view()` (el contrato del memo es suyo). Gemelo de `OpenFgaAuthorizationDriver.writeCatalog`.
+     */
+    private writeCatalog;
     /**
      * Vista de este driver con OTRO resolutor de la cadena y el mismo estado
      * (conexión, memo del catálogo, deadline). Es lo que usa
@@ -393,4 +399,3 @@ export declare class DatabaseAuthorizationDriver implements AuthorizationDriver
      */
     private eachReconcileRow;
 }
-//# sourceMappingURL=database_driver.d.ts.map

package/build/src/drivers/database_driver.js

@@ -327,12 +327,24 @@ export class DatabaseAuthorizationDriver {
             // `resolveChain` y la barrera del freeze (autoridad). Un despliegue con
             // pool 1 lo declara `false` (ver `DatabaseDriverOptions`).
             transactionalWrites: this.transactionalWrites,
+            // Estrategia 2.5.0 · firma 4 (D15): `false` EXPLÍCITO — `database` es el driver ESTABLE de 2.5.0 (el experimental
+            // es `openfga`). Explícito para que la copia de `authorization.capabilities()` y este objeto digan lo mismo.
+            experimental: false,
         });
         assertCatalogOptions('DatabaseAuthorizationDriver', options);
         this.catalog =
             options.catalog ??
                 new CatalogCache({ driver: 'database', timeoutMs: this.timeoutMs, revalidate: options.catalogRevalidate });
     }
+    /**
+     * **El catálogo de una ESCRITURA** (K4; asentar · cierre 2, D-1): con la versión contrastada en fresco SIEMPRE
+     * (`CatalogCache.freshView`), ignore o no la ventana `{ everyMs }`. Un `catalog` inyectado que no lo traiga cae en
+     * `view()` (el contrato del memo es suyo). Gemelo de `OpenFgaAuthorizationDriver.writeCatalog`.
+     */
+    writeCatalog() {
+        const catalog = this.catalog;
+        return typeof catalog.freshView === 'function' ? catalog.freshView() : catalog.view();
+    }
     /**
      * Vista de este driver con OTRO resolutor de la cadena y el mismo estado
      * (conexión, memo del catálogo, deadline). Es lo que usa
@@ -610,7 +622,11 @@ export class DatabaseAuthorizationDriver {
         // a lo sumo uno es visible ahí y los demás serían filas huérfanas; el
         // scope puede no existir ya para el árbol (D8), así que no se filtra por
         // visibilidad — quitar nunca concede.
-        const named = rolesToRevoke(await this.catalog.view(), role, scope);
+        // Asentar · cierre 2 (D-1 del re-ataque; gemelo del 🟡 5 de `openfga`, K4): el catálogo de una ESCRITURA, con la
+        // versión en fresco. Con el memo de `{ everyMs }` un local recién definido en otro proceso que ensombrece al global
+        // no salía en `rolesToRevoke`: el DELETE no tocaba su fila y la asignación local seguía concediendo (un «revocado»
+        // falso, mudo y persistente).
+        const named = rolesToRevoke(await this.writeCatalog(), role, scope);
         // Sin cadena con la que canonizar, TODAS las ortografías de las que el
         // uuid puede ser alias (3b-8 · A4, mismo fan-out que `scopes.detached`):
         // con una sola, un alias hacía del DELETE un no-op silencioso y la fila
@@ -1141,6 +1157,11 @@ export class DatabaseAuthorizationDriver {
                     scope_type: target.type,
                     scope_uuid: toDbScopeUuid(target),
                 };
+                // Cierre-2 de L11 (C1): un deny que el origen guarda con una condición ajena se migra como deny (fail-closed:
+                // perderlo concedería) pero se DECLARA: `invalid-condition` es deriva y el operador decide.
+                if (fact.invalidCondition !== undefined) {
+                    note('deny', 'invalid-condition', `${fact.detail} (${fact.invalidCondition})`);
+                }
                 usableFacts += 1;
                 const denyId = denyKey(row);
                 if (wantedDenies.has(denyId))
@@ -1309,4 +1330,3 @@ export class DatabaseAuthorizationDriver {
         }
     }
 }
-//# sourceMappingURL=database_driver.js.map

package/build/src/drivers/database_relations_driver.d.ts

@@ -88,6 +88,13 @@ export declare class DatabaseRelationsDriver implements RelationsDriver {
     deny(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationDenyOptions): Promise<void>;
     /** `removeDeny`: borra la tupla `denied_<rel>`. Sobre CUALQUIER tipo declarado (D8/R2-4 b). No-op si no está. */
     removeDeny(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationDenyOptions): Promise<void>;
+    /**
+     * **El techo de anidación de grupos de ESTE driver** (lote «antes de RC» · R1, decisión del dueño 2026-10-17 (5)):
+     * `database` no tiene techo técnico (la CTE deduplica y termina con ciclos), así que es `null` SALVO el opt-in
+     * explícito `database.enforceGroupDepth: true`, que aplica el `maxGroupDepth` de la config (obligatorio y numérico
+     * con el opt-in: lo valida `defineRelationsConfig` al arrancar).
+     */
+    groupDepthLimit(): Promise<number | null>;
     unrelate(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationWriteOptions): Promise<void>;
     /**
      * **F-05 en las LECTURAS y las PURGAS del driver** (2.4.0-alpha.3, cierre
@@ -117,14 +124,14 @@ export declare class DatabaseRelationsDriver implements RelationsDriver {
      * misma función que el doble y `openfga` cuando alinea su `batchCheck`). Tope, `[]` y F-05 por ítem como `checkMany`.
      */
     decideMany(subject: RelSubject, relation: string, objects: RelObject[], partition: ScopeRef): Promise<RelationDecision[]>;
-    listObjects(subject: RelSubject, relation: string, objectType: string, partition: ScopeRef, _page?: RelationPage): Promise<RelationObjectsPage>;
-    listSubjects(relation: string, object: RelObject, partition: ScopeRef, _page?: RelationPage): Promise<RelationSubjectsPage>;
+    listObjects(subject: RelSubject, relation: string, objectType: string, partition: ScopeRef): Promise<RelationObjectsPage>;
+    listSubjects(relation: string, object: RelObject, partition: ScopeRef): Promise<RelationSubjectsPage>;
     /**
      * **`listDenies`** (lote D · D1): los sujetos con deny DIRECTO de `relation` sobre `object` —hechos, como
      * `listSubjects` sobre la relación almacenada `denied_<rel>`; no resta ni deriva—. Sobre CUALQUIER tipo declarado
      * (D8/R2-4 b: con el opt-in retirado, los denies vivos se siguen pudiendo listar y borrar).
      */
-    listDenies(relation: string, object: RelObject, partition: ScopeRef, page?: RelationPage): Promise<RelationSubjectsPage>;
+    listDenies(relation: string, object: RelObject, partition: ScopeRef): Promise<RelationSubjectsPage>;
     /**
      * **`denyPhase` — ¿admite este driver escrituras de deny en el tipo?** (lote D · D2, R2-5): la fase del opt-in EN
      * LA CONFIG DE ESTE DRIVER (`'write'`, `'read'` o `null`). F-05 estricto del par (422), cero sentencias: es
@@ -140,7 +147,7 @@ export declare class DatabaseRelationsDriver implements RelationsDriver {
      * directos): en un grupo con `member(g1#member, g2)`, `membersOf(g2)` trae a
      * los holders de g1 y `listSubjects(member, g2)` solo el userset `g1#member`.
      */
-    membersOf(object: RelObject, relation: string, partition: ScopeRef, _page?: RelationPage): Promise<RelationSubjectsPage>;
+    membersOf(object: RelObject, relation: string, partition: ScopeRef): Promise<RelationSubjectsPage>;
     purgeObject(object: RelObject, partition: ScopeRef, options?: RelationTransactionOptions): Promise<void>;
     purgeSubject(subject: RelSubject, partition: ScopeRef, options?: RelationTransactionOptions): Promise<void>;
     /**
@@ -184,4 +191,3 @@ export declare class DatabaseRelationsDriver implements RelationsDriver {
      */
     enumerateRelationsMany(partitions: ScopeRef[], page?: RelationPage): Promise<RelationTuplePage>;
 }
-//# sourceMappingURL=database_relations_driver.d.ts.map

package/build/src/drivers/database_relations_driver.js

@@ -29,13 +29,15 @@ import { AuthorizationBackendTimeoutError, AuthorizationConfigError, InvalidIden
 import { assertPartition, assertSubject, assertExpiresAt, partitionKey } from '../identity.js';
 import { relationPartitionTrigger, relationPartitionTriggerDrops } from '../relation_partition_trigger.js';
 import { isClock, systemClock } from '../clock.js';
-import { resolveGrantExpiry, sameInstant } from '../expiry.js';
+import { isActiveExpiry, resolveGrantExpiry, sameInstant } from '../expiry.js';
+import { assertGroupDepthSettings, groupDepthLimitError, groupNestingVerdict, isGroupNesting, plannedByReconcile } from '../relations/group_depth.js';
 import { sqlExpiryCodec } from '../shared/sql_expiry.js';
 import { guardSql, isDeadlock, isUniqueViolation, withDeadline } from '../shared/backend_guard.js';
 import { assertCallerTransaction } from '../shared/transaction_guard.js';
 import { isRelUserset } from '../types.js';
 import { assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject, assertRelationDenyable, assertDenySubject, assertDenyNoExpiry, cutPathAllows, decideFrom, deniableAbove, deniedRelationOf, storedRelationKind, denyPhaseOf, relationsDown, RELATION_DENY_PREFIX, } from '../relations/define_relations_config.js';
 import { assertCheckManyObjects, distinctObjects, expandByPosition } from '../relations/check_many.js';
+import { assertEnumeratePage, assertNoListPage, enumerateLimit } from '../relations/page.js';
 const DEFAULT_TIMEOUT_MS = 5_000;
 /**
  * **Cota de candidatos de `membersOf` cuando el objeto tiene un deny vigente** (lote D · cierre 1 de D1, 🟡 4): con deny
@@ -58,9 +60,6 @@ const GROUP_MEMBER = 'member';
  * userset puede colisionar con ella.
  */
 const HOLDER_RELATION = '';
-/** Tamaño de página por defecto y tope de `enumerateRelations` (origen de reconcile). */
-const DEFAULT_ENUMERATE_LIMIT = 100;
-const MAX_ENUMERATE_LIMIT = 1_000;
 /** Formato de id de relación: minúsculas, dígitos y `._-`; sin separadores del store. */
 const RELATION_ID_FORMAT = /^[a-z0-9_.-]+$/;
 const DIALECTS = {
@@ -116,6 +115,9 @@ export class DatabaseRelationsDriver {
     #database;
     #expiryCodec;
     constructor(config, options = {}, database = db) {
+        // Cierre de R1 · 🟡 4 del auditor: el driver RE-VALIDA el techo de la config (una config extendida con spread no pasó
+        // por `defineRelationsConfig`; `NaN` o `enforceGroupDepth: true` sin número apagaban el gate en silencio). 500.
+        assertGroupDepthSettings(config.maxGroupDepth, config.enforceGroupDepth, 'DatabaseRelationsDriver');
         this.#config = config;
         this.#connectionName = options.connection;
         this.#timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -137,6 +139,8 @@ export class DatabaseRelationsDriver {
             // Cierre 2 de D2 · 🟠 N1: renovar (otra caducidad) es delete + insert en UNA transacción (`#upsert`): ningún
             // instante sin la tupla, así que una membresía que transporta un deny se renueva sin ventana.
             atomicRenewal: true,
+            // Estrategia 2.5.0 · firma 4 (D15): `false` EXPLÍCITO — `database` es el driver ESTABLE de 2.5.0.
+            experimental: false,
         });
     }
     /**
@@ -367,6 +371,54 @@ export class DatabaseRelationsDriver {
         this.#assertObject(object);
         await this.#deleteTuple('removeDeny', subject, deniedRelationOf(relation), object, partition, options);
     }
+    /**
+     * **El techo de anidación de grupos de ESTE driver** (lote «antes de RC» · R1, decisión del dueño 2026-10-17 (5)):
+     * `database` no tiene techo técnico (la CTE deduplica y termina con ciclos), así que es `null` SALVO el opt-in
+     * explícito `database.enforceGroupDepth: true`, que aplica el `maxGroupDepth` de la config (obligatorio y numérico
+     * con el opt-in: lo valida `defineRelationsConfig` al arrancar).
+     */
+    async groupDepthLimit() {
+        return this.#groupDepthLimit();
+    }
+    #groupDepthLimit() {
+        const { maxGroupDepth, enforceGroupDepth } = assertGroupDepthSettings(this.#config.maxGroupDepth, this.#config.enforceGroupDepth, 'DatabaseRelationsDriver');
+        return enforceGroupDepth && typeof maxGroupDepth === 'number' ? maxGroupDepth : null;
+    }
+    /**
+     * **El gate de R1 en `database`** (opt-in): la arista `group:<parent>#member@group:<child>#member` que se va a escribir
+     * VIVA no puede cerrar un ciclo ni dejar un camino de grupos anidados más largo que el techo. El grafo se LEE POR EL
+     * MISMO CLIENTE QUE ESCRIBE (`trx`: la transacción del llamante con `{ transaction }`, o la interna de la escritura) —
+     * T-6 del tester: leído por la conexión del motor, un llamante que en UNA transacción escribe `A⊂B` y luego `B⊂C`
+     * pasaría las dos (la segunda no ve la primera, sin confirmar). Lo que esto NO cierra, declarado: dos transacciones
+     * CONCURRENTES que escriben cada una media cadena (cada una ve su foto, sin cerrojo) — la carrera entre procesos.
+     * Una sentencia por nivel del BFS (y por cada 500 grupos del nivel), con la caducidad ESTRICTA de la lectura.
+     */
+    async #assertGroupNesting(trx, operation, partitionKey, edge, now, limit) {
+        const neighbours = async (groups, column) => {
+            const out = [];
+            for (let i = 0; i < groups.length; i += 500) {
+                const chunk = groups.slice(i, i + 500);
+                const rows = await this.#sql(`${operation}.groupDepth`, () => this.#whereActive(trx
+                    .from(RELATIONS_TABLE)
+                    .where('partition_key', partitionKey)
+                    .where('object_type', GROUP_TYPE)
+                    .where('relation', GROUP_MEMBER)
+                    .where('subject_type', GROUP_TYPE)
+                    .where('subject_relation', GROUP_MEMBER)
+                    .whereIn(column, chunk), now).select({ child: 'subject_uuid', parent: 'object_uuid' }));
+                for (const row of rows)
+                    out.push({ child: row.child, parent: row.parent });
+            }
+            return out;
+        };
+        const verdict = await groupNestingVerdict(edge, limit, {
+            parentsOf: (groups) => neighbours(groups, 'subject_uuid'),
+            childrenOf: (groups) => neighbours(groups, 'object_uuid'),
+        });
+        if (verdict.kind !== 'ok') {
+            throw groupDepthLimitError(verdict, `group:${edge.parent}#member@group:${edge.child}#member`, limit);
+        }
+    }
     /** El check-then-delete-insert idempotente de `relate`/`deny` sobre la relación ALMACENADA. */
     async #upsert(operation, subject, relation, object, partition, requested, options) {
         const partitionKey = this.#keyOf(partition);
@@ -399,10 +451,21 @@ export class DatabaseRelationsDriver {
             // Los tres estados (invariante 10): omitido preserva la VIGENTE (una
             // caducada revive sin caducidad), null la quita, Date la fija.
             const expiresAt = resolveGrantExpiry(previous, requested, now);
+            // Idempotente (invariante 6): la misma caducidad no reescribe nada — y va ANTES del gate de R1: un `relate`
+            // repetido de una arista preexistente (sembrada antes de alpha.4 o con el gate apagado) sigue siendo un no-op.
+            if (current && sameInstant(previous, expiresAt))
+                return;
+            // R1 (opt-in en `database`): una arista de anidación que queda VIVA —nueva, renovada o revivida— pasa el gate,
+            // leyendo el grafo por ESTE `trx` (T-6). Una vencida no conecta nada (la misma regla que la lectura). Antes del
+            // DELETE: un 422 no deja la arista vieja borrada.
+            const limit = this.#groupDepthLimit();
+            if (limit !== null &&
+                isGroupNesting(subject, relation, object) &&
+                isActiveExpiry(expiresAt, now) &&
+                !plannedByReconcile(options, partition, { child: subject.object.id, parent: object.id })) {
+                await this.#assertGroupNesting(trx, operation, partitionKey, { child: subject.object.id, parent: object.id }, now, limit);
+            }
             if (current) {
-                // Idempotente (invariante 6): la misma caducidad no reescribe nada.
-                if (sameInstant(previous, expiresAt))
-                    return;
                 // **INSERT/DELETE-ONLY (decisión (c))**: cambiar la caducidad es
                 // BORRAR la fila e INSERTAR otra —nunca un UPDATE—; la fila nueva
                 // tiene otro `uuid`, que es lo que lo hace observable. Dentro de la
@@ -592,10 +655,12 @@ export class DatabaseRelationsDriver {
         }
         return { distinct, index, facts };
     }
-    async listObjects(subject, relation, objectType, partition, _page) {
+    async listObjects(subject, relation, objectType, partition) {
         assertRelationDeclared(this.#config, { type: objectType }, relation);
         assertPartition(partition);
         this.#assertId('el tipo de objeto', objectType, RELATION_ID_MAX);
+        // 7.4: sin página (un quinto argumento ≠ undefined ⇒ 500 con cero sentencias), después de F-05 y la partición.
+        assertNoListPage('listObjects', arguments[4], 'database');
         const partitionKey = this.#keyOf(partition);
         const s = this.#subjectColumns(subject, partitionKey);
         // Lote D · D-15: `listObjects` RESTA (la misma regla de corte que `check`, objeto a objeto).
@@ -630,14 +695,15 @@ export class DatabaseRelationsDriver {
             .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
         return { objects };
     }
-    async listSubjects(relation, object, partition, _page) {
+    async listSubjects(relation, object, partition) {
         assertRelationDeclared(this.#config, object, relation);
         assertPartition(partition);
         this.#assertObject(object);
-        return this.#directSubjects('listSubjects', relation, object, partition, _page);
+        assertNoListPage('listSubjects', arguments[3], 'database');
+        return this.#directSubjects('listSubjects', relation, object, partition);
     }
     /** Los sujetos DIRECTOS vigentes de UNA relación almacenada (`listSubjects`; `listDenies` con `denied_<rel>`). */
-    async #directSubjects(operation, relation, object, partition, _page) {
+    async #directSubjects(operation, relation, object, partition) {
         const partitionKey = this.#keyOf(partition);
         // DIRECTOS del relation EXACTO (invariante 7): ni transitivo (eso es
         // `membersOf`) ni derivado por includes. `usersetSubjects: true` ⇒ los
@@ -657,11 +723,12 @@ export class DatabaseRelationsDriver {
      * `listSubjects` sobre la relación almacenada `denied_<rel>`; no resta ni deriva—. Sobre CUALQUIER tipo declarado
      * (D8/R2-4 b: con el opt-in retirado, los denies vivos se siguen pudiendo listar y borrar).
      */
-    async listDenies(relation, object, partition, page) {
+    async listDenies(relation, object, partition) {
         assertRelationDeclared(this.#config, object, relation);
         assertPartition(partition);
         this.#assertObject(object);
-        return this.#directSubjects('listDenies', deniedRelationOf(relation), object, partition, page);
+        assertNoListPage('listDenies', arguments[3], 'database');
+        return this.#directSubjects('listDenies', deniedRelationOf(relation), object, partition);
     }
     /**
      * **`denyPhase` — ¿admite este driver escrituras de deny en el tipo?** (lote D · D2, R2-5): la fase del opt-in EN
@@ -679,12 +746,13 @@ export class DatabaseRelationsDriver {
      * directos): en un grupo con `member(g1#member, g2)`, `membersOf(g2)` trae a
      * los holders de g1 y `listSubjects(member, g2)` solo el userset `g1#member`.
      */
-    async membersOf(object, relation, partition, _page) {
+    async membersOf(object, relation, partition) {
         // Cierre-2 · 🟡 3: F-05 (par, ESTRICTA) también en `membersOf`, la octava
         // operación del puerto; antes solo `#assertObject` (gramática).
         assertRelationDeclared(this.#config, object, relation);
         assertPartition(partition);
         this.#assertObject(object);
+        assertNoListPage('membersOf', arguments[3], 'database');
         const partitionKey = this.#keyOf(partition);
         const relations = this.#expandDown(object.type, relation);
         const meta = this.#dialectMeta();
@@ -844,9 +912,12 @@ export class DatabaseRelationsDriver {
      */
     async enumerateRelations(partition, page) {
         assertPartition(partition);
+        // 7.4 (injerto 4, H2/H3): limit entero ≥ 1 y after = un uuid canónico (el cursor que ESTE driver emite) o 422,
+        // con cero sentencias; un limit por encima del techo se recorta en #enumerateRows.
+        const checked = assertEnumeratePage('enumerateRelations', page, 'uuid', 'database');
         const wanted = new Map();
         wanted.set(partitionKey(partition), partition);
-        return this.#enumerateRows('enumerateRelations', wanted, page);
+        return this.#enumerateRows('enumerateRelations', wanted, checked);
     }
     /**
      * **`enumerateRelationsMany` — K particiones en UNA consulta** (2.4.0-alpha.8
@@ -875,7 +946,8 @@ export class DatabaseRelationsDriver {
             if (!wanted.has(key))
                 wanted.set(key, partition);
         }
-        return this.#enumerateRows('enumerateRelationsMany', wanted, page);
+        const checked = assertEnumeratePage('enumerateRelationsMany', page, 'uuid', 'database');
+        return this.#enumerateRows('enumerateRelationsMany', wanted, checked);
     }
     /**
      * La consulta de `enumerateRelations`/`enumerateRelationsMany`: los hechos
@@ -887,7 +959,8 @@ export class DatabaseRelationsDriver {
     async #enumerateRows(operation, wanted, page) {
         const partitionKeys = [...wanted.keys()];
         const declaredTypes = [GROUP_TYPE, ...this.#config.objectTypes.map((t) => t.type)];
-        const limit = Math.max(1, Math.min(page?.limit ?? DEFAULT_ENUMERATE_LIMIT, MAX_ENUMERATE_LIMIT));
+        // La COPIA validada en la entrada (assertEnumeratePage), no la página del llamante: aquí solo el default y el RECORTE al techo, declarado en «Limits».
+        const limit = enumerateLimit(page);
         const after = page?.after;
         const rows = await this.#sql(operation, () => {
             let q = this.#connection()
@@ -959,4 +1032,3 @@ function rowsOf(result) {
     }
     return result?.rows ?? [];
 }
-//# sourceMappingURL=database_relations_driver.js.map