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

package/build/src/manager.js

@@ -10,7 +10,7 @@ import { assertKnownScope, canonicalScopeTargets, isAuthzError, resolveChain, ro
 import { CatalogCache, GLOBAL_OWNER_KEY, invalidateAuthzCatalog, isRoleVisibleWith, readLocalRoles, withAuthzCatalogWrite } from './catalog/catalog_cache.js';
 import { assertAssignableAt } from './catalog/catalog.js';
 import { systemClock } from './clock.js';
-import { ActorRequiredError, AuthorizationBackendError, AuthorizationBackendTimeoutError, isPartialWrite, AuthorizationFrozenError, AuthorizationConfigError, AuthorizationInternalError, CatalogConflictError, InvalidIdentityError, MassPurgeRefusedError, PruneInterruptedError, NoDescendantsResolverError, NotWithinError, PermissionNotDelegableError, RankExceededError, RoleImmutableError, RoleLevelAboveOwnerError, ScopeCycleError, ScopeResolverError, TooManyScopesError, UnknownPermissionError, UnknownRoleError, FreezeHeldError, UnsupportedOperationError, ViewExpiredError, WithinRequiredError, WithinRootForbiddenError, ScopeDriftUnguardedError, ScopeDepthLimitError, ScopeRequeueRefusedError, StaleSourceRefusedError, OperatorWindowExpiredError, } from './errors.js';
+import { ActorRequiredError, AuthorizationBackendTimeoutError, isPartialWrite, AuthorizationFrozenError, AuthorizationConfigError, AuthorizationInternalError, CatalogConflictError, InvalidIdentityError, MassPurgeRefusedError, PruneInterruptedError, NoDescendantsResolverError, NotWithinError, PermissionNotDelegableError, RankExceededError, RoleImmutableError, RoleLevelAboveOwnerError, ScopeCycleError, ScopeResolverError, ScopeTreeDriftError, TooManyScopesError, UnknownPermissionError, UnknownRoleError, UnknownScopeError, FreezeHeldError, UnsupportedOperationError, ViewExpiredError, WithinRequiredError, WithinRootForbiddenError, ScopeDriftUnguardedError, ScopeDepthLimitError, ScopeRequeueRefusedError, StaleSourceRefusedError, OperatorWindowExpiredError, isDeploymentFailure, isTransientRelayFailure, markDeploymentFailure, } from './errors.js';
 import { APP_SCOPE_TYPE, normalizeAuthorizationCapabilities } from './types.js';
 import { memoizeAncestors } from './memoize_ancestors.js';
 import { AUTHZ_TABLES_ORIGIN } from './reconcile.js';
@@ -77,6 +77,14 @@ export const DEFAULT_RELAY_BATCH = 100;
 export const DEFAULT_RELAY_LIMIT = 10_000;
 /** Páginas que `authz:reconcile` pasea para MEDIR la ventana del relay (3b-3a). */
 const RELAY_WINDOW_MAX_PAGES = 1_000;
+/**
+ * **Fallos del relay que solo dicen algo de la posición del HIJO** (asentar · cierre 2, O-2 del re-ataque): el
+ * `E_AUTHZ_SCOPE_TREE_DRIFT` del respaldo (el consumidor no pone al hijo bajo el padre ENCOLADO). La pasada contamina
+ * solo la clave del hijo, no la del padre encolado: un `attached` de OTRO hijo bajo ese padre escribe otra arista y
+ * conmuta (la misma lectura que la variante B del censo de aparcadas, alpha.8). Hasta aquí, mientras la entrada fallaba
+ * —hasta `maxAttempts` pasadas, y una más tras cada `requeue`— taponaba la org entera para los hijos nuevos.
+ */
+const CHILD_ONLY_FAILURES = new WeakSet();
 /**
  * **Saltos que la sonda de `only` sigue hacia atrás para heredar el ORIGEN de
  * un bloqueo** (2.4.0-alpha.6). Cada salto es una consulta `earlierPending`
@@ -1214,6 +1222,7 @@ export class AuthorizationManager {
         const parked = new Set();
         /** El último id visto: la outbox pagina desde ahí (lo saltado se queda). */
         let after;
+        const passContext = { outbox, batchSize, appliedThisPass: [] };
         const defer = (item, keys, reason, error, origin) => {
             for (const key of keys)
                 block(key, item.id, origin);
@@ -1295,24 +1304,42 @@ export class AuthorizationManager {
                         }
                     }
                 }
