uniweb 0.12.17 → 0.12.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.12.17",
+  "version": "0.12.19",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -42,11 +42,11 @@
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
     "@uniweb/core": "0.7.11",
-    "@uniweb/runtime": "0.8.13",
-    "@uniweb/kit": "0.9.11"
+    "@uniweb/kit": "0.9.11",
+    "@uniweb/runtime": "0.8.13"
   },
   "peerDependencies": {
-    "@uniweb/build": "0.14.3",
+    "@uniweb/build": "0.14.4",
     "@uniweb/content-reader": "1.1.10",
     "@uniweb/semantic-parser": "1.1.17"
   },
@@ -60,5 +60,8 @@
     "@uniweb/semantic-parser": {
       "optional": true
     }
+  },
+  "scripts": {
+    "test": "node --test 'test/**/*.test.js'"
   }
 }

package/src/commands/add.js

@@ -21,10 +21,9 @@ import { scaffoldFoundation, scaffoldSite, applyContent, applyStarter, mergeTemp
 import {
   readWorkspaceConfig,
   addWorkspaceGlob,
-  discoverFoundations,
-  discoverSites,
   updateRootScripts,
 } from '../utils/config.js'
+import { discoverFoundations, discoverSites } from '../utils/discover.js'
 import { validatePackageName, getExistingPackageNames, resolveUniqueName } from '../utils/names.js'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 import { detectPackageManager, filterCmd, installCmd } from '../utils/pm.js'

package/src/commands/build.js

@@ -45,8 +45,8 @@
  *   --bundle            # Full vite pipeline (third-party hosts)
  */
 
-import { existsSync, readFileSync } from 'node:fs'
-import { resolve, join, dirname } from 'node:path'
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { resolve, join, dirname, basename } from 'node:path'
 import { spawn } from 'node:child_process'
 import { writeFile, mkdir } from 'node:fs/promises'
 import { createRequire } from 'node:module'
@@ -243,6 +243,118 @@ async function buildFoundation(projectDir, options = {}) {
   log(`  ${colors.bright}uniweb handoff <email>${colors.reset}      Hand off a site to a client`)
 }
 
+/**
+ * Ensure a local foundation's `dist/entry.js` is current.
+ *
+ * Whenever a build or deploy reads a local foundation from disk — bundle
+ * mode (vite imports it, prerender loads it for SSG), or link mode where
+ * the foundation is uploaded alongside the site — the foundation must be
+ * built and current. Otherwise the verb fails with "Foundation not found
+ * at .../dist/entry.js" or silently ships stale artifacts.
+ *
+ * `buildWorkspace()` already cascades when invoked from a workspace root,
+ * but verbs invoked from a site directory (`uniweb build` in `sites/x/`,
+ * `uniweb deploy`, `uniweb export`) used to skip the cascade and rely on
+ * the user having pre-built the foundation. That broke fresh checkouts
+ * where the foundation has never been built locally.
+ *
+ * This helper is idempotent: when the workspace-root cascade has already
+ * run, the freshness check sees a current `dist/entry.js` and returns
+ * without rebuilding. So adding the call inside `buildSite()` /
+ * `buildSiteLink()` does not double-build under `buildWorkspace()`.
+ *
+ * Freshness rule: a built artifact (`dist/entry.js` or the legacy
+ * `dist/foundation.js`) exists AND its mtime is >= the newest mtime of
+ * any tracked source file. Tracked sources: every file under
+ * `<foundation>/src/`, plus root-level `package.json`, `foundation.js`,
+ * `meta.js` (the structural files that drive entry generation and
+ * schema). Build outputs and node_modules are skipped.
+ *
+ * Both artifact names are accepted because the foundation build emitter
+ * was renamed `dist/foundation.js → dist/entry.js` in `@uniweb/build`
+ * v0.14.3. A foundation built with an older @uniweb/build still produces
+ * the legacy name; we don't want the cascade to keep rebuilding such a
+ * foundation forever just because the new name is missing.
+ */
+async function ensureFoundationFresh(foundationDir, label = 'foundation') {
+  const distArtifact = findFoundationDistArtifact(foundationDir)
+
+  if (!distArtifact) {
+    info(`Local ${label} not built yet — building ${basename(foundationDir)} first`)
+    log('')
+    await buildFoundation(foundationDir)
+    log('')
+    return { built: true, reason: 'missing' }
+  }
+
+  const distMtime = statSync(distArtifact).mtimeMs
+  const stale = isFoundationSourceNewerThan(foundationDir, distMtime)
+
+  if (stale) {
+    info(`Local ${label} sources changed — rebuilding ${basename(foundationDir)}`)
+    log('')
+    await buildFoundation(foundationDir)
+    log('')
+    return { built: true, reason: 'stale' }
+  }
+
+  return { built: false, reason: 'fresh' }
+}
+
+/**
+ * Locate the foundation's built entry artifact. Returns the path of the
+ * first match, or null when neither file exists. Prefers the current
+ * name (`dist/entry.js`) over the legacy one (`dist/foundation.js`).
+ */
+function findFoundationDistArtifact(foundationDir) {
+  for (const name of ['entry.js', 'foundation.js']) {
+    const p = join(foundationDir, 'dist', name)
+    if (existsSync(p)) return p
+  }
+  return null
+}
+
+/**
+ * Returns true if any tracked foundation source file has an mtime newer
+ * than `referenceMtime`. Walks `<foundationDir>/src/` recursively (skipping
+ * dotfiles, node_modules, and dist). Also stats the root structural files.
+ */
+function isFoundationSourceNewerThan(foundationDir, referenceMtime) {
+  const rootFiles = ['package.json', 'foundation.js', 'meta.js']
+  for (const f of rootFiles) {
+    const p = join(foundationDir, f)
+    if (existsSync(p) && statSync(p).mtimeMs > referenceMtime) return true
+  }
+
+  const srcDir = join(foundationDir, 'src')
+  if (!existsSync(srcDir)) return false
+
+  const stack = [srcDir]
+  while (stack.length) {
+    const dir = stack.pop()
+    let entries
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const e of entries) {
+      if (e.name === 'node_modules' || e.name === 'dist' || e.name.startsWith('.')) continue
+      const full = join(dir, e.name)
+      if (e.isDirectory()) {
+        stack.push(full)
+        continue
+      }
+      if (!e.isFile()) continue
+      try {
+        if (statSync(full).mtimeMs > referenceMtime) return true
+      } catch { /* ignore */ }
+    }
+  }
+
+  return false
+}
+
 /**
  * Load site i18n configuration
  *
@@ -452,6 +564,11 @@ async function buildSiteLink(projectDir, options = {}) {
   // null and theme defaults come from theme.yml only.
   const foundationDir = await resolveFoundationDirForSite(projectDir, siteConfig).catch(() => null)
 
+  // Cascade: a local foundation in link mode is uploaded alongside the
+  // site (site-bound mode), so its dist must be current. Idempotent under
+  // buildWorkspace() — the freshness check no-ops when already built.
+  if (foundationDir) await ensureFoundationFresh(foundationDir)
+
   await buildSiteData({
     siteRoot: projectDir,
     distDir,
@@ -548,6 +665,12 @@ async function buildSite(projectDir, options = {}) {
 
   info('Building site...')
 
+  // Cascade: bundle mode imports the foundation through vite, and (when
+  // prerender is on) loads dist/entry.js for SSG. A local foundation must
+  // therefore be current. Idempotent under buildWorkspace() — when the
+  // workspace cascade has already built it, the freshness check no-ops.
+  if (foundationDir) await ensureFoundationFresh(foundationDir)
+
   // Run vite build for sites
   await runLocalVite(projectDir, ['build'])
 
@@ -924,7 +1047,20 @@ export async function build(args = []) {
       if (prerenderFlag) prerender = true
       if (noPrerenderFlag) prerender = false
 
-      await buildSite(projectDir, { prerender, foundationDir, siteConfig, host })
+      // If `--foundation-dir` wasn't passed, resolve the local foundation
+      // from site.yml + package.json. Required so buildSite() can cascade
+      // to the local foundation when the user runs `uniweb build` from a
+      // site dir on a fresh checkout where dist/ doesn't exist yet.
+      const resolvedFoundationDir =
+        foundationDir
+        || (await resolveFoundationDirForSite(projectDir, siteConfig).catch(() => null))
+
+      await buildSite(projectDir, {
+        prerender,
+        foundationDir: resolvedFoundationDir,
+        siteConfig,
+        host,
+      })
     }
   } catch (err) {
     error(err.message)

package/src/commands/dev.js

@@ -36,7 +36,8 @@ import { spawn } from 'node:child_process'
 import { join } from 'node:path'
 
 import { detectPackageManager, filterCmd } from '../utils/pm.js'
-import { discoverSites, readWorkspaceConfig } from '../utils/config.js'
+import { readWorkspaceConfig } from '../utils/config.js'
+import { discoverSites } from '../utils/discover.js'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 import { readFlagValue } from '../utils/args.js'
 

package/src/commands/doctor.js

@@ -10,7 +10,7 @@ import { loadDeployYml } from '@uniweb/build/site'
 import { listAdapters } from '@uniweb/build/hosts'
 import { getCliVersion } from '../versions.js'
 import { readAgentsVersion } from '../utils/agents-stamp.js'
-import { discoverFoundations, discoverSites } from '../utils/config.js'
+import { discoverFoundations, discoverSites } from '../utils/discover.js'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 
 /**

package/src/commands/rename.js

@@ -47,14 +47,13 @@ import yaml from 'js-yaml'
 import { isExtensionPackage } from '@uniweb/build'
 import { findWorkspaceRoot } from '../utils/workspace.js'
 import {
-  discoverFoundations,
-  discoverSites,
   readWorkspaceConfig,
   writeWorkspaceConfig,
   readRootPackageJson,
   writeRootPackageJson,
   updateRootScripts,
 } from '../utils/config.js'
+import { discoverFoundations, discoverSites } from '../utils/discover.js'
 import { getExistingPackageNames, validatePackageName } from '../utils/names.js'
 import { detectPackageManager, installCmd } from '../utils/pm.js'
 import { getCliPrefix } from '../utils/interactive.js'

package/src/framework-index.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-05-06T17:01:18.376Z",
+  "generatedAt": "2026-05-06T22:34:24.827Z",
   "packages": {
     "@uniweb/build": {
-      "version": "0.14.3",
+      "version": "0.14.4",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -92,7 +92,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.4.8",
+      "version": "0.4.9",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",

package/src/utils/config.js

@@ -1,8 +1,17 @@
 /**
  * Workspace Config Management
  *
- * Read/write pnpm-workspace.yaml and root package.json.
- * Used by both `create` and `add` commands.
+ * Read/write pnpm-workspace.yaml and root package.json, plus URL config
+ * for the platform backend / registry. Used by both `create` and `add`
+ * commands.
+ *
+ * This module is on the CLI's startup path (statically imported by
+ * `commands/login.js`, which is loaded by `src/index.js`). It MUST NOT
+ * import any optional peer dependency — most importantly `@uniweb/build`,
+ * which is absent in `npx uniweb create` scratch dirs and global
+ * installs. Workspace package discovery (which does need `@uniweb/build`)
+ * lives in `./discover.js` and is loaded only by commands that already
+ * require a project context.
  */
 
 import { existsSync, readFileSync } from 'node:fs'
