toiljs 0.0.115 → 0.0.117

package/test/search.test.ts

@@ -1,114 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-
-import {
-    getPages,
-    type PageMeta,
-    pagePath,
-    registerPages,
-    searchPages,
-} from '../src/client/search/search';
-
-const PAGES: PageMeta[] = [
-    {
-        path: '/',
-        dynamic: false,
-        metadata: { title: 'Home', description: 'Welcome to the toil demo site' },
-    },
-    {
-        path: '/about',
-        dynamic: false,
-        metadata: { title: 'About', description: 'Who we are', keywords: ['team', 'company'] },
-    },
-    {
-        path: '/blog',
-        dynamic: false,
-        metadata: {
-            title: 'Blog',
-            description: 'Articles and updates',
-            openGraph: { title: 'The Blog', siteName: 'toil' },
-        },
-    },
-    { path: '/blog/:id', dynamic: true, metadata: { title: 'Blog post' } },
-    { path: '/get-started', dynamic: false, metadata: {} },
-];
-
-beforeEach(() => {
-    registerPages(PAGES);
-});
-
-describe('searchPages', () => {
-    it('returns no results for an empty / whitespace query', () => {
-        expect(searchPages('')).toEqual([]);
-        expect(searchPages('   ')).toEqual([]);
-    });
-
-    it('ranks a title match above a description-only match', () => {
-        const results = searchPages('about');
-        expect(results[0].page.path).toBe('/about');
-        // Two pages mention "about"? Only /about does here; the home page does not.
-        expect(results.map((r) => r.page.path)).toContain('/about');
-        expect(results[0].matches).toContain('title');
-    });
-
-    it('matches keywords', () => {
-        const results = searchPages('team');
-        expect(results).toHaveLength(1);
-        expect(results[0].page.path).toBe('/about');
-        expect(results[0].matches).toContain('keywords');
-    });
-
-    it('matches OpenGraph fields', () => {
-        const results = searchPages('blog', { fields: ['openGraph'] });
-        expect(results.map((r) => r.page.path)).toEqual(['/blog']);
-        expect(results[0].matches).toEqual(['openGraph']);
-    });
-
-    it('makes slugs word-searchable via the path field', () => {
-        const results = searchPages('started');
-        expect(results.map((r) => r.page.path)).toContain('/get-started');
-    });
-
-    it('excludes dynamic routes unless includeDynamic is set', () => {
-        expect(searchPages('post').map((r) => r.page.path)).not.toContain('/blog/:id');
-        expect(searchPages('post', { includeDynamic: true }).map((r) => r.page.path)).toContain(
-            '/blog/:id',
-        );
-    });
-
-    it('uses AND semantics: every term must match', () => {
-        expect(searchPages('blog updates').map((r) => r.page.path)).toEqual(['/blog']);
-        expect(searchPages('blog nonexistentword')).toEqual([]);
-    });
-
-    it('honors the limit option', () => {
-        // "toil" appears in the home description and the blog's OpenGraph siteName.
-        const all = searchPages('toil');
-        expect(all.length).toBeGreaterThan(1);
-        expect(searchPages('toil', { limit: 1 })).toHaveLength(1);
-    });
-
-    it('restricts matching to the requested fields', () => {
-        // "welcome" only lives in the home description; excluding it yields nothing.
-        expect(searchPages('welcome', { fields: ['title', 'keywords'] })).toEqual([]);
-        expect(searchPages('welcome', { fields: ['description'] }).map((r) => r.page.path)).toEqual(
-            ['/'],
-        );
-    });
-
-    it('is case-insensitive', () => {
-        expect(searchPages('ABOUT')[0].page.path).toBe('/about');
-    });
-});
-
-describe('registry helpers', () => {
-    it('getPages returns the registered index', () => {
-        expect(getPages()).toBe(PAGES);
-    });
-
-    it('pagePath normalizes results, pages, and raw strings', () => {
-        const result = searchPages('about')[0];
-        expect(pagePath(result)).toBe('/about');
-        expect(pagePath(result.page)).toBe('/about');
-        expect(pagePath('/raw')).toBe('/raw');
-    });
-});