+                let appliedHow;
                 try {
-                    await this.#applyScopeChange(driver, item);
+                    appliedHow = await this.#applyScopeChange(driver, item, passContext);
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
-                    const transient = _a.#isTransientRelayFailure(error);
+                    const transient = isTransientRelayFailure(error);
+                    const code = typeof error?.code === 'string' ? error.code : undefined;
                     await outbox.markFailed(item.id, message, { transient });
-                    for (const key of keys)
+                    const failedKeys = typeof error === 'object' && error !== null && CHILD_ONLY_FAILURES.has(error) ? [scopeKey(item.change.child)] : keys;
+                    for (const key of failedKeys)
                         block(key, item.id, 'failed');
                     parked.add(id);
-                    failures.push({ id: item.id, change: item.change, error: message, transient });
+                    failures.push({
+                        id: item.id,
+                        change: item.change,
+                        error: message,
+                        transient,
+                        ...(code !== undefined ? { code } : {}),
+                        ...(isDeploymentFailure(error) ? { deployment: true } : {}),
+                    });
                     entries.push({ id: item.id, change: item.change, status: 'failed', reason: message, attempts: item.attempts });
                     continue;
                 }
                 await outbox.markApplied(item.id);
                 done.add(id);
                 applied.push({ id: item.id, change: item.change, attempts: item.attempts });
-                entries.push({ id: item.id, change: item.change, status: 'applied', attempts: item.attempts });
+                passContext.appliedThisPass.push(item.change);
+                entries.push({
+                    id: item.id,
+                    change: item.change,
+                    status: 'applied',
+                    attempts: item.attempts,
+                    ...(appliedHow?.reason !== undefined ? { reason: appliedHow.reason } : {}),
+                    ...(appliedHow?.appliedParent !== undefined ? { appliedParent: appliedHow.appliedParent } : {}),
+                });
             }
             // Una outbox que ignora `after` devuelve el mismo lote atascado: la
             // pasada termina aquí en vez de dar vueltas (lo que quede, y lo que
@@ -1380,18 +1407,6 @@ export class AuthorizationManager {
                 'lo que no se pidió (filtra en el puerto, no en memoria).');
         }
     }
-    /**
-     * La caída del BACKEND no dice nada de la entrada (alpha.5 · R2a): un
-     * `AuthorizationBackendError` (503; el timeout es uno), y en general
-     * cualquier 503 (el freeze, el resolutor caído). Todo lo demás —422, 500,
-     * `E_AUTHZ_SCOPE_TREE_DRIFT`, el padre inexistente, un error sin status de
-     * un driver de terceros— es de la entrada y cuenta hacia el aparcado.
-     */
-    static #isTransientRelayFailure(error) {
-        if (error instanceof AuthorizationBackendError)
-            return true;
-        return typeof error === 'object' && error !== null && error.status === 503;
-    }
     /**
      * Las claves de scope de lo APARCADO ⇒ el id aparcado que las nombra
      * (alpha.5 · R2a). El censo lo lee `#relayInputs`: el `dead` ya leído si
@@ -2112,17 +2127,105 @@ export class AuthorizationManager {
      * —el driver demuestra cero o lanza—, arista al final** (S6). Al revés,
      * una purga muerta a medias dejaría grants vivos en un scope sin ancestro,
      * los denies heredados dejarían de aplicar y esos permisos serían
-     * INDENEGABLES (invariante 2).
+     * INDENEGABLES (invariante 2). **Salvo el PADRE** (lote C · TREE): un
+     * `attached`/`moved` se aplica con el padre FRESCO del consumidor, no con
+     * el encolado (ver el cuerpo); devuelve `'superseded'` si el nodo ya no
+     * existe en el consumidor (aplicada sin arista).
      */
-    async #applyScopeChange(driver, item) {
+    async #applyScopeChange(driver, item, context) {
         const change = item.change;
