@griddo/cx 11.13.0 → 11.13.2

package/exporter/core/http/with-circuit-breaker.ts

@@ -0,0 +1,86 @@
+import type { HttpAdapter, HttpRequest, HttpResponse } from "./types";
+
+type CircuitState = "closed" | "open" | "half-open";
+
+export interface CircuitBreakerOptions {
+	/** Number of consecutive failures before opening the circuit. */
+	failureThreshold: number;
+	/** Time in ms before switching from open to half-open. */
+	cooldownMs: number;
+	/** Called when the circuit opens. */
+	onOpen?: () => void;
+	/** Called when the circuit closes (recovery). */
+	onClose?: () => void;
+}
+
+export class CircuitOpenError extends Error {
+	constructor(cooldownMs: number) {
+		super(`Circuit breaker is open. Cooldown: ${cooldownMs}ms`);
+		this.name = "CircuitOpenError";
+	}
+}
+
+/**
+ * Decorator that adds circuit breaker logic to an HttpAdapter.
+ *
+ * States:
+ * - CLOSED:    requests pass through normally, failures are counted
+ * - OPEN:      all requests fail immediately with CircuitOpenError
+ * - HALF-OPEN: one probe request is allowed; success → CLOSED, failure → OPEN
+ */
+function withCircuitBreaker(adapter: HttpAdapter, options: CircuitBreakerOptions): HttpAdapter {
+	const { failureThreshold, cooldownMs, onOpen, onClose } = options;
+
+	let state: CircuitState = "closed";
+	let failures = 0;
+	let openedAt = 0;
+
+	function recordSuccess() {
+		if (state === "half-open") {
+			state = "closed";
+			failures = 0;
+			onClose?.();
+		} else {
+			failures = 0;
+		}
+	}
+
+	function recordFailure() {
+		failures++;
+		if (failures >= failureThreshold) {
+			state = "open";
+			openedAt = Date.now();
+			onOpen?.();
+		}
+	}
+
+	function shouldAllowRequest(): boolean {
+		if (state === "closed") return true;
+
+		if (state === "open" && Date.now() - openedAt >= cooldownMs) {
+			state = "half-open";
+			return true;
+		}
+
+		return state === "half-open";
+	}
+
+	return {
+		async request(req: HttpRequest): Promise<HttpResponse> {
+			if (!shouldAllowRequest()) {
+				throw new CircuitOpenError(cooldownMs);
+			}
+
+			try {
+				const response = await adapter.request(req);
+				recordSuccess();
+				return response;
+			} catch (e) {
+				recordFailure();
+				throw e;
+			}
+		},
+	};
+}
+
+export { withCircuitBreaker };

package/exporter/core/http/with-retry.ts

@@ -0,0 +1,87 @@
+import type { HttpAdapter, HttpRequest, HttpResponse } from "./types";
+
+export interface RetryOptions {
+	/** Max number of attempts (including the first one). */
+	attempts: number;
+	/** Base delay between retries in milliseconds. */
+	delayMs: number;
+	/** Backoff strategy: "fixed" (same delay) or "exponential" (1x, 2x, 4x...). Default: "fixed". */
+	backoff?: "fixed" | "exponential";
+	/** Add random jitter (±50%) to the delay to avoid thundering herd. Default: false. */
+	jitter?: boolean;
+	/** Decide whether a successful response should be retried (e.g. 5xx). */
+	retryOn?: (response: HttpResponse) => boolean;
+	/** Called before each retry. */
+	onRetry?: (context: {
+		request: HttpRequest;
+		attempt: number;
+		delayMs: number;
+		error?: Error;
+		response?: HttpResponse;
+	}) => void;
+}
+
+function wait(ms: number): Promise<void> {
+	return new Promise((res) => setTimeout(res, ms));
+}
+
+function computeDelay(
+	baseMs: number,
+	attempt: number,
+	backoff: "fixed" | "exponential",
+	jitter: boolean,
+): number {
+	let ms = backoff === "exponential" ? baseMs * 2 ** (attempt - 1) : baseMs;
+
+	if (jitter) {
+		ms = Math.round(ms * (0.5 + Math.random()));
+	}
+
+	return ms;
+}
+
+/**
+ * Decorator that adds retry logic to an HttpAdapter.
+ *
+ * Retries on:
+ * - Transport errors (network failures, DNS, connection refused, timeouts)
+ * - Responses matching `retryOn` predicate (e.g. status >= 500)
+ *
+ * Supports fixed and exponential backoff with optional jitter.
+ */
+function withRetry(adapter: HttpAdapter, options: RetryOptions): HttpAdapter {
+	const { attempts, delayMs, backoff = "fixed", jitter = false, retryOn, onRetry } = options;
+
+	return {
+		async request(req: HttpRequest): Promise<HttpResponse> {
+			let lastError: Error | undefined;
+
+			for (let attempt = 1; attempt <= attempts; attempt++) {
+				try {
+					const response = await adapter.request(req);
+
+					if (retryOn?.(response) && attempt < attempts) {
+						const ms = computeDelay(delayMs, attempt, backoff, jitter);
+						onRetry?.({ request: req, attempt, delayMs: ms, response });
+						await wait(ms);
+						continue;
+					}
+
+					return response;
+				} catch (e) {
+					lastError = e as Error;
+
+					if (attempt < attempts) {
+						const ms = computeDelay(delayMs, attempt, backoff, jitter);
+						onRetry?.({ request: req, attempt, delayMs: ms, error: lastError });
+						await wait(ms);
+					}
+				}
+			}
+
+			throw lastError;
+		},
+	};
+}
+
+export { withRetry };

