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

package/build/src/errors.d.ts

@@ -41,6 +41,18 @@ export declare class AuthorizationBackendTimeoutError extends AuthorizationBacke
     static code: string;
     constructor(driver: string, operation: string, timeoutMs: number, cause?: unknown);
 }
+/**
+ * **El grafo excede lo que el motor resuelve** (lote «antes de RC» · R3, decisión del dueño 2026-10-17 (4)): OpenFGA
+ * respondió `authorization_model_resolution_too_complex` —una cadena de scopes o una anidación de grupos más profunda que
+ * su `--resolve-node-limit`—. Es un `AuthorizationBackendError` (503, se maneja igual y el relay lo trata como
+ * transitorio) con código propio, porque NO es una caída: en el BORDE es probabilístico (a 23 saltos falla entre un 4 % y
+ * un 26 % según la carga, medido en 3b-2e) y un reintento puede acertar, pero por ENCIMA de la cota falla siempre. Las
+ * cotas están en la tabla «Limits» del README (`FACTS_MAX_RESOLVE_DEPTH`). Nunca un `false`: deniega, pero ruidoso.
+ */
+export declare class ResolutionLimitError extends AuthorizationBackendError {
+    static code: string;
+    constructor(driver: string, operation: string, cause?: unknown);
+}
 /**
  * El resolutor de ancestros del consumidor lanzó. Es una dependencia más de
  * cada pregunta (el árbol de scopes), así que su caída se clasifica como la
@@ -135,6 +147,33 @@ export declare function isThenable(value: unknown): boolean;
 export declare function markPartialWrite<E extends object>(error: E): E & {
     partialWrite: true;
 };
+/**
+ * **Marca de fallo de DESPLIEGUE** (lote «antes de RC» · cierre de L11, 🟠 A1 del auditor = H1; adelanta SOLO esta pieza
+ * de la decisión del dueño 2026-10-17 (3), que R3 generaliza con `classifyFgaFailure`): el error dice algo del
+ * DESPLIEGUE —el modelo fijado no es el que genera la config (la puerta L11), o el generador no puede generar con él—,
+ * no de la entrada que se estaba aplicando. Para el relay es TRANSITORIO (`markFailed(…, { transient: true })`: no
+ * consume intento ni aparca): aparcar un `moved`/`detached` por un despliegue a medias era fail-open PERSISTENTE (los
+ * admins de la org vieja conservaban el acceso hasta un `requeue` manual). Para el llamante sigue siendo lo que es
+ * (500 `E_AUTHZ_CONFIG`, «no es transitorio»): la marca es una propiedad, no una clase, y no cambia ni `status` ni
+ * `code`. Interna: no se exporta por `index.ts` (R3 decide la forma pública).
+ */
+export declare function markDeploymentFailure<E extends object>(error: E): E & {
+    deploymentFailure: true;
+};
+/** ¿El error viene marcado como fallo de despliegue (`markDeploymentFailure`)? */
+export declare function isDeploymentFailure(error: unknown): boolean;
+/**
+ * **¿Es un fallo TRANSITORIO para el relay?** (no consume intento ni aparca; `markFailed(…, { transient: true })`).
+ * PUNTO DE PASO ÚNICO de la regla (el manager la llama en cada fallo de la pasada; la guardia `fga.errors.classify` la
+ * juzga sobre las formas medidas). Transitorio: un 503 del backend (`AuthorizationBackendError` y subclases —timeout,
+ * `E_AUTHZ_RESOLUTION_LIMIT`—, o cualquier `status` 503), un fallo marcado de DESPLIEGUE (`markDeploymentFailure`) y
+ * **una CARRERA que escapa** (409 `E_AUTHZ_WRITE_CONFLICT`: otro escritor —un `grant` concurrente sobre la misma
+ * arista `scope#binding` del barrido, o la contención del árbol de `reparent`— llegó antes). Cierre de R3 (🟠 R3-A1 del
+ * auditor, decisión (3) firmada «carrera ⇒ como hoy»: antes de R3 la carrera que escapaba del guard era un 503
+ * transitorio): para el LLAMANTE sigue siendo 409; para el relay, aparcar por contención era H1 (un `moved` aparcado
+ * deja el padre viejo concediendo y tapona su clave). Lo demás —422, 500 sin marca, error sin `status`— cuenta intento.
+ */
+export declare function isTransientRelayFailure(error: unknown): boolean;
 /** ¿El error viene marcado como escritura parcial (`markPartialWrite`)? */
 export declare function isPartialWrite(error: unknown): boolean;
 /**
@@ -156,6 +195,24 @@ export declare class AuthorizationInternalError extends Exception {
 export declare class UnknownScopeError extends Exception {
     static status: number;
     static code: string;
+    /**
+     * **Para el OPERADOR, no para el tenant** (rotación 2 · cierre 2 · RC2-A): en `updateScopedRole`/`deleteScopedRole` el
+     * scope que no resuelve es el OWNER del rol (dormido), que el llamante no pasó y puede ser de otro tenant: el `message`
+     * nombra el rol y el owner va aquí, NO enumerable (mismo patrón que `NotWithinError.details`). Ausente en el resto de
+     * rutas, donde el scope desconocido es el que pasó el llamante y el `message` lo nombra.
+     */
+    readonly details: {
+        owner: {
+            type: string;
+            uuid: string | null;
+        };
+    } | undefined;
+    constructor(message?: string, details?: {
+        owner: {
+            type: string;
+            uuid: string | null;
+        };
+    });
 }
 /**
  * Se preguntó por un scope que no es la raíz y el driver no tiene resolutor
@@ -362,6 +419,14 @@ export declare class RenewalUnsafeError extends Exception {
     static status: number;
     static code: string;
     static carrier(membership: string, denied: string): RenewalUnsafeError;
+    /**
+     * **La clave YA existe con una condición que el paquete no escribe** (lote «antes de RC» · L11, injerto 3 del juez —H8
+     * del auditor—): `relate` (relaciones) o `grant` (roles) de `openfga` sobre una tupla cuya condición es `foreign`
+     * (otra condición, o `not_expired` con un contexto que no es exactamente `{ valid_until }`) o `unparseable`
+     * (`fgaTupleExpiry`). Tratarla como «sin caducidad» era un no-op mudo sobre una tupla que el servidor ignora o evalúa
+     * con otra semántica; como «vencida», una reescritura en dos `Write` sin mirar nada. 409 y CERO escrituras.
+     */
+    static foreignCondition(operation: string, tuple: string, detail: string): RenewalUnsafeError;
 }
 /**
  * **La renovación SE APLICÓ y un deny concurrente cayó en su ventana** (cierre 3 de D2 · 🟡 C2-3; código PROPIO desde el
@@ -411,6 +476,27 @@ export declare class ActorRequiredError extends Exception {
 export declare class NotWithinError extends Exception {
     static status: number;
     static code: string;
+    /**
+     * **Para el OPERADOR, no para el tenant** (rotación 2 de M4 · R2-03, decisión del dueño 2026-10-22 (3)). Hasta
+     * 2.5.0-alpha.4 el `message` imprimía la cadena ENTERA del scope (`unit:<B1x> → unit:<B1> → organization:<org de B>
+     * → app`): el admin de A que conoce un uuid de B aprendía a qué tenant pertenece y su ruta, y un 422 es lo que un
+     * framework devuelve al cliente tal cual (la misma clase de fuga que 3E · Q2 cerró en `ROLE_NOT_VISIBLE`). Ahora el
+     * `message` nombra solo lo que el llamante ya tiene —el scope que pasó y su `within`— y la cadena va aquí, NO
+     * enumerable como `ScopeDepthLimitError.details` (alpha.8): `JSON.stringify(error)` —lo que un handler genérico
+     * manda— no la lleva, y el log del servidor la lee por `error.details.chain`. El CÓDIGO no cambia.
+     */
+    readonly details: {
+        chain: ReadonlyArray<{
+            type: string;
+            uuid: string | null;
+        }>;
+    } | undefined;
+    constructor(message: string, details?: {
+        chain: ReadonlyArray<{
+            type: string;
+            uuid: string | null;
+        }>;
+    });
 }
 /**
  * `config.requireWithin` (`true` o `'non-root'`) y una escritura llegó sin
@@ -495,6 +581,31 @@ export declare class ScopeDepthLimitError extends Exception {
         server: string;
     });
 }
+/**
+ * **La arista de anidación de grupos que el techo del driver no admite** (lote «antes de RC» · R1, decisiones del dueño
+ * 2026-10-17 (5) y (5-bis)): `relate(group:Gc#member, 'member', group:Gp)` dejaría una cadena de grupos anidados MÁS
+ * LARGA que el techo del driver —el camino más largo que atraviesa la arista nueva, hacia arriba y hacia abajo—, cerraría
+ * un CICLO, o el grafo a recorrer pasa de `GROUP_DEPTH_MAX_NODES`. 422 y CERO escrituras: la pregunta está bien formada,
+ * es el grafo el que no cabe. Gemelo de `E_AUTHZ_SCOPE_DEPTH_LIMIT` y con su misma regla de letra (alpha.8, 7.2): el
+ * `message` es para el TENANT (la cadena, el techo, `maxGroupDepth`, «no se ha escrito nada») y no nombra el
+ * backend; el porqué del techo —OpenFGA no resuelve más allá, el mando del servidor es `OPENFGA_RESOLVE_NODE_LIMIT`— va
+ * en `details`, NO enumerable (un handler genérico que serializa el error no se lo enseña al tenant).
+ */
+export declare class GroupDepthLimitError extends Exception {
+    static status: number;
+    static code: string;
+    readonly details: {
+        reason: 'too-deep' | 'cycle' | 'too-many-groups';
+        edge: string;
+        depth: number | null;
+        maxGroupDepth: number;
+        /** Solo con `too-many-groups`: qué cota se pasó (grupos, requests, tuplas leídas o el deadline total). */
+        budget?: 'nodes' | 'reads' | 'tuples' | 'deadline';
+        why: string;
+        server: string;
+    };
+    constructor(message: string, details: GroupDepthLimitError['details']);
+}
 /**
  * Una primitiva de 2.1 necesita un método OPCIONAL del puerto que el driver
  * activo no implementa (2.1, B5): se nombra el método y se lanza. 500 porque
@@ -531,6 +642,33 @@ export declare class UnsupportedOperationError extends Exception {
      * entre procesos (invariante 14); moverla al commit del consumidor lo anula.
      */
     static transactionalCatalog(operation: string): UnsupportedOperationError;
