@wallavi/vercel-build 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -92,29 +92,6 @@ declare function ejecutarIgnorar(opciones: OpcionesIgnorar): number;
 declare function comandoIgnorar(args: string[], entorno: Entorno): number;
 declare const ignorar: typeof comandoIgnorar;
 
-declare const VARIABLES_VERCEL: readonly ["VERCEL_TOKEN", "VERCEL_ORG_ID", "VERCEL_PROJECT_ID"];
-declare const PASOS_VERCEL: readonly (readonly string[])[];
-interface ArgumentosDesplegar {
-    carpeta: string;
-    antes?: string;
-}
-declare function leerArgumentosDesplegar(args: readonly string[]): {
-    ok: true;
-    valor: ArgumentosDesplegar;
-} | {
-    ok: false;
-    motivo: string;
-};
-interface OpcionesDesplegar extends Entorno {
-    carpeta: string;
-    antes?: string;
-    ejecutar?: Ejecutar;
-    evaluar?: (opciones: OpcionesCambios) => Evaluacion;
-}
-declare function ejecutarDesplegar(opciones: OpcionesDesplegar): number;
-declare function comandoDesplegar(args: string[], entorno: Entorno): number;
-declare const desplegar: typeof comandoDesplegar;
-
 declare const API_VERCEL_URL = "https://api.vercel.com";
 declare const LIMITE_PAGINA_VERCEL = 100;
 declare const MAX_PAGINAS_VERCEL = 1000;
@@ -941,7 +918,8 @@ interface RespuestaHttp {
     estado: number;
     cuerpo: string;
 }
