uniweb 0.13.16 → 0.14.0

package/src/commands/rename.js

@@ -53,7 +53,7 @@ import {
   writeWorkspaceConfig,
   readRootPackageJson,
   writeRootPackageJson,
-  updateRootScripts,
+  updateRootScripts
 } from '../utils/config.js'
 import { discoverFoundations, discoverSites } from '../utils/discover.js'
 import { writeJsonPreservingStyleAsync } from '../utils/json-file.js'
@@ -68,7 +68,7 @@ const colors = {
   cyan: '\x1b[36m',
   green: '\x1b[32m',
   yellow: '\x1b[33m',
-  red: '\x1b[31m',
+  red: '\x1b[31m'
 }
 
 const success = (msg) => console.log(`${colors.green}✓${colors.reset} ${msg}`)
@@ -107,7 +107,9 @@ export async function rename(args = []) {
   const rootDir = findWorkspaceRoot()
   if (!rootDir) {
     error('Not in a Uniweb workspace.')
-    log(`Run this command from your project root or a site/foundation directory.`)
+    log(
+      `Run this command from your project root or a site/foundation directory.`
+    )
     process.exit(1)
   }
 
@@ -133,7 +135,11 @@ function computeNewFolderPath(rootDir, oldPath, oldName, newName) {
   const leaf = basename(oldPath)
   const folderWillRename = leaf === oldName
   if (!folderWillRename) {
-    return { folderWillRename, newPath: oldPath, newDir: join(rootDir, oldPath) }
+    return {
+      folderWillRename,
+      newPath: oldPath,
+      newDir: join(rootDir, oldPath)
+    }
   }
   const parent = dirname(oldPath)
   const newPath = parent === '.' ? newName : join(parent, newName)
@@ -146,7 +152,11 @@ function computeNewFolderPath(rootDir, oldPath, oldName, newName) {
  * (the multi-PM compatibility invariant). Wildcard entries
  * (`extensions/*`) are left alone — only specific paths get rewritten.
  */
-async function updateWorkspaceManifestsForFolderMove(rootDir, oldPath, newPath) {
+async function updateWorkspaceManifestsForFolderMove(
+  rootDir,
+  oldPath,
+  newPath
+) {
   const wsConfig = await readWorkspaceConfig(rootDir)
   const rootPkg = await readRootPackageJson(rootDir)
   if (wsConfig.packages.includes(oldPath)) {
@@ -154,7 +164,10 @@ async function updateWorkspaceManifestsForFolderMove(rootDir, oldPath, newPath)
     wsConfig.packages[idx] = newPath
     await writeWorkspaceConfig(rootDir, wsConfig)
   }
-  if (Array.isArray(rootPkg.workspaces) && rootPkg.workspaces.includes(oldPath)) {
+  if (
+    Array.isArray(rootPkg.workspaces) &&
+    rootPkg.workspaces.includes(oldPath)
+  ) {
     const idx = rootPkg.workspaces.indexOf(oldPath)
     rootPkg.workspaces[idx] = newPath
     await writeRootPackageJson(rootDir, rootPkg)
@@ -178,7 +191,9 @@ async function validateRenameName(rootDir, newName) {
   }
   const existingNames = await getExistingPackageNames(rootDir)
   if (existingNames.has(newName)) {
-    error(`Cannot rename: a package named ${colors.bright}${newName}${colors.reset} already exists in this workspace.`)
+    error(
+      `Cannot rename: a package named ${colors.bright}${newName}${colors.reset} already exists in this workspace.`
+    )
     process.exit(1)
   }
 }
@@ -199,11 +214,13 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
   await validateRenameName(rootDir, newName)
 
   const foundations = await discoverFoundations(rootDir)
-  const target = foundations.find(f => f.name === oldName)
+  const target = foundations.find((f) => f.name === oldName)
   if (!target) {
-    error(`No foundation named ${colors.bright}${oldName}${colors.reset} in this workspace.`)
+    error(
+      `No foundation named ${colors.bright}${oldName}${colors.reset} in this workspace.`
+    )
     if (foundations.length > 0) {
-      log(`Available: ${foundations.map(f => f.name).join(', ')}`)
+      log(`Available: ${foundations.map((f) => f.name).join(', ')}`)
     }
     process.exit(1)
   }
@@ -214,17 +231,24 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
   // sites' deps + site.yml::foundation; extension rename touches
   // site.yml::extensions URLs).
   if (isExtensionPackage(join(rootDir, target.path))) {
-    error(`${colors.bright}${oldName}${colors.reset} is an extension, not a foundation.`)
+    error(
+      `${colors.bright}${oldName}${colors.reset} is an extension, not a foundation.`
+    )
     log(`Use \`${prefix} rename extension ${oldName} ${newName}\` instead.`)
     process.exit(1)
   }
 
   const oldFoundationPath = target.path
   const oldFoundationDir = join(rootDir, oldFoundationPath)
-  const { folderWillRename, newPath: newFoundationPath, newDir: newFoundationDir } =
-    computeNewFolderPath(rootDir, oldFoundationPath, oldName, newName)
+  const {
+    folderWillRename,
+    newPath: newFoundationPath,
+    newDir: newFoundationDir
+  } = computeNewFolderPath(rootDir, oldFoundationPath, oldName, newName)
   if (folderWillRename && existsSync(newFoundationDir)) {
-    error(`Cannot rename: target folder ${colors.bright}${newFoundationPath}/${colors.reset} already exists.`)
+    error(
+      `Cannot rename: target folder ${colors.bright}${newFoundationPath}/${colors.reset} already exists.`
+    )
     process.exit(1)
   }
 
@@ -263,7 +287,7 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
         siteYmlPath,
         ymlData,
         hasDep,
-        ymlMatches,
+        ymlMatches
       })
     }
   }
@@ -271,12 +295,16 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
   // ─── Print plan, then execute ────────────────────────────────
 
   log('')
-  log(`${colors.bright}Rename foundation${colors.reset}: ${colors.yellow}${oldName}${colors.reset} → ${colors.green}${newName}${colors.reset}`)
+  log(
+    `${colors.bright}Rename foundation${colors.reset}: ${colors.yellow}${oldName}${colors.reset} → ${colors.green}${newName}${colors.reset}`
+  )
   log('')
   if (folderWillRename) {
     info(`  Folder:  ${oldFoundationPath}/  →  ${newFoundationPath}/`)
   } else {
-    info(`  Folder:  ${oldFoundationPath}/  (unchanged — leaf doesn't match package name)`)
+    info(
+      `  Folder:  ${oldFoundationPath}/  (unchanged — leaf doesn't match package name)`
+    )
   }
   info(`  package.json::name:  "${oldName}"  →  "${newName}"`)
   if (affectedSites.length === 0) {
@@ -301,17 +329,24 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
       delete s.pkg.dependencies[oldName]
       s.pkg.dependencies[newName] = oldValue.startsWith('file:')
         ? `file:${newRel}`
-        : oldValue  // npm-pinned, leave it; rename-then-republish is out of scope.
+        : oldValue // npm-pinned, leave it; rename-then-republish is out of scope.
       await writeJsonPreservingStyleAsync(s.sitePkgPath, s.pkg, s.pkgSrc)
     }
     if (s.ymlMatches) {
       const newYmlData = { ...s.ymlData, foundation: newName }
-      await writeFile(s.siteYmlPath, yaml.dump(newYmlData, { flowLevel: -1, quotingType: "'" }))
+      await writeFile(
+        s.siteYmlPath,
+        yaml.dump(newYmlData, { flowLevel: -1, quotingType: "'" })
+      )
     }
   }
 
   if (folderWillRename) {
-    await updateWorkspaceManifestsForFolderMove(rootDir, oldFoundationPath, newFoundationPath)
+    await updateWorkspaceManifestsForFolderMove(
+      rootDir,
+      oldFoundationPath,
+      newFoundationPath
+    )
   }
 
   // Root scripts can reference the foundation by name (e.g. `pnpm --filter
@@ -322,7 +357,9 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
   await updateRootScripts(rootDir, freshSites, pm)
 
   log('')
-  success(`Renamed foundation ${colors.bright}${oldName}${colors.reset} → ${colors.bright}${newName}${colors.reset}`)
+  success(
+    `Renamed foundation ${colors.bright}${oldName}${colors.reset} → ${colors.bright}${newName}${colors.reset}`
+  )
   printNextSteps(prefix, pm)
 }
 
