uniweb 0.14.23 → 0.14.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.14.23",
+  "version": "0.14.24",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -46,9 +46,9 @@
     "@uniweb/runtime": "0.9.6"
   },
   "peerDependencies": {
-    "@uniweb/build": "0.16.13",
-    "@uniweb/semantic-parser": "1.2.1",
-    "@uniweb/content-reader": "1.2.2"
+    "@uniweb/content-reader": "1.2.2",
+    "@uniweb/build": "0.16.14",
+    "@uniweb/semantic-parser": "1.2.1"
   },
   "peerDependenciesMeta": {
     "@uniweb/build": {

package/partials/agents.md

@@ -231,6 +231,10 @@ cat <foundation>/sections/Hero/meta.js       # what one expects and accepts
 
 **Extensions add to that vocabulary.** If `site.yml` carries an `extensions:` list, each entry is a second foundation contributing its own section types, usable by name in exactly the same way. Enumerate their `sections/` too. The primary foundation wins on a name collision, and extensions are checked in declared order.
 
+**An extension *is* a foundation** — same build, same output; it just contributes no Layout or theme variables. So each entry takes the **same shapes** `foundation:` does: a workspace package name, a versioned catalog ref (`@org/name@1.2.3`), or a full URL. Use the same table above to decide whether you can add a section type to one.
+
+> **A site-relative URL (`/effects/entry.js`) only works where the site serves its own files** — `uniweb export` and `uniweb deploy --host=<adapter>`. A site published to Uniweb hosting ships no JS, so nothing serves that path, and `uniweb publish` rejects it with a pointer to the catalog-ref form. Register the extension (`uniweb register` in its directory) and reference it like any other foundation. When you reference a workspace-local extension, `uniweb publish` brings it along exactly as it does the primary — releasing it if its code changed, and pinning the released version on the published site.
+
 Each `meta.js` is a catalog entry: `description` (what the type is for), `content:` (what markdown it expects), `params:` (what frontmatter it accepts, with defaults), `presets:` (named param bundles). Read them as a menu — that is what they are. There is no CLI command that lists them; reading the folder *is* the discovery step.
 
 > **Never write a `type:` or a param you haven't confirmed exists.** Both failures are silent (Part 0) — invisible from the terminal, visible only on the page.
@@ -615,6 +619,9 @@ slug: { fr: a-propos }      # Localized URL segment per language
 # site.yml
 index: home                 # Just set the homepage
 pages: [home, about, ...]   # Order pages (... = rest, first = homepage); without ... = strict
+foundation: '@acme/ui@1.2.0'  # The component system (see Part 2, step 1)
+extensions: ['@acme/fx@0.3.1'] # Secondary foundations — same shapes as foundation:
+runtime: 0.9.6              # Optional runtime pin; omit and the host chooses
 ```
 
 **Configuration cascades: `page.yml` → `folder.yml` → `site.yml` → foundation defaults.** Each level inherits from the one above and overrides specific values, the way CSS specificity works. This is what makes bulk assignment natural — put `layout: marketing` in a `folder.yml` and every page in that folder inherits it, while one page can still override with its own `page.yml`. Reach for `folder.yml` before editing the same key into a dozen `page.yml` files.
@@ -1948,6 +1955,8 @@ Platform-specific configuration that doesn't belong in npm-standard fields. All
 
 **Runtime policy** (foundation authors only — sites don't set this). At build time a foundation pins the `@uniweb/runtime` version it built against into `dist/runtime-pin.json`, alongside a policy controlling how that version moves forward on already-published sites: `exact` (stay put), `auto-patch` (within `MAJOR.MINOR.x`), `auto-minor` (within `MAJOR.x.y`, the default). Most foundations should leave it unset — the runtime is backwards-compatible at the minor level by convention, so `auto-minor` lets sites pick up fixes without a foundation rebuild. Set `exact` only if you depend on undocumented runtime internals or have audited against one release. Site owners cannot override your choice.
 
+**Why this is yours and not the site's.** A published site ships **no JS** — content, config, data and assets only. Your foundation is the only part that contains code linking against the runtime, and that link is wider than it looks: a foundation externalizes `react`, `react-dom`, `react-dom/server`, both JSX runtimes and `@uniweb/core`, all supplied by the runtime at load time. So a foundation built against a runtime is bound to *that* React and *that* core API. The general rule, which also explains why the reverse holds: **each policy is declared by whoever's code binds to the thing being updated** — you declare the runtime policy because your code links against the runtime; the site declares its foundation policy because its content binds to your section types.
+
 `@uniweb/runtime` arrives **transitively** through `@uniweb/build`, so your foundation pins a runtime version without declaring one — that's intentional. **Don't add `@uniweb/runtime` to your foundation's dependencies**; to bump the pinned version, bump `@uniweb/build`. If the pin is missing or malformed, the platform serves the foundation through its legacy compatibility path — sites still work, they just don't participate in runtime propagation.
 
 ### Localization

package/src/backend/client.js

@@ -461,9 +461,14 @@ export class BackendClient {
     // Runtime rides as a query param (?runtime=<version>) per the shipped /dev
     // route (D3, "request-carried"), NOT the body. Languages, when present, go in
     // the body; absent → no body (the route only requires the runtime).
+    // Omitted when the site pins no runtime — silence is NOT a request to change
+    // it, so the backend keeps the site on its current resolved version (its
+    // order: body → current → UNIWEBD_DEFAULT_RUNTIME → highest installed → 400).
+    // Sending a locally-computed guess instead would undo a propagation walk on
+    // the next publish.
     return this.request(`/dev/site/publish/${encodeURIComponent(uuid)}`, {
       method: 'POST',
-      query: { runtime: runtimeVersion },
+      ...(runtimeVersion ? { query: { runtime: runtimeVersion } } : {}),
       ...(languages ? { body: JSON.stringify({ languages }) } : {})
     })
   }

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

@@ -26,7 +26,7 @@ import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { execFileSync } from 'node:child_process'
 
-import { detectFoundationType } from '@uniweb/build'
+import { detectFoundationType, isExtensionUrl } from '@uniweb/build'
 import { computeFoundationDigest } from '../utils/code-upload.js'
 import { readFlagValue } from '../utils/args.js'
 import { isNonInteractive } from '../utils/interactive.js'
@@ -60,6 +60,52 @@ export function resolveLocalFoundation(siteDir, siteYml) {
   }
 }
 
+/**
+ * The site's LOCAL extensions — the ones publish must bring along. An extension IS
+ * a foundation (same build, same output), so it is declared and resolved the same
+ * way and goes through the SAME resolver, for the same reason `resolveLocalFoundation`
+ * does: "which code" must never drift between the build and the publish.
+ *
+ * A declaration that resolves to a URL or a catalog ref yields nothing local — the
+ * host already serves that code. Only workspace-local extensions need releasing.
+ *
+ * @param {string} siteDir
+ * @param {object} siteYml - parsed site.yml
+ * @returns {Array<{ decl: string, dir: string, scopedName: string|null, version: string|null }>}
+ *   `decl` is the authored declaration, which is the wire entry's `$id` — the key
+ *   publish stamps the pinned ref back onto.
+ */
+export function resolveLocalExtensions(siteDir, siteYml) {
+  const list = siteYml?.extensions
+  if (!Array.isArray(list)) return []
+  const out = []
+  for (const entry of list) {
+    // Only the name/ref form can be local; an explicit `url` never is.
+    const decl =
+      entry && typeof entry === 'object'
+        ? entry.ref || entry.name || null
+        : typeof entry === 'string'
+          ? entry
+          : null
+    if (!decl || isExtensionUrl(decl)) continue
+    let info
+    try {
+      info = detectFoundationType(decl, siteDir)
+    } catch {
+      // Unresolved — the site build surfaces the canonical error; nothing local.
+      continue
+    }
+    if (!info || info.type !== 'local' || !info.path) continue
+    out.push({
+      decl,
+      dir: info.path,
+      scopedName: foundationScopedName(info.path),
+      version: readPkgField(info.path, 'version')
+    })
+  }
+  return out
+}
+
 // The foundation's scoped catalog name (`@org/name`) from its package.json — an
 // already-scoped `name`, else `uniweb.scope` + a bare `name`. Null when neither
 // yields a scoped name (then we can't look up the registered version, so the
@@ -140,11 +186,43 @@ export async function bringFoundationAlong({
     // along, and no ref override (forward the site.yml ref verbatim).
     return { released: false, proceed: true, ref: null }
   }
+  return bringLocalCodeAlong({
+    client,
+    local,
+    kind: 'foundation',
+    args,
+    say,
+    confirm,
+    cliBin,
+    dryRun
+  })
+}
 
+/**
+ * Bring ONE piece of local code along — the primary foundation or one extension.
+ * Identical logic for both because an extension is a foundation; `kind` only names
+ * it in the messages.
+ *
+ * @param {object} o
+ * @param {{dir: string, scopedName: string|null, version: string|null}} o.local
+ * @param {'foundation'|'extension'} o.kind
+ * @returns {Promise<{ released: boolean, proceed: boolean, ref: string|null }>}
+ */
+async function bringLocalCodeAlong({
+  client,
+  local,
+  kind,
+  args,
+  say,
+  confirm,
+  cliBin,
+  dryRun = false
+}) {
+  const Kind = kind === 'extension' ? 'Extension ' : 'Foundation'
   const label =
     local.scopedName || local.version
-      ? `${local.scopedName || 'foundation'}${local.version ? `@${local.version}` : ''}`
-      : 'the local foundation'
+      ? `${local.scopedName || kind}${local.version ? `@${local.version}` : ''}`
+      : `the local ${kind}`
   const skipPrompts =
     args.includes('--yes') ||
     args.includes('--force') ||
@@ -163,7 +241,7 @@ export async function bringFoundationAlong({
   // a login (the digest read is auth-gated). The real run does the compare.
   if (dryRun) {
     say.dim(
-      `Foundation  : ${label} — local; would release if changed or not yet registered`
+      `${Kind}  : ${label} — local; would release if changed or not yet registered`
     )
     return { released: false, proceed: true, ref: null }
   }
@@ -175,7 +253,7 @@ export async function bringFoundationAlong({
     : null
 
   if (!reg) {
-    say.info(`Releasing the foundation ${label} (not yet registered)…`)
+    say.info(`Releasing the ${kind} ${label} (not yet registered)…`)
     return {
       released: releaseFoundation(local, args, cliBin, say),
       proceed: true,
@@ -190,7 +268,7 @@ export async function bringFoundationAlong({
 
   if (reg.digest && localDigest && reg.digest === localDigest) {
     say.dim(
-      `Foundation  : ${label} — unchanged since release (digest matches); nothing to release.`
+      `${Kind}  : ${label} — unchanged since release (digest matches); nothing to release.`
     )
     return { released: false, proceed: true, ref: pinnedRef() }
   }
@@ -198,7 +276,7 @@ export async function bringFoundationAlong({
   // A different version locally → a new version to release.
   if (local.version && local.version !== reg.latest_version) {
     say.info(
-      `Releasing the foundation ${label} (new version; registered latest is ${reg.latest_version})…`
+      `Releasing the ${kind} ${label} (new version; registered latest is ${reg.latest_version})…`
     )
     return {
       released: releaseFoundation(local, args, cliBin, say),
@@ -233,14 +311,14 @@ export async function bringFoundationAlong({
     return { released: false, proceed: true, ref: pinnedRef() }
   }
 
-  // Case 3 (§4): the foundation was edited but the version wasn't bumped. The
+  // Case 3 (§4): the code was edited but the version wasn't bumped. The
   // registered version is immutable, so we never silently ship the old code —
   // the deliberate release gate is a version bump (§3.1).
   say.warn(
     `Your local ${label} differs from the registered version ${reg.latest_version}, but the version wasn't bumped.`
   )
   say.dim(
-    "A registered version is immutable. Bump the foundation's version to release the change, then re-run `uniweb publish`."
+    `A registered version is immutable. Bump the ${kind}'s version to release the change, then re-run \`uniweb publish\`.`
   )
   if (skipPrompts || isNonInteractive(args)) {
     say.dim(`Proceeding with the already-registered ${reg.latest_version}.`)
@@ -252,7 +330,7 @@ export async function bringFoundationAlong({
   )
   if (!proceed) {
     say.info(
-      'Aborted — bump the foundation version, then re-run `uniweb publish`.'
+      `Aborted — bump the ${kind} version, then re-run \`uniweb publish\`.`
     )
     return { released: false, proceed: false, ref: null }
   }
@@ -282,3 +360,52 @@ function releaseFoundation(local, args, cliBin, say) {
   console.log('')
   return true
 }
+
+/**
+ * Bring the site's LOCAL extensions along — the exact parallel of
+ * `bringFoundationAlong`, run for each workspace-local extension.
+ *
+ * An extension is a foundation, so it gets a foundation's freshness guarantee:
+ * released when unregistered or newly versioned, skipped on a digest match, and
+ * never silently shipped stale. Before this, a site could go live against a stale
+ * extension with nothing noticing — the primary was covered and the rest were not.
+ *
+ * @param {object} o - same shape as bringFoundationAlong
+ * @returns {Promise<{ proceed: boolean, released: number, pins: Object<string,string> }>}
+ *   `pins` maps each authored declaration (the wire entry's `$id`) → the pinned
+ *   `@scope/name@version`, for `emitSyncPackages({ injectExtensions })`. Delivery is
+ *   version-pinned, so an unpinned local name on the wire points at code the host
+ *   cannot serve — the same reason the primary's ref is stamped.
+ */
+export async function bringExtensionsAlong({
+  client,
+  siteDir,
+  siteYml,
+  args,
+  say,
+  confirm,
+  cliBin,
+  dryRun = false
+}) {
+  const locals = resolveLocalExtensions(siteDir, siteYml)
+  const pins = {}
+  let released = 0
+  for (const local of locals) {
+    const r = await bringLocalCodeAlong({
+      client,
+      local,
+      kind: 'extension',
+      args,
+      say,
+      confirm,
+      cliBin,
+      dryRun
+    })
+    // A declined prompt aborts the whole publish, exactly as it does for the
+    // primary — a site live against half its code is worse than not shipping.
+    if (!r.proceed) return { proceed: false, released, pins: {} }
+    if (r.released) released += 1
+    if (r.ref) pins[local.decl] = r.ref
+  }
+  return { proceed: true, released, pins }
+}

package/src/commands/publish.js

@@ -49,6 +49,7 @@ import {
   rewriteBallAssets
 } from '@uniweb/build/site'
 import { emitSyncPackages } from '@uniweb/build/uwx'
+import { isSiteRelativeExtensionUrl } from '@uniweb/build'
 import { resolveDefaultLocale } from '@uniweb/core/locale-config'
 
 import { BackendClient } from '../backend/client.js'
@@ -68,7 +69,10 @@ import {
 } from '../backend/site-sync.js'
 import { uploadDataBundle } from '../backend/data-bundle.js'
 import { uploadSiteMedia, describeAssetRefusal } from '../backend/site-media.js'
-import { bringFoundationAlong } from '../backend/foundation-bring-along.js'
+import {
+  bringFoundationAlong,
+  bringExtensionsAlong
+} from '../backend/foundation-bring-along.js'
 import { settlePaymentIfNeeded } from '../backend/payment-handoff.js'
 
 const c = {
@@ -104,15 +108,6 @@ async function confirm(question, defaultYes = false) {
   }
 }
 
-// Highest installed runtime from the backend's /dev/config list (numeric-aware
-// sort). 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]
-}
-
 // Origin-relative serve path → clickable absolute URL (self-serve default).
 function absolutizeServeUrl(origin, url) {
   if (!url || typeof url !== 'string') return null
@@ -218,14 +213,24 @@ export async function publish(args = []) {
     )
     if (!dryRun) return { exitCode: 1 }
   }
-  const runtimeVersion = siteYml.runtime || pickHighestRuntime(installed)
-  if (!runtimeVersion && !dryRun) {
-    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.'
-    )
-    return { exitCode: 1 }
-  }
+  // An explicit pin is sent; NOTHING is synthesized when site.yml is silent.
+  //
+  // This used to fall back to the highest version the backend reported
+  // installed. That is the producer guessing at a fact the control plane owns —
+  // and once propagation moves sites, actively wrong: a walk advances a site to
+  // X, and the next publish would restate a *different* version the producer
+  // computed locally, silently undoing it.
+  //
+  // Silence is not a request to change the runtime, so the backend resolves it:
+  // the site's CURRENT resolved runtime → UNIWEBD_DEFAULT_RUNTIME → (self-serve)
+  // highest installed → 400. That keeps a propagated site where the walk put it,
+  // and it is the authority's answer rather than ours.
+  //
+  // ⚠️ Do NOT reintroduce a local fallback. Sending our own guess when the site
+  // did not ask is what makes an unpinned republish regress. (The pinned path is
+  // unaffected — an explicit pin is still validated fail-closed above, and the
+  // backend refuses a backward move unless forced.)
+  const runtimeVersion = siteYml.runtime || null
 
   // deploy.yml target (the Uniweb hosting memory). No --target on publish — it
   // always targets Uniweb hosting; resolveTarget gives us the target name +
@@ -249,11 +254,46 @@ export async function publish(args = []) {
   }
   const autoSave = noSave ? 'off' : resolved.autoSave || 'lastDeploy'
 
+  // A SITE-RELATIVE extension URL cannot work on Uniweb hosting: the published
+  // site ships no JS, so nothing serves that path. The request falls through to
+  // the SPA shell and returns 200 with `text/html`, which `import()` then fails
+  // to parse — and `loadExtensions` uses Promise.allSettled, so nothing throws
+  // and every section the extension provides silently renders "Component not
+  // found". A 200-with-HTML is strictly worse to debug than a 404 (the same
+  // shape that forced the `/data/` carve-out at the edge), so fail here, at the
+  // author's screen, rather than at a visitor's.
+  //
+  // `export` / `deploy --host` are unaffected — there the site serves its own
+  // files and a relative URL is exactly right.
+  const relativeExtensions = (
+    Array.isArray(siteYml.extensions) ? siteYml.extensions : []
+  )
+    .map((e) => (e && typeof e === 'object' ? e.url || e.ref || e.name : e))
+    .filter((d) => isSiteRelativeExtensionUrl(d))
+  if (relativeExtensions.length) {
+    say.err(
+      `Site-relative extension URL${relativeExtensions.length > 1 ? 's' : ''} cannot be served by Uniweb hosting: ${relativeExtensions.join(', ')}`
+    )
+    say.dim(
+      'A published site ships no JS, so nothing serves that path. An extension is a foundation —'
+    )
+    say.dim(
+      'register it (`uniweb register` in the extension directory) and reference it by name or'
+    )
+    say.dim(
+      '`@org/name@version` in site.yml::extensions, the same way the primary foundation is declared.'
+    )
+    say.dim(
+      'Site-relative URLs keep working with `uniweb export` and `uniweb deploy --host=<adapter>`.'
+    )
+    return { exitCode: 1 }
+  }
+
   if (dryRun) {
     say.info('Dry run — would bring the foundation along, sync, and go live:')
     say.dim(`Backend     : ${client.origin}`)
     say.dim(
-      `Runtime     : ${runtimeVersion || '(unresolved — needs a backend or a site.yml runtime: pin)'}${runtimeVersion && !siteYml.runtime ? ' (highest installed)' : ''}`
+      `Runtime     : ${runtimeVersion || '(not pinned — the backend keeps this site on its current runtime)'}`
     )
     say.dim(
       `site_uuid   : ${siteYml.$uuid || '(none — the site is created before anything uploads)'}`
@@ -270,6 +310,16 @@ export async function publish(args = []) {
       cliBin: process.argv[1],
       dryRun: true
     })
+    await bringExtensionsAlong({
+      client,
+      siteDir,
+      siteYml,
+      args,
+      say,
+      confirm,
+      cliBin: process.argv[1],
+      dryRun: true
+    })
     await settlePaymentIfNeeded({
       client,
       uuid: siteYml.$uuid || null,
@@ -298,6 +348,27 @@ export async function publish(args = []) {
     say.dim('Fix the foundation, then re-run `uniweb publish`.')
     return { exitCode: 1 }
   }
+
+  // 1b. Same for the site's LOCAL extensions. An extension is a foundation, so
+  //     it gets the same freshness guarantee — otherwise a site could go live
+  //     against stale extension code with nothing noticing.
+  let ext
+  try {
+    ext = await bringExtensionsAlong({
+      client,
+      siteDir,
+      siteYml,
+      args,
+      say,
+      confirm,
+      cliBin: process.argv[1]
+    })
+  } catch (err) {
+    say.err(`Extension release failed: ${err.message}`)
+    say.dim('Fix the extension, then re-run `uniweb publish`.')
+    return { exitCode: 1 }
+  }
+  if (!ext.proceed) return { exitCode: 1 }
   if (!fnd.proceed) return { exitCode: 0 }
 
   // 2. Build the site data (link mode): dist/site-content.json (+ per-locale),
@@ -489,6 +560,9 @@ export async function publish(args = []) {
         ? { baseVersions, itemBaseVersions: readItemBaseVersions(siteDir) }
         : {}),
       ...(Object.keys(injectInfo).length ? { injectInfo } : {}),
+      ...(Object.keys(ext.pins).length
+        ? { injectExtensions: ext.pins }
+        : {}),
       ...(assetRewrite ? { assetRewrite } : {})
     })
   } catch (err) {
@@ -598,7 +672,11 @@ export async function publish(args = []) {
         ...(recordedRef ? { ref: recordedRef } : {}),
         released: fnd.released
       },
-      runtime: runtimeVersion,
+      // Only when the site pinned one. An unpinned site's runtime is resolved by
+      // the backend and can move under propagation, so recording a value here
+      // would be a snapshot that silently goes stale — and `deploy.yml` is a
+      // record of what this publish did, not a cache of backend state.
+      ...(runtimeVersion ? { runtime: runtimeVersion } : {}),
       locales: Array.isArray(result.locales) ? result.locales : languages
     }
   })

