uniweb 0.12.34 → 0.12.36

package/src/commands/deploy.js

@@ -1,67 +1,46 @@
 /**
- * Deploy Command
+ * Deploy Command — ship a site to its resolved target.
  *
- * Deploys a site. Host is determined by the resolved deploy.yml target
- * (or `--target <name>` / `--host <name>` flags). The default is `uniweb`:
+ * `uniweb deploy` resolves WHERE a site goes from deploy.yml (+ `--host` /
+ * `--target`) and ships it there:
+ *   - THIRD-PARTY host (`s3-cloudfront`, `cloudflare-pages`, `github-pages`,
+ *     `generic-static`, …): build `dist/` in bundle mode and hand it to the
+ *     host adapter for upload + invalidation.
+ *   - UNIWEB hosting target (an explicit `--host=uniweb`, or a `uniweb` target
+ *     in deploy.yml): DELEGATE to `uniweb publish` — the smart path (sync +
+ *     dynamic hosting, brings the foundation along). So deploy.yml stays one
+ *     actionable "where this site deploys" record, uniweb included.
  *
- *   - `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.
+ * `uniweb publish` is the canonical direct verb for Uniweb hosting (reach for it
+ * by default); `uniweb export` writes a self-contained artifact you upload
+ * yourself.
  *
- *   - 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.
- *
- * For static-host artifacts WITHOUT upload, see `uniweb export`. To publish a
- * site that already lives on the backend as a synced draft, see `uniweb release`.
- *
- * Uniweb-host flow (deployToUniwebBackend) — the composite deploy = build → ball →
- * media → push → publish:
- *   1. Resolve the site dir + deploy.yml target; discover() the backend (GET
- *      /dev/config) and resolve the runtime (`site.yml::runtime` if pinned, else the
- *      backend's highest installed; fail closed if neither resolves).
- *   2. Build the site data (link mode): site-content.json (+ per-locale variants),
- *      collection data, search indexes, processed assets.
- *   3. Partition collections by schema presence: schema-less → the static-data ball;
- *      schema-backed → typed folder entities on the push lane.
- *   4. Upload the site's local media (entity refs + the ball's refs, one deduped set) →
- *      each site-root ref's backend serve URL; rewrite the ball with it, then upload the
- *      rewritten ball (content-addressed → `info.data_bundle`).
- *   5. Push — the SAME two-lane sync `uniweb push` uses (site-content with
- *      `info.data_bundle` stamped + media refs rewritten, then the folder + records) —
- *      over the send-only-changed cache; the backend mints/round-trips the site uuid.
- *   6. Publish — make the just-pushed composite live; the backend returns the serve URL.
+ * Host resolution:
+ *   1. --target <name> picks a target from deploy.yml (full config)
+ *   2. deploy.yml's `default:` target when no flag is given
+ *   3. with no deploy.yml at all, NO host is chosen → deploy prompts for a
+ *      third-party adapter (interactive) rather than assuming Uniweb;
+ *      non-interactive → an actionable error pointing at `publish` / `--host`
+ *   4. --host <name> is a one-off override (does NOT persist to deploy.yml)
  *
  * Usage:
- *   uniweb deploy                  Build + deploy to the resolved target
- *   uniweb deploy --dry-run        Resolve everything; POST nothing
- *   uniweb deploy --target <name>  Pick a target from deploy.yml (default: its `default:`)
- *   uniweb deploy --host <name>    One-off host override (not persisted to deploy.yml)
+ *   uniweb deploy --host <name>    Build bundle-mode dist/ + hand to the host adapter
+ *   uniweb deploy --host=uniweb    Delegate to `uniweb publish` (Uniweb hosting)
+ *   uniweb deploy --target <name>  Pick a target from deploy.yml
+ *   uniweb deploy --dry-run        Resolve everything; upload nothing
  *   uniweb deploy --no-save        Skip the deploy.yml lastDeploy auto-save
- *   uniweb deploy --backend <url>  Override the backend origin
  *
- * Backend: BackendClient. Origin from --backend/--registry > UNIWEB_REGISTER_URL
- * > the default. Auth: --token > UNIWEB_TOKEN > `uniweb login` session.
- *
- * Escape hatch: UNIWEB_SKIP_BUILD=1 reuses an existing dist/ (static-host flow).
+ * Escape hatch: UNIWEB_SKIP_BUILD=1 reuses an existing dist/.
  */
 
 import { existsSync } from 'node:fs'
