fix: typecheck + test stability across plugin, signals, and visuals

Five fixes the test job needed:

1. packages/stx/src/index.ts — alias `BuildResult` re-export from
   site-builder to `SiteBuildResult` since build-optimizer also exports
   `BuildResult` (TS2300 duplicate identifier).

2. packages/stx/src/utils.ts — `resolveTemplatePath`'s final guard now
   also accepts paths inside the configured `root`/`layoutsDir`/
   `componentsDir`/`partialsDir`/`pagesDir`. Tests and tools that point
   those at directories outside cwd (e.g. spa-fragment-real.test.ts,
   monorepo workspace setups) were getting their resolved templates
   rejected by the cwd-only guard.

3. packages/stx/src/site-builder/seo.ts — `injectSeo` now writes the
   per-page `<title>` and strips any prior one. Without this every
   built page kept stx's default `<title>stx Project</title>` even
   though og:title/twitter:title got rewritten correctly.

4. packages/bun-plugin/src/index.ts — `onResolve({ filter: /^\// })`
   was marking the entrypoint absolute path as external when there
   was no importer, causing `Bun.build` to silently produce zero
   outputs under `bun test`. Skip when `args.importer` is falsy so
   only actual imports get externalized.

5. packages/desktop/test/clipboard-strip.test.ts — afterEach was doing
   `delete globalThis.Blob`, wiping Bun's built-in for every later
   test in the run (the build-optimizer optimizeTemplate suite hit
   "Blob is not defined" because of this). Save originals in
   beforeEach and restore in afterEach instead.

Full test suite goes from 61 fails → 0 fails (8695 pass).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: glennmichael123

packages/bun-plugin/src/index.ts

@@ -172,6 +172,12 @@ export function stxPlugin(userOptions?: StxOptions): BunPlugin {
         // Bare absolute paths only — don't intercept Windows drive paths
         // or schemeless URLs (//cdn.example.com/...).
         if (args.path.startsWith('//')) return null
+        // Don't intercept entrypoints — when entrypoints are passed as
+        // absolute paths (common in tests and tooling), they have no
+        // importer. Marking those external would tell Bun to skip them
+        // entirely and emit no output. We only want to externalize
+        // *imports* originating from inside another module.
+        if (!args.importer) return null
         return { external: true, path: args.path }
       })
 

packages/desktop/test/clipboard-strip.test.ts

