@rathnasgala2/template 2.2.0 → 3.0.0

package/src/core/internal/feeds.js

@@ -20,6 +20,7 @@
 
 import { escapeHtml } from './skeleton.js';
 import { derivePublicBasePath, joinPublicRoute } from './route.js';
+import { deriveAuthorSlugs } from './route-labels.js';
 import {
   contentLastModified,
   contentRoute,
@@ -47,6 +48,52 @@ function toRfc822(rfc3339) {
   return new Date(rfc3339).toUTCString();
 }
 
+/**
+ * @param {string} value an attribute value as it appears in HTML source
+ * @returns {string} the value with the five predefined entities decoded
+ */
+function decodeAttribute(value) {
+  return value
+    .replace(/"/g, '"')
+    .replace(/'/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&');
+}
+
+/**
+ * Make every `href`/`src` in an article body absolute against the article's
+ * own URL: a feed reader renders the body away from the site, so a relative
+ * link or image would otherwise point nowhere.
+ *
+ * @param {string} bodyHtml sanitized body HTML
+ * @param {string} pageUrl the article's absolute URL
+ * @returns {string} the body with absolute links and image sources
+ */
+export function absolutizeBodyLinks(bodyHtml, pageUrl) {
+  return bodyHtml.replace(
+    /\b(href|src)="([^"]*)"/g,
+    (match, attribute, value) => {
+      try {
+        return `${attribute}="${escapeHtml(new URL(decodeAttribute(value), pageUrl).toString())}"`;
+      } catch {
+        return match;
+      }
+    },
+  );
+}
+
+/**
+ * Wrap text in a CDATA section, splitting any `]]>` it contains so the
+ * section can never be closed early.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function cdata(text) {
+  return `<![CDATA[${text.replaceAll(']]>', ']]]]><![CDATA[>')}]]>`;
+}
+
 /**
  * Build the deterministic Atom 1.0 and RSS 2.0 feed documents for one
  * validated `build-input:2.0.0` instance.
@@ -59,6 +106,7 @@ function toRfc822(rfc3339) {
 export function buildFeeds(validatedInput) {
   const { publication, authors, content, basePath, baseUrl } = validatedInput;
   const authorsById = new Map(authors.map((author) => [author.id, author]));
+  const authorSlugs = deriveAuthorSlugs(authors);
   const articles = selectPublishedArticles(content).slice(0, FEED_ITEM_LIMIT);
 
   /**
@@ -84,12 +132,19 @@ export function buildFeeds(validatedInput) {
     .map((record) => {
       const { frontmatter } = record;
       const entryUrl = absoluteUrl(contentRoute(frontmatter));
-      const authorNames = frontmatter.authorIds.map(
-        (id) => authorsById.get(id)?.displayName ?? '',
-      );
-      const authorsXml = authorNames
-        .map((name) => `<author><name>${escapeHtml(name)}</name></author>`)
+      const authorsXml = frontmatter.authorIds
+        .map((id) => {
+          const author = authorsById.get(id);
+          const uri = author
+            ? `<uri>${escapeHtml(absoluteUrl(`/authors/${authorSlugs.get(id) ?? id}`))}</uri>`
+            : '';
+          return `<author><name>${escapeHtml(author?.displayName ?? '')}</name>${uri}</author>`;
+        })
+        .join('');
+      const categoriesXml = frontmatter.tags
+        .map((tag) => `<category term="${escapeHtml(tag)}"/>`)
         .join('');
+      const contentXml = `<content type="html">${escapeHtml(absolutizeBodyLinks(record.body, entryUrl))}</content>`;
       const summaryXml = frontmatter.description
         ? `<summary>${escapeHtml(frontmatter.description)}</summary>`
         : '';
@@ -101,7 +156,9 @@ export function buildFeeds(validatedInput) {
         `<published>${escapeHtml(frontmatter.publishedAt)}</published>` +
         `<link href="${escapeHtml(entryUrl)}" rel="alternate"/>` +
         authorsXml +
+        categoriesXml +
         summaryXml +
+        contentXml +
         `</entry>`
       );
     })
@@ -126,13 +183,24 @@ export function buildFeeds(validatedInput) {
       const descriptionXml = frontmatter.description
         ? `<description>${escapeHtml(frontmatter.description)}</description>`
         : '';
+      const creatorsXml = frontmatter.authorIds
+        .map((id) => authorsById.get(id)?.displayName)
+        .filter(Boolean)
+        .map((name) => `<dc:creator>${escapeHtml(String(name))}</dc:creator>`)
+        .join('');
+      const categoriesXml = frontmatter.tags
+        .map((tag) => `<category>${escapeHtml(tag)}</category>`)
+        .join('');
       return (
         `<item>` +
         `<title>${escapeHtml(frontmatter.title)}</title>` +
         `<link>${escapeHtml(itemUrl)}</link>` +
         `<guid isPermaLink="true">${escapeHtml(itemUrl)}</guid>` +
         `<pubDate>${escapeHtml(toRfc822(frontmatter.publishedAt))}</pubDate>` +
+        creatorsXml +
+        categoriesXml +
         descriptionXml +
+        `<content:encoded>${cdata(absolutizeBodyLinks(record.body, itemUrl))}</content:encoded>` +
         `</item>`
       );
     })
@@ -146,7 +214,7 @@ export function buildFeeds(validatedInput) {
   // review request).
   const rssXml =
     '<?xml version="1.0" encoding="UTF-8"?>\n' +
-    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">' +
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">' +
     '<channel>' +
     `<title>${escapeHtml(publication.title)}</title>` +
     `<link>${escapeHtml(siteUrl)}</link>` +

package/src/core/internal/icons.js

@@ -0,0 +1,52 @@
+/**
+ * The template's own fixed inline icon set. Chrome (header, footer, cards,
+ * article furniture) is template-owned markup, never author content, so
+ * these inline `<svg>` elements are emitted straight into the page and never
+ * pass through the author-content sanitizer in `content-security.js`. Every
+ * icon is decorative (`aria-hidden`, not focusable); a control that carries
+ * only an icon always has its own accessible name from the message catalog.
+ * No external icon file, font or network request is involved.
+ *
+ * Path data is the approved design reference's icon set (24x24 grid,
+ * stroke-based; fill/stroke colours come from the base layer, never here).
+ */
+
+/** @type {Readonly<Record<string, string>>} */
+export const ICONS = Object.freeze({
+  search: '<circle cx="11" cy="11" r="7"/><path d="m20 20-3.5-3.5"/>',
+  sun: '<circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/>',
+  monitor:
+    '<rect x="3" y="4" width="18" height="12" rx="2"/><path d="M8 20h8M12 16v4"/>',
+  moon: '<path d="M20.5 14.5A8.5 8.5 0 1 1 9.5 3.5a7 7 0 0 0 11 11z"/>',
+  arrow: '<path d="M5 12h14M13 6l6 6-6 6"/>',
+  back: '<path d="M19 12H5M11 6l-6 6 6 6"/>',
+  upright: '<path d="M7 17 17 7M8 7h9v9"/>',
+  chevron: '<path d="m9 6 6 6-6 6"/>',
+  clock: '<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/>',
+  rss: '<path d="M4 11a9 9 0 0 1 9 9M4 4a16 16 0 0 1 16 16"/><circle cx="5" cy="19" r="1.2"/>',
+  code: '<path d="m8 8-5 4 5 4M16 8l5 4-5 4"/>',
+  mail: '<rect x="3" y="5" width="18" height="14" rx="2"/><path d="m3 7 9 6 9-6"/>',
+  link: '<path d="M10 14a4 4 0 0 0 5.7 0l3-3a4 4 0 0 0-5.7-5.7l-1 1"/><path d="M14 10a4 4 0 0 0-5.7 0l-3 3a4 4 0 0 0 5.7 5.7l1-1"/>',
+  bookmark: '<path d="M6 3h12v18l-6-4-6 4z"/>',
+  menu: '<path d="M4 7h16M4 12h16M4 17h16"/>',
+  hash: '<path d="M5 9h14M5 15h14M10 4 8 20M16 4l-2 16"/>',
+  book: '<path d="M3 5h6a3 3 0 0 1 3 3v12a2 2 0 0 0-2-2H3zM21 5h-6a3 3 0 0 0-3 3v12a2 2 0 0 1 2-2h7z"/>',
+  sparkle:
+    '<path d="M12 3l1.8 5.2L19 10l-5.2 1.8L12 17l-1.8-5.2L5 10l5.2-1.8z"/><path d="M19 16l.7 2 2 .7-2 .7-.7 2-.7-2-2-.7 2-.7z"/>',
+  list: '<path d="M9 6h11M9 12h11M9 18h11M4 6h.01M4 12h.01M4 18h.01"/>',
+  layers: '<path d="m12 3 9 5-9 5-9-5z"/><path d="m3 13 9 5 9-5"/>',
+  pen: '<path d="M4 20h4L19 9l-4-4L4 16z"/><path d="m13 7 4 4"/>',
+});
+
+/**
+ * Render one inline icon.
+ *
+ * @param {string} name a key of {@link ICONS}
+ * @returns {string} the `<svg>` markup, or an empty string for an unknown
+ *   name (a defect the tests catch, never an author-reachable path)
+ */
+export function icon(name) {
+  const paths = ICONS[name];
+  if (paths === undefined) return '';
+  return `<svg class="g-icon" viewBox="0 0 24 24" aria-hidden="true" focusable="false">${paths}</svg>`;
+}