+    /**
+     * **Los `list*` de relaciones no paginan en 2.5** (lote «antes de RC» · 7.4, opción 4 del juez, decisión del dueño
+     * 2026-10-17 (7.4)): `listObjects`/`listSubjects`/`listDenies`/`membersOf` ya no tienen `page` en la firma (nunca
+     * hizo nada: se diseñó en la Fase 4 y no llegó a programarse). Un valor DISTINTO de `undefined` —`null`, `{}`,
+     * `{ limit: 0 }`…— que llegue por JS o `as any` es 500 con cero llamadas al backend, en el manager y en los drivers:
+     * una lista entera que PARECE una página es la ruptura muda que el linaje L8 prohíbe. La paginación de verdad llegará
+     * como métodos aparte (`*Page`, 2.6) con capacidad propia.
+     */
+    static listPage(operation: string, driver: string): UnsupportedOperationError;
+    /**
+     * **Un cursor que este driver nunca emitió** (7.4, injerto 4 del juez; `openfga` y el doble): sus `enumerate*`
+     * devuelven todo en una página y JAMÁS un cursor, así que un `after` no puede haber salido de ellos. 500 con cero
+     * llamadas: aceptarlo en silencio sería empezar «desde algún sitio» o ignorarlo, las dos cosas mudas.
+     */
+    static enumerateCursor(operation: string, driver: string): UnsupportedOperationError;
+}
+/**
+ * **Una página de `enumerate*` mal formada** (lote «antes de RC» · 7.4, injerto 4 del juez; tester H2/H3, auditor T-1):
+ * `limit` que no es un entero ≥ 1 (`NaN`, `0`, negativo, decimal, cadena) o `after` que no es una cadena no vacía (en
+ * `database`, además, con forma de uuid canónico en minúsculas: el cursor que ESE driver emite). 422 porque es la
+ * pregunta la que está mal formada (invariante 5); hasta 7.4 `limit: NaN` generaba una consulta sin `LIMIT` y un
+ * `after` ajeno era un 503 en PostgreSQL (la columna es `uuid`) y un fin silencioso en MySQL/SQLite. Un `limit` por
+ * encima de `RELATIONS_ENUMERATE_MAX_LIMIT` NO es este error: se recorta (con cursor, sin pérdida).
+ */
+export declare class InvalidRelationPageError extends Exception {
+    static status: number;
+    static code: string;
 }
 /**
  * Una vista de `forRequest()` se usó para LEER después de `maxAgeMs` (2D ·
@@ -944,4 +1082,25 @@ export declare class DenyMigrationRefusedError extends Exception {
         message: string;
     }>;
 }
-//# sourceMappingURL=errors.d.ts.map
+/**
+ * **`saveRelationsConfig` se NIEGA a guardar una config que encoge el alcance de un deny vivo** (lote RC · sublote (8);
+ * decisión §2026-10-15 (8) y firmas «(8 · panel)» 2026-10-22): la guarda de `database` con la propiedad «para todo deny
+ * vivo de `authz_relations`, alcance nuevo ⊇ alcance viejo» (`src/relations/deny_reach.ts`). Cero escrituras (ni la fila
+ * ni la versión del catálogo). Lleva `findings` (un hallazgo por tipo/relación: `shrunk`, `orphan` o `no-baseline` —sin
+ * línea base utilizable no se puede juzgar—, con su receta). Salidas con nombre, separadas: `{ establishBaseline: true }`
+ * levanta solo `no-baseline`; `{ allowDenyReachShrink: ['tipo#relación'] }` exime solo esos hallazgos. 500 y no 422 por
+ * precedente (`E_AUTHZ_DENY_MIGRATION_REFUSED`, `E_AUTHZ_MASS_RECONCILE_REFUSED`): no es una pregunta mal formada, es el
+ * estado del despliegue.
+ */
+export declare class DenyReachRefusedError extends Exception {
+    static status: number;
+    static code: string;
+    findings: ReadonlyArray<{
+        objectType: string;
+        relation: string;
+        reason: string;
+        count: number;
+        lost: string[];
+        recipe: string;
+    }>;
+}

