@uniweb/build 0.14.30 → 0.14.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.14.30",
+  "version": "0.14.32",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {

package/src/dev/plugin.js

@@ -23,10 +23,59 @@
 import { resolve, join } from 'node:path'
 import { watch } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
+import { existsSync, readdirSync } from 'node:fs'
 import { build } from 'vite'
 import { resolveFoundationSrcPath } from '../utils/foundation-source-root.js'
 
+/** Directories that never hold foundation source and must never be walked. */
+const UNWATCHABLE_DIRS = new Set(['node_modules', 'dist', 'build', 'coverage'])
+
+/**
+ * Resolve what to watch for a foundation's source changes.
+ *
+ * Returns the source root as a NON-recursive target (root-level main.js,
+ * styles.css, …) plus each source subdirectory as a recursive target.
+ *
+ * Enumerating subdirectories rather than naming them keeps this correct across
+ * every foundation layout — `sections/`, `components/`, `utils/`, `layouts/`,
+ * whatever extra section paths `defineFoundationConfig({ sections })` declares,
+ * and whatever a given project happens to call its folders.
+ *
+ * Known limitation: a top-level directory created after the server starts is
+ * not watched recursively until restart. The non-recursive root watch still
+ * sees it appear, so a rebuild fires; only per-file events inside it are
+ * missed. This matches the existing directory-rename limitation.
+ *
+ * Watching the source root recursively is not an option: under the flat layout
+ * (`main: "./_entry.generated.js"`) that root is the foundation *package* root,
+ * so a recursive watch descends into `node_modules/`. On Linux — including
+ * WSL2 — Node implements recursive fs.watch as one inotify watch per
+ * subdirectory, which exhausts `fs.inotify.max_user_watches` on startup and
+ * fails with ENOSPC. macOS hides the bug entirely: FSEvents makes a recursive
+ * watch a single handle regardless of tree size.
+ *
+ * @param {string} srcPath - Foundation source directory (absolute)
+ * @returns {Array<{path: string, recursive: boolean}>}
+ */
+function resolveWatchTargets(srcPath) {
+  const targets = [{ path: srcPath, recursive: false }]
+
+  let entries = []
+  try {
+    entries = readdirSync(srcPath, { withFileTypes: true })
+  } catch {
+    return targets
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    if (entry.name.startsWith('.') || UNWATCHABLE_DIRS.has(entry.name)) continue
+    targets.push({ path: join(srcPath, entry.name), recursive: true })
+  }
+
+  return targets
+}
+
 /**
  * Create the foundation dev plugin
  *
@@ -180,28 +229,37 @@ export function foundationDevPlugin(options = {}) {
           }, 200)
         }
 
-        try {
-          watcher = watch(srcPath, { recursive: true }, (eventType, filename) => {
-            // Ignore generated files (build output triggers entry regeneration)
-            if (filename && filename.includes('_entry.generated')) return
-
-            // Only rebuild for source file changes
-            if (
-              filename &&
-              (filename.endsWith('.js') ||
-                filename.endsWith('.jsx') ||
-                filename.endsWith('.ts') ||
-                filename.endsWith('.tsx') ||
-                filename.endsWith('.css') ||
-                filename.endsWith('.svg'))
-            ) {
-              console.log(`[foundation] ${filename} changed`)
-              scheduleRebuild()
-            }
-          })
+        const onChange = (eventType, filename) => {
+          // Ignore generated files (build output triggers entry regeneration)
+          if (filename && filename.includes('_entry.generated')) return
+
+          // Only rebuild for source file changes
+          if (
+            filename &&
+            (filename.endsWith('.js') ||
+              filename.endsWith('.jsx') ||
+              filename.endsWith('.ts') ||
+              filename.endsWith('.tsx') ||
+              filename.endsWith('.css') ||
+              filename.endsWith('.svg'))
+          ) {
+            console.log(`[foundation] ${filename} changed`)
+            scheduleRebuild()
+          }
+        }
+
+        const watchers = []
+        for (const target of resolveWatchTargets(srcPath)) {
+          try {
+            watchers.push(watch(target.path, { recursive: target.recursive }, onChange))
+          } catch (err) {
+            console.warn(`[foundation] Could not watch ${target.path}:`, err.message)
+          }
+        }
+
+        if (watchers.length > 0) {
+          watcher = { close: () => watchers.forEach(w => w.close()) }
           console.log(`[foundation] Watching ${srcPath}`)
-        } catch (err) {
-          console.warn(`[foundation] Could not watch source:`, err.message)
         }
       }
     },

package/src/generate-entry.js

@@ -22,7 +22,12 @@
 import { writeFile, readFile, mkdir } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { join, dirname } from 'node:path'
-import { discoverComponents, discoverLayoutsInPath } from './schema.js'
+import {
+  discoverComponents,
+  discoverLayoutsInPath,
+  DEFAULT_SECTION_PATHS,
+  LAYOUTS_PATH
+} from './schema.js'
 import { extractAllRuntimeSchemas, extractAllLayoutRuntimeSchemas } from './runtime-schema.js'
 import { collectSchemaRefs, buildDataSchemaMap } from './resolve-data-schema.js'
 
@@ -361,6 +366,53 @@ export async function generateEntryPoint(srcDir, outputPath = null, options = {}
   }
 }
 
+/** Normalize native path separators so matching is platform-independent. */
+const toPosix = path => path.replace(/\\/g, '/')
+
+/**
+ * Structural paths worth watching, given a foundation source root.
+ *
+ * Lives next to `shouldRegenerateForFile` so the watch surface and the match
+ * predicate stay in sync — anything this returns is a path that predicate can
+ * match, and nothing it matches lies outside these paths.
+ *
+ * Derived from the same discovery constants `generateEntryPoint` scans, and
+ * takes the same `sectionPaths` override, so a foundation that declares extra
+ * search paths via `defineFoundationConfig({ sections })` is watched wherever
+ * its sections actually live. Foundation folder layout is free-form — `src/`,
+ * `foundations/blog/`, `marketing/src/` — but every path here is relative to
+ * the resolved source root, so layout does not matter.
+ *
+ * Deliberately does NOT include the source root itself. Under the flat layout
+ * (`main: "./_entry.generated.js"`) the source root IS the foundation package
+ * root, so handing it to a watcher pulls in `node_modules/`, `dist/` and
+ * `.git/` — thousands of directories, and on Linux one inotify watch each.
+ *
+ * @param {string} srcDir - Foundation source directory (absolute)
+ * @param {Object} [options]
+ * @param {string[]} [options.sectionPaths] - Section search paths (relative to srcDir)
+ * @returns {string[]} Absolute paths to hand to a watcher
+ */
+export function getStructuralWatchPaths(srcDir, options = {}) {
+  const { sectionPaths = DEFAULT_SECTION_PATHS } = options
+
+  const rootFiles = [
+    'meta.js',
+    'main.js',
+    'main.jsx',
+    'foundation.js',
+    'foundation.jsx',
+    'styles.css',
+    'index.css'
+  ]
+
+  return [
+    ...sectionPaths.map(path => join(srcDir, path)),
+    join(srcDir, LAYOUTS_PATH),
+    ...rootFiles.map(file => join(srcDir, file))
+  ]
+}
+
 /**
  * Check if a file change should trigger entry point regeneration.
  *
@@ -370,14 +422,28 @@ export async function generateEntryPoint(srcDir, outputPath = null, options = {}
  * The content-comparison guard in generateEntryPoint() makes false positives
  * cheap (discovery runs but no write), so we err on the side of regenerating.
  *
+ * The bare-file and entry-file rules below are scoped to the primary `sections`
+ * path on purpose: that is the only path where relaxed discovery applies.
+ * Additional paths declared via `defineFoundationConfig({ sections })` use
+ * strict discovery, where a section is only registered once it has a `meta.js`
+ * — and the "meta.js anywhere" rule already covers those. Widening the bare-file
+ * rule to every configured path would fire on files discovery ignores.
+ *
  * @param {string} file - Absolute path of the changed file
  * @param {string} srcDir - Foundation source directory (absolute)
  * @returns {string|null} Reason string if regeneration needed, null otherwise
  */
 export function shouldRegenerateForFile(file, srcDir) {
-  if (!file.startsWith(srcDir + '/')) return null
+  // Both sides arrive with native separators — chokidar normalizes the paths it
+  // emits with path.normalize() on Windows, and srcDir comes from path.resolve().
+  // Comparing against a hardcoded '/' silently matched nothing on Windows, so
+  // entry regeneration never fired there and new sections needed a dev restart.
+  const normalized = toPosix(file)
+  const base = toPosix(srcDir).replace(/\/+$/, '')
+
+  if (!normalized.startsWith(base + '/')) return null
 
-  const rel = file.slice(srcDir.length + 1)
+  const rel = normalized.slice(base.length + 1)
 
   // meta.js anywhere — affects runtime metadata
   if (rel.endsWith('/meta.js') || rel === 'meta.js') {

package/src/hosts/ci-workflow.js

@@ -22,10 +22,27 @@
  * @param {boolean} [opts.checkout] — Include the checkout step (default true).
  * @returns {string} YAML fragment, no trailing newline.
  */
+/**
+ * Fallback pnpm major, for callers that don't supply one.
+ *
+ * **Must equal the CLI's `versions.js::PNPM_VERSION`.** This is a copy
+ * across a package boundary — `@uniweb/build` cannot import from the CLI,
+ * since the dependency runs the other way — and copies drift. This one
+ * drifted twice in a week: stale at '11' when the CLI moved to '10', then
+ * stale at '10' when it moved back to '11'.
+ *
+ * The CLI always passes an explicit value, so this never applies on the
+ * normal path; it exists for direct API and test callers. Drift is caught
+ * by a CLI-side test that generates a workflow *without* passing a version
+ * and asserts the emitted major matches `PNPM_VERSION` — i.e. the guard
+ * lives at the boundary where the two values have to agree.
+ */
+const FALLBACK_PNPM_VERSION = '11'
+
 export function setupSteps({
   packageManager = 'pnpm',
   nodeVersion = '20',
-  pnpmVersion = '11',
+  pnpmVersion = FALLBACK_PNPM_VERSION,
   checkout = true,
 } = {}) {
   const lines = []

package/src/hosts/cloudflare-pages.js

@@ -201,7 +201,7 @@ async function initCi({
   site,
   packageManager = 'pnpm',
   nodeVersion = '20',
-  pnpmVersion = '11',
+  pnpmVersion,
   domain = null,
   projectName = null,
   previews = true,

package/src/hosts/github-pages.js

@@ -281,7 +281,7 @@ const adapter = {
     target = 'site',
     packageManager = 'pnpm',
     nodeVersion = '20',
-    pnpmVersion = '11',
+    pnpmVersion,
     domain = null,
   }) {
     if (target === 'foundation') {

package/src/hosts/netlify.js

@@ -140,7 +140,7 @@ async function initCi({
   site,
   packageManager = 'pnpm',
   nodeVersion = '20',
-  pnpmVersion = '11',
+  pnpmVersion,
   domain = null,
   previews = true,
 }) {

package/src/hosts/vercel.js

@@ -122,7 +122,7 @@ async function initCi({
   site,
   packageManager = 'pnpm',
   nodeVersion = '20',
-  pnpmVersion = '11',
+  pnpmVersion,
   domain = null,
   previews = true,
 }) {

package/src/schema.js

@@ -26,8 +26,10 @@ const META_FILE_NAME = 'meta.js'
 // Whichever exists at the source root is loaded.
 const FOUNDATION_FILE_NAMES = ['main.js', 'foundation.js']
 
-// Default paths to scan for section types (relative to srcDir)
-const DEFAULT_SECTION_PATHS = ['sections']
+// Default paths to scan for section types (relative to srcDir).
+// Exported so dev-server watchers can derive their watch surface from the same
+// value discovery uses, instead of re-typing the literal and drifting from it.
+export const DEFAULT_SECTION_PATHS = ['sections']
 
 // Extensions recognized as component entry files
 const COMPONENT_EXTENSIONS = new Set(['.jsx', '.tsx', '.js', '.ts'])
@@ -36,7 +38,7 @@ const COMPONENT_EXTENSIONS = new Set(['.jsx', '.tsx', '.js', '.ts'])
 const SECTIONS_PATH = 'sections'
 
 // The layouts path where layout components are discovered
-const LAYOUTS_PATH = 'layouts'
+export const LAYOUTS_PATH = 'layouts'
 
 /**
  * Load a meta.js file via dynamic import

package/src/site/config.js

@@ -23,7 +23,11 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { resolve, dirname, join } from 'node:path'
 import yaml from 'js-yaml'
-import { generateEntryPoint, shouldRegenerateForFile } from '../generate-entry.js'
+import {
+  generateEntryPoint,
+  shouldRegenerateForFile,
+  getStructuralWatchPaths
+} from '../generate-entry.js'
 import { importMapPlugin } from '../import-map-plugin.js'
 import { resolveFoundationSrcPath } from '../utils/foundation-source-root.js'
 
@@ -360,11 +364,16 @@ export async function defineSiteConfig(options = {}) {
     },
 
     configureServer(server) {
-      // Watch foundation src for structural changes that affect the entry
+      // Watch foundation src for structural changes that affect the entry.
+      // Add the structural paths individually rather than the source root:
+      // under the flat layout that root is the foundation *package* root, so
+      // adding it walks node_modules/, dist/ and .git/. Vite's default ignore
+      // list filters those out today, but there is no reason to hand a package
+      // root to a watcher and depend on the filter to undo it.
       const srcDir = resolveFoundationSrcPath(foundationInfo.path)
       const entryPath = join(srcDir, '_entry.generated.js')
 
-      server.watcher.add(srcDir)
+      server.watcher.add(getStructuralWatchPaths(srcDir))
 
       server.watcher.on('all', async (event, path) => {
         const reason = shouldRegenerateForFile(path, srcDir)