-        if (change.op === 'attached') {
-            await driver.onScopeAttached?.(change.child, change.parent);
-            return;
-        }
-        if (change.op === 'moved') {
-            await driver.onScopeMoved?.(change.child, change.parent);
-            return;
+        if (change.op === 'attached' || change.op === 'moved') {
+            // **Asentar · cierre 1 (B4 del auditor del panel de estrategia)**: el padre FRESCO es SOLO para un driver que
+            // mantiene el árbol como HECHOS en su store (`capabilities.hierarchyFacts`: `openfga`). En `database` no hay árbol
+            // que pueda divergir —decide `resolveChain` en cada pregunta—, así que su relay se comporta EXACTAMENTE como en
+            // `f19fd37`: el padre ENCOLADO, sin resolutor ni modos de fallo nuevos (caso de paridad en `scope_outbox.spec`).
+            if (driver.capabilities?.hierarchyFacts !== true) {
+                if (change.op === 'attached')
+                    await driver.onScopeAttached?.(change.child, change.parent);
+                else
+                    await driver.onScopeMoved?.(change.child, change.parent);
+                return undefined;
+            }
+            // **El relay aplica el padre FRESCO del consumidor** (lote C · TREE, decisión del dueño 2026-10-20 (1), (d)
+            // corregida del juez; 🟠 «TREE con outbox»). El padre ENCOLADO es el que el consumidor quería al notificar, y la
+            // receta publicada notifica ANTES de confirmar la fila: dos `moved` del MISMO nodo pueden confirmar en un orden y
+            // encolarse en el otro, y relevar el padre encolado dejaba el store, para siempre y en silencio, con OTRO padre que
+            // la base del consumidor (medido: 1000/1000 forzado en PG y 200/200 en MySQL). Convergencia (juez TREE §2): la
+            // entrada del ÚLTIMO commit de un nodo se aplica después de ese commit y lee el estado final.
+            //
+            // **Pero el resolutor no es fiable por construcción** (🔴 1 del auditor del paso 4; firma del dueño 2026-10-21): uno
+            // filtrado por tenant responde `null` de todo en un comando (README «the realistic accident») y uno con caché/réplica
+            // responde el padre VIEJO. Aplicar a ciegas convertía un fallo ruidoso en un TREE persistente y MUDO. Regla mínima:
+            // el padre fresco se aplica cuando lo RESPALDA la propia cola —otra entrada del mismo hijo que lo dice (pendiente,
+            // aplicada en esta pasada o aplicada después)—; si no, la entrada FALLA con un error que CONSUME intento (y se aparca
+            // con su motivo tras `maxAttempts`, exit ≠ 0 en cada pasada):
+            //  - cadena con padre = encolado ⇒ se aplica (el caso normal);
+            //  - padre ≠ encolado RESPALDADO (otra entrada del hijo con ese padre) ⇒ se aplica el fresco, `reason:
+            //    'consumer-parent'` y `appliedParent` en el reporte (la carrera S1: el store converge);
+            //  - padre ≠ encolado SIN respaldo ⇒ 500 `E_AUTHZ_SCOPE_TREE_DRIFT` (resolutor rancio, o un cambio no notificado);
+            //    con un resolutor que se refresca (TTL), un reintento posterior ve el padre encolado y lo aplica;
+            //  - `null` RESPALDADO por un `detached` del hijo en la cola ⇒ aplicada SIN arista, `reason: 'superseded'` (D×D no
+            //    resucita un nodo borrado);
+            //  - `null` sin respaldo ⇒ 422 `E_AUTHZ_UNKNOWN_SCOPE` (resolutor filtrado por tenant, o hijo huérfano en la base);
+            //  - cadena TRUNCADA (`[hijo]` de un nodo que no es la raíz: le falta `app`) ⇒ 503 `E_AUTHZ_RESOLVER_FAILED`
+            //    (auditor ⚪ 7: jamás inventar la raíz);
+            //  - el resolutor LANZA ⇒ 503 transitorio, no consume intento (regla de alpha.5);
+            //  - sin `scopes.resolveChain` ⇒ 500 `E_AUTHZ_CONFIG` (desviación 6 del paso 4).
+            // Residuo declarado: con un resolutor rancio Y otra entrada del mismo hijo que respalde justo el padre rancio (dos
+            // movimientos seguidos del nodo dentro del TTL de la caché) el relay no puede distinguirlo de la carrera S1 y aplica;
+            // el reporte lo dice (`consumer-parent`, exit 1 del relay) y la red (`authz:reconcile --dry-run`, su fase `tree`) lo
+            // ve; el campo `drift.treeMismatch` NO existe todavía (llega en 2.6). Límite declarado `openfga.relay.stale-resolver`.
+            let resolver;
+            try {
+                resolver = this.#resolver('authz:scopes:relay');
+            }
+            catch (error) {
+                // Desviación 6 del paso 4, con su caso (asentar · cierre 1, 🟡-3 del tester): un proceso relay sin
+                // `scopes.resolveChain` es un DESPLIEGUE mal configurado ⇒ transitorio para el relay (inv. 5): no consume intento
+                // ni aparca la cola entera. Hasta el caso, el 500 contaba intento y la aparcaba en `maxAttempts` pasadas.
+                throw markDeploymentFailure(error);
+            }
+            const chain = await resolveChain(resolver, change.child, 'authz:scopes:relay');
+            const childKey = scopeKey(change.child);
+            if (chain === null) {
+                if (await this.#relayBacking(context, item, (other) => other.op === 'detached' && scopeKey(other.child) === childKey)) {
+                    return { reason: 'superseded', appliedParent: null };
+                }
+                throw new UnknownScopeError(`authz:scopes:relay: el resolutor del consumidor no conoce ${childKey} (devolvió null) y ninguna entrada ` +
+                    `'detached' de ese nodo en la cola lo respalda. No se aplica nada: un resolutor filtrado por tenant (sin ` +
+                    `petición en el comando) o con caché, o una fila huérfana en tu árbol. El resolutor del relay tiene que leer ` +
+                    `lo CONFIRMADO, sin contexto de tenant. La entrada consume intento y se aparca si persiste.`);
+            }
+            if (chain.length < 2) {
+                throw new ScopeResolverError('authz:scopes:relay', new TypeError(`resolveChain devolvió una cadena de un solo elemento para ${childKey}: le falta la raíz 'app'`));
+            }
+            const parent = chain[1];
+            const parentKey = scopeKey(parent);
+            let reason;
+            if (parentKey !== scopeKey(change.parent)) {
+                const backed = await this.#relayBacking(context, item, (other) => other.op !== 'detached' && scopeKey(other.child) === childKey && scopeKey(other.parent) === parentKey);
+                if (!backed) {
+                    const drift = new ScopeTreeDriftError(`authz:scopes:relay: el padre de ${childKey} que da el resolutor del consumidor (${parentKey}) no es el ` +
+                        `encolado (${scopeKey(change.parent)}) y ninguna otra entrada de ese nodo en la cola lo respalda. No se ` +
+                        `aplica nada: un resolutor con caché o réplica atrasada, o un cambio de árbol no notificado. El resolutor del ` +
+                        `relay tiene que leer lo CONFIRMADO, sin TTL. La entrada consume intento y se aparca si persiste. Si tu base ` +
+                        `ya tiene a ${childKey} bajo ${parentKey} y esta entrada es una intención VIEJA (otra entrada del nodo se ` +
+                        `aplicó antes en otra pasada), la salida es volver a notificar scopes.moved(${childKey}, ${parentKey}) —la ` +
+                        `entrada nueva la respalda— y reencolar #${String(item.id)} con authz:scopes:requeue ` +
+                        `--id=${String(item.id)} --apply. Si ese requeue se niega (E_AUTHZ_REQUEUE_REFUSED) solo por cambios ` +
+                        `aplicados de OTROS hijos bajo ${scopeKey(change.parent)}, el conflicto es falso: authz:scopes:requeue ` +
+                        `--id=${String(item.id)} --force y después authz:scopes:relay (el relay vuelve a resolver el padre en ` +
+                        `fresco y exige respaldo: no revierte nada).`);
+                    CHILD_ONLY_FAILURES.add(drift);
+                    throw drift;
+                }
+                reason = 'consumer-parent';
+            }
+            if (change.op === 'attached')
+                await driver.onScopeAttached?.(change.child, parent);
+            else
+                await driver.onScopeMoved?.(change.child, parent);
+            return { ...(reason !== undefined ? { reason } : {}), appliedParent: parent };
         }
         // La auditoría no pierde al autor por haber pasado por una cola.
         const event = {
@@ -2134,6 +2237,32 @@ export class AuthorizationManager {
         await driver.onScopeDetached?.(change.child);
         await this.#notify(event);
     }
+    /**
+     * **¿La cola RESPALDA el padre fresco?** (asentar · cierre 1, 🔴 1 del auditor). Otra entrada del mismo hijo que lo
+     * dice: aplicada en ESTA pasada, PENDIENTE (cualquier id; se pagina la cola entera, solo cuando el fresco no coincide
+     * con el encolado: raro) o APLICADA con un id posterior (`laterApplied`, si la outbox lo trae). Nunca una aplicada
+     * ANTERIOR de otra pasada: una caché rancia diría justo el padre de esa entrada vieja.
+     */
+    async #relayBacking(context, item, matches) {
+        if (context.appliedThisPass.some(matches))
+            return true;
+        const mine = String(item.id);
+        let after;
+        for (let page = 0; page < RELAY_WINDOW_MAX_PAGES; page++) {
+            const batch = await context.outbox.pending(context.batchSize, after);
+            if (batch.some((other) => String(other.id) !== mine && matches(other.change)))
+                return true;
+            if (batch.length < context.batchSize)
+                break;
+            after = batch[batch.length - 1].id;
+        }
+        if (typeof context.outbox.laterApplied === 'function') {
+            const later = await context.outbox.laterApplied(item.id, [item.change.child], RELAY_WINDOW_MAX_PAGES);
+            if (later.some((other) => matches(other.change)))
+                return true;
+        }
+        return false;
+    }
     /** Cota entera positiva de las opciones del relay (500 si llega otra cosa). */
     /**
      * **Una opción desconocida es 500, nunca silencio** (2.4.0-alpha.8 · X-1;
@@ -3826,4 +3955,3 @@ export class AuthorizationManager {
     }
 }
 _a = AuthorizationManager;
-//# sourceMappingURL=manager.js.map

package/build/src/memoize_ancestors.d.ts

@@ -20,4 +20,3 @@ import type { ScopeChainResolver } from './types.js';
  * respétala tú.
  */
 export declare function memoizeAncestors(resolver: ScopeChainResolver): ScopeChainResolver;
-//# sourceMappingURL=memoize_ancestors.d.ts.map

package/build/src/memoize_ancestors.js

@@ -39,4 +39,3 @@ export function memoizeAncestors(resolver) {
         return pending;
     };
 }
