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

package/build/commands/authz_catalog_prune_orphans.d.ts

@@ -34,6 +34,11 @@ export declare function orphanLines(orphans: OrphanRow[], purged: Set<string>, s
     level: 'log' | 'warning';
     message: string;
 }>;
+/**
+ * La letra de los disparadores del seguro de purga masiva (3b-0b · AA2 + rotación 2 · R2-02), en el orden en que
+ * el manager los reporta. Pura, para que el caso la fije.
+ */
+export declare function massPurgeLetter(reasons: ReadonlyArray<string>): string;
 /**
  * Lista —y con `--force` borra— los roles LOCALES cuyo owner el árbol del
  * consumidor YA NO conoce (3b-0 · Z2).
@@ -56,6 +61,7 @@ export declare function orphanLines(orphans: OrphanRow[], purged: Set<string>, s
  *   node ace authz:catalog:prune-orphans                      # --dry-run: solo lista
  *   node ace authz:catalog:prune-orphans --force              # purga de verdad
  *   node ace authz:catalog:prune-orphans --force --allow-mass-purge
+ *   node ace authz:catalog:prune-orphans --max-local-roles=50000   # catálogo local de más de 10 000 roles
  *
  * Es una operación de PLATAFORMA, no una escritura que dispare un tenant: no
  * lleva actor ni mide rangos. Hasta 3G esta limpieza la arrastraba
@@ -63,8 +69,10 @@ export declare function orphanLines(orphans: OrphanRow[], purged: Set<string>, s
  * resuelve—, y de ahí salieron tres de las cuatro regresiones de la Fase 3.
  *
  * `--allow-mass-purge` (3b-0b · AA2) desbloquea la cota que rechaza una
- * pasada con la firma de un resolutor ciego (todos los owners huérfanos, o
- * más del 50 % de los roles locales): es una decisión humana, no un default.
+ * pasada con la firma de un resolutor ciego (todos los owners huérfanos,
+ * más del 50 % de los roles locales, o —rotación 2 · R2-02— huérfanos de más
+ * de un owner con alguno que todavía concede): es una decisión humana, no un
+ * default. `--max-local-roles` (R2-04) sube la cota de la lectura.
  */
 export default class AuthzCatalogPruneOrphans extends BaseCommand {
     static commandName: string;
@@ -72,6 +80,13 @@ export default class AuthzCatalogPruneOrphans extends BaseCommand {
     static options: CommandOptions;
     force: boolean | undefined;
     allowMassPurge: boolean | undefined;
+    /**
+     * Rotación 2 · R2-04: la cota de la lectura del catálogo local (default 10 000). Hasta este cierre el mensaje
+     * de `E_AUTHZ_TOO_MANY_LOCAL_ROLES` pedía «subir la cota» y no había mando: un tenant que pasara de 10 000 roles
+     * locales dejaba este comando muerto para todos. Un valor que no es un entero ≥ 1 lo rechaza el manager (500
+     * `E_AUTHZ_CONFIG`) antes de leer nada.
+     */
+    maxLocalRoles: number | undefined;
     run(): Promise<void>;
 }
 export {};

package/build/commands/authz_catalog_prune_orphans.js

@@ -54,6 +54,18 @@ export function orphanLines(orphans, purged, skipped) {
     }
     return lines;
 }
