uniweb 0.37.0 → 0.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.37.0",
+  "version": "0.37.1",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -42,14 +42,14 @@
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
     "@uniweb/core": "^0.16.0",
-    "@uniweb/kit": "^0.15.2",
+    "@uniweb/kit": "^0.15.3",
     "@uniweb/runtime": "^0.13.5",
     "@uniweb/semantic-parser": "^1.4.0"
   },
   "peerDependencies": {
     "@uniweb/build": "^0.33.0",
-    "@uniweb/content-reader": "^1.2.4",
-    "@uniweb/semantic-parser": "^1.4.0"
+    "@uniweb/semantic-parser": "^1.4.0",
+    "@uniweb/content-reader": "^1.2.4"
   },
   "peerDependenciesMeta": {
     "@uniweb/build": {

package/src/framework-index.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-09-02T16:36:26.382Z",
+  "generatedAt": "2026-09-02T17:42:38.924Z",
   "packages": {
     "@uniweb/api": {
       "version": "0.2.2",
@@ -54,7 +54,7 @@
       ]
     },
     "@uniweb/kit": {
-      "version": "0.15.2",
+      "version": "0.15.3",
       "path": "framework/kit",
       "deps": [
         "@uniweb/core",
@@ -119,7 +119,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.8.19",
+      "version": "0.8.20",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",

package/src/templates/fetchers/github.js

@@ -8,6 +8,7 @@ import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import * as tar from 'tar'
+import { fetchWithRetry as sharedFetchWithRetry } from '../../utils/fetch-retry.js'
 
 /**
  * Fetch a template from a GitHub repository
@@ -78,21 +79,9 @@ export async function fetchGitHubTemplate(owner, repo, options = {}) {
   }
 }
 
-/**
- * Fetch with retry and timeout
- */
-async function fetchWithRetry(url, options = {}, maxRetries = 3) {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      const response = await fetch(url, {
-        ...options,
-        signal: AbortSignal.timeout(60000) // 60s timeout for GitHub (can be slow)
-      })
-      return response
-    } catch (err) {
-      if (attempt === maxRetries) throw err
-      const delay = Math.min(1000 * Math.pow(2, attempt), 10000)
-      await new Promise((r) => setTimeout(r, delay))
-    }
-  }
-}
+// Retry + timeout live in one place now (`../../utils/fetch-retry.js`).
+// This file carried its own copy, as did the other two fetchers — three
+// byte-identical implementations, and none reachable from the upload paths
+// that had no retry at all. The wrapper keeps this caller's own timeout.
+const fetchWithRetry = (url, options = {}, maxRetries = 3) =>
+  sharedFetchWithRetry(url, { ...options }, { retries: maxRetries, timeoutMs: 60000 })

package/src/templates/fetchers/npm.js

@@ -8,6 +8,7 @@ import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import * as tar from 'tar'
+import { fetchWithRetry as sharedFetchWithRetry } from '../../utils/fetch-retry.js'
 
 /**
  * Fetch a template from npm registry
@@ -76,21 +77,9 @@ export async function fetchNpmTemplate(packageName, options = {}) {
   }
 }
 
-/**
- * Fetch with retry and timeout
- */
-async function fetchWithRetry(url, options = {}, maxRetries = 3) {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      const response = await fetch(url, {
-        ...options,
-        signal: AbortSignal.timeout(30000) // 30s timeout
-      })
-      return response
-    } catch (err) {
-      if (attempt === maxRetries) throw err
-      const delay = Math.min(1000 * Math.pow(2, attempt), 10000)
-      await new Promise((r) => setTimeout(r, delay))
-    }
-  }
-}
+// Retry + timeout live in one place now (`../../utils/fetch-retry.js`).
+// This file carried its own copy, as did the other two fetchers — three
+// byte-identical implementations, and none reachable from the upload paths
+// that had no retry at all. The wrapper keeps this caller's own timeout.
+const fetchWithRetry = (url, options = {}, maxRetries = 3) =>
+  sharedFetchWithRetry(url, { ...options }, { retries: maxRetries, timeoutMs: 30000 })

package/src/templates/fetchers/release.js

@@ -8,6 +8,7 @@ import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import * as tar from 'tar'
+import { fetchWithRetry as sharedFetchWithRetry } from '../../utils/fetch-retry.js'
 
 // GitHub repository for official templates
 const TEMPLATES_REPO = 'uniweb/templates'
@@ -222,22 +223,9 @@ async function handleGitHubError(response) {
   throw new Error(`GitHub API error: ${response.status}`)
 }
 
-/**
- * Fetch with retry and timeout
- */
-async function fetchWithRetry(url, options = {}, maxRetries = 3) {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      const response = await fetch(url, {
-        ...options,
-        redirect: 'follow',
-        signal: AbortSignal.timeout(60000) // 60s timeout
-      })
-      return response
-    } catch (err) {
-      if (attempt === maxRetries) throw err
-      const delay = Math.min(1000 * Math.pow(2, attempt), 10000)
-      await new Promise((r) => setTimeout(r, delay))
-    }
-  }
-}
+// Retry + timeout live in one place now (`../../utils/fetch-retry.js`).
+// This file carried its own copy, as did the other two fetchers — three
+// byte-identical implementations, and none reachable from the upload paths
+// that had no retry at all. The wrapper keeps this caller's own timeout.
+const fetchWithRetry = (url, options = {}, maxRetries = 3) =>
+  sharedFetchWithRetry(url, { redirect: 'follow', ...options }, { retries: maxRetries, timeoutMs: 60000 })