package/src/commands/runtime.js

@@ -1,9 +1,22 @@
 /**
  * uniweb runtime register — upload a built `@uniweb/runtime` to the backend so it
  * can serve the runtime version. The runtime is a SYSTEM artifact: registering it
- * requires **@std membership** (a non-@std bearer 403s). Foundations pin a runtime
- * version (`dist/runtime-pin.json`); that version must be registered, or `uniweb
- * register` of such a foundation fails.
+ * requires **@std membership** (a non-@std bearer 403s).
+ *
+ * A foundation emits `dist/runtime-pin.json`, but NOTHING READS IT — not this CLI,
+ * not the backend, not the edge (verified across all three lanes 2026-08-04,
+ * channel `platform-backend-framework-8de5`). An earlier version of this comment
+ * claimed `uniweb register` of a foundation fails when its pinned version isn't
+ * registered. That was never true, and it propagated into a kb doc before anyone
+ * checked it against `commands/register.js` three files away.
+ *
+ * The pin is a **compatibility floor**, not a selector: a site loads a primary
+ * foundation plus N extensions, each emitting its own pin, and a site has exactly
+ * one runtime — so pins are plural and the selector must be singular. The selector
+ * is `site.yml::runtime` (see commands/publish.js), which the backend stamps into
+ * the site's meta at publish. The pin's designed use is publish-time VALIDATION
+ * (is the selected runtime inside every foundation's compatible interval?), which
+ * is producer-side and not yet implemented.
  *
  * Contract AGREED with the backend (2026-06-14): `POST /dev/runtime`, @std-gated,
  * manifest-last. Wire + the two-half artifact set (SPA + ssr-edge isolate, the

package/src/framework-index.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-08-04T14:08:24.823Z",
+  "generatedAt": "2026-08-04T19:33:10.456Z",
   "packages": {
     "@uniweb/build": {
-      "version": "0.16.13",
+      "version": "0.16.14",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -59,7 +59,7 @@
       "deps": []
     },
     "@uniweb/press": {
-      "version": "0.4.14",
+      "version": "0.4.15",
       "path": "framework/press",
       "deps": []
     },
@@ -110,7 +110,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.6.11",
+      "version": "0.6.12",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",