@acms-subir/core 0.0.1

package/src/layouts/Site.astro

@@ -0,0 +1,218 @@
+---
+import { getRepo } from '../lib/repo';
+import { renderMarkdown } from '../lib/markdown';
+import { resolveDesign } from '../lib/theme';
+import { siteOrigin, absUrl, canonicalPath } from '../lib/seo';
+import { siteLang } from '../lib/dates';
+import { CONTENT } from '../lib/content';
+import { I18N, localeFromPath, localeHomeUrl } from '../lib/i18n';
+import '../styles/site.css';
+import '../styles/cards.css';
+
+interface Props {
+  title?: string;
+  description?: string;
+  // standalone pages (the /links link-in-bio page) skip the site nav + footer
+  bare?: boolean;
+  // a hand-tuned SEO title is used verbatim — no "· Site" suffix
+  exactTitle?: boolean;
+  // social/OG: share image (site default when empty), og:type, article dates
+  // and author for posts; jsonLd is emitted as a schema.org script verbatim
+  image?: string;
+  imageAlt?: string;
+  type?: 'website' | 'article';
+  publishedAt?: number | null;
+  modifiedAt?: number | null;
+  authorName?: string;
+  jsonLd?: Record<string, unknown>;
+  noindex?: boolean;
+}
+const {
+  title, description, bare = false, exactTitle = false,
+  image, imageAlt, type = 'website', publishedAt, modifiedAt, authorName, jsonLd, noindex = false,
+} = Astro.props;
+
+const repo = await getRepo(Astro.locals);
+const [settings, pages, navItems] = await Promise.all([repo.getSettings(), repo.listPages(), repo.listNavItems()]);
+const design = resolveDesign(settings);
+const navPages = pages.filter((p) => p.status === 'published' && !p.isHome);
+const headerNav = navItems.filter((n) => n.area === 'header');
+const footerNav = navItems.filter((n) => n.area === 'footer');
+const socialNav = navItems.filter((n) => n.area === 'social');
+const isExternal = (url: string) => /^https?:\/\//.test(url);
+const current = Astro.url.pathname;
+const fullTitle = exactTitle && title ? title : title ? `${title} · ${settings.siteTitle}` : settings.siteTitle;
+const footerHtml = settings.footerText
+  ? renderMarkdown(settings.footerText)
+  : `<p>${settings.siteTitle}${settings.tagline ? ` — ${settings.tagline}` : ''}</p>`;
+
+const origin = siteOrigin(settings, Astro.url);
+const ann = settings.announcement;
+// defense in depth against a stored javascript: link (the admin form also
+// rejects these on save)
+const annLink = ann.link.startsWith('/') || /^https?:\/\//i.test(ann.link) ? ann.link : '';
+const showAnnouncement = !bare && ann.enabled && ann.text.trim().length > 0;
+// dismissals are remembered per-text, so editing the message re-shows the bar
+const annKey = showAnnouncement
+  ? `acms-ann-${[...ann.text].reduce((h, c) => ((h * 31 + c.charCodeAt(0)) >>> 0), 0).toString(36)}`
+  : '';
+const canonical = origin + canonicalPath(current);
+const metaDescription = description || settings.tagline || undefined;
+// with i18n configured, the request path decides the document language; the
+// locale setting (a date-formatting concern) stays the fallback
+const reqLocale = I18N.enabled ? localeFromPath(current) : '';
+const htmlLang = reqLocale || siteLang(settings);
+// hreflang alternates connect the per-language home pages; other routes have
+// no language twins yet, so alternates are emitted only on home paths
+const isHomePath = I18N.enabled && I18N.locales.some((l) => current === localeHomeUrl(l));
+const shareImage = image || settings.siteCover || '';
+const shareImageAbs = shareImage ? absUrl(shareImage, origin) : '';
+const faviconType =
+  settings.siteFavicon.endsWith('.svg') ? 'image/svg+xml'
+  : settings.siteFavicon.endsWith('.png') || settings.siteFavicon.includes('.webp') ? 'image/png'
+  : undefined;
+const homeJsonLd =
+  current === '/'
+    ? {
+        '@context': 'https://schema.org',
+        '@type': 'WebSite',
+        name: settings.siteTitle,
+        ...(settings.tagline ? { description: settings.tagline } : {}),
+        url: origin + '/',
+      }
+    : null;
+---
+
+<!doctype html>
+<html lang={htmlLang}>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{fullTitle}</title>
+    {metaDescription && <meta name="description" content={metaDescription} />}
+    {noindex && <meta name="robots" content="noindex" />}
+    <link rel="canonical" href={canonical} />
+    {isHomePath && I18N.locales.map((l) => (
+      <link rel="alternate" hreflang={l} href={origin + localeHomeUrl(l)} />
+    ))}
+    {isHomePath && <link rel="alternate" hreflang="x-default" href={origin + '/'} />}
+    {settings.siteFavicon && <link rel="icon" href={settings.siteFavicon} type={faviconType} />}
+    <link rel="alternate" type="application/rss+xml" title={settings.siteTitle} href={`${origin}/rss.xml`} />
+    <link rel="sitemap" href={`${origin}/sitemap.xml`} />
+    <meta property="og:site_name" content={settings.siteTitle} />
+    <meta property="og:title" content={title || settings.siteTitle} />
+    {metaDescription && <meta property="og:description" content={metaDescription} />}
+    <meta property="og:type" content={type} />
+    <meta property="og:url" content={canonical} />
+    {shareImageAbs && <meta property="og:image" content={shareImageAbs} />}
+    {shareImageAbs && imageAlt && <meta property="og:image:alt" content={imageAlt} />}
+    {type === 'article' && publishedAt && (
+      <meta property="article:published_time" content={new Date(publishedAt).toISOString()} />
+    )}
+    {type === 'article' && modifiedAt && (
+      <meta property="article:modified_time" content={new Date(modifiedAt).toISOString()} />
+    )}
+    {type === 'article' && authorName && <meta property="article:author" content={authorName} />}
+    <meta name="twitter:card" content={shareImageAbs ? 'summary_large_image' : 'summary'} />
+    <meta name="twitter:title" content={title || settings.siteTitle} />
+    {metaDescription && <meta name="twitter:description" content={metaDescription} />}
+    {shareImageAbs && <meta name="twitter:image" content={shareImageAbs} />}
+    {homeJsonLd && <script type="application/ld+json" set:html={JSON.stringify(homeJsonLd)} />}
+    {jsonLd && <script type="application/ld+json" set:html={JSON.stringify(jsonLd)} />}
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    {design.fontsHref && <link href={design.fontsHref} rel="stylesheet" />}
+    <Fragment set:html={`<style>${design.css}</style>`} />
+    {settings.headCode && <Fragment set:html={settings.headCode} />}
+  </head>
+  <body>
+    {showAnnouncement && (
+      <div class="announcement-bar" data-ann-key={ann.dismissible ? annKey : undefined} hidden={ann.dismissible || undefined}>
+        {annLink ? <a href={annLink}>{ann.text}</a> : <span>{ann.text}</span>}
+        {ann.dismissible && (
+          <button type="button" class="announcement-x" aria-label="Dismiss announcement">✕</button>
+        )}
+      </div>
+    )}
+    {showAnnouncement && ann.dismissible && (
+      <script is:inline define:vars={{ annKey }}>
+        (() => {
+          const bar = document.querySelector('.announcement-bar');
+          if (!bar) return;
+          try {
+            if (localStorage.getItem(annKey) === '1') return;
+          } catch { /* private mode: always show */ }
+          bar.hidden = false;
+          bar.querySelector('.announcement-x')?.addEventListener('click', () => {
+            bar.remove();
+            try { localStorage.setItem(annKey, '1'); } catch { /* ignore */ }
+          });
+        })();
+      </script>
+    )}
+    {!bare && (
+      <header class="site-header">
+        <a class="brand" href="/">
+          {settings.siteLogo ? <img class="brand-logo" src={settings.siteLogo} alt={settings.siteTitle} /> : settings.siteTitle}
+        </a>
+        <nav class="site-nav">
+          {headerNav.length > 0 ? (
+            headerNav.map((n) => (
+              <a
+                href={n.url}
+                aria-current={current === n.url ? 'page' : undefined}
+                target={isExternal(n.url) ? '_blank' : undefined}
+                rel={isExternal(n.url) ? 'noopener' : undefined}
+              >{n.label}</a>
+            ))
+          ) : (
+            <>
+              <a href="/" aria-current={current === '/' ? 'page' : undefined}>Home</a>
+              {navPages.map((p) => (
+                <a href={`/${p.slug}`} aria-current={current === `/${p.slug}` ? 'page' : undefined}>{p.title}</a>
+              ))}
+              {Object.values(CONTENT.collections).map((c) => (
+                <a href={c.base} aria-current={current.startsWith(c.base) ? 'page' : undefined}>{c.plural}</a>
+              ))}
+              <a href="/links" aria-current={current === '/links' ? 'page' : undefined}>Links</a>
+            </>
+          )}
+          {I18N.enabled && (
+            <span class="lang-switch" role="group" aria-label="Language">
+              {I18N.locales.map((l) => (
+                <a
+                  href={localeHomeUrl(l)}
+                  lang={l}
+                  class:list={[{ on: l === reqLocale }]}
+                  aria-current={l === reqLocale ? 'true' : undefined}
+                >{l.toUpperCase()}</a>
+              ))}
+            </span>
+          )}
+        </nav>
+      </header>
+    )}
+    <main class="site-main">
+      <slot />
+    </main>
+    {!bare && (
+      <footer class="site-footer">
+        {footerNav.length > 0 && (
+          <nav class="footer-nav">
+            {footerNav.map((n) => (
+              <a href={n.url} target={isExternal(n.url) ? '_blank' : undefined} rel={isExternal(n.url) ? 'noopener' : undefined}>{n.label}</a>
+            ))}
+          </nav>
+        )}
+        {socialNav.length > 0 && (
+          <nav class="social-nav">
+            {socialNav.map((n) => (
+              <a href={n.url} target={isExternal(n.url) ? '_blank' : undefined} rel={isExternal(n.url) ? 'noopener' : undefined}>{n.label}</a>
+            ))}
+          </nav>
+        )}
+        <div class="footer-text" set:html={footerHtml} />
+      </footer>
+    )}
+    {settings.footerCode && <Fragment set:html={settings.footerCode} />}
+  </body>
+</html>