package/src/core/internal/llms.js

@@ -0,0 +1,252 @@
+/**
+ * `llms.txt` and `llms-full.txt` generation (the llmstxt.org format): a
+ * Markdown index of the publication for language-model assistants, and one
+ * plain-text file carrying every article in full.
+ *
+ * Only `status: "published"` content is listed. Unlisted content is
+ * reachable by direct link and marked `noindex`; it is never advertised
+ * here either.
+ */
+
+import { derivePublicBasePath, joinPublicRoute } from './route.js';
+import { routeSegmentForLabel } from './route-labels.js';
+import { compareUtf8Bytes } from './source-inventory.js';
+import {
+  contentLastModified,
+  contentRoute,
+  selectPublishedArticles,
+} from './page-kinds.js';
+import { getMessages } from './messages.js';
+
+/** @type {Readonly<Record<string, string>>} */
+const NAMED_ENTITIES = Object.freeze({
+  amp: '&',
+  lt: '<',
+  gt: '>',
+  quot: '"',
+  apos: "'",
+  nbsp: ' ',
+  hellip: '…',
+  mdash: '—',
+  ndash: '–',
+  lsquo: '‘',
+  rsquo: '’',
+  ldquo: '“',
+  rdquo: '”',
+});
+
+/**
+ * Convert a sanitized HTML fragment to readable plain text. Tags are removed
+ * first and entities decoded afterwards, so escaped markup in the source
+ * stays literal text and can never be turned back into a tag.
+ *
+ * @param {string} html a render-policy-conformant HTML fragment
+ * @returns {string} plain text with paragraph breaks, `#` headings and `-`
+ *   list items
+ */
+export function htmlToText(html) {
+  const stripped = html
+    .replace(/<(script|style)\b[\s\S]*?<\/\1\s*>/gi, '')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(
+      /<h([1-6])\b[^>]*>/gi,
+      (_match, level) => `\n\n${'#'.repeat(Number(level))} `,
+    )
+    .replace(/<li\b[^>]*>/gi, '\n- ')
+    .replace(
+      /<\/(?:p|div|h[1-6]|pre|blockquote|ul|ol|table|tr|figure|section)\s*>/gi,
+      '\n\n',
+    )
+    .replace(/<[^>]*>/g, '');
+  return stripped
+    .replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (match, body) => {
+      if (body[0] === '#') {
+        const code =
+          body[1] === 'x' || body[1] === 'X'
+            ? Number.parseInt(body.slice(2), 16)
+            : Number.parseInt(body.slice(1), 10);
+        return Number.isInteger(code) && code > 0 && code <= 0x10ffff
+          ? String.fromCodePoint(code)
+          : '';
+      }
+      return NAMED_ENTITIES[body.toLowerCase()] ?? match;
+    })
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+/**
+ * Build both documents.
+ *
+ * @param {import('../../../types/index.d.ts').NormalizedBuildInput} validatedInput
+ * @param {object} urls absolute URLs of the sibling documents
+ * @param {string} urls.rss
+ * @param {string} urls.atom
+ * @param {string} urls.sitemap
+ * @param {string} urls.searchIndex
+ * @param {string} urls.full this file's `llms-full.txt` sibling
+ * @returns {{llmsTxt: string, llmsFullTxt: string}} the exact UTF-8 texts
+ */
+export function buildLlmsDocuments(validatedInput, urls) {
+  const { publication, authors, content, basePath, baseUrl } = validatedInput;
+  const messages = getMessages(publication.defaultLanguage);
+  const authorsById = new Map(authors.map((author) => [author.id, author]));
+  /**
+   * @param {string} route an un-joined route
+   * @returns {string} the absolute URL
+   */
+  const absoluteUrl = (route) =>
+    new URL(
+      joinPublicRoute(derivePublicBasePath(baseUrl, basePath), route),
+      baseUrl,
+    ).toString();
+  const oneLine = (/** @type {string} */ value) =>
+    value.replace(/\s+/g, ' ').trim();
+
+  const articles = selectPublishedArticles(content);
+  const pages = content
+    .filter(
+      (record) =>
+        record.frontmatter.kind === 'page' &&
+        record.frontmatter.status === 'published',
+    )
+    .sort((a, b) =>
+      compareUtf8Bytes(
+        contentRoute(a.frontmatter),
+        contentRoute(b.frontmatter),
+      ),
+    );
+
+  /**
+   * @param {{title: string, url: string, description?: string}} item
+   * @returns {string} one list line
+   */
+  const link = ({ title, url, description }) =>
+    `- [${oneLine(title).replace(/[[\]]/g, '')}](${url})` +
+    (description ? `: ${oneLine(description)}` : '');
+
+  /** @type {Map<string, number>} */
+  const seriesCounts = new Map();
+  for (const record of [...articles, ...pages]) {
+    const series = record.frontmatter.series;
+    if (series) seriesCounts.set(series, (seriesCounts.get(series) ?? 0) + 1);
+  }
+
+  const authorNames = authors.map((author) => author.displayName);
+  const intro =
+    `${articles.length === 1 ? '1 article' : `${articles.length} articles`}` +
+    (authorNames.length > 0 ? ` by ${authorNames.join(', ')}` : '') +
+    `. Each article is a standalone page; the full text of every article is in llms-full.txt.`;
+
+  /** @type {string[]} */
+  const lines = [
+    `# ${oneLine(publication.title)}`,
+    '',
+    `> ${oneLine(publication.description)}`,
+    '',
+    intro,
+    '',
+    '## Articles',
+    '',
+    ...articles.map((record) =>
+      link({
+        title: record.frontmatter.title,
+        url: absoluteUrl(contentRoute(record.frontmatter)),
+        description: record.frontmatter.description,
+      }),
+    ),
+  ];
+  if (pages.length > 0) {
+    lines.push(
+      '',
+      '## Pages',
+      '',
+      ...pages.map((record) =>
+        link({
+          title: record.frontmatter.title,
+          url: absoluteUrl(contentRoute(record.frontmatter)),
+          description: record.frontmatter.description,
+        }),
+      ),
+    );
+  }
+  if (seriesCounts.size > 0) {
+    lines.push(
+      '',
+      '## Series',
+      '',
+      ...[...seriesCounts.keys()].sort().map((name) =>
+        link({
+          title: name,
+          url: absoluteUrl(`/series/${routeSegmentForLabel(name)}`),
+          description:
+            /** @type {(c: string, n: string, p: string) => string} */ (
+              messages.seriesPageDescription
+            )(String(seriesCounts.get(name)), name, publication.title),
+        }),
+      ),
+    );
+  }
+  lines.push(
+    '',
+    '## Optional',
+    '',
+    ...(articles.length > 0
+      ? [
+          link({
+            title: 'Archive',
+            url: absoluteUrl('/archive'),
+            description: 'Every article by year',
+          }),
+        ]
+      : []),
+    link({
+      title: 'Full text of every article',
+      url: urls.full,
+      description: 'Plain text',
+    }),
+    link({ title: 'RSS feed', url: urls.rss }),
+    link({ title: 'Atom feed', url: urls.atom }),
+    link({ title: 'Sitemap', url: urls.sitemap }),
+    link({
+      title: 'Search index',
+      url: urls.searchIndex,
+      description: 'JSON',
+    }),
+  );
+
+  const fullSections = articles.map((record) => {
+    const { frontmatter } = record;
+    const names = frontmatter.authorIds
+      .map((id) => authorsById.get(id)?.displayName)
+      .filter(Boolean);
+    return [
+      `# ${oneLine(frontmatter.title)}`,
+      '',
+      `URL: ${absoluteUrl(contentRoute(frontmatter))}`,
+      `Published: ${frontmatter.publishedAt}`,
+      ...(frontmatter.updatedAt
+        ? [`Updated: ${contentLastModified(frontmatter)}`]
+        : []),
+      ...(names.length > 0 ? [`Author: ${names.join(', ')}`] : []),
+      ...(frontmatter.tags.length > 0
+        ? [`Tags: ${frontmatter.tags.join(', ')}`]
+        : []),
+      ...(frontmatter.description
+        ? ['', `> ${oneLine(frontmatter.description)}`]
+        : []),
+      '',
+      htmlToText(record.body),
+    ].join('\n');
+  });
+  const llmsFullTxt =
+    [
+      `# ${oneLine(publication.title)}`,
+      '',
+      `> ${oneLine(publication.description)}`,
+      ...fullSections.flatMap((section) => ['', '---', '', section]),
+    ].join('\n') + '\n';
+
+  return { llmsTxt: `${lines.join('\n')}\n`, llmsFullTxt };
+}

