@griddo/cx-render-mock 1.0.0

package/dist/index.mjs

@@ -0,0 +1,544 @@
+// src/core.ts
+var LIVE_STATUS = {
+  UNPUBLISHED: 1,
+  // isUnpublished / offline — estado final de despublicación
+  PENDING_PUBLISHING: 2,
+  // isPendingPublishing / upload-pending — transitorio
+  LIVE: 3,
+  // isLiveStatus / active — estado final de publicación
+  PENDING_UNPUBLISHING: 4
+  // isPendingUnpublishing / offline-pending — transitorio
+};
+var DEFAULT_TIMINGS = {
+  settleMs: 45e3,
+  settlePollMs: 3e3,
+  maxRounds: 3,
+  roundWaitMs: 1500,
+  buildStartMaxWaits: 15,
+  buildStartRetryWaitMs: 2e3
+};
+var DEFAULT_PAGE_LIST_QUERY = { page: 1, itemsPerPage: 300 };
+var listPageUrl = (apiUrl, siteId, query = DEFAULT_PAGE_LIST_QUERY) => `${apiUrl}site/${siteId}/pages?deleted=false&page=${query.page}&itemsPerPage=${query.itemsPerPage}&format=list`;
+var pageListSignature = (items) => (items || []).filter((p) => p && p.id != null).map((p) => `${p.id}:${p.liveStatus?.id ?? ""}:${p.hash ?? ""}`).sort().join("|");
+var decideSettleStep = (prevSignature, signature, elapsedMs, timings = DEFAULT_TIMINGS) => {
+  if (elapsedMs >= timings.settleMs) return { action: "go" };
+  if (prevSignature !== null && prevSignature === signature) return { action: "go" };
+  return { action: "wait", waitMs: Math.min(timings.settlePollMs, timings.settleMs - elapsedMs) };
+};
+var classifyPage = (hash, status) => {
+  if (hash != null) return "publish";
+  if (status === LIVE_STATUS.PENDING_PUBLISHING) return "needsHash";
+  return "skip";
+};
+var diffMissingByTitle = (items, wanted, expectedStatus) => {
+  const w = wanted || [];
+  if (w.length === 0) return [];
+  const statusByTitle = {};
+  items.forEach((p) => {
+    if (p && p.title != null && w.includes(p.title)) {
+      const st = p.liveStatus?.id;
+      if (st === expectedStatus || !(p.title in statusByTitle)) statusByTitle[p.title] = st ?? -1;
+    }
+  });
+  return w.filter((t) => statusByTitle[t] !== expectedStatus);
+};
+var buildEndBody = (publishHashes, siteHash, unpublishHashes, publishPagesIds) => ({
+  publishHashes,
+  siteHash: siteHash ?? null,
+  unpublishHashes,
+  publishPagesIds
+});
+var collectRepublishIds = (items, missing) => {
+  const ids = [];
+  items.forEach((p) => {
+    const st = p?.liveStatus?.id;
+    if (p && p.id != null && missing.includes(p.title) && st !== LIVE_STATUS.LIVE)
+      ids.push(p.id);
+  });
+  return Array.from(new Set(ids));
+};
+var decideBuildStartStep = (status, startWaits, timings = DEFAULT_TIMINGS) => {
+  if (status < 400) return { action: "proceed" };
+  if (startWaits >= timings.buildStartMaxWaits) return { action: "fail" };
+  return { action: "retry", waitMs: timings.buildStartRetryWaitMs };
+};
+var selectPendingSites = (sites, onlyIds) => {
+  const ids = [];
+  (sites || []).forEach((site) => {
+    if (!site || site.id == null || !site.shouldBeUpdated) return;
+    if (onlyIds && !onlyIds.includes(site.id)) return;
+    ids.push(site.id);
+  });
+  return Array.from(new Set(ids));
+};
+
+// src/errors.ts
+var RENDER_ERROR_CODE = {
+  /** `build/start` siguió respondiendo error hasta agotar los reintentos: el site no llega a estar listo. */
+  BUILD_START_NOT_READY: "BUILD_START_NOT_READY",
+  /** `build/end` respondió >= 400: el render no se ha aplicado y el bloqueo puede seguir puesto. */
+  BUILD_END_FAILED: "BUILD_END_FAILED",
+  /** Se agotaron las rondas y algunos títulos no alcanzaron el estado final. Mira `missingTitles`. */
+  TITLES_NOT_FINAL: "TITLES_NOT_FINAL",
+  /** No se pudo saber qué sites tenían render pendiente. */
+  SITES_LOOKUP_FAILED: "SITES_LOOKUP_FAILED",
+  /** No se pudo leer el listado de páginas de un site. */
+  PAGE_LIST_FAILED: "PAGE_LIST_FAILED",
+  /** Falló marcar páginas como pendientes de publicar. */
+  MARK_PENDING_FAILED: "MARK_PENDING_FAILED",
+  /** Falló publicar un site. */
+  PUBLISH_FAILED: "PUBLISH_FAILED"
+};
+var RenderError = class extends Error {
+  constructor(code, message, detail = {}) {
+    super(message);
+    this.name = "RenderError";
+    this.code = code;
+    this.status = detail.status;
+    this.body = detail.body;
+    this.missingTitles = detail.missingTitles;
+    if (detail.cause !== void 0) this.cause = detail.cause;
+  }
+};
+
+// src/logger.ts
+var NOOP_LOGGER = {
+  debug: () => void 0,
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+var createConsoleLogger = (level = "info") => {
+  const order = { debug: 10, info: 20, warn: 30, error: 40 };
+  const min = order[level];
+  const emit = (method) => (message, meta) => {
+    if (order[method] < min) return;
+    if (meta === void 0) console[method](message);
+    else console[method](message, meta);
+  };
+  return { debug: emit("debug"), info: emit("info"), warn: emit("warn"), error: emit("error") };
+};
+
+// src/api-client.ts
+var ApiClient = class {
+  constructor(config) {
+    this.transport = config.transport;
+    this.apiUrl = config.apiUrl;
+    this.headers = {
+      "Content-Type": "application/json",
+      authorization: `Bearer ${config.authToken}`
+    };
+    this.logger = config.logger ?? NOOP_LOGGER;
+  }
+  /** URL absoluta de un path relativo a `apiUrl`. Útil cuando la URL la compone el núcleo. */
+  url(path) {
+    return `${this.apiUrl}${path}`;
+  }
+  get(path, spec = {}) {
+    return this.send("GET", path, spec);
+  }
+  post(path, spec = {}) {
+    return this.send("POST", path, spec);
+  }
+  put(path, spec = {}) {
+    return this.send("PUT", path, spec);
+  }
+  /**
+   * Lanza si la respuesta trae error. Se usa cuando la llamada ya se hizo sin `expectOk` porque había que
+   * inspeccionar el status antes de decidir.
+   */
+  ensureOk(res, code, describe) {
+    if (res.status < 400) return;
+    throw new RenderError(code, `${describe} respondi\xF3 ${res.status}`, {
+      status: res.status,
+      body: res.body
+    });
+  }
+  async send(method, path, spec) {
+    const url = path.startsWith("http") ? path : this.url(path);
+    const opts = { headers: this.headers, body: spec.body };
+    const res = await (method === "GET" ? this.transport.get(url, opts) : method === "POST" ? this.transport.post(url, opts) : this.transport.put(url, opts));
+    if (spec.expectOk) this.ensureOk(res, spec.expectOk, `${method} ${path}`);
+    return res;
+  }
+};
+
+// src/sleep.ts
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/engine.ts
+var CxRenderEngine = class {
+  constructor(deps) {
+    this.api = new ApiClient(deps);
+    this.logger = this.api.logger;
+    this.sleep = deps.sleep ?? defaultSleep;
+    this.timings = { ...DEFAULT_TIMINGS, ...deps.timings };
+    this.pageList = { ...DEFAULT_PAGE_LIST_QUERY, ...deps.pageList };
+  }
+  /**
+   * Renderiza un site en **una sola pasada**: settle adaptativo → `build/start` → `GET page/{id}` →
+   * `build/end`.
+   *
+   * El settle previo da tiempo a que el backend termine de propagar las copias de las páginas globales; sin él,
+   * `build/start` devolvería una lista incompleta. Es ADAPTATIVO: sondea el listado hasta que dos sondas
+   * consecutivas coinciden (quiescencia) o hasta el techo `timings.settleMs` — rápido cuando el backend va
+   * suelto, paciente bajo carga. Las páginas que lleguen tarde no se reintentan aquí: de eso se encarga
+   * {@link renderUntilLive}.
+   *
+   * ⚠️ `build/start` deja el site bloqueado y `build/end` lo libera. En el camino normal `build/end` se emite
+   * siempre, pero si el transporte rechaza entre ambos el bloqueo queda colgado durante horas: llama a
+   * {@link releaseRenderLock} en tu `finally`.
+   *
+   * @throws {RenderError} `BUILD_START_NOT_READY` si el site no llega a estar listo, `BUILD_END_FAILED` si el
+   * render no se aplica.
+   */
+  async renderSiteOnce(siteId) {
+    const startOnce = async (startWaits = 0) => {
+      const bs = await this.api.get(`site/${siteId}/build/start`);
+      const startStep = decideBuildStartStep(bs.status, startWaits, this.timings);
+      if (startStep.action === "fail") {
+        throw new RenderError(
+          RENDER_ERROR_CODE.BUILD_START_NOT_READY,
+          `GET site/${siteId}/build/start sigue en ${bs.status} tras ${startWaits} esperas (\xBFel site no acaba de asentarse?)`,
+          { status: bs.status, body: bs.body }
+        );
+      }
+      if (startStep.action === "retry") {
+        this.logger.debug(
+          `build/start del site ${siteId} en ${bs.status}: espera ${startStep.waitMs}ms y reintenta`
+        );
+        await this.sleep(startStep.waitMs);
+        return startOnce(startWaits + 1);
+      }
+      const siteHash = bs.body?.siteHash || null;
+      const publishIds = bs.body?.publishIds || [];
+      const unpublishHashes = bs.body?.unpublishHashes || [];
+      this.logger.debug(
+        `site ${siteId}: ${publishIds.length} p\xE1ginas candidatas, ${unpublishHashes.length} a despublicar`
+      );
+      const publishHashes = [];
+      const publishPagesIds = [];
+      for (const pageId of publishIds) {
+        const pres = await this.api.get(`page/${pageId}`);
+        const hash = pres.body?.hash;
+        const status = pres.body?.liveStatus?.id;
+        if (classifyPage(hash, status) === "publish") {
+          publishHashes.push(hash);
+          publishPagesIds.push(pageId);
+        }
+      }
+      await this.api.post(`site/${siteId}/build/end`, {
+        body: buildEndBody(publishHashes, siteHash, unpublishHashes, publishPagesIds),
+        expectOk: RENDER_ERROR_CODE.BUILD_END_FAILED
+      });
+      this.logger.info(`site ${siteId} renderizado: ${publishPagesIds.length} p\xE1ginas publicadas`);
+    };
+    await this.settleBeforeStart(siteId);
+    return startOnce();
+  }
+  /**
+   * Settle ADAPTATIVO previo al build/start: sondea el listado del site cada `timings.settlePollMs` y arranca
+   * cuando dos sondas consecutivas devuelven la misma firma (`cxCore.pageListSignature`) o al agotar el techo
+   * `timings.settleMs` (la decisión es de `cxCore.decideSettleStep`). Best-effort: si el listado falla durante
+   * el settle, se procede al render en vez de morir aquí (peor caso = el de siempre, un pase incompleto que
+   * recogen las rondas de `renderUntilLive`). Con `settleMs <= 0` no sondea (settle desactivado).
+   */
+  async settleBeforeStart(siteId) {
+    if (this.timings.settleMs <= 0) return;
+    try {
+      let prev = null;
+      let elapsed = 0;
+      for (; ; ) {
+        const sig = pageListSignature(await this.listPages([siteId]));
+        const step = decideSettleStep(prev, sig, elapsed, this.timings);
+        if (step.action === "go") return;
+        prev = sig;
+        await this.sleep(step.waitMs);
+        elapsed += step.waitMs;
+      }
+    } catch (err) {
+      this.logger.warn(
+        `settle del site ${siteId}: el sondeo del listado fall\xF3 (${err instanceof Error ? err.message : String(err)}); se procede al render sin asentar`
+      );
+    }
+  }
+  /**
+   * Renderiza **todos los sites que tengan render pendiente**, que es lo que hace el render real en cada pasada:
+   * pregunta al backend qué sites tienen cambios sin renderizar (`GET sites/all` → `shouldBeUpdated`) y los
+   * resuelve uno por uno.
+   *
+   * @param onlyIds acota a esos sites. **Úsalo si compartes la base de datos con otros procesos**: sin acotar,
+   * esta pasada arrastra también el trabajo pendiente de los demás, que es tan lento como caro.
+   * @returns los ids que ha renderizado.
+   * @throws {RenderError} `SITES_LOOKUP_FAILED` si no se puede consultar la lista de sites.
+   */
+  async renderPendingSites(onlyIds) {
+    const res = await this.api.get("sites/all", {
+      expectOk: RENDER_ERROR_CODE.SITES_LOOKUP_FAILED
+    });
+    const all = Array.isArray(res.body) ? res.body : res.body?.items || [];
+    const pending = selectPendingSites(all, onlyIds);
+    this.logger.info(
+      pending.length > 0 ? `sites con render pendiente: ${pending.join(", ")}` : "ning\xFAn site con render pendiente"
+    );
+    for (const siteId of pending) await this.renderSiteOnce(siteId);
+    return pending;
+  }
+  /**
+   * Lleva los títulos pedidos a su estado final, reintentando lo que falte.
+   *
+   * Mientras queden títulos pendientes, vuelve a marcar como pendientes las copias que se hayan quedado
+   * despublicadas y renderiza otra vez, hasta `timings.maxRounds` rondas; la última confirma o lanza. Si todo
+   * está ya en su sitio, la primera comprobación pasa y no renderiza nada.
+   *
+   * @param expectedStatus estado final esperado. Por defecto `LIVE_STATUS.LIVE`; usa `LIVE_STATUS.UNPUBLISHED`
+   * para confirmar una despublicación.
+   * @throws {RenderError} `TITLES_NOT_FINAL` si tras la última ronda sigue faltando algún título.
+   */
+  async renderUntilLive(siteIds, titles, expectedStatus = LIVE_STATUS.LIVE) {
+    const wanted = titles || [];
+    if (wanted.length === 0) return;
+    const attempt = async (round) => {
+      const missing = await this.missingPagesByTitle(siteIds, wanted, expectedStatus);
+      if (missing.length === 0) return;
+      if (round >= this.timings.maxRounds)
+        return this.confirmPagesByTitle(siteIds, wanted, expectedStatus);
+      this.logger.warn(
+        `ronda ${round}/${this.timings.maxRounds}: faltan ${missing.length}/${wanted.length} t\xEDtulos (${missing.join(", ")})`
+      );
+      await this.republishMissingWantedLive(siteIds, missing, expectedStatus);
+      for (const siteId of siteIds) await this.renderSiteOnce(siteId);
+      await this.sleep(this.timings.roundWaitMs);
+      return attempt(round + 1);
+    };
+    return attempt(1);
+  }
+  /**
+   * Comprueba, sin renderizar, que los títulos están en `expectedStatus`.
+   *
+   * @throws {RenderError} `TITLES_NOT_FINAL`, con los títulos que faltan en `missingTitles`.
+   */
+  async confirmPagesByTitle(siteIds, titles, expectedStatus = LIVE_STATUS.LIVE) {
+    const wanted = titles || [];
+    if (wanted.length === 0) return;
+    const missing = await this.missingPagesByTitle(siteIds, wanted, expectedStatus);
+    if (missing.length > 0) {
+      throw new RenderError(
+        RENDER_ERROR_CODE.TITLES_NOT_FINAL,
+        `estos t\xEDtulos no est\xE1n en liveStatus ${expectedStatus}: ${missing.join(", ")}`,
+        {
+          missingTitles: missing
+        }
+      );
+    }
+  }
+  /**
+   * Libera el bloqueo de render que deja `build/start`, emitiendo un `build/end` vacío.
+   *
+   * Llámalo en tu `finally` si un render puede abortar a medias. Es best-effort: no lanza aunque el backend
+   * responda con error, porque el caso normal es que ya no hubiera nada que liberar.
+   */
+  async releaseRenderLock(siteId) {
+    const res = await this.api.post(`site/${siteId}/build/end`, {
+      body: buildEndBody([], null, [], [])
+    });
+    if (res.status >= 400) {
+      this.logger.debug(
+        `releaseRenderLock del site ${siteId}: el backend respondi\xF3 ${res.status} (probablemente no hab\xEDa bloqueo)`
+      );
+    }
+  }
+  /** Títulos que aún no están en `expectedStatus`, leyendo el listado completo de cada site. */
+  async missingPagesByTitle(siteIds, titles, expectedStatus) {
+    const wanted = titles || [];
+    if (wanted.length === 0) return [];
+    const items = await this.listPages(siteIds);
+    return diffMissingByTitle(items, wanted, expectedStatus);
+  }
+  /** Devuelve a "pendiente de publicar" las copias despublicadas de los títulos que faltan. */
+  async republishMissingWantedLive(siteIds, missing, expectedStatus) {
+    if (expectedStatus !== LIVE_STATUS.LIVE || missing.length === 0) return;
+    const items = await this.listPages(siteIds);
+    const uniqueIds = collectRepublishIds(items, missing);
+    if (uniqueIds.length === 0) return;
+    this.logger.info(`re-marcando ${uniqueIds.length} p\xE1ginas como pendientes de publicar`);
+    await this.api.put("pages/status/upload-pending", { body: { ids: uniqueIds } });
+  }
+  /**
+   * Páginas de los sites indicados, **paginando hasta el final** del listado.
+   *
+   * Recorre páginas mientras el backend devuelva el lote completo: si llega uno más corto, es el último. Así un
+   * site con más páginas que `pageList.itemsPerPage` no se queda a medias, que era la causa de confirmaciones
+   * por título erróneas cuando solo se leía la primera página.
+   *
+   * @throws {RenderError} `PAGE_LIST_FAILED` si el backend no puede devolver el listado.
+   */
+  async listPages(siteIds) {
+    const items = [];
+    for (const siteId of siteIds) {
+      let page = this.pageList.page;
+      for (let fetched = 0; fetched < MAX_LIST_PAGES; fetched++) {
+        const query = { page, itemsPerPage: this.pageList.itemsPerPage };
+        const res = await this.api.get(listPageUrl(this.api.url(""), siteId, query), {
+          expectOk: RENDER_ERROR_CODE.PAGE_LIST_FAILED
+        });
+        const batch = res.body && (res.body.items || res.body) || [];
+        items.push(...batch);
+        if (batch.length < this.pageList.itemsPerPage) break;
+        page += 1;
+        if (fetched === MAX_LIST_PAGES - 1) {
+          this.logger.warn(
+            `listado del site ${siteId} cortado en ${MAX_LIST_PAGES} p\xE1ginas: \xBFel backend ignora el par\xE1metro page?`
+          );
+        }
+      }
+    }
+    return items;
+  }
+};
+var MAX_LIST_PAGES = 1e3;
+
+// src/publish.ts
+var CmsPublisher = class {
+  constructor(deps) {
+    this.api = new ApiClient(deps);
+    this.logger = this.api.logger;
+  }
+  /**
+   * Marca páginas como pendientes de publicar. Sin ids no hace nada.
+   *
+   * @throws {RenderError} `MARK_PENDING_FAILED` si el backend responde >= 400.
+   */
+  async markPagesPending(pageIds) {
+    if (!pageIds || pageIds.length === 0) return;
+    await this.api.put("pages/status/upload-pending", {
+      body: { ids: pageIds },
+      expectOk: RENDER_ERROR_CODE.MARK_PENDING_FAILED
+    });
+    this.logger.info(`${pageIds.length} p\xE1ginas marcadas como pendientes de publicar`);
+  }
+  /**
+   * Publica los sites indicados, uno por uno.
+   *
+   * @throws {RenderError} `PUBLISH_FAILED` si el backend responde >= 400 para alguno.
+   */
+  async publishSites(siteIds) {
+    for (const siteId of siteIds || []) {
+      await this.api.post(`site/${siteId}/publish`, { expectOk: RENDER_ERROR_CODE.PUBLISH_FAILED });
+      this.logger.info(`site ${siteId} publicado`);
+    }
+  }
+  /**
+   * Los dos pasos en orden: marca las páginas y publica los sites. Es el disparo completo que deja el trabajo
+   * listo para que el motor lo renderice.
+   */
+  async publishPages(siteIds, pageIds) {
+    await this.markPagesPending(pageIds);
+    await this.publishSites(siteIds);
+  }
+};
+
+// src/facade.ts
+var CxRenderMock = class {
+  constructor(deps) {
+    this.engine = new CxRenderEngine(deps);
+    this.publisher = new CmsPublisher(deps);
+  }
+  /**
+   * El flujo entero: publica, renderiza y confirma que los títulos llegaron a su estado final. Libera el bloqueo
+   * de render de cada site si algo falla a medias.
+   *
+   * @param expectedStatus estado final esperado. Por defecto `LIVE_STATUS.LIVE`.
+   * @throws {RenderError} con el `code` de la etapa que falló.
+   */
+  async publishAndRender(siteIds, pageIds, titles, expectedStatus = LIVE_STATUS.LIVE) {
+    await this.publisher.publishPages(siteIds, pageIds);
+    try {
+      await this.engine.renderUntilLive(siteIds, titles, expectedStatus);
+    } catch (error) {
+      for (const siteId of siteIds) await this.engine.releaseRenderLock(siteId);
+      throw error;
+    }
+  }
+};
+
+// src/transport.ts
+var withRetry = (transport, opts = {}) => {
+  const attempts = opts.attempts ?? 3;
+  const delayMs = opts.delayMs ?? 500;
+  const methods = opts.methods ?? ["get"];
+  const shouldRetry = opts.shouldRetry ?? ((res) => res.status >= 500);
+  const sleep = opts.sleep ?? defaultSleep;
+  const logger = opts.logger ?? NOOP_LOGGER;
+  const run = async (method, url, reqOpts) => {
+    if (!methods.includes(method)) return transport[method](url, reqOpts);
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      try {
+        const res = await transport[method](url, reqOpts);
+        if (attempt === attempts || !shouldRetry(res)) return res;
+        logger.warn(
+          `retry ${method.toUpperCase()} ${url}: status ${res.status}, intento ${attempt}/${attempts}`
+        );
+      } catch (error) {
+        lastError = error;
+        if (attempt === attempts) throw error;
+        logger.warn(
+          `retry ${method.toUpperCase()} ${url}: el transporte fall\xF3, intento ${attempt}/${attempts}`,
+          error
+        );
+      }
+      await sleep(delayMs * attempt);
+    }
+    throw lastError ?? new Error(`withRetry: ning\xFAn intento ejecutado para ${method.toUpperCase()} ${url}`);
+  };
+  return {
+    get: (url, reqOpts) => run("get", url, reqOpts),
+    post: (url, reqOpts) => run("post", url, reqOpts),
+    put: (url, reqOpts) => run("put", url, reqOpts)
+  };
+};
+var withTimeout = (transport, opts) => {
+  const logger = opts.logger ?? NOOP_LOGGER;
+  const race = (method, url, reqOpts) => {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        logger.warn(`timeout ${method.toUpperCase()} ${url}: sin respuesta en ${opts.ms}ms`);
+        reject(new Error(`Timeout de ${opts.ms}ms en ${method.toUpperCase()} ${url}`));
+      }, opts.ms);
+    });
+    return Promise.race([transport[method](url, reqOpts), timeout]).finally(
+      () => clearTimeout(timer)
+    );
+  };
+  return {
+    get: (url, reqOpts) => race("get", url, reqOpts),
+    post: (url, reqOpts) => race("post", url, reqOpts),
+    put: (url, reqOpts) => race("put", url, reqOpts)
+  };
+};
+export {
+  CmsPublisher,
+  CxRenderEngine,
+  CxRenderMock,
+  DEFAULT_PAGE_LIST_QUERY,
+  DEFAULT_TIMINGS,
+  LIVE_STATUS,
+  NOOP_LOGGER,
+  RENDER_ERROR_CODE,
+  RenderError,
+  buildEndBody,
+  classifyPage,
+  collectRepublishIds,
+  createConsoleLogger,
+  decideBuildStartStep,
+  decideSettleStep,
+  diffMissingByTitle,
+  listPageUrl,
+  pageListSignature,
+  selectPendingSites,
+  withRetry,
+  withTimeout
+};
+//# sourceMappingURL=index.mjs.map