@adobe/aem-cli 16.20.13 → 16.21.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [16.21.0](https://github.com/adobe/helix-cli/compare/v16.20.13...v16.21.0) (2026-07-15)
+
+
+### Features
+
+* **content:** render DA content via the real html2md -> html-pipeline chain ([d40bf69](https://github.com/adobe/helix-cli/commit/d40bf69e11d308317e63b73890fd087b13a3844a)), closes [#2759](https://github.com/adobe/helix-cli/issues/2759) [#2756](https://github.com/adobe/helix-cli/issues/2756)
+
 ## [16.20.13](https://github.com/adobe/helix-cli/compare/v16.20.12...v16.20.13) (2026-07-15)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/aem-cli",
-  "version": "16.20.13",
+  "version": "16.21.0",
   "description": "AEM CLI",
   "main": "index.js",
   "type": "module",
@@ -44,6 +44,8 @@
   },
   "dependencies": {
     "@adobe/fetch": "4.3.0",
+    "@adobe/helix-html-pipeline": "6.29.6",
+    "@adobe/helix-html2md": "2.2.2",
     "@adobe/helix-log": "7.0.0",
     "@adobe/helix-shared-config": "11.1.29",
     "@adobe/helix-shared-git": "3.0.25",
@@ -62,7 +64,6 @@
     "faye-websocket": "0.11.4",
     "fs-extra": "11.3.5",
     "glob": "13.0.6",
-    "glob-to-regexp": "0.4.1",
     "hast-util-select": "6.0.4",
     "hast-util-to-html": "9.0.5",
     "http-proxy-agent": "9.1.0",
@@ -71,8 +72,8 @@
     "ini": "7.0.0",
     "isomorphic-git": "1.38.5",
     "jose": "6.2.3",
-    "mime": "4.1.0",
     "livereload-js": "4.0.2",
+    "mime": "4.1.0",
     "node-diff3": "3.2.1",
     "node-fetch": "3.3.2",
     "open": "11.0.0",

package/src/content/content-html-pipeline.js

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/**
+ * Renders da.live-authored content HTML from `content/` through the
+ * `html2md` -> `helix-html-pipeline` markdown-rendering chain, run locally by calling
+ * `htmlPipe()` (the same entry point production uses) against a hand-built minimal pipeline
+ * state and a fake in-memory content-bus loader.
+ */
+
+import { html2md } from '@adobe/helix-html2md';
+import {
+  PipelineState, PipelineRequest, PipelineResponse, htmlPipe,
+} from '@adobe/helix-html-pipeline';
+
+/**
+ * `htmlPipe` treats a literal `.html` path (no selector) as a code-bus (statically deployed)
+ * resource and skips markdown rendering entirely -- production only ever requests pages at
+ * extension-less paths (`/foo`), reserving `.html` for real static files. `.plain.html` is
+ * exempt: its `plain` selector already routes through the content-bus/markdown branch.
+ * @param {string} path
+ * @returns {string}
+ */
+function toContentPath(path) {
+  if (path.endsWith('.plain.html')) {
+    return path;
+  }
+  const clean = path.endsWith('.html') ? path.slice(0, -'.html'.length) : path;
+  // a literal "index" path segment is a reserved internal artifact -- fetchContent rejects it
+  // outright, so an index document maps back to its containing directory, same as "/".
+  if (clean.endsWith('/index')) {
+    return clean.slice(0, -'index'.length) || '/';
+  }
+  return clean;
+}
+
+/**
+ * A minimal `s3Loader` stand-in. With no folder mapping configured, `htmlPipe` only ever
+ * makes two content-bus lookups: the page's own markdown, and (if configured) the
+ * metadata.json sheet for the `fetchSourcedMetadata` step.
+ * @param {string} md
+ * @param {object[]} metadataSheetRows
+ * @returns {object}
+ */
+function createLocalLoader(md, metadataSheetRows) {
+  return {
+    async getObject(bucketId, key) {
+      if (bucketId === 'helix-content-bus' && key.endsWith('/metadata.json')) {
+        if (metadataSheetRows.length > 0) {
+          return new PipelineResponse(JSON.stringify({ data: metadataSheetRows }));
+        }
+        return new PipelineResponse('', { status: 404 });
+      }
+      if (bucketId === 'helix-content-bus') {
+        return new PipelineResponse(md);
+      }
+      return new PipelineResponse('', { status: 404 });
+    },
+    async headObject() {
+      return new PipelineResponse('', { status: 404 });
+    },
+  };
+}
+
+/**
+ * @param {string} rawHtml body-only or partial HTML from content/, as stored by da.live
+ * @param {object} [options]
+ * @param {string} [options.path] request path, e.g. `/foo.html` or `/foo.plain.html`
+ * @param {Console} [options.log]
+ * @param {string} [options.headHtml] local head.html content, injected into <head>
+ * @param {object[]} [options.metadataSheetRows] raw rows from the site's /metadata.json, fed
+ *   through the same `fetchSourcedMetadata` step production uses to build sheet-based
+ *   metadata overrides
+ * @param {object} [options.headers] incoming request headers (e.g. `req.headers`), used to
+ *   resolve a real host for canonical/og:url instead of a placeholder
+ * @param {string} [options.org] the AEM org this content belongs to, if known
+ * @param {string} [options.site] the AEM site this content belongs to, if known
+ * @returns {Promise<string | null>} the rendered HTML (full document, or a bare fragment for
+ *   `.plain.html` paths), or `null` if rendering failed and the caller should fall back to
+ *   serving the raw file
+ */
+export async function renderContentHtml(rawHtml, {
+  path = '/index.html',
+  log = console,
+  headHtml = '',
+  metadataSheetRows = [],
+  headers = {},
+  org = 'local',
+  site = 'local',
+} = {}) {
+  try {
+    const md = await html2md(rawHtml, { log, url: new URL(path, 'http://localhost').href });
+
+    const contentPath = toContentPath(path);
+    const state = new PipelineState({
+      path: contentPath,
+      log,
+      org: org || 'local',
+      site: site || 'local',
+      ref: 'local',
+      partition: 'preview',
+      s3Loader: createLocalLoader(md, metadataSheetRows),
+      config: {
+        contentBusId: 'local',
+        owner: 'local',
+        repo: 'local',
+        cdn: {},
+        metadata: { source: ['metadata.json'] },
+        headers: {},
+        features: { rendering: { version: 2 } },
+        head: { html: headHtml },
+      },
+    });
+
+    const req = new PipelineRequest(new URL(contentPath, 'http://localhost'), { headers });
+    const res = await htmlPipe(state, req);
+    if (res.error) {
+      log.warn?.(`content-html-pipeline: failed to render ${path}: ${res.error}`);
+      return null;
+    }
+    return res.body;
+  } catch (e) {
+    log.warn?.(`content-html-pipeline: failed to render ${path}: ${e.message}`);
+    return null;
+  }
+}

package/src/server/HelixServer.js

@@ -22,7 +22,7 @@ import { asyncHandler, BaseServer } from './BaseServer.js';
 import LiveReload from './LiveReload.js';
 import { saveSiteTokenToFile } from '../config/config-utils.js';
 import { CONTENT_DIR } from '../content/content-shared.js';
-import { transformContentMetadataHtml } from '../content/content-metadata-html.js';
+import { renderContentHtml } from '../content/content-html-pipeline.js';
 import { DA_IMS_CLIENT_ID, DA_IMS_SCOPE, startDaLoginRedirect } from '../content/da-auth.js';
 
 const LOGIN_ROUTE = '/.aem/cli/login';
@@ -43,26 +43,6 @@ const daContentAuthRateLimit = rateLimit({
 const HTML_FOLDER_EXTENSIONS = ['.html', '.plain.html'];
 const HTML_FOLDER_EXTENSIONS_PREFER_PLAIN = [...HTML_FOLDER_EXTENSIONS].reverse();
 
-/**
- * @param {import('express').Request} req
- * @param {import('./RequestContext.js').default} ctx
- * @returns {string}
- */
-function absolutePageUrlFromRequest(req, ctx) {
-  const raw = req.headers['x-forwarded-proto'];
-  const proto = (Array.isArray(raw) ? raw[0] : raw) || req.protocol || 'http';
-  const host = req.get('host');
-  if (!host) {
-    return '';
-  }
-  try {
-    const pathWithQuery = req.originalUrl || ctx.url;
-    return new URL(pathWithQuery, `${proto}://${host}`).href;
-  } catch {
-    return '';
-  }
-}
-
 export class HelixServer extends BaseServer {
   /**
    * Creates a new HelixServer for the given project.
@@ -517,11 +497,24 @@ export class HelixServer extends BaseServer {
             // Content may already reference the preview host directly (not just via
             // the content.da.live rewrite above), so gate on presence, not on rewrite.
             const needsDaContentAuth = !!previewOrigin && htmlContent.includes(previewOrigin);
+            if (this._project.metadataSheet) {
+              this._project.metadataSheet.setCookie(req.headers.cookie || '');
+              await this._project.metadataSheet.ensureLoaded();
+            }
+            const metadataSheetRows = this._project.metadataSheet?.getRows();
             if (isPlainFallback) {
               if (liveReload) {
                 liveReload.registerFile(ctx.requestId, servedFilePath);
               }
-              const fragment = utils.extractMainContent(htmlContent);
+              const rendered = await renderContentHtml(htmlContent, {
+                path: ctx.path,
+                log,
+                metadataSheetRows,
+                headers: req.headers,
+                org: this._project.org,
+                site: this._project.site,
+              });
+              const fragment = rendered ?? utils.extractMainContent(htmlContent);
               res.set({
                 'content-type': 'text/html; charset=utf-8',
                 'access-control-allow-origin': '*',
@@ -530,29 +523,26 @@ export class HelixServer extends BaseServer {
               log.debug(`${pfx}served from ${CONTENT_DIR}/: ${ctx.path}`);
               return;
             }
-            const absolutePageUrl = absolutePageUrlFromRequest(req, ctx);
-            if (this._project.metadataSheet) {
-              this._project.metadataSheet.setCookie(req.headers.cookie || '');
-              await this._project.metadataSheet.ensureLoaded();
-            }
-            const sheetRow = this._project.metadataSheet?.matchPath(ctx.path) ?? null;
-            const { htmlFragment, metaTagsHtml } = transformContentMetadataHtml(htmlContent, {
-              absolutePageUrl,
-              sheetRow,
+            await this._project.headHtml.update();
+            const headHtml = this._project.headHtml.localHtml || '';
+            const rendered = await renderContentHtml(htmlContent, {
+              path: ctx.path,
+              log,
+              headHtml,
+              metadataSheetRows,
+              headers: req.headers,
+              org: this._project.org,
+              site: this._project.site,
             });
-            htmlContent = htmlFragment;
-            // content/ files are plain HTML (body only, no <head>)
-            // wrap with a full document and inject local head.html
-            if (!htmlContent.includes('<head>')) {
-              await this._project.headHtml.update();
-              const headHtml = this._project.headHtml.localHtml || '';
-              htmlContent = `<html><head>${headHtml}${metaTagsHtml}</head>${htmlContent}</html>`;
+            if (rendered !== null) {
+              htmlContent = rendered;
+            } else if (!htmlContent.includes('<head>')) {
+              // pipeline failed to render -- fall back to a minimal wrap so local dev never
+              // breaks outright on a rendering bug.
+              htmlContent = `<html><head>${headHtml}</head>${htmlContent}</html>`;
             } else {
-              await this._project.headHtml.setCookie(req.headers.cookie);
-              htmlContent = await this._project.headHtml.replace(htmlContent);
-              if (metaTagsHtml) {
-                htmlContent = htmlContent.replace(/<\/head>/i, `${metaTagsHtml}</head>`);
-              }
+              // content already had its own <head> -- still merge in the local head.html
+              htmlContent = htmlContent.replace(/<\/head>/i, `${headHtml}</head>`);
             }
             const proxyPageUrl = new URL(ctx.url, proxyUrl);
             for (const [key, value] of proxyUrl.searchParams.entries()) {

package/src/server/MetadataSheetSupport.js

@@ -10,25 +10,8 @@
  * governing permissions and limitations under the License.
  */
 
-import globToRegExp from 'glob-to-regexp';
 import { getFetch } from '../fetch-utils.js';
 
-/**
- * Normalizes the request path for matching against metadata.json URL globs.
- * @param {string} pathname
- * @returns {string}
- */
-export function normalizePathForMetadataMatch(pathname) {
-  let p = pathname || '/';
-  if (!p.startsWith('/')) {
-    p = `/${p}`;
-  }
-  if (p.length > 5 && p.endsWith('.html')) {
-    p = p.slice(0, -5);
-  }
-  return p || '/';
-}
-
 /**
  * @param {unknown} body
  * @returns {object[]}
@@ -44,82 +27,6 @@ function extractDataRows(body) {
   return /** @type {object[]} */ (data.filter((r) => r && typeof r === 'object'));
 }
 
-/**
- * @param {object[]} rows
- * @returns {Array<{ pattern: string, regex: RegExp, row: object }>}
- */
-export function compileMetadataSheetPatterns(rows) {
-  /** @type {Array<{ pattern: string, regex: RegExp, row: object }>} */
-  const out = [];
-  for (const row of rows) {
-    const pattern = row.URL;
-    if (typeof pattern !== 'string' || !pattern.trim()) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    try {
-      const regex = globToRegExp(pattern, { globstar: true });
-      out.push({ pattern, regex, row });
-    } catch {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-  }
-  return out;
-}
-
-/**
- * Merges all matching metadata sheet rows for a path: most specific URL pattern first,
- * then each field uses the first non-empty value (empty string falls through to broader rows).
- * @param {string} normalizedPath
- * @param {Array<{ pattern: string, regex: RegExp, row: object }>} compiled
- * @returns {Record<string, string> | null}
- */
-export function mergeMetadataSheetRows(normalizedPath, compiled) {
-  /** @type {Array<{ pattern: string, row: object }>} */
-  const hits = [];
-  for (const { pattern, regex, row } of compiled) {
-    if (regex.test(normalizedPath)) {
-      hits.push({ pattern, row });
-    }
-  }
-  if (hits.length === 0) {
-    return null;
-  }
-  hits.sort((a, b) => b.pattern.length - a.pattern.length);
-
-  /** @type {Set<string>} */
-  const keys = new Set();
-  for (const { row } of hits) {
-    for (const k of Object.keys(row)) {
-      if (k !== 'URL' && !k.startsWith(':')) {
-        keys.add(k);
-      }
-    }
-  }
-
-  /** @type {Record<string, string>} */
-  const merged = {};
-  for (const key of keys) {
-    for (const { row } of hits) {
-      const v = row[key];
-      if (v === undefined || v === null) {
-        // eslint-disable-next-line no-continue
-        continue;
-      }
-      const s = String(v).trim();
-      if (s === '') {
-        // eslint-disable-next-line no-continue
-        continue;
-      }
-      merged[key] = s;
-      break;
-    }
-  }
-
-  return Object.keys(merged).length > 0 ? merged : null;
-}
-
 export default class MetadataSheetSupport {
   /**
    * @param {{ proxyUrl: string, log: object, allowInsecure: boolean, siteToken?: string }} opts
@@ -133,8 +40,9 @@ export default class MetadataSheetSupport {
     this.allowInsecure = allowInsecure;
     this.siteToken = siteToken || '';
     this.cookie = '';
-    /** @type {Array<{ pattern: string, regex: RegExp, row: object }> | null} */
-    this._compiled = null;
+    /** @type {object[] | null} raw metadata.json sheet rows, fed to helix-html-pipeline's own
+     *   `fetchSourcedMetadata` step so it builds the sheet-based overrides itself */
+    this._rows = null;
     /** @type {Promise<void> | null} */
     this._loadPromise = null;
   }
@@ -143,7 +51,7 @@ export default class MetadataSheetSupport {
     const next = cookie || '';
     if (this.cookie !== next) {
       this.cookie = next;
-      this._compiled = null;
+      this._rows = null;
       this._loadPromise = null;
     }
   }
@@ -152,18 +60,18 @@ export default class MetadataSheetSupport {
     const next = siteToken || '';
     if (this.siteToken !== next) {
       this.siteToken = next;
-      this._compiled = null;
+      this._rows = null;
       this._loadPromise = null;
     }
   }
 
   invalidate() {
-    this._compiled = null;
+    this._rows = null;
     this._loadPromise = null;
   }
 
   async ensureLoaded() {
-    if (this._compiled !== null) {
+    if (this._rows !== null) {
       return;
     }
     if (this._loadPromise) {
@@ -193,29 +101,23 @@ export default class MetadataSheetSupport {
       });
       if (!resp.ok) {
         this.log.debug(`metadata.json not loaded (${resp.status}) from ${this.url}`);
-        this._compiled = [];
+        this._rows = [];
         return;
       }
       const text = await resp.text();
       const body = JSON.parse(text);
-      const rows = extractDataRows(body);
-      this._compiled = compileMetadataSheetPatterns(rows);
-      this.log.debug(`loaded metadata.json (${this._compiled.length} URL pattern(s)) from ${this.url}`);
+      this._rows = extractDataRows(body);
+      this.log.debug(`loaded metadata.json (${this._rows.length} row(s)) from ${this.url}`);
     } catch (e) {
       this.log.debug(`metadata.json fetch/parse failed: ${e.message || e}`);
-      this._compiled = [];
+      this._rows = [];
     }
   }
 
   /**
-   * @param {string} pathname ctx.path or resource path with .html
-   * @returns {object | null}
+   * @returns {object[]} raw metadata.json sheet rows, or an empty array if none were loaded
    */
-  matchPath(pathname) {
-    if (!this._compiled || this._compiled.length === 0) {
-      return null;
-    }
-    const normalized = normalizePathForMetadataMatch(pathname);
-    return mergeMetadataSheetRows(normalized, this._compiled);
+  getRows() {
+    return this._rows ?? [];
   }
 }

package/src/content/content-metadata-html.js

@@ -1,321 +0,0 @@
-/*
- * Copyright 2026 Adobe. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-
-/**
- * Transforms da.live-style `<div class="metadata">` blocks in content HTML into
- * `<meta>` tags for local dev (`aem up`), strips the block from the body, and
- * adds description / Open Graph / Twitter tags where data is available.
- */
-
-import { unified } from 'unified';
-import rehypeParse from 'rehype-parse';
-import { select } from 'hast-util-select';
-import { toHtml } from 'hast-util-to-html';
-
-/** @typedef {import('hast').Root} HastRoot */
-/** @typedef {import('hast').Element} HastElement */
-
-const REHYPE_PARSE = { fragment: true };
-
-/**
- * @param {string} s
- * @returns {string}
- */
-export function escapeHtmlAttr(s) {
-  return String(s)
-    .replace(/&/g, '&amp;')
-    .replace(/"/g, '&quot;')
-    .replace(/</g, '&lt;');
-}
-
-/**
- * @param {string} label
- * @returns {string}
- */
-export function slugifyMetadataLabel(label) {
-  return label
-    .normalize('NFKD')
-    .replace(/[\u0300-\u036f]/g, '')
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-|-$/g, '');
-}
-
-/**
- * @param {import('hast').Node | null | undefined} node
- * @returns {string}
- */
-function textContent(node) {
-  if (!node) {
-    return '';
-  }
-  if (node.type === 'text') {
-    return node.value;
-  }
-  if (Array.isArray(node.children)) {
-    return node.children.map((c) => textContent(c)).join('');
-  }
-  return '';
-}
-
-/**
- * @param {HastElement} metadataRoot
- * @returns {Array<[string, string]>}
- */
-export function extractMetadataPairs(metadataRoot) {
-  /** @type {Array<[string, string]>} */
-  const pairs = [];
-  if (!metadataRoot.children) {
-    return pairs;
-  }
-  for (const row of metadataRoot.children) {
-    if (row.type !== 'element' || row.tagName !== 'div') {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    const cells = (row.children || []).filter(
-      (c) => c.type === 'element' && c.tagName === 'div',
-    );
-    if (cells.length < 2) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    const label = textContent(cells[0]).trim();
-    const value = textContent(cells[1]).trim();
-    if (label) {
-      pairs.push([label, value]);
-    }
-  }
-  return pairs;
-}
-
-/**
- * @param {HastElement} node
- * @param {string} className
- * @returns {boolean}
- */
-function hasClass(node, className) {
-  const cn = node.properties?.className;
-  if (Array.isArray(cn)) {
-    return cn.includes(className);
-  }
-  if (typeof cn === 'string') {
-    return cn.split(/\s+/).includes(className);
-  }
-  return false;
-}
-
-/**
- * @param {import('hast').Node} tree
- * @param {import('hast').Element} target
- * @returns {boolean}
- */
-function removeNode(tree, target) {
-  if (tree === target) {
-    return true;
-  }
-  if ('children' in tree && Array.isArray(tree.children)) {
-    const { children } = tree;
-    for (let i = 0; i < children.length; i += 1) {
-      const c = children[i];
-      if (c === target) {
-        children.splice(i, 1);
-        return true;
-      }
-      if (removeNode(c, target)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-/**
- * @param {HastRoot} tree
- * @returns {string}
- */
-function firstImgSrc(tree) {
-  const img = select('img[src]', tree);
-  if (!img || img.type !== 'element') {
-    return '';
-  }
-  const s = img.properties?.src;
-  return typeof s === 'string' ? s : '';
-}
-
-/**
- * @param {HastRoot} tree
- * @returns {string}
- */
-function firstParagraphText(tree) {
-  const p = select('p', tree);
-  return p && p.type === 'element' ? textContent(p).trim() : '';
-}
-
-/**
- * Truncates a string to `max` characters, trimming and appending an ellipsis when needed.
- * @param {string} s
- * @param {number} max
- * @returns {string}
- */
-function truncateWithEllipsis(s, max) {
-  if (s.length <= max) {
-    return s;
-  }
-  return `${s.slice(0, max - 1).trim()}…`;
-}
-
-const SEO_LABEL_SKIP = new Set(['title', 'description', 'image']);
-
-/**
- * @param {object | null | undefined} sheetRow row from /metadata.json matched for this URL
- * @param {Set<string> | null | undefined} excludeMetaNames lowercase meta `name` values to skip
- *   (local page wins)
- * @returns {string[]}
- */
-export function buildSheetMetaLines(sheetRow, excludeMetaNames) {
-  if (!sheetRow || typeof sheetRow !== 'object') {
-    return [];
-  }
-  /** @type {string[]} */
-  const lines = [];
-  for (const [k, v] of Object.entries(sheetRow)) {
-    if (k === 'URL' || k.startsWith(':')) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    if (excludeMetaNames && excludeMetaNames.has(k.toLowerCase())) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    if (v === undefined || v === null) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    const s = String(v).trim();
-    if (!s) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    lines.push(`<meta name="${escapeHtmlAttr(k)}" content="${escapeHtmlAttr(s)}">`);
-  }
-  return lines;
-}
-
-/**
- * @param {string[]} lines
- * @returns {string}
- */
-function joinLines(lines) {
-  return lines.length > 0 ? `\n${lines.join('\n')}\n` : '';
-}
-
-/**
- * @param {string} htmlFragment body-only or partial HTML from content/
- * @param {{ absolutePageUrl?: string, sheetRow?: object | null }} [options]
- * @returns {{ htmlFragment: string, metaTagsHtml: string }}
- */
-export function transformContentMetadataHtml(htmlFragment, options = {}) {
-  const { absolutePageUrl = '', sheetRow = null } = options;
-
-  let tree;
-  try {
-    tree = unified().use(rehypeParse, REHYPE_PARSE).parse(htmlFragment);
-  } catch {
-    return { htmlFragment, metaTagsHtml: joinLines(buildSheetMetaLines(sheetRow)) };
-  }
-
-  const metadataEl = select('div.metadata', tree);
-  if (!metadataEl || metadataEl.type !== 'element' || !hasClass(metadataEl, 'metadata')) {
-    return { htmlFragment, metaTagsHtml: joinLines(buildSheetMetaLines(sheetRow)) };
-  }
-
-  const pairs = extractMetadataPairs(metadataEl);
-
-  /** Names from page metadata; sheet entries with the same meta name are skipped. */
-  const localPairMetaNames = new Set();
-  for (const [label, value] of pairs) {
-    const slug = slugifyMetadataLabel(label);
-    if (!slug || value === undefined) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    localPairMetaNames.add(slug);
-  }
-
-  const sheetLines = buildSheetMetaLines(sheetRow, localPairMetaNames);
-
-  const lowerMap = new Map(pairs.map(([k, v]) => [k.toLowerCase().trim(), v]));
-
-  removeNode(tree, metadataEl);
-
-  const title = (lowerMap.get('title') || textContent(select('h1', tree)).trim() || '').trim();
-  let description = (lowerMap.get('description') || firstParagraphText(tree) || '').trim();
-  description = truncateWithEllipsis(description, 200);
-  const image = (lowerMap.get('image') || lowerMap.get('og image') || firstImgSrc(tree) || '').trim();
-
-  /** @type {string[]} */
-  const seoLines = [];
-
-  if (description) {
-    const e = escapeHtmlAttr(description);
-    seoLines.push(`<meta name="description" content="${e}">`);
-    seoLines.push(`<meta property="og:description" content="${e}">`);
-    seoLines.push(`<meta name="twitter:description" content="${e}">`);
-  }
-
-  if (title) {
-    const e = escapeHtmlAttr(title);
-    seoLines.push(`<meta property="og:title" content="${e}">`);
-    seoLines.push(`<meta name="twitter:title" content="${e}">`);
-  }
-
-  if (absolutePageUrl) {
-    seoLines.push(`<meta property="og:url" content="${escapeHtmlAttr(absolutePageUrl)}">`);
-  }
-
-  if (image) {
-    const e = escapeHtmlAttr(image);
-    const alt = escapeHtmlAttr(title || 'image');
-    seoLines.push(`<meta property="og:image" content="${e}">`);
-    seoLines.push(`<meta property="og:image:secure_url" content="${e}">`);
-    seoLines.push(`<meta property="og:image:alt" content="${alt}">`);
-    seoLines.push('<meta name="twitter:card" content="summary_large_image">');
-    seoLines.push(`<meta name="twitter:image" content="${e}">`);
-  } else {
-    seoLines.push('<meta name="twitter:card" content="summary">');
-  }
-
-  /** @type {string[]} */
-  const pairLines = [];
-  for (const [label, value] of pairs) {
-    const key = label.toLowerCase().trim();
-    if (SEO_LABEL_SKIP.has(key)) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    const slug = slugifyMetadataLabel(label);
-    if (!slug || value === undefined) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    pairLines.push(
-      `<meta name="${escapeHtmlAttr(slug)}" content="${escapeHtmlAttr(value)}">`,
-    );
-  }
-
-  // SEO first, then sheet (fields not overridden by local pairs), then local page metadata
-  const allLines = [...seoLines, ...sheetLines, ...pairLines];
-  const htmlOut = toHtml(tree);
-  return { htmlFragment: htmlOut, metaTagsHtml: joinLines(allLines) };
-}