@pyreon/head 0.22.0 → 0.23.0

package/src/tests/context-identity.test.ts

@@ -3,48 +3,46 @@
  * place across the published `lib/` artifacts.
  *
  * The bug this test exists to catch: `@pyreon/head@0.21.0` shipped four
- * sub-entries (`lib/index.js`, `lib/provider.js`, `lib/use-head.js`,
- * `lib/ssr.js`) AND the shared `@vitus-labs/tools-rolldown` build invokes
- * rolldown ONCE PER SUB-ENTRY (no cross-entry shared chunks). Result:
- * every sub-bundle independently inlined `context.ts` and ran its own
- * `createContext(null)` at module init — each call minted a unique
- * `Symbol.for(...).id`, so a `useContext(HeadContext)` lookup in one
- * bundle (e.g. the app's `useHead` from `lib/use-head.js`) silently
- * MISSED a `provide(HeadContext)` from another (e.g. `renderWithHead`
- * from `lib/ssr.js`). The bug was invisible in dev / source-mode tests
- * because Vite's `bun` condition resolves to a single shared
- * `src/context.ts` (ESM single-evaluation guarantee), but SSG output
- * silently dropped every `useHead()`-registered tag — bad for SEO,
- * social scrapers, accessibility, no-JS.
+ * sub-entries (`lib/{index,provider,use-head,ssr}.js`) and the shared
+ * `@vitus-labs/tools-rolldown` (< 2.4.0) invoked rolldown ONCE PER
+ * SUB-ENTRY (no cross-entry shared chunks). Result: every sub-bundle
+ * independently inlined `context.ts` and ran its own `createContext(null)`
+ * at module init — each call minted a unique `Symbol.for(...).id`, so a
+ * `useContext(HeadContext)` lookup in one bundle (e.g. the app's
+ * `useHead` from `lib/use-head.js`) silently MISSED a
+ * `provide(HeadContext)` from another (e.g. `renderWithHead` from
+ * `lib/ssr.js`). The bug was invisible in dev / source-mode tests because
+ * Vite's `bun` condition resolves to a single shared `src/context.ts`
+ * (ESM single-evaluation guarantee), but SSG output silently dropped
+ * every `useHead()`-registered tag — bad for SEO, social scrapers,
+ * accessibility, no-JS.
  *
- * The fix (`vl-tools.config.mjs` + self-package imports + the new
- * `./context` sub-export): source uses `@pyreon/head/context` for the
- * runtime VALUE; the build externalizes that specifier; every sub-bundle
- * resolves to the SAME `lib/context.js` at runtime — one Symbol, one
- * shared context.
+ * The durable fix lives upstream in `@vitus-labs/tools-rolldown >= 2.4.0`:
+ * the build tool now creates SHARED CHUNKS across sub-entries, so the
+ * shared `context.ts` gets hoisted into a single chunk (`lib/context.js`)
+ * that every other sub-entry imports via relative-path `./context.js`.
+ * `createContext(null)` runs exactly once at runtime; `HeadContext` is
+ * one Symbol across every sub-entry's bundle. No per-package
+ * externalization / self-package-import workaround needed.
  *
- * Structural assertions:
+ * Structural assertions (the BUG-CLASS-LOCK — same intent, cleaner shape):
  *   1. `lib/context.js` is the ONLY bundle that calls `createContext(`.
- *   2. Every other published sub-bundle (`index`, `ssr`, `use-head`,
- *      `provider`) imports `HeadContext` from `@pyreon/head/context`
- *      (the external — the bundler's signal that the symbol comes from
- *      a shared runtime chunk, not from inlined source).
+ *   2. EVERY other published JS file under `lib/` (including
+ *      `lib/_chunks/*.js` shared chunks the tool emits) has ZERO
+ *      `createContext` references — they all import `HeadContext` from
+ *      `./context.js`, sharing the single Symbol identity.
  *
- * Together these two invariants make the bug class structurally
- * impossible to re-introduce silently — any future regression (e.g.
- * removing the `vl-tools.config.mjs` external, or reverting a source
- * file to a relative `./context` import for the runtime VALUE) flips
- * one of the per-bundle counters and trips the assertion.
- *
- * Bisect-verified at the build artifact:
- * - With the fix: lib/context.js has 1 createContext call site (+ 1
- *   import line = 2 occurrences); every other sub-bundle has 0.
- * - Without the fix (revert `vl-tools.config.mjs`): every sub-bundle
- *   gets its own inlined `createContext(null)` (2 occurrences each) —
- *   this test fails on the first non-context bundle.
+ * Together these invariants make the bug class structurally impossible
+ * to re-introduce silently — any future regression (e.g. downgrade of
+ * the build tool below 2.4.0, or a build-config change that re-enables
+ * per-entry inlining) flips one of the per-bundle counters and trips
+ * the assertion. Bisect-verified by reverting the
+ * `@vitus-labs/tools-rolldown` bump: every non-context sub-bundle gets
+ * its own inlined `createContext(null)` call (2 occurrences each), and
+ * the second assertion fails on the first non-context bundle.
  */
 
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { describe, expect, it } from 'vitest'
 
@@ -52,7 +50,21 @@ const PKG_ROOT = resolve(__dirname, '..', '..')
 const LIB_DIR = resolve(PKG_ROOT, 'lib')
 const libExists = existsSync(resolve(LIB_DIR, 'index.js'))
 
-const read = (name: string) => readFileSync(resolve(LIB_DIR, name), 'utf8')
+const read = (rel: string) => readFileSync(resolve(LIB_DIR, rel), 'utf8')
+
+/** Every published JS file under lib/ (incl. _chunks/), excluding source maps. */
+function publishedJsFiles(): string[] {
+  const out: string[] = []
+  for (const entry of readdirSync(LIB_DIR, { withFileTypes: true })) {
+    if (entry.isFile() && entry.name.endsWith('.js')) out.push(entry.name)
+    else if (entry.isDirectory() && entry.name === '_chunks') {
+      for (const sub of readdirSync(resolve(LIB_DIR, entry.name))) {
+        if (sub.endsWith('.js')) out.push(`_chunks/${sub}`)
+      }
+    }
+  }
+  return out
+}
 
 /**
  * The bundle gate runs only when `lib/` has been built — `bun install`'s
@@ -67,10 +79,9 @@ describe.skipIf(!libExists)(
   () => {
     // ── Invariant 1: ONE createContext call across all bundles ───────
     //
-    // `lib/context.js` is the canonical single chunk. Each other
-    // sub-bundle (`index`, `ssr`, `use-head`, `provider`) should
-    // import `HeadContext` from it externally, NOT inline a fresh
-    // `createContext(null)` call.
+    // `lib/context.js` is the canonical single chunk. Every other
+    // sub-bundle / shared chunk should import `HeadContext` from it,
+    // NOT inline a fresh `createContext(null)` call.
 
     it('lib/context.js is the SINGLE bundle that calls createContext()', () => {
       const src = read('context.js')
@@ -81,50 +92,27 @@ describe.skipIf(!libExists)(
       expect(src).toContain('createContext(null)')
     })
 
-    it.each([
-      ['index.js'],
-      ['provider.js'],
-      ['use-head.js'],
-      ['ssr.js'],
-    ])('lib/%s does NOT inline createContext (must import HeadContext from @pyreon/head/context)', (name) => {
-      const src = read(name)
-      // Zero `createContext` references — anything > 0 means the bundle
-      // either imports `createContext` (= would call it at init) or
-      // declares its own `HeadContext = createContext(...)`. Both are
-      // the bug. With the fix, the sub-bundle's HeadContext arrives via
-      // an external `import { HeadContext } from "@pyreon/head/context"`.
-      expect(src.match(/createContext/g)?.length ?? 0).toBe(0)
-    })
-
-    // ── Invariant 2: external import to @pyreon/head/context ─────────
+    // ── Invariant 2: ZERO createContext references in EVERY other JS ──
     //
-    // Every non-`context` sub-bundle that USES HeadContext must import
-    // it from the externalized `@pyreon/head/context` specifier (the
-    // bundler's signal the symbol is shared with `lib/context.js`).
+    // Covers both the top-level sub-entries AND the `_chunks/*.js` files
+    // the build tool now emits — any file that contains `createContext`
+    // would be running it at module-init and minting its own Symbol.
 
-    it.each([
-      ['index.js'],
-      ['provider.js'],
-      ['use-head.js'],
-      ['ssr.js'],
-    ])('lib/%s imports HeadContext via the externalized @pyreon/head/context specifier', (name) => {
-      const src = read(name)
-      // The bundler emits the import verbatim for externalized specifiers.
-      // Both ESM string literal styles (`"…"` and `'…'`) are matched
-      // because rolldown's output quoting is deterministic but not
-      // version-pinned by this test.
-      const hasExternalImport =
-        /from\s+["']@pyreon\/head\/context["']/.test(src)
-      expect(hasExternalImport).toBe(true)
+    it('NO other lib/*.js (or lib/_chunks/*.js) calls createContext()', () => {
+      const offenders: Array<{ file: string; count: number }> = []
+      for (const rel of publishedJsFiles()) {
+        if (rel === 'context.js') continue
+        const count = read(rel).match(/createContext/g)?.length ?? 0
+        if (count > 0) offenders.push({ file: rel, count })
+      }
+      expect(offenders).toEqual([])
     })
 
     // ── Invariant 3: the package.json wiring that enables it ─────────
     //
-    // Two things must coexist for the externalization to be honored —
-    // the `./context` sub-export (so the import has a runtime target),
-    // and the `vl-tools.config.mjs` external rule (so the bundler keeps
-    // the specifier instead of inlining). Locking these here means a
-    // future revert of either side immediately fails the test.
+    // The `./context` sub-export gives `HeadContext` a stable public
+    // address. Locking it here means a future revert immediately fails
+    // the test.
 
     it('package.json declares the ./context sub-export', () => {
       const pkg = JSON.parse(read('../package.json')) as {
@@ -134,17 +122,5 @@ describe.skipIf(!libExists)(
       expect(pkg.exports['./context']?.import).toBe('./lib/context.js')
       expect(pkg.exports['./context']?.bun).toBe('./src/context.ts')
     })
-
-    it('vl-tools.config.mjs externalizes @pyreon/head/context for every sub-entry build', () => {
-      // Plain text read instead of dynamic import — vitest serves test
-      // files via http:// URLs, and Node's default ESM loader rejects
-      // anything outside `file:` / `data:`. Text-grep is enough: this
-      // assertion is structural, not behavioural — the build pipeline
-      // already proved the contract by emitting external imports in
-      // every sub-bundle (invariants 1 and 2 above).
-      const cfg = readFileSync(resolve(PKG_ROOT, 'vl-tools.config.mjs'), 'utf8')
-      expect(cfg).toContain("'@pyreon/head/context'")
-      expect(cfg).toMatch(/external\s*:/)
-    })
   },
 )

package/src/use-head.ts

@@ -1,10 +1,7 @@
 import { onMount, onUnmount, useContext } from '@pyreon/core'
 import { effect } from '@pyreon/reactivity'
 import type { HeadEntry, HeadTag, UseHeadInput } from './context'
-// Runtime VALUE import via self-package path so the build externalizes
-// the symbol — every sub-entry resolves to the same `lib/context.js` at
-// runtime. See `ssr.ts` for the full rationale + `tests/context-identity.test.ts`.
-import { HeadContext } from '@pyreon/head/context'
+import { HeadContext } from './context'
 import { syncDom } from './dom'
 
 /** Cast a strict tag interface to the internal props format, stripping undefined values */