uniweb 0.12.8 → 0.12.10

package/README.md

@@ -310,14 +310,22 @@ Start with local files deployed anywhere. The same foundation works across all t
 
 ## Deployment
 
-A Uniweb project produces two artifacts — a **site** (content) and a **foundation** (code) — and they don't have to ship together. That opens up deployment options other frameworks can't express:
+A Uniweb project produces two artifacts — a **site** (content) and a **foundation** (code) — and they don't have to ship together. Two top-level modes:
 
-- **Bundled mode** — site and foundation built into one self-contained `dist/`, deployed to any static host.
-- **Linked mode** — the foundation lives in any host and the site in any other host; different sites can dynamically link with the same foundation. Update the foundation, every site picks it up — no site rebuilds.
+- **Standalone mode** — site and foundation built into one self-contained `dist/`, deployed to any static host.
+- **Linked mode** — the foundation is a separate file the site loads at runtime, with two flavours:
+  - **Site-bound** — the foundation belongs to one site and rides with it (`foundation: ~self/<name>@<version>` in `site.yml`).
+  - **Cataloged** — the foundation is a catalog product, published once and licensed to consuming sites (`foundation: '@<org>/<name>@<version>'`).
 
-Two verbs handle it: `uniweb publish` sends a foundation to a registry, `uniweb deploy` sends a site to a host. Most projects start bundled (one command, one destination) and grow into linked mode by changing one line in `site.yml`. Mix providers freely — foundation on GitHub Pages, site on Vercel; or use Uniweb's registry + hosting for propagation, gated rollouts, and edge SSR.
+`uniweb publish` ships a cataloged foundation; `uniweb deploy` ships a site (and, for site-bound, the foundation along with it). Most projects start standalone or site-bound and grow into cataloged when a foundation needs to serve more than one site.
 
