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

package/build/src/testing/main.js

@@ -13,4 +13,3 @@ export { runRelationsDriverContract, registerRelationsDriverContract, makeRelati
 export { createTestClock } from './test_clock.js';
 export { runRelationsReconcileContract, registerRelationsReconcileContract, } from './relations_reconcile_contract.js';
 export { runScopeOutboxContract, registerScopeOutboxContract, makeScopeOutbox, SCOPE_OUTBOX_CAPABILITY_KEYS, } from './scope_outbox_contract.js';
-//# sourceMappingURL=main.js.map

package/build/src/testing/migration_contract.d.ts

@@ -290,4 +290,3 @@ export declare function runMigrationDirection(harness: MigrationContractHarness,
  */
 export declare function runMigrationContract(harness: MigrationContractHarness): void;
 export declare function registerMigrationContract(harness: MigrationContractHarness, api: ContractTestApi): void;
-//# sourceMappingURL=migration_contract.d.ts.map

package/build/src/testing/migration_contract.js

@@ -586,4 +586,3 @@ export function registerMigrationContract(harness, api) {
         }
     });
 }
-//# sourceMappingURL=migration_contract.js.map

package/build/src/testing/relations_contract.d.ts

@@ -22,6 +22,13 @@ export declare const RELATIONS_CONTRACT_OBJECT_TYPES: readonly ["document", "wor
  * editor ⊆ viewer` (includes de un nivel) y `membersOf` habilitado en `database`.
  */
 export declare function contractRelationsConfig(): RelationsConfig;
+/**
+ * **La config del contrato CON techo de anidación de grupos** (lote «antes de RC» · R1, cierre: el runner publicado no
+ * tenía ningún caso del techo y un driver de terceros no tenía juez): la MISMA config que `contractRelationsConfig` con
+ * `maxGroupDepth` (por defecto 3) y el opt-in de `database` (`database.enforceGroupDepth`). Un driver que declare
+ * `groupDepthLimit()` tiene que responder con un techo ≤ ese número (la config solo BAJA el del driver) y aplicarlo.
+ */
+export declare function contractGroupDepthRelationsConfig(maxGroupDepth?: number): RelationsConfig;
 /**
  * **La config del contrato CON deny** (plan 2.5 · lote D · D1): los MISMOS dos tipos con el mismo retículo y, además,
  * un tercero sin opt-in —para que «deny sobre un tipo sin deny ⇒ 422» y «D8: un tipo sin opt-in también honra»
@@ -102,4 +109,3 @@ export declare function registerRelationsDriverContract(harness: RelationsDriver
     registered: number;
     covered: Set<keyof RelationsDriverCapabilities>;
 };
-//# sourceMappingURL=relations_contract.d.ts.map

package/build/src/testing/relations_contract.js

@@ -25,6 +25,7 @@ import { RenewalUnsafeError } from '../errors.js';
 import { RelationsManager } from '../relations/manager.js';
 import { defineRelationsConfig, assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject, assertRelationDenyable, assertDenySubject, assertDenyNoExpiry, cutPathAllows, decideFrom, deniedRelationOf, denyPhaseOf, storedRelationKind, relationsDown, RELATION_DENY_PREFIX, } from '../relations/define_relations_config.js';
 import { assertCheckManyObjects, distinctObjects, expandByPosition, RELATIONS_CHECK_MANY_MAX } from '../relations/check_many.js';
+import { assertEnumeratePage, assertNoListPage } from '../relations/page.js';
 import { systemClock } from '../clock.js';
 import { resolveGrantExpiry, sameInstant } from '../expiry.js';
 import { isRelUserset } from '../types.js';
@@ -59,6 +60,23 @@ export function contractRelationsConfig() {
         database: { membersOf: true },
     });
 }
+/**
+ * **La config del contrato CON techo de anidación de grupos** (lote «antes de RC» · R1, cierre: el runner publicado no
+ * tenía ningún caso del techo y un driver de terceros no tenía juez): la MISMA config que `contractRelationsConfig` con
+ * `maxGroupDepth` (por defecto 3) y el opt-in de `database` (`database.enforceGroupDepth`). Un driver que declare
+ * `groupDepthLimit()` tiene que responder con un techo ≤ ese número (la config solo BAJA el del driver) y aplicarlo.
+ */
+export function contractGroupDepthRelationsConfig(maxGroupDepth = 3) {
+    return defineRelationsConfig({
+        objectTypes: RELATIONS_CONTRACT_OBJECT_TYPES.map((type) => ({
+            type,
+            relations: [{ name: 'owner' }, { name: 'editor', includes: ['owner'] }, { name: 'viewer', includes: ['editor'] }],
+        })),
+        holderTypes: [...RELATIONS_HOLDER_TYPES],
+        database: { membersOf: true, enforceGroupDepth: true },
+        maxGroupDepth,
+    });
+}
 /**
  * **La config del contrato CON deny** (plan 2.5 · lote D · D1): los MISMOS dos tipos con el mismo retículo y, además,
  * un tercero sin opt-in —para que «deny sobre un tipo sin deny ⇒ 422» y «D8: un tipo sin opt-in también honra»
@@ -308,10 +326,12 @@ function buildRelationsDouble(options, tuples, now) {
             assertSubjectDeclared(subject);
             return resolves(subject, relation, object, scopeKeyOf(partition));
         },
-        async listObjects(subject, relation, objectType, partition, page) {
+        async listObjects(subject, relation, objectType, partition) {
             assertRelationDeclared(config, { type: objectType }, relation);
             assertSubjectDeclared(subject);
             const partitionKey = scopeKeyOf(partition);
+            // 7.4: el doble tampoco pagina (un quinto argumento ≠ undefined ⇒ 500), después de F-05 y la partición.
+            assertNoListPage('listObjects', arguments[4], 'double');
             const ids = new Set();
             for (const t of tuples) {
                 if (t.partition === partitionKey && t.objectType === objectType && active(t))
@@ -332,9 +352,10 @@ function buildRelationsDouble(options, tuples, now) {
             }
             return { objects: matches };
         },
-        async listSubjects(relation, object, partition, page) {
+        async listSubjects(relation, object, partition) {
             assertRelationDeclared(config, object, relation);
             const partitionKey = scopeKeyOf(partition);
+            assertNoListPage('listSubjects', arguments[3], 'double');
             // DIRECTOS del relation EXACTO (invariante 7): ni transitivo (eso es
             // `membersOf`) ni derivado. `usersetSubjects` decide si los usersets
             // (`group:g#member`) salen o solo los holders.
@@ -422,9 +443,11 @@ function buildRelationsDouble(options, tuples, now) {
             assertRelationDeclared(config, object, relation);
             return denyPhaseOf(config, object.type) ?? null;
         };
-        driver.listDenies = async (relation, object, partition) => {
+        driver.listDenies = async function (relation, object, partition) {
             assertRelationDeclared(config, object, relation);
-            const direct = directSubjects(scopeKeyOf(partition), object.type, object.id, deniedRelationOf(relation));
+            const key = scopeKeyOf(partition);
+            assertNoListPage('listDenies', arguments[3], 'double');
+            const direct = directSubjects(key, object.type, object.id, deniedRelationOf(relation));
             return { subjects: dedupeSubjects(direct.map((t) => t.subject)) };
         };
         driver.decideMany = async (subject, relation, objects, partition) => {
@@ -444,16 +467,19 @@ function buildRelationsDouble(options, tuples, now) {
         };
     }
     if (capabilities.membersOfNative) {
-        driver.membersOf = async (object, relation, partition) => {
+        driver.membersOf = async function (object, relation, partition) {
             assertRelationDeclared(config, object, relation);
             // Lote D: `membersOf` RESTA (corte de camino por candidato, como `database`).
             const key = scopeKeyOf(partition);
+            assertNoListPage('membersOf', arguments[3], 'double');
             return { subjects: collectMembers(object, relation, key).filter((s) => resolves(s, relation, object, key)) };
         };
     }
     if (capabilities.enumerateRelations) {
-        driver.enumerateRelations = async (partition) => {
+        driver.enumerateRelations = async (partition, page) => {
             const partitionKey = scopeKeyOf(partition);
+            // 7.4: la misma forma que los drivers reales; el doble no emite cursor (todo en una página) ⇒ after es 500.
+            assertEnumeratePage('enumerateRelations', page, 'none', 'double');
             // SIN filtrar la caducada (R-15): llega con su `expiresAt` para que el
             // destino de reconcile la cuente en `skipped`, no para que desaparezca.
             const out = tuples
@@ -703,6 +729,46 @@ export function registerRelationsDriverContract(harness, api) {
             await state.manager.relate({ object: g2, relation: 'member' }, 'viewer', doc, p);
             assert.isTrue(await state.manager.check(u, 'viewer', doc, p));
         });
+        /* ── R1 (lote «antes de RC»): el techo de anidación de grupos, si el driver lo declara ── */
+        test('R1 · groupDepthLimit (si el driver lo declara): con maxGroupDepth 3 + database.enforceGroupDepth el techo es ≤ 3 y se APLICA — la arista que deja una cadena más larga, por ARRIBA o por ABAJO, o que cierra un ciclo ⇒ 422 E_AUTHZ_GROUP_DEPTH_LIMIT sin escribir (check sigue F) y sin evento por el manager; la membresía de un holder y una relación de dominio no son anidación', async ({ assert, }) => {
+            const config = contractGroupDepthRelationsConfig(3);
+            const driver = await harness.makeDriver(config);
+            // `groupDepthLimit` es OPCIONAL en el puerto: un driver sin él no declara techo (el plan del reconcile no tiene
+            // nada que negar) y no hay gate que juzgar. Lo mismo un driver que responde `null` (sin techo con esta config).
+            const limit = typeof driver.groupDepthLimit === 'function' ? await driver.groupDepthLimit() : null;
+            if (limit === null)
+                return;
+            assert.isTrue(Number.isInteger(limit) && limit >= 1 && limit <= 3, `el techo con maxGroupDepth 3 tiene que estar en 1..3 (llegó ${String(limit)})`);
+            const events = [];
+            const manager = new RelationsManager(driver, config, { driverName: harness.name, onRelationWrite: (e) => void events.push(e) });
+            const p = partition();
+            const g = Array.from({ length: limit + 2 }, () => ({ type: 'group', id: docId() }));
+            const member = (o) => ({ object: o, relation: 'member' });
+            for (let i = 0; i < limit; i++)
+                await manager.relate(member(g[i]), 'member', g[i + 1], p);
+            const u = holder();
+            await manager.relate(u, 'member', g[0], p);
+            assert.isTrue(await manager.check(u, 'member', g[limit], p), `una cadena de ${limit} saltos (el techo) entra y resuelve`);
+            const before = events.length;
+            const refused = async (label, run) => {
+                const error = await run().then(() => null, (e) => e);
+                assert.equal(error?.status, 422, `${label}: ${error?.message ?? 'entró'}`);
+                assert.equal(error?.code, 'E_AUTHZ_GROUP_DEPTH_LIMIT', label);
+                return error;
+            };
+            await refused('por ARRIBA (la cima de la cadena dentro de otro grupo)', () => manager.relate(member(g[limit]), 'member', g[limit + 1], p));
+            assert.isFalse(await manager.check(u, 'member', g[limit + 1], p), 'la arista rechazada no se escribió');
+            const x = { type: 'group', id: docId() };
+            await refused('por ABAJO (otro grupo dentro de la base de la cadena)', () => manager.relate(member(x), 'member', g[0], p));
+            const v = holder();
+            await manager.relate(v, 'member', x, p);
+            assert.isFalse(await manager.check(v, 'member', g[0], p), 'x ⊂ g0 no se escribió');
+            await refused('el CICLO', () => manager.relate(member(g[limit]), 'member', g[0], p));
+            assert.equal(events.length, before + 1, '422 ⇒ esa escritura no ocurrió y no hay evento (invariante 13): solo el del holder v');
+            // No es anidación: la membresía de un holder y una relación de dominio sobre la cima.
+            await manager.relate(holder(), 'member', g[limit], p);
+            await manager.relate(member(g[limit]), 'viewer', { type: 'document', id: docId() }, p);
+        });
         /* ── R-05: la partición aísla ── */
         test('R-05 · partición: relate en A no concede en B', async ({ assert }) => {
             const u = holder();
@@ -750,6 +816,93 @@ export function registerRelationsDriverContract(harness, api) {
             const page = await state.manager.listObjects(u, 'viewer', 'document', p);
             assert.sameMembers(page.objects.map((o) => o.id).sort(), [d1.id, d2.id].sort());
         });
+        /* ── 7.4 (lote «antes de RC», opción 4 del juez): los listados NO paginan ── */
+        /**
+         * **P13 · «sin página ⇒ lista completa y sin cursor»** (injerto 1 del juez; auditor R1-2, tester P13). N = 150:
+         * por encima del default de 100 de `enumerate*` de `database` y del `page_size` 100 de `Read` en OpenFGA, así que
+         * un driver que pagina por dentro y devuelve la PRIMERA página (o un cursor que nadie lee) es rojo aquí. El tipo ya
+         * no tiene `cursor` (protege a quien compila); este caso protege en EJECUCIÓN frente a un driver de terceros y a un
+         * default de `limit` que alguien meta en 2.6. `listObjects` puede venir `truncated` SOLO si el driver declara
+         * `listObjectsTruncation` (y entonces lo que trae ⊆ lo escrito); los demás, el conjunto exacto.
+         */
+        test('7.4 · P13 · sin page los listados son EXHAUSTIVOS y sin cursor: N=150 (> 100 de enumerate y del page_size de Read) en listSubjects y listObjects —y listDenies con relationDenies, membersOf con membersOfNative—; listObjects truncated solo con listObjectsTruncation', async ({ assert, }) => {
+            const N = 150;
+            const p = partition();
+            const users = Array.from({ length: N }, () => holder());
+            const ids = (subjects) => subjects.map((s) => s.uuid).sort();
+            const expected = users.map((u) => u.uuid).sort();
+            const doc = { type: 'document', id: docId() };
+            for (const u of users)
+                await state.manager.relate(u, 'viewer', doc, p);
+            const subjects = await state.manager.listSubjects('viewer', doc, p);
+            assert.notProperty(subjects, 'cursor', 'listSubjects sin page no devuelve cursor');
+            assert.notEqual(subjects.truncated, true, 'listSubjects no corta (Read se agota o lanza)');
+            assert.deepEqual(ids(subjects.subjects), expected, `listSubjects devuelve los ${N}, no una página`);
+            const reader = holder();
+            const docs = Array.from({ length: N }, () => docId());
+            for (const id of docs)
+                await state.manager.relate(reader, 'viewer', { type: 'document', id }, p);
+            const objects = await state.manager.listObjects(reader, 'viewer', 'document', p);
+            assert.notProperty(objects, 'cursor', 'listObjects sin page no devuelve cursor');
+            const got = objects.objects.map((o) => o.id).sort();
+            if (objects.truncated === true) {
+                assert.isTrue(harness.capabilities.listObjectsTruncation, 'truncated sin declarar listObjectsTruncation');
+                assert.includeMembers(docs, got, 'lo que trae una lista truncada es de lo escrito');
+            }
+            else {
+                assert.deepEqual(got, [...docs].sort(), `listObjects devuelve los ${N}, no una página`);
+            }
+            if (harness.capabilities.membersOfNative) {
+                const group = { type: 'group', id: docId() };
+                for (const u of users)
+                    await state.manager.relate(u, 'member', group, p);
+                const members = await state.manager.membersOf(group, 'member', p);
+                assert.notProperty(members, 'cursor', 'membersOf sin page no devuelve cursor');
+                assert.deepEqual(ids(members.subjects), expected, `membersOf devuelve los ${N}`);
+            }
+            if (harness.capabilities.relationDenies) {
+                const { manager } = await denyManager();
+                const denied = { type: 'document', id: docId() };
+                for (const u of users)
+                    await manager.deny(u, 'viewer', denied, p);
+                const denies = await manager.listDenies('viewer', denied, p);
+                assert.notProperty(denies, 'cursor', 'listDenies sin page no devuelve cursor');
+                assert.deepEqual(ids(denies.subjects), expected, `listDenies devuelve los ${N}`);
+            }
+        });
+        /**
+         * **RC74-1 · página en los cuatro listados ⇒ 500, cero llamadas** (capa MANAGER, sobre el driver del harness). En
+         * 2.6 este caso pasa a ser la cara `whenFalse` de cada capacidad de paginación. `undefined` EXPLÍCITO entra
+         * (RC74-3). No se exige al driver en directo: obligaría a un tercero a un 500 por un parámetro que ya no está en
+         * el tipo (lo cubren la guardia y los specs de los drivers del paquete).
+         */
+        test('7.4 · RC74-1 · listObjects/listSubjects/listDenies/membersOf con page ({ limit: 1 }, null, {}) ⇒ 500 E_AUTHZ_UNSUPPORTED nombrando la operación, con CERO llamadas al driver; undefined explícito entra (RC74-3)', async ({ assert, }) => {
+            const u = holder();
+            const doc = { type: 'document', id: docId() };
+            const group = { type: 'group', id: docId() };
+            const p = partition();
+            const m = state.manager;
+            const calls = [
+                ['listObjects', (page) => m.listObjects(u, 'viewer', 'document', p, page)],
+                ['listSubjects', (page) => m.listSubjects('viewer', doc, p, page)],
+                ['listDenies', (page) => m.listDenies('viewer', doc, p, page)],
+                ['membersOf', (page) => m.membersOf(group, 'member', p, page)],
+            ];
+            for (const [operation, call] of calls) {
+                for (const page of [{ limit: 1 }, null, {}]) {
+                    const before = state.calls();
+                    const caught = await call(page).then(() => null, (e) => e);
+                    assert.isNotNull(caught, `${operation}(…, ${JSON.stringify(page)}) entró: una página que no hace nada es una lista entera que parece una página`);
+                    assert.equal(caught.status, 500, `${operation}: ${caught.message}`);
+                    assert.equal(caught.code, 'E_AUTHZ_UNSUPPORTED', `${operation}: ${caught.message}`);
+                    assert.include(caught.message, operation);
+                    assert.equal(state.calls(), before, `${operation} con page: CERO llamadas al driver`);
+                }
+            }
+            // RC74-3: el argumento `undefined` explícito es «sin página» (quien reenvía un opcional vacío no se rompe).
+            assert.isArray((await m.listObjects(u, 'viewer', 'document', p, undefined)).objects);
+            assert.isArray((await m.listSubjects('viewer', doc, p, undefined)).subjects);
+        });
         /* ── R-12: identidad mal formada ⇒ 422 ── */
         test('R-12 · partición mal formada ⇒ 422 con code', async ({ assert }) => {
             const u = holder();
@@ -1783,6 +1936,21 @@ export function registerRelationsDriverContract(harness, api) {
             for (const r of denies)
                 await m.deny(u, r, object, p);
         }
+        /* ── Estrategia 2.5.0 · firma 4 · el par `experimental` (regla D15; mismo nombre que en roles) ── */
+        // Dice lo que el consumidor tiene que saber («fuera de la garantía de la versión») y no apaga casos: el runner corre
+        // ENTERO contra un driver experimental. Se observa la declaración del driver y la copia normalizada del manager.
+        caseFor('experimental', {
+            whenTrue: () => test('experimental:true · el driver se declara EXPERIMENTAL (capabilities.experimental === true) y `relations.capabilities()` lo publica tal cual; el runner corre igual contra él', async ({ assert }) => {
+                assert.strictEqual(state.base.capabilities?.experimental, true, 'el harness declara experimental: true y el driver no: declara lo observable');
+                const published = state.manager.capabilities();
+                assert.strictEqual(published.experimental, true);
+                assert.isTrue(Object.isFrozen(published));
+            }),
+            whenFalse: () => test('experimental:false · el driver NO se declara experimental (ausente o false) y `relations.capabilities().experimental` es false, nunca undefined (D15)', async ({ assert }) => {
+                assert.notStrictEqual(state.base.capabilities?.experimental, true, 'el harness declara experimental: false y el driver declara true: declara lo observable');
+                assert.strictEqual(state.manager.capabilities().experimental, false);
+            }),
+        });
         /* ── Cierre 2 de D2 · 🟠 N1 · el par `atomicRenewal` (renovar una membresía que TRANSPORTA un deny) ── */
         /**
          * Siembra: U ∈ g con caducidad (+1 h), un allow DIRECTO de U sobre X y —si el driver deniega— el deny de `g#member`
@@ -2361,4 +2529,3 @@ export function registerRelationsDriverContract(harness, api) {
     });
     return { registered, covered };
 }
-//# sourceMappingURL=relations_contract.js.map

package/build/src/testing/relations_reconcile_contract.d.ts

@@ -30,4 +30,3 @@ export declare function registerRelationsReconcileContract(harness: RelationsRec
 }): {
     registered: number;
 };
-//# sourceMappingURL=relations_reconcile_contract.d.ts.map

package/build/src/testing/relations_reconcile_contract.js

@@ -424,4 +424,3 @@ export function registerRelationsReconcileContract(harness, api) {
     });
     return { registered };
 }
-//# sourceMappingURL=relations_reconcile_contract.js.map

package/build/src/testing/scope_outbox_contract.d.ts

@@ -108,4 +108,3 @@ export declare function registerScopeOutboxContract(harness: ScopeOutboxContract
     registered: number;
     covered: Set<keyof ScopeOutboxCapabilities>;
 };
-//# sourceMappingURL=scope_outbox_contract.d.ts.map

package/build/src/testing/scope_outbox_contract.js

@@ -752,4 +752,3 @@ export function registerScopeOutboxContract(harness, api) {
     });
     return { registered, covered };
 }
-//# sourceMappingURL=scope_outbox_contract.js.map

package/build/src/testing/scope_tree.d.ts

@@ -62,4 +62,3 @@ export declare function descendantsFrom(tree: ContractScopeTree): ScopeDescendan
  */
 export declare function memoryScopeTree(): ContractScopeTree;
 export { APP_SCOPE };
-//# sourceMappingURL=scope_tree.d.ts.map

package/build/src/testing/scope_tree.js

@@ -142,4 +142,3 @@ export function memoryScopeTree() {
     };
 }
 export { APP_SCOPE };
-//# sourceMappingURL=scope_tree.js.map

package/build/src/testing/test_clock.d.ts

@@ -12,4 +12,3 @@ export interface TestClock {
 }
 /** Un reloj de test parado en `start` (default: la hora de pared al crearlo), controlable con `set`/`advance`. */
 export declare function createTestClock(start?: Date | number | string): TestClock;
-//# sourceMappingURL=test_clock.d.ts.map

package/build/src/testing/test_clock.js

@@ -62,4 +62,3 @@ export function createTestClock(start = systemClock()) {
     clock.at = (offsetMs) => new Date(current + offsetMs);
     return clock;
 }
-//# sourceMappingURL=test_clock.js.map

package/build/src/traits/authz_scopes.d.ts

@@ -42,4 +42,3 @@ export type WithAuthzScopes<T extends Constructor> = T & AuthzScopesStatics;
  */
 export declare function withAuthzScopes<T extends Constructor | AuthzScopesOptions>(arg: T): T extends Constructor ? WithAuthzScopes<T> : <U extends Constructor>(Base: U) => WithAuthzScopes<U>;
 export {};
-//# sourceMappingURL=authz_scopes.d.ts.map

package/build/src/traits/authz_scopes.js

@@ -54,4 +54,3 @@ export function withAuthzScopes(arg) {
     const clock = options.clock ?? systemClock;
     return (Base) => mixin(Base, clock);
 }
-//# sourceMappingURL=authz_scopes.js.map

package/build/src/traits/has_uuid.d.ts

@@ -81,6 +81,11 @@ export declare const hasUuid: <Model extends NormalizeConstructor<typeof BaseMod
         <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model_1>>, "paginate">): void;
         <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event>): void;
     };
+    before: {
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends "find" | "fetch">(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, Event_1>): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>], "paginate">): void;
+        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): void;
+    };
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -117,11 +122,6 @@ export declare const hasUuid: <Model extends NormalizeConstructor<typeof BaseMod
     };
     $defineProperty: <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Prop extends keyof Model_1>(this: Model_1, propertyName: Prop, defaultValue: Model_1[Prop], strategy: "inherit" | "define" | ((value: Model_1[Prop]) => Model_1[Prop])) => void;
     boot: () => void;
