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

package/build/src/drivers/openfga_relations_driver.js

@@ -29,23 +29,42 @@
  * Pureza: vive detrás del subpath `@jantstack/adonis-authz/openfga`
  * (`src/openfga.ts`), como el driver `facts` de roles: es lo único que puede
  * tocar `@openfga/sdk` (peer opcional). La abstracción no filtra: ningún error
- * del SDK escapa (todo va por `#guard`, que clasifica a 503/timeout).
+ * del SDK escapa (todo va por `#guard`, que clasifica con `classifyFgaFailure`, R3).
  */
 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, ResolutionLimitError, UnsupportedOperationError, markDeploymentFailure, 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 { fgaTupleExpiry, isActiveExpiry, resolveGrantExpiry, sameInstant } 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, assertExperimentalOptIn, assertPinnedModel, factsModelDifferences, factsModelDriftError } from './openfga_facts.js';
 import { assertCheckManyObjects, distinctObjects, expandByPosition } from '../relations/check_many.js';
+import { assertEnumeratePage, assertNoListPage } from '../relations/page.js';
 import { assertFgaObjectId, FACTS_EXPIRY_CONDITION, FACTS_GROUP_TYPE, } from './openfga_facts.js';
-import { assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject } from '../relations/define_relations_config.js';
-import { isTimeoutLike, withDeadline } from '../shared/backend_guard.js';
+import { assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject, assertRelationDenyable, assertDenySubject, assertDenyNoExpiry, denyPhaseOf, deniedRelationOf, storedRelationKind, 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 { GROUP_DEPTH_CALIBRATION_BACKOFF_MS, GROUP_DEPTH_RECALIBRATION_MIN_INTERVAL_MS, GroupDepthBudget, assertGroupDepthSettings, calibrateGroupDepth, groupNestingError, groupNestingVerdict, isGroupNesting, plannedByReconcile, } from '../relations/group_depth.js';
+import { fgaFailureError, isServerWriteLimit, 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 PARA EL ESCRITOR (`#purgeByFilters`): una purga que cabe aquí es UN
+ * `Write`, sin PREFIJO que cortar —un `Check` concurrente SÍ puede observar ese `Write` a medias: lector rasgado, fila
+ * «torn read» de Limits, decisión (6a) del dueño—; 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;
 /**
@@ -112,6 +131,42 @@ const IGNORE_DUPLICATE_WRITES = {
 const IGNORE_MISSING_DELETES = {
     conflict: { onMissingDeletes: ClientWriteRequestOnMissingDeletes.Ignore },
 };
+/** La condición de una tupla leída, en la forma de `StoredRelationTuple` (el ÚNICO paso por `fgaTupleExpiry`). */
+function storedCondition(condition) {
+    const expiry = fgaTupleExpiry(condition);
+    if (expiry.kind === 'expiry')
+        return { validUntil: expiry.at };
+    if (expiry.kind === 'none')
+        return { validUntil: null };
+    return { validUntil: null, invalid: `${expiry.kind}: ${expiry.detail}` };
+}
+/**
+ * **El error de una llamada DENTRO de la espera tras una calibración fallida** (cierre-3 de R1 · R-5): una instancia NUEVA
+ * por llamada, con `cause` = el error memorizado. Misma clase, `status`, `code` y `details` que el memorizado, salvo un
+ * TIMEOUT (`AuthorizationBackendTimeoutError`), que pasa a 503 `AuthorizationBackendError` no-timeout: lo que venció fue
+ * la sonda de OTRA llamada; esta no tocó la red y su escritura no ocurrió, así que el manager no debe notificar
+ * `indeterminate` (invariante 13).
+ */
+function backoffError(memorized, remainingMs) {
+    const suffix = ` (la calibración del techo de anidación falló hace poco; en espera ${Math.max(0, Math.ceil(remainingMs))} ms más, sin sondear)`;
+    if (memorized instanceof AuthorizationBackendTimeoutError) {
+        const error = new AuthorizationBackendError('openfga-relations', 'groupDepthLimit', memorized);
+        error.message = `${memorized.message}${suffix}`;
+        return error;
+    }
+    if (!(memorized instanceof Error))
+        return memorized;
+    const copy = Object.create(Object.getPrototypeOf(memorized));
+    for (const key of Reflect.ownKeys(memorized)) {
+        if (key === 'partialWrite' || key === 'stack')
+            continue;
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(memorized, key));
+    }
+    Object.defineProperty(copy, 'message', { value: `${memorized.message}${suffix}`, writable: true, configurable: true, enumerable: false });
+    Object.defineProperty(copy, 'cause', { value: memorized, writable: true, configurable: true, enumerable: false });
+    Error.captureStackTrace?.(copy, backoffError);
+    return copy;
+}
 export class OpenFgaRelationsDriver {
     /**
      * Lo que declara (cada valor tiene su cara en `runRelationsDriverContract`):
@@ -146,6 +201,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
@@ -161,6 +223,8 @@ export class OpenFgaRelationsDriver {
         // ajusta (usa `database` para lo que tenga que ir en su transacción, o
         // `requireTransactionalWrites` para fallar al arrancar).
         transactionalWrites: false,
+        // Estrategia 2.5.0 · firma 4 (regla D15: opcional, normalizada a `false`): EXPERIMENTAL en 2.5.x, como el de roles.
+        experimental: true,
     });
     client;
     #config;
@@ -174,8 +238,30 @@ export class OpenFgaRelationsDriver {
     #listObjectsDeadlineMs;
     #monotonic;
     #logger;
+    /**
+     * **La comparación modelo ↔ config de L11** (`#modelGate`): se lee UNA vez por proceso (`readAuthorizationModel` del
+     * `modelId` fijado, obligatorio) y se comparte con las vistas `withClock` (objeto que se muta). Un fallo transitorio
+     * al leerla no se memoriza (503 y se reintenta en la siguiente).
+     */
+    #modelMemo = {};
+    /**
+     * **La calibración del techo de anidación de grupos** (R1, decisión 5 + 5-bis): UNA por proceso, compartida con las
+     * vistas `withClock` (objeto que se muta, como `#modelMemo`). Se memoriza SOLO el éxito: un fallo (503, deadline, el
+     * 500 de una sonda ciega) no se queda — la siguiente operación vuelve a calibrar (C13a), pero no antes de
+     * `GROUP_DEPTH_CALIBRATION_BACKOFF_MS` (`failure`: hasta entonces se relanza ese mismo error sin sondear; cierre-2 de
+     * R1 · D5). Y un 503 `E_AUTHZ_RESOLUTION_LIMIT` de una lectura invalida el éxito memorizado, como mucho una vez cada
+     * `GROUP_DEPTH_RECALIBRATION_MIN_INTERVAL_MS` (`invalidatedAt`; P2 del juez): el límite BAJADO en el servidor se ve
+     * sin reiniciar la app.
+     */
+    #groupDepthMemo = {};
     diagnostics = { unparseableTuples: 0 };
     constructor(config, options) {
+        // Estrategia 2.5.0 · firma 4: `openfga` es EXPERIMENTAL en 2.5.x. PRIMERA línea: sin el token, 500 sin crear el cliente
+        // (la vista `withClock` reconstruye con las MISMAS opciones, así que hereda el token y vuelve a pasar por aquí).
+        assertExperimentalOptIn('OpenFgaRelationsDriver', options?.experimental);
+        // 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` apagaba el gate en silencio). 500 al construir.
+        assertGroupDepthSettings(config.maxGroupDepth, config.enforceGroupDepth, 'OpenFgaRelationsDriver');
         this.#config = config;
         this.#options = options;
         this.#now = options.now ?? systemClock;
@@ -228,6 +314,10 @@ export class OpenFgaRelationsDriver {
         }
         this.#monotonic = monotonic ?? (() => performance.now());
         this.#logger = options.logger ?? console;
+        // **L11 · `modelId` OBLIGATORIO, siempre** (decisión del dueño 2026-10-17 (2); sustituye a D14 —«solo con deny»— y a
+        // `#assertPinnedForDecideMany`, P5/P6): sin el pin, la puerta L11 compara el modelo del arranque y el servidor
+        // evalúa con el último de AHORA, así que la igualdad no protegería nada.
+        assertPinnedModel('OpenFgaRelationsDriver', options.modelId);
         this.client = new OpenFgaClient({
             apiUrl: options.apiUrl,
             storeId: options.storeId,
@@ -249,6 +339,9 @@ export class OpenFgaRelationsDriver {
         }
         const view = new OpenFgaRelationsDriver(this.#config, { ...this.#options, now });
         view.client = this.client;
+        // La puerta L11 es del PROCESO: la vista comparte la lectura del modelo (el MISMO objeto, que se muta).
+        view.#modelMemo = this.#modelMemo;
+        view.#groupDepthMemo = this.#groupDepthMemo;
         return view;
     }
     /** El `context` de todo `Check`/`ListObjects`: la condición `not_expired` se evalúa contra este instante (un `now` por operación). */
@@ -267,21 +360,28 @@ export class OpenFgaRelationsDriver {
      * que dice «venció el deadline» —503 `E_AUTHZ_BACKEND_TIMEOUT`, indeterminado—,
      * y para lo que el cliente lanza por su cuenta el `isTimeoutLike` ESTRICTO
      * de `backend_guard.ts` (`ECONNABORTED`/`ETIMEDOUT`/`.timeout` numérico/
-     * `KnexTimeoutError`, por la cadena de `cause`). Hasta el cierre-2 este
+     * `KnexTimeoutError` y, desde R3, el `FgaError` sin respuesta, por la cadena de `cause`); el RESTO lo clasifica
+     * `classifyFgaFailure` (R3: transitorio 503, `E_AUTHZ_RESOLUTION_LIMIT` 503, despliegue 500, carrera 409, 4xx
+     * desconocido 500). Hasta el cierre-2 este
      * driver duplicaba la función con una rama por SUBSTRING del mensaje
      * (`/timeout/i`): un error que decía «no es timeout» salía como timeout con
      * `indeterminate: true` sin haber borrado nada, y el docblock afirmaba en
      * falso «mismo criterio que roles».
      */
-    async #guard(operation, fn) {
+    async #guard(operation, fn, write = false) {
         const fail = (error) => {
             // Un error del paquete (422/500 ya clasificado) se propaga tal cual.
             if (error instanceof InvalidIdentityError || error instanceof PurgeIncompleteError)
                 return error;
-            if (isTimeoutLike(error)) {
-                return new AuthorizationBackendTimeoutError('openfga-relations', operation, this.#timeoutMs, error);
-            }
-            return new AuthorizationBackendError('openfga-relations', operation, error);
+            // R3 (decisión del dueño 2026-10-17 (3)): la clase la decide `classifyFgaFailure`, el MISMO punto de paso que el
+            // driver de roles (por `statusCode` + `apiErrorCode`, jamás por el mensaje).
+            // Cierre de R3 (🟡 R3-A2): `write` ⇒ el 504 / `deadline_exceeded` del `Write` es indeterminado (timeout).
+            const failure = fgaFailureError('openfga-relations', operation, error, { timeoutMs: this.#timeoutMs, write });
+            // Cierre-2 de R1 · D5 (P2 del juez): un 503 de profundidad FUERA de la calibración dice que el servidor ya no
+            // resuelve lo que el techo memorizado prometía (límite bajado sin reiniciar la app) ⇒ re-calibrar, acotado.
+            if (failure instanceof ResolutionLimitError && operation !== 'groupDepthLimit')
+                this.#invalidateGroupDepth();
+            return failure;
         };
         let pending;
         try {
@@ -294,6 +394,69 @@ export class OpenFgaRelationsDriver {
             throw fail(error);
         }), this.#timeoutMs, () => new AuthorizationBackendTimeoutError('openfga-relations', operation, this.#timeoutMs));
     }
+    /* ── L11: el modelo FIJADO es el que genera la config (una puerta, por tipo) ─────────────────────────── */
+    /**
+     * **La lectura del modelo, UNA por proceso** (L11; memo compartido con las vistas `withClock` — es un OBJETO que se
+     * MUTA, nunca se reasigna en la vista, H11 b): `readAuthorizationModel` del `modelId` FIJADO (obligatorio desde L11) y
+     * `factsModelDifferences` contra la config de este proceso, con el MISMO mapa de holders que usa `openfga:provision`
+     * (H11 a). Se memoriza el ÉXITO de la lectura —también si hay diferencias: el modelo fijado no cambia (C13 b)— y un
+     * generador que no puede generar (500, H11 d); **un fallo al LEER el modelo NO se memoriza, sea de la clase que sea**
+     * (C13 a; cierre de L11): la siguiente operación vuelve a leer.
+     */
+    #modelGate() {
+        const memo = this.#modelMemo;
+        if (memo.gate)
+            return memo.gate;
+        // Cierre de L11 (🟡-6 del tester): «comparación hecha ⇒ memo» y «fallo al leer el modelo ⇒ no memo», por la FASE y no
+        // por la clase del error — con R3 un 401/403 o un modelo inexistente serán 500 de despliegue y no pueden quedarse
+        // memorizados de por vida en el proceso.
+        let compared = false;
+        const gate = this.#guard('readAuthorizationModel', async () => {
+            const response = await this.client.readAuthorizationModel();
+            const served = response?.authorization_model;
+            if (!Array.isArray(served?.type_definitions)) {
+                throw new Error('la respuesta de ReadAuthorizationModel no trae type_definitions; no se toma por un modelo igual');
+            }
+            return served;
+        }).then((served) => {
+            compared = true;
+            return factsModelDifferences(served, { holderTypes: this.#holderTypes, relations: this.#config, slice: 'relations' });
+        });
+        const pending = gate.catch((error) => {
+            if (!compared && memo.gate === pending)
+                memo.gate = undefined;
+            throw error;
+        });
+        memo.gate = pending;
+        pending.catch(() => { });
+        return pending;
+    }
+    /**
+     * **La puerta L11** (lote «antes de RC», decisión del dueño 2026-10-17 (1); sustituye a P1–P4 —D-31, R2, la excepción
+     * D8 por relación y `#modelDenied`— y a P6 —`#assertPinnedForDecideMany`—): antes de la PRIMERA llamada al servidor
+     * de la operación, el modelo que sirve el driver tiene que ser IGUAL al que genera la config en los tipos que la
+     * operación toca, más `group` (un `group#member` distinto cambia quién es miembro y, con ello, qué concede un `check`
+     * de cualquier tipo), más los holders y las CONDICIONES (deciden la vigencia de toda tupla). Si no, 500
+     * `E_AUTHZ_CONFIG` nombrando las diferencias por ruta y CERO llamadas que evalúen o escriban.
+     *
+     * Sin exenciones (injerto 4 del juez): las purgas y los `list*` pasan la puerta ENTERA —el orden de la purga (L10) se
+     * demostró sobre la semántica de la CONFIG y la vigencia la decide la condición del modelo—; `enumerateRelations(Many)`,
+     * que es el ORIGEN de una migración y tiene que poder rescatar un store con deriva, pasa SOLO la parte `conditions`
+     * (`part: 'conditions'`). El orden en cada operación: la puerta de `{ transaction }`, F-05 y la gramática (422, cero
+     * llamadas) van ANTES; la puerta va justo antes de la primera llamada (H1-5).
+     */
+    async #assertModel(operation, types, part = 'full') {
+        const comparison = await this.#modelGate();
+        const touched = [...types];
+        // Una operación sobre `group` (una membresía) cambia lo que concede o niega CUALQUIER tipo —y su renovación lee los
+        // `denied_*` de los tipos con deny (`#carriedDeny`)—: compara todos los tipos de la config.
+        const groupWide = touched.includes(RELATION_USERSET_TYPE) ? this.#config.objectTypes.map((t) => t.type) : [];
+        const relevant = new Set([...touched, ...groupWide, RELATION_USERSET_TYPE, ...Object.values(this.#holderTypes)]);
+        const hits = comparison.differences.filter((d) => part === 'conditions' ? d.type === null && d.path.startsWith('conditions.') : d.type === null || relevant.has(d.type));
+        if (hits.length > 0)
+            throw factsModelDriftError('OpenFgaRelationsDriver', operation, this.#options.modelId, hits);
+        return comparison;
+    }
     /* ── Composición y parseo de ids (⚪5: partición por string en el id) ────── */
     /** `<type>:<scopeKey(partition)>|<objectUuid>`. */
     #objectId(objectType, partitionKey, objectUuid) {
@@ -380,8 +543,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
@@ -413,18 +580,303 @@ export class OpenFgaRelationsDriver {
         const user = this.#subjectUser(subject, partitionKey);
         const key = { user, relation, object: objectId };
         const now = this.#now();
+        await this.#assertModel('relate', [object.type]);
         const current = await this.#readTuple('relate', key);
+        // L11 · H8: la clave YA existe con una condición que el paquete no escribe (`foreign`) o no sabe leer
+        // (`unparseable`). Tratarla como «sin caducidad» haría de este `relate` un no-op mudo (y la tupla inerte para el
+        // servidor, M-a); como «vencida», una renovación en dos `Write` sin mirar portadoras. 409, cero escrituras, receta.
+        if (current?.invalid !== undefined) {
+            throw RenewalUnsafeError.foreignCondition('relate', `${objectId}#${relation}@${user}`, current.invalid);
+        }
         const previous = current ? current.validUntil : null;
         const expiresAt = resolveGrantExpiry(previous, options?.expiresAt, now);
         if (current && sameInstant(previous, expiresAt))
             return;
+        // R1 (decisión del dueño 2026-10-17 (5)): una arista de anidación que queda VIVA —nueva, renovada o revivida— pasa el
+        // gate del techo (calibrado, o el `maxGroupDepth` menor de la config) ANTES de cualquier `Write`: 422 y cero escrituras.
+        // El no-op idéntico de ARRIBA va ANTES (invariante 6: un `relate` repetido de una arista preexistente no se vuelve 422).
+        if (isGroupNesting(subject, relation, object) &&
+            isActiveExpiry(expiresAt, now) &&
+            !plannedByReconcile(options, partition, { child: subject.object.id, parent: object.id })) {
+            const limit = await this.groupDepthLimit();
+            // El presupuesto (y su deadline TOTAL) empieza DESPUÉS de la calibración: el primer `relate` de un proceso en frío
+            // paga la calibración aparte y no puede dar un 422 espurio por ella (cierre de R1, panel).
+            const budget = new GroupDepthBudget();
+            if (limit !== null)
+                await this.#assertGroupNesting(partitionKey, { child: subject.object.id, parent: object.id }, now, limit, budget);
+        }
         const tuple = expiresAt
             ? { ...key, condition: { name: FACTS_EXPIRY_CONDITION, context: { valid_until: expiresAt.toISOString() } } }
             : key;
         if (current) {
-            await this.#guard('relate', () => this.client.write({ deletes: [key] }, IGNORE_MISSING_DELETES));
+            // 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), true);
+            // 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), true);
+            }
+            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), true);
+    }
+    /**
+     * **El techo de anidación de grupos de ESTE driver** (lote «antes de RC» · R1, decisiones del dueño 2026-10-17 (5) y
+     * (5-bis), opción (a)): ACTIVO por defecto. Se CALIBRA contra el servidor (`#calibratedGroupDepth`) y es el mínimo de
+     * la sonda positiva y la negativa (22 en OpenFGA v1.19 con `--resolve-node-limit` por defecto, medido en F0 · M-c); el
+     * `maxGroupDepth` de la config solo puede BAJARLO — uno mayor que el calibrado es 500 `E_AUTHZ_CONFIG` con las dos
+     * cifras (el despliegue promete un techo que el servidor no resuelve) —, y `false` lo apaga de forma explícita (sin
+     * calibrar). Solo lectura: lo usa `relate` antes de escribir una arista `group#member` y el plan de
+     * `reconcileRelations` sobre el destino.
+     */
+    async groupDepthLimit() {
+        const configured = assertGroupDepthSettings(this.#config.maxGroupDepth, this.#config.enforceGroupDepth, 'OpenFgaRelationsDriver').maxGroupDepth;
+        if (configured === false)
+            return null;
+        const calibrated = await this.#calibratedGroupDepth();
+        if (configured !== undefined && configured > calibrated) {
+            throw Object.assign(new AuthorizationConfigError(`OpenFgaRelationsDriver: maxGroupDepth = ${configured} en la config de relaciones y el servidor solo resuelve ` +
+                `${calibrated} saltos de grupos anidados (calibrado con tuplas contextuales: el mínimo de un miembro y de un ` +
+                'no-miembro con membresía). Un techo por encima del calibrado admitiría cadenas que darán 503 ' +
+                `E_AUTHZ_RESOLUTION_LIMIT a los no-miembros. Baja maxGroupDepth a ≤ ${calibrated}, o sube ` +
+                'OPENFGA_RESOLVE_NODE_LIMIT (--resolve-node-limit) en el servidor y reinicia la app: SUBIR el límite no lo ' +
+                'detecta nada (la calibración se memoriza por proceso); BAJARLO sí, sin reinicio — el 503 de profundidad de ' +
+                'una lectura la re-calibra, como mucho una vez por minuto.'), { details: { maxGroupDepth: configured, calibrated } });
+        }
+        return configured ?? calibrated;
+    }
+    /**
+     * La calibración memorizada (solo el éxito; una en vuelo se comparte). Tras un fallo, durante
+     * `GROUP_DEPTH_CALIBRATION_BACKOFF_MS` se relanza la MISMA CLASE de error sin sondear (cierre-2 de R1 · D5: el backoff);
+     * después se vuelve a calibrar. Cada llamada de la ventana recibe un error NUEVO con `cause` = el memorizado (cierre-3 ·
+     * R-5: compartir la instancia compartía cualquier anotación de un llamador), y un TIMEOUT de la calibración se relanza
+     * como 503 no-timeout: la escritura de la ventana no tocó la red, así que no es indeterminada (invariante 13).
+     */
+    #calibratedGroupDepth() {
+        const memo = this.#groupDepthMemo;
+        if (memo.calibrated)
+            return memo.calibrated;
+        if (memo.failure && this.#monotonic() - memo.failure.at < GROUP_DEPTH_CALIBRATION_BACKOFF_MS) {
+            return Promise.reject(backoffError(memo.failure.error, GROUP_DEPTH_CALIBRATION_BACKOFF_MS - (this.#monotonic() - memo.failure.at)));
+        }
+        const pending = this.#calibrate().then((calibrated) => {
+            if (memo.calibrated === pending)
+                memo.failure = undefined;
+            return calibrated;
+        }, (error) => {
+            if (memo.calibrated === pending) {
+                memo.calibrated = undefined;
+                memo.failure = { at: this.#monotonic(), error };
+            }
+            throw error;
+        });
+        memo.calibrated = pending;
+        pending.catch(() => { });
+        return pending;
+    }
+    /**
+     * **Re-calibración tras un 503 de profundidad** (cierre-2 de R1 · D5 (a), P2 del juez): olvida el techo memorizado para
+     * que la siguiente escritura de anidación lo vuelva a medir, como mucho UNA vez cada
+     * `GROUP_DEPTH_RECALIBRATION_MIN_INTERVAL_MS` por proceso (reloj monótono). Es lo que hace honesta (5-bis) —«nadie
+     * recibe 503 dentro del límite»— cuando el operador BAJA el límite del servidor sin reiniciar; subirlo no da 503 y
+     * sigue pidiendo reinicio. Sin techo memorizado (nunca calibró, o falló) no hay nada que olvidar.
+     */
+    #invalidateGroupDepth() {
+        const memo = this.#groupDepthMemo;
+        if (memo.calibrated === undefined)
+            return;
+        const now = this.#monotonic();
+        if (memo.invalidatedAt !== undefined && now - memo.invalidatedAt < GROUP_DEPTH_RECALIBRATION_MIN_INTERVAL_MS)
+            return;
+        memo.calibrated = undefined;
+        memo.invalidatedAt = now;
+    }
+    /**
+     * **La calibración** (decisión 5: «con tuplas contextuales, solo lectura, forma de dominio»; 5-bis: el MÍNIMO de las
+     * dos sondas): un `Check` con TODO el grafo en `contextual_tuples` sobre ids que no existen en el store —
+     * `<holder>:authz-calibration-member ∈ g0 ⊂ … ⊂ gK` y la relación de DOMINIO del primer tipo declarado sobre
+     * `gK#member` (positiva: T), y `<holder>:authz-calibration-outsider ∈ h0 ⊂ h1` (negativa CON membresía: F; sin
+     * membresías la sonda es CIEGA, M-c) —, siempre con `HIGHER_CONSISTENCY`. Pasa antes la puerta L11 (el modelo fijado es
+     * el de la config). Sin ningún tipo con relación (que acepte `group#member`) calibra con `group#member` y resta 1
+     * (T-4: la forma `member` resuelve un salto más que la de dominio).
+     */
+    async #calibrate() {
+        const domainType = this.#config.objectTypes.find((t) => t.relations.length > 0);
+        const domain = domainType ? { type: domainType.type, relation: domainType.relations[0].name } : null;
+        await this.#assertModel('groupDepthLimit', [domain?.type ?? RELATION_USERSET_TYPE]);
+        const holder = Object.values(this.#holderTypes)[0];
+        if (!holder) {
+            throw new AuthorizationConfigError('OpenFgaRelationsDriver: sin holderTypes no se puede calibrar el techo de anidación de grupos (la sonda necesita un holder).');
+        }
+        const ns = 'authz-calibration';
+        const group = (name) => `${RELATION_USERSET_TYPE}:${ns}|${name}`;
+        const member = `${holder}:${ns}-member`;
+        const outsider = `${holder}:${ns}-outsider`;
+        const context = this.#checkContext(this.#now());
+        const probe = async (depth, side) => {
+            const tuples = [
+                { user: member, relation: RELATION_USERSET_RELATION, object: group('g0') },
+            ];
+            for (let i = 0; i < depth; i++) {
+                tuples.push({ user: `${group(`g${i}`)}#${RELATION_USERSET_RELATION}`, relation: RELATION_USERSET_RELATION, object: group(`g${i + 1}`) });
+            }
+            tuples.push({ user: outsider, relation: RELATION_USERSET_RELATION, object: group('h0') });
+            tuples.push({ user: `${group('h0')}#${RELATION_USERSET_RELATION}`, relation: RELATION_USERSET_RELATION, object: group('h1') });
+            const top = `${group(`g${depth}`)}#${RELATION_USERSET_RELATION}`;
+            const target = domain
+                ? { relation: domain.relation, object: `${domain.type}:${ns}|x` }
+                : { relation: RELATION_USERSET_RELATION, object: group(`g${depth}`) };
+            if (domain)
+                tuples.push({ user: top, relation: domain.relation, object: target.object });
+            try {
+                const response = await this.#guard('groupDepthLimit', () => this.client.check({ user: side === 'positive' ? member : outsider, relation: target.relation, object: target.object, contextualTuples: tuples, context }, { consistency: ConsistencyPreference.HigherConsistency }));
+                return (response?.allowed === true) === (side === 'positive') ? 'ok' : 'blind';
+            }
+            catch (error) {
+                if (error instanceof ResolutionLimitError)
+                    return 'too-complex';
+                throw error;
+            }
+        };
+        const calibrated = await calibrateGroupDepth(probe);
+        return domain ? calibrated : Math.max(0, calibrated - 1);
+    }
+    /**
+     * **El gate de R1 en `openfga`**: lee el grafo de anidación de la partición hacia ARRIBA desde el contenedor (un `Read`
+     * por `user` = `group:<g>#member` y tipo `group:`, por grupo) y hacia ABAJO desde el contenido (un `Read` por objeto
+     * `group:<g>` y relación `member`, que trae también los holders: O(miembros) en una escritura rara, declarado), con la
+     * vigencia del instante de la escritura (una arista vencida no conecta; una con condición `foreign`/`unparseable`
+     * CUENTA: más 422, nunca menos). Concurrencia: dos `relate` que juntas exceden pasan las dos (cada una lee el grafo
+     * sin la otra) — declarado parcial, como `scopes.maxDepth`.
+     *
+     * **Presupuesto** (cierre de R1 · 🟠 1 del auditor): cada página de `Read` pasa por `GroupDepthBudget` —requests,
+     * tuplas leídas (los holders que el `Read` hacia abajo no puede filtrar cuentan) y deadline TOTAL del veredicto—; al
+     * pasarlo, 422 `too-many-groups` sin escribir.
+     */
+    async #assertGroupNesting(partitionKey, edge, now, limit, budget) {
+        const pages = { before: () => budget.beforeRead(), after: (n) => budget.charge(n) };
+        const prefix = `${RELATION_USERSET_TYPE}:${partitionKey}|`;
+        const live = (t) => t.invalid !== undefined || isActiveExpiry(t.validUntil ?? null, now);
+        const idOf = (fullObject) => {
+            const parsed = this.#parseObjectId(fullObject);
+            return parsed && parsed.type === RELATION_USERSET_TYPE && parsed.partitionKey === partitionKey ? parsed.objectUuid : null;
+        };
+        const verdict = await groupNestingVerdict(edge, limit, {
+            parentsOf: async (groups) => {
+                const out = [];
+                for (const child of groups) {
+                    const user = `${prefix}${child}#${RELATION_USERSET_RELATION}`;
+                    for (const t of await this.#readAll('relate', { user, relation: RELATION_USERSET_RELATION, object: `${RELATION_USERSET_TYPE}:` }, pages)) {
+                        const parent = t.user === user && t.relation === RELATION_USERSET_RELATION && live(t) ? idOf(t.object) : null;
+                        if (parent !== null)
+                            out.push({ child, parent });
+                    }
+                }
+                return out;
+            },
+            childrenOf: async (groups) => {
+                const out = [];
+                for (const parent of groups) {
+                    const object = `${prefix}${parent}`;
+                    for (const t of await this.#readAll('relate', { object, relation: RELATION_USERSET_RELATION }, pages)) {
+                        const suffix = `#${RELATION_USERSET_RELATION}`;
+                        if (t.object !== object || t.relation !== RELATION_USERSET_RELATION || !t.user.endsWith(suffix) || !live(t))
+                            continue;
+                        const child = idOf(t.user.slice(0, -suffix.length));
+                        if (child !== null)
+                            out.push({ child, parent });
+                    }
+                }
+                return out;
+            },
+        });
+        if (verdict.kind !== 'ok') {
+            throw groupNestingError('openfga-relations', verdict, `group:${edge.parent}#member@group:${edge.child}#member`, limit);
+        }
+    }
+    /**
+     * **¿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}|`) &&
+                        // L11: un deny con una condición `foreign`/`unparseable` cuenta como VIVO (fail-closed: más 409, nunca menos).
+                        (t.invalid !== undefined || 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).
+                // L11: una arista con condición `foreign`/`unparseable` se sigue (más grupos que mirar: más 409, nunca menos).
+                if (parent.invalid === undefined && !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 };
         }
-        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.
@@ -440,7 +892,7 @@ export class OpenFgaRelationsDriver {
         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) };
+        return { ...key, ...storedCondition(found.condition) };
     }
     async unrelate(subject, relation, object, partition, options) {
         this.#rejectTransaction('unrelate', options);
@@ -451,9 +903,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.#assertModel('unrelate', [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));
+        this.client.write({ deletes: [{ user, relation, object: objectId }] }, IGNORE_MISSING_DELETES), true);
+    }
+    /**
+     * **`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 puerta del modelo (L11). 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.#assertModel('deny', [object.type]);
+        const key = { user, relation: deniedRelationOf(relation), object: objectId };
+        try {
+            await this.#guard('deny', () => this.client.write({ writes: [key] }, IGNORE_DUPLICATE_WRITES), true);
+        }
+        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 409 de la carrera (R3; hasta R3, 503).
+            // R3: el 409 es la clase «carrera» (409 `E_AUTHZ_WRITE_CONFLICT`, antes 503); se mira la CAUSA del SDK.
+            if (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 puerta del modelo (L11, antes D-31) SÍ corre aquí** (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.#assertModel('removeDeny', [object.type]);
+        await this.#guard('removeDeny', () => this.client.write({ deletes: [{ user, relation: deniedRelationOf(relation), object: objectId }] }, IGNORE_MISSING_DELETES), true);
     }
     /* ── Lecturas ───────────────────────────────────────────────────────────── */
     /**
@@ -477,6 +987,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.#assertModel('check', [object.type]);
         const response = await this.#guard('check', () => this.client.check({ user, relation, object: objectId, context }, { consistency: this.#consistency }));
         return response.allowed === true;
     }
@@ -500,6 +1011,7 @@ export class OpenFgaRelationsDriver {
         const user = this.#subjectUser(subject, partitionKey);
         const { distinct, index } = distinctObjects(objects);
         const context = this.#checkContext(this.#now());
+        await this.#assertModel('checkMany', distinct.map((object) => object.type));
         const checks = distinct.map((object, i) => ({
             user,
             relation,
@@ -519,6 +1031,105 @@ 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);
+        const partitionKey = this.#keyOf(partition);
+        const user = this.#subjectUser(subject, partitionKey);
+        const { distinct, index } = distinctObjects(objects);
+        const context = this.#checkContext(this.#now());
+        // L11: con la puerta, el modelo ES el que genera la config (con D8 por TIPO ENTERO): un tipo en forma `deny` declara
+        // `denied_<rel>` para TODAS sus relaciones, uno en forma `plain` para ninguna.
+        const { denyForm } = await this.#assertModel('decideMany', distinct.map((object) => object.type));
+        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 && denyForm.get(object.type) === 'deny';
+            });
+            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]);
+    }
+    /**
+     * **`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 puerta L11 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.#assertModel('denyPhase', [object.type]);
+        return phase;
+    }
+    /** `listDenies` = `Read` por `(object, denied_<rel>)`: los denies DIRECTOS (hechos). Cualquier tipo declarado (D8). */
+    async listDenies(relation, object, partition) {
+        assertRelationDeclared(this.#config, object, relation);
+        assertPartition(partition);
+        // 7.4: sin página (≠ undefined ⇒ 500 con cero llamadas al cliente), después de F-05 y la partición.
+        assertNoListPage('listDenies', arguments[3], 'openfga');
+        const partitionKey = this.#keyOf(partition);
+        const objectId = this.#objectId(object.type, partitionKey, object.id);
+        const now = this.#now();
+        await this.#assertModel('listDenies', [object.type]);
+        const tuples = await this.#readAll('listDenies', { object: objectId, relation: deniedRelationOf(relation) });
+        const subjects = [];
+        for (const t of tuples) {
+            // L11: una condición `foreign`/`unparseable` no se lista (se avisa y se cuenta): el paquete no sabe si está viva.
+            if (t.invalid !== undefined) {
+                this.#warnUnparseable('listDenies', `${t.object}#${t.relation}@${t.user} (${t.invalid})`);
+                continue;
+            }
+            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
@@ -562,12 +1173,14 @@ export class OpenFgaRelationsDriver {
      * 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) {
+    async listObjects(subject, relation, objectType, partition) {
         assertRelationDeclared(this.#config, { type: objectType }, relation);
         assertPartition(partition);
+        assertNoListPage('listObjects', arguments[4], 'openfga');
         const partitionKey = this.#keyOf(partition);
         const user = this.#subjectUser(subject, partitionKey);
         const context = this.#checkContext(this.#now());
+        await this.#assertModel('listObjects', [objectType]);
         const { raw, truncated } = await this.#listObjectsPage({ user, relation, type: objectType, context });
         const objects = [];
         for (const full of raw) {
@@ -589,18 +1202,26 @@ export class OpenFgaRelationsDriver {
      * derivado por includes. `usersetSubjects: true` ⇒ los usersets
      * (`group#member`) salen junto con los holders.
      */
-    async listSubjects(relation, object, partition, _page) {
+    async listSubjects(relation, object, partition) {
         assertRelationDeclared(this.#config, object, relation);
         assertPartition(partition);
+        assertNoListPage('listSubjects', arguments[3], 'openfga');
         const partitionKey = this.#keyOf(partition);
         const objectId = this.#objectId(object.type, partitionKey, object.id);
         // `Read` devuelve tuplas ESCRITAS, no evaluadas: la caducidad se filtra en
         // cliente con el MISMO reloj del driver (R-15, estricta: la que vence en
         // `now` ya no cuenta), como las enumeraciones del driver de roles.
         const now = this.#now();
+        await this.#assertModel('listSubjects', [object.type]);
         const tuples = await this.#readAll('listSubjects', { object: objectId, relation });
         const subjects = [];
         for (const t of tuples) {
+            // L11: una condición `foreign`/`unparseable` NO es un hecho vigente que listar (sería «permanente» por defecto);
+            // se avisa y se cuenta en `diagnostics.unparseableTuples`.
+            if (t.invalid !== undefined) {
+                this.#warnUnparseable('listSubjects', `${t.object}#${t.relation}@${t.user} (${t.invalid})`);
+                continue;
+            }
             if (t.validUntil && t.validUntil.getTime() <= now.getTime())
                 continue;
             const subject = this.#userToSubject(t.user);
@@ -640,13 +1261,26 @@ export class OpenFgaRelationsDriver {
      * la CADUCADA también llega, con su `expiresAt` (R-15), para que el destino
      * la cuente en `skipped`.
      *
+     * **Una tupla con condición AJENA llega marcada** (`invalidCondition`, L11) y
+     * con `expiresAt` = la ÉPOCA. Eso es conservador SOLO para los allows: un
+     * lector que ignore la marca lee el deny (o la membresía de `group` que lo
+     * transporta) como VENCIDO y deja de negar —fail-OPEN— (cierre-2 · ⚪ C3).
+     * Ninguna fecha sirve para los dos tipos de tupla: el lector tiene que mirar
+     * `invalidCondition` ANTES que `expiresAt` (el plan del paquete lo hace).
+     *
      * **Coste: O(tuplas del store) por PASADA** (2.4.0-alpha.6): es un barrido
      * entero por llamada, sea cual sea el tamaño de la partición (medido: 5 000
      * tuplas ⇒ 50 páginas ≈ 170 ms; 15 000 ⇒ 151 páginas ≈ 0,5 s). Para K
      * particiones usa `enumerateRelationsMany`: UN barrido en vez de K.
      */
-    async enumerateRelations(partition, _page) {
+    async enumerateRelations(partition, page) {
         assertPartition(partition);
+        // 7.4 (injerto 4): limit basura ⇒ 422; after ⇒ 500 (este driver no emite cursor: devuelve TODO en una página).
+        // Un limit válido se IGNORA (una página, O(store)): declarado en «Limits».
+        assertEnumeratePage('enumerateRelations', page, 'none', 'openfga');
+        // L11: el ORIGEN de una migración pasa SOLO la parte `conditions` de la puerta (tiene que poder rescatar un store
+        // con deriva de reglas; la vigencia de lo que emite sí depende de la condición del modelo).
+        await this.#assertModel('enumerateRelations', [], 'conditions');
         return this.#sweep([partition], 'enumerateRelations');
     }
     /**
@@ -675,13 +1309,15 @@ export class OpenFgaRelationsDriver {
      * se cuenta en `diagnostics.unparseableTuples` y se avisa. Sin particiones
      * es 500 `E_AUTHZ_CONFIG` con cero lecturas: no hay «éxito vacío».
      */
-    async enumerateRelationsMany(partitions, _page) {
+    async enumerateRelationsMany(partitions, page) {
         if (!Array.isArray(partitions) || partitions.length === 0) {
             throw new AuthorizationConfigError('enumerateRelationsMany: sin particiones no hay nada que enumerar (y un barrido del store para nadie no es un éxito vacío). ' +
                 'Pasa al menos una partición.');
         }
         for (const partition of partitions)
             assertPartition(partition);
+        assertEnumeratePage('enumerateRelationsMany', page, 'none', 'openfga');
+        await this.#assertModel('enumerateRelationsMany', [], 'conditions');
         return this.#sweep(partitions, 'enumerateRelationsMany');
     }
     /** El barrido: UN `Read({})` paginado del store entero, repartido por la clave ENTERA de partición. */
@@ -713,10 +1349,17 @@ 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,
+                // Cierre de L11 (⚪ A3.3 del auditor): con una condición que el paquete no escribe (o no sabe leer) `expiresAt` NO
+                // es `null` sino la ÉPOCA. Cierre-2 (⚪ C3): eso es fail-CLOSED para un allow que lea un tercero sin mirar
+                // `invalidCondition` (lo lee VENCIDO), pero fail-OPEN para un deny o una membresía que transporta uno (deja de negar);
+                // con `null` era al revés. Ninguna fecha vale para los dos: la marca es lo que manda, y VIAJA al plan, que la
+                // clasifica antes de mirar la fecha (`invalid-condition`, L9): nunca se migra ni se poda como sobrante.
+                expiresAt: key.invalid !== undefined ? new Date(0) : key.validUntil,
+                ...(key.invalid !== undefined ? { invalidCondition: key.invalid } : {}),
             });
         }
         return { tuples };
@@ -736,9 +1379,10 @@ export class OpenFgaRelationsDriver {
         assertObjectTypeDeclared(this.#config, object);
         assertPartition(partition);
         const objectId = this.#objectId(object.type, this.#keyOf(partition), object.id);
+        await this.#assertModel('purgeObject', [object.type]);
         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);
@@ -761,11 +1405,11 @@ export class OpenFgaRelationsDriver {
             assertSubject(subject);
         const user = this.#subjectUser(subject, this.#keyOf(partition));
         const types = [FACTS_GROUP_TYPE, ...this.#config.objectTypes.map((t) => t.type)];
+        // Toca TODOS los tipos declarados: la puerta los compara todos.
+        await this.#assertModel('purgeSubject', types);
         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);
@@ -775,7 +1419,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
@@ -790,22 +1434,61 @@ 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 PREFIJO que cortar (atómico para el ESCRITOR: un `Check`
+     *    concurrente puede observar el `Write` a medias —lector rasgado, fila «torn read» de Limits, decisión (6a)—).
+     *  - **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), true);
+            }
+            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 ────────────────────────────────────────────────────────────── */
@@ -822,12 +1505,15 @@ export class OpenFgaRelationsDriver {
      * sondea las cinco operaciones que entran por aquí con un mutante que
      * «termina» en la página vacía.
      */
-    async #readAll(operation, filter) {
+    async #readAll(operation, filter, 
+    /** R1: el presupuesto del gate de anidación (antes de cada página y con las tuplas de cada una). */
+    pageHooks) {
         const keys = [];
         let continuationToken;
         const seenTokens = new Set();
         let pages = 0;
         do {
+            pageHooks?.before();
             const response = await this.#guard(operation, () => this.client.read(filter, {
                 pageSize: READ_PAGE_SIZE,
                 continuationToken,
@@ -840,6 +1526,7 @@ export class OpenFgaRelationsDriver {
             if (!Array.isArray(response?.tuples)) {
                 throw new AuthorizationBackendError('openfga-relations', operation, new Error(`la respuesta del Read (página ${pages}) no trae 'tuples'; no se toma por vacía`));
             }
+            pageHooks?.after(response.tuples.length);
             for (const tuple of response.tuples) {
                 const key = tuple?.key;
                 if (!key?.user || !key?.relation || !key?.object) {
@@ -848,12 +1535,7 @@ export class OpenFgaRelationsDriver {
                 }
                 // Con su caducidad (R-15): quien la lee decide si filtra (`listSubjects`),
                 // la emite (`enumerateRelations`) o la ignora (`purge*` borra TODO).
-                keys.push({
-                    user: key.user,
-                    relation: key.relation,
-                    object: key.object,
-                    validUntil: toExpiryDate(key.condition?.context?.valid_until),
-                });
+                keys.push({ user: key.user, relation: key.relation, object: key.object, ...storedCondition(key.condition) });
             }
             continuationToken = response.continuation_token || undefined;
             if (continuationToken) {
@@ -882,4 +1564,86 @@ 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).
-//# sourceMappingURL=openfga_relations_driver.js.map
+/** La LETRA del 500 de N3 (fijada por `relations_openfga.spec`, «⚪ N3 · …»). */
+function purgeWriteLimitError(operation, size, deleted, cause) {
+    const sdk = cause?.cause?.apiErrorMessage;
+    // R3: es un fallo de DESPLIEGUE (transitorio para el relay), como el que ya clasificó `#guard`.
+    return markDeploymentFailure(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;
+}