package/exporter/services/api.ts

@@ -12,20 +12,18 @@ import crypto from "node:crypto";
 import fsp from "node:fs/promises";
 import path from "node:path";
 
-import {
-	GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS,
-	GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS,
-} from "@shared/envs";
-
 import { RenderError } from "../core/errors";
 import { pathExists } from "../core/fs";
 import { GriddoLog } from "../core/GriddoLog";
+import { getHttpAdapter } from "../core/http";
 import { addLogToBuffer } from "../core/logger";
 import { brush } from "../shared/brush";
 import { DEFAULT_HEADERS } from "../shared/headers";
 import { AuthService } from "./auth";
 import { getRenderPathsHydratedWithDomainFromDB } from "./render";
 
+const adapter = getHttpAdapter();
+
 /**
  * Make a GET/PUT/POST request to the Griddo API.
  *
@@ -44,15 +42,7 @@ async function requestAPI<T extends APIResponses>(
 	method: string,
 	appendToLog = "",
 ): Promise<T> {
-	const {
-		endpoint,
-		body,
-		cacheKey = "",
-		attempt = 1,
-		headers,
-		useApiCacheDir = true,
-		logToFile = true,
-	} = props;
+	const { endpoint, body, cacheKey = "", headers, useApiCacheDir = true, logToFile = true } = props;
 	const cacheOptions = { endpoint, body, headers, cacheKey };
 
 	// Cache
@@ -75,23 +65,25 @@ async function requestAPI<T extends APIResponses>(
 	try {
 		const start = new Date();
 
-		// Prepare fetch options
-		const fetchOptions: RequestInit = {
-			method: method.toUpperCase(),
-			headers: Object.assign({}, DEFAULT_HEADERS, headers, AuthService.headers) as Record<
-				string,
-				string
-			>,
-		};
-
-		// Add body for non-GET requests
-		if (method.toLowerCase() !== "get" && body) {
-			fetchOptions.body = JSON.stringify(body);
-			if (!fetchOptions.headers) fetchOptions.headers = {};
-			(fetchOptions.headers as Record<string, string>)["Content-Type"] = "application/json";
+		// Prepare request
+		const requestHeaders = Object.assign(
+			{},
+			DEFAULT_HEADERS,
+			headers,
+			AuthService.headers,
+		) as Record<string, string>;
+
+		const hasBody = method.toLowerCase() !== "get" && body;
+		if (hasBody) {
+			requestHeaders["Content-Type"] = "application/json";
 		}
 
-		const response = await fetch(endpoint, fetchOptions);
+		const response = await adapter.request({
+			url: endpoint,
+			method: method.toUpperCase(),
+			headers: requestHeaders,
+			body: hasBody ? JSON.stringify(body) : undefined,
+		});
 
 		// Handle non-2xx responses
 		if (!response.ok) {
@@ -120,38 +112,11 @@ async function requestAPI<T extends APIResponses>(
 	} catch (e) {
 		const error = e as Error;
 
-		if (attempt > GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS) {
-			GriddoLog.log(`
-Max attempts ${GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS} reached
---------------------------------------
-- ${method.toUpperCase()} ${endpoint}
-- BODY: ${JSON.stringify(body)}
-- HEADERS: ${JSON.stringify(headers)}
-- ERROR: ${error.message}
---------------------------------------
-`);
-			throw new RenderError(error);
-		}
-
 		showApiError(error, {
 			callInfo: { endpoint, body },
 		});
 
-		GriddoLog.warn(`Waiting for retry: ${method}`, endpoint);
-
-		await delay(GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS * 1000);
-
-		return requestAPI<T>(
-			{
-				endpoint,
-				body,
-				headers,
-				cacheKey,
-				attempt: attempt + 1,
-			},
-			method,
-			appendToLog,
-		);
+		throw new RenderError(error);
 	}
 }
 
@@ -238,15 +203,6 @@ function getSafeSiteId(response: APIResponses) {
 	return "site" in response && response.site ? response.site : undefined;
 }
 
-/**
- * Custom delay using the "promise hack",
- *
- * @param ms Amount of miliseconds to be delayed
- */
-function delay(ms: number): Promise<void> {
-	return new Promise((res) => setTimeout(res, ms));
-}
-
 /**
  * Converts milliseconds to seconds with a fixed number of decimals.
  *

package/exporter/services/auth.ts

@@ -1,17 +1,21 @@
 import type { AuthHeaders } from "../shared/types/api";
 
 import { throwError } from "../core/errors";
+import { getHttpAdapter } from "../core/http";
 import { LOGIN } from "../shared/endpoints";
 import { GRIDDO_BOT_PASSWORD, GRIDDO_BOT_USER } from "../shared/envs";
 import { LoginError } from "../shared/errors";
 import { DEFAULT_HEADERS } from "../shared/headers";
 
+const adapter = getHttpAdapter();
+
 class AuthService {
 	headers: AuthHeaders | undefined;
 
 	async login() {
 		try {
-			const response = await fetch(LOGIN, {
+			const response = await adapter.request({
+				url: LOGIN,
 				method: "POST",
 				headers: Object.assign({}, DEFAULT_HEADERS, {
 					"Content-Type": "application/json",
@@ -27,7 +31,12 @@ class AuthService {
 				throw new Error("Error while login in the API");
 			}
 
-			const { token } = await response.json();
+			const { token } = await response.json<{ token: string }>();
+
+			if (!token || typeof token !== "string") {
+				throw new Error("Login response missing valid token");
+			}
+
 			this.headers = {
 				Authorization: `bearer ${token}`,
 				"Cache-Control": "no-store",

package/exporter/services/domains.ts

@@ -27,7 +27,12 @@ async function getInstanceDomains() {
 			return { ...domain, slug: domain.slug.replace("/", "") };
 		});
 
-	return [...new Set(filteredDomains)];
+	const seen = new Set<string>();
+	return filteredDomains.filter((d) => {
+		if (seen.has(d.slug)) return false;
+		seen.add(d.slug);
+		return true;
+	});
 }
 
 export { getInstanceDomains };

package/exporter/services/llms.ts

@@ -36,7 +36,7 @@ async function getClientLLMsTxtTemplate(filePath: string) {
 
 async function generateLlmsTxt(domain: string): Promise<void> {
 	if (GRIDDO_RENDER_DISABLE_LLMS_TXT) {
-		GriddoLog.verbose(`Skipping llms.txt generation: Disabled by environment variable.`);
+		GriddoLog.verbose(`${domain} skipped llms.txt generation: disabled by environment variable.`);
 		return;
 	}
 

package/exporter/services/manage-store.ts

@@ -50,26 +50,17 @@ async function saveRenderInfoInStore(renderInfo: RenderInfo, domain: string) {
 async function getPageInStoreDir(basePath: string) {
 	const filesInStore = await fsp.readdir(basePath);
 
-	return filesInStore
-		.filter(async (file) => {
+	const checks = await Promise.all(
+		filesInStore.map(async (file) => {
 			const fullPathFile = `${basePath}/${file}`;
 			const stat = await fsp.stat(fullPathFile);
-			// Si es un directorio, no lo incluimos.
-			if (stat?.isDirectory()) {
-				return false;
-			}
-
-			// Si es un archivo pero no tiene la extensión `.json`, no lo incluimos
-			if (path.extname(file) !== ".json") {
-				return false;
-			}
-
-			// no es dir, es json.
+			if (stat?.isDirectory()) return false;
+			if (path.extname(file) !== ".json") return false;
 			return true;
-		})
-		.map((page) => {
-			return path.join(basePath, page);
-		});
+		}),
+	);
+
+	return filesInStore.filter((_, i) => checks[i]).map((page) => path.join(basePath, page));
 }
 
 /**
@@ -140,15 +131,21 @@ async function writeUniqueFileSync(filePath: string, content: string) {
  * @param props An array of props to be removed
  */
 function removeProperties(obj: Record<string, unknown>, propsToRemove: Set<string>) {
+	const seen = new WeakSet<object>();
+
 	function remove(currentObj: Record<string, unknown>) {
 		if (!currentObj || typeof currentObj !== "object" || Array.isArray(currentObj)) {
 			return;
 		}
 
+		if (seen.has(currentObj)) {
+			return;
+		}
+		seen.add(currentObj);
+
 		for (const key in currentObj) {
 			if (Object.hasOwn(currentObj, key)) {
 				if (propsToRemove.has(key)) {
-					// Búsqueda O(1) en lugar de O(n)
 					delete currentObj[key];
 				} else {
 					const value = currentObj[key];
@@ -167,6 +164,7 @@ export {
 	getBuildMetadata,
 	getPageInStoreDir,
 	removeOrphanSites,
+	removeProperties,
 	saveRenderInfoInStore,
 	saveSitePagesInStore,
 	writeUniqueFileSync,

package/exporter/services/pages.ts

@@ -482,9 +482,16 @@ function addPageNumberToTitle(title: string, pageNumber: number) {
 }
 
 export {
+	addPageNumberToTitle,
+	addPageNumberToUrl,
 	createGriddoListPages,
 	createGriddoMultiPages,
 	createGriddoSinglePage,
 	getMultiPageElements,
+	getOpenGraph,
+	getPage,
+	getPageCluster,
+	getPageMetadata,
 	getPaginatedPages,
+	removeDuplicateTrailing,
 };

package/exporter/services/reference-fields.ts

@@ -88,9 +88,7 @@ async function fetchContentTypeData(props: FetchDataProps) {
 
 	// Avoid fetch ReferenceField with empty `data.sources`
 	if (Array.isArray(data.sources) && data.sources.length < 1) {
-		GriddoLog.info(
-			`Warning: Page with id: ${page.id} has a ReferenceField with empty \`data.sources\``,
-		);
+		GriddoLog.warn(`Page with id: ${page.id} has a ReferenceField with empty \`data.sources\``);
 
 		return [];
 	}
@@ -99,8 +97,8 @@ async function fetchContentTypeData(props: FetchDataProps) {
 
 	// Inform that the ReferenceField has not `data.sources`
 	if (!data.sources && data.mode === "auto") {
-		GriddoLog.info(
-			`Warning: Page with id: ${page.id} has a ReferenceField with \`undefined\` \`data.sources\``,
+		GriddoLog.warn(
+			`Page with id: ${page.id} has a ReferenceField with \`undefined\` \`data.sources\``,
 		);
 	}
 

package/exporter/services/render.ts

@@ -124,16 +124,12 @@ async function hasNewCommit(basePath: string): Promise<boolean> {
 	const commitFile = path.join(basePath, "commit");
 	const currentCommit = execSync("git rev-parse HEAD").toString().trim();
 
-	if (await pathExists(commitFile)) {
+	try {
 		const savedCommit = (await fsp.readFile(commitFile, "utf-8")).trim();
-		if (savedCommit === currentCommit) {
-			return false; // No hay nuevo commit
-		}
-
+		return savedCommit !== currentCommit;
+	} catch {
 		return true;
 	}
-
-	return true;
 }
 
 async function updateCommitFile(options: { basePath: string }) {

package/exporter/services/store.ts

@@ -334,11 +334,17 @@ async function createStore(options: {
 			const totalPages = pagesToFetchFromAPI.length;
 			const progressCounter = { current: 0 };
 			const progress = new siteFetchProgressBar(site.name, totalPages);
-			const pagesToStore = pagesToFetchFromAPI.map((id: number) =>
-				limit(() => fetchSitePageAndSaveInStore(siteDirName, id, progressCounter, progress)),
-			);
 
-			await Promise.all(pagesToStore);
+			// Drain in batches to avoid holding all promise wrappers in memory
+			const BATCH_SIZE = 100;
+			for (let i = 0; i < totalPages; i += BATCH_SIZE) {
+				const batch = pagesToFetchFromAPI.slice(i, i + BATCH_SIZE);
+				await Promise.all(
+					batch.map((id: number) =>
+						limit(() => fetchSitePageAndSaveInStore(siteDirName, id, progressCounter, progress)),
+					),
+				);
+			}
 		}
 	}
 

package/exporter/shared/envs.ts

@@ -25,12 +25,20 @@ const GRIDDO_PUBLIC_API_URL = env.GRIDDO_PUBLIC_API_URL || env.PUBLIC_API_URL;
 const GRIDDO_BOT_USER = env.botEmail || env.GRIDDO_BOT_USER;
 const GRIDDO_BOT_PASSWORD = env.botPassword || env.GRIDDO_BOT_PASSWORD;
 
+/**
+ * Parses an integer from an env var string with a safe fallback.
+ */
+function safeParseInt(value: string, fallback: number): number {
+	const parsed = Number.parseInt(value);
+	return Number.isNaN(parsed) ? fallback : parsed;
+}
+
 // Rendering
-const GRIDDO_AI_EMBEDDINGS = envIsTruthy(env.GRIDDO_AI_EMBEDDINGS || env.GRIDDO_API_AI_EMBEDDINGS);
-const GRIDDO_API_CONCURRENCY_COUNT = Number.parseInt(env.GRIDDO_API_CONCURRENCY_COUNT || env.GRIDDO_RENDER_CONCURRENCY_COUNT || "10");
+const GRIDDO_AI_EMBEDDINGS = envIsTruthy(env.GRIDDO_AI_EMBEDDINGS);
+const GRIDDO_API_CONCURRENCY_COUNT = safeParseInt(env.GRIDDO_API_CONCURRENCY_COUNT || env.GRIDDO_RENDER_CONCURRENCY_COUNT || "10", 10);
 const GRIDDO_ASSET_PREFIX = env.GRIDDO_ASSET_PREFIX || env.ASSET_PREFIX || env.GRIDDO_RENDER_ASSET_PREFIX;
 const GRIDDO_BUILD_LOGS = envIsTruthy(env.GRIDDO_BUILD_LOGS || env.GRIDDO_RENDER_BUILD_LOGS);
-const GRIDDO_BUILD_LOGS_BUFFER_SIZE = Number.parseInt(env.GRIDDO_RENDER_BUILD_LOGS_BUFFER_SIZE || "500");
+const GRIDDO_BUILD_LOGS_BUFFER_SIZE = safeParseInt(env.GRIDDO_RENDER_BUILD_LOGS_BUFFER_SIZE || "500", 500);
 const GRIDDO_REACT_APP_INSTANCE = env.GRIDDO_REACT_APP_INSTANCE || env.REACT_APP_INSTANCE || env.GRIDDO_APP_INSTANCE || env.GRIDDO_EDITOR_APP_INSTANCIE;
 const GRIDDO_RENDER_DISABLE_LLMS_TXT = envIsTruthy(env.GRIDDO_RENDER_DISABLE_LLMS_TXT);
 const GRIDDO_SEARCH_FEATURE = envIsTruthy(env.GRIDDO_SEARCH_FEATURE || env.GRIDDO_RENDER_SEARCH_FEATURE);
@@ -39,10 +47,13 @@ const GRIDDO_SSG_BUNDLE_ANALYZER = envIsTruthy(env.GRIDDO_RENDER_SSG_BUNDLE_ANAL
 const GRIDDO_SSG_VERBOSE_LOGS = envIsTruthy(env.GRIDDO_RENDER_SSG_VERBOSE_LOGS);
 const GRIDDO_USE_DIST_BACKUP = envIsTruthy(env.GRIDDO_RENDER_USE_DIST_BACKUP);
 const GRIDDO_VERBOSE_LOGS = envIsTruthy(env.GRIDDO_VERBOSE_LOGS || env.GRIDDO_RENDER_VERBOSE_LOGS);
-const GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS = Number.parseInt(env.GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS || "4");
-const GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS = Number.parseInt(env.GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS || "4");
-const GRIDDO_RENDER_LIFECYCLE_RETRY_ATTEMPTS = Number.parseInt(env.GRIDDO_RENDER_LIFECYCLE_RETRY_ATTEMPTS || "1");
 const GRIDDO_RENDER_ENABLED_LLM_MD = envIsTruthy(env.GRIDDO_RENDER_ENABLED_LLM_MD);
+const GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS = safeParseInt(env.GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS || "4", 4);
+const GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS = safeParseInt(env.GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS || "4", 4);
+const GRIDDO_RENDER_API_TIMEOUT_MS = safeParseInt(env.GRIDDO_RENDER_API_TIMEOUT_MS || "300000", 300000);
+const GRIDDO_RENDER_CIRCUIT_BREAKER_FAILURE_THRESHOLD = safeParseInt(env.GRIDDO_RENDER_CIRCUIT_BREAKER_FAILURE_THRESHOLD || "10", 10);
+const GRIDDO_RENDER_CIRCUIT_BREAKER_COOLDOWN_MS = safeParseInt(env.GRIDDO_RENDER_CIRCUIT_BREAKER_COOLDOWN_MS || "30000", 30000);
+const GRIDDO_RENDER_LIFECYCLE_RETRY_ATTEMPTS = safeParseInt(env.GRIDDO_RENDER_LIFECYCLE_RETRY_ATTEMPTS || "1", 1);
 
 export {
 	GRIDDO_AI_EMBEDDINGS,
@@ -57,6 +68,9 @@ export {
 	GRIDDO_REACT_APP_INSTANCE,
 	GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS,
 	GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS,
+	GRIDDO_RENDER_API_TIMEOUT_MS,
+	GRIDDO_RENDER_CIRCUIT_BREAKER_COOLDOWN_MS,
+	GRIDDO_RENDER_CIRCUIT_BREAKER_FAILURE_THRESHOLD,
 	GRIDDO_RENDER_DISABLE_LLMS_TXT,
 	GRIDDO_RENDER_ENABLED_LLM_MD,
 	GRIDDO_RENDER_LIFECYCLE_RETRY_ATTEMPTS,

package/exporter/shared/types/api.ts

@@ -115,8 +115,6 @@ export interface APIRequest {
 	body?: any;
 	/** Reference id to manage cache between renders. */
 	cacheKey?: string;
-	/** Number of connection attempts (in case it fails on the first attempt). */
-	attempt?: number;
 	/**
 	 * Headers for the post api fetch
 	 */

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

@@ -57,7 +57,7 @@ export async function gatsbyRenderDomain(domain: string) {
 
 	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}.`,
+			`(Pre-check) ${domain} skipped start-render it is marked as <${RENDER_MODE.IDLE}> with the reason <${reason}>`,
 		);
 		return;
 	}
@@ -68,7 +68,9 @@ export async function gatsbyRenderDomain(domain: string) {
 
 	// Render mode reason to log information to the terminal
 	const renderModeReason = derivedRenderModeReason ? ` <${derivedRenderModeReason}>` : "";
-	GriddoLog.info(`Init render (${derivedRenderMode})${renderModeReason} for domain ${domain}\n`);
+	GriddoLog.info(
+		`Init render ${domain} <${derivedRenderMode}> with the reason${renderModeReason}\n`,
+	);
 
 	// Render context
 	const context = new RenderContext<SSG>({

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

@@ -144,7 +144,11 @@ class SyncRender {
 				// ../page-data/about-us/page-data.json // página con slug
 				// ../page-data/programs/page-data.json // página con slug
 				// ../page-data/index/page-data.json // <---- ¡página root index!
-				const normalizedCompose = page.composePath === "/" ? "index" : page.composePath;
+				//
+				// Ojo: `composePath` viene normalizado por `removeTrailingSlash`
+				// (ver `scanPages`), así que la home llega como "" y no como "/".
+				const normalizedCompose =
+					page.composePath === "" || 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 });