package/src/lib/auth.ts

@@ -0,0 +1,94 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { env } from './env';
+
+const COOKIE = 'acms_session';
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+
+function secret(): string {
+  const s = env('SESSION_SECRET');
+  if (!s) throw new Error('SESSION_SECRET is not set — add it to .env');
+  return s;
+}
+
+function hmac(payload: string): string {
+  return createHmac('sha256', secret()).update(payload).digest('hex');
+}
+
+function safeEqual(a: string, b: string): boolean {
+  return a.length === b.length && timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+
+// ---- sessions -------------------------------------------------------------
+// Two token formats coexist:
+//   legacy (env-password owner):  `${exp}.${hmac(exp)}`
+//   user accounts:                `u.${userId}.${exp}.${hmac(userId.exp)}`
+// The sentinel OWNER_ENV identifies a session created with ADMIN_PASSWORD
+// (the bootstrap owner — always works, even with zero users in the DB).
+
+export const OWNER_ENV = '__owner_env__';
+
+export function createSessionToken(userId: string = OWNER_ENV): string {
+  const exp = Date.now() + WEEK_MS;
+  if (userId === OWNER_ENV) return `${exp}.${hmac(String(exp))}`;
+  return `u.${userId}.${exp}.${hmac(`${userId}.${exp}`)}`;
+}
+
+// Returns the session's user id (OWNER_ENV for env-password sessions) or
+// null. Truthy/falsy compatible with the old boolean signature.
+export function verifySessionToken(token: string | undefined): string | null {
+  if (!token) return null;
+  if (token.startsWith('u.')) {
+    const parts = token.split('.');
+    if (parts.length !== 4) return null;
+    const [, userId, expStr, sig] = parts;
+    if (!userId || Number(expStr) < Date.now()) return null;
+    return safeEqual(sig, hmac(`${userId}.${expStr}`)) ? userId : null;
+  }
+  const [expStr, sig] = token.split('.');
+  if (!expStr || !sig) return null;
+  if (Number(expStr) < Date.now()) return null;
+  return safeEqual(sig, hmac(expStr)) ? OWNER_ENV : null;
+}
+
+// The env master password — bootstrap owner login, kept for backward compat.
+export function checkPassword(input: string): boolean {
+  const pw = env('ADMIN_PASSWORD');
+  if (!pw) return false;
+  return safeEqual(input, pw);
+}
+
+// ---- password hashing (user accounts) -------------------------------------
+// PBKDF2-SHA256 via WebCrypto: portable across Workers and Node, no native
+// deps. Format: pbkdf2$<iterations>$<saltHex>$<hashHex>.
+
+const PBKDF2_ITERATIONS = 100_000;
+
+const toHex = (buf: ArrayBuffer) =>
+  [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('');
+const fromHex = (hex: string) =>
+  new Uint8Array(hex.match(/.{2}/g)?.map((b) => parseInt(b, 16)) ?? []);
+
+async function pbkdf2(password: string, salt: Uint8Array, iterations: number): Promise<string> {
+  const key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, ['deriveBits']);
+  const bits = await crypto.subtle.deriveBits(
+    { name: 'PBKDF2', hash: 'SHA-256', salt: salt as BufferSource, iterations },
+    key,
+    256
+  );
+  return toHex(bits);
+}
+
+export async function hashPassword(password: string): Promise<string> {
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const hash = await pbkdf2(password, salt, PBKDF2_ITERATIONS);
+  return `pbkdf2$${PBKDF2_ITERATIONS}$${toHex(salt.buffer)}$${hash}`;
+}
+
+export async function verifyPassword(password: string, stored: string): Promise<boolean> {
+  const [scheme, itersStr, saltHex, hashHex] = stored.split('$');
+  if (scheme !== 'pbkdf2' || !itersStr || !saltHex || !hashHex) return false;
+  const hash = await pbkdf2(password, fromHex(saltHex), Number(itersStr));
+  return safeEqual(hash, hashHex);
+}
+
+export const SESSION_COOKIE = COOKIE;

package/src/lib/backup/unzip.ts

@@ -0,0 +1,38 @@
+// Minimal ZIP reader for acms backups. Backups are written by zip.ts with
+// the store method (no compression), so this only needs to walk the central
+// directory and slice entries out — deflated archives from other tools are
+// rejected with a clear error.
+
+export function unzip(buf: ArrayBuffer): Map<string, Uint8Array> {
+  const bytes = new Uint8Array(buf);
+  const view = new DataView(buf);
+
+  // find the end-of-central-directory record (scan back past any comment)
+  let eocd = -1;
+  for (let i = bytes.length - 22; i >= Math.max(0, bytes.length - 22 - 65536); i--) {
+    if (view.getUint32(i, true) === 0x06054b50) { eocd = i; break; }
+  }
+  if (eocd < 0) throw new Error('Not a ZIP file.');
+  const count = view.getUint16(eocd + 10, true);
+  let off = view.getUint32(eocd + 16, true);
+
+  const entries = new Map<string, Uint8Array>();
+  for (let n = 0; n < count; n++) {
+    if (view.getUint32(off, true) !== 0x02014b50) throw new Error('Corrupt ZIP central directory.');
+    const method = view.getUint16(off + 10, true);
+    const compSize = view.getUint32(off + 20, true);
+    const nameLen = view.getUint16(off + 28, true);
+    const extraLen = view.getUint16(off + 30, true);
+    const commentLen = view.getUint16(off + 32, true);
+    const headerOff = view.getUint32(off + 42, true);
+    const name = new TextDecoder().decode(bytes.subarray(off + 46, off + 46 + nameLen));
+    if (method !== 0) throw new Error('Compressed ZIP entries are not supported — use an unmodified acms backup.');
+    // local header repeats name/extra lengths; data starts after them
+    const localNameLen = view.getUint16(headerOff + 26, true);
+    const localExtraLen = view.getUint16(headerOff + 28, true);
+    const dataStart = headerOff + 30 + localNameLen + localExtraLen;
+    entries.set(name, bytes.subarray(dataStart, dataStart + compSize));
+    off += 46 + nameLen + extraLen + commentLen;
+  }
+  return entries;
+}

package/src/lib/backup/zip.ts

@@ -0,0 +1,105 @@
+// Minimal ZIP writer (store method, no compression) so the backup endpoint
+// needs no dependency and runs on both Workers and Node. Entries are pulled
+// from an async iterator and emitted as they arrive, so the stream holds at
+// most one entry's bytes at a time (plus the central directory records).
+// Media is already webp/jpeg/png — deflating it again buys nothing.
+
+export interface ZipEntry {
+  name: string;
+  data: Uint8Array;
+}
+
+const CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+
+function crc32(data: Uint8Array): number {
+  let c = 0xffffffff;
+  for (let i = 0; i < data.length; i++) c = CRC_TABLE[(c ^ data[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+// MS-DOS date/time pair, the only timestamp format ZIP requires.
+function dosDateTime(ms: number): { time: number; date: number } {
+  const d = new Date(ms);
+  return {
+    time: (d.getHours() << 11) | (d.getMinutes() << 5) | (d.getSeconds() >> 1),
+    date: (Math.max(0, d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate(),
+  };
+}
+
+function le(bytes: number, ...fields: [size: 2 | 4, value: number][]): Uint8Array {
+  const buf = new Uint8Array(bytes);
+  const view = new DataView(buf.buffer);
+  let off = 0;
+  for (const [size, value] of fields) {
+    if (size === 2) view.setUint16(off, value, true);
+    else view.setUint32(off, value >>> 0, true);
+    off += size;
+  }
+  return buf;
+}
+
+export function zipStream(entries: AsyncIterable<ZipEntry>, mtimeMs: number): ReadableStream<Uint8Array> {
+  const { time, date } = dosDateTime(mtimeMs);
+
+  async function* chunks(): AsyncGenerator<Uint8Array> {
+    const central: Uint8Array[] = [];
+    let offset = 0;
+    for await (const { name, data } of entries) {
+      const nameBytes = new TextEncoder().encode(name);
+      const crc = crc32(data);
+      const headerOffset = offset;
+      // local file header: version 2.0, UTF-8 names (bit 11), stored
+      yield le(30,
+        [4, 0x04034b50], [2, 20], [2, 0x0800], [2, 0],
+        [2, time], [2, date], [4, crc], [4, data.length], [4, data.length],
+        [2, nameBytes.length], [2, 0],
+      );
+      yield nameBytes;
+      yield data;
+      offset += 30 + nameBytes.length + data.length;
+      const record = new Uint8Array(46 + nameBytes.length);
+      record.set(
+        le(46,
+          [4, 0x02014b50], [2, 20], [2, 20], [2, 0x0800], [2, 0],
+          [2, time], [2, date], [4, crc], [4, data.length], [4, data.length],
+          [2, nameBytes.length], [2, 0], [2, 0], [2, 0], [2, 0],
+          [4, 0], [4, headerOffset],
+        ),
+      );
+      record.set(nameBytes, 46);
+      central.push(record);
+    }
+    const centralStart = offset;
+    let centralSize = 0;
+    for (const record of central) {
+      yield record;
+      centralSize += record.length;
+    }
+    yield le(22,
+      [4, 0x06054b50], [2, 0], [2, 0], [2, central.length], [2, central.length],
+      [4, centralSize], [4, centralStart], [2, 0],
+    );
+  }
+
+  // pull-driven so a slow download applies backpressure to the entry
+  // iterator instead of buffering the whole archive in the stream queue
+  const iter = chunks();
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      const { value, done } = await iter.next();
+      if (done) controller.close();
+      else controller.enqueue(value);
+    },
+    async cancel() {
+      await iter.return(undefined);
+    },
+  });
+}

package/src/lib/blocksToHtml.ts

@@ -0,0 +1,68 @@
+import type { WidgetInstance } from './schema';
+import { parseConfig } from './schema';
+import { renderMarkdown } from './markdown';
+
+// One-way upgrade path: legacy widget-block pages are converted to TipTap-
+// parseable HTML the first time they open in the editor. The markup below
+// matches the parseHTML rules of the editor's card nodes
+// (src/components/editor/extensions/cards.tsx), so blocks round-trip into
+// real cards. Runs server-side; escaping is ours.
+
+const esc = (s: string) =>
+  s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+
+export function blocksToHtml(blocks: WidgetInstance[]): string {
+  const out: string[] = [];
+  for (const b of blocks) {
+    switch (b.type) {
+      case 'hero': {
+        const c = parseConfig('hero', b.config);
+        if (c.heading) out.push(`<h2>${esc(c.heading)}</h2>`);
+        if (c.sub) out.push(`<p>${esc(c.sub)}</p>`);
+        if (c.ctaLabel)
+          out.push(
+            `<div class="pc-buttoncard" data-align="${c.align === 'left' ? 'left' : 'center'}"><a href="${esc(c.ctaHref)}">${esc(c.ctaLabel)}</a></div>`
+          );
+        break;
+      }
+      case 'text': {
+        const c = parseConfig('text', b.config);
+        if (c.markdown) out.push(renderMarkdown(c.markdown));
+        break;
+      }
+      case 'image': {
+        const c = parseConfig('image', b.config);
+        if (!c.src) break;
+        const caption = c.caption ? `<figcaption>${esc(c.caption)}</figcaption>` : '';
+        out.push(`<figure class="pc-image"><img src="${esc(c.src)}" alt="${esc(c.alt)}">${caption}</figure>`);
+        break;
+      }
+      case 'button': {
+        const c = parseConfig('button', b.config);
+        if (!c.label) break;
+        out.push(`<div class="pc-buttoncard" data-align="center"><a href="${esc(c.href)}">${esc(c.label)}</a></div>`);
+        break;
+      }
+      case 'embed': {
+        const c = parseConfig('embed', b.config);
+        if (!c.url) break;
+        out.push(
+          `<figure class="pc-embed" data-provider="iframe" data-url="${esc(c.url)}" data-height="${c.height}"><div class="pc-embed-frame" style="height:${c.height}px"><iframe src="${esc(c.url)}"></iframe></div></figure>`
+        );
+        break;
+      }
+      case 'customHtml': {
+        const c = parseConfig('customHtml', b.config);
+        const combined = [c.html, c.css ? `<style>${c.css}</style>` : '', c.js ? `<script>${c.js}</script>` : '']
+          .filter(Boolean)
+          .join('\n');
+        if (combined) out.push(`<div class="pc-html">${combined}</div>`);
+        break;
+      }
+      case 'spacer':
+        // prose flow has its own rhythm — spacers don't translate
+        break;
+    }
+  }
+  return out.join('\n');
+}

package/src/lib/brand.ts

@@ -0,0 +1,26 @@
+// User-visible identity and first-boot seed content, overridable per project
+// via the integration's options in astro.config:
+//   acms({ brand: { name: 'My CMS' }, seed: { siteTitle: 'My Blog', ... } })
+// The scaffolder (create-acms-subir) writes those options from its prompts.
+// Internal protocol identifiers (session cookie name, backup format id,
+// localStorage prefixes) intentionally live with their features instead —
+// renaming those would invalidate existing sessions and backups.
+import { userConfig } from 'virtual:acms-config';
+
+const b = userConfig.brand ?? {};
+const s = userConfig.seed ?? {};
+
+export const BRAND = {
+  name: b.name ?? 'Acms',
+  version: b.version ?? userConfig.coreVersion,
+  stack: b.stack ?? 'Astro + D1/SQLite',
+};
+
+// Only read when the database is empty on first boot — editing these after
+// a site has content has no effect.
+export const SEED = {
+  siteTitle: s.siteTitle ?? b.name ?? 'Acms',
+  tagline: s.tagline ?? 'A widget-based CMS on Astro + Cloudflare',
+  heroHeading: s.heroHeading ?? `Welcome to ${s.siteTitle ?? b.name ?? 'Acms'}`,
+  heroSub: s.heroSub ?? 'Your new site, assembled from widgets.',
+};