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

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

@@ -11,6 +11,15 @@ export interface RelationsReconcileHarness {
     makeB(config: RelationsConfig): RelationsDriver | Promise<RelationsDriver>;
     /** Limpia ambos backends antes de cada caso. */
     clean?(): Promise<void>;
+    /**
+     * **La cara del DENY** (plan 2.5 · lote D · D2; tester T3 / D-27): los dos drivers declaran `relationDenies: true` y
+     * `config` tiene al menos un tipo en `deny: 'write'`. Registra, por dirección, (a) «el deny viaja como deny» —con
+     * `kind`, ANTES que los allows, y el CENSO lo busca por `listDenies`; `check` del destino niega— y (b) «la poda de un
+     * deny sobrante es `removeDeny`, después de los allows», más un negativo global (S6: destino sin `relationDenies` ⇒
+     * 500 `E_AUTHZ_DENY_MIGRATION_REFUSED` con CERO escrituras). Un driver de terceros que declare `relationDenies` y no
+     * marque `kind` en `enumerateRelations` NO pasa (a): la pasada se niega con el motivo `unmarked`.
+     */
+    denies?: boolean;
 }
 export declare function runRelationsReconcileContract(harness: RelationsReconcileHarness): {
     registered: number;
@@ -21,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

@@ -190,6 +190,213 @@ export function registerRelationsReconcileContract(harness, api) {
                 assert.lengthOf(first.subjects, 0, 'dry-run no tocó el destino');
             });
         }