-    before: {
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_1 extends "find" | "fetch">(this: Model_1, event: Event_1, handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, Event_1>): void;
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model_1, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model_1>], "paginate">): void;
-        <Model_1 extends import("@adonisjs/lucid/types/model").LucidModel, Event_2 extends import("@adonisjs/lucid/types/model").EventsList>(this: Model_1, event: Event_2, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model_1>, Event_2>): 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>[]>;
@@ -148,4 +148,3 @@ export declare const hasUuid: <Model extends NormalizeConstructor<typeof BaseMod
     fetchOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
     updateOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
 } & Model;
-//# sourceMappingURL=has_uuid.d.ts.map

package/build/src/traits/has_uuid.js

@@ -35,4 +35,3 @@ export const hasUuid = (superclass) => {
     ], WithPrimaryUuidClass, "generateUuid", null);
     return WithPrimaryUuidClass;
 };
-//# sourceMappingURL=has_uuid.js.map

package/build/src/types.d.ts

@@ -334,6 +334,15 @@ export interface AuthorizationDriverCapabilities {
      * `transactional: true`.
      */
     transactionalWrites: boolean;
+    /**
+     * **El driver es EXPERIMENTAL: fuera de la garantía de la versión** (estrategia 2.5.0, firma 4 del dueño 2026-10-21).
+     * **Opcional y normalizada a `false`** (regla D15). `openfga` = `true` en 2.5.x: no apto para producción, no se
+     * construye sin `experimental: 'openfga@2.5'` (500 `E_AUTHZ_CONFIG` sin él) y sus límites declarados —con cifra,
+     * receta, detector y versión de cierre (2.6)— están en README «Limits». `database` = `false` (no la declara). El juez
+     * corre ENTERO contra un driver experimental (no hay skip): la capacidad dice lo que el consumidor tiene que saber, no
+     * apaga casos. Par de caras en `runAuthorizationDriverContract`.
+     */
+    experimental?: boolean;
 }
 /**
  * Las claves de `AuthorizationDriverCapabilities`, LITERALES (2.4.0-alpha.4):
@@ -730,6 +739,14 @@ export interface ReconcileFact {
      * que es justo lo que la migración no puede hacer.
      */
     expiresAt?: Date | null;
