@uniweb/build 0.16.15 → 0.16.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.16.15",
+  "version": "0.16.17",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -64,10 +64,10 @@
     "@uniweb/content-writer": "0.3.3"
   },
   "optionalDependencies": {
-    "@uniweb/runtime": "0.9.7",
     "@uniweb/content-reader": "1.2.2",
     "@uniweb/semantic-parser": "1.2.1",
-    "@uniweb/schemas": "0.2.5"
+    "@uniweb/schemas": "0.2.5",
+    "@uniweb/runtime": "0.9.7"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/dev/plugin.js

@@ -26,6 +26,7 @@ import { readFile } from 'node:fs/promises'
 import { existsSync, readdirSync } from 'node:fs'
 import { build } from 'vite'
 import { resolveFoundationSrcPath } from '../utils/foundation-source-root.js'
+import { DEV_REBUILD_MARKER } from '../vite-foundation-plugin.js'
 
 /** Directories that never hold foundation source and must never be walked. */
 const UNWATCHABLE_DIRS = new Set(['node_modules', 'dist', 'build', 'coverage'])
@@ -126,6 +127,13 @@ export function foundationDevPlugin(options = {}) {
           root: resolvedFoundationPath,
           configFile: existsSync(configPath) ? configPath : false,
           logLevel: 'warn',
+          // Marks this as a dev rebuild so the foundation plugin skips the
+          // `entry-ssr.js` sub-build — a second full Vite pass, on every save,
+          // producing something nothing in the dev loop reads. A marker plugin
+          // rather than an option because the foundation's own vite.config.js
+          // constructs the plugin, not us; and rather than `mode`/`command`,
+          // which both say "build" here since this IS a real build.
+          plugins: [{ name: DEV_REBUILD_MARKER }],
           build: {
             outDir: 'dist',
             emptyOutDir: true,

package/src/site/config.js

@@ -113,22 +113,50 @@ export function detectFoundationType(foundation, siteRoot) {
     }
   }
 
-  // Catalog registry ref:
-  //   `@org/name@version`  → resolves via the registry CDN.
-  // Link-mode by definition — the foundation lives on the hosting edge and is
-  // loaded at runtime. Surfacing this as `type: 'url'` makes Vite skip the
-  // local-foundation bundling path and use the noop virtual module. Base URL
-  // defaults to the production worker but is overridable via UNIWEB_REGISTRY_URL
-  // for self-hosted / staging.
+  // Catalog registry ref: `@org/name@version`.
+  //
+  // A build does NOT turn this into a URL. Where a foundation is served is the
+  // host's to say — a serve location is READ (from backend discovery, or from an
+  // upload plan's `serve_base`), never reconstructed. `@uniweb/cli`'s
+  // DISCOVERY_DEFAULTS carries no serve-root default for exactly this reason.
+  // A build is offline and backend-optional by design, so it has nothing to ask.
+  //
+  // A ref names a foundation in the Uniweb platform's catalog, and `uniweb
+  // publish` — the verb reserved for that target — has the platform resolve it,
+  // running no vite build. That is one hosting target among many. The others
+  // reach a host through `uniweb deploy --host=<adapter>` or `uniweb export`,
+  // and both need a concrete URL, which the site declares: the runtime accepts
+  // any URL, from any host.
+  //
+  // Until 2026-08-04 this returned `{base}/foundations/{ns}/{name}/{ver}/foundation.js`
+  // against a hardcoded host, overridable only through an env var that did not
+  // match the documented backend selection — so `--backend`, `uniweb login
+  // --backend` and the documented env var all left it pinned — and the artifact
+  // names were the pre-`entry.js` ones the build stopped emitting.
   const orgScopedMatch = /^@([a-z0-9_-]+)\/([a-z0-9_-]+)@(.+)$/.exec(name)
   if (orgScopedMatch) {
-    const base = process.env.UNIWEB_REGISTRY_URL || 'https://site-router.uniweb-edge.workers.dev'
-    const [, ns, fn, ver] = orgScopedMatch
-    return {
-      type: 'url',
-      url: `${base}/foundations/${ns}/${fn}/${ver}/foundation.js`,
-      cssUrl: `${base}/foundations/${ns}/${fn}/${ver}/assets/foundation.css`
-    }
+    throw new Error(
+      [
+        `Foundation "${name}" is a catalog ref, and a build cannot resolve it to a URL.`,
+        `Where a foundation is served is the host's to declare, so the build does not guess it.`,
+        ``,
+        `  • Deploying to another host (\`uniweb deploy --host=<adapter>\`), or taking`,
+        `    the build anywhere (\`uniweb export\`)? Declare the served URL in site.yml —`,
+        `    the runtime accepts any URL, from any host:`,
+        ``,
+        `      foundation: https://<host>/<path>/entry.js`,
+        ``,
+        `    or the object form when the stylesheet sits elsewhere:`,
+        ``,
+        `      foundation: { url: 'https://…/entry.js', cssUrl: 'https://…/assets/style.css' }`,
+        ``,
+        `  • Iterating locally?`,
+        `    Reference the workspace foundation by package name.`,
+        ``,
+        `  • Targeting the Uniweb platform?`,
+        `    \`uniweb publish\` has the platform resolve the ref — no build-time URL needed.`
+      ].join('\n')
+    )
   }
 
   // Versionless scoped names (`@org/name`) are valid as *handles* — they
@@ -290,15 +318,14 @@ export async function defineSiteConfig(options = {}) {
   // Read site.yml
   const siteConfig = readSiteConfig(siteRoot)
 
-  // Allow callers to override `foundation:` without modifying site.yml on
-  // disk. Used by `uniweb deploy` to substitute a workspace-local file: ref
-  // with the resolved registry ref (`@ns/name@ver`) for the duration of the
-  // deploy build, so the site builds in runtime/link mode against the just-
-  // published artifact instead of bundling the local source.
-  const foundationOverride = process.env.UNIWEB_FOUNDATION_REF
-  if (foundationOverride) {
-    siteConfig.foundation = foundationOverride
-  }
+  // `site.yml` is the only place a site's foundation is declared. A
+  // `UNIWEB_FOUNDATION_REF` env override lived here until 2026-08-04, silently
+  // substituting a different foundation for the duration of a build. It served
+  // the `uniweb deploy` auto-publish flow, which was removed; after that no
+  // command set it, so what remained was an invisible way for a site to be
+  // rendered by code its own config did not name. Removed rather than kept as a
+  // manual escape hatch — which foundation renders a site is exactly the thing
+  // that should never be true-but-unstated.
 
   // Determine base path for deployment (priority: option > env > site.yml)
   // Normalize: ensure leading slash, collapse repeated slashes, add trailing slash for Vite

package/src/uwx/data-schema.js

@@ -29,6 +29,14 @@ const TEXT_KINDS = new Set(['string', 'text'])
 // carrying one round-trips as the RAW source string (no ProseMirror conversion).
 const CONTENT_TEXT_FORMATS = new Set(['markdown', 'html'])
 
+// The field an open map's key lowers into. `name` matches the idiom already in use
+// for this shape (the backend's site-content `collections` section), so an open map
+// and a hand-authored row set produce the same wire shape rather than two spellings
+// of one thing. Not configurable on purpose: a second way to spell it would be a
+// vocabulary addition for a collision that does not exist yet — a value schema that
+// declares its own `name` is an error instead, which names the problem precisely.
+const OPEN_MAP_KEY = 'name'
+
 /**
  * A `text` field marked as rich content (`format: markdown` or `html`): the
  * file-based body target. Round-trips as the raw source string — what the retired
@@ -119,7 +127,7 @@ function lowerSectionsForm(sectionsMap, resolve, optResolve) {
   let explicit = null
   let firstSingle = null
   for (const [secName, def] of Object.entries(sectionsMap)) {
-    sections[secName] = lowerSection(def, resolve, optResolve)
+    sections[secName] = lowerSection(def, resolve, optResolve, secName)
     if (def.brief === true) explicit = secName
     if (!firstSingle && (def.kind || 'single') === 'single') firstSingle = secName
   }
@@ -138,7 +146,7 @@ function lowerSectionsForm(sectionsMap, resolve, optResolve) {
 // are type: section"); `nestable` → `self_nesting`; `append_only` (insert-only
 // records) passes through; authored cross-cutting `constraints` pass through as a
 // bare array. Leaves and nested sections share one ordered `fields:` namespace.
-function lowerSection(def, resolve, optResolve) {
+function lowerSection(def, resolve, optResolve, path = '') {
   const out = {}
   if ((def.kind || 'single') === 'multi') out.multiple = true
   if (def.brief === true) out.brief = true
@@ -147,14 +155,29 @@ function lowerSection(def, resolve, optResolve) {
 
   const fields = {}
   for (const [key, rawField] of Object.entries(def.fields || {})) {
-    fields[key] = lowerField(rawField, resolve, optResolve)
+    fields[key] = lowerField(rawField, resolve, optResolve, path ? `${path}/${key}` : key)
   }
   // Explicit child sections (sections-form, e.g. under a binder) → `type: section`
   // fields, in the same ordered namespace as the leaves.
   for (const [childName, childDef] of Object.entries(def.sections || {})) {
-    fields[childName] = { type: 'section', ...lowerSection(childDef, resolve, optResolve) }
+    const childPath = path ? `${path}/${childName}` : childName
+    fields[childName] = {
+      type: 'section',
+      ...lowerSection(childDef, resolve, optResolve, childPath)
+    }
   }
-  if (Object.keys(fields).length) out.fields = fields
+  // A section with neither leaves nor sub-sections carries nothing, and is not a
+  // valid section on this wire by either party's reckoning. Refusing here fails at
+  // the schema author's screen; emitting it fails in a consumer's restore, which is
+  // the last possible moment and the wrong screen (2026-08-04: `@std/form` shipped
+  // exactly this, because `values:` had no lowering and silently produced no fields).
+  if (!Object.keys(fields).length) {
+    throw new Error(
+      `Data schema: section '${path || '(root)'}' declares no fields and no sub-sections. ` +
+        `A section must carry at least one leaf or child section.`
+    )
+  }
+  out.fields = fields
   if (Array.isArray(def.constraints) && def.constraints.length) out.constraints = def.constraints
   return out
 }
@@ -166,17 +189,69 @@ function lowerSection(def, resolve, optResolve) {
 //   array of ref      → entity_ref + multiple
 //   array of scalar   → the scalar kind + multiple
 //   ref               → entity_ref (model by name)
-function lowerField(rawField, resolve, optResolve) {
+function lowerField(rawField, resolve, optResolve, path = '') {
   const field = asField(rawField)
   const type = field.type
 
   if (type === 'object') {
-    return { type: 'section', ...lowerSection({ kind: 'single', fields: field.fields }, resolve, optResolve) }
+    // An OPEN MAP (`values:`) is ROWS, not a singleton. Its keys belong to the
+    // author, which makes them data — so the map lowers to a `multi` section whose
+    // key field carries what was the object key, with a section-scoped uniqueness
+    // rule making that key the row's identity. This is the same shape `array of
+    // object` already lowers to, and the idiom the backend's own site-content
+    // `collections` section uses; no new wire construct is involved.
+    //
+    // Identity is the KEY, never row position — a round-trip that rebuilds the map
+    // from order looks correct and drifts the first time rows are reordered.
+    // Authoring order is still preserved into row order, because for a form the
+    // field order is what the visitor sees.
+    if (field.values !== undefined) {
+      const value = asField(field.values)
+      if (value.type !== 'object' || !value.fields) {
+        throw new Error(
+          `Data schema: open map at '${path}' declares 'values' that is not an object with ` +
+            `'fields'. An open map lowers to rows, and a row needs declared columns.`
+        )
+      }
+      if (value.fields[OPEN_MAP_KEY]) {
+        throw new Error(
+          `Data schema: open map at '${path}' has a value field named '${OPEN_MAP_KEY}', which ` +
+            `is the field the map's key lowers into. Rename that field.`
+        )
+      }
+      return {
+        type: 'section',
+        ...lowerSection(
+          {
+            kind: 'multi',
+            // `translatable: false` is load-bearing, not tidiness: a string field is
+            // localized by default, and a localized key could differ per locale —
+            // which would destroy the identity the key exists to carry. The key is an
+            // identifier, never content.
+            fields: {
+              [OPEN_MAP_KEY]: { type: 'string', required: true, translatable: false },
+              ...value.fields
+            },
+            constraints: [{ kind: 'unique_field', field: OPEN_MAP_KEY, scope: 'section' }]
+          },
+          resolve,
+          optResolve,
+          path
+        )
+      }
+    }
+    return {
+      type: 'section',
+      ...lowerSection({ kind: 'single', fields: field.fields }, resolve, optResolve, path)
+    }
   }
   if (type === 'array') {
     const items = field.items ? asField(field.items) : null
     if (items && items.type === 'object') {
-      return { type: 'section', ...lowerSection({ kind: 'multi', fields: items.fields }, resolve, optResolve) }
+      return {
+        type: 'section',
+        ...lowerSection({ kind: 'multi', fields: items.fields }, resolve, optResolve, path)
+      }
     }
     if (items && items.type === 'ref') {
       // Multi-valued reference — the per-field `multiple` flag (the `array` Kind

package/src/vite-foundation-plugin.js

@@ -466,6 +466,22 @@ async function buildEntrySSR(foundationRoot, entrySourcePath, outDir) {
   }
 }
 
+/**
+ * Marks a foundation build as a DEV-server rebuild.
+ *
+ * The dev server runs a real Vite `build()` of the foundation on every watched
+ * change (`dev/plugin.js`), so `command`, `mode` and `isProduction` cannot tell
+ * a dev rebuild from a shipping build — all of them say "build". An injected
+ * marker plugin can, and it survives the foundation's own `vite.config.js`
+ * being merged in, which a plugin *option* would not (the dev server does not
+ * construct the foundation plugin — the foundation's config file does).
+ *
+ * Used to skip the `entry-ssr.js` sub-build in dev: it is a second full Vite
+ * pass per save, and nothing in the dev loop reads it (dev never ships, and the
+ * SSR lanes that run locally — SSG prerender and unipress — load `entry.js`).
+ */
+export const DEV_REBUILD_MARKER = 'uniweb:dev-foundation-rebuild'
+
 /**
  * Vite plugin for foundation builds
  */
@@ -481,6 +497,7 @@ export function foundationBuildPlugin(options = {}) {
   let resolvedOutDir
   let resolvedRoot
   let isProduction
+  let isDevRebuild = false
 
   return {
     name: 'uniweb-foundation-build',
@@ -500,6 +517,7 @@ export function foundationBuildPlugin(options = {}) {
       resolvedOutDir = config.build.outDir
       resolvedRoot = config.root
       isProduction = config.mode === 'production'
+      isDevRebuild = (config.plugins || []).some((p) => p?.name === DEV_REBUILD_MARKER)
     },
 
     async writeBundle() {
@@ -554,8 +572,20 @@ export function foundationBuildPlugin(options = {}) {
       //
       // (The legacy self-contained buildSSRBundle() — React + runtime INLINED,
       // ~14 MB with Shiki — is retained below, unused, for reference only.)
-      const entrySourcePath = join(resolvedSrcDir, entryFileName)
-      await buildEntrySSR(resolvedRoot, entrySourcePath, outDir)
+      // Skipped on a DEV rebuild: this is a second full Vite pass, it runs on
+      // every save, and nothing in the dev loop reads its output. The local SSR
+      // lanes load `entry.js` (SSG prerender via `import()`, unipress the same);
+      // only the edge isolate needs the single-file twin, and dev ships nothing
+      // to it.
+      //
+      // Shipping lanes are unaffected — `uniweb build`, and `register`/`publish`
+      // which build through it. `register`'s build-if-stale check also requires
+      // `entry-ssr.js`, so a dist left behind by a dev session is treated as
+      // stale and rebuilt rather than uploaded without one.
+      if (!isDevRebuild) {
+        const entrySourcePath = join(resolvedSrcDir, entryFileName)
+        await buildEntrySSR(resolvedRoot, entrySourcePath, outDir)
+      }
     },
 
     async closeBundle() {