@@ -332,31 +369,42 @@ async function renameSite(rootDir, oldName, newName, prefix) {
   await validateRenameName(rootDir, newName)
 
   const sites = await discoverSites(rootDir)
-  const target = sites.find(s => s.name === oldName)
+  const target = sites.find((s) => s.name === oldName)
   if (!target) {
-    error(`No site named ${colors.bright}${oldName}${colors.reset} in this workspace.`)
+    error(
+      `No site named ${colors.bright}${oldName}${colors.reset} in this workspace.`
+    )
     if (sites.length > 0) {
-      log(`Available: ${sites.map(s => s.name).join(', ')}`)
+      log(`Available: ${sites.map((s) => s.name).join(', ')}`)
     }
     process.exit(1)
   }
 
   const oldSitePath = target.path
   const oldSiteDir = join(rootDir, oldSitePath)
-  const { folderWillRename, newPath: newSitePath, newDir: newSiteDir } =
-    computeNewFolderPath(rootDir, oldSitePath, oldName, newName)
+  const {
+    folderWillRename,
+    newPath: newSitePath,
+    newDir: newSiteDir
+  } = computeNewFolderPath(rootDir, oldSitePath, oldName, newName)
   if (folderWillRename && existsSync(newSiteDir)) {
-    error(`Cannot rename: target folder ${colors.bright}${newSitePath}/${colors.reset} already exists.`)
+    error(
+      `Cannot rename: target folder ${colors.bright}${newSitePath}/${colors.reset} already exists.`
+    )
     process.exit(1)
   }
 
   log('')
-  log(`${colors.bright}Rename site${colors.reset}: ${colors.yellow}${oldName}${colors.reset} → ${colors.green}${newName}${colors.reset}`)
+  log(
+    `${colors.bright}Rename site${colors.reset}: ${colors.yellow}${oldName}${colors.reset} → ${colors.green}${newName}${colors.reset}`
+  )
   log('')
   if (folderWillRename) {
     info(`  Folder:  ${oldSitePath}/  →  ${newSitePath}/`)
   } else {
-    info(`  Folder:  ${oldSitePath}/  (unchanged — leaf doesn't match package name)`)
+    info(
+      `  Folder:  ${oldSitePath}/  (unchanged — leaf doesn't match package name)`
+    )
   }
   info(`  package.json::name:  "${oldName}"  →  "${newName}"`)
   log('')
@@ -366,7 +414,11 @@ async function renameSite(rootDir, oldName, newName, prefix) {
   }
   await rewritePackageJsonName(join(newSiteDir, 'package.json'), newName)
   if (folderWillRename) {
-    await updateWorkspaceManifestsForFolderMove(rootDir, oldSitePath, newSitePath)
+    await updateWorkspaceManifestsForFolderMove(
+      rootDir,
+      oldSitePath,
+      newSitePath
+    )
   }
 
   // Root scripts include `pnpm --filter <site-name>` style invocations
@@ -377,7 +429,9 @@ async function renameSite(rootDir, oldName, newName, prefix) {
   await updateRootScripts(rootDir, freshSites, pm)
 
   log('')
-  success(`Renamed site ${colors.bright}${oldName}${colors.reset} → ${colors.bright}${newName}${colors.reset}`)
+  success(
+    `Renamed site ${colors.bright}${oldName}${colors.reset} → ${colors.bright}${newName}${colors.reset}`
+  )
   printNextSteps(prefix, pm)
 }
 
@@ -390,23 +444,32 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
   // by `extension: true` declaration). Find via discoverFoundations,
   // then verify the extension marker.
   const foundations = await discoverFoundations(rootDir)
-  const target = foundations.find(f => f.name === oldName)
+  const target = foundations.find((f) => f.name === oldName)
   if (!target) {
-    error(`No package named ${colors.bright}${oldName}${colors.reset} in this workspace.`)
+    error(
+      `No package named ${colors.bright}${oldName}${colors.reset} in this workspace.`
+    )
     process.exit(1)
   }
   if (!isExtensionPackage(join(rootDir, target.path))) {
-    error(`${colors.bright}${oldName}${colors.reset} is a foundation, not an extension.`)
+    error(
+      `${colors.bright}${oldName}${colors.reset} is a foundation, not an extension.`
+    )
     log(`Use \`${prefix} rename foundation ${oldName} ${newName}\` instead.`)
     process.exit(1)
   }
 
   const oldExtPath = target.path
   const oldExtDir = join(rootDir, oldExtPath)
-  const { folderWillRename, newPath: newExtPath, newDir: newExtDir } =
-    computeNewFolderPath(rootDir, oldExtPath, oldName, newName)
+  const {
+    folderWillRename,
+    newPath: newExtPath,
+    newDir: newExtDir
+  } = computeNewFolderPath(rootDir, oldExtPath, oldName, newName)
   if (folderWillRename && existsSync(newExtDir)) {
-    error(`Cannot rename: target folder ${colors.bright}${newExtPath}/${colors.reset} already exists.`)
+    error(
+      `Cannot rename: target folder ${colors.bright}${newExtPath}/${colors.reset} already exists.`
+    )
     process.exit(1)
   }
 
@@ -429,19 +492,25 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
       continue
     }
     const exts = Array.isArray(ymlData.extensions) ? ymlData.extensions : []
