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

package/build/src/relations/reconcile.js

@@ -27,14 +27,16 @@
  * clave, niega la dirección rancia y congela; la guardia de superficie de
  * `command_flags.spec.ts` impide re-exportarlo por ningún subpath.
  */
-import { ActorRequiredError, AuthorizationConfigError, CheckManyBatchError, DenyMigrationRefusedError, InvalidIdentityError, InvalidSlugError, MassReconcileRefusedError, NoScopeResolverError, RelationConfigError, RelationConfigUnknownKeyError, RelationDenyExpiryError, RelationNotDenyableError, RelationTypeUnknownError, RelationUnknownError, RelationUsersetUnsupportedError, UnknownScopeError, UnsupportedOperationError, isPartialWrite, markPartialWrite, } from '../errors.js';
+import { ActorRequiredError, AuthorizationConfigError, CheckManyBatchError, DenyMigrationRefusedError, GroupDepthLimitError, InvalidIdentityError, InvalidRelationPageError, InvalidSlugError, MassReconcileRefusedError, NoScopeResolverError, RelationConfigError, RelationConfigUnknownKeyError, RelationDenyExpiryError, RelationNotDenyableError, RelationTypeUnknownError, RelationUnknownError, RelationUsersetUnsupportedError, UnknownScopeError, UnsupportedOperationError, isPartialWrite, markPartialWrite, } from '../errors.js';
 import { systemClock } from '../clock.js';
 import { isActiveExpiry, sameInstant } from '../expiry.js';
 import { assertPartition, scopeKey } from '../identity.js';
 import { isRelUserset } from '../types.js';
 import { assertRelationDeclared, assertSupportedUserset, RELATION_DENY_PREFIX, RELATION_USERSET_TYPE, relationsUp } from './define_relations_config.js';
+import { denyReachCheck } from './deny_reach.js';
 import { relationTupleKey } from './tuple_key.js';
 import { carriedDenies, denyCarrierGroups, relationTransitionOrder } from './tuple_order.js';
