@wxxb789/anc 0.0.1

package/src/components/TableOfContents.astro

@@ -0,0 +1,69 @@
+---
+/**
+ * The article's headings, as a real nested list.
+ *
+ * Three properties are load-bearing, and each is a decision the parity plan's
+ * L4 records against Quartz:
+ *
+ * 1. **Nested `<ol>`, not a flat list with a `depth-N` class.** The nesting is
+ *    the structure, so a screen reader announces "list, 3 items, item 2, list,
+ *    2 items" rather than reading eleven siblings and leaving the reader to
+ *    infer the hierarchy from indentation they cannot see.
+ * 2. **Complete in the server-rendered HTML.** Requirements section 5.3 makes
+ *    reading and navigation work without JavaScript. A small progressive script
+ *    may mark the current section, but it never creates or removes a TOC link.
+ * 3. **Collapse costs zero JavaScript.** `<details>`/`<summary>` is the native
+ *    disclosure widget: keyboard-operable, announced correctly, and `open` by
+ *    default so a reader who never interacts sees the whole list.
+ *
+ * Recursion is `Astro.self`, which renders at build time — the nesting is real
+ * markup by the time the page is written, not a component boundary a browser
+ * has to resolve.
+ *
+ * Quartz's own table of contents is the component worth studying, but its
+ * contrast is not: its unread links measure 2.04:1 in light and 2.92:1 in dark,
+ * both WCAG AA failures in the default state. Ours uses `--color-link`, which
+ * `tests/design-tokens.test.ts` proves at 6.72:1 and 10.37:1.
+ */
+import type { TocEntry } from '../lib/markdown.js';
+import { translate } from '../lib/translations.js';
+
+interface Props {
+  entries: readonly TocEntry[];
+  /**
+   * Set on the outermost list only. Nested lists are rendered by `Astro.self`
+   * with it absent, which is what keeps the `<details>` shell and the labelled
+   * `<nav>` from being emitted once per level.
+   */
+  isRoot?: boolean;
+  /**
+   * The note's own language. Only the root renders a chrome string, so only the
+   * root needs it — the nested calls carry heading text, which is the article's
+   * own words in the article's own language either way.
+   */
+  lang?: string;
+}
+
+const { entries, isRoot = false, lang } = Astro.props;
+---
+
+{isRoot ? (
+  <nav class="toc" aria-labelledby="toc-title">
+    {/* `open` so the list is visible by default and the disclosure is an
+        affordance to *close* it. A reader who never touches it loses nothing,
+        and with JavaScript disabled the element still opens and closes. */}
+    <details class="toc-details" open>
+      <summary id="toc-title">{translate(lang).tocHeading}</summary>
+      <Astro.self entries={entries} />
+    </details>
+  </nav>
+) : (
+  <ol class="toc-list">
+    {entries.map((entry) => (
+      <li>
+        <a href={`#${entry.id}`}>{entry.text}</a>
+        {entry.children.length > 0 && <Astro.self entries={entry.children} />}
+      </li>
+    ))}
+  </ol>
+)}

package/src/components/TagBrowser.astro