package/build/src/errors.js

@@ -45,6 +45,27 @@ export class AuthorizationBackendTimeoutError extends AuthorizationBackendError
         this.message = `El backend de autorización '${driver}' no respondió en ${timeoutMs} ms (${operation})`;
     }
 }
+/**
+ * **El grafo excede lo que el motor resuelve** (lote «antes de RC» · R3, decisión del dueño 2026-10-17 (4)): OpenFGA
+ * respondió `authorization_model_resolution_too_complex` —una cadena de scopes o una anidación de grupos más profunda que
+ * su `--resolve-node-limit`—. Es un `AuthorizationBackendError` (503, se maneja igual y el relay lo trata como
+ * transitorio) con código propio, porque NO es una caída: en el BORDE es probabilístico (a 23 saltos falla entre un 4 % y
+ * un 26 % según la carga, medido en 3b-2e) y un reintento puede acertar, pero por ENCIMA de la cota falla siempre. Las
+ * cotas están en la tabla «Limits» del README (`FACTS_MAX_RESOLVE_DEPTH`). Nunca un `false`: deniega, pero ruidoso.
+ */
+export class ResolutionLimitError extends AuthorizationBackendError {
+    static code = 'E_AUTHZ_RESOLUTION_LIMIT';
+    constructor(driver, operation, cause) {
+        super(driver, operation, cause);
+        this.message =
+            `El backend de autorización '${driver}' no pudo resolver ${operation}: el grafo (la cadena de scopes o la ` +
+                'anidación de grupos) excede lo que OpenFGA resuelve (resolution_too_complex). En el borde es probabilístico y un ' +
+                'reintento puede acertar; por encima de la cota falla siempre: ver «Limits» en el README (FACTS_MAX_RESOLVE_DEPTH ' +
+                'para la cadena de scopes; maxGroupDepth (defineRelationsConfig) para la anidación de grupos —el driver ' +
+                'openfga lo calibra contra el servidor, 22 en v1.19 por defecto—; el mando del servidor es OPENFGA_RESOLVE_NODE_LIMIT / --resolve-node-limit). ' +
+                'Nunca es un «sin permiso».';
+    }
+}
 /**
  * El resolutor de ancestros del consumidor lanzó. Es una dependencia más de
  * cada pregunta (el árbol de scopes), así que su caída se clasifica como la
@@ -177,6 +198,52 @@ export function markPartialWrite(error) {
     }
     return error;
 }
+/**
+ * **Marca de fallo de DESPLIEGUE** (lote «antes de RC» · cierre de L11, 🟠 A1 del auditor = H1; adelanta SOLO esta pieza
+ * de la decisión del dueño 2026-10-17 (3), que R3 generaliza con `classifyFgaFailure`): el error dice algo del
+ * DESPLIEGUE —el modelo fijado no es el que genera la config (la puerta L11), o el generador no puede generar con él—,
+ * no de la entrada que se estaba aplicando. Para el relay es TRANSITORIO (`markFailed(…, { transient: true })`: no
+ * consume intento ni aparca): aparcar un `moved`/`detached` por un despliegue a medias era fail-open PERSISTENTE (los
+ * admins de la org vieja conservaban el acceso hasta un `requeue` manual). Para el llamante sigue siendo lo que es
+ * (500 `E_AUTHZ_CONFIG`, «no es transitorio»): la marca es una propiedad, no una clase, y no cambia ni `status` ni
+ * `code`. Interna: no se exporta por `index.ts` (R3 decide la forma pública).
+ */
+export function markDeploymentFailure(error) {
+    try {
+        Object.defineProperty(error, 'deploymentFailure', { value: true, enumerable: false, configurable: true });
+    }
+    catch {
+        // Un error congelado no admite la marca: se propaga sin ella (cuenta intento, como antes de la marca).
+    }
+    return error;
+}
+/** ¿El error viene marcado como fallo de despliegue (`markDeploymentFailure`)? */
+export function isDeploymentFailure(error) {
+    return error !== null && typeof error === 'object' && error.deploymentFailure === true;
+}
+/**
+ * **¿Es un fallo TRANSITORIO para el relay?** (no consume intento ni aparca; `markFailed(…, { transient: true })`).
+ * PUNTO DE PASO ÚNICO de la regla (el manager la llama en cada fallo de la pasada; la guardia `fga.errors.classify` la
+ * juzga sobre las formas medidas). Transitorio: un 503 del backend (`AuthorizationBackendError` y subclases —timeout,
+ * `E_AUTHZ_RESOLUTION_LIMIT`—, o cualquier `status` 503), un fallo marcado de DESPLIEGUE (`markDeploymentFailure`) y
+ * **una CARRERA que escapa** (409 `E_AUTHZ_WRITE_CONFLICT`: otro escritor —un `grant` concurrente sobre la misma
+ * arista `scope#binding` del barrido, o la contención del árbol de `reparent`— llegó antes). Cierre de R3 (🟠 R3-A1 del
+ * auditor, decisión (3) firmada «carrera ⇒ como hoy»: antes de R3 la carrera que escapaba del guard era un 503
+ * transitorio): para el LLAMANTE sigue siendo 409; para el relay, aparcar por contención era H1 (un `moved` aparcado
+ * deja el padre viejo concediendo y tapona su clave). Lo demás —422, 500 sin marca, error sin `status`— cuenta intento.
+ */
+export function isTransientRelayFailure(error) {
+    if (error instanceof AuthorizationBackendError)
+        return true;
+    if (isDeploymentFailure(error))
+        return true;
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const { status, code } = error;
+    if (code === WriteConflictError.code)
+        return true;
+    return status === 503;
+}
 /** ¿El error viene marcado como escritura parcial (`markPartialWrite`)? */
 export function isPartialWrite(error) {
     return error !== null && typeof error === 'object' && error.partialWrite === true;
@@ -200,6 +267,10 @@ export class AuthorizationInternalError extends Exception {
 export class UnknownScopeError extends Exception {
     static status = 422;
     static code = 'E_AUTHZ_UNKNOWN_SCOPE';
+    constructor(message, details) {
+        super(message);
+        Object.defineProperty(this, 'details', { value: details, enumerable: false, configurable: true, writable: false });
+    }
 }
 /**
  * Se preguntó por un scope que no es la raíz y el driver no tiene resolutor
@@ -428,6 +499,19 @@ export class RenewalUnsafeError extends Exception {
             'membresía ACEPTANDO la ventana — mientras dura, el sujeto no recibe el deny del grupo y concede lo que otro camino le ' +
             'dé y ese deny corte.');
     }
+    /**
+     * **La clave YA existe con una condición que el paquete no escribe** (lote «antes de RC» · L11, injerto 3 del juez —H8
+     * del auditor—): `relate` (relaciones) o `grant` (roles) de `openfga` sobre una tupla cuya condición es `foreign`
+     * (otra condición, o `not_expired` con un contexto que no es exactamente `{ valid_until }`) o `unparseable`
+     * (`fgaTupleExpiry`). Tratarla como «sin caducidad» era un no-op mudo sobre una tupla que el servidor ignora o evalúa
+     * con otra semántica; como «vencida», una reescritura en dos `Write` sin mirar nada. 409 y CERO escrituras.
+     */
+    static foreignCondition(operation, tuple, detail) {
+        return new RenewalUnsafeError(`${operation}: la tupla ${tuple} ya existe en el store con una condición que este paquete no escribe ni sabe leer ` +
+            `(${detail}). No se reescribe a ciegas: el paquete no sabe qué concede (la puede haber escrito otra herramienta, o ` +
+            'un modelo anterior). No se ha escrito nada. Receta: revísala y bórrala a mano (SDK/CLI de OpenFGA, o unrelate/' +
+            'revoke por el paquete) y repite.');
+    }
 }
 /**
  * **La renovación SE APLICÓ y un deny concurrente cayó en su ventana** (cierre 3 de D2 · 🟡 C2-3; código PROPIO desde el
@@ -485,6 +569,10 @@ export class ActorRequiredError extends Exception {
 export class NotWithinError extends Exception {
     static status = 422;
     static code = 'E_AUTHZ_NOT_WITHIN';
+    constructor(message, details) {
+        super(message);
+        Object.defineProperty(this, 'details', { value: details, enumerable: false, configurable: true, writable: false });
+    }
 }
 /**
  * `config.requireWithin` (`true` o `'non-root'`) y una escritura llegó sin
@@ -555,6 +643,24 @@ export class ScopeDepthLimitError extends Exception {
         Object.defineProperty(this, 'details', { value: details, enumerable: false, configurable: true, writable: false });
     }
 }
+/**
+ * **La arista de anidación de grupos que el techo del driver no admite** (lote «antes de RC» · R1, decisiones del dueño
+ * 2026-10-17 (5) y (5-bis)): `relate(group:Gc#member, 'member', group:Gp)` dejaría una cadena de grupos anidados MÁS
+ * LARGA que el techo del driver —el camino más largo que atraviesa la arista nueva, hacia arriba y hacia abajo—, cerraría
+ * un CICLO, o el grafo a recorrer pasa de `GROUP_DEPTH_MAX_NODES`. 422 y CERO escrituras: la pregunta está bien formada,
+ * es el grafo el que no cabe. Gemelo de `E_AUTHZ_SCOPE_DEPTH_LIMIT` y con su misma regla de letra (alpha.8, 7.2): el
+ * `message` es para el TENANT (la cadena, el techo, `maxGroupDepth`, «no se ha escrito nada») y no nombra el
+ * backend; el porqué del techo —OpenFGA no resuelve más allá, el mando del servidor es `OPENFGA_RESOLVE_NODE_LIMIT`— va
+ * en `details`, NO enumerable (un handler genérico que serializa el error no se lo enseña al tenant).
+ */
+export class GroupDepthLimitError extends Exception {
+    static status = 422;
+    static code = 'E_AUTHZ_GROUP_DEPTH_LIMIT';
+    constructor(message, details) {
+        super(message);
+        Object.defineProperty(this, 'details', { value: details, enumerable: false, configurable: true, writable: false });
+    }
+}
 /**
  * Una primitiva de 2.1 necesita un método OPCIONAL del puerto que el driver
  * activo no implementa (2.1, B5): se nombra el método y se lanza. 500 porque
@@ -620,6 +726,46 @@ export class UnsupportedOperationError extends Exception {
                 `removeDeny (hechos) y relate/unrelate/purge* (relaciones) admiten { transaction }.`;
         return error;
     }
+    /**
+     * **Los `list*` de relaciones no paginan en 2.5** (lote «antes de RC» · 7.4, opción 4 del juez, decisión del dueño
+     * 2026-10-17 (7.4)): `listObjects`/`listSubjects`/`listDenies`/`membersOf` ya no tienen `page` en la firma (nunca
+     * hizo nada: se diseñó en la Fase 4 y no llegó a programarse). Un valor DISTINTO de `undefined` —`null`, `{}`,
+     * `{ limit: 0 }`…— que llegue por JS o `as any` es 500 con cero llamadas al backend, en el manager y en los drivers:
+     * una lista entera que PARECE una página es la ruptura muda que el linaje L8 prohíbe. La paginación de verdad llegará
+     * como métodos aparte (`*Page`, 2.6) con capacidad propia.
+     */
+    static listPage(operation, driver) {
+        const error = new UnsupportedOperationError('page', operation, driver);
+        error.message =
+            `${operation}: se pasó una página (page) y ${operation} no pagina en 2.5 — devuelve el conjunto COMPLETO (o ` +
+                `señala truncated), nunca un cursor. No se ha llamado al backend ('${driver}'). Quita el argumento page; la ` +
+                `paginación de los listados llegará como métodos aparte (*Page) con capacidad propia.`;
+        return error;
+    }
+    /**
+     * **Un cursor que este driver nunca emitió** (7.4, injerto 4 del juez; `openfga` y el doble): sus `enumerate*`
+     * devuelven todo en una página y JAMÁS un cursor, así que un `after` no puede haber salido de ellos. 500 con cero
+     * llamadas: aceptarlo en silencio sería empezar «desde algún sitio» o ignorarlo, las dos cosas mudas.
+     */
+    static enumerateCursor(operation, driver) {
+        const error = new UnsupportedOperationError('page.after', operation, driver);
+        error.message =
+            `${operation}: el driver '${driver}' no emite cursor (devuelve todas las tuplas en una página), así que un ` +
+                `page.after no salió de él y no se acepta. No se ha llamado al backend. Llama sin after.`;
+        return error;
+    }
+}
+/**
+ * **Una página de `enumerate*` mal formada** (lote «antes de RC» · 7.4, injerto 4 del juez; tester H2/H3, auditor T-1):
+ * `limit` que no es un entero ≥ 1 (`NaN`, `0`, negativo, decimal, cadena) o `after` que no es una cadena no vacía (en
+ * `database`, además, con forma de uuid canónico en minúsculas: el cursor que ESE driver emite). 422 porque es la
+ * pregunta la que está mal formada (invariante 5); hasta 7.4 `limit: NaN` generaba una consulta sin `LIMIT` y un
+ * `after` ajeno era un 503 en PostgreSQL (la columna es `uuid`) y un fin silencioso en MySQL/SQLite. Un `limit` por
+ * encima de `RELATIONS_ENUMERATE_MAX_LIMIT` NO es este error: se recorta (con cursor, sin pérdida).
+ */
+export class InvalidRelationPageError extends Exception {
+    static status = 422;
+    static code = 'E_AUTHZ_INVALID_PAGE';
 }
 /**
  * Una vista de `forRequest()` se usó para LEER después de `maxAgeMs` (2D ·
@@ -1006,4 +1152,18 @@ export class DenyMigrationRefusedError extends Exception {
     static code = 'E_AUTHZ_DENY_MIGRATION_REFUSED';
     refusals = [];
 }
-//# sourceMappingURL=errors.js.map
+/**
+ * **`saveRelationsConfig` se NIEGA a guardar una config que encoge el alcance de un deny vivo** (lote RC · sublote (8);
+ * decisión §2026-10-15 (8) y firmas «(8 · panel)» 2026-10-22): la guarda de `database` con la propiedad «para todo deny
+ * vivo de `authz_relations`, alcance nuevo ⊇ alcance viejo» (`src/relations/deny_reach.ts`). Cero escrituras (ni la fila
+ * ni la versión del catálogo). Lleva `findings` (un hallazgo por tipo/relación: `shrunk`, `orphan` o `no-baseline` —sin
+ * línea base utilizable no se puede juzgar—, con su receta). Salidas con nombre, separadas: `{ establishBaseline: true }`
+ * levanta solo `no-baseline`; `{ allowDenyReachShrink: ['tipo#relación'] }` exime solo esos hallazgos. 500 y no 422 por
+ * precedente (`E_AUTHZ_DENY_MIGRATION_REFUSED`, `E_AUTHZ_MASS_RECONCILE_REFUSED`): no es una pregunta mal formada, es el
+ * estado del despliegue.
+ */
+export class DenyReachRefusedError extends Exception {
+    static status = 500;
+    static code = 'E_AUTHZ_DENY_REACH_REFUSED';
+    findings = [];
+}