package/src/core/internal/media/pipeline.js

@@ -192,7 +192,9 @@ function derivativePath(sourceDigest, variant, extension) {
  *
  * @param {Buffer} bytes verified source bytes
  * @param {ImageReference} reference the reference these bytes back
- * @returns {PipelineOutputFile[]} the output files this reference produces
+ * @returns {{files: PipelineOutputFile[], width: number, height: number}}
+ *   the output files this reference produces and the canonical original's
+ *   pixel dimensions
  */
 function processImage(bytes, reference) {
   const format = sniffMediaFormat(bytes);
@@ -214,18 +216,21 @@ function processImage(bytes, reference) {
   if (format === 'webp' || format === 'avif') {
     // Bounded container/dimension validation only; see webp-probe.js and
     // avif-probe.js module documentation for the documented scope decision.
-    if (format === 'webp') {
-      probeWebp(bytes, reference.path);
-    } else {
-      probeAvif(bytes, reference.path);
-    }
+    const size =
+      format === 'webp'
+        ? probeWebp(bytes, reference.path)
+        : probeAvif(bytes, reference.path);
     const extension = EXTENSION_BY_MEDIA_TYPE[MEDIA_TYPE_BY_FORMAT[format]];
-    return [
-      {
-        path: derivativePath(reference.sourceDigest, 'original', extension),
-        bytes,
-      },
-    ];
+    return {
+      files: [
+        {
+          path: derivativePath(reference.sourceDigest, 'original', extension),
+          bytes,
+        },
+      ],
+      width: size.width,
+      height: size.height,
+    };
   }
 
   /** @type {{width: number, height: number, rgba: Buffer}} */
@@ -261,7 +266,7 @@ function processImage(bytes, reference) {
       bytes: encode(resized),
     });
   }
-  return outputs;
+  return { files: outputs, width: oriented.width, height: oriented.height };
 }
 
 /**
@@ -272,8 +277,11 @@ function processImage(bytes, reference) {
  *   the validated build input
  * @param {{sourceDirectory: string}} options the media pipeline's own
  *   options
- * @returns {Promise<{assets: import('../../../../types/index.d.ts').ManifestAssetEntry[], files: PipelineOutputFile[]}>}
- *   the asset manifest rows and the output files backing them
+ * @returns {Promise<{assets: import('../../../../types/index.d.ts').ManifestAssetEntry[], files: PipelineOutputFile[], dimensions: Record<string, {width: number, height: number}>}>}
+ *   the asset manifest rows, the output files backing them, and the pixel
+ *   dimensions of each image's canonical original keyed by its output path
+ *   (`manifestAsset` has no width/height field, so this is the one place the
+ *   renderer learns them, for `<img width height>` and structured data)
  */
 export async function processMedia(buildInput, { sourceDirectory }) {
   const imageReferences = collectImageReferences(buildInput);
@@ -295,14 +303,21 @@ export async function processMedia(buildInput, { sourceDirectory }) {
 
   /** @type {PipelineOutputFile[]} */
   const files = [];
+  /** @type {Record<string, {width: number, height: number}>} */
+  const dimensions = {};
   let totalBytes = 0;
 
   for (const reference of imageReferences) {
     const bytes = await readAndVerify(sourceDirectory, reference);
-    for (const output of processImage(bytes, reference)) {
+    const processed = processImage(bytes, reference);
+    for (const output of processed.files) {
       totalBytes += output.bytes.byteLength;
       files.push(output);
     }
+    dimensions[processed.files[0].path] = {
+      width: processed.width,
+      height: processed.height,
+    };
   }
 
   for (const reference of fontReferences) {
@@ -349,5 +364,5 @@ export async function processMedia(buildInput, { sourceDirectory }) {
     });
   });
 
-  return { assets, files };
+  return { assets, files, dimensions };
 }

