uniweb 0.81.1 → 0.81.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.81.1",
+  "version": "0.81.3",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -41,17 +41,17 @@
     "js-yaml": "^4.1.0",
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
-    "@uniweb/runtime": "^0.28.10",
     "@uniweb/content-writer": "^0.3.4",
     "@uniweb/schemas": "^0.10.2",
-    "@uniweb/core": "^0.36.0",
+    "@uniweb/runtime": "^0.28.10",
     "@uniweb/kit": "^0.19.15",
+    "@uniweb/core": "^0.36.0",
     "@uniweb/semantic-parser": "^1.5.1"
   },
   "peerDependencies": {
-    "@uniweb/content-reader": "^1.2.8",
     "@uniweb/semantic-parser": "^1.5.1",
-    "@uniweb/build": "^0.75.0"
+    "@uniweb/content-reader": "^1.2.8",
+    "@uniweb/build": "^0.75.1"
   },
   "peerDependenciesMeta": {
     "@uniweb/build": {

package/partials/agents.md

@@ -2761,6 +2761,8 @@ locales/freeform/es/records/article/x.md       # records work too
 
 These are **body only — no frontmatter**; params and config still come from the source section. `uniweb i18n init-freeform es pages/about hero` creates one pre-filled and records a source hash, so `uniweb i18n status --freeform` can tell you when the original moved on (`update-hash` to acknowledge). `move`, `rename`, and `prune --freeform` keep them aligned when pages get reorganized.
 
+**A tagged data block translates by the shape its key declares** in the component's `meta.js` `data:` — a data schema or an inline field map: its text fields, never an enum, a URL or a `translatable: false` field. A key declared `{}` leaves its blocks to a heuristic that offers any string whose field name and value don't look structural, so a `style: display-black` naming one of your component's looks gets translated too. Declare the shape of every block a translator will see — `{ name: 'string', style: { type: 'string', enum: [...] } }`.
+
 **Records translate in the same `extract` run**, into their own manifest at `locales/records/manifest.json` — keyed by the RECORD, so a record translated once is found by every query that returns it. A record whose query has a data schema translates exactly the fields the schema says are text — never an enum, a URL, a date, a number, a file, a reference or a `translatable: false` field — which are the fields a push carries in each language; mark a string that is a code or a key `translatable: false` and no translator is asked for it. An excerpt the build derives is re-derived from each language's body.
 
 **Component side.** Nothing to do: `content.title` arrives in the active language. The one thing a foundation builds is a switcher.

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/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/commands/pull.js

@@ -73,6 +73,7 @@ import { downloadMissingAssets, downloadFileRecords } from '../backend/asset-dow
 import {
   readBackendState,
   siteContentDocumentToProject,
+  dataBlockModels,
   recordsToProject,
   siteSelfScope,
   readZip,
@@ -988,7 +989,10 @@ export async function pull(args = [], deps = {}) {
         prune,
         keepAuthoredFoundation,
         // So a query's `@acme/member` comes back as the author's `@/member`.
-        scope: await scopeFor(siteDoc)
+        scope: await scopeFor(siteDoc),
+        // A translated data block is read back by what its section's type declares it is, as the
+        // push translated it — after the registered foundation above, whose section types say it.
+        dataModel: await dataBlockModels(siteDir)
       })
       wrote.push(...report.pages, ...report.sections, ...report.layout)
       removed.push(

package/src/framework-index.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-02T03:03:06.390Z",
+  "generatedAt": "2026-10-03T13:45:26.166Z",
   "packages": {
     "@uniweb/api": {
       "version": "0.6.9",
@@ -10,7 +10,7 @@
       ]
     },
     "@uniweb/build": {
-      "version": "0.75.0",
+      "version": "0.75.1",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -117,7 +117,7 @@
       "deps": []
     },
     "@uniweb/templates": {
-      "version": "0.17.11",
+      "version": "0.17.12",
       "path": "framework/templates",
       "deps": []
     },