@uniweb/build 0.11.8 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.11.8",
+  "version": "0.12.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -59,8 +59,8 @@
   },
   "optionalDependencies": {
     "@uniweb/content-reader": "1.1.9",
-    "@uniweb/runtime": "0.8.9",
-    "@uniweb/schemas": "0.2.1"
+    "@uniweb/schemas": "0.2.1",
+    "@uniweb/runtime": "0.8.9"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/vite-foundation-plugin.js

@@ -7,7 +7,8 @@
  * - Processing preview images for presets
  */
 
-import { writeFile, mkdir } from 'node:fs/promises'
+import { writeFile, mkdir, readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 import { buildSchema } from './schema.js'
 import { generateEntryPoint, shouldRegenerateForFile } from './generate-entry.js'
@@ -42,30 +43,144 @@ async function buildSchemaWithPreviews(srcDir, outDir, isProduction, sectionPath
 let _buildingSSRBundle = false
 
 /**
- * Build a self-contained ESM bundle for edge SSR (Cloudflare Dynamic Workers).
+ * Emit dist/runtime-pin.json declaring the @uniweb/runtime version this
+ * foundation was built against. Read by the edge isolate (under the
+ * Strategy S split-bundle path) to decide which runtime/{ver}/ssr.js to
+ * side-load from R2. See kb/platform/plans/edge-ssr-bundling-strategy.md
+ * and kb/platform/operations/release-workflow.md.
+ *
+ * Reads the resolved version from the foundation's node_modules/@uniweb/
+ * runtime/package.json so the pin reflects what was actually linked at
+ * build time, not what the foundation's own package.json range happens
+ * to allow.
+ *
+ * Silently no-ops when @uniweb/runtime isn't resolvable (e.g., the
+ * foundation depends on the runtime via a workspace alias that puts it
+ * elsewhere). The edge resolver treats the absence of a pin as the
+ * legacy single-bundle path, so omitting the pin is harmless during the
+ * dual-mode window.
+ *
+ * Optional foundation-author override: a `uniweb.runtimePolicy` field
+ * in the foundation's own package.json gets recorded alongside the
+ * runtime version so the registry's semver resolver can apply it.
+ *
+ * @param {string} outDir - dist/ directory to write to.
+ * @param {string} projectRoot - foundation project root (where package.json lives).
+ */
+async function emitRuntimePin(outDir, projectRoot) {
+  // Resolve @uniweb/runtime via two strategies, in order:
+  //   1. createRequire from this plugin's location (catches the runtime
+  //      pulled in transitively through @uniweb/build, @uniweb/core, etc.).
+  //   2. Walk up node_modules from the project root (catches the case
+  //      where the foundation depends on runtime directly).
+  // The first covers the common case (foundations don't typically depend
+  // on runtime directly — it's the host environment, not a foundation
+  // import); the second is a safety net.
+  let runtimePkgPath = null
+
+  try {
+    // Resolve via an exported subpath, not 'package.json' directly —
+    // @uniweb/runtime's `exports` map doesn't include package.json, so
+    // require.resolve on it throws ERR_PACKAGE_PATH_NOT_EXPORTED.
+    // Walking back from the resolved subpath finds the package root.
+    const { createRequire } = await import('node:module')
+    const { dirname: pathDirname } = await import('node:path')
+    const pluginRequire = createRequire(import.meta.url)
+    const ssrEntry = pluginRequire.resolve('@uniweb/runtime/ssr')
+    let dir = pathDirname(ssrEntry)
+    for (let i = 0; i < 5; i++) {
+      const candidate = join(dir, 'package.json')
+      if (existsSync(candidate)) {
+        const pkg = JSON.parse(await readFile(candidate, 'utf-8'))
+        if (pkg.name === '@uniweb/runtime') {
+          runtimePkgPath = candidate
+          break
+        }
+      }
+      const parent = resolve(dir, '..')
+      if (parent === dir) break
+      dir = parent
+    }
+  } catch {
+    // Fall through to the walk-up search.
+  }
+
+  if (!runtimePkgPath) {
+    let dir = projectRoot
+    for (let i = 0; i < 10; i++) {
+      const candidate = join(dir, 'node_modules', '@uniweb', 'runtime', 'package.json')
+      if (existsSync(candidate)) {
+        runtimePkgPath = candidate
+        break
+      }
+      const parent = resolve(dir, '..')
+      if (parent === dir) break
+      dir = parent
+    }
+  }
+
+  if (!runtimePkgPath) {
+    // No runtime resolvable. Skip emission — edge will treat as legacy.
+    return
+  }
+
+  let runtimeVersion
+  try {
+    const pkg = JSON.parse(await readFile(runtimePkgPath, 'utf-8'))
+    runtimeVersion = pkg.version
+  } catch {
+    return
+  }
+  if (!runtimeVersion) return
+
+  // Read foundation's own package.json for an optional runtimePolicy
+  // field. Default policy (auto-patch) lives at the registry layer; we
+  // only record the foundation's override if explicitly set.
+  let policy = null
+  try {
+    const foundationPkgPath = join(projectRoot, 'package.json')
+    if (existsSync(foundationPkgPath)) {
+      const foundationPkg = JSON.parse(await readFile(foundationPkgPath, 'utf-8'))
+      policy = foundationPkg?.uniweb?.runtimePolicy ?? null
+    }
+  } catch {
+    // Foundation package.json malformed; skip policy. Pin still emits.
+  }
+
+  const pin = { runtime: runtimeVersion }
+  if (policy) pin.policy = policy
+
+  const pinPath = join(outDir, 'runtime-pin.json')
+  await writeFile(pinPath, JSON.stringify(pin, null, 2) + '\n', 'utf-8')
+  console.log(`Generated runtime-pin.json (runtime ${runtimeVersion}${policy ? `, policy ${policy}` : ''})`)
+}
+
+/**
+ * @deprecated 2026-04-27 — Strategy S Phase 2.
+ *
+ * Foundations no longer carry their own runtime bundle. Runtime + React +
+ * core + theming now live in R2 under `runtime/{version}/worker-runtime.js`,
+ * published by the platform's `/deploy-runtime` skill, and side-loaded
+ * by the Cloudflare isolate alongside `dist/foundation.js`.
  *
+ * The invocation in `writeBundle()` is commented out; this function
+ * definition is kept for the rollout window so it can be flipped back
+ * on with one line if Phase 1's edge dispatcher misbehaves in production.
+ * Phase 3 cleanup deletes this function entirely once the new path is
+ * proven healthy.
+ *
+ * See `kb/platform/plans/edge-ssr-bundling-strategy.md`.
+ *
+ * Original purpose (preserved for context):
+ * Build a self-contained ESM bundle for edge SSR (Cloudflare Dynamic Workers).
  * Produces `ssr-worker-bundle.js` — a single ESM file with React,
  * ReactDOM/server, `@uniweb/core`, `@uniweb/runtime/ssr`,
  * `@uniweb/theming`, and the foundation's components all inlined. No
- * external imports.
- *
- * This is **NOT a foundation**. The foundation is `dist/foundation.js`
- * — a foundation-shaped ESM module that externalizes runtime and links
- * to it at runtime, the same as in browser SPA / framework SSG / unipress
- * (Node SSR). This file is something different: a self-contained SSR
- * pipeline shaped for the Cloudflare Workers Dynamic Worker LOADER, with
- * the foundation embedded as one of several inputs. The size ratio
- * (typical ~12× larger than `foundation.js`) reflects what's actually
- * inside it.
- *
- * The artifact is bundled this way because the Dynamic Worker LOADER
- * accepts a closed `modules` map at isolate construction (no external
- * resolver, no path back to npm or R2 for transitive imports). One
- * file in, everything resolves. A future refactor can switch to side-
- * loading runtime + React + core into the modules map separately so
- * foundations stop carrying runtime in their bundles — see
- * `kb/platform/plans/edge-runtime-side-loading.md`. Until then, this
- * build pre-bundles for the isolate's contract.
+ * external imports. The artifact was bundled this way because the
+ * Dynamic Worker LOADER accepts a closed `modules` map at isolate
+ * construction. The Phase -1 prototype (2026-04-27) verified the LOADER
+ * actually deduplicates shared modules across multiple ESM bundles, so
+ * a multi-entry modules map became viable — that's what Strategy S uses.
  *
  * @param {string} outDir - Path to dist/ directory containing foundation.js
  */
@@ -118,8 +233,16 @@ async function buildSSRBundle(outDir) {
     // - @uniweb/theming (buildSectionOverrides, used by runtime/ssr)
     //
     // All in a single file so the Dynamic Worker isolate has one React instance.
+    // L2/L3 helpers from @uniweb/runtime/ssr that worker SSR + framework SSG
+    // both depend on. Keep this list in sync with runtime/src/ssr-renderer.js
+    // exports — missing one here makes the foundation bundle fail to import
+    // it ("module does not provide an export named X") inside the SSR isolate.
     const ssrExports = runtimeSSRPath
-      ? `export { initPrerender, renderPage, injectPageContent, prefetchIcons } from "${runtimeSSRPath.replace(/\\/g, '/')}";`
+      ? `export {
+          initPrerender, initPrerenderForLocale,
+          renderPage, injectPageContent, prefetchIcons,
+          sliceContentForLocale, hydrateDataStore,
+        } from "${runtimeSSRPath.replace(/\\/g, '/')}";`
       : ''
 
     // Resolve React to a single package directory to avoid duplicate instances
@@ -191,6 +314,7 @@ export function foundationBuildPlugin(options = {}) {
 
   let resolvedSrcDir
   let resolvedOutDir
+  let resolvedRoot
   let isProduction
 
   return {
@@ -209,6 +333,7 @@ export function foundationBuildPlugin(options = {}) {
     async configResolved(config) {
       resolvedSrcDir = resolve(config.root, srcDir)
       resolvedOutDir = config.build.outDir
+      resolvedRoot = config.root
       isProduction = config.mode === 'production'
     },
 
@@ -235,8 +360,25 @@ export function foundationBuildPlugin(options = {}) {
 
       console.log(`Generated meta/schema.json with ${Object.keys(schema).length - 1} components`)
 
-      // Build self-contained SSR bundle for edge rendering (Dynamic Workers)
-      await buildSSRBundle(outDir)
+      // Emit runtime-pin.json so the edge isolate (under Strategy S) can
+      // side-load the matching runtime/{ver}/ssr.js. Lands silently before
+      // the dual-mode resolver ships; foundations published in the dual-mode
+      // window already have the pin and start using the split-bundle path
+      // automatically once the edge is updated.
+      await emitRuntimePin(outDir, resolvedRoot)
+
+      // Strategy S Phase 2: foundations no longer carry a self-contained
+      // SSR bundle. The runtime + React + core + theming live in R2 under
+      // runtime/{version}/worker-runtime.js (uploaded by the platform's
+      // /deploy-runtime skill); the Cloudflare isolate side-loads them
+      // alongside dist/foundation.js via the edge dual-mode dispatcher.
+      // See kb/platform/plans/edge-ssr-bundling-strategy.md.
+      //
+      // The buildSSRBundle() function is kept (just not invoked) so it
+      // can be flipped back on with one line if Phase 1's edge dispatcher
+      // misbehaves in production. Phase 3 cleanup deletes the function
+      // entirely once we're confident the new path is healthy.
+      // await buildSSRBundle(outDir)
     },
 
     async closeBundle() {