uniweb 0.12.34 → 0.12.36

package/src/commands/runtime.js

@@ -76,7 +76,7 @@ export async function runtime(args = []) {
   }
 
   // Version from the SPA build's manifest (the backend keys the version on it);
-  // --version overrides, parity with `uniwebd runtime install --version`.
+  // --version overrides, parity with the backend's runtime install --version.
   let version = readFlagValue(rest, '--version')
   if (!version) {
     try {

package/src/commands/status.js

@@ -0,0 +1,193 @@
+/**
+ * uniweb status — show how a site's local files compare to the Uniweb backend:
+ * its sync identity, unpushed content changes, and the foundation it references.
+ *
+ * LOCAL + OFFLINE by default: it builds the sync packages with an OFFLINE Model
+ * resolver and diffs them against the send-only-changed cache (the same diff
+ * `uniweb push` runs) — no auth, no backend round-trip.
+ *
+ * `--remote` adds the backend signals (may prompt for login, like `git fetch`):
+ *   - whether the synced draft differs from what's live (publish needed), and
+ *   - whether a newer foundation version is registered than the site pins.
+ * Those use ASSUMED endpoints (see kb shipping-verbs-and-freshness.md §6.5); until
+ * the backend exposes them, `--remote` degrades silently to the local view.
+ *
+ * Usage:
+ *   uniweb status            Sync identity + unpushed content + foundation ref (local)
+ *   uniweb status --remote   Also: draft-vs-live + a newer-registered-foundation check
+ *   uniweb status --json     One JSON line (adds a `remote` object under --remote)
+ *
+ * Run from a site, or a workspace with one site.
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import yaml from 'js-yaml'
+
+import { resolveSiteDir, resolveSiteBackend } from './deploy.js'
+import { probeUnpushed } from '../backend/site-sync.js'
+import { BackendClient } from '../backend/client.js'
+import { readFlagValue } from '../utils/args.js'
+import { resolveLocalFoundation } from '../backend/foundation-bring-along.js'
+import { computeFoundationDigest } from '../utils/code-upload.js'
+
+const c = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  cyan: '\x1b[36m', green: '\x1b[32m', yellow: '\x1b[33m',
+}
+const say = {
+  ok: (m) => console.log(`${c.green}✓${c.reset} ${m}`),
+  info: (m) => console.log(`${c.cyan}→${c.reset} ${m}`),
+  warn: (m) => console.log(`${c.yellow}⚠${c.reset} ${m}`),
+  dim: (m) => console.log(`  ${c.dim}${m}${c.reset}`),
+}
+
+function readSiteYml(siteDir) {
+  const p = join(siteDir, 'site.yml')
+  if (!existsSync(p)) return {}
+  try {
+    return yaml.load(readFileSync(p, 'utf8')) || {}
+  } catch {
+    return {}
+  }
+}
+
+function foundationRef(siteYml) {
+  const f = siteYml.foundation
+  if (!f) return null
+  return typeof f === 'string' ? f : f.ref || null
+}
+
+// A versioned registry ref `@org/name@1.2.3` → its scoped name `@org/name` and
+// pinned version `1.2.3`. A bare/local/unversioned ref → nulls.
+function splitFoundationRef(fnd) {
+  if (!fnd || fnd[0] !== '@') return { scope: null, version: null }
+  const at = fnd.lastIndexOf('@')
+  return at > 0 ? { scope: fnd.slice(0, at), version: fnd.slice(at + 1) } : { scope: null, version: null }
+}
+
+export async function status(args = []) {
+  const jsonMode = args.includes('--json')
+  const remote = args.includes('--remote')
+  const siteDir = await resolveSiteDir(args, 'status')
+  const siteYml = readSiteYml(siteDir)
+  const uuid = siteYml.$uuid || null
+  const fnd = foundationRef(siteYml)
+  const { scope: fndScope, version: fndVersion } = splitFoundationRef(fnd)
+
+  // Local content diff — builds the sync packages, never authenticates.
+  let probe = null
+  let probeErr = null
+  try {
+    probe = await probeUnpushed(siteDir)
+  } catch (err) {
+    probeErr = err.message
+  }
+
+  // Remote signals — opt-in (`--remote`). May prompt for login. Degrades to null
+  // on 404 / any failure, so a backend without the endpoints just shows local.
+  let site = null
+  let fdnLatest = null
+  let foundationFresh = null // true/false when both digests are known; else null
+  if (remote) {
+    try {
+      const client = new BackendClient({
+        originFlag: readFlagValue(args, '--backend') || readFlagValue(args, '--registry'),
+        siteBackend: await resolveSiteBackend(siteDir),
+        token: readFlagValue(args, '--token') || undefined,
+        args,
+        command: 'Status',
+      })
+      if (uuid) site = await client.siteStatus(uuid)
+      // Foundation freshness: prefer the LOCAL foundation's scoped name (so a
+      // local-foundation site can be checked too); fall back to a scoped
+      // site.yml ref. The digest compare is read-only — it never builds, so it
+      // only fires when the local foundation is already built (dist present).
+      const local = resolveLocalFoundation(siteDir, siteYml)
+      const lookupName = local?.scopedName || fndScope
+      if (lookupName) fdnLatest = await client.readFoundationLatest(lookupName)
+      if (local?.dir && fdnLatest?.digest) {
+        const localDigest = computeFoundationDigest(join(local.dir, 'dist'))
+        if (localDigest) foundationFresh = localDigest === fdnLatest.digest
+      }
+    } catch {
+      // degrade silently
+    }
+  }
+
+  if (jsonMode) {
+    console.log(
+      JSON.stringify({
+        synced: Boolean(uuid),
+        uuid,
+        foundation: fnd,
+        changed: probe ? probe.changed : null,
+        unchanged: probe ? probe.unchanged : null,
+        ...(probeErr ? { error: probeErr } : {}),
+        ...(remote ? { remote: { site, foundation_latest: fdnLatest?.latest_version ?? null, foundation_fresh: foundationFresh } } : {}),
+      })
+    )
+    return { exitCode: 0 }
+  }
+
+  console.log('')
+
+  // Sync identity
+  if (uuid) {
+    say.ok(`Synced — site-content ${c.bold}${uuid}${c.reset}`)
+  } else {
+    say.warn('Not synced — this site has never been pushed to a backend.')
+    say.dim('Run `uniweb push` to create it, or `uniweb publish` to sync and go live in one step.')
+  }
+
+  // Content
+  if (probeErr) {
+    say.warn(`Couldn't compute content changes: ${probeErr}`)
+    say.dim('A build error or an unresolved data Model can block the offline diff.')
+  } else if (!uuid) {
+    const n = probe.changed
+    say.info(`${n} content ${n === 1 ? 'entity' : 'entities'} ready to push.`)
+  } else if (probe.changed === 0) {
+    say.ok('Content is in sync with the last push.')
+  } else {
+    const n = probe.changed
+    say.info(
+      `${c.bold}${n}${c.reset} content ${n === 1 ? 'entity' : 'entities'} not pushed` +
+        (probe.unchanged ? ` (${probe.unchanged} unchanged)` : '') +
+        '.'
+    )
+    say.dim('Run `uniweb publish` to sync and go live (or `uniweb push` to sync only).')
+  }
+
+  // Foundation
+  if (fnd) say.dim(`Foundation: ${fnd}`)
+
+  // Remote signals
+  if (remote) {
+    if (site) {
+      if (site.draft_dirty) {
+        say.info('Synced draft has changes not yet live — run `uniweb publish` to go live.')
+      } else if (site.published) {
+        say.ok('Live with the latest synced content.')
+      } else {
+        say.info('Synced but not published yet — run `uniweb publish` to go live.')
+      }
+    }
+    if (fdnLatest?.latest_version && fndVersion && fdnLatest.latest_version !== fndVersion) {
+      say.info(`A newer foundation version (${fdnLatest.latest_version}) is registered than the site pins (${fndVersion}).`)
+    }
+    if (foundationFresh === false) {
+      say.info('Local foundation differs from the registered version — `uniweb register` (or `uniweb publish`) to release the change.')
+    } else if (foundationFresh === true) {
+      say.ok('Local foundation matches the registered version.')
+    }
+    if (!site && !fdnLatest) {
+      say.dim('(No remote signals — the backend may not expose them yet.)')
+    }
+  }
+
+  console.log('')
+  return { exitCode: 0 }
+}
+
+export default status

package/src/framework-index.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-06-23T17:13:47.118Z",
+  "generatedAt": "2026-06-25T01:51:21.593Z",
   "packages": {
     "@uniweb/build": {
-      "version": "0.14.17",
+      "version": "0.14.19",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -20,7 +20,7 @@
       "deps": []
     },
     "@uniweb/content-writer": {
-      "version": "0.2.5",
+      "version": "0.2.6",
       "path": "framework/content-writer",
       "deps": []
     },
@@ -99,7 +99,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.4.23",
+      "version": "0.4.25",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",

package/src/index.js

@@ -606,8 +606,10 @@ async function main() {
     process.exit(result?.exitCode ?? 0)
   }
 
-  // Handle register command (dynamic import — depends on @uniweb/build)
-  if (command === 'register') {
+  // Handle register command (dynamic import — depends on @uniweb/build).
+  // `release` is a code-only synonym: `register` reads naturally the first
+  // time, `release` for updates (shipping-model.md §6.1). Same act, same code.
+  if (command === 'register' || command === 'release') {
     const { register } = await importProjectCommand('./commands/register.js')
     const result = await register(args.slice(1))
     process.exit(result?.exitCode ?? 0)
@@ -627,6 +629,13 @@ async function main() {
     process.exit(result?.exitCode ?? 0)
   }
 
+  // Handle status command (dynamic import — offline emit via @uniweb/build)
+  if (command === 'status') {
+    const { status } = await importProjectCommand('./commands/status.js')
+    const result = await status(args.slice(1))
+    process.exit(result?.exitCode ?? 0)
+  }
+
   // Handle clone command (global — bootstraps a new project from a backend site;
   // STANDALONE, so a global `uniweb clone` runs here instead of delegating to a
   // project-local CLI that doesn't exist yet. clone.js avoids any static
@@ -663,15 +672,16 @@ async function main() {
     return
   }
 
-  // Handle publish command — CMS-publish a SYNCED site (POST /dev/site/publish).
-  // Distinct from `deploy` (file-built host) and `register` (foundation publishing).
+  // Handle publish command — the smart Uniweb-hosting path: bring the
+  // foundation along, sync, settle payment, go live. Distinct from `deploy`
+  // (third-party hosts) and `register`/`release` (foundation code → catalog).
   if (command === 'publish') {
     const { publish } = await importProjectCommand('./commands/publish.js')
     const result = await publish(args.slice(1))
     process.exit(result?.exitCode ?? 0)
   }
 
-  // Handle deploy command (dynamic import — depends on @uniweb/build)
+  // Handle deploy command — third-party hosts only (dynamic import — @uniweb/build)
   if (command === 'deploy') {
     const { deploy } = await importProjectCommand('./commands/deploy.js')
     await deploy(args.slice(1))
@@ -1079,18 +1089,26 @@ async function main() {
  * without loading @uniweb/build or any project context.
  */
 function printCommandHelp(command) {
+  // `release` is a synonym of `register` (shipping-model.md §6.1) — show the
+  // same help block.
+  if (command === 'release') command = 'register'
   const blocks = {
     deploy: `
-${colors.cyan}${colors.bright}uniweb deploy${colors.reset} ${colors.dim}— Deploy a site${colors.reset}
+${colors.cyan}${colors.bright}uniweb deploy${colors.reset} ${colors.dim}— Ship a site to its resolved target${colors.reset}
 
 ${colors.bright}Usage:${colors.reset}
-  uniweb deploy [options]
+  uniweb deploy --host <name> [options]
 
-The host is determined by the resolved deploy.yml target. Defaults to
-${colors.cyan}uniweb${colors.reset} hosting (link-mode, edge JIT prerender) when no deploy.yml exists.
+Ships a site to its resolved target. A THIRD-PARTY host builds dist/ (bundle
+mode) and hands it to a host adapter for upload + invalidation. A UNIWEB target
+(\`--host=uniweb\`, or a \`uniweb\` target in deploy.yml) delegates to
+${colors.cyan}uniweb publish${colors.reset} (sync + dynamic serving; brings the foundation along) — the
+canonical direct verb for Uniweb hosting. With no host chosen, deploy prompts for
+a third-party adapter. For a self-contained dist/ you upload yourself, use
+${colors.cyan}uniweb export${colors.reset}.
 
 ${colors.bright}Hosts:${colors.reset}
-  uniweb              Uniweb hosting (default; requires \`uniweb login\`)
+  uniweb              Uniweb hosting (delegates to \`uniweb publish\`)
   cloudflare-pages    Cloudflare Pages (build artifact + adapter postBuild)
   netlify             Netlify (alias of cloudflare-pages adapter)
   vercel              Vercel (build-only — deploy via \`npx vercel\`)
@@ -1099,43 +1117,40 @@ ${colors.bright}Hosts:${colors.reset}
   generic-static      Plain static-host build, no host-specific helpers
 
 ${colors.bright}Options:${colors.reset}
+  --host <name>       The host to ship to (no value → interactive third-party picker, TTY only)
   --target <name>     Pick a target from deploy.yml (default: deploy.yml's \`default:\`)
-  --host <name>       Override the resolved target's host (does not persist)
-  --host              No value → interactive picker (TTY only)
-  --dry-run           Resolve site.yml + foundation/runtime; print summary; no writes
-  --no-auto-publish   Don't auto-publish workspace-local foundation as part of deploy
+  --dry-run           Resolve the target + adapter; print summary; upload nothing
   --no-save           Skip the auto-save of lastDeploy in deploy.yml
-  --backend <url>     Override the default backend origin (\$UNIWEB_REGISTER_URL or built-in)
   --non-interactive   Fail with usage info instead of prompting
 
-${colors.bright}Auth:${colors.reset}
-  \`host: uniweb\` requires authentication. Run \`uniweb login\` first, set
-  \`UNIWEB_TOKEN=<bearer>\` env var, or use a static-host adapter that
-  doesn't need a Uniweb account. CI / agents / piped stdin auto-detect
-  non-interactive mode and bail with an actionable error instead of
-  hanging on a browser callback.
-
 ${colors.bright}Examples:${colors.reset}
-  uniweb deploy                              # Default (host=uniweb)
-  uniweb deploy --dry-run                    # Print summary, no writes
-  uniweb deploy --host=cloudflare-pages      # One-off override
-  uniweb deploy --target=preview             # Pick named target from deploy.yml
+  uniweb deploy --host=cloudflare-pages      # Build + upload to Cloudflare Pages
+  uniweb deploy --host=s3-cloudfront         # Build + upload + invalidate
+  uniweb deploy --host=uniweb                # → delegates to \`uniweb publish\`
+  uniweb deploy --target=preview             # Named target from deploy.yml
 `,
     publish: `
-${colors.cyan}${colors.bright}uniweb publish${colors.reset} ${colors.dim}— Publish a synced site (make its backend state live)${colors.reset}
+${colors.cyan}${colors.bright}uniweb publish${colors.reset} ${colors.dim}— Publish a site to Uniweb hosting (the smart path)${colors.reset}
 
 ${colors.bright}Usage:${colors.reset}
   uniweb publish [options]
 
-Publishes a site that's synced to the backend (has site.yml::\$uuid from
-\`uniweb push\`) — makes its CURRENT backend state live, including edits made
-through the app. Run \`uniweb push\` first to include local edits. For a
-file-only site use \`uniweb deploy\`; to register a FOUNDATION use \`uniweb register\`.
+The most ergonomic command in the tool: \`uniweb login && uniweb publish\` reads
+your project and makes the site live on Uniweb hosting. It resolves which site,
+BRINGS THE FOUNDATION ALONG (releases the local foundation when its code
+changed), syncs content, settles payment when go-live needs it (a browser
+handoff), and goes live. A published-registry foundation needs no release; an
+already-paid site opens no browser.
+
+For a third-party host use \`uniweb deploy --host=<name>\`; to register a
+FOUNDATION on its own use \`uniweb register\` (alias \`uniweb release\`).
 
 ${colors.bright}Options:${colors.reset}
+  --dry-run          Resolve everything; release/sync/POST nothing
+  --yes              Skip confirmations (CI); never block on a prompt
+  --no-save          Skip the deploy.yml lastDeploy auto-save
   --backend <url>    Backend origin (default: \$UNIWEB_REGISTER_URL or built-in)
   --token <bearer>   Auth bearer (skips \`uniweb login\`)
-  --dry-run          Resolve everything; POST nothing
 `,
     create: `
 ${colors.cyan}${colors.bright}uniweb create${colors.reset} ${colors.dim}— Create a new project${colors.reset}
@@ -1269,15 +1284,18 @@ ${colors.bright}Options:${colors.reset}
 Exit codes: 0 clean (or warn-only), 1 violations under --strict, 2 setup error.
 `,
     register: `
-${colors.cyan}${colors.bright}uniweb register${colors.reset} ${colors.dim}— Register a foundation + its data schemas with the backend registry${colors.reset}
+${colors.cyan}${colors.bright}uniweb register${colors.reset} ${colors.dim}— Register (release) a foundation + its data schemas with the backend registry${colors.reset}
 
 ${colors.bright}Usage:${colors.reset}
   uniweb register [options]
+  uniweb release  [options]      ${colors.dim}(synonym — reads naturally for updates)${colors.reset}
 
 Builds one \`.uwx\` document and submits it to the registry over HTTP. Run
-\`uniweb login\` first (or pass \`--token\`). \`register\` is for FOUNDATIONS (and
-schemas); \`uniweb publish\` makes a synced SITE live; \`uniweb deploy\` hosts a
-file-built site.
+\`uniweb login\` first (or pass \`--token\`). \`register\`/\`release\` are for
+FOUNDATIONS (and schemas) — code only; \`uniweb publish\` makes a synced SITE
+live (and brings its foundation along); \`uniweb deploy\` hosts on a third-party
+host. \`register\` and \`release\` are the same act: \`register\` reads naturally
+the first time, \`release\` for updates.
 
 Auto-detects what you run it in:
   • a foundation        the foundation + the data schemas it defines/renders
@@ -1293,7 +1311,7 @@ ${colors.bright}Options:${colors.reset}
   --scope @org       Publish under @org (resolves @/x -> @org/x); default: package.json uniweb.scope
   --dry-run          Print the .uwx; submit nothing
   -o, --output <f>   Write the .uwx to a file; submit nothing
-  --registry <url>   Submit endpoint (default: \$UNIWEB_REGISTER_URL or a local URL)
+  --backend <url>    Backend origin (alias: --registry; default: \$UNIWEB_REGISTER_URL or a local URL)
   --token <bearer>   Submit with this bearer; skips \`uniweb login\` (or set UNIWEB_TOKEN)
   --non-interactive  Fail with usage info instead of prompting
 
@@ -1463,13 +1481,15 @@ ${colors.bright}Commands:${colors.reset}
   rename <type>      Rename a foundation, site, or extension across the workspace
   dev                Start a dev server for a site
   build              Build the current project
-  deploy             Deploy a site to Uniweb hosting
+  publish            Publish a site to Uniweb hosting (smart: foundation + sync + go live)
+  deploy             Deploy a site to a third-party host (--host=<adapter>)
   export             Export a self-contained site for third-party hosting
-  publish            Publish a synced site (make its backend state live)
   register           Register a foundation + its data schemas with the backend registry
+  release            Release a foundation version (synonym of register)
   runtime register   Register an @uniweb/runtime version to the backend (@std only)
   push               Push a site's content to the backend
   pull               Pull a site's content from the backend
+  status             Show a site's sync state (unpushed content, foundation)
   inspect <path>     Inspect parsed content shape of a markdown file or folder
   docs               Generate component documentation
   doctor             Diagnose project configuration issues
@@ -1498,21 +1518,24 @@ ${colors.bright}Global Options:${colors.reset}
                        Auto-detected when CI=true or no TTY (pipes, agents)
 
 ${colors.bright}Publish Options:${colors.reset}
+  --dry-run          Resolve everything; release/sync/POST nothing
+  --yes              Skip confirmations (CI); never block on a prompt
+  --no-save          Skip the deploy.yml lastDeploy auto-save
   --backend <url>    Backend origin (default: \$UNIWEB_REGISTER_URL or built-in)
   --token <bearer>   Auth bearer (skips \`uniweb login\`)
-  --dry-run          Resolve everything; POST nothing
 
-  uniweb publish makes a SYNCED site live (run \`uniweb push\` first). To register
-  a foundation use \`uniweb register\`; to host a file-built site use \`uniweb deploy\`.
+  uniweb publish is the smart Uniweb-hosting path: it brings the site's
+  foundation along, syncs, and goes live. To register a foundation on its own
+  use \`uniweb register\` (alias \`uniweb release\`); for a third-party host use
+  \`uniweb deploy --host=<name>\`.
 
 ${colors.bright}Deploy Options:${colors.reset}
+  --host <name>      The host to ship to (no value → interactive third-party
+                     picker, TTY only). Third-party: cloudflare-pages, netlify,
+                     vercel, github-pages, s3-cloudfront, generic-static.
+                     \`--host=uniweb\` delegates to \`uniweb publish\`.
   --target <name>    Pick a target from deploy.yml (default: deploy.yml's \`default:\`)
-  --host <name>      Override the resolved target's host (does not persist).
-                     Without a value, opens an interactive picker (TTY only).
-                     Hosts: uniweb, cloudflare-pages, netlify, vercel,
-                     github-pages, s3-cloudfront, generic-static.
-  --dry-run          Resolve site.yml + foundation/runtime; print summary; no writes
-  --no-auto-publish  Don't auto-publish workspace-local foundation as part of deploy
+  --dry-run          Resolve the target + adapter; print summary; upload nothing
   --no-save          Skip the auto-save of lastDeploy in deploy.yml
 
 ${colors.bright}Dev Options:${colors.reset}

package/src/utils/asset-upload.js

@@ -1,8 +1,8 @@
 /**
- * Site asset delivery — the asset lane for `uniweb deploy` (channel
+ * Site asset delivery — the asset lane for `uniweb publish` (channel
  * framework-backend-f90d). After the link build processes a site's media into
  * `dist/assets/`, those bytes are delivered to the backend's content-addressed
- * asset store, and the deploy step rewrites the content's local refs to durable
+ * asset store, and the publish step rewrites the content's local refs to durable
  * serve URLs:
  *
  *   1. PLAN   — POST {apiBase}/dev/assets with the file list ({ path,
@@ -147,7 +147,7 @@ export async function uploadSiteAssets({ apiBase, token, distDir, files, onProgr
     onProgress(`↑ ${src.path}`)
     let putRes
     try {
-      // The plan's url may be origin-relative (direct mode → uniwebd) or
+      // The plan's url may be origin-relative (direct mode → the backend) or
       // absolute (presigned → storage); new URL() resolves both.
       putRes = await fetch(new URL(up.url, origin), { method: up.method || 'PUT', headers, body: src.bytes ?? readFileSync(src.diskPath) })
     } catch (err) {

package/src/utils/code-upload.js

@@ -8,7 +8,7 @@
  *   1. PLAN   — POST {apiBase}/dev/registry/code-uploads with the file list
  *               ({ path, content_type, size, sha256? }). The response carries
  *               one upload target per file ({ path, method, url, headers })
- *               plus mode: 'direct' (dev — URLs point back at uniwebd) or
+ *               plus mode: 'direct' (dev — URLs point back at the backend) or
  *               'presigned' (prod — storage PUTs; bytes never transit the
  *               backend). The CLI never branches on the mode.
  *   2. UPLOAD — PUT each file's raw bytes to its URL with the given headers.
@@ -35,7 +35,7 @@
  */
 
 import { createHash } from 'node:crypto'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 
 // Extension → declared content type. Extension-honest by construction (Vite
@@ -111,6 +111,46 @@ export function uploadOrder(files) {
   return [...rest, ...entry]
 }
 
+/**
+ * The deterministic content digest of a built foundation — the freshness
+ * fingerprint `register` records and `publish`/`status` later compare against
+ * (shipping-model.md §4.1). It answers one question — "did the foundation change
+ * since it was released?" — with NO local state, so it has to be reproducible:
+ * the same source, built on any machine, must yield the same digest.
+ *
+ * Algorithm (§4.1): `sha256` over the newline-joined, SORTED list of the
+ * per-file `sha256` (hex) of exactly what `register` ships for a foundation —
+ *   - the code-upload set (`collectDistFiles`: entry + chunks + assets, with
+ *     `meta/**` and `*.map` already excluded), and
+ *   - the schema source (`meta/schema.json`) — NOT uploaded as a file, and not
+ *     sent verbatim: register submits its *content* as the foundation-schema
+ *     ENTITY in the `.uwx`. It's read here only to fold the schema into the
+ *     local freshness fingerprint (so a schema edit shows as "changed").
+ * Hashes are SORTED (so the digest is order-independent) and taken over file
+ * CONTENTS, not names, so content-hashed chunk filenames don't perturb it.
+ * Returns null when there's nothing to hash (no usable dist), so callers skip
+ * cleanly rather than fingerprinting emptiness.
+ *
+ * The result is OPAQUE to the backend — it stores the string and returns it
+ * verbatim; the framework owns the algorithm end-to-end and can change it
+ * freely (a digest only ever compares against one the same CLI computed).
+ *
+ * @param {string} distDir - the built `dist/` directory
+ * @returns {string|null} `sha256:<hex>` or null when there's nothing to hash
+ */
+export function computeFoundationDigest(distDir) {
+  const hashes = collectDistFiles(distDir).map((f) => f.sha256)
+  // The schema rides in the register `.uwx`, not the code-upload set, so fold
+  // it in explicitly — a schema-only change is still a foundation change.
+  const schemaPath = join(distDir, 'meta', 'schema.json')
+  if (existsSync(schemaPath)) {
+    hashes.push(createHash('sha256').update(readFileSync(schemaPath)).digest('hex'))
+  }
+  if (!hashes.length) return null
+  hashes.sort()
+  return 'sha256:' + createHash('sha256').update(hashes.join('\n')).digest('hex')
+}
+
 /**
  * The gateway serve URL for a file of a registered foundation version.
  * Mirrors the backend storage convention: scope WITHOUT the '@'.
@@ -180,7 +220,7 @@ export async function uploadFoundationCode({
   const plan = await planRes.json()
   const targets = new Map((plan.uploads || []).map((u) => [u.path, u]))
   const serveBase = plan.serve_base || null
-  // The ONE mode-aware bit: direct-mode PUTs are bearer-authed uniwebd
+  // The ONE mode-aware bit: direct-mode PUTs are bearer-authed backend
   // routes; presigned URLs are self-authorizing and must NOT carry a
   // bearer (foreign auth headers can break signed-request validation).
   const authHeaders = plan.mode === 'direct' ? { Authorization: `Bearer ${token}` } : {}

package/src/utils/config.js

@@ -49,14 +49,35 @@ function readCliConfig() {
   return _cliConfig
 }
 
+/**
+ * The origin the LAST `uniweb login` authenticated against — persisted on the
+ * session record so subsequent verbs default to the backend you logged into
+ * (no `--backend` per command). Sync read; null when there's no session or it
+ * carries no origin (older sessions). Read directly (not via registry-auth.js)
+ * to keep this module off the optional-peer / import-cycle path.
+ * @returns {string|null}
+ */
+function readSessionOrigin() {
+  try {
+    const p = join(homedir(), '.uniweb', 'registry-auth.json')
+    if (!existsSync(p)) return null
+    const o = JSON.parse(readFileSync(p, 'utf8'))?.origin
+    return o || null
+  } catch {
+    return null
+  }
+}
+
 /**
  * Get the backend's API base origin. `register` POSTs to
  * {origin}/dev/registry/register, `login` to {origin}/dev/auth/login, etc.
- * (BackendClient.resolveBackendOrigin layers the --backend/--registry flag on
- * top of this.)
+ * (BackendClient.resolveBackendOrigin layers the --backend flag and a site's
+ * deploy.yml backend on top of this.)
  *
- * Priority: UNIWEB_REGISTER_URL's origin > ~/.uniweb/config.json registryApiUrl
- * > local default.
+ * Priority: UNIWEB_REGISTER_URL's origin > the logged-in session origin >
+ * ~/.uniweb/config.json registryApiUrl > the default (uniweb.app). Local dev
+ * points at a local backend EXPLICITLY (--backend / UNIWEB_REGISTER_URL /
+ * `uniweb login --backend …`), rather than the default being localhost.
  * @returns {string}
  */
 export function getRegistryApiBaseUrl() {
@@ -64,11 +85,15 @@ export function getRegistryApiBaseUrl() {
   if (fromEnv) {
     try { return new URL(fromEnv).origin } catch { /* fall through */ }
   }
+  const fromSession = readSessionOrigin()
+  if (fromSession) {
+    try { return new URL(fromSession).origin } catch { return fromSession }
+  }
   const fromCfg = readCliConfig().registryApiUrl
   if (fromCfg) {
     try { return new URL(fromCfg).origin } catch { return fromCfg }
   }
-  return 'http://localhost:8080'
+  return 'https://uniweb.app'
 }
 
 /**