package/test/seo.test.ts

@@ -1,175 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type { ScannedRoute } from '../src/compiler/routes';
-import {
-    injectSeoHtml,
-    llmsTxt,
-    robotsTxt,
-    routeSeo,
-    seoHeadTags,
-    sitemapXml,
-} from '../src/compiler/seo';
-
-const routes: ScannedRoute[] = [
-    { file: 'a', pattern: '/' },
-    { file: 'b', pattern: '/about' },
-    { file: 'c', pattern: '/blog/:id' }, // dynamic, excluded from sitemap
-    { file: 'd', pattern: '/photo/:id', slot: 'modal', intercept: true }, // slot/intercept, excluded
-];
-
-describe('seoHeadTags', () => {
-    it('bakes description, OG, canonical, preconnect, and JSON-LD', () => {
-        const html = seoHeadTags({
-            url: 'https://x.test',
-            title: 'Home',
-            description: 'desc',
-            openGraph: { type: 'website', image: 'https://x.test/og.png' },
-            preconnect: ['https://cdn.test'],
-            jsonLd: { '@context': 'https://schema.org', '@type': 'WebSite' },
-        });
-        expect(html).toContain('<meta name="description" content="desc" />');
-        expect(html).toContain('<meta property="og:title" content="Home" />');
-        expect(html).toContain('<meta property="og:image" content="https://x.test/og.png" />');
-        expect(html).toContain('<link rel="canonical" href="https://x.test" />');
-        expect(html).toContain('<link rel="preconnect" href="https://cdn.test" />');
-        expect(html).toContain('application/ld+json');
-        expect(html).toContain('"@type":"WebSite"');
-    });
-
-    it('escapes attribute values', () => {
-        expect(seoHeadTags({ description: 'a "b" <c>' })).toContain(
-            'content="a &quot;b&quot; &lt;c&gt;"',
-        );
-    });
-
-    it('renders a full Twitter card + OG image dimensions + fb:app_id', () => {
-        const html = seoHeadTags({
-            title: 'Home',
-            description: 'd',
-            openGraph: {
-                image: 'https://x.test/og.png',
-                imageAlt: 'alt',
-                imageWidth: 1200,
-                imageHeight: 630,
-            },
-            twitter: { site: '@x' },
-            facebook: { appId: '123' },
-        });
-        expect(html).toContain('<meta name="twitter:card" content="summary_large_image" />');
-        expect(html).toContain('<meta name="twitter:site" content="@x" />');
-        expect(html).toContain('<meta name="twitter:title" content="Home" />');
-        expect(html).toContain('<meta name="twitter:image" content="https://x.test/og.png" />');
-        expect(html).toContain('<meta property="og:image:width" content="1200" />');
-        expect(html).toContain('<meta property="og:image:alt" content="alt" />');
-        expect(html).toContain('<meta property="fb:app_id" content="123" />');
-    });
-
-    it('neutralizes </script> in JSON-LD (no script breakout)', () => {
-        const html = seoHeadTags({ jsonLd: { x: '</script><img src=x onerror=alert(1)>' } });
-        expect(html).not.toContain('</script><img');
-        expect(html).toContain('\\u003c/script');
-    });
-});
-
-describe('routeSeo', () => {
-    it("overlays a route's metadata over the site defaults and points URLs at the route", () => {
-        const site = { url: 'https://x.test', title: 'Site', description: 'site desc' };
-        const out = routeSeo(site, { title: 'About', description: 'about desc' }, '/about');
-        expect(out.title).toBe('About');
-        expect(out.description).toBe('about desc');
-        expect(out.url).toBe('https://x.test/about');
-    });
-
-    it('falls back to the site defaults when a route has no metadata', () => {
-        const site = { url: 'https://x.test', title: 'Site' };
-        expect(routeSeo(site, null, '/x')).toMatchObject({
-            title: 'Site',
-            url: 'https://x.test/x',
-        });
-    });
-});
-
-describe('injectSeoHtml', () => {
-    it('replaces the title + description and inserts the rest before </head>', () => {
-        const shell =
-            '<!doctype html><html><head><title>old</title><meta name="description" content="" /></head><body></body></html>';
-        const out = injectSeoHtml(shell, {
-            title: 'New',
-            description: 'fresh',
-            url: 'https://x.test',
-        });
-        expect(out).toContain('<title>New</title>');
-        expect(out).not.toContain('<title>old</title>');
-        expect(out.match(/name="description"/g)).toHaveLength(1);
-        expect(out).toContain('content="fresh"');
-        expect(out).toContain('<link rel="canonical" href="https://x.test" />');
-    });
-});
-
-describe('robotsTxt', () => {
-    it('allows all + lists AI crawlers + links the sitemap by default', () => {
-        const txt = robotsTxt({ url: 'https://x.test' });
-        expect(txt).toContain('User-agent: *');
-        expect(txt).toContain('Allow: /');
-        expect(txt).toContain('User-agent: GPTBot');
-        expect(txt).toContain('User-agent: ClaudeBot');
-        expect(txt).toContain('Sitemap: https://x.test/sitemap.xml');
-    });
-
-    it('disallows AI crawlers when ai: "disallow"', () => {
-        const txt = robotsTxt({ url: 'https://x.test', robots: { ai: 'disallow' } });
-        expect(txt).toMatch(/User-agent: GPTBot\nDisallow: \//);
-    });
-
-    it('is empty when robots: false', () => {
-        expect(robotsTxt({ robots: false })).toBe('');
-    });
-});
-
-describe('sitemapXml', () => {
-    it('lists only static routes, absolute', () => {
-        const xml = sitemapXml({ url: 'https://x.test' }, routes);
-        expect(xml).toContain('<loc>https://x.test</loc>');
-        expect(xml).toContain('<loc>https://x.test/about</loc>');
-        expect(xml).not.toContain(':id');
-        expect(xml).not.toContain('/photo');
-    });
-
-    it('is empty without a base url', () => {
-        expect(sitemapXml({}, routes)).toBe('');
-    });
-});
-
-describe('llmsTxt', () => {
-    it('renders title, summary, instructions, and pages', () => {
-        const txt = llmsTxt(
-            {
-                url: 'https://x.test',
-                title: 'My Site',
-                description: 'a site',
-                llms: { instructions: 'Be nice.' },
-            },
-            routes,
-        );
-        expect(txt).toContain('# My Site');
-        expect(txt).toContain('> a site');
-        expect(txt).toContain('Be nice.');
-        expect(txt).toContain('[Home](https://x.test)');
-        expect(txt).toContain('[/about](https://x.test/about)');
-    });
-
-    it('is empty when llms: false', () => {
-        expect(llmsTxt({ llms: false }, routes)).toBe('');
-    });
-
-    it('renders a supplied page list (titles + descriptions, e.g. SSG pages) over the static paths', () => {
-        const txt = llmsTxt({ url: 'https://x.test', title: 'Docs' }, routes, [
-            { title: 'useReducer | React Hooks', url: 'https://x.test/hooks/usereducer', description: 'A reducer.' },
-            { title: 'About', url: 'https://x.test/about' },
-        ]);
-        expect(txt).toContain('[useReducer | React Hooks](https://x.test/hooks/usereducer): A reducer.');
-        expect(txt).toContain('[About](https://x.test/about)');
-        // the supplied list replaces the bare static-path fallback
-        expect(txt).not.toContain('[Home](https://x.test)');
-    });
-});

package/test/slot-layouts.test.ts

@@ -1,69 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { loadConfig } from '../src/compiler/config';
-import { generate } from '../src/compiler/generate';
-
-const roots: string[] = [];
-function project(files: Record<string, string>): string {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'toil-gen-'));
-    roots.push(root);
-    for (const [rel, content] of Object.entries(files)) {
-        const abs = path.join(root, rel);
-        fs.mkdirSync(path.dirname(abs), { recursive: true });
-        fs.writeFileSync(abs, content);
-    }
-    return root;
-}
-afterEach(() => {
-    for (const r of roots.splice(0)) fs.rmSync(r, { recursive: true, force: true });
-});
-
-const COMP = `export default function C() { return null; }\n`;
-const LAYOUT = `export default function L({ children }) { return children; }\n`;
-const HTML = `<!doctype html><html><head></head><body><div id="root"></div></body></html>\n`;
-
-describe('generate: parallel-slot layout chains', () => {
-    it('keeps the parent layout on the full-page route but drops it from the @slot route', async () => {
-        const root = project({
-            'client/public/index.html': HTML,
-            'client/routes/gallery/layout.tsx': LAYOUT,
-            'client/routes/gallery/index.tsx': COMP,
-            'client/routes/gallery/photo/[id].tsx': COMP,
-            'client/routes/gallery/@modal/(.)photo/[id].tsx': COMP,
-        });
-        const cfg = await loadConfig({ root });
-        generate(cfg);
-        const lines = fs.readFileSync(path.join(cfg.toilDir, 'routes.ts'), 'utf8').split('\n');
-
-        // The normal full-page route is wrapped by gallery/layout.
-        const mainLine = lines.find((l) => l.includes('photo/[id]') && !l.includes('@modal'));
-        expect(mainLine).toMatch(/gallery\/layout/);
-
-        // The intercepting @modal slot route is rendered INTO gallery/layout's <Slot>, so it must not
-        // re-include that layout (doing so recurses, the slot rendering itself forever).
-        const slotLine = lines.find((l) => l.includes('@modal'));
-        expect(slotLine).toContain('intercept: true');
-        expect(slotLine).toMatch(/layouts: \[\]/);
-        expect(slotLine).not.toMatch(/gallery\/layout/);
-    });
-
-    it('still applies a layout placed inside the @slot subtree', async () => {
-        const root = project({
-            'client/public/index.html': HTML,
-            'client/routes/gallery/layout.tsx': LAYOUT,
-            'client/routes/gallery/@modal/layout.tsx': LAYOUT,
-            'client/routes/gallery/@modal/(.)photo/[id].tsx': COMP,
-        });
-        const cfg = await loadConfig({ root });
-        generate(cfg);
-        const lines = fs.readFileSync(path.join(cfg.toilDir, 'routes.ts'), 'utf8').split('\n');
-        const slotLine = lines.find((l) => l.includes('@modal/(.)photo'));
-        // The slot's own layout (inside @modal) applies; the parent gallery layout does not.
-        expect(slotLine).toMatch(/@modal\/layout/);
-        expect(slotLine).not.toMatch(/gallery\/layout/);
-    });
-});