+    /**
+     * `deny` (cierre-2 de L11 · C1): el origen guarda ese deny con una condición que el paquete no escribe ni sabe leer
+     * (escritor AJENO; el motivo, p. ej. `foreign: condición 'inverted'`). NO es un deny limpio: el destino lo migra como
+     * deny —fail-closed: ante la duda, niega— pero lo DECLARA (`invalid-condition`, deriva); y en la pasada de
+     * MANTENIMIENTO (origen = destino) no se escribe ni se borra, solo se reporta. Un destino que ignore la marca lo trata
+     * como deny permanente, que es la lectura conservadora para un deny.
+     */
+    invalidCondition?: string;
     /** Cómo lo nombra el origen (para `details`): un motivo sin la fila no se arregla. */
     detail: string;
 }
@@ -1151,6 +1168,18 @@ export interface ScopeRelayFailure {
     change: ScopeTreeChange;
     error: string;
     transient: boolean;
+    /**
+     * Cierre de R3 (⚪ R3-A7; punto 7): el `code` del error (`E_AUTHZ_WRITE_CONFLICT`, `E_AUTHZ_RESOLUTION_LIMIT`,
+     * `E_AUTHZ_BACKEND_UNAVAILABLE`…), para que el comando diga QUÉ rama transitoria corrió: una carrera o un grafo
+     * demasiado profundo no son «el backend no respondió». Ausente si el error no trae `code` (driver de terceros).
+     */
+    code?: string;
+    /**
+     * Cierre-2 de L11 (⚪ C2): `true` ⇒ el fallo es del DESPLIEGUE (el modelo fijado no es el que genera la config, o el
+     * generador no puede generar con él; `isDeploymentFailure`), no del backend ni de la entrada. Es `transient` también
+     * (no consume intento), pero el backend SÍ respondió: el comando lo dice en su propia línea. Ausente = no lo es.
+     */
+    deployment?: true;
 }
 /** Qué fue de una entrada en la pasada (2.4.0-alpha.5 · R1, `ScopeRelayReport.entries`). */
 export type ScopeRelayEntryStatus = 'applied' | 'deferred' | 'failed' | 'dead';