package/build/src/expiry.d.ts

@@ -20,8 +20,57 @@ export declare function isActiveExpiry(expiresAt: Date | null, now?: Date): bool
  * una reescritura (que en openfga es delete+write con ventana de denegación).
  */
 export declare function sameInstant(a: Date | null | undefined, b: Date | null | undefined): boolean;
-/** Lo que devuelve el backend como caducidad (número, ISO, Date) → Date | null. */
+/**
+ * Lo que devuelve el backend SQL como caducidad (número, ISO, Date) → Date | null. **Solo SQL** (`sql_expiry.ts`): una
+ * tupla de OpenFGA se lee con `fgaTupleExpiry` (L11), nunca con esto — aquí una cadena ilegible es `null` =
+ * PERMANENTE, que para una tupla del store era fail-open (C6-1/C6-2).
+ */
 export declare function toExpiryDate(value: unknown): Date | null;
 /** ¿El outcome de un grant cambió la caducidad de una asignación que ya existía? */
 export declare function expiryChanged(outcome: GrantOutcome): boolean;
-//# sourceMappingURL=expiry.d.ts.map
+/**
+ * El nombre de la condición de caducidad que escribe el paquete (`current_time < valid_until`). Es la MISMA cadena que
+ * `FACTS_EXPIRY_CONDITION` del generador del modelo (`openfga_facts.ts` la re-exporta desde aquí: una sola fuente).
+ */
+export declare const FGA_EXPIRY_CONDITION = "not_expired";
+/**
+ * **Lo que dice la condición de una tupla LEÍDA de OpenFGA** (lote «antes de RC» · L11, decisión del dueño 2026-10-17
+ * (1); injerto 2 del juez; F0 · M-a(2)/M-b). Cuatro estados, y ninguno es «permanente» por defecto:
+ *
+ *  - `none`: la tupla no lleva condición. Con el modelo GENERADO toda relación la admite así y el servidor la evalúa
+ *    PERMANENTE (medido, F0 · M-a(2)); la puerta L11 garantiza que el modelo que sirve el driver es ése.
+ *  - `expiry`: `not_expired` con el contexto EXACTAMENTE `{ valid_until }` y una marca RFC3339 de la gramática que
+ *    acepta el servidor. `at` es el milisegundo SIGUIENTE a la fracción (techo al ms: el servidor compara en ns y el
+ *    paquete manda `current_time` en ms, así que `now < at` ⇔ `ns(now) < trunc9(ns(valid_until))`; medido 58/58, el
+ *    `floor` de `new Date()` fallaba 30/60 — F0 · M-b).
+ *  - `foreign`: otra condición (`inverted`…), o `not_expired` con un contexto que trae MÁS que `valid_until` (un
+ *    `current_time` congelado en la tupla gana al de la petición: medido por el auditor, H2). El paquete no la
+ *    escribe y no sabe qué concede.
+ *  - `unparseable`: `not_expired` sin contexto o sin `valid_until` (el servidor responde 400 al evaluarla), o una marca
+ *    que el servidor acepta y este parser no reproduce. Hasta L11 eso era `null` = PERMANENTE (`toExpiryDate`).
+ *
+ * Qué hace cada consumidor con `foreign`/`unparseable` lo decide él, siempre fail-closed (tabla en el README): VIVA
+ * donde la tupla NIEGA o transporta un deny, AUSENTE donde CONCEDE, intocable en el destino de un reconcile, 409 con
+ * receta si una escritura del paquete tendría que reemplazarla, borrada igual en una purga.
+ */
+export type FgaTupleExpiry = {
+    kind: 'none';
+} | {
+    kind: 'expiry';
+    at: Date;
+} | {
+    kind: 'foreign';
+    detail: string;
+} | {
+    kind: 'unparseable';
+    detail: string;
+};
+export declare function fgaTupleExpiry(condition: unknown): FgaTupleExpiry;
+/**
+ * **La gramática de marca de tiempo que acepta OpenFGA v1.19 en `valid_until`, en nanosegundos desde la época**
+ * (F0 · M-b, medido): `YYYY-MM-DDTHH:MM:SS[(.|,)d+](Z|±hh:mm)`, fracción de cualquier longitud TRUNCADA a 9 dígitos
+ * (sin redondeo), coma decimal admitida, desfase con `hh` de 0 a 24 y `mm` de 0 a 59 (`+24:00`/`-24:00`/`+24:01` se
+ * aceptan; `+99:00` no; 25–98 sin medir ⇒ aquí `null`, fail-closed), fecha y hora válidas del calendario gregoriano
+ * proléptico (año 0000–9999; `02-30`, `T24:00:00`, minuto/segundo 60 ⇒ `null`). Todo lo demás ⇒ `null`.
+ */
+export declare function fgaTimestampNs(value: string): bigint | null;