-//# sourceMappingURL=memoize_ancestors.js.map

package/build/src/models/authz_assignment.d.ts

@@ -77,6 +77,11 @@ declare const AuthzAssignment_base: {
         <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
         <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
     };
+    before: {
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -113,11 +118,6 @@ declare const AuthzAssignment_base: {
     };
     $defineProperty: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model>(this: Model, propertyName: Prop, defaultValue: Model[Prop], strategy: "inherit" | "define" | ((value: Model[Prop]) => Model[Prop])) => void;
     boot: () => void;
-    before: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
-    };
     create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
@@ -163,4 +163,3 @@ export default class AuthzAssignment extends AuthzAssignment_base {
     createdAt: DateTime;
 }
 export {};
-//# sourceMappingURL=authz_assignment.d.ts.map

package/build/src/models/authz_assignment.js

@@ -57,4 +57,3 @@ __decorate([
     column.dateTime({ autoCreate: true, columnName: 'created_at' }),
     __metadata("design:type", DateTime)
 ], AuthzAssignment.prototype, "createdAt", void 0);
-//# sourceMappingURL=authz_assignment.js.map

package/build/src/models/authz_deny.d.ts

@@ -75,6 +75,11 @@ declare const AuthzDeny_base: {
         <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
         <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
     };
+    before: {
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -111,11 +116,6 @@ declare const AuthzDeny_base: {
     };
     $defineProperty: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model>(this: Model, propertyName: Prop, defaultValue: Model[Prop], strategy: "inherit" | "define" | ((value: Model[Prop]) => Model[Prop])) => void;
     boot: () => void;
-    before: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
-    };
     create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
