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

package/build/index.d.ts

@@ -3,7 +3,7 @@
  *   import { AuthorizationManager, APP_SCOPE } from '@jantstack/adonis-authz'
  */
 export { AuthorizationManager, DEFAULT_MAX_SCOPES, DEFAULT_MAX_DESCENDANTS, MAX_SCOPE_BOUND, DEFAULT_VIEW_MAX_AGE_MS, PARKED_CENSUS_MAX, RELAY_ORIGIN_MAX_HOPS, RELAY_LEASE_POLL_MS, expandExcludedSubtrees } from './src/manager.js';
-export type { AuthorizationView, ForRequestOptions } from './src/manager.js';
+export type { AuthorizationView, ForRequestOptions, MassPurgeReason } from './src/manager.js';
 export { defineConfig } from './src/define_config.js';
 export type { AuthorizationConfig } from './src/define_config.js';
 export { syncAuthzCatalog, diffAuthzCatalog, catalogInSync, formatCatalogDiff, formatScopedRoles, formatShadowedRoles, runCatalogDiff, syncCatalogs, } from './src/catalog/catalog.js';
@@ -50,7 +50,7 @@ export type { SqlScopeOutboxOptions } from './src/scope_outbox.js';
  * obligaría a importar ese SDK — acoplando el call-site al backend que este
  * paquete existe para abstraer.
  */
-export { AuthorizationBackendError, AuthorizationBackendTimeoutError, ScopeResolverError, InvalidIdentityError, InvalidSlugError, AuthorizationConfigError, AuthorizationInternalError, UnknownScopeError, NoScopeResolverError, UnknownRoleError, UnknownPermissionError, CatalogConflictError, RoleIsNotAccessError, ScopeCycleError, PurgeIncompleteError, WriteConflictError, RenewalUnsafeError, RenewalRacedError, ActorRequiredError, CheckManyBatchError, NotWithinError, WithinRequiredError, WithinRootForbiddenError, TooManyScopesError, TooManyLocalRolesError, MassPurgeRefusedError, PruneInterruptedError, UnsupportedDialectError, ScopeTooDeepError, ScopeDepthLimitError, ScopeRequeueRefusedError, UnsupportedOperationError, NoDescendantsResolverError, ViewExpiredError, RoleNotVisibleError, AmbiguousRoleError, RoleImmutableError, RoleLevelAboveOwnerError, RoleNotAssignableAtError, PermissionNotDelegableError, RankExceededError, ModelTooLargeError, RelationConfigError, RelationConfigUnknownKeyError, RelationTypeUnknownError, RelationUnknownError, RelationUsersetUnsupportedError, RelationNotDenyableError, RelationDenyExpiryError, MembersOfDenyLimitError, ScopeTreeDriftError, ScopeDriftUnguardedError, AuthorizationFrozenError, FreezeHeldError, MassReconcileRefusedError, DenyMigrationRefusedError, StaleSourceRefusedError, OperatorWindowExpiredError, ReconcileTooLargeError, markPartialWrite, isPartialWrite, } from './src/errors.js';
+export { AuthorizationBackendError, AuthorizationBackendTimeoutError, ResolutionLimitError, ScopeResolverError, InvalidIdentityError, InvalidSlugError, AuthorizationConfigError, AuthorizationInternalError, UnknownScopeError, NoScopeResolverError, UnknownRoleError, UnknownPermissionError, CatalogConflictError, RoleIsNotAccessError, ScopeCycleError, PurgeIncompleteError, WriteConflictError, RenewalUnsafeError, RenewalRacedError, ActorRequiredError, CheckManyBatchError, NotWithinError, WithinRequiredError, WithinRootForbiddenError, TooManyScopesError, TooManyLocalRolesError, MassPurgeRefusedError, PruneInterruptedError, UnsupportedDialectError, ScopeTooDeepError, ScopeDepthLimitError, GroupDepthLimitError, ScopeRequeueRefusedError, UnsupportedOperationError, NoDescendantsResolverError, ViewExpiredError, RoleNotVisibleError, AmbiguousRoleError, RoleImmutableError, RoleLevelAboveOwnerError, RoleNotAssignableAtError, PermissionNotDelegableError, RankExceededError, ModelTooLargeError, RelationConfigError, RelationConfigUnknownKeyError, RelationTypeUnknownError, RelationUnknownError, RelationUsersetUnsupportedError, RelationNotDenyableError, RelationDenyExpiryError, MembersOfDenyLimitError, InvalidRelationPageError, ScopeTreeDriftError, ScopeDriftUnguardedError, AuthorizationFrozenError, FreezeHeldError, MassReconcileRefusedError, DenyMigrationRefusedError, DenyReachRefusedError, StaleSourceRefusedError, OperatorWindowExpiredError, ReconcileTooLargeError, markPartialWrite, isPartialWrite, } from './src/errors.js';
 /**
  * Validación de identidad y de slugs (422). La aplica el manager en cada
  * llamada y los drivers por defensa en profundidad; se exporta para que un
@@ -72,9 +72,12 @@ export type { RelationsManagerOptions } from './src/relations/manager.js';
 export { relationTupleKey, relationSubjectKey } from './src/relations/tuple_key.js';
 export type { RelationTupleKind, RelationTupleIdentity } from './src/relations/tuple_key.js';
 export { RELATIONS_CHECK_MANY_MAX } from './src/relations/check_many.js';
-export type { RelationsReconcileReport, RelationsReconcileDetail, RelationsPartitionRefusal } from './src/relations/reconcile.js';
-export { saveRelationsConfig, readRelationsConfig, readRelationsConfigSpec, } from './src/relations_config_store.js';
-export type { RelationsConfigStoreOptions } from './src/relations_config_store.js';
+export { RELATIONS_ENUMERATE_DEFAULT_LIMIT, RELATIONS_ENUMERATE_MAX_LIMIT } from './src/relations/page.js';
+export { RELATIONS_GROUP_DEPTH_MEASURED, GROUP_DEPTH_CONFIG_MAX, GROUP_DEPTH_MAX_NODES, GROUP_DEPTH_MAX_READS, GROUP_DEPTH_MAX_TUPLES, GROUP_DEPTH_DEADLINE_MS, GROUP_DEPTH_CALIBRATION_BACKOFF_MS, GROUP_DEPTH_RECALIBRATION_MIN_INTERVAL_MS, } from './src/relations/group_depth.js';
+export type { RelationsReconcileReport, RelationsReconcileDetail, RelationsPartitionRefusal, RelationsPartitionRefusalReason } from './src/relations/reconcile.js';
+export { saveRelationsConfig, readRelationsConfig, readRelationsConfigSpec, checkRelationsConfigDenyReach, } from './src/relations_config_store.js';
+export type { RelationsConfigStoreOptions, SaveRelationsConfigOptions, RelationsConfigDenyReachCheck } from './src/relations_config_store.js';
+export type { DenyReachFinding, DenyReachReason } from './src/relations/deny_reach.js';
 export { DatabaseRelationsDriver, RELATIONS_MEMBERS_DENY_CHECK_MAX } from './src/drivers/database_relations_driver.js';
 export type { DatabaseRelationsDriverOptions } from './src/drivers/database_relations_driver.js';
 export { resolveGrantExpiry, isActiveExpiry, sameInstant } from './src/expiry.js';
@@ -86,7 +89,7 @@ export type { DatabaseDriverOptions } from './src/drivers/database_driver.js';
  * opcional `@openfga/sdk`. Un consumidor solo-database arranca sin él (D9).
  */
 export { APP_SCOPE, APP_SCOPE_TYPE, DEFAULT_RECONCILE_MAX_TUPLES } from './src/types.js';
