@jantstack/adonis-authz 2.0.0-alpha.1 → 2.4.0-alpha.10

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

@@ -68,6 +68,13 @@ declare const AuthzRolePermission_base: {
     connection?: string | undefined;
     first: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => Promise<null | InstanceType<T>>;
     truncate: (cascade?: boolean) => Promise<void>;
+    transaction: import("@adonisjs/lucid/types/database").TransactionFn;
+    query: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model>>(this: Model, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model, Result>;
+    after: {
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>[], "fetch">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
+        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
+    };
     readonly booted: boolean;
     $columnsDefinitions: Map<string, import("@adonisjs/lucid/types/model").ModelColumnOptions>;
     $relationsDefinitions: Map<string, import("@adonisjs/lucid/types/relations").RelationshipsContract>;
@@ -109,11 +116,6 @@ declare const AuthzRolePermission_base: {
         <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<[import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>, import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model>], "paginate">): void;
         <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
     };
-    after: {
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "fetch", handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>[], "fetch">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel>(this: Model, event: "paginate", handler: import("@adonisjs/lucid/types/model").HooksHandler<import("@adonisjs/lucid/types/model").ModelPaginatorContract<InstanceType<Model>>, "paginate">): void;
-        <Model extends import("@adonisjs/lucid/types/model").LucidModel, Event extends import("@adonisjs/lucid/types/model").EventsList>(this: Model, event: Event, handler: import("@adonisjs/lucid/types/model").HooksHandler<InstanceType<Model>, Event>): void;
-    };
     create: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createQuietly: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>, options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>>;
     createMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, values: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
@@ -139,8 +141,6 @@ declare const AuthzRolePermission_base: {
     fetchOrNewUpMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
     fetchOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
     updateOrCreateMany: <T extends import("@adonisjs/lucid/types/model").LucidModel>(this: T, predicate: keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>> | (keyof import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>)[], payload: Partial<import("@adonisjs/lucid/types/model").ModelAttributes<InstanceType<T>>>[], options?: import("@adonisjs/lucid/types/model").ModelAssignOptions) => Promise<InstanceType<T>[]>;
-    query: <Model extends import("@adonisjs/lucid/types/model").LucidModel, Result = InstanceType<Model>>(this: Model, options?: import("@adonisjs/lucid/types/model").ModelAdapterOptions) => import("@adonisjs/lucid/types/model").ModelQueryBuilderContract<Model, Result>;
-    transaction: import("@adonisjs/lucid/types/database").TransactionFn;
 } & import("@adonisjs/lucid/types/model").LucidModel;
 /** Pivot rol ↔ permiso del motor de autorización propio. */
 export default class AuthzRolePermission extends AuthzRolePermission_base {

package/build/src/models/authz_role_permission.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authz_role_permission.d.ts","sourceRoot":"","sources":["../../../src/models/authz_role_permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oZAsBoxtB,gDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAjBr2tB,4DAA4D;AAC5D,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,wBAA2B;IAC1E,OAAc,KAAK,SAA2B;IAC9C,OAAc,UAAU,SAAS;IAGzB,IAAI,EAAE,MAAM,CAAA;IAGZ,QAAQ,EAAE,MAAM,CAAA;IAGhB,cAAc,EAAE,MAAM,CAAA;IAGtB,SAAS,EAAE,QAAQ,CAAA;CAC5B"}
+{"version":3,"file":"authz_role_permission.d.ts","sourceRoot":"","sources":["../../../src/models/authz_role_permission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oZAsBoxtB,gDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAjBr2tB,4DAA4D;AAC5D,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,wBAA2B;IAC1E,OAAc,KAAK,SAA2B;IAC9C,OAAc,UAAU,SAAS;IAGzB,IAAI,EAAE,MAAM,CAAA;IAGZ,QAAQ,EAAE,MAAM,CAAA;IAGhB,cAAc,EAAE,MAAM,CAAA;IAGtB,SAAS,EAAE,QAAQ,CAAA;CAC5B"}

package/build/src/openfga.d.ts

@@ -8,6 +8,22 @@
  * el driver: un consumidor solo-database arranca sin el SDK instalado, y
  * `scripts/check_purity.mjs` (regla 3) lo vigila en cada build.
  */
-export { OpenFgaAuthorizationDriver, openFgaAuthorizationModel, provisionOpenFgaStore, importAuthzFactsToOpenFga, assertHolderTypes, parseBindingId, correlateBatchResults, isDuplicateWrite, DEFAULT_TIMEOUT_MS, } from './drivers/openfga_driver.js';
-export type { HolderTypeMap, OpenFgaDriverOptions, ImportFactsOptions, ImportFactsResult, } from './drivers/openfga_driver.js';
+export { OpenFgaAuthorizationDriver, provisionOpenFgaStore, assertHolderTypes, parseBindingId, correlateBatchResults, isDuplicateWrite, DEFAULT_TIMEOUT_MS, } from './drivers/openfga_driver.js';
+export type { HolderTypeMap, OpenFgaDriverOptions } from './drivers/openfga_driver.js';
+/**
+ * El driver `openfga` del puerto `RelationsDriver` (Fase 4, lote 4-4): ReBAC
+ * sobre el MISMO store y `modelId` que el driver `facts` de roles. Vive detrás
+ * de esta puerta como el resto de lo que toca `@openfga/sdk`.
+ */
+export { OpenFgaRelationsDriver } from './drivers/openfga_relations_driver.js';
+export type { OpenFgaRelationsDriverOptions } from './drivers/openfga_relations_driver.js';
+/**
+ * El modelo (c2r) y la proyección del catálogo (3b-2a; desde 3b-2k · K2 es
+ * el ÚNICO modelo: `openFgaAuthorizationModel` —el del modo `resolver`— y
+ * `importAuthzFactsToOpenFga` se borraron con él). Sin `@openfga/sdk` —es
+ * JSON y cadenas—, pero se publica por esta misma puerta: es material de
+ * OpenFGA y solo lo usa quien lo elige.
+ */
+export { openFgaFactsModel, factsRelationsOf, factsRelationMap, factsCatalogTuples, factsTupleId, factsModelBytes, assertFactsModelPublishable, assertFgaObjectId, FACTS_MODEL_MAX_BYTES, FACTS_MODEL_WARN_RATIO, FGA_MAX_RELATION_NAME, FGA_MAX_OBJECT_ID, FACTS_MAX_RESOLVE_DEPTH, FGA_MAX_BATCH_CHECK, factsScopeObject, factsParentTuple, FACTS_SCOPE_TYPE, FACTS_PARENT_RELATION, factsRootTuples, FACTS_ROOTED_RELATION, factsRelationTypeDefinitions, assertRelationsConfigPublishable, RESERVED_FACTS_TYPES, FACTS_GROUP_TYPE, FACTS_GROUP_MEMBER_RELATION, } from './drivers/openfga_facts.js';
+export type { FactsRelations, FactsCatalogTuple, FactsTuple, FactsRelationsConfig, RelationObjectType, RelationObjectRelation, } from './drivers/openfga_facts.js';
 //# sourceMappingURL=openfga.d.ts.map

package/build/src/openfga.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openfga.d.ts","sourceRoot":"","sources":["../../src/openfga.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,qBAAqB,EACrB,yBAAyB,EACzB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,6BAA6B,CAAA;AACpC,YAAY,EACV,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,6BAA6B,CAAA"}
+{"version":3,"file":"openfga.d.ts","sourceRoot":"","sources":["../../src/openfga.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,EAC1B,qBAAqB,EACrB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,6BAA6B,CAAA;AACpC,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEtF;;;;GAIG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAA;AAC9E,YAAY,EAAE,6BAA6B,EAAE,MAAM,uCAAuC,CAAA;AAE1F;;;;;;GAMG;AACH,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,2BAA2B,EAC3B,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,qBAAqB,EACrB,4BAA4B,EAC5B,gCAAgC,EAChC,oBAAoB,EACpB,gBAAgB,EAChB,2BAA2B,GAC5B,MAAM,4BAA4B,CAAA;AACnC,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,4BAA4B,CAAA"}

package/build/src/openfga.js

@@ -8,5 +8,19 @@
  * el driver: un consumidor solo-database arranca sin el SDK instalado, y
  * `scripts/check_purity.mjs` (regla 3) lo vigila en cada build.
  */
-export { OpenFgaAuthorizationDriver, openFgaAuthorizationModel, provisionOpenFgaStore, importAuthzFactsToOpenFga, assertHolderTypes, parseBindingId, correlateBatchResults, isDuplicateWrite, DEFAULT_TIMEOUT_MS, } from './drivers/openfga_driver.js';
+export { OpenFgaAuthorizationDriver, provisionOpenFgaStore, assertHolderTypes, parseBindingId, correlateBatchResults, isDuplicateWrite, DEFAULT_TIMEOUT_MS, } from './drivers/openfga_driver.js';
+/**
+ * El driver `openfga` del puerto `RelationsDriver` (Fase 4, lote 4-4): ReBAC
+ * sobre el MISMO store y `modelId` que el driver `facts` de roles. Vive detrás
+ * de esta puerta como el resto de lo que toca `@openfga/sdk`.
+ */
+export { OpenFgaRelationsDriver } from './drivers/openfga_relations_driver.js';
+/**
+ * El modelo (c2r) y la proyección del catálogo (3b-2a; desde 3b-2k · K2 es
+ * el ÚNICO modelo: `openFgaAuthorizationModel` —el del modo `resolver`— y
+ * `importAuthzFactsToOpenFga` se borraron con él). Sin `@openfga/sdk` —es
+ * JSON y cadenas—, pero se publica por esta misma puerta: es material de
+ * OpenFGA y solo lo usa quien lo elige.
+ */
+export { openFgaFactsModel, factsRelationsOf, factsRelationMap, factsCatalogTuples, factsTupleId, factsModelBytes, assertFactsModelPublishable, assertFgaObjectId, FACTS_MODEL_MAX_BYTES, FACTS_MODEL_WARN_RATIO, FGA_MAX_RELATION_NAME, FGA_MAX_OBJECT_ID, FACTS_MAX_RESOLVE_DEPTH, FGA_MAX_BATCH_CHECK, factsScopeObject, factsParentTuple, FACTS_SCOPE_TYPE, FACTS_PARENT_RELATION, factsRootTuples, FACTS_ROOTED_RELATION, factsRelationTypeDefinitions, assertRelationsConfigPublishable, RESERVED_FACTS_TYPES, FACTS_GROUP_TYPE, FACTS_GROUP_MEMBER_RELATION, } from './drivers/openfga_facts.js';
 //# sourceMappingURL=openfga.js.map

package/build/src/openfga.js.map

@@ -1 +1 @@
-{"version":3,"file":"openfga.js","sourceRoot":"","sources":["../../src/openfga.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,qBAAqB,EACrB,yBAAyB,EACzB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,6BAA6B,CAAA"}
+{"version":3,"file":"openfga.js","sourceRoot":"","sources":["../../src/openfga.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,EAC1B,qBAAqB,EACrB,iBAAiB,EACjB,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,6BAA6B,CAAA;AAGpC;;;;GAIG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAA;AAG9E;;;;;;GAMG;AACH,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,2BAA2B,EAC3B,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,qBAAqB,EACrB,4BAA4B,EAC5B,gCAAgC,EAChC,oBAAoB,EACpB,gBAAgB,EAChB,2BAA2B,GAC5B,MAAM,4BAA4B,CAAA"}

package/build/src/reconcile.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Piezas COMPARTIDAS de `authz:reconcile` (3b-3b): lo que las dos
+ * direcciones —`--to=openfga` (3b-3a) y `--to=database`— tienen que decidir
+ * igual o el reporte deja de significar lo mismo según hacia dónde se migre.
+ *
+ * Vive aquí y no en un driver porque el driver `database` no puede importar
+ * del `openfga` (arrastraría el SDK, que es una peer dependency opcional) y
+ * porque duplicar la normalización de `batchSize`, la cota del volcado o la
+ * suma de fases es la forma más barata de que las dos direcciones cuenten
+ * distinto. Módulo puro: sin base de datos, sin red y sin `#aliases` del
+ * consumidor (`check:purity`).
+ */
+import type { ReconcileCounts } from './types.js';
+/** Filas por lote en el ORIGEN y operaciones por escritura en el destino. */
+export declare const RECONCILE_BATCH = 100;
+/**
+ * Cómo se NOMBRA el origen cuando los hechos son las tablas del paquete
+ * (3b-5). No es un driver: es el esquema PUBLICADO, y por eso tiene nombre
+ * propio en el reporte —«de dónde salieron los hechos» es la diferencia
+ * entre una migración y una pasada contra el driver activo—.
+ */
+export declare const AUTHZ_TABLES_ORIGIN = "authz_assignments/authz_denies";
+/** Tope de filas del reporte que se nombran una a una (el resto solo se cuenta). */
+export declare const RECONCILE_MAX_DETAILS = 200;
+/** Las cuatro fases de una pasada; en `--to=database` las tres primeras son cero. */
+export type ReconcileFamily = 'root' | 'catalog' | 'tree' | 'facts';
+export declare function reconcileBatchSize(value: number | undefined): number;
+/**
+ * La cota DECLARADA del volcado (3b-3b · B5). No es una promesa de memoria:
+ * es el número por encima del cual la pasada se niega con
+ * `E_AUTHZ_RECONCILE_TOO_LARGE` en vez de intentarlo y morir a medias.
+ */
+export declare function reconcileMaxTuples(value: number | undefined): number;
+export declare function emptyReconcileCounts(): ReconcileCounts;
+export declare function emptyReconcilePhases(): Record<ReconcileFamily, ReconcileCounts>;
+export declare function sumReconcilePhases(phases: Record<ReconcileFamily, ReconcileCounts>): ReconcileCounts;
+//# sourceMappingURL=reconcile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,6EAA6E;AAC7E,eAAO,MAAM,eAAe,MAAM,CAAA;AAElC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,mCAAmC,CAAA;AAEnE,oFAAoF;AACpF,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC,qFAAqF;AACrF,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAA;AAEnE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAMpE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAMpE;AAED,wBAAgB,oBAAoB,IAAI,eAAe,CAEtD;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAAC,eAAe,EAAE,eAAe,CAAC,CAO/E;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,EAAE,eAAe,CAAC,GAAG,eAAe,CAUpG"}

package/build/src/reconcile.js

@@ -0,0 +1,69 @@
+/**
+ * Piezas COMPARTIDAS de `authz:reconcile` (3b-3b): lo que las dos
+ * direcciones —`--to=openfga` (3b-3a) y `--to=database`— tienen que decidir
+ * igual o el reporte deja de significar lo mismo según hacia dónde se migre.
+ *
+ * Vive aquí y no en un driver porque el driver `database` no puede importar
+ * del `openfga` (arrastraría el SDK, que es una peer dependency opcional) y
+ * porque duplicar la normalización de `batchSize`, la cota del volcado o la
+ * suma de fases es la forma más barata de que las dos direcciones cuenten
+ * distinto. Módulo puro: sin base de datos, sin red y sin `#aliases` del
+ * consumidor (`check:purity`).
+ */
+import { AuthorizationConfigError } from './errors.js';
+import { DEFAULT_RECONCILE_MAX_TUPLES } from './types.js';
+/** Filas por lote en el ORIGEN y operaciones por escritura en el destino. */
+export const RECONCILE_BATCH = 100;
+/**
+ * Cómo se NOMBRA el origen cuando los hechos son las tablas del paquete
+ * (3b-5). No es un driver: es el esquema PUBLICADO, y por eso tiene nombre
+ * propio en el reporte —«de dónde salieron los hechos» es la diferencia
+ * entre una migración y una pasada contra el driver activo—.
+ */
+export const AUTHZ_TABLES_ORIGIN = 'authz_assignments/authz_denies';
+/** Tope de filas del reporte que se nombran una a una (el resto solo se cuenta). */
+export const RECONCILE_MAX_DETAILS = 200;
+export function reconcileBatchSize(value) {
+    if (value === undefined)
+        return RECONCILE_BATCH;
+    if (!Number.isInteger(value) || value < 1) {
+        throw new AuthorizationConfigError(`authz:reconcile: batchSize debe ser un entero >= 1 (llegó ${String(value)})`);
+    }
+    return value;
+}
+/**
+ * La cota DECLARADA del volcado (3b-3b · B5). No es una promesa de memoria:
+ * es el número por encima del cual la pasada se niega con
+ * `E_AUTHZ_RECONCILE_TOO_LARGE` en vez de intentarlo y morir a medias.
+ */
+export function reconcileMaxTuples(value) {
+    if (value === undefined)
+        return DEFAULT_RECONCILE_MAX_TUPLES;
+    if (!Number.isInteger(value) || value < 1) {
+        throw new AuthorizationConfigError(`authz:reconcile: maxTuples debe ser un entero >= 1 (llegó ${String(value)})`);
+    }
+    return value;
+}
+export function emptyReconcileCounts() {
+    return { written: 0, updated: 0, unchanged: 0, extra: 0, deleted: 0 };
+}
+export function emptyReconcilePhases() {
+    return {
+        root: emptyReconcileCounts(),
+        catalog: emptyReconcileCounts(),
+        tree: emptyReconcileCounts(),
+        facts: emptyReconcileCounts(),
+    };
+}
+export function sumReconcilePhases(phases) {
+    const total = emptyReconcileCounts();
+    for (const counts of Object.values(phases)) {
+        total.written += counts.written;
+        total.updated += counts.updated;
+        total.unchanged += counts.unchanged;
+        total.extra += counts.extra;
+        total.deleted += counts.deleted;
+    }
+    return total;
+}
+//# sourceMappingURL=reconcile.js.map

package/build/src/reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.js","sourceRoot":"","sources":["../../src/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EAAE,4BAA4B,EAAE,MAAM,YAAY,CAAA;AAGzD,6EAA6E;AAC7E,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,CAAA;AAElC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,gCAAgC,CAAA;AAEnE,oFAAoF;AACpF,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAA;AAKxC,MAAM,UAAU,kBAAkB,CAAC,KAAyB;IAC1D,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,eAAe,CAAA;IAC/C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,wBAAwB,CAAC,6DAA6D,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IACnH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAyB;IAC1D,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,4BAA4B,CAAA;IAC5D,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,wBAAwB,CAAC,6DAA6D,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IACnH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAA;AACvE,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO;QACL,IAAI,EAAE,oBAAoB,EAAE;QAC5B,OAAO,EAAE,oBAAoB,EAAE;QAC/B,IAAI,EAAE,oBAAoB,EAAE;QAC5B,KAAK,EAAE,oBAAoB,EAAE;KAC9B,CAAA;AACH,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,MAAgD;IACjF,MAAM,KAAK,GAAG,oBAAoB,EAAE,CAAA;IACpC,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QAC3C,KAAK,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,CAAA;QAC/B,KAAK,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,CAAA;QAC/B,KAAK,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,CAAA;QACnC,KAAK,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,CAAA;QAC3B,KAAK,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,CAAA;IACjC,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC"}

package/build/src/relation_partition_trigger.d.ts

@@ -0,0 +1,8 @@
+type TriggerDialect = 'sqlite' | 'postgres' | 'mysql';
+export declare function triggerDialectOf(dialect: string): TriggerDialect;
+/** Las sentencias a EJECUTAR (enteras) para crear el trigger de partición. */
+export declare function relationPartitionTrigger(dialect: string): string[];
+/** Las sentencias para soltar el trigger (y, en PG, su función) en el `down()`. */
+export declare function relationPartitionTriggerDrops(dialect: string): string[];
+export {};
+//# sourceMappingURL=relation_partition_trigger.d.ts.map

package/build/src/relation_partition_trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation_partition_trigger.d.ts","sourceRoot":"","sources":["../../src/relation_partition_trigger.ts"],"names":[],"mappings":"AAuCA,KAAK,cAAc,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAA;AAErD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAShE;AAED,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CA8BlE;AAED,mFAAmF;AACnF,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAYvE"}

package/build/src/relation_partition_trigger.js

@@ -0,0 +1,93 @@
+/**
+ * **La DDL del trigger de partición de `authz_relations` por dialecto** (Fase 4,
+ * lote 4-3) — módulo PURO, sin dependencia del servicio `db` de Lucid, para que
+ * lo pueda importar tanto el driver `database` de relaciones como el espejo del
+ * esquema de la suite (que se carga ANTES de bootear la app).
+ *
+ * El trigger es la defensa en profundidad contra un escritor «a mano» que meta
+ * en `authz_relations` una fila cuyo USERSET (sujeto con `subject_relation`)
+ * pertenece a OTRA partición que la de la fila. Cada sentencia se ejecuta
+ * ENTERA (su cuerpo `BEGIN…END` lleva `;` dentro): nunca por un runner que
+ * trocea por `;`.
+ *
+ * **L-4b**: «es userset» es `subject_relation <> ''`, no `IS NOT NULL`. Desde
+ * L-4b un holder lleva `''` (la columna es `NOT NULL DEFAULT ''` para que el
+ * UNIQUE lo defienda: NULL ≠ NULL en los tres motores); con `IS NOT NULL` el
+ * trigger dispararía en CADA holder (`subject_partition` NULL ≠ `partition_key`).
+ * Una fila vieja con NULL que nadie rellenó tampoco dispara: `NULL <> ''` es
+ * NULL —falso— en SQLite, PG y MySQL (tolerancia a NULL, coherente con el
+ * driver, que también lo lee como holder).
+ *
+ * La forma es RADICALMENTE distinta en cada motor (medido por el analista, y
+ * probado en INSERT **y** UPDATE):
+ *  - **SQLite**: `CREATE TRIGGER … BEFORE INSERT/UPDATE … WHEN … BEGIN SELECT
+ *    RAISE(ABORT, …); END` — un trigger por evento; `IS NOT` es el distinto
+ *    null-safe.
+ *  - **PostgreSQL**: exige una FUNCIÓN plpgsql SEPARADA (`RAISE EXCEPTION`) y
+ *    un `CREATE TRIGGER … EXECUTE FUNCTION` que la invoca; un solo trigger
+ *    `BEFORE INSERT OR UPDATE`. `IS DISTINCT FROM` es el distinto null-safe.
+ *  - **MySQL**: `SIGNAL SQLSTATE '45000'` dentro de `IF … THEN … END IF`; un
+ *    trigger por evento; `<=>` es el igual null-safe (`NOT (a <=> b)` = distinto).
+ *
+ * Cualquier otro dialecto ⇒ 500 `E_AUTHZ_UNSUPPORTED_DIALECT` (nunca una tabla
+ * sin defensa), exactamente como `sqlDescendantsOf`.
+ */
+import { UnsupportedDialectError } from './errors.js';
+const RELATIONS_TABLE = 'authz_relations';
+const TRIGGER_MESSAGE = 'authz_relations: un userset no puede pertenecer a otra partición que su tupla';
+export function triggerDialectOf(dialect) {
+    if (dialect === 'sqlite3' || dialect === 'better-sqlite3')
+        return 'sqlite';
+    if (dialect === 'postgres')
+        return 'postgres';
+    if (dialect === 'mysql' || dialect === 'mysql2')
+        return 'mysql';
+    throw new UnsupportedDialectError(`relationPartitionTrigger: dialecto '${dialect}' sin observación en la suite ` +
+        `(hoy: PostgreSQL, MySQL 8 y SQLite). El trigger de partición defiende al escritor a mano, ` +
+        `y su DDL no se declara igual en dos motores: mídelo antes de dar por buena una tabla sin defensa.`);
+}
+/** Las sentencias a EJECUTAR (enteras) para crear el trigger de partición. */
+export function relationPartitionTrigger(dialect) {
+    const kind = triggerDialectOf(dialect);
+    if (kind === 'sqlite') {
+        const body = (event) => `CREATE TRIGGER authz_relations_partition_b${event === 'INSERT' ? 'i' : 'u'} ` +
+            `BEFORE ${event} ON ${RELATIONS_TABLE} FOR EACH ROW ` +
+            `WHEN NEW.subject_relation <> '' AND NEW.subject_partition IS NOT NEW.partition_key ` +
+            `BEGIN SELECT RAISE(ABORT, '${TRIGGER_MESSAGE}'); END`;
+        return [body('INSERT'), body('UPDATE')];
+    }
+    if (kind === 'postgres') {
+        return [
+            `CREATE OR REPLACE FUNCTION authz_relations_partition_guard() RETURNS trigger LANGUAGE plpgsql AS $authz$ ` +
+                `BEGIN ` +
+                `IF NEW.subject_relation <> '' AND NEW.subject_partition IS DISTINCT FROM NEW.partition_key THEN ` +
+                `RAISE EXCEPTION '${TRIGGER_MESSAGE} (subject_partition=%, partition_key=%)', NEW.subject_partition, NEW.partition_key; ` +
+                `END IF; RETURN NEW; END; $authz$`,
+            `CREATE TRIGGER authz_relations_partition_biu BEFORE INSERT OR UPDATE ON ${RELATIONS_TABLE} ` +
+                `FOR EACH ROW EXECUTE FUNCTION authz_relations_partition_guard()`,
+        ];
+    }
+    // mysql
+    const body = (event) => `CREATE TRIGGER authz_relations_partition_b${event === 'INSERT' ? 'i' : 'u'} ` +
+        `BEFORE ${event} ON ${RELATIONS_TABLE} FOR EACH ROW ` +
+        `BEGIN ` +
+        `IF NEW.subject_relation <> '' AND NOT (NEW.subject_partition <=> NEW.partition_key) THEN ` +
+        `SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = '${TRIGGER_MESSAGE}'; ` +
+        `END IF; END`;
+    return [body('INSERT'), body('UPDATE')];
+}
+/** Las sentencias para soltar el trigger (y, en PG, su función) en el `down()`. */
+export function relationPartitionTriggerDrops(dialect) {
+    const kind = triggerDialectOf(dialect);
+    if (kind === 'postgres') {
+        return [
+            `DROP TRIGGER IF EXISTS authz_relations_partition_biu ON ${RELATIONS_TABLE}`,
+            'DROP FUNCTION IF EXISTS authz_relations_partition_guard()',
+        ];
+    }
+    return [
+        'DROP TRIGGER IF EXISTS authz_relations_partition_bi',
+        'DROP TRIGGER IF EXISTS authz_relations_partition_bu',
+    ];
+}
+//# sourceMappingURL=relation_partition_trigger.js.map

package/build/src/relation_partition_trigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation_partition_trigger.js","sourceRoot":"","sources":["../../src/relation_partition_trigger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAErD,MAAM,eAAe,GAAG,iBAAiB,CAAA;AACzC,MAAM,eAAe,GAAG,+EAA+E,CAAA;AAIvG,MAAM,UAAU,gBAAgB,CAAC,OAAe;IAC9C,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,gBAAgB;QAAE,OAAO,QAAQ,CAAA;IAC1E,IAAI,OAAO,KAAK,UAAU;QAAE,OAAO,UAAU,CAAA;IAC7C,IAAI,OAAO,KAAK,OAAO,IAAI,OAAO,KAAK,QAAQ;QAAE,OAAO,OAAO,CAAA;IAC/D,MAAM,IAAI,uBAAuB,CAC/B,uCAAuC,OAAO,gCAAgC;QAC5E,4FAA4F;QAC5F,mGAAmG,CACtG,CAAA;AACH,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,wBAAwB,CAAC,OAAe;IACtD,MAAM,IAAI,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACtC,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;QACtB,MAAM,IAAI,GAAG,CAAC,KAA0B,EAAE,EAAE,CAC1C,6CAA6C,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG;YAC9E,UAAU,KAAK,OAAO,eAAe,gBAAgB;YACrD,qFAAqF;YACrF,8BAA8B,eAAe,SAAS,CAAA;QACxD,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAA;IACzC,CAAC;IACD,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;QACxB,OAAO;YACL,2GAA2G;gBACzG,QAAQ;gBACR,kGAAkG;gBAClG,oBAAoB,eAAe,sFAAsF;gBACzH,kCAAkC;YACpC,2EAA2E,eAAe,GAAG;gBAC3F,iEAAiE;SACpE,CAAA;IACH,CAAC;IACD,QAAQ;IACR,MAAM,IAAI,GAAG,CAAC,KAA0B,EAAE,EAAE,CAC1C,6CAA6C,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG;QAC9E,UAAU,KAAK,OAAO,eAAe,gBAAgB;QACrD,QAAQ;QACR,2FAA2F;QAC3F,+CAA+C,eAAe,KAAK;QACnE,aAAa,CAAA;IACf,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAA;AACzC,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,6BAA6B,CAAC,OAAe;IAC3D,MAAM,IAAI,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACtC,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;QACxB,OAAO;YACL,2DAA2D,eAAe,EAAE;YAC5E,2DAA2D;SAC5D,CAAA;IACH,CAAC;IACD,OAAO;QACL,qDAAqD;QACrD,qDAAqD;KACtD,CAAA;AACH,CAAC"}

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

@@ -0,0 +1,109 @@
+import type { RelObject } from '../types.js';
+/** Una relación de un tipo de objeto (`document#viewer`), con sus `includes` de un nivel. */
+export interface RelationObjectRelationSpec {
+    /** El nombre de la relación (`owner`, `editor`, `viewer`). */
+    name: string;
+    /**
+     * Otras relaciones del MISMO tipo que ésta incluye (`viewer or editor`):
+     * un `relate(u, editor, doc)` concede también `viewer`. Un nivel, SIN
+     * `from` en v1 (la herencia cross-objeto metería un TTU entre tipos y
+     * habría que re-medir profundidad — diferido a 2.6+).
+     */
+    includes?: readonly string[];
+}
+/** Un tipo de objeto de relaciones (`document`, `folder`, `space`…). */
+export interface RelationObjectTypeSpec {
+    /** El tipo FGA del objeto. */
+    type: string;
+    /** Sus relaciones, en orden de declaración. */
+    relations: readonly RelationObjectRelationSpec[];
+}
+/** Opciones específicas del driver `database`. */
+export interface RelationsDatabaseOptions {
+    /**
+     * Habilita `membersOf` (membresía TRANSITIVA a través de usersets), que solo
+     * el driver `database` resuelve (CTE recursiva). En `openfga` la transitiva
+     * sería `ListUsers`, que trunca, así que la opción NO es válida fuera de
+     * `database`.
+     */
+    membersOf?: boolean;
+}
+/** La config que declara el consumidor. */
+export interface RelationsConfigSpec {
+    /** Los tipos de objeto y sus relaciones. */
+    objectTypes: readonly RelationObjectTypeSpec[];
+    /**
+     * Los holder types del config del consumidor (`user`, `admin`…). Se suman a
+     * los tipos reservados: un tipo de objeto de relaciones no puede llamarse
+     * como un holder (⚪4).
+     */
+    holderTypes?: readonly string[];
+    /** Opciones del driver `database` (donde vive `membersOf`). */
+    database?: RelationsDatabaseOptions;
+}
+/** La config ya validada y CONGELADA que consulta el manager de relaciones. */
+export interface RelationsConfig {
+    readonly objectTypes: readonly RelationObjectTypeSpec[];
+    /** ¿`membersOf` está habilitado (opción de `database`)? */
+    readonly membersOf: boolean;
+    /** ¿Existe el tipo de objeto? (F-05, cara del tipo). */
+    hasType(objectType: string): boolean;
+    /** ¿La relación está declarada para ese tipo? (F-05, cara de la relación). */
+    isDeclared(objectType: string, relation: string): boolean;
+}
+/**
+ * **F-05, la función ÚNICA** (L-0): rechaza un `object.type` no declarado
+ * (422 `E_AUTHZ_RELATION_TYPE_UNKNOWN`) o una `relation` no declarada para ese
+ * tipo (422 `E_AUTHZ_RELATION_UNKNOWN`). La aplican el `RelationsManager`
+ * (corta primero) Y los dos drivers de relaciones, ANTES de tocar el backend
+ * — la misma función, así que la misma clase, el mismo `code` y el mismo
+ * mensaje por cualquier puerta. Hacía falta en el driver (panel `{trx}`, 🔴 2
+ * del auditor): `manager.driver()` y `reconcileRelations` (que escribe con
+ * `to.relate`) entran por él, y sin la guarda
+ * `relate(evil, 'assignee', {type:'role_binding', id:<roleUuid>}, S)` componía
+ * en el store COMPARTIDO el id exacto de un binding de roles y
+ * `roles.authorize` pasaba de `false` a `true` (medido contra el `:8101`).
+ * La gramática de identidad no basta: `role_binding`/`assignee` son
+ * gramaticalmente válidos.
+ *
+ * **Cubre las OCHO operaciones del puerto** (`2.4.0-alpha.3`, cierre del
+ * 🔴 1 / 🟠 2 del auditor y cierre-2): hasta alpha.3 solo `relate`/`unrelate`
+ * la llamaban, y por `purgeObject({ type: 'role_binding', id: R }, S)` el
+ * puerto de relaciones BORRABA el binding real del store compartido
+ * (`authorize` pasaba de `true` a `false`, 0 tuplas, evento de auditoría
+ * limpio), y `listSubjects('assignee', role_binding)` enumeraba sus asignados
+ * sin catálogo ni `within`. **Son DOS funciones, no un opcional** (cierre-2,
+ * 🟠 1 del re-ataque): el primer cierre hizo `relation` opcional con un
+ * `if (relation === undefined) return` compartido por todas las llamadas, y
+ * eso APAGÓ F-05 en `relate`/`unrelate` sin relación (`request.input('relation')`
+ * ausente): antes `isDeclared('document', undefined)` era `false` ⇒ 422 con
+ * cero llamadas; con el opcional los dobles escribían la tupla, `openfga`
+ * devolvía 503 del servidor y `database` lo salvaba su driver (paridad rota),
+ * y `listSubjects(undefined)` devolvía la UNIÓN de relaciones del objeto.
+ * Esta función es ESTRICTA: la relación es obligatoria (ausente, `undefined`,
+ * vacía o no-string ⇒ 422 `E_AUTHZ_RELATION_UNKNOWN`) y la usan `relate`/
+ * `unrelate`/`check`/`listSubjects`/`membersOf` (+ `listObjects`, que también
+ * nombra una relación) y el userset de un sujeto (`{ object, relation }`).
+ * Quien NO nombra relación —`purgeObject`— usa `assertObjectTypeDeclared`.
+ */
+export declare function assertRelationDeclared(config: RelationsConfig, object: RelObject | {
+    type: string;
+}, relation: string): void;
+/**
+ * **F-05 sobre el TIPO solo** (cierre-2 de alpha.3): la mitad de F-05 que
+ * aplican las operaciones que NO nombran relación —`purgeObject`— y la primera
+ * comprobación de `assertRelationDeclared`. Un tipo no declarado (o un objeto
+ * que no es `{ type }`) ⇒ 422 `E_AUTHZ_RELATION_TYPE_UNKNOWN`. Separada de la
+ * estricta a propósito: deducir «solo el tipo» de un `relation === undefined`
+ * era lo que apagaba F-05 en `relate`/`unrelate` sin relación (🟠 1 del
+ * re-ataque del auditor).
+ */
+export declare function assertObjectTypeDeclared(config: RelationsConfig, object: RelObject | {
+    type: string;
+}): void;
+/**
+ * Valida y congela la config de relaciones. Config inválida ⇒ 422
+ * `E_AUTHZ_RELATION_CONFIG` (misma clase que el gate del modelo del lote 4-1).
+ */
+export declare function defineRelationsConfig(spec: RelationsConfigSpec): RelationsConfig;
+//# sourceMappingURL=define_relations_config.d.ts.map

package/build/src/relations/define_relations_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define_relations_config.d.ts","sourceRoot":"","sources":["../../../src/relations/define_relations_config.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAQ5C,6FAA6F;AAC7F,MAAM,WAAW,0BAA0B;IACzC,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAA;IACZ;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC7B;AAED,wEAAwE;AACxE,MAAM,WAAW,sBAAsB;IACrC,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,+CAA+C;IAC/C,SAAS,EAAE,SAAS,0BAA0B,EAAE,CAAA;CACjD;AAED,kDAAkD;AAClD,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,2CAA2C;AAC3C,MAAM,WAAW,mBAAmB;IAClC,4CAA4C;IAC5C,WAAW,EAAE,SAAS,sBAAsB,EAAE,CAAA;IAC9C;;;;OAIG;IACH,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC/B,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,wBAAwB,CAAA;CACpC;AAED,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,EAAE,SAAS,sBAAsB,EAAE,CAAA;IACvD,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,wDAAwD;IACxD,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;IACpC,8EAA8E;IAC9E,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;CAC1D;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACpC,QAAQ,EAAE,MAAM,GACf,IAAI,CAeN;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAc5G;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,GAAG,eAAe,CA0IhF"}