-    const hits = exts.filter(e => typeof e === 'string' && e.startsWith(oldUrlPrefix))
+    const hits = exts.filter(
+      (e) => typeof e === 'string' && e.startsWith(oldUrlPrefix)
+    )
     if (hits.length > 0) {
       affectedSites.push({ site, ymlData, siteYmlPath, hits })
     }
   }
 
   log('')
-  log(`${colors.bright}Rename extension${colors.reset}: ${colors.yellow}${oldName}${colors.reset} → ${colors.green}${newName}${colors.reset}`)
+  log(
+    `${colors.bright}Rename extension${colors.reset}: ${colors.yellow}${oldName}${colors.reset} → ${colors.green}${newName}${colors.reset}`
+  )
   log('')
   if (folderWillRename) {
     info(`  Folder:  ${oldExtPath}/  →  ${newExtPath}/`)
   } else {
-    info(`  Folder:  ${oldExtPath}/  (unchanged — leaf doesn't match package name)`)
+    info(
+      `  Folder:  ${oldExtPath}/  (unchanged — leaf doesn't match package name)`
+    )
   }
   info(`  package.json::name:  "${oldName}"  →  "${newName}"`)
   if (affectedSites.length === 0) {
@@ -449,7 +518,9 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
   } else {
     info(`  Sites referencing this extension:`)
     for (const { site, hits } of affectedSites) {
-      info(`    • ${site.name} at ${site.path}/  (${hits.length} entr${hits.length === 1 ? 'y' : 'ies'})`)
+      info(
+        `    • ${site.name} at ${site.path}/  (${hits.length} entr${hits.length === 1 ? 'y' : 'ies'})`
+      )
     }
   }
   log('')