@@ -1179,6 +1208,13 @@ export interface ScopeRelayEntry {
     status: ScopeRelayEntryStatus;
     reason?: string;
     attempts?: number;
+    /**
+     * Solo en `applied` de un `attached`/`moved` relevado contra un driver con `hierarchyFacts` (asentar · cierre 1): el
+     * padre que se APLICÓ de verdad —el FRESCO del consumidor, que puede no ser `change.parent` (`reason:
+     * 'consumer-parent'`)— o `null` si no se escribió arista (`reason: 'superseded'`: el nodo ya no existe y un `detached`
+     * suyo lo respalda). Ausente en `database`, que aplica el encolado tal cual.
+     */
+    appliedParent?: ScopeRef | null;
     /**
      * Solo en `deferred` (2.4.0-alpha.8): el ORIGEN —transitivo, la causa
      * raíz— del bloqueo que la aplazó. `parked` = una entrada APARCADA (la
@@ -1963,7 +1999,12 @@ export interface RelationDenyOptions extends RelationTransactionOptions {
 }
 /** Una decisión de `decideMany` (D9): `allow` (concede aquí), `deny` (no heredes más allá de este objeto), `none` (nada aquí). */
 export type RelationDecision = 'allow' | 'deny' | 'none';
-/** Una página de una enumeración de relaciones (cursor opaco que AVANZA, no filtra herencia). */
+/**
+ * Una página de `enumerateRelations`/`enumerateRelationsMany` (cursor opaco que AVANZA, no filtra herencia). **Solo
+ * `enumerate*`** desde el lote «antes de RC» · 7.4: los `list*` no paginan en 2.5 (ver `RelationObjectsPage`).
+ * `limit` entero ≥ 1 (si no, 422 `E_AUTHZ_INVALID_PAGE`; por encima de `RELATIONS_ENUMERATE_MAX_LIMIT` se recorta);
+ * `after` = el `cursor` que devolvió la página anterior, sin tocar.
+ */
 export interface RelationPage {
     limit?: number;
     after?: string;
@@ -2054,24 +2095,31 @@ export interface RelationsDriverCapabilities {
      * `runRelationsDriverContract`.
      */
     atomicRenewal?: boolean;
+    /**
+     * **El driver es EXPERIMENTAL: fuera de la garantía de la versión** (estrategia 2.5.0, firma 4). Mismo nombre y misma
+     * regla que en `AuthorizationDriverCapabilities` (D15: opcional, normalizada a `false`). `openfga` = `true` en 2.5.x
+     * (500 `E_AUTHZ_CONFIG` al construir sin `experimental: 'openfga@2.5'`; límites en README «Limits», cierre en 2.6);
+     * `database` = `false`. Par de caras en `runRelationsDriverContract`.
+     */
+    experimental?: boolean;
 }
 /** Las claves de `RelationsDriverCapabilities`, literales: lo que `relations.capabilities()` normaliza (2.4.0-alpha.4). */
 export declare const RELATIONS_DRIVER_CAPABILITY_KEYS: ReadonlyArray<keyof RelationsDriverCapabilities>;
 /** La copia congelada y normalizada de `relations.capabilities()`; misma regla que `normalizeAuthorizationCapabilities`. */
 export declare function normalizeRelationsCapabilities(declared: Partial<RelationsDriverCapabilities> | undefined): Readonly<RelationsDriverCapabilities>;
 /**
- * Una página de `listObjects`/`listSubjects`/`enumerateRelations`. `truncated`
- * dice si el backend cortó al tope (solo con `listObjectsTruncation`): un
- * consumidor que lo ve sabe que hay MÁS y no toma la lista por completa.
+ * La respuesta de `listObjects`. **Sin `cursor`** (lote «antes de RC» · 7.4, opción 4 del juez): los `list*` de
+ * relaciones devuelven el conjunto COMPLETO o señalan `truncated`; nunca un cursor. `truncated` dice si el backend
+ * cortó (tope o deadline; solo con `listObjectsTruncation`): un consumidor que lo ve sabe que hay MÁS y no toma la
+ * lista por completa. La paginación de los listados llegará en 2.6 como métodos APARTE (`*Page`) con capacidad propia.
  */
 export interface RelationObjectsPage {
     objects: RelObject[];
-    cursor?: string;
     truncated?: boolean;
 }
+/** La respuesta de `listSubjects`/`listDenies`/`membersOf`: completa o `truncated`, **sin `cursor`** (7.4). */
 export interface RelationSubjectsPage {
     subjects: RelSubject[];
-    cursor?: string;
     truncated?: boolean;
 }
 /** Una tupla de relación tal como la enumera `enumerateRelations` (origen de reconcile). */
@@ -2096,6 +2144,19 @@ export interface RelationTuple {
      * o se contaría como relación no declarada, y perder un deny no es una pérdida que se pueda declarar.
      */
     kind?: 'allow' | 'deny';
+    /**
+     * **La condición de la tupla escrita no es la `not_expired` del paquete, o no se puede leer** (lote «antes de RC» ·
+     * L11): el porqué, legible. Solo lo pone un driver que lee condiciones (`openfga`, `fgaTupleExpiry`): `foreign` (otra
+     * condición o un contexto que no es exactamente `{ valid_until }`) o `unparseable`. Con esto puesto `expiresAt` es la
+     * ÉPOCA (`new Date(0)`) y no es una caducidad real. **La época NO es conservadora para todo** (cierre-2 de L11 · ⚪ C3):
+     * un lector que ignore este campo la lee VENCIDA, que es fail-CLOSED para un ALLOW (deja de conceder) pero fail-OPEN
+     * para un DENY (`kind: 'deny'`) y para una membresía de `group` que TRANSPORTA un deny (deja de negar). Ningún valor de
+     * `expiresAt` es seguro para los dos tipos de tupla (con `null` era al revés): quien lea `enumerateRelations` TIENE que
+     * mirar `invalidCondition` antes que la fecha. Dentro del paquete se hace: `reconcileRelations` la clasifica en el PLAN, antes de mirar la fecha, como `invalid-condition` (origen:
+     * no se migra; destino: presente e intocable, nunca se poda) y es deriva. Opcional (un driver de terceros anterior
+     * sigue compilando; ausente = la condición se entendió).
+     */
+    invalidCondition?: string;
 }
 export interface RelationTuplePage {
     tuples: RelationTuple[];
@@ -2160,10 +2221,14 @@ export interface RelationsDriver {
      * llamante (eso es `decideMany`, lote D).
      */
     checkMany?(subject: RelSubject, relation: string, objects: RelObject[], partition: ScopeRef): Promise<boolean[]>;
-    /** Los objetos de tipo `objectType` sobre los que `subject` tiene `relation`. Directos + derivados, sin herencia abierta. */
-    listObjects(subject: RelSubject, relation: string, objectType: string, partition: ScopeRef, page?: RelationPage): Promise<RelationObjectsPage>;
-    /** Los sujetos DIRECTOS de `relation` sobre `object` (holders y usersets). Nunca la membresía transitiva (eso es `membersOf`). */
-    listSubjects(relation: string, object: RelObject, partition: ScopeRef, page?: RelationPage): Promise<RelationSubjectsPage>;
+    /**
+     * Los objetos de tipo `objectType` sobre los que `subject` tiene `relation`. Directos + derivados, sin herencia
+     * abierta. **Sin página** (7.4): el conjunto completo o `truncated`; un quinto argumento distinto de `undefined` ⇒
+     * 500 `E_AUTHZ_UNSUPPORTED` sin tocar el backend (lo mismo en `listSubjects`/`listDenies`/`membersOf`).
+     */
+    listObjects(subject: RelSubject, relation: string, objectType: string, partition: ScopeRef): Promise<RelationObjectsPage>;
+    /** Los sujetos DIRECTOS de `relation` sobre `object` (holders y usersets). Nunca la membresía transitiva (eso es `membersOf`). Sin página (7.4). */
+    listSubjects(relation: string, object: RelObject, partition: ScopeRef): Promise<RelationSubjectsPage>;
     /** Borra todas las tuplas cuyo OBJETO es `object` (F-05 sobre el TIPO, alpha.3) y demuestra cero, o lanza 500 `E_AUTHZ_PURGE_INCOMPLETE` (invariante 11). Si falla tras borrar parte, marcado con `markPartialWrite`. */
     purgeObject(object: RelObject, partition: ScopeRef, options?: RelationTransactionOptions): Promise<void>;
     /** Borra todas las tuplas cuyo SUJETO es `subject` (F-05 sobre el userset, alpha.3) y demuestra cero, o lanza 500. Si falla tras borrar parte, marcado con `markPartialWrite`. */
@@ -2174,7 +2239,7 @@ export interface RelationsDriver {
      * `listSubjects(member, group)`, que devuelve solo los hechos DIRECTOS. Solo
      * lo trae el driver con `membersOfNative: true`.
      */
-    membersOf?(object: RelObject, relation: string, partition: ScopeRef, page?: RelationPage): Promise<RelationSubjectsPage>;
+    membersOf?(object: RelObject, relation: string, partition: ScopeRef): Promise<RelationSubjectsPage>;
     /** ORIGEN de `authz:reconcile` de relaciones: las tuplas paginadas, sin filtrar (la caducada LLEGA con su `expiresAt`). Solo con `enumerateRelations: true`. */
     enumerateRelations?(partition: ScopeRef, page?: RelationPage): Promise<RelationTuplePage>;
     /**
@@ -2200,8 +2265,8 @@ export interface RelationsDriver {
     deny?(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationDenyOptions): Promise<void>;
     /** Retira el deny. No-op seguro si no existe. Sobre CUALQUIER tipo declarado (D8: retirar el opt-in es reversible). */
     removeDeny?(subject: RelSubject, relation: string, object: RelObject, partition: ScopeRef, options?: RelationDenyOptions): Promise<void>;
-    /** Los sujetos con deny DIRECTO de `relation` sobre `object` (hechos, como `listSubjects`; no resta nada). */
-    listDenies?(relation: string, object: RelObject, partition: ScopeRef, page?: RelationPage): Promise<RelationSubjectsPage>;
+    /** Los sujetos con deny DIRECTO de `relation` sobre `object` (hechos, como `listSubjects`; no resta nada). Sin página (7.4). */
+    listDenies?(relation: string, object: RelObject, partition: ScopeRef): Promise<RelationSubjectsPage>;
     /**
      * **La primitiva de CADENA** (D9): una decisión por objeto, POR POSICIÓN — `allow` si `check` concede; si no, `deny`
      * si el sujeto tiene un deny vivo (directo o por grupo) sobre alguna relación de `up*(down*(R))` en el objeto; si
@@ -2222,6 +2287,17 @@ export interface RelationsDriver {
     denyPhase?(object: {
         type: string;
     }, relation: string): Promise<'read' | 'write' | null>;
+    /**
+     * **El techo de anidación de grupos que ESTE driver aplica** (lote «antes de RC» · R1, decisión del dueño 2026-10-17
+     * (5): «cada driver declara su techo»): saltos `group⊂group` del camino más largo que admite al escribir una arista
+     * `group#member`, o `null` si no aplica ninguno. `openfga`: el CALIBRADO contra el servidor (el mínimo de un miembro y
+     * de un no-miembro con membresía; solo lectura, tuplas contextuales, memoriza solo el éxito) o el `maxGroupDepth` de
+     * la config si es menor; `database`: `maxGroupDepth` con `database.enforceGroupDepth`, si no `null`. Lo llama
+     * `reconcileRelations` sobre el DESTINO en la fase de PLAN (también en `--dry-run`: es de solo lectura) para NEGAR la
+     * partición cuya cadena final lo excede, nunca saltar la arista. Opcional: un driver de terceros sin él no tiene techo
+     * para el plan. Lectura de configuración: no recibe tupla ni partición.
+     */
+    groupDepthLimit?(): Promise<number | null>;
     /**
      * Vista de este driver con OTRO reloj de pared (R-15, paridad con
      * `AuthorizationDriver.withClock`, 2.5 · J1): mismo backend, solo cambia el
@@ -2242,4 +2318,3 @@ export interface RelationsDriver {
  * factory (como el de roles), así que el comando nunca toca el SDK (pureza).
  */
 export type RelationsDriverFactory = () => RelationsDriver | Promise<RelationsDriver>;
-//# sourceMappingURL=types.d.ts.map

package/build/src/types.js

@@ -57,6 +57,8 @@ export const AUTHORIZATION_DRIVER_CAPABILITY_KEYS = Object.freeze([
     'canonicalScopeReads',
     'enumerateFacts',
     'transactionalWrites',
+    // Estrategia 2.5.0 · firma 4 (D15): opcional, normalizada a `false`.
+    'experimental',
 ]);
 /**
  * **La copia CONGELADA y NORMALIZADA que publica `authorization.capabilities()`**
@@ -100,6 +102,8 @@ export const RELATIONS_DRIVER_CAPABILITY_KEYS = Object.freeze([
     'transactionalWrites',
     'relationDenies',
     'atomicRenewal',
+    // Estrategia 2.5.0 · firma 4 (D15): opcional, normalizada a `false`.
+    'experimental',
 ]);
 /** La copia congelada y normalizada de `relations.capabilities()`; misma regla que `normalizeAuthorizationCapabilities`. */
 export function normalizeRelationsCapabilities(declared) {
@@ -108,4 +112,3 @@ export function normalizeRelationsCapabilities(declared) {
         out[key] = declared?.[key] === true;
     return Object.freeze(out);
 }
-//# sourceMappingURL=types.js.map