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

package/build/src/drivers/database_relations_driver.js

@@ -25,18 +25,26 @@
  */
 import db from '@adonisjs/lucid/services/db';
 import { v7 as uuidv7 } from 'uuid';
-import { AuthorizationConfigError, InvalidIdentityError, UnsupportedDialectError, UnsupportedOperationError, WriteConflictError, } from '../errors.js';
+import { AuthorizationBackendTimeoutError, AuthorizationConfigError, InvalidIdentityError, MembersOfDenyLimitError, UnsupportedDialectError, UnsupportedOperationError, WriteConflictError, } from '../errors.js';
 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 } from '../shared/backend_guard.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 } from '../relations/define_relations_config.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
+ * cada candidato se juzga con un `check` (una CTE por candidato). Pasada ⇒ 500 `E_AUTHZ_MEMBERS_DENY_LIMIT`, nunca una
+ * lista parcial. En «Limits» del README, atada a esta constante (`scope_depth.spec`).
+ */
+export const RELATIONS_MEMBERS_DENY_CHECK_MAX = 1_000;
 const RELATIONS_TABLE = 'authz_relations';
 /** Longitud máxima del id de un objeto/holder de relación (columna `varchar(64)`). */
 const RELATION_ID_MAX = 64;
@@ -52,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 = {
@@ -110,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;
@@ -125,6 +133,14 @@ export class DatabaseRelationsDriver {
             listObjectsTruncation: false,
             injectableClock: true,
             transactionalWrites: this.#transactionalWrites,
+            // Lote D · D1: el deny vive en la MISMA tabla (`relation = 'denied_<rel>'`) y TODA lectura lo honra SIEMPRE
+            // (D8: también en un tipo sin opt-in —una fila deny es un hecho—).
+            relationDenies: true,
+            // 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,
         });
     }
     /**
@@ -293,21 +309,30 @@ export class DatabaseRelationsDriver {
             b.where('subject_relation', relation);
     }
     /* ── Expansión de includes (un nivel, hacia ABAJO desde la relación) ──── */
+    /** `down*(R)` — desde el lote D, la función ÚNICA de la config (`relationsDown`), la misma que el doble y el oráculo. */
     #expandDown(objectType, relation) {
