@griddo/cx 11.13.3 → 11.14.0

package/build/index.js

@@ -24918,6 +24918,7 @@ function safeParseInt(value, fallback) {
   return Number.isNaN(parsed) ? fallback : parsed;
 }
 var GRIDDO_AI_EMBEDDINGS = envIsTruthy(env.GRIDDO_AI_EMBEDDINGS);
+var GRIDDO_INDEXNOW_ENABLED = envIsTruthy(env.GRIDDO_INDEXNOW_ENABLED);
 var GRIDDO_API_CONCURRENCY_COUNT = safeParseInt(env.GRIDDO_API_CONCURRENCY_COUNT || env.GRIDDO_RENDER_CONCURRENCY_COUNT || "10", 10);
 var GRIDDO_ASSET_PREFIX = env.GRIDDO_ASSET_PREFIX || env.ASSET_PREFIX || env.GRIDDO_RENDER_ASSET_PREFIX;
 var GRIDDO_BUILD_LOGS = envIsTruthy(env.GRIDDO_BUILD_LOGS || env.GRIDDO_RENDER_BUILD_LOGS);
@@ -25327,7 +25328,7 @@ var SITE_URI = `${GRIDDO_API_URL2}/site/`;
 var package_default = {
   name: "@griddo/cx",
   description: "Griddo SSG based on Gatsby",
-  version: "11.13.3",
+  version: "11.14.0",
   authors: [
     "Hisco <francis.vega@griddo.io>"
   ],
@@ -25366,6 +25367,7 @@ var package_default = {
     "start-render": "node ./build/commands/start-render",
     "end-render": "node ./build/commands/end-render",
     "upload-search-content": "node ./build/commands/upload-search-content",
+    "notify-indexnow": "node ./build/commands/notify-indexnow",
     "reset-render": "node ./build/commands/reset-render",
     "// ONLY LOCAL SCRIPTS": "",
     "prepare-assets-directory": "node ./build/commands/prepare-assets-directory",
@@ -25387,7 +25389,7 @@ var package_default = {
   },
   devDependencies: {
     "@biomejs/biome": "2.3.4",
-    "@griddo/core": "11.13.3",
+    "@griddo/core": "11.14.0",
     "@types/node": "20.19.4",
     "@typescript/native-preview": "7.0.0-dev.20260401.1",
     cheerio: "1.1.2",
@@ -25421,7 +25423,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  gitHead: "6dd412b5408e057baa6c1c89f4815c85c7e16a45"
+  gitHead: "d2c96b30e53ce16a9d06df7fd512308ae6fff64c"
 };
 
 // exporter/shared/headers.ts

package/build/services/indexnow-key-file.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Derive the IndexNow key for a given domain. It is a deterministic function
+ * of the domain slug so every machine and every rerun produces the same key.
+ * IndexNow only requires the key to be 8-128 alphanumeric chars and to match
+ * the file served at the host root; it does not need to be secret (ownership
+ * is proven by the ability to serve the file, not by the key being private).
+ */
+declare function getIndexNowKeyForDomain(domain: string): string;
+/**
+ * Filename served at the public root of every domain so IndexNow can verify
+ * ownership of the host. Returns `null` when the feature is disabled, which
+ * also means the file will not be written.
+ */
+declare function getIndexNowKeyFilename(domain: string): string | null;
+/**
+ * Write the IndexNow host-key file to the domain `current-dist` so it ends up
+ * served at `https://<host>/<key>.txt`. On FROM_SCRATCH the file is carried
+ * over via the `current-dist -> dist` rename; on INCREMENTAL it is pulled in
+ * through the `artifactsToCopyToExports` list (see sync action).
+ */
+declare function generateIndexNowKeyFile(domain: string): Promise<void>;
+export { generateIndexNowKeyFile, getIndexNowKeyFilename, getIndexNowKeyForDomain };

package/build/services/indexnow-notify.d.ts

@@ -0,0 +1,29 @@
+export interface NotifyDomainResult {
+    domain: string;
+    sent: number;
+    upsertCount: number;
+    deleteCount: number;
+    requests: number;
+    succeeded: boolean;
+}
+/**
+ * Read the payload emitted by `IndexNowCollector`, group URLs by host and POST
+ * each batch to the IndexNow endpoint. Sends upserts and deletes together in a
+ * single request per host (dedup by URL). Deletes the payload file only when
+ * every request succeeded, so a partial failure leaves the file in place for a
+ * later retry.
+ */
+declare function notifyDomain(options: {
+    domain: string;
+    key: string;
+}): Promise<NotifyDomainResult | null>;
+/**
+ * Orchestrate the IndexNow notification for a single domain. Applies the
+ * feature flag and dry-run skips, resolves the host key and delegates to
+ * `notifyDomain`. Logs a summary line when a request actually ran.
+ */
+declare function notifyIndexNowForDomain(options: {
+    slug: string;
+    dryRun: boolean;
+}): Promise<void>;
+export { notifyDomain, notifyIndexNowForDomain };

package/build/services/indexnow-payload.d.ts

@@ -0,0 +1,54 @@
+import type { GriddoPageObject } from "../shared/types/pages";
+import type { Site } from "../shared/types/sites";
+export interface IndexNowUpsertEntry {
+    id: number;
+    url: string;
+    siteId: number;
+}
+export interface IndexNowDeleteEntry {
+    id: number;
+    url: string;
+    siteId: number;
+    reason: "offlinePending" | "siteUnpublished";
+}
+export interface IndexNowPayloadFile {
+    domain: string;
+    renderedAt: string;
+    upsert: IndexNowUpsertEntry[];
+    delete: IndexNowDeleteEntry[];
+    skipped: {
+        noindex: number;
+        noUrlResolved: number;
+        paginatedSecondary: number;
+    };
+}
+interface FlushOptions {
+    domain: string;
+    sitesToPublish: Site[];
+    sitesToUnpublish: Site[];
+}
+interface CollectOptions {
+    siteId: number;
+    pageId: number;
+    pageObjects: GriddoPageObject[];
+    uploadPending: number[];
+}
+/**
+ * Collects URLs that should be notified to IndexNow during `createStore`.
+ * Intended usage:
+ * - `collect()` during the per-page loop (reuses the already-fetched page
+ *   objects, so upserts cost 0 extra API calls).
+ * - `flush()` once per render to resolve delete URLs via `getPage` and write
+ *   the payload file to `.griddo/cache/<domain>/indexnow-payload.json`.
+ */
+declare class IndexNowCollector {
+    readonly enabled: boolean;
+    private upserts;
+    private skipped;
+    constructor(enabled?: boolean);
+    collect(options: CollectOptions): void;
+    flush(options: FlushOptions): Promise<void>;
+    private extractCanonical;
+    private resolveUrlForId;
+}
+export { IndexNowCollector };

package/build/services/render.d.ts

@@ -59,6 +59,7 @@ declare function getRenderPathsHydratedWithDomainFromDB(options?: {
     __ssg: string;
     __exports_dist: string;
 }>;
+declare function getDomainDryRunFromDB(domain: string): Promise<boolean>;
 declare function getRenderMetadataFromDB(): Promise<{
     griddoVersion: string;
     buildReportFileName: string;
@@ -67,4 +68,4 @@ declare function getRenderMetadataFromDB(): Promise<{
  * Save a file with the end of build process to use as `end-render` signal.
  */
 declare function generateBuildReport(domain: string): Promise<void>;
-export { assertRenderIsValid, generateBuildReport, getRenderMetadataFromDB, getRenderModeFromDB, getRenderPathsHydratedWithDomainFromDB, markRenderAsCompleted, markRenderAsStarted, resolveDomainRenderMode, updateCommitFile, };
+export { assertRenderIsValid, generateBuildReport, getDomainDryRunFromDB, getRenderMetadataFromDB, getRenderModeFromDB, getRenderPathsHydratedWithDomainFromDB, markRenderAsCompleted, markRenderAsStarted, resolveDomainRenderMode, updateCommitFile, };

package/build/shared/envs.d.ts

@@ -3,6 +3,7 @@ declare const GRIDDO_PUBLIC_API_URL: string | undefined;
 declare const GRIDDO_BOT_USER: string | undefined;
 declare const GRIDDO_BOT_PASSWORD: string | undefined;
 declare const GRIDDO_AI_EMBEDDINGS: boolean;
+declare const GRIDDO_INDEXNOW_ENABLED: boolean;
 declare const GRIDDO_API_CONCURRENCY_COUNT: number;
 declare const GRIDDO_ASSET_PREFIX: string | undefined;
 declare const GRIDDO_BUILD_LOGS: boolean;
@@ -22,4 +23,4 @@ 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;
-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, };
+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_INDEXNOW_ENABLED, 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/cli.mjs

@@ -85,6 +85,15 @@ export const AVAILABLE_COMMANDS = [
 		rootArgument: true,
 		noStaticFiles: false,
 	},
+	{
+		name: "notify-indexnow",
+		description: "Notify IndexNow with the render delta of every domain",
+		domainArgument: false,
+		script: "notify-indexnow",
+		isCommandPack: false,
+		rootArgument: true,
+		noStaticFiles: false,
+	},
 	{
 		name: "reset-render",
 		description: "Reset render state",

package/exporter/build.sh

@@ -20,6 +20,7 @@ esbuild ${log} ./exporter/react/index.tsx ${react_opts} --outfile=./build/react/
 # This .sh needs to be run from a npm script, so esbuild dependency is available
 esbuild ${log} ./exporter/commands/end-render.ts ${bundle_node_opts}end-render.js
 esbuild ${log} ./exporter/commands/upload-search-content.ts ${bundle_node_opts}upload-search-content.js
+esbuild ${log} ./exporter/commands/notify-indexnow.ts ${bundle_node_opts}notify-indexnow.js
 esbuild ${log} ./exporter/commands/reset-render.ts ${bundle_node_opts}reset-render.js
 esbuild ${log} ./exporter/commands/start-render.ts ${bundle_node_opts}start-render.js
 esbuild ${log} ./exporter/commands/prepare-domains-render.ts ${bundle_node_opts}prepare-domains-render.js

package/exporter/commands/end-render.ts

@@ -5,7 +5,9 @@ import { throwError, withErrorHandler } from "../core/errors";
 import { pathExists } from "../core/fs";
 import { GriddoLog } from "../core/GriddoLog";
 import { AuthService } from "../services/auth";
+import { notifyIndexNowForDomain } from "../services/indexnow-notify";
 import {
+	getDomainDryRunFromDB,
 	getRenderMetadataFromDB,
 	getRenderModeFromDB,
 	getRenderPathsHydratedWithDomainFromDB,
@@ -62,6 +64,15 @@ async function endRender() {
 		GriddoLog.info(`Site (${siteId})`);
 		await endSiteRender(siteId, body);
 	}
+
+	try {
+		const dryRun = await getDomainDryRunFromDB(domain);
+		await notifyIndexNowForDomain({ slug: domain, dryRun });
+	} catch (err) {
+		GriddoLog.warn(
+			`indexnow: notify failed for ${domain}: ${(err as Error)?.message ?? String(err)}`,
+		);
+	}
 }
 
 async function main() {

package/exporter/commands/notify-indexnow.ts

@@ -0,0 +1,19 @@
+import { withErrorHandler } from "../core/errors";
+import { AuthService } from "../services/auth";
+import { getInstanceDomains } from "../services/domains";
+import { notifyIndexNowForDomain } from "../services/indexnow-notify";
+
+async function notifyIndexNow() {
+	const domains = await getInstanceDomains();
+
+	for (const { slug, dryRun } of domains) {
+		await notifyIndexNowForDomain({ slug, dryRun });
+	}
+}
+
+async function main() {
+	await AuthService.login();
+	await notifyIndexNow();
+}
+
+withErrorHandler(main);

package/exporter/services/generate-md.ts

@@ -28,20 +28,17 @@ export async function generateMdsFromHtmls(domain: string) {
 
 	try {
 		for await (const page of pages) {
-			// Es home de dominio
-			// Evitamos hacer markdown del home principal del dominio porque ahí irá el llms.txt
-			if (page.path === path.join(distDirectory, "index.html")) continue;
-
 			// No es index.html
 			// evita parsear algunos htmls que se cuelan de gatsby...
 			if (!page.path.endsWith("index.html")) continue;
 
-			const pathWithoutIndexHtml = page.path.split(/\/index\.html$/);
-			let file = "";
-			if (pathWithoutIndexHtml.length === 2) {
-				file = pathWithoutIndexHtml[0];
-			}
-			await fsp.writeFile(`${file}.md`, page.content);
+			// Home del dominio: escribimos dist/index.md porque dominio.com.md en browser queda raro
+			const isHome = page.path === path.join(distDirectory, "index.html");
+			const outPath = isHome
+				? path.join(distDirectory, "index.md")
+				: `${page.path.replace(/\/index\.html$/, "")}.md`;
+
+			await fsp.writeFile(outPath, page.content);
 			GriddoLog.info(`Generating MD for a ${page.path}`);
 		}
 	} catch (error) {

package/exporter/services/indexnow-key-file.ts

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { GriddoLog } from "../core/GriddoLog";
+import { GRIDDO_INDEXNOW_ENABLED } from "../shared/envs";
+import { getRenderPathsHydratedWithDomainFromDB } from "./render";
+
+const KEY_LENGTH = 32;
+
+/**
+ * Derive the IndexNow key for a given domain. It is a deterministic function
+ * of the domain slug so every machine and every rerun produces the same key.
+ * IndexNow only requires the key to be 8-128 alphanumeric chars and to match
+ * the file served at the host root; it does not need to be secret (ownership
+ * is proven by the ability to serve the file, not by the key being private).
+ */
+function getIndexNowKeyForDomain(domain: string): string {
+	return createHash("sha256").update(domain, "utf-8").digest("hex").slice(0, KEY_LENGTH);
+}
+
+/**
+ * Filename served at the public root of every domain so IndexNow can verify
+ * ownership of the host. Returns `null` when the feature is disabled, which
+ * also means the file will not be written.
+ */
+function getIndexNowKeyFilename(domain: string): string | null {
+	if (!GRIDDO_INDEXNOW_ENABLED) return null;
+	return `${getIndexNowKeyForDomain(domain)}.txt`;
+}
+
+/**
+ * Write the IndexNow host-key file to the domain `current-dist` so it ends up
+ * served at `https://<host>/<key>.txt`. On FROM_SCRATCH the file is carried
+ * over via the `current-dist -> dist` rename; on INCREMENTAL it is pulled in
+ * through the `artifactsToCopyToExports` list (see sync action).
+ */
+async function generateIndexNowKeyFile(domain: string): Promise<void> {
+	const filename = getIndexNowKeyFilename(domain);
+	if (!filename) return;
+
+	const key = getIndexNowKeyForDomain(domain);
+	const { __root } = await getRenderPathsHydratedWithDomainFromDB({ domain });
+	const distDirectory = path.join(__root, "current-dist");
+	const filePath = path.join(distDirectory, filename);
+
+	try {
+		await fsp.mkdir(distDirectory, { recursive: true });
+		await fsp.writeFile(filePath, key, "utf-8");
+		GriddoLog.verbose(`indexnow: wrote host-key file ${filePath}`);
+	} catch (err) {
+		GriddoLog.warn(
+			`indexnow: failed to write host-key file ${filePath}: ${(err as Error)?.message ?? String(err)}`,
+		);
+	}
+}
+
+export { generateIndexNowKeyFile, getIndexNowKeyFilename, getIndexNowKeyForDomain };

package/exporter/services/indexnow-notify.ts

@@ -0,0 +1,196 @@
+import type { IndexNowPayloadFile } from "./indexnow-payload";
+
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { GriddoLog } from "../core/GriddoLog";
+import { GRIDDO_INDEXNOW_ENABLED } from "../shared/envs";
+import { getIndexNowKeyForDomain } from "./indexnow-key-file";
+import { getRenderPathsHydratedWithDomainFromDB } from "./render";
+
+const INDEXNOW_ENDPOINT = "https://api.indexnow.org/indexnow";
+const INDEXNOW_MAX_URLS_PER_REQUEST = 10_000;
+
+export interface NotifyDomainResult {
+	domain: string;
+	sent: number;
+	upsertCount: number;
+	deleteCount: number;
+	requests: number;
+	succeeded: boolean;
+}
+
+/**
+ * Read the payload emitted by `IndexNowCollector`, group URLs by host and POST
+ * each batch to the IndexNow endpoint. Sends upserts and deletes together in a
+ * single request per host (dedup by URL). Deletes the payload file only when
+ * every request succeeded, so a partial failure leaves the file in place for a
+ * later retry.
+ */
+async function notifyDomain(options: {
+	domain: string;
+	key: string;
+}): Promise<NotifyDomainResult | null> {
+	const { domain, key } = options;
+	const { __cache } = await getRenderPathsHydratedWithDomainFromDB({ domain });
+	const payloadPath = path.join(__cache, "indexnow-payload.json");
+
+	const payload = await readPayload(payloadPath);
+	if (!payload) {
+		GriddoLog.verbose(`indexnow: no payload for ${domain}, skipping`);
+		return null;
+	}
+
+	const upsertCount = payload.upsert.length;
+	const deleteCount = payload.delete.length;
+
+	const urls = collectUrls(payload);
+	if (urls.length === 0) {
+		GriddoLog.verbose(`indexnow: empty payload for ${domain}, removing file`);
+		await safeUnlink(payloadPath);
+		return { domain, sent: 0, upsertCount, deleteCount, requests: 0, succeeded: true };
+	}
+
+	const byHost = groupByHost(urls);
+	let requests = 0;
+	let succeeded = true;
+
+	for (const [host, hostUrls] of byHost) {
+		for (const batch of batchUrls(hostUrls, INDEXNOW_MAX_URLS_PER_REQUEST)) {
+			requests++;
+			const ok = await postBatch({ host, key, urlList: batch });
+			if (!ok) succeeded = false;
+		}
+	}
+
+	if (succeeded) {
+		await safeUnlink(payloadPath);
+	}
+
+	return { domain, sent: urls.length, upsertCount, deleteCount, requests, succeeded };
+}
+
+function collectUrls(payload: IndexNowPayloadFile): string[] {
+	const set = new Set<string>();
+	for (const entry of payload.upsert) set.add(entry.url);
+	for (const entry of payload.delete) set.add(entry.url);
+	return Array.from(set);
+}
+
+function groupByHost(urls: string[]): Map<string, string[]> {
+	const byHost = new Map<string, string[]>();
+	for (const url of urls) {
+		let host: string;
+		try {
+			host = new URL(url).host;
+		} catch {
+			GriddoLog.warn(`indexnow: invalid URL skipped: ${url}`);
+			continue;
+		}
+		const list = byHost.get(host);
+		if (list) list.push(url);
+		else byHost.set(host, [url]);
+	}
+	return byHost;
+}
+
+function* batchUrls(urls: string[], size: number): Generator<string[]> {
+	for (let i = 0; i < urls.length; i += size) {
+		yield urls.slice(i, i + size);
+	}
+}
+
+async function postBatch(options: {
+	host: string;
+	key: string;
+	urlList: string[];
+}): Promise<boolean> {
+	const { host, key, urlList } = options;
+	const payload = {
+		host,
+		key,
+		keyLocation: `https://${host}/${key}.txt`,
+		urlList,
+	};
+
+	try {
+		const response = await fetch(INDEXNOW_ENDPOINT, {
+			method: "POST",
+			headers: { "Content-Type": "application/json; charset=utf-8" },
+			body: JSON.stringify(payload),
+		});
+
+		if (!response.ok) {
+			const bodyText = await safeReadBody(response);
+			GriddoLog.warn(
+				`indexnow: ${host} HTTP ${response.status} (${urlList.length} urls)${bodyText ? `: ${bodyText}` : ""}`,
+			);
+			return false;
+		}
+
+		GriddoLog.verbose(`indexnow: ${host} pinged (${urlList.length} urls, HTTP ${response.status})`);
+		return true;
+	} catch (err) {
+		GriddoLog.warn(`indexnow: ${host} request failed: ${(err as Error)?.message ?? String(err)}`);
+		return false;
+	}
+}
+
+async function safeReadBody(response: Response): Promise<string> {
+	try {
+		const text = await response.text();
+		return text.slice(0, 200);
+	} catch {
+		return "";
+	}
+}
+
+async function readPayload(p: string): Promise<IndexNowPayloadFile | null> {
+	try {
+		const raw = await fsp.readFile(p, "utf-8");
+		return JSON.parse(raw) as IndexNowPayloadFile;
+	} catch {
+		return null;
+	}
+}
+
+async function safeUnlink(p: string): Promise<void> {
+	try {
+		await fsp.unlink(p);
+	} catch {
+		// Missing file is fine.
+	}
+}
+
+/**
+ * Orchestrate the IndexNow notification for a single domain. Applies the
+ * feature flag and dry-run skips, resolves the host key and delegates to
+ * `notifyDomain`. Logs a summary line when a request actually ran.
+ */
+async function notifyIndexNowForDomain(options: {
+	slug: string;
+	dryRun: boolean;
+}): Promise<void> {
+	const { slug, dryRun } = options;
+
+	if (!GRIDDO_INDEXNOW_ENABLED) {
+		GriddoLog.info("indexnow: feature disabled (GRIDDO_INDEXNOW_ENABLED), skipping");
+		return;
+	}
+
+	if (dryRun) {
+		GriddoLog.verbose(`indexnow: domain ${slug} ignored by dry-render`);
+		return;
+	}
+
+	const key = getIndexNowKeyForDomain(slug);
+	const result = await notifyDomain({ domain: slug, key });
+	if (!result) return;
+
+	const status = result.succeeded ? "ok" : "partial failure";
+	GriddoLog.info(
+		`indexnow: ${result.domain} -> ${result.sent} urls (${result.upsertCount} upsert, ${result.deleteCount} delete) in ${result.requests} request(s) [${status}]`,
+	);
+}
+
+export { notifyDomain, notifyIndexNowForDomain };