perf(site): compile the registry once per build, not twice (#139)

Astro loads `astro.config.mjs` in a module graph of its own, separate
from the one the pages render in. `src/lib/registry.ts` is therefore
instantiated twice in a single build, and the module-level memo is not
shared between the two copies. An instrumented `astro build` called
`compileRegistry` twice.

Deferring the first call does not help, because the two graphs never
share a module variable whenever it runs. Memoise on `globalThis`
instead, under a registered symbol, which is the one scope both graphs
agree on. An instrumented build now calls `compileRegistry` once.

Compiling the real registry takes about 2.6s and materialises 86397
references, so the second pass cost that time and a second copy in
memory on every build and every `dev` start.

Lifetime is unchanged: the process, exactly as the module memo was. A
`dev` server still needs a restart after the `data/` submodule changes.

Closes #131


Claude-Session: https://claude.ai/code/session_011HLhfpsrWxq56jnZr1gD8B

Co-authored-by: Moritz Mähr <14755525+maehr@users.noreply.github.com>
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: maehr

src/lib/registry.test.ts

@@ -0,0 +1,28 @@
+// The compiled registry is memoised on `globalThis` rather than in a module
+// variable, because Astro loads `astro.config.mjs` in a module graph of its own
+// and would otherwise compile the whole registry a second time.
+process.env.TEXTREFS_REGISTRY_FIXTURE = '1';
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { loadRegistry, loadWorks } from './registry.js';
+import { fixtureRegistry } from './registry.fixture.js';
+
+const CACHE_KEY = Symbol.for('textrefs.compiledRegistry');
+
+test('the fixture short-circuit never compiles or caches the real registry', () => {
+	// The env check has to stay above the cache, or every fixture-backed test
+	// would pay for a full compile of the real registry and leave it on the
+	// global for whatever ran next.
+	assert.equal(loadRegistry(), fixtureRegistry);
+	assert.equal(
+		Object.getOwnPropertySymbols(globalThis).includes(CACHE_KEY),
+		false,
+		'the fixture path must not populate the global cache',
+	);
+});
+
+test('repeated loads return one registry', () => {
+	assert.equal(loadRegistry(), loadRegistry());
+	assert.equal(loadWorks(), loadRegistry().works);
+});

src/lib/registry.ts

@@ -4,11 +4,23 @@ import {
 } from '../../scripts/compile.js';
 import { fixtureRegistry } from './registry.fixture.js';
 
-let cached: CompiledRegistry | null = null;
+// Astro loads `astro.config.mjs` in a module graph of its own, separate from
+// the one the pages render in, so this module is instantiated twice in a single
+// build and a module-level memo is not shared between the two. Compiling the
+// real registry takes about 2.6s and materialises 86k records, so the second
+// pass is worth avoiding. `globalThis` is the one scope both graphs agree on;
+// the registered symbol keeps the key from colliding with anything else.
+//
+// Lifetime is the process, exactly as the module-level memo was, so a `dev`
+// server still needs a restart after the `data/` submodule changes.
+const CACHE_KEY = Symbol.for('textrefs.compiledRegistry');
+type CacheHost = { [CACHE_KEY]?: CompiledRegistry };
+
 function registry(): CompiledRegistry {
 	if (process.env.TEXTREFS_REGISTRY_FIXTURE === '1') return fixtureRegistry;
-	cached ??= compileRegistry();
-	return cached;
+	const host = globalThis as CacheHost;
+	host[CACHE_KEY] ??= compileRegistry();
+	return host[CACHE_KEY];
 }
 
 /**