-→ **[Deploying](https://github.com/uniweb/docs/blob/main/development/deploying.md)** — the full menu: bundled vs linked, the two-verb model, one-foundation-many-sites, optimized hosting on the Uniweb platform, and recipes for other hosting services.
+Where can you deploy?
+
+- **Free static hosts** — Vercel, Cloudflare Pages, Netlify, GitHub Pages — work great when you have a site to publish. Built-in adapters: `vercel`, `cloudflare-pages`, `netlify`, `github-pages`. Lifecycle is Git-driven: connect your repo, the host runs `uniweb build` on each push, serves `dist/`. The framework auto-detects the CI host and emits the right helper files.
+- **AWS S3 + CloudFront** — `uniweb deploy --host=s3-cloudfront` builds, syncs, and invalidates in one command.
+- **Uniweb hosting** — paid (starts at $14/month per site). Always serves linked sites with JIT prerender, edge SSR, locale-aware routing, foundation/runtime version propagation, and the multi-tenant CMS for non-technical content authors via the visual editor. The right choice when foundation developers or agencies build for clients who manage their own content. The catalog is private and access-segregated — foundations are commercial products licensed by site, not packages on a public registry.
+
+→ **[Deploying](https://github.com/uniweb/docs/blob/main/development/deploying.md)** — the full menu: picking a deploy path (free vs paid), standalone vs linked, site-bound vs cataloged, the two-verb model, CI-detection, and per-host recipes.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.12.8",
+  "version": "0.12.10",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -41,14 +41,14 @@
     "js-yaml": "^4.1.0",
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
-    "@uniweb/core": "0.7.10",
-    "@uniweb/kit": "0.9.10",
-    "@uniweb/runtime": "0.8.11"
+    "@uniweb/runtime": "0.8.13",
+    "@uniweb/kit": "0.9.11",
+    "@uniweb/core": "0.7.11"
   },
   "peerDependencies": {
-    "@uniweb/build": "0.13.5",
-    "@uniweb/content-reader": "1.1.10",
-    "@uniweb/semantic-parser": "1.1.17"
+    "@uniweb/build": "0.14.2",
+    "@uniweb/semantic-parser": "1.1.17",
+    "@uniweb/content-reader": "1.1.10"
   },
   "peerDependenciesMeta": {
     "@uniweb/build": {

package/partials/agents.md

@@ -172,7 +172,7 @@ The `uniweb` block in `package.json` carries platform-specific configuration tha
 **Catalog vs site-bound foundations.** Two distribution intents share the same `dist/foundation.js` artifact:
 
 - A **catalog foundation** is a deliberate product — named, versioned, listed in the catalog, consumable by other developers' sites. Use `uniweb publish @org/name` for these. The CLI requires an explicit name argument so you don't accidentally catalog a foundation that was meant to be site-bound.
-- A **site-bound foundation** powers exactly one site. Don't run `uniweb publish` for it. Just run `uniweb deploy` from the site directory — the CLI auto-publishes your local foundation as part of the deploy, under a registry slot scoped to the site itself, with no naming ceremony. The foundation isn't visible in the catalog and isn't owned by the developer who happened to run the deploy.
+- A **site-bound foundation** powers exactly one site. Don't run `uniweb publish` for it. Just run `uniweb deploy` from the site directory — the CLI auto-publishes your local foundation as part of the deploy, **uploaded with the site's other published assets** (per-site storage, never to the catalog). With no naming ceremony, no catalog visibility, and no developer-vs-site ownership confusion. To later promote the foundation to a catalog product, run `uniweb publish @org/name` from the foundation directory and update the site's `site.yml` to a versioned ref (`foundation: '@org/name@1.2.3'`).
 
 **On the split between `package.json::name` and `uniweb.id`:** the workspace name is what pnpm uses for `file:` linking and what `site.yml::foundation` references. The published id is what the registry stores. Keeping them separate means renaming on the registry (e.g. `marketing` → `marketing-pro`) is a one-shot `uniweb publish --name marketing-pro` — it persists to `uniweb.id` without touching the workspace.
 

package/src/commands/build.js

@@ -35,6 +35,10 @@
  *   uniweb build --target site       # Explicitly build as site
  *   uniweb build --prerender         # Force pre-rendering
  *   uniweb build --no-prerender      # Skip pre-rendering
+ *   uniweb build --host <name>       # Pick the host adapter for this build's
+ *                                      postBuild step (e.g. cloudflare-pages,
+ *                                      s3-cloudfront, github-pages,
+ *                                      generic-static). Default: cloudflare-pages.
  *
  * Internal flags (called by `uniweb deploy` / `uniweb export`):
  *   --link              # Data-only pipeline (Uniweb-edge)
@@ -540,7 +544,7 @@ async function resolveFoundationDirForSite(siteDir, siteConfig) {
  * Build a site
  */
 async function buildSite(projectDir, options = {}) {
-  const { prerender = false, foundationDir, siteConfig = null } = options
+  const { prerender = false, foundationDir, siteConfig = null, host = null } = options
 
   info('Building site...')
 
@@ -613,6 +617,7 @@ async function buildSite(projectDir, options = {}) {
 
       const result = await prerenderSite(projectDir, {
         foundationDir: foundationDir || resolveFoundationDir(projectDir, siteConfig),
+        host,
         onProgress: (msg) => log(`  ${colors.dim}${msg}${colors.reset}`)
       })
 
@@ -710,7 +715,7 @@ async function discoverWorkspacePackages(workspaceDir) {
  * Build all packages in a workspace
  */
 async function buildWorkspace(workspaceDir, options = {}) {
-  const { prerenderFlag, noPrerenderFlag } = options
+  const { prerenderFlag, noPrerenderFlag, host = null } = options
 
   log(`${colors.cyan}${colors.bright}Building workspace...${colors.reset}`)
   log('')
@@ -757,7 +762,7 @@ async function buildWorkspace(workspaceDir, options = {}) {
     // Resolve foundation directory for this site
     const foundationDir = resolveFoundationDir(site.path, siteConfig)
 
-    await buildSite(site.path, { prerender, foundationDir, siteConfig })
+    await buildSite(site.path, { prerender, foundationDir, siteConfig, host })
     log('')
   }
 
@@ -835,6 +840,27 @@ export async function build(args = []) {
     foundationDir = resolve(args[foundationDirIndex + 1])
   }
 
+  // --host names the host adapter for this build's prerender step.
+  // Default = 'cloudflare-pages' (resolved inside prerender.js, via the
+  // registry). Build does not read deploy.yml; that is the deploy
+  // orchestrator's job. See kb/framework/plans/static-host-deploy-adapters.md.
+  //
+  // `--host` with no value → interactive picker (errors in CI / non-TTY).
+  const { readFlagValue } = await import('../utils/args.js')
+  const hostFlag = readFlagValue(args, '--host')
+  let host = null
+  if (hostFlag === null) {
+    const { promptForHost } = await import('../utils/host-prompt.js')
+    try {
+      host = await promptForHost({ args })
+    } catch (err) {
+      error(err.message)
+      process.exit(1)
+    }
+  } else if (typeof hostFlag === 'string') {
+    host = hostFlag
+  }
+
   // Auto-detect project type if not specified
   if (!targetType) {
     targetType = detectProjectType(projectDir)
@@ -868,7 +894,7 @@ export async function build(args = []) {
   // Run appropriate build
   try {
     if (targetType === 'workspace') {
-      await buildWorkspace(projectDir, { prerenderFlag, noPrerenderFlag })
+      await buildWorkspace(projectDir, { prerenderFlag, noPrerenderFlag, host })
     } else if (targetType === 'foundation') {
       await buildFoundation(projectDir)
     } else {
@@ -898,7 +924,7 @@ export async function build(args = []) {
       if (prerenderFlag) prerender = true
       if (noPrerenderFlag) prerender = false
 
-      await buildSite(projectDir, { prerender, foundationDir, siteConfig })
+      await buildSite(projectDir, { prerender, foundationDir, siteConfig, host })
     }
   } catch (err) {
     error(err.message)

package/src/commands/deploy.js

@@ -1,13 +1,23 @@
 /**
  * Deploy Command
  *
- * Deploys a site to uniweb-edge. Always runtime-linked: the edge serves a
- * runtime template + per-site base.html, with the foundation loaded by URL.
- * For static-host artifacts (no upload), see `uniweb export`.
+ * Deploys a site. Host is determined by the resolved deploy.yml target
+ * (or `--target <name>` / `--host <name>` flags). The default is `uniweb`:
  *
- * Flow:
+ *   - `uniweb` (default): Uniweb hosting — link-mode + edge JIT prerender.
+ *     Foundation loaded by URL from the registry. Requires `uniweb login`
+ *     and a `foundation:` declaration in site.yml.
+ *
+ *   - Static-host adapters (`s3-cloudfront`, `cloudflare-pages`,
+ *     `github-pages`, `generic-static`, …): build dist/ in bundle-mode
+ *     and hand it to a host adapter for upload + invalidation. No login,
+ *     no edge. See kb/framework/plans/static-host-deploy-adapters.md.
+ *
+ * For static-host artifacts WITHOUT upload, see `uniweb export`.
+ *
+ * Default-flow steps:
  *   1. Read site.yml → { site.id?, site.handle?, foundation, runtime? }.
- *   2. Resolve runtime (default: GET /api/runtime/latest from the Worker).
+ *   2. Resolve runtime (default: GET /runtime/latest from the Worker).
  *   3. ensureAuth() → bearer CLI JWT from ~/.uniweb/auth.json.
  *   4. Build `dist/` if missing.
  *   5. Load dist/site-content.json → extract `languages` for the capability
@@ -19,9 +29,9 @@
  *        - publishToken returned → fast path.
  *        - needsReview:true + reviewUrl → open browser, wait for callback,
  *          consume { publishToken, siteId, handle }.
- *   9. POST Worker /api/publish/validate to confirm foundation + runtime
+ *   9. POST Worker /publish/check to confirm foundation + runtime
  *      exist and the token's namespace claim matches.
- *  10. POST Worker /api/publish/process with the full payload.
+ *  10. POST Worker /publish with the full payload.
  *  11. On first-deploy create flow: write site.id + site.handle back into
  *      site.yml so subsequent deploys fast-path.
  *
@@ -29,6 +39,10 @@
  *   uniweb deploy                          Normal deploy (browser may open on first deploy)
  *   uniweb deploy --dry-run                Resolve everything but skip the Worker POST
  *   uniweb deploy --no-auto-publish        Don't auto-publish workspace-local foundation
+ *   uniweb deploy --target <name>          Pick a target from deploy.yml (default: deploy.yml's `default:`)
+ *   uniweb deploy --host <name>            Override the resolved target's host adapter
+ *                                          (does not write to deploy.yml on success)
+ *   uniweb deploy --no-save                Skip the auto-save of lastDeploy in deploy.yml
  *
  * Internal escape hatches (UNIWEB_* env vars — see framework/cli/docs/env-vars.md):
  *   UNIWEB_SKIP_BUILD=1                    Reuse existing dist/ instead of rebuilding
@@ -48,6 +62,9 @@ import { execSync } from 'node:child_process'
 import yaml from 'js-yaml'
 
 import { detectFoundationType } from '@uniweb/build'
+import { loadDeployYml, resolveTarget, recordLastDeploy } from '@uniweb/build/site'
+import { promptForHost } from '../utils/host-prompt.js'
+import { readFlagValue } from '../utils/args.js'
 
 import { ensureAuth, readAuth, decodeJwtPayload } from '../utils/auth.js'
 import { getBackendUrl, getRegistryUrl } from '../utils/config.js'
@@ -65,6 +82,7 @@ function splitRegistryRef(ref) {
   const m = /^(@[^/]+\/[^@]+|~[^/]+\/[^@]+|[^@]+)@(.+)$/.exec(ref)
   return m ? { name: m[1], version: m[2] } : null
 }
+
 import {
   findWorkspaceRoot,
   findSites,
@@ -404,6 +422,63 @@ export async function deploy(args = []) {
   // site.id / site.handle from prior deploys.
   const siteYmlPath = join(siteDir, 'site.yml')
   const siteYml = await readSiteYml(siteYmlPath)
+
+  // Host dispatch.
+  //
+  // Resolution order:
+  //   1. --target <name> picks a target from deploy.yml (full config:
+  //      host + adapter-specific fields)
+  //   2. deploy.yml's `default:` target is used when no flag is given
+  //   3. With no deploy.yml at all, the implicit default is host: 'uniweb'
+  //   4. --host <name> is a one-off override of the resolved target's host
+  //      and does NOT persist on success (see saveDeployTarget below).
+  //
+  // The default flow (`uniweb`) requires a `foundation:` declaration;
+  // static-host deploys don't, so this branch comes BEFORE the foundation
+  // check. See kb/framework/plans/static-host-deploy-adapters.md.
+  const targetFromFlag = readFlagValue(args, '--target')
+  let hostFromFlag = readFlagValue(args, '--host')
+  const noSave = args.includes('--no-save')
+
+  let deployYml
+  try {
+    deployYml = await loadDeployYml(siteDir)
+  } catch (err) {
+    say.err(err.message)
+    process.exit(1)
+  }
+  let resolved
+  try {
+    resolved = resolveTarget(deployYml, targetFromFlag || null)
+  } catch (err) {
+    say.err(err.message)
+    process.exit(1)
+  }
+  // --host with no value → interactive picker. Pre-selects the resolved
+  // target's host so Enter does the obvious thing.
+  if (hostFromFlag === null) {
+    try {
+      hostFromFlag = await promptForHost({ args, preselect: resolved.host })
+    } catch (err) {
+      say.err(err.message)
+      process.exit(1)
+    }
+  }
+  const host = hostFromFlag || resolved.host
+  const hostOverridden = !!hostFromFlag && hostFromFlag !== resolved.host
+  // Auto-save scope: 'off' from --no-save OR an ad-hoc --host override
+  // (we don't want a one-off experiment to rewrite the file).
+  const autoSave = noSave || hostOverridden ? 'off' : resolved.autoSave
+
+  if (host !== 'uniweb') {
+    await deployStaticHost(siteDir, host, resolved, {
+      dryRun,
+      autoSave,
+      hostOverridden,
+    })
+    return
+  }
+
   if (!siteYml.foundation) {
     say.err('site.yml is missing `foundation`.')
     say.dim('Add a line like:  foundation: \'@uniweb/docs-foundation@0.1.20\'')
@@ -512,7 +587,7 @@ export async function deploy(args = []) {
   if (!runtimeVersion) {
     runtimeVersion = await fetchLatestRuntime(workerUrl)
     if (!runtimeVersion) {
-      say.err('Could not resolve a runtime version (no runtime: in site.yml, /api/runtime/latest failed).')
+      say.err('Could not resolve a runtime version (no runtime: in site.yml, /runtime/latest failed).')
       process.exit(1)
     }
     say.dim(`Runtime: ${runtimeVersion} (latest; pin via \`runtime:\` in site.yml)`)
@@ -542,11 +617,12 @@ export async function deploy(args = []) {
     // serving edge, not here). Always --link: the edge serves a runtime
     // template + per-site base.html, never a self-contained vite bundle.
     //
-    // For workspace-local foundations (Phase 2 resolution above),
-    // UNIWEB_FOUNDATION_REF tells defineSiteConfig to use the resolved
-    // registry ref instead of site.yml's literal value. Link mode doesn't
-    // run vite at all, so the env var is harmless but passed through for
-    // consistency with future work.
+    // Phase 4d: workspace-local foundations carry the `~self/{name}@{ver}`
+    // placeholder at this point; the canonical `~{siteId}/...` ref isn't
+    // known until authorize returns. Link mode doesn't run vite or fetch
+    // the foundation, so site-content.json's foundation field reflects
+    // whatever's in site.yml — that's fine because the publish payload
+    // overrides it with the canonical form post-authorize.
     //
     // Spawn the SAME CLI binary that's currently running rather than
     // `npx uniweb build` — npx walks node_modules and would resolve to
@@ -556,9 +632,7 @@ export async function deploy(args = []) {
     execSync(`node ${JSON.stringify(process.argv[1])} build --link`, {
       cwd: siteDir,
       stdio: 'inherit',
-      env: foundationBuildOverride
-        ? { ...process.env, UNIWEB_FOUNDATION_REF: foundationBuildOverride }
-        : process.env,
+      env: process.env,
     })
     console.log('')
   } else if (!existsSync(contentPath)) {
@@ -693,9 +767,16 @@ export async function deploy(args = []) {
       // CLI can write `features:` back into site.yml accurately. Older
       // PHP that doesn't include this field is a no-op.
       mintedFeatures = Array.isArray(cb.features) ? cb.features : null
+      // Phase 4d: workspace-local foundation deploys on the create flow
+      // need the rewritten `~{siteId}/{name}@{ver}` ref + upload endpoint.
+      // PHP/unicloud put them in the finalize response; the web app
+      // forwards them to the loopback. Catalog-ref deploys leave them
+      // undefined and we fall back to the placeholder/derived URL below.
+      if (cb.foundationRef) foundation = cb.foundationRef
+      if (cb.foundationUploadUrl) foundationUploadUrl = cb.foundationUploadUrl
       // Review path: Worker URLs are implicit (we derive them from config).
-      publishUrl = `${workerUrl}/api/publish/process`
-      validateUrl = `${workerUrl}/api/publish/validate`
+      publishUrl = `${workerUrl}/publish`
+      validateUrl = `${workerUrl}/publish/check`
     } else {
       publishToken = authRes.publishToken
       siteIdResolved = authRes.siteId
@@ -731,7 +812,7 @@ export async function deploy(args = []) {
   // Phase 4d: upload site-bound foundation files directly. Replaces the
   // pre-Phase-4d `execSync('uniweb publish')` flow — we now know the
   // canonical `~{siteId}/{name}@{ver}` ref from authorize, and the worker's
-  // /api/foundations endpoint accepts the publish token's siteId claim
+  // /foundations endpoint accepts the publish token's siteId claim
   // for this scope.
   if (localFoundation) {
     say.info(`Building foundation at ${localFoundation.relPath}…`)
@@ -749,7 +830,7 @@ export async function deploy(args = []) {
 
     say.info(`Uploading foundation as ${foundation}…`)
     const foundationFiles = await collectFoundationDistFiles(join(localFoundation.path, 'dist'))
-    const foundationPublishUrl = foundationUploadUrl || `${workerUrl}/api/foundations`
+    const foundationPublishUrl = foundationUploadUrl || `${workerUrl}/foundations`
     const { gitSha: fGitSha, gitDirty: fGitDirty } = readGitState(localFoundation.path)
     await callFoundationUpload({
       url: foundationPublishUrl,
@@ -784,36 +865,60 @@ export async function deploy(args = []) {
     process.exit(1)
   }
 
-  // Asset pipeline — upload dist/assets/* + favicon + fonts to S3, then
-  // rewrite each locale's siteContent so semantic-parser resolves CDN URLs
-  // at render time. Assets themselves are locale-shared (they live in
-  // dist/assets/ regardless of language), so the diff/upload runs once
-  // and the rewrite walks every locale's content tree in localeContents.
+  // Collect compiled collection JSON files from dist/data/. The framework
+  // emits these for `collection:` data sources — `<name>.json` cascade
+  // payloads plus per-record `<name>/<slug>.json` files when `deferred:` is
+  // declared. Editor publish has no equivalent (collections live in the DB);
+  // CLI sites need them shipped as static R2 objects.
+  //
+  // Read BEFORE the asset pipeline so the asset scan can pick up image
+  // refs in collection JSON (e.g. `article.image: "/covers/foo.svg"`)
+  // and the rewrite can swap them for CDN URLs alongside locale content.
+  const dataFiles = await collectDataFiles(distDir)
+  // Decode each data file as JSON so the asset scan can walk the tree;
+  // mutated in place by the rewrite step. Re-stringified before publish.
+  const dataFileObjects = {}
+  for (const [k, raw] of Object.entries(dataFiles)) {
+    try {
+      dataFileObjects[k] = JSON.parse(raw)
+    } catch {
+      dataFileObjects[k] = null // unparseable — skip rewrite, ship as-is
+    }
+  }
+  if (Object.keys(dataFiles).length > 0) {
+    say.dim(`Data files     : ${Object.keys(dataFiles).length} (collection JSON)`)
+  }
+
+  // Asset pipeline — upload dist/assets/* + favicon + fonts + content-scan
+  // hits (public/, data file refs) to S3, then rewrite each locale's
+  // siteContent + each parsed data file so the runtime resolves CDN URLs at
+  // render time. Assets are locale-shared (they live in dist/assets/ +
+  // public/ regardless of language); diff/upload runs once and the rewrite
+  // walks every locale's content tree + every data-file JSON tree.
   // Skipped with --skip-assets.
   if (!skipAssets) {
     await uploadAssetsAndRewriteContent({
       siteDir,
       localeContents,
+      dataFileObjects,
       siteYml,
       theme,
       backendUrl,
       cliToken,
       siteId: siteIdResolved,
     })
+    // Re-stringify any data-file JSON that the rewrite step mutated, so the
+    // publish payload below sees the rewritten URLs. Untouched files round-
+    // trip identically.
+    for (const k of Object.keys(dataFiles)) {
+      if (dataFileObjects[k] !== null) {
+        dataFiles[k] = JSON.stringify(dataFileObjects[k])
+      }
+    }
   } else {
     say.dim('Skipping asset upload (--skip-assets).')
   }
 
-  // Collect compiled collection JSON files from dist/data/. The framework
-  // emits these for `collection:` data sources — `<name>.json` cascade
-  // payloads plus per-record `<name>/<slug>.json` files when `deferred:` is
-  // declared. Editor publish has no equivalent (collections live in the DB);
-  // CLI sites need them shipped as static R2 objects.
-  const dataFiles = await collectDataFiles(distDir)
-  if (Object.keys(dataFiles).length > 0) {
-    say.dim(`Data files     : ${Object.keys(dataFiles).length} (collection JSON)`)
-  }
-
   say.info('Publishing…')
   const publishPayload = {
     foundation,
@@ -886,6 +991,162 @@ export async function deploy(args = []) {
   if (handleResolved) {
     console.log(`  ${c.cyan}https://${handleResolved}.uniweb.website/${c.reset}`)
   }
+
+  // Record a fresh lastDeploy.<target> entry. Skipped on --no-save (and
+  // on --host overrides, but uniweb-host can't be reached via override
+  // since the override branches into deployStaticHost above).
+  await persistLastDeploy(siteDir, {
+    targetName: resolved.targetName,
+    targetConfig: resolved.fromFile ? null : { host: 'uniweb' },
+    autoSave,
+    lastDeploy: {
+      at: deployReceipt.deployedAt,
+      host: 'uniweb',
+      url: deployReceipt.url,
+      siteId: siteIdResolved,
+      handle: handleResolved,
+      foundation: {
+        shape: 'linked',
+        ref: foundationRef,
+      },
+      runtime: runtimeVersion,
+    },
+  })
+}
+
+// ─── Static-host deploy (S3+CloudFront, etc.) ─────────────────
+//
+// Distinct from the uniweb-edge flow above. Picked when the resolved
+// deploy.yml target (or --host override) names a static-host adapter
+// registered in @uniweb/build/hosts. Always runs `uniweb build` (bundle
+// mode + prerender) first, then hands dist/ to the adapter's deploy hook
+// for upload + invalidation.
+//
+// See kb/framework/plans/static-host-deploy-adapters.md.
+
+async function deployStaticHost(siteDir, hostName, resolved, { dryRun, autoSave, hostOverridden }) {
+  let getAdapter
+  try {
+    ({ getAdapter } = await import('@uniweb/build/hosts'))
+  } catch (err) {
+    say.err('Failed to load host adapter registry from @uniweb/build/hosts.')
+    say.dim(err.message)
+    process.exit(1)
+  }
+
+  let adapter
+  try {
+    adapter = getAdapter(hostName)
+  } catch (err) {
+    say.err(err.message)
+    say.dim('Set the host in deploy.yml or pass --host=<name>. See `uniweb deploy --help`.')
+    process.exit(1)
+  }
+
+  if (typeof adapter.deploy !== 'function') {
+    say.err(`Host adapter '${hostName}' does not implement a deploy step.`)
+    say.dim(`Build with \`uniweb build --host=${hostName}\` and upload \`dist/\` manually,`)
+    say.dim(`or use a host whose adapter ships a deploy hook (e.g., s3-cloudfront).`)
+    process.exit(1)
+  }
+
+  const deployConfig = resolved.config || {}
+  const distDir = join(siteDir, 'dist')
+
+  if (dryRun) {
+    say.info(`Dry run — would deploy via host adapter: ${c.bold}${adapter.name}${c.reset}`)
+    say.dim(`Site dir       : ${siteDir}`)
+    say.dim(`dist/          : ${existsSync(distDir) ? 'exists (would not rebuild)' : 'missing (would build)'}`)
+    say.dim(`Target         : ${resolved.targetName}`)
+    say.dim(`bucket         : ${deployConfig.bucket || '(unset)'}`)
+    say.dim(`distributionId : ${deployConfig.distributionId || '(unset)'}`)
+    say.dim(`region         : ${deployConfig.region || '(unset)'}`)
+    say.dim(`profile        : ${deployConfig.profile || '(default AWS chain)'}`)
+    return
+  }
+
+  // Always rebuild — the static-host flow expects fresh dist/ on every
+  // deploy. UNIWEB_SKIP_BUILD env var lets CI / dev loops reuse an
+  // existing build (mirrors the uniweb-edge flow's escape hatch).
+  const skipBuild = parseBoolEnv('UNIWEB_SKIP_BUILD')
+  if (skipBuild) {
+    if (!existsSync(distDir)) {
+      say.err('UNIWEB_SKIP_BUILD is set but dist/ does not exist.')
+      process.exit(1)
+    }
+    say.info('UNIWEB_SKIP_BUILD set — reusing existing dist/.')
+  } else {
+    say.info(`Building site (host: ${adapter.name})…`)
+    console.log('')
+    try {
+      execSync(
+        `node ${JSON.stringify(process.argv[1])} build --bundle --host ${JSON.stringify(adapter.name)}`,
+        { cwd: siteDir, stdio: 'inherit' }
+      )
+    } catch {
+      say.err('Build failed. See output above.')
+      process.exit(1)
+    }
+    if (!existsSync(distDir)) {
+      say.err('Build did not produce dist/.')
+      process.exit(1)
+    }
+    console.log('')
+  }
+
+  // Hand off to the adapter. DeployError is the structured shape from
+  // @uniweb/build/hosts/s3-cloudfront — translate to user-facing output.
+  try {
+    await adapter.deploy({
+      distDir,
+      deployConfig,
+      env: process.env,
+      log: (m) => console.log(m),
+    })
+  } catch (err) {
+    if (err && err.name === 'DeployError') {
+      say.err(err.message)
+      if (err.hint) {
+        console.log('')
+        console.log(err.hint)
+      }
+      process.exit(1)
+    }
+    throw err
+  }
+
+  // Record a fresh lastDeploy.<target> entry. Skipped on --no-save and
+  // on ad-hoc --host overrides — see autoSave gating in deploy().
+  await persistLastDeploy(siteDir, {
+    targetName: resolved.targetName,
+    targetConfig: resolved.fromFile ? null : { host: hostName, ...deployConfig },
+    autoSave,
+    lastDeploy: {
+      at: new Date().toISOString(),
+      host: hostName,
+      // Static hosts know their public URL only via the user's CDN config;
+      // we don't have it on hand. Future: pull from a known field.
+    },
+  })
+  if (hostOverridden && !dryRun) {
+    say.dim('--host override active — did not write to deploy.yml. Edit deploy.yml to make this permanent.')
+  }
+}
+
+// ─── deploy.yml lastDeploy persistence ──────────────────────────
+
+async function persistLastDeploy(siteDir, opts) {
+  if (opts.autoSave === 'off') return
+  try {
+    const result = await recordLastDeploy(siteDir, opts)
+    if (result?.created) {
+      say.dim(`Wrote deploy.yml (target: ${opts.targetName})`)
+    }
+  } catch (err) {
+    // The deploy itself succeeded — never fail the whole command on a
+    // memo-write error. Surface it so the user can fix the file.
+    say.dim(`Could not update deploy.yml: ${err.message}`)
+  }
 }
 
 // ─── site.yml ──────────────────────────────────────────────
@@ -1008,7 +1269,7 @@ export async function resolveSiteDir(args, verb = 'deploy') {
 
 async function fetchLatestRuntime(workerUrl) {
   try {
-    const res = await fetch(`${workerUrl}/api/runtime/latest`)
+    const res = await fetch(`${workerUrl}/runtime/latest`)
     if (!res.ok) return null
     const body = await res.json()
     return body.version || null
@@ -1168,7 +1429,7 @@ async function callPublish({ url, token, body }) {
 
 /**
  * Walk a built foundation's `dist/` directory and return `{ relPath: base64Bytes }`
- * — the shape `POST /api/foundations` expects in its `files` field.
+ * — the shape `POST /foundations` expects in its `files` field.
  */
 async function collectFoundationDistFiles(distDir) {
   if (!existsSync(distDir)) {
@@ -1219,13 +1480,37 @@ async function callFoundationUpload({ url, token, body }) {
  * siteContent is mutated in place so the caller's publish payload picks up
  * the rewritten nodes without passing anything back.
  */
-async function uploadAssetsAndRewriteContent({ siteDir, localeContents, siteYml, theme, backendUrl, cliToken, siteId }) {
+async function uploadAssetsAndRewriteContent({ siteDir, localeContents, dataFileObjects = {}, siteYml, theme, backendUrl, cliToken, siteId }) {
   const distAssetsDir = join(siteDir, 'dist', 'assets')
   const hasDistAssets = existsSync(distAssetsDir)
 
   // 1. Enumerate local files + read size.
   const localFiles = hasDistAssets ? await walkAssetDir(distAssetsDir) : []
 
+  // 1a. Content-scan: walk site-content.json (and locale variants) for any
+  //     asset references (image/document src/href) and resolve absolute
+  //     paths to local files under `dist/` or `public/`. This catches static
+  //     assets the author placed in `public/covers/`, `public/images/`, etc.
+  //     that the dist/assets walk above misses (vite's image-pipeline only
+  //     produces files for refs that go through it). Each resolved file
+  //     joins the upload pipeline; the rewrite step at the end maps every
+  //     such reference to its CDN identifier so content stays portable
+  //     across site delete / template extraction.
+  const contentRefMap = await scanContentForAssetRefs(localeContents, dataFileObjects, siteDir)
+  const seenPaths = new Set(localFiles.map((f) => f.fullPath))
+  for (const [, info] of contentRefMap) {
+    if (seenPaths.has(info.resolvedPath)) continue
+    const ext = (info.filename.split('.').pop() || '').toLowerCase()
+    const st = await stat(info.resolvedPath)
+    localFiles.push({
+      filename: info.filename,
+      fullPath: info.resolvedPath,
+      size: st.size,
+      mime: MIME_BY_EXT[ext] || 'application/octet-stream',
+    })
+    seenPaths.add(info.resolvedPath)
+  }
+
   // 1a. Favicon — sits at site root, not in dist/assets. Ship it through
   //     the same pipeline so it ends up at assets.uniweb.app with an
   //     identifier; config.favicon gets set further down.
@@ -1345,14 +1630,39 @@ async function uploadAssetsAndRewriteContent({ siteDir, localeContents, siteYml,
   }
 
   // 6. Rewrite each locale's content in place. Image/document nodes whose
-  //    src/href references a local /assets/{filename} get an info.identifier
-  //    pointing to the uploaded (or reused) asset. Walking every locale
-  //    means translated content (which still references the same image
-  //    files via the source ProseMirror tree) gets the same rewrite.
+  //    src/href references an uploaded asset get an info.identifier pointing
+  //    to the CDN. Walking every locale means translated content (which
+  //    still references the same image files via the source ProseMirror
+  //    tree) gets the same rewrite.
+  //
+  //    Two lookup paths:
+  //      - byOriginalRef: full src/href string → identifier (covers static
+  //        public/ assets like `/covers/foo.svg` and dist/-resolved refs)
+  //      - byFilename: legacy match for `assets/{filename}` shape — kept
+  //        for back-compat with content authored against the old vite-
+  //        produced `/assets/...` URLs.
   const byFilenameAll = new Map([...reused, ...fresh])
+  const byOriginalRef = new Map()
+  for (const [ref, info] of contentRefMap) {
+    const id = byFilenameAll.get(info.filename)
+    if (id) byOriginalRef.set(ref, id)
+  }
   let rewritten = 0
   for (const lang of Object.keys(localeContents)) {
-    rewritten += rewriteAssetReferences(localeContents[lang], byFilenameAll)
+    rewritten += rewriteAssetReferences(localeContents[lang], byFilenameAll, byOriginalRef)
+  }
+  // Data files: walk the JSON tree. Two patterns coexist in collection
+  // payloads:
+  //   - Flat fields (e.g. `article.image: "/covers/foo.svg"`) → replace
+  //     the string with a resolveAssetCdnUrl(identifier). The runtime
+  //     reads these as plain URLs, so rewriting at deploy time is the
+  //     simplest path to portability.
+  //   - Nested ProseMirror sub-trees (e.g. `article.content`) → use the
+  //     existing image/document node rewrite (sets `attrs.info.identifier`).
+  for (const k of Object.keys(dataFileObjects)) {
+    if (dataFileObjects[k] === null) continue
+    rewritten += rewriteFlatAssetUrls(dataFileObjects[k], byOriginalRef)
+    rewritten += rewriteAssetReferences(dataFileObjects[k], byFilenameAll, byOriginalRef)
   }
   if (rewritten > 0) {
     say.dim(`Rewrote ${rewritten} asset reference(s) across ${Object.keys(localeContents).length} locale(s).`)
@@ -1626,45 +1936,69 @@ async function runInPool(items, concurrency, worker) {
 
 /**
  * Walk siteContent (ProseMirror-ish JSON tree) and rewrite any node whose
- * `attrs.src` or `attrs.href` references a local `/assets/{filename}` that
- * we've uploaded/reused. Sets `attrs.info.identifier` so semantic-parser
- * resolves the real CDN URL (and optimized variants) at render time.
+ * `attrs.src` or `attrs.href` references an uploaded/reused asset. Sets
+ * `attrs.info.identifier` so semantic-parser resolves the real CDN URL
+ * (and optimized variants) at render time.
+ *
+ * Two lookup paths, in order:
+ *   1. `byOriginalRef` — full src/href string → identifier. Covers static
+ *      public/ assets (`/covers/foo.svg`, `/images/foo.png`) and any
+ *      content-scan-resolved file. Decouples assets from site lifecycle
+ *      (templates can extract content + identifier; assets stay on CDN).
+ *   2. `byFilename` (legacy) — only fires when the path matches the old
+ *      `/assets/{filename}` shape. Kept so re-deploys of content authored
+ *      against pre-content-scan CLIs still work.
  *
  * Returns the number of rewrites performed — useful for reporting, and to
  * detect "nothing matched" (likely a content-shape mismatch worth flagging).
  */
-function rewriteAssetReferences(node, byFilename) {
+function rewriteAssetReferences(node, byFilename, byOriginalRef = new Map()) {
   let count = 0
   const walk = (n) => {
     if (!n || typeof n !== 'object') return
     if (Array.isArray(n)) { for (const child of n) walk(child); return }
     if (n.attrs && typeof n.attrs === 'object') {
-      const srcRef = pickAssetRef(n.attrs.src)
-      const hrefRef = pickAssetRef(n.attrs.href)
-      const ref = srcRef || hrefRef
-      if (ref) {
-        const identifier = byFilename.get(ref)
-        if (identifier) {
-          n.attrs.info = {
-            ...(n.attrs.info || {}),
-            identifier,
-            contentType: 'website',
-            viewType: 'profile',
-          }
-          // Clear the local Vite-hashed path so the runtime resolves via
-          // info.identifier (→ assets.uniweb.app CDN) instead of requesting
-          // a non-existent /assets/... file from the site host.
-          if (srcRef) n.attrs.src = null
-          if (hrefRef) n.attrs.href = null
-          // Match the Editor shape: plain `image` nodes skip identifier
-          // resolution in older runtimes; `ImageBlock` routes through
-          // parseImgBlock which reads info.identifier and fills url.
-          if (n.type === 'image' && n.attrs.role !== 'icon') {
-            n.type = 'ImageBlock'
-          }
-          count++
+      // Prefer full-ref lookup (covers static + dist refs uniformly);
+      // fall back to legacy `assets/{filename}` extraction.
+      let identifier = null
+      let srcMatched = false
+      let hrefMatched = false
+      if (typeof n.attrs.src === 'string' && byOriginalRef.has(n.attrs.src)) {
+        identifier = byOriginalRef.get(n.attrs.src)
+        srcMatched = true
+      } else if (typeof n.attrs.href === 'string' && byOriginalRef.has(n.attrs.href)) {
+        identifier = byOriginalRef.get(n.attrs.href)
+        hrefMatched = true
+      } else {
+        const srcRef = pickAssetRef(n.attrs.src)
+        const hrefRef = pickAssetRef(n.attrs.href)
+        const ref = srcRef || hrefRef
+        if (ref) {
+          identifier = byFilename.get(ref) || null
+          srcMatched = !!srcRef
+          hrefMatched = !srcRef && !!hrefRef
         }
       }
+      if (identifier) {
+        n.attrs.info = {
+          ...(n.attrs.info || {}),
+          identifier,
+          contentType: 'website',
+          viewType: 'profile',
+        }
+        // Clear the local path so the runtime resolves via info.identifier
+        // (→ assets.uniweb.app CDN) instead of requesting a non-existent
+        // file from the site host.
+        if (srcMatched) n.attrs.src = null
+        if (hrefMatched) n.attrs.href = null
+        // Match the Editor shape: plain `image` nodes skip identifier
+        // resolution in older runtimes; `ImageBlock` routes through
+        // parseImgBlock which reads info.identifier and fills url.
+        if (n.type === 'image' && n.attrs.role !== 'icon') {
+          n.type = 'ImageBlock'
+        }
+        count++
+      }
     }
     for (const v of Object.values(n)) if (typeof v === 'object') walk(v)
   }
@@ -1679,6 +2013,153 @@ function pickAssetRef(v) {
   return m ? m[1] : null
 }
 
+/**
+ * Walk every locale's content for `attrs.src` and `attrs.href` strings, and
+ * resolve absolute-path refs (e.g. `/covers/foo.svg`) to local files under
+ * the site root.
+ *
+ * Resolution order per ref:
+ *   1. `dist/{path}`    — vite outputs, link-mode collection JSON, etc.
+ *   2. `public/{path}`  — static author-placed assets (covers, images).
+ *
+ * Returns Map<originalRef, { resolvedPath, filename }> where:
+ *   - `originalRef`  — the exact src/href string from content (used as the
+ *                      lookup key during rewrite).
+ *   - `resolvedPath` — absolute path on disk (used for upload).
+ *   - `filename`     — basename, used as the assets-server upload filename.
+ *                      Server keys by (siteId, filename); collisions across
+ *                      paths with the same basename are flagged as warnings.
+ *
+ * Skips:
+ *   - Non-string values, refs that don't start with `/`, protocol-relative
+ *     refs (`//cdn.example.com/...`), and external URLs.
+ *   - Refs starting with `/api/` or `/_` (worker-internal paths, never
+ *     local files).
+ *   - Nodes already rewritten with `attrs.info.identifier` set (re-deploy).
+ */
+async function scanContentForAssetRefs(localeContents, dataFileObjects, siteDir) {
+  const candidates = new Set()
+  for (const lang of Object.keys(localeContents)) {
+    walkContentForAssetRefs(localeContents[lang], candidates)
+  }
+  // Also walk parsed collection JSON files. These contain BOTH ProseMirror-
+  // shaped sub-trees (article.content) AND flat string fields (article.image,
+  // article.cover, etc.). The walker captures both: any string-valued src/
+  // href/image/cover/thumbnail/icon/poster field, plus any string anywhere
+  // that looks like an absolute path with a known media extension.
+  for (const k of Object.keys(dataFileObjects || {})) {
+    if (dataFileObjects[k] !== null) {
+      walkContentForAssetRefs(dataFileObjects[k], candidates)
+    }
+  }
+
+  const results = new Map()
+  const filenameToRef = new Map() // detect collisions (same basename, different path)
+  for (const ref of candidates) {
+    if (!isResolvableContentRef(ref)) continue
+    const cleanPath = ref.split('?')[0].split('#')[0].slice(1) // drop leading '/'
+    const distCandidate = join(siteDir, 'dist', cleanPath)
+    const publicCandidate = join(siteDir, 'public', cleanPath)
+    let resolvedPath = null
+    if (existsSync(distCandidate)) {
+      try { if ((await stat(distCandidate)).isFile()) resolvedPath = distCandidate } catch {}
+    }
+    if (!resolvedPath && existsSync(publicCandidate)) {
+      try { if ((await stat(publicCandidate)).isFile()) resolvedPath = publicCandidate } catch {}
+    }
+    if (!resolvedPath) continue
+    const filename = resolvedPath.split(sep).pop()
+    const prior = filenameToRef.get(filename)
+    if (prior && prior !== resolvedPath) {
+      // Two different files want the same upload filename — server keys by
+      // filename so the second would clobber the first. Skip + warn rather
+      // than silently overwrite. Caller can rename the file or move one
+      // into a vite-processed path to disambiguate via content hashing.
+      say.warn(
+        `Asset filename collision: "${filename}" exists at multiple paths ` +
+          `(${prior}, ${resolvedPath}). Skipping the second; rename to disambiguate.`
+      )
+      continue
+    }
+    filenameToRef.set(filename, resolvedPath)
+    results.set(ref, { resolvedPath, filename })
+  }
+  return results
+}
+
+// Field names commonly used for media in collection JSON. The walker
+// collects any absolute-path string under these keys as a potential asset
+// reference. ProseMirror image/link nodes are caught separately via attrs.
+const FLAT_ASSET_FIELDS = new Set([
+  'src', 'href', 'image', 'cover', 'thumbnail', 'icon', 'poster', 'logo',
+  'avatar', 'photo', 'banner', 'background',
+])
+
+function walkContentForAssetRefs(node, refs) {
+  if (!node || typeof node !== 'object') return
+  if (Array.isArray(node)) { for (const child of node) walkContentForAssetRefs(child, refs); return }
+  if (node.attrs && typeof node.attrs === 'object') {
+    // Skip nodes already rewritten in a prior deploy — those have an
+    // identifier and the runtime resolves them through the CDN already.
+    if (!node.attrs.info?.identifier) {
+      if (typeof node.attrs.src === 'string') refs.add(node.attrs.src)
+      if (typeof node.attrs.href === 'string') refs.add(node.attrs.href)
+    }
+  }
+  // Flat fields: collection-shaped objects (e.g. an article record) often
+  // carry media URLs as plain string fields rather than ProseMirror nodes.
+  // Capture absolute-path values under known keys.
+  for (const [k, v] of Object.entries(node)) {
+    if (typeof v === 'string' && FLAT_ASSET_FIELDS.has(k) && isResolvableContentRef(v)) {
+      refs.add(v)
+    } else if (typeof v === 'object') {
+      walkContentForAssetRefs(v, refs)
+    }
+  }
+}
+
+/**
+ * Walk an arbitrary JSON tree and replace any string equal to a key in
+ * `byOriginalRef` (and not already a CDN URL) with the asset's CDN URL.
+ * Used for collection JSON files where image refs are flat string fields
+ * (e.g. `article.image: "/covers/foo.svg"`) rather than ProseMirror nodes.
+ *
+ * Returns the number of replacements performed.
+ */
+function rewriteFlatAssetUrls(node, byOriginalRef) {
+  let count = 0
+  const walk = (n, parent, key) => {
+    if (n == null) return
+    if (typeof n === 'string') {
+      const id = byOriginalRef.get(n)
+      if (id && parent != null && key != null) {
+        parent[key] = resolveAssetCdnUrl(id)
+        count++
+      }
+      return
+    }
+    if (typeof n !== 'object') return
+    if (Array.isArray(n)) {
+      for (let i = 0; i < n.length; i++) walk(n[i], n, i)
+      return
+    }
+    for (const [k, v] of Object.entries(n)) walk(v, n, k)
+  }
+  walk(node, null, null)
+  return count
+}
+
+function isResolvableContentRef(ref) {
+  if (typeof ref !== 'string' || !ref) return false
+  // Absolute-path only — relative paths (`./foo`, `foo`) are content-author
+  // shorthand handled elsewhere; URLs (`http://`, `//cdn`) never resolve to
+  // local files; worker-internal paths (`/api/`, `/_`) aren't asset content.
+  if (!ref.startsWith('/')) return false
+  if (ref.startsWith('//')) return false
+  if (ref.startsWith('/api/') || ref.startsWith('/_')) return false
+  return true
+}
+
 // ─── Loopback listener (review path) ───────────────────────
 
 /**

package/src/commands/export.js

@@ -17,6 +17,10 @@
  * Usage:
  *   uniweb export                          Produce dist/ for static hosting
  *   uniweb export --no-prerender           Skip per-page prerendered HTML
+ *   uniweb export --host <name>            Pick a host adapter for postBuild
+ *                                          (e.g. cloudflare-pages, s3-cloudfront,
+ *                                          github-pages, generic-static).
+ *                                          Default: cloudflare-pages.
  */
 
 import { execSync } from 'node:child_process'
@@ -42,14 +46,31 @@ const say = {
 export async function exportSite(args = []) {
   const siteDir = await resolveSiteDir(args, 'export')
 
-  // Pass through --no-prerender; everything else gets ignored. `uniweb
-  // export` is intentionally low-flag: the user picks the destination
-  // host themselves outside the CLI, so there's nothing to configure
-  // beyond what `uniweb build --bundle` already exposes.
+  // Pass through --no-prerender and --host. Everything else is ignored.
+  // `uniweb export` stays low-flag: the user picks the destination host
+  // themselves outside the CLI, so there's nothing to configure beyond
+  // what `uniweb build --bundle` already exposes.
   const noPrerender = args.includes('--no-prerender')
   const buildArgs = ['build', '--bundle']
   if (noPrerender) buildArgs.push('--no-prerender')
 
+  const { readFlagValue } = await import('../utils/args.js')
+  const hostFlag = readFlagValue(args, '--host')
+  if (hostFlag === null) {
+    // --host with no value → prompt here so the build subprocess gets
+    // a concrete value (and doesn't re-prompt against its own argv).
+    const { promptForHost } = await import('../utils/host-prompt.js')
+    try {
+      const chosen = await promptForHost({ args })
+      buildArgs.push('--host', chosen)
+    } catch (err) {
+      say.err(err.message)
+      process.exit(1)
+    }
+  } else if (typeof hostFlag === 'string') {
+    buildArgs.push('--host', hostFlag)
+  }
+
   say.info('Exporting site (vite build → dist/)…')
   console.log('')
 

package/src/framework-index.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-05-01T02:07:21.541Z",
+  "generatedAt": "2026-05-05T18:36:54.411Z",
   "packages": {
     "@uniweb/build": {
-      "version": "0.13.5",
+      "version": "0.14.2",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -24,7 +24,7 @@
       "deps": []
     },
     "@uniweb/core": {
-      "version": "0.7.10",
+      "version": "0.7.11",
       "path": "framework/core",
       "deps": [
         "@uniweb/semantic-parser",
@@ -42,7 +42,7 @@
       "deps": []
     },
     "@uniweb/kit": {
-      "version": "0.9.10",
+      "version": "0.9.11",
       "path": "framework/kit",
       "deps": [
         "@uniweb/core"
@@ -59,7 +59,7 @@
       "deps": []
     },
     "@uniweb/runtime": {
-      "version": "0.8.11",
+      "version": "0.8.13",
       "path": "framework/runtime",
       "deps": [
         "@uniweb/core",
@@ -92,7 +92,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.4.4",
+      "version": "0.4.6",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",

package/src/utils/args.js

@@ -0,0 +1,37 @@
+/**
+ * argv parsing helpers shared across CLI commands.
+ */
+
+/**
+ * Read `--flag value` from argv. Accepts both `--flag value` and
+ * `--flag=value`.
+ *
+ * Returns:
+ *   - undefined when the flag is absent
+ *   - null when the flag is present without a value (last arg, next is
+ *     another flag, or `--flag=` empty form)
+ *   - string when the flag carries a value
+ *
+ * The three-state return lets callers distinguish "not given" (e.g.,
+ * fall back to a default) from "given but empty" (e.g., trigger an
+ * interactive prompt).
+ *
+ * @param {string[]} args
+ * @param {string} name — Including the leading dashes, e.g. '--host'.
+ * @returns {string | null | undefined}
+ */
+export function readFlagValue(args, name) {
+  const eqPrefix = name + '='
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === name) {
+      const next = args[i + 1]
+      if (next === undefined || next.startsWith('--')) return null
+      return next
+    }
+    if (args[i].startsWith(eqPrefix)) {
+      const v = args[i].slice(eqPrefix.length)
+      return v === '' ? null : v
+    }
+  }
+  return undefined
+}

package/src/utils/config.js

@@ -14,9 +14,15 @@ import { filterCmd } from './pm.js'
 
 // ── Platform URLs ──────────────────────────────────────────────
 
-// Production defaults — regular users get these out of the box
+// Production defaults — regular users get these out of the box.
+// REGISTRY hosts platform operations (publish, foundations, runtime, admin):
+//   moved to hosting.uniweb.app in the CDN migration (Phase 4c, 2026-05-04).
+// BACKEND hosts the PHP user-facing surface (login, account, orgs, billing,
+//   publish-authorize): owned by the v4 single-domain plan
+//   (kb/platform/plans/uniweb-domain-plan-v4.md), which will move it to
+//   uniweb.app/api/* when v4 ships. Until then, it stays at hub.uniweb.app.
 const PRODUCTION_BACKEND_URL = 'https://hub.uniweb.app'
-const PRODUCTION_REGISTRY_URL = 'https://site-router.uniweb-edge.workers.dev'
+const PRODUCTION_REGISTRY_URL = 'https://hosting.uniweb.app'
 
 /**
  * Read ~/.uniweb/config.json for persistent URL overrides.

package/src/utils/host-prompt.js

@@ -0,0 +1,50 @@
+/**
+ * Interactive host adapter selection
+ *
+ * Prompts the user to pick a host adapter from the registry. Used when
+ * `--host` is passed without a value to `uniweb deploy / build / export`.
+ *
+ * Non-interactive contexts (CI, piped input, --non-interactive) get a
+ * structured error instead of a prompt — never silently default to
+ * something the user didn't pick.
+ */
+
+import { promptSelect } from './workspace.js'
+import { isNonInteractive } from './interactive.js'
+
+/**
+ * Pick a host adapter, optionally with a pre-selection.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.args — Argv, used only to gate non-interactive mode.
+ * @param {string|null} [opts.preselect] — Suggested adapter name; the prompt
+ *   highlights this so Enter accepts it without arrow-key navigation.
+ * @returns {Promise<string>} The chosen adapter name.
+ * @throws {Error} When non-interactive (with the registry list in the message),
+ *   or when the user aborts the prompt.
+ */
+export async function promptForHost({ args, preselect = null } = {}) {
+  // Lazy-load so this module doesn't pull @uniweb/build at import time
+  // for callers that never reach the prompt path.
+  const { listAdapters } = await import('@uniweb/build/hosts')
+  const adapters = listAdapters()
+
+  if (isNonInteractive(args || [])) {
+    const list = adapters.join(', ')
+    throw new Error(
+      `--host requires a value when running non-interactively. Known adapters: ${list}.`
+    )
+  }
+
+  // promptSelect doesn't expose initial-index, so move the preselect to
+  // the top of the list — the menu still highlights index 0 by default.
+  const ordered = preselect && adapters.includes(preselect)
+    ? [preselect, ...adapters.filter(a => a !== preselect)]
+    : adapters
+
+  const choice = await promptSelect('Pick a host adapter:', ordered)
+  if (!choice) {
+    throw new Error('Host selection cancelled.')
+  }
+  return choice
+}

package/templates/foundation/package.json.hbs

@@ -7,7 +7,7 @@
   "exports": {
     ".": "./_entry.generated.js",
     "./styles": "./styles.css",
-    "./dist": "./dist/foundation.js",
+    "./dist": "./dist/entry.js",
     "./dist/styles": "./dist/assets/style.css"
   },
   "imports": {