@cparkerwebm/webmonterey 1.1.0 → 1.2.0

package/src/cli/audit.ts

@@ -0,0 +1,323 @@
+/*
+ * `webm audit [dist/client]` - the pre-launch checks that only a BUILD can answer.
+ *
+ * `webm doctor` reads source. Some things are only visible in the output: whether every image
+ * that reached the page has alt text, whether every internal link lands on a file the build
+ * produced (or a route the Worker serves), whether the sitemap the build wrote is complete and
+ * advertised. Each is the kind of thing a launch checklist says to "check" and nobody does
+ * exhaustively by hand on a forty-page site.
+ *
+ * Pure where it can be: `audit()` takes the built files and returns findings, so the rules are
+ * tested with literal HTML. `run()` reads dist/ and, unless told not to, makes one request per
+ * unique external link - the one part that needs a network.
+ *
+ * WHAT IT DOES NOT DO: write alt text. It lists the images that have none; the launch skill is
+ * what looks at each one and writes the words. An empty `alt=""` is a valid declaration that an
+ * image is decorative and is not reported - only a MISSING attribute is.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+
+export interface AuditInput {
+  /** Relative html path -> contents, for every page in the build. */
+  pages: Map<string, string>;
+  /** Whether a relative path exists in the build output. */
+  exists: (rel: string) => boolean;
+  /** Read a relative non-html file from the build, or null. */
+  read: (rel: string) => string | null;
+  /** wrangler.jsonc's run_worker_first, so an on-demand route is not reported as broken. */
+  workerFirst: string[];
+  /** The production origin, for sitemap and external-link decisions. Undefined while unset. */
+  origin?: string;
+}
+
+export interface AuditReport {
+  missingAlt: { page: string; src: string }[];
+  brokenInternal: { page: string; href: string }[];
+  /** Unique external URLs, for the caller to probe. */
+  external: string[];
+  sitemap: { problems: string[]; urls: number };
+}
+
+/** The value of one attribute on a tag, or null when absent. Quoted or bare. */
+export function attr(tag: string, name: string): string | null {
+  const m = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i').exec(tag);
+  if (!m) return null;
+  return m[1] ?? m[2] ?? m[3] ?? '';
+}
+
+/** Whether an attribute is present at all, with or without a value. */
+export function hasAttr(tag: string, name: string): boolean {
+  return new RegExp(`\\s${name}(?=[\\s=>/])`, 'i').test(tag);
+}
+
+/** Every `<img>` on a page that declares no alt attribute at all. */
+export function imagesWithoutAlt(html: string): string[] {
+  const out: string[] = [];
+  for (const m of html.matchAll(/<img\b[^>]*>/gi)) {
+    const tag = m[0];
+    if (hasAttr(tag, 'alt')) continue;
+    out.push(attr(tag, 'src') ?? '(no src)');
+  }
+  return out;
+}
+
+const SKIP_SCHEMES = /^(mailto:|tel:|sms:|javascript:|data:|#)/i;
+
+/** The hrefs on a page, split into internal paths and external URLs. */
+export function links(html: string, origin?: string): { internal: string[]; external: string[] } {
+  const internal = new Set<string>();
+  const external = new Set<string>();
+  for (const m of html.matchAll(/<a\b[^>]*>/gi)) {
+    const href = attr(m[0], 'href');
+    if (!href || SKIP_SCHEMES.test(href)) continue;
+    if (/^https?:\/\//i.test(href)) {
+      /* A link to the site's own origin is internal - check it as a path. */
+      if (origin && href.startsWith(origin)) internal.add(href.slice(origin.length) || '/');
+      else external.add(href);
+      continue;
+    }
+    if (href.startsWith('//')) {
+      external.add(`https:${href}`);
+      continue;
+    }
+    internal.add(href);
+  }
+  return { internal: [...internal], external: [...external] };
+}
+
+/**
+ * Does an internal href land somewhere? A file the build wrote, in any of the forms the asset
+ * router would serve it under, or a route the Worker answers.
+ */
+export function resolves(href: string, input: Pick<AuditInput, 'exists' | 'workerFirst'>): boolean {
+  let path = href.split('#')[0]!.split('?')[0]!;
+  try {
+    path = decodeURIComponent(path);
+  } catch {
+    /* leave it */
+  }
+  if (!path.startsWith('/')) return true; /* relative to the page; not worth a false positive */
+  if (path === '/') return input.exists('index.html');
+
+  const bare = path.replace(/\/$/, '');
+  const rel = bare.slice(1);
+  if (input.exists(rel) || input.exists(`${rel}.html`) || input.exists(`${rel}/index.html`)) {
+    return true;
+  }
+  return input.workerFirst.some((entry) =>
+    entry.endsWith('/*')
+      ? bare === entry.slice(0, -2) || bare.startsWith(entry.slice(0, -1))
+      : entry === bare || entry === `${bare}/`,
+  );
+}
+
+/** `<loc>` values out of a sitemap document. */
+export function locs(xml: string): string[] {
+  return [...xml.matchAll(/<loc>\s*([^<]+?)\s*<\/loc>/g)].map((m) => m[1]!);
+}
+
+/**
+ * The sitemap the build wrote: present, advertised in robots.txt, every child present, every URL
+ * on the production origin and landing on a page.
+ */
+export function auditSitemap(input: AuditInput): AuditReport['sitemap'] {
+  const problems: string[] = [];
+  const index = input.read('sitemap-index.xml');
+  if (!index) {
+    return {
+      problems: [
+        input.origin
+          ? 'sitemap-index.xml was not built'
+          : 'no sitemap - `domain` in webmonterey.json is unset, so nothing has an absolute URL',
+      ],
+      urls: 0,
+    };
+  }
+
+  const robots = input.read('robots.txt') ?? '';
+  if (!/^Sitemap:\s*\S+/m.test(robots)) problems.push('robots.txt has no Sitemap: line');
+
+  let urls = 0;
+  for (const childUrl of locs(index)) {
+    const childRel = childUrl.replace(/^https?:\/\/[^/]+\//, '');
+    const child = input.read(childRel);
+    if (!child) {
+      problems.push(`${childRel} is listed in the index and was not built`);
+      continue;
+    }
+    for (const url of locs(child)) {
+      urls++;
+      if (input.origin && !url.startsWith(input.origin)) {
+        problems.push(`${url} is not on ${input.origin}`);
+        continue;
+      }
+      const path = url.replace(/^https?:\/\/[^/]+/, '') || '/';
+      if (!resolves(path, input)) problems.push(`${url} is in the sitemap and has no page`);
+    }
+  }
+  if (urls === 0) problems.push('the sitemap lists no URLs');
+  return { problems, urls };
+}
+
+export function audit(input: AuditInput): AuditReport {
+  const missingAlt: AuditReport['missingAlt'] = [];
+  const brokenInternal: AuditReport['brokenInternal'] = [];
+  const external = new Set<string>();
+
+  for (const [page, html] of input.pages) {
+    for (const src of imagesWithoutAlt(html)) missingAlt.push({ page, src });
+    const found = links(html, input.origin);
+    for (const href of found.internal) {
+      if (!resolves(href, input)) brokenInternal.push({ page, href });
+    }
+    for (const url of found.external) external.add(url);
+  }
+
+  return {
+    missingAlt,
+    brokenInternal,
+    external: [...external].sort(),
+    sitemap: auditSitemap(input),
+  };
+}
+
+/* ── the command ─────────────────────────────────────────────────────────────────────────── */
+
+function walk(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
+    const full = join(dir, e.name);
+    return e.isDirectory() ? walk(full) : [full];
+  });
+}
+
+/** Strip // and /* comments so JSON.parse can read a .jsonc file. */
+function parseJsonc<T>(source: string): T {
+  const stripped = source
+    .replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, comment) => (comment ? '' : m))
+    .replace(/,(\s*[}\]])/g, '$1');
+  return JSON.parse(stripped) as T;
+}
+
+/**
+ * One request per unique external URL. HEAD first; a 405 gets a GET, because plenty of servers
+ * refuse HEAD and answer GET. Failures are reported as warnings, not failures: many sites block
+ * anything that is not a browser, and a link that a bot cannot fetch is not necessarily broken.
+ */
+async function probe(urls: string[]): Promise<{ url: string; status: string }[]> {
+  const bad: { url: string; status: string }[] = [];
+  const queue = [...urls];
+  const worker = async () => {
+    for (let url = queue.shift(); url; url = queue.shift()) {
+      try {
+        let res = await fetch(url, {
+          method: 'HEAD',
+          redirect: 'follow',
+          signal: AbortSignal.timeout(8000),
+        });
+        if (res.status === 405 || res.status === 403) {
+          res = await fetch(url, {
+            method: 'GET',
+            redirect: 'follow',
+            signal: AbortSignal.timeout(8000),
+          });
+        }
+        if (res.status >= 400) bad.push({ url, status: String(res.status) });
+      } catch (error) {
+        bad.push({ url, status: error instanceof Error ? error.name : 'error' });
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: 6 }, worker));
+  return bad.sort((a, b) => a.url.localeCompare(b.url));
+}
+
+export async function run(argv: string[]): Promise<number> {
+  const dist = resolve(argv.find((a) => !a.startsWith('-')) ?? 'dist/client');
+  const noExternal = argv.includes('--no-external');
+
+  if (!existsSync(join(dist, 'index.html'))) {
+    console.error(`webm audit: no build at ${dist}. Run \`npm run build\` first.`);
+    return 1;
+  }
+
+  const siteRoot = process.cwd();
+  const files = walk(dist);
+  const rels = new Set(files.map((f) => relative(dist, f)));
+  const pages = new Map(
+    files
+      .filter((f) => f.endsWith('.html'))
+      .map((f) => [relative(dist, f), readFileSync(f, 'utf8')]),
+  );
+
+  const wranglerPath = ['wrangler.jsonc', 'wrangler.json']
+    .map((f) => join(siteRoot, f))
+    .find(existsSync);
+  const wrangler = wranglerPath
+    ? parseJsonc<{ assets?: { run_worker_first?: string[] } }>(readFileSync(wranglerPath, 'utf8'))
+    : null;
+
+  const sitePath = join(siteRoot, 'webmonterey.json');
+  const site = existsSync(sitePath)
+    ? (JSON.parse(readFileSync(sitePath, 'utf8')) as { domain?: string })
+    : {};
+  const origin = site.domain && site.domain !== 'CHANGEME' ? `https://${site.domain}` : undefined;
+
+  const report = audit({
+    pages,
+    exists: (rel) => rels.has(rel),
+    read: (rel) =>
+      rels.has(rel) && statSync(join(dist, rel)).isFile()
+        ? readFileSync(join(dist, rel), 'utf8')
+        : null,
+    workerFirst: wrangler?.assets?.run_worker_first ?? [],
+    origin,
+  });
+
+  let failed = 0;
+  const section = (ok: boolean, title: string) => console.log(`${ok ? '  ok ' : 'FAIL '} ${title}`);
+
+  section(report.missingAlt.length === 0, `Every image declares alt text (${pages.size} pages)`);
+  for (const { page, src } of report.missingAlt)
+    console.log(`       ${page}: <img src="${src}"> has no alt attribute`);
+  if (report.missingAlt.length) {
+    failed++;
+    console.log(
+      `       Write alt text for each - what the image shows, in context - or alt="" if it is decorative.`,
+    );
+  }
+
+  section(
+    report.brokenInternal.length === 0,
+    'Every internal link lands on a page or a Worker route',
+  );
+  for (const { page, href } of report.brokenInternal) console.log(`       ${page}: ${href}`);
+  if (report.brokenInternal.length) failed++;
+
+  section(
+    report.sitemap.problems.length === 0,
+    `The sitemap is complete and advertised (${report.sitemap.urls} URLs)`,
+  );
+  for (const p of report.sitemap.problems) console.log(`       ${p}`);
+  if (report.sitemap.problems.length) failed++;
+
+  if (noExternal) {
+    console.log(`  --  ${report.external.length} external links not probed (--no-external)`);
+  } else if (report.external.length) {
+    const bad = await probe(report.external);
+    console.log(
+      `${bad.length ? 'warn ' : '  ok '} ${report.external.length} external links respond (${bad.length} did not)`,
+    );
+    for (const { url, status } of bad) console.log(`       ${status.padEnd(12)} ${url}`);
+    if (bad.length)
+      console.log(
+        `       Open each in a browser before deciding it is broken - many sites refuse bots.`,
+      );
+  } else {
+    console.log('  ok  no external links');
+  }
+
+  console.log(`\n${failed === 0 ? 'audit clean' : `${failed} check(s) failed`}`);
+  return failed ? 1 : 0;
+}

