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

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

package/build/src/identity.d.ts

@@ -173,6 +173,8 @@ export declare function scopeSpellings(scope: ScopeRef): ScopeRef[];
 export declare function isDashlessUuid(value: unknown): value is string;
 /** La forma 8-4-4-4-12 de un uuid de 32 hex (la ortografía CANÓNICA). */
 export declare function dashedUuid(dashless: string): string;
+/** ¿Es un uuid en su ortografía CANÓNICA (8-4-4-4-12, minúsculas)? (7.4: la forma del cursor de `enumerate*` de `database`.) */
+export declare function isCanonicalUuid(value: unknown): value is string;
 /**
  * **¿Es una ortografía NO canónica de un uuid?** (D4 + cierre 🟠 A2 del
  * auditor del lote A, decisión del dueño 2026-10-15): todo valor que, sin
@@ -336,4 +338,3 @@ export interface IdentityParts {
  * cuesta una consulta ni deja rastro.
  */
 export declare function assertIdentity(parts: IdentityParts): void;
-//# sourceMappingURL=identity.d.ts.map

package/build/src/identity.js

@@ -306,6 +306,10 @@ export function dashedUuid(dashless) {
 /* ── Partición de RELACIONES (D4, plan 2.5 · lote A) ───────────────────── */
 /** La ortografía CANÓNICA de un uuid: exactamente 8-4-4-4-12, minúsculas. */
 const CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/** ¿Es un uuid en su ortografía CANÓNICA (8-4-4-4-12, minúsculas)? (7.4: la forma del cursor de `enumerate*` de `database`.) */
+export function isCanonicalUuid(value) {
+    return typeof value === 'string' && CANONICAL_UUID.test(value);
+}
 /**
  * **¿Es una ortografía NO canónica de un uuid?** (D4 + cierre 🟠 A2 del
  * auditor del lote A, decisión del dueño 2026-10-15): todo valor que, sin
@@ -606,4 +610,3 @@ export function assertIdentity(parts) {
     if ('expiresAt' in parts)
         assertExpiresAt(parts.expiresAt);
 }
-//# sourceMappingURL=identity.js.map

package/build/src/manager.d.ts

@@ -787,4 +787,3 @@ export declare class AuthorizationManager {
         maxScopes?: number;
     }): Promise<ScopeRef[]>;
 }
-//# sourceMappingURL=manager.d.ts.map

package/build/src/manager.js

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

package/build/src/memoize_ancestors.d.ts

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

package/build/src/memoize_ancestors.js

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

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

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

package/build/src/models/authz_assignment.js

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

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

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

package/build/src/models/authz_deny.js

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