package/src/utils/asset-upload.js

@@ -30,6 +30,7 @@ import { createHash } from 'node:crypto'
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { contentTypeFor } from './code-upload.js'
+import { fetchWithRetry, isTransientStatus } from './fetch-retry.js'
 
 /**
  * Walk a built site's `dist/assets/` and produce the upload file list. `path` is
@@ -202,11 +203,20 @@ export async function uploadSiteAssets({
     try {
       // The plan's url may be origin-relative (direct mode → the backend) or
       // absolute (presigned → storage); new URL() resolves both.
-      putRes = await fetch(new URL(up.url, origin), {
+      // ⭐ **Retried.** A single connection-level failure used to fail the whole
+      // verb after every other file had already gone up. The PUT is idempotent
+      // here — same bytes, same target, verified by `x-uniweb-sha256` on receipt
+      // — so repeating it is safe by construction, which is why this opts in to
+      // `retryOnStatus` rather than inheriting it.
+      //
+      // ⚠️ 120s per attempt, not the helper's 30s default: this bounds the time
+      // to send a whole BODY, and aborting a legitimately slow upload only to
+      // retry it is worse than not timing out at all.
+      putRes = await fetchWithRetry(new URL(up.url, origin), {
         method: up.method || 'PUT',
         headers,
         body: src.bytes ?? readFileSync(src.diskPath)
-      })
+      }, { timeoutMs: 120_000, retryOnStatus: isTransientStatus })
     } catch (err) {
       failed.push({ path: src.path, status: 0, detail: err.message })
       continue

package/src/utils/code-upload.js

@@ -41,6 +41,7 @@
 import { createHash } from 'node:crypto'
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { join } from 'node:path'
+import { fetchWithRetry, isTransientStatus } from './fetch-retry.js'
 
 // Extension → declared content type. Extension-honest by construction (Vite
 // output); anything unknown ships as octet-stream.
@@ -287,7 +288,16 @@ export async function uploadFoundationCode({
     }
     const bytes = readFileSync(join(distDir, file.path))
     try {
-      const res = await fetch(new URL(target.url, origin), {
+      // ⭐ **Retried.** A single connection-level failure used to fail the whole
+      // verb after every other file had already gone up. The PUT is idempotent
+      // here — same bytes, same target, verified by `x-uniweb-sha256` on receipt
+      // — so repeating it is safe by construction, which is why this opts in to
+      // `retryOnStatus` rather than inheriting it.
+      //
+      // ⚠️ 120s per attempt, not the helper's 30s default: this bounds the time
+      // to send a whole BODY, and aborting a legitimately slow upload only to
+      // retry it is worse than not timing out at all.
+      const res = await fetchWithRetry(new URL(target.url, origin), {
         method: target.method || 'PUT',
         // x-uniweb-sha256: optional integrity guard — direct mode verifies
         // the received bytes and 400s on mismatch (corruption-in-flight).
@@ -297,7 +307,7 @@ export async function uploadFoundationCode({
           'x-uniweb-sha256': file.sha256
         },
         body: bytes
-      })
+      }, { timeoutMs: 120_000, retryOnStatus: isTransientStatus })
       if (res.ok) {
         uploaded.push(file.path)
         onProgress(`${file.path} (${file.size} bytes)`)

package/src/utils/fetch-retry.js

@@ -0,0 +1,109 @@
+/**
+ * `fetch` with bounded retry and a timeout. **The one implementation.**
+ *
+ * ## Why this file exists
+ *
+ * There were three, byte-identical apart from a timeout constant — one each in
+ * `templates/fetchers/{npm,release,github}.js` — and **none of them was reachable
+ * from the code that needed it most.** The three upload paths (`code-upload`,
+ * `asset-upload`, `site-data-upload`) had no retry at all, so a single
+ * connection-level failure on any one file failed the whole `register` / `push`
+ * / `publish` after every other file had already gone up.
+ *
+ * ⭐ **Measured by the `flows` lane, 2026-09-02:** roughly one red per full suite
+ * run, landing on a *different flow each time* and passing on re-run every time —
+ * the signature of an unretried transient, with the network as the variable
+ * rather than any flow. Their symptom was recorded as "not diagnosed, may be the
+ * manor, the CDN, or the connection"; it was none of those. It was us.
+ *
+ * ## ⚠️ What a retry does NOT do
+ *
+ * It masks whatever drops the connection. That is the right trade for a genuine
+ * transient and the wrong one for a systematic fault: if the failure rate ever
+ * climbs, a retry turns a fast red into a slow one and hides the cause. **Do not
+ * read a green run as evidence the network is healthy.**
+ *
+ * ## Retrying a PUT is safe HERE, and not in general
+ *
+ * These uploads are idempotent by construction — the same bytes to the same
+ * target, with an `x-uniweb-sha256` integrity guard the far side verifies. That
+ * is why `retryOnStatus` is **opt-in** rather than the default: a caller has to
+ * assert its own idempotence, because this helper cannot know it.
+ */
+
+const DEFAULT_RETRIES = 3
+const DEFAULT_TIMEOUT_MS = 30_000
+const MAX_BACKOFF_MS = 10_000
+
+/** Exponential backoff, capped. Attempt is 1-based. */
+const backoffMs = (attempt) => Math.min(1000 * Math.pow(2, attempt), MAX_BACKOFF_MS)
+
+/**
+ * @param {string|URL} url
+ * @param {RequestInit} [options] - passed to `fetch`; `signal` is supplied here.
+ * @param {Object} [config]
+ * @param {number} [config.retries=3] - total attempts, not extra ones.
+ * @param {number} [config.timeoutMs=30000] - per ATTEMPT, not for the whole call.
+ *   ⚠️ For an upload this bounds the time to send a whole body, so a large file
+ *   on a slow link needs a generous value — too short and a legitimately slow
+ *   upload is aborted and then retried, which is worse than no timeout at all.
+ * @param {(status: number) => boolean} [config.retryOnStatus] - opt-in. Without
+ *   it only a THROWN fetch is retried (a connection-level failure, which is what
+ *   surfaces as `status: 0` in the upload paths). A caller passing this asserts
+ *   its request is safe to repeat.
+ * @param {(info: {attempt: number, of: number, reason: string, delayMs: number}) => void} [config.onRetry]
+ *   Called before each wait. ⭐ Worth passing: a retry that no one can see turns
+ *   a visible failure into an invisible slowdown, which is its own defect.
+ * @returns {Promise<Response>}
+ */
+export async function fetchWithRetry(url, options = {}, config = {}) {
+  const {
+    retries = DEFAULT_RETRIES,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    retryOnStatus = null,
+    onRetry = null,
+  } = config
+
+  let lastErr = null
+
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const res = await fetch(url, {
+        ...options,
+        signal: options.signal ?? AbortSignal.timeout(timeoutMs),
+      })
+
+      if (attempt < retries && retryOnStatus && retryOnStatus(res.status)) {
+        const delayMs = backoffMs(attempt)
+        onRetry?.({ attempt, of: retries, reason: `HTTP ${res.status}`, delayMs })
+        await new Promise((r) => setTimeout(r, delayMs))
+        continue
+      }
+
+      return res
+    } catch (err) {
+      lastErr = err
+      // The last attempt throws to the caller, which keeps this a drop-in for
+      // the three template fetchers whose contract was "throws like fetch".
+      if (attempt === retries) throw err
+      const delayMs = backoffMs(attempt)
+      onRetry?.({ attempt, of: retries, reason: err.message, delayMs })
+      await new Promise((r) => setTimeout(r, delayMs))
+    }
+  }
+
+  /* c8 ignore next 2 -- unreachable: the loop returns or throws on the last attempt */
+  throw lastErr
+}
+
+/**
+ * The statuses worth repeating an idempotent request for: a server that failed
+ * to answer this time, or asked us to slow down.
+ *
+ * ⛔ Never a 4xx other than 429 — a rejection does not improve on repetition,
+ * and retrying one turns a clear error into a delayed clear error.
+ *
+ * @param {number} status
+ * @returns {boolean}
+ */
+export const isTransientStatus = (status) => status === 429 || status >= 500

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