package/src/cli/checks.test.ts

@@ -217,7 +217,7 @@ test('a site with components but no credit import warns', () => {
   const ctx = base({
     components: new Map([['src/components/regions/footer/footer.astro', '<footer>hi</footer>']]),
   });
-  const result = runCheck('agency-credit', ctx);
+  const result = runCheck('webmaster-credit', ctx);
   assert.equal(result.status, 'warn');
   assert.match(result.detail!, /footer component/);
 });
@@ -227,15 +227,15 @@ test('a footer that imports the credit passes', () => {
     components: new Map([
       [
         'src/components/regions/footer/footer.astro',
-        `import Credit from '@cparkerwebm/webmonterey/webmonterey/credits/Credit.astro';`,
+        `import Webmaster from '@cparkerwebm/webmonterey/webmonterey/webmaster/Webmaster.astro';`,
       ],
     ]),
   });
-  assert.equal(runCheck('agency-credit', ctx).status, 'pass');
+  assert.equal(runCheck('webmaster-credit', ctx).status, 'pass');
 });
 
 test('a site with no components yet is not nagged', () => {
-  assert.equal(runCheck('agency-credit', base()).status, 'pass');
+  assert.equal(runCheck('webmaster-credit', base()).status, 'pass');
 });
 
 test('a comment explaining a trap does not trip the check that enforces it', () => {
@@ -274,7 +274,7 @@ test("WebMonterey's own site is not asked to credit itself", () => {
     site: { client: 'WebMonterey', domain: 'webmonterey.com' },
     components: new Map([['src/components/regions/footer/footer.astro', '<footer>x</footer>']]),
   });
-  assert.equal(runCheck('agency-credit', ctx).status, 'pass');
+  assert.equal(runCheck('webmaster-credit', ctx).status, 'pass');
 });
 
 test('a cron with no custom entrypoint FAILS, and names the fix', () => {
@@ -405,7 +405,7 @@ test("a placeholder favicon still in public/ fails - it is the agency's mark on
    */
   const ctx = base({
     site: { client: 'Acme', domain: 'acme.com', launched: '2026-03-01' },
-    placeholders: ['public/favicon.svg', 'public/open-graph.png'],
+    placeholders: ['public/favicon.svg', 'public/opengraph.png'],
   });
   const result = runCheck('placeholder-branding', ctx);
   assert.equal(result.status, 'fail', 'a LAUNCHED site shipping the agency mark is a fault');

package/src/cli/checks.ts

@@ -676,14 +676,16 @@ export const CHECKS: Check[] = [
     },
   },
   {
-    id: 'agency-credit',
-    title: 'Something renders the agency credit',
-    silentAs: 'the site ships with no "Powered by WebMonterey" and nobody notices for months',
+    id: 'webmaster-credit',
+    title: 'Something renders the webmaster credit',
+    silentAs:
+      'the site ships with no "Powered by WebMonterey", the /webmaster page is orphaned, and nobody notices for months',
     run(ctx) {
       /*
        * The package ships no footer - it ships no components at all - so the credit is imported
        * by whichever site component renders the footer. That is the right seam and it is also
-       * easy to simply never do, which is how live client sites ended up without it.
+       * easy to simply never do, which is how live client sites ended up without it. Without it
+       * the /webmaster page the package injects is reachable from nothing.
        *
        * A warning, not a failure: a site mid-build has no footer yet, and failing there trains
        * people to ignore the doctor. `/webm:launch` is where it becomes blocking.
@@ -697,11 +699,11 @@ export const CHECKS: Check[] = [
       if (ctx.site.domain === 'webmonterey.com') return pass;
 
       for (const src of ctx.components.values()) {
-        if (/webmonterey\/credits/.test(stripComments(src))) return pass;
+        if (/webmonterey\/webmaster/.test(stripComments(src))) return pass;
       }
       return warn(
-        'no component imports @cparkerwebm/webmonterey/webmonterey/credits/Credit.astro. ' +
-          'The footer component is where it goes.',
+        'no component imports @cparkerwebm/webmonterey/webmonterey/webmaster/Webmaster.astro. ' +
+          'The footer component is where it goes; it links to the /webmaster page.',
       );
     },
   },

package/src/emails/footer.ts

@@ -14,7 +14,7 @@
  * constant — and a caller that has to remember to pass the year eventually forgets, which
  * shows up as a stale copyright the following January.
  */
-import { CREDIT_TEXT, creditUrl } from '../includes/webmonterey/credits/credit.ts';
+import { CREDIT_TEXT, creditUrl } from '../includes/webmonterey/webmaster/webmaster.ts';
 import { DEFAULT_COPY, fill } from '../includes/webmonterey/copy-defaults.ts';
 
 export interface EmailFooterInput {
@@ -75,13 +75,13 @@ export function renderFooterHtml(input: EmailFooterInput): string {
    * in a browser is the expected behavior, so the warning would be noise about something no
    * reader was surprised by. Nothing is lost that email a11y actually asks for.
    *
-   * `title` is absent from both links ON PURPOSE, here and in Credit.astro. It is not reliably
+   * `title` is absent from both links ON PURPOSE, here and in Webmaster.astro. It is not reliably
    * announced by screen readers, is unreachable by keyboard and touch entirely, and either
    * duplicates the link text or competes with it for the accessible name. The link text is the
    * accessible name; that is the mechanism that works.
    *
    * `rel="noopener"` without `noreferrer`, also on purpose: the referrer IS the attribution.
-   * Stripping it would leave only utm_content. See credit.ts.
+   * Stripping it would leave only utm_content. See webmaster.ts.
    */
   return `    <div style="max-width:640px;margin:0 auto;padding:24px 32px 8px;text-align:center;font-size:13px;line-height:1.6;color:#3f3f3f;">
       <p style="margin:0;">&copy; ${year} ${escapeHtml(input.client)}</p>

package/src/includes/cloudflare/r2/media.ts

@@ -5,7 +5,7 @@
  *
  *   src/assets/    images the DESIGN uses — imported, hashed, optimised at build by sharp.
  *                  A logo, an icon, a hero shot. These belong in the repo.
- *   public/        small fixed files that need a stable URL (favicons, open-graph.png).
+ *   public/        small fixed files that need a stable URL (favicons, opengraph.png).
  *   R2 (here)      everything too large or too numerous to sit in git: video, audio, PDFs,
  *                  photo galleries, downloads, anything migrated wholesale off a WordPress
  *                  uploads folder.

package/src/includes/webmonterey/copy-defaults.ts

@@ -67,6 +67,13 @@ export interface Copy {
     /** `{domain}` is replaced with the site's domain. */
     footerNotice: string;
   };
+  /** The /webmaster page. `intro` wraps the agency link: `before` <a>WebMonterey</a> `after`. */
+  webmaster: {
+    title: string;
+    description: string;
+    intro: { before: string; after: string };
+    body: string[];
+  };
 }
 
 /*
@@ -125,6 +132,19 @@ export const DEFAULT_COPY: Copy = {
     reference: 'Reference: #{id}',
     footerNotice: 'This is an automated notification for your account at the {domain} website.',
   },
+  webmaster: {
+    title: 'Our Webmaster',
+    description:
+      'This website was designed, built and managed by WebMonterey, a webmaster maintenance service in Monterey, California.',
+    intro: {
+      before: 'This website was designed, built and managed by',
+      after:
+        ', a webmaster maintenance service in Monterey, California. WebMonterey handles the hosting, security, updates and ongoing care of the site so that we can focus on what we do.',
+    },
+    body: [
+      "If you have a question about this website, notice something that isn't working, or have trouble using a page, please let WebMonterey know and they will take care of it.",
+    ],
+  },
 };
 
 /** Merge the site's overrides over the defaults, key by key, at any depth. */

package/src/includes/webmonterey/webmaster/Webmaster.astro

@@ -0,0 +1,52 @@
+---
+/*
+ * The webmaster credit. Goes in the site footer.
+ *
+ *   <Webmaster />   ->   Powered by WebMonterey
+ *
+ * AN INTERNAL LINK. It points at the site's own /webmaster page, which the package injects on
+ * every site - so the visitor stays on the client's site, and the page they land on says who
+ * built it and who to contact when something is wrong. The outbound link to the agency lives on
+ * that page, once, with its UTM parameters. See webmaster.ts for why.
+ *
+ * No target, no rel: this is an ordinary same-site link and it navigates like one. The old
+ * outbound credit opened a new tab; an internal link that did would be a bug.
+ *
+ * NO `title` ATTRIBUTE, and that is the correct state rather than an omission. `title` is not
+ * reliably announced by screen readers, is unreachable by keyboard and touch entirely, and either
+ * duplicates the link text or competes with it for the accessible name.
+ */
+import { CREDIT_TEXT, WEBMASTER_PATH } from './webmaster.ts';
+
+interface Props {
+  class?: string;
+}
+
+const { class: className } = Astro.props;
+---
+
+<p class:list={['webm-credit', className]}>
+  <a href={WEBMASTER_PATH}>{CREDIT_TEXT}</a>
+</p>
+
+<style>
+  @layer webm.components.core {
+    .webm-credit {
+      font-size: var(--webm-font-size-xs);
+      color: var(--webm-text-muted);
+    }
+
+    /*
+     * Underline at the text's own color. An underline in --webm-border-subtle is ~1.3:1 on
+     * white - effectively invisible, leaving nothing to mark the link as clickable.
+     */
+    .webm-credit a {
+      color: inherit;
+      text-decoration-color: currentColor;
+    }
+
+    .webm-credit a:hover {
+      color: var(--webm-link-hover);
+    }
+  }
+</style>

package/src/includes/webmonterey/webmaster/webmaster.test.ts

@@ -0,0 +1,74 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+import { AGENCY, contentTag, CREDIT_TEXT, creditUrl, WEBMASTER_PATH } from './webmaster.ts';
+
+/*
+ * Webmaster.astro read as SOURCE, because it cannot be imported here: an .astro file only
+ * resolves inside an Astro build. A source assertion is the weaker tool and it is the one
+ * available.
+ */
+const componentSource = readFileSync(new URL('./Webmaster.astro', import.meta.url), 'utf8');
+const template = componentSource.replace(/\{\s*\/\*[\s\S]*?\*\/\s*\}/g, '');
+const anchors: string[] = template.match(/<a\s[^>]*>/g) ?? [];
+const anchor = (): string => anchors[0] ?? '';
+
+test('creditUrl points at the agency home page, not a /credits page', () => {
+  const url = new URL(creditUrl('example.com'));
+  assert.equal(url.origin, 'https://webmonterey.com');
+  assert.equal(url.pathname, '/');
+});
+
+test('creditUrl carries all four UTM parameters', () => {
+  const { searchParams } = new URL(creditUrl('example.com'));
+  assert.equal(searchParams.get('utm_source'), 'client');
+  assert.equal(searchParams.get('utm_campaign'), 'webmaster');
+  assert.equal(searchParams.get('utm_content'), 'example_com');
+});
+
+test('utm_medium separates the two surfaces, and defaults to website', () => {
+  assert.equal(
+    new URL(creditUrl('example.com', 'website')).searchParams.get('utm_medium'),
+    'website',
+  );
+  assert.equal(new URL(creditUrl('example.com', 'email')).searchParams.get('utm_medium'), 'email');
+  assert.equal(new URL(creditUrl('example.com')).searchParams.get('utm_medium'), 'website');
+});
+
+test('utm_content is the production domain, with every dot as an underscore', () => {
+  const url = new URL(creditUrl('sub.example.co.uk', 'email'));
+  assert.equal(url.searchParams.get('utm_content'), 'sub_example_co_uk');
+  /* Scoped to the query: the destination host is allowed to look like a host. */
+  assert.equal(url.search.includes('.'), false);
+});
+
+test('contentTag changes nothing but the dots', () => {
+  assert.equal(contentTag('localhost'), 'localhost');
+  assert.equal(contentTag('steven-glaze.com'), 'steven-glaze_com');
+});
+
+test('CREDIT_TEXT is the shared wording', () => {
+  assert.equal(CREDIT_TEXT, 'Powered by WebMonterey');
+});
+
+test('the agency identity is internally consistent', () => {
+  assert.ok(AGENCY.id.startsWith(AGENCY.url), 'the @id lives on the agency origin');
+  assert.ok(AGENCY.sameAs.every((u) => u.startsWith('https://')));
+  assert.equal(new Set(AGENCY.sameAs).size, AGENCY.sameAs.length, 'no duplicate profile');
+});
+
+/* ── the footer credit: an INTERNAL link now ──────────────────────────────────────────────── */
+
+test("the site credit renders exactly one link, to the site's own webmaster page", () => {
+  assert.equal(anchors.length, 1, `expected one anchor, found ${anchors.length}`);
+  assert.match(anchor(), new RegExp(`href=\\{WEBMASTER_PATH\\}`));
+  assert.equal(WEBMASTER_PATH, '/webmaster');
+});
+
+test('an internal link does not open a new tab and carries no rel', () => {
+  // The old outbound credit opened a new tab; an internal link that did would be a bug.
+  assert.doesNotMatch(anchor(), /target=/);
+  assert.doesNotMatch(anchor(), /rel=/);
+  assert.doesNotMatch(template, /opens in a new tab/);
+});