@@ -9,11 +9,27 @@ import { clipboard } from '../src/clipboard'
 
 describe('clipboard.writeHTML stripHtml fallback', () => {
   let writes: Array<{ html: string, text: string }>
+  // Save originals so we can restore them after each test. Bun ships a
+  // real `Blob` global, and other tests in the suite (e.g. the
+  // build-optimizer optimizeTemplate suite) rely on it. A bare
+  // `delete globalThis.Blob` in afterEach would wipe Bun's built-in and
+  // poison every subsequent test in the run.
+  let origWindowBlob: any
+  let origWindowClipboardItem: any
+  let origGlobalBlob: any
+  let origGlobalClipboardItem: any
+  let origNavigatorClipboard: any
 
   beforeEach(() => {
     delete (window as any).craft
     writes = []
 
+    origWindowBlob = (window as any).Blob
+    origWindowClipboardItem = (window as any).ClipboardItem
+    origGlobalBlob = (globalThis as any).Blob
+    origGlobalClipboardItem = (globalThis as any).ClipboardItem
+    origNavigatorClipboard = (navigator as any).clipboard
+
     // very-happy-dom doesn't ship Blob/ClipboardItem; stub minimal
     // versions that capture the bytes the production code feeds in.
     ;(window as any).Blob = class FakeBlob {
@@ -37,11 +53,20 @@ describe('clipboard.writeHTML stripHtml fallback', () => {
   })
 
   afterEach(() => {
-    delete (navigator as any).clipboard
-    delete (window as any).Blob
-    delete (window as any).ClipboardItem
-    delete (globalThis as any).Blob
-    delete (globalThis as any).ClipboardItem
+    if (origNavigatorClipboard === undefined) delete (navigator as any).clipboard
+    else (navigator as any).clipboard = origNavigatorClipboard
+
+    if (origWindowBlob === undefined) delete (window as any).Blob
+    else (window as any).Blob = origWindowBlob
+
+    if (origWindowClipboardItem === undefined) delete (window as any).ClipboardItem
+    else (window as any).ClipboardItem = origWindowClipboardItem
+
+    if (origGlobalBlob === undefined) delete (globalThis as any).Blob
+    else (globalThis as any).Blob = origGlobalBlob
+
+    if (origGlobalClipboardItem === undefined) delete (globalThis as any).ClipboardItem
+    else (globalThis as any).ClipboardItem = origGlobalClipboardItem
   })
 
   it('strips simple HTML tags from the plaintext alt', async () => {

packages/stx/src/index.ts

@@ -147,7 +147,7 @@ export {
   stripLocalePrefix,
   translate,
   type BuildOptions,
-  type BuildResult,
+  type BuildResult as SiteBuildResult,
   type PageMeta,
   type RouterOptions,
   type SiteConfig,

packages/stx/src/site-builder/seo.ts

@@ -23,6 +23,7 @@ export function injectSeo(html: string, site: SiteConfig, page: PageMeta = {}, p
     tags.push(`<link rel="icon"${mime ? ` type="${mime}"` : ''} href="${escapeAttr(seo.favicon)}">`)
   }
   tags.push(
+    `<title>${escapeText(title)}</title>`,
     `<link rel="canonical" href="${escapeAttr(url)}">`,
     `<meta name="description" content="${escapeAttr(description)}">`,
     `<meta property="og:title" content="${escapeAttr(title)}">`,
@@ -54,6 +55,12 @@ export function injectSeo(html: string, site: SiteConfig, page: PageMeta = {}, p
   // Strip any existing block we previously injected (idempotent rebuilds)
   html = html.replace(/<!--\s*SEO\s*-->[\s\S]*?<!--\s*\/SEO\s*-->\s*/g, '')
 
+  // Strip any existing <title> — site.config.ts pages[*].title is the
+  // source of truth. Without this, stx's default `<title>stx Project</title>`
+  // (or a stale per-page title) survives and the browser shows it instead
+  // of the SEO block's title.
+  html = html.replace(/<title>[\s\S]*?<\/title>\s*/i, '')
+
   // Strip stale tags emitted by stx's defaults that aren't in the marker block
   html = html
     .replace(/<meta\s+name="title"\s+content="stx Project"[^>]*>\s*/g, '')
@@ -79,3 +86,10 @@ function escapeAttr(s: string): string {
     .replace(/</g, '&lt;')
     .replace(/>/g, '&gt;')
 }
+
+function escapeText(s: string): string {
+  return s
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+}

packages/stx/src/utils.ts

@@ -794,19 +794,27 @@ export async function resolveTemplatePath(
 ): Promise<string | null> {
   const result = await resolveTemplatePathInner(templatePath, currentFilePath, options, dependencies)
   if (result === null) return null
-  // Final guard: every path the resolver returns must stay inside the
-  // project root. Any escape (a malformed include path, an interpolated
-  // user-controlled directive argument, ...) gets rejected here so the
-  // caller treats it as "not found" rather than serving an arbitrary
-  // file. We don't try to confine to layouts/components/partials
-  // specifically — too easy to break legitimate setups — but the
-  // project-root boundary is non-negotiable.
-  const safe = assertInsideRoot(result, process.cwd())
-  if (!safe) {
-    console.warn(`[stx] rejected resolved template path that escapes project root: ${result} (template: ${templatePath}, from: ${currentFilePath})`)
-    return null
+  // Final guard: every path the resolver returns must stay inside a
+  // trusted directory. Any escape (a malformed include path, an
+  // interpolated user-controlled directive argument, ...) gets rejected
+  // here so the caller treats it as "not found" rather than serving an
+  // arbitrary file. The project root is the primary boundary, but
+  // explicit `root`/`layoutsDir`/`componentsDir`/`partialsDir`/`pagesDir`
+  // values are also trusted — they may legitimately point outside cwd
+  // (e.g. tests using a fixture in another repo, monorepos pointing at
+  // sibling packages). The guard is non-negotiable: if the path is
+  // inside *none* of those, it gets rejected.
+  const safeUnderCwd = assertInsideRoot(result, process.cwd())
+  if (safeUnderCwd) return safeUnderCwd
+
+  const trustedDirs = [options.root, options.layoutsDir, options.componentsDir, options.partialsDir, options.pagesDir]
+    .filter((d): d is string => typeof d === 'string' && d.length > 0)
+  for (const dir of trustedDirs) {
+    const resolvedDir = path.isAbsolute(dir) ? dir : path.resolve(process.cwd(), dir)
+    if (assertInsideRoot(result, resolvedDir)) return path.resolve(result)
   }
-  return safe
+  console.warn(`[stx] rejected resolved template path that escapes project root: ${result} (template: ${templatePath}, from: ${currentFilePath})`)
+  return null
 }
 
 async function resolveTemplatePathInner(