@sarimarcus/content-sites-core 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All packages in the platform release in lockstep; entries are per release version.
 
+## 0.9.0 (2026-09-30)
+
+- `./config`: `defineSiteConfig` (the shared Astro config: static skeleton, image service, Vite settings, outbound-rel → sitemap → Pagefind; lastmod map from content, guide dirs, `itemKeys`, `extraKeys`; sitemap `exclude` and `rules`; optional `redirects` and `ssrNoExternal`; `pagefind` injected), `buildLastmodMap`, `sitemapSerialize`, `outboundLinkRel({ root })`, and the guide scanners `latestGuideDate`, `guideDateMap`, `guidePublishDates` with one `dateModified` regex. Peer-depends on `@astrojs/sitemap` and `@tailwindcss/vite` (SLA-2747).
+
 ## 0.8.0 (2026-09-30)
 
 - Stable release of 0.8.0-rc.0, unchanged: adopted on all three sites with every page identical (Córdoba 631, Granada 589, Dark Skies 654, including Córdoba's .ics feeds); astro check 0 errors (SLA-2747).

package/dist/config/guideDates.d.ts

@@ -0,0 +1,11 @@
+/** Latest `dateModified` across the `.astro` pages of one directory; 1970-01-01 when it is missing or has none. */
+export declare function latestGuideDate(dirPath: string): string;
+/** `<dir>/<slug>` → latest `dateModified`, for each `.astro` page of `pagesDir/<dir>` that has one. */
+export declare function guideDateMap(pagesDir: string, dir: string): Map<string, string>;
+/**
+ * Route path → earliest `datePublished` for the guide pages in the given `pagesDir` subdirectories, e.g.
+ * '/plan/getting-there' → '2026-06-12'. Keyed by full route so a /plan/<slug> never lends its date to a
+ * same-named /discover/<slug>. Pages without a `datePublished` are absent. A missing directory throws: an
+ * empty map would silently drop every badge.
+ */
+export declare function guidePublishDates(pagesDir: string, ...dirs: string[]): Record<string, string>;

package/dist/config/guideDates.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { EPOCH } from "../dates/lastmod.js";
+const DATE_MODIFIED = /dateModified[:\s=]*["'](\d{4}-\d{2}-\d{2})/g;
+const DATE_PUBLISHED = /datePublished\s*[=:]\s*["'](\d{4}-\d{2}-\d{2})/g;
+function astroFiles(dir) {
+    return fs.readdirSync(dir).filter((f) => f.endsWith('.astro'));
+}
+function latestIn(content) {
+    let latest = EPOCH;
+    for (const m of content.matchAll(DATE_MODIFIED))
+        if (m[1] > latest)
+            latest = m[1];
+    return latest;
+}
+/** Latest `dateModified` across the `.astro` pages of one directory; 1970-01-01 when it is missing or has none. */
+export function latestGuideDate(dirPath) {
+    let latest = EPOCH;
+    if (!fs.existsSync(dirPath))
+        return latest;
+    for (const file of astroFiles(dirPath)) {
+        const d = latestIn(fs.readFileSync(path.join(dirPath, file), 'utf-8'));
+        if (d > latest)
+            latest = d;
+    }
+    return latest;
+}
+/** `<dir>/<slug>` → latest `dateModified`, for each `.astro` page of `pagesDir/<dir>` that has one. */
+export function guideDateMap(pagesDir, dir) {
+    const map = new Map();
+    const dirPath = path.join(pagesDir, dir);
+    if (!fs.existsSync(dirPath))
+        return map;
+    for (const file of astroFiles(dirPath)) {
+        const d = latestIn(fs.readFileSync(path.join(dirPath, file), 'utf-8'));
+        if (d > EPOCH)
+            map.set(`${dir}/${file.replace('.astro', '')}`, d);
+    }
+    return map;
+}
+/**
+ * Route path → earliest `datePublished` for the guide pages in the given `pagesDir` subdirectories, e.g.
+ * '/plan/getting-there' → '2026-06-12'. Keyed by full route so a /plan/<slug> never lends its date to a
+ * same-named /discover/<slug>. Pages without a `datePublished` are absent. A missing directory throws: an
+ * empty map would silently drop every badge.
+ */
+export function guidePublishDates(pagesDir, ...dirs) {
+    const dates = {};
+    for (const rawDir of dirs) {
+        const dir = rawDir.replace(/^\/+|\/+$/g, '');
+        const dirPath = path.join(pagesDir, dir);
+        if (!fs.existsSync(dirPath))
+            throw new Error(`guidePublishDates: ${path.join(path.basename(pagesDir), dir)} does not exist`);
+        for (const file of astroFiles(dirPath)) {
+            const content = fs.readFileSync(path.join(dirPath, file), 'utf-8');
+            let published = null;
+            for (const m of content.matchAll(DATE_PUBLISHED))
+                if (published === null || m[1] < published)
+                    published = m[1];
+            if (published)
+                dates[`/${dir}/${file.replace(/\.astro$/, '')}`] = published;
+        }
+    }
+    return dates;
+}

package/dist/config/index.d.ts

@@ -1 +1,5 @@
-export {};
+export { defineSiteConfig, buildLastmodMap, sitemapSerialize } from './siteConfig.ts';
+export type { SiteConfigOptions, SitemapRule, PagefindIntegration } from './siteConfig.ts';
+export { outboundLinkRel } from './outboundLinkRel.ts';
+export type { OutboundLinkRelOptions } from './outboundLinkRel.ts';
+export { latestGuideDate, guideDateMap, guidePublishDates } from './guideDates.ts';

package/dist/config/index.js

@@ -1,2 +1,4 @@
-// Public surface of @sarimarcus/content-sites-core/config. Components land here from SLA-2742 on.
-export {};
+// Public surface of @sarimarcus/content-sites-core/config. Node-only: astro.config.mjs imports it.
+export { defineSiteConfig, buildLastmodMap, sitemapSerialize } from "./siteConfig.js";
+export { outboundLinkRel } from "./outboundLinkRel.js";
+export { latestGuideDate, guideDateMap, guidePublishDates } from "./guideDates.js";

package/dist/config/outboundLinkRel.d.ts

@@ -0,0 +1,11 @@
+import type { AstroIntegration } from 'astro';
+export interface OutboundLinkRelOptions {
+    /** Site root; the classification store is read from `src/data/outbound-domains.json` under it. */
+    root: string | URL;
+}
+/**
+ * Astro integration enforcing the outbound rel policy on every anchor of the built HTML, whichever component
+ * rendered it: competitor-classified hosts gain `nofollow`, affiliate-classified hosts gain `sponsored`, and
+ * everything else is untouched.
+ */
+export declare function outboundLinkRel({ root }: OutboundLinkRelOptions): AstroIntegration;

package/dist/config/outboundLinkRel.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+function walk(dir, out = []) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const p = path.join(dir, e.name);
+        if (e.isDirectory())
+            walk(p, out);
+        else if (/\.html$/.test(e.name))
+            out.push(p);
+    }
+    return out;
+}
+function mergeRel(attrs, tokens) {
+    if (/\brel\s*=\s*["'][^"']*["']/i.test(attrs)) {
+        return attrs.replace(/\brel\s*=\s*["']([^"']*)["']/i, (_m, existing) => {
+            const set = new Set([...existing.split(/\s+/).filter(Boolean), ...tokens]);
+            return `rel="${[...set].join(' ')}"`;
+        });
+    }
+    return `${attrs} rel="${tokens.join(' ')}"`;
+}
+/**
+ * Astro integration enforcing the outbound rel policy on every anchor of the built HTML, whichever component
+ * rendered it: competitor-classified hosts gain `nofollow`, affiliate-classified hosts gain `sponsored`, and
+ * everything else is untouched.
+ */
+export function outboundLinkRel({ root }) {
+    const siteRoot = root instanceof URL ? fileURLToPath(root) : root;
+    return {
+        name: 'outbound-link-rel',
+        hooks: {
+            'astro:build:done': async ({ dir, logger }) => {
+                const store = JSON.parse(fs.readFileSync(path.join(siteRoot, 'src/data/outbound-domains.json'), 'utf-8'));
+                const classes = new Map(Object.entries(store.domains).map(([d, e]) => [d.replace(/^www\./, '').toLowerCase(), e.class]));
+                const outDir = fileURLToPath(dir);
+                let files = 0;
+                let anchors = 0;
+                for (const file of walk(outDir)) {
+                    const original = fs.readFileSync(file, 'utf-8');
+                    let changed = false;
+                    const html = original.replace(/<a\b([^>]*)>/gi, (tag, attrs) => {
+                        const href = attrs.match(/href\s*=\s*"([^"]*)"/i)?.[1] ?? attrs.match(/href\s*=\s*'([^']*)'/i)?.[1];
+                        if (!href || !/^https?:\/\//i.test(href))
+                            return tag;
+                        let host;
+                        try {
+                            host = new URL(href).hostname.toLowerCase().replace(/^www\./, '');
+                        }
+                        catch {
+                            return tag;
+                        }
+                        const cls = classes.get(host) ?? 'other';
+                        if (cls !== 'competitor' && cls !== 'affiliate')
+                            return tag;
+                        anchors++;
+                        const tokens = [];
+                        if (cls === 'competitor' && !/\bnofollow\b/i.test(attrs))
+                            tokens.push('nofollow');
+                        if (cls === 'affiliate' && !/\bsponsored\b/i.test(attrs))
+                            tokens.push('sponsored');
+                        if (!tokens.length)
+                            return tag;
+                        changed = true;
+                        return `<a${mergeRel(attrs, ['noopener', ...tokens])}>`;
+                    });
+                    if (changed)
+                        fs.writeFileSync(file, html);
+                    files++;
+                }
+                logger.info(`outbound-link-rel: scanned ${files} html file(s), enforced policy on ${anchors} affiliate/competitor anchor(s)`);
+            },
+        },
+    };
+}

package/dist/config/siteConfig.d.ts

@@ -0,0 +1,55 @@
+import type { AstroIntegration, AstroUserConfig } from 'astro';
+import { type SitemapItem } from '@astrojs/sitemap';
+export interface SitemapRule {
+    match: (parts: string[]) => boolean;
+    priority?: number;
+    changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+}
+/** astro-pagefind's default export. Passed in: it ships TypeScript source, which plain Node refuses under node_modules. */
+export type PagefindIntegration = (options: {
+    indexConfig: {
+        excludeSelectors: string[];
+        forceLanguage: string;
+    };
+}) => AstroIntegration;
+export interface SiteConfigOptions {
+    /** Absolute origin, e.g. `https://www.example.com`. */
+    site: string;
+    /** Site root (pass `new URL('.', import.meta.url)`): holds src/content, src/pages and src/data/outbound-domains.json. */
+    root: string | URL;
+    redirects?: Record<string, string>;
+    lastmod: {
+        /** URL segment → content directory, e.g. `{ monument: 'monuments' }`. */
+        contentDirMap: Record<string, string>;
+        /** src/pages subdirectories whose `.astro` guides carry a `dateModified`. */
+        guideDirs: string[];
+        /** Extra lookup keys an item's date also feeds; each keeps the latest date it sees. */
+        itemKeys?: (urlType: string, item: Record<string, unknown>) => string[];
+        /** Extra lookup keys computed from each content directory's latest date. */
+        extraKeys?: (collectionMax: Record<string, string>) => Record<string, string | undefined>;
+    };
+    sitemap?: {
+        /** A pathname any predicate accepts is left out; `/search` always is. */
+        exclude?: Array<(pathname: string) => boolean>;
+        /** Every matching rule sets its fields on the item. */
+        rules?: SitemapRule[];
+    };
+    /** Packages Vite must bundle during SSR. */
+    ssrNoExternal?: string[];
+    pagefind: PagefindIntegration;
+    /** Pagefind index language. */
+    language?: string;
+}
+/** Lookup key → date for the sitemap, plus the latest date overall (the fallback). */
+export declare function buildLastmodMap(rootDir: string, opts: SiteConfigOptions['lastmod']): {
+    lastmodMap: Map<string, string>;
+    mostRecent: string;
+};
+/** The sitemap `serialize` hook: trailing slash stripped, exclusions dropped, lastmod looked up, rules applied. */
+export declare function sitemapSerialize(lastmodMap: Map<string, string>, mostRecent: string, { exclude, rules }?: NonNullable<SiteConfigOptions['sitemap']>): (item: SitemapItem) => SitemapItem | undefined;
+/**
+ * The Astro config every content site shares: static output, the image service, build and Vite settings, and the
+ * outbound-rel → sitemap → Pagefind integrations. The sitemap `lastmod` comes from content `dateModified`, guide
+ * pages and the site's extra keys, looked up by the first 3, 2, then 1 path segments.
+ */
+export declare function defineSiteConfig(opts: SiteConfigOptions): AstroUserConfig;

package/dist/config/siteConfig.js

@@ -0,0 +1,155 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import tailwindcss from '@tailwindcss/vite';
+import sitemap, {} from '@astrojs/sitemap';
+import { outboundLinkRel } from "./outboundLinkRel.js";
+import { guideDateMap } from "./guideDates.js";
+import { EPOCH } from "../dates/lastmod.js";
+// A missing date, or a date-only value equal to today, is stamped with the build instant.
+function toDateWithTime(dateStr) {
+    if (!dateStr)
+        return new Date().toISOString();
+    if (dateStr.includes('T'))
+        return new Date(dateStr).toISOString();
+    const today = new Date().toISOString().split('T')[0];
+    if (dateStr === today)
+        return new Date().toISOString();
+    return new Date(`${dateStr}T12:00:00Z`).toISOString();
+}
+/** Lookup key → date for the sitemap, plus the latest date overall (the fallback). */
+export function buildLastmodMap(rootDir, opts) {
+    const lastmodMap = new Map();
+    const contentBase = path.join(rootDir, 'src/content');
+    let mostRecent = EPOCH;
+    const collectionMax = {};
+    for (const [urlType, dir] of Object.entries(opts.contentDirMap)) {
+        const dirPath = path.join(contentBase, dir);
+        if (!fs.existsSync(dirPath))
+            continue;
+        let maxForCollection = EPOCH;
+        for (const file of fs.readdirSync(dirPath)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const content = JSON.parse(fs.readFileSync(path.join(dirPath, file), 'utf-8'));
+                if (content.slug && content.dateModified) {
+                    lastmodMap.set(`${urlType}/${content.slug}`, content.dateModified);
+                    for (const key of opts.itemKeys?.(urlType, content) ?? []) {
+                        if (content.dateModified > (lastmodMap.get(key) || ''))
+                            lastmodMap.set(key, content.dateModified);
+                    }
+                    if (content.dateModified > maxForCollection)
+                        maxForCollection = content.dateModified;
+                    if (content.dateModified > mostRecent)
+                        mostRecent = content.dateModified;
+                }
+            }
+            catch {
+                // an unparseable file contributes nothing
+            }
+        }
+        collectionMax[dir] = maxForCollection;
+    }
+    for (const dir of Object.values(opts.contentDirMap)) {
+        if (collectionMax[dir] && collectionMax[dir] > EPOCH)
+            lastmodMap.set(dir, collectionMax[dir]);
+    }
+    const pagesDir = path.join(rootDir, 'src/pages');
+    for (const dir of opts.guideDirs) {
+        let maxForHub = EPOCH;
+        for (const [key, date] of guideDateMap(pagesDir, dir)) {
+            lastmodMap.set(key, date);
+            if (date > maxForHub)
+                maxForHub = date;
+        }
+        if (maxForHub > EPOCH)
+            lastmodMap.set(dir, maxForHub);
+    }
+    for (const [key, date] of Object.entries(opts.extraKeys?.(collectionMax) ?? {})) {
+        if (date && date > EPOCH)
+            lastmodMap.set(key, date);
+    }
+    return { lastmodMap, mostRecent };
+}
+/** The sitemap `serialize` hook: trailing slash stripped, exclusions dropped, lastmod looked up, rules applied. */
+export function sitemapSerialize(lastmodMap, mostRecent, { exclude = [], rules = [] } = {}) {
+    return (item) => {
+        if (item.url.endsWith('/'))
+            item.url = item.url.slice(0, -1);
+        const url = new URL(item.url);
+        if (url.pathname === '/search')
+            return undefined;
+        if (exclude.some((ex) => ex(url.pathname)))
+            return undefined;
+        const pathParts = url.pathname.split('/').filter(Boolean);
+        const dateModified = lastmodMap.get(pathParts.slice(0, 3).join('/')) ||
+            lastmodMap.get(pathParts.slice(0, 2).join('/')) ||
+            lastmodMap.get(pathParts[0]) ||
+            mostRecent;
+        item.lastmod = toDateWithTime(dateModified);
+        for (const rule of rules) {
+            if (!rule.match(pathParts))
+                continue;
+            if (rule.priority !== undefined)
+                item.priority = rule.priority;
+            if (rule.changefreq !== undefined)
+                item.changefreq = rule.changefreq;
+        }
+        return item;
+    };
+}
+/**
+ * The Astro config every content site shares: static output, the image service, build and Vite settings, and the
+ * outbound-rel → sitemap → Pagefind integrations. The sitemap `lastmod` comes from content `dateModified`, guide
+ * pages and the site's extra keys, looked up by the first 3, 2, then 1 path segments.
+ */
+export function defineSiteConfig(opts) {
+    const rootDir = opts.root instanceof URL ? fileURLToPath(opts.root) : opts.root;
+    const { lastmodMap, mostRecent } = buildLastmodMap(rootDir, opts.lastmod);
+    return {
+        ...(opts.redirects ? { redirects: opts.redirects } : {}),
+        site: opts.site,
+        base: '/',
+        output: 'static',
+        trailingSlash: 'never',
+        compressHTML: true,
+        image: {
+            service: {
+                entrypoint: process.env.CI ? 'astro/assets/services/noop' : 'astro/assets/services/sharp',
+                config: {
+                    limitInputPixels: false,
+                    avif: { quality: 65, effort: 6, chromaSubsampling: '4:2:0' },
+                    // Astro re-encodes from decoded pixels, so the delivered quality is set here, not by the source file.
+                    webp: { quality: 65, effort: 6 },
+                },
+            },
+        },
+        build: {
+            format: 'file',
+            inlineStylesheets: 'auto',
+        },
+        vite: {
+            plugins: [tailwindcss()],
+            worker: { format: 'es' },
+            ...(opts.ssrNoExternal?.length ? { ssr: { noExternal: opts.ssrNoExternal } } : {}),
+            build: {
+                cssMinify: true,
+                minify: 'esbuild',
+                rollupOptions: {
+                    external: ['/pagefind/pagefind-ui.js', '/pagefind/pagefind.js'],
+                },
+            },
+        },
+        integrations: [
+            outboundLinkRel({ root: rootDir }),
+            sitemap({ serialize: sitemapSerialize(lastmodMap, mostRecent, opts.sitemap) }),
+            opts.pagefind({
+                indexConfig: {
+                    excludeSelectors: ['nav', 'footer', '.breadcrumb', '[data-pagefind-ignore]'],
+                    forceLanguage: opts.language ?? 'en',
+                },
+            }),
+        ],
+    };
+}

