uniweb 0.81.2 → 0.82.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.81.2",
+  "version": "0.82.0",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -42,15 +42,15 @@
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
     "@uniweb/content-writer": "^0.3.4",
-    "@uniweb/core": "^0.36.0",
-    "@uniweb/kit": "^0.19.15",
-    "@uniweb/runtime": "^0.28.10",
+    "@uniweb/kit": "^0.19.16",
+    "@uniweb/core": "^0.37.0",
     "@uniweb/semantic-parser": "^1.5.1",
-    "@uniweb/schemas": "^0.10.2"
+    "@uniweb/schemas": "^0.11.0",
+    "@uniweb/runtime": "^0.29.0"
   },
   "peerDependencies": {
-    "@uniweb/build": "^0.75.1",
     "@uniweb/content-reader": "^1.2.8",
+    "@uniweb/build": "^0.76.0",
     "@uniweb/semantic-parser": "^1.5.1"
   },
   "peerDependenciesMeta": {

package/partials/agents.md

@@ -1762,7 +1762,7 @@ export default function DocsLayout({ header, body, footer, left, right, params }
 
 Layouts are full components with their own `params` in `meta.js`, not just structural wrappers — a header height or sidebar width is a layout param.
 
-**Layout `meta.js`** declares areas and optional scroll behavior: `{ areas: ['header', 'footer', 'left'], scroll: 'self' }`. Area names are arbitrary. `scroll` controls scroll restoration: unset = runtime manages `window` (default), `'self'` = the layout scrolls itself, or a CSS selector (`'main'`) = runtime manages that element.
+**Layout `meta.js`** declares areas and optional scroll behavior: `{ areas: ['header', 'footer', 'left'], scroll: 'self' }`. Area names are arbitrary. `areas` tells an editor what to offer; a page renders the areas its site's `layout/` folder fills. `scroll` controls scroll restoration: unset = runtime manages `window` (default), `'self'` = the layout scrolls itself, or a CSS selector (`'main'`) = runtime manages that element.
 
 Two optional keys tune how areas behave across a navigation. `transitions` renames or opts regions out of per-area view transitions (`{ left: null }`, or `false` for the whole layout). `layers` sets which area paints on top — every area is stacked above the body by default, so a fixed header works without declaring anything, but areas are equal to each other, so a layout whose chrome overlaps says which wins: `layers: { header: 2, left: 1 }`. Both take an object to override per region, or `false` to opt out. **A `z-index` inside an area cannot lift it past another area** — each area is its own stacking context — so reach for `layers` rather than a bigger number, and for `<Overlay>` when a modal needs to escape the area entirely.
 
@@ -1890,7 +1890,7 @@ function Article({ content, block }) {
 
 When a record genuinely needs to be a single object, that's the foundation's job — read `[0]`, or reshape once with a `handlers.data` hook.
 
-**Declaring keys and schemas.** `meta.js` declares each `content.data` key the component receives, with its schema, in a single `data:` field — there is no separate `schemas:` key. Each value is a **named ref**, an **inline field map**, an **inline rich-form** (`{ fields: [...] }`, an editor form), or `{}` for a key with no schema (an external API's records). Refs resolve on disk at build time, never fetched: `@/name` (this foundation's `schemas/`), `@std/name` (shared standards, from `@uniweb/schemas`), `@org/name` (an org's own `@org/schemas` package). A schema supplies field defaults, drives the editor, and lets a fetch of another name fill the key. ⛔ **Delivery was default-on until this change** — every fetched key reached every component, and `data:` was a hint; a component that reads a key it does not declare now receives nothing under it. `data: false` declares nothing, like no `data:`. Keys a foundation's handlers (or a shared hook) read go in `main.js` `data:`, in the same form, and every section receives them.
+**Declaring keys and schemas.** `meta.js` declares each `content.data` key the component receives, with its schema, in a single `data:` field — there is no separate `schemas:` key. Each value is a **named ref**, an **inline field map**, an **inline rich-form** (`{ fields: [...] }`, an editor form), or `{}` for a key with no schema (an external API's records). Refs resolve on disk at build time, never fetched: `@/name` (this foundation's `schemas/`), `@std/name` (shared standards, from `@uniweb/schemas`), `@org/name` (an org's own `@org/schemas` package). A schema drives the editor, checks your data (`uniweb validate`), and lets a fetch of another name fill the key — it fills no field: **a record reaches the component as it is**, so a field it lacks is absent, and what that renders as is your component's choice (`record.status ?? 'published'`). **A named schema declares no `default:`** — the build refuses one; a `default:` belongs only in an inline field map or form, where an editor pre-fills from it. ⛔ **Delivery was default-on until this change** — every fetched key reached every component, and `data:` was a hint; a component that reads a key it does not declare now receives nothing under it. `data: false` declares nothing, like no `data:`. Keys a foundation's handlers (or a shared hook) read go in `main.js` `data:`, in the same form, and every section receives them.
 
 ```js
 // meta.js
@@ -1898,7 +1898,7 @@ export default {
   data: {
     articles: '@/article',                               // named ref (this foundation)
     authors:  '@std/person',                             // named ref (shared standard)
-    pricing:  { tier: { type: 'string', default: '' } }, // inline field map
+    pricing:  { tier: { type: 'string' } },              // inline field map
   },
 }
 ```
@@ -2415,7 +2415,7 @@ Content handlers are a transform layer between data assembly and the component,
 | `content` | After the data handler | `(data, block)` | ProseMirror document, or null | Transform raw content (Loom instantiation, template expansion) |
 | `props` | After parsing, defaults, and guarantees | `(content, params, block)` | `{ content, params }`, or null | Post-process the final shape before the component sees it |
 
-The `content` handler receives `block.parsedContent.data` — the section's declared keys, its foundation's `main.js` `data:` included, so **declare there every key a handler reads** — and reads raw ProseMirror from `block.rawContent`, returning a new ProseMirror document that the framework re-parses through the semantic parser. Returning `null` — or the same reference as `block.rawContent` — signals no change.
+The `content` handler receives `block.parsedContent.data` — the section's declared keys, its foundation's `main.js` `data:` included, so **declare there every key a handler reads** — and reads raw ProseMirror from `block.rawContent`, returning a new ProseMirror document that the framework re-parses through the semantic parser. Returning `null` — or the same reference as `block.rawContent` — signals no change. Anything that is not a document is ignored, with a warning once per handler: the first argument is the section's *data*, so a pass-through `(x) => x` returns the data, not the content.
 
 > **`block.rawContent` may or may not be wrapped.** Unwrap it defensively — `const doc = block.rawContent?.doc ?? block.rawContent` — before passing it to `instantiateContent` / `instantiateRepeated`. This is the first thing a hand-written handler gets wrong.
 

package/src/backend/client.js

@@ -748,8 +748,14 @@ export class BackendClient {
    * @param {string[]} [opts.languages]
    * @returns {Promise<Response>}
    */
-  async publishSite(uuid, { languages } = {}) {
-    return this.request(`/dev/site/publish/${encodeURIComponent(uuid)}`, {
+  async publishSite(uuid, { languages, confirm, unattended = false } = {}) {
+    // `confirm`: the token of a confirm the backend offered on a refused publish, sent back as it
+    // came, to settle a change to the site's plan and publish in one call. `unattended`: no one
+    // answered it — `--yes` did, which the backend settles for a reduction and nothing else.
+    const query = confirm
+      ? `?confirm=${encodeURIComponent(confirm)}${unattended ? '&unattended=true' : ''}`
+      : ''
+    return this.request(`/dev/site/publish/${encodeURIComponent(uuid)}${query}`, {
       method: 'POST',
       ...(languages ? { body: JSON.stringify({ languages }) } : {})
     })

package/src/backend/payment-handoff.js

@@ -91,8 +91,8 @@ const OPENABLE = /^https?:\/\//i
  * @param {string} [o.contentType] - the response's content-type header
  * @param {string} [o.body] - the raw response body
  * @returns {{ kind: 'not-payment' }
- *          | { kind: 'settle', url: string, handle: string|null, reason: string, message: string|null }
- *          | { kind: 'stop', reason: string|null, message: string|null }}
+ *          | { kind: 'settle', url: string, handle: string|null, reason: string, message: string|null, confirm: { prompt: string, token: string, reduction: boolean }|null }
+ *          | { kind: 'stop', reason: string|null, message: string|null, confirm: { prompt: string, token: string, reduction: boolean }|null }}
  */
 export function readPaymentRefusal({ status, contentType = '', body = '' } = {}) {
   if (status !== 402) return { kind: 'not-payment' }
@@ -134,7 +134,17 @@ export function readPaymentRefusal({ status, contentType = '', body = '' } = {})
   // problem body carries the number, so the two are not distinguishable by their
   // fields. Reading a URL out of a body that never promised this envelope is how
   // a `settle` gets synthesised from something that is not a refusal at all.
-  if (!isProblem) return { kind: 'stop', reason, message }
+  if (!isProblem) return { kind: 'stop', reason, message, confirm: null }
+
+  // ⭐ A CHANGE THE TERMINAL MAY CONFIRM (since 2026-10-03): `{ prompt, token, reduction }`
+  // beside the door, when everything the publish owes is a change to a plan the site already has.
+  // `prompt` is the backend's sentence, shown verbatim; `token` goes back as it came. Read only
+  // whole — a confirm missing either half is not one.
+  const confirm =
+    problem.confirm && typeof problem.confirm.prompt === 'string' && problem.confirm.prompt &&
+    typeof problem.confirm.token === 'string' && problem.confirm.token
+      ? { prompt: problem.confirm.prompt, token: problem.confirm.token, reduction: problem.confirm.reduction === true }
+      : null
 
   // The door, if one was handed over. `remedy_url` is the current spelling — ONE
   // key for every reason, which is what lets a reason we have never heard of still
@@ -160,7 +170,7 @@ export function readPaymentRefusal({ status, contentType = '', body = '' } = {})
   // the platform's URL opener; a `file:` or a `javascript:` URL is not a place a
   // person goes. Refusing them costs a legitimate backend nothing.
   const url = candidate && OPENABLE.test(candidate) ? candidate : null
-  if (!url) return { kind: 'stop', reason, message }
+  if (!url) return { kind: 'stop', reason, message, confirm }
 
   return {
     kind: 'settle',
@@ -170,7 +180,8 @@ export function readPaymentRefusal({ status, contentType = '', body = '' } = {})
         ? legacy.handle
         : null,
     reason,
-    message
+    message,
+    confirm
   }
 }
 
@@ -187,9 +198,11 @@ export function readPaymentRefusal({ status, contentType = '', body = '' } = {})
  * @param {string[]} o.args - argv slice (for --non-interactive detection)
  * @param {object} o.say - { ok, info, warn, err, dim } reporters
  * @param {(url: string) => Promise<boolean>} [o.open] - injected for tests
+ * @param {boolean} [o.interactive] - whether someone is at the terminal, when the caller has decided
+ *   it already (`settleRefusal`); else read from `args` and stdin
  * @returns {Promise<{ opened: boolean }>}
  */
-export async function reportPaymentRefusal({ verdict, args = [], say, open }) {
+export async function reportPaymentRefusal({ verdict, args = [], say, open, interactive }) {
   // The backend's own sentence is the HEADLINE when there is one. A generic
   // lead would be wrong as often as right — "payment is required" does not
   // describe a declined card — and `detail` is written for this reader.
@@ -201,24 +214,149 @@ export async function reportPaymentRefusal({ verdict, args = [], say, open }) {
     return { opened: false }
   }
 
-  const { isNonInteractive } = await import('../utils/interactive.js')
-  if (isNonInteractive(args)) {
+  if (interactive === undefined) {
+    const { isNonInteractive } = await import('../utils/interactive.js')
+    interactive = !isNonInteractive(args)
+  }
+  if (!interactive) {
     say.dim(`Finish this in a browser, then re-run \`uniweb publish\`:`)
     say.dim(`  ${verdict.url}`)
     return { opened: false }
   }
 
+  return openDoor({ url: verdict.url, say, open })
+}
+
+/** Open the backend's door, verbatim, and say how to come back. */
+async function openDoor({ url, say, open }) {
   const openBrowser = open || (await import('../utils/registry-auth.js')).openBrowser
-  // ⛔ Reason-agnostic wording. The backend's own `detail` above carries the
-  // specifics; a lead sentence naming payment would be wrong the moment a refusal
-  // is a quota or an unverified domain — and the reason set is open by design.
+  // ⛔ Reason-agnostic wording. The backend's own `detail` carries the specifics;
+  // a lead sentence naming payment would be wrong the moment a refusal is a quota
+  // or an unverified domain — and the reason set is open by design.
   say.info('Opening your browser to finish this…')
-  say.dim(`  ${verdict.url}`)
+  say.dim(`  ${url}`)
   // VERBATIM. Nothing is appended — see the header.
-  const opened = await openBrowser(verdict.url)
+  const opened = await openBrowser(url)
   if (!opened) {
     say.warn('Could not open a browser automatically — open the URL above.')
   }
   say.dim('Once that is done, re-run `uniweb publish`.')
   return { opened }
 }
+
+const CONFIRM = 'Confirm and publish'
+const CONTINUE = 'Continue and publish'
+const OPEN = 'Open it in the app'
+const CANCEL = 'Cancel'
+
+// A reduction offered again and again, with no one to ask, is answered this many times and no more.
+const MAX_UNATTENDED = 3
+
+/**
+ * ⭐ A REFUSAL THE TERMINAL MAY SETTLE (since 2026-10-03). When everything a publish owes is a change
+ * to a plan the site already has, the `402` carries `confirm: { prompt, token, reduction }` beside its
+ * door, and the backend's sentence is asked at an interactive terminal: confirm, open the app, or
+ * cancel. Confirming publishes again with the token (`?confirm=`):
+ *
+ * - `200` — settled and published: the response is returned, for the caller to finish with.
+ * - `402` with a fresh `confirm` — the change or its price moved and nothing was applied: asked again,
+ *   with the new sentence.
+ * - `402` without one — what is owed can no longer be confirmed here (it now asks for a first plan,
+ *   or the plan's card can no longer be named): its sentence, and its door. ⛔ Not a declined card —
+ *   a confirmed change is invoiced as it applies, and a decline later shows in the app's billing.
+ *   *(This said "the card could not settle it" until the day it was written, 2026-10-03.)*
+ *
+ * ⭐ **A CHARGE AND A REDUCTION ARE ASKED DIFFERENTLY** (`reduction`, a field the backend keeps
+ * stable). A charge is confirmed only by someone at the terminal: Enter cancels, no flag answers it,
+ * and with `--yes` — which promises never to block on a prompt — it is not asked either, but reported
+ * with the way to confirm it. A reduction — the offer only lowers what the site pays — asks lightly: Enter continues, and
+ * `--yes` answers it without asking, with or without a terminal, telling the backend it was answered
+ * unattended (`&unattended=true`), which settles a reduction and nothing else. *[Diego, 2026-10-03:
+ * "allow it for reductions only, keep charges interactive".]*
+ *
+ * With no one at the terminal and nothing to answer it, there is no prompt: the refusal is reported as
+ * before, its door printed, and the publish fails. A refusal with no `confirm` behaves as it always has.
+ *
+ * @param {object} o
+ * @param {ReturnType<typeof readPaymentRefusal>} o.verdict - the first refusal
+ * @param {string[]} o.args - argv slice (for `--yes` and --non-interactive detection)
+ * @param {object} o.say - { ok, info, warn, err, dim } reporters
+ * @param {(token: string, options?: { unattended?: boolean }) => Promise<Response>} o.republish - the
+ *   same publish, with `?confirm=<token>` (and `&unattended=true` when no one answered)
+ * @param {boolean} [o.interactive] - whether someone is at the terminal; read from `args` and stdin
+ * @param {boolean} [o.yes] - whether `--yes` answers a reduction; read from `args`
+ * @param {(question: string, options: string[], fallback: string) => Promise<string>} [o.ask]
+ * @param {(url: string) => Promise<boolean>} [o.open]
+ * @returns {Promise<{ exitCode: number } | { response: Response, body?: string }>} `response` when
+ *   the publish went through, or failed for a reason that is not payment (with its body, read)
+ */
+export async function settleRefusal({ verdict, args = [], say, republish, interactive, yes, ask, open }) {
+  if (interactive === undefined) {
+    const { isNonInteractive } = await import('../utils/interactive.js')
+    interactive = !isNonInteractive(args)
+  }
+  if (yes === undefined) yes = args.includes('--yes')
+  let current = verdict
+  let unattended = 0
+  for (;;) {
+    const offer = current.confirm
+    const reduction = offer?.reduction === true
+    let answered
+
+    if (reduction && yes && unattended < MAX_UNATTENDED) {
+      // `--yes` answers a change that only lowers the bill — said, so the log shows what was accepted.
+      unattended++
+      say.info(offer.prompt)
+      say.dim('Continuing: `--yes` answers a change that only lowers what the site pays.')
+      answered = { unattended: true }
+    } else if (!offer || !interactive || (yes && !reduction)) {
+      await reportPaymentRefusal({ verdict: current, args, say, open, interactive: interactive && !yes })
+      if (offer && !reduction) {
+        say.dim('This change charges the site\'s card, so only you can confirm it: run `uniweb publish` at a terminal, without `--yes`.')
+      } else if (reduction) {
+        say.dim('This change only lowers what the site pays: `uniweb publish --yes` continues it without a prompt.')
+      }
+      return { exitCode: 1 }
+    } else {
+      const go = reduction ? CONTINUE : CONFIRM
+      const choices = [go, ...(current.kind === 'settle' ? [OPEN] : []), CANCEL]
+      // Enter continues a reduction and cancels a charge.
+      const fallback = reduction ? CONTINUE : CANCEL
+      const pick = ask
+        ? await ask(offer.prompt, choices, fallback)
+        : await (await import('../utils/interactive.js')).pickOne(offer.prompt, choices, fallback)
+
+      if (pick === OPEN) {
+        await openDoor({ url: current.url, say, open })
+        return { exitCode: 1 }
+      }
+      if (pick !== go) {
+        say.dim('Cancelled — nothing changed, and nothing was made live. The site is synced as a draft.')
+        return { exitCode: 1 }
+      }
+      answered = {}
+    }
+
+    let response
+    try {
+      response = await republish(offer.token, answered)
+    } catch (err) {
+      say.err(String(err?.message || err))
+      return { exitCode: 1 }
+    }
+    if (response.ok) return { response }
+
+    const body = await response.text().catch(() => '')
+    const next = readPaymentRefusal({
+      status: response.status,
+      contentType: response.headers?.get?.('content-type') || '',
+      body
+    })
+    if (next.kind === 'not-payment') return { response, body }
+    if (next.confirm) {
+      // Nothing was applied: the change or its price moved since the offer. Ask again.
+      say.warn('The change or its price moved since that offer, so nothing was applied.')
+    }
+    current = next
+  }
+}

package/src/commands/build.js

@@ -249,10 +249,7 @@ async function buildFoundation(projectDir, options = {}) {
   log('')
   log(`${colors.bright}Share with clients:${colors.reset}`)
   log(
-    `  ${colors.bright}uniweb publish${colors.reset}              Register your foundation (one-time setup)`
-  )
-  log(
-    `  ${colors.bright}uniweb handoff <email>${colors.reset}      Hand off a site to a client`
+    `  ${colors.bright}uniweb register${colors.reset}             Release your foundation to the catalog (alias: uniweb release)`
   )
 }
 
@@ -1026,9 +1023,6 @@ function showNextSteps(hasFoundations, hasSites) {
     log(
       `  ${colors.bright}uniweb register${colors.reset}             Release your foundation to the catalog (alias: uniweb release)`
     )
-    log(
-      `  ${colors.bright}uniweb handoff <email>${colors.reset}      Hand off a site to a client`
-    )
   }
   if (hasSites) {
     log('')

package/src/commands/publish.js

@@ -112,7 +112,7 @@ import {
 } from '../backend/foundation-bring-along.js'
 import {
   readPaymentRefusal,
-  reportPaymentRefusal
+  settleRefusal
 } from '../backend/payment-handoff.js'
 import { reportSchemalessQueries } from '../utils/schemaless-report.js'
 import {
@@ -1050,31 +1050,43 @@ export async function publish(args = []) {
       say.dim('Is that the backend you meant? Switch with: uniweb login --backend <url>')
     return { exitCode: 1 }
   }
+  // The body of a publish that did not go through — read once, and kept for the report below.
+  let failedBody = ''
   if (!pubRes.ok) {
-    const body = await pubRes.text().catch(() => '')
+    failedBody = await pubRes.text().catch(() => '')
 
     // A 402 is the backend's payment gate — the ONLY gate, evaluated here on
     // every publish against whatever posture that deployment runs. It is a
     // refusal, not a fault: the content is already synced as a draft, so the
     // recovery is to settle and re-run. Give it the backend's own sentence
-    // rather than the raw envelope.
+    // rather than the raw envelope — and when it offers a change the terminal
+    // may confirm, ask, and publish again with the answer.
     const refusal = readPaymentRefusal({
       status: pubRes.status,
       contentType: pubRes.headers?.get?.('content-type') || '',
-      body
+      body: failedBody
     })
     if (refusal.kind !== 'not-payment') {
-      await reportPaymentRefusal({ verdict: refusal, args, say })
-      return { exitCode: 1 }
+      const settled = await settleRefusal({
+        verdict: refusal,
+        args,
+        say,
+        republish: (token, { unattended } = {}) =>
+          client.publishSite(siteUuid, { ...(languages ? { languages } : {}), confirm: token, unattended })
+      })
+      if ('exitCode' in settled) return { exitCode: settled.exitCode }
+      pubRes = settled.response
+      failedBody = settled.body ?? ''
     }
-
+  }
+  if (!pubRes.ok) {
     say.err(`Publish rejected: HTTP ${pubRes.status} ${pubRes.statusText}`)
     if (pubRes.status === 401 || pubRes.status === 403) {
       say.dim(
         "Credentials weren't accepted — run `uniweb login` again."
       )
     }
-    if (body) say.dim(body.slice(0, 800))
+    if (failedBody) say.dim(failedBody.slice(0, 800))
     return { exitCode: 1 }
   }
   let result
@@ -1163,6 +1175,11 @@ export async function publish(args = []) {
   say.ok(
     `Published ${c.bold}${siteUuid}${c.reset}${result.status ? ` (${result.status})` : ''}`
   )
+  // What the request changed, in the backend's own sentences — a confirmed change, or a reduction
+  // (`applied`, its §4A). Absent when nothing changed.
+  for (const line of Array.isArray(result.applied) ? result.applied : []) {
+    if (typeof line === 'string' && line) say.info(line)
+  }
 
   // ⛔ SAY IT WHEN A LANGUAGE ASKED FOR DID NOT GO OUT.
   //

package/src/framework-index.json

@@ -1,16 +1,16 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-03T13:45:26.166Z",
+  "generatedAt": "2026-10-05T18:23:45.673Z",
   "packages": {
     "@uniweb/api": {
-      "version": "0.6.9",
+      "version": "0.6.10",
       "path": "framework/api",
       "deps": [
         "@uniweb/core"
       ]
     },
     "@uniweb/build": {
-      "version": "0.75.1",
+      "version": "0.76.0",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -35,7 +35,7 @@
       "deps": []
     },
     "@uniweb/core": {
-      "version": "0.36.0",
+      "version": "0.37.0",
       "path": "framework/core",
       "deps": [
         "@uniweb/semantic-parser",
@@ -48,14 +48,14 @@
       "deps": []
     },
     "@uniweb/icons": {
-      "version": "0.4.27",
+      "version": "0.4.28",
       "path": "framework/icons",
       "deps": [
         "@uniweb/core"
       ]
     },
     "@uniweb/kit": {
-      "version": "0.19.15",
+      "version": "0.19.16",
       "path": "framework/kit",
       "deps": [
         "@uniweb/core",
@@ -76,7 +76,7 @@
       "deps": []
     },
     "@uniweb/projections": {
-      "version": "0.7.13",
+      "version": "0.7.14",
       "path": "framework/projections",
       "deps": [
         "@uniweb/content-writer",
@@ -84,7 +84,7 @@
       ]
     },
     "@uniweb/runtime": {
-      "version": "0.28.10",
+      "version": "0.29.0",
       "path": "framework/runtime",
       "deps": [
         "@uniweb/core",
@@ -97,7 +97,7 @@
       "deps": []
     },
     "@uniweb/schemas": {
-      "version": "0.10.2",
+      "version": "0.11.0",
       "path": "framework/schemas",
       "deps": []
     },
@@ -117,7 +117,7 @@
       "deps": []
     },
     "@uniweb/templates": {
-      "version": "0.17.12",
+      "version": "0.17.13",
       "path": "framework/templates",
       "deps": []
     },
@@ -127,7 +127,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.10.19",
+      "version": "0.10.20",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",