@@ -0,0 +1,70 @@
+---
+/**
+ * The enhanced tag browser, shared by `/tags/` and `/tags/<tag>/`.
+ *
+ * Both routes render the region's ids and the five `data-tag-browse-*`
+ * sentences that `src/scripts/tag-browser.ts` queries. When the shape lived on
+ * both pages a one-sided rename was silent: the client's `querySelector`
+ * returned null and the enhancement degraded without an error. The component
+ * owns that shape once; the script and this markup now move together or not at
+ * all.
+ *
+ * `mode` is the one thing that differs. `switch` renders the tag chooser;
+ * `fixed` renders the start button for the page's own tag. The complete static
+ * `FacetIndex`/`NoteList` beside it remains the no-JS route, so this region
+ * stays hidden until the script runs and unhides the static list on failure;
+ * `data-pagefind-ignore` keeps the region out of the Pagefind index.
+ */
+import { TAG_PAGE_SIZE } from '../lib/tag-browser-model.js';
+import { NAV_LANGUAGE, TAG_BROWSE_DATASET, datasetAttribute, translate } from '../lib/translations.js';
+
+interface Props {
+  mode: 'switch' | 'fixed';
+  /** The fixed page's tag key, sent to the snapshot exactly as the route spells it. */
+  tagKey?: string;
+  /** The chooser's options; ignored when `mode` is `fixed`. */
+  facets?: readonly { key: string; label: string }[];
+}
+
+const { mode, tagKey, facets = [] } = Astro.props;
+const t = translate(NAV_LANGUAGE);
+// The five status sentences travel as data attributes so no locale table ships
+// to the browser (`tag-browser.ts` reads them from `root.dataset`).
+const browserData = Object.fromEntries([
+  [datasetAttribute(TAG_BROWSE_DATASET.loading), t.tagBrowseLoading],
+  [datasetAttribute(TAG_BROWSE_DATASET.empty), t.tagBrowseEmpty],
+  [datasetAttribute(TAG_BROWSE_DATASET.exhausted), t.tagBrowseExhausted],
+  [datasetAttribute(TAG_BROWSE_DATASET.unknown), t.tagBrowseUnknown],
+  [datasetAttribute(TAG_BROWSE_DATASET.failed), t.tagBrowseFailed],
+]);
+---
+
+<section
+  id="tag-browser"
+  hidden
+  data-pagefind-ignore
+  data-mode={mode}
+  {...mode === 'fixed' ? { 'data-tag-key': tagKey } : {}}
+  data-page-size={String(TAG_PAGE_SIZE)}
+  aria-labelledby="tag-browser-title"
+  {...browserData}
+>
+  <h2 id="tag-browser-title">{t.tagBrowseHeading}</h2>
+  {mode === 'switch' ? (
+    <>
+      <label for="tag-browser-select">{t.tagBrowseSelectLabel}</label>
+      <select id="tag-browser-select">
+        <option value="">{t.tagBrowsePrompt}</option>
+        {facets.map((facet) => (
+          <option value={facet.key}>{facet.label}</option>
+        ))}
+      </select>
+    </>
+  ) : (
+    <button id="tag-browse-start" type="button">{t.tagBrowseStart}</button>
+  )}
+  <p id="tag-browser-current" hidden></p>
+  <p id="tag-browser-status" role="status"></p>
+  <ol id="tag-browser-results"></ol>
+  <button id="tag-browse-more" type="button" hidden>{t.tagBrowseMore}</button>
+</section>

package/src/layouts/Layout.astro