package/dist/dates/lastmod.d.ts

@@ -1,3 +1,4 @@
+export declare const EPOCH = "1970-01-01";
 /** The latest of several `YYYY-MM-DD` strings; empty values are skipped, and none gives 1970-01-01. */
 export declare function maxDate(...dates: string[]): string;
 /** The latest `data.dateModified` across collection entries; entries without one are skipped. */

package/dist/dates/lastmod.js

@@ -1,4 +1,4 @@
-const EPOCH = '1970-01-01';
+export const EPOCH = '1970-01-01';
 /** The latest of several `YYYY-MM-DD` strings; empty values are skipped, and none gives 1970-01-01. */
 export function maxDate(...dates) {
     let latest = EPOCH;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarimarcus/content-sites-core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Non-visual utilities, Astro config builders and SEO schema assembly shared by the content sites.",
   "type": "module",
   "license": "MIT",
@@ -62,6 +62,8 @@
     "marked": "^18.0.14"
   },
   "peerDependencies": {
-    "astro": "^7.0.6"
+    "astro": "^7.0.6",
+    "@astrojs/sitemap": "^3.7.4",
+    "@tailwindcss/vite": "~4.3.3"
   }
 }

package/src/config/guideDates.ts

@@ -0,0 +1,62 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { EPOCH } from '../dates/lastmod.ts';
+
+const DATE_MODIFIED = /dateModified[:\s=]*["'](\d{4}-\d{2}-\d{2})/g;
+const DATE_PUBLISHED = /datePublished\s*[=:]\s*["'](\d{4}-\d{2}-\d{2})/g;
+
+function astroFiles(dir: string): string[] {
+  return fs.readdirSync(dir).filter((f) => f.endsWith('.astro'));
+}
+
+function latestIn(content: string): string {
+  let latest = EPOCH;
+  for (const m of content.matchAll(DATE_MODIFIED)) if (m[1] > latest) latest = m[1];
+  return latest;
+}
+
+/** Latest `dateModified` across the `.astro` pages of one directory; 1970-01-01 when it is missing or has none. */
+export function latestGuideDate(dirPath: string): string {
+  let latest = EPOCH;
+  if (!fs.existsSync(dirPath)) return latest;
+  for (const file of astroFiles(dirPath)) {
+    const d = latestIn(fs.readFileSync(path.join(dirPath, file), 'utf-8'));
+    if (d > latest) latest = d;
+  }
+  return latest;
+}
+
+/** `<dir>/<slug>` → latest `dateModified`, for each `.astro` page of `pagesDir/<dir>` that has one. */
+export function guideDateMap(pagesDir: string, dir: string): Map<string, string> {
+  const map = new Map<string, string>();
+  const dirPath = path.join(pagesDir, dir);
+  if (!fs.existsSync(dirPath)) return map;
+  for (const file of astroFiles(dirPath)) {
+    const d = latestIn(fs.readFileSync(path.join(dirPath, file), 'utf-8'));
+    if (d > EPOCH) map.set(`${dir}/${file.replace('.astro', '')}`, d);
+  }
+  return map;
+}
+
+/**
+ * Route path → earliest `datePublished` for the guide pages in the given `pagesDir` subdirectories, e.g.
+ * '/plan/getting-there' → '2026-06-12'. Keyed by full route so a /plan/<slug> never lends its date to a
+ * same-named /discover/<slug>. Pages without a `datePublished` are absent. A missing directory throws: an
+ * empty map would silently drop every badge.
+ */
+export function guidePublishDates(pagesDir: string, ...dirs: string[]): Record<string, string> {
+  const dates: Record<string, string> = {};
+  for (const rawDir of dirs) {
+    const dir = rawDir.replace(/^\/+|\/+$/g, '');
+    const dirPath = path.join(pagesDir, dir);
+    if (!fs.existsSync(dirPath)) throw new Error(`guidePublishDates: ${path.join(path.basename(pagesDir), dir)} does not exist`);
+    for (const file of astroFiles(dirPath)) {
+      const content = fs.readFileSync(path.join(dirPath, file), 'utf-8');
+      let published: string | null = null;
+      for (const m of content.matchAll(DATE_PUBLISHED)) if (published === null || m[1] < published) published = m[1];
+      if (published) dates[`/${dir}/${file.replace(/\.astro$/, '')}`] = published;
+    }
+  }
+  return dates;
+}

package/src/config/index.ts

@@ -1,2 +1,6 @@
-// Public surface of @sarimarcus/content-sites-core/config. Components land here from SLA-2742 on.
-export {};
+// Public surface of @sarimarcus/content-sites-core/config. Node-only: astro.config.mjs imports it.
+export { defineSiteConfig, buildLastmodMap, sitemapSerialize } from './siteConfig.ts';
+export type { SiteConfigOptions, SitemapRule, PagefindIntegration } from './siteConfig.ts';
+export { outboundLinkRel } from './outboundLinkRel.ts';
+export type { OutboundLinkRelOptions } from './outboundLinkRel.ts';
+export { latestGuideDate, guideDateMap, guidePublishDates } from './guideDates.ts';

package/src/config/outboundLinkRel.ts

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { AstroIntegration } from 'astro';
+
+export interface OutboundLinkRelOptions {
+  /** Site root; the classification store is read from `src/data/outbound-domains.json` under it. */
+  root: string | URL;
+}
+
+function walk(dir: string, out: string[] = []): string[] {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) walk(p, out);
+    else if (/\.html$/.test(e.name)) out.push(p);
+  }
+  return out;
+}
+
+function mergeRel(attrs: string, tokens: string[]): string {
+  if (/\brel\s*=\s*["'][^"']*["']/i.test(attrs)) {
+    return attrs.replace(/\brel\s*=\s*["']([^"']*)["']/i, (_m, existing: string) => {
+      const set = new Set([...existing.split(/\s+/).filter(Boolean), ...tokens]);
+      return `rel="${[...set].join(' ')}"`;
+    });
+  }
+  return `${attrs} rel="${tokens.join(' ')}"`;
+}
+
+/**
+ * Astro integration enforcing the outbound rel policy on every anchor of the built HTML, whichever component
+ * rendered it: competitor-classified hosts gain `nofollow`, affiliate-classified hosts gain `sponsored`, and
+ * everything else is untouched.
+ */
+export function outboundLinkRel({ root }: OutboundLinkRelOptions): AstroIntegration {
+  const siteRoot = root instanceof URL ? fileURLToPath(root) : root;
+  return {
+    name: 'outbound-link-rel',
+    hooks: {
+      'astro:build:done': async ({ dir, logger }) => {
+        const store = JSON.parse(fs.readFileSync(path.join(siteRoot, 'src/data/outbound-domains.json'), 'utf-8')) as {
+          domains: Record<string, { class: string }>;
+        };
+        const classes = new Map(Object.entries(store.domains).map(([d, e]) => [d.replace(/^www\./, '').toLowerCase(), e.class]));
+        const outDir = fileURLToPath(dir);
+        let files = 0;
+        let anchors = 0;
+        for (const file of walk(outDir)) {
+          const original = fs.readFileSync(file, 'utf-8');
+          let changed = false;
+          const html = original.replace(/<a\b([^>]*)>/gi, (tag, attrs: string) => {
+            const href = attrs.match(/href\s*=\s*"([^"]*)"/i)?.[1] ?? attrs.match(/href\s*=\s*'([^']*)'/i)?.[1];
+            if (!href || !/^https?:\/\//i.test(href)) return tag;
+            let host: string;
+            try {
+              host = new URL(href).hostname.toLowerCase().replace(/^www\./, '');
+            } catch {
+              return tag;
+            }
+            const cls = classes.get(host) ?? 'other';
+            if (cls !== 'competitor' && cls !== 'affiliate') return tag;
+            anchors++;
+            const tokens: string[] = [];
+            if (cls === 'competitor' && !/\bnofollow\b/i.test(attrs)) tokens.push('nofollow');
+            if (cls === 'affiliate' && !/\bsponsored\b/i.test(attrs)) tokens.push('sponsored');
+            if (!tokens.length) return tag;
+            changed = true;
+            return `<a${mergeRel(attrs, ['noopener', ...tokens])}>`;
+          });
+          if (changed) fs.writeFileSync(file, html);
+          files++;
+        }
+        logger.info(`outbound-link-rel: scanned ${files} html file(s), enforced policy on ${anchors} affiliate/competitor anchor(s)`);
+      },
+    },
+  };
+}

