freestruct 1.0.0 → 1.1.0

package/engine/config.js

@@ -20,7 +20,8 @@ export const KNOWN_CONFIG_KEYS = Object.freeze([
   'site', 'twitter', 'og', 'author', 'jsonLd', 'basePath', 'outputDir', 'minify', 'runHooks',
   'generateSitemap', 'generateFeed', 'generate404', 'generateRobots',
   'readingTime', 'lastModified', 'lazyLoad', 'linkCheck', 'searchIndex',
-  'cacheBusting',
+  'cacheBusting', 'hooks', 'indexNow', 'ogImageGeneration',
+  'search', 'breadcrumb', 'verification', 'llms', 'locales', 'article',
 ]);
 
 // Flags that EXISTED and no longer do anything. We warn loudly, never guess.
@@ -82,6 +83,211 @@ export function collectConfigDiagnostics(config, configName) {
     if (config.site.url === undefined) warnings.push('site.url missing - canonical/sitemap/feed urls will be broken');
   }
 
+  // og.image shape (issue #20): the back-compat string form is always fine;
+  // the object form accepts { src, width, height, alt, allowSvg }. Wrong
+  // shapes warn loudly here and the engine keeps its behavior honest (no
+  // image ships when src is not a usable string).
+  const ogImageShape = config.og?.image;
+  if (ogImageShape && typeof ogImageShape === 'string' && ogImageShape !== ''
+      && /\.svg$/i.test(ogImageShape.split(/[?#]/)[0])) {
+    warnings.push('og.image src "' + ogImageShape + '" is an SVG: most social scrapers cannot render it and the share preview blanks (ship a raster image, or switch to the object form { src: ..., allowSvg: true } to accept it)');
+  }
+  if (ogImageShape !== undefined && ogImageShape !== null && typeof ogImageShape === 'object') {
+    if (Array.isArray(ogImageShape)) {
+      warnings.push('og.image must be a string or a { src, width, height, alt } object, not an array - no image ships');
+    } else {
+      if (typeof ogImageShape.src !== 'string' || ogImageShape.src === '') {
+        warnings.push('og.image object is missing a string src - no image ships (the plain string form still works)');
+      } else if (/\.svg$/i.test(String(ogImageShape.src).split(/[?#]/)[0])
+          && ogImageShape.allowSvg !== true) {
+        warnings.push('og.image src "' + ogImageShape.src + '" is an SVG: most social scrapers cannot render it and the share preview blanks (ship a raster image, or set allowSvg: true to accept it)');
+      }
+      const KNOWN_OGIMAGE_KEYS = ['src', 'width', 'height', 'alt', 'allowSvg'];
+      const unknownOg = Object.keys(ogImageShape).filter(k => !KNOWN_OGIMAGE_KEYS.includes(k));
+      if (unknownOg.length > 0) {
+        warnings.push('unknown og.image companion key(s): "' + unknownOg.join('", "') + '" (known: ' + KNOWN_OGIMAGE_KEYS.join(', ') + ')');
+      }
+      if (ogImageShape.width !== undefined && ogImageShape.width !== '') {
+        const w = Number(ogImageShape.width);
+        if (!Number.isFinite(w) || w <= 0) warnings.push('og.image.width must be a positive number - it will be dropped');
+      }
+      if (ogImageShape.height !== undefined && ogImageShape.height !== '') {
+        const h = Number(ogImageShape.height);
+        if (!Number.isFinite(h) || h <= 0) warnings.push('og.image.height must be a positive number - it will be dropped');
+      }
+      if (ogImageShape.alt !== undefined && typeof ogImageShape.alt !== 'string' && typeof ogImageShape.alt !== 'number') {
+        warnings.push('og.image.alt must be a string or number - it will be dropped');
+      }
+      if (ogImageShape.allowSvg !== undefined && typeof ogImageShape.allowSvg !== 'boolean') {
+        warnings.push('og.image.allowSvg must be a boolean');
+      }
+    }
+  }
+
+  // hooks shape (issue #21): hooks is an object keyed by hook seam; each
+  // seam takes one string command or a list of them. Unknown seams and
+  // non-string entries warn loudly here, and the runner treats both
+  // honestly (non-strings are skipped, unknown seams have no runner).
+  if (config.hooks !== undefined && (typeof config.hooks !== 'object' || config.hooks === null || Array.isArray(config.hooks))) {
+    warnings.push('hooks must be a { postBuild: [...] } object, not ' + (Array.isArray(config.hooks) ? 'an array' : typeof config.hooks));
+  } else if (config.hooks) {
+    const KNOWN_HOOK_SEAMS = ['postBuild'];
+    for (const seam of Object.keys(config.hooks)) {
+      if (KNOWN_HOOK_SEAMS.includes(seam)) continue;
+      warnings.push('unknown hooks seam "' + seam + '" (known: ' + KNOWN_HOOK_SEAMS.join(', ') + ')');
+    }
+    const postBuild = config.hooks.postBuild;
+    if (postBuild !== undefined && !Array.isArray(postBuild) && typeof postBuild !== 'string') {
+      warnings.push('hooks.postBuild must be a string command or a list of string commands');
+    } else if (Array.isArray(postBuild)) {
+      for (const entry of postBuild) {
+        if (typeof entry !== 'string' || entry === '') {
+          warnings.push('every hooks.postBuild entry must be a non-empty string command');
+          break;
+        }
+      }
+    }
+  }
+
+  // indexNow shape (issue #19): true (generate-once-and-persist) or
+  // { key: '<32-hex>' }. A wrong-shaped key warns here and the indexnow
+  // subcommand refuses it too - no silently-dead submission command.
+  if (config.indexNow !== undefined && config.indexNow !== null && config.indexNow !== false) {
+    if (config.indexNow === true) {
+      // generate-once-and-persist path: shape is fine
+    } else if (typeof config.indexNow === 'string' || typeof config.indexNow === 'object') {
+      const key = typeof config.indexNow === 'string' ? config.indexNow : config.indexNow.key;
+      if (!/^[a-f0-9]{32}$/.test(String(key || ''))) {
+        warnings.push('indexNow key must be 32 lowercase hex chars (the IndexNow key contract) - the key file will not ship');
+      }
+      if (typeof config.indexNow === 'object') {
+        const unknownIdx = Object.keys(config.indexNow).filter(k => k !== 'key');
+        if (unknownIdx.length > 0) {
+          warnings.push('unknown indexNow key(s): "' + unknownIdx.join('", "') + '"');
+        }
+      }
+    } else {
+      warnings.push('indexNow must be true or { key: "<32-hex>" }');
+    }
+  }
+
+  // ogImageGeneration shape (issue #22): a { template, font?, width?,
+  // height? } object. Runtime resolution (engine/ogimage.js) warns on
+  // missing templates; here we catch the key-level shape mistakes.
+  if (config.ogImageGeneration !== undefined && (typeof config.ogImageGeneration !== 'object' || config.ogImageGeneration === null || Array.isArray(config.ogImageGeneration))) {
+    warnings.push('ogImageGeneration must be a { template, font, width, height } object, not ' + (Array.isArray(config.ogImageGeneration) ? 'an array' : typeof config.ogImageGeneration));
+  }
+
+  // jsonLd map shape (issue #25): the legacy forms are a single object or a
+  // list; the scoped map form keys every entry by a slug glob whose value is
+  // an LD+JSON object or a list of them. Wrong shapes warn loudly; the
+  // runner skips bad values per block rather than dropping the global set.
+  if (config.jsonLd !== undefined && !Array.isArray(config.jsonLd) && config.jsonLd !== null) {
+    if (typeof config.jsonLd !== 'object') {
+      warnings.push('jsonLd must be an LD+JSON object, a list of them, or a slug-glob map of them');
+    } else if (Object.keys(config.jsonLd).length > 0) {
+      const pathish = (k) => /^\//.test(k) || k === '*' || k === '**' || k.includes('*');
+      const keys = Object.keys(config.jsonLd);
+      const allPathish = keys.every(pathish);
+      const anyPathish = keys.some(pathish);
+      if (allPathish) {
+        // scoped map: validate each value's shape up front
+        for (const key of keys) {
+          const v = config.jsonLd[key];
+          const blocks = Array.isArray(v) ? v : [v];
+          if (blocks.length === 0 || blocks.some((b) => !b || typeof b !== 'object' || Array.isArray(b))) {
+            warnings.push('jsonLd "' + key + '" must map to an LD+JSON object or a list of them');
+          }
+        }
+      } else if (anyPathish) {
+        warnings.push('jsonLd mixes slug-glob keys with schema-object keys - either use the scoped map form (every key a glob) or the legacy object form; the run skips no block but reads it as a legacy object');
+      }
+    }
+  }
+
+  // og.scoped shape (issue #25 follow-on): a slug-glob map whose values take
+  // the og.image shapes (string, or the structured object form).
+  if (config.og?.scoped !== undefined && (typeof config.og.scoped !== 'object' || config.og.scoped === null || Array.isArray(config.og.scoped))) {
+    warnings.push('og.scoped must be a slug-glob map of og.image values (string or { src, width, height, alt, allowSvg }), not ' + (Array.isArray(config.og.scoped) ? 'an array' : typeof config.og.scoped));
+  } else if (config.og?.scoped && typeof config.og.scoped === 'object') {
+    for (const [key, v] of Object.entries(config.og.scoped)) {
+      if (!/^\//.test(key) && key !== '*' && !key.includes('*')) {
+        warnings.push('og.scoped keys must be slug globs (starting with "/", optionally with * / **) - skipping "' + key + '"');
+      }
+      if (v === null || Array.isArray(v) || (typeof v !== 'string' && typeof v !== 'object')) {
+        warnings.push('og.scoped "' + key + '" must be an og image string or a { src, width, height, alt, allowSvg } object (a list of images is not a variant - one page matches one image) - no image ships from this key');
+      }
+    }
+  }
+
+  // Per-page JSON-LD type override shape (SEO-gap pass): a slug-glob map
+  // keyed like og.scoped; the page-level value decides WHAT article type a
+  // page gets when it does not already carry LD+JSON.
+  if (config.article?.scoped !== undefined && (typeof config.article.scoped !== 'object' || config.article.scoped === null || Array.isArray(config.article.scoped))) {
+    warnings.push('article.scoped must be a slug-glob map of LD+JSON type strings ("Article", "TechArticle", "NewsArticle"), not ' + (Array.isArray(config.article.scoped) ? 'an array' : typeof config.article.scoped));
+  } else if (config.article?.scoped && typeof config.article.scoped === 'object') {
+    for (const [key, v] of Object.entries(config.article.scoped)) {
+      if (!/^\//.test(key) && !key.includes('*')) {
+        warnings.push('article.scoped keys must be slug globs (starting with "/", optionally with * / **) - skipping "' + key + '"');
+      }
+      if (!['Article', 'TechArticle', 'NewsArticle'].includes(String(v))) {
+        warnings.push('article.scoped "' + key + '" must be "Article", "TechArticle" or "NewsArticle" (got "' + String(v) + '") - the page gets no article type');
+      }
+    }
+  }
+
+  // search shape (SEO-gap pass): { url: ... } - the SearchAction target.
+  // The {search_term_string} placeholder in the URL is the schema.org
+  // contract; anything else turns the potentialAction block into a broken
+  // search target, so the shape diagnostic warns below.
+  if (config.search !== undefined && config.search !== null && (typeof config.search !== 'object' || Array.isArray(config.search))) {
+    warnings.push('search must be a { url: "..." } object');
+  } else if (config.search?.url !== undefined) {
+    if (typeof config.search.url !== 'string' || config.search.url === '') {
+      warnings.push('search.url must be a non-empty string URL with a {search_term_string} placeholder');
+    } else if (!config.search.url.includes('{search_term_string}')) {
+      warnings.push('search.url must contain the {search_term_string} placeholder or the SearchAction block is a broken search target - omitted');
+    }
+  }
+
+  // breadcrumb shape (SEO-gap pass): true opts the page into auto-built
+  // BreadcrumbList LD+JSON from the page's own position in the URL tree.
+  if (config.breadcrumb !== undefined && typeof config.breadcrumb !== 'boolean') {
+    warnings.push('breadcrumb must be true (auto BreadcrumbList from URL structure)');
+  }
+
+  // verification shape (SEO-gap pass): map of provider -> content value.
+  if (config.verification !== undefined && config.verification !== null && (typeof config.verification !== 'object' || Array.isArray(config.verification))) {
+    warnings.push('verification must be an object of provider -> verification-string (google, bing, yandex, pinterest)');
+  } else if (config.verification) {
+    const KNOWN_VERIFICATION_PROVIDERS = ['google', 'bing', 'yandex', 'pinterest'];
+    for (const [provider, v] of Object.entries(config.verification)) {
+      if (!KNOWN_VERIFICATION_PROVIDERS.includes(provider)) {
+        warnings.push('unknown verification provider "' + provider + '" (known: ' + KNOWN_VERIFICATION_PROVIDERS.join(', ') + ') - no meta ships for it');
+      } else if (typeof v !== 'string' || v === '') {
+        warnings.push('verification.' + provider + ' must be a non-empty string verification code - no meta ships for it');
+      }
+    }
+  }
+
+  // llms shape (SEO-gap pass): true opts the run into emitting llms.txt in
+  // the output dir (the AI-consumable docs summary convention).
+  if (config.llms !== undefined && typeof config.llms !== 'boolean') {
+    warnings.push('llms must be true (emit llms.txt in the output dir)');
+  }
+
+  // locales shape (SEO-gap pass): map of slug glob -> language code. Pages
+  // that match a pattern get hreflang alternates pointing at its siblings.
+  if (config.locales !== undefined && config.locales !== null && (typeof config.locales !== 'object' || Array.isArray(config.locales))) {
+    warnings.push('locales must be a map of slug glob -> language code (e.g. "/de/**: de"), not ' + (Array.isArray(config.locales) ? 'an array' : typeof config.locales));
+  } else if (config.locales && typeof config.locales === 'object') {
+    for (const [pattern, lang] of Object.entries(config.locales)) {
+      if (typeof lang !== 'string' || lang === '') {
+        warnings.push('locales "' + pattern + '" must map to a non-empty language code string');
+      }
+    }
+  }
+
   for (const w of warnings) {
     console.log('[freestruct] config warning: ' + w);
   }

package/engine/hooks.js

@@ -1,8 +1,30 @@
-// engine/hooks.js - purge hooks (Phase 1.1 split)
+// engine/hooks.js - purge hooks + general postBuild hooks (Phase 1.1 split)
 // Same security posture as 0.4.x: hooks run only with runHooks: true.
 
 import { execSync } from 'child_process';
 
+// Issue #24: values ride FUNCTION replacers, never string-form replace
+// strings. In string form a value carrying $& / $' / $1..9 is treated as
+// replacement SYNTAX and corrupts the command that is about to run.
+function substitutePlaceholders(command, { siteUrl, buildHash, outputDir }) {
+  return command
+    .replace(/\$\{?SITE_URL\}?/g, () => siteUrl)
+    .replace(/\$\{?BUILD_HASH\}?/g, () => buildHash)
+    .replace(/\$\{?OUTPUT_DIR\}?/g, () => outputDir);
+}
+
+// Hook children get the same facts as the placeholder substitution, as env
+// vars, so a hook script does not have to do string surgery to learn where
+// the build landed (issue #21: postBuild consumers chain scripts cleanly).
+function hookEnv({ siteUrl, buildHash, outputDir }) {
+  return {
+    ...process.env,
+    FREESTRUCT_SITE_URL: siteUrl,
+    FREESTRUCT_BUILD_HASH: buildHash,
+    FREESTRUCT_OUTPUT_DIR: outputDir,
+  };
+}
+
 export function runPurgeHooks(config, buildHash, outputDir) {
   const siteUrl = config.site.url;
   const purgeList = Array.isArray(config.cacheBusting.purge)
@@ -18,15 +40,7 @@ export function runPurgeHooks(config, buildHash, outputDir) {
       continue;
     }
 
-    command = command
-      .replace(/\$SITE_URL/g, siteUrl)
-      .replace(/\$BUILD_HASH/g, buildHash)
-      .replace(/\$OUTPUT_DIR/g, outputDir);
-
-    command = command
-      .replace(/\$\{SITE_URL\}/g, siteUrl)
-      .replace(/\$\{BUILD_HASH\}/g, buildHash)
-      .replace(/\$\{OUTPUT_DIR\}/g, outputDir);
+    command = substitutePlaceholders(command, { siteUrl, buildHash, outputDir });
 
     console.log('Purge hook ' + name + ': running...');
     try {
@@ -43,3 +57,47 @@ export function runPurgeHooks(config, buildHash, outputDir) {
     }
   }
 }
+
+// ---------- general postBuild hooks (issue #21) ----------
+
+// Generalize the already-reviewed purge runner into a first-class seam:
+//   hooks:
+//     postBuild:
+//       - node scripts/whatever.mjs
+// Same contract as the purges: nothing executes without runHooks: true,
+// execSync carries a timeout, stdio is inherited, the same $-placeholders
+// (plus the FREESTRUCT_* env vars) reach the child. Unlike purge hooks, a
+// nonzero hook exit is collected and the orchestrator turns the collection
+// into a build failure (exit 4 - documented in the CLI contract).
+export function runPostBuildHooks(config, buildHash, outputDir) {
+  const raw = config.hooks?.postBuild;
+  if (raw === undefined || raw === null) return [];
+  const commands = Array.isArray(raw) ? raw : [raw];
+  if (commands.length === 0) return [];
+
+  const siteUrl = config.site.url;
+  const failures = [];
+  for (const entry of commands) {
+    if (typeof entry !== 'string' || entry === '') {
+      console.log('[freestruct] hooks.postBuild entry is not a non-empty string command - skipped');
+      continue;
+    }
+    const command = substitutePlaceholders(entry, { siteUrl, buildHash, outputDir });
+
+    if (!config.runHooks) {
+      console.log('PostBuild hook: Command: ' + command.substring(0, 100) + '...');
+      console.log('PostBuild hooks disabled (set runHooks: true to enable)');
+      return [];
+    }
+
+    console.log('PostBuild hook: running ' + command.substring(0, 76) + '...');
+    try {
+      execSync(command, { stdio: 'inherit', timeout: 30000, env: hookEnv({ siteUrl, buildHash, outputDir }) });
+      console.log('PostBuild hook: done');
+    } catch (e) {
+      console.log('  PostBuild hook: FAILED (exit ' + e.status + ')');
+      failures.push(e);
+    }
+  }
+  return failures;
+}

package/engine/indexnow.js

@@ -0,0 +1,140 @@
+// engine/indexnow.js - IndexNow key-file emission + submission (issue #19)
+// IndexNow is a one-POST notify protocol (Bing + Seznam + Yandex), and this
+// engine is the component that already owns the sitemap, so the fit is
+// natural: key file into the output dir (the keyLocation contract), a
+// `freestruct indexnow` subcommand that reads the baked sitemap.xml and
+// POSTs the URL list. Honesty contract: submission only makes sense AFTER
+// the output is deployed live (keyLocation must resolve) - docs say so; the
+// command surfaces HTTP status codes in its output; --dry-run prints the
+// request body without touching the network for CI.
+
+import fs from 'fs';
+import crypto from 'crypto';
+import path from 'path';
+
+export const INDEXNOW_API = 'https://api.indexnow.org/indexnow';
+const KEYFILE_HIDDEN = ['indexnow-key.txt'];
+
+// ---------- key resolution ----------
+
+/** 32 lowercase hex chars is the documented IndexNow key shape. */
+export function isValidIndexNowKey(key) {
+  return typeof key === 'string' && /^[a-f0-9]{32}$/.test(key);
+}
+
+/**
+ * Resolve the IndexNow key for a run.
+ *   indexNow.key (config, 32-hex)   wins
+ *   indexNow: true                  reads configDir/indexnow-key.txt, or
+ *                                   generates one and PERSISTS it (generate-
+ *                                   once: the same key across runs keeps the
+ *                                   keyLocation stable at the search engines)
+ * Rotating? Change the config key or delete indexnow-key.txt - loudly logged.
+ * Returns { key, source } or null when IndexNow is not configured.
+ */
+export function resolveIndexNowKey(config, configDir) {
+  const cfg = config.indexNow;
+  if (cfg === undefined || cfg === null || cfg === false) return null;
+  if (typeof cfg === 'string' || typeof cfg === 'object') {
+    const key = typeof cfg === 'string' ? cfg : cfg.key;
+    if (key !== undefined && key !== null) {
+      if (!isValidIndexNowKey(key)) return null; // config diagnostics already warned
+      return { key, source: 'config' };
+    }
+  }
+  const persistPath = path.join(configDir, 'indexnow-key.txt');
+  if (fs.existsSync(persistPath)) {
+    const key = fs.readFileSync(persistPath, 'utf8').trim();
+    if (isValidIndexNowKey(key)) return { key, source: 'persisted (' + KEYFILE_HIDDEN[0] + ')' };
+  }
+  const key = crypto.randomBytes(16).toString('hex');
+  fs.writeFileSync(persistPath, key + '\n', 'utf8');
+  console.log('[freestruct] indexnow: generated a new key and persisted it to ' + persistPath
+    + ' (generate-once: commit this file so the keyLocation stays stable across runs)');
+  return { key, source: 'generated' };
+}
+
+/** Emit <key>.txt into the output dir (the keyLocation file search engines probe). */
+export function emitIndexNowKeyFile(key, outputDir) {
+  const keyFile = path.join(outputDir, key + '.txt');
+  fs.writeFileSync(keyFile, key + '\n', 'utf8');
+  console.log('[freestruct] indexnow: key file written: ' + key + '.txt (deploy it live - keyLocation must resolve)');
+  return keyFile;
+}
+
+// ---------- submission ----------
+
+/** Read the baked sitemap.xml and return its URL list (null when absent/empty). */
+export function readSitemapUrls(outputDir) {
+  const sitemapPath = path.join(outputDir, 'sitemap.xml');
+  if (!fs.existsSync(sitemapPath)) return null;
+  const sitemap = fs.readFileSync(sitemapPath, 'utf8');
+  const urls = (sitemap.match(/<loc>([\s\S]*?)<\/loc>/g) || [])
+    .map(e => e.replace(/<\/?loc>/g, '').trim())
+    .filter(Boolean);
+  return urls.length > 0 ? urls : null;
+}
+
+/**
+ * POST the sitemap URL list to api.indexnow.org. Returns the HTTP status so
+ * the caller can surface it (202 = accepted). `dryRun` skips the network.
+ */
+export async function submitIndexNow({ config, configDir, outputDir, dryRun }) {
+  const resolved = resolveIndexNowKey(config, configDir);
+  if (!resolved) {
+    console.log('[freestruct] indexnow: not configured (set indexNow in the config)');
+    return { ok: false, status: null, reason: 'not-configured' };
+  }
+  if (!isValidIndexNowKey(config.indexNow?.key) && (config.indexNow === undefined)) {
+    console.log('[freestruct] indexnow: no key resolved');
+    return { ok: false, status: null, reason: 'no-key' };
+  }
+
+  const urls = readSitemapUrls(outputDir);
+  if (!urls) {
+    console.log('[freestruct] indexnow: no sitemap.xml with <loc> entries in ' + outputDir
+      + ' - run freestruct first (indexnow reads the baked sitemap)');
+    return { ok: false, status: null, reason: 'no-sitemap' };
+  }
+
+  let host;
+  try { host = new URL(config.site.url).host; } catch (e) {
+    console.log('[freestruct] indexnow: site.url is not parseable - cannot derive host');
+    return { ok: false, status: null, reason: 'bad-site-url' };
+  }
+
+  const payload = {
+    host,
+    key: resolved.key,
+    urlList: urls,
+    keyLocation: config.site.url.replace(/\/$/, '') + '/' + resolved.key + '.txt',
+  };
+
+  console.log('[freestruct] indexnow: submitting ' + urls.length + ' URL(s) to ' + INDEXNOW_API
+    + ' (key source: ' + resolved.source + ')');
+  if (dryRun) {
+    console.log('[freestruct] indexnow: --dry-run, request body:');
+    console.log(JSON.stringify(payload, null, 2));
+    return { ok: true, status: 'dry-run', reason: 'dry-run' };
+  }
+
+  let res;
+  try {
+    res = await fetch(INDEXNOW_API, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json; charset=utf-8' },
+      body: JSON.stringify(payload),
+    });
+  } catch (e) {
+    console.log('[freestruct] indexnow: request failed: ' + e.message);
+    return { ok: false, status: null, reason: 'network-error' };
+  }
+
+  console.log('[freestruct] indexnow: HTTP ' + res.status
+    + (res.status === 200 || res.status === 202 ? ' (accepted)' : ' (NOT accepted - the engines surface failures; check key file live deployment)'));
+  if (res.status !== 200 && res.status !== 202) {
+    const body = await res.text().catch(() => '');
+    if (body) console.log('[freestruct] indexnow: response: ' + body.slice(0, 300));
+  }
+  return { ok: res.status === 200 || res.status === 202, status: res.status, reason: 'http' };
+}