nappup 2.3.3 → 2.3.5

package/README.md

@@ -138,3 +138,20 @@ await publishApp(fileList, signer, {
 - **`fileList`** — a `FileList` or array of `File` objects (each needs `webkitRelativePath`).
 - **`signer`** — a [NIP-07](https://github.com/nostr-protocol/nips/blob/master/07.md)-compatible signer. In the browser, `window.nostr` is used automatically if omitted.
 - **`onEvent`** — optional callback that receives progress events with a `type` (`'init'`, `'file-uploaded'`, `'complete'`, `'error'`, …) and `progress` (0–100).
+
+Rejected uploads use `NappupError`, with a stable code from
+`NAPPUP_ERROR_CODES`. The original error is retained as `cause`, and some
+errors include structured `details`, so applications can show their own
+recovery instructions without matching CLI-oriented message text:
+
+```js
+import publishApp, { NAPPUP_ERROR_CODES } from 'nappup'
+
+try {
+  await publishApp(fileList, signer)
+} catch (error) {
+  if (error.code === NAPPUP_ERROR_CODES.GENERIC_FOLDER_NAME) {
+    // Ask the user to choose a unique app folder name.
+  }
+}
+```

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "MIT",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {
@@ -22,7 +22,7 @@
     "@noble/hashes": "^2.0.0",
     "dotenv": "^17.2.0",
     "file-type": "^21.0.0",
-    "libp2r2p": "^0.10.2",
+    "libp2r2p": "^0.10.5",
     "mime-types": "^3.0.1",
     "nmmr": "^2.0.0"
   },

package/src/errors.js

@@ -0,0 +1,78 @@
+const ERROR_CODE = /^[A-Z][A-Z0-9_]*$/
+
+export const NAPPUP_ERROR_CODES = Object.freeze({
+  UPLOAD_CANCELLED: 'NAPPUP_UPLOAD_CANCELLED',
+  NO_SIGNER: 'NAPPUP_NO_SIGNER',
+  EMPTY_FILE_LIST: 'NAPPUP_EMPTY_FILE_LIST',
+  RELAY_LOOKUP_FAILED: 'NAPPUP_RELAY_LOOKUP_FAILED',
+  NO_OUTBOX_RELAYS: 'NAPPUP_NO_OUTBOX_RELAYS',
+  INVALID_D_TAG: 'NAPPUP_INVALID_D_TAG',
+  GENERIC_FOLDER_NAME: 'NAPPUP_GENERIC_FOLDER_NAME',
+  INVALID_FOLDER_NAME: 'NAPPUP_INVALID_FOLDER_NAME',
+  BLOSSOM_UPLOAD_FAILED: 'NAPPUP_BLOSSOM_UPLOAD_FAILED',
+  IRFS_UPLOAD_FAILED: 'NAPPUP_IRFS_UPLOAD_FAILED',
+  MANIFEST_UPLOAD_FAILED: 'NAPPUP_MANIFEST_UPLOAD_FAILED',
+  UPLOAD_FAILED: 'NAPPUP_UPLOAD_FAILED'
+})
+
+// Carries a stable machine-readable code while retaining technical context.
+export class NappupError extends Error {
+  constructor (code, messageOrOptions = code, causeOrOptions) {
+    if (typeof code !== 'string' || !ERROR_CODE.test(code)) {
+      throw new TypeError('Nappup error code should be uppercase snake case')
+    }
+    const objectOptions = messageOrOptions && typeof messageOrOptions === 'object'
+      ? messageOrOptions
+      : null
+    const trailingOptions = !objectOptions && causeOrOptions && typeof causeOrOptions === 'object' &&
+      (Object.hasOwn(causeOrOptions, 'cause') || Object.hasOwn(causeOrOptions, 'details'))
+      ? causeOrOptions
+      : null
+    const options = objectOptions || trailingOptions
+    const message = objectOptions
+      ? (objectOptions.message ?? code)
+      : (messageOrOptions ?? code)
+    const cause = objectOptions
+      ? objectOptions.cause
+      : trailingOptions
+        ? trailingOptions.cause
+        : causeOrOptions
+    super(message, cause === undefined ? undefined : { cause })
+    Object.defineProperty(this, 'name', {
+      configurable: true,
+      value: 'NappupError',
+      writable: true
+    })
+    Object.defineProperty(this, 'code', {
+      configurable: false,
+      enumerable: true,
+      value: code,
+      writable: false
+    })
+    if (options?.details !== undefined) {
+      Object.defineProperty(this, 'details', {
+        configurable: false,
+        enumerable: true,
+        value: options.details,
+        writable: false
+      })
+    }
+  }
+}
+
+// Ensures every error crossing nappup's public API has a documented code.
+export function normalizeNappupError (error) {
+  if (typeof error?.code === 'string' && error.code.startsWith('NAPPUP_')) return error
+  if (error?.name === 'AbortError' || error?.code === 'ABORT_ERR') {
+    return new NappupError(
+      NAPPUP_ERROR_CODES.UPLOAD_CANCELLED,
+      error?.message || 'Upload cancelled',
+      { cause: error }
+    )
+  }
+  return new NappupError(
+    NAPPUP_ERROR_CODES.UPLOAD_FAILED,
+    error?.message || 'Upload failed',
+    { cause: error }
+  )
+}

package/src/helpers/app-metadata.js

@@ -1,4 +1,5 @@
 const IMAGE_EXTENSIONS = /\.(?:ico|svg|webp|png|jpe?g|gif|avif)(?:[?#].*)?$/i
+const CONVENTIONAL_ICON_BASENAME = /^(?:favicon(?:[-_.]\w+)*|apple-touch-icon(?:-precomposed|[-_.]\w+)*)\.(?:ico|svg|webp|png|jpe?g|gif|avif)$/i
 
 // Decodes the character references commonly used in metadata attributes.
 function decodeHtml (value) {
@@ -55,11 +56,11 @@ function scanTags (htmlContent, names) {
 }
 
 // Adds a unique icon source with a stable priority and document order.
-function addIconSource (sources, seen, href, kind, priority, index) {
+function addIconSource (sources, seen, href, kind, priority, index, { sizes, type } = {}) {
   const value = typeof href === 'string' ? href.trim() : ''
   if (!value || seen.has(value)) return
   seen.add(value)
-  sources.push({ href: value, kind, priority, index })
+  sources.push({ href: value, kind, priority, index, sizes, type })
 }
 
 function metadataMarkup (htmlContent) {
@@ -88,10 +89,11 @@ export function extractHtmlMetadata (htmlContent) {
       }
       if (tagName === 'link') {
         const rels = new Set((attributes.rel || '').toLowerCase().split(/\s+/).filter(Boolean))
-        if (rels.has('icon')) addIconSource(iconSources, seenIcons, attributes.href, 'icon', 10, index)
-        else if (rels.has('apple-touch-icon')) addIconSource(iconSources, seenIcons, attributes.href, 'apple-touch-icon', 20, index)
-        else if (rels.has('apple-touch-icon-precomposed')) addIconSource(iconSources, seenIcons, attributes.href, 'apple-touch-icon', 21, index)
-        else if (rels.has('mask-icon') || rels.has('fluid-icon')) addIconSource(iconSources, seenIcons, attributes.href, 'mask-icon', 30, index)
+        const iconAttributes = { sizes: attributes.sizes, type: attributes.type }
+        if (rels.has('icon')) addIconSource(iconSources, seenIcons, attributes.href, 'icon', 10, index, iconAttributes)
+        else if (rels.has('apple-touch-icon')) addIconSource(iconSources, seenIcons, attributes.href, 'apple-touch-icon', 20, index, iconAttributes)
+        else if (rels.has('apple-touch-icon-precomposed')) addIconSource(iconSources, seenIcons, attributes.href, 'apple-touch-icon', 21, index, iconAttributes)
+        else if (rels.has('mask-icon') || rels.has('fluid-icon')) addIconSource(iconSources, seenIcons, attributes.href, 'mask-icon', 30, index, iconAttributes)
         else if (rels.has('manifest')) addIconSource(iconSources, seenIcons, attributes.href, 'manifest', 40, index)
         else if (rels.has('image_src')) addIconSource(iconSources, seenIcons, attributes.href, 'social-image', 70, index)
         continue
@@ -127,7 +129,12 @@ export function extractHtmlMetadata (htmlContent) {
     name,
     description,
     baseHref,
-    iconSources: iconSources.map(({ href, kind }) => ({ href, kind }))
+    iconSources: iconSources.map(({ href, kind, sizes, type }) => ({
+      href,
+      kind,
+      ...(sizes ? { sizes } : {}),
+      ...(type ? { type } : {})
+    }))
   }
 }
 
@@ -139,6 +146,8 @@ export function extractWebManifestIcons (manifest) {
       .map((icon, index) => ({
         href: typeof icon?.src === 'string' ? icon.src.trim() : '',
         kind: 'web-app-manifest',
+        sizes: typeof icon?.sizes === 'string' ? icon.sizes : undefined,
+        type: typeof icon?.type === 'string' ? icon.type : undefined,
         purpose: typeof icon?.purpose === 'string' ? icon.purpose.toLowerCase().split(/\s+/) : ['any'],
         index
       }))
@@ -147,7 +156,12 @@ export function extractWebManifestIcons (manifest) {
         const rank = icon => icon.purpose.includes('any') ? 0 : icon.purpose.includes('maskable') ? 1 : 2
         return rank(left) - rank(right) || left.index - right.index
       })
-      .map(({ href, kind }) => ({ href, kind }))
+      .map(({ href, kind, sizes, type }) => ({
+        href,
+        kind,
+        ...(sizes ? { sizes } : {}),
+        ...(type ? { type } : {})
+      }))
   } catch (_) {
     return []
   }
@@ -174,10 +188,26 @@ function filePath (file) {
 
 // Finds a conventional favicon file in a bundle.
 export function findFavicon (fileList) {
-  return fileList.find(file => {
+  const candidates = fileList.filter(file => {
     const filename = filePath(file).split('/').pop().toLowerCase()
-    return filename.startsWith('favicon.') && IMAGE_EXTENSIONS.test(filename)
-  }) || null
+    return CONVENTIONAL_ICON_BASENAME.test(filename) && IMAGE_EXTENSIONS.test(filename)
+  })
+  return candidates.sort((left, right) => iconQuality({}, filePath(right)) - iconQuality({}, filePath(left)))[0] || null
+}
+
+function iconQuality (source, path) {
+  const sizes = typeof source?.sizes === 'string' ? source.sizes.toLowerCase() : ''
+  const dimensions = [...sizes.matchAll(/(\d{1,5})x(\d{1,5})/g)]
+    .map(match => Math.min(Number(match[1]), Number(match[2])))
+  if (dimensions.length) return Math.max(...dimensions)
+  if (/\bany\b/.test(sizes) || /\.svg(?:[?#]|$)/i.test(path) || source?.type === 'image/svg+xml') return 512
+  const filename = path.split('/').pop()
+  const inferred = [...filename.matchAll(/(?:^|[-_.])(\d{2,5})x(\d{2,5})(?=[-_.]|$)/gi)]
+    .map(match => Math.min(Number(match[1]), Number(match[2])))
+  if (inferred.length) return Math.max(...inferred)
+  if (/^apple-touch-icon/i.test(filename) || source?.kind === 'apple-touch-icon') return 180
+  if (/\.ico$/i.test(filename)) return 32
+  return 1
 }
 
 // Finds the best local icon referenced by HTML or its Web App Manifest.
@@ -186,21 +216,32 @@ export async function findAppIcon (fileList, htmlContent, indexFile, readFileTex
   const indexPath = filePath(indexFile) || 'index.html'
   const byPath = new Map(fileList.map(file => [filePath(file), file]))
   const findFromSources = async sources => {
+    const candidates = []
+    let order = 0
     for (const source of sources) {
       const path = resolveAppPath(source.href, indexPath, metadata.baseHref)
       const file = path && byPath.get(path)
       if (!file) continue
-      if (source.kind !== 'manifest') return file
+      if (source.kind !== 'manifest') {
+        candidates.push({ file, quality: iconQuality(source, path), order: order++ })
+        continue
+      }
 
       try {
         const manifestText = readFileText ? await readFileText(file) : await file.text()
         for (const icon of extractWebManifestIcons(manifestText)) {
           const iconPath = resolveAppPath(icon.href, path)
-          if (iconPath && byPath.has(iconPath)) return byPath.get(iconPath)
+          if (iconPath && byPath.has(iconPath)) {
+            candidates.push({
+              file: byPath.get(iconPath),
+              quality: iconQuality(icon, iconPath),
+              order: order++
+            })
+          }
         }
       } catch (_) {}
     }
-    return null
+    return candidates.sort((left, right) => right.quality - left.quality || left.order - right.order)[0]?.file || null
   }
 
   const specificSources = metadata.iconSources.filter(source => !['tile-image', 'social-image'].includes(source.kind))

package/src/helpers/app.js

@@ -5,5 +5,5 @@ export const GENERIC_BUILD_FOLDER_NAMES = new Set([
 ])
 
 export function isNostrAppDTagSafe (string) {
-  return typeof string === 'string' && string.length <= NOSTR_APP_D_TAG_MAX_LENGTH
+  return typeof string === 'string' && string.length > 0 && string.length <= NOSTR_APP_D_TAG_MAX_LENGTH
 }

package/src/index.js

@@ -8,6 +8,9 @@ import { extractHtmlMetadata, findAppIcon, findIndexFile } from '#helpers/app-me
 import { getBlossomServers, healthCheckServers, uploadFilesToBlossom } from '#services/blossom-upload.js'
 import { uploadBinaryDataChunks } from '#services/irfs-upload.js'
 import { uploadSiteManifest } from '#services/site-manifest.js'
+import { NappupError, NAPPUP_ERROR_CODES, normalizeNappupError } from '#errors.js'
+
+export { NappupError, NAPPUP_ERROR_CODES } from '#errors.js'
 
 // TL;DR
 // import publishApp from 'nappup'
@@ -26,21 +29,8 @@ import { uploadSiteManifest } from '#services/site-manifest.js'
 // }
 //
 export default async function (fileList, nostrSigner, opts = {}) {
-  const onEvent = typeof opts.onEvent === 'function' ? opts.onEvent : null
-  let lastProgress = 0
   try {
-    return await toApp(fileList, nostrSigner, onEvent
-      ? {
-          ...opts,
-          onEvent (event) {
-            lastProgress = event.progress ?? lastProgress
-            onEvent(event)
-          }
-        }
-      : opts)
-  } catch (err) {
-    if (onEvent) try { onEvent({ type: 'error', error: err, progress: lastProgress }) } catch (_) {}
-    throw err
+    return await toApp(fileList, nostrSigner, opts)
   } finally {
     await nostrRelays.disconnectAll()
   }
@@ -59,8 +49,34 @@ export default async function (fileList, nostrSigner, opts = {}) {
  *   'manifest-published' — unified site manifest and app metadata published
  *   'complete'           — { napp } (terminal, progress === 100)
  *   'error'              — { error } (terminal, error is rethrown)
+ *
+ * Every rejected error has a stable `NAPPUP_*` code and may retain its cause.
  */
-export async function toApp (fileList, nostrSigner, {
+export async function toApp (fileList, nostrSigner, opts = {}) {
+  const onEvent = typeof opts.onEvent === 'function' ? opts.onEvent : null
+  let lastProgress = 0
+  const publishOptions = onEvent
+    ? {
+        ...opts,
+        onEvent (event) {
+          lastProgress = event.progress ?? lastProgress
+          onEvent(event)
+        }
+      }
+    : opts
+  try {
+    return await publishApp(fileList, nostrSigner, publishOptions)
+  } catch (error) {
+    const normalized = normalizeNappupError(error)
+    if (onEvent) {
+      try { onEvent({ type: 'error', error: normalized, progress: lastProgress }) } catch (_) {}
+    }
+    throw normalized
+  }
+}
+
+// Implements publishing after the public boundary has installed error normalization.
+async function publishApp (fileList, nostrSigner, {
   log = () => {}, onEvent = () => {}, dTag, channel = 'main', shouldReupload = false
 } = {}) {
   let steps = 0
@@ -74,27 +90,66 @@ export async function toApp (fileList, nostrSigner, {
     } catch (_) {}
   }
   if (!nostrSigner && typeof window !== 'undefined') nostrSigner = window.nostr
-  if (!nostrSigner) throw new Error('No Nostr signer found')
+  if (!nostrSigner) {
+    throw new NappupError(NAPPUP_ERROR_CODES.NO_SIGNER, 'No Nostr signer found')
+  }
   if (typeof window !== 'undefined' && nostrSigner === window.nostr) nostrSigner.getRelays = getRelays
 
-  const writeRelays = [...new Set((await nostrSigner.getRelays()).write
-    .map(relay => relay.trim().replace(/\/$/, '')))]
-  log(`Found ${writeRelays.length} outbox relays:\n${writeRelays.join(', ')}`)
-  if (!writeRelays.length) throw new Error('No outbox relays found')
+  fileList = Array.from(fileList || [])
+  if (!fileList.length) {
+    throw new NappupError(NAPPUP_ERROR_CODES.EMPTY_FILE_LIST, 'No app files were provided')
+  }
 
-  if (typeof dTag === 'string') {
-    if (!isNostrAppDTagSafe(dTag)) throw new Error('dTag must be a non-empty string with at most 260 characters')
+  if (dTag !== undefined && dTag !== null) {
+    if (!isNostrAppDTagSafe(dTag)) {
+      throw new NappupError(
+        NAPPUP_ERROR_CODES.INVALID_D_TAG,
+        'dTag must be a non-empty string with at most 260 characters',
+        { details: { dTag } }
+      )
+    }
   } else {
-    const folderName = fileList[0].webkitRelativePath.split('/')[0].trim()
+    const relativePath = typeof fileList[0]?.webkitRelativePath === 'string'
+      ? fileList[0].webkitRelativePath
+      : ''
+    const folderName = relativePath.split('/')[0].trim()
     if (GENERIC_BUILD_FOLDER_NAMES.has(folderName.toLowerCase())) {
-      throw new Error(`Folder name "${folderName}" is a generic build folder. Please provide a d tag with the -d flag.`)
+      throw new NappupError(
+        NAPPUP_ERROR_CODES.GENERIC_FOLDER_NAME,
+        `Folder name "${folderName}" is a generic build folder. Please provide a d tag with the -d flag.`,
+        { details: { folderName } }
+      )
     }
     dTag = folderName
     if (!isNostrAppDTagSafe(dTag)) {
-      throw new Error('Could not derive a valid d tag from the folder name. Please provide one with the -d flag.')
+      throw new NappupError(
+        NAPPUP_ERROR_CODES.INVALID_FOLDER_NAME,
+        'Could not derive a valid d tag from the folder name. Please provide one with the -d flag.',
+        { details: { folderName } }
+      )
     }
   }
 
+  let signerRelays
+  try {
+    signerRelays = await nostrSigner.getRelays()
+  } catch (error) {
+    throw new NappupError(
+      NAPPUP_ERROR_CODES.RELAY_LOOKUP_FAILED,
+      'Could not read the signer outbox relays',
+      { cause: error }
+    )
+  }
+  const writeRelays = [...new Set((Array.isArray(signerRelays?.write) ? signerRelays.write : [])
+    .flatMap(relay => typeof relay === 'string' && relay.trim()
+      ? [relay.trim().replace(/\/$/, '')]
+      : []
+    ))]
+  log(`Found ${writeRelays.length} outbox relays:\n${writeRelays.join(', ')}`)
+  if (!writeRelays.length) {
+    throw new NappupError(NAPPUP_ERROR_CODES.NO_OUTBOX_RELAYS, 'No outbox relays found')
+  }
+
   const fileMetadata = []
   const nappJsonFile = fileList.find(file => file.webkitRelativePath.split('/').slice(1).join('/') === '.well-known/napp.json')
   let nappJson = {}
@@ -124,10 +179,16 @@ export async function toApp (fileList, nostrSigner, {
 
   const faviconFile = await findAppIcon(fileList, indexHtml, indexFile, file => streamToText(file.stream()))
   let iconMetadata
+  let isExplicitIcon = false
   let pause = 1000
 
   log('Checking for blossom servers...')
-  const blossomServerUrls = await getBlossomServers(nostrSigner, writeRelays)
+  let blossomServerUrls = []
+  try {
+    blossomServerUrls = await getBlossomServers(nostrSigner, writeRelays)
+  } catch (error) {
+    log('Could not read Blossom server preferences; using relay-based upload instead', error)
+  }
   let healthyBlossomServers = []
   if (blossomServerUrls.length) {
     log(`Found ${blossomServerUrls.length} blossom servers: ${blossomServerUrls.join(', ')}`)
@@ -182,6 +243,7 @@ export async function toApp (fileList, nostrSigner, {
     try {
       log('Uploading icon from napp.json')
       iconMetadata = await uploadMediaFromDataUrl(nappJson.icon[0][0], 'icon')
+      isExplicitIcon = Boolean(iconMetadata)
     } catch (error) {
       log('Failed to upload icon from napp.json', error)
     }
@@ -236,7 +298,18 @@ export async function toApp (fileList, nostrSigner, {
       shouldReupload,
       log
     })
-    if (failedFiles.length) throw new Error(`${failedFiles.length} file(s) failed to upload to blossom`)
+    if (failedFiles.length) {
+      throw new NappupError(
+        NAPPUP_ERROR_CODES.BLOSSOM_UPLOAD_FAILED,
+        `${failedFiles.length} file(s) failed to upload to Blossom`,
+        {
+          details: {
+            failedFileCount: failedFiles.length,
+            filenames: failedFiles.map(failed => failed.filename).filter(Boolean)
+          }
+        }
+      )
+    }
 
     for (const uploaded of uploadedFiles) {
       const metadata = {
@@ -246,73 +319,93 @@ export async function toApp (fileList, nostrSigner, {
         size: uploaded.size
       }
       fileMetadata.push(metadata)
-      if (faviconFile && uploaded.file === faviconFile) iconMetadata = { ...metadata }
+      if (!iconMetadata && faviconFile && uploaded.file === faviconFile) iconMetadata = { ...metadata }
       steps++
       emit({ type: 'file-uploaded', filename: uploaded.filename, service: 'blossom' })
     }
   } else {
     for (const file of fileList) {
-      const nmmr = new NMMR()
-      let chunkLength = 0
-      for await (const chunk of streamToChunks(file.stream(), 51000)) {
-        chunkLength++
-        await nmmr.append(chunk)
-      }
-      // Empty IRFS blobs deliberately have no chunks and no manifest reference.
-      if (!chunkLength) {
-        steps++
-        emit({ type: 'file-uploaded', filename: file.webkitRelativePath.split('/').slice(1).join('/'), service: 'irfs' })
-        continue
-      }
-
       const filename = file.webkitRelativePath.split('/').slice(1).join('/')
-      log(`Uploading ${chunkLength} file parts of ${filename}`)
-      ;({ pause } = await uploadBinaryDataChunks({
-        nmmr, signer: nostrSigner, filename, chunkLength, log, pause, shouldReupload
-      }))
-      const metadata = {
-        rootHash: nmmr.getRoot(),
-        filename,
-        mimeType: file.type || 'application/octet-stream',
-        size: file.size
+      try {
+        const nmmr = new NMMR()
+        let chunkLength = 0
+        for await (const chunk of streamToChunks(file.stream(), 51000)) {
+          chunkLength++
+          await nmmr.append(chunk)
+        }
+        // Empty IRFS blobs deliberately have no chunks and no manifest reference.
+        if (!chunkLength) {
+          steps++
+          emit({ type: 'file-uploaded', filename, service: 'irfs' })
+          continue
+        }
+
+        log(`Uploading ${chunkLength} file parts of ${filename}`)
+        ;({ pause } = await uploadBinaryDataChunks({
+          nmmr, signer: nostrSigner, filename, chunkLength, log, pause, shouldReupload
+        }))
+        const metadata = {
+          rootHash: nmmr.getRoot(),
+          filename,
+          mimeType: file.type || 'application/octet-stream',
+          size: file.size
+        }
+        fileMetadata.push(metadata)
+        if (!iconMetadata && faviconFile && file === faviconFile) iconMetadata = { ...metadata }
+        steps++
+        emit({ type: 'file-uploaded', filename, service: 'irfs' })
+      } catch (error) {
+        throw new NappupError(
+          NAPPUP_ERROR_CODES.IRFS_UPLOAD_FAILED,
+          `Failed to upload "${filename}" to Nostr relays`,
+          { cause: error, details: { filename } }
+        )
       }
-      fileMetadata.push(metadata)
-      if (faviconFile && file === faviconFile) iconMetadata = { ...metadata }
-      steps++
-      emit({ type: 'file-uploaded', filename, service: 'irfs' })
     }
   }
 
   log(`Uploading unified site manifest ${dTag}`)
-  const manifest = await uploadSiteManifest({
-    dTag,
-    channel,
-    fileMetadata,
-    name: manifestName,
-    nameLang: nappJson.name?.[0]?.[1],
-    isNameAuto: !nappJson.name?.[0]?.[0],
-    summary: manifestSummary,
-    summaryLang: nappJson.summary?.[0]?.[1],
-    isSummaryAuto: !nappJson.summary?.[0]?.[0],
-    icon: iconMetadata,
-    isIconAuto: !nappJson.icon?.[0]?.[0],
-    descriptions: nappJson.description,
-    keyArt: keyArtMetadata,
-    screenshots: screenshotMetadata,
-    uploadService,
-    signer: nostrSigner,
-    log,
-    pause,
-    shouldReupload,
-    self: nappJson.self?.[0]?.[0],
-    countries: nappJson.country,
-    categories: nappJson.category,
-    hashtags: nappJson.hashtag
-  })
+  let manifest
+  try {
+    manifest = await uploadSiteManifest({
+      dTag,
+      channel,
+      fileMetadata,
+      name: manifestName,
+      nameLang: nappJson.name?.[0]?.[1],
+      isNameAuto: !nappJson.name?.[0]?.[0],
+      summary: manifestSummary,
+      summaryLang: nappJson.summary?.[0]?.[1],
+      isSummaryAuto: !nappJson.summary?.[0]?.[0],
+      icon: iconMetadata,
+      isIconAuto: !isExplicitIcon,
+      descriptions: nappJson.description,
+      keyArt: keyArtMetadata,
+      screenshots: screenshotMetadata,
+      uploadService,
+      sourceRelays: writeRelays,
+      blossomServers: healthyBlossomServers,
+      signer: nostrSigner,
+      log,
+      pause,
+      shouldReupload,
+      self: nappJson.self?.[0]?.[0],
+      countries: nappJson.country,
+      categories: nappJson.category,
+      hashtags: nappJson.hashtag
+    })
+  } catch (error) {
+    throw new NappupError(
+      NAPPUP_ERROR_CODES.MANIFEST_UPLOAD_FAILED,
+      'Failed to publish the app manifest to Nostr relays',
+      { cause: error }
+    )
+  }
 
   const appEntity = appEncode({
     dTag: manifest.tags.find(tag => tag[0] === 'd')[1],
     pubkey: manifest.pubkey,
+    // Keep empty array to generate the shorter app entity.
     relays: [],
     kind: manifest.kind
   })

package/src/services/blossom-upload.js

@@ -1,11 +1,7 @@
 import { sha256 } from '@noble/hashes/sha2.js'
 import nostrRelays from '#services/nostr-relays.js'
 import { bytesToBase16 } from '#helpers/base16.js'
-
-function normalizeServerUrl (url) {
-  if (!url.startsWith('http')) url = 'https://' + url
-  return url.replace(/\/$/, '') + '/'
-}
+import { normalizeBlossomServerUrl } from 'libp2r2p/url'
 
 async function createAuthHeader (signer, modify) {
   const now = Math.floor(Date.now() / 1000)
@@ -37,10 +33,11 @@ export async function getBlossomServers (signer, writeRelays) {
   events.sort((a, b) => b.created_at - a.created_at)
   const best = events[0]
 
-  return (best.tags ?? [])
-    .filter(t => Array.isArray(t) && t[0] === 'server' && /^https?:\/\//.test(t[1]))
-    .map(t => t[1].trim().replace(/\/$/, ''))
-    .filter(Boolean)
+  return [...new Set((best.tags ?? [])
+    .filter(t => Array.isArray(t) && t[0] === 'server')
+    .flatMap(tag => {
+      try { return [normalizeBlossomServerUrl(tag[1])] } catch (_) { return [] }
+    }))]
 }
 
 /**
@@ -51,8 +48,9 @@ export async function getBlossomServers (signer, writeRelays) {
 export async function healthCheckServers (servers, signer, { log = () => {} } = {}) {
   const results = await Promise.allSettled(
     servers.map(async (serverUrl) => {
-      await fetch(normalizeServerUrl(serverUrl), { method: 'HEAD' })
-      return serverUrl
+      const normalized = normalizeBlossomServerUrl(serverUrl)
+      await fetch(normalized, { method: 'HEAD' })
+      return normalized
     })
   )
 
@@ -88,7 +86,7 @@ export async function computeFileHash (file) {
 async function uploadFileToServer (serverUrl, signer, file, fileHash, mimeType, { shouldReupload, log, maxRetries = 5 }) {
   // Check if already uploaded
   if (!shouldReupload) {
-    const checkResponse = await fetch(serverUrl + fileHash, { method: 'HEAD' })
+    const checkResponse = await fetch(`${serverUrl}/${fileHash}`, { method: 'HEAD' })
     if (checkResponse.ok) {
       return { success: true, alreadyExists: true }
     }
@@ -106,7 +104,7 @@ async function uploadFileToServer (serverUrl, signer, file, fileHash, mimeType,
         evt.tags.push(['t', 'upload'])
         evt.tags.push(['x', fileHash])
       })
-      const response = await fetch(serverUrl + 'upload', {
+      const response = await fetch(`${serverUrl}/upload`, {
         method: 'PUT',
         headers: { 'Content-Type': mimeType, Authorization: authorization },
         body: file.stream(),
@@ -145,7 +143,12 @@ export async function uploadFilesToBlossom ({
   maxRetries = 5,
   log = () => {}
 }) {
-  if (servers.length === 0) return { uploadedFiles: [], failedFiles: [...fileList.map(f => ({ file: f }))] }
+  const normalizedServers = [...new Set(servers.flatMap(server => {
+    try { return [normalizeBlossomServerUrl(server)] } catch (_) { return [] }
+  }))]
+  if (normalizedServers.length === 0) {
+    return { uploadedFiles: [], failedFiles: [...fileList.map(f => ({ file: f }))] }
+  }
 
   // Pre-compute file info
   const fileInfos = await Promise.all(
@@ -161,24 +164,22 @@ export async function uploadFilesToBlossom ({
   const fileServerResults = fileInfos.map(() => ({ successCount: 0, errors: [] }))
 
   // Upload to each server in parallel, but within a server, upload files sequentially
-  const serverTasks = servers.map(async (server) => {
-    const serverUrl = normalizeServerUrl(server)
-
+  const serverTasks = normalizedServers.map(async (serverUrl) => {
     for (let i = 0; i < fileInfos.length; i++) {
       const info = fileInfos[i]
-      log(`Uploading ${info.filename} to ${server}`)
+      log(`Uploading ${info.filename} to ${serverUrl}`)
       const result = await uploadFileToServer(serverUrl, signer, info.file, info.sha256, info.mimeType, { shouldReupload, log, maxRetries })
 
       if (result.success) {
         fileServerResults[i].successCount++
         if (result.alreadyExists) {
-          log(`${info.filename}: Already exists on ${server}`)
+          log(`${info.filename}: Already exists on ${serverUrl}`)
         } else {
-          log(`${info.filename}: Uploaded to ${server}`)
+          log(`${info.filename}: Uploaded to ${serverUrl}`)
         }
       } else {
-        fileServerResults[i].errors.push({ server, error: result.error })
-        log(`${info.filename}: Failed to upload to ${server}: ${result.error?.message ?? result.error}`)
+        fileServerResults[i].errors.push({ server: serverUrl, error: result.error })
+        log(`${info.filename}: Failed to upload to ${serverUrl}: ${result.error?.message ?? result.error}`)
       }
     }
   })

package/src/services/site-manifest.js

@@ -3,10 +3,12 @@ import nostrRelays, { nappRelays } from '#services/nostr-relays.js'
 import { throttledSendEvent } from '#services/irfs-upload.js'
 import { sha256 } from '@noble/hashes/sha2.js'
 import { bytesToBase16 } from '#helpers/base16.js'
+import { normalizeBlossomServerUrl, normalizeRelayUrl } from 'libp2r2p/url'
 
 const MANAGED_MANIFEST_TAGS = new Set([
   'd', 'service', 'path', 'r', 'name', 'summary', 'description', 'self',
-  'c', 'l', 't', 'auto', 'icon', 'key_art', 'screenshot', 'x', 'published_at'
+  'c', 'l', 't', 'auto', 'icon', 'key_art', 'screenshot', 'relay', 'server',
+  'x', 'published_at'
 ])
 
 export function normalizeManifestPath (value) {
@@ -169,9 +171,29 @@ function buildMetadataTags ({
   return tags
 }
 
+function normalizeServiceUrls (values, normalizer) {
+  const urls = []
+  for (const value of Array.isArray(values) ? values : []) {
+    try {
+      const normalized = normalizer(value)
+      if (!urls.includes(normalized)) urls.push(normalized)
+    } catch (_) {}
+  }
+  return urls
+}
+
+function buildSourceHintTags (sourceRelays, blossomServers) {
+  return [
+    ...normalizeServiceUrls(sourceRelays, normalizeRelayUrl)
+      .map(relay => ['relay', relay]),
+    ...normalizeServiceUrls(blossomServers, normalizeBlossomServerUrl)
+      .map(server => ['server', server])
+  ]
+}
+
 export function buildManifestTags ({
   dTag, uploadService, fileMetadata = [], icon, keyArt = [], screenshots = [],
-  previousTags = [], publishedAt, ...metadata
+  previousTags = [], publishedAt, sourceRelays = [], blossomServers = [], ...metadata
 }) {
   if (uploadService !== 'irfs' && uploadService !== 'blossom') {
     throw new Error('Unknown upload service')
@@ -199,6 +221,7 @@ export function buildManifestTags ({
     ['d', dTag],
     ...referenceTags,
     ['service', uploadService],
+    ...buildSourceHintTags(sourceRelays, blossomServers),
     ['x', aggregateHash, 'aggregate'],
     ['published_at', String(publishedAt)],
     ...buildMetadataTags({ ...metadata, hasIcon: Boolean(icon) }),