@@ -158,4 +158,3 @@ export default class AuthzDeny extends AuthzDeny_base {
     createdAt: DateTime;
 }
 export {};
-//# sourceMappingURL=authz_deny.d.ts.map

package/build/src/models/authz_deny.js

@@ -47,4 +47,3 @@ __decorate([
     column.dateTime({ autoCreate: true, columnName: 'created_at' }),
     __metadata("design:type", DateTime)
 ], AuthzDeny.prototype, "createdAt", void 0);
-//# sourceMappingURL=authz_deny.js.map

package/build/src/models/authz_permission.d.ts

@@ -75,6 +75,11 @@ declare const AuthzPermission_base: {
         <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
         <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
     };
+    before: {
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -111,11 +116,6 @@ declare const AuthzPermission_base: {
     };
     $defineProperty: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model>(this: Model, propertyName: Prop, defaultValue: Model[Prop], strategy: "inherit" | "define" | ((value: Model[Prop]) => Model[Prop])) => void;
     boot: () => void;
-    before: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
-    };
     create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
@@ -162,4 +162,3 @@ export default class AuthzPermission extends AuthzPermission_base {
     updatedAt: DateTime;
 }
 export {};
-//# sourceMappingURL=authz_permission.d.ts.map

package/build/src/models/authz_permission.js

@@ -43,4 +43,3 @@ __decorate([
     column.dateTime({ autoCreate: true, autoUpdate: true, columnName: 'updated_at' }),
     __metadata("design:type", DateTime)
 ], AuthzPermission.prototype, "updatedAt", void 0);
