uniweb 0.13.17 → 0.14.1

package/README.md

@@ -360,7 +360,7 @@ Markdown in a git repo and content in the Uniweb apps can share the same site. D
 
 ---
 
-Both paths use the same framework. The difference is who edits content, where it lives, and what gets deployed. For the deeper menu — site-bound vs cataloged foundations, S3+CloudFront, manual exports, per-host recipes, foundation propagation — see → **[Deploying](https://github.com/uniweb/docs/blob/main/development/deploying.md)**.
+Both paths use the same framework. The difference is who edits content, where it lives, and what gets deployed. For the deeper menu — standalone vs cataloged foundations, S3+CloudFront, manual exports, per-host recipes, foundation propagation — see → **[Deploying](https://github.com/uniweb/docs/blob/main/development/deploying.md)**.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.13.17",
+  "version": "0.14.1",
   "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.34",
-    "@uniweb/kit": "0.9.46",
-    "@uniweb/runtime": "0.8.42"
+    "@uniweb/core": "0.8.0",
+    "@uniweb/kit": "0.10.1",
+    "@uniweb/runtime": "0.9.0"
   },
   "peerDependencies": {
-    "@uniweb/build": "0.15.14",
-    "@uniweb/content-reader": "1.1.19",
-    "@uniweb/semantic-parser": "1.1.21"
+    "@uniweb/build": "0.16.0",
+    "@uniweb/content-reader": "1.2.0",
+    "@uniweb/semantic-parser": "1.2.0"
   },
   "peerDependenciesMeta": {
     "@uniweb/build": {

package/partials/agents.md

@@ -468,8 +468,12 @@ Optional attributes: `{size=20}`, `{color=red}`. Custom SVGs: `![Logo](./logo.sv
 [text](url){target=_blank}              <!-- Open in new tab -->
 [text](./file.pdf){download}            <!-- Download -->
 ![alt](./img.jpg){role=banner}          <!-- Role determines array: images, icons, or videos -->
+![alt](./demo.mp4){role=video}          <!-- → content.videos[], not content.images[] -->
+![alt](./img.jpg){href=/products}       <!-- Clickable media: href + target ride along -->
 ```
 
+Sizing and loading ride on the image: `{width=800 height=600 loading=lazy fit=cover position=center}`. A video adds `{poster=./thumb.jpg autoplay muted loop controls}`; a `{role=pdf}` document adds `{preview=./cover.jpg author=… description=…}`.
+
 **Quote values containing spaces:** `{note="Ready to go"}`, not `{note=Ready to go}` — unquoted values end at the first space.
 
 **Separators are forgiving.** `:` works wherever `=` does, and pairs may be separated by whitespace, a comma, or both — `{role=banner width=1200}`, `{role:banner, width:1200}` and `{role:banner,width:1200}` are identical. `=` and spaces are canonical, and that is what gets written back on save. Two rules keep it unambiguous: the separator must **touch** the key (`{note:warning}` is one pair, `{note : warning}` is two flags), and a value containing a **comma** must be quoted (`{style="a, b"}`). A value containing a colon needs no quoting — only the first colon separates, so `{href:https://example.com}` is fine.
@@ -493,6 +497,10 @@ This is [less important]{muted} context.
 
 Sites can adjust these or add named styles in `theme.yml`'s `inline:` section. Overrides merge **property by property**, so declare only what differs (`accent: { font-weight: inherit }` keeps the default color); to drop a default property rather than change it, give it a neutral value (`initial`, `inherit`, `unset`).
 
+> **On a site synced with Uniweb Cloud, the built-in style names round-trip *editable*** — an author who opens a page containing `[Get started]{accent}` gets the editor's own styling control for it, and can change or remove it like any text they styled there.
+>
+> **A name the editor doesn't know is preserved exactly, but not editable** — a style you defined yourself in `inline:`, two names on one span, or a `class`/`id` set. Nothing is lost and nothing is approximated: it survives every edit and save untouched, the editor simply offers no control for it. That is a permanent property rather than a gap, because the name set is open by design — you can add styles the editor has no way to know about.
+
 ### Fenced code: data blocks vs snippets
 
 Fenced code serves two purposes depending on whether it carries a tag.
@@ -630,6 +638,49 @@ seo:
 
 **Localized URLs:** on a multilingual site (`languages:` in site.yml), `slug: { <lang>: <segment> }` gives a page a native URL segment per language; the folder name stays the canonical route. Nested folders compose automatically, and localized URLs flow through navigation, the language switcher, and the sitemap. See Part 5 for the translation workflow.
 
+### Your site is readable by agents, automatically
+
+Every build emits two things an AI agent can use directly, alongside the HTML. **Free, on by default, nothing to install.**
+
+| Artifact | What it is |
+|---|---|
+| `/llms.txt` | An annotated index of the site — every page, with a one-line description, linking to the `.md` below |
+| `/{route}.md` | Each page as clean markdown: the content, no navigation, no chrome |
+
+The point is the pair. An agent fetches the index, *reads* what each page is about, and goes straight to the one it needs — two requests, no HTML stripping, no guessing at URLs. Descriptions come from `page.yml`'s `description:`, then `seo.ogDescription`, then the page's opening paragraph, so a site usually gets a complete index without writing any of them.
+
+**Large sites also get per-branch indexes.** A branch with at least 5 pages gets its own — `/docs/llms.txt` lists just the docs, titled by that folder. The site index still lists everything; a branch index is an extra entry point, not a replacement, so an agent that starts at `/llms.txt` still reaches any page in two hops.
+
+```yaml
+# site.yml — all optional; these are the defaults
+agents:
+  index: true            # /llms.txt
+  markdown: true         # /{route}.md
+  branchIndexes: true    # /docs/llms.txt for branches big enough to want one
+  branchMinPages: 5      # how big is big enough
+  exclude: [/internal]   # keep a branch out of both (cascades)
+
+agents: false            # or turn the whole thing off in one word
+```
+
+**Set `seo.baseUrl` if you want absolute links** in the index — without it the links are root-relative, which still works for an agent that arrived via the index. `uniweb doctor` warns when it's unset.
+
+**What's excluded, and it's deliberate:** `seo.noindex` pages, `hidden` pages, `_`-prefixed drafts, and dynamic route templates. An index *describes* pages rather than merely listing them, so an unlinked page would become both discoverable and summarized — which is why these exclusions are load-bearing rather than tidy-up. `noindex` or `hidden` on a **folder** takes the whole branch with it.
+
+**Declaring how your content may be used** is a separate axis from whether it may be fetched, and it goes in `seo.robots`:
+
+```yaml
+# site.yml
+seo:
+  robots:
+    contentSignals:
+      search: true       # may appear in search results
+      ai-input: true     # may be retrieved at inference time
+      ai-train: false    # may not be used to train a model
+```
+
+That emits a `Content-Signal:` line in `robots.txt`. Declare only what you mean — an omitted signal says nothing, which is not the same as saying no.
+
 ### Collections and dynamic routes
 
 Most content lives in `pages/` — a fixed composition of sections on a fixed set of pages. **Collections are the other kind: repeating content managed as a set of files**, one item per file, that pages pull from. Blog posts, team members, products, case studies, bibliographies.

package/src/backend/client.js

@@ -28,8 +28,16 @@
  */
 
 import { getRegistryApiBaseUrl } from '../utils/config.js'
-import { ensureRegistryAuth, fetchMe, readRegistryAuth, isExpired } from '../utils/registry-auth.js'
-import { fetchOrgs as fetchOrgsImpl, createOrg as createOrgImpl } from '../utils/registry-orgs.js'
+import {
+  ensureRegistryAuth,
+  fetchMe,
+  readRegistryAuth,
+  isExpired
+} from '../utils/registry-auth.js'
+import {
+  fetchOrgs as fetchOrgsImpl,
+  createOrg as createOrgImpl
+} from '../utils/registry-orgs.js'
 import { uploadFoundationCode } from '../utils/code-upload.js'
 import { uploadSiteAssets } from '../utils/asset-upload.js'
 import { uploadRuntime } from '../utils/runtime-upload.js'
@@ -51,11 +59,26 @@ import { uploadRuntime } from '../utils/runtime-upload.js'
  * @returns {string} a bare origin with no trailing slash
  */
 export function resolveBackendOrigin(flag, { siteBackend } = {}) {
-  const norm = (v) => { try { return new URL(v).origin } catch { return null } }
-  if (flag) { const o = norm(flag); if (o) return o }
+  const norm = (v) => {
+    try {
+      return new URL(v).origin
+    } catch {
+      return null
+    }
+  }
+  if (flag) {
+    const o = norm(flag)
+    if (o) return o
+  }
   const env = process.env.UNIWEB_REGISTER_URL
-  if (env) { const o = norm(env); if (o) return o }
-  if (siteBackend) { const o = norm(siteBackend); if (o) return o }
+  if (env) {
+    const o = norm(env)
+    if (o) return o
+  }
+  if (siteBackend) {
+    const o = norm(siteBackend)
+    if (o) return o
+  }
   return getRegistryApiBaseUrl()
 }
 
@@ -67,12 +90,15 @@ export function resolveBackendOrigin(flag, { siteBackend } = {}) {
  * `runtime.installed` is empty so runtime resolution requires an explicit pin.
  */
 export const DISCOVERY_DEFAULTS = {
-  gatewayBase: '/gateway',
+  // No serve-root default. Serve locations are read from discovery or from an
+  // upload plan's `serve_base`; nothing here reconstructs one, so a default
+  // would be a route name with no consumer. (A `gatewayBase` entry lived here
+  // unread until 2026-07-29.)
   assetBase: 'https://assets.uniweb.app/',
   auth: { loginPath: '/dev/auth/login', required: true },
   delivery: { deploy: true, publish: true, broker: 'self-serve' },
   assets: { supported: false },
-  runtime: { installed: [] },
+  runtime: { installed: [] }
 }
 
 export class BackendClient {
@@ -88,8 +114,19 @@ export class BackendClient {
    * @param {string} [opts.command] - label for the login prompt ('Pushing', 'Registering', …)
    * @param {typeof fetch} [opts.fetchImpl] - injectable fetch (tests)
    */
-  constructor({ origin, originFlag, siteBackend, token, getToken, args = [], command = 'This command', fetchImpl } = {}) {
-    this.origin = (origin || resolveBackendOrigin(originFlag, { siteBackend })).replace(/\/+$/, '')
+  constructor({
+    origin,
+    originFlag,
+    siteBackend,
+    token,
+    getToken,
+    args = [],
+    command = 'This command',
+    fetchImpl
+  } = {}) {
+    this.origin = (
+      origin || resolveBackendOrigin(originFlag, { siteBackend })
+    ).replace(/\/+$/, '')
     this._token = token || process.env.UNIWEB_TOKEN || null
     this._getToken = getToken || null
     this._args = args
@@ -117,13 +154,25 @@ export class BackendClient {
       this._warnedOriginMismatch = true
       try {
         const stored = await readRegistryAuth()
-        if (stored?.token && !isExpired(stored) && stored.origin &&
-            stored.origin.replace(/\/+$/, '') !== this.origin) {
-          console.error(`\x1b[33m⚠\x1b[0m Logged in to ${stored.origin}, but this command targets ${this.origin} — the session may be rejected. Run \`uniweb login --backend ${this.origin}\`, or pass --token.`)
+        if (
+          stored?.token &&
+          !isExpired(stored) &&
+          stored.origin &&
+          stored.origin.replace(/\/+$/, '') !== this.origin
+        ) {
+          console.error(
+            `\x1b[33m⚠\x1b[0m Logged in to ${stored.origin}, but this command targets ${this.origin} — the session may be rejected. Run \`uniweb login --backend ${this.origin}\`, or pass --token.`
+          )
         }
-      } catch { /* advisory only */ }
+      } catch {
+        /* advisory only */
+      }
     }
-    this._token = await ensureRegistryAuth({ apiBase: this.origin, command: this._command, args: this._args })
+    this._token = await ensureRegistryAuth({
+      apiBase: this.origin,
+      command: this._command,
+      args: this._args
+    })
     return this._token
   }
 
@@ -143,7 +192,10 @@ export class BackendClient {
    * @param {boolean} [opts.auth=true]
    * @returns {Promise<Response>}
    */
-  async request(path, { method = 'GET', body, headers = {}, query, auth = true } = {}) {
+  async request(
+    path,
+    { method = 'GET', body, headers = {}, query, auth = true } = {}
+  ) {
     const url = new URL(path, this.origin)
     if (query) {
       for (const [k, v] of Object.entries(query)) {
@@ -154,7 +206,8 @@ export class BackendClient {
     if (auth) h.Authorization = `Bearer ${await this.token()}`
     if (body != null && h['Content-Type'] == null) {
       if (typeof body === 'string') h['Content-Type'] = 'application/json'
-      else if (body instanceof Uint8Array || Buffer.isBuffer(body)) h['Content-Type'] = 'application/zip'
+      else if (body instanceof Uint8Array || Buffer.isBuffer(body))
+        h['Content-Type'] = 'application/zip'
     }
     return this._fetch(url.href, { method, headers: h, body })
   }
@@ -167,7 +220,7 @@ export class BackendClient {
    * lifetime; a missing route or any transport/parse error falls back to
    * DISCOVERY_DEFAULTS (non-breaking — an older backend still works). Lets the
    * CLI hardcode nothing about a backend but its origin and discover the rest:
-   * `gatewayBase`/`assetBase` (serve/asset roots — relative ⇒ relative-to-origin),
+   * `assetBase` (the asset root — relative ⇒ relative-to-origin),
    * `auth`, `delivery` (deploy/publish? broker), `assets` (lane built yet?),
    * `runtime.installed` (the default-runtime source replacing the old /runtime/latest).
    * @returns {Promise<object>}
@@ -201,7 +254,10 @@ export class BackendClient {
    * @returns {Promise<Response>}
    */
   async register(uwxJson) {
-    return this.request('/dev/registry/register', { method: 'POST', body: uwxJson })
+    return this.request('/dev/registry/register', {
+      method: 'POST',
+      body: uwxJson
+    })
   }
 
   /**
@@ -210,7 +266,11 @@ export class BackendClient {
    * @param {object} opts - { name, version, distDir, files?, onProgress? }
    */
   async uploadFoundationCode(opts) {
-    return uploadFoundationCode({ apiBase: this.origin, token: await this.token(), ...opts })
+    return uploadFoundationCode({
+      apiBase: this.origin,
+      token: await this.token(),
+      ...opts
+    })
   }
 
   /**
@@ -223,7 +283,10 @@ export class BackendClient {
   async readDataSchema(modelName) {
     const res = await this.request(dataSchemaPath(modelName))
     if (res.status === 404) return null
-    if (!res.ok) throw new Error(`Model-read ${modelName} failed: HTTP ${res.status} ${res.statusText}`)
+    if (!res.ok)
+      throw new Error(
+        `Model-read ${modelName} failed: HTTP ${res.status} ${res.statusText}`
+      )
     return res.json()
   }
 
@@ -245,12 +308,17 @@ export class BackendClient {
     const m = /^@([^/]+)\/([^@/]+)/.exec(String(scopedName || ''))
     if (!m) return null
     try {
-      const res = await this.request(`/dev/registry/${encodeURIComponent(m[1])}/${encodeURIComponent(m[2])}`)
+      const res = await this.request(
+        `/dev/registry/${encodeURIComponent(m[1])}/${encodeURIComponent(m[2])}`
+      )
       if (!res.ok) return null
       const body = await res.json().catch(() => null)
       if (!body) return null
       // The read returns `version`; callers use `latest_version`. Tolerate both.
-      return { ...body, latest_version: body.latest_version ?? body.version ?? null }
+      return {
+        ...body,
+        latest_version: body.latest_version ?? body.version ?? null
+      }
     } catch {
       return null
     }
@@ -265,27 +333,74 @@ export class BackendClient {
 
   /** POST /dev/orgs { handle } → { handle, uuid, is_primary }. Throws with the server's detail on 409/422. */
   async createOrg(handle) {
-    return createOrgImpl({ apiBase: this.origin, token: await this.token(), handle })
+    return createOrgImpl({
+      apiBase: this.origin,
+      token: await this.token(),
+      handle
+    })
   }
 
   // ── Site sync (push / pull) ─────────────────────────────────────────────────────
 
+  /**
+   * POST /dev/site — CREATE an EMPTY site and return its site-content uuid.
+   *
+   * The uuid exists before any content or asset does, which is the whole point:
+   * uploaded bytes are metered against an owning entity and freed by deleting it,
+   * so an upload with no site to charge is billed and can never be reclaimed.
+   * Creating the site first is what makes a failed first publish leave a clearable
+   * empty site instead of unfreeable bytes.
+   *
+   * A thin re-projection of the same op the app's blank-site create uses, so the
+   * two lanes cannot drift. Adoption of `foundation` is best-effort — an
+   * unreleased ref leaves the resolved ref null and the site still exists — but
+   * the field itself is required and cannot be blank.
+   *
+   * NOT idempotent: two calls mint two sites (a name is not a unique key, by
+   * design). Callers must guard on `site.yml::$uuid` and write the result back
+   * immediately — see `ensureSiteExists`.
+   *
+   * @param {{ name: string, foundation: string, asOrg?: string|null }} opts
+   * @returns {Promise<Response>} `{ site_content_uuid }`
+   */
+  async createSite({ name, foundation, asOrg } = {}) {
+    return this.request('/dev/site', {
+      method: 'POST',
+      // Both fields are REQUIRED: `info.name` is `required: true` on the model
+      // (and is a plain string — an identity label, never a `{lang: …}` map, since
+      // a localized value can vanish under locale projection and a name must always
+      // render), and a site must resolve to a foundation. Adoption of the ref is
+      // best-effort on the backend, but the field itself cannot be blank — so send
+      // whatever the site declares and let the backend judge it.
+      body: JSON.stringify({ name, foundation }),
+      query: { as_org: asOrg }
+    })
+  }
+
   /** POST /dev/site/content — CREATE a site from its content lane (.uwx zip). */
   async createSiteContent(buffer, { asOrg } = {}) {
-    return this.request('/dev/site/content', { method: 'POST', body: buffer, query: pushQuery(asOrg) })
+    return this.request('/dev/site/content', {
+      method: 'POST',
+      body: buffer,
+      query: pushQuery(asOrg)
+    })
   }
 
   /** POST /dev/site/content/push/{uuid} — UPDATE the content lane by site uuid (.uwx zip). */
   async updateSiteContent(uuid, buffer, { asOrg } = {}) {
     return this.request(`/dev/site/content/push/${encodeURIComponent(uuid)}`, {
-      method: 'POST', body: buffer, query: pushQuery(asOrg),
+      method: 'POST',
+      body: buffer,
+      query: pushQuery(asOrg)
     })
   }
 
   /** POST /dev/site/folder/push/{uuid} — push the folder lane, keyed by the site uuid (.uwx zip). */
   async pushFolder(uuid, buffer, { asOrg } = {}) {
     return this.request(`/dev/site/folder/push/${encodeURIComponent(uuid)}`, {
-      method: 'POST', body: buffer, query: pushQuery(asOrg),
+      method: 'POST',
+      body: buffer,
+      query: pushQuery(asOrg)
     })
   }
 
@@ -295,14 +410,14 @@ export class BackendClient {
    */
   async pullSiteContent(uuid, { etag } = {}) {
     return this.request(`/dev/site/content/pull/${encodeURIComponent(uuid)}`, {
-      headers: etag ? { 'If-None-Match': etag } : {},
+      headers: etag ? { 'If-None-Match': etag } : {}
     })
   }
 
   /** GET /dev/site/folder/pull/{uuid} — the folder lane (folder + record documents). */
   async pullFolder(uuid, { etag } = {}) {
     return this.request(`/dev/site/folder/pull/${encodeURIComponent(uuid)}`, {
-      headers: etag ? { 'If-None-Match': etag } : {},
+      headers: etag ? { 'If-None-Match': etag } : {}
     })
   }
 
@@ -314,7 +429,7 @@ export class BackendClient {
    * theme, languages, locales, optional dataFiles/searchFiles) plus an optional
    * `site_uuid`. First deploy of a never-synced site omits it → the backend mints
    * a uuid and returns it for write-back to deploy.yml; later deploys resend it so
-   * `/gateway/site/{uuid}/` stays stable. Returns the raw Response so the caller
+   * the site's published URL stays stable. Returns the raw Response so the caller
    * messages its own errors and reads `{ site_uuid, url, locales }` on 200.
    * @param {object} payload - the deploy payload (universal currency)
    * @param {object} [opts]
@@ -323,7 +438,10 @@ export class BackendClient {
    */
   async deploy(payload, { siteUuid } = {}) {
     const body = siteUuid ? { ...payload, site_uuid: siteUuid } : payload
-    return this.request('/dev/deploy', { method: 'POST', body: JSON.stringify(body) })
+    return this.request('/dev/deploy', {
+      method: 'POST',
+      body: JSON.stringify(body)
+    })
   }
 
   /**
@@ -346,18 +464,20 @@ export class BackendClient {
     return this.request(`/dev/site/publish/${encodeURIComponent(uuid)}`, {
       method: 'POST',
       query: { runtime: runtimeVersion },
-      ...(languages ? { body: JSON.stringify({ languages }) } : {}),
+      ...(languages ? { body: JSON.stringify({ languages }) } : {})
     })
   }
 
   /**
-   * POST /dev/site/unpublish/{uuid} — drop the published-folder gate so /gateway
+   * POST /dev/site/unpublish/{uuid} — drop the published-folder gate so the host
    * stops serving the site's dynamic content. Returns the raw Response ({ was_published }).
    * @param {string} uuid - the site-content uuid
    * @returns {Promise<Response>}
    */
   async unpublishSite(uuid) {
-    return this.request(`/dev/site/unpublish/${encodeURIComponent(uuid)}`, { method: 'POST' })
+    return this.request(`/dev/site/unpublish/${encodeURIComponent(uuid)}`, {
+      method: 'POST'
+    })
   }
 
   /**
@@ -374,7 +494,9 @@ export class BackendClient {
    */
   async siteStatus(uuid) {
     try {
-      const res = await this.request(`/dev/site/status/${encodeURIComponent(uuid)}`)
+      const res = await this.request(
+        `/dev/site/status/${encodeURIComponent(uuid)}`
+      )
       return res.ok ? await res.json().catch(() => null) : null
     } catch {
       return null
@@ -394,7 +516,9 @@ export class BackendClient {
    */
   async canGoLive(uuid) {
     try {
-      const res = await this.request(`/dev/site/${encodeURIComponent(uuid)}/can-go-live`)
+      const res = await this.request(
+        `/dev/site/${encodeURIComponent(uuid)}/can-go-live`
+      )
       return res.ok ? await res.json().catch(() => null) : null
     } catch {
       return null
@@ -409,24 +533,33 @@ export class BackendClient {
    * @param {object} opts - { distDir, files?, onProgress? }
    */
   async uploadSiteAssets(opts) {
-    return uploadSiteAssets({ apiBase: this.origin, token: await this.token(), ...opts })
+    return uploadSiteAssets({
+      apiBase: this.origin,
+      token: await this.token(),
+      ...opts
+    })
   }
 
   /**
    * Upload a built `@uniweb/runtime` to the runtime registry (plan → PUT-per-file),
-   * served at `/gateway/runtime/{version}`. @std-gated on the backend. Thin
+   * served by the backend at a location it reports. @std-gated on the backend. Thin
    * pass-through to utils/runtime-upload.js with this client's origin + token.
    * @param {object} opts - { version, distDir, files?, onProgress? }
    */
   async uploadRuntime(opts) {
-    return uploadRuntime({ apiBase: this.origin, token: await this.token(), ...opts })
+    return uploadRuntime({
+      apiBase: this.origin,
+      token: await this.token(),
+      ...opts
+    })
   }
 }
 
 /** `@scope/name` → /dev/registry/data-schemas/{scope}/{name}; a bare name → …/{name}. */
 export function dataSchemaPath(modelName) {
   const m = /^@([^/]+)\/(.+)$/.exec(modelName)
-  if (m) return `/dev/registry/data-schemas/${encodeURIComponent(m[1])}/${encodeURIComponent(m[2])}`
+  if (m)
+    return `/dev/registry/data-schemas/${encodeURIComponent(m[1])}/${encodeURIComponent(m[2])}`
   return `/dev/registry/data-schemas/${encodeURIComponent(modelName)}`
 }
 

package/src/backend/data-bundle.js

@@ -20,16 +20,28 @@ import { buildAssetUrl } from '../utils/asset-upload.js'
  * @param {{ onProgress?: (m: string) => void }} [opts]
  * @returns {Promise<string>} the content-addressed serve URL (→ `info.data_bundle`)
  */
-export async function uploadDataBundle(client, ball, { onProgress } = {}) {
+export async function uploadDataBundle(
+  client,
+  ball,
+  { siteUuid = null, onProgress } = {}
+) {
   const bytes = Buffer.from(JSON.stringify(ball))
   const sha256 = createHash('sha256').update(bytes).digest('hex')
   const localUrl = '/data-bundle/base.json' // bookkeeping key into assetsByLocalUrl
 
   const result = await client.uploadSiteAssets({
     files: [
-      { path: 'data-bundle/base.json', content_type: 'application/json', size: bytes.length, sha256, localUrl, bytes },
+      {
+        path: 'data-bundle/base.json',
+        content_type: 'application/json',
+        size: bytes.length,
+        sha256,
+        localUrl,
+        bytes
+      }
     ],
-    onProgress,
+    siteUuid,
+    onProgress
   })
   if (result.failed?.length) {
     const f = result.failed[0]