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

package/build/src/relations/manager.js

@@ -28,6 +28,7 @@ import { assertNotFrozenRow } from '../freeze.js';
 import { isRelUserset, normalizeRelationsCapabilities } from '../types.js';
 import { assertRelationDeclared, assertObjectTypeDeclared, assertUsersetSubject, assertRelationDenyable, assertDenySubject, assertDenyNoExpiry, } from './define_relations_config.js';
 import { assertCheckManyObjects } from './check_many.js';
+import { assertEnumeratePage, assertNoListPage } from './page.js';
 /**
  * ¿Cada POSICIÓN del array es un boolean? Por índice, nunca con `some`/`every`
  * (que saltan los huecos de un array disperso: 🟡 A3 del auditor del lote A).
@@ -327,7 +328,8 @@ export class RelationsManager {
             timeoutMs: this.#options.freezeTimeoutMs,
         });
     }
-    async relate(subject, relation, object, partition, options) {
+    async relate(subject, relation, object, partition, rawOptions) {
+        const options = knownWriteOptions(rawOptions);
         this.#assertTransactional(options, 'relate');
         await this.#assertNotFrozen('relate');
         this.#assertDeclared(object, relation);
@@ -346,7 +348,8 @@ export class RelationsManager {
         await this.#write(event, () => this.#driver.relate(subject, relation, object, partition, options));
         await this.#notify(event);
     }
-    async unrelate(subject, relation, object, partition, options) {
+    async unrelate(subject, relation, object, partition, rawOptions) {
+        const options = knownWriteOptions(rawOptions);
         this.#assertTransactional(options, 'unrelate');
         await this.#assertNotFrozen('unrelate');
         this.#assertDeclared(object, relation);
@@ -474,12 +477,13 @@ export class RelationsManager {
         await this.#notify(event);
     }
     /** Los sujetos con deny DIRECTO de `relation` sobre `object` (hechos: no resta ni deriva). Cualquier tipo declarado (D8). */