@@ -0,0 +1,305 @@
+---
+import '../styles/global.css';
+// `?url` keeps this a classic, render-blocking script: Astro compiles a normal
+// `<script>` to `type="module"`, which defers and would paint one frame of the
+// wrong theme. Importing the URL keeps the source under `src/scripts/` and
+// content-hashed, while the tag stays inline-free and same-origin.
+import themeInit from '../scripts/theme-init.js?url';
+// The deployed policy's one source. `?raw` inlines the file's text at build
+// time, so the `<meta>` below is derived from the same bytes `_headers` ships
+// rather than restated, and cannot drift from it.
+import shippedHeaders from '../../public/_headers?raw';
+import SiteMetadata from '../components/SiteMetadata.astro';
+import CollectionExplorer from '../components/CollectionExplorer.astro';
+import { entries } from '../lib/content.js';
+import { collectionNavigation } from '../lib/collection-navigation.js';
+import { PRIMARY_NAV, SITE_MAP } from '../lib/routes.js';
+import { canonicalUrl, describe, SITE_NAME } from '../lib/site.js';
+import {
+  MESSAGE_DATASET,
+  NAV_LANGUAGE,
+  THEME_DATASET,
+  THEME_NAMES,
+  datasetAttribute,
+  translate,
+} from '../lib/translations.js';
+
+interface Props {
+  title: string;
+  description?: string;
+  /** BCP 47 tag from the document's own metadata, when the artifact carries one. */
+  lang?: string;
+}
+
+const { title, lang = NAV_LANGUAGE } = Astro.props;
+
+/**
+ * This document's chrome, resolved from this document's own language.
+ *
+ * The whole of TK-16 is that this line reads `lang` — a per-entry field on the
+ * validated contract — rather than one site-wide locale. A zh-CN note therefore
+ * renders Chinese chrome inside `<html lang="zh-CN">` while an English note in
+ * the same build renders English chrome, which is a shape Quartz's global
+ * `cfg.locale` cannot express. Routes that are not a single document pass no
+ * `lang` and land on `NAV_LANGUAGE`; `translations.ts` documents why.
+ */
+const t = translate(lang);
+
+/**
+ * `describe` rather than a default parameter, and that is a fix rather than a
+ * refactor: a default only fires on `undefined`, while the note page passes
+ * `entry.excerpt` — the one required string the content contract admits *empty*.
+ * A note with an empty excerpt therefore shipped
+ * `<meta name="description" content="">`, which is worse than no tag at all,
+ * since a consumer scrapes the page when the tag is absent and renders nothing
+ * when it is present and empty. The fixture corpus has exactly one such note.
+ *
+ * The fallback is this document's own, so a Chinese note with an empty excerpt
+ * describes itself in Chinese rather than falling back across a language.
+ */
+const description = describe(Astro.props.description, t.siteDescription);
+
+/**
+ * The explorer rail's groups, resolved against the route being rendered.
+ *
+ * Computed in the layout rather than passed in by each page, so every route
+ * carries the same navigation frame by construction — a page that forgets to
+ * ask is the failure mode this prevents, and it is the same reason
+ * `SiteMetadata` lives here. `Astro.url.pathname` is what makes the rail
+ * contextual: it opens the group holding the current page and no other, and it
+ * is what centres each group's window on the note being read.
+ *
+ * **This line is why the rail's size is a scaling property rather than a page's
+ * own concern.** It renders on every route, so whatever it costs is paid once
+ * per published page — the rail listing the whole corpus made a site O(n²) in
+ * bytes. `GROUP_WINDOW` in `collection-navigation.ts` is the bound that fixed
+ * it and carries the measurements.
+ */
+const explorerGroups = collectionNavigation(entries, Astro.url.pathname, t.uncollected);
+
+/**
+ * The site-wide Content-Security-Policy, as a `<meta http-equiv>`.
+ *
+ * `public/_headers` is Cloudflare Pages' format, so a host that ignores it —
+ * GitHub Pages, the documented zero-secret path, or any plain static server —
+ * served no CSP at all. The meta element carries the same policy to every host.
+ *
+ * Read from the `/*` rule of `_headers` rather than restated, minus the
+ * directives a meta-delivered policy cannot carry and the browser ignores with a
+ * console warning (CSP3 §3.3): `frame-ancestors`, `report-uri`, `report-to`, and
+ * `sandbox`. Clickjacking protection therefore still depends on a host that
+ * sends the header. Where `_headers` is honoured both policies apply; they are
+ * the same policy, so the intersection is unchanged.
+ *
+ * Omitted under `astro dev` only, whose client injects inline scripts the
+ * shipped policy forbids. Keyed on Vite's `MODE`, not `PROD`: `PROD` follows
+ * `NODE_ENV`, so a build started with `NODE_ENV=test` — every build a test
+ * harness spawns — would silently ship no policy. `tests/csp-meta.test.ts`
+ * asserts the emitted value against `_headers` and its enforcement in Chromium.
+ */
+const META_UNSUPPORTED = new Set(['frame-ancestors', 'report-uri', 'report-to', 'sandbox']);
+const metaPolicy = (() => {
+  let inSiteRule = false;
+  for (const line of shippedHeaders.split(/\r?\n/)) {
+    if (line.trim() === '' || line.trimStart().startsWith('#')) continue;
+    if (!/^\s/.test(line)) {
+      inSiteRule = line.trim() === '/*';
+      continue;
+    }
+    const match = inSiteRule ? /^\s*Content-Security-Policy:\s*(.+)$/i.exec(line) : null;
+    if (match === null) continue;
+    return match[1]!
+      .split(';')
+      .map((directive) => directive.trim())
+      .filter((directive) => directive !== '' && !META_UNSUPPORTED.has(directive.split(/\s+/)[0]!.toLowerCase()))
+      .join('; ');
+  }
+  throw new Error('public/_headers declares no site-wide Content-Security-Policy for the <meta> policy');
+})();
+---
+
+<!doctype html>
+<html lang={lang}>
+  <head>
+    <meta charset="UTF-8" />
+    {/* First after the charset: a meta policy governs only what follows it. */}
+    {import.meta.env.MODE !== 'development' && <meta http-equiv="Content-Security-Policy" content={metaPolicy} />}
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="description" content={description} />
+    <meta name="generator" content={Astro.generator} />
+    <title>{title}</title>
+    <script is:inline src={themeInit}></script>
+    {/* TK-08: the canonical URL, the Open Graph and Twitter card metadata, and
+        the feed discovery link. Rendered here rather than by each page so that
+        every route carries them by construction — a page that forgets to ask
+        is the failure mode this prevents. It derives everything from
+        `Astro.site`, `Astro.url`, and the artifact; it takes no new props
+        beyond the three this layout already has. */}
+    <SiteMetadata title={title} description={description} lang={lang} />
+    {/* The one seam a page has into the document head.
+        TK-15 fills it with the math stylesheet and font, gated on
+        `RenderedNote.hasMath`, and the Mermaid assets gated on `.hasMermaid`.
+        `src/pages/notes/[slug].astro` already uses it for the `hasCode` case,
+        so the mechanism is exercised rather than speculative.
+
+        A named slot rather than a widening `Props` interface: a per-ticket prop
+        would make this file the contended one every time a ticket needs a tag
+        in the head, which is the collision the wave plan exists to avoid. */}
+    <slot name="head" />
+  </head>
+  <body>
+    <a class="skip-link" href="#main">{t.skipToContent}</a>
+    <header class="site-header">
+      {/* The site's name is a proper noun, so it is the one word in this header
+          that is not translated — see `SITE_NAME`. */}
+      <a class="brand" href="/">{SITE_NAME}</a>
+      <nav class="site-nav" aria-label={t.primaryNavLabel}>
+        {PRIMARY_NAV.map((item) => <a href={item.href}>{t[item.label]}</a>)}
+        {/* The shortcut is in the accessible name rather than in a `title`,
+            which no screen reader reliably announces and no keyboard reader
+            can discover. `aria-keyshortcuts` is the attribute that exists for
+            exactly this, and the visible text stays one word. */}
+        <button
+          id="search-toggle"
+          type="button"
+          aria-keyshortcuts="/"
+          aria-label={t.searchToggleLabel}
+          data-js-only
+        >{t.searchToggle}</button>
+        {/* The three theme labels travel as `data-` attributes rather than as a
+            locale table in the bundle: `preferences.ts` cycles the attribute and
+            reads back the label the build already resolved, so the script ships
+            no strings, knows no locale, and adds no bytes that scale with the
+            number of languages. The rendered text is the `system` label, which
+            is the state before any preference is stored. */}
+        <button
+          id="theme-toggle"
+          type="button"
+          data-js-only
+          {...Object.fromEntries(
+            THEME_NAMES.map((theme) => [datasetAttribute(THEME_DATASET[theme]), t.themeLabel(theme)]),
+          )}
+        >{t.themeLabel(THEME_NAMES[0])}</button>
+        <button id="reader-toggle" type="button" aria-pressed="false" data-js-only>{t.readerToggle}</button>
+      </nav>
+    </header>
+    {/* TK-06. Every region the search script fills is declared here in HTML
+        rather than constructed in JavaScript, for three reasons: the `<label>`
+        and the `<input>` stay a real labelled pair instead of Pagefind's
+        `data-`-attribute substitute; the dialog has something to focus the
+        instant it opens, before the bundle has loaded; and the status line is a
+        live region that exists before the first message is written into it, so
+        the message is announced rather than silently appearing.
+
+        `data-pagefind-ignore` on the whole dialog: it is on every page, so
+        without it the index would carry this chrome on all 32 notes — the same
+        defect TK-12 fixed for the back link and the heading anchors.
+
+        The close button is a `<form method="dialog">`, which needs no script
+        and — per the parity plan §7.6 — never navigates, so `form-action 'none'`
+        does not touch it. */}
+    <dialog id="search-dialog" aria-label={t.searchDialogLabel} data-pagefind-ignore>
+      <form method="dialog" class="search-close"><button>{t.searchClose}</button></form>
+      <label class="search-label" for="search-input">{t.searchFieldLabel}</label>
+      {/* `type="search"` for the browser's own clear control and the right
+          on-screen keyboard. `autocomplete="off"` because a site search field
+          offering the reader's previous queries from other sites is noise. */}
+      <input id="search-input" type="search" autocomplete="off" autocapitalize="none" enterkeyhint="search" />
+      <div id="search-filters">
+        <div id="search-filter-tag"></div>
+        <div id="search-filter-collection"></div>
+      </div>
+      {/* `role="status"` is an `aria-live="polite"` region: the reader hears
+          "Loading the search index" or "No results" without focus moving off
+          the field they are typing into.
+
+          The four load-state sentences travel as `data-` attributes for the same
+          reason the theme labels do: `search-dialog.ts` reads the one it needs
+          off this element, so the bundle carries no locale table and the page
+          announces its own language. There is no rendered text — the region is
+          empty until a state is announced, which is what makes the first message
+          an announcement rather than a change nobody hears. */}
+      <p id="search-status" role="status" {...Object.fromEntries([
+        [datasetAttribute(MESSAGE_DATASET.idle), t.searchIdle],
+        [datasetAttribute(MESSAGE_DATASET.loading), t.searchLoading],
+        [datasetAttribute(MESSAGE_DATASET.empty), t.searchEmpty],
+        [datasetAttribute(MESSAGE_DATASET.failed), t.searchFailed],
+      ])}></p>
+      <ol id="search-results"></ol>
+    </dialog>
+    {/* The reading frame: the article, and the collection rail beside it.
+        Requirements section 16 asks for an explorer, a centred article, and a
+        contextual rail on desktop; collapsible panels on tablet; one column on
+        mobile. This grid is all three — see `.page-shell` in `global.css`.
+
+        The rail follows `<main>` in document order at every width, and the
+        stylesheet never reorders it. That is what keeps the reading order, the
+        tab order, and the visual order the same thing: a reader tabbing forward
+        reaches the article before the site-wide navigation, and a reader with no
+        CSS gets the article first. Placing the explorer visually before the
+        article — Quartz's left-hand shape — would mean either a DOM order that
+        puts the site's whole navigation ahead of the page's own content, or a
+        `grid-column` that makes the tab order disagree with the layout. */}
+    <div class="page-shell">
+      <main id="main" tabindex="-1">
+        <slot />
+        {/* The link preview panel (TK-07). Empty until a preview opens, and
+            `position: fixed`, so it contributes no layout wherever it sits — but
+            it must sit inside a landmark. axe-core's `region` rule reports every
+            element of page content that is in none, and an open panel parented to
+            `<body>` was exactly that: it was reported on every route, in both
+            themes, at both widths, and moving it here is what cleared it.
+
+            That audit is run out of band and is not reproducible from this
+            repository — axe-core is in neither `dependencies` nor
+            `devDependencies`, so the check needs an `axe.min.js` fetched to a
+            scratch path. TK-09 owns the question of whether it becomes a release
+            gate. Recorded this way deliberately: the rule the panel was breaking
+            is nameable and checkable by anyone who runs axe, which is worth more
+            than a violation count nothing here can recompute.
+
+            After the slot, so the document order a screen reader walks puts a
+            transient description of a link after the content that contains the
+            link, rather than before the article it describes. */}
+        <div id="link-preview" role="tooltip" hidden></div>
+      </main>
+      {/* TK-05c. Built entirely at build time and collapsed with native
+          `<details>`, so it is complete and operable with scripting disabled —
+          the Quartz explorer failure the parity plan's L5 names. It renders
+          nothing at all on a corpus with fewer than two notes. */}
+      <CollectionExplorer groups={explorerGroups} lang={lang} />
+    </div>
+    <footer class="site-footer">
+      {/* Every fixed route is linked from here, on every page, so no route is an
+          orphan. This nav deliberately survives reader mode, which hides the
+          header's secondary links: hiding the only path to a route would make
+          reader mode remove information rather than chrome. */}
+      <nav class="site-map" aria-label={t.siteMapLabel}>
+        {SITE_MAP.map((item) => <a href={item.href}>{t[item.label]}</a>)}
+      </nav>
+      <p>{t.siteSubtitle}</p>
+      {/* Scope item 10 requires the printed page to carry its canonical URL.
+          A printed page has no address bar, so the full absolute URL is what
+          makes it findable again — TK-05a emitted the route and left this for
+          TK-08 to upgrade once `site:` was configured. */}
+      <p class="print-only">{t.publishedAt(canonicalUrl(Astro.site, Astro.url.pathname))}</p>
+    </footer>
+    <script>
+      import '../scripts/preferences.js';
+      import '../scripts/search-dialog.js';
+      import '../scripts/link-preview.js';
+      if (document.querySelector('.prose[data-code-copy] .code-block')) {
+        void import('../scripts/code-copy.js');
+      }
+      if (document.querySelector('.toc')) {
+        void import('../scripts/toc-active.js');
+      }
+      if (document.querySelector('#tag-browser')) {
+        void import('../scripts/tag-browser.js');
+      }
+      if (document.querySelector('[data-graph-controls]')) {
+        void import('../scripts/graph-client.js');
+      }
+    </script>
+  </body>
+</html>