@@ -10,7 +19,6 @@ import { readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import yaml from 'js-yaml'
-import { classifyPackage } from '@uniweb/build'
 import { filterCmd } from './pm.js'
 
 // ── Platform URLs ──────────────────────────────────────────────
@@ -223,63 +231,6 @@ export async function updateRootScripts(rootDir, sites, pm = 'pnpm') {
   await writeRootPackageJson(rootDir, pkg)
 }
 
-/**
- * Discover foundations in the workspace
- * @param {string} rootDir - Workspace root directory
- * @returns {Promise<Array<{name: string, path: string}>>}
- */
-export async function discoverFoundations(rootDir) {
-  return discoverByKind(rootDir, 'foundation')
-}
-
-/**
- * Discover sites in the workspace
- * @param {string} rootDir - Workspace root directory
- * @returns {Promise<Array<{name: string, path: string}>>}
- */
-export async function discoverSites(rootDir) {
-  return discoverByKind(rootDir, 'site')
-}
-
-/**
- * Walk the workspace globs and return packages of the requested kind.
- * Uses `classifyPackage` from @uniweb/build — the canonical classifier
- * shared with the build pipeline, which keys on real signals (site.yml
- * for sites, generated entry for foundations) rather than which
- * `@uniweb/*` packages happen to be in dependencies. Templates whose
- * sites pull runtime transitively through the foundation (e.g.,
- * marketing) used to be invisible to the older dependency-based check.
- */
-async function discoverByKind(rootDir, kind) {
-  const { packages } = await readWorkspaceConfig(rootDir)
-  const out = []
-
-  for (const pattern of packages) {
-    const dirs = await resolveGlob(rootDir, pattern)
-    for (const dir of dirs) {
-      const fullPath = join(rootDir, dir)
-      if (classifyPackage(fullPath) !== kind) continue
-
-      // Read package.json for the package name. Synthesize one from
-      // the directory if it's missing or malformed — we still want
-      // the package to surface in pickers.
-      const pkgPath = join(fullPath, 'package.json')
-      let name = dir.split('/').pop()
-      if (existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
-          if (pkg.name) name = pkg.name
-        } catch {
-          // keep directory-derived name
-        }
-      }
-      out.push({ name, path: dir })
-    }
-  }
-
-  return out
-}
-
 // Resolve a workspace glob pattern to actual directories
 export async function resolveGlob(rootDir, pattern) {
   const clean = pattern.replace(/^["']|["']$/g, '')

package/src/utils/discover.js

@@ -0,0 +1,75 @@
+/**
+ * Workspace package discovery
+ *
+ * Walks the workspace globs and classifies each package as a site or
+ * foundation using `classifyPackage` from `@uniweb/build` — the canonical
+ * classifier shared with the build pipeline. It keys on real signals
+ * (site.yml for sites, generated entry for foundations) rather than which
+ * `@uniweb/*` packages happen to be in dependencies, so templates whose
+ * sites pull runtime transitively through the foundation (e.g., marketing)
+ * are classified correctly.
+ *
+ * Why this lives in its own file: `@uniweb/build` is an OPTIONAL peer
+ * dependency of the CLI. The CLI's startup path (`src/index.js` and
+ * everything it statically imports) MUST run in environments where
+ * `@uniweb/build` is not installed — `npx uniweb create` in a scratch
+ * dir, `npm i -g uniweb` before any project exists, etc. Anything that
+ * imports `@uniweb/build` therefore must NOT be reachable from the
+ * startup graph; it must be loaded dynamically by commands that already
+ * require a project context. Keeping discovery in this dedicated module
+ * makes that boundary structural rather than conventional.
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { classifyPackage } from '@uniweb/build'
+import { readWorkspaceConfig, resolveGlob } from './config.js'
+
+/**
+ * Discover foundations in the workspace.
+ * @param {string} rootDir - Workspace root directory
+ * @returns {Promise<Array<{name: string, path: string}>>}
+ */
+export async function discoverFoundations(rootDir) {
+  return discoverByKind(rootDir, 'foundation')
+}
+
+/**
+ * Discover sites in the workspace.
+ * @param {string} rootDir - Workspace root directory
+ * @returns {Promise<Array<{name: string, path: string}>>}
+ */
+export async function discoverSites(rootDir) {
+  return discoverByKind(rootDir, 'site')
+}
+
+async function discoverByKind(rootDir, kind) {
+  const { packages } = await readWorkspaceConfig(rootDir)
+  const out = []
+
+  for (const pattern of packages) {
+    const dirs = await resolveGlob(rootDir, pattern)
+    for (const dir of dirs) {
+      const fullPath = join(rootDir, dir)
+      if (classifyPackage(fullPath) !== kind) continue
+
+      // Read package.json for the package name. Synthesize one from
+      // the directory if it's missing or malformed — we still want
+      // the package to surface in pickers.
+      const pkgPath = join(fullPath, 'package.json')
+      let name = dir.split('/').pop()
+      if (existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
+          if (pkg.name) name = pkg.name
+        } catch {
+          // keep directory-derived name
+        }
+      }
+      out.push({ name, path: dir })
+    }
+  }
+
+  return out
+}

package/src/utils/names.js

@@ -5,7 +5,8 @@
  * and detects collisions with existing workspace packages.
  */
 
-import { discoverFoundations, discoverSites, readWorkspaceConfig, resolveGlob } from './config.js'
+import { readWorkspaceConfig, resolveGlob } from './config.js'
+import { discoverFoundations, discoverSites } from './discover.js'
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'