-//# sourceMappingURL=authz_permission.js.map

package/build/src/models/authz_role.d.ts

@@ -77,6 +77,11 @@ declare const AuthzRole_base: {
         <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
         <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
     };
+    before: {
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -113,11 +118,6 @@ declare const AuthzRole_base: {
     };
     $defineProperty: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model>(this: Model, propertyName: Prop, defaultValue: Model[Prop], strategy: "inherit" | "define" | ((value: Model[Prop]) => Model[Prop])) => void;
     boot: () => void;
-    before: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
-    };
     create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
@@ -170,4 +170,3 @@ export default class AuthzRole extends AuthzRole_base {
     updatedAt: DateTime;
 }
 export {};
-//# sourceMappingURL=authz_role.d.ts.map

package/build/src/models/authz_role.js

@@ -68,4 +68,3 @@ __decorate([
     column.dateTime({ autoCreate: true, autoUpdate: true, columnName: 'updated_at' }),
     __metadata("design:type", DateTime)
 ], AuthzRole.prototype, "updatedAt", void 0);
-//# sourceMappingURL=authz_role.js.map

package/build/src/models/authz_role_permission.d.ts

@@ -75,6 +75,11 @@ declare const AuthzRolePermission_base: {
         <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
         <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
     };
+    before: {
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -111,11 +116,6 @@ declare const AuthzRolePermission_base: {
     };
     $defineProperty: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model>(this: Model, propertyName: Prop, defaultValue: Model[Prop], strategy: "inherit" | "define" | ((value: Model[Prop]) => Model[Prop])) => void;
     boot: () => void;
-    before: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends "find" | "fetch">(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, Event>): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
-    };
     create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
@@ -152,4 +152,3 @@ export default class AuthzRolePermission extends AuthzRolePermission_base {
     createdAt: DateTime;
 }
 export {};
-//# sourceMappingURL=authz_role_permission.d.ts.map

package/build/src/models/authz_role_permission.js

@@ -32,4 +32,3 @@ __decorate([
     column.dateTime({ autoCreate: true, columnName: 'created_at' }),
     __metadata("design:type", DateTime)
 ], AuthzRolePermission.prototype, "createdAt", void 0);
-//# sourceMappingURL=authz_role_permission.js.map

package/build/src/openfga.d.ts

@@ -24,6 +24,5 @@ export type { OpenFgaRelationsDriverOptions } from './drivers/openfga_relations_
  * JSON y cadenas—, pero se publica por esta misma puerta: es material de
  * OpenFGA y solo lo usa quien lo elige.
  */
-export { openFgaFactsModel, factsRelationsOf, factsRelationMap, factsCatalogTuples, factsTupleId, factsModelBytes, assertFactsModelPublishable, assertFgaObjectId, FACTS_MODEL_MAX_BYTES, FACTS_MODEL_WARN_RATIO, FGA_MAX_RELATION_NAME, FGA_MAX_OBJECT_ID, FACTS_MAX_RESOLVE_DEPTH, FGA_MAX_BATCH_CHECK, factsScopeObject, factsParentTuple, FACTS_SCOPE_TYPE, FACTS_PARENT_RELATION, factsRootTuples, FACTS_ROOTED_RELATION, factsRelationTypeDefinitions, assertRelationsConfigPublishable, RESERVED_FACTS_TYPES, FACTS_GROUP_TYPE, FACTS_GROUP_MEMBER_RELATION, } from './drivers/openfga_facts.js';
-export type { FactsRelations, FactsCatalogTuple, FactsTuple, FactsRelationsConfig, RelationObjectType, RelationObjectRelation, } from './drivers/openfga_facts.js';
-//# sourceMappingURL=openfga.d.ts.map
+export { openFgaFactsModel, factsRelationsOf, factsRelationMap, factsCatalogTuples, factsTupleId, factsModelBytes, assertFactsModelPublishable, assertFgaObjectId, FACTS_MODEL_MAX_BYTES, FACTS_MODEL_WARN_RATIO, FGA_MAX_RELATION_NAME, FGA_MAX_OBJECT_ID, FACTS_MAX_RESOLVE_DEPTH, FGA_MAX_BATCH_CHECK, factsScopeObject, factsParentTuple, FACTS_SCOPE_TYPE, FACTS_PARENT_RELATION, factsRootTuples, FACTS_ROOTED_RELATION, factsRelationTypeDefinitions, assertRelationsConfigPublishable, RESERVED_FACTS_TYPES, FACTS_GROUP_TYPE, FACTS_GROUP_MEMBER_RELATION, factsModelDifferences, } from './drivers/openfga_facts.js';
+export type { FactsModelComparison, FactsModelDifference, FactsModelSlice, FactsRelations, FactsCatalogTuple, FactsTuple, FactsRelationsConfig, RelationObjectType, RelationObjectRelation, } from './drivers/openfga_facts.js';

