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

package/build/src/drivers/openfga_relations_driver.js

@@ -29,28 +29,32 @@
  * 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, RenewalRacedError, RenewalUnsafeError, 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 { isActiveExpiry, 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, canonicalRewrite, factsRelationRewrites } 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, assertRelationDenyable, assertDenySubject, assertDenyNoExpiry, denyPhaseOf, deniedRelationOf, storedRelationKind, hasDenyTypes, relationsDown, RELATION_DENY_PREFIX, RELATION_USERSET_RELATION, RELATION_USERSET_TYPE, } from '../relations/define_relations_config.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 { isServerWriteLimit, isTimeoutLike, withDeadline } from '../shared/backend_guard.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** — `--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»).
+ * 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
@@ -127,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`):
@@ -183,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;
@@ -197,13 +239,29 @@ export class OpenFgaRelationsDriver {
     #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).
+     * **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;
@@ -256,18 +314,10 @@ export class OpenFgaRelationsDriver {
         }
         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.`);
-        }
+        // **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,
@@ -289,8 +339,9 @@ 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.
+        // 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). */
@@ -309,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 {
@@ -336,145 +394,68 @@ 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;
-    }
+    /* ── L11: el modelo FIJADO es el que genera la config (una puerta, por tipo) ─────────────────────────── */
     /**
-     * **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.
+     * **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.
      */
-    #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;
+    #modelGate() {
         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;
+        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;
         });
-        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(() => { });
+        memo.gate = pending;
+        pending.catch(() => { });
+        return pending;
     }
     /**
-     * **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.
+     * **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 #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.`);
-        }
+    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>`. */
@@ -599,12 +580,31 @@ export class OpenFgaRelationsDriver {
         const user = this.#subjectUser(subject, partitionKey);
         const key = { user, relation, object: objectId };
         const now = this.#now();
-        await this.#assertModelDeny([object.type]);
+        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;
@@ -620,11 +620,11 @@ export class OpenFgaRelationsDriver {
                 if (carried !== null)
                     throw RenewalUnsafeError.carrier(membership, carried);
             }
-            await this.#guard('relate', () => this.client.write({ deletes: [key] }, IGNORE_MISSING_DELETES));
+            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));
+                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
@@ -652,7 +652,181 @@ export class OpenFgaRelationsDriver {
             }
             return;
         }
-        await this.#guard('relate', () => this.client.write({ writes: [tuple] }, IGNORE_DUPLICATE_WRITES));
+        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
@@ -676,14 +850,16 @@ export class OpenFgaRelationsDriver {
                     // 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)) {
+                        // 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).
-                if (!isActiveExpiry(parent.validUntil ?? null, now))
+                // 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);
@@ -716,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);
@@ -727,10 +903,10 @@ 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.#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
@@ -738,7 +914,7 @@ export class OpenFgaRelationsDriver {
      * 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.
+     * 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);
@@ -750,16 +926,17 @@ 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.#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));
+            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 503 de siempre.
-            if (error?.status === 503 && error?.cause?.statusCode === 409) {
+            // 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}`);
@@ -772,7 +949,7 @@ export class OpenFgaRelationsDriver {
      * **`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 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.
@@ -785,8 +962,8 @@ 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('removeDeny', () => this.client.write({ deletes: [{ user, relation: deniedRelationOf(relation), object: objectId }] }, IGNORE_MISSING_DELETES));
+        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 ───────────────────────────────────────────────────────────── */
     /**
@@ -810,7 +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.#assertModelDeny([object.type]);
+        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;
     }
@@ -834,7 +1011,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));
+        await this.#assertModel('checkMany', distinct.map((object) => object.type));
         const checks = distinct.map((object, i) => ({
             user,
             relation,
@@ -869,13 +1046,13 @@ export class OpenFgaRelationsDriver {
         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();
+        // 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) => {
@@ -884,7 +1061,7 @@ export class OpenFgaRelationsDriver {
             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)}`);
+                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.
@@ -910,27 +1087,9 @@ export class OpenFgaRelationsDriver {
         });
         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
+     * 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`).
@@ -940,19 +1099,27 @@ export class OpenFgaRelationsDriver {
         const phase = denyPhaseOf(this.#config, object.type);
         if (phase === undefined)
             return null;
-        await this.#assertModelDeny([object.type]);
+        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, _page) {
+    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);
@@ -1006,13 +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.#assertModelDeny([objectType]);
+        await this.#assertModel('listObjects', [objectType]);
         const { raw, truncated } = await this.#listObjectsPage({ user, relation, type: objectType, context });
         const objects = [];
         for (const full of raw) {
@@ -1034,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);
@@ -1085,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');
     }
     /**
@@ -1120,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. */
@@ -1162,7 +1353,13 @@ export class OpenFgaRelationsDriver {
                 ...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 };
@@ -1182,6 +1379,7 @@ 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.#purgeByFilters('purgeObject', [[{ object: objectId }, `objeto ${objectId}`]], progress);
@@ -1207,6 +1405,8 @@ 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 {
             await this.#purgeByFilters('purgeSubject', types.map((type) => [{ user, object: `${type}:` }, `sujeto ${user} en '${type}'`]), progress);
@@ -1241,7 +1441,8 @@ export class OpenFgaRelationsDriver {
      * 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.
+     *    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
@@ -1266,7 +1467,7 @@ export class OpenFgaRelationsDriver {
             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));
+                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
@@ -1304,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,
@@ -1322,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) {
@@ -1330,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) {
@@ -1364,23 +1564,18 @@ 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 ` +
+    // 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 });
+            : '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
@@ -1452,4 +1647,3 @@ function annotateRacedDeny(error, membership, recheck, applied = false) {
     }
     return error;
 }
-//# sourceMappingURL=openfga_relations_driver.js.map