-export type { AuthorizationDriver, AuthorizationDriverFactory, AuthorizedScopes, AuthzWriteEvent, AuthzCatalogWriteEvent, CatalogPermissionSpec, CatalogRole, CatalogRoleSpec, CatalogSpec, ScopedRoleChanges, ScopedRoleSpec, DenyOptions, DenyRef, ExcludedSubtree, GrantOptions, GrantOutcome, HolderTypeMap, ReconcileCounts, ReconcileFact, ReconcileFactPage, ReconcileFactsEnumerator, ReconcileOptions, ReconcileReport, ReconcileSkip, ReconcileSource, RoleQuery, ScopeChainResolver, ScopeDescendantsResolver, ScopeEdge, ScopeEdgePage, ScopeEdgesEnumerator, ScopedWriteOptions, ScopeRef, ScopeType, SubjectRef, WriteOptions, AuthorizationDriverCapabilities, RelationsDriver, RelationsDriverCapabilities, RelObject, RelSubject, RelUserset, RelationRef, RelationWriteEvent, RelationWriteOptions, RelationDenyOptions, RelationDecision, RelationTransactionOptions, RelationPurgeOptions, RelationPage, RelationObjectsPage, RelationSubjectsPage, RelationTuple, RelationTuplePage, ScopeOutbox, ScopeOutboxContext, ScopeOutboxLease, ScopeOutboxPendingFilter, ScopeOutboxFailure, ScopeRequeueConflict, ScopeRequeueReport, ScopeTreeChange, PendingScopeTreeChange, RelayedScopeChange, ScopeRelayReport, ScopeRelayFailure, ScopeRelayEntry, ScopeRelayEntryStatus, ScopeEnqueueReceipt, } from './src/types.js';
+export type { AuthorizationDriver, AuthorizationDriverFactory, AuthorizedScopes, AuthzWriteEvent, AuthzCatalogWriteEvent, CatalogPermissionSpec, CatalogRole, CatalogRoleSpec, CatalogSpec, ScopedRoleChanges, ScopedRoleSpec, DenyOptions, DenyRef, ExcludedSubtree, GrantOptions, GrantOutcome, HolderTypeMap, ReconcileCounts, ReconcileFact, ReconcileFactPage, ReconcileFactsEnumerator, ReconcileOptions, ReconcileReport, ReconcileSkip, ReconcileSource, RoleQuery, ScopeChainResolver, ScopeDescendantsResolver, ScopeEdge, ScopeEdgePage, ScopeEdgesEnumerator, ScopedWriteOptions, ScopeRef, ScopeType, SnapshotAnswer, SnapshotReads, SubjectRef, WriteOptions, AuthorizationDriverCapabilities, RelationsDriver, RelationsDriverCapabilities, RelObject, RelSubject, RelUserset, RelationRef, RelationWriteEvent, RelationWriteOptions, RelationDenyOptions, RelationDecision, RelationTransactionOptions, RelationPurgeOptions, RelationPage, RelationObjectsPage, RelationSubjectsPage, RelationTuple, RelationTuplePage, ScopeOutbox, ScopeOutboxContext, ScopeOutboxLease, ScopeOutboxPendingFilter, ScopeOutboxFailure, ScopeRequeueConflict, ScopeRequeueReport, ScopeTreeChange, PendingScopeTreeChange, RelayedScopeChange, ScopeRelayReport, ScopeRelayFailure, ScopeRelayEntry, ScopeRelayEntryStatus, ScopeEnqueueReceipt, } from './src/types.js';
 export { isRelUserset } from './src/types.js';
 /**
  * **¿De quién es esta transacción?** (L-1 · 🟠 9, regla del puerto `{trx}`):
@@ -106,4 +109,3 @@ export { default as AuthzAssignment } from './src/models/authz_assignment.js';
 export { default as AuthzDeny } from './src/models/authz_deny.js';
 export { withAuthzScopes } from './src/traits/authz_scopes.js';
 export { hasUuid } from './src/traits/has_uuid.js';
-//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -43,7 +43,7 @@ export { sqlScopeOutbox } from './src/scope_outbox.js';
  * obligaría a importar ese SDK — acoplando el call-site al backend que este
  * paquete existe para abstraer.
  */