package/build/src/openfga.js

@@ -22,5 +22,7 @@ export { OpenFgaRelationsDriver, DEFAULT_LIST_OBJECTS_DEADLINE_MS, LIST_OBJECTS_
  * JSON y cadenas—, pero se publica por esta misma puerta: es material de
  * OpenFGA y solo lo usa quien lo elige.
  */
-export { openFgaFactsModel, factsRelationsOf, factsRelationMap, factsCatalogTuples, factsTupleId, factsModelBytes, assertFactsModelPublishable, assertFgaObjectId, FACTS_MODEL_MAX_BYTES, FACTS_MODEL_WARN_RATIO, FGA_MAX_RELATION_NAME, FGA_MAX_OBJECT_ID, FACTS_MAX_RESOLVE_DEPTH, FGA_MAX_BATCH_CHECK, factsScopeObject, factsParentTuple, FACTS_SCOPE_TYPE, FACTS_PARENT_RELATION, factsRootTuples, FACTS_ROOTED_RELATION, factsRelationTypeDefinitions, assertRelationsConfigPublishable, RESERVED_FACTS_TYPES, FACTS_GROUP_TYPE, FACTS_GROUP_MEMBER_RELATION, } from './drivers/openfga_facts.js';
-//# sourceMappingURL=openfga.js.map
+export { openFgaFactsModel, factsRelationsOf, factsRelationMap, factsCatalogTuples, factsTupleId, factsModelBytes, assertFactsModelPublishable, assertFgaObjectId, FACTS_MODEL_MAX_BYTES, FACTS_MODEL_WARN_RATIO, FGA_MAX_RELATION_NAME, FGA_MAX_OBJECT_ID, FACTS_MAX_RESOLVE_DEPTH, FGA_MAX_BATCH_CHECK, factsScopeObject, factsParentTuple, FACTS_SCOPE_TYPE, FACTS_PARENT_RELATION, factsRootTuples, FACTS_ROOTED_RELATION, factsRelationTypeDefinitions, assertRelationsConfigPublishable, RESERVED_FACTS_TYPES, FACTS_GROUP_TYPE, FACTS_GROUP_MEMBER_RELATION, 
+// L11 (lote «antes de RC»): la comparación modelo servido ↔ config, la que usan las dos puertas y la relectura de
+// `openfga:provision`.
+factsModelDifferences, } from './drivers/openfga_facts.js';

package/build/src/reconcile.d.ts

@@ -34,4 +34,3 @@ export declare function reconcileMaxTuples(value: number | undefined): number;
 export declare function emptyReconcileCounts(): ReconcileCounts;
 export declare function emptyReconcilePhases(): Record<ReconcileFamily, ReconcileCounts>;
 export declare function sumReconcilePhases(phases: Record<ReconcileFamily, ReconcileCounts>): ReconcileCounts;
-//# sourceMappingURL=reconcile.d.ts.map

package/build/src/reconcile.js

@@ -66,4 +66,3 @@ export function sumReconcilePhases(phases) {
     }
     return total;
 }
-//# sourceMappingURL=reconcile.js.map

package/build/src/relation_partition_trigger.d.ts

@@ -5,4 +5,3 @@ export declare function relationPartitionTrigger(dialect: string): string[];
 /** Las sentencias para soltar el trigger (y, en PG, su función) en el `down()`. */
 export declare function relationPartitionTriggerDrops(dialect: string): string[];
 export {};
-//# sourceMappingURL=relation_partition_trigger.d.ts.map

package/build/src/relation_partition_trigger.js

@@ -90,4 +90,3 @@ export function relationPartitionTriggerDrops(dialect) {
         'DROP TRIGGER IF EXISTS authz_relations_partition_bu',
     ];
 }
-//# sourceMappingURL=relation_partition_trigger.js.map

package/build/src/relations/check_many.d.ts

@@ -14,4 +14,3 @@ export declare function distinctObjects(objects: RelObject[]): {
 };
 /** Reparte las respuestas de los objetos DISTINTOS a las posiciones del lote. */
 export declare function expandByPosition(index: number[], answers: boolean[]): boolean[];
-//# sourceMappingURL=check_many.d.ts.map

package/build/src/relations/check_many.js

