@griddo/cx 11.13.0 → 11.13.2

package/build/react/GriddoIntegrations/utils.d.ts

@@ -8,7 +8,7 @@ declare function filterHeadIntegrations(integrations: Core.PageIntegration[]): {
     content: string;
     type: "addon" | "analytics" | "datalayer";
 }[];
-declare const filterPositionIntegrations: (integrations: Core.PageIntegration[], position: "end" | "head" | "start") => {
+declare const filterPositionIntegrations: (integrations: Core.PageIntegration[], position: "head" | "start" | "end") => {
     content: string;
     type: "addon" | "analytics" | "datalayer";
 }[];

package/build/services/manage-store.d.ts

@@ -29,4 +29,11 @@ declare function saveSitePagesInStore(siteDirName: string, pages: GriddoPageObje
  */
 declare function removeOrphanSites(sitesToPublish: Site[], domain: string): Promise<void>;
 declare function writeUniqueFileSync(filePath: string, content: string): Promise<void>;
-export { getBuildMetadata, getPageInStoreDir, removeOrphanSites, saveRenderInfoInStore, saveSitePagesInStore, writeUniqueFileSync, };
+/**
+ * Remove props from an object
+ *
+ * @param obj The object
+ * @param props An array of props to be removed
+ */
+declare function removeProperties(obj: Record<string, unknown>, propsToRemove: Set<string>): void;
+export { getBuildMetadata, getPageInStoreDir, removeOrphanSites, removeProperties, saveRenderInfoInStore, saveSitePagesInStore, writeUniqueFileSync, };

package/build/services/pages.d.ts

@@ -1,6 +1,20 @@
-import type { Fields } from "@griddo/core";
+import type { Core, Fields } from "@griddo/core";
 import type { GriddoListPage, GriddoMultiPage, GriddoPageObject, GriddoSinglePage, MultiPageElements, PageAdditionalInfo } from "../shared/types/pages";
 import type { TemplateWithReferenceField } from "../shared/types/templates";
+/**
+ * Return an OpenGraph object.
+ *
+ * @param props.socialTitle The social title.
+ * @param props.socialDescription The social description.
+ * @param props.socialImage The social image in Cloudinary or DAM url format.
+ */
+declare function getOpenGraph({ socialTitle, socialDescription, socialImage }: Pick<Core.Page, "socialTitle" | "socialDescription" | "socialImage">): Core.Page["openGraph"];
+/**
+ * Get the Page metadata object from a page Object.
+ *
+ * @param params A Page object
+ */
+declare function getPageMetadata(params: Core.Page): GriddoPageObject["context"]["pageMetadata"];
 /**
  * Create a single Griddo page object.
  *
@@ -25,10 +39,67 @@ declare function createGriddoMultiPages(page: GriddoMultiPage, additionalInfo: P
  * @param page The page to get the multipage parts.
  */
 declare function getMultiPageElements(page: TemplateWithReferenceField): Promise<MultiPageElements> | null;
+/**
+ * Get `itemsPerPage` elements from the `items` using as offset `page` number.
+ * It's a kind of paginator for an array.
+ *
+ * @param itemsPerPage The items per page.
+ * @param items An array of items, the queriedData.
+ * @param page The page to be returned.
+ *
+ * @example
+ * getPage(3, ["a", "b", "c", "d", "e", "f", "g", "h"], 2)
+ * // -> ["d", "e", "f"]
+ */
+declare function getPage(itemsPerPage: number, items: Fields.QueriedDataItem[], page: number): Fields.SimpleContentType<Omit<unknown, "__contentTypeKind">>[];
+/**
+ * Takes an array of items and split it grouping in arrays of pages based on `itemsPerPage`.
+ *
+ * @param itemsPerPage The items per page.
+ * @param items An array of items, the queriedData.
+ *
+ * @example
+ * getPageCluster(3, ["a", "b", "c", "d", "e", "f", "g", "h"])
+ * // -> [["a", "b", "c"], ["d", "e", "f"], ["g", "h"]]
+ */
+declare function getPageCluster(itemsPerPage: number, items: Fields.QueriedDataItem[]): Fields.SimpleContentType<Omit<unknown, "__contentTypeKind">>[][];
 /**
  * Takes a template object and split the whole queriedItems into separated queriedItems to use in Griddo static list templates.
  *
  * @param listTemplate A template schema with the ReferenceField data included.
  */
 declare function getPaginatedPages(listTemplate: TemplateWithReferenceField): Fields.SimpleContentType<Omit<unknown, "__contentTypeKind">>[][];
-export { createGriddoListPages, createGriddoMultiPages, createGriddoSinglePage, getMultiPageElements, getPaginatedPages, };
+/**
+ * Remove duplicate ending trailing character from a string
+ *
+ * @param url the strin url
+ * @example
+ * removeDuplicateTrailingSlash('http://griddo.com/foo/bar//')
+ * // -> http://griddo.com/foo/bar/
+ */
+declare function removeDuplicateTrailing(url: string): string;
+/**
+ * Adds a number to an URL adding optionally an ending slash.
+ *
+ * @param url The url.
+ * @param pageNumber A number to be added to the url.
+ * @param options.addEndingSlash Boolean that indicates if return the final url with an end slash or not.
+ *
+ * @example
+ * addPageNumberToUrl("web.com", 3) // "web.com/3"
+ * addPageNumberToUrl("web.com", 3, { addEndingSlash: true }) // "web.com/3/"
+ */
+declare function addPageNumberToUrl(url: string, pageNumber: number, options?: {
+    addEndingSlash: boolean;
+}): string;
+/**
+ * Adds a number to an string with the format "string - number"
+ *
+ * @param title The title
+ * @param pageNumber A number to be added to the title.
+ *
+ * @example
+ * addPageNumberToTitle("The page", 3) // "The page - 3"
+ */
+declare function addPageNumberToTitle(title: string, pageNumber: number): string;
+export { addPageNumberToTitle, addPageNumberToUrl, createGriddoListPages, createGriddoMultiPages, createGriddoSinglePage, getMultiPageElements, getOpenGraph, getPage, getPageCluster, getPageMetadata, getPaginatedPages, removeDuplicateTrailing, };

package/build/services/reference-fields.d.ts

@@ -12,7 +12,7 @@ declare function getReferenceFieldData({ page, cacheKey }: {
     cacheKey: string;
 }): Promise<{
     [key: string]: any;
-    type: "formTemplate" | "template";
+    type: "template" | "formTemplate";
     templateType: string;
     activeSectionSlug: string;
     activeSectionBase: string;

package/build/shared/envs.d.ts

@@ -15,8 +15,11 @@ declare const GRIDDO_SSG_BUNDLE_ANALYZER: boolean;
 declare const GRIDDO_SSG_VERBOSE_LOGS: boolean;
 declare const GRIDDO_USE_DIST_BACKUP: boolean;
 declare const GRIDDO_VERBOSE_LOGS: boolean;
+declare const GRIDDO_RENDER_ENABLED_LLM_MD: boolean;
 declare const GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS: number;
 declare const GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS: number;
+declare const GRIDDO_RENDER_API_TIMEOUT_MS: number;
+declare const GRIDDO_RENDER_CIRCUIT_BREAKER_FAILURE_THRESHOLD: number;
+declare const GRIDDO_RENDER_CIRCUIT_BREAKER_COOLDOWN_MS: number;
 declare const GRIDDO_RENDER_LIFECYCLE_RETRY_ATTEMPTS: number;
-declare const GRIDDO_RENDER_ENABLED_LLM_MD: boolean;
-export { GRIDDO_AI_EMBEDDINGS, GRIDDO_API_CONCURRENCY_COUNT, GRIDDO_API_URL, GRIDDO_ASSET_PREFIX, GRIDDO_BOT_PASSWORD, GRIDDO_BOT_USER, GRIDDO_BUILD_LOGS, GRIDDO_BUILD_LOGS_BUFFER_SIZE, GRIDDO_PUBLIC_API_URL, GRIDDO_REACT_APP_INSTANCE, GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS, GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS, GRIDDO_RENDER_DISABLE_LLMS_TXT, GRIDDO_RENDER_ENABLED_LLM_MD, GRIDDO_RENDER_LIFECYCLE_RETRY_ATTEMPTS, GRIDDO_SEARCH_FEATURE, GRIDDO_SKIP_BUILD_CHECKS, GRIDDO_SSG_BUNDLE_ANALYZER, GRIDDO_SSG_VERBOSE_LOGS, GRIDDO_USE_DIST_BACKUP, GRIDDO_VERBOSE_LOGS, };
+export { GRIDDO_AI_EMBEDDINGS, GRIDDO_API_CONCURRENCY_COUNT, GRIDDO_API_URL, GRIDDO_ASSET_PREFIX, GRIDDO_BOT_PASSWORD, GRIDDO_BOT_USER, GRIDDO_BUILD_LOGS, GRIDDO_BUILD_LOGS_BUFFER_SIZE, GRIDDO_PUBLIC_API_URL, 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, GRIDDO_SEARCH_FEATURE, GRIDDO_SKIP_BUILD_CHECKS, GRIDDO_SSG_BUNDLE_ANALYZER, GRIDDO_SSG_VERBOSE_LOGS, GRIDDO_USE_DIST_BACKUP, GRIDDO_VERBOSE_LOGS, };

package/build/shared/types/api.d.ts

@@ -81,8 +81,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/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -12,7 +12,7 @@ function getRoot(rootFlag) {
 	if (rootFlag) {
 		return path.resolve(rootFlag);
 	}
-	return path.resolve(__dirname, "../../");
+	return process.cwd();
 }
 
 function getDBPath(rootFlag) {
@@ -96,8 +96,8 @@ export const AVAILABLE_COMMANDS = [
 	},
 ];
 
-function showHelp() {
-	console.log("Griddo CX CLI - Available commands:\n");
+export function showHelp() {
+	console.log("Griddo Render Engine CLI - Available commands:\n");
 
 	AVAILABLE_COMMANDS.forEach((cmd) => {
 		const domainArg = cmd.domainArgument ? " --domain=<domain>" : "";
@@ -114,11 +114,11 @@ function showHelp() {
 	console.log("  griddo-render --help");
 }
 
-function findCommand(commandName) {
+export function findCommand(commandName) {
 	return AVAILABLE_COMMANDS.find((cmd) => cmd.name === commandName);
 }
 
-function validateCommand(commandName, config) {
+export function validateCommand(commandName, config) {
 	const command = findCommand(commandName);
 
 	if (!command) {
@@ -154,7 +154,7 @@ function validateCommand(commandName, config) {
 	return { command, config: validatedConfig };
 }
 
-function executeCommand(command, config) {
+export function executeCommand(command, config) {
 	try {
 		const env = { ...process.env };
 		const scriptPath = path.join(COMMANDS_PATH, command.script);
@@ -164,9 +164,11 @@ function executeCommand(command, config) {
 			return;
 		}
 
-		const commandToRun = `node ${scriptPath}${config.domain ? ` ${config.domain}` : ""}${config.noStaticFiles ? " --dry-render" : ""}`;
+		const args = [scriptPath];
+		if (config.domain) args.push(config.domain);
+		if (config.noStaticFiles) args.push("--dry-render");
 
-		execSync(commandToRun, {
+		execFileSync("node", args, {
 			stdio: "inherit",
 			env,
 			cwd: process.cwd(),
@@ -245,4 +247,20 @@ function main() {
 	executeCommand(command, config);
 }
 
-main();
+// Only run when executed directly, not when imported for testing
+// fs.realpathSync is needed to resolve symlinks (e.g. node_modules/.bin/ entries)
+const isDirectRun = (() => {
+	try {
+		return (
+			!!process.argv[1] &&
+			fs.realpathSync(path.resolve(process.argv[1])) ===
+				fs.realpathSync(path.resolve(fileURLToPath(import.meta.url)))
+		);
+	} catch {
+		return false;
+	}
+})();
+
+if (isDirectRun) {
+	main();
+}

package/exporter/commands/README.md

@@ -1,4 +1,4 @@
-# Comandos del Orquestador Griddo CX
+# Comandos del Orquestador Griddo Render Engine
 
 Este directorio contiene los comandos principales de Griddo Exporter (CX). Estos comandos forman parte del ciclo de vida completo del proceso de render de una instancia.
 

package/exporter/commands/end-render.ts

@@ -41,7 +41,7 @@ async function endRender() {
 	const { renderMode, reason } = await getRenderModeFromDB(domain);
 	if (renderMode === RENDER_MODE.IDLE) {
 		GriddoLog.info(
-			`(From Current Render) [${domain}]: Skipping end-render as it is marked as IDLE with the reason ${reason}.`,
+			`(Pre-check) ${domain} skipped end-render as it is marked as <${RENDER_MODE.IDLE}> with the reason <${reason}>`,
 		);
 		return;
 	}

package/exporter/commands/prepare-domains-render.ts

@@ -132,7 +132,7 @@ async function prepareDomains() {
 
 		// Log RenderModes/Reason
 		GriddoLog.info(
-			`(From Initial Render) [${domainSlug}]: Marked as ${renderMode} with the reason: ${reason}`,
+			`(Pre-check) ${domainSlug} marked as <${renderMode}> with the reason <${reason}>`,
 		);
 
 		db.domains[domainSlug] = db.domains[domainSlug] || {};

package/exporter/commands/{single-domain-upload-search-content.ts → single-domain-upload-search-content.noop}

@@ -133,9 +133,7 @@ async function uploadRenderedSearchContentToAPI(options: {
 	const { htmlContentDir, jsonContentDir } = options;
 
 	if (!(await pathExists(jsonContentDir)) || !(await pathExists(htmlContentDir))) {
-		GriddoLog.info(
-			`(From Current Render) Skipping uploading content to the search endpoint because it has not exported sites.`,
-		);
+		GriddoLog.info(`(Pre-check) skipped uploading content because it has not exported sites`);
 
 		return;
 	}
@@ -184,7 +182,7 @@ async function uploadSearchContent() {
 
 	if (renderMode === RENDER_MODE.IDLE) {
 		GriddoLog.info(
-			`(From Current Render) [${domain}]: Skipping upload-search-content as it is marked as IDLE with the reason ${reason}.`,
+			`(Pre-check) ${domain} skipped upload-search-content as it is marked as <${RENDER_MODE.IDLE}> with the reason <${reason}>`,
 		);
 		return;
 	}

package/exporter/commands/upload-search-content.ts

@@ -73,10 +73,7 @@ async function uploadRenderedSearchContentToAPI(options: {
 	const { htmlContentDir, jsonContentDir } = options;
 
 	if (!(await pathExists(jsonContentDir)) || !(await pathExists(htmlContentDir))) {
-		GriddoLog.info(
-			`Skipping uploading content to the search endpoint because it has not exported sites.`,
-		);
-
+		GriddoLog.info(`uploading content skipped because it has not exported sites`);
 		return;
 	}
 

package/exporter/core/check-env-health.ts

@@ -171,4 +171,4 @@ function checkEnvironmentHealth() {
 	throwError(CheckHealthError);
 }
 
-export { checkEnvironmentHealth };
+export { checkDeprecatedEnvVars, checkEnvVarValues, checkEnvironmentHealth, checkRecommendedEnvVars, checkRequiredEnvVars };

package/exporter/core/errors.ts

@@ -1,7 +1,5 @@
 import type { ErrorsType } from "../shared/errors";
 
-import path from "node:path";
-
 import { brush } from "../shared/brush";
 import { RENDER_MODE } from "../shared/types/render";
 import { readDB, writeDB } from "./db";
@@ -66,26 +64,28 @@ async function withErrorHandler(fn: () => Promise<void>) {
 			GriddoLog.error(`An unexpected error occurred ${error}`);
 		}
 
-		// Try to rollback the exports directory if needed
 		try {
 			const data = await readDB();
-			const { root } = data.paths;
-			if (data.needsRollbackOnError) {
-				GriddoLog.info("Cleaning exports dir...");
-				GriddoLog.verbose(`Deleting ${path.join(root, "exports")}...`);
+			const domain = data.currentRenderingDomain;
 
-				await distRollback(data.currentRenderingDomain!);
+			if (!domain) {
+				GriddoLog.warn("No currentRenderingDomain set, skipping cleanup");
 			} else {
-				GriddoLog.info("No rollback needed, skipping...");
+				if (data.needsRollbackOnError) {
+					GriddoLog.info("Cleaning exports dir...");
+					await distRollback(domain);
+				} else {
+					GriddoLog.info("No rollback needed, skipping...");
+				}
+
+				data.domains[domain].isRendering = false;
+				data.domains[domain].renderMode = RENDER_MODE.ERROR;
+				await writeDB(data);
 			}
 		} catch (_e) {
 			GriddoLog.info("Early render stage, no db.json created yet...");
 		}
 
-		const data = await readDB();
-		data.domains[data.currentRenderingDomain!].isRendering = false;
-		data.domains[data.currentRenderingDomain!].renderMode = RENDER_MODE.ERROR;
-		await writeDB(data);
 		throw error;
 	}
 }

package/exporter/core/fs.ts

@@ -39,10 +39,8 @@ async function deleteDisposableSiteDirs(baseDir: string) {
 async function mkDirs(dirs: string[], options?: MakeDirectoryOptions) {
 	for (const dir of dirs) {
 		try {
-			if (!(await pathExists(dir))) {
-				await fsp.mkdir(dir, { recursive: true, ...options });
-				GriddoLog.verbose(`create directory: ${dir}`);
-			}
+			await fsp.mkdir(dir, { recursive: true, ...options });
+			GriddoLog.verbose(`create directory: ${dir}`);
 		} catch (error) {
 			throwError(ArtifactError, error);
 		}
@@ -96,10 +94,8 @@ async function cpDirs(
 		// Copy directory
 		try {
 			// First clean destination
-			if (await pathExists(dstCompose)) {
-				await fsp.rm(dstCompose, { recursive: true, force: true });
-				GriddoLog.verbose(`clean destination: ${dstCompose}`);
-			}
+			await fsp.rm(dstCompose, { recursive: true, force: true });
+			GriddoLog.verbose(`clean destination: ${dstCompose}`);
 
 			// Then copy src to dst
 			await fsp.cp(srcCompose, dstCompose, {
@@ -153,7 +149,7 @@ async function mvDirs(
 
 		try {
 			// Clean destination
-			if (override && (await pathExists(dstCompose))) {
+			if (override) {
 				await fsp.rm(dstCompose, { recursive: true, force: true });
 			}
 
@@ -203,10 +199,6 @@ async function restoreBackup(src: string, suffix = "-BACKUP") {
 async function deleteBackup(src: string, suffix = "-BACKUP") {
 	const dst = src + suffix;
 
-	if (!(await pathExists(dst))) {
-		return;
-	}
-
 	try {
 		await fsp.rm(dst, { recursive: true, force: true });
 		GriddoLog.verbose(`Backup ${dst} has been deleted`);
@@ -252,6 +244,8 @@ async function siteIsEmpty(sitePath: string) {
 	if (siteFiles.length === xmlFiles.length) {
 		return true;
 	}
+
+	return false;
 }
 
 /**
@@ -334,14 +328,18 @@ async function pathExists(dir: string) {
  */
 async function* findFilesBySuffix(dir: string, suffix: string): AsyncGenerator<string> {
 	const dirHandle = await fsp.opendir(dir);
-	for await (const item of dirHandle) {
-		const fullPath = path.join(dir, item.name);
-		if (item.isDirectory()) {
-			// yield* para encadenar otro generator.
-			yield* findFilesBySuffix(fullPath, suffix);
-		} else if (item.isFile() && item.name.endsWith(suffix)) {
-			yield fullPath;
+	try {
+		for await (const item of dirHandle) {
+			const fullPath = path.join(dir, item.name);
+			if (item.isDirectory()) {
+				// yield* para encadenar otro generator.
+				yield* findFilesBySuffix(fullPath, suffix);
+			} else if (item.isFile() && item.name.endsWith(suffix)) {
+				yield fullPath;
+			}
 		}
+	} finally {
+		await dirHandle.close().catch(() => {});
 	}
 }
 
@@ -354,20 +352,26 @@ async function* findFilesBySuffix(dir: string, suffix: string): AsyncGenerator<s
  */
 async function* walkStore(storeDir: string): AsyncGenerator<string> {
 	const storeDirHandle = await fsp.opendir(storeDir);
-
-	for await (const siteDirent of storeDirHandle) {
-		if (siteDirent.isDirectory()) {
-			const siteDirPath = path.join(storeDir, siteDirent.name);
-			const siteDirHandle = await fsp.opendir(siteDirPath);
-
-			for await (const fileDirent of siteDirHandle) {
-				const filePath = path.join(siteDirPath, fileDirent.name);
-
-				if (fileDirent.isFile() && path.extname(filePath) === ".json") {
-					yield filePath;
+	try {
+		for await (const siteDirent of storeDirHandle) {
+			if (siteDirent.isDirectory()) {
+				const siteDirPath = path.join(storeDir, siteDirent.name);
+				const siteDirHandle = await fsp.opendir(siteDirPath);
+				try {
+					for await (const fileDirent of siteDirHandle) {
+						const filePath = path.join(siteDirPath, fileDirent.name);
+
+						if (fileDirent.isFile() && path.extname(filePath) === ".json") {
+							yield filePath;
+						}
+					}
+				} finally {
+					await siteDirHandle.close().catch(() => {});
 				}
 			}
 		}
+	} finally {
+		await storeDirHandle.close().catch(() => {});
 	}
 }
 

package/exporter/core/http/create-adapter.ts

@@ -0,0 +1,58 @@
+import type { HttpAdapter } from "./types";
+
+import {
+	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,
+} from "../../shared/envs";
+import { GriddoLog } from "../GriddoLog";
+import { createUndiciAdapter } from "./undici-adapter";
+import { withCircuitBreaker } from "./with-circuit-breaker";
+import { withRetry } from "./with-retry";
+
+let adapter: HttpAdapter | undefined;
+
+/**
+ * Sync getter del adapter HTTP.
+ *
+ * Composición:
+ *   circuitBreaker → retry(exponential + jitter) → undici(timeout nativo)
+ */
+function getHttpAdapter(): HttpAdapter {
+	if (!adapter) {
+		adapter = withCircuitBreaker(
+			withRetry(createUndiciAdapter({ timeoutMs: GRIDDO_RENDER_API_TIMEOUT_MS }), {
+				attempts: GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS,
+				delayMs: GRIDDO_RENDER_API_FETCH_RETRY_WAIT_SECONDS * 1000,
+				backoff: "exponential",
+				jitter: true,
+				retryOn: (res) => res.status >= 500,
+				onRetry: ({ request: req, attempt, delayMs, error, response }) => {
+					const cause = response ? `HTTP ${response.status}` : error?.message;
+					GriddoLog.warn(
+						`Retry ${attempt}/${GRIDDO_RENDER_API_FETCH_RETRY_ATTEMPTS}: ${req.method} ${req.url} — ${cause} (next in ${delayMs}ms)`,
+					);
+				},
+			}),
+			{
+				failureThreshold: GRIDDO_RENDER_CIRCUIT_BREAKER_FAILURE_THRESHOLD,
+				cooldownMs: GRIDDO_RENDER_CIRCUIT_BREAKER_COOLDOWN_MS,
+				onOpen: () => GriddoLog.warn("Circuit breaker OPEN — requests will fail fast"),
+				onClose: () => GriddoLog.info("Circuit breaker CLOSED — recovered"),
+			},
+		);
+		GriddoLog.verbose("HTTP adapter: undici (timeout + retry + circuit breaker)");
+	}
+	return adapter;
+}
+
+/**
+ * Reset del singleton (para tests).
+ */
+function resetHttpAdapter(): void {
+	adapter = undefined;
+}
+
+export { getHttpAdapter, resetHttpAdapter };

package/exporter/core/http/index.ts

@@ -0,0 +1,7 @@
+export type { HttpAdapter, HttpRequest, HttpResponse } from "./types";
+export type { CircuitBreakerOptions } from "./with-circuit-breaker";
+export type { RetryOptions } from "./with-retry";
+
+export { getHttpAdapter, resetHttpAdapter } from "./create-adapter";
+export { CircuitOpenError, withCircuitBreaker } from "./with-circuit-breaker";
+export { withRetry } from "./with-retry";

package/exporter/core/http/types.ts

@@ -0,0 +1,22 @@
+/** Descriptor de request que recibe el adapter. */
+export interface HttpRequest {
+	url: string;
+	method: string;
+	headers: Record<string, string>;
+	body?: string;
+}
+
+/** Descriptor de response que devuelve el adapter. */
+export interface HttpResponse {
+	status: number;
+	statusText: string;
+	ok: boolean;
+	headers: Record<string, string>;
+	json: <T = unknown>() => Promise<T>;
+	text: () => Promise<string>;
+}
+
+/** Contrato del adapter. Un solo metodo, sin estado. */
+export interface HttpAdapter {
+	request: (req: HttpRequest) => Promise<HttpResponse>;
+}

package/exporter/core/http/undici-adapter.ts

@@ -0,0 +1,53 @@
+import type { HttpAdapter, HttpRequest, HttpResponse } from "./types";
+
+import { request } from "undici";
+
+export interface UndiciAdapterOptions {
+	/** Request timeout in milliseconds. Cancels the request if exceeded. */
+	timeoutMs?: number;
+}
+
+function createUndiciAdapter(options: UndiciAdapterOptions = {}): HttpAdapter {
+	const { timeoutMs } = options;
+
+	return {
+		async request(req: HttpRequest): Promise<HttpResponse> {
+			const {
+				statusCode,
+				headers: rawHeaders,
+				body,
+			} = await request(req.url, {
+				method: req.method as "GET" | "POST" | "PUT" | "PATCH" | "DELETE",
+				headers: req.headers,
+				body: req.body,
+				signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,
+			});
+
+			const headers: Record<string, string> = {};
+			for (const [key, value] of Object.entries(rawHeaders)) {
+				if (value !== undefined) {
+					headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
+				}
+			}
+
+			let buffered: string | undefined;
+			const getText = async () => {
+				if (buffered === undefined) {
+					buffered = await body.text();
+				}
+				return buffered;
+			};
+
+			return {
+				status: statusCode,
+				statusText: "",
+				ok: statusCode >= 200 && statusCode < 300,
+				headers,
+				json: async <T>() => JSON.parse(await getText()) as T,
+				text: getText,
+			};
+		},
+	};
+}
+
+export { createUndiciAdapter };