uniweb 0.41.1 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.41.1",
+  "version": "0.42.0",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -41,13 +41,13 @@
     "js-yaml": "^4.1.0",
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
-    "@uniweb/core": "^0.19.0",
-    "@uniweb/kit": "^0.15.6",
+    "@uniweb/core": "^0.20.0",
     "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/runtime": "^0.14.2"
+    "@uniweb/kit": "^0.15.7",
+    "@uniweb/runtime": "^0.15.0"
   },
   "peerDependencies": {
-    "@uniweb/build": "^0.37.1",
+    "@uniweb/build": "^0.38.0",
     "@uniweb/content-reader": "^1.2.4",
     "@uniweb/semantic-parser": "^1.4.0"
   },

package/partials/agents.md

@@ -876,6 +876,8 @@ pages/blog/
 
 > **The record arrives as a single-element array under the query key** — `content.data.recent[0]`, not `content.data.article`. The runtime never coerces it to an object and never synthesizes a singular key. See *Data* in Part 4.
 
+**Records with URLs of their own shape — `[...path]/`.** A folder named exactly `[...path]` (one fixed spelling) captures the rest of the URL: `/blog/my-post` and `/blog/rust/2025/my-post` both reach it. The capture yields three standard variables — `:path` (the whole capture), `:dir` (everything before the last segment), `:slug` (the last segment, the record's handle) — and the record is still delivered by `slug`, so the section reads `content.data.recent[0]` as before. A record's URL is its folder placement plus its slug (`- folder: rust/2025` in `records.yml` → `/blog/rust/2025/my-post`). A query may bind a part — `scope: :dir` exposes the folder branch, `where: { tag: :dir }` keeps it private — and an unbound variable drops its clause, so one saved query serves the list page and the detail page. Reference: `reference/dynamic-routes.md`.
+
 **Two options for bigger sets:**
 
 `deferred: [body]` strips heavy fields from the list payload — cards stay light, while a `[slug]` page still receives the full record automatically and other components fetch on demand via `useEntityDetail`. For a remote source, add `detailUrl: /api/articles/{slug}` so the framework knows how to fetch one full record; file-based records emit per-record files at `/data/<name>/<slug>.json` and need no configuration.
@@ -938,7 +940,7 @@ import LessonHeader from '../../components/LessonHeader' // ❌ breaks if you re
 
 Within the same directory, use normal relative imports (`./AIFeedbackCard`).
 
-**Foundation entry (`main.js`).** A single `export default { … }` whose top-level keys are the capabilities the foundation provides — `name`, `description`, `defaultLayout`, `defaultSection`, `viewTransitions`, `props`, `defaultInsets`, `xref`, `outputs`, `handlers` — plus an optional named `vars` export. Section types and layouts are auto-discovered and merged in by `@uniweb/build`. The build wraps your default export under `default.capabilities` in `dist/entry.js`; you never write that wrapper. The one place it matters: when you import your **own** `main.js` from a component (e.g. a download button calling `compileDocument(website, { foundation })`), you get the bare default object — pass it through directly, Press handles both shapes.
+**Foundation entry (`main.js`).** A single `export default { … }` whose top-level keys are the capabilities the foundation provides — `name`, `description`, `defaultLayout`, `defaultSection`, `viewTransitions`, `props`, `defaultInsets`, `xref`, `outputs`, `handlers` — plus an optional named `vars` export. Everything here is read at render; the one thing a foundation declares that *isn't* — which host services it supports — lives in `package.json` instead (see [Declaring what your foundation supports](#declaring-what-your-foundation-supports)). Section types and layouts are auto-discovered and merged in by `@uniweb/build`. The build wraps your default export under `default.capabilities` in `dist/entry.js`; you never write that wrapper. The one place it matters: when you import your **own** `main.js` from a component (e.g. a download button calling `compileDocument(website, { foundation })`), you get the bare default object — pass it through directly, Press handles both shapes.
 
 ### Props interface
 
@@ -1722,6 +1724,7 @@ const page = website.activePage
 | `block.stableId` / `block.key` | Stable ID from filename or `id:` / unique key across pages — use as React key |
 | `block.path` | Page route this block belongs to |
 | `block.dataLoading` | True while declared data is still resolving |
+| `block.dataError` | `{ <key>: message }` when a declared fetch FAILED, else `null`. A failed key is absent from `content.data` — never `[]`, which means "no records" |
 
 ```jsx
 // getPageHierarchy(options) →
@@ -1752,6 +1755,7 @@ A component on a page with a `data:` or `fetch:` declaration automatically recei
 ```jsx
 function Article({ content, block }) {
   if (block.dataLoading) return <DataPlaceholder />
+  if (block.dataError?.articles) return <LoadFailed />   // the request failed — not "no records"
   const article = content.data.articles?.[0]   // focused record on a [slug] page
   if (!article) return <NotFound />
   return <ArticleView article={article} />
@@ -1775,7 +1779,7 @@ export default {
 
 A foundation can route a scope to a plain folder of schema files instead of a package via an optional `schemas.config.js` at its root — `export default { '@acme': '../shared/acme-schemas' }`. A routed scope wins over the package convention; `@/` and `@uniweb` are never routable; a routed scope has no package fallback for a missing schema (it errors rather than silently loading a different definition). Per-schema keys override single entries (most-specific wins: file › directory › package). Worked examples: `development/schemas-in-practice.md`.
 
-**Authoring queries.** Fetch declarations accept `where:` (a where-object predicate), `sort:` (e.g. `date desc`), and `limit:`. Whether the source evaluates them or the framework applies them as a runtime fallback is a transport detail controlled by the site's `fetcher.supports:` declaration.
+**Authoring queries.** Fetch declarations accept `where:` (a where-object predicate), `sort:` (ONE key, e.g. `date desc`), and `limit:`. The framework evaluates them in the browser over the records it fetched; a host that answers queries evaluates the same language at the source; a foundation transport decides for itself. The declaration is identical in every case.
 
 ```yaml
 # pages/blog/page.yml
@@ -1794,33 +1798,29 @@ fetch:
 
 ### Fetching from other sources (`fetcher:`)
 
-A site isn't limited to file-based collections. The `fetcher:` block in `site.yml` tunes the framework's default fetcher and opts into foundation-provided **named transports** per schema:
+A site isn't limited to file-based records. The default fetcher also reads a plain JSON `url:` — GET, or `method: POST` with a `body:`, an optional `transform:` dot-path, the `detail:` forms for a record — and evaluates `where` / `sort` / `limit` in the browser over what arrived. A site published to a Uniweb host reads the host's records with no configuration at all.
+
+A backend with its own base URL, headers, wire or query language is a **transport**: a named `{ resolve, cacheKey? }` exported by the foundation (or an extension), which the site selects per schema in `fetcher:` — the only thing that block is for:
 
 ```yaml
 # site.yml
 fetcher:
-  baseUrl: https://api.example.com
-  headers: { X-Tenant: acme }
-  envelope: { list: data.items, item: data.article, error: errors.0.message }
-
-  supports: [where, limit, sort]     # which operators the source evaluates natively
-
   transports:
-    articles: uniweb                 # a foundation-registered transport handles `data: articles`
+    articles: acme                   # a foundation-registered transport handles `data: articles`
     events: default                  # explicitly route back to the default fetcher
-  uniweb:                            # binding config that transport reads
-    siteFolder: abc-123-def
+  acme:                              # binding config that transport reads
+    apiKey: pk_public_123
 ```
 
-**`supports:` is a capability declaration, not a switch.** With `supports: []` (the default) the source is treated as static: the whole collection is fetched and the framework applies `where` / `sort` / `limit` in JS afterward, so two pages with different predicates share one cache entry. With `supports: [where]` the predicate ships in the request and the cache splits per predicate. With `[where, limit, sort]` the source returns the final result and the framework passes it through. Pushdown applies only to remote `url:` sources — local `path:` reads are static files and always evaluate operators as a runtime fallback.
+**Selection is explicit and site-owned.** For each request: `fetcher.transports[as]` wins if set; otherwise `fetcher.transports.default` if set; otherwise the framework's default fetcher. No route-walking, no `match()` predicates, no silent foundation-owned routing — the site picks.
 
-**Selection is explicit and site-owned.** For each request: `fetcher.transports[schema]` wins if set; otherwise `fetcher.transports.default` if set; otherwise the framework's default fetcher applies `baseUrl` / `headers` / `envelope`. No route-walking, no `match()` predicates, no silent foundation-owned routing — the site picks.
+⛔ `fetcher.baseUrl`, `headers`, `envelope`, `supports` and `request.*` are **retired**: a third party's conventions belong in a transport, not in the runtime every site loads. The build warns once and ignores them.
 
 > **Never put secrets in `site.yml`** — every value in it is public to the browser. Sites needing private credentials proxy through the same origin at the deployment layer, so the site fetches `/api/…` and the proxy attaches the credential server-side.
 
-**Failures degrade rather than break:** a failed fetch falls back to `[]`, logs a build warning, and the page still renders. Components should handle the empty case — which the guaranteed content shape already encourages.
+**Failures are visible, not empty:** a fetch that failed leaves its key ABSENT from `content.data` and names the message on `block.dataError[key]`; it is never delivered as `[]`, which means "no records". The page still renders — a section reads `dataError` to tell the two apart.
 
-Recipes for staying on the default fetcher, and for writing a custom transport: `development/connecting-a-backend.md`.
+When a plain `url:` is enough and when a transport is the answer: `development/connecting-a-backend.md`.
 
 Full model: `reference/data-fetching.md`. Where-object format with examples: `authoring/predicates.md`.
 
@@ -1911,6 +1911,49 @@ if (!url) return null          // this site has no agent — render nothing, or
 
 *(A live agent that errors mid-conversation is a different problem — that's ordinary request failure, handled where you make the request.)*
 
+### Declaring what your foundation supports
+
+`resolveService` is how you ask at render time. The other direction — telling a
+host, *before* anything renders, which services your foundation is built to use —
+is one line in the foundation's `package.json`:
+
+```json
+{
+  "uniweb": { "supports": ["search", "submit", "tracking"] }
+}
+```
+
+Service names, the same ones you pass to `resolveService`. It reaches a host when
+the foundation is registered, and it answers a question a host cannot otherwise
+answer: **a service only does something if the foundation renders something
+against it.** A host that offers search has no way to know whether your sections
+draw a search box, so without this it either offers a site something its code
+will ignore, or withholds something it would have used.
+
+**Three states, and they are three different answers:**
+
+| | |
+|---|---|
+| the key is **absent** | *unknown* — nobody said. Not a refusal |
+| `"supports": []` | an explicit *none* — this foundation honours no host service |
+| `"supports": ["search"]` | these, and only these |
+
+⛔ **Nothing is assumed on your behalf**, in either direction. An unstated set is
+never read as "all" and never as "none", so the only way a host learns your
+search box exists is that you said so.
+
+**List what you actually integrate.** `uniweb doctor` warns when your source
+reaches for a service you did not list — but it reads your code with a pattern
+matcher, so it sees `resolveService(website, 'search')` and misses a service
+reached through a variable or a helper. It can tell you that you forgot one; it
+cannot promise it found them all. The declaration is yours to keep accurate.
+
+⚖️ **Baseline behaviour is not yours to declare.** Some services do something for
+a site whether or not a foundation cooperates — the runtime reports page views
+wherever tracking is configured, with no help from your components. List
+`tracking` when you go *beyond* that (your own events on your own components);
+leaving it out does not switch the baseline off.
+
 ```yaml
 # site.yml — only when YOU are providing the endpoint. Publishing to Uniweb
 # Cloud needs nothing here; `uniweb export` and most `deploy --host` targets do.

package/src/backend/client.js

@@ -581,7 +581,7 @@ export class BackendClient {
 
   /**
    * GET /dev/site/status/{uuid} → the site's publish lifecycle (Contract 3,
-   * shipped backend-side — collab backend-framework-b220):
+   * shipped backend-side — collab backend↔framework):
    *   { published: boolean, last_pushed_at?: string, last_published_at?: string, draft_dirty?: boolean }
    * `draft_dirty` = never-published, or the synced draft changed since the last
    * publish ("pushed but not published").

package/src/backend/foundation-bring-along.js

@@ -174,7 +174,7 @@ function forwardedFlags(args) {
  *   any release, so it reflects the released version + the scope register
  *   derived. Delivery is version-pinned end-to-end (the gateway serves a
  *   foundation only by a concrete version, no latest-resolution at serve time —
- *   collab framework-backend-5c3e), so an unversioned local ref MUST be pinned
+ *   collab framework↔backend), so an unversioned local ref MUST be pinned
  *   on the wire or the live site points at code the gateway can't serve. null
  *   when the site already references a registry ref / URL (no override needed)
  *   or no scoped ref can be formed.

package/src/backend/site-sync.js

@@ -345,7 +345,7 @@ export function readSyncCache(siteDir) {
  * that. An offline re-emit produces the AUTHORED document, which is a different
  * document, so it matches nothing and every entity reads as changed forever. That is
  * not hypothetical: it is what `uniweb status` did on any site with one local image
- * (backend-framework-787e, 2026-08-19) — `push` said "1 entity unchanged" and
+ * (backend↔framework, 2026-08-19) — `push` said "1 entity unchanged" and
  * `status --json` said `changed: 1`, from the same cache, seconds apart.
  *
  * ⭐ What is left is what only a backend round-trip produces — an asset **serve URL**
@@ -487,7 +487,7 @@ export function readFolderItemUuids(siteDir) {
  * The backend refuses an all-blank section over stored items rather than applying it,
  * because applying it would insert every record fresh and delete every stored row —
  * content survives, identity does not. So `push` worked once and every push after was
- * refused. Measured 2026-08-29; collab framework-backend-812b.
+ * refused. Measured 2026-08-29; collab framework↔backend.
  *
  * ⭐ Keyed by NAME, which the backend enforces unique within the section and uses as
  * its own join key. ⛔ Not `$id`: it holds the same string but is a payload-local
@@ -1225,7 +1225,7 @@ export async function pushSyncPackages({
         // ⭐ THE BACKEND ALREADY SENDS WHAT LOCATES IT — `section_id`,
         // `records_without_uuid`, `stored_items` — and this branch discarded every
         // one of them, so every refusal anyone collected was missing the only fields
-        // that say WHERE. (Named by backend in collab `framework-backend-812b`,
+        // that say WHERE. (Named by backend in collab framework↔backend,
         // 2026-08-28: "the offending section and both counts have been in the body of
         // every refusal you have collected".)
         const n = problem.records_without_uuid

package/src/commands/doctor.js

@@ -177,31 +177,76 @@ function loadSiteYml(dir) {
  * inside a dependency is the wrong answer.
  */
 function sourceMatches(dir, pattern) {
+  let found = false
+  forEachSourceFile(dir, (text) => {
+    // `pattern` may carry /g, whose lastIndex persists across .test() calls —
+    // reset so a second file is not silently skipped.
+    pattern.lastIndex = 0
+    if (pattern.test(text)) found = true
+  })
+  return found
+}
+
+/**
+ * Read every component source file under `dir`, handing each one's text to `fn`.
+ *
+ * Same roots and same exclusions as `sourceMatches` (which is built on this):
+ * only where a foundation puts components, never `node_modules`, because the
+ * question is always "did the developer write this".
+ */
+function forEachSourceFile(dir, fn) {
   const roots = ['sections', 'layouts', 'components']
   const walk = (d, depth = 0) => {
-    if (depth > 6) return false
+    if (depth > 6) return
     let entries
     try {
       entries = readdirSync(d, { withFileTypes: true })
     } catch {
-      return false
+      return
     }
     for (const entry of entries) {
       if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue
       const p = join(d, entry.name)
       if (entry.isDirectory()) {
-        if (walk(p, depth + 1)) return true
+        walk(p, depth + 1)
       } else if (/\.(jsx?|tsx?)$/.test(entry.name)) {
         try {
-          if (pattern.test(readFileSync(p, 'utf8'))) return true
+          fn(readFileSync(p, 'utf8'))
         } catch {
           // unreadable file — not this check's problem to report
         }
       }
     }
-    return false
   }
-  return roots.some((r) => walk(join(dir, r)))
+  for (const r of roots) walk(join(dir, r))
+}
+
+/**
+ * The host services a foundation's own source actually reaches for.
+ *
+ * ⚠️ A HINT, NEVER THE ANSWER. This is a regex over source, so it sees only the
+ * literal spellings below: `resolveService(website, name)` with a variable name
+ * is invisible to it, and so is a service reached through a helper. That makes
+ * it usable for "you used this and did not declare it" (a false negative just
+ * means no warning) and useless as a source of truth (a false negative would
+ * mean a capability silently dropped from what we publish).
+ *
+ * ⛔ Which is why the declaration is authored and this only checks it. Deriving
+ * `uniweb.supports` from a scan would make a missed match into a service the
+ * operator cannot buy, with nothing anywhere naming the cause.
+ */
+function servicesUsedInSource(dir) {
+  const found = new Set()
+  forEachSourceFile(dir, (text) => {
+    for (const m of text.matchAll(/resolveService\s*\(\s*[^,()]+,\s*['"`]([\w-]+)['"`]/g)) {
+      found.add(m[1])
+    }
+    // The service-specific readers, which name no service string of their own.
+    if (/\bisSearchEnabled\s*\(/.test(text)) found.add('search')
+    if (/\buseTracker\s*\(/.test(text)) found.add('tracking')
+    if (/from\s+['"`]@uniweb\/api['"`]/.test(text)) found.add('api')
+  })
+  return found
 }
 
 // A fenced data block tagged `form`, in any of the serialization formats the
@@ -380,6 +425,71 @@ const CONSENT_NEAR_MISSES = new Set(['require', 'requires', 'required.', 'true',
  * A bare `tracking: <url>` string is the documented shorthand and carries no
  * options — there is nothing in it to be wrong.
  */
+/**
+ * `uniweb doctor` — a foundation's `uniweb.supports` declaration.
+ *
+ * A host offers services (`config.services.<name>`); a foundation has to render
+ * something against one, or an operator who provisioned it gets nothing and no
+ * error. `package.json::uniweb.supports` is how a foundation states which ones
+ * it honours, and it rides to the registry as `info.supports`
+ * (`build/src/uwx/registry-package.js`).
+ *
+ * ## ⭐ WHY THIS WARNS RATHER THAN THE BUILD FILLING IT IN
+ *
+ * `servicesUsedInSource` is a regex and cannot see a service reached through a
+ * variable or a helper. Deriving the declaration from it would publish a list
+ * SHORTER than the truth, and a capability missing from that list is one the
+ * operator cannot buy — with nothing anywhere naming the cause. A false negative
+ * in a warning costs a missing warning; a false negative in a derivation costs a
+ * silently unsellable feature. So the developer authors it and this checks it,
+ * at the one moment the person who can fix it is looking.
+ *
+ * ## ⚖️ Nothing here defaults a service ON
+ *
+ * Absent means UNKNOWN, not "none" and not "all". Assuming search because most
+ * foundations have one would claim a service for the developer who never met
+ * this key — who is the same developer who forgot to declare it — turning a loud
+ * failure (reported unknown) into a silent one (an operator paying for something
+ * their site will never render).
+ *
+ * Silent when a foundation reaches for no service at all: a check that fires on
+ * correct configuration is how everyone learns to ignore the checker.
+ */
+export function checkFoundationSupports({ foundationName, folderName, srcDir, pkg, issues }) {
+  const used = servicesUsedInSource(srcDir)
+  if (used.size === 0) return
+
+  const declared = pkg?.uniweb?.supports
+  const hasDeclaration = Array.isArray(declared)
+  const missing = [...used]
+    .filter((name) => !hasDeclaration || !declared.includes(name))
+    .sort()
+  if (missing.length === 0) return
+
+  const id = 'foundation-supports-incomplete'
+  const list = missing.join(', ')
+  issues.push({
+    id,
+    type: 'warning',
+    foundation: foundationName,
+    message: hasDeclaration
+      ? `${foundationName} uses ${list} but does not declare ${missing.length === 1 ? 'it' : 'them'} in uniweb.supports`
+      : `${foundationName} uses ${list} but declares no uniweb.supports`,
+    details: { used: [...used].sort(), declared: hasDeclaration ? declared : null }
+  })
+
+  if (hasDeclaration) {
+    warn(`[${id}] ${foundationName} uses ${list}, not listed in uniweb.supports`)
+  } else {
+    warn(`[${id}] ${foundationName} uses ${list} and declares no uniweb.supports`)
+    log(`    Without it a host cannot tell "this foundation supports nothing" from`)
+    log(`    "nobody said" — so what it renders may never be offered to the operator.`)
+  }
+  const merged = [...new Set([...(hasDeclaration ? declared : []), ...missing])].sort()
+  log(`    Add to ${folderName}/package.json:`)
+  log(`      ${colors.dim}"uniweb": { "supports": ${JSON.stringify(merged)} }${colors.reset}`)
+}
+
 export function checkTrackingBlock({ siteName, siteYml, issues }) {
   const tracking = siteYml?.tracking
   if (tracking === undefined || tracking === null) return
@@ -829,6 +939,17 @@ export async function doctor(args = []) {
     log(`      ${colors.dim}@import "@uniweb/kit/prose-tokens.css";${colors.reset}`)
   }
 
+  // ── uniweb.supports — the services this foundation says it is built against ──
+  for (const f of foundations) {
+    checkFoundationSupports({
+      foundationName: f.name,
+      folderName: f.folderName,
+      srcDir: resolveFoundationSrcPath(f.path),
+      pkg: loadPackageJson(f.path),
+      issues
+    })
+  }
+
   if (extensions.length > 0) {
     log('')
     success(`Found ${extensions.length} extension(s):`)

package/src/commands/publish.js

@@ -127,7 +127,7 @@ const say = {
 //
 // ⇒ So this branch is implementing the contract, not defending against drift. I
 // reported the two shapes as a violation of "finished values only" in collab
-// framework-backend-812b; the backend checked, found the adjacent ruling that
+// framework↔backend; the backend checked, found the adjacent ruling that
 // explains the relative arm, and ratified both. Do not "fix" it by demanding one
 // shape — the caller's own origin is the missing half on the relative arm, and we
 // are the caller.
@@ -626,7 +626,7 @@ export async function publish(args = []) {
   //    different statements, and an `if (x)` guard collapses them into one. The
   //    cost is always paid by whoever is downstream trying to tell them apart.
   //
-  // Both halves agreed in channel backend-framework-82f2 (2026-09-01); the
+  // Both halves agreed in channel backend↔framework (2026-09-01); the
   // backend's route accepts an empty `files` array as of the same exchange.
   say.info('Uploading schema-less record data…')
   try {
@@ -684,7 +684,7 @@ export async function publish(args = []) {
   // Stamp deploy-derived info on the site-content entity: the data-bundle URL,
   // and the PINNED foundation ref (`@scope/name@version`) from the bring-along.
   // Delivery is version-pinned end-to-end (the gateway serves a foundation only
-  // by a concrete version — collab framework-backend-5c3e), so pinning the
+  // by a concrete version — collab framework↔backend), so pinning the
   // released version on the wire is required when site.yml uses an unversioned
   // local ref; injectInfo overrides info.foundation. A registry/URL ref → fnd.ref
   // is null → the site.yml ref is forwarded verbatim (already pinned).

package/src/commands/push.js

@@ -406,7 +406,7 @@ export async function push(args = [], deps = {}) {
       // and push did neither until 2026-08-19: it sent the authored alias (`src`),
       // which names a foundation no deployment can resolve. A site created that way
       // keeps the bad ref, and the backend's create guard now refuses it outright
-      // (channel backend-framework-787e, their measurement).
+      // (channel backend↔framework, their measurement).
       //
       // ⭐ Same shape as the send-only-changed defect fixed this morning, and missed
       // for the same reason: the rule was applied at the writers under discussion and

package/src/framework-index.json

@@ -1,16 +1,16 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-09-03T04:51:43.576Z",
+  "generatedAt": "2026-09-04T23:59:53.886Z",
   "packages": {
     "@uniweb/api": {
-      "version": "0.2.5",
+      "version": "0.2.6",
       "path": "framework/api",
       "deps": [
         "@uniweb/core"
       ]
     },
     "@uniweb/build": {
-      "version": "0.37.1",
+      "version": "0.38.0",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -34,7 +34,7 @@
       "deps": []
     },
     "@uniweb/core": {
-      "version": "0.19.0",
+      "version": "0.20.0",
       "path": "framework/core",
       "deps": [
         "@uniweb/semantic-parser",
@@ -47,14 +47,14 @@
       "deps": []
     },
     "@uniweb/icons": {
-      "version": "0.4.10",
+      "version": "0.4.11",
       "path": "framework/icons",
       "deps": [
         "@uniweb/core"
       ]
     },
     "@uniweb/kit": {
-      "version": "0.15.6",
+      "version": "0.15.7",
       "path": "framework/kit",
       "deps": [
         "@uniweb/core",
@@ -73,7 +73,7 @@
       "deps": []
     },
     "@uniweb/projections": {
-      "version": "0.5.7",
+      "version": "0.5.8",
       "path": "framework/projections",
       "deps": [
         "@uniweb/content-writer",
@@ -81,7 +81,7 @@
       ]
     },
     "@uniweb/runtime": {
-      "version": "0.14.2",
+      "version": "0.15.0",
       "path": "framework/runtime",
       "deps": [
         "@uniweb/core",

package/src/utils/site-data-upload.js

@@ -87,7 +87,7 @@ export async function uploadSiteData({
   // Nothing looked wrong at either end: no error, no warning, just a request
   // that was never sent.
   //
-  // Agreed both sides in channel backend-framework-82f2; the backend's plan
+  // Agreed both sides in channel backend↔framework; the backend's plan
   // route accepted an empty `files` array in the same exchange (it was a 400
   // before, which is what made the omission look like the only option).
   const entries = Object.entries(ball?.data || {})