-export { AuthorizationBackendError, AuthorizationBackendTimeoutError, ScopeResolverError, InvalidIdentityError, InvalidSlugError, AuthorizationConfigError, AuthorizationInternalError, UnknownScopeError, NoScopeResolverError, UnknownRoleError, UnknownPermissionError, CatalogConflictError, RoleIsNotAccessError, ScopeCycleError, PurgeIncompleteError, WriteConflictError, RenewalUnsafeError, RenewalRacedError, ActorRequiredError, CheckManyBatchError, NotWithinError, WithinRequiredError, WithinRootForbiddenError, TooManyScopesError, TooManyLocalRolesError, MassPurgeRefusedError, PruneInterruptedError, UnsupportedDialectError, ScopeTooDeepError, ScopeDepthLimitError, ScopeRequeueRefusedError, UnsupportedOperationError, NoDescendantsResolverError, ViewExpiredError, RoleNotVisibleError, AmbiguousRoleError, RoleImmutableError, RoleLevelAboveOwnerError, RoleNotAssignableAtError, PermissionNotDelegableError, RankExceededError, ModelTooLargeError, RelationConfigError, RelationConfigUnknownKeyError, RelationTypeUnknownError, RelationUnknownError, RelationUsersetUnsupportedError, RelationNotDenyableError, RelationDenyExpiryError, MembersOfDenyLimitError, ScopeTreeDriftError, ScopeDriftUnguardedError, AuthorizationFrozenError, FreezeHeldError, MassReconcileRefusedError, DenyMigrationRefusedError, StaleSourceRefusedError, OperatorWindowExpiredError, ReconcileTooLargeError, 
+export { AuthorizationBackendError, AuthorizationBackendTimeoutError, ResolutionLimitError, ScopeResolverError, InvalidIdentityError, InvalidSlugError, AuthorizationConfigError, AuthorizationInternalError, UnknownScopeError, NoScopeResolverError, UnknownRoleError, UnknownPermissionError, CatalogConflictError, RoleIsNotAccessError, ScopeCycleError, PurgeIncompleteError, WriteConflictError, RenewalUnsafeError, RenewalRacedError, ActorRequiredError, CheckManyBatchError, NotWithinError, WithinRequiredError, WithinRootForbiddenError, TooManyScopesError, TooManyLocalRolesError, MassPurgeRefusedError, PruneInterruptedError, UnsupportedDialectError, ScopeTooDeepError, ScopeDepthLimitError, GroupDepthLimitError, ScopeRequeueRefusedError, UnsupportedOperationError, NoDescendantsResolverError, ViewExpiredError, RoleNotVisibleError, AmbiguousRoleError, RoleImmutableError, RoleLevelAboveOwnerError, RoleNotAssignableAtError, PermissionNotDelegableError, RankExceededError, ModelTooLargeError, RelationConfigError, RelationConfigUnknownKeyError, RelationTypeUnknownError, RelationUnknownError, RelationUsersetUnsupportedError, RelationNotDenyableError, RelationDenyExpiryError, MembersOfDenyLimitError, InvalidRelationPageError, ScopeTreeDriftError, ScopeDriftUnguardedError, AuthorizationFrozenError, FreezeHeldError, MassReconcileRefusedError, DenyMigrationRefusedError, DenyReachRefusedError, StaleSourceRefusedError, OperatorWindowExpiredError, ReconcileTooLargeError, 
 // Cierre de alpha.3 (invariante 13 en purgas multi-request): un driver de
 // relaciones de terceros marca con `markPartialWrite` el fallo que llega
 // DESPUÉS de haber borrado parte; el manager notifica `indeterminate: true`.
@@ -66,10 +66,18 @@ export { RelationsManager } from './src/relations/manager.js';
 // Plan 2.5 · lote A: la clave PURA de una tupla (P3, con `kind` desde el primer día) y el tope de `checkMany` (P4).
 export { relationTupleKey, relationSubjectKey } from './src/relations/tuple_key.js';
 export { RELATIONS_CHECK_MANY_MAX } from './src/relations/check_many.js';
+// Lote «antes de RC» · 7.4: la página de `enumerate*` (default y techo; por encima se recorta con cursor).
+export { RELATIONS_ENUMERATE_DEFAULT_LIMIT, RELATIONS_ENUMERATE_MAX_LIMIT } from './src/relations/page.js';
+// Lote «antes de RC» · R1: las cotas de la anidación de grupos (la fila de «Limits»); la regla vive en los drivers.
+export { RELATIONS_GROUP_DEPTH_MEASURED, GROUP_DEPTH_CONFIG_MAX, GROUP_DEPTH_MAX_NODES, 
+// Cierre de R1 (🟠 1 del auditor): el presupuesto de la comprobación de una arista en openfga.
+GROUP_DEPTH_MAX_READS, GROUP_DEPTH_MAX_TUPLES, GROUP_DEPTH_DEADLINE_MS, 
+// Cierre-2 de R1 (D5): la espera tras una calibración fallida y la cota de la re-calibración tras un 503 de profundidad.
+GROUP_DEPTH_CALIBRATION_BACKOFF_MS, GROUP_DEPTH_RECALIBRATION_MIN_INTERVAL_MS, } from './src/relations/group_depth.js';
 // La config de relaciones PERSISTIDA (🟡3): API de PLATAFORMA (bajo el gate de
 // versión, invariante 14). La CONSUME `authz:relations:reconcile` (config del
 // destino, para la deriva del modelo fusionado en --dry-run).
-export { saveRelationsConfig, readRelationsConfig, readRelationsConfigSpec, } from './src/relations_config_store.js';
+export { saveRelationsConfig, readRelationsConfig, readRelationsConfigSpec, checkRelationsConfigDenyReach, } from './src/relations_config_store.js';
 // El driver `database` de relaciones (el consumidor lo cablea en
 // `relations.drivers` de config/authorization.ts). El driver `openfga` de
 // relaciones NO sale de aquí: vive en el subpath `/openfga` (peer opcional).
@@ -100,4 +108,3 @@ export { default as AuthzAssignment } from './src/models/authz_assignment.js';
 export { default as AuthzDeny } from './src/models/authz_deny.js';
 export { withAuthzScopes } from './src/traits/authz_scopes.js';
 export { hasUuid } from './src/traits/has_uuid.js';
-//# sourceMappingURL=index.js.map

package/build/providers/authz_provider.d.ts

@@ -43,4 +43,3 @@ export default class AuthzProvider {
     constructor(app: ApplicationService);
     register(): void;
 }
-//# sourceMappingURL=authz_provider.d.ts.map

package/build/providers/authz_provider.js

@@ -84,4 +84,3 @@ export default class AuthzProvider {
         });
     }
 }
