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

package/build/src/drivers/openfga_relations_driver.js

@@ -32,20 +32,35 @@
  * del SDK escapa (todo va por `#guard`, que clasifica a 503/timeout).
  */
 import { OpenFgaClient, ConsistencyPreference, ClientWriteRequestOnMissingDeletes, ClientWriteRequestOnDuplicateWrites, } from '@openfga/sdk';
-import { AuthorizationBackendError, AuthorizationBackendTimeoutError, AuthorizationConfigError, InvalidIdentityError, PurgeIncompleteError, UnsupportedOperationError, markPartialWrite, } from '../errors.js';
+import { AuthorizationBackendError, AuthorizationBackendTimeoutError, AuthorizationConfigError, InvalidIdentityError, PurgeIncompleteError, RenewalRacedError, RenewalUnsafeError, UnsupportedOperationError, markPartialWrite, } from '../errors.js';
 import { assertPartition, assertSubject, assertRelationId, assertExpiresAt, partitionKey } from '../identity.js';
 import { isClock, systemClock } from '../clock.js';
-import { resolveGrantExpiry, sameInstant, toExpiryDate } from '../expiry.js';
+import { isActiveExpiry, resolveGrantExpiry, sameInstant, toExpiryDate } from '../expiry.js';
 import { isRelUserset } from '../types.js';
 import { alignBatchResults } from './openfga_driver.js';
-import { FGA_MAX_BATCH_CHECK } from './openfga_facts.js';
+import { FGA_MAX_BATCH_CHECK, canonicalRewrite, factsRelationRewrites } from './openfga_facts.js';
 import { assertCheckManyObjects, distinctObjects, expandByPosition } from '../relations/check_many.js';
 import { assertFgaObjectId, FACTS_EXPIRY_CONDITION, FACTS_GROUP_TYPE, } from './openfga_facts.js';
-import { assertRelationDeclared, assertObjectTypeDeclared } from '../relations/define_relations_config.js';
-import { isTimeoutLike, withDeadline } from '../shared/backend_guard.js';
+import { assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject, assertRelationDenyable, assertDenySubject, assertDenyNoExpiry, denyPhaseOf, deniedRelationOf, storedRelationKind, hasDenyTypes, relationsDown, RELATION_DENY_PREFIX, RELATION_USERSET_RELATION, RELATION_USERSET_TYPE, } from '../relations/define_relations_config.js';
+import { relationDeleteOrder, relationOrderClass } from '../relations/tuple_order.js';
+import { isServerWriteLimit, isTimeoutLike, withDeadline } from '../shared/backend_guard.js';
 export const DEFAULT_TIMEOUT_MS = 5_000;
-/** Tope de operaciones por `Write` en FGA (`exceeded_entity_limit` a partir de 100). */
-const WRITE_BATCH_SIZE = 100;
+/**
+ * **Tope de operaciones por `Write` en FGA** — `--max-tuples-per-write` del servidor, default 100. MEDIDO en v1.19.0
+ * (`openfga-dev`, lote D · cierre 1 de D1): 100 deletes en un `Write` entran; 101 —o 50 writes + 51 deletes— es 400
+ * «The number of write operations exceeds the allowed limit of 100» y NO se aplica nada (el `Write` es transaccional).
+ * Es también la frontera de la purga atómica (`#purgeByFilters`): una purga que cabe aquí es UN `Write`, sin estado
+ * intermedio; con más membresías de grupo que esto, el residuo es una fila DECLARADA (README, «Deny on relations»).
+ * **Requisito del despliegue: `--max-tuples-per-write` ≥ 100** (README, «Limits»). Un servidor con el tope MÁS BAJO
+ * responde 400 `exceeded_entity_limit` al primer `Write` que lo pase, y ése puede no ser el primero de la purga (con
+ * tope 50 y `[3 allows][60 membresías][40 denies]` el `Write` de 3 ya se aplicó): el driver lo dice como **500
+ * `E_AUTHZ_CONFIG`** nombrando el requisito —no como un 503 que parece transitorio: repetida, la purga vuelve a pedir
+ * un `Write` de más de lo que el servidor admite y no termina nunca— y, si ya borró algo, **marcado como escritura
+ * parcial** (`indeterminate: true`, invariante 13). Cierre 2 de D1 · ⚪ N3 del auditor (la letra anterior, «503 sin
+ * haber borrado nada», era falsa con varios `Write`). Uno con el tope más alto no cambia nada (el driver sigue partiendo
+ * en 100). Sin opción para bajarlo: la cota es del servidor y el remedio es su arranque.
+ */
+export const RELATIONS_PURGE_WRITE_MAX = 100;
 /** Tamaño de página de `Read` (máximo del servidor). */
 const READ_PAGE_SIZE = 100;
 /**
@@ -65,6 +80,40 @@ const MAX_READ_PAGES = 10_000;
  * truncado FALSO (el servidor devolvió todo); por encima, se perdería el corte.
  */
 const DEFAULT_LIST_OBJECTS_MAX = 1_000;
+/**
+ * **B4 (plan 2.5 · lote B): el corte EFECTIVO de `ListObjects` del servidor**.
+ * Pasado, el servidor devuelve lo que llevaba resuelto con 200 y SIN señal
+ * (analista M4, medido): la segunda forma —además del tope— de una lista
+ * parcial muda. El driver mide cada llamada con un reloj MONÓTONO y, si duró
+ * ≥ `LIST_OBJECTS_DEADLINE_RATIO` × el corte configurado, señala
+ * `truncated: true` (la MISMA señal que el tope). **El corte efectivo es el
+ * MENOR de dos** (cierre 2 del lote B · 🟠 N1, medido por el auditor contra
+ * OpenFGA v1.19.0): `--listObjects-deadline` (3 s por defecto) si ≠ 0 y, si es
+ * 0, `--request-timeout` (3 s por defecto) — `list_objects.go` solo pone su
+ * propio timeout cuando el deadline ≠ 0 y, si no, hereda el ctx del
+ * interceptor de `--request-timeout`, que corta igual con un 200 mudo (con
+ * `--request-timeout=30ms`: `200 objects 0 of 40000`). «Sin deadline» no
+ * existe: el servidor siempre corta en alguno. **El corte efectivo es el MENOR
+ * de `--listObjects-deadline` (si ≠ 0), `--request-timeout` y, por HTTP,
+ * `--http-upstream-timeout` (5 s por defecto en el gateway)** (⚪ N10, cierre 3
+ * del lote B: el tercer corte, no medido para `ListObjects`, también cuenta);
+ * declara ESE menor en `listObjectsDeadlineMs` — y nunca por encima del
+ * `timeoutMs` del cliente: la señal tiene que poder saltar antes de que el
+ * cliente corte (500 al construir si no).
+ */
+export const DEFAULT_LIST_OBJECTS_DEADLINE_MS = 3_000;
+export const LIST_OBJECTS_DEADLINE_RATIO = 0.9;
+/**
+ * **SOLO TESTS** (⚪ 9 del cierre 1 del lote B): la clave —un símbolo— bajo la que
+ * un test inyecta la fuente del reloj MONÓTONO en ms con el que `#listObjectsPage`
+ * mide cada `ListObjects` (default `performance.now`). Fuera del tipo publicado
+ * `OpenFgaRelationsDriverOptions` y NO re-exportada por `/openfga`: un
+ * `monotonic: () => 0` en producción apagaría la señal del deadline, y una opción
+ * con ese poder no viaja en la superficie pública. No es el reloj de pared
+ * (`now`, que decide la caducidad): una ventana se mide con un reloj que no
+ * salta (2E · H3), y así el caso del deadline corre sin `sleep`.
+ */
+export const MONOTONIC_CLOCK = Symbol('OpenFgaRelationsDriver.monotonic');
 /**
  * Ignora duplicados en el `Write` de una tupla que NO estaba (idempotencia de
  * dos `relate` concurrentes idénticos). Cambiar la caducidad de una que SÍ
@@ -98,7 +147,9 @@ export class OpenFgaRelationsDriver {
      *    y devuelve SOLO las tuplas de relación de la partición (tipo declarado o
      *    `group`), descartando las de `facts` (scope/role/role_binding).
      *  - `listObjectsTruncation: true`: `ListObjects` trunca al tope del servidor
-     *    y este driver lo SEÑALA (medido contra el `:8103` de tope 3).
+     *    y este driver lo SEÑALA (medido contra el `:8103` de tope 3) — y desde
+     *    B4 (plan 2.5) también cuando la llamada roza el DEADLINE del servidor
+     *    (≥ 0,9 × `listObjectsDeadlineMs`), la otra forma de lista parcial muda.
      *  - `injectableClock: true` (R-15): `withClock(now)` fija el reloj que viaja
      *    como `current_time` y filtra `listSubjects`, como el driver de roles.
      */