package/test/sri.test.ts

@@ -1,129 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { buildImportMapIntegrity, injectImportMap, injectSri } from '../src/compiler/sri';
-
-describe('injectSri', () => {
-    const dirs: string[] = [];
-    function outDir(files: Record<string, string>): string {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'toil-sri-'));
-        dirs.push(root);
-        for (const [rel, body] of Object.entries(files)) {
-            const full = path.join(root, rel);
-            fs.mkdirSync(path.dirname(full), { recursive: true });
-            fs.writeFileSync(full, body);
-        }
-        return root;
-    }
-    afterEach(() => {
-        for (const d of dirs.splice(0)) fs.rmSync(d, { recursive: true, force: true });
-    });
-
-    it('adds sha384 integrity + crossorigin to a local module script', () => {
-        const root = outDir({ 'assets/index-abc.js': 'console.log(1)' });
-        const html = injectSri(
-            '<script type="module" crossorigin src="/assets/index-abc.js"></script>',
-            root,
-            '/',
-        );
-        expect(html).toMatch(/integrity="sha384-[A-Za-z0-9+/]+=*"/);
-        // Vite already put crossorigin on the tag, so it isn't duplicated.
-        expect(html.match(/crossorigin/g)?.length).toBe(1);
-    });
-
-    it('adds integrity to stylesheets and modulepreload, plus a missing crossorigin', () => {
-        const root = outDir({
-            'assets/a.css': 'body{}',
-            'assets/chunk.js': 'export default 1',
-        });
-        const css = injectSri('<link rel="stylesheet" href="/assets/a.css">', root, '/');
-        expect(css).toMatch(/integrity="sha384-/);
-        expect(css).toContain('crossorigin="anonymous"');
-        const pre = injectSri('<link rel="modulepreload" href="/assets/chunk.js" />', root, '/');
-        expect(pre).toMatch(/integrity="sha384-/);
-        expect(pre.trimEnd().endsWith('/>')).toBe(true); // self-closing preserved
-    });
-
-    it('leaves external URLs, inline scripts, icons, and missing files alone', () => {
-        const root = outDir({ 'assets/x.js': 'x' });
-        const external = '<script src="https://cdn.example.com/a.js"></script>';
-        expect(injectSri(external, root, '/')).toBe(external);
-        const inline = '<script type="application/json">{"a":1}</script>';
-        expect(injectSri(inline, root, '/')).toBe(inline);
-        const icon = '<link rel="icon" href="/favicon.ico">';
-        expect(injectSri(icon, root, '/')).toBe(icon);
-        const missing = '<script src="/assets/gone.js"></script>';
-        expect(injectSri(missing, root, '/')).toBe(missing); // unreadable -> skipped, not crashed
-    });
-
-    it('does not double-tag a script that already has integrity', () => {
-        const root = outDir({ 'assets/x.js': 'x' });
-        const already = '<script src="/assets/x.js" integrity="sha384-existing"></script>';
-        expect(injectSri(already, root, '/')).toBe(already);
-    });
-
-    it('honors a non-root base', () => {
-        const root = outDir({ 'assets/x.js': 'x' });
-        const html = injectSri('<script src="/sub/assets/x.js"></script>', root, '/sub/');
-        expect(html).toMatch(/integrity="sha384-/);
-    });
-});
-
-describe('buildImportMapIntegrity + injectImportMap (module-graph coverage)', () => {
-    const dirs: string[] = [];
-    function outDir(files: Record<string, string>): string {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'toil-srimap-'));
-        dirs.push(root);
-        for (const [rel, body] of Object.entries(files)) {
-            const full = path.join(root, rel);
-            fs.mkdirSync(path.dirname(full), { recursive: true });
-            fs.writeFileSync(full, body);
-        }
-        return root;
-    }
-    afterEach(() => {
-        for (const d of dirs.splice(0)) fs.rmSync(d, { recursive: true, force: true });
-    });
-
-    it('maps every emitted chunk (incl. ones no HTML tag references) with sha384', () => {
-        const root = outDir({
-            'assets/index-abc.js': 'entry',
-            'assets/layout-def.js': 'lazy route chunk', // loaded via import(), never in a tag
-            'assets/react-ghi.js': 'vendor',
-            'assets/style-x.css': 'body{}', // not a module: excluded
-        });
-        const tag = buildImportMapIntegrity(root, '/');
-        expect(tag).not.toBeNull();
-        const map = JSON.parse((tag as string).replace(/^<script type="importmap">|<\/script>$/g, ''));
-        expect(Object.keys(map.integrity).sort()).toEqual([
-            '/assets/index-abc.js',
-            '/assets/layout-def.js',
-            '/assets/react-ghi.js',
-        ]);
-        for (const v of Object.values(map.integrity)) expect(v).toMatch(/^sha384-/);
-    });
-
-    it('prefixes a non-root base and returns null with no chunks', () => {
-        const root = outDir({ 'assets/a.js': 'a' });
-        const tag = buildImportMapIntegrity(root, '/sub/') as string;
-        expect(tag).toContain('"/sub/assets/a.js"');
-        const empty = outDir({ 'index.html': '<html></html>' });
-        expect(buildImportMapIntegrity(empty, '/')).toBeNull();
-    });
-
-    it('injects after <head>, before any module script, and is idempotent', () => {
-        const html = '<html><head><meta x></head><body><script type="module" src="/a.js"></script></body></html>';
-        const tag = '<script type="importmap">{"integrity":{"/assets/a.js":"sha384-zzz"}}</script>';
-        const out = injectImportMap(html, tag);
-        expect(out.indexOf('importmap')).toBeGreaterThan(out.indexOf('<head>'));
-        expect(out.indexOf('importmap')).toBeLessThan(out.indexOf('type="module"'));
-        // Idempotent: a second pass does not duplicate the map.
-        expect(injectImportMap(out, tag)).toBe(out);
-        // No <head>: falls back to before the first <script>.
-        const headless = injectImportMap('<script src="/x.js"></script>', tag);
-        expect(headless.indexOf('importmap')).toBeLessThan(headless.indexOf('src="/x.js"'));
-    });
-});

