fix(ssg): give the resolved config the router key its pages read

`main` has not typechecked since 566dfde, and four releases went out on it —
0.2.259 through 0.2.263.

That commit fixed the SSG's router forwarding by calling
`injectRouterScript(html, { router: options.router })` inside `renderPage`, and
took an `any` cast off `SSGConfig.router` so the field had a real type. Both
halves were right; the value was not there. `renderPage` is called with the
`cfg` built in `generateStaticSite`, so its `options.router` is `cfg.router` —
and `cfg` never had a `router` key. Every page read `undefined`, no
`__stxRouterConfig` was emitted, and a project that set `container` or
`prefetch` still got the client's built-in defaults. The fix was inert.

Nothing caught it except the type. `Required<SSGConfig>` turned the missing key
into TS2741, which is the compiler reporting precisely the bug that commit set
out to fix — and it was left unresolved, so the signal became noise on every
run since.

So populate the key. It reads the loaded config rather than `buildConfig`
because `router` is a top-level key of `stx.config.ts`, like `partialsDir`
beside it, and an explicit call option wins, like every other key in the
object.

The tests read the built HTML. An inert fix passes anything that asserts on the
call site, which is how this shipped in the first place, so these run
`generateStaticSite` against a project that declares a container and check what
comes out — including flags set to `false`, the case a truthy forward drops
while looking correct. Verified to fail against the unfixed file.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: chrisbbreuer

packages/stx/src/ssg.ts

@@ -1089,6 +1089,18 @@ export async function generateStaticSite(options: SSGConfig = {}): Promise<SSGRe
     console.warn(siteUrlFallbackWarning())
 
   const cfg: Required<SSGConfig> = {
+    // The router config the injected script is handed, and the reason
+    // `SSGConfig.router` was given a real type: `renderPage` is called with
+    // this object, so its `options.router` is this key. It was never set, so
+    // the forwarding added in 566dfdead read `undefined` on every page and
+    // emitted no `__stxRouterConfig` — the fix was inert, and the compiler has
+    // been saying so since the `any` cast came off.
+    //
+    // Read from the loaded config rather than `buildConfig`, because `router`
+    // is a top-level key of `stx.config.ts` like `partialsDir` below. The `??`
+    // is for the type only: `loadStxConfig` merges `defaultConfig`, which
+    // always carries a `router`, so the fallback is unreachable at runtime.
+    router: options.router ?? (stxConfig as any)?.router ?? {},
     pagesDir: options.pagesDir || buildConfig.pagesDir || 'pages',
     outputDir: options.outputDir || buildConfig.outputDir || 'dist',
     baseUrl: options.baseUrl || buildConfig.baseUrl || '/',

packages/stx/test/ssg/router-config-forwarding.test.ts

@@ -0,0 +1,89 @@
+/**
+ * A project's router settings reach the pages the static build generates.
+ *
+ * `renderPage` hands `injectRouterScript` its own `options.router`, and the
+ * object it is given is the resolved `cfg` built in `generateStaticSite`.
+ * That object had no `router` key, so the value was `undefined` on every page
+ * and no `__stxRouterConfig` was emitted at all — a project that set
+ * `container` or `prefetch` in `stx.config.ts` got the client's built-in
+ * defaults instead, and the same source navigated differently depending on
+ * whether the SSG or the dev server had rendered it (stacksjs/stx#1792 P2).
+ *
+ * The forwarding at the call site was added first and did nothing, because the
+ * key it read was never populated. Nothing failed; the pages were merely wrong.
+ * These tests are the thing that was missing — they read the built HTML, so an
+ * inert fix cannot pass them.
+ */
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { existsSync, readFileSync } from 'node:fs'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+let dir = ''
+const originalCwd = process.cwd()
+
+beforeEach(async () => {
+  dir = await mkdtemp(path.join(tmpdir(), 'stx-router-cfg-'))
+  await Bun.write(path.join(dir, 'views', 'index.stx'), '<main><h1>Home</h1></main>\n')
+})
+
+afterEach(async () => {
+  process.chdir(originalCwd)
+  if (dir)
+    await rm(dir, { recursive: true, force: true })
+})
+
+/** Write the project's `stx.config.ts`, the way a real project declares this. */
+async function writeConfig(router: Record<string, unknown>): Promise<void> {
+  await Bun.write(
+    path.join(dir, 'stx.config.ts'),
+    `export default ${JSON.stringify({ router }, null, 2)}\n`,
+  )
+}
+
+async function build(options: Record<string, unknown> = {}): Promise<string> {
+  process.chdir(dir)
+  const { generateStaticSite } = await import('../../src/ssg')
+  await generateStaticSite({ pagesDir: 'views', outputDir: 'dist', ...options })
+  const out = path.join(dir, 'dist', 'index.html')
+  return existsSync(out) ? readFileSync(out, 'utf8') : ''
+}
+
+/** The one line the page carries the config on. */
+function routerConfig(html: string): Record<string, unknown> | null {
+  const match = html.match(/window\.__stxRouterConfig\s*=\s*(\{.*?\});/s)
+  return match ? JSON.parse(match[1]) : null
+}
+
+describe('the static build forwards router config', () => {
+  it('carries a container declared in stx.config.ts onto the page', async () => {
+    await writeConfig({ container: '#app-shell' })
+
+    const config = routerConfig(await build())
+
+    expect(config).not.toBeNull()
+    expect(config?.container).toBe('#app-shell')
+  })
+
+  it('carries the flags too, including the ones that are false', async () => {
+    // `false` is the case a truthy forward drops, and turning a feature off is
+    // the reason anyone writes it down.
+    await writeConfig({ container: 'main', prefetch: false, viewTransitions: false })
+
+    const config = routerConfig(await build())
+
+    expect(config?.prefetch).toBe(false)
+    expect(config?.viewTransitions).toBe(false)
+  })
+
+  it('lets an explicit call option win over the config', async () => {
+    // Matches every other key in the resolved config: what the caller passes
+    // beats what the project declared.
+    await writeConfig({ container: '#from-config' })
+
+    const config = routerConfig(await build({ router: { container: '#from-caller' } }))
+
+    expect(config?.container).toBe('#from-caller')
+  })
+})