chore: merge #755 deterministic root reservations

Refs #686 #694

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: owjs3901

e2e/landing-zero-runtime.spec.ts

@@ -148,13 +148,13 @@ test.describe('Landing Page - Zero Runtime Validation', () => {
 
     expect(headingClasses.length).toBeGreaterThan(1)
     const atomicClasses = headingClasses.filter((className) =>
-      /^(?:[a-z][a-z0-9_]{0,2}-)?[a-z0-9_]{1,3}$/i.test(className),
+      /^(?:[a-z]-)?[a-z0-9_]{1,3}$/i.test(className),
     )
     expect(atomicClasses.length).toBeGreaterThan(1)
     expect(
       headingClasses.every(
         (className) =>
-          /^(?:[a-z][a-z0-9_]{0,2}-)?[a-z0-9_]{1,3}$/i.test(className) ||
+          /^(?:[a-z]-)?[a-z0-9_]{1,3}$/i.test(className) ||
           /^typo-[a-z0-9]+$/i.test(className),
       ),
       `Expected compact base-37 classes, received: ${headingClasses.join(' ')}`,

packages/vite-plugin/src/__tests__/landing-config-preloads.test.ts

@@ -0,0 +1,93 @@
+import { resolve } from 'node:path'
+
+import { expect, it } from 'bun:test'
+import { type Plugin, resolveConfig } from 'vite'
+
+import {
+  type AssetsManifest,
+  getPluginApi,
+  vitePluginRscMinimal,
+} from '../../../../apps/landing/node_modules/@vitejs/plugin-rsc/dist/plugin.js'
+import { productionFixture } from './production-fixture'
+
+it.each([true, false])(
+  'removes dead proxy preloads from actual landing plugin with entry group=%s',
+  async (withEntry) => {
+    // Given actual config plugins and typed entry/reference asset dependencies.
+    const root = resolve(import.meta.dir, '../../../../apps/landing')
+    const config = await resolveConfig(
+      { root, configLoader: 'bundle' },
+      'build',
+    )
+    const apiPlugin = vitePluginRscMinimal()
+    const cleanup = config.plugins.find(
+      (p) => p.name === 'landing:omit-devup-css-proxy-preloads',
+    )
+    if (!cleanup) throw new TypeError('Expected actual landing cleanup')
+    let api: ReturnType<typeof getPluginApi>
+    const entry = {
+      js: ['/assets/devup-ui.css-DEAD.js', '/assets/main.js'],
+      css: ['/assets/devup-ui.css'],
+    }
+    const reference = {
+      js: [
+        '/assets/devup-ui-7.css-DEAD.js',
+        '/assets/card.js',
+        '/assets/vendor-devup-ui.css-LIVE.js',
+      ],
+      css: ['/assets/card.css'],
+    }
+    const assets = {
+      clientEntryUrl: '/assets/main.js',
+      ...(withEntry ? { clientEntryDeps: entry } : {}),
+      clientReferenceDeps: { card: reference },
+      serverResources: { page: { css: ['/assets/server.css'] } },
+    } satisfies AssetsManifest
+    const provider: Plugin = {
+      name: 'test:provide-rsc-assets',
+      configResolved(miniConfig) {
+        api = getPluginApi(miniConfig)
+      },
+      generateBundle: {
+        order: 'pre',
+        handler() {
+          if (!api) throw new TypeError('Expected public MINI build RSC API')
+          api.manager.buildAssetsManifest = assets
+        },
+      },
+    }
+    const fixture = await productionFixture()
+    try {
+      const main = await fixture.file(
+        'app/src/main.js',
+        'export const value=1;',
+      )
+      // When Vite supplies a genuine client hook context in a tiny normal build.
+      const output = await fixture.run(false, [], {
+        plugins: [apiPlugin, cleanup, provider],
+        build: { write: false, lib: { entry: main, formats: ['es'] } },
+      })
+      // Then only dead JS preloads disappear; ordinary JS, CSS and metadata remain.
+      expect(output.some((item) => item.type === 'chunk')).toBe(true)
+      expect(reference.js).toEqual([
+        '/assets/card.js',
+        '/assets/vendor-devup-ui.css-LIVE.js',
+      ])
+      expect(reference.css).toEqual(['/assets/card.css'])
+      expect(entry.js).toEqual(
+        withEntry
+          ? ['/assets/main.js']
+          : ['/assets/devup-ui.css-DEAD.js', '/assets/main.js'],
+      )
+      expect(entry.css).toEqual(['/assets/devup-ui.css'])
+      expect(assets.clientEntryUrl).toBe('/assets/main.js')
+      expect(assets.serverResources).toEqual({
+        page: { css: ['/assets/server.css'] },
+      })
+      expect(api?.manager.buildAssetsManifest).toBe(assets)
+    } finally {
+      await fixture.close()
+    }
+  },
+  30000,
+)

packages/vite-plugin/src/__tests__/nonphysical-arrival-native.test.ts

@@ -58,10 +58,6 @@ it('subtracts a learned physical arrival when a fresh native generation promotes
     await fixture.run(false, [provider])
     expect(await fixture.learned()).toContain(physical)
     // When the same actual source joins the next native generation's scan roots.
-    await fixture.file(
-      'app/src/main.js',
-      "export {cls} from '../../outside/view.js';",
-    )
     await fixture.run(false, [], {
       plugins: [
         DevupUI({ sourceDirs: [`${fixture.directory}/outside`] }),

packages/vite-plugin/src/__tests__/nonphysical-modules.test.ts

@@ -128,7 +128,7 @@ it('keeps existing direct and recursive extraction filenames consistent across q
     await realpath(await mkdtemp(join(tmpdir(), 'devup-v1-current-id-')))
   ).replaceAll('\\', '/')
   const entry = join(root, 'src/main.ts')
-  const style = `${root}/z-style.ts`
+  const style = `${root}/a-style.ts`
   const constant = `${root}/src/constant.ts`
   const direct: {
     readonly id: string

packages/vite-plugin/src/__tests__/production-entry-reservation.test.ts

@@ -1,11 +1,17 @@
-import { createNonphysicalIdStore } from '@devup-ui/plugin-utils'
+import { symlink } from 'node:fs/promises'
+
+import {
+  createNonphysicalIdStore,
+  resolveSourceDirs,
+} from '@devup-ui/plugin-utils'
 import { expect, it } from 'bun:test'
 import { resolveConfig, type UserConfig } from 'vite'
 
 import {
   prepareProductionManifest,
   type ProductionOptions,
 } from '../production-manifest'
+import { productionRootSources } from '../production-root-sources'
 import { productionFixture } from './production-fixture'
 
 it.each([
@@ -20,7 +26,7 @@ it.each([
   'html',
   'html-mixed',
 ] as const)(
-  'reserves input closure while preserving legacy inventory when input=%s',
+  'reserves roots and input closure while preserving legacy inventory when input=%s',
   async (form) => {
     // Given exact inputs outside sourceDirs and an unrelated configured search file.
     const fixture = await productionFixture()
@@ -129,16 +135,17 @@ it.each([
         options,
         (inputs) => observed.push(...inputs.fileDependencies),
       )
-      // Then ordinary HTML retains 919 inventory, while scripts reserve only reached candidates.
+      // Then ordinary HTML retains 919 inventory, while scripts also reserve configured roots.
       const legacy = form === 'html' || form === 'html-mixed'
       const expected =
         form === 'virtual'
-          ? []
+          ? [unused]
           : [
               entry,
               view,
               ...(form === 'mdx' ? [mdx] : []),
-              ...(legacy ? [unused, tooling] : []),
+              unused,
+              ...(legacy ? [tooling] : []),
             ]
       const context = manifest.contexts.find(
         ({ context }) => context === 'client',
@@ -149,7 +156,7 @@ it.each([
         'virtual:learned.js',
       ])
       expect(context?.scan).not.toContain('virtual:learned.js')
-      if (!legacy) expect(context?.scan).not.toContain(unused)
+      expect(context?.scan).toContain(unused)
       if (form !== 'virtual')
         expect(observed).toContain(
           entry.replaceAll('/', process.platform === 'win32' ? '\\' : '/'),
@@ -159,3 +166,94 @@ it.each([
     }
   },
 )
+
+it('censuses explicit roots and includes without test, output or automatic package inventories', async () => {
+  // Given default roots, explicit overrides, linked siblings and an included package.
+  const fixture = await productionFixture()
+  const source = await fixture.file('app/src/view.js', 'export {};')
+  const app = await fixture.file('app/app/page.js', 'export {};')
+  const configured = await fixture.file('app/custom/view.js', 'export {};')
+  const included = await fixture.file(
+    'app/node_modules/included/src/view.js',
+    'export {};',
+  )
+  await fixture.file(
+    'app/node_modules/included/package.json',
+    '{"name":"included"}',
+  )
+  for (const name of '__tests__ tests test __fixtures__ fixtures dist build out coverage .next tooling scripts generated'.split(
+    ' ',
+  ))
+    await fixture.file(`app/src/${name}/view.js`, 'export {};')
+  for (const name of 'view.test.tsx view.spec.js types.d.ts types.d.mts types.d.cts'.split(
+    ' ',
+  ))
+    await fixture.file(`app/src/${name}`, 'export {};')
+  await fixture.file('app/node_modules/included/dist/unused.js', 'export {};')
+  await fixture.file(
+    'app/node_modules/included/fixtures/unused.js',
+    'export {};',
+  )
+  await fixture.file(
+    'app/node_modules/@devup-ui/tooling/package.json',
+    '{"main":"index.js"}',
+  )
+  await fixture.file(
+    'app/node_modules/@devup-ui/tooling/index.js',
+    'export {};',
+  )
+  const outside = await fixture.file('outside/view.js', 'export {};')
+  for (const name of ['first', 'second'])
+    await symlink(
+      `${fixture.directory}/outside`,
+      `${fixture.root}/src/${name}`,
+      'junction',
+    )
+  await symlink(
+    `${fixture.root}/src`,
+    `${fixture.directory}/outside/cycle`,
+    'junction',
+  )
+  await symlink(
+    `${fixture.root}/src/fixtures`,
+    `${fixture.root}/src/blocked`,
+    'junction',
+  )
+  try {
+    // When the same private census uses default roots or explicit sourceDirs.
+    const options = {
+      cwd: fixture.root,
+      exclude: [`${fixture.root}/src/generated`],
+      includeMdx: ['.mdx'],
+    }
+    const defaults = productionRootSources(
+      { ...options, roots: resolveSourceDirs(fixture.root) },
+      ['included'],
+    )
+    const override = productionRootSources(
+      { ...options, roots: resolveSourceDirs(fixture.root, ['custom']) },
+      [],
+    )
+    // Then lexical aliases survive cycles; excluded census sources never join either set.
+    const paths = defaults.map(({ path }) => path.replaceAll('\\', '/')).sort()
+    expect(paths).toEqual(
+      [
+        source,
+        app,
+        included,
+        `${fixture.root}/src/first/view.js`,
+        `${fixture.root}/src/second/view.js`,
+      ].sort(),
+    )
+    expect(
+      defaults.filter(
+        ({ realPath }) => realPath.replaceAll('\\', '/') === outside,
+      ),
+    ).toHaveLength(2)
+    expect(override.map(({ path }) => path.replaceAll('\\', '/'))).toEqual([
+      configured,
+    ])
+  } finally {
+    await fixture.close()
+  }
+})

packages/vite-plugin/src/__tests__/production-extracted-numbering-native.test.ts

@@ -13,7 +13,7 @@ function fileIds(): string[] {
 }
 
 it.each([false, true])(
-  'reserves only extracted identities when native inputs reach dist and test modules with singleCss=%s',
+  'reserves root candidates and reached dist and test modules with singleCss=%s',
   async (singleCss) => {
     // Given an independently specified cohort and four unreachable counterexamples.
     const fixture = await productionFixture()
@@ -45,9 +45,27 @@ it.each([false, true])(
       'app/node_modules/@devup-ui/tooling/package.json',
       '{"name":"@devup-ui/tooling","type":"module","main":"index.js"}',
     )
+    const unused = await fixture.file(
+      'app/src/aaa-unused.js',
+      "import {css} from '@devup-ui/react'; import 'foreign-poison'; import '@devup-editor/root-only'; export const unused=css({zIndex:99});",
+    )
+    await fixture.file(
+      'app/node_modules/foreign-poison/package.json',
+      '{broken',
+    )
+    await fixture.file(
+      'app/node_modules/@devup-editor/root-only/package.json',
+      '{"name":"@devup-editor/root-only","exports":"./dist/style.js"}',
+    )
+    const rootOnly = await fixture.file(
+      'app/node_modules/@devup-editor/root-only/dist/style.js',
+      "import {css} from '@devup-ui/react'; export const rootOnly=css({zIndex:88});",
+    )
     const negatives = []
     for (const path of [
-      'app/src/aaa-unused.js',
+      'app/src/fixtures/unused.js',
+      'app/src/tooling/unused.js',
+      'app/src/dist/unused.js',
       'app/node_modules/@devup-ui/tooling/index.js',
       'app/node_modules/@devup-ui/fixture/dist/unused.js',
     ])
@@ -64,6 +82,7 @@ it.each([false, true])(
       ),
     )
     const expected = [main, tokens, rank, reached, dist, page].sort()
+    const reservedExpected = [...expected, unused, rootOnly].sort()
     const seeds: string[][] = []
     const completed: string[][] = []
     const original = NonphysicalModules.prototype.extract
@@ -120,6 +139,7 @@ it.each([false, true])(
         expect(js).toContain(rule?.[1] ?? 'missing-class')
       }
       expect(css).not.toContain('z-index:99')
+      expect(css).not.toContain('z-index:88')
       expect(js).not.toContain('@devup-ui/react')
       const roots = [...new Set(direct.mock.calls.map(([, id]) => id))].sort()
       const returns = recursive.mock.calls.flatMap(([, result]) => {
@@ -160,13 +180,13 @@ it.each([false, true])(
           stylingAndRecursion: 'passed',
         }),
       )
-      expect(reserved).toEqual(expected)
-      expect(seeds[0]).toEqual(expected)
+      expect(reserved).toEqual(reservedExpected)
+      expect(seeds[0]).toEqual(reservedExpected)
       const numbers: unknown = JSON.parse(wasm.exportFileMap())
       if (numbers === null || typeof numbers !== 'object')
         throw new TypeError('Expected real numbering object')
       expect(Object.getOwnPropertyDescriptor(numbers, page)?.value).toBe(
-        expected.filter((id) => id < page).length,
+        reservedExpected.filter((id) => id < page).length,
       )
       for (const id of negatives)
         expect(Object.getOwnPropertyDescriptor(numbers, id)).toBeUndefined()

packages/vite-plugin/src/__tests__/production-manifest.test.ts

@@ -126,9 +126,9 @@ it('reserves all configured contexts while keeping scan authority separate from
     'app/src/docs.mdx',
     '# Reserved documentation',
   )
-  const accepted: string[] = []
-  const imports = ["import './imports.js';"]
-  const rejected = [entry, plain, markdown]
+  const accepted: string[] = [markdown]
+  const imports = ["import './imports.js'; import './docs.mdx';"]
+  const rejected = [entry, plain]
   for (const name of ['included', 'excluded'])
     await fixture.file(
       `app/node_modules/${name}/package.json`,