-    async listDenies(relation, object, partition, page) {
+    async listDenies(relation, object, partition) {
         this.#assertDeclared(object, relation);
         this.#assertDenies('listDenies');
         assertPartition(partition);
         this.#assertObjectId(object);
-        return this.#driver.listDenies(relation, object, partition, page);
+        assertNoListPage('listDenies', arguments[3], this.#driverLabel());
+        return this.#driver.listDenies(relation, object, partition);
     }
     /**
      * **La primitiva de CADENA** (lote D · D9, decisión del dueño 2026-10-14): una decisión por objeto, POR POSICIÓN —
@@ -509,6 +513,10 @@ export class RelationsManager {
         }
         return answers;
     }
+    /** El nombre del driver en los mensajes (la clave en `relations.drivers`, como en las puertas de `{ transaction }`). */
+    #driverLabel() {
+        return this.#options.driverName ?? 'relations';
+    }
     /**
      * **D-28 · la capacidad `relationDenies`** (regla D15: opcional, normalizada a `false`): sin ella, o sin el método
      * del puerto, las cuatro operaciones del deny son 500 `E_AUTHZ_UNSUPPORTED` nombrándose, con CERO llamadas al
@@ -520,17 +528,26 @@ export class RelationsManager {
         throw new UnsupportedOperationError(operation, 'el deny de relaciones', this.#options.driverName ?? 'relations', `El driver no declara relationDenies: true (o no trae '${operation}'): no sabe escribir ni honrar un deny. ` +
             `Los dos drivers del paquete (database, openfga) lo traen desde 2.5.0-alpha.3.`);
     }
-    async listObjects(subject, relation, objectType, partition, page) {
+    /**
+     * **Los cuatro listados no paginan en 2.5** (lote «antes de RC» · 7.4, opción 4 del juez): `page` salió de la firma
+     * de `listObjects`/`listSubjects`/`listDenies`/`membersOf` (nunca hizo nada) y un valor distinto de `undefined` que
+     * llegue por JS o `as any` es 500 `E_AUTHZ_UNSUPPORTED` con CERO llamadas al driver (`assertNoListPage`), DESPUÉS de
+     * F-05 y de la partición (RC74-5: primero la identidad de la pregunta). Sin página, la lista es completa o lleva
+     * `truncated`; nunca un cursor.
+     */
+    async listObjects(subject, relation, objectType, partition) {
         this.#assertDeclared({ type: objectType }, relation);
         assertPartition(partition);
         this.#assertSubject(subject, partition);
-        return this.#driver.listObjects(subject, relation, objectType, partition, page);
+        assertNoListPage('listObjects', arguments[4], this.#driverLabel());
+        return this.#driver.listObjects(subject, relation, objectType, partition);
     }
-    async listSubjects(relation, object, partition, page) {
+    async listSubjects(relation, object, partition) {
         this.#assertDeclared(object, relation);
         assertPartition(partition);
         this.#assertObjectId(object);
-        return this.#driver.listSubjects(relation, object, partition, page);
+        assertNoListPage('listSubjects', arguments[3], this.#driverLabel());
+        return this.#driver.listSubjects(relation, object, partition);
     }
     /**
      * **Las purgas notifican** (2.4.0-alpha.3 · E, hallazgo #4; D-1/D-3): UN
@@ -592,7 +609,7 @@ export class RelationsManager {
      * `E_AUTHZ_UNSUPPORTED` nombrándola (la transitiva sería `ListUsers`, que
      * trunca), jamás un `skip`.
      */
-    async membersOf(object, relation, partition, page) {
+    async membersOf(object, relation, partition) {
         // Cierre-2 · 🟡 3: `membersOf` toma `(object, relation)` —la forma exacta
         // que F-05 guarda— y era la octava operación fuera de «las siete»; un
         // driver de terceros con `membersOfNative: true` sobre un store compartido
@@ -605,7 +622,8 @@ export class RelationsManager {
             throw new UnsupportedOperationError('membersOf', 'la membresía transitiva de un grupo', 'relations', `Solo el driver 'database' la resuelve (CTE recursiva); en 'openfga' la transitiva sería ` +
                 `'ListUsers', que trunca. Usa 'listSubjects' para los hechos directos.`);
         }
-        return this.#driver.membersOf(object, relation, partition, page);
+        assertNoListPage('membersOf', arguments[3], this.#driverLabel());
+        return this.#driver.membersOf(object, relation, partition);
     }
     /** ORIGEN de `authz:reconcile` de relaciones. 500 `E_AUTHZ_UNSUPPORTED` si el driver no lo trae. */
     async enumerateRelations(partition, page) {
@@ -613,7 +631,10 @@ export class RelationsManager {
         if (!this.#driver.enumerateRelations || !this.#driver.capabilities?.enumerateRelations) {
             throw new UnsupportedOperationError('enumerateRelations', 'ser origen de authz:reconcile de relaciones', 'relations');
         }
-        return this.#driver.enumerateRelations(partition, page);
+        // 7.4 (injerto 4): la FORMA de la página (limit entero ≥ 1, after cadena no vacía) ⇒ 422 sin tocar el driver; qué
+        // cursor es legítimo lo decide el driver (el manager no sabe qué emite).
+        const checked = assertEnumeratePage('enumerateRelations', page, 'opaque', this.#driverLabel());
+        return this.#driver.enumerateRelations(partition, checked);
     }
     /**
      * **K particiones en UN barrido** (2.4.0-alpha.6) si el driver trae
@@ -646,9 +667,10 @@ export class RelationsManager {
         if (!this.#driver.enumerateRelations || !this.#driver.capabilities?.enumerateRelations) {
             throw new UnsupportedOperationError('enumerateRelationsMany', 'ser origen de authz:reconcile de relaciones', 'relations');
         }
+        const checked = assertEnumeratePage('enumerateRelationsMany', page, 'opaque', this.#driverLabel());
         if (typeof this.#driver.enumerateRelationsMany === 'function')
-            return this.#driver.enumerateRelationsMany(partitions, page);
-        if (page?.after !== undefined) {
+            return this.#driver.enumerateRelationsMany(partitions, checked);
+        if (checked?.after !== undefined) {
             throw new AuthorizationConfigError('enumerateRelationsMany: el driver de relaciones no implementa enumerateRelationsMany y el respaldo del manager (K llamadas ' +
                 'a enumerateRelations) no sabe reanudar con un cursor: `after` no se acepta aquí (reanudar aplicaría el cursor de UNA ' +
                 'partición a todas y perdería tuplas en silencio). Implementa enumerateRelationsMany en el driver, o pagina partición a ' +
@@ -656,7 +678,7 @@ export class RelationsManager {
         }
         const tuples = [];
         for (const partition of partitions) {
-            const one = await this.#driver.enumerateRelations(partition, page);
+            const one = await this.#driver.enumerateRelations(partition, checked);
             if (one.cursor !== undefined) {
                 throw new AuthorizationConfigError(`enumerateRelationsMany: la partición ${scopeKey(partition)} tiene más tuplas de las que caben en una página y el driver ` +
                     'de relaciones no implementa enumerateRelationsMany: el respaldo del manager (K llamadas a enumerateRelations) no ' +
@@ -681,4 +703,27 @@ export class RelationsManager {
         assertSubject(subject);
     }
 }
-//# sourceMappingURL=manager.js.map
+/**
+ * **Las opciones de `relate`/`unrelate` que cruzan al driver** (cierre de R1 · 🟡 2 del auditor + 🟠 C del tester): un
+ * objeto NUEVO con SOLO las claves conocidas (`transaction`, `actor`, `expiresAt`, con su presencia: «omitido» ≠
+ * `undefined` explícito no importa al driver, pero `'expiresAt' in options` sí al evento), leídas UNA vez — un `Proxy`
+ * de la app no llega al driver, ni sus símbolos, ni respuestas distintas entre la validación y la escritura. Lo que no
+ * es un objeto pasa tal cual (las validaciones de siempre lo juzgan).
+ */
+function knownWriteOptions(options) {
+    if (options === undefined || options === null || typeof options !== 'object')
+        return options;
+    const out = {};
+    for (const key of KNOWN_WRITE_OPTION_KEYS)
+        if (key in options)
+            out[key] = options[key];
+    return out;
+}
+/**
+ * **La lista de claves que cruzan, EXHAUSTIVA por tipo** (cierre-2 de R1 · D3 (b), injerto del analista y del auditor):
+ * el `satisfies` exige UNA entrada por cada clave de `RelationWriteOptions` (y ninguna más). Una clave nueva del tipo —una
+ * de seguridad, por ejemplo— que no se decida aquí NO COMPILA: hasta el cierre-2 se perdía en silencio en el manager
+ * (fallo abierto si la clave era una guarda). Decidir = `true` (cruza al driver) o sacarla del tipo.
+ */
+const KNOWN_WRITE_OPTIONS = { transaction: true, actor: true, expiresAt: true };
+export const KNOWN_WRITE_OPTION_KEYS = Object.freeze(Object.keys(KNOWN_WRITE_OPTIONS));

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

@@ -0,0 +1,19 @@
+import type { RelationPage } from '../types.js';
+/** Tamaño de página de `enumerate*` en `database` cuando no se pide `limit`. */
+export declare const RELATIONS_ENUMERATE_DEFAULT_LIMIT = 100;
+/** Techo de `limit` en `enumerate*` de `database`: por encima se RECORTA (con cursor, sin pérdida), no es un error. */
+export declare const RELATIONS_ENUMERATE_MAX_LIMIT = 1000;
+/** Regla 1: un `list*` de relaciones con página (cualquier valor distinto de `undefined`) ⇒ 500 sin tocar el backend. */
+export declare function assertNoListPage(operation: string, page: unknown, driver: string): void;
+/** Qué cursor emite quien valida: `uuid` (database), `none` (openfga, el doble), `opaque` (el manager). */
+export type EnumerateCursorKind = 'uuid' | 'none' | 'opaque';
+/**
+ * Regla 2: la forma de la página de `enumerate*`. `undefined` = sin página. Devuelve una COPIA de lo validado (cada campo
+ * se lee UNA vez: un getter que cambia entre la validación y el uso no cuela un `NaN` como `limit`, ⚪ 1 del auditor 7.x);
+ * quien consulta usa la copia, jamás la página original.
+ */
+export declare function assertEnumeratePage(operation: string, page: unknown, cursor: EnumerateCursorKind, driver: string): RelationPage | undefined;
+/** El `limit` efectivo de `enumerate*` (tras `assertEnumeratePage`): el default, o el pedido recortado al techo. */
+export declare function enumerateLimit(page: {
+    limit?: number;
+} | undefined): number;

package/build/src/relations/page.js

@@ -0,0 +1,74 @@
+/**
+ * **La página de relaciones, en UN sitio** (lote «antes de RC» · 7.4, opción 4 del juez —`loteRC-74-paginacion-juez.md`,
+ * 88,5/100—, decisión del dueño 2026-10-17 (7.4)). Dos reglas, compartidas por el manager, los dos drivers y el doble:
+ *
+ *  1. **Los `list*` no paginan en 2.5.** `listObjects`/`listSubjects`/`listDenies`/`membersOf` ya no tienen `page` en
+ *     la firma. `undefined` (ausente o explícito) es «sin página»; CUALQUIER otro valor —`null`, `{}`, `{ after: '' }`,
+ *     `{ limit: 0 }`…— que llegue por JS o `as any` ⇒ 500 `E_AUTHZ_UNSUPPORTED` nombrando la operación, con CERO
+ *     llamadas al backend (`assertNoListPage`). Se mira `!== undefined`, jamás `arguments.length` (RC74-3: quien reenvía
+ *     un opcional vacío no se rompe). Orden de las guardas (RC74-5): F-05 y partición ANTES; la página, la última.
+ *  2. **`enumerate*` valida su página** (`assertEnumeratePage`): `limit` entero ≥ 1 o 422 `E_AUTHZ_INVALID_PAGE`
+ *     (`NaN` generaba una consulta SIN `LIMIT`, tester H2), por encima de `RELATIONS_ENUMERATE_MAX_LIMIT` se RECORTA
+ *     (`enumerateLimit`: con cursor, sin pérdida; declarado en «Limits»); `after` cadena no vacía o 422, y según el
+ *     cursor que el driver emite: `uuid` (`database`: el uuid canónico de la fila; un cursor ajeno era un 503 en PG y
+ *     un fin silencioso en MySQL/SQLite, H3), `none` (`openfga` y el doble no emiten cursor ⇒ 500) u `opaque` (el
+ *     manager, que no sabe qué emite el driver: solo la forma).
+ *
+ * Lo que NO hace (H3 a medias, a propósito): atar el cursor a su partición —un cursor de A reutilizado en B salta
+ * filas— exige un sobre de cursor; es del lote C / 2.6.
+ */
+import { InvalidRelationPageError, UnsupportedOperationError } from '../errors.js';
+import { isCanonicalUuid } from '../identity.js';
+/** Tamaño de página de `enumerate*` en `database` cuando no se pide `limit`. */
+export const RELATIONS_ENUMERATE_DEFAULT_LIMIT = 100;
+/** Techo de `limit` en `enumerate*` de `database`: por encima se RECORTA (con cursor, sin pérdida), no es un error. */
+export const RELATIONS_ENUMERATE_MAX_LIMIT = 1_000;
+/** Regla 1: un `list*` de relaciones con página (cualquier valor distinto de `undefined`) ⇒ 500 sin tocar el backend. */
+export function assertNoListPage(operation, page, driver) {
+    if (page !== undefined)
+        throw UnsupportedOperationError.listPage(operation, driver);
+}
+/**
+ * Regla 2: la forma de la página de `enumerate*`. `undefined` = sin página. Devuelve una COPIA de lo validado (cada campo
+ * se lee UNA vez: un getter que cambia entre la validación y el uso no cuela un `NaN` como `limit`, ⚪ 1 del auditor 7.x);
+ * quien consulta usa la copia, jamás la página original.
+ */
+export function assertEnumeratePage(operation, page, cursor, driver) {
+    if (page === undefined)
+        return undefined;
+    if (page === null || typeof page !== 'object' || Array.isArray(page)) {
+        throw new InvalidRelationPageError(`${operation}: la página tiene que ser un objeto { limit?, after? } (llegó ${describe(page)}).`);
+    }
+    const { limit, after } = page;
+    if (limit !== undefined && !(typeof limit === 'number' && Number.isInteger(limit) && limit >= 1)) {
+        throw new InvalidRelationPageError(`${operation}: page.limit tiene que ser un entero ≥ 1 (llegó ${describe(limit)}); por encima de ` +
+            `${RELATIONS_ENUMERATE_MAX_LIMIT} se recorta, no es un error.`);
+    }
+    if (after === undefined)
+        return limit === undefined ? {} : { limit };
+    if (typeof after !== 'string' || after.length === 0) {
+        throw new InvalidRelationPageError(`${operation}: page.after tiene que ser el cursor que devolvió la página anterior (llegó ${describe(after)}).`);
+    }
+    if (cursor === 'none')
+        throw UnsupportedOperationError.enumerateCursor(operation, driver);
+    if (cursor === 'uuid' && !isCanonicalUuid(after)) {
+        throw new InvalidRelationPageError(`${operation}: page.after no es un cursor de este driver ('${driver}' emite el uuid canónico de la última fila leída); ` +
+            `pasa el cursor que devolvió la página anterior, sin tocarlo.`);
+    }
+    return limit === undefined ? { after } : { limit, after };
+}
+/** El `limit` efectivo de `enumerate*` (tras `assertEnumeratePage`): el default, o el pedido recortado al techo. */
+export function enumerateLimit(page) {
+    return Math.min(page?.limit ?? RELATIONS_ENUMERATE_DEFAULT_LIMIT, RELATIONS_ENUMERATE_MAX_LIMIT);
+}
+function describe(value) {
+    if (typeof value === 'string')
+        return `'${value.slice(0, 40)}'`;
+    if (typeof value === 'number')
+        return String(value);
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'un array';
+    return typeof value;
+}

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

@@ -1,5 +1,6 @@
 import type { Clock } from '../clock.js';
 import type { RelationsDriver, ScopeRef } from '../types.js';
+import type { DenyReachFinding } from './deny_reach.js';
 import type { RelationsConfig } from './define_relations_config.js';
 export interface RelationsReconcileOptions {
     /** El driver del que se LEEN las tuplas (origen). Necesita `enumerateRelations`. */
@@ -50,6 +51,16 @@ export interface RelationsReconcileOptions {
      * sigue — nunca un throw a mitad de pasada.
      */
     toConfig?: RelationsConfig;
+    /**
+     * **El detector del alcance de los denies (8)**: con él, la pasada lista en `report.denyReach` los denies vivos de sus
+     * particiones (origen y destino) cuyo alcance encoge de `baseline` (la config persistida; `null` = sin línea base, solo
+     * huérfanos) a `current` (la config que sirve el proceso). Solo LEE lo que la pasada ya enumeró: cero lecturas y cero
+     * escrituras de más. Lo pide `authz:relations:reconcile --dry-run`.
+     */
+    denyReach?: {
+        baseline: RelationsConfig | null;
+        current: RelationsConfig;
+    };
     /**
      * El reloj que decide qué tupla del ORIGEN está CADUCADA (R-15): una caducada
      * no se migra —se cuenta en `skipped.expired`— y no respalda nada en el
@@ -80,7 +91,7 @@ export interface RelationsReconcileOptions {
  * cierre 5 de D2 (opción A) NIEGA SU PARTICIÓN (`partitionsRefused`: cero escrituras y cero borrados en ella, el resto
  * migra); la línea la nombra con su receta y es deriva. `withheld-by-unsafe-deny` (cierre 4) se fue con la retención.
  */
-export declare const RELATIONS_RECONCILE_DETAIL_REASONS: readonly ["invalid-identity", "userset-unsupported", "undeclared", "deny-conditional", "renewal-unsafe"];
+export declare const RELATIONS_RECONCILE_DETAIL_REASONS: readonly ["invalid-identity", "userset-unsupported", "undeclared", "deny-conditional", "renewal-unsafe", "invalid-condition"];
 export type RelationsReconcileDetailReason = (typeof RELATIONS_RECONCILE_DETAIL_REASONS)[number];
 export interface RelationsReconcileDetail {
     /** De qué store llegó enumerada. */
@@ -315,13 +326,57 @@ export interface RelationsReconcileReport {
      * la pasada real dan los mismos números. Es deriva (exit ≠ 0) mientras exista. Opcional en el tipo; ausente = `[]`.
      */
     partitionsRefused?: RelationsPartitionRefusal[];
+    /**
+     * **Las particiones cuya cadena de grupos FINAL excede el techo del destino** (lote «antes de RC» · R1, decisión del
+     * dueño 2026-10-17 (5); 🔴 C-1 del auditor): por cada una, la profundidad (saltos `group⊂group` del camino más largo,
+     * con los ciclos contados de forma conservadora), el techo (`to.groupDepthLimit()`, el CALIBRADO del destino) y la
+     * cadena. Esa partición está además en `partitionsRefused` (causa `too-deep`): cero escrituras en ella — saltar la
+     * arista que excede quitaría los denies que transporta y fabricaría una concesión —. Lo decide el PLAN: mismos números
+     * en `--dry-run` y en la real. Opcional en el tipo; ausente = `[]`.
+     */
+    tooDeep?: Array<{
+        partition: string;
+        depth: number;
+        limit: number;
+        chain: string[];
+    }>;
+    /**
+     * **El detector de (8)** (lote RC · sublote (8)): solo si se pidió (`denyReach` en las opciones; el comando lo pide en
+     * `--dry-run`). Los denies VIVOS de las particiones de la pasada —en el ORIGEN y en el DESTINO, enumerados por la misma
+     * pasada— juzgados con `denyReachCheck` (`src/relations/deny_reach.ts`, el mismo punto de paso que la guarda de
+     * `database` y que `checkRelationsConfigDenyReach`), en las dos direcciones entre la línea base (`baseline`: la config
+     * persistida) y la config que SIRVE el proceso (`current`). Sirve a los dos drivers; `findings` y `stale` son deriva
+     * (exit ≠ 0); `unjudged` (sin línea base) NO lo es (firma (8 · `--dry-run`): exit 0 con su línea, el runbook no cambia).
+     */
+    denyReach?: {
+        /** `'persisted'`: se comparó contra la config persistida; `'none'`: sin línea base, solo se buscan huérfanos. */
+        baseline: 'persisted' | 'none';
+        /** Persistida → servida: `shrunk` y `orphan` (también sin línea base). `count` = claves de tupla DISTINTAS (firma (8 · `count`)). */
+        findings: Array<DenyReachFinding & {
+            sides: Array<'origen' | 'destino'>;
+        }>;
+        /** Servida → persistida: la línea base RANCIA (`stale`, solo con línea base; firma (8 · rancia)). */
+        stale: Array<DenyReachFinding & {
+            sides: Array<'origen' | 'destino'>;
+        }>;
+        /** Sin línea base: cuántos denies vivos (claves distintas, no huérfanos) quedan SIN juzgar. `0` con línea base. */
+        unjudged: number;
+    };
 }
+/**
+ * Por qué se NIEGA una partición: `renewal-unsafe` (membresía portadora que cambia de caducidad), `deny-conditional` (deny
+ * con caducidad que el destino no puede rehacer) o, desde el cierre de L11 (🟡 A2 del auditor), `invalid-condition`: una
+ * tupla de `group` (una membresía, portadora posible) con una condición que el paquete no escribe ni sabe leer
+ * (`foreign`/`unparseable`) en una partición con ALGÚN deny — el servidor puede estar evaluándola VIVA (un `not_expired`
+ * con `current_time` congelado lo está, medido) y transportando ese deny; saltarla como allow fabricaba una concesión.
+ */
+export type RelationsPartitionRefusalReason = 'renewal-unsafe' | 'deny-conditional' | 'invalid-condition' | 'too-deep';
 /** Una partición NEGADA (cierre 5 de D2): por qué, qué receta, y lo que la pasada habría hecho en ella y NO hizo. */
 export interface RelationsPartitionRefusal {
     partition: string;
     /** Las causas, una por tupla: `renewal-unsafe` (membresía portadora) o `deny-conditional` (deny con caducidad). */
     causes: Array<{
-        reason: 'renewal-unsafe' | 'deny-conditional';
+        reason: RelationsPartitionRefusalReason;
         tuple: string;
     }>;
     /** La deriva que queda a la vista: lo que la pasada escribiría, renovaría y (con `--prune`) borraría en ella. */
@@ -397,7 +452,7 @@ export declare function denyRefusalRecipe(reason: DenyRefusal['reason'], objectT
  * openfga/openfga#2151—) NO existe forma sin ventana de cambiar la caducidad de una membresía que transporta un deny, ni
  * de rehacer permanente un deny con caducidad. Ninguna de las salidas de abajo se presenta como segura.
  */
-export declare function partitionRefusalRecipe(reasons: Iterable<'renewal-unsafe' | 'deny-conditional'>): string;
+export declare function partitionRefusalRecipe(reasons: Iterable<RelationsPartitionRefusalReason>): string;
 /**
  * Migra las tuplas de relación de `from` a `to` en `partition`. Idempotente
  * (una segunda pasada no escribe nada) y bidireccional (funciona en cualquier
@@ -469,4 +524,3 @@ export declare const RELATION_RESIDUES: Readonly<Record<RelationsReconcileDetail
     how: string;
     why: string;
 }>>;
-//# sourceMappingURL=reconcile.d.ts.map