@@ -460,13 +531,16 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
   await rewritePackageJsonName(join(newExtDir, 'package.json'), newName)
 
   for (const a of affectedSites) {
-    const newExts = (a.ymlData.extensions || []).map(e =>
+    const newExts = (a.ymlData.extensions || []).map((e) =>
       typeof e === 'string' && e.startsWith(oldUrlPrefix)
         ? newUrlPrefix + e.slice(oldUrlPrefix.length)
         : e
     )
     const newYmlData = { ...a.ymlData, extensions: newExts }
-    await writeFile(a.siteYmlPath, yaml.dump(newYmlData, { flowLevel: -1, quotingType: "'" }))
+    await writeFile(
+      a.siteYmlPath,
+      yaml.dump(newYmlData, { flowLevel: -1, quotingType: "'" })
+    )
   }
 
   if (folderWillRename) {
@@ -479,7 +553,9 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
 
   const pm = detectPackageManager()
   log('')
-  success(`Renamed extension ${colors.bright}${oldName}${colors.reset} → ${colors.bright}${newName}${colors.reset}`)
+  success(
+    `Renamed extension ${colors.bright}${oldName}${colors.reset} → ${colors.bright}${newName}${colors.reset}`
+  )
   printNextSteps(prefix, pm)
 }
 
@@ -487,8 +563,12 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
 
 function printNextSteps(prefix, pm) {
   log('')
-  log(`Next: ${colors.cyan}${installCmd(pm)}${colors.reset}  ${colors.dim}(refresh symlinks under the new name)${colors.reset}`)
-  log(`      ${colors.cyan}${prefix} doctor${colors.reset}  ${colors.dim}(verify wiring)${colors.reset}`)
+  log(
+    `Next: ${colors.cyan}${installCmd(pm)}${colors.reset}  ${colors.dim}(refresh symlinks under the new name)${colors.reset}`
+  )
+  log(
+    `      ${colors.cyan}${prefix} doctor${colors.reset}  ${colors.dim}(verify wiring)${colors.reset}`
+  )
 }
 
 function showHelp(prefix) {

package/src/commands/runtime.js

@@ -22,19 +22,28 @@ import { readFileSync } from 'node:fs'
 import { resolve, join } from 'node:path'
 
 import { BackendClient } from '../backend/client.js'
-import { collectRuntimeFiles, hasWorkerRuntime, hasShims } from '../utils/runtime-upload.js'
+import {
+  collectRuntimeFiles,
+  hasWorkerRuntime,
+  hasShims
+} from '../utils/runtime-upload.js'
 import { readFlagValue } from '../utils/args.js'
 
 const c = {
-  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
-  cyan: '\x1b[36m', green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m',
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m'
 }
 const say = {
   ok: (m) => console.log(`${c.green}✓${c.reset} ${m}`),
   info: (m) => console.log(`${c.cyan}→${c.reset} ${m}`),
   warn: (m) => console.log(`${c.yellow}⚠${c.reset} ${m}`),
   err: (m) => console.error(`${c.red}✗${c.reset} ${m}`),
-  dim: (m) => console.log(`  ${c.dim}${m}${c.reset}`),
+  dim: (m) => console.log(`  ${c.dim}${m}${c.reset}`)
 }
 
 // The runtime package dir: --path, else the cwd when it IS @uniweb/runtime.
@@ -42,7 +51,10 @@ function resolveRuntimeDir(args) {
   const pathFlag = readFlagValue(args, '--path')
   if (pathFlag) return resolve(pathFlag)
   try {
-    if (JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf8')).name === '@uniweb/runtime') {
+    if (
+      JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf8'))
+        .name === '@uniweb/runtime'
+    ) {
       return process.cwd()
     }
   } catch {
@@ -54,8 +66,14 @@ function resolveRuntimeDir(args) {
 export async function runtime(args = []) {
   const sub = args[0]
   if (sub !== 'register') {
-    say.err(sub ? `Unknown subcommand: runtime ${sub}` : 'Usage: uniweb runtime register')
-    say.dim('uniweb runtime register — upload the built @uniweb/runtime to the backend (@std only).')
+    say.err(
+      sub
+        ? `Unknown subcommand: runtime ${sub}`
+        : 'Usage: uniweb runtime register'
+    )
+    say.dim(
+      'uniweb runtime register — upload the built @uniweb/runtime to the backend (@std only).'
+    )
     return { exitCode: sub ? 1 : 0 }
   }
   const rest = args.slice(1)
@@ -80,60 +98,92 @@ export async function runtime(args = []) {
   let version = readFlagValue(rest, '--version')
   if (!version) {
     try {
-      version = JSON.parse(readFileSync(join(distDir, 'app', 'manifest.json'), 'utf8')).version
+      version = JSON.parse(
+        readFileSync(join(distDir, 'app', 'manifest.json'), 'utf8')
+      ).version
     } catch (err) {
       say.err(`Could not read dist/app/manifest.json: ${err.message}`)
       return { exitCode: 2 }
     }
     if (!version) {
-      say.err('dist/app/manifest.json has no "version" field — rebuild the runtime.')
+      say.err(
+        'dist/app/manifest.json has no "version" field — rebuild the runtime.'
+      )
       return { exitCode: 2 }
     }
   }
   // The ssr-edge artifact is a SET: worker-runtime.js + its shims/*.js. Warn when
   // the set is absent or incomplete (a worker without shims can't resolve react).
   if (!hasWorkerRuntime(files)) {
-    say.warn("dist/worker-runtime.js is missing — the SSR isolate bundle won't be uploaded.")
-    say.dim('Build it first: `pnpm build:worker` in @uniweb/runtime (after `pnpm build`).')
+    say.warn(
+      "dist/worker-runtime.js is missing — the SSR isolate bundle won't be uploaded."
+    )
+    say.dim(
+      'Build it first: `pnpm build:worker` in @uniweb/runtime (after `pnpm build`).'
+    )
   } else if (!hasShims(files)) {
-    say.warn('dist/worker-runtime.js is present but dist/shims/ is missing — the SSR isolate set is incomplete.')
-    say.dim('The isolate resolves react/jsx-runtime/@uniweb/core through those shims; re-run `pnpm build:worker`.')
+    say.warn(
+      'dist/worker-runtime.js is present but dist/shims/ is missing — the SSR isolate set is incomplete.'
+    )
+    say.dim(
+      'The isolate resolves react/jsx-runtime/@uniweb/core through those shims; re-run `pnpm build:worker`.'
+    )
   }
 
   if (dryRun) {
-    say.info(`Would register ${c.bold}@uniweb/runtime@${version}${c.reset} (${files.length} files):`)
-    for (const f of files) say.dim(`${f.path}  ${f.size} bytes  ${f.content_type}`)
+    say.info(
+      `Would register ${c.bold}@uniweb/runtime@${version}${c.reset} (${files.length} files):`
+    )
+    for (const f of files)
+      say.dim(`${f.path}  ${f.size} bytes  ${f.content_type}`)
     return { exitCode: 0 }
   }
 
   const client = new BackendClient({
-    originFlag: readFlagValue(rest, '--backend') || readFlagValue(rest, '--registry'),
+    originFlag:
+      readFlagValue(rest, '--backend') || readFlagValue(rest, '--registry'),
     token: readFlagValue(rest, '--token') || undefined,
     args: rest,
-    command: 'Registering the runtime',
+    command: 'Registering the runtime'
   })
 
-  say.info(`Registering ${c.bold}@uniweb/runtime@${version}${c.reset} → ${c.dim}${client.origin}${c.reset} (${files.length} files)…`)
+  say.info(
+    `Registering ${c.bold}@uniweb/runtime@${version}${c.reset} → ${c.dim}${client.origin}${c.reset} (${files.length} files)…`
+  )
   let result
   try {
-    result = await client.uploadRuntime({ version, distDir, files, onProgress: (m) => say.dim(m) })
+    result = await client.uploadRuntime({
+      version,
+      distDir,
+      files,
+      onProgress: (m) => say.dim(m)
+    })
   } catch (err) {
     if (err.status === 403) {
-      say.err('Not authorized — registering a runtime version requires @std membership.')
+      say.err(
+        'Not authorized — registering a runtime version requires @std membership.'
+      )
       return { exitCode: 1 }
     }
     say.err(`Runtime registration failed: ${err.message}`)
-    say.dim('Set the origin with --backend <url>; auth with `uniweb login` or --token <bearer>.')
+    say.dim(
+      'Set the origin with --backend <url>; auth with `uniweb login` or --token <bearer>.'
+    )
     return { exitCode: 1 }
   }
   if (result.failed.length) {
     say.err(`${result.failed.length} file(s) failed to upload:`)
-    for (const f of result.failed) say.dim(`${f.path} — HTTP ${f.status} ${f.detail}`)
-    say.dim('Re-run `uniweb runtime register` to resume — completed files dedupe.')
+    for (const f of result.failed)
+      say.dim(`${f.path} — HTTP ${f.status} ${f.detail}`)
+    say.dim(
+      'Re-run `uniweb runtime register` to resume — completed files dedupe.'
+    )
     return { exitCode: 1 }
   }
   console.log('')
-  say.ok(`Registered ${c.bold}@uniweb/runtime@${version}${c.reset} (${result.uploaded.length} files, ${result.mode} mode)`)
+  say.ok(
+    `Registered ${c.bold}@uniweb/runtime@${version}${c.reset} (${result.uploaded.length} files, ${result.mode} mode)`
+  )
   if (result.serveBase) say.dim(`served at ${result.serveBase}`)
   return { exitCode: 0 }
 }