@griddo/cx 11.9.7 → 11.9.8-rc.0

package/exporter/ssg-adapters/gatsby/index.ts

@@ -0,0 +1,114 @@
+import type { SSG } from "./shared/types";
+
+import path from "node:path";
+
+import { readDB, writeDB } from "../../core/db";
+import { pathExists } from "../../core/fs";
+import { GriddoLog } from "../../core/GriddoLog";
+import { doLifeCycle } from "../../core/life-cycle";
+import { initializeLogFile } from "../../core/logger";
+import {
+	getRenderMetadataFromDB,
+	getRenderModeFromDB,
+	getRenderPathsHydratedWithDomainFromDB,
+} from "../../services/render";
+import { getRenderArtifacts } from "../../services/render-artifacts";
+import { RenderContext } from "../../shared/context";
+import { GRIDDO_ASSET_PREFIX, GRIDDO_BUILD_LOGS } from "../../shared/envs";
+import { RENDER_MODE } from "../../shared/types/render";
+import { cleanAction } from "./actions/clean";
+import { closeAction } from "./actions/close";
+import { dataAction } from "./actions/data";
+import { healthCheckAction } from "./actions/healthCheck";
+import { initAction } from "./actions/init";
+import { logsAction } from "./actions/logs";
+import { metaAction } from "./actions/meta";
+import { prepareAction } from "./actions/prepare";
+import { relocationAction } from "./actions/relocation";
+import { restoreAction } from "./actions/restore";
+import { ssgAction } from "./actions/ssg";
+import { syncAction } from "./actions/sync";
+import { getGatsbyArtifacts } from "./shared/artifacts";
+import { disableRollbackOnError, enableRollbackOnError } from "./shared/utils";
+
+const FILE_LOGS_ENABLED = GRIDDO_BUILD_LOGS; //  && GRIDDO_BUILD_LOGS_TO_FILE;
+
+/**
+ * Executes a complete Gatsby render process for a given domain.
+ *
+ * The render process consists of multiple lifecycle steps that handle cleaning,
+ * preparing, building and syncing the site. It can run in two modes:
+ * - FROM_SCRATCH: Performs a complete rebuild of the domains sites.
+ * - INCREMENTAL: Only rebuilds changed pages while preserving the rest.
+ */
+export async function gatsbyRenderDomain(domain: string) {
+	// Init render log
+	await initializeLogFile();
+
+	// Render data
+	const { renderMode, reason } = await getRenderModeFromDB(domain);
+	const renderMetadata = await getRenderMetadataFromDB();
+	const pathsHydratedWithDomain = await getRenderPathsHydratedWithDomainFromDB({ domain });
+	const { __ssg } = pathsHydratedWithDomain;
+
+	// Artifacts
+	const renderArtifacts = await getRenderArtifacts(domain);
+	const ssgArtifacts = await getGatsbyArtifacts(domain);
+
+	// SSG Gatsby assetPrefix
+	const assetPrefix = GRIDDO_ASSET_PREFIX ? `${GRIDDO_ASSET_PREFIX}/${domain}` : "";
+
+	// Previous render error management
+	const domainSentinelFile = await pathExists(path.join(__ssg, `.render-sentinel-${domain}`));
+	const derivedRenderMode = domainSentinelFile ? RENDER_MODE.FROM_SCRATCH : renderMode;
+	const derivedRenderModeReason = domainSentinelFile ? "previous render error" : reason;
+
+	const data = await readDB();
+	data.domains[domain].renderMode = derivedRenderMode;
+	data.domains[domain].renderModeReason = derivedRenderModeReason;
+	data.domains[domain].isRendering = false;
+
+	if (renderMode === RENDER_MODE.IDLE && derivedRenderMode === RENDER_MODE.IDLE) {
+		GriddoLog.info(
+			`(From Current Render) [${domain}]: Skipping start-render as it is marked as IDLE with the reason ${reason}.`,
+		);
+		return;
+	}
+
+	data.domains[domain].isRendering = true;
+	data.currentRenderingDomain = domain;
+	await writeDB(data);
+
+	// Render mode reason to log information to the terminal
+	const renderModeReason = derivedRenderModeReason ? ` <${derivedRenderModeReason}>` : "";
+	GriddoLog.info(`Init render (${derivedRenderMode})${renderModeReason} for domain ${domain}\n`);
+
+	// Render context
+	const context = new RenderContext<SSG>({
+		domain,
+		pathsHydratedWithDomain,
+		renderArtifacts,
+		renderMetadata,
+		renderMode: derivedRenderMode,
+		ssg: { assetPrefix, ssgArtifacts },
+	});
+
+	// A las actions se les pasa siempre `context` y cada action ya utiliza lo que necesita.
+	// Si una action necesita devolver algo para otra, se guarda en el context.
+	// Ejemplo: el dataAction obtiene los ids de páginas para renderizar y
+	// borrar y los guarda en context.pathsToRender y context.pathsToDelete.
+	await doLifeCycle("Init", async () => initAction(context));
+	await doLifeCycle("Clean", async () => cleanAction(context));
+	await doLifeCycle("Prepare", async () => prepareAction(context));
+	await doLifeCycle("Restore", async () => restoreAction(context));
+	await enableRollbackOnError();
+	await doLifeCycle("Data", async () => dataAction(context));
+	await doLifeCycle("SSG", async () => ssgAction(context));
+	await doLifeCycle("Relocation", async () => relocationAction(context));
+	await doLifeCycle("Meta", async () => metaAction(context));
+	await doLifeCycle("Sync", async () => syncAction(context));
+	await doLifeCycle("HealthCheck", async () => healthCheckAction(context));
+	await doLifeCycle("Logs", async () => logsAction(context), { skip: !FILE_LOGS_ENABLED ? "Build logs to file are disabled" : false }); // biome-ignore format: oneliner
+	await doLifeCycle("Close", async () => closeAction(context));
+	await disableRollbackOnError();
+}