-//# sourceMappingURL=authz_provider.js.map

package/build/services/main.d.ts

@@ -7,4 +7,3 @@ import type { AuthorizationManager } from '../src/manager.js';
  */
 declare let authorization: AuthorizationManager;
 export { authorization as default };
-//# sourceMappingURL=main.d.ts.map

package/build/services/main.js

@@ -10,4 +10,3 @@ await app.booted(async () => {
     authorization = await app.container.make('authz.manager');
 });
 export { authorization as default };
-//# sourceMappingURL=main.js.map

package/build/services/relations.d.ts

@@ -11,4 +11,3 @@ import type { RelationsManager } from '../src/relations/manager.js';
  */
 declare let relations: RelationsManager;
 export { relations as default };
-//# sourceMappingURL=relations.d.ts.map

package/build/services/relations.js

@@ -14,4 +14,3 @@ await app.booted(async () => {
     relations = await app.container.make('authz.relations');
 });
 export { relations as default };
-//# sourceMappingURL=relations.js.map

package/build/src/catalog/catalog.d.ts

@@ -286,4 +286,3 @@ export declare function runCatalogDiff(catalogs: CatalogSource[], options?: {
 export declare function syncCatalogs(catalogs: CatalogSource[], options?: SyncCatalogOptions): Promise<{
     count: number;
 } & CatalogSyncReport>;
-//# sourceMappingURL=catalog.d.ts.map

package/build/src/catalog/catalog.js

@@ -856,4 +856,3 @@ export async function syncCatalogs(catalogs, options = {}) {
     }
     return { count, shadowedByGlobal, assignableAtViolations };
 }
-//# sourceMappingURL=catalog.js.map

package/build/src/catalog/catalog_cache.d.ts

@@ -304,6 +304,19 @@ export declare class CatalogCache {
      * vuelve a intentarlo.
      */
     view(): Promise<CatalogView>;
+    /**
+     * **La foto para una ESCRITURA** (lote C · carreras, resolución 2 del juez = K4): contrasta la versión con la fila
+     * SIEMPRE, ignore o no la ventana `{ everyMs }`. Con `'always'` es exactamente `view()`. La ventana es para DECIDIR
+     * (invariante 14: una pregunta puede responder con un catálogo de hasta `everyMs` de antigüedad); una escritura del driver
+     * deja ESTADO en el store que no caduca —el barrido de `moved`, el settle, la proyección—, y con un memo rancio un rol
+     * recién definido en otro proceso no se barre (fail-open persistente medido, K4). Coste: el SELECT por PK de `'always'`.
+     *
+     * **Nunca se suma a una comprobación ni a una carga EN VUELO** (asentar · cierre 2, ⚪ 6 / O-6 del auditor): la que ya
+     * estaba en marcha pudo leer la fila ANTES de la escritura que precede a esta llamada (la propia, o la de otro proceso
+     * que la escritura acaba de observar) y serviría esa foto. Se espera la carga en vuelo y se lee la versión otra vez;
+     * una carga que arranca DESPUÉS de esta llamada sí se comparte (ya es posterior).
+     */
+    freshView(): Promise<CatalogView>;
     /**
      * Olvida la foto de ESTE memo. La siguiente pregunta recarga. Es un bump
      * de generación, no un `#view = null`: una carga en vuelo capturó la
@@ -321,4 +334,3 @@ export declare class CatalogCache {
  * disfrazado de dato.
  */
 export declare function parseAssignableAt(slug: string, raw: unknown): readonly ScopeType[] | null;
-//# sourceMappingURL=catalog_cache.d.ts.map

package/build/src/catalog/catalog_cache.js

@@ -240,7 +240,8 @@ export async function readLocalRoles(options = {}) {
         .select('uuid', 'slug', 'scope_type', 'rank', 'owner_scope_key'));
     if (rows.length > maxLocalRoles) {
         throw new TooManyLocalRolesError(`El catálogo tiene más de ${maxLocalRoles} roles locales (cota 'maxLocalRoles'). No se devuelve una lista ` +
-            `parcial: quien lee esto decide qué se BORRA. Sube la cota a sabiendas si tu catálogo local es así de grande.`);
+            `parcial: quien lee esto decide qué se BORRA. Sube la cota a sabiendas si tu catálogo local es así de grande: ` +
+            `pruneOrphanRoles({ maxLocalRoles }) o --max-local-roles en authz:catalog:prune-orphans.`);
     }
     if (rows.length === 0)
         return [];
@@ -420,6 +421,31 @@ export class CatalogCache {
         }
         return this.#reload();
     }