package/test/ssg.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { sitemapXml, type SeoConfig } from '../src/compiler/seo';
-import { fillPattern } from '../src/compiler/ssg';
-import { type ScannedRoute } from '../src/compiler/routes';
-
-describe('fillPattern', () => {
-    it('substitutes :param and *catch-all segments', () => {
-        expect(fillPattern('/:a/:b/:c', { a: 'x', b: 'y', c: 'z' })).toBe('/x/y/z');
-        expect(fillPattern('/blog/:id', { id: '42' })).toBe('/blog/42');
-        expect(fillPattern('/docs/*slug', { slug: ['a', 'b'] })).toBe('/docs/a/b');
-        expect(fillPattern('/static', {})).toBe('/static');
-    });
-});
-
-describe('sitemapXml with SSG paths', () => {
-    const seo: SeoConfig = { url: 'https://x.dev' };
-    const routes: ScannedRoute[] = [
-        { file: 'a', pattern: '/' },
-        { file: 'b', pattern: '/about' },
-        { file: 'c', pattern: '/blog/:id' },
-    ];
-
-    it('lists static routes plus enumerated SSG URLs, deduped, never the bare pattern', () => {
-        const xml = sitemapXml(seo, routes, ['/blog/1', '/blog/2', '/about']);
-        expect(xml).toContain('https://x.dev/blog/1');
-        expect(xml).toContain('https://x.dev/blog/2');
-        expect(xml).toContain('https://x.dev/about');
-        expect(xml).not.toContain('/blog/:id'); // dynamic pattern is never listed literally
-        expect((xml.match(/<loc>[^<]*\/about<\/loc>/g) ?? []).length).toBe(1); // deduped
-    });
-
-    it('is empty without a base url', () => {
-        expect(sitemapXml({}, routes, ['/blog/1'])).toBe('');
-    });
-});