package/exporter/ssg-adapters/gatsby/shared/artifacts.ts

@@ -0,0 +1,16 @@
+import path from "node:path";
+
+import { getRenderPathsHydratedWithDomainFromDB } from "../../../services/render";
+
+export async function getGatsbyArtifacts(domain: string) {
+	const { __ssg } = await getRenderPathsHydratedWithDomainFromDB({ domain });
+
+	return {
+		disposables: [
+			path.join(__ssg, "public"),
+			path.join(__ssg, "static"),
+			path.join(__ssg, ".cache"),
+		],
+		cacheables: [".cache"],
+	};
+}

package/exporter/ssg-adapters/gatsby/shared/diff-assets.ts

@@ -0,0 +1,128 @@
+import { createHash } from "node:crypto";
+import fsp from "node:fs/promises";
+import { join } from "node:path";
+
+import { GriddoLog } from "../../../core/GriddoLog";
+
+/**
+ * Patrones de archivos de assets críticos para la comparación de builds.
+ * Estos archivos son los que realmente afectan el webpackCompilationHash:
+ * - app-*.js: Código principal de la aplicación
+ * - framework-*.js: Framework de Gatsby/React
+ * - webpack-runtime-*.js: Runtime de webpack
+ *
+ * Si estos archivos no cambian entre renders, el hash debería ser el mismo.
+ */
+const _KEY_ASSET_PATTERNS = [/^app-.*\.js$/, /^framework-.*\.js$/, /^webpack-runtime-.*\.js$/];
+
+const KEY_ASSET_PATTERNS = [/\.js$/];
+
+/**
+ * Calcula los hashes SHA256 del contenido de los assets clave en un directorio.
+ * Solo procesa archivos que coincidan con KEY_ASSET_PATTERNS.
+ *
+ * @param dir La ruta al directorio (ej. './public')
+ * @returns Un Map donde la clave es el nombre del fichero y el valor es su hash.
+ *          Si el directorio no existe o hay errores, retorna un Map vacío.
+ */
+async function getAssetHashes(dir: string): Promise<Map<string, string>> {
+	const assetHashes = new Map<string, string>();
+
+	try {
+		const allFiles = await fsp.readdir(dir);
+		const keyAssetFiles = allFiles.filter((fileName) =>
+			KEY_ASSET_PATTERNS.some((pattern) => pattern.test(fileName)),
+		);
+
+		for (const fileName of keyAssetFiles) {
+			const filePath = join(dir, fileName);
+			const fileContent = await fsp.readFile(filePath);
+			const hash = createHash("sha256").update(fileContent).digest("hex");
+			assetHashes.set(fileName, hash);
+		}
+
+		return assetHashes;
+	} catch (error) {
+		GriddoLog.build(`ERROR: Error processing directory ${dir}: ${error}`);
+		// Si un directorio no existe (ej. el de producción la primera vez),
+		// lo tratamos como si no tuviera assets.
+		return assetHashes;
+	}
+}
+
+/**
+ * Compara los assets clave entre dos directorios de build de Gatsby.
+ * Solo compara los archivos definidos en KEY_ASSET_PATTERNS.
+ *
+ * @param dir1 Ruta al primer directorio (ej. el de producción)
+ * @param dir2 Ruta al segundo directorio (ej. el del nuevo build)
+ * @returns `true` si hay diferencias en los assets clave, `false` si son idénticos.
+ */
+export async function getAssetsDiffBetweenRenders(dir1: string, dir2: string): Promise<boolean> {
+	const [hashes1, hashes2] = await Promise.all([getAssetHashes(dir1), getAssetHashes(dir2)]);
+
+	// Si el número de assets clave es diferente, hay cambios.
+	if (hashes1.size !== hashes2.size) {
+		return true;
+	}
+
+	// Comparamos los hashes de cada fichero.
+	for (const [fileName, hash1] of hashes1.entries()) {
+		const hash2 = hashes2.get(fileName);
+
+		// Si un fichero existe en el primero pero no en el segundo, hay cambios.
+		if (!hash2) {
+			return true;
+		}
+
+		// Si el contenido (hash) de un fichero ha cambiado.
+		if (hash1 !== hash2) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Actualiza el webpackCompilationHash en un único fichero HTML.
+ * @param filePath Ruta al fichero HTML.
+ * @param newHash El nuevo hash a insertar.
+ */
+export async function patchHtmlFile(filePath: string, newHash: string): Promise<void> {
+	try {
+		const content = await fsp.readFile(filePath, "utf-8");
+
+		// Esta expresión regular captura tres grupos:
+		// 1. La parte ANTES del hash (window.___webpackCompilationHash=")
+		// 2. El hash ANTIGUO ([^"]*)
+		// 3. La parte DESPUÉS del hash (";</script>)
+		const regex = /(window\.___webpackCompilationHash=")([^"]*)(";<\/script>)/;
+
+		// Solo reemplazamos el segundo grupo (el hash)
+		const newContent = content.replace(regex, `$1${newHash}$3`);
+
+		if (content === newContent) {
+			// GriddoLog.warn(`WARN: No se encontró el hash en ${filePath}. El fichero no fue modificado.`);
+			return;
+		}
+
+		await fsp.writeFile(filePath, newContent, "utf-8");
+	} catch (error) {
+		GriddoLog.error(`Failed to process file ${filePath}: ${error}`);
+	}
+}
+
+// --- Ejemplo de uso ---
+// async function miScriptDeDeploy() {
+//   const dirProduccion = '/ruta/a/produccion/public';
+//   const dirNuevoBuild = './public';
+
+//   const hayDiferencias = await getAssetsDiffBetweenRenders(dirProduccion, dirNuevoBuild);
+
+//   if (hayDiferencias) {
+//     // Lógica para el CAMINO A (cambio de código)
+//   } else {
+//     // Lógica para el CAMINO B (solo contenido)
+//   }
+// }

package/exporter/ssg-adapters/gatsby/shared/extract-assets.ts

@@ -0,0 +1,75 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { pathExists } from "../../../core/fs";
+import { getRenderPathsHydratedWithDomainFromDB } from "../../../services/render";
+
+/**
+ * Update the Griddo's `/dist` dir with the contents from `public` dir only
+ * with files of type: js, json and css.
+ * TODO: Explicar que el static se copia a assets porque el js va en el subdominio de assets.
+ */
+async function extractAssetsFromDist(domain: string) {
+	const { __root, __exports } = await getRenderPathsHydratedWithDomainFromDB({ domain });
+
+	// Archivos (no carpetas) válidos de public
+	const filesFromDist = (await fsp.readdir(path.join(__exports, "dist"))).filter(
+		(file) =>
+			path.extname(file) === ".js" ||
+			path.extname(file) === ".json" ||
+			path.extname(file) === ".css",
+	);
+
+	// Creamos assets si es necesario (needsAssetPrefix)
+	await fsp.mkdir(path.join(__root, "assets"), { recursive: true });
+	// page-data folder
+	await fsp.cp(
+		path.join(__exports, "dist", "page-data"),
+		path.join(__root, "assets", "page-data"),
+		{
+			preserveTimestamps: true,
+			recursive: true,
+		},
+	);
+	// static folder si existe
+	if (await pathExists(path.join(__root, "static"))) {
+		await fsp.cp(path.join(__root, "static"), path.join(__root, "assets"), {
+			force: false,
+			preserveTimestamps: true,
+			recursive: true,
+		});
+	}
+	// dist/static -> assets/static
+	if (await pathExists(path.join(__exports, "dist", "static"))) {
+		await fsp.cp(path.join(__exports, "dist", "static"), path.join(__root, "assets", "static"), {
+			force: false,
+			preserveTimestamps: true,
+			recursive: true,
+		});
+	}
+	// otro static...
+	if (await pathExists(path.join(__root, "static"))) {
+		await fsp.cp(path.join(__root, "static"), path.join(__exports, "dist", domain), {
+			preserveTimestamps: true,
+			recursive: true,
+			force: false,
+		});
+	}
+
+	// Copia el resto de archivos...
+	// for (const file of filesFromDist) {
+	// 	const fileSrc = path.join(__exports, "dist", file);
+	// 	const fileDest = path.join(__root, "assets", file);
+	// 	await fsp.cp(fileSrc, fileDest, { preserveTimestamps: true, recursive: true });
+	// }
+
+	const arraysOfPromises: any[] = filesFromDist.map((file) => {
+		const fileSrc = path.join(__exports, "dist", file);
+		const fileDest = path.join(__root, "assets", file);
+		return fsp.cp(fileSrc, fileDest, { preserveTimestamps: true, recursive: true });
+	});
+
+	await Promise.all(arraysOfPromises);
+}
+
+export { extractAssetsFromDist };

package/exporter/ssg-adapters/gatsby/shared/gatsby-build.ts

@@ -0,0 +1,58 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+import { GriddoLog } from "../../../core/GriddoLog";
+import { getRenderPathsHydratedWithDomainFromDB } from "../../../services/render";
+import { GRIDDO_SSG_VERBOSE_LOGS } from "../../../shared/envs";
+
+/**
+ * Spawn a new node process `gatsby build`
+ * @note This proccess can not access to the custom Griddo `process.env` so it
+ * needs variables passed to it via the `env` prop.
+ */
+async function gatsbyBuild(assetPrefixWithDomain: string): Promise<void> {
+	GriddoLog.verbose(`read assetPrefixWithDomain, ${assetPrefixWithDomain}`);
+	GriddoLog.verbose(`using this NODE_OPTIONS in gatsby command: ${process.env.NODE_OPTIONS}`);
+
+	const { __ssg } = await getRenderPathsHydratedWithDomainFromDB();
+
+	// Remove `--openssl-legacy-provider` from NODE_OPTIONS because this value
+	// break Gatsby render.
+	const nodeOptionsWithoutLegacyOpenSSL = process.env.NODE_OPTIONS
+		? process.env.NODE_OPTIONS.replace(/--openssl-legacy-provider\s*/g, "").trim()
+		: "";
+
+	// Ruta al ejecutable de Gatsby
+	const gatsbyExecutable = path.join(__ssg, "node_modules", ".bin", "gatsby");
+
+	const args = ["build", "--prefix-paths"];
+	if (GRIDDO_SSG_VERBOSE_LOGS) {
+		args.push("--verbose");
+	}
+
+	return new Promise((resolve, reject) => {
+		const child = spawn(gatsbyExecutable, args, {
+			cwd: __ssg,
+			stdio: ["ignore", "inherit", "inherit"],
+			env: {
+				...process.env,
+				SPAWN_ASSET_PREFIX_WITH_DOMAIN: assetPrefixWithDomain,
+				NODE_OPTIONS: nodeOptionsWithoutLegacyOpenSSL,
+			},
+		});
+
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve();
+			} else {
+				reject(new Error(`Gatsby build failed with exit code ${code}`));
+			}
+		});
+
+		child.on("error", (error) => {
+			reject(new Error(`Failed to start Gatsby build process: ${error.message}`));
+		});
+	});
+}
+
+export { gatsbyBuild };