+    /**
+     * **La foto para una ESCRITURA** (lote C · carreras, resolución 2 del juez = K4): contrasta la versión con la fila
+     * SIEMPRE, ignore o no la ventana `{ everyMs }`. Con `'always'` es exactamente `view()`. La ventana es para DECIDIR
+     * (invariante 14: una pregunta puede responder con un catálogo de hasta `everyMs` de antigüedad); una escritura del driver
+     * deja ESTADO en el store que no caduca —el barrido de `moved`, el settle, la proyección—, y con un memo rancio un rol
+     * recién definido en otro proceso no se barre (fail-open persistente medido, K4). Coste: el SELECT por PK de `'always'`.
+     *
+     * **Nunca se suma a una comprobación ni a una carga EN VUELO** (asentar · cierre 2, ⚪ 6 / O-6 del auditor): la que ya
+     * estaba en marcha pudo leer la fila ANTES de la escritura que precede a esta llamada (la propia, o la de otro proceso
+     * que la escritura acaba de observar) y serviría esa foto. Se espera la carga en vuelo y se lee la versión otra vez;
+     * una carga que arranca DESPUÉS de esta llamada sí se comparte (ya es posterior).
+     */
+    async freshView() {
+        if (this.#loading)
+            await this.#loading.catch(() => undefined);
+        const current = this.#view;
+        if (!current || !this.#isFresh())
+            return this.#reload();
+        const dbVersion = await this.#readVersion();
+        if (this.#view === current && this.#isFresh() && dbVersion === current.version) {
+            this.#checkedAt = this.#now();
+            return current;
+        }
+        return this.#reload(dbVersion);
+    }
     /** Una carga compartida; `knownVersion` es la fila recién leída por una revalidación (se ahorra releerla). */
     #reload(knownVersion) {
         if (!this.#loading) {
@@ -663,4 +689,3 @@ function buildCatalogView(permissions, roles, links, loadedAt, version) {
         version,
     };
 }
-//# sourceMappingURL=catalog_cache.js.map

package/build/src/clock.d.ts

@@ -21,4 +21,3 @@ export type Clock = () => Date;
 export declare const systemClock: Clock;
 /** `now` tiene que ser una función; se valida al construir (500 `E_AUTHZ_CONFIG` es del llamante). */
 export declare function isClock(value: unknown): value is Clock;
-//# sourceMappingURL=clock.d.ts.map

package/build/src/clock.js

@@ -4,4 +4,3 @@ export const systemClock = () => new Date();
 export function isClock(value) {
     return typeof value === 'function';
 }
-//# sourceMappingURL=clock.js.map

package/build/src/define_config.d.ts

@@ -381,4 +381,3 @@ export declare function defineConfig<T extends AuthorizationConfig>(config: T):
  * barata (claves, no valores).
  */
 export declare function assertAuthorizationConfigShape(config: unknown): void;
-//# sourceMappingURL=define_config.d.ts.map

package/build/src/define_config.js

@@ -77,12 +77,36 @@ function assertConfigBlock(value, path) {
             `una clave conocida no es «nada»: se ignoraría en silencio (plan 2.5 · B2).`);
     }
 }