@@ -52,6 +52,7 @@
 
 import { createHash } from 'node:crypto'
 import { humanBytes } from './bytes.js'
+import { fetchWithRetry, isTransientStatus } from './fetch-retry.js'
 
 /**
  * Plan + upload a site's static collection data files.
@@ -189,7 +190,16 @@ export async function uploadSiteData({
     try {
       // Relative on the direct arm, absolute on presigned — `new URL` resolves
       // both against the origin.
-      const res = await fetch(new URL(target.url, origin), {
+      // ⭐ **Retried.** A single connection-level failure used to fail the whole
+      // verb after every other file had already gone up. The PUT is idempotent
+      // here — same bytes, same target, verified by `x-uniweb-sha256` on receipt
+      // — so repeating it is safe by construction, which is why this opts in to
+      // `retryOnStatus` rather than inheriting it.
+      //
+      // ⚠️ 120s per attempt, not the helper's 30s default: this bounds the time
+      // to send a whole BODY, and aborting a legitimately slow upload only to
+      // retry it is worse than not timing out at all.
+      const res = await fetchWithRetry(new URL(target.url, origin), {
         method: target.method || 'PUT',
         headers: {
           'Content-Type': 'application/json',
@@ -197,7 +207,7 @@ export async function uploadSiteData({
           ...authHeaders
         },
         body: f.bytes
-      })
+      }, { timeoutMs: 120_000, retryOnStatus: isTransientStatus })
       if (res.ok) {
         uploaded.push(f.path)
         onProgress(`${f.path}`)