package/src/core/internal/messages.js

@@ -56,6 +56,110 @@ const CATALOGS = Object.freeze({
     appearanceModeLightLabel: 'Light',
     appearanceModeDarkLabel: 'Dark',
     appearanceModeSystemLabel: 'System',
+    searchButtonLabel: 'Search',
+    searchButtonAriaLabel: 'Search articles',
+    searchPlaceholderLabel: 'Search the publication',
+    searchEmptyLabel: 'No articles match your search.',
+    searchUnavailableLabel: 'Search is unavailable right now.',
+    copyCodeLabel: 'Copy',
+    copiedLabel: 'Copied',
+    linkCopiedLabel: 'Link copied.',
+    copyBlockedLabel:
+      'Copying is blocked here. Copy the address from your browser.',
+    codeSelectedLabel: 'Code selected. Press Ctrl C or Command C to copy.',
+    savedLabel: 'Saved for later.',
+    unsavedLabel: 'Removed from saved articles.',
+    menuSummaryLabel: 'Menu',
+    featuredLabel: 'Featured',
+    readEssayLabel: 'Read the essay',
+    latestHeading: 'Latest',
+    moreArticlesHeading: 'More articles',
+    browseByTagLabel: 'Browse by tag',
+    seriesCardLabel: 'Series',
+    /** @type {(count: string) => string} */
+    partsCountLabel: (count) => `${count} parts`,
+    startSeriesLabel: 'Start with part 1',
+    newsletterLabel: 'Newsletter',
+    newsletterActionLabel: 'Subscribe',
+    /** @type {(minutes: string) => string} */
+    readingTimeLabel: (minutes) => `${minutes} min read`,
+    /** @type {(part: string, total: string) => string} */
+    seriesPartLabel: (part, total) => `Part ${part} of ${total}`,
+    onThisPageLabel: 'On this page',
+    writtenByLabel: 'Written by',
+    aboutTheAuthorLabel: 'About the author',
+    youAreHereLabel: 'You are here',
+    newerArticleLabel: 'Newer',
+    olderArticleLabel: 'Older',
+    moreArticlesNavigationLabel: 'More articles',
+    keepReadingHeading: 'Keep reading',
+    /** @type {(tag: string) => string} */
+    moreInTagLabel: (tag) => `More in ${tag}`,
+    shareLabel: 'Share',
+    copyLinkLabel: 'Copy link to this article',
+    saveForLaterLabel: 'Save for later',
+    tagListLabel: 'Tags',
+    tagKickerLabel: 'Tag',
+    seriesKickerLabel: 'Series',
+    archiveKickerLabel: 'Archive',
+    authorKickerLabel: 'Author',
+    /** @type {(count: string) => string} */
+    articleCountLabel: (count) =>
+      count === '1' ? '1 article' : `${count} articles`,
+    emptyListingLabel: 'No articles yet.',
+    aboutPageTitle: 'About',
+    /** @type {(date: string) => string} */
+    updatedLabel: (date) => `Updated ${date}`,
+    /** @type {(tag: string) => string} */
+    tagPageTitle: (tag) => `Posts tagged \u201c${tag}\u201d`,
+    /** @type {(count: string, tag: string, publication: string) => string} */
+    tagPageDescription: (count, tag, publication) =>
+      `${count === '1' ? '1 article' : `${count} articles`} tagged ${tag} on ${publication}.`,
+    /** @type {(count: string, name: string, publication: string) => string} */
+    seriesPageDescription: (count, name, publication) =>
+      `${name}, a series of ${count === '1' ? '1 part' : `${count} parts`} on ${publication}.`,
+    /** @type {(year: string) => string} */
+    archivePageTitle: (year) => `Archive ${year}`,
+    /** @type {(count: string, year: string, publication: string) => string} */
+    archivePageDescription: (count, year, publication) =>
+      `${count === '1' ? '1 article' : `${count} articles`} published in ${year} on ${publication}.`,
+    /** @type {(name: string, publication: string) => string} */
+    authorPageDescription: (name, publication) =>
+      `Articles written by ${name} on ${publication}.`,
+    /** @type {(count: string, publication: string) => string} */
+    tagsRootDescription: (count, publication) =>
+      `Browse the ${count} topics covered on ${publication}.`,
+    /** @type {(count: string, publication: string) => string} */
+    seriesRootDescription: (count, publication) =>
+      `Browse the ${count} series published on ${publication}.`,
+    /** @type {(count: string, publication: string) => string} */
+    archiveRootDescription: (count, publication) =>
+      `Every article on ${publication}, ${count} in all, by year.`,
+    /** @type {(publication: string) => string} */
+    indexPageDescription: (publication) =>
+      `All articles on ${publication}, newest first.`,
+    exploreColumnLabel: 'Explore',
+    rssFeedLabel: 'RSS feed',
+    /** @type {(iso: string) => string} */
+    formatDate: (iso) => {
+      const months = [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'May',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec',
+      ];
+      const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
+      if (!match) return iso;
+      return `${months[Number(match[2]) - 1]} ${Number(match[3])}, ${match[1]}`;
+    },
   }),
 });