-        const out = new Set([relation]);
-        const type = this.#config.objectTypes.find((t) => t.type === objectType);
-        const queue = [relation];
-        while (queue.length) {
-            const current = queue.pop();
-            const def = type?.relations.find((r) => r.name === current);
-            for (const inc of def?.includes ?? []) {
-                if (!out.has(inc)) {
-                    out.add(inc);
-                    queue.push(inc);
-                }
-            }
+        return relationsDown(this.#config, objectType, relation);
+    }
+    /**
+     * **Lo que una lectura con deny tiene que traer para `R`** (lote D · D5/D8): los grants de `down*(R)` y los denies de
+     * `up*(down*(R))` (almacenados como `denied_<rel>`). SIEMPRE, también en un tipo sin opt-in (D8: una fila deny es un
+     * hecho; si el tipo retiró el opt-in con denies vivos, `database` sigue denegando). Sin filas `denied_*` la respuesta
+     * es la de 2.4.0-alpha.10 (el corte no tiene nada que cortar).
+     */
+    #readRelations(objectType, relation) {
+        return [...this.#expandDown(objectType, relation), ...deniableAbove(this.#config, objectType, relation).map(deniedRelationOf)];
+    }
+    /** Reparte las relaciones leídas de un objeto en grants y denies (nombre PÚBLICO). */
+    #split(relations) {
+        const allowed = new Set();
+        const denied = new Set();
+        for (const r of relations) {
+            if (r.startsWith(RELATION_DENY_PREFIX))
+                denied.add(r.slice(RELATION_DENY_PREFIX.length));
+            else
+                allowed.add(r);
         }
-        return [...out];
+        return { allowed, denied };
     }
     /* ── Escrituras ───────────────────────────────────────────────────────── */
     async relate(subject, relation, object, partition, options) {
@@ -321,14 +346,88 @@ export class DatabaseRelationsDriver {
         this.#assertId(`la relación de '${object.type}'`, relation, RELATION_ID_MAX);
         // R-15 (defensa en profundidad; el manager ya lo validó): los tres estados.
         assertExpiresAt(options?.expiresAt);
-        const requested = options?.expiresAt;
+        await this.#upsert('relate', subject, relation, object, partition, options?.expiresAt, options);
+    }
+    /**
+     * **`deny` = la tupla `denied_<rel>`, por el MISMO camino idempotente que `relate`** (lote D · D1): F-05 sobre el
+     * nombre PÚBLICO, la puerta de escritura del opt-in (fase `'write'`, D10), ni `group` ni `*`, y SIN caducidad (D3:
+     * `expiresAt` ⇒ 422; un deny escrito a mano con caducidad se rehace permanente). Por la transacción del llamante si
+     * llega (L-4, como `relate`).
+     */
+    async deny(subject, relation, object, partition, options) {
+        assertRelationDeclared(this.#config, object, relation);
+        assertRelationDenyable(this.#config, object, relation);
+        assertDenyNoExpiry(options);
+        assertPartition(partition);
+        this.#assertObject(object);
+        assertDenySubject(subject);
+        await this.#upsert('deny', subject, deniedRelationOf(relation), object, partition, null, options);
+    }
+    /** `removeDeny`: borra la tupla `denied_<rel>`. Sobre CUALQUIER tipo declarado (D8/R2-4 b). No-op si no está. */
+    async removeDeny(subject, relation, object, partition, options) {
+        assertRelationDeclared(this.#config, object, relation);
+        assertDenyNoExpiry(options);
+        assertPartition(partition);
+        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);
         const s = this.#subjectColumns(subject, partitionKey);
         const codec = this.#expiry;
         const now = this.#now();
         // L-4: por la transacción del llamante si llegó (`#writer`, juzgada AQUÍ,
         // después de F-05 y la gramática y antes de la primera sentencia).
-        const { client, external } = this.#writer('relate', options);
+        const { client, external } = this.#writer(operation, options);
         // El check-then-delete-insert idempotente. Con transacción EXTERNA corre
         // tal cual sobre ella (el trigger de partición dispara en ESE INSERT,
         // dentro de la trx del consumidor; NUNCA se abre una interna: la fila
@@ -336,7 +435,7 @@ export class DatabaseRelationsDriver {
         // una transacción INTERNA de la conexión del driver (la atomicidad
         // trigger+insert de 4-3). Cada sentencia lleva su deadline (`#sql`).
         const write = async (trx) => {
-            const existing = await this.#sql('relate.select', () => trx
+            const existing = await this.#sql(`${operation}.select`, () => trx
                 .from(RELATIONS_TABLE)
                 .where('partition_key', partitionKey)
                 .where('object_type', object.type)
@@ -352,17 +451,28 @@ 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
                 // trx del llamante, el rollback devuelve la fila (y la caducidad) VIEJA.
-                await this.#sql('relate.delete', () => trx.from(RELATIONS_TABLE).where('uuid', current.uuid).delete());
+                await this.#sql(`${operation}.delete`, () => trx.from(RELATIONS_TABLE).where('uuid', current.uuid).delete());
             }
-            await this.#sql('relate.insert', () => trx.table(RELATIONS_TABLE).insert({
+            await this.#sql(`${operation}.insert`, () => trx.table(RELATIONS_TABLE).insert({
                 uuid: uuidv7(),
                 partition_key: partitionKey,
                 object_type: object.type,
@@ -383,11 +493,11 @@ export class DatabaseRelationsDriver {
                 await write(client);
             }
             catch (error) {
-                this.#poisoned('relate', error);
+                this.#poisoned(operation, error);
             }
             return;
         }
-        await this.#sql('relate', () => client.transaction(write));
+        await this.#sql(operation, () => client.transaction(write));
     }
     async unrelate(subject, relation, object, partition, options) {
         // L-0 · F-05 también al RETIRAR (paridad con `openfga`).
@@ -395,11 +505,15 @@ export class DatabaseRelationsDriver {
         assertPartition(partition);
         this.#assertObject(object);
         this.#assertId(`la relación de '${object.type}'`, relation, RELATION_ID_MAX);
+        await this.#deleteTuple('unrelate', subject, relation, object, partition, options);
+    }
+    /** El DELETE de UNA tupla (relación ALMACENADA): `unrelate` y `removeDeny`. Un `unrelate` nunca toca `denied_*` (D-04). */
+    async #deleteTuple(operation, subject, relation, object, partition, options) {
         const partitionKey = this.#keyOf(partition);
         const s = this.#subjectColumns(subject, partitionKey);
-        const { client, external } = this.#writer('unrelate', options);
+        const { client, external } = this.#writer(operation, options);
         try {
-            await this.#sql('unrelate', () => client
+            await this.#sql(operation, () => client
                 .from(RELATIONS_TABLE)
                 .where('partition_key', partitionKey)
                 .where('object_type', object.type)
@@ -412,7 +526,7 @@ export class DatabaseRelationsDriver {
         }
         catch (error) {
             if (external)
-                this.#poisoned('unrelate', error);
+                this.#poisoned(operation, error);
             throw error;
         }
     }
@@ -433,21 +547,25 @@ export class DatabaseRelationsDriver {
         this.#assertObject(object);
         const partitionKey = this.#keyOf(partition);
         const s = this.#subjectColumns(subject, partitionKey);
-        const relations = this.#expandDown(object.type, relation);
+        // Lote D · D5: los grants de `down*(R)` Y los denies de `up*(down*(R))`, en UNA consulta sobre la misma CTE
+        // `principal` (el deny también viaja por `group#member`, anidado, y una membresía caducada no lo transporta);
+        // el CORTE se decide en `cutPathAllows`, la función ÚNICA de la config.
+        const relations = this.#readRelations(object.type, relation);
         const meta = this.#dialectMeta();
         const q = (name) => `${meta.quote}${name}${meta.quote}`;
         const at = this.#expiry.bind(this.#now());
         const { cte, bindings: cteBindings } = this.#principalCte(meta, q, s, partitionKey, at);
         const relPlaceholders = relations.map(() => '?').join(', ');
         const sql = cte +
-            ` SELECT ${meta.hint}1 FROM ${q(RELATIONS_TABLE)} r ` +
+            ` SELECT ${meta.hint}DISTINCT r.${q('relation')} AS ${q('relation')} FROM ${q(RELATIONS_TABLE)} r ` +
             `JOIN principal p ON r.${q('subject_type')} = p.p_type AND r.${q('subject_uuid')} = p.p_uuid ` +
             `AND COALESCE(r.${q('subject_relation')}, '') = p.p_rel ` +
             `WHERE r.${q('partition_key')} = ? AND r.${q('object_type')} = ? AND r.${q('object_uuid')} = ? ` +
-            `AND r.${q('relation')} IN (${relPlaceholders}) AND ${this.#activeSql(q, 'r')} LIMIT 1`;
+            `AND r.${q('relation')} IN (${relPlaceholders}) AND ${this.#activeSql(q, 'r')}`;
         const bindings = [...cteBindings, partitionKey, object.type, object.id, ...relations, at];
         const rows = rowsOf(await this.#raw('check', sql, bindings));
-        return rows.length > 0;
+        const { allowed, denied } = this.#split(rows.map((row) => String(row.relation)));
+        return cutPathAllows(this.#config, object.type, relation, allowed, denied);
     }
     /**
      * **`checkMany` = UNA consulta** (plan 2.5 · lote A, P4-8): la MISMA CTE
@@ -460,7 +578,35 @@ export class DatabaseRelationsDriver {
      * de la consulta (defensa en profundidad: el manager ya lo hizo).
      */
     async checkMany(subject, relation, objects, partition) {
-        assertCheckManyObjects(objects);
+        const { distinct, index, facts } = await this.#readMany('checkMany', subject, relation, objects, partition);
+        const answers = distinct.map((object) => {
+            const { allowed, denied } = this.#split(facts.get(`${object.type}:${object.id}`) ?? []);
+            return cutPathAllows(this.#config, object.type, relation, allowed, denied);
+        });
+        return expandByPosition(index, answers);
+    }
+    /**
+     * **`decideMany` = la consulta de `checkMany`** (lote D · D9): los grants de `down*(R)` y los denies de
+     * `up*(down*(R))` de cada objeto distinto, con UN `now` y en UNA consulta, y la regla AMPLIA de `decideFrom` (la
+     * misma función que el doble y `openfga` cuando alinea su `batchCheck`). Tope, `[]` y F-05 por ítem como `checkMany`.
+     */
+    async decideMany(subject, relation, objects, partition) {
+        const { distinct, index, facts } = await this.#readMany('decideMany', subject, relation, objects, partition);
+        const answers = distinct.map((object) => {
+            const { allowed, denied } = this.#split(facts.get(`${object.type}:${object.id}`) ?? []);
+            return decideFrom(this.#config, object.type, relation, allowed, denied);
+        });
+        return index.map((at) => answers[at]);
+    }
+    /**
+     * **`checkMany`/`decideMany` = UNA consulta** (plan 2.5 · lote A, P4-8; lote D): la MISMA CTE `principal` de
+     * `check` (el sujeto y sus grupos, transitivo, solo vigentes) y un `SELECT DISTINCT object_type, object_uuid,
+     * relation` sobre los hechos de la partición que casan con CUALQUIER objeto distinto del lote —agrupados por TIPO,
+     * porque los `includes` se expanden por tipo— con grants Y denies (`#readRelations`), con UN solo `now` para todo
+     * el lote. F-05 y la gramática del id, POR ÍTEM, antes de la consulta (defensa en profundidad).
+     */
+    async #readMany(operation, subject, relation, objects, partition) {
+        assertCheckManyObjects(objects, operation);
         for (const object of objects) {
             assertRelationDeclared(this.#config, object, relation);
             this.#assertObject(object);
@@ -473,7 +619,7 @@ export class DatabaseRelationsDriver {
         const q = (name) => `${meta.quote}${name}${meta.quote}`;
         const at = this.#expiry.bind(this.#now());
         const { cte, bindings: cteBindings } = this.#principalCte(meta, q, s, partitionKey, at);
-        // Un grupo por TIPO de objeto: `(object_type = ? AND object_uuid IN (…) AND relation IN (<expandDown(tipo)>))`.
+        // Un grupo por TIPO de objeto: `(object_type = ? AND object_uuid IN (…) AND relation IN (<grants y denies del tipo>))`.
         const byType = new Map();
         for (const object of distinct) {
             const ids = byType.get(object.type) ?? [];
@@ -483,7 +629,7 @@ export class DatabaseRelationsDriver {
         const groups = [];
         const groupBindings = [];
         for (const [type, ids] of byType) {
-            const relations = this.#expandDown(type, relation);
+            const relations = this.#readRelations(type, relation);
             groups.push(`(r.${q('object_type')} = ? AND r.${q('object_uuid')} IN (${ids.map(() => '?').join(', ')}) ` +
                 `AND r.${q('relation')} IN (${relations.map(() => '?').join(', ')}))`);
             groupBindings.push(type, ...ids, ...relations);
@@ -492,52 +638,78 @@ export class DatabaseRelationsDriver {
             // ⚪ A8 (auditor del lote A): el hint de MySQL va ANTES de DISTINCT (como en
             // `listObjects`); detrás, el optimizador lo ignora y a > 1000 niveles de
             // anidación `checkMany` era `ERROR 3636` (503) donde `check` respondía.
-            ` SELECT ${meta.hint}DISTINCT r.${q('object_type')} AS object_type, r.${q('object_uuid')} AS object_uuid ` +
+            ` SELECT ${meta.hint}DISTINCT r.${q('object_type')} AS object_type, r.${q('object_uuid')} AS object_uuid, ` +
+            `r.${q('relation')} AS relation ` +
             `FROM ${q(RELATIONS_TABLE)} r ` +
             `JOIN principal p ON r.${q('subject_type')} = p.p_type AND r.${q('subject_uuid')} = p.p_uuid ` +
             `AND COALESCE(r.${q('subject_relation')}, '') = p.p_rel ` +
             `WHERE r.${q('partition_key')} = ? AND (${groups.join(' OR ')}) AND ${this.#activeSql(q, 'r')}`;
         const bindings = [...cteBindings, partitionKey, ...groupBindings, at];
-        const rows = rowsOf(await this.#raw('checkMany', sql, bindings));
-        const granted = new Set(rows.map((row) => `${row.object_type}:${row.object_uuid}`));
-        const answers = distinct.map((object) => granted.has(`${object.type}:${object.id}`));
-        return expandByPosition(index, answers);
+        const rows = rowsOf(await this.#raw(operation, sql, bindings));
+        const facts = new Map();
+        for (const row of rows) {
+            const key = `${row.object_type}:${row.object_uuid}`;
+            const list = facts.get(key) ?? [];
+            list.push(String(row.relation));
+            facts.set(key, list);
+        }
+        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);
-        const relations = this.#expandDown(objectType, relation);
+        // Lote D · D-15: `listObjects` RESTA (la misma regla de corte que `check`, objeto a objeto).
+        const relations = this.#readRelations(objectType, relation);
         const meta = this.#dialectMeta();
         const q = (name) => `${meta.quote}${name}${meta.quote}`;
         const at = this.#expiry.bind(this.#now());
         const { cte, bindings: cteBindings } = this.#principalCte(meta, q, s, partitionKey, at);
         const relPlaceholders = relations.map(() => '?').join(', ');
         const sql = cte +
-            ` SELECT ${meta.hint}DISTINCT r.${q('object_uuid')} AS ${q('object_uuid')} FROM ${q(RELATIONS_TABLE)} r ` +
+            ` SELECT ${meta.hint}DISTINCT r.${q('object_uuid')} AS ${q('object_uuid')}, r.${q('relation')} AS ${q('relation')} ` +
+            `FROM ${q(RELATIONS_TABLE)} r ` +
             `JOIN principal p ON r.${q('subject_type')} = p.p_type AND r.${q('subject_uuid')} = p.p_uuid ` +
             `AND COALESCE(r.${q('subject_relation')}, '') = p.p_rel ` +
             `WHERE r.${q('partition_key')} = ? AND r.${q('object_type')} = ? ` +
             `AND r.${q('relation')} IN (${relPlaceholders}) AND ${this.#activeSql(q, 'r')}`;
         const bindings = [...cteBindings, partitionKey, objectType, ...relations, at];
         const rows = rowsOf(await this.#raw('listObjects', sql, bindings));
-        const objects = rows
-            .map((row) => ({ type: objectType, id: String(row.object_uuid) }))
+        const byObject = new Map();
+        for (const row of rows) {
+            const id = String(row.object_uuid);
+            const list = byObject.get(id) ?? [];
+            list.push(String(row.relation));
+            byObject.set(id, list);
+        }
+        const objects = [...byObject]
+            .filter(([, rels]) => {
+            const { allowed, denied } = this.#split(rels);
+            return cutPathAllows(this.#config, objectType, relation, allowed, denied);
+        })
+            .map(([id]) => ({ type: objectType, id }))
             .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);
+        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) {
         const partitionKey = this.#keyOf(partition);
         // DIRECTOS del relation EXACTO (invariante 7): ni transitivo (eso es
         // `membersOf`) ni derivado por includes. `usersetSubjects: true` ⇒ los
         // usersets (`group#member`) salen junto con los holders. Solo VIGENTES (R-15).
         const now = this.#now();
-        const rows = await this.#sql('listSubjects', () => this.#whereActive(this.#connection()
+        const rows = await this.#sql(operation, () => this.#whereActive(this.#connection()
             .from(RELATIONS_TABLE)
             .where('partition_key', partitionKey)
             .where('object_type', object.type)
@@ -546,6 +718,27 @@ export class DatabaseRelationsDriver {
         const subjects = rows.map((row) => this.#rowToSubject(row));
         return { subjects };
     }
+    /**
+     * **`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).
+     */
+    async listDenies(relation, object, partition) {
+        assertRelationDeclared(this.#config, object, relation);
+        assertPartition(partition);
+        this.#assertObject(object);
+        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
+     * LA CONFIG DE ESTE DRIVER (`'write'`, `'read'` o `null`). F-05 estricto del par (422), cero sentencias: es
+     * configuración. La llama `reconcileRelations` en la fase de plan cuando el origen trae denies.
+     */
+    async denyPhase(object, relation) {
+        assertRelationDeclared(this.#config, object, relation);
+        return denyPhaseOf(this.#config, object.type) ?? null;
+    }
     /**
      * Membresía TRANSITIVA de un objeto-grupo: todos los HOLDERS que son `member`
      * directa o a través de grupos anidados (usersets `group#member`). CTE
@@ -553,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();
@@ -604,7 +798,45 @@ export class DatabaseRelationsDriver {
             partitionKey, at,
         ];
         const rows = rowsOf(await this.#raw('membersOf', sql, bindings));
-        const subjects = rows.map((row) => ({ type: String(row.subject_type), uuid: String(row.subject_uuid) }));
+        const candidates = rows.map((row) => ({ type: String(row.subject_type), uuid: String(row.subject_uuid) }));
+        // **Lote D · `membersOf` RESTA** (juez ronda 2: «listObjects y membersOf restan»; D8: siempre, con o sin opt-in).
+        // Si el objeto tiene alguna fila `denied_*` vigente, cada candidato se juzga con `check` —el MISMO corte de camino
+        // que el resto de lecturas, un `check` por candidato—; sin filas deny, cero consultas de más (la respuesta y el coste
+        // de 2.4.0-alpha.10). Coste declarado: O(miembros) consultas cuando el objeto tiene denies.
+        const denied = await this.#sql('membersOf.denies', () => this.#whereActive(this.#connection()
+            .from(RELATIONS_TABLE)
+            .where('partition_key', partitionKey)
+            .where('object_type', object.type)
+            .where('object_uuid', object.id)
+            .whereIn('relation', deniableAbove(this.#config, object.type, relation).map(deniedRelationOf)), this.#now())
+            .select('uuid')
+            .limit(1));
+        if (denied.length === 0)
+            return { subjects: candidates };
+        // **Cierre 1 de D1 · 🟡 4 del auditor**: con deny, N `check` en serie sin cota ni deadline total era una
+        // amplificación barata para quien puede escribir un deny (disponibilidad, no concesión). Cota DECLARADA
+        // (`RELATIONS_MEMBERS_DENY_CHECK_MAX`, «Limits» del README) ⇒ 500 ANTES del primer `check`, nunca una lista parcial;
+        // y deadline TOTAL sobre el bucle (`timeoutMs` del driver) ⇒ 503 `E_AUTHZ_BACKEND_TIMEOUT`, el bucle se para.
+        if (candidates.length > RELATIONS_MEMBERS_DENY_CHECK_MAX) {
+            throw new MembersOfDenyLimitError(`membersOf(${object.type}, '${relation}'): el objeto tiene un deny vigente y ${candidates.length} candidatos; con deny ` +
+                `cada candidato se juzga con un check y la cota es ${RELATIONS_MEMBERS_DENY_CHECK_MAX} ` +
+                `(RELATIONS_MEMBERS_DENY_CHECK_MAX). No se devuelve una lista parcial: pregunta check por sujeto, o retira el deny.`);
+        }
+        let expired = false;
+        const loop = (async () => {
+            const subjects = [];
+            for (const candidate of candidates) {
+                if (expired)
+                    break;
+                if (await this.check(candidate, relation, object, partition))
+                    subjects.push(candidate);
+            }
+            return subjects;
+        })();
+        const subjects = await withDeadline(loop, this.#timeoutMs, () => {
+            expired = true;
+            return new AuthorizationBackendTimeoutError('database-relations', 'membersOf', this.#timeoutMs);
+        });
         return { subjects };
     }
     /* ── Purga (invariante 11): el DELETE demuestra el cero ───────────────── */
@@ -680,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
@@ -711,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
@@ -723,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()
@@ -740,7 +977,9 @@ export class DatabaseRelationsDriver {
         const pageRows = hasMore ? rows.slice(0, limit) : rows;
         const tuples = pageRows.map((row) => ({
             subject: this.#rowToSubject(row),
-            relation: String(row.relation),
+            // Lote D · D2: `denied_<rel>` sale como `{ relation: <rel>, kind: 'deny' }` (punto de paso único,
+            // `storedRelationKind`); hasta D2 salía la relación almacenada y el reconcile la contaba como no declarada.
+            ...storedRelationKind(String(row.relation)),
             object: { type: String(row.object_type), id: String(row.object_uuid) },
             // La partición canónica PEDIDA: el barrido de ortografías ya la unificó.
             partition: wanted.get(String(row.partition_key)),
@@ -793,4 +1032,3 @@ function rowsOf(result) {
     }
     return result?.rows ?? [];
 }
-//# sourceMappingURL=database_relations_driver.js.map