package/src/config/siteConfig.ts

@@ -0,0 +1,185 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { AstroIntegration, AstroUserConfig } from 'astro';
+import tailwindcss from '@tailwindcss/vite';
+import sitemap, { type SitemapItem } from '@astrojs/sitemap';
+import { outboundLinkRel } from './outboundLinkRel.ts';
+import { guideDateMap } from './guideDates.ts';
+
+import { EPOCH } from '../dates/lastmod.ts';
+
+export interface SitemapRule {
+  match: (parts: string[]) => boolean;
+  priority?: number;
+  changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+}
+
+/** astro-pagefind's default export. Passed in: it ships TypeScript source, which plain Node refuses under node_modules. */
+export type PagefindIntegration = (options: { indexConfig: { excludeSelectors: string[]; forceLanguage: string } }) => AstroIntegration;
+
+export interface SiteConfigOptions {
+  /** Absolute origin, e.g. `https://www.example.com`. */
+  site: string;
+  /** Site root (pass `new URL('.', import.meta.url)`): holds src/content, src/pages and src/data/outbound-domains.json. */
+  root: string | URL;
+  redirects?: Record<string, string>;
+  lastmod: {
+    /** URL segment → content directory, e.g. `{ monument: 'monuments' }`. */
+    contentDirMap: Record<string, string>;
+    /** src/pages subdirectories whose `.astro` guides carry a `dateModified`. */
+    guideDirs: string[];
+    /** Extra lookup keys an item's date also feeds; each keeps the latest date it sees. */
+    itemKeys?: (urlType: string, item: Record<string, unknown>) => string[];
+    /** Extra lookup keys computed from each content directory's latest date. */
+    extraKeys?: (collectionMax: Record<string, string>) => Record<string, string | undefined>;
+  };
+  sitemap?: {
+    /** A pathname any predicate accepts is left out; `/search` always is. */
+    exclude?: Array<(pathname: string) => boolean>;
+    /** Every matching rule sets its fields on the item. */
+    rules?: SitemapRule[];
+  };
+  /** Packages Vite must bundle during SSR. */
+  ssrNoExternal?: string[];
+  pagefind: PagefindIntegration;
+  /** Pagefind index language. */
+  language?: string;
+}
+
+// A missing date, or a date-only value equal to today, is stamped with the build instant.
+function toDateWithTime(dateStr: string | undefined): string {
+  if (!dateStr) return new Date().toISOString();
+  if (dateStr.includes('T')) return new Date(dateStr).toISOString();
+  const today = new Date().toISOString().split('T')[0];
+  if (dateStr === today) return new Date().toISOString();
+  return new Date(`${dateStr}T12:00:00Z`).toISOString();
+}
+
+/** Lookup key → date for the sitemap, plus the latest date overall (the fallback). */
+export function buildLastmodMap(rootDir: string, opts: SiteConfigOptions['lastmod']): { lastmodMap: Map<string, string>; mostRecent: string } {
+  const lastmodMap = new Map<string, string>();
+  const contentBase = path.join(rootDir, 'src/content');
+  let mostRecent = EPOCH;
+  const collectionMax: Record<string, string> = {};
+  for (const [urlType, dir] of Object.entries(opts.contentDirMap)) {
+    const dirPath = path.join(contentBase, dir);
+    if (!fs.existsSync(dirPath)) continue;
+    let maxForCollection = EPOCH;
+    for (const file of fs.readdirSync(dirPath)) {
+      if (!file.endsWith('.json')) continue;
+      try {
+        const content = JSON.parse(fs.readFileSync(path.join(dirPath, file), 'utf-8'));
+        if (content.slug && content.dateModified) {
+          lastmodMap.set(`${urlType}/${content.slug}`, content.dateModified);
+          for (const key of opts.itemKeys?.(urlType, content) ?? []) {
+            if (content.dateModified > (lastmodMap.get(key) || '')) lastmodMap.set(key, content.dateModified);
+          }
+          if (content.dateModified > maxForCollection) maxForCollection = content.dateModified;
+          if (content.dateModified > mostRecent) mostRecent = content.dateModified;
+        }
+      } catch {
+        // an unparseable file contributes nothing
+      }
+    }
+    collectionMax[dir] = maxForCollection;
+  }
+  for (const dir of Object.values(opts.contentDirMap)) {
+    if (collectionMax[dir] && collectionMax[dir] > EPOCH) lastmodMap.set(dir, collectionMax[dir]);
+  }
+  const pagesDir = path.join(rootDir, 'src/pages');
+  for (const dir of opts.guideDirs) {
+    let maxForHub = EPOCH;
+    for (const [key, date] of guideDateMap(pagesDir, dir)) {
+      lastmodMap.set(key, date);
+      if (date > maxForHub) maxForHub = date;
+    }
+    if (maxForHub > EPOCH) lastmodMap.set(dir, maxForHub);
+  }
+  for (const [key, date] of Object.entries(opts.extraKeys?.(collectionMax) ?? {})) {
+    if (date && date > EPOCH) lastmodMap.set(key, date);
+  }
+  return { lastmodMap, mostRecent };
+}
+
+/** The sitemap `serialize` hook: trailing slash stripped, exclusions dropped, lastmod looked up, rules applied. */
+export function sitemapSerialize(
+  lastmodMap: Map<string, string>,
+  mostRecent: string,
+  { exclude = [], rules = [] }: NonNullable<SiteConfigOptions['sitemap']> = {},
+): (item: SitemapItem) => SitemapItem | undefined {
+  return (item) => {
+    if (item.url.endsWith('/')) item.url = item.url.slice(0, -1);
+    const url = new URL(item.url);
+    if (url.pathname === '/search') return undefined;
+    if (exclude.some((ex) => ex(url.pathname))) return undefined;
+    const pathParts = url.pathname.split('/').filter(Boolean);
+    const dateModified =
+      lastmodMap.get(pathParts.slice(0, 3).join('/')) ||
+      lastmodMap.get(pathParts.slice(0, 2).join('/')) ||
+      lastmodMap.get(pathParts[0]) ||
+      mostRecent;
+    item.lastmod = toDateWithTime(dateModified);
+    for (const rule of rules) {
+      if (!rule.match(pathParts)) continue;
+      if (rule.priority !== undefined) item.priority = rule.priority;
+      if (rule.changefreq !== undefined) item.changefreq = rule.changefreq as SitemapItem['changefreq'];
+    }
+    return item;
+  };
+}
+
+/**
+ * The Astro config every content site shares: static output, the image service, build and Vite settings, and the
+ * outbound-rel → sitemap → Pagefind integrations. The sitemap `lastmod` comes from content `dateModified`, guide
+ * pages and the site's extra keys, looked up by the first 3, 2, then 1 path segments.
+ */
+export function defineSiteConfig(opts: SiteConfigOptions): AstroUserConfig {
+  const rootDir = opts.root instanceof URL ? fileURLToPath(opts.root) : opts.root;
+  const { lastmodMap, mostRecent } = buildLastmodMap(rootDir, opts.lastmod);
+  return {
+    ...(opts.redirects ? { redirects: opts.redirects } : {}),
+    site: opts.site,
+    base: '/',
+    output: 'static',
+    trailingSlash: 'never',
+    compressHTML: true,
+    image: {
+      service: {
+        entrypoint: process.env.CI ? 'astro/assets/services/noop' : 'astro/assets/services/sharp',
+        config: {
+          limitInputPixels: false,
+          avif: { quality: 65, effort: 6, chromaSubsampling: '4:2:0' },
+          // Astro re-encodes from decoded pixels, so the delivered quality is set here, not by the source file.
+          webp: { quality: 65, effort: 6 },
+        },
+      },
+    },
+    build: {
+      format: 'file',
+      inlineStylesheets: 'auto',
+    },
+    vite: {
+      plugins: [tailwindcss()],
+      worker: { format: 'es' },
+      ...(opts.ssrNoExternal?.length ? { ssr: { noExternal: opts.ssrNoExternal } } : {}),
+      build: {
+        cssMinify: true,
+        minify: 'esbuild',
+        rollupOptions: {
+          external: ['/pagefind/pagefind-ui.js', '/pagefind/pagefind.js'],
+        },
+      },
+    },
+    integrations: [
+      outboundLinkRel({ root: rootDir }),
+      sitemap({ serialize: sitemapSerialize(lastmodMap, mostRecent, opts.sitemap) }),
+      opts.pagefind({
+        indexConfig: {
+          excludeSelectors: ['nav', 'footer', '.breadcrumb', '[data-pagefind-ignore]'],
+          forceLanguage: opts.language ?? 'en',
+        },
+      }),
+    ],
+  };
+}

package/src/dates/lastmod.ts

@@ -1,4 +1,4 @@
-const EPOCH = '1970-01-01';
+export const EPOCH = '1970-01-01';
 
 /** The latest of several `YYYY-MM-DD` strings; empty values are skipped, and none gives 1970-01-01. */
 export function maxDate(...dates: string[]): string {