+import { groupChainDepth, plannedRelateOptions } from './group_depth.js';
 /**
  * La clave con la que se casan origen y destino es `relationTupleKey` (plan
  * 2.5 · lote A, P3-4): la MISMA función pura y exportada que un consumidor
@@ -74,6 +76,7 @@ export const RELATIONS_RECONCILE_DETAIL_REASONS = Object.freeze([
     'undeclared',
     'deny-conditional',
     'renewal-unsafe',
+    'invalid-condition',
 ]);
 /**
  * **Una receta POR MOTIVO** (cierre 1 de D2 · 🟡 6, ⚪ 11). `honor` = el deny ya está en el destino y lo que falta es
@@ -138,6 +141,19 @@ export function partitionRefusalRecipe(reasons) {
         out.push(`deny-conditional: un deny no caduca (D3) y este destino no puede rehacerlo permanente en una escritura. removeDeny + ` +
             `deny de esa tupla en el DESTINO aceptando la ventana de forma EXPLÍCITA — entre los dos el deny no niega —, y repite.`);
     }
+    if (set.has('too-deep')) {
+        out.push(`too-deep: la cadena de grupos anidados que dejaría la pasada en esta partición es más larga que el techo del DESTINO ` +
+            `(en openfga, más allá todo check de un no-miembro es 503 E_AUTHZ_RESOLUTION_LIMIT). Saltar la arista que excede ` +
+            `quitaría los denies que transporta: no se hace. Aplana la anidación en el ORIGEN (unrelate de la arista y miembros ` +
+            `metidos en un grupo menos profundo) —sin --prune cuenta también lo que el destino ya tiene de más—, o sube el techo ` +
+            `del destino (OPENFGA_RESOLVE_NODE_LIMIT en el servidor; maxGroupDepth en la config solo lo baja), y repite.`);
+    }
+    if (set.has('invalid-condition')) {
+        out.push(`invalid-condition: una membresía de group con una condición que el paquete no escribe ni sabe leer puede estar VIVA en ` +
+            `el servidor (un not_expired con current_time congelado lo está) y transportar los denies de la partición: el paquete ` +
+            `no sabe qué concede y no migra la partición a ciegas. Revisa esa tupla en su store (SDK/CLI de OpenFGA): bórrala, o ` +
+            `reescríbela por el paquete (unrelate + relate con la caducidad que corresponda), y repite.`);
+    }
     return out.join(' ');
 }
 /**
@@ -215,11 +231,26 @@ export async function reconcileRelations(options) {
             }
         }
         : undefined;
+    // R1 (decisión del dueño 2026-10-17 (5); 🔴 C-1): el techo de anidación del DESTINO — el calibrado en `openfga`, de
+    // solo lectura, así que también en `--dry-run` (mismo 500 si la config promete más de lo que el servidor resuelve) —.
+    // Un driver sin el método no tiene techo para el plan.
+    // Solo si hay alguna arista de anidación en el origen o en el destino de las particiones pedidas: sin ninguna, la cadena
+    // final es 0 y no hay nada que preguntar (ni calibración que pagar, ni la puerta del modelo de la calibración por
+    // delante de la del deny).
+    const anyNesting = [...enumeratedByKey.values(), ...destByKeyAll.values()].some((tuples) => tuples.some(isNestingTuple));
+    const groupDepthLimit = anyNesting && typeof to.groupDepthLimit === 'function' ? await to.groupDepthLimit() : null;
     const plans = [];
     for (const partition of partitions) {
         const enumerated = enumeratedByKey.get(scopeKey(partition)) ?? [];
         const destTuples = destByKeyAll.get(scopeKey(partition)) ?? [];
-        plans.push(planPartition(partition, enumerated, destTuples, { now, prune, toConfig, atomicRenewal: to.capabilities?.atomicRenewal === true, cuts }));
+        plans.push(planPartition(partition, enumerated, destTuples, {
+            now,
+            prune,
+            toConfig,
+            atomicRenewal: to.capabilities?.atomicRenewal === true,
+            cuts,
+            groupDepthLimit,
+        }));
     }
     const report = {
         dryRun,
@@ -238,7 +269,10 @@ export async function reconcileRelations(options) {
         partitions: plans.map((plan) => emptyPartitionReport(plan.partition)),
         orderResidue: [],
         partitionsRefused: [],
+        tooDeep: [],
     };
+    if (options.denyReach !== undefined)
+        report.denyReach = detectDenyReach(options.denyReach, enumeratedByKey, destByKeyAll);
     for (const plan of plans) {
         // **El seguro de borrado masivo** (R-17, paridad con `authz:reconcile` de
         // roles / AA2). `prune` + un ORIGEN sin una sola tupla utilizable + un destino
@@ -255,6 +289,8 @@ export async function reconcileRelations(options) {
                 `una sola relación. Comprueba el --from y el store; si de verdad quieres vaciarlo, --allow-mass-delete.` +
                 `${partitions.length > 1 ? ' No se ha escrito nada en ninguna partición.' : ''}`);
         }
+        if (plan.tooDeep)
+            report.tooDeep.push({ partition: scopeKey(plan.partition), ...plan.tooDeep });
         report.massDelete ||= plan.massDelete;
         report.skipped.expired += plan.skipped.expired;
         report.skipped.undeclared += plan.skipped.undeclared;
@@ -303,7 +339,7 @@ export async function reconcileRelations(options) {
  */
 function refusePartition(plan, row, report, prune) {
     const refusal = plan.refusal;
-    const PRUNABLE = new Set(['invalid-identity', 'userset-unsupported', 'undeclared']);
+    const PRUNABLE = new Set(['invalid-identity', 'userset-unsupported', 'undeclared', 'invalid-condition']);
     for (const detail of plan.details) {
         report.details.push(prune && detail.side === 'destino' && PRUNABLE.has(detail.reason) ? { ...detail, pruned: false } : detail);
     }
@@ -388,7 +424,7 @@ async function applyPartition(plan, row, report, context) {
     // gramática se LISTA siempre, en los dos lados; con `prune` el del destino lleva `pruned: false` desde el plan. El
     // `renewal-unsafe` (cierre 2 de D2 · 🟠 N1) no es un borrado: no lleva `pruned`.
     // Cierre 4 de D2: `deny-conditional` (ya del PLAN) lleva `pruned: false` siempre.
-    const PRUNABLE = new Set(['invalid-identity', 'userset-unsupported', 'undeclared']);
+    const PRUNABLE = new Set(['invalid-identity', 'userset-unsupported', 'undeclared', 'invalid-condition']);
     for (const detail of plan.details) {
         report.details.push(prune && detail.side === 'destino' && PRUNABLE.has(detail.reason) ? { ...detail, pruned: false } : detail);
     }
@@ -547,7 +583,11 @@ async function denyGate(to, plans) {
                 push({ objectType, relation, reason: 'undeclared', message: String(error?.message ?? error), recipe: denyRefusalRecipe('undeclared', objectType, relation) });
                 continue;
             }
-            if (error?.status === 500 && error?.code === AuthorizationConfigError.code) {
+            // Cierre de R3 (⚪ R3-A7): «el modelo fijado no declara denied_*» es SOLO el 500 de la puerta del modelo (sin
+            // respuesta HTTP en la cadena de `cause`). Un 500 E_AUTHZ_CONFIG que trae la respuesta del servidor (401/403/404,
+            // store inexistente, un 4xx desconocido: R3) es del DESPLIEGUE, no del modelo: se propaga con su letra en vez de
+            // reportarse como negativa `reason: 'model'` con la receta del modelo (fail-closed igual: nada se escribe).
+            if (error?.status === 500 && error?.code === AuthorizationConfigError.code && !carriesHttpResponse(error)) {
                 push({ objectType, relation, reason: 'model', message: String(error?.message ?? error), recipe: denyRefusalRecipe('model', objectType, relation) });
                 continue;
             }
@@ -688,7 +728,7 @@ function partitionsOf(options) {
     });
 }
 function planPartition(partition, enumerated, destTuples, context) {
-    const { now, prune, toConfig, atomicRenewal, cuts } = context;
+    const { now, prune, toConfig, atomicRenewal, cuts, groupDepthLimit = null } = context;
     // R-15: la caducada LLEGA del origen (el puerto lo exige) y aquí se DESCARTA
     // contándola: no se migra ni respalda nada en el destino. Decidido con UN
     // `now` para toda la pasada.
@@ -706,12 +746,30 @@ function planPartition(partition, enumerated, destTuples, context) {
     const usersetResidue = [];
     const undeclaredResidue = [];
     const denyRefusals = [];
+    /** Cierre de L11 (🟡 A2): las membresías (origen o destino) con una condición que el paquete no escribe ni sabe leer. */
+    const invalidCarriers = [];
     const refuse = (tuple, reason, message) => {
         const objectType = String(tuple?.object?.type);
         const relation = String(tuple?.relation);
         denyRefusals.push({ objectType, relation, reason, message, recipe: denyRefusalRecipe(reason, objectType, relation) });
     };
     for (const tuple of enumerated) {
+        // L11 (injerto 3 del juez): una tupla del ORIGEN cuya condición el paquete no escribe o no sabe leer
+        // (`invalidCondition`, `fgaTupleExpiry`) NO se migra —su `expiresAt` null no es «permanente»—; se lista y es deriva.
+        // Un deny así NIEGA la PASADA (500 `E_AUTHZ_DENY_MIGRATION_REFUSED`: perder un deny no es una pérdida declarable); una
+        // MEMBRESÍA así en una partición con algún deny niega SU partición (cierre de L11, abajo).
+        if (typeof tuple?.invalidCondition === 'string') {
+            if (kindOf(tuple) === 'deny') {
+                refuse(tuple, 'invalid', `condición que el paquete no escribe: ${tuple.invalidCondition}`);
+                continue;
+            }
+            skipped.invalid += 1;
+            invalid.push({ side: 'origen', reason: 'invalid-condition', tuple: describeTuple(tuple), message: tuple.invalidCondition });
+            // Cierre de L11 (🟡 A2): una MEMBRESÍA así puede ser una portadora VIVA — se decide abajo si niega la partición.
+            if (tuple?.object?.type === RELATION_USERSET_TYPE)
+                invalidCarriers.push(tuple);
+            continue;
+        }
         if (!isActiveExpiry(tuple.expiresAt ?? null, now)) {
             skipped.expired += 1;
             continue;
@@ -794,6 +852,8 @@ function planPartition(partition, enumerated, destTuples, context) {
     /** Cierre 4 de D2 · 🟡 C3-2: los denies del destino VENCIDOS (no cuentan como presentes, pero el destino los tiene). */
     const expiredDenyByKey = new Map();
     const residue = new Set();
+    /** L11: las claves del destino con una condición que el paquete no escribe: el origen no las reescribe. */
+    const blockedKeys = new Set();
     for (const tuple of destTuples) {
         // ⚪ 8 (cierre 1 de D2): un deny del DESTINO sin `kind` (un driver de terceros que no marca) es la MISMA negativa
         // `unmarked` que en el origen, decidida en el PLAN: planificarlo como allow lo podaría con `unrelate(denied_*)` (que
@@ -831,6 +891,20 @@ function planPartition(partition, enumerated, destTuples, context) {
             undeclaredResidue.push({ side: 'destino', reason: 'undeclared', tuple: describeTuple(tuple), message: undeclared });
             continue;
         }
+        // L11 · H8: una tupla del DESTINO con una condición que el paquete no escribe es PRESENTE e INTOCABLE: `extra` con
+        // motivo y nunca `toDelete` (ni con `--prune`), y su CLAVE no se reescribe desde el origen (un `relate` sobre ella es
+        // 409 a mitad de pasada). No entra en el contexto del orden, y NO porque el servidor la ignore —un `not_expired` con
+        // `current_time` congelado está VIVO (medido, H2)—, sino porque si es una MEMBRESÍA (la única forma de transportar un
+        // deny) en una partición con algún deny, la partición se NIEGA (cierre de L11, 🟡 A2: cero escrituras, el orden no se
+        // usa); sin ningún deny en la partición no transporta nada que el orden tenga que ordenar.
+        if (typeof tuple?.invalidCondition === 'string') {
+            residue.add(tuple);
+            invalid.push({ side: 'destino', reason: 'invalid-condition', tuple: describeTuple(tuple), message: tuple.invalidCondition });
+            blockedKeys.add(keyed.key);
+            if (tuple?.object?.type === RELATION_USERSET_TYPE)
+                invalidCarriers.push(tuple);
+            continue;
+        }
         // Cierre 3 de D2 · 🟠 C2-1 / 🟡 C2-2: una tupla del destino VENCIDA en `now` (el MISMO `now` con el que el origen
         // descarta las suyas) no conecta nada —ni en `database` ni en FGA— y el plan la trata como AUSENTE: su reescritura es
         // una escritura normal (nunca `toUpdate`, nunca `renewal-unsafe`) y no entra en el contexto del orden (ni portadora,
@@ -844,6 +918,27 @@ function planPartition(partition, enumerated, destTuples, context) {
         }
         destByKey.set(keyed.key, tuple);
     }
+    // L11 · H8: una clave que el destino tiene con una condición que el paquete no escribe NO se reescribe desde el origen
+    // (sería un `relate` que el driver rechaza con 409 a mitad de pasada): la tupla del origen se lista y es deriva; un deny
+    // NIEGA la partición. Sale también del contexto del orden (no se va a escribir).
+    for (const key of blockedKeys) {
+        const tuple = sourceByKey.get(key);
+        if (!tuple)
+            continue;
+        sourceByKey.delete(key);
+        sourceTuples.splice(sourceTuples.indexOf(tuple), 1);
+        if (kindOf(tuple) === 'deny') {
+            refuse(tuple, 'invalid', `el DESTINO tiene ${describeTuple(tuple)} con una condición que el paquete no escribe`);
+            continue;
+        }
+        skipped.invalid += 1;
+        invalid.push({
+            side: 'origen',
+            reason: 'invalid-condition',
+            tuple: describeTuple(tuple),
+            message: 'la clave existe en el DESTINO con una condición que el paquete no escribe: no se reescribe (bórrala allí a mano y repite)',
+        });
+    }
     const toWrite = [];
     const toUpdate = [];
     const denyWrite = [];
@@ -968,14 +1063,58 @@ function planPartition(partition, enumerated, destTuples, context) {
     // (también con `--prune` y las vencidas): queda EXACTAMENTE como estaba, que es lo único certificable; el resto migra.
     // Sustituye a la retención del cierre 4 (`relationWithheldWrites`, `withheld-by-unsafe-deny`, `carrier-conflict`): retener
     // tupla a tupla no cubría lo que el destino YA concedía (D4-1) y su negativa era global (D4-3).
-    const causes = [...denyConditional, ...renewalUnsafe].map((detail) => ({ reason: detail.reason, tuple: detail.tuple }));
+    const causes = [...denyConditional, ...renewalUnsafe].map((detail) => ({
+        reason: detail.reason,
+        tuple: detail.tuple,
+    }));
+    // **Cierre de L11 (🟡 A2 del auditor; criterio del dueño: ante la duda, la opción que nunca concede de más)**: una
+    // membresía `foreign`/`unparseable` (origen o destino) en una partición con ALGÚN deny (origen o destino, vivo o no,
+    // marcado o no) NIEGA la partición. El servidor puede estar evaluándola VIVA y transportando ese deny; migrarla sin ella
+    // —o escribir en el destino alrededor de ella— fabricaba un `check = true` que ningún estado del origen concedía (medido:
+    // `.claude/reproducciones/loteRC-L11-auditor-carrier.ts`). Mismo mecanismo que la opción A: cero escrituras en ella.
+    const anyDeny = [...enumerated, ...destTuples].some((tuple) => kindOf(tuple) === 'deny' || String(tuple?.relation ?? '').startsWith(RELATION_DENY_PREFIX));
+    if (anyDeny)
+        for (const tuple of invalidCarriers)
+            causes.push({ reason: 'invalid-condition', tuple: describeTuple(tuple) });
+    // **R1 (decisión del dueño 2026-10-17 (5); 🔴 C-1 del auditor)**: la cadena de grupos anidados que dejaría la pasada
+    // —el estado FINAL (T-5 del tester): las aristas vivas del origen, más las del destino que se QUEDAN (sin `--prune`,
+    // todas las vivas; con él y sin él, TODO el residuo intocable que siga vivo —`invalid-identity`, `undeclared`,
+    // `invalid-condition`, …: nadie lo borra y el servidor lo evalúa; cierre de R1 · 🟡 3 del auditor, hasta entonces
+    // solo `invalid-condition`)—, y las de condición ilegible cuentan como vivas— no puede pasar
+    // del techo del destino. Si pasa, la partición se NIEGA (cero escrituras): saltar la arista que excede quitaría los
+    // denies que transporta y el destino concedería lo que el origen niega. Un ciclo NO niega por sí solo (OpenFGA lo
+    // evalúa bien): cuenta, de forma conservadora, como k − 1 saltos de su recorrido.
+    let tooDeep;
+    if (groupDepthLimit !== null) {
+        const edges = [];
+        const push = (tuple) => {
+            if (isNestingTuple(tuple))
+                edges.push({ child: tuple.subject.object.id, parent: tuple.object.id });
+        };
+        for (const tuple of sourceTuples)
+            push(tuple);
+        if (!prune)
+            for (const tuple of destByKey.values())
+                push(tuple);
+        for (const tuple of destTuples)
+            if (residue.has(tuple) && residueAlive(tuple, now))
+                push(tuple);
+        const { depth, chain } = groupChainDepth(edges);
+        if (depth > groupDepthLimit) {
+            tooDeep = { depth, limit: groupDepthLimit, chain };
+            causes.push({
+                reason: 'too-deep',
+                tuple: `cadena de ${depth} saltos de grupos anidados > techo ${groupDepthLimit} del destino: ${chain.slice(0, 8).join(' ⊂ ')}${chain.length > 8 ? ' ⊂ …' : ''}`,
+            });
+        }
+    }
     const refusal = causes.length > 0
         ? {
             partition: scopeKey(partition),
             causes,
             pending: {
                 write: toWrite.length + denyWrite.length,
-                update: toUpdate.length + denyUpdate.length + causes.length,
+                update: toUpdate.length + denyUpdate.length + denyConditional.length + renewalUnsafe.length,
                 delete: prune ? allowDelete.length + denyDelete.length : 0,
             },
             recipe: partitionRefusalRecipe(causes.map((cause) => cause.reason)),
@@ -1007,8 +1146,39 @@ function planPartition(partition, enumerated, destTuples, context) {
         shortening,
         denyConditional: denyConditional.length,
         refusal,
+        ...(tooDeep ? { tooDeep } : {}),
     };
 }
+/**
+ * R1: ¿es una arista de anidación `group:P#member@group:C#member` (allow)? La misma forma que `isGroupNesting`, y con
+ * ids de TEXTO (el residuo `invalid-identity` del destino puede traer cualquier cosa: con un id que no es texto no hay
+ * arista que contar).
+ */
+function isNestingTuple(tuple) {
+    return (kindOf(tuple) === 'allow' &&
+        tuple?.object?.type === RELATION_USERSET_TYPE &&
+        typeof tuple.object.id === 'string' &&
+        tuple.relation === 'member' &&
+        isRelUserset(tuple.subject) &&
+        tuple.subject.object?.type === RELATION_USERSET_TYPE &&
+        typeof tuple.subject.object.id === 'string' &&
+        tuple.subject.relation === 'member');
+}
+/**
+ * R1 · 🟡 3: ¿sigue VIVA en el servidor una tupla del RESIDUO del destino? Una con condición ilegible, sí (no se sabe
+ * leer: cuenta, más negativas nunca menos); una con caducidad legible, si no ha vencido en `now`; una caducidad que no
+ * se entiende, también viva (conservador).
+ */
+function residueAlive(tuple, now) {
+    if (typeof tuple?.invalidCondition === 'string')
+        return true;
+    try {
+        return liveInDestination(tuple, now);
+    }
+    catch {
+        return true;
+    }
+}
 /**
  * **¿Cuenta una tupla del DESTINO en el plan?** (cierre 3 de D2 · 🟠 C2-1 / 🟡 C2-2): sí si está VIVA en `now` (el mismo
  * `now` de toda la pasada, con el que el origen descarta sus caducadas); una VENCIDA es AUSENTE — no conecta nada en
@@ -1036,6 +1206,62 @@ function orderView(tuple) {
 function kindOf(tuple) {
     return tuple?.kind === 'deny' ? 'deny' : 'allow';
 }
+/**
+ * **El detector de (8) sobre lo ya enumerado**: agrupa los denies de cada lado por tipo y relación pública —contando CLAVES
+ * DE TUPLA distintas (`relationTupleKey`): un deny espejado en origen y destino es uno, firma (8 · `count`)— y les pasa
+ * `denyReachCheck` (la MISMA función que la guarda de `database` y el detector de un driver), en las dos direcciones. Un deny
+ * es una tupla con `kind: 'deny'` (o, sin marcar, con la relación almacenada `denied_*`: la cuenta igual — la puerta del
+ * deny ya la niega aparte como `unmarked`). LÍMITE: lo que no se enumera no se ve (un TIPO retirado de la config del
+ * driver no se enumera; la guarda de `database` y `checkRelationsConfigDenyReach` sí leen la tabla entera).
+ */
+function detectDenyReach(options, source, destination) {
+    const sides = new Map();
+    const keys = new Map();
+    for (const [side, byKey] of [['origen', source], ['destino', destination]]) {
+        for (const tuples of byKey.values()) {
+            for (const tuple of tuples) {
+                const stored = typeof tuple?.relation === 'string' ? tuple.relation : '';
+                const relation = kindOf(tuple) === 'deny' ? stored : stored.startsWith(RELATION_DENY_PREFIX) ? stored.slice(RELATION_DENY_PREFIX.length) : null;
+                const objectType = tuple?.object?.type;
+                if (!relation || typeof objectType !== 'string')
+                    continue;
+                const group = `${objectType}#${relation}`;
+                let identity;
+                try {
+                    identity = relationTupleKey({ ...tuple, kind: 'deny', relation });
+                }
+                catch {
+                    identity = JSON.stringify([scopeKeyOrNull(tuple?.partition), objectType, tuple?.object?.id, relation, tuple?.subject]);
+                }
+                keys.set(group, (keys.get(group) ?? new Set()).add(identity));
+                sides.set(group, (sides.get(group) ?? new Set()).add(side));
+            }
+        }
+    }
+    const groups = [...keys].map(([group, identities]) => {
+        const [objectType, relation] = group.split('#');
+        return { objectType, relation, count: identities.size };
+    });
+    const check = denyReachCheck(options.baseline, options.current, groups);
+    const withSides = (finding) => ({
+        ...finding,
+        sides: [...(sides.get(`${finding.objectType}#${finding.relation}`) ?? [])].sort(),
+    });
+    return {
+        baseline: check.baseline,
+        findings: check.findings.filter((finding) => finding.reason !== 'no-baseline').map(withSides),
+        stale: check.staleBaseline.map(withSides),
+        unjudged: check.findings.filter((finding) => finding.reason === 'no-baseline').reduce((total, finding) => total + finding.count, 0),
+    };
+}
+function scopeKeyOrNull(partition) {
+    try {
+        return scopeKey(partition);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * **F-05 del destino sobre una fila ENUMERADA del destino** (cierre 3 del lote B ·
  * 🟠 N9, capa 1): la MISMA `assertRelationDeclared` que corre en la primera línea
@@ -1072,6 +1298,20 @@ export const RELATION_REJECTIONS = Object.freeze({
     [RelationNotDenyableError.code]: { kind: 'refused', refusal: 'phase', where: "denyGate: denyPhase del DESTINO ≠ 'write' ⇒ 500 antes de escribir" },
     [RelationDenyExpiryError.code]: { kind: 'unreachable', why: 'el reconcile nunca pasa expiresAt a deny/removeDeny (D3: el deny no caduca)' },
     [CheckManyBatchError.code]: { kind: 'unreachable', why: 'el reconcile no llama a checkMany ni a decideMany' },
+    // Lote «antes de RC» · R1: el gate de anidación de grupos de los drivers del paquete. La profundidad la decide el PLAN
+    // (partición NEGADA, causa `too-deep`, sobre el estado FINAL) y la pasada escribe con la marca del plan (`plannedRelateOptions`),
+    // que esos drivers respetan (un ciclo preexistente se migra; un estado intermedio no se certifica). Un driver de
+    // terceros que lo lance igual se PROPAGA (fail-closed: la pasada se corta con su marca de parcial).
+    [GroupDepthLimitError.code]: {
+        kind: 'unreachable',
+        why: 'planPartition decide la profundidad (partitionsRefused too-deep) y relateOrSkip escribe con plannedRelateOptions (marca no falsificable atada a la arista): el gate de los drivers del paquete no se consulta en la pasada',
+    },
+    // Lote «antes de RC» · 7.4: la página de `enumerate*`. El reconcile no pasa `limit` y como `after` solo el cursor que el
+    // ORIGEN acaba de emitir (`enumerateAllMany`); un 422 de página ahí es un driver que rechaza su propio cursor: se propaga.
+    [InvalidRelationPageError.code]: {
+        kind: 'unreachable',
+        why: 'enumerateAllMany no pasa limit y solo reenvía como after el cursor que el ORIGEN acaba de emitir: un 422 de página sería un driver que rechaza su propio cursor (se propaga, la pasada no empieza a escribir)',
+    },
     [RelationConfigError.code]: { kind: 'unreachable', why: 'se lanza al DEFINIR la config; cuando el reconcile corre los drivers ya están construidos' },
     [RelationConfigUnknownKeyError.code]: { kind: 'unreachable', why: 'se lanza al DEFINIR la config (clave desconocida de la spec, B2)' },
     [InvalidSlugError.code]: { kind: 'unreachable', why: 'gramática de SLUGS del catálogo de roles: ninguna escritura de relaciones la invoca' },
@@ -1102,6 +1342,10 @@ export const RELATION_422_REASONS = Object.freeze(Object.fromEntries(Object.entr
  */
 export const RELATION_RESIDUES = Object.freeze({
     'invalid-identity': { where: 'plan', how: 'enumeratedKey (origen y destino); capa 2 por RELATION_REJECTIONS' },
+    'invalid-condition': {
+        where: 'plan',
+        how: 'planPartition (L11): una tupla con RelationTuple.invalidCondition — origen: no se migra (skipped.invalid; un deny NIEGA la pasada); destino: presente e intocable (extra, nunca toDelete) y su clave no se reescribe desde el origen; una membresía de group así en una partición con algún deny NIEGA la partición (partitionsRefused, cierre de L11)',
+    },
     'userset-unsupported': { where: 'plan', how: 'classifySubject (origen y destino, con o sin toConfig); capa 2 por RELATION_REJECTIONS' },
     'undeclared': { where: 'plan', how: 'classifyDestinationRow (destino, con toConfig); sin toConfig, capa 2 por RELATION_REJECTIONS' },
     'renewal-unsafe': {
@@ -1156,9 +1400,10 @@ function declaredIn(config, objectType) {
  */
 async function relateOrSkip(to, tuple) {
     try {
-        await to.relate(tuple.subject, tuple.relation, tuple.object, tuple.partition, {
-            expiresAt: tuple.expiresAt ?? null,
-        });
+        // R1: la profundidad de los grupos ya la decidió el PLAN sobre el estado final (y negó la partición si excedía); el
+        // gate del driver no se repite aquí (`plannedRelateOptions`: un ciclo preexistente se migra, y un estado intermedio
+        // de la pasada no es el que se certifica). La marca es la IDENTIDAD del objeto, atada a ESTA arista.
+        await to.relate(tuple.subject, tuple.relation, tuple.object, tuple.partition, plannedRelateOptions({ expiresAt: tuple.expiresAt ?? null }, tuple));
         return true;
     }
     catch (error) {
@@ -1169,4 +1414,13 @@ async function relateOrSkip(to, tuple) {
         throw error;
     }
 }
-//# sourceMappingURL=reconcile.js.map
+/** ¿Trae la cadena de `cause` una respuesta HTTP del backend (`statusCode` numérico, la forma del SDK de OpenFGA)? */
+function carriesHttpResponse(error) {
+    let current = error;
+    for (let depth = 0; current && depth < 6; depth++) {
+        if (typeof current.statusCode === 'number')
+            return true;
+        current = current.cause;
+    }
+    return false;
+}

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

@@ -22,4 +22,3 @@ export interface RelationTupleIdentity {
  */
 export declare function relationSubjectKey(subject: RelSubject): string;
 export declare function relationTupleKey(tuple: RelationTupleIdentity): string;
-//# sourceMappingURL=tuple_key.d.ts.map

package/build/src/relations/tuple_key.js

@@ -57,4 +57,3 @@ export function relationTupleKey(tuple) {
     assertRelationId('la relación', tuple.relation);
     return `${kind}|${scopeKey(tuple.partition)}|${tuple.object.type}:${tuple.object.id}#${tuple.relation}@${relationSubjectKey(tuple.subject)}`;
 }
-//# sourceMappingURL=tuple_key.js.map

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

@@ -42,8 +42,10 @@
  * reparto NO depende del orden de enumeración del origen ni del `Read`.
  *
  * **Lo que garantiza, exactamente** (demostrado por fuerza bruta; README «Denies migrate as denies»): **si el grafo de
- * precedencias no tiene un CICLO, ningún estado intermedio concede algo que no concedían el estado inicial o el final, y
- * ningún sujeto denegado en los dos concede en ninguno.** El RESIDUO es exactamente el ciclo (`residue`): dos membresías
+ * precedencias no tiene un CICLO, ningún PREFIJO (el estado del store tras cada `Write` de la secuencia) concede algo que
+ * no concedían el estado inicial o el final, y ningún sujeto denegado en los dos concede en ninguno.** Es una garantía
+ * sobre PREFIJOS —una operación CORTADA—, no sobre lectores: un `Check` que abarca dos `Write` consecutivos puede mezclar
+ * lecturas de uno y otro (lector rasgado, fila «torn read» de Limits; decisión (6a) del dueño, linaje L12). El RESIDUO es exactamente el ciclo (`residue`): dos membresías
  * que cambian en la misma pasada cuyas exigencias se contradicen —la forma típica: el mismo sujeto entra (o sale) a la
  * vez en dos grupos y cada uno trae un deny que corta un allow que trae el otro—. Ahí NO existe en general ningún orden
  * seguro (la fuerza bruta lo mide: de los casos del ciclo que conceden, una parte no admite NINGUNA permutación del diff
@@ -111,7 +113,7 @@ export declare function denyCarrierGroups(views: Iterable<RelationOrderView>): S
 export declare function carriedDenies(views: Iterable<RelationOrderView>, group: string): RelationOrderView[];
 /**
  * **El orden de una TRANSICIÓN** (cierre 2 de D2 · 🟡 N3): ver el docblock del módulo. `residue` = las membresías de los
- * ciclos del grafo de precedencias (sin garantía); vacío ⇒ ningún estado intermedio concede fuera de inicial ∪ final.
+ * ciclos del grafo de precedencias (sin garantía); vacío ⇒ ningún PREFIJO concede fuera de inicial ∪ final.
  */
 export declare function relationTransitionOrder<T>(transition: RelationTransition<T>, view: (item: T) => RelationOrderView, options?: {
     cuts?: RelationCuts;
@@ -123,4 +125,3 @@ export declare function relationTransitionOrder<T>(transition: RelationTransitio
 export declare function relationWriteOrder<T>(items: readonly T[], view: (item: T) => RelationOrderView, context?: readonly RelationOrderView[]): T[];
 /** **El orden de BORRADO** de un conjunto que solo SALE (las purgas de `openfga`): allows → membresías → denies. */
 export declare function relationDeleteOrder<T>(items: readonly T[], view: (item: T) => RelationOrderView, context?: readonly RelationOrderView[]): T[];
-//# sourceMappingURL=tuple_order.d.ts.map

package/build/src/relations/tuple_order.js

@@ -42,8 +42,10 @@
  * reparto NO depende del orden de enumeración del origen ni del `Read`.
  *
  * **Lo que garantiza, exactamente** (demostrado por fuerza bruta; README «Denies migrate as denies»): **si el grafo de
- * precedencias no tiene un CICLO, ningún estado intermedio concede algo que no concedían el estado inicial o el final, y
- * ningún sujeto denegado en los dos concede en ninguno.** El RESIDUO es exactamente el ciclo (`residue`): dos membresías
+ * precedencias no tiene un CICLO, ningún PREFIJO (el estado del store tras cada `Write` de la secuencia) concede algo que
+ * no concedían el estado inicial o el final, y ningún sujeto denegado en los dos concede en ninguno.** Es una garantía
+ * sobre PREFIJOS —una operación CORTADA—, no sobre lectores: un `Check` que abarca dos `Write` consecutivos puede mezclar
+ * lecturas de uno y otro (lector rasgado, fila «torn read» de Limits; decisión (6a) del dueño, linaje L12). El RESIDUO es exactamente el ciclo (`residue`): dos membresías
  * que cambian en la misma pasada cuyas exigencias se contradicen —la forma típica: el mismo sujeto entra (o sale) a la
  * vez en dos grupos y cada uno trae un deny que corta un allow que trae el otro—. Ahí NO existe en general ningún orden
  * seguro (la fuerza bruta lo mide: de los casos del ciclo que conceden, una parte no admite NINGUNA permutación del diff
@@ -240,7 +242,7 @@ function reach(graph, index, group) {
 }
 /**
  * **El orden de una TRANSICIÓN** (cierre 2 de D2 · 🟡 N3): ver el docblock del módulo. `residue` = las membresías de los
- * ciclos del grafo de precedencias (sin garantía); vacío ⇒ ningún estado intermedio concede fuera de inicial ∪ final.
+ * ciclos del grafo de precedencias (sin garantía); vacío ⇒ ningún PREFIJO concede fuera de inicial ∪ final.
  */
 export function relationTransitionOrder(transition, view, options = {}) {
     const writes = (transition.writes ?? []).map((item) => ({ item, view: view(item) }));
@@ -595,4 +597,3 @@ export function relationDeleteOrder(items, view, context = []) {
  * `refusal`), y el resto migra. Una partición negada queda exactamente como estaba, que es lo único que se puede
  * certificar sin una escritura atómica de la renovación (openfga/openfga#2151).
  */
-//# sourceMappingURL=tuple_order.js.map

package/build/src/relations_config_store.d.ts

@@ -1,8 +1,33 @@
 import type { RelationsConfig, RelationsConfigSpec } from './relations/define_relations_config.js';
+import type { DenyReachFinding } from './relations/deny_reach.js';
 export interface RelationsConfigStoreOptions {
     connection?: string;
     timeoutMs?: number;
 }
+/**
+ * Opciones de `saveRelationsConfig`: las del store más las DOS salidas con nombre de la guarda del alcance de los denies
+ * (8), separadas a propósito (A3 del auditor del panel: una salida que se usa como paso rutinario de adopción y no caduca es
+ * un interruptor de apagado).
+ */
+export interface SaveRelationsConfigOptions extends RelationsConfigStoreOptions {
+    /**
+     * **La adopción de la línea base** (firma (8 · línea base)): levanta SOLO el motivo `no-baseline`, y SOLO cuando no hay
+     * línea base utilizable (sin fila, o una fila que la lectura TODO O NADA no puede tipar); con una línea base utilizable es
+     * INERTE (no sirve para estrechar después). Sigue juzgando los huérfanos. Solo `true` la levanta; un valor que no es
+     * boolean es 500 `E_AUTHZ_CONFIG` (L5). Úsala UNA vez, con la spec que la flota sirve HOY, en una release que no cambie
+     * `relations.config` (adoptar en una release que estrecha certifica el estrechamiento: A4).
+     */
+    establishBaseline?: boolean;
+    /**
+     * **La salida forzada ACOTADA** (firma (8 · salida forzada)): la lista de `tipo#relación` cuyos hallazgos `shrunk`/`orphan`
+     * se guardan aunque encojan el alcance de sus denies vivos. Exime SOLO esos: un hallazgo no nombrado se niega igual (un
+     * encogimiento nuevo en otra relación no viaja en el mismo guardado forzado). No exime `no-baseline` (esa es
+     * `establishBaseline`). No hay `true` global: cualquier forma que no sea un array de `tipo#relación` es 500
+     * `E_AUTHZ_CONFIG` (L5). Y un nombre que en ESE guardado no exime ningún `shrunk`/`orphan` también es 500
+     * `E_AUTHZ_CONFIG` sin escribir (cierre 1 del sublote (8)): la lista se retira tras el guardado que la necesita.
+     */
+    allowDenyReachShrink?: readonly string[];
+}
 /**
  * **Guarda (persiste) la config de relaciones** bajo el gate de versión: la
  * valida (⚪4/F-05 de config), la serializa a JSON y hace UPSERT de la fila
@@ -10,7 +35,38 @@ export interface RelationsConfigStoreOptions {
  * última sentencia (invariante 14): un sync en otro proceso la ve en la
  * siguiente pregunta—. Devuelve la config congelada.
  */
-export declare function saveRelationsConfig(spec: RelationsConfigSpec, options?: RelationsConfigStoreOptions): Promise<RelationsConfig>;
+export declare function saveRelationsConfig(spec: RelationsConfigSpec, options?: SaveRelationsConfigOptions): Promise<RelationsConfig>;
+/** Lo que devuelve `checkRelationsConfigDenyReach`. */
+export interface RelationsConfigDenyReachCheck {
+    /** `'persisted'`: hay línea base utilizable; `'none'`: no la hay (sin fila, o una fila que no se puede tipar). */
+    baseline: 'persisted' | 'none';
+    /**
+     * Persistida → servida: `shrunk`, `orphan` (también sin línea base) y, con `baseline: 'none'` y denies vivos,
+     * `no-baseline` — lo mismo que juzgaría la guarda al guardar la config servida, sin salidas forzadas.
+     */
+    findings: DenyReachFinding[];
+    /** Servida → persistida: `stale` — la línea base es más estrecha que lo servido en grupos con denies vivos (A1/S-B). */
+    staleBaseline: DenyReachFinding[];
+    /** `true` sii no hay ningún hallazgo en ninguna dirección (`no-baseline` cuenta como hallazgo). */
+    ok: boolean;
+    /** Una línea por hallazgo, con el prefijo estable de su rama (`denyReachLine`). */
+    lines: string[];
+}
+/**
+ * **El detector de UN solo driver** (firma (8 · detector de un driver), R4 del analista del panel): en un despliegue
+ * solo-`database` el detector de `authz:relations:reconcile --dry-run` no corre (necesita DOS drivers de relaciones:
+ * origen = destino es 500). Esta función compara la config que SIRVE el proceso (`served`) con la línea base persistida
+ * sobre los denies vivos de `authz_relations`, en las DOS direcciones:
+ *  - persistida → servida: lo que la guarda negaría (`shrunk`, `orphan`, `no-baseline`);
+ *  - servida → persistida: la línea base RANCIA (`stale`), que la guarda no puede ver.
+ *
+ * Solo LEE (la fila y un `GROUP BY` de `authz_relations`, por `options.connection` o la primaria), sin transacción y sin el
+ * cerrojo del catálogo, con el MISMO punto de paso que la guarda (`baselineOf` + `liveDenyGroups` + `denyReachCheck`).
+ * **Receta**: en CI, DESPUÉS del paso que guarda la config y ANTES de servir, y en un cron; falla el job si `ok` es `false`.
+ * **Nunca** como fallo duro en `ready`: durante un despliegue un pod viejo que se reinicia sirve la config estrecha contra la
+ * fila nueva y entraría en un bucle de reinicios.
+ */
+export declare function checkRelationsConfigDenyReach(served: Pick<RelationsConfig, 'objectTypes'>, options?: RelationsConfigStoreOptions): Promise<RelationsConfigDenyReachCheck>;
 /** Lee el spec persistido (o `null` si no hay relaciones declaradas — opt-in). */
 export declare function readRelationsConfigSpec(options?: RelationsConfigStoreOptions): Promise<RelationsConfigSpec | null>;
 /**
@@ -19,4 +75,3 @@ export declare function readRelationsConfigSpec(options?: RelationsConfigStoreOp
  * relación de la base, así que el modelo que republique los lleva.
  */
 export declare function readRelationsConfig(options?: RelationsConfigStoreOptions): Promise<RelationsConfig | null>;
-//# sourceMappingURL=relations_config_store.d.ts.map