@@ -110,6 +161,13 @@ export class OpenFgaRelationsDriver {
         enumerateRelations: true,
         listObjectsTruncation: true,
         injectableClock: true,
+        // Lote D · D1: el deny es la relación `denied_<rel>` del modelo fusionado (`X = … but not denied_X`); el corte lo
+        // evalúa el SERVIDOR en `check`/`batchCheck`/`ListObjects` (una lista cortada es un subconjunto: fail-closed).
+        relationDenies: true,
+        // Cierre 2 de D2 · 🟠 N1: `false` EXPLÍCITO — FGA no reemplaza la misma clave en un `Write` (M5): `relate` renueva
+        // con DOS (delete, write). Por eso NIEGA renovar una membresía que transporta un deny (409
+        // `E_AUTHZ_RENEWAL_UNSAFE`, cero escrituras) y marca parcial la renovación permitida cuyo 2.º `Write` falla.
+        atomicRenewal: false,
         // L-2/L-5 (panel `{trx}`, (C)): `false` EXPLÍCITO, y no puede ser otra
         // cosa — una tupla no entra en una transacción SQL: el store es otro
         // servicio y no hay 2PC, así que «los dos o ninguno» con la transacción
@@ -135,7 +193,15 @@ export class OpenFgaRelationsDriver {
     #timeoutMs;
     #consistency;
     #listObjectsMax;
+    #listObjectsDeadlineMs;
+    #monotonic;
     #logger;
+    /**
+     * **Las relaciones `denied_*` que declara el modelo que sirve este driver** (lote D · D-31): se lee UNA vez por
+     * proceso (`readAuthorizationModel` del `modelId` fijado —D14 lo exige con un tipo con deny—) y se comparte con
+     * las vistas `withClock`. Un fallo al leerla no se memoriza (503 y se reintenta en la siguiente).
+     */
+    #modelMemo = {};
     diagnostics = { unparseableTuples: 0 };
     constructor(config, options) {
         this.#config = config;
@@ -149,7 +215,59 @@ export class OpenFgaRelationsDriver {
                 ? ConsistencyPreference.MinimizeLatency
                 : ConsistencyPreference.HigherConsistency;
         this.#listObjectsMax = options.listObjectsMaxResults ?? DEFAULT_LIST_OBJECTS_MAX;
+        const deadline = options.listObjectsDeadlineMs ?? DEFAULT_LIST_OBJECTS_DEADLINE_MS;
+        // 🟠 N1 (cierre 2 del lote B): `Infinity` se RETIRA. Con `--listObjects-deadline=0`
+        // el `--request-timeout` del servidor sigue cortando con un 200 mudo
+        // (medido, v1.19.0), así que «sin deadline» era una receta para la lista
+        // parcial muda que B4 impide. Solo un entero > 0: el corte efectivo.
+        if (!(Number.isInteger(deadline) && deadline > 0)) {
+            throw new AuthorizationConfigError(`OpenFgaRelationsDriver: listObjectsDeadlineMs debe ser un entero > 0 en ms: el corte EFECTIVO de ListObjects ` +
+                `de tu servidor, que es --listObjects-deadline si no es 0 y, si es 0, --request-timeout (3 s por defecto; ` +
+                `medido en OpenFGA v1.19.0: con el deadline a 0 el request-timeout corta igual con un 200 mudo). El servidor ` +
+                `siempre corta en alguno de los dos; declara el menor. No hay «sin deadline» (Infinity ya no se admite) ` +
+                `(llegó ${String(options.listObjectsDeadlineMs)}); default ${DEFAULT_LIST_OBJECTS_DEADLINE_MS}.`);
+        }
+        // ⚪ N10 (cierre 3 del lote B): la señal tiene que poder SALTAR antes de que
+        // el cliente corte. Un deadline declarado por encima del `timeoutMs` del
+        // cliente (5 s por defecto) nunca alcanza su umbral 0,9 × D —el cliente
+        // aborta con 503 antes— y, si el servidor corta ANTES que D, la lista muda
+        // pasa como completa (`Number.MAX_SAFE_INTEGER` era «sin deadline» con otro
+        // nombre y pasaba `Number.isInteger`). Guarda por construcción, sin tope
+        // arbitrario: D ≤ timeoutMs del cliente, o 500.
+        if (deadline > this.#timeoutMs) {
+            throw new AuthorizationConfigError(`OpenFgaRelationsDriver: listObjectsDeadlineMs (${deadline}) no puede ser mayor que el timeoutMs del cliente ` +
+                `(${this.#timeoutMs}): la señal tiene que poder saltar antes de que el cliente corte. Con un deadline por encima ` +
+                `del timeout el umbral 0,9 × listObjectsDeadlineMs nunca se alcanza (el cliente aborta con 503 antes) y, si el ` +
+                `servidor corta antes, la lista parcial muda pasa como completa. Declara el corte EFECTIVO del servidor —el MENOR ` +
+                `de --listObjects-deadline (si ≠ 0), --request-timeout y, por HTTP, --http-upstream-timeout— y un timeoutMs ≥ a él.`);
+        }
+        this.#listObjectsDeadlineMs = deadline;
+        // ⚪ 9 (cierre 1 del lote B): el reloj monótono inyectable SOLO entra por el
+        // símbolo (no está en el tipo publicado); la clave de texto `monotonic` de
+        // alpha.2 ya no gobierna nada y se rechaza (L5: una opción inerte no cae en
+        // silencio en el default).
+        if (options.monotonic !== undefined) {
+            throw new AuthorizationConfigError(`OpenFgaRelationsDriver: 'monotonic' no es una opción pública (era SOLO TESTS); el reloj monótono se inyecta ` +
+                `por el símbolo MONOTONIC_CLOCK del módulo del driver, que no se exporta por '/openfga'.`);
+        }
+        const monotonic = options[MONOTONIC_CLOCK];
+        if (monotonic !== undefined && typeof monotonic !== 'function') {
+            throw new AuthorizationConfigError(`OpenFgaRelationsDriver: [MONOTONIC_CLOCK] debe ser una función () => number (llegó ${typeof monotonic})`);
+        }
+        this.#monotonic = monotonic ?? (() => performance.now());
         this.#logger = options.logger ?? console;
+        // **D14** (decisión del dueño 2026-10-14; auditor R2-2): con algún tipo con opt-in del deny (en cualquier fase), el
+        // `modelId` FIJADO es obligatorio. Sin él cada `Check` evalúa contra el ÚLTIMO modelo del store, y un
+        // `openfga:provision` desde un proceso viejo (sin `denied_*`) haría que este pod concediera sobre objetos denegados
+        // sin enterarse; con él, la guarda D-31 lee ESE modelo una vez y es 500 si no declara el deny.
+        if (hasDenyTypes(config) && !options.modelId) {
+            throw new AuthorizationConfigError(`OpenFgaRelationsDriver: la config de relaciones declara deny en ${config.objectTypes
+                .filter((t) => t.deny !== undefined)
+                .map((t) => `'${t.type}' (${t.deny})`)
+                .join(', ')} y el driver no tiene modelId fijado (D14). Con deny activo cada pod tiene que evaluar contra un modelo ` +
+                `CONOCIDO que declare denied_<rel>: publica el modelo (openfga:provision), fija OPENFGA_MODEL_ID en TODA la flota ` +
+                `y despliega. Sin el pin, un modelo republicado sin denied_* haría conceder sobre objetos denegados.`);
+        }
         this.client = new OpenFgaClient({
             apiUrl: options.apiUrl,
             storeId: options.storeId,
@@ -171,6 +289,8 @@ export class OpenFgaRelationsDriver {
         }
         const view = new OpenFgaRelationsDriver(this.#config, { ...this.#options, now });
         view.client = this.client;
+        // La guarda D-31 es del PROCESO: la vista comparte la lectura del modelo.
+        view.#modelMemo = this.#modelMemo;
         return view;
     }
     /** El `context` de todo `Check`/`ListObjects`: la condición `not_expired` se evalúa contra este instante (un `now` por operación). */
@@ -216,6 +336,146 @@ export class OpenFgaRelationsDriver {
             throw fail(error);
         }), this.#timeoutMs, () => new AuthorizationBackendTimeoutError('openfga-relations', operation, this.#timeoutMs));
     }
+    /* ── D-31: el modelo FIJADO tiene que declarar el deny de los tipos con opt-in ─────────────────────────── */
+    /** Las relaciones `<tipo>#denied_<rel>` que declara el modelo que sirve este driver (memo por proceso). */
+    #modelDenied() {
+        this.#readModel();
+        return this.#modelMemo.denied;
+    }
+    /**
+     * **R2 del auditor del panel «óptimo» (cierre 5 de D2): la DERIVA modelo ↔ config en TODOS los tipos**, no solo en los
+     * que tienen deny: por tipo declarado en la config (y `group`), las relaciones cuya regla en el modelo FIJADO no es la
+     * que genera el paquete (`factsRelationRewrites`, por igualdad tras `canonicalRewrite`) o que el modelo no trae. La
+     * MISMA lectura del modelo (memo por proceso) que D-31.
+     */
+    #modelDrift() {
+        this.#readModel();
+        return this.#modelMemo.drift;
+    }
+    /** UNA lectura del modelo por proceso (memo compartido con las vistas `withClock`); un fallo no se memoriza. */
+    #readModel() {
+        if (this.#modelMemo.denied)
+            return;
+        const memo = this.#modelMemo;
+        const served = this.#guard('readAuthorizationModel', async () => {
+            const response = this.#options.modelId
+                ? await this.client.readAuthorizationModel()
+                : await this.client.readLatestAuthorizationModel();
+            const definitions = response?.authorization_model?.type_definitions;
+            if (!Array.isArray(definitions)) {
+                throw new Error('la respuesta de ReadAuthorizationModel no trae type_definitions; no se toma por «sin deny»');
+            }
+            // R2 (cierre 5 de D2): la deriva de TODOS los tipos de la config (y `group`) contra lo que genera el paquete.
+            // En un tipo SIN opt-in también vale la forma CON deny (`<rel> = base but not denied_<rel>`): es D8 —el opt-in
+            // retirado con el modelo aún publicado—, más restrictivo, nunca una concesión por una regla vieja.
+            const drift = new Map();
+            const expectedTypes = [
+                { type: RELATION_USERSET_TYPE, relations: { member: { this: {} } } },
+                ...this.#config.objectTypes.map((spec) => ({
+                    type: spec.type,
+                    relations: factsRelationRewrites(spec),
+                    alternative: spec.deny === undefined ? factsRelationRewrites({ ...spec, deny: 'read' }) : undefined,
+                })),
+            ];
+            for (const { type, relations: expectedRelations, alternative } of expectedTypes) {
+                const servedRelations = definitions.find((definition) => definition?.type === type)?.relations ?? {};
+                // Cierre 6 de D2 · 🟡 D5-2: la excepción D8 vale solo si el modelo trae la forma CON deny ENTERA para esa
+                // relación: `<rel>` Y `denied_<rel>` (el cierre del corte de camino). Con `denied_editor = this` (sin `or
+                // denied_viewer`) un modelo a mano concedía `editor` a quien tiene deny en `viewer`, donde `database` niega.
+                const denyFormMatches = (name) => {
+                    if (!alternative)
+                        return false;
+                    const denied = deniedRelationOf(name);
+                    return sameRewrite(servedRelations[name], alternative[name]) && sameRewrite(servedRelations[denied], alternative[denied]);
+                };
+                const differing = Object.keys(expectedRelations).filter((name) => !sameRewrite(servedRelations[name], expectedRelations[name]) && !denyFormMatches(name));
+                if (differing.length > 0)
+                    drift.set(type, differing);
+            }
+            // Cierre 1 de D1 · ⚪ 7: no basta con que EXISTA `denied_<rel>`: `<rel>` tiene que RESTARLO.
+            // Cierre 2 de D1 · ⚪ N4: tampoco basta con la FORMA. En un tipo CON opt-in, `<rel>` y `denied_<rel>` tienen que
+            // ser EXACTAMENTE las reglas que genera el paquete para ese tipo (`factsRelationRewrites`, la fuente única del
+            // generador), por igualdad estructural tras `canonicalRewrite`: un modelo a mano con `denied_editor: [user]` (sin
+            // `or denied_viewer`, el cierre del corte de camino) restaba bien y CONCEDÍA `editor` a un owner con deny en
+            // `viewer`, donde `database` niega. En un tipo SIN opt-in (D8: opt-in retirado con el modelo aún publicado) no hay
+            // regla del paquete con la que comparar: cuenta la forma de ⚪ 7 (`difference` con `subtract` = `denied_<rel>`),
+            // que es lo que `decideMany` necesita para saber qué deny preguntar.
+            const out = new Set();
+            for (const definition of definitions) {
+                const relations = definition?.relations ?? {};
+                const spec = this.#config.objectTypes.find((t) => t.type === definition?.type);
+                const expected = spec && spec.deny !== undefined ? factsRelationRewrites(spec) : undefined;
+                for (const name of Object.keys(relations)) {
+                    if (!name.startsWith(RELATION_DENY_PREFIX))
+                        continue;
+                    const relation = name.slice(RELATION_DENY_PREFIX.length);
+                    const base = relations[relation];
+                    const ok = expected
+                        ? sameRewrite(base, expected[relation]) && sameRewrite(relations[name], expected[name])
+                        : base?.difference?.subtract?.computedUserset?.relation === name;
+                    if (ok)
+                        out.add(`${definition.type}#${name}`);
+                }
+            }
+            return { denied: out, drift };
+        }).catch((error) => {
+            // Un fallo (503) NO se memoriza: la siguiente lo vuelve a intentar.
+            if (memo.denied === denied) {
+                memo.denied = undefined;
+                memo.drift = undefined;
+            }
+            throw error;
+        });
+        const denied = served.then((x) => x.denied);
+        memo.denied = denied;
+        memo.drift = served.then((x) => x.drift);
+        // Las dos promesas derivan de UNA: si nadie espera una de ellas, su rechazo no puede quedar sin capturar.
+        memo.denied.catch(() => { });
+        memo.drift.catch(() => { });
+    }
+    /**
+     * **D-31 · un tipo con opt-in y un modelo FIJADO sin `denied_<rel>` ⇒ 500 al USARLO** (juez ronda 2 §2, H3 b):
+     * un pod con la config nueva y el pin a un modelo viejo (o republicado por un proceso viejo) concedería sobre un
+     * objeto denegado —la resta la hace el servidor con el modelo que el pod fija—. Antes de la primera request de
+     * cualquier operación sobre esos tipos se comprueba (una lectura del modelo por proceso) y, si falta, 500
+     * `E_AUTHZ_CONFIG` nombrando las relaciones: ruidoso en vez de conceder. Tipos sin opt-in: sin coste.
+     */
+    async #assertModelDeny(types) {
+        const wanted = [];
+        const distinct = [...new Set(types)];
+        for (const type of distinct) {
+            if (denyPhaseOf(this.#config, type) === undefined)
+                continue;
+            const spec = this.#config.objectTypes.find((t) => t.type === type);
+            for (const relation of spec?.relations ?? [])
+                wanted.push(`${type}#${deniedRelationOf(relation.name)}`);
+        }
+        if (wanted.length > 0) {
+            const declared = await this.#modelDenied();
+            const missing = wanted.filter((name) => !declared.has(name));
+            if (missing.length > 0) {
+                throw new AuthorizationConfigError(`OpenFgaRelationsDriver: la config declara deny y el modelo que sirve este driver (modelId ` +
+                    `${this.#options.modelId ?? '(último)'}) NO declara ${missing.join(', ')} —o la declara pero <rel> o denied_<rel> no son las reglas que genera el paquete (but not y el cierre del corte de camino)— (D-31). Con ese modelo el servidor no ` +
+                    `resta el deny: un pod así concedería sobre objetos denegados. Republica el modelo desde la config actual ` +
+                    `(openfga:provision) y fija el modelId nuevo en TODA la flota antes de desplegar.`);
+            }
+        }
+        // R2 del auditor del panel «óptimo» (cierre 5 de D2): la MISMA comparación en los tipos SIN deny. Un pod con una config
+        // que ESTRECHA una regla (`viewer` deja de incluir `editor`) y el pin a un modelo viejo concedía por la regla vieja,
+        // en silencio, donde `database` con la misma config niega. Misma lectura del modelo, ya memorizada.
+        // Cierre 6 de D2 · ⚪ (D5-2): `group` se compara en TODA operación, no solo en las suyas — un `group#member` del
+        // modelo que no es `this` cambia quién es miembro y, con ello, qué concede un `check` de `document`.
+        const drift = await this.#modelDrift();
+        const compared = [...new Set([...distinct, RELATION_USERSET_TYPE])];
+        const drifted = compared.flatMap((type) => (drift.get(type) ?? []).map((relation) => `${type}#${relation}`));
+        if (drifted.length > 0) {
+            throw new AuthorizationConfigError(`OpenFgaRelationsDriver: el modelo que sirve este driver (modelId ${this.#options.modelId ?? '(último)'}) declara ` +
+                `${drifted.join(', ')} con una regla DISTINTA de la que genera la config de este proceso (includes / deny), o no la ` +
+                `declara (D-31 en todos los tipos, R2). Con ese modelo el servidor decide por la regla del modelo: un pod así ` +
+                `concedería lo que la config —y database con la misma config— niega. Republica el modelo desde la config actual ` +
+                `(openfga:provision) y fija el modelId nuevo en TODA la flota antes de desplegar.`);
+        }
+    }
     /* ── Composición y parseo de ids (⚪5: partición por string en el id) ────── */
     /** `<type>:<scopeKey(partition)>|<objectUuid>`. */
     #objectId(objectType, partitionKey, objectUuid) {
@@ -238,8 +498,9 @@ export class OpenFgaRelationsDriver {
         if (isRelUserset(subject)) {
             // alpha.3 · F-05 también en el USERSET del sujeto (la misma función que
             // el manager): `role_binding:<key>|<R>#role` como `user` de un `Read`/
-            // `Check`/`Write` no se compone nunca.
-            assertRelationDeclared(this.#config, subject.object, subject.relation);
+            // `Check`/`Write` no se compone nunca. B3 (lote B): y solo `group#member`
+            // — otro userset era un 400 del servidor (503 mal clasificado).
+            assertUsersetSubject(this.#config, subject);
             const object = this.#objectId(subject.object.type, partitionKey, subject.object.id);
             return `${object}#${subject.relation}`;
         }
@@ -301,8 +562,12 @@ export class OpenFgaRelationsDriver {
      *  - presente con la caducidad que toca ⇒ no-op (idempotente, invariante 6);
      *  - presente con OTRA ⇒ delete + write en DOS llamadas (FGA no admite
      *    delete+write de la misma clave en un `Write`, ni reescribir su
-     *    condición): entre ambas hay un instante en el que `check` responde
-     *    `false` —fail-closed, la misma ventana que el `grant` de roles—.
+     *    condición): entre ambas la tupla NO está. Para un allow eso solo
+     *    quita (fail-closed, la misma ventana que el `grant` de roles); para una
+     *    membresía `group:*#member` que TRANSPORTA un deny, CONCEDERÍA — desde el
+     *    cierre 2 de D2 (🟠 N1) esa renovación es 409 `E_AUTHZ_RENEWAL_UNSAFE`
+     *    con cero escrituras (`#carriedDeny`), y si el 2.º `Write` de una
+     *    renovación permitida falla el error va marcado PARCIAL (`markPartialWrite`).
      */
     /**
      * **`{ transaction }` se rechaza también AQUÍ** (L-5, defensa en
@@ -334,6 +599,7 @@ export class OpenFgaRelationsDriver {
         const user = this.#subjectUser(subject, partitionKey);
         const key = { user, relation, object: objectId };
         const now = this.#now();
+        await this.#assertModelDeny([object.type]);
         const current = await this.#readTuple('relate', key);
         const previous = current ? current.validUntil : null;
         const expiresAt = resolveGrantExpiry(previous, options?.expiresAt, now);
@@ -343,14 +609,111 @@ export class OpenFgaRelationsDriver {
             ? { ...key, condition: { name: FACTS_EXPIRY_CONDITION, context: { valid_until: expiresAt.toISOString() } } }
             : key;
         if (current) {
+            // Cierre 2 de D2 · 🟠 N1 (decisión del dueño 2026-10-15 (9)): una membresía que TRANSPORTA un deny no se renueva
+            // con dos `Write` — entre el delete y el write el sujeto quedaría sin el deny y concedería. 409, CERO escrituras.
+            // Cierre 3 de D2 · ⚪ C2-4: una membresía YA VENCIDA no conecta nada (el deny ya no alcanza al sujeto por ella), así
+            // que no hay ventana que proteger: se reescribe sin comprobar portadora (hasta el cierre 3 era un 409 espurio).
+            const guarded = object.type === RELATION_USERSET_TYPE && isActiveExpiry(previous, now);
+            const membership = `${objectId}#${relation}@${user}`;
+            if (guarded) {
+                const carried = await this.#carriedDeny(objectId, partitionKey, now);
+                if (carried !== null)
+                    throw RenewalUnsafeError.carrier(membership, carried);
+            }
             await this.#guard('relate', () => this.client.write({ deletes: [key] }, IGNORE_MISSING_DELETES));
+            // Cierre 2 de D2 · 🟠 N1 (b): el delete YA entró — si el write falla, la escritura es PARCIAL (invariante 13: el
+            // manager notifica `indeterminate: true`); hasta el cierre era un 503 «sin escribir» con la tupla borrada.
+            try {
+                await this.#guard('relate', () => this.client.write({ writes: [tuple] }, IGNORE_DUPLICATE_WRITES));
+            }
+            catch (error) {
+                // Cierre 3 de D2 · 🟡 C2-3: la membresía quedó BORRADA. Si entre la comprobación y el delete entró un deny en el
+                // grupo (TOCTOU), ese deny ya no alcanza al sujeto —y no lo alcanzará hasta que la membresía se reescriba—: el
+                // error parcial lo NOMBRA (`carriedDeny`) con la receta. Mejor esfuerzo: si la re-lectura también falla, se dice.
+                if (guarded && error !== null && typeof error === 'object') {
+                    annotateRacedDeny(error, membership, await this.#recheckCarried(objectId, partitionKey, now));
+                }
+                throw error !== null && typeof error === 'object' ? markPartialWrite(error) : error;
+            }
+            // Cierre 3 de D2 · 🟡 C2-3: la RE-COMPROBACIÓN. Un deny que entró entre `#carriedDeny` y los dos `Write` no alcanzó
+            // al sujeto durante la ventana; la renovación se aplicó (el estado final es correcto) y el error lo dice, marcado
+            // parcial (el manager notifica `indeterminate: true`). La ventana NO se cierra (FGA no tiene una primitiva para
+            // serializar `deny` contra la renovación): deja de ser muda. README «Every other renewal stays two `Write`s».
+            if (guarded) {
+                const recheck = await this.#recheckCarried(objectId, partitionKey, now);
+                if (recheck.deny !== null)
+                    throw markPartialWrite(RenewalRacedError.raced(membership, recheck.deny));
+                if (recheck.error !== undefined) {
+                    const error = recheck.error;
+                    throw error !== null && typeof error === 'object'
+                        ? markPartialWrite(annotateRacedDeny(error, membership, recheck, true))
+                        : error;
+                }
+            }
+            return;
         }
         await this.#guard('relate', () => this.client.write({ writes: [tuple] }, IGNORE_DUPLICATE_WRITES));
     }
-    /** La tupla EXACTA de una clave (un `Read` por clave completa), con su caducidad si la lleva. */
+    /**
+     * **¿Transporta el grupo un deny vivo?** (cierre 2 de D2 · 🟠 N1): el `#member` de `group` —o el de un grupo que lo
+     * contiene, transitivamente (`group:G#member@group:H#member`: los miembros de H heredan los denies de G)— es sujeto de
+     * una tupla `denied_*` de la partición, en algún tipo con opt-in del deny. Devuelve la primera que encuentra (para la
+     * letra) o `null`. Coste: por cada grupo del cierre hacia arriba, un `Read` por `user` + tipo (el filtro que FGA admite:
+     * `user` y `object` tipo) por cada tipo con deny, y uno de sus padres. Solo corre en una RENOVACIÓN de membresía.
+     */
+    async #carriedDeny(groupObjectId, partitionKey, now) {
+        const denyTypes = this.#config.objectTypes.filter((t) => denyPhaseOf(this.#config, t.type) !== undefined).map((t) => t.type);
+        if (denyTypes.length === 0)
+            return null;
+        const seen = new Set([groupObjectId]);
+        const queue = [groupObjectId];
+        while (queue.length > 0) {
+            const userset = `${queue.shift()}#${RELATION_USERSET_RELATION}`;
+            for (const type of denyTypes) {
+                for (const t of await this.#readAll('relate', { user: userset, object: `${type}:` })) {
+                    // Cierre 6 de D2 · 🟡 D5-1: un deny VENCIDO no transporta nada (la MISMA regla que C2-4 para la arista y que el
+                    // plan para toda tupla del destino: vencida = ausente). Contarlo hacía de la pasada REAL un 409 que el dry-run
+                    // no anunciaba, y las particiones siguientes no migraban.
+                    if (t.relation.startsWith(RELATION_DENY_PREFIX) &&
+                        t.object.startsWith(`${type}:${partitionKey}|`) &&
+                        isActiveExpiry(t.validUntil ?? null, now)) {
+                        return `${t.object}#${t.relation}@${t.user}`;
+                    }
+                }
+            }
+            for (const parent of await this.#readAll('relate', { user: userset, relation: RELATION_USERSET_RELATION, object: `${RELATION_USERSET_TYPE}:` })) {
+                // Cierre 3 de D2 · ⚪ C2-4: una arista de anidación VENCIDA no transporta nada (no conecta en FGA).
+                if (!isActiveExpiry(parent.validUntil ?? null, now))
+                    continue;
+                if (!seen.has(parent.object)) {
+                    seen.add(parent.object);
+                    queue.push(parent.object);
+                }
+            }
+        }
+        return null;
+    }
+    /** `#carriedDeny` tras los dos `Write` (🟡 C2-3): nunca lanza; un fallo de la re-lectura viaja en `error`. */
+    async #recheckCarried(groupObjectId, partitionKey, now) {
+        try {
+            return { deny: await this.#carriedDeny(groupObjectId, partitionKey, now) };
+        }
+        catch (error) {
+            return { deny: null, error };
+        }
+    }
+    /**
+     * La tupla EXACTA de una clave (un `Read` por clave completa), con su caducidad si la lleva.
+     * ⚪ N5 (cierre 2 del lote B): un 200 sin `tuples` NO es «no existe» — hasta el cierre `?? []` lo
+     * vendía así y `relate` escribía a ciegas (una caducidad vigente que no se ve no se preserva).
+     * Es 503, como `#readAll`: exhaustivo-o-ruidoso también en la lectura de UNA clave.
+     */
     async #readTuple(operation, key) {
         const response = await this.#guard(operation, () => this.client.read(key, { consistency: this.#consistency }));
-        const found = (response.tuples ?? []).map((t) => t.key).find((k) => k?.user === key.user && k?.relation === key.relation && k?.object === key.object);
+        if (!Array.isArray(response?.tuples)) {
+            throw new AuthorizationBackendError('openfga-relations', operation, new Error(`la respuesta del Read de la clave no trae 'tuples'; no se toma por «no existe»`));
+        }
+        const found = response.tuples.map((t) => t.key).find((k) => k?.user === key.user && k?.relation === key.relation && k?.object === key.object);
         if (!found)
             return null;
         return { ...key, validUntil: toExpiryDate(found.condition?.context?.valid_until) };
@@ -364,10 +727,67 @@ export class OpenFgaRelationsDriver {
         const partitionKey = this.#keyOf(partition);
         const objectId = this.#objectId(object.type, partitionKey, object.id);
         const user = this.#subjectUser(subject, partitionKey);
+        await this.#assertModelDeny([object.type]);
         await this.#guard('unrelate', () => 
         // Re-unrelate no-op seguro: borrar una tupla ausente se ignora.
         this.client.write({ deletes: [{ user, relation, object: objectId }] }, IGNORE_MISSING_DELETES));
     }
+    /**
+     * **`deny` = UN `Write` de la tupla `denied_<rel>`** (lote D · D1): sin caducidad (D3), así que no hay renovación
+     * ni ventana —un re-deny idéntico lo ignora el servidor (`on_duplicate: ignore`)—; una tupla de deny escrita a mano
+     * CON condición devuelve 409 y, desde el cierre 1 de D2 (🟡 4), sale como 500 `E_AUTHZ_CONFIG` con la receta
+     * (`AuthorizationConfigError.conditionalDeny`; hasta entonces era un 503 que se repetía para siempre). Antes del `Write`: la
+     * puerta de `{ transaction }` (L-5), F-05 sobre el nombre PÚBLICO, la puerta del opt-in (fase `'write'`), sin
+     * caducidad, la partición, `*`, el sujeto y la guarda del modelo (D-31). CERO llamadas si algo de eso falla.
+     */
+    async deny(subject, relation, object, partition, options) {
+        this.#rejectTransaction('deny', options);
+        assertRelationDeclared(this.#config, object, relation);
+        assertRelationDenyable(this.#config, object, relation);
+        assertDenyNoExpiry(options);
+        assertPartition(partition);
+        assertDenySubject(subject);
+        const partitionKey = this.#keyOf(partition);
+        const objectId = this.#objectId(object.type, partitionKey, object.id);
+        const user = this.#subjectUser(subject, partitionKey);
+        await this.#assertModelDeny([object.type]);
+        const key = { user, relation: deniedRelationOf(relation), object: objectId };
+        try {
+            await this.#guard('deny', () => this.client.write({ writes: [key] }, IGNORE_DUPLICATE_WRITES));
+        }
+        catch (error) {
+            // Cierre 1 de D2 · 🟡 4: el 409 de una clave que ya existe CON condición (medido en v1.19.0: «already exists with
+            // a different condition») no es una caída. Se confirma RELEYENDO la tupla (no por el texto del mensaje): si está y
+            // lleva condición, 500 con la receta; si no, el 503 de siempre.
+            if (error?.status === 503 && error?.cause?.statusCode === 409) {
+                const found = await this.#guard('deny', () => this.client.read(key, { consistency: this.#consistency }));
+                if (Array.isArray(found?.tuples) && found.tuples.some((t) => t?.key?.condition)) {
+                    throw AuthorizationConfigError.conditionalDeny('deny', `${key.object}#${key.relation}@${key.user}`);
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * **`removeDeny` = UN delete de `denied_<rel>`** (no-op si no está). Sobre CUALQUIER tipo declarado (D8/R2-4 b):
+     * `Write` con delete no valida la relación contra el modelo (medido en v1.19.0), así que un deny vivo de un tipo
+     * que retiró el opt-in se puede borrar. Ojo: quitar un deny CONCEDE (filas declaradas S8–S10).
+     * **La guarda D-31 SÍ corre aquí para los tipos CON opt-in** (letra corregida en el cierre 1 de D1, ⚪ 5 del auditor:
+     * la decisión 4 del informe decía que no): con el opt-in vivo y un modelo fijado sin `denied_*` ⇒ 500 antes del
+     * delete. Con el opt-in RETIRADO no hay guarda (el tipo no está en la config con `deny`) y el delete borra de verdad
+     * (medido por el auditor: `listDenies` de 1 a 0 y `check` vuelve a `true` con el modelo viejo) — retirar es reversible.
+     */
+    async removeDeny(subject, relation, object, partition, options) {
+        this.#rejectTransaction('removeDeny', options);
+        assertRelationDeclared(this.#config, object, relation);
+        assertDenyNoExpiry(options);
+        assertPartition(partition);
+        const partitionKey = this.#keyOf(partition);
+        const objectId = this.#objectId(object.type, partitionKey, object.id);
+        const user = this.#subjectUser(subject, partitionKey);
+        await this.#assertModelDeny([object.type]);
+        await this.#guard('removeDeny', () => this.client.write({ deletes: [{ user, relation: deniedRelationOf(relation), object: objectId }] }, IGNORE_MISSING_DELETES));
+    }
     /* ── Lecturas ───────────────────────────────────────────────────────────── */
     /**
      * **F-05 en las LECTURAS y las PURGAS del driver** (2.4.0-alpha.3, cierre
@@ -390,6 +810,7 @@ export class OpenFgaRelationsDriver {
         const objectId = this.#objectId(object.type, partitionKey, object.id);
         const user = this.#subjectUser(subject, partitionKey);
         const context = this.#checkContext(this.#now());
+        await this.#assertModelDeny([object.type]);
         const response = await this.#guard('check', () => this.client.check({ user, relation, object: objectId, context }, { consistency: this.#consistency }));
         return response.allowed === true;
     }
@@ -413,6 +834,7 @@ export class OpenFgaRelationsDriver {
         const user = this.#subjectUser(subject, partitionKey);
         const { distinct, index } = distinctObjects(objects);
         const context = this.#checkContext(this.#now());
+        await this.#assertModelDeny(distinct.map((object) => object.type));
         const checks = distinct.map((object, i) => ({
             user,
             relation,
@@ -432,16 +854,157 @@ export class OpenFgaRelationsDriver {
         }
         return expandByPosition(index, answers);
     }
+    /**
+     * **`decideMany` = un `batchCheck` con `R` y los `denied_<m>` de las relaciones FUENTE de `down*(R)`** (lote D ·
+     * D9, juez ronda 2 §4): por el cierre ascendente del modelo (`denied_X = this ∨ denied_P`), `denied_<fuente>`
+     * cubre todo `up*(down*(R))` — en el retículo del contrato, 2 ítems por objeto (`R` y `denied_owner`). Mismo
+     * `current_time` en TODOS los ítems (un `now` por lote), alineado por `correlationId` (`alignBatchResults`, la
+     * misma función que `checkMany` y roles), troceado por `FGA_MAX_BATCH_CHECK`, y un `error` en UN ítem ⇒ 503 para
+     * todo el lote (nunca `none`: S15). La decisión sale de `decideFrom`, la regla ÚNICA (la misma que `database` y el
+     * doble). En un tipo sin opt-in se pregunta el deny solo si el modelo que sirve el driver lo declara (opt-in
+     * retirado con el modelo aún publicado, D8); si no, cada posición es `allow` o `none` (no hay deny posible).
+     */
+    async decideMany(subject, relation, objects, partition) {
+        assertCheckManyObjects(objects, 'decideMany');
+        for (const object of objects)
+            assertRelationDeclared(this.#config, object, relation);
+        assertPartition(partition);
+        this.#assertPinnedForDecideMany();
+        const partitionKey = this.#keyOf(partition);
+        const user = this.#subjectUser(subject, partitionKey);
+        const { distinct, index } = distinctObjects(objects);
+        const context = this.#checkContext(this.#now());
+        await this.#assertModelDeny(distinct.map((object) => object.type));
+        const declared = await this.#modelDenied();
+        const checks = [];
+        const plan = [];
+        distinct.forEach((object, i) => {
+            const objectId = this.#objectId(object.type, partitionKey, object.id);
+            const down = relationsDown(this.#config, object.type, relation);
+            const type = this.#config.objectTypes.find((t) => t.type === object.type);
+            const sources = down.filter((name) => {
+                const includes = type?.relations.find((r) => r.name === name)?.includes ?? [];
+                return includes.length === 0 && declared.has(`${object.type}#${deniedRelationOf(name)}`);
+            });
+            plan.push({ object, sources });
+            // `correlationId` del servidor: `^[\w\d-]{1,36}$` (sin `:`): `a<i>` para R, `d<i>-<k>` para la fuente k.
+            checks.push({ user, relation, object: objectId, context, correlationId: `a${i}` });
+            sources.forEach((source, k) => {
+                checks.push({ user, relation: deniedRelationOf(source), object: objectId, context, correlationId: `d${i}-${k}` });
+            });
+        });
+        const allowed = new Map();
+        for (let start = 0; start < checks.length; start += FGA_MAX_BATCH_CHECK) {
+            const chunk = checks.slice(start, start + FGA_MAX_BATCH_CHECK);
+            const response = await this.#guard('decideMany', () => this.client.batchCheck({ checks: chunk }, { consistency: this.#consistency }));
+            const results = alignBatchResults('openfga-relations', 'decideMany', chunk, response.result);
+            results.forEach((r, i) => allowed.set(chunk[i].correlationId, r.allowed === true));
+        }
+        // D9, por posición: `allow` si el `Check` de R concede (el servidor ya aplicó el corte); si no, `deny` si alguno
+        // de los `denied_<fuente>` alcanza al sujeto (su cierre cubre up*(down*(R))); si no, `none`. Es `decideFrom` con el
+        // corte ya evaluado en el servidor (los dos drivers y el doble responden la misma tabla: casos D9 de la COMÚN).
+        const answers = plan.map(({ sources }, i) => {
+            if (allowed.get(`a${i}`))
+                return 'allow';
+            return sources.some((_, k) => allowed.get(`d${i}-${k}`)) ? 'deny' : 'none';
+        });
+        return index.map((at) => answers[at]);
+    }
+    /**
+     * **`decideMany` exige `modelId` FIJADO, con o sin tipos con deny** (lote D · cierre 1 de D1, 🟡 3 del auditor; D14
+     * extendido a la primitiva de cadena). `decideMany` decide qué `denied_*` preguntar con el memo del modelo
+     * (`#modelDenied`), y `check` lo resta el SERVIDOR con el modelo que evalúa: sin pin, el memo es el «último» del
+     * momento de la primera lectura y el servidor evalúa con el último de AHORA. Republicado un modelo con deny (flota con
+     * dos configs, reactivación del opt-in), `check` daba `false` por el deny y `decideMany` respondía `none` —la cadena
+     * del llamante seguía subiendo y concedía por el padre: fail-open en la primitiva—. Con el pin, memo y `Check` son
+     * del MISMO modelo. 500 `E_AUTHZ_CONFIG` con cero llamadas, ANTES de leer nada.
+     */
+    #assertPinnedForDecideMany() {
+        if (this.#options.modelId)
+            return;
+        throw new AuthorizationConfigError(`OpenFgaRelationsDriver.decideMany: exige modelId FIJADO (D14, también sin tipos con deny). decideMany decide qué ` +
+            `denied_<rel> preguntar con el modelo que leyó una vez, y sin pin el servidor evalúa check con el ÚLTIMO modelo del ` +
+            `store: tras republicar un modelo con deny respondería 'none' donde check responde false, y la cadena del llamante ` +
+            `concedería por el padre. Receta: provision (openfga:provision) → fijar modelId (OPENFGA_MODEL_ID) en TODA la flota ` +
+            `→ desplegar. No se ha llamado al servidor.`);
+    }
+    /**
+     * **`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 y, con opt-in, el modelo FIJADO comprobado con la MISMA guarda D-31 que `deny` (500 si
+     * no declara `denied_<rel>`). F-05 estricto del par, antes de nada (422, cero llamadas). La llama
+     * `reconcileRelations` en la fase de plan cuando el origen trae denies: un destino `openfga` sin `'write'` en el
+     * tipo, o con un pin a un modelo sin el deny, NIEGA la pasada antes de la primera escritura (jamás `skipped`).
+     */
+    async denyPhase(object, relation) {
+        assertRelationDeclared(this.#config, object, relation);
+        const phase = denyPhaseOf(this.#config, object.type);
+        if (phase === undefined)
+            return null;
+        await this.#assertModelDeny([object.type]);
+        return phase;
+    }
+    /** `listDenies` = `Read` por `(object, denied_<rel>)`: los denies DIRECTOS (hechos). Cualquier tipo declarado (D8). */
+    async listDenies(relation, object, partition, _page) {
+        assertRelationDeclared(this.#config, object, relation);
+        assertPartition(partition);
+        const partitionKey = this.#keyOf(partition);
+        const objectId = this.#objectId(object.type, partitionKey, object.id);
+        const now = this.#now();
+        const tuples = await this.#readAll('listDenies', { object: objectId, relation: deniedRelationOf(relation) });
+        const subjects = [];
+        for (const t of tuples) {
+            if (t.validUntil && t.validUntil.getTime() <= now.getTime())
+                continue;
+            const subject = this.#userToSubject(t.user);
+            if (subject)
+                subjects.push(subject);
+            else
+                this.#warnUnparseable('listDenies', t.user);
+        }
+        return { subjects };
+    }
+    /**
+     * **El envoltorio ÚNICO de `ListObjects`** (plan 2.5 · lote B · B4; linaje L8,
+     * 5.ª iteración ⇒ M8: propiedad universal «toda enumeración que se puede
+     * cortar devuelve `truncated` o lanza»). `ListObjects` corta de DOS formas,
+     * las dos con 200 y sin `continuation_token` ni bandera: (1) al tope del
+     * servidor (`listObjectsMaxResults`): `>= tope` resultados CRUDOS ⇒ no se
+     * puede prometer la lista completa; (2) al DEADLINE del servidor
+     * (`--listObjects-deadline`, 3 s por defecto): pasado, devuelve lo que
+     * llevaba resuelto (analista M4, medido). La (2) se detecta midiendo la
+     * llamada con el reloj MONÓTONO (`monotonic`, `performance.now`): si duró
+     * ≥ `LIST_OBJECTS_DEADLINE_RATIO` × `listObjectsDeadlineMs`, `truncated`. Es
+     * una señal conservadora a propósito (una llamada lenta pero completa sale
+     * como truncada; una cortada JAMÁS como completa). Todo `ListObjects` del
+     * driver pasa por aquí — la guardia de superficie (columna `truncation`) lo
+     * sondea con las dos causas y un mutante por cada una. Las enumeraciones por
+     * `Read` (`listSubjects`, `enumerateRelations`, las purgas) no se cortan:
+     * `#readAll` agota el token o lanza 503 («exhaustivo o ruidoso»).
+     */
+    async #listObjectsPage(request) {
+        const started = this.#monotonic();
+        const response = await this.#guard('listObjects', () => this.client.listObjects(request, { consistency: this.#consistency }));
+        const elapsedMs = this.#monotonic() - started;
+        // 🟡 4 (cierre 1 del lote B): un 200 sin `objects` (un proxy, una caché, un
+        // cuerpo vacío) NO es una lista completa vacía: es una enumeración que no
+        // se puede prometer ⇒ 503, como `#readAll` con una respuesta sin `tuples`.
+        // Hasta el cierre `response.objects ?? []` la vendía como `{ objects: [] }`
+        // sin `truncated` — la lista «completa» muda que M8 prohíbe.
+        if (!Array.isArray(response?.objects)) {
+            throw new AuthorizationBackendError('openfga-relations', 'listObjects', new Error(`la respuesta de ListObjects no trae 'objects'; no se toma por vacía (sería una lista completa muda)`));
+        }
+        const raw = response.objects;
+        const byCap = raw.length >= this.#listObjectsMax;
+        const byDeadline = elapsedMs >= LIST_OBJECTS_DEADLINE_RATIO * this.#listObjectsDeadlineMs;
+        return { raw, truncated: byCap || byDeadline, elapsedMs };
+    }
     /**
      * `listObjects` = `ListObjects` (resuelve includes + usersets del lado del
-     * servidor) + FILTRO por partición + señal de TRUNCADO. `ListObjects` corta
-     * al tope del servidor sin `continuation_token` ni bandera, así que el
-     * truncado se detecta comparando el número de resultados CRUDOS con el tope
-     * configurado (`listObjectsMaxResults`): `>= tope` ⇒ no se puede prometer la
-     * lista completa ⇒ `truncated: true`. El filtro por partición se aplica
-     * DESPUÉS (los ids llevan la partición), así que en un store con varias
-     * particiones el tope se consume entre todas — otra razón para señalar el
-     * truncado y no callar (documentado en el README).
+     * servidor) + FILTRO por partición + señal de TRUNCADO (`#listObjectsPage`:
+     * tope o deadline, B4). El filtro por partición se aplica DESPUÉS (los ids
+     * llevan la partición), así que en un store con varias particiones el tope
+     * se consume entre todas — otra razón para señalar el truncado y no callar
+     * (documentado en el README).
      */
     async listObjects(subject, relation, objectType, partition, _page) {
         assertRelationDeclared(this.#config, { type: objectType }, relation);
@@ -449,9 +1012,8 @@ export class OpenFgaRelationsDriver {
         const partitionKey = this.#keyOf(partition);
         const user = this.#subjectUser(subject, partitionKey);
         const context = this.#checkContext(this.#now());
-        const response = await this.#guard('listObjects', () => this.client.listObjects({ user, relation, type: objectType, context }, { consistency: this.#consistency }));
-        const raw = response.objects ?? [];
-        const truncated = raw.length >= this.#listObjectsMax;
+        await this.#assertModelDeny([objectType]);
+        const { raw, truncated } = await this.#listObjectsPage({ user, relation, type: objectType, context });
         const objects = [];
         for (const full of raw) {
             const parsed = this.#parseObjectId(full);
@@ -596,7 +1158,8 @@ export class OpenFgaRelationsDriver {
             }
             tuples.push({
                 subject,
-                relation: key.relation,
+                // Lote D · D2: `denied_<rel>` ⇒ `{ relation: <rel>, kind: 'deny' }` (`storedRelationKind`, punto de paso único).
+                ...storedRelationKind(key.relation),
                 object: { type: parsed.type, id: parsed.objectUuid },
                 partition,
                 expiresAt: key.validUntil,
@@ -621,7 +1184,7 @@ export class OpenFgaRelationsDriver {
         const objectId = this.#objectId(object.type, this.#keyOf(partition), object.id);
         const progress = { deleted: 0 };
         try {
-            await this.#purgeByFilter('purgeObject', { object: objectId }, `objeto ${objectId}`, progress);
+            await this.#purgeByFilters('purgeObject', [[{ object: objectId }, `objeto ${objectId}`]], progress);
         }
         catch (error) {
             throw this.#partialIfDeleted(error, progress);
@@ -646,9 +1209,7 @@ export class OpenFgaRelationsDriver {
         const types = [FACTS_GROUP_TYPE, ...this.#config.objectTypes.map((t) => t.type)];
         const progress = { deleted: 0 };
         try {
-            for (const type of types) {
-                await this.#purgeByFilter('purgeSubject', { user, object: `${type}:` }, `sujeto ${user} en '${type}'`, progress);
-            }
+            await this.#purgeByFilters('purgeSubject', types.map((type) => [{ user, object: `${type}:` }, `sujeto ${user} en '${type}'`]), progress);
         }
         catch (error) {
             throw this.#partialIfDeleted(error, progress);
@@ -658,7 +1219,7 @@ export class OpenFgaRelationsDriver {
      * **Una purga que muere a MEDIAS es indeterminada** (invariante 13,
      * 2.4.0-alpha.3, cierre del 🟡 6 del auditor). La purga NO es un `Write`:
      * son N `Read`+`deleteTuples` (ortografías × tipos, y lotes de
-     * `WRITE_BATCH_SIZE`), y un 503 que no es timeout —o el 500
+     * `RELATIONS_PURGE_WRITE_MAX`), y un 503 que no es timeout —o el 500
      * `E_AUTHZ_PURGE_INCOMPLETE` de la demostración de cero— puede llegar
      * después de haber borrado parte. Si YA se borró al menos una tupla, el
      * error se marca (`markPartialWrite`, `src/errors.ts`: una propiedad, la
@@ -673,30 +1234,75 @@ export class OpenFgaRelationsDriver {
             return markPartialWrite(error);
         return error;
     }
-    /** Lee por filtro, borra en lotes, y RE-LEE para demostrar cero (o lanza). `progress.deleted` cuenta lo que YA se borró (un lote que falla no borró nada: el `Write` de FGA es transaccional). */
-    async #purgeByFilter(operation, filter, what, progress) {
-        const keys = await this.#readAll(operation, filter);
-        for (let i = 0; i < keys.length; i += WRITE_BATCH_SIZE) {
-            const batch = keys.slice(i, i + WRITE_BATCH_SIZE);
-            await this.#guard(operation, () => this.client.deleteTuples(batch.map((k) => ({ user: k.user, relation: k.relation, object: k.object })), IGNORE_MISSING_DELETES));
+    /**
+     * **Lee TODOS los filtros, borra en un `Write` si cabe —y si no, en ORDEN GLOBAL: allows → membresías → denies— y
+     * RE-LEE cada filtro para demostrar cero (o lanza)** (lote D · D-16/D-26/S3; cierre 1 de D1, 🟠 1 del auditor; el
+     * orden S6 de roles, invariante 6). La propiedad: **una purga cortada a medias no concede nada que no concedieran el
+     * estado inicial o el final** —con la única excepción DECLARADA de abajo—.
+     *
+     *  - **Cabe en `RELATIONS_PURGE_WRITE_MAX` (100) ⇒ UN solo `Write`**: FGA lo aplica de forma transaccional (medido:
+     *    101 es 400 y no se aplica nada), así que NO hay estado intermedio que cortar.
+     *  - **No cabe ⇒ tres clases, cada una en sus propios `Write`, en el orden de BORRADO del punto de paso ÚNICO
+     *    `relationDeleteOrder`** (`src/relations/tuple_order.ts`; cierre 1 de D2 · 🟠 1: el mismo que el reconcile): (1) los allows sobre objetos que no son
+     *    `group` —quitar un allow solo resta (D-12, monotonía)—; (2) las MEMBRESÍAS `group:*#member@<sujeto>` —una membresía
+     *    TRANSPORTA allows y denies a la vez: borrarla antes que un allow directo deja ese allow sin el deny que lo cortaba
+     *    (🟠 1: con el orden «solo prefijo» de alpha.3-dev, `group:g#member@U` caía en el lote 1 y `doc:V#viewer@U` en el 2;
+     *    cortada entre los dos, U CONCEDÍA sobre V; la gemela `purgeSubject(g#member)` con la arista anidada
+     *    `group:h#member@group:g#member`)—, en UN `Write` PROPIO si caben (ordenadas por objeto, las portadoras de deny al
+     *    final: el reparto no depende del `Read`); (3) los `denied_*`, al final —quedan denies de MÁS, nunca de menos—.
+     *  - **Residuo DECLARADO**: con MÁS de 100 membresías del sujeto no caben en un `Write`, y una que transporta un deny
+     *    puede caer en un lote anterior a otra que transporta un allow (fila con caso en `relations_openfga.spec`, frase en
+     *    el README). No se niega la purga antes de borrar (invariante 11: una purga no espera; un 500 dejaría al sujeto de
+     *    baja con TODO su acceso): sale marcada como parcial (`indeterminate: true`) y se repite.
+     *
+     * `purgeObject` pasa por aquí igual: sobre un objeto que no es `group` no hay membresías (allows → denies); sobre
+     * `group:g` todo son membresías de g, y cada miembro queda dentro o fuera de g —su estado inicial o el final—.
+     * `progress.deleted` cuenta lo que YA se borró (un lote que falla no borró nada) para la marca de escritura parcial
+     * (invariante 13).
+     */
+    async #purgeByFilters(operation, filters, progress) {
+        const read = [];
+        for (const [filter, what] of filters)
+            read.push({ filter, what, keys: await this.#readAll(operation, filter) });
+        for (const batch of purgeWrites(read.flatMap((r) => r.keys))) {
+            try {
+                await this.#guard(operation, () => this.client.deleteTuples(batch.map((k) => ({ user: k.user, relation: k.relation, object: k.object })), IGNORE_MISSING_DELETES));
+            }
+            catch (error) {
+                // Cierre 2 de D1 · ⚪ N3: el 400 del tope de operaciones por `Write` del SERVIDOR no es una caída (503
+                // reintentable): es un despliegue con `--max-tuples-per-write` < `RELATIONS_PURGE_WRITE_MAX`. 500 con la letra;
+                // la marca de escritura parcial la pone `#partialIfDeleted` si ya se aplicó un `Write` anterior.
+                if (isServerWriteLimit(error))
+                    throw purgeWriteLimitError(operation, batch.length, progress.deleted, error);
+                throw error;
+            }
             progress.deleted += batch.length;
         }
-        if (keys.length === 0)
-            return;
-        // Demostración de cero: re-lee tras borrar (invariante 11).
-        const residue = await this.#readAll(operation, filter);
-        if (residue.length > 0) {
-            throw new PurgeIncompleteError(`${operation}: quedan ${residue.length} tuplas de ${what} tras el borrado ` +
-                `(${residue.slice(0, 3).map((k) => `${k.user}#${k.relation}@${k.object}`).join('; ')}). ` +
-                `No se confirma la purga.`);
+        // Demostración de cero: re-lee tras borrar (invariante 11), solo los filtros que tenían algo.
+        for (const { filter, what, keys } of read) {
+            if (keys.length === 0)
+                continue;
+            const residue = await this.#readAll(operation, filter);
+            if (residue.length > 0) {
+                throw new PurgeIncompleteError(`${operation}: quedan ${residue.length} tuplas de ${what} tras el borrado ` +
+                    `(${residue.slice(0, 3).map((k) => `${k.user}#${k.relation}@${k.object}`).join('; ')}). ` +
+                    `No se confirma la purga.`);
+            }
         }
     }
     /* ── Helpers ────────────────────────────────────────────────────────────── */
     /**
-     * TODAS las tuplas que casan con el filtro, paginando `Read` hasta agotar el
-     * `continuation_token`. `Read` no tiene tope de resultados (a diferencia de
-     * `ListObjects`), así que es exhaustivo — por eso las purgas y `listSubjects`
-     * van por aquí, no por `ListObjects`.
+     * **El envoltorio ÚNICO de `Read`** (B4, la otra mitad de la propiedad
+     * universal): TODAS las tuplas que casan con el filtro, paginando `Read`
+     * hasta agotar el `continuation_token`. `Read` no tiene tope de resultados
+     * (a diferencia de `ListObjects`), así que es exhaustivo — por eso las purgas,
+     * `listSubjects` y `enumerateRelations(Many)` van por aquí, no por
+     * `ListObjects` — y cuando NO puede serlo, lanza 503 en vez de devolver una
+     * página corta: una respuesta sin `tuples`, un token que se repite (el
+     * servidor no avanza; una página vacía con token cae aquí) o más de
+     * `MAX_READ_PAGES` páginas. La guardia de superficie (columna `truncation`)
+     * sondea las cinco operaciones que entran por aquí con un mutante que
+     * «termina» en la página vacía.
      */
     async #readAll(operation, filter) {
         const keys = [];
@@ -758,4 +1364,92 @@ export class OpenFgaRelationsDriver {
 // de modo que un 400 de validación de FGA o el cuerpo de un 502 que mencionara
 // la palabra salía como 503 `E_AUTHZ_BACKEND_TIMEOUT` con `indeterminate: true`
 // sin haber borrado nada (medido por el auditor: `alpha3-cierre-parcial.ts` B).
+/** Igualdad ESTRUCTURAL de dos reglas de reescritura (D-31, cierre 2 de D1 · ⚪ N4); una ausente nunca es igual. */
+function sameRewrite(served, generated) {
+    if (served === undefined || generated === undefined)
+        return false;
+    return JSON.stringify(canonicalRewrite(served)) === JSON.stringify(canonicalRewrite(generated));
+}
+/** La LETRA del 500 de N3 (fijada por `relations_openfga.spec`, «⚪ N3 · …»). */
+function purgeWriteLimitError(operation, size, deleted, cause) {
+    const sdk = cause?.cause?.apiErrorMessage;
+    return new AuthorizationConfigError(`OpenFgaRelationsDriver: ${operation}: el servidor OpenFGA rechazó un Write de ${size} tuplas por su tope de ` +
+        `operaciones por Write (exceeded_entity_limit${typeof sdk === 'string' ? `: «${sdk}»` : ''}). El driver parte las ` +
+        `purgas en RELATIONS_PURGE_WRITE_MAX = ${RELATIONS_PURGE_WRITE_MAX} y exige --max-tuples-per-write ≥ ` +
+        `${RELATIONS_PURGE_WRITE_MAX} en el servidor (OPENFGA_MAX_TUPLES_PER_WRITE; el default es ${RELATIONS_PURGE_WRITE_MAX}). ` +
+        `No es transitorio: repetida, la purga vuelve a fallar igual. ` +
+        (deleted > 0
+            ? `Ya se habían borrado ${deleted} tuplas en Write anteriores: la purga quedó A MEDIAS (escritura parcial).`
+            : 'No se borró nada.'), { cause });
+}
+/**
+ * **Los `Write` de una purga, en orden** (lote D · cierre 1 de D1, 🟠 1; ver `#purgeByFilters`): uno solo si todo cabe
+ * en `RELATIONS_PURGE_WRITE_MAX`; si no, en el orden de BORRADO del punto de paso ÚNICO `relationDeleteOrder`
+ * (`src/relations/tuple_order.ts`, cierre 1 de D2 · 🟠 1: el MISMO que usa el reconcile) — allows sobre objetos que no
+ * son `group`, luego las membresías `group:*#member` (las portadoras de deny al final, ordenadas por objeto y sujeto) y
+ * al final los `denied_*` —, con CADA CLASE en sus PROPIOS `Write` (con ≤ 100 membresías, uno). Pura: la tabla de verdad
+ * del caso la juzga contra el servidor, y la PROPIEDAD la juzga sin servidor la guardia de superficie
+ * (`GS · P · openfga.purge.order`, cierre 2 de D1 · ⚪ N2), con los mutantes de orden en el corredor publicado
+ * (`npm run check:guard-mutants`). Exportada solo para eso: no sale por `/openfga`.
+ */
+export function purgeWrites(keys) {
+    if (keys.length === 0)
+        return [];
+    if (keys.length <= RELATIONS_PURGE_WRITE_MAX)
+        return [[...keys]];
+    const view = (k) => ({ deny: k.relation.startsWith(RELATION_DENY_PREFIX), object: k.object, user: k.user });
+    const ordered = relationDeleteOrder(keys, view);
+    const chunks = (list) => {
+        const out = [];
+        for (let i = 0; i < list.length; i += RELATIONS_PURGE_WRITE_MAX)
+            out.push(list.slice(i, i + RELATIONS_PURGE_WRITE_MAX));
+        return out;
+    };
+    // Cada CLASE en sus propios `Write`: una membresía nunca comparte lote con el último allow ni con el primer deny.
+    const runs = [];
+    let previous;
+    for (const k of ordered) {
+        const cls = relationOrderClass(view(k));
+        if (cls !== previous)
+            runs.push([]);
+        runs[runs.length - 1].push(k);
+        previous = cls;
+    }
+    return runs.flatMap(chunks);
+}
+/**
+ * **El error de una renovación en dos `Write` NOMBRA el deny que entró en la ventana** (cierre 3 de D2 · 🟡 C2-3). Sobre
+ * el error que se propaga (su clase y su `code` no cambian): `carriedDeny` = el deny que la re-comprobación encontró, y la
+ * letra con la receta; si la re-comprobación también falló, lo dice (`carriedDenyUnknown: true`). `applied` = la
+ * renovación SÍ se aplicó y lo que falló es solo la re-comprobación. Un error congelado se propaga tal cual.
+ */
+function annotateRacedDeny(error, membership, recheck, applied = false) {
+    let note = null;
+    const target = error;
+    try {
+        if (recheck.deny !== null) {
+            target.carriedDeny = recheck.deny;
+            note =
+                ` — Cierre 3 de D2 (C2-3): la membresía ${membership} quedó BORRADA y un deny concurrente (${recheck.deny}) que ` +
+                    'entró en el grupo durante la renovación ya NO alcanza al sujeto por ella, y no lo alcanzará hasta que la ' +
+                    'membresía se reescriba. Receta: vuelve a escribirla (relate: ya no existe, así que es UN Write) o retira y ' +
+                    'reescribe ese deny después.';
+        }
+        else if (recheck.error !== undefined) {
+            target.carriedDenyUnknown = true;
+            note = applied
+                ? ` — Cierre 3 de D2 (C2-3): la renovación de ${membership} SE APLICÓ, pero la re-comprobación de un deny ` +
+                    'concurrente en su grupo falló: no se sabe si un deny entró en la ventana entre los dos Write. Receta: lista los ' +
+                    'denies del grupo (listDenies) y revisa las decisiones de ese sujeto en esa ventana.'
+                : ` — Cierre 3 de D2 (C2-3): la membresía ${membership} quedó BORRADA y la re-comprobación de un deny concurrente ` +
+                    'en su grupo también falló. Receta: vuelve a escribir la membresía (relate) y lista los denies del grupo.';
+        }
+        if (note !== null && typeof target.message === 'string')
+            target.message += note;
+    }
+    catch {
+        // Un error congelado no admite la nota: se propaga el original (la clase y el `code` no cambian).
+    }
+    return error;
+}
 //# sourceMappingURL=openfga_relations_driver.js.map