+/**
+ * **Lápidas: claves que NO existen aquí pero que la letra de una decisión firmada nombra así** (cierre-2 de R1 · D1 (a),
+ * decisión del dueño 2026-10-20: «`relations.maxGroupDepth` ⇒ 500 con mensaje que apunta a `defineRelationsConfig`»).
+ * La decisión (5) escribió `relations.maxGroupDepth`; el mando vive en `defineRelationsConfig` (la config que capturan
+ * las factories de los drivers, `manager.driver()` y `runRelationsReconcile`) y se lee como `relations.config.maxGroupDepth`.
+ * Sin alias (una clave hermana se validaría y no gobernaría tres de las cuatro rutas): la ruta literal es el MISMO 500
+ * de clave desconocida, con la receta del sitio bueno en vez de la lista de claves.
+ */
+const MISPLACED_CONFIG_KEYS = Object.freeze({
+    'relations.maxGroupDepth': "defineConfig: la clave 'relations.maxGroupDepth' no existe. El techo de anidación de grupos va en la config de " +
+        'RELACIONES: defineRelationsConfig({ objectTypes, maxGroupDepth, database: { enforceGroupDepth } }), y ese objeto en ' +
+        'relations.config. Es la config que capturan los drivers (las factories de relations.drivers), manager.driver() y ' +
+        'runRelationsReconcile (authz:relations:reconcile): una clave hermana de relations no llegaría a ninguno y el límite ' +
+        'no se aplicaría.',
+    'relations.enforceGroupDepth': "defineConfig: la clave 'relations.enforceGroupDepth' no existe. El opt-in del techo de anidación de grupos en " +
+        'database va en la config de RELACIONES: defineRelationsConfig({ objectTypes, maxGroupDepth, database: { ' +
+        'enforceGroupDepth: true } }), y ese objeto en relations.config (la que capturan los drivers).',
+});
 function assertKnownConfigKeys(value, known, path) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return;
     for (const key of Object.keys(value)) {
         if (known.includes(key))
             continue;
+        // Cierre-3 · R-6: `Object.hasOwn` — una clave `constructor`/`toString` (o un `__proto__` propio de un JSON) leía el
+        // prototipo de la tabla y el 500 llevaba de mensaje `function Object() { [native code] }`.
+        const dotted = path === '' ? key : `${path}.${key}`;
+        const tombstone = Object.hasOwn(MISPLACED_CONFIG_KEYS, dotted) ? MISPLACED_CONFIG_KEYS[dotted] : undefined;
+        if (tombstone !== undefined)
+            throw new AuthorizationConfigError(tombstone);
         const where = path === '' ? `'${key}' en la raíz` : `'${path}.${key}'`;
         throw new AuthorizationConfigError(`defineConfig: la clave ${where} no existe (claves válidas en ${path === '' ? 'la raíz' : path}: ${known.join(', ')}). ` +
             `Ninguna clave del config se descarta en silencio (plan 2.5 · B2): un typo ('requireWithing') sería una ` +
@@ -121,4 +145,3 @@ export function assertAuthorizationConfigShape(config) {
         assertKnownConfigKeys(c[block], AUTHORIZATION_CONFIG_KEYS[block], block);
     }
 }
-//# sourceMappingURL=define_config.js.map

package/build/src/drivers/database_driver.d.ts

@@ -1,5 +1,5 @@
 import db from '@adonisjs/lucid/services/db';
-import type { AuthorizationDriver, AuthorizationDriverCapabilities, CatalogRoleRef, DenyRef, GrantOptions, GrantOutcome, NormalizedRoleQuery, ReconcileOptions, ReconcileReport, ReconcileSource, RoleQuery, ScopeRef, ScopeType, SubjectRef, WriteOptions } from '../types.js';
+import type { AuthorizationDriver, AuthorizationDriverCapabilities, CatalogRoleRef, DenyRef, GrantOptions, GrantOutcome, NormalizedRoleQuery, ReconcileOptions, ReconcileReport, ReconcileSource, RoleQuery, ScopeRef, ScopeType, SnapshotAnswer, SnapshotReads, SubjectRef, WriteOptions } from '../types.js';
 import type { ScopeChainResolver } from '../types.js';
 import { CatalogCache } from '../catalog/catalog_cache.js';
 import type { CatalogRevalidate, CatalogRole, CatalogView } from '../catalog/catalog_cache.js';
@@ -168,7 +168,7 @@ export declare class DatabaseAuthorizationDriver implements AuthorizationDriver
     /**
      * Lo que este driver declara (3b-2e · E2). El árbol es del consumidor
      * (`resolveChain`), así que no hay hechos de jerarquía ni deriva que
-     * mitigar; `authorize` son varias consultas SQL; la membresía la resuelve
+     * mitigar; `authorize` es UNA consulta SQL de hechos (la foto, rotación 2 · cierre 3) más el catálogo y el árbol, no un `Check`; la membresía la resuelve
      * el propio SQL contra la cadena que le pasan; los `list*` no enumeran
      * herencia (invariante 7); y `purgeRole` está implementado en una
      * transacción.
@@ -204,6 +204,12 @@ export declare class DatabaseAuthorizationDriver implements AuthorizationDriver
      */
     readonly catalog: CatalogCache;
     constructor(options?: DatabaseDriverOptions);
+    /**
+     * **El catálogo de una ESCRITURA** (K4; asentar · cierre 2, D-1): con la versión contrastada en fresco SIEMPRE
+     * (`CatalogCache.freshView`), ignore o no la ventana `{ everyMs }`. Un `catalog` inyectado que no lo traiga cae en
+     * `view()` (el contrato del memo es suyo). Gemelo de `OpenFgaAuthorizationDriver.writeCatalog`.
+     */
+    private writeCatalog;
     /**
      * Vista de este driver con OTRO resolutor de la cadena y el mismo estado
      * (conexión, memo del catálogo, deadline). Es lo que usa
@@ -242,6 +248,33 @@ export declare class DatabaseAuthorizationDriver implements AuthorizationDriver
      */
     private sql;
     private first;
+    /**
+     * **La FOTO de una decisión: el punto de paso ÚNICO** (rotación 2 · cierre 3; 4.ª aparición del linaje L12 «lector
+     * rasgado», la primera en `database`). Propiedad universal: *toda DECISIÓN de `database` que combina concesión y deny
+     * se lee en UNA foto*. Hasta aquí `authorize` leía los denies y las asignaciones en DOS sentencias, y una escritura
+     * que caía entre las dos daba una respuesta que NINGÚN estado real daba (un `deny` y después un `grant` ⇒ `true` una
+     * vez; repro `.claude/reproducciones/database-authorize-rasgado.spec.ts`).
+     *
+     * La foto es **UNA sentencia**: las partes van unidas con `UNION ALL` y cada fila dice de qué parte es
+     * (`foto_kind`). Una sentencia ve UN estado en los tres motores y en cualquier aislamiento —PostgreSQL toma la foto
+     * por SENTENCIA en READ COMMITTED, InnoDB una vista de lectura por sentencia, SQLite una transacción de lectura
+     * implícita—, así que no hace falta abrir una transacción REPEATABLE READ como `withSourceSnapshot` del reconcile:
+     * eso costaría BEGIN/COMMIT por pregunta en el camino caliente y, con un pool de 1 (`:memory:`), retendría la única
+     * conexión mientras el catálogo o un `resolveChain` SQL del consumidor esperan otra. Elegido por eso: una ida y
+     * vuelta (antes dos), sin conexión retenida y sin nivel por motor.
+     *
+     * Lo que va DENTRO de la foto: los HECHOS (asignaciones —con el vínculo rol→permiso por `JOIN` cuando la parte lo
+     * filtra— y denies). Lo que va FUERA, antes o después: el catálogo (memo contrastado con la versión compartida,
+     * invariante 14) y la cadena del consumidor (`resolveChain`). «Cadena frente a hechos» (un `scopes.moved` entre el
+     * `resolveChain` y la foto) depende del resolutor del consumidor y está DECLARADO en README «Limits» (fila «Torn
+     * read»), no se arregla aquí.
+     *
+     * Columnas comunes de cada parte: `foto_kind`, `foto_scope_type`, `foto_scope_uuid`, `foto_role` y
+     * `foto_permission` (`null` en la parte que no la tiene). Solo SQL estándar del query builder (M6). Una sola parte
+     * es una sola `SELECT`, sin `UNION`. La guardia `database.decision.snapshot` cuenta las sentencias que tocan
+     * `authz_assignments`/`authz_denies` por decisión: con dos, rojo.
+     */
+    private readFoto;
     /**
      * Por dónde escribe `operation` (L-3): la transacción ABIERTA del llamante
      * si llegó en `options.transaction` —validada contra la conexión de este
@@ -310,16 +343,41 @@ export declare class DatabaseAuthorizationDriver implements AuthorizationDriver
         scope: ScopeRef;
         role: CatalogRoleRef;
     }>>;
+    /** La parte de la foto de `rolesInChain`: asignaciones vigentes del holder en los scopes de la cadena (`null` sin cadena). */
+    private rolesInChainPart;
+    /** De las filas de la foto a la respuesta de `rolesInChain` (catálogo DESPUÉS de la foto: es memo, no hechos). */
+    private rolesInChainFrom;
     listRoleScopes(subject: SubjectRef, scopeType: ScopeType): Promise<ScopeRef[]>;
     /** ¿El rol (por uuid) existe en el scope cuya cadena tiene esas claves? (3B · B2, `declaredRoleAt`) */
     private visibleAt;
     listScopes(subject: SubjectRef, permission: string): Promise<ScopeRef[]>;
+    /** La parte «asignaciones vigentes del holder cuyo rol concede el permiso», en todo scope (la de `listScopes`). */
+    private grantsOfPart;
+    /** La parte «denies del holder» (de UN permiso si se da; si no, todos), en todo scope. */
+    private deniesPart;
+    /**
+     * De la foto a la respuesta de `listScopes` (árbol y catálogo DESPUÉS de la foto). `denies` son los del permiso: por
+     * scope, el conjunto de roles que conceden; el scope se lista si el árbol lo conoce, alguno de esos roles existe ahí
+     * (3B · B2) y ningún deny de la cadena lo bloquea — exactamente lo que `authorize` diría.
+     */
+    private listScopesFrom;
     /**
      * Denies directos del holder (2.1, B5): del scope exacto o todos. Solo los
      * de permisos que el catálogo declara (memo); los de scopes que el árbol
      * no conoce no se listan (D8), como en `listRoleScopes`.
      */
     listDenies(subject: SubjectRef, scope?: ScopeRef): Promise<DenyRef[]>;
+    /** De las filas de denies a `DenyRef[]` (catálogo y, sin `scope` pedido, árbol DESPUÉS de la foto). */
+    private deniesFrom;
+    /**
+     * **Varias lecturas del puerto en UNA foto** (rotación 2 · cierre 3, L12; método OPCIONAL del puerto,
+     * `AuthorizationDriver.readSnapshot`, capacidad `snapshotDecisions`). Es lo que el manager usa para las decisiones
+     * que COMPONE con dos métodos del puerto —`effectivePermissions` y la policy de delegación (`rolesInChain` +
+     * `listDenies`), `authorizedScopes` (`listScopes` + `listDenies`)—: cada respuesta pedida es EXACTAMENTE la del método
+     * homónimo, y todas salen de la MISMA foto de los hechos (`readFoto`: una sentencia). Lo no pedido no viene.
+     * Árbol y catálogo se leen después de la foto, como en cada método suelto.
+     */
+    readSnapshot(subject: SubjectRef, reads: SnapshotReads): Promise<SnapshotAnswer>;
     /**
      * Borra asignaciones y denies del scope exacto, en una transacción. Si el
      * árbol aún lo conoce se purga su identidad canónica (K1); si ya no (el
@@ -393,4 +451,3 @@ export declare class DatabaseAuthorizationDriver implements AuthorizationDriver
      */
     private eachReconcileRow;
 }
-//# sourceMappingURL=database_driver.d.ts.map