-type SolicitarVercel = (url: string, headers: Record<string, string>) => RespuestaHttp;
+type MetodoHttpVercel = "GET" | "POST";
+type SolicitarVercel = (url: string, headers: Record<string, string>, metodo?: MetodoHttpVercel) => RespuestaHttp;
 declare const solicitarVercel: SolicitarVercel;
 declare function pedirJsonVercel(rutaQuery: string, token: string, solicitar?: SolicitarVercel, baseUrl?: string): {
     estado: number;
@@ -978,6 +956,425 @@ declare function ejecutarMedir(opciones: OpcionesMedir): number;
 declare function comandoMedir(args: string[], entorno: Entorno): number;
 declare const medir: typeof comandoMedir;
 
+declare const INTERVALO_POLL_DEPLOY_MS = 5000;
+declare const TIMEOUT_POLL_DEPLOY_MS = 600000;
+type Dormir = (ms: number) => void;
+declare const dormirSincrono: Dormir;
+declare const esquemaDeploymentPromocion: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readySubstate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readySubstate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readySubstate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    id: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readySubstate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readySubstate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    id: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readySubstate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+    readySubstate: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+    aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const esquemaListaDeploymentsPromocion: z.ZodObject<{
+    deployments: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    deployments: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    deployments: z.ZodArray<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        state: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readyState: z.ZodOptional<z.ZodEnum<["BUILDING", "ERROR", "INITIALIZING", "QUEUED", "READY", "CANCELED"]>>;
+        readySubstate: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, z.ZodTypeAny, "passthrough">>;
+type DeploymentPromocion = z.infer<typeof esquemaDeploymentPromocion>;
+declare function limpiarIdOUrlDeploy(valor: string): string | null;
+declare function extraerIdOUrlDeploy(salida: string, error?: string): string | null;
+declare function extraerAliasProduccion(deployment: DeploymentPromocion): string | null;
+interface OpcionesPromover {
+    teamId?: string;
+    projectId?: string;
+    token?: string;
+    sha?: string;
+    urlDeploy?: string | null;
+    salidaDeploy?: string;
+    errorDeploy?: string;
+    cwd?: string;
+    carpeta?: string;
+    env?: NodeJS.ProcessEnv;
+    ejecutar?: Ejecutar;
+    solicitar?: SolicitarVercel;
+    dormir?: Dormir;
+    intervaloMs?: number;
+    timeoutMs?: number;
+    maxIntentos?: number;
+    baseUrl?: string;
+}
+type ResultadoPromocion = {
+    ok: true;
+    codigo: 0;
+    deploymentId: string;
+    alias: string | null;
+    url: string | null;
+} | {
+    ok: false;
+    codigo: 1;
+    motivo: string;
+};
+declare function esperarYPromoverDeploy(opciones: OpcionesPromover): ResultadoPromocion;
+
+declare const VARIABLES_VERCEL: readonly ["VERCEL_TOKEN", "VERCEL_ORG_ID", "VERCEL_PROJECT_ID"];
+declare const PASOS_VERCEL: readonly [readonly ["pull", "--yes", "--environment=production"], readonly ["build", "--prod"], readonly ["deploy", "--prebuilt", "--prod"]];
+declare const PASO_DEPLOY_REMOTO: readonly ["deploy", "--prod", "--yes", "--no-wait"];
+declare const ARCHIVO_ENV_PRODUCCION: string;
+interface ArgumentosDesplegar {
+    carpeta: string;
+    antes?: string;
+    urlSalud?: string;
+}
+declare function leerArgumentosDesplegar(args: readonly string[]): {
+    ok: true;
+    valor: ArgumentosDesplegar;
+} | {
+    ok: false;
+    motivo: string;
+};
+declare function tieneVariablesSensibles(carpeta: string): boolean;
+declare function extraerUrlSalud(salida: string, error?: string): string | null;
+interface OpcionesDesplegar extends Entorno {
+    carpeta: string;
+    antes?: string;
+    urlSalud?: string;
+    ejecutar?: Ejecutar;
+    evaluar?: (opciones: OpcionesCambios) => Evaluacion;
+    solicitar?: SolicitarVercel;
+    dormir?: Dormir;
+    intervaloPollMs?: number;
+    timeoutPollMs?: number;
+    maxIntentosPoll?: number;
+    baseUrl?: string;
+}
+declare function ejecutarDesplegar(opciones: OpcionesDesplegar): number;
+declare function comandoDesplegar(args: string[], entorno: Entorno): number;
+declare const desplegar: typeof comandoDesplegar;
+
 declare const ARCHIVO_DEPLOYMENTS_V6 = "deployments-v6.json";
 declare const ARCHIVO_CAPTURA_V6 = "captura-v6.json";
 declare const REFERENCIA_DEPLOYMENTS_V6 = "https://vercel.com/docs/rest-api/reference/endpoints/deployments/list-deployments";
@@ -1273,7 +1670,7 @@ declare function ejecutarCapturar(opciones: OpcionesCapturar): number;
 declare function comandoCapturar(args: string[], entorno: Entorno): number;
 declare const capturar: typeof comandoCapturar;
 
-declare const USO = "Uso: wallavi-vercel <comando> [opciones]\n\nComandos:\n  ignorar                                                                          decide si Vercel debe omitir el build\n  desplegar --carpeta <ruta> [--antes <sha>]                                       compila y despliega a producci\u00F3n si hay cambios\n  medir --equipo <slug|team_id> --desde <AAAA-MM-DD> --hasta <AAAA-MM-DD> [...]    calcula los minutos de build por d\u00EDa en UTC\n  capturar --equipo <slug|team_id> --desde <AAAA-MM-DD> --hasta <AAAA-MM-DD> ...   descarga deployments de Vercel y escribe su captura\n\nOpciones:\n  -h, --help                                                                       muestra esta ayuda\n";
+declare const USO = "Uso: wallavi-vercel <comando> [opciones]\n\nComandos:\n  ignorar                                                                          decide si Vercel debe omitir el build\n  desplegar --carpeta <ruta> [--antes <sha>] [--url-salud <url>]                  compila, despliega y verifica la salud HTTP\n  medir --equipo <slug|team_id> --desde <AAAA-MM-DD> --hasta <AAAA-MM-DD> [...]    calcula los minutos de build por d\u00EDa en UTC\n  capturar --equipo <slug|team_id> --desde <AAAA-MM-DD> --hasta <AAAA-MM-DD> ...   descarga deployments de Vercel y escribe su captura\n\nOpciones:\n  -h, --help                                                                       muestra esta ayuda\n";
 interface Entorno {
     cwd: string;
     env: NodeJS.ProcessEnv;
@@ -1284,4 +1681,4 @@ type Comando = (args: string[], entorno: Entorno) => number;
 declare const COMANDOS: Record<string, Comando>;
 declare function principal(argv: string[], entorno: Entorno): number;
 
-export { API_VERCEL_URL, ARCHIVO_CAPTURA_V6, ARCHIVO_CONFIG, ARCHIVO_DEPLOYMENTS_V6, type ArgumentosCapturar, type ArgumentosDesplegar, type ArgumentosMedir, COMANDOS, type CapturaV6, type Comando, type ConfigVercelBuild, type DeploymentVercel, type DiaMinutos, ESTADOS_DEPLOYMENT, type Ejecutar, type Entorno, type EquipoVercel, ErrorContratoVercel, ErrorRedVercel, type Evaluacion, LIMITE_PAGINA_VERCEL, MAX_PAGINAS_VERCEL, type OpcionesCambios, type OpcionesCapturar, type OpcionesDesplegar, type OpcionesIgnorar, type OpcionesMedir, type OpcionesProceso, PASOS_VERCEL, PREFIJO_PREVIEW, type PaginaDeployments, type PaginaTeams, type PaginacionVercel, type PedidoCaptura, type ProyectoVercelBuild, RAMA_PRINCIPAL, REFERENCIA_DEPLOYMENTS_V6, type RespuestaHttp, type Resultado, type ResultadoDeployments, type ResultadoProceso, type SolicitarVercel, USO, VARIABLES_VERCEL, armarCapturaV6, calcularMinutosPorDia, capturar, comandoCapturar, comandoDesplegar, comandoIgnorar, comandoMedir, comandoTurbo, configVacia, consultarDeployments, desplegar, ejecutar, ejecutarCapturar, ejecutarDesplegar, ejecutarIgnorar, ejecutarMedir, esquemaArchivoDeployments, esquemaCapturaV6, esquemaConfig, esquemaDeployment, esquemaEquipo, esquemaEstadoDeployment, esquemaPaginaDeployments, esquemaPaginaTeams, esquemaPaginacion, esquemaPedidoCaptura, evaluarCambios, ignorar, leerArgumentosCapturar, leerArgumentosDesplegar, leerArgumentosMedir, leerConfig, leerFlagsCli, leerRespuestaDeployments, medir, normalizarCarpeta, paquetesDeTurbo, pedirJsonVercel, principal, proyectoDeCarpeta, ramaPermitida, rangoFechasUtc, redactarToken, resolverEquipo, solicitarVercel, ubicarEnRepo, validarConfig, validarFechaIso };
+export { API_VERCEL_URL, ARCHIVO_CAPTURA_V6, ARCHIVO_CONFIG, ARCHIVO_DEPLOYMENTS_V6, ARCHIVO_ENV_PRODUCCION, type ArgumentosCapturar, type ArgumentosDesplegar, type ArgumentosMedir, COMANDOS, type CapturaV6, type Comando, type ConfigVercelBuild, type DeploymentPromocion, type DeploymentVercel, type DiaMinutos, type Dormir, ESTADOS_DEPLOYMENT, type Ejecutar, type Entorno, type EquipoVercel, ErrorContratoVercel, ErrorRedVercel, type Evaluacion, INTERVALO_POLL_DEPLOY_MS, LIMITE_PAGINA_VERCEL, MAX_PAGINAS_VERCEL, type MetodoHttpVercel, type OpcionesCambios, type OpcionesCapturar, type OpcionesDesplegar, type OpcionesIgnorar, type OpcionesMedir, type OpcionesProceso, type OpcionesPromover, PASOS_VERCEL, PASO_DEPLOY_REMOTO, PREFIJO_PREVIEW, type PaginaDeployments, type PaginaTeams, type PaginacionVercel, type PedidoCaptura, type ProyectoVercelBuild, RAMA_PRINCIPAL, REFERENCIA_DEPLOYMENTS_V6, type RespuestaHttp, type Resultado, type ResultadoDeployments, type ResultadoProceso, type ResultadoPromocion, type SolicitarVercel, TIMEOUT_POLL_DEPLOY_MS, USO, VARIABLES_VERCEL, armarCapturaV6, calcularMinutosPorDia, capturar, comandoCapturar, comandoDesplegar, comandoIgnorar, comandoMedir, comandoTurbo, configVacia, consultarDeployments, desplegar, dormirSincrono, ejecutar, ejecutarCapturar, ejecutarDesplegar, ejecutarIgnorar, ejecutarMedir, esperarYPromoverDeploy, esquemaArchivoDeployments, esquemaCapturaV6, esquemaConfig, esquemaDeployment, esquemaDeploymentPromocion, esquemaEquipo, esquemaEstadoDeployment, esquemaListaDeploymentsPromocion, esquemaPaginaDeployments, esquemaPaginaTeams, esquemaPaginacion, esquemaPedidoCaptura, evaluarCambios, extraerAliasProduccion, extraerIdOUrlDeploy, extraerUrlSalud, ignorar, leerArgumentosCapturar, leerArgumentosDesplegar, leerArgumentosMedir, leerConfig, leerFlagsCli, leerRespuestaDeployments, limpiarIdOUrlDeploy, medir, normalizarCarpeta, paquetesDeTurbo, pedirJsonVercel, principal, proyectoDeCarpeta, ramaPermitida, rangoFechasUtc, redactarToken, resolverEquipo, solicitarVercel, tieneVariablesSensibles, ubicarEnRepo, validarConfig, validarFechaIso };

package/dist/index.js

@@ -91,13 +91,13 @@ var esquemaArchivoDeployments = zod.z.object({
   paginas: zod.z.array(esquemaPaginaDeployments).min(1)
 }).passthrough();
 var SCRIPT_FETCH = [
-  "const [u] = process.argv.slice(1), h = require('node:fs').readFileSync(0, 'utf8');",
-  "fetch(u, { method: 'GET', headers: JSON.parse(h) })",
+  "const [u, m = 'GET'] = process.argv.slice(1), h = require('node:fs').readFileSync(0, 'utf8');",
+  "fetch(u, { method: m, headers: JSON.parse(h) })",
   "  .then(async (r) => process.stdout.write(JSON.stringify({ estado: r.status, cuerpo: await r.text() })))",
   "  .catch((e) => { process.stderr.write(String(e?.message || e)); process.exit(1); });"
 ].join("\n");
-var solicitarVercel = (url, headers) => {
-  const r = child_process.spawnSync(process.execPath, ["-e", SCRIPT_FETCH, url], {
+var solicitarVercel = (url, headers, metodo = "GET") => {
+  const r = child_process.spawnSync(process.execPath, ["-e", SCRIPT_FETCH, url, metodo], {
     input: JSON.stringify(headers),
     shell: false,
     encoding: "utf8",
@@ -113,26 +113,22 @@ var solicitarVercel = (url, headers) => {
 function pedirJsonVercel(rutaQuery, token, solicitar = solicitarVercel, baseUrl = API_VERCEL_URL) {
   let respuesta;
   try {
-    respuesta = solicitar(`${baseUrl}${rutaQuery}`, {
-      Authorization: `Bearer ${token}`
-    });
+    const headers = { Authorization: `Bearer ${token}` };
+    respuesta = solicitar(`${baseUrl}${rutaQuery}`, headers);
   } catch (e) {
     if (e instanceof ErrorRedVercel || e instanceof ErrorContratoVercel)
       throw e;
     throw new ErrorRedVercel(e.message);
   }
   if (respuesta.estado < 200 || respuesta.estado >= 300) {
-    throw new ErrorRedVercel(
-      `HTTP ${respuesta.estado} en GET ${rutaQuery}`,
-      respuesta.estado
-    );
+    const msg = `HTTP ${respuesta.estado} en GET ${rutaQuery}`;
+    throw new ErrorRedVercel(msg, respuesta.estado);
   }
   try {
     return { estado: respuesta.estado, valor: JSON.parse(respuesta.cuerpo) };
   } catch (e) {
-    throw new ErrorContratoVercel(
-      `JSON inv\xE1lido en GET ${rutaQuery}: ${e.message}`
-    );
+    const msg = `JSON inv\xE1lido en GET ${rutaQuery}: ${e.message}`;
+    throw new ErrorContratoVercel(msg);
   }
 }
 function resolverEquipo(equipo, token, solicitar = solicitarVercel, baseUrl = API_VERCEL_URL) {
@@ -233,12 +229,8 @@ function calcularMinutosPorDia(paginas, desde, hasta) {
   };
 }
 function leerArgumentosMedir(args) {
-  const f = leerFlagsCli(args, [
-    "--equipo",
-    "--desde",
-    "--hasta",
-    "--respuesta"
-  ]);
+  const flags = ["--equipo", "--desde", "--hasta", "--respuesta"];
+  const f = leerFlagsCli(args, flags);
   if (!f.ok) return f;
   const { equipo, desde, hasta, respuesta } = f.valores;
   if (!equipo) return { ok: false, motivo: "falta --equipo <slug|team_id>" };
@@ -585,12 +577,12 @@ function ejecutar(comando, args, opciones) {
     maxBuffer: 64 * 1024 * 1024,
     stdio: opciones.heredar ? "inherit" : "pipe"
   });
-  const fallo = r.error?.message ?? (r.signal ? `termin\xF3 por la se\xF1al ${r.signal}` : void 0);
+  const fallo2 = r.error?.message ?? (r.signal ? `termin\xF3 por la se\xF1al ${r.signal}` : void 0);
   return {
     codigo: r.status,
     salida: r.stdout ?? "",
     error: r.stderr ?? "",
-    ...fallo ? { fallo } : {}
+    ...fallo2 ? { fallo: fallo2 } : {}
   };
 }
 var incierto = (motivo) => ({
@@ -710,6 +702,265 @@ function evaluarCambios(opciones) {
     motivo: `turbo: ${nombre} sin paquetes afectados`
   };
 }
+var INTERVALO_POLL_DEPLOY_MS = 5e3;
+var TIMEOUT_POLL_DEPLOY_MS = 6e5;
+var REGEX_ANSI = new RegExp(
+  `${String.fromCharCode(27)}\\[[0-9;]*[a-zA-Z]`,
+  "g"
+);
+var dormirSincrono = (ms) => {
+  if (ms > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+var esquemaDeploymentPromocion = zod.z.object({
+  id: zod.z.string().min(1).optional(),
+  uid: zod.z.string().min(1).optional(),
+  projectId: zod.z.string().min(1).optional(),
+  target: zod.z.string().nullable().optional(),
+  state: esquemaEstadoDeployment.optional(),
+  readyState: esquemaEstadoDeployment.optional(),
+  readySubstate: zod.z.string().min(1).optional(),
+  url: zod.z.string().min(1).optional(),
+  alias: zod.z.union([zod.z.array(zod.z.string()), zod.z.string()]).optional(),
+  aliases: zod.z.array(zod.z.string()).optional(),
+  meta: zod.z.record(zod.z.unknown()).optional()
+}).passthrough().refine((d) => d.id !== void 0 || d.uid !== void 0, {
+  message: "el deployment debe incluir id o uid"
+}).refine((d) => d.state !== void 0 || d.readyState !== void 0, {
+  message: "el deployment debe incluir state o readyState"
+});
+var esquemaListaDeploymentsPromocion = zod.z.object({ deployments: zod.z.array(esquemaDeploymentPromocion) }).passthrough();
+function limpiarIdOUrlDeploy(valor) {
+  const sinAnsi = valor.replace(REGEX_ANSI, "").trim();
+  const limpio = sinAnsi.replace(/^https?:\/\//i, "").replace(/[/?#].*$/, "").replace(/[.,;]+$/, "").trim();
+  return limpio || null;
+}
+function extraerIdOUrlDeploy(salida, error = "") {
+  const stdout = salida.replace(REGEX_ANSI, "");
+  const texto = `${error}
+${salida}`.replace(REGEX_ANSI, "");
+  const urlStdout = /^\s*(https?:\/\/[^\s\]"')>]+)/im.exec(stdout)?.[1];
+  const produccion = /\bProduction\s*:\s*(https?:\/\/[^\s\]"')>]+)/i.exec(
+    texto
+  )?.[1];
+  const alias = /\bAlias(?:ed)?\s*:\s*(https?:\/\/[^\s\]"')>]+)/i.exec(
+    texto
+  )?.[1];
+  const candidata = urlStdout ?? produccion ?? alias;
+  if (candidata) {
+    const limpio = limpiarIdOUrlDeploy(candidata);
+    if (limpio && limpio !== "vercel.com") return limpio;
+  }
+  return /\b(dpl_[a-zA-Z0-9]+)\b/.exec(texto)?.[1] ?? null;
+}
+function normalizarUrlHttps(dominioOUrl) {
+  const limpio = dominioOUrl.trim().replace(/[.,;]+$/, "").replace(/\/+$/, "");
+  return /^https?:\/\//i.test(limpio) ? limpio : `https://${limpio}`;
+}
+function esDominioVercelApp(dominioOUrl) {
+  const host = dominioOUrl.trim().replace(/^https?:\/\//i, "").split("/")[0]?.toLowerCase() ?? "";
+  return host === "vercel.app" || host.endsWith(".vercel.app");
+}
+function extraerAliasProduccion(deployment) {
+  const crudos = [];
+  if (Array.isArray(deployment.alias)) crudos.push(...deployment.alias);
+  else if (typeof deployment.alias === "string") crudos.push(deployment.alias);
+  if (Array.isArray(deployment.aliases)) crudos.push(...deployment.aliases);
+  const candidatos = crudos.map((c) => c.trim()).filter(Boolean);
+  if (candidatos.length === 0) {
+    return deployment.url && !esDominioVercelApp(deployment.url) ? normalizarUrlHttps(deployment.url) : null;
+  }
+  const dominioPropio = candidatos.find((c) => !esDominioVercelApp(c));
+  return normalizarUrlHttps(dominioPropio ?? candidatos[0]);
+}
+function obtenerShaCommit(opc, ej) {
+  const explicito = opc.sha?.trim() || opc.env?.VERCEL_GIT_COMMIT_SHA?.trim();
+  if (explicito) return explicito;
+  const dirs = [opc.carpeta, opc.cwd].filter((d) => Boolean(d));
+  for (const dir of dirs) {
+    const raiz = ubicarEnRepo(dir, ej)?.raiz ?? dir;
+    const r = ej("git", ["rev-parse", "HEAD"], {
+      cwd: raiz,
+      ...opc.env ? { env: opc.env } : {}
+    });
+    if (r.codigo === 0 && r.salida.trim() !== "") return r.salida.trim();
+  }
+  return null;
+}
+var err = (motivo) => ({ ok: false, motivo });
+var fallo = (motivo) => ({
+  ok: false,
+  codigo: 1,
+  motivo
+});
+function llamarApiVercel(rutaQuery, ctx, metodo = "GET") {
+  let respuesta;
+  try {
+    const auth = { Authorization: `Bearer ${ctx.token}` };
+    respuesta = ctx.solicitar(`${ctx.baseUrl}${rutaQuery}`, auth, metodo);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return err(`fallo de red en ${metodo} ${rutaQuery} (${msg})`);
+  }
+  if (respuesta.estado < 200 || respuesta.estado >= 300) {
+    return err(`HTTP ${respuesta.estado} en ${metodo} ${rutaQuery}`);
+  }
+  return { ok: true, cuerpo: respuesta.cuerpo };
+}
+function validarIdentidadDeployment(d, ctx) {
+  const deploymentId = d.id ?? d.uid;
+  if (d.projectId !== void 0 && d.projectId !== ctx.projectId) {
+    return err(
+      `el deploy ${deploymentId} pertenece al proyecto ${d.projectId} y no a ${ctx.projectId}`
+    );
+  }
+  if (d.target !== void 0 && d.target !== null && d.target !== "production") {
+    return err(
+      `el deploy ${deploymentId} no es de producci\xF3n (target=${d.target})`
+    );
+  }
+  const shaMeta = typeof d.meta?.githubCommitSha === "string" ? d.meta.githubCommitSha.trim() : typeof d.meta?.gitCommitSha === "string" ? d.meta.gitCommitSha.trim() : "";
+  if (!shaMeta || shaMeta !== ctx.sha) {
+    return err(
+      `el deploy ${deploymentId} corresponde al SHA ${shaMeta || "desconocido"} y no a ${ctx.sha}`
+    );
+  }
+  return { ok: true, deploymentId };
+}
+function consultarDeploymentV13(idOrUrl, ctx) {
+  const ruta = `/v13/deployments/${encodeURIComponent(idOrUrl)}?${ctx.qTeam}`;
+  const resp = llamarApiVercel(ruta, ctx, "GET");
+  if (!resp.ok) return resp;
+  let json;
+  try {
+    json = JSON.parse(resp.cuerpo);
+  } catch (e) {
+    return err(`JSON inv\xE1lido en GET ${ruta} (${e.message})`);
+  }
+  const r = esquemaDeploymentPromocion.safeParse(json);
+  if (!r.success) {
+    return err(`respuesta inv\xE1lida en GET ${ruta} (${r.error.message})`);
+  }
+  const val = validarIdentidadDeployment(r.data, ctx);
+  if (!val.ok) return val;
+  return { ok: true, valor: r.data, deploymentId: val.deploymentId };
+}
+function esperarYPromoverDeploy(opciones) {
+  const ej = opciones.ejecutar ?? ejecutar;
+  const solicitar = opciones.solicitar ?? solicitarVercel;
+  const dormir = opciones.dormir ?? dormirSincrono;
+  const intervaloMs = opciones.intervaloMs ?? INTERVALO_POLL_DEPLOY_MS;
+  const timeoutMs = opciones.timeoutMs ?? TIMEOUT_POLL_DEPLOY_MS;
+  const maxIntentos = opciones.maxIntentos;
+  const token = opciones.token?.trim() || opciones.env?.VERCEL_TOKEN?.trim() || "";
+  const teamId = opciones.teamId?.trim() || opciones.env?.VERCEL_ORG_ID?.trim() || "";
+  const projectId = opciones.projectId?.trim() || opciones.env?.VERCEL_PROJECT_ID?.trim() || "";
+  const baseUrl = (opciones.baseUrl ?? opciones.env?.VERCEL_API_URL)?.trim() || API_VERCEL_URL;
+  if (!token || !teamId || !projectId) {
+    return fallo("faltan credenciales de Vercel para promover el deploy");
+  }
+  const sha = obtenerShaCommit(opciones, ej);
+  if (!sha) {
+    return fallo(
+      "no se pudo determinar el SHA actual para verificar el deploy"
+    );
+  }
+  const ctx = {
+    qTeam: `teamId=${encodeURIComponent(teamId)}`,
+    projectId,
+    sha,
+    token,
+    solicitar,
+    baseUrl
+  };
+  let idOrUrl = opciones.urlDeploy !== void 0 && opciones.urlDeploy !== null ? limpiarIdOUrlDeploy(opciones.urlDeploy) : extraerIdOUrlDeploy(
+    opciones.salidaDeploy ?? "",
+    opciones.errorDeploy ?? ""
+  );
+  let transcurridoMs = 0;
+  let intentos = 0;
+  let deployListo = null;
+  let deploymentId = "";
+  while (deployListo === null) {
+    intentos++;
+    let actual;
+    if (idOrUrl) {
+      const c = consultarDeploymentV13(idOrUrl, ctx);
+      if (!c.ok) return fallo(c.motivo);
+      actual = c.valor;
+      deploymentId = c.deploymentId;
+    } else {
+      const q = `${ctx.qTeam}&projectId=${encodeURIComponent(projectId)}&target=production&sha=${encodeURIComponent(sha)}`;
+      const ruta = `/v6/deployments?${q}`;
+      const resp = llamarApiVercel(ruta, ctx, "GET");
+      if (!resp.ok) return fallo(resp.motivo);
+      let json;
+      try {
+        json = JSON.parse(resp.cuerpo);
+      } catch (e) {
+        return fallo(`JSON inv\xE1lido en GET ${ruta} (${e.message})`);
+      }
+      const lista = esquemaListaDeploymentsPromocion.safeParse(json);
+      if (!lista.success || lista.data.deployments.length === 0) {
+        return fallo(
+          `no se encontr\xF3 deployment de producci\xF3n para el SHA ${sha}`
+        );
+      }
+      actual = lista.data.deployments[0];
+      const val = validarIdentidadDeployment(actual, ctx);
+      if (!val.ok) return fallo(val.motivo);
+      deploymentId = val.deploymentId;
+      idOrUrl = deploymentId;
+    }
+    const estado = actual.readyState ?? actual.state;
+    if (estado === "ERROR" || estado === "CANCELED") {
+      return fallo(`el deploy ${deploymentId} termin\xF3 en estado ${estado}`);
+    }
+    if (estado === "READY") {
+      deployListo = actual;
+      break;
+    }
+    if (maxIntentos !== void 0 && intentos >= maxIntentos || transcurridoMs + intervaloMs > timeoutMs) {
+      return fallo(
+        `timeout esperando a que el deploy ${deploymentId} llegue a READY (estado: ${estado})`
+      );
+    }
+    dormir(intervaloMs);
+    transcurridoMs += intervaloMs;
+  }
+  let deployFinal = deployListo;
+  if (deployListo.readySubstate !== "PROMOTED") {
+    const rutaPromote = `/v10/projects/${encodeURIComponent(projectId)}/promote/${encodeURIComponent(deploymentId)}?${ctx.qTeam}`;
+    const respPromote = llamarApiVercel(rutaPromote, ctx, "POST");
+    if (!respPromote.ok) return fallo(respPromote.motivo);
+    for (; ; ) {
+      intentos++;
+      const c = consultarDeploymentV13(deploymentId, ctx);
+      if (!c.ok) return fallo(c.motivo);
+      const dConf = c.valor;
+      const estadoConf = dConf.readyState ?? dConf.state;
+      if (estadoConf === "ERROR" || estadoConf === "CANCELED") {
+        return fallo(
+          `el deploy ${deploymentId} termin\xF3 en estado ${estadoConf} durante la promoci\xF3n`
+        );
+      }
+      if (estadoConf === "READY" && dConf.readySubstate === "PROMOTED") {
+        deployFinal = dConf;
+        break;
+      }
+      if (maxIntentos !== void 0 && intentos >= maxIntentos || transcurridoMs + intervaloMs > timeoutMs) {
+        return fallo(
+          `timeout esperando que el deploy ${deploymentId} quede PROMOTED (subestado: ${dConf.readySubstate ?? "sin subestado"})`
+        );
+      }
+      dormir(intervaloMs);
+      transcurridoMs += intervaloMs;
+    }
+  }
+  const alias = extraerAliasProduccion(deployFinal) ?? extraerAliasProduccion(deployListo);
+  const urlRaw = deployFinal.url ?? deployListo.url;
+  const url = urlRaw ? normalizarUrlHttps(urlRaw) : null;
+  return { ok: true, codigo: 0, deploymentId, alias, url };
+}
 
 // src/comandos/desplegar.ts
 var VARIABLES_VERCEL = [
@@ -722,9 +973,25 @@ var PASOS_VERCEL = [
   ["build", "--prod"],
   ["deploy", "--prebuilt", "--prod"]
 ];
+var PASO_DEPLOY_REMOTO = [
+  "deploy",
+  "--prod",
+  "--yes",
+  "--no-wait"
+];
+var ARCHIVO_ENV_PRODUCCION = path3__namespace.join(
+  ".vercel",
+  ".env.production.local"
+);
+var MARCADOR_SENSITIVE = "[SENSITIVE]";
+var REGEX_ANSI2 = new RegExp(
+  `${String.fromCharCode(27)}\\[[0-9;]*[a-zA-Z]`,
+  "g"
+);
 function leerArgumentosDesplegar(args) {
   let carpeta;
   let antes;
+  let urlSalud;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i] ?? "";
     if (arg === "--carpeta" || arg.startsWith("--carpeta=")) {
@@ -743,6 +1010,14 @@ function leerArgumentosDesplegar(args) {
       antes = valor.trim();
       continue;
     }
+    if (arg === "--url-salud" || arg.startsWith("--url-salud=")) {
+      const valor = arg === "--url-salud" ? args[++i] : arg.slice("--url-salud=".length);
+      if (!valor || valor.trim() === "" || valor.startsWith("-")) {
+        return { ok: false, motivo: "falta el valor de --url-salud <url>" };
+      }
+      urlSalud = valor.trim();
+      continue;
+    }
     return { ok: false, motivo: `argumento no reconocido: ${arg}` };
   }
   if (!carpeta) {
@@ -753,9 +1028,30 @@ function leerArgumentosDesplegar(args) {
   }
   return {
     ok: true,
-    valor: { carpeta, ...antes !== void 0 ? { antes } : {} }
+    valor: {
+      carpeta,
+      ...antes !== void 0 ? { antes } : {},
+      ...urlSalud !== void 0 ? { urlSalud } : {}
+    }
   };
 }
+function tieneVariablesSensibles(carpeta) {
+  const archivo = path3__namespace.join(carpeta, ARCHIVO_ENV_PRODUCCION);
+  return fs.existsSync(archivo) && fs.statSync(archivo).isFile() && fs.readFileSync(archivo, "utf8").includes(MARCADOR_SENSITIVE);
+}
+function extraerUrlSalud(salida, error = "") {
+  const stdout = salida.replace(REGEX_ANSI2, "");
+  const texto = `${error}
+${salida}`.replace(REGEX_ANSI2, "");
+  const alias = /\bAlias(?:ed)?\s*:\s*(https?:\/\/[^\s\]"')>]+)/i.exec(
+    texto
+  )?.[1];
+  const urlStdout = /^\s*(https?:\/\/[^\s\]"')>]+)/im.exec(stdout)?.[1];
+  const produccion = /\bProduction\s*:\s*(https?:\/\/[^\s\]"')>]+)/i.exec(
+    texto
+  )?.[1];
+  return (alias ?? urlStdout ?? produccion)?.replace(/[.,;]+$/, "") ?? null;
+}
 function redactarCredenciales(texto, env) {
   let limpio = texto;
   for (const nombre of VARIABLES_VERCEL) {
@@ -766,9 +1062,30 @@ function redactarCredenciales(texto, env) {
   }
   return limpio;
 }
+function correrPasoVercel(ej, paso, cwd, opciones) {
+  const r = ej("vercel", paso, { cwd, env: opciones.env });
+  if (r.salida.trim() !== "") {
+    opciones.salida(redactarCredenciales(r.salida.trimEnd(), opciones.env));
+  }
+  if (r.error.trim() !== "") {
+    opciones.error(redactarCredenciales(r.error.trimEnd(), opciones.env));
+  }
+  if (r.codigo !== 0) {
+    const codigo = r.codigo ?? 127;
+    opciones.error(
+      redactarCredenciales(
+        `wallavi-vercel desplegar: vercel ${paso.join(" ")} fall\xF3 (${r.fallo ?? `c\xF3digo ${codigo}`})`,
+        opciones.env
+      )
+    );
+    return { ok: false, codigo };
+  }
+  return { ok: true, resultado: r };
+}
 function ejecutarDesplegar(opciones) {
   const ej = opciones.ejecutar ?? ejecutar;
   const evaluar = opciones.evaluar ?? evaluarCambios;
+  const solicitar = opciones.solicitar ?? solicitarVercel;
   const rutaCarpeta = path3__namespace.resolve(opciones.cwd, opciones.carpeta);
   if (!fs.existsSync(rutaCarpeta) || !fs.statSync(rutaCarpeta).isDirectory()) {
     opciones.error(
@@ -795,27 +1112,93 @@ function ejecutarDesplegar(opciones) {
     );
     return 0;
   }
-  for (const paso of PASOS_VERCEL) {
-    const r = ej("vercel", paso, {
-      cwd: rutaCarpeta,
-      env: opciones.env
-    });
-    if (r.salida.trim() !== "") {
-      opciones.salida(redactarCredenciales(r.salida.trimEnd(), opciones.env));
+  const rPull = correrPasoVercel(ej, PASOS_VERCEL[0], rutaCarpeta, opciones);
+  if (!rPull.ok) return rPull.codigo;
+  const cwdResuelto = path3__namespace.resolve(opciones.cwd);
+  const raizGit = ubicarEnRepo(rutaCarpeta, ej)?.raiz ?? ubicarEnRepo(cwdResuelto, ej)?.raiz;
+  const carpetasEnv = [
+    ...new Set(
+      [rutaCarpeta, cwdResuelto, raizGit].filter(
+        (c) => Boolean(c)
+      )
+    )
+  ];
+  const carpetasSensibles = carpetasEnv.filter(tieneVariablesSensibles);
+  const haySensibles = carpetasSensibles.length > 0;
+  if (haySensibles) {
+    for (const dir of carpetasSensibles) {
+      fs.rmSync(path3__namespace.join(dir, ARCHIVO_ENV_PRODUCCION), { force: true });
     }
-    if (r.error.trim() !== "") {
-      opciones.error(redactarCredenciales(r.error.trimEnd(), opciones.env));
+    opciones.salida(
+      "wallavi-vercel desplegar: .vercel/.env.production.local contiene [SENSITIVE]; se omite --prebuilt y se delega a vercel deploy --prod --yes --no-wait"
+    );
+  }
+  const pasosRestantes = haySensibles ? [PASO_DEPLOY_REMOTO] : PASOS_VERCEL.slice(1);
+  let ultimoDeploy = rPull.resultado;
+  for (const paso of pasosRestantes) {
+    const r = correrPasoVercel(ej, paso, rutaCarpeta, opciones);
+    if (!r.ok) return r.codigo;
+    ultimoDeploy = r.resultado;
+  }
+  let aliasPromovido = null;
+  let urlDeployPromovido = null;
+  if (haySensibles) {
+    const promocion = esperarYPromoverDeploy({
+      cwd: opciones.cwd,
+      carpeta: rutaCarpeta,
+      env: opciones.env,
+      salidaDeploy: ultimoDeploy.salida,
+      errorDeploy: ultimoDeploy.error,
+      ejecutar: ej,
+      solicitar,
+      ...opciones.dormir !== void 0 ? { dormir: opciones.dormir } : {},
+      ...opciones.intervaloPollMs !== void 0 ? { intervaloMs: opciones.intervaloPollMs } : {},
+      ...opciones.timeoutPollMs !== void 0 ? { timeoutMs: opciones.timeoutPollMs } : {},
+      ...opciones.maxIntentosPoll !== void 0 ? { maxIntentos: opciones.maxIntentosPoll } : {},
+      ...opciones.baseUrl !== void 0 ? { baseUrl: opciones.baseUrl } : {}
+    });
+    if (!promocion.ok) {
+      opciones.error(
+        redactarCredenciales(
+          `wallavi-vercel desplegar: ${promocion.motivo}`,
+          opciones.env
+        )
+      );
+      return promocion.codigo;
     }
-    if (r.codigo !== 0) {
-      const codigo = r.codigo ?? 127;
+    aliasPromovido = promocion.alias;
+    urlDeployPromovido = promocion.url;
+  }
+  const urlSalud = opciones.urlSalud?.trim() || opciones.env.VERCEL_HEALTHCHECK_URL?.trim() || aliasPromovido || extraerUrlSalud(ultimoDeploy.salida, ultimoDeploy.error) || urlDeployPromovido;
+  if (!urlSalud) {
+    opciones.error(
+      redactarCredenciales(
+        "wallavi-vercel desplegar: healthcheck HTTP fall\xF3 (no se obtuvo URL del deploy)",
+        opciones.env
+      )
+    );
+    return 1;
+  }
+  try {
+    const respuesta = solicitar(urlSalud, {});
+    if (respuesta.estado >= 500 || respuesta.cuerpo.includes("MIDDLEWARE_INVOCATION_FAILED")) {
+      const detalle = respuesta.cuerpo.includes("MIDDLEWARE_INVOCATION_FAILED") ? `HTTP ${respuesta.estado} MIDDLEWARE_INVOCATION_FAILED` : `HTTP ${respuesta.estado}`;
       opciones.error(
         redactarCredenciales(
-          `wallavi-vercel desplegar: vercel ${paso.join(" ")} fall\xF3 (${r.fallo ?? `c\xF3digo ${codigo}`})`,
+          `wallavi-vercel desplegar: healthcheck HTTP fall\xF3 en ${urlSalud} (${detalle})`,
           opciones.env
         )
       );
-      return codigo;
+      return 1;
     }
+  } catch (e) {
+    opciones.error(
+      redactarCredenciales(
+        `wallavi-vercel desplegar: healthcheck HTTP fall\xF3 en ${urlSalud} (${e instanceof Error ? e.message : String(e)})`,
+        opciones.env
+      )
+    );
+    return 1;
   }
   opciones.salida(
     `wallavi-vercel desplegar: desplegado (${evaluacion.motivo})`
@@ -831,7 +1214,8 @@ function comandoDesplegar(args, entorno) {
   return ejecutarDesplegar({
     ...entorno,
     carpeta: leido.valor.carpeta,
-    ...leido.valor.antes !== void 0 ? { antes: leido.valor.antes } : {}
+    ...leido.valor.antes !== void 0 ? { antes: leido.valor.antes } : {},
+    ...leido.valor.urlSalud !== void 0 ? { urlSalud: leido.valor.urlSalud } : {}
   });
 }
 var desplegar = comandoDesplegar;
@@ -905,7 +1289,7 @@ var USO = `Uso: wallavi-vercel <comando> [opciones]
 
 Comandos:
   ignorar                                                                          decide si Vercel debe omitir el build
-  desplegar --carpeta <ruta> [--antes <sha>]                                       compila y despliega a producci\xF3n si hay cambios
+  desplegar --carpeta <ruta> [--antes <sha>] [--url-salud <url>]                  compila, despliega y verifica la salud HTTP
   medir --equipo <slug|team_id> --desde <AAAA-MM-DD> --hasta <AAAA-MM-DD> [...]    calcula los minutos de build por d\xEDa en UTC
   capturar --equipo <slug|team_id> --desde <AAAA-MM-DD> --hasta <AAAA-MM-DD> ...   descarga deployments de Vercel y escribe su captura
 
@@ -949,16 +1333,20 @@ exports.API_VERCEL_URL = API_VERCEL_URL;
 exports.ARCHIVO_CAPTURA_V6 = ARCHIVO_CAPTURA_V6;
 exports.ARCHIVO_CONFIG = ARCHIVO_CONFIG;
 exports.ARCHIVO_DEPLOYMENTS_V6 = ARCHIVO_DEPLOYMENTS_V6;
+exports.ARCHIVO_ENV_PRODUCCION = ARCHIVO_ENV_PRODUCCION;
 exports.COMANDOS = COMANDOS;
 exports.ESTADOS_DEPLOYMENT = ESTADOS_DEPLOYMENT;
 exports.ErrorContratoVercel = ErrorContratoVercel;
 exports.ErrorRedVercel = ErrorRedVercel;
+exports.INTERVALO_POLL_DEPLOY_MS = INTERVALO_POLL_DEPLOY_MS;
 exports.LIMITE_PAGINA_VERCEL = LIMITE_PAGINA_VERCEL;
 exports.MAX_PAGINAS_VERCEL = MAX_PAGINAS_VERCEL;
 exports.PASOS_VERCEL = PASOS_VERCEL;
+exports.PASO_DEPLOY_REMOTO = PASO_DEPLOY_REMOTO;
 exports.PREFIJO_PREVIEW = PREFIJO_PREVIEW;
 exports.RAMA_PRINCIPAL = RAMA_PRINCIPAL;
 exports.REFERENCIA_DEPLOYMENTS_V6 = REFERENCIA_DEPLOYMENTS_V6;
+exports.TIMEOUT_POLL_DEPLOY_MS = TIMEOUT_POLL_DEPLOY_MS;
 exports.USO = USO;
 exports.VARIABLES_VERCEL = VARIABLES_VERCEL;
 exports.armarCapturaV6 = armarCapturaV6;
@@ -972,22 +1360,29 @@ exports.comandoTurbo = comandoTurbo;
 exports.configVacia = configVacia;
 exports.consultarDeployments = consultarDeployments;
 exports.desplegar = desplegar;
+exports.dormirSincrono = dormirSincrono;
 exports.ejecutar = ejecutar;
 exports.ejecutarCapturar = ejecutarCapturar;
 exports.ejecutarDesplegar = ejecutarDesplegar;
 exports.ejecutarIgnorar = ejecutarIgnorar;
 exports.ejecutarMedir = ejecutarMedir;
+exports.esperarYPromoverDeploy = esperarYPromoverDeploy;
 exports.esquemaArchivoDeployments = esquemaArchivoDeployments;
 exports.esquemaCapturaV6 = esquemaCapturaV6;
 exports.esquemaConfig = esquemaConfig;
 exports.esquemaDeployment = esquemaDeployment;
+exports.esquemaDeploymentPromocion = esquemaDeploymentPromocion;
 exports.esquemaEquipo = esquemaEquipo;
 exports.esquemaEstadoDeployment = esquemaEstadoDeployment;
+exports.esquemaListaDeploymentsPromocion = esquemaListaDeploymentsPromocion;
 exports.esquemaPaginaDeployments = esquemaPaginaDeployments;
 exports.esquemaPaginaTeams = esquemaPaginaTeams;
 exports.esquemaPaginacion = esquemaPaginacion;
 exports.esquemaPedidoCaptura = esquemaPedidoCaptura;
 exports.evaluarCambios = evaluarCambios;
+exports.extraerAliasProduccion = extraerAliasProduccion;
+exports.extraerIdOUrlDeploy = extraerIdOUrlDeploy;
+exports.extraerUrlSalud = extraerUrlSalud;
 exports.ignorar = ignorar;
 exports.leerArgumentosCapturar = leerArgumentosCapturar;
 exports.leerArgumentosDesplegar = leerArgumentosDesplegar;
@@ -995,6 +1390,7 @@ exports.leerArgumentosMedir = leerArgumentosMedir;
 exports.leerConfig = leerConfig;
 exports.leerFlagsCli = leerFlagsCli;
 exports.leerRespuestaDeployments = leerRespuestaDeployments;
+exports.limpiarIdOUrlDeploy = limpiarIdOUrlDeploy;
 exports.medir = medir;
 exports.normalizarCarpeta = normalizarCarpeta;
 exports.paquetesDeTurbo = paquetesDeTurbo;
@@ -1006,6 +1402,7 @@ exports.rangoFechasUtc = rangoFechasUtc;
 exports.redactarToken = redactarToken;
 exports.resolverEquipo = resolverEquipo;
 exports.solicitarVercel = solicitarVercel;
+exports.tieneVariablesSensibles = tieneVariablesSensibles;
 exports.ubicarEnRepo = ubicarEnRepo;
 exports.validarConfig = validarConfig;
 exports.validarFechaIso = validarFechaIso;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wallavi/vercel-build",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "description": "Detección de cambios y despliegue compartidos para los proyectos de Vercel del monorepo",
   "license": "MIT",