-import { readFile } from 'node:fs/promises'
 import { resolve, join } from 'node:path'
 import { execSync } from 'node:child_process'
-import yaml from 'js-yaml'
 
-import { loadDeployYml, resolveTarget, recordLastDeploy, assembleDataBall, collectBallAssets, rewriteBallAssets } from '@uniweb/build/site'
+import { loadDeployYml, resolveTarget, recordLastDeploy } from '@uniweb/build/site'
 import { promptForHost } from '../utils/host-prompt.js'
 import { readFlagValue } from '../utils/args.js'
 import { parseBoolEnv } from '../utils/env.js'
-import { BackendClient } from '../backend/client.js'
-import { emitSyncPackages } from '@uniweb/build/uwx'
-import { makeModelResolver, readSyncCache, pushSyncPackages } from '../backend/site-sync.js'
-import { uploadDataBundle } from '../backend/data-bundle.js'
-import { uploadSiteMedia } from '../backend/site-media.js'
 
 import {
   findWorkspaceRoot,
@@ -71,69 +50,6 @@ import {
 } from '../utils/workspace.js'
 import { isNonInteractive, getCliPrefix } from '../utils/interactive.js'
 
-const FOUNDATION_POLICIES = new Set(['exact', 'auto-patch', 'auto-minor'])
-
-/**
- * Parse the `foundation:` field from site.yml into a normalized shape.
- *
- * Accepts:
- *   - string: '@uniweb/votiverse@0.1.1'
- *   - object: { ref: '@uniweb/votiverse@0.1.1', policy?: ..., pinned?: true }
- *
- * Returns one of:
- *   - { error: 'description of what's wrong' }
- *   - { normalized, policy?, pinned }   where `normalized` is whichever
- *     shape we received (string or { ref, policy?, pinned? }) — the Worker
- *     accepts both. `policy`/`pinned` are also returned individually so
- *     the CLI can print friendly diagnostics.
- *
- * Validation rules (mirrors publish.js::parseFoundationConfig):
- *   - `policy` must be one of 'exact', 'auto-patch', 'auto-minor'
- *   - `pinned: true` + `policy: not-exact` is rejected as conflicting
- */
-function parseSiteFoundation(input) {
-  if (typeof input === 'string') {
-    return { normalized: input, policy: null, pinned: false }
-  }
-  if (!input || typeof input !== 'object') {
-    return { error: 'foundation must be a string or object' }
-  }
-
-  // Object form must carry `ref`; everything else is metadata.
-  if (!input.ref || typeof input.ref !== 'string') {
-    return { error: 'foundation.ref is required when using object form' }
-  }
-  if (!/^@[a-z0-9_-]+\/[a-z0-9_-]+@.+$/.test(input.ref)) {
-    return {
-      error: `foundation.ref does not match @namespace/name@version: '${input.ref}'`,
-    }
-  }
-
-  let policy = null
-  if (input.policy != null) {
-    if (!FOUNDATION_POLICIES.has(input.policy)) {
-      return {
-        error: `foundation.policy must be one of 'exact', 'auto-patch', 'auto-minor' (got '${input.policy}')`,
-      }
-    }
-    policy = input.policy
-  }
-  const pinned = input.pinned === true
-
-  if (pinned && policy && policy !== 'exact') {
-    return {
-      error: `foundation: 'pinned: true' conflicts with policy '${policy}'. ` +
-        `Use either 'pinned: true' or 'policy: \"exact\"' (they're equivalent), or drop one.`,
-    }
-  }
-
-  return {
-    normalized: { ref: input.ref, ...(policy ? { policy } : {}), ...(pinned ? { pinned: true } : {}) },
-    policy: pinned ? 'exact' : policy,
-    pinned,
-  }
-}
-
 const c = {
   reset: '\x1b[0m',
   bold: '\x1b[1m',
@@ -156,24 +72,12 @@ const say = {
 export async function deploy(args = []) {
   const dryRun = args.includes('--dry-run')
   const siteDir = await resolveSiteDir(args)
-  // Read site.yml — declares the foundation (required) and optionally the
-  // 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.
+  // Host dispatch. Resolution order:
+  //   1. --target <name> picks a target from deploy.yml
+  //   2. deploy.yml's `default:` target when no flag is given
+  //   3. with no deploy.yml, the implicit default is host: 'uniweb'
+  //   4. --host <name> is a one-off override (does not persist on success)
   const targetFromFlag = readFlagValue(args, '--target')
   let hostFromFlag = readFlagValue(args, '--host')
   const noSave = args.includes('--no-save')
@@ -202,291 +106,61 @@ export async function deploy(args = []) {
       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\'')
-    process.exit(1)
-  }
-
-  // Foundation may be string or object form (see site.yml docs).
-  const fnd = parseSiteFoundation(siteYml.foundation)
-  if (fnd.error) {
-    say.err(`site.yml: ${fnd.error}`)
-    process.exit(1)
-  }
-  // `foundation` is the on-the-wire shape we forward to PHP authorize +
-  // Worker publish. PHP only inspects the namespace via the ref string;
-  // it doesn't care about policy/pinned, so the object form passes through.
-  // The Worker (publish.js::parseFoundationConfig) handles both shapes.
-  let foundation = fnd.normalized
-  if (fnd.policy && fnd.policy !== 'auto-patch') {
-    say.dim(`Foundation policy: ${fnd.policy}${fnd.pinned ? ' (pinned)' : ''}`)
-  } else if (fnd.pinned) {
-    say.dim('Foundation policy: exact (pinned)')
-  }
-
-  // Uniweb hosting → the new backend's /dev/deploy delivery lane (BackendClient):
-  // one authed POST, no PHP authorize, no Worker publish, no JWT. Backend chosen by
-  // origin only; capabilities + installed runtimes discovered via GET /dev/config.
-  // Foundation/runtime resolution, payload assembly, the POST, and the deploy.yml
-  // uuid round-trip all live in deployToUniwebBackend. The legacy PHP-authorize +
-  // Worker-publish flow below is retired by this routing (excised on cutover).
-  await deployToUniwebBackend(siteDir, siteYml, { foundation, args, dryRun, resolved, deployYml, autoSave })
-  return
-}
-
-// ─── Uniweb-backend deploy (the /dev/deploy delivery lane) ────────────────
-//
-// Hosts a file-built site on the Uniweb backend through BackendClient: one authed
-// POST /dev/deploy carrying the deploy payload `build-site-data.js` produces. The
-// login bearer authorizes (the account IS the authorization) — no PHP authorize,
-// no Worker publish, no JWT, no asset-presign dance. Backend is chosen by origin
-// only (--backend/--registry > UNIWEB_REGISTER_URL > default); everything else is
-// discovered via GET /dev/config (capabilities + installed runtimes). Replaces the
-// legacy PHP+Worker flow in deploy() above.
-
-async function deployToUniwebBackend(siteDir, siteYml, { foundation, args, dryRun, resolved, deployYml, autoSave }) {
-  const client = new BackendClient({
-    originFlag: readFlagValue(args, '--backend') || readFlagValue(args, '--registry'),
-    token: readFlagValue(args, '--token'),
-    args,
-    command: 'Deploying',
-  })
-
-  const foundationDir = readFlagValue(args, '--foundation') // optional local foundation for Model schemas
-  const asOrg = readFlagValue(args, '--as-org')
-
-  // Anonymous capability handshake (cached). The composite deploy ends in a publish,
-  // so confirm that lane is offered (the push/sync lanes are the backend's baseline).
-  const config = await client.discover()
-  if (config?.delivery && config.delivery.publish === false) {
-    say.err(`Backend at ${client.origin} does not offer the publish lane (delivery.publish=false).`)
-    process.exit(1)
-  }
-
-  // Runtime resolution: an explicit site.yml::runtime pin wins; else the highest
-  // version the backend reports installed; else fail closed with a clear
-  // precondition error (better than serving a site with no runtime).
-  const installed = Array.isArray(config?.runtime?.installed) ? config.runtime.installed : []
-  if (siteYml.runtime && installed.length && !installed.includes(siteYml.runtime)) {
-    say.err(`Runtime ${siteYml.runtime} (from site.yml) is not installed on the backend.`)
-    say.dim(`Installed: ${installed.join(', ') || '(none)'} — pin one of these in site.yml (\`runtime:\`), or have it installed on the backend.`)
-    process.exit(1)
-  }
-  const runtimeVersion = siteYml.runtime || pickHighestRuntime(installed)
-  if (!runtimeVersion) {
-    say.err('Could not resolve a runtime version.')
-    say.dim('Pin one with `runtime:` in site.yml, or install one on the backend so /dev/config reports it.')
-    process.exit(1)
-  }
-
-  if (dryRun) {
-    say.info('Dry run — would deploy to the Uniweb backend as a composite (ball → push → publish):')
-    say.dim(`Backend     : ${client.origin}`)
-    say.dim(`Foundation  : ${typeof foundation === 'string' ? foundation : foundation.ref}`)
-    say.dim(`Runtime     : ${runtimeVersion}${siteYml.runtime ? '' : ' (highest installed)'}`)
-    say.dim(`site_uuid   : ${siteYml.$uuid || '(none — the first push mints it)'}`)
-    return
-  }
-
-  // Build (link mode): emits dist/data/*, dist/_search/*, dist/assets/*, and
-  // dist/site-content.json. Spawn the SAME CLI binary so the inner build can't resolve
-  // to a different installed version.
-  say.info('Building site…')
-  console.log('')
-  execSync(`node ${JSON.stringify(process.argv[1])} build --link`, {
-    cwd: siteDir,
-    stdio: 'inherit',
-    env: process.env,
-  })
-  console.log('')
-
-  const distDir = join(siteDir, 'dist')
-  const contentPath = join(distDir, 'site-content.json')
-  if (!existsSync(contentPath)) {
-    say.err('Build did not produce dist/site-content.json')
-    process.exit(1)
-  }
-
-  // Non-local @std/registry Model schemas resolve through the backend (same as push).
-  const resolveModel = makeModelResolver({ client, offline: false })
-
-  // 1. Partition the collections by schema presence. A first emit reads `schemaless`
-  //    — the collections with no data schema, delivered statically via the ball. Its
-  //    packages are discarded (deploy is not a hot path; the cheap clarity beats a
-  //    schemaless-only fast path, a later optimization).
-  let probe
-  try {
-    probe = await emitSyncPackages(siteDir, { ...(foundationDir ? { foundationDir } : {}), resolveModel })
-  } catch (err) {
-    say.err(`Could not build the sync package: ${err.message}`)
-    process.exit(1)
-  }
-  const schemalessNames = (probe.schemaless || []).map((col) => col.name)
-  const localAssets = probe.localAssets || [] // entity-content site-root media refs
-
-  // 2. Assemble the static-data ball (schema-less collection data + the search index) —
-  //    BEFORE uploading it, because its schema-less records can carry local media too,
-  //    which we upload + rewrite to serve URLs exactly like entity content (the backend
-  //    serves a serve_url in the ball identically — it unwraps the ball verbatim).
-  let ball = await assembleDataBall(distDir, schemalessNames)
-  const ballAssets = collectBallAssets(ball)
-
-  // 2b. Upload ALL local media (entity refs + ball refs) on one asset lane → the
-  //     ref→serveUrl map. The same map rewrites the entity content (assetRewrite, real
-  //     emit below) AND the ball (here, before it's uploaded). Co-located refs were
-  //     warned + skipped by the producer; a missing file is skipped here (warned).
-  let assetRewrite = null
-  const mediaRefs = [...new Set([...localAssets, ...ballAssets])]
-  if (mediaRefs.length) {
-    say.info('Uploading media…')
-    try {
-      const map = await uploadSiteMedia(client, siteDir, mediaRefs, {
-        onProgress: (m) => say.dim(`  ${m}`),
-        warn: (m) => say.dim(`! ${m}`),
-      })
-      if (Object.keys(map).length) assetRewrite = map
-      if (ballAssets.length) ball = rewriteBallAssets(ball, map) // swap the ball's local refs → serve URLs
-      say.dim(`Media          : ${Object.keys(map).length}/${mediaRefs.length} ref(s) → serve URL`)
-    } catch (err) {
-      say.err(`Media upload failed: ${err.message}`)
+  let host = hostFromFlag || resolved.host
+
+  // A Uniweb-hosting target is `publish`'s flow. When the user EXPLICITLY chose
+  // uniweb (a `--host=uniweb`, or a `uniweb` target in deploy.yml), DELEGATE to
+  // `uniweb publish` so deploy.yml stays one actionable record. When NO host was
+  // chosen (the implicit default with no deploy.yml), don't assume uniweb:
+  // prompt for a third-party adapter (interactive) or point at publish / --host
+  // (non-interactive). promptForHost lists only third-party adapters.
+  if (host === 'uniweb') {
+    const explicitUniweb = hostFromFlag === 'uniweb' || (resolved.fromFile && resolved.host === 'uniweb')
+    if (explicitUniweb) {
+      say.info('Uniweb hosting target → running `uniweb publish`.')
+      console.log('')
+      // publish ignores deploy's --host/--target; --dry-run/--no-save/--backend
+      // /--token pass straight through.
+      const { publish } = await import('./publish.js')
+      const result = await publish(args)
+      process.exit(result?.exitCode ?? 0)
+    }
+    if (isNonInteractive(args)) {
+      say.err('`uniweb deploy` needs a host. For Uniweb hosting use `uniweb publish`; for a third-party host pass `--host=<adapter>`.')
+      console.log('')
+      say.dim('`uniweb publish`          Uniweb hosting (sync + dynamic hosting; brings the foundation along)')
+      say.dim('`uniweb deploy --host=…`  Third-party host (s3-cloudfront, cloudflare-pages, github-pages, generic-static)')
+      say.dim('`uniweb export`           Self-contained dist/ artifact you upload anywhere')
       process.exit(1)
     }
-  }
-
-  // 2c. Upload the (media-rewritten) ball. `data_bundle` is its content-addressed serve
-  //     URL; omitted when there is nothing static to deliver.
-  let dataBundle
-  if (ball) {
-    say.info('Uploading data bundle…')
+    say.info('`uniweb deploy` ships to a third-party host. (For Uniweb hosting, run `uniweb publish`.)')
     try {
-      dataBundle = await uploadDataBundle(client, ball, { onProgress: (m) => say.dim(`  ${m}`) })
+      host = await promptForHost({ args })
     } catch (err) {
-      say.err(`Data bundle upload failed: ${err.message}`)
+      say.err(err.message)
       process.exit(1)
     }
-    say.dim(`Data bundle    : ${Object.keys(ball.data).length} data + ${Object.keys(ball.search).length} search file(s)`)
-  }
-
-  // 3. Push the site (content + folder) over the send-only-changed cache — the SAME
-  //    two-lane submission `uniweb push` uses — stamping info.data_bundle on the
-  //    site-content entity and rewriting local media refs to their backend serve URLs.
-  const priorHashes = readSyncCache(siteDir)
-  let pkg
-  try {
-    pkg = await emitSyncPackages(siteDir, {
-      ...(foundationDir ? { foundationDir } : {}),
-      resolveModel,
-      priorHashes,
-      ...(dataBundle ? { injectInfo: { data_bundle: dataBundle } } : {}),
-      ...(assetRewrite ? { assetRewrite } : {}),
-    })
-  } catch (err) {
-    say.err(`Could not build the sync package: ${err.message}`)
-    process.exit(1)
-  }
-  for (const w of pkg.warnings) say.dim(`! ${w}`)
-  const report = {
-    info: (m) => say.info(m),
-    note: (m) => say.dim(m),
-    error: (m) => say.err(m),
-    dim: (s) => `${c.dim}${s}${c.reset}`,
-  }
-  const pushResult = await pushSyncPackages({ client, siteDir, pkg, asOrg, report })
-  if (pushResult.exitCode !== 0) process.exit(pushResult.exitCode)
-  const siteUuid = pushResult.boundSiteUuid
-  if (!siteUuid) {
-    say.err('Push did not yield a site uuid — cannot publish.')
-    process.exit(1)
   }
 
-  // 4. Publish: make the just-pushed composite live (its current backend state).
-  const siteContent = JSON.parse(await readFile(contentPath, 'utf8'))
-  const languages = extractLanguages(siteContent)
-  say.info(`Publishing to ${c.dim}${client.origin}${c.reset} …`)
-  let pubRes
-  try {
-    pubRes = await client.publishSite(siteUuid, { runtimeVersion, ...(languages ? { languages } : {}) })
-  } catch (err) {
-    say.err(`Could not reach the backend at ${client.origin}: ${err.message}`)
-    say.dim('Set the origin with --backend <url> or UNIWEB_REGISTER_URL.')
-    process.exit(1)
-  }
-  if (!pubRes.ok) {
-    say.err(`Publish rejected: HTTP ${pubRes.status} ${pubRes.statusText}`)
-    if (pubRes.status === 401 || pubRes.status === 403) {
-      say.dim("Credentials weren't accepted — run `uniweb login` (or pass --token <bearer>).")
-    }
-    const body = await pubRes.text().catch(() => '')
-    if (body) say.dim(body.slice(0, 800))
-    process.exit(1)
-  }
-  let result
-  try { result = await pubRes.json() } catch { result = {} }
-  const serveUrl = absolutizeServeUrl(client.origin, result.url)
+  // 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). A host picked interactively
+  // for a bare `deploy` is NOT an override — we DO want to remember it.
+  const hostOverridden = !!hostFromFlag && hostFromFlag !== resolved.host
+  const autoSave = noSave || hostOverridden ? 'off' : resolved.autoSave
 
-  // Persist deploy memory. One identity: site.yml::$uuid (the push uuid) — no separate
-  // deploy uuid. recordLastDeploy touches only lastDeploy.<target>.
-  await persistLastDeploy(siteDir, {
-    targetName: resolved.targetName,
-    targetConfig: resolved.fromFile ? null : { host: 'uniweb' },
+  await deployStaticHost(siteDir, host, resolved, {
+    dryRun,
     autoSave,
-    lastDeploy: {
-      at: new Date().toISOString(),
-      host: 'uniweb',
-      backend: client.origin,
-      siteUuid,
-      url: serveUrl,
-      foundation: { ref: typeof foundation === 'string' ? foundation : foundation?.ref },
-      runtime: runtimeVersion,
-      locales: Array.isArray(result.locales) ? result.locales : languages,
-    },
+    hostOverridden,
   })
-
-  console.log('')
-  say.ok(`Deployed ${c.bold}${siteUuid}${c.reset}`)
-  if (serveUrl) console.log(`  ${c.cyan}${serveUrl}${c.reset}`)
-}
-
-// Pick the highest runtime from the backend's installed list. localeCompare with
-// numeric ordering puts '0.8.16' above '0.8.9' and orders the synthetic dev tags
-// deterministically. Null when the list is empty.
-function pickHighestRuntime(installed) {
-  if (!Array.isArray(installed) || installed.length === 0) return null
-  return [...installed].sort((a, b) => String(b).localeCompare(String(a), undefined, { numeric: true }))[0]
-}
-
-// The deploy response `url` is the serve path. When origin-relative (the self-serve
-// default, e.g. /gateway/site/<uuid>/) prefix the BackendClient origin so the printed
-// link is clickable; absolute URLs pass through unchanged.
-function absolutizeServeUrl(origin, url) {
-  if (!url || typeof url !== 'string') return null
-  if (/^https?:\/\//.test(url)) return url
-  return `${origin.replace(/\/$/, '')}${url.startsWith('/') ? '' : '/'}${url}`
 }
 
 // ─── 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.
+// 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.
 
 async function deployStaticHost(siteDir, hostName, resolved, { dryRun, autoSave, hostOverridden }) {
   let getAdapter
@@ -531,7 +205,7 @@ async function deployStaticHost(siteDir, hostName, resolved, { dryRun, autoSave,
 
   // 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).
+  // existing build.
   const skipBuild = parseBoolEnv('UNIWEB_SKIP_BUILD')
   if (skipBuild) {
     if (!existsSync(distDir)) {
@@ -613,25 +287,11 @@ async function persistLastDeploy(siteDir, opts) {
   }
 }
 
-// ─── site.yml ──────────────────────────────────────────────
-
-async function readSiteYml(path) {
-  if (!existsSync(path)) return {}
-  try {
-    const parsed = yaml.load(await readFile(path, 'utf8'))
-    return parsed && typeof parsed === 'object' ? parsed : {}
-  } catch (err) {
-    say.err(`Could not parse ${path}: ${err.message}`)
-    process.exit(1)
-  }
-}
-
-// ─── Resolve site dir + runtime ────────────────────────────
+// ─── Resolve site dir ──────────────────────────────────────
 
-// Exported so `uniweb export` (commands/export.js) can reuse the same
-// site-discovery logic without duplicating it. `verb` is the command
-// being run ("deploy" or "export"); it appears in the error messages
-// so the user gets accurate guidance.
+// Exported so `uniweb export` / `uniweb publish` / `uniweb status` reuse the
+// same site-discovery logic. `verb` is the command being run; it appears in
+// the error messages so the user gets accurate guidance.
 export async function resolveSiteDir(args, verb = 'deploy') {
   const cwd = process.cwd()
   const prefix = getCliPrefix()
@@ -664,17 +324,28 @@ export async function resolveSiteDir(args, verb = 'deploy') {
   say.err('No site found in this workspace.')
   if (verb === 'export') {
     say.dim('`export` produces a self-contained dist/ artifact for third-party hosting.')
+  } else if (verb === 'deploy') {
+    say.dim('`deploy` ships a built site to a third-party host (use `uniweb publish` for Uniweb hosting).')
   } else {
-    say.dim('`deploy` publishes a built Uniweb site to the hosting platform.')
+    say.dim(`\`${verb}\` operates on a site.`)
   }
   process.exit(1)
 }
 
-// ─── Content helpers ───────────────────────────────────────
-
-function extractLanguages(siteContent) {
-  const langs = siteContent?.config?.languages
-  if (!Array.isArray(langs) || langs.length === 0) return ['en']
-  // Three accepted shapes: plain `'en'`, Editor `{ value, label }`, site.yml `{ code, label }`.
-  return langs.map((l) => (typeof l === 'string' ? l : l?.value || l?.code)).filter(Boolean)
+// The site's deploy.yml-bound backend origin (for the resolved `uniweb` target),
+// or null when there's no deploy.yml, the target isn't Uniweb hosting, or no
+// backend was recorded. Site verbs pass this to BackendClient as `siteBackend`
+// so a site stays bound to the backend it publishes to — deploy.yml is the
+// record of *where* a site is deployed (the 98% case is uniweb.app, but a B2B
+// university backend is just a `backend:` on the target). Sits below --backend
+// and UNIWEB_REGISTER_URL but above the logged-in session in the resolution
+// ladder (see resolveBackendOrigin). Best-effort: any read/parse error → null.
+export async function resolveSiteBackend(siteDir) {
+  try {
+    const deployYml = await loadDeployYml(siteDir)
+    const resolved = resolveTarget(deployYml, null)
+    return resolved.host === 'uniweb' ? (resolved.config?.backend || null) : null
+  } catch {
+    return null
+  }
 }

package/src/commands/export.js

@@ -3,7 +3,8 @@
  *
  * Produces a self-contained, vite-built site artifact in `dist/` for
  * hosting on a third-party CDN (Netlify, Vercel, GitHub Pages, S3 +
- * CloudFront, etc.). Does NOT upload anywhere — that's `uniweb deploy`.
+ * CloudFront, etc.). Does NOT upload anywhere — `uniweb deploy --host`
+ * uploads to a third-party host; `uniweb publish` ships to Uniweb hosting.
  *
  * The `dist/` output bundles the runtime + foundation + content into
  * concatenated packaging, with a vite-built `index.html` + `entry.js` +
@@ -12,7 +13,8 @@
  * Internally this is `uniweb build --bundle` plus user guidance for the
  * upload step. The `--link` / `--bundle` flag pair is internal-only
  * vocabulary now (Phase 2 of the CLI ergonomics overhaul); users see
- * `uniweb deploy` (uniweb-edge) and `uniweb export` (third-party host).
+ * `uniweb publish` (Uniweb hosting), `uniweb deploy --host` (third-party),
+ * and `uniweb export` (self-contained artifact).
  *
  * Usage:
  *   uniweb export                          Produce dist/ for static hosting
@@ -102,5 +104,5 @@ export async function exportSite(args = []) {
   console.log(`    ${c.dim}Vercel:${c.reset}  ${c.cyan}vercel --prod${c.reset}`)
   console.log(`    ${c.dim}S3:${c.reset}      ${c.cyan}aws s3 sync dist/ s3://your-bucket/${c.reset}`)
   console.log('')
-  console.log(`  ${c.dim}For Uniweb-hosted sites instead, use ${c.reset}${c.cyan}uniweb deploy${c.reset}${c.dim}.${c.reset}`)
+  console.log(`  ${c.dim}For Uniweb hosting instead, use ${c.reset}${c.cyan}uniweb publish${c.reset}${c.dim}.${c.reset}`)
 }