package/src/lib/artifact-source.js

@@ -0,0 +1,72 @@
+/**
+ * Which artifact file this build reads.
+ *
+ * The default is the producer-generated `src/data/content.json`. Setting
+ * `CONTENT_ARTIFACT` to another path — `pnpm run build:fixture` does exactly
+ * that — builds the whole site from a different artifact without touching the
+ * generated one, which the agent contract forbids editing by hand.
+ *
+ * Every consumer resolves the path through here rather than hardcoding it, so
+ * the build gate, the redirect emitter, the pages, and the tests over `dist/`
+ * can never end up reading two different artifacts and agreeing about it.
+ *
+ * The path is resolved against `process.cwd()` rather than against
+ * `import.meta.url`, and that is load-bearing: Astro bundles this module into
+ * `dist/.prerender/`, so `import.meta.url` points inside the build output at
+ * the moment the pages actually read it. `pnpm` runs every script with the
+ * working directory set to the directory holding `package.json`, and Astro
+ * resolves its own project root the same way — so cwd is the one anchor all
+ * three consumers agree on.
+ *
+ * ponytail: this means the build must be started from the repository root. It
+ * already had to be — `astro build` finds `astro.config.mjs` the same way.
+ */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { validateArtifact } from "./schema.js";
+const DEFAULT_ARTIFACT = 'src/data/content.json';
+/**
+ * Repository-relative path of the artifact, suitable for an error message.
+ *
+ * `||` rather than `??`: an empty `CONTENT_ARTIFACT` is a caller who meant to
+ * pass a path and passed nothing. With `??` it would resolve to the working
+ * directory and fail on a directory read, without naming the empty variable.
+ */
+export const ARTIFACT_PATH = process.env['CONTENT_ARTIFACT'] || DEFAULT_ARTIFACT;
+/**
+ * Absolute filesystem path to the artifact, anchored at the repository root.
+ *
+ * `path.resolve` rather than a hand-built `file://` URL: a URL parses `#` and
+ * `?` in the *directory* name as a fragment and a query, so a checkout under
+ * `Q:/re#po` silently resolves to the drive root, and it percent-decodes, so a
+ * literal `%20` in a path becomes a space. Neither is hypothetical on a machine
+ * whose worktrees live under generated directory names.
+ *
+ * A function rather than a constant so a test can change `CONTENT_ARTIFACT` and
+ * see the effect without re-importing the module.
+ */
+export function artifactPath(path = ARTIFACT_PATH) {
+    return resolve(process.cwd(), path);
+}
+/**
+ * The artifact's raw bytes, exactly as they are on disk.
+ *
+ * Returned as text rather than parsed because two callers need the bytes
+ * themselves: `emit-redirects.ts` hashes them into the redirect map's
+ * `content_version`, and `built-routes.test.ts` recomputes that hash to prove
+ * the map came from the artifact `dist/` was built from.
+ */
+export function readArtifact(path = ARTIFACT_PATH) {
+    return readFileSync(artifactPath(path), 'utf8');
+}
+/**
+ * The validated artifact, read from whichever file this build selected.
+ *
+ * One place where read, parse, and validate happen together, because three
+ * callers were doing all three and a fourth would have got the error label
+ * subtly wrong. Every caller sees an artifact that has already passed the
+ * contract, and a violation names the file it actually came from.
+ */
+export function loadArtifact(path = ARTIFACT_PATH) {
+    return validateArtifact(JSON.parse(readArtifact(path)), path);
+}

package/src/lib/build-bindings.js

@@ -0,0 +1,11 @@
+/**
+ * Build-time globals substituted by `vite.define` from the private snapshot
+ * workspace (`readStaged` in `astro.config.mjs`).
+ *
+ * They carry the digest-named same-origin binding for the snapshot and the
+ * SQLite WASM, or `null` when a build staged none, so the Worker fails closed
+ * and fetches nothing. Declared here rather than in a `.d.ts` because
+ * `scripts/compile-package.ts` builds its TypeScript program from `src` and
+ * `scripts` sources, not from ambient declaration files.
+ */
+export {};