package/build/src/expiry.js

@@ -32,7 +32,11 @@ export function sameInstant(a, b) {
         return false;
     return a.getTime() === b.getTime();
 }
-/** Lo que devuelve el backend como caducidad (número, ISO, Date) → Date | null. */
+/**
+ * Lo que devuelve el backend SQL como caducidad (número, ISO, Date) → Date | null. **Solo SQL** (`sql_expiry.ts`): una
+ * tupla de OpenFGA se lee con `fgaTupleExpiry` (L11), nunca con esto — aquí una cadena ilegible es `null` =
+ * PERMANENTE, que para una tupla del store era fail-open (C6-1/C6-2).
+ */
 export function toExpiryDate(value) {
     if (value === null || value === undefined || value === '')
         return null;
@@ -47,4 +51,94 @@ export function expiryChanged(outcome) {
         outcome.previousExpiresAt !== undefined &&
         !sameInstant(outcome.previousExpiresAt, outcome.expiresAt));
 }
-//# sourceMappingURL=expiry.js.map
+/* ── L11 · la caducidad de una TUPLA de OpenFGA, en UN sitio ───────────── */
+/**
+ * El nombre de la condición de caducidad que escribe el paquete (`current_time < valid_until`). Es la MISMA cadena que
+ * `FACTS_EXPIRY_CONDITION` del generador del modelo (`openfga_facts.ts` la re-exporta desde aquí: una sola fuente).
+ */
+export const FGA_EXPIRY_CONDITION = 'not_expired';
+const NONE = Object.freeze({ kind: 'none' });
+export function fgaTupleExpiry(condition) {
+    if (condition === undefined || condition === null)
+        return NONE;
+    if (typeof condition !== 'object' || Array.isArray(condition)) {
+        return { kind: 'unparseable', detail: `la condición no es un objeto (${JSON.stringify(condition)})` };
+    }
+    const { name, context } = condition;
+    if (typeof name !== 'string' || name === '') {
+        return { kind: 'unparseable', detail: `condición sin nombre (${JSON.stringify(condition)})` };
+    }
+    if (name !== FGA_EXPIRY_CONDITION)
+        return { kind: 'foreign', detail: `condición '${name}'` };
+    if (context === undefined || context === null || typeof context !== 'object' || Array.isArray(context)) {
+        return { kind: 'unparseable', detail: `${FGA_EXPIRY_CONDITION} sin contexto (sin valid_until el servidor responde 400 al evaluarla)` };
+    }
+    const keys = Object.keys(context);
+    if (!keys.includes('valid_until')) {
+        return { kind: 'unparseable', detail: `${FGA_EXPIRY_CONDITION} sin valid_until en el contexto (${keys.join(', ') || 'vacío'})` };
+    }
+    if (keys.length !== 1) {
+        return {
+            kind: 'foreign',
+            detail: `${FGA_EXPIRY_CONDITION} con contexto {${keys.sort().join(', ')}}: el paquete solo escribe {valid_until} (un current_time en la tupla gana al de la petición)`,
+        };
+    }
+    const raw = context.valid_until;
+    const ns = typeof raw === 'string' ? fgaTimestampNs(raw) : null;
+    if (ns === null)
+        return { kind: 'unparseable', detail: `valid_until ilegible (${JSON.stringify(raw)})` };
+    return { kind: 'expiry', at: new Date(Number(ceilDiv(ns, 1000000n))) };
+}
+/**
+ * **La gramática de marca de tiempo que acepta OpenFGA v1.19 en `valid_until`, en nanosegundos desde la época**
+ * (F0 · M-b, medido): `YYYY-MM-DDTHH:MM:SS[(.|,)d+](Z|±hh:mm)`, fracción de cualquier longitud TRUNCADA a 9 dígitos
+ * (sin redondeo), coma decimal admitida, desfase con `hh` de 0 a 24 y `mm` de 0 a 59 (`+24:00`/`-24:00`/`+24:01` se
+ * aceptan; `+99:00` no; 25–98 sin medir ⇒ aquí `null`, fail-closed), fecha y hora válidas del calendario gregoriano
+ * proléptico (año 0000–9999; `02-30`, `T24:00:00`, minuto/segundo 60 ⇒ `null`). Todo lo demás ⇒ `null`.
+ */
+export function fgaTimestampNs(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:[.,](\d+))?(?:(Z)|([+-])(\d{2}):(\d{2}))$/.exec(value);
+    if (!match)
+        return null;
+    const [, ys, mos, ds, hs, mis, ss, fraction, zulu, sign, ohs, oms] = match;
+    const year = Number(ys);
+    const month = Number(mos);
+    const day = Number(ds);
+    const hour = Number(hs);
+    const minute = Number(mis);
+    const second = Number(ss);
+    if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month))
+        return null;
+    if (hour > 23 || minute > 59 || second > 59)
+        return null;
+    let offsetSeconds = 0;
+    if (!zulu) {
+        const offsetHours = Number(ohs);
+        const offsetMinutes = Number(oms);
+        if (offsetHours > 24 || offsetMinutes > 59)
+            return null;
+        offsetSeconds = (sign === '-' ? -1 : 1) * (offsetHours * 3600 + offsetMinutes * 60);
+    }
+    const seconds = BigInt(daysFromCivil(year, month, day)) * 86400n + BigInt(hour * 3600 + minute * 60 + second - offsetSeconds);
+    const nanos = fraction ? BigInt(fraction.slice(0, 9).padEnd(9, '0')) : 0n;
+    return seconds * 1000000000n + nanos;
+}
+function daysInMonth(year, month) {
+    if (month === 2)
+        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0 ? 29 : 28;
+    return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+/** Días desde 1970-01-01 de una fecha del gregoriano proléptico (H. Hinnant, `days_from_civil`). */
+function daysFromCivil(year, month, day) {
+    const y = month <= 2 ? year - 1 : year;
+    const era = Math.floor(y / 400);
+    const yoe = y - era * 400;
+    const doy = Math.floor((153 * (month + (month > 2 ? -3 : 9)) + 2) / 5) + day - 1;
+    const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+    return era * 146_097 + doe - 719_468;
+}
+/** Techo de una división entera de BigInt (la de BigInt trunca hacia cero). */
+function ceilDiv(n, d) {
+    const q = n / d;
+    return n % d !== 0n && n > 0n ? q + 1n : q;
+}

package/build/src/freeze.d.ts

@@ -197,4 +197,3 @@ export declare function releaseFreeze(token: FreezeToken, input: {
 export declare function isOperatorHolder(holder: string | null): boolean;
 /** El `kind` que el holder lleva escrito (`operator:123:ab…` → `operator`); el de operador, por `isOperatorHolder`. */
 export declare function freezeKindOf(holder: string | null): FreezeKind | 'unknown';
-//# sourceMappingURL=freeze.d.ts.map

package/build/src/freeze.js

@@ -303,4 +303,3 @@ export function freezeKindOf(holder) {
     const prefix = holder.slice(0, holder.indexOf(':'));
     return prefix === 'reconcile' || prefix === 'platform' ? prefix : 'unknown';
 }
-//# sourceMappingURL=freeze.js.map

package/build/src/hierarchical_resolver.d.ts

@@ -53,4 +53,3 @@ export interface HierarchicalResolverOptions {
  * ...padres canónicos, APP_SCOPE]`: cada nivel es la fila leída.
  */
 export declare function hierarchicalScopeResolver(options: HierarchicalResolverOptions): ScopeChainResolver;
-//# sourceMappingURL=hierarchical_resolver.d.ts.map

package/build/src/hierarchical_resolver.js

@@ -84,4 +84,3 @@ export function hierarchicalScopeResolver(options) {
         }
     };
 }
-//# sourceMappingURL=hierarchical_resolver.js.map

package/build/src/http/app_access_middleware.d.ts

@@ -22,4 +22,3 @@ export interface AppAccessOptions {
 export default class AppAccessMiddleware {
     handle(ctx: HttpContext, next: NextFn, options: AppAccessOptions): Promise<any>;
 }
-//# sourceMappingURL=app_access_middleware.d.ts.map

package/build/src/http/app_access_middleware.js

@@ -41,4 +41,3 @@ export default class AppAccessMiddleware {
         return next();
     }
 }
-//# sourceMappingURL=app_access_middleware.js.map

package/build/src/http/resource_access_middleware.d.ts

@@ -102,4 +102,3 @@ export interface ResourceAccessOptions {
 export default class ResourceAccessMiddleware {
     handle(ctx: HttpContext, next: NextFn, options: ResourceAccessOptions): Promise<any>;
 }
-//# sourceMappingURL=resource_access_middleware.d.ts.map

package/build/src/http/resource_access_middleware.js

@@ -78,4 +78,3 @@ export default class ResourceAccessMiddleware {
         return next();
     }
 }
-//# sourceMappingURL=resource_access_middleware.js.map