@@ -56,4 +56,3 @@ export function distinctObjects(objects) {
 export function expandByPosition(index, answers) {
     return index.map((at) => answers[at]);
 }
-//# sourceMappingURL=check_many.js.map

package/build/src/relations/define_relations_config.d.ts

@@ -48,10 +48,10 @@ export type RelationDenyPhase = 'read' | 'write';
  * Las claves del lote D entran AQUÍ, en el mismo commit que su efecto.
  */
 export declare const RELATIONS_SPEC_KEYS: Readonly<{
-    root: readonly ["objectTypes", "holderTypes", "database"];
+    root: readonly ["objectTypes", "holderTypes", "database", "maxGroupDepth"];
     objectType: readonly ["type", "relations", "deny"];
     relation: readonly ["name", "includes"];
-    database: readonly ["membersOf"];
+    database: readonly ["membersOf", "enforceGroupDepth"];
 }>;
 /** Una relación de un tipo de objeto (`document#viewer`), con sus `includes` de un nivel. */
 export interface RelationObjectRelationSpec {
@@ -87,6 +87,15 @@ export interface RelationsDatabaseOptions {
      * `database`.
      */
     membersOf?: boolean;
+    /**
+     * **El límite de anidación de grupos en `database`, OPT-IN** (lote «antes de RC» · R1, decisión del dueño 2026-10-17
+     * (5): «`database` SIN límite por defecto —no tiene techo técnico—, opt-in con mando explícito aparte del número»).
+     * `true` ⇒ el driver `database` rechaza con 422 `E_AUTHZ_GROUP_DEPTH_LIMIT` la arista `group#member` que deje una
+     * cadena más larga que `maxGroupDepth` (que entonces es OBLIGATORIO y numérico: 500 al arrancar si no). Mando aparte
+     * a propósito (V2-4 del auditor): el `maxGroupDepth` que pones para tu CI `openfga` NO activa el gate en tu producción
+     * `database`. Default `false`.
+     */
+    enforceGroupDepth?: boolean;
 }
 /** La config que declara el consumidor. */
 export interface RelationsConfigSpec {
@@ -100,12 +109,26 @@ export interface RelationsConfigSpec {
     holderTypes?: readonly string[];
     /** Opciones del driver `database` (donde vive `membersOf`). */
     database?: RelationsDatabaseOptions;
+    /**
+     * **El techo de anidación de grupos que declara la APP** (lote «antes de RC» · R1, decisiones del dueño 2026-10-17 (5)
+     * y (5-bis)): saltos `group⊂group` del camino MÁS LARGO. Cada driver declara su techo — `openfga` lo CALIBRA contra
+     * el servidor al primer uso (22 en OpenFGA v1.19 por defecto) y lo aplica SIEMPRE; `database` no tiene ninguno salvo
+     * `database.enforceGroupDepth` —; este valor solo puede BAJAR el de `openfga` (uno mayor que el calibrado ⇒ 500
+     * `E_AUTHZ_CONFIG` al calibrar, con las dos cifras) y es EL número en `database` con el opt-in. Entero 1..97 o `false`
+     * (apaga el de `openfga`, de forma explícita); cualquier otro valor ⇒ 500 al ARRANCAR. El paquete no lee variables de
+     * entorno: valida la tuya (`Env.schema.number.optional()`) y pásala aquí.
+     */
+    maxGroupDepth?: number | false;
 }
 /** La config ya validada y CONGELADA que consulta el manager de relaciones. */
 export interface RelationsConfig {
     readonly objectTypes: readonly RelationObjectTypeSpec[];
     /** ¿`membersOf` está habilitado (opción de `database`)? */
     readonly membersOf: boolean;
+    /** R1: el techo de anidación de grupos declarado por la app (`undefined` = el del driver; `false` = apagado explícito). */
+    readonly maxGroupDepth?: number | false;
+    /** R1: ¿el driver `database` aplica `maxGroupDepth`? (opt-in, `database.enforceGroupDepth`). */
+    readonly enforceGroupDepth?: boolean;
     /** ¿Existe el tipo de objeto? (F-05, cara del tipo). */
     hasType(objectType: string): boolean;
     /** ¿La relación está declarada para ese tipo? (F-05, cara de la relación). */
@@ -292,4 +315,3 @@ export declare function assertDenySubject(subject: unknown): void;
  * versión la lea como «permanente» sin que nadie lo decidiera.
  */
 export declare function assertDenyNoExpiry(options: unknown): void;
-//# sourceMappingURL=define_relations_config.d.ts.map