package/exporter/ssg-adapters/gatsby/shared/sync-render.ts

@@ -0,0 +1,300 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import pLimit from "p-limit";
+
+import { findFilesBySuffix } from "../../../core/fs";
+import { GriddoLog } from "../../../core/GriddoLog";
+import { GRIDDO_SSG_BUNDLE_ANALYZER } from "../../../shared/envs";
+import { getAssetsDiffBetweenRenders, patchHtmlFile } from "./diff-assets";
+
+interface SyncRenderConfig {
+	src: string;
+	dst: string;
+	pagesToCreate: number[];
+	pagesToDelete: number[];
+	artifactsToCopyToExports: string[];
+}
+interface CopyFilePath {
+	from: string;
+	to: string;
+}
+interface SyncState {
+	htmlToAdd: CopyFilePath[];
+	jsonToAdd: CopyFilePath[];
+	htmlToDelete: string[];
+	jsonToDelete: string[];
+}
+interface PageInfo {
+	id: number;
+	composePath: string; // p.ej. '/about-us' o '/'
+	htmlPath: string; // p.ej. '/path/to/public/about-us/index.html'
+	jsonPath: string; // p.ej. '/path/to/public/page-data/about-us/page-data.json'
+}
+interface GatsbyPageData {
+	result: {
+		pageContext: {
+			id: number;
+			fullPath: {
+				site: string;
+				domain: string;
+				domainUrl: string;
+				language: string;
+				page: string;
+				compose: string;
+			};
+		};
+	};
+}
+
+class SyncRender {
+	private bundleDir: string;
+	private currentRenderDir: string;
+	private pagesToCreate: number[];
+	private pagesToDelete: number[];
+	private assetArtifacts: string[];
+
+	private state: SyncState = {
+		htmlToAdd: [],
+		jsonToAdd: [],
+		htmlToDelete: [],
+		jsonToDelete: [],
+	};
+
+	constructor(config: SyncRenderConfig) {
+		this.bundleDir = config.dst;
+		this.currentRenderDir = config.src;
+		this.pagesToCreate = config.pagesToCreate;
+		this.pagesToDelete = config.pagesToDelete;
+		this.assetArtifacts = config.artifactsToCopyToExports;
+	}
+
+	public async execute() {
+		await this.setPagesToDelete();
+		await this.setPagesToAdd();
+		await this.sync();
+		if (GRIDDO_SSG_BUNDLE_ANALYZER) {
+			await this.assertAssetsAreValid();
+		}
+	}
+
+	private async assertAssetsAreValid() {
+		const isDifferent = await getAssetsDiffBetweenRenders(this.currentRenderDir, this.bundleDir);
+		if (isDifferent) {
+			GriddoLog.info(
+				"Warning: JavaScript and CSS bundles must have the same files and content. You can ignore this warning if the rendering process only has pages to unpublish.",
+			);
+		} else {
+			GriddoLog.info("Previous and current JavaScript and CSS packages successfully matched");
+		}
+	}
+
+	private async setPagesToDelete() {
+		// INCLUIMOS LAS PÁGINAS A CREAR EN LAS CANDIDATAS A BORRAR
+		// =======================================================
+		// El set de ids incluye tanto las páginas a borrar como las que se van
+		// a crear para manejar correctamente los cambios de slug.
+		//
+		// Ejemplo: Si la página `id=3` tiene slug `about` y después viene con
+		// `slug=about-us`, necesitamos borrar la página `id=3` del render previo
+		// y volver a crearla con la nueva ruta.
+		//
+		// ¿Por qué? Porque el slug determina dónde se guarda la página:
+		// - /about/index.html -> /about-us/index.html
+		//
+		// Si no la borrásemos previamente, tendríamos ambas páginas:
+		// `/about/index.html` y `/about-us/index.html`
+		const candidateIdsToDelete = new Set<number>([...this.pagesToDelete, ...this.pagesToCreate]);
+		const existingPreviousPages = await this.scanPages(this.bundleDir);
+
+		for (const page of existingPreviousPages) {
+			if (candidateIdsToDelete.has(page.id)) {
+				this.state.htmlToDelete.push(page.htmlPath);
+				this.state.jsonToDelete.push(page.jsonPath);
+			}
+		}
+
+		GriddoLog.verbose(`${this.state.htmlToDelete.length} pages HTML to delete`);
+		GriddoLog.verbose(`${this.state.jsonToDelete.length} pages JSON to delete`);
+	}
+
+	private async setPagesToAdd() {
+		const candidateIdsToCreate = new Set<number>(this.pagesToCreate);
+		const newPages = await this.scanPages(this.currentRenderDir);
+
+		for (const page of newPages) {
+			if (candidateIdsToCreate.has(page.id)) {
+				const htmlTo = path.join(this.bundleDir, page.composePath, "index.html");
+				const normalizedCompose = page.composePath === "/" ? "index" : page.composePath;
+				const jsonTo = path.join(this.bundleDir, "page-data", normalizedCompose, "page-data.json");
+
+				this.state.htmlToAdd.push({ from: page.htmlPath, to: htmlTo });
+				this.state.jsonToAdd.push({ from: page.jsonPath, to: jsonTo });
+			}
+		}
+
+		GriddoLog.verbose(`${this.state.htmlToAdd.length} pages HTML to create`);
+		GriddoLog.verbose(`${this.state.jsonToAdd.length} pages JSON to create`);
+	}
+
+	private async sync() {
+		// Delete...
+		const allFilesToDelete = [...this.state.htmlToDelete, ...this.state.jsonToDelete];
+		for (const file of allFilesToDelete) {
+			try {
+				// Usar `force: true` para no fallar si el archivo ya no existe.
+				await fsp.rm(file, { force: true });
+				GriddoLog.verbose(`Sync (remove) : ${file}`);
+			} catch (e) {
+				// El error solo se registraría si es un problema de permisos, etc.
+				GriddoLog.error(`Failed to remove ${file}:`, e);
+			}
+		}
+
+		await this.restoreWebpackCompilationHash();
+
+		// Copy...
+		const allFilesToAdd = [...this.state.htmlToAdd, ...this.state.jsonToAdd];
+		for (const file of allFilesToAdd) {
+			try {
+				await fsp.mkdir(path.dirname(file.to), { recursive: true });
+				await fsp.copyFile(file.from, file.to);
+				GriddoLog.verbose(`Sync (copy) : ${file.from} -> ${file.to}`);
+			} catch (e) {
+				GriddoLog.error(`Failed to copy ${file.from} to ${file.to}:`, e);
+			}
+		}
+
+		// AVOID TO RESTORE webpackCompilationHash
+		// await this.copyAppDataJsonFile();
+		await this.copyAssetArtifacts();
+		await this.copySitemaps();
+	}
+
+	// TODO: Optimizar esto a lo bestia...
+	private async restoreWebpackCompilationHash() {
+		const appDataJson = path.join(this.bundleDir, "page-data", "app-data.json");
+		const webpackCompilationHash = JSON.parse(
+			await fsp.readFile(appDataJson, "utf8"),
+		).webpackCompilationHash;
+		GriddoLog.build(
+			`Reading webpackCompilationHash from ${appDataJson} = ${webpackCompilationHash}`,
+		);
+
+		const changedHtmlFilePaths = this.state.htmlToAdd.map(({ from }) => from);
+
+		for (const htmlFilePath of changedHtmlFilePaths) {
+			await patchHtmlFile(htmlFilePath, webpackCompilationHash);
+		}
+	}
+
+	// private async copyAppDataJsonFile() {
+	// 	try {
+	// 		const src = path.join(this.currentRenderDir, "page-data", "app-data.json");
+	// 		const dst = path.join(this.bundleDir, "page-data", "app-data.json");
+	// 		await fsp.copyFile(src, dst);
+	// 		GriddoLog.verbose("Copied app-data.json");
+	// 	} catch (e) {
+	// 		GriddoLog.error("Failed to copy app-data.json:", e);
+	// 	}
+	// }
+
+	private async copyAssetArtifacts() {
+		for (const assetArtifact of this.assetArtifacts) {
+			const src = path.join(this.currentRenderDir, assetArtifact);
+			const dst = path.join(this.bundleDir, assetArtifact);
+			try {
+				await fsp.mkdir(path.dirname(dst), { recursive: true });
+				await fsp.copyFile(src, dst);
+				GriddoLog.verbose(`Copied artifact: ${assetArtifact}`);
+			} catch (e) {
+				GriddoLog.error(`Failed to copy artifact ${src} to ${dst}:`, e);
+			}
+		}
+	}
+
+	private async copySitemaps() {
+		const renderSrc = path.resolve(this.currentRenderDir);
+		const renderDst = path.resolve(this.bundleDir);
+
+		// Primero, elimina los sitemaps existentes en el destino
+		const xmlFilesInDst = findFilesBySuffix(renderDst, ".xml");
+		for await (const xmlFile of xmlFilesInDst) {
+			const basename = path.basename(xmlFile);
+			if (basename.startsWith("sitemap-") || basename === "sitemap.xml") {
+				await fsp.rm(xmlFile, { force: true });
+			}
+		}
+
+		// Segundo, copia los nuevos sitemaps desde el origen
+		const xmlFilesInSrc = findFilesBySuffix(renderSrc, ".xml");
+		for await (const src of xmlFilesInSrc) {
+			// Reconstruye la ruta de destino de forma más robusta
+			const relativePath = path.relative(renderSrc, src);
+			const dst = path.join(renderDst, relativePath);
+
+			try {
+				await fsp.mkdir(path.dirname(dst), { recursive: true });
+				await fsp.copyFile(src, dst);
+			} catch (e) {
+				GriddoLog.error(`Failed to copy sitemap ${src} to ${dst}:`, e);
+			}
+		}
+
+		GriddoLog.verbose(`Copied sitemap files.`);
+	}
+
+	/**
+	 * Escanea un directorio de build de Gatsby y extrae la información esencial de cada página.
+	 * Lee cada page-data.json una sola vez para optimizar el rendimiento.
+	 * @param dir Directorio a escanear (src o dst).
+	 * @returns Un array con la información de cada página encontrada.
+	 */
+	private async scanPages(dir: string): Promise<PageInfo[]> {
+		// 1. Crea una instancia de p-limit con 128 lecturas a la vez...
+		// Como ejemplo: macOS tiene un límite que suele empezar en 256.
+		const limit = pLimit(128);
+
+		// 2. Recolecta todos los paths de los archivos.
+		const gatsbyPageDataGenerator = findFilesBySuffix(
+			path.join(dir, "page-data"),
+			"page-data.json",
+		);
+		const jsonFilePaths: string[] = [];
+		for await (const file of gatsbyPageDataGenerator) {
+			jsonFilePaths.push(file);
+		}
+
+		// 3. Mapea cada path a una promesa envuelta por pLimit.
+		const processingPromises = jsonFilePaths.map((jsonFile) => {
+			return limit(async (): Promise<PageInfo | null> => {
+				try {
+					const fileContent = await fsp.readFile(jsonFile, "utf-8");
+					const content = JSON.parse(fileContent) as GatsbyPageData;
+
+					const id = content.result.pageContext.id;
+					const composePath = content.result.pageContext.fullPath.compose;
+					const normalizedCompose = composePath === "/" ? "index" : composePath;
+
+					return {
+						id,
+						composePath,
+						htmlPath: path.join(dir, composePath, "index.html"),
+						jsonPath: path.join(dir, "page-data", normalizedCompose, "page-data.json"),
+					};
+				} catch (e) {
+					GriddoLog.error(`Error reading or parsing page data from ${jsonFile}:`, e);
+					return null;
+				}
+			});
+		});
+
+		// 4. Go :)
+		const pagesFoundOrNull = await Promise.all(processingPromises);
+
+		// 5. Filtra los nulos y devuelve solo las páginas válidas.
+		return pagesFoundOrNull.filter((page): page is PageInfo => page !== null);
+	}
+}
+
+export { SyncRender };