+/**
+ * La letra de los disparadores del seguro de purga masiva (3b-0b · AA2 + rotación 2 · R2-02), en el orden en que
+ * el manager los reporta. Pura, para que el caso la fije.
+ */
+export function massPurgeLetter(reasons) {
+    const words = {
+        'all-owners': 'todos los owners salen huérfanos',
+        'proportion': 'más del 50 % de los roles locales',
+        'granting-across-owners': 'huérfanos de más de un owner y alguno TODAVÍA concede o no se sabe',
+    };
+    return reasons.map((reason) => words[reason] ?? reason).join('; ') || 'sin motivo reportado';
+}
 /**
  * Lista —y con `--force` borra— los roles LOCALES cuyo owner el árbol del
  * consumidor YA NO conoce (3b-0 · Z2).
@@ -76,6 +88,7 @@ export function orphanLines(orphans, purged, skipped) {
  *   node ace authz:catalog:prune-orphans                      # --dry-run: solo lista
  *   node ace authz:catalog:prune-orphans --force              # purga de verdad
  *   node ace authz:catalog:prune-orphans --force --allow-mass-purge
+ *   node ace authz:catalog:prune-orphans --max-local-roles=50000   # catálogo local de más de 10 000 roles
  *
  * Es una operación de PLATAFORMA, no una escritura que dispare un tenant: no
  * lleva actor ni mide rangos. Hasta 3G esta limpieza la arrastraba
@@ -83,8 +96,10 @@ export function orphanLines(orphans, purged, skipped) {
  * resuelve—, y de ahí salieron tres de las cuatro regresiones de la Fase 3.
  *
  * `--allow-mass-purge` (3b-0b · AA2) desbloquea la cota que rechaza una
- * pasada con la firma de un resolutor ciego (todos los owners huérfanos, o
- * más del 50 % de los roles locales): es una decisión humana, no un default.
+ * pasada con la firma de un resolutor ciego (todos los owners huérfanos,
+ * más del 50 % de los roles locales, o —rotación 2 · R2-02— huérfanos de más
+ * de un owner con alguno que todavía concede): es una decisión humana, no un
+ * default. `--max-local-roles` (R2-04) sube la cota de la lectura.
  */
 export default class AuthzCatalogPruneOrphans extends BaseCommand {
     static commandName = 'authz:catalog:prune-orphans';
@@ -94,9 +109,10 @@ export default class AuthzCatalogPruneOrphans extends BaseCommand {
     };
     async run() {
         const { default: authorization } = await import('../services/main.js');
-        const { orphans, purged, skipped, massPurge, dryRun } = await authorization.pruneOrphanRoles({
+        const { orphans, purged, skipped, massPurge, massPurgeReasons, dryRun } = await authorization.pruneOrphanRoles({
             force: this.force === true,
             allowMassPurge: this.allowMassPurge === true,
+            ...(this.maxLocalRoles !== undefined ? { maxLocalRoles: this.maxLocalRoles } : {}),
         });
         // Los que todavía conceden —y los que NADIE puede demostrar que no
         // concedan— van aparte, con aviso: purgarlos es revocar permisos vivos,
@@ -110,7 +126,8 @@ export default class AuthzCatalogPruneOrphans extends BaseCommand {
         }
         if (dryRun) {
             if (massPurge) {
-                this.logger.warning(`${orphans.length} de los roles locales quedarían huérfanos: eso es la firma de un 'scopes.resolveChain' ciego. ` +
+                this.logger.warning(`${orphans.length} de los roles locales quedarían huérfanos: eso es la firma de un 'scopes.resolveChain' ciego ` +
+                    `(${massPurgeLetter(massPurgeReasons ?? [])}). ` +
                     `Con --force esto se rechaza (E_AUTHZ_MASS_PURGE_REFUSED); comprueba el resolutor antes de añadir --allow-mass-purge.`);
             }
             this.logger.warning(`${orphans.length} rol(es) local(es) con el owner fuera del árbol. No se ha borrado nada: repite con --force.`);
@@ -128,7 +145,13 @@ __decorate([
 ], AuthzCatalogPruneOrphans.prototype, "force", void 0);
 __decorate([
     flags.boolean({
-        description: 'Allow a pass that would purge every owner (or more than half the local roles) — check your resolveChain first',
+        description: 'Allow a pass that would purge every owner, more than half the local roles, or orphans of several owners that still grant (or cannot be counted) — check your resolveChain first',
     }),
     __metadata("design:type", Object)
 ], AuthzCatalogPruneOrphans.prototype, "allowMassPurge", void 0);
+__decorate([
+    flags.number({
+        description: 'Cap on the local roles this pass reads (default 10000); above it, 500 E_AUTHZ_TOO_MANY_LOCAL_ROLES, never a partial list',
+    }),
+    __metadata("design:type", Object)
+], AuthzCatalogPruneOrphans.prototype, "maxLocalRoles", void 0);

package/build/commands/authz_scopes_relay.js

@@ -207,7 +207,11 @@ export default class AuthzScopesRelay extends BaseCommand {
                 'Revísala en la cola (el consumidor puede volver a notificar el cambio) o reconcilia.');
         }
         if (report.busy) {
-            this.logger.info('Otra pasada del relay tiene el lease de la cola: esta no ha aplicado nada (el relay es escritor único).');
+            // Rotación 2 · R2-01b: la rama sigue saliendo 0 —respuesta del dueño en el cierre 2: la línea y `--max-age` son el
+            // detector; el caso fija exit 0 exacto (T-05)—, y la línea dice lo que puede ser.
+            this.logger.info('Otra pasada del relay tiene el lease de la cola: esta no ha aplicado nada (el relay es escritor único). ' +
+                'En MySQL, durante 2.5.x, el lease puede tenerlo OTRO despliegue del mismo servidor (el nombre de transición no ' +
+                'lleva la base; se retira en 2.6): si se repite en cada pasada, la cola no avanza — vigílala con --max-age.');
             if (report.dead.length > 0)
                 this.exitCode = 1;
             return;

package/build/commands/authz_scopes_requeue.js

@@ -69,7 +69,8 @@ export function requeueLines(input) {
             level: 'error',
             message: 'Otra pasada del relay tiene el lease de la cola: con --apply no se ha reencolado NADA (todo o nada: reencolar y no ' +
                 'aplicar dejaría la entrada con un solo intento, que la siguiente pasada gastaría). Reintenta (--wait-lease-ms espera ' +
-                'a que la suelten), o reencola sin --apply y deja que la próxima pasada la aplique.',
+                'a que la suelten), o reencola sin --apply y deja que la próxima pasada la aplique. En MySQL, durante 2.5.x, el ' +
+                'lease puede tenerlo OTRO despliegue del mismo servidor (el nombre de transición no lleva la base; se retira en 2.6).',
         });
         return { lines, clean: false };
     }

package/build/commands/authz_upgrade_1x.d.ts

@@ -0,0 +1,216 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * **`authz:upgrade-1x`** (rotación 3 · cierre 3, ESTRUCTURAL; firmado por el dueño el 2026-10-26).
+ *
+ * La subida 1.x → 2.x de MySQL deja de ser un bloque SQL que el operador copia y pasa a ser CÓDIGO que inspecciona el
+ * estado antes de tocar nada. Es el tercer defecto del linaje «receta del operador que no aguanta su re-ejecución»
+ * (R3-01 → RR-1 → A1/A2 del re-ataque 2, los tres confirmados en `mysql84`), y la regla de `CLAUDE.md` es que el
+ * tercero no se parchea: se quita el camino manual.
+ *
+ * Reparto (mismo patrón que `unfreezePlan`/`reconcileLines`):
+ *  - `readUpgrade1xState` LEE (information_schema, el marcador y los datos) por UNA sesión;
+ *  - `upgrade1xPlan(estado, banderas)` es la función PURA que DECIDE: estado detectado, negativa o pasos;
+ *  - `run()` imprime el plan y, solo con `--force`, ejecuta los pasos por esa misma sesión.
+ *
+ * Qué hace la subida (lo que era el bloque MySQL del README): los `MODIFY` de collation/tipo, `expires_at` de
+ * `timestamp` a `datetime(3)` en la zona de sesión que tenía 1.x (`@@global.time_zone`), la CONVERSIÓN de cada
+ * caducidad de 1.x desde la zona de sus procesos (`--zone`) a UTC, `authz_catalog_version` con sus dos filas, y las
+ * columnas `owner_scope_key`/`assignable_at`. El marcador `authz_upgrade_1x` (fila `expires_at`) se ARMA antes del
+ * `MODIFY` y SOLO si la columna sigue siendo `timestamp` (cierra A1/B2: una base ya en `datetime` sin marcador no se
+ * convierte nunca por defecto); la conversión y el «hecho» van en UNA transacción (DML de InnoDB: todo o nada) y la
+ * conversión va ANTES de crear `authz_catalog_version`, así que ningún proceso 2.x ha podido escribir una fila que se
+ * convierta (sin esa tabla toda escritura de 2.x es 503).
+ *
+ * Cierre 4 de la rotación 3 (firmado 2026-10-26, «sí, firmo la a) con el 2 y el 3»), tres límites que el código solo no
+ * podía ver:
+ *  - C1 · un proceso 1.x VIVO tras la conversión sigue escribiendo la pared de su zona en el `datetime(3)` y nada lo
+ *    detecta después (el marcador ya dice `done`). Precondición OBLIGATORIA y CONFIRMADA: todo `--force` que convierte
+ *    (`1x-sin-subir`, `a-medias` antes de `convert`, `--fix-previous-upgrade`) exige `--confirm-legacy-stopped`; sin
+ *    ella, negativa con cero sentencias de escritura. El esquema NO se cambia para romper las escrituras de 1.x (opción
+ *    b descartada por el dueño).
+ *  - C2 · «la conversión y el done en UNA transacción» solo es verdad en InnoDB: el comando lee
+ *    `information_schema.tables.engine` de `authz_assignments` y del marcador y, si alguno no es InnoDB, se niega
+ *    (`motor-no-transaccional`) antes de tocar nada; las tablas que crea llevan `ENGINE=InnoDB` explícito.
+ *  - P1 · una base NACIDA en 2.x no se distingue de una subida ENTERA con el bloque viejo: `--declare-born-in-2` es la
+ *    DECLARACIÓN del operador (el comando no puede demostrar que no hubo 1.x) y escribe el marcador `done`/`born` sin
+ *    tocar datos.
+ *
+ * Cierre 5 de la rotación 3 (firmado 2026-10-27): born se NIEGA donde el comando SÍ ve 1.x (`upgrade1xLegacyTraces`:
+ * DDL de 1.x pendiente o fechas cero, además de `timestamp` y del marcador), y `receta-vieja` deja de ofrecerlo ahí (B1,
+ * B1-bis); las banderas de la conversión se rechazan con born en vez de tragarse (H4).
+ */
+/** El estado detectado: la PRIMERA línea de la salida empieza por `estado: <clave>` (CLAUDE.md punto 7). */
+export type Upgrade1xStateKey = 'no-mysql' | 'sin-tablas' | '1x-sin-subir' | 'a-medias' | 'receta-vieja' | 'hecho' | 'incoherente' | 'motor-no-transaccional';
+/** Los DDL de la subida que se detectan pendientes uno a uno (cada uno es idempotente por inspección). */
+export declare const UPGRADE_1X_PRE_CONVERT_DDL: readonly ["collation-roles", "collation-permissions", "assignments", "collation-denies"];
+export declare const UPGRADE_1X_POST_CONVERT_DDL: readonly ["catalog-version", "roles-owner", "permissions-assignable"];
+export type Upgrade1xDdl = (typeof UPGRADE_1X_PRE_CONVERT_DDL)[number] | (typeof UPGRADE_1X_POST_CONVERT_DDL)[number];
+/** Un paso ejecutable, en el orden en que el plan los pone. */
+export type Upgrade1xStep = 'zero-dates' | 'marker-table' | 'marker-arm' | 'convert' | 'fix-previous' | 'born' | Upgrade1xDdl;
+/** Los pasos que CONVIERTEN caducidades: con `--force` exigen `--confirm-legacy-stopped` (C1). */
+export declare const UPGRADE_1X_CONVERTING_STEPS: readonly Upgrade1xStep[];
+export interface Upgrade1xMarker {
+    step: string;
+    /** `armed` (antes del MODIFY de `expires_at`, con la columna aún `timestamp`) o `done`. */
+    state: string;
+    /**
+     * `upgrade` (subida completa), `fix-previous` (corrección de quien subió con el bloque viejo) o `born` (el operador
+     * DECLARÓ la base nacida en 2.x: `--declare-born-in-2`; zona `+00:00`, ningún dato tocado).
+     */
+    mode: string;
+    zone: string | null;
+    /** `--upgraded-at` de la corrección, ISO; `null` en `upgrade`. */
+    upgradedAt: string | null;
+}
+/** Lo que `readUpgrade1xState` lee. Las entradas de la tabla de verdad de `upgrade1xPlan`. */
+export interface Upgrade1xState {
+    /** Nombre de la conexión de Lucid sobre la que se lee. */
+    connection: string;
+    /** `dialect.name` de esa conexión. Fuera de MySQL nada más se lee. */
+    dialect: string;
+    /** Faltan tablas de 1.x (`authz_roles`, `authz_permissions`, `authz_assignments`, `authz_denies`). */
+    missingTables: string[];
+    /**
+     * Tablas que la conversión escribe en UNA transacción (`authz_assignments` y, si existe, `authz_upgrade_1x`) con un
+     * motor que NO es InnoDB, como `tabla (MOTOR)` (C2: en MyISAM el ROLLBACK no deshace nada). Ausente = ninguna.
+     */
+    nonTransactional?: string[];
+    /** `COLUMN_TYPE` de `authz_assignments.expires_at` (`timestamp`, `datetime(3)`, …), o `null` si no existe. */
+    expiresType: string | null;
+    /** Filas de `authz_upgrade_1x`; `null` si la tabla no existe; `'malformed'` si existe con otra forma. */
+    marker: Upgrade1xMarker[] | null | 'malformed';
+    /** DDL pendientes, en orden canónico. */
+    pendingDdl: Upgrade1xDdl[];
+    /** Combinaciones de esquema que ningún punto de corte de este comando produce (índices a medias, …). */
+    schemaOdd: string[];
+    /** ¿Existe `authz_catalog_version`? (con ella un proceso 2.x puede haber escrito). */
+    catalogVersionTable: boolean;
+    /** Filas con `expires_at` no nulo. */
+    expiring: number;
+    /** Caducidades presentes que MySQL no puede convertir (fecha cero, mes/día cero): `CONVERT_TZ` da `NULL` (A2). */
+    unreadable: number;
+    /** Zonas sondeadas (`--zone`, la del marcador) → ¿`CONVERT_TZ` las convierte? (tablas de zonas cargadas). */
+    zones: Record<string, boolean>;
+    /** Milisegundo del UUIDv7 más antiguo de `authz_assignments` (`null` si no hay ninguno v7). */
+    oldestV7Ms: number | null;
+    /** Filas cuyo `uuid` no tiene forma de UUIDv7. */
+    nonV7: number;
+    /** Con `--fix-previous-upgrade`: filas con caducidad insertadas antes de `--upgraded-at` (de 1.x). */
+    fixBefore: number | null;
+    /** …y de ellas, las que la conversión ADELANTA (las únicas que la corrección mueve). */
+    fixCandidates: number | null;
+    /** Reloj de pared (`systemClock`), para «`--upgraded-at` no es futuro». */
+    nowMs: number;
+}
+export interface Upgrade1xFlags {
+    zone?: string;
+    force?: boolean;
+    dryRun?: boolean;
+    fixPreviousUpgrade?: boolean;
+    upgradedAt?: string;
+    zeroDates?: string;
+    /** C1: el operador CONFIRMA que todos los procesos 1.x están parados (obligatoria con `--force` donde se convierte). */
+    confirmLegacyStopped?: boolean;
+    /** P1: el operador DECLARA que la base nació en 2.x (nunca tuvo datos de 1.x). */
+    declareBornIn2?: boolean;
+}
+export interface Upgrade1xLine {
+    level: 'info' | 'warning' | 'error' | 'success';
+    message: string;
+}
+export interface Upgrade1xPlan {
+    state: Upgrade1xStateKey;
+    /** `noop` (nada que hacer, exit 0), `refuse` (exit 1, nada escrito) o `run` (hay pasos). */
+    action: 'noop' | 'refuse' | 'run';
+    /** `run` con `--force`: se ejecutan los pasos. `run` sin él es la simulación (exit 0, cero escrituras). */
+    write: boolean;
+    exitCode: 0 | 1;
+    /** La zona con la que se convierte (bandera o marcador). */
+    zone: string | null;
+    upgradedAtMs: number | null;
+    steps: Upgrade1xStep[];
+    /** La primera es SIEMPRE `estado: <clave> · …`. */
+    lines: Upgrade1xLine[];
+}
+/** La zona que guarda el marcador `born`: 2.x siempre escribió UTC (columna `zone` NOT NULL). */
+export declare const UPGRADE_1X_BORN_ZONE = "+00:00";
+/** La letra de la negativa de born con rastro de 1.x (rotación 3 · cierre 5, B1/B1-bis). */
+export declare const UPGRADE_1X_BORN_TRACE_TEXT = "hay rastro de 1.x, born no aplica";
+/**
+ * Los RASTROS de 1.x que el comando DETECTA en una base con `expires_at` ya `datetime(3)` y sin marcador (rotación 3 ·
+ * cierre 5, B1/B1-bis). Ninguna migración publicada de 2.x deja un paso de esquema pendiente (crean `authz_catalog_version`
+ * con sus dos filas, `owner_scope_key` con el unique de tres columnas, `assignable_at` y las columnas `utf8mb4_bin`), y el
+ * codec de 2.x no escribe fechas cero. Sin ninguno de los dos, una base nacida en 2.x y una subida entera con el bloque
+ * viejo tienen la misma forma: ahí `--declare-born-in-2` sigue siendo una DECLARACIÓN del operador.
+ */
+export declare function upgrade1xLegacyTraces(state: Pick<Upgrade1xState, 'pendingDdl' | 'unreadable'>): string[];
+/**
+ * La precondición de C1, en una frase: la usan la negativa, la línea del plan y la simulación. Un proceso 1.x vivo tras
+ * la conversión escribe la PARED de su zona en el `datetime(3)` que 2.x lee como UTC, y ya nada lo detecta.
+ */
+export declare const UPGRADE_1X_LEGACY_STOPPED_TEXT: string;
+/** El instante en el que `--zero-dates=expire` deja una caducidad ilegible: PASADO, nunca `NULL` (A2). */
+export declare const UPGRADE_1X_EXPIRED_INSTANT = 86400;
+/** `--upgraded-at` exige ISO con zona explícita (`Z` o `±hh:mm`): sin ella JavaScript la leería en la hora local. */
+export declare function parseUpgradedAt(value: string | undefined): number | null;
+/** El prefijo de UUIDv7 de un milisegundo (`xxxxxxxx-xxxx`): las filas insertadas antes ordenan por debajo, por bytes. */
+export declare function v7Prefix(ms: number): string;
+export declare function describeUpgrade1xStep(step: Upgrade1xStep): string;
+/**
+ * Decide, sin I/O, qué hacer con el estado detectado. Tabla de verdad (la fija `command_flags_upgrade_1x.spec.ts`):
+ *
+ * | `expires_at` | marcador | otras entradas | estado | acción |
+ * |---|---|---|---|---|
+ * | (no MySQL) | — | — | `no-mysql` | noop, exit 0, cero sentencias |
+ * | falta una tabla de 1.x | — | — | `sin-tablas` | negativa |
+ * | `timestamp` | ninguno | sin `authz_catalog_version` | `1x-sin-subir` | subida completa; exige `--zone` |
+ * | `timestamp` | `armed` | sin `authz_catalog_version` | `a-medias` | reanuda con la zona del marcador |
+ * | `timestamp` | `done` | — | `incoherente` (B2: volcado de 1.x restaurado) | negativa |
+ * | `timestamp` | ninguno/`armed` | con `authz_catalog_version` | `incoherente` (2.x pudo escribir en la columna de 1.x) | negativa |
+ * | `datetime(3)` | ninguno | alguna caducidad o DDL pendiente | `receta-vieja` | negativa; con `--fix-previous-upgrade` corrige |
+ * | `datetime(3)` | ninguno | ninguna caducidad y nada pendiente | `hecho` | noop |
+ * | `datetime(3)` | `armed` | sin `authz_catalog_version` | `a-medias` | convierte y termina |
+ * | `datetime(3)` | `done` | DDL pendiente | `a-medias` | termina el DDL |
+ * | `datetime(3)` | `done` | nada pendiente | `hecho` | noop (otra `--zone` ⇒ negativa) |
+ * | otro tipo, marcador con otra forma, índices a medias | | | `incoherente` | negativa |
+ * | (cualquiera) | (cualquiera) | `authz_assignments` o el marcador no son InnoDB | `motor-no-transaccional` (C2) | negativa |
+ * | `datetime(3)` | ninguno | `--declare-born-in-2`, sin rastro de 1.x | `receta-vieja` / `hecho` | escribe el marcador `done`/`born`, cero datos (P1) |
+ * | `datetime(3)` | ninguno | `--declare-born-in-2` + DDL pendiente o fechas cero | `receta-vieja` | negativa: «hay rastro de 1.x, born no aplica» (B1) |
+ * | (cualquiera) | (cualquiera) | `--declare-born-in-2` + `--zero-dates`/`--confirm-legacy-stopped`/`--zone`/fix | | negativa (H4) |
+ *
+ * Y en todo estado que convierte: zona desconocida para MySQL ⇒ negativa ANTES de tocar nada; caducidades ilegibles ⇒
+ * negativa salvo `--zero-dates=expire`; con `--force`, sin `--confirm-legacy-stopped` ⇒ negativa (C1). Escribir exige
+ * `--force`; sin él es la simulación (que menciona la precondición).
+ */
+export declare function upgrade1xPlan(state: Upgrade1xState, flags: Upgrade1xFlags): Upgrade1xPlan;
+type Query = (sql: string, bindings?: unknown[]) => Promise<any[]>;
+export declare function readUpgrade1xState(q: Query, connection: string, flags: Upgrade1xFlags, nowMs: number): Promise<Upgrade1xState>;
+export declare function runUpgrade1xStep(q: Query, step: Upgrade1xStep, plan: Upgrade1xPlan): Promise<string>;
+/**
+ *   node ace authz:upgrade-1x --zone=Europe/Madrid             # simulación: estado detectado + plan, cero escrituras
+ *   node ace authz:upgrade-1x --zone=Europe/Madrid --confirm-legacy-stopped --force     # sube (re-ejecutable tras un corte)
+ *   node ace authz:upgrade-1x --fix-previous-upgrade --zone=Europe/Madrid --upgraded-at=2026-09-01T10:00:00Z --confirm-legacy-stopped --force
+ *   node ace authz:upgrade-1x --declare-born-in-2 --force     # base nacida en 2.x: marcador, cero datos
+ */
+export default class AuthzUpgrade1x extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static options: CommandOptions;
+    /**
+     * Gancho de TEST (cortes): se llama tras cada paso confirmado; si lanza, el comando se comporta como un proceso
+     * cortado ahí (exit 1, lo hecho queda hecho). Nadie lo pone en producción.
+     */
+    static afterStep: ((step: Upgrade1xStep) => void | Promise<void>) | undefined;
+    zone: string | undefined;
+    force: boolean | undefined;
+    dryRun: boolean | undefined;
+    fixPreviousUpgrade: boolean | undefined;
+    upgradedAt: string | undefined;
+    zeroDates: string | undefined;
+    confirmLegacyStopped: boolean | undefined;
+    declareBornIn2: boolean | undefined;
+    connection: string | undefined;
+    run(): Promise<void>;
+}
+export {};