+        if (harness.denies === true) {
+            const denyType = harness.config.objectTypes.find((t) => t.deny === 'write')?.type;
+            if (!denyType)
+                throw new Error(`runRelationsReconcileContract [${harness.name}]: denies: true exige un tipo con deny: 'write' en config`);
+            const writesOf = (driver) => {
+                const log = [];
+                const proxy = new Proxy(driver, {
+                    get(target, prop) {
+                        const value = Reflect.get(target, prop, target);
+                        if (typeof prop === 'string' && ['relate', 'unrelate', 'deny', 'removeDeny'].includes(prop) && typeof value === 'function') {
+                            return async (...args) => {
+                                log.push(`${prop} ${args[1]}`);
+                                return value.apply(target, args);
+                            };
+                        }
+                        return typeof value === 'function' ? value.bind(target) : value;
+                    },
+                });
+                return { driver: proxy, log };
+            };
+            /**
+             * Cierre 3 de D2 (🟠 C2-1 / 🟡 C2-2): un espía que pregunta `check(probe)` tras CADA escritura del destino — los
+             * prefijos de la pasada, tal como los ve el PDP del destino.
+             */
+            const prefixSpy = (driver, probe) => {
+                const prefixes = [];
+                const proxy = new Proxy(driver, {
+                    get(target, prop) {
+                        const value = Reflect.get(target, prop, target);
+                        if (typeof prop === 'string' && ['relate', 'unrelate', 'deny', 'removeDeny'].includes(prop) && typeof value === 'function') {
+                            return async (...args) => {
+                                const out = await value.apply(target, args);
+                                const s = args[0];
+                                const who = isRelUserset(s) ? `${s.object.id.slice(-4)}#${s.relation}` : `${s.uuid.slice(-4)}`;
+                                prefixes.push(`${prop}(${who} ${args[1]} ${args[2]?.type}:${String(args[2]?.id).slice(-4)}) ⇒ ${await probe(driver)}`);
+                                return out;
+                            };
+                        }
+                        return typeof value === 'function' ? value.bind(target) : value;
+                    },
+                });
+                return { driver: proxy, prefixes };
+            };
+            const past = () => new Date(Date.now() - 3_600_000);
+            for (const dir of directions) {
+                const from = () => (dir.source === 'A' ? a : b);
+                const to = () => (dir.source === 'A' ? b : a);
+                test(`${dir.label} · vigencia · C2-1 · una membresía PORTADORA VENCIDA en el destino y viva en el origen es una escritura normal (jamás renewal-unsafe): ningún prefijo concede, el destino niega o concede según el ORIGEN y la 2.ª pasada tiene el plan vacío`, async ({ assert }) => {
+                    const p = { type: 'unit', uuid: uuidv7() };
+                    const u = { type: 'user', uuid: uuidv7() };
+                    const h = { type: 'group', id: uuidv7() };
+                    const x = { type: denyType, id: uuidv7() };
+                    const y = { type: denyType, id: uuidv7() };
+                    for (const side of [from(), to()]) {
+                        await side.deny({ object: h, relation: 'member' }, 'viewer', x, p);
+                        await side.relate({ object: h, relation: 'member' }, 'viewer', y, p);
+                    }
+                    await from().relate(u, 'member', h, p);
+                    await from().relate(u, 'viewer', x, p);
+                    await to().relate(u, 'member', h, p, { expiresAt: past() });
+                    assert.isFalse(await from().check(u, 'viewer', x, p), 'el origen niega X');
+                    assert.isTrue(await from().check(u, 'viewer', y, p), 'el origen concede Y');
+                    assert.isFalse(await to().check(u, 'viewer', x, p), 'el destino niega X al empezar');
+                    assert.isFalse(await to().check(u, 'viewer', y, p), 'el destino niega Y al empezar (la membresía venció)');
+                    const dry = await reconcileRelations({ from: from(), to: to(), partition: p, toConfig: harness.config, dryRun: true });
+                    const spy = prefixSpy(to(), (d) => d.check(u, 'viewer', x, p));
+                    const report = await reconcileRelations({ from: from(), to: spy.driver, partition: p, toConfig: harness.config });
+                    for (const r of [dry, report]) {
+                        assert.deepEqual((r.details ?? []).map((d) => d.reason), [], 'ni renewal-unsafe ni residuo: la vencida es AUSENTE');
+                        assert.deepEqual({ written: r.written, updated: r.updated }, { written: 2, updated: 0 }, 'la membresía y el allow son ESCRITURAS');
+                        assert.deepEqual(r.orderResidue, []);
+                    }
+                    assert.notInclude(spy.prefixes.join(' | '), '⇒ true', `ningún prefijo concede X: ${spy.prefixes.join(' | ')}`);
+                    assert.isFalse(await to().check(u, 'viewer', x, p), 'el destino niega X, como el origen');
+                    assert.isTrue(await to().check(u, 'viewer', y, p), 'el destino concede Y, como el origen');
+                    const again = await reconcileRelations({ from: from(), to: to(), partition: p, toConfig: harness.config });
+                    assert.equal(again.written + again.updated + again.deleted, 0, 'converge: la 2.ª pasada no escribe nada');
+                    assert.deepEqual(again.details ?? [], []);
+                });
+                test(`${dir.label} · vigencia · C2-2 · una arista de anidación VENCIDA solo en el destino no cuenta para el auto-corte del orden: la membresía que entra en el grupo que DENIEGA va antes que la del grupo que concede, y ningún prefijo concede (sin residuo)`, async ({ assert }) => {
+                    const p = { type: 'unit', uuid: uuidv7() };
+                    const u = { type: 'user', uuid: uuidv7() };
+                    // Ids ordenados: sin la precedencia «h antes que g», el desempate estable pondría g primero.
+                    const [gId, hId, kId] = [uuidv7(), uuidv7(), uuidv7()].sort();
+                    const g = { type: 'group', id: gId };
+                    const h = { type: 'group', id: hId };
+                    const k = { type: 'group', id: kId };
+                    const x = { type: denyType, id: uuidv7() };
+                    for (const side of [from(), to()]) {
+                        await side.relate({ object: g, relation: 'member' }, 'viewer', x, p);
+                        await side.deny({ object: k, relation: 'member' }, 'viewer', x, p);
+                        await side.deny({ object: h, relation: 'member' }, 'viewer', x, p);
+                    }
+                    await to().relate({ object: g, relation: 'member' }, 'member', k, p, { expiresAt: past() });
+                    await from().relate(u, 'member', g, p);
+                    await from().relate(u, 'member', h, p);
+                    assert.isFalse(await to().check(u, 'viewer', x, p));
+                    const spy = prefixSpy(to(), (d) => d.check(u, 'viewer', x, p));
+                    const report = await reconcileRelations({ from: from(), to: spy.driver, partition: p, toConfig: harness.config });
+                    assert.deepEqual(report.orderResidue, []);
+                    assert.lengthOf(spy.prefixes, 2, spy.prefixes.join(' | '));
+                    assert.notInclude(spy.prefixes.join(' | '), '⇒ true', `ningún prefijo concede: ${spy.prefixes.join(' | ')}`);
+                    assert.isFalse(await to().check(u, 'viewer', x, p), 'final: niega, como el origen');
+                });
+                test(`${dir.label} · vigencia · C3-1 · una membresía PORTADORA VIVA en el destino con una caducidad MÁS CORTA que la del origen: en un destino sin atomicRenewal no se renueva (renewal-unsafe) y su PARTICIÓN se niega —cero escrituras, partitionsRefused— (cierre 5 de D2, opción A); con atomicRenewal se renueva; en los dos, el destino NIEGA en now y TRAS la caducidad vieja (reloj inyectado), como el origen`, async ({ assert }) => {
+                    const p = { type: 'unit', uuid: uuidv7() };
+                    const u = { type: 'user', uuid: uuidv7() };
+                    const h = { type: 'group', id: uuidv7() };
+                    const x = { type: denyType, id: uuidv7() };
+                    const old = new Date(Date.now() + 3_600_000);
+                    for (const side of [from(), to()])
+                        await side.deny({ object: h, relation: 'member' }, 'viewer', x, p);
+                    await from().relate(u, 'member', h, p, { expiresAt: new Date(Date.now() + 86_400_000) });
+                    await from().relate(u, 'viewer', x, p);
+                    await to().relate(u, 'member', h, p, { expiresAt: old });
+                    assert.isFalse(await from().check(u, 'viewer', x, p), 'el origen niega X');
+                    const atomic = to().capabilities?.atomicRenewal === true;
+                    const dry = await reconcileRelations({ from: from(), to: to(), partition: p, toConfig: harness.config, dryRun: true });
+                    const spy = writesOf(to());
+                    const report = await reconcileRelations({ from: from(), to: spy.driver, partition: p, toConfig: harness.config });
+                    for (const r of [dry, report]) {
+                        assert.deepEqual({
+                            written: r.written,
+                            updated: r.updated,
+                            details: (r.details ?? []).map((d) => `${d.side}:${d.reason}`),
+                            refused: (r.partitionsRefused ?? []).map((x) => x.causes.map((c) => c.reason).join(',')),
+                        }, atomic
+                            ? { written: 1, updated: 1, details: [], refused: [] }
+                            : { written: 0, updated: 0, details: ['destino:renewal-unsafe'], refused: ['renewal-unsafe'] }, `atomicRenewal=${atomic}`);
+                    }
+                    if (!atomic)
+                        assert.deepEqual(spy.log, [], `ni la renovación ni el allow llegan al driver: ${spy.log.join(' | ')}`);
+                    assert.isFalse(await to().check(u, 'viewer', x, p), 'el destino niega X en now');
+                    // El HORIZONTE: tras la caducidad vieja del destino, con el reloj del destino adelantado (sin sleeps).
+                    const later = typeof to().withClock === 'function' ? to().withClock(() => new Date(old.getTime() + 1_000)) : null;
+                    if (later)
+                        assert.isFalse(await later.check(u, 'viewer', x, p), `ROJO (C3-1): tras la caducidad vieja el destino concede lo que el origen niega`);
+                });
+                test(`${dir.label} · D2 · el deny viaja como DENY (kind), ANTES que los allows; el CENSO lo busca por listDenies y check niega en el destino`, async ({ assert }) => {
+                    const seed = makeSeed();
+                    await plant(from(), seed);
+                    const object = { type: denyType, id: uuidv7() };
+                    const viaGroup = { type: denyType, id: uuidv7() };
+                    // Corte de camino (owner con deny en editor), y un deny transportado por g1#member (u3 es miembro).
+                    await from().relate(seed.u1, 'owner', object, seed.partition);
+                    await from().deny(seed.u1, 'editor', object, seed.partition);
+                    await from().relate(seed.u3, 'viewer', viaGroup, seed.partition);
+                    await from().deny({ object: seed.g1, relation: 'member' }, 'viewer', viaGroup, seed.partition);
+                    const spy = writesOf(to());
+                    const report = await reconcileRelations({ from: from(), to: spy.driver, partition: seed.partition });
+                    assert.equal(report.denies?.written, 2, 'los dos denies, contados aparte');
+                    assert.equal(report.written, seed.facts.length + 4);
+                    assert.equal(report.skipped.undeclared, 0, 'un deny NUNCA es undeclared');
+                    const firstAllow = spy.log.findIndex((l) => l.startsWith('relate'));
+                    const lastDeny = spy.log.map((l) => l.startsWith('deny')).lastIndexOf(true);
+                    assert.isBelow(lastDeny, firstAllow, `fase 1 (denies) antes que fase 2 (allows): ${spy.log.join(' | ')}`);
+                    assert.isFalse(spy.log.some((l) => l.includes('denied_')), 'jamás relate/unrelate de una relación denied_*');
+                    await census(assert, to(), seed);
+                    const denied = await to().listDenies('editor', object, seed.partition);
+                    assert.isTrue(denied.subjects.some((s) => subjectKey(s) === subjectKey(seed.u1)), 'CENSO del deny directo');
+                    const deniedGroup = await to().listDenies('viewer', viaGroup, seed.partition);
+                    assert.isTrue(deniedGroup.subjects.some((s) => subjectKey(s) === `${seed.g1.type}:${seed.g1.id}#member`), 'CENSO del deny a g1#member');
+                    assert.isFalse(await to().check(seed.u1, 'owner', object, seed.partition), 'corte de camino en el destino');
+                    assert.isFalse(await to().check(seed.u3, 'viewer', viaGroup, seed.partition), 'el deny del grupo llega a su miembro');
+                    const again = await reconcileRelations({ from: from(), to: to(), partition: seed.partition });
+                    assert.equal(again.written + again.updated + again.deleted, 0, 'idempotente con denies');
+                    assert.equal(again.denies?.unchanged, 2);
+                });
+                test(`${dir.label} · D2 · --prune: el deny SOBRANTE se borra con removeDeny (jamás unrelate), DESPUÉS de los allows sobrantes`, async ({ assert }) => {
+                    const seed = makeSeed();
+                    await plant(from(), seed);
+                    const gone = { type: denyType, id: uuidv7() };
+                    await to().relate(seed.u2, 'viewer', gone, seed.partition);
+                    await to().deny(seed.u2, 'viewer', gone, seed.partition);
+                    const spy = writesOf(to());
+                    const report = await reconcileRelations({ from: from(), to: spy.driver, partition: seed.partition, prune: true });
+                    assert.equal(report.denies?.deleted, 1);
+                    const prunes = spy.log.filter((l) => l.startsWith('unrelate') || l.startsWith('removeDeny'));
+                    assert.deepEqual(prunes, ['unrelate viewer', 'removeDeny viewer'], 'allows antes que denies; el deny con removeDeny');
+                    assert.lengthOf((await to().listDenies('viewer', gone, seed.partition)).subjects, 0);
+                    await census(assert, to(), seed);
+                });
+            }
+            test('D2 · S6 · un destino SIN relationDenies con un deny en el origen ⇒ 500 E_AUTHZ_DENY_MIGRATION_REFUSED con CERO escrituras (jamás skipped)', async ({ assert }) => {
+                const seed = makeSeed();
+                await plant(a, seed);
+                await a.deny(seed.u1, 'viewer', { type: denyType, id: uuidv7() }, seed.partition);
+                const blind = writesOf(b);
+                const target = new Proxy(blind.driver, {
+                    get(t, prop) {
+                        if (prop === 'capabilities')
+                            return { ...b.capabilities, relationDenies: false };
+                        return Reflect.get(t, prop, t);
+                    },
+                });
+                let caught = null;
+                try {
+                    await reconcileRelations({ from: a, to: target, partition: seed.partition });
+                }
+                catch (error) {
+                    caught = error;
+                }
+                assert.equal(caught?.status, 500, String(caught?.message));
+                assert.equal(caught?.code, 'E_AUTHZ_DENY_MIGRATION_REFUSED');
+                assert.deepEqual(blind.log, [], 'CERO escrituras: tampoco los allows');
+            });
+        }
         // El puerto exige `enumerateRelations` en ambos: un driver que no lo trae
         // no puede ser origen ni destino (500, jamás una migración a ciegas).
         test('un driver sin `enumerateRelations` ⇒ 500 E_AUTHZ_UNSUPPORTED como origen', async ({ assert }) => {
@@ -217,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
@@ -1826,7 +1862,12 @@ export declare function isRelUserset(subject: RelSubject): subject is RelUserset
  * muta el store.
  */
 export interface RelationRef {
-    operation: 'relate' | 'unrelate';
+    /**
+     * La operación. **Ensanchada en 2.5.0-alpha.3 (lote D)** con `'deny'` y `'removeDeny'`: un `assertWrite`/
+     * `onRelationWrite` escrito contra 2.4 con `if (op === 'unrelate') quitar; else añadir` trataría un DENY como un
+     * alta y CONCEDERÍA de más en el índice del consumidor (auditor R2-14). Haz `switch` sobre la operación.
+     */
+    operation: 'relate' | 'unrelate' | 'deny' | 'removeDeny';
     subject: RelSubject;
     relation: string;
     object: RelObject;
@@ -1856,11 +1897,16 @@ export interface RelationRef {
  *   terceros y dentro de una `{ transaction }` sería un número que un
  *   rollback desmiente). Quien necesite el «cuántas» tiene
  *   `enumerateRelations`/`listSubjects` ANTES de purgar. Las purgas NO pasan
- *   por `assertWrite` (su `RelationRef.operation` es `'relate' | 'unrelate'`,
+ *   por `assertWrite` (su `RelationRef.operation` es `'relate' | 'unrelate' | 'deny' | 'removeDeny'`,
  *   tipo publicado del hook R-13).
  */
 export interface RelationWriteEvent {
-    operation: 'relate' | 'unrelate' | 'purgeObject' | 'purgeSubject';
+    /**
+     * La operación. Desde 2.5.0-alpha.3 también `'deny'`/`'removeDeny'` (con `subject`, `relation` —el nombre
+     * PÚBLICO, nunca `denied_<rel>`—, `object`, `partition` y `actor`; sin `expiresAt`: el deny no caduca, D3). **Un
+     * handler que trate todo lo que no sea `unrelate` como alta concede de más** (R2-14): ramifica por operación.
+     */
+    operation: 'relate' | 'unrelate' | 'deny' | 'removeDeny' | 'purgeObject' | 'purgeSubject';
     /** Ausente solo en `purgeObject` (afecta a todos los sujetos del objeto). */
     subject?: RelSubject;
     /** Ausente en `purgeObject`/`purgeSubject` (afectan a todas las relaciones). */
@@ -1943,7 +1989,22 @@ export interface RelationWriteOptions extends RelationTransactionOptions {
      */
     expiresAt?: Date | null;
 }
-/** Una página de una enumeración de relaciones (cursor opaco que AVANZA, no filtra herencia). */
+/**
+ * Opciones de `deny`/`removeDeny` (plan 2.5 · lote D): la transacción del consumidor y el `actor`. **Sin `expiresAt`**
+ * (D3: el deny no caduca en v1): pasarlo —incluso `null`— es 422 `E_AUTHZ_DENY_EXPIRY_UNSUPPORTED` con la razón medida.
+ */
+export interface RelationDenyOptions extends RelationTransactionOptions {
+    /** Quién ordena el deny; validado (422) y viaja en `RelationWriteEvent.actor`. */
+    actor?: SubjectRef;
+}
+/** 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 `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;
@@ -2014,24 +2075,51 @@ export interface RelationsDriverCapabilities {
      * revierten juntos) y que una transacción ajena no recibe ni una sentencia.
      */
     transactionalWrites: boolean;
+    /**
+     * **El driver sabe denegar** (plan 2.5 · lote D, D1): trae `deny`/`removeDeny`/`listDenies`/`decideMany` y TODAS
+     * sus lecturas honran las tuplas `denied_<rel>` con la semántica de CORTE DE CAMINO (D5: un deny en `Y` anula todo
+     * grant de `T` con `Y ∈ up*(T)`). **Opcional y normalizada a `false`** (regla D15: toda clave nueva desde 2.5.0 es
+     * `?:`); con `false` (o ausente) las cuatro operaciones del deny son 500 `E_AUTHZ_UNSUPPORTED` nombrándolas, con
+     * CERO llamadas al driver. `database` y `openfga` = `true`. Par de caras en `runRelationsDriverContract`.
+     */
+    relationDenies?: boolean;
+    /**
+     * **`relate` sobre una tupla EXISTENTE con otra caducidad es UNA escritura atómica** (plan 2.5 · lote D · cierre 2 de
+     * D2, 🟠 N1): ningún instante sin la tupla. `database` = `true` (delete + insert en UNA transacción). `openfga` =
+     * `false`: FGA no reemplaza la misma clave en un `Write` (M5), así que renueva con DOS (delete, write) y entre ellos la
+     * tupla no está — si es una membresía `group:*#member` que TRANSPORTA un deny (el grupo, o uno por encima de él, es
+     * sujeto de un deny vivo de la partición), el sujeto quedaría sin el deny. Un driver con `false` (o ausente: regla D15,
+     * opcional y normalizada a `false`) **tiene que NEGAR esa renovación** con 409 `E_AUTHZ_RENEWAL_UNSAFE` y CERO
+     * escrituras, y marcar como escritura PARCIAL (`markPartialWrite`) la renovación permitida cuyo 2.º `Write` falla; el
+     * reconcile no le pide renovar una membresía portadora (residuo `renewal-unsafe`). Par de caras en
+     * `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). */
@@ -2047,6 +2135,28 @@ export interface RelationTuple {
      * (la lección de la 3b); filtrarla en el origen la haría desaparecer sin rastro.
      */
     expiresAt?: Date | null;
+    /**
+     * **`allow` o `deny`** (plan 2.5 · lote D · D2): un deny se enumera con su relación PÚBLICA (`viewer`, no la
+     * almacenada `denied_viewer`) y `kind: 'deny'`. Opcional en el tipo exportado (un driver de terceros anterior
+     * sigue compilando; ausente = `allow`), **obligatorio en la práctica para un driver con `relationDenies: true`**:
+     * `reconcileRelations` se NIEGA (500 `E_AUTHZ_DENY_MIGRATION_REFUSED`, motivo `unmarked`) a migrar una tupla cuya
+     * relación empieza por el prefijo reservado `denied_` y no viene marcada — un deny sin `kind` casaría con un allow
+     * 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[];
@@ -2111,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`. */
@@ -2125,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>;
     /**
@@ -2142,6 +2256,48 @@ export interface RelationsDriver {
      * jamás «vacío = éxito» para una partición que no pudo leer entera.
      */
     enumerateRelationsMany?(partitions: ScopeRef[], page?: RelationPage): Promise<RelationTuplePage>;
+    /**
+     * **Deny de relación** (plan 2.5 · lote D · D1; obligatorio con `relationDenies: true`): escribe el deny de
+     * `relation` sobre `object` para `subject` (la tupla almacenada `denied_<relation>`). Idempotente, SIN caducidad
+     * (D3). Solo sobre un tipo en fase `'write'` del opt-in (422 `E_AUTHZ_RELATION_NOT_DENYABLE` si no), nunca sobre
+     * `group` ni con `*`. Corte de camino (D5): un deny en `editor` anula entero un grant de `owner`.
+     */
+    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). 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
+     * no, `none`. Las MISMAS garantías que `checkMany`: 1..`RELATIONS_CHECK_MANY_MAX` objetos (422 fuera), un `now`
+     * por lote, F-05 por ítem, y un `error` en UN ítem ⇒ 503 para todo el lote (nunca `none`: sería fail-open).
+     */
+    decideMany?(subject: RelSubject, relation: string, objects: RelObject[], partition: ScopeRef): Promise<RelationDecision[]>;
+    /**
+     * **¿Admite ESTE driver escrituras de deny en `object.type`?** (plan 2.5 · lote D · D2; juez ronda 2 · R2-5: «la
+     * pregunta la responde el driver DESTINO en la fase de plan, antes de escribir: su config de relaciones y, en
+     * `openfga`, su modelo fijado»). Devuelve la fase del opt-in del tipo en la config DEL DRIVER (`'write'`, `'read'`)
+     * o `null` sin opt-in. F-05 estricto del par (422 si el tipo o la relación no están declarados), cero escrituras;
+     * en `openfga` con opt-in además comprueba el modelo FIJADO (D-31: 500 `E_AUTHZ_CONFIG` si no declara
+     * `denied_<rel>`). Lo llama `reconcileRelations` ANTES de escribir nada cuando el origen trae denies: un destino
+     * con `relationDenies: true` que no lo traiga no puede ser destino de denies (500, jamás `skipped`). Lectura de
+     * configuración: no lee tuplas ni recibe partición.
+     */
+    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
@@ -2162,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