package/test/ssr-hydration.test.tsx

@@ -1,122 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Real-hydration test: drive the actual build (`extractRouteTemplate`, which now
- * renders with `renderToString`) -> splice -> `hydrateRoot` path in jsdom and
- * assert there is NO hydration mismatch and the content is present. This is the
- * failure users hit ("server rendered HTML didn't match the client"), and it
- * covers the things that broke it:
- *   - "text + hole + text" (`Hello, <Hole>{name}</Hole>!`): needs the `<!-- -->`
- *     text-boundary markers `renderToString` emits.
- *   - an `<img>`, whose React 19 auto-preload `<link>` must be kept OUT of `#root`.
- *   - an `<Island>`, which must be empty on the first (hydration) render.
- *   - the Suspense dehydration markers (`<!--$-->`): `assembleRouteElement` wraps the
- *     route (and each layout) in `Suspense`, so we hydrate through the SAME `Suspense`
- *     structure the client Router renders. Remove that wrapping and this test fails
- *     with "server rendered HTML didn't match the client", the exact regression.
- */
-import { act, Suspense } from 'react';
-import { hydrateRoot } from 'react-dom/client';
-import { describe, expect, it, vi } from 'vitest';
-
-import { Hole, Island, RawHtml, __setSsrBuild } from '../src/client/ssr/markers';
-import { extractRouteTemplate } from '../src/compiler/template-build';
-import { reactEscapeHtml, spliceTemplate } from '../src/compiler/template';
-
-const NAME = 'world';
-const BLURB = 'Rendered at the <strong>edge</strong>.';
-
-function Page(): React.ReactElement {
-    return (
-        <main>
-            <img src="/images/logo.svg" alt="logo" width={28} height={28} />
-            <h1>
-                Hello, <Hole id="name">{NAME}</Hole>!
-            </h1>
-            <p>
-                <RawHtml id="blurb" html={BLURB} as="span" />
-            </p>
-            <Island>
-                <span className="isle">island-only</span>
-            </Island>
-        </main>
-    );
-}
-
-const SHELL =
-    '<!doctype html><html><head><title>t</title></head><body><div id="root"></div></body></html>';
-
-/** Build the template (renderToString + strip), splice per-slot values, return #root inner HTML. */
-function serverRootHtml(): string {
-    const art = extractRouteTemplate({
-        name: 'hyd',
-        Page,
-        layouts: [],
-        loaderData: null,
-        loaderContext: null,
-        setSsrBuild: __setSsrBuild,
-        shell: SHELL,
-    });
-    const valueFor: Record<number, Buffer> = {
-        0: Buffer.from(reactEscapeHtml(NAME), 'utf8'), // name (text)
-        1: Buffer.from(BLURB, 'utf8'), // blurb (raw)
-    };
-    const nSlots = art.slotsBin.readUInt16LE(44);
-    const inserts: { offset: number; value: Buffer }[] = [];
-    let o = 46;
-    for (let i = 0; i < nSlots; i++) {
-        inserts.push({ offset: art.slotsBin.readUInt32LE(o), value: valueFor[art.slotsBin.readUInt16LE(o + 4)] });
-        o += 8;
-    }
-    const full = spliceTemplate(art.tmpl, inserts).toString('utf8');
-    const m = /<div id="root">([\s\S]*?)<\/div><template id="__toil_ssr">/.exec(full);
-    if (!m) throw new Error('could not isolate #root');
-    return m[1];
-}
-
-describe('ssr hydration (real hydrateRoot, no mismatch)', () => {
-    it('hydrates the spliced server markup cleanly and reveals the island after mount', async () => {
-        const rootInner = serverRootHtml();
-        expect(rootInner).not.toContain('rel="preload"'); // preload hoisted to <head>, not #root
-        expect(rootInner).not.toContain('island-only'); // island empty server-side
-        expect(rootInner).toContain('Hello, '); // text hole filled
-        expect(rootInner).toContain('<strong>edge</strong>'); // raw hole verbatim
-
-        document.body.innerHTML = `<div id="root">${rootInner}</div>`;
-        const rootEl = document.getElementById('root')!;
-
-        const recoverable: string[] = [];
-        const consoleErrors: string[] = [];
-        const spy = vi.spyOn(console, 'error').mockImplementation((...a: unknown[]) => {
-            consoleErrors.push(a.map(String).join(' '));
-        });
-        try {
-            await act(async () => {
-                // Hydrate through the route Suspense `assembleRouteElement` emits (layouts: []
-                // here -> just the route boundary), so the client's Suspense markers line up
-                // with the server's. This is what the real client Router does.
-                hydrateRoot(
-                    rootEl,
-                    (
-                        <Suspense fallback={null}>
-                            <Page />
-                        </Suspense>
-                    ),
-                    {
-                        onRecoverableError: (e) => recoverable.push(String(e)),
-                    },
-                );
-            });
-        } finally {
-            spy.mockRestore();
-        }
-
-        const noise = /hydrat|did not match|server rendered|didn't match/i;
-        expect(recoverable.filter((e) => noise.test(e))).toEqual([]);
-        expect(consoleErrors.filter((e) => noise.test(e))).toEqual([]);
-
-        // Content survived hydration (not regenerated/blanked); the island revealed after mount.
-        expect(rootEl.querySelector('h1')?.textContent).toBe('Hello, world!');
-        expect(rootEl.querySelector('.isle')?.textContent).toBe('island-only');
-        expect(rootEl.querySelector('img')?.getAttribute('src')).toBe('/images/logo.svg');
-    });
-});