nappup 1.7.2 → 1.8.0

package/bin/nappup/helpers.js

@@ -9,7 +9,6 @@ export function parseArgs (args) {
   let dir = null
   let sk = null
   let dTag = null
-  let dTagRaw = null
   let channel = null
   let shouldReupload = false
   let yes = false
@@ -21,9 +20,6 @@ export function parseArgs (args) {
     } else if (args[i] === '-d' && args[i + 1]) {
       dTag = args[i + 1]
       i++
-    } else if (args[i] === '-D' && args[i + 1]) {
-      dTagRaw = args[i + 1]
-      i++
     } else if (args[i] === '--main' && channel === null) {
       channel = 'main'
     } else if (args[i] === '--next' && channel === null) {
@@ -43,7 +39,6 @@ export function parseArgs (args) {
     dir: path.resolve(dir ?? '.'),
     sk,
     dTag,
-    dTagRaw,
     channel: channel || 'main',
     shouldReupload,
     yes

package/bin/nappup/index.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
+import path from 'node:path'
 import NostrSigner from '#services/nostr-signer.js'
+import { GENERIC_BUILD_FOLDER_NAMES } from '#helpers/app.js'
 import {
   parseArgs,
   confirmArgs,
@@ -11,7 +13,23 @@ import toApp from '#index.js'
 const args = parseArgs(process.argv.slice(2))
 await confirmArgs(args)
 
-const { dir, sk, dTag, dTagRaw, channel, shouldReupload } = args
+const { dir, sk, channel, shouldReupload } = args
+let { dTag } = args
+
+if (!dTag) {
+  let folderName = path.basename(dir)
+  if (GENERIC_BUILD_FOLDER_NAMES.has(folderName.toLowerCase())) {
+    const parentName = path.basename(path.dirname(dir))
+    if (parentName && parentName !== '.' && parentName !== '/' && !GENERIC_BUILD_FOLDER_NAMES.has(parentName.toLowerCase())) {
+      folderName = parentName
+    } else {
+      console.error(`Directory name "${folderName}" is a generic build folder. Please provide a d tag with -d.`)
+      process.exit(1)
+    }
+  }
+  dTag = folderName
+}
+
 const fileList = await toFileList(getFiles(dir), dir)
 
-await toApp(fileList, await NostrSigner.create(sk), { log: console.log.bind(console), dTag, dTagRaw, channel, shouldReupload })
+await toApp(fileList, await NostrSigner.create(sk), { log: console.log.bind(console), dTag, channel, shouldReupload })

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "MIT",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {

package/src/helpers/app.js

@@ -1,41 +1,9 @@
-import { bytesToBase36, isBase36 } from '#helpers/base36.js'
+export const NOSTR_APP_D_TAG_MAX_LENGTH = 260
 
-// 63 - (1<channel> + 5<b36loggeduserpkslug> 50<b36pk>)
-// <b36loggeduserpkslug> pk chars at positions [7][17][27][37][47]
-// to avoid vanity or pow colisions
-export const NOSTR_APP_D_TAG_MAX_LENGTH = 7
+export const GENERIC_BUILD_FOLDER_NAMES = new Set([
+  'build', 'dist', 'out', 'output', 'public', 'www', '_site', '.next', '.output', '.nuxt'
+])
 
 export function isNostrAppDTagSafe (string) {
-  return string.length > 0 && string.length <= NOSTR_APP_D_TAG_MAX_LENGTH && isBase36(string)
-}
-
-export function isSubdomainSafe (string) {
-  return /(?:^[a-z0-9]$)|(?:^(?!.*--)[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$)/.test(string)
-}
-
-export function deriveNostrAppDTag (string) {
-  return toSubdomainSafe(string, NOSTR_APP_D_TAG_MAX_LENGTH)
-}
-
-async function toSubdomainSafe (string, maxStringLength) {
-  const byteLength = baseMaxLengthToMaxSourceByteLength(maxStringLength, 36)
-  const bytes = (await toSha1(string)).slice(0, byteLength)
-  return bytesToBase36(bytes, maxStringLength)
-}
-
-async function toSha1 (string) {
-  const bytes = new TextEncoder().encode(string)
-  return new Uint8Array(await crypto.subtle.digest('SHA-1', bytes))
-}
-
-// baseMaxLengthToMaxSourceByteLength(19, 62) === 14 byte length
-// baseMaxLengthToMaxSourceByteLength(7, 36) === 4 byte length
-function baseMaxLengthToMaxSourceByteLength (maxStringLength, base) {
-  if (!base) throw new Error('Which base?')
-  const baseLog = Math.log(base)
-  const log256 = Math.log(256)
-
-  const maxByteLength = (maxStringLength * baseLog) / log256
-
-  return Math.floor(maxByteLength)
+  return typeof string === 'string' && string.length <= NOSTR_APP_D_TAG_MAX_LENGTH
 }

package/src/helpers/nip19.js

@@ -9,9 +9,9 @@ const textEncoder = new TextEncoder()
 const textDecoder = new TextDecoder()
 
 const kindByChannel = {
-  main: 37448,
-  next: 37449,
-  draft: 37450
+  main: 35128,
+  next: 35129,
+  draft: 35130
 }
 const channelByKind = Object.fromEntries(
   Object.entries(kindByChannel).map(([k, v]) => [v, k])

package/src/index.js

@@ -3,7 +3,7 @@ import { appEncode } from '#helpers/nip19.js'
 import nostrRelays, { nappRelays } from '#services/nostr-relays.js'
 import { getRelays } from '#helpers/signer.js'
 import { streamToChunks, streamToText } from '#helpers/stream.js'
-import { isNostrAppDTagSafe, deriveNostrAppDTag } from '#helpers/app.js'
+import { isNostrAppDTagSafe, GENERIC_BUILD_FOLDER_NAMES } from '#helpers/app.js'
 import { extractHtmlMetadata, findFavicon, findIndexFile } from '#helpers/app-metadata.js'
 import { NAPP_CATEGORIES } from '#config/napp-categories.js'
 import { getBlossomServers, healthCheckServers, uploadFilesToBlossom } from '#services/blossom-upload.js'
@@ -14,14 +14,14 @@ import { uploadBinaryDataChunks, throttledSendEvent } from '#services/irfs-uploa
 // await publishApp(
 //   fileList,
 //   window.nostr,
-//   { dTagRaw: 'My app identifier unique to this nsec', onEvent: ({ progress }) => console.log(progress) }
+//   { dTag: 'My app identifier unique to this nsec', onEvent: ({ progress }) => console.log(progress) }
 // )
 //
 // Simple usage -> onEvent: ({ progress, error }) => { if (error) { throw error } else { progressBar.style.width = `${progress}%` } }
 // Geek usage ->
 // onEvent: (event) => {
 //   if (event.type === 'file-uploaded') console.log(`Uploaded ${event.filename} via ${event.service}`)
-//   if (event.type === 'complete') console.log(`Done! Access at https://44billion.net/${event.naddr}`)
+//   if (event.type === 'complete') console.log(`Done! Access at https://44billion.net/${event.napp}`)
 //   if (event.type === 'error') console.error('Error during publishing:', event.error)
 // }
 //
@@ -47,25 +47,25 @@ export default async function (fileList, nostrSigner, opts = {}) {
 }
 
 /**
- * Publishes an app to Nostr relays and/or blossom servers.
+ * Publishes a site to Nostr relays and/or blossom servers.
  *
  * The optional `onEvent` callback receives structured progress events.
  * Every event has `type` (string) and `progress` (0–100 integer).
  *
  * Event types:
- *   'init'             — { totalFiles, totalSteps, dTag, relayCount, blossomCount }
- *   'icon-uploaded'    — { service: 'blossom'|'irfs'|null }
- *   'file-uploaded'    — { filename, service: 'blossom'|'irfs' }
- *   'stall-published'  — listing metadata published
- *   'bundle-published' — app bundle published
- *   'complete'         — { napp } (terminal, progress === 100)
- *   'error'            — { error } (terminal, error is rethrown)
+ *   'init'               — { totalFiles, totalSteps, dTag, relayCount, blossomCount }
+ *   'media-uploaded'     — { mediaType: 'icon'|'key_art'|'screenshot', service: 'blossom'|'irfs'|null }
+ *   'file-uploaded'      — { filename, service: 'blossom'|'irfs' }
+ *   'listing-published'  — app listing metadata published
+ *   'manifest-published' — site manifest published
+ *   'complete'           — { napp } (terminal, progress === 100)
+ *   'error'              — { error } (terminal, error is rethrown)
  *
  * Terminal events ('complete' or 'error') signal that no more events will follow.
  * The 'error' event is only emitted when using the default export wrapper.
  * Direct `toApp` callers receive the thrown error via normal async/await.
  */
-export async function toApp (fileList, nostrSigner, { log = () => {}, onEvent = () => {}, dTag, dTagRaw, channel = 'main', shouldReupload = false } = {}) {
+export async function toApp (fileList, nostrSigner, { log = () => {}, onEvent = () => {}, dTag, channel = 'main', shouldReupload = false } = {}) {
   let _steps = 0
   let _totalSteps = 1
   const emit = (event) => { try { onEvent({ ...event, progress: event.type === 'complete' ? 100 : Math.round((_steps / _totalSteps) * 100) }) } catch (_) {} }
@@ -79,12 +79,15 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, onEvent =
   if (writeRelays.length === 0) throw new Error('No outbox relays found')
 
   if (typeof dTag === 'string') {
-    if (!isNostrAppDTagSafe(dTag)) throw new Error('dTag should be [A-Za-z0-9] with length ranging from 1 to 19')
+    if (!isNostrAppDTagSafe(dTag)) throw new Error('dTag must be a non-empty string with at most 260 characters')
   } else {
-    dTag = dTagRaw || fileList[0].webkitRelativePath.split('/')[0].trim()
-    if (!isNostrAppDTagSafe(dTag)) dTag = await deriveNostrAppDTag(dTag || Math.random().toString(36))
+    const folderName = fileList[0].webkitRelativePath.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.`)
+    }
+    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.')
   }
-  let nmmr
   const fileMetadata = []
 
   // Check for .well-known/napp.json
@@ -101,15 +104,15 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, onEvent =
   }
 
   const indexFile = findIndexFile(fileList)
-  let stallName = nappJson.stallName?.[0]?.[0]
-  let stallSummary = nappJson.stallSummary?.[0]?.[0]
+  let listingName = nappJson.name?.[0]?.[0]
+  let listingSummary = nappJson.summary?.[0]?.[0]
 
-  if (indexFile && (!stallName || !stallSummary)) {
+  if (indexFile && (!listingName || !listingSummary)) {
     try {
       const htmlContent = await streamToText(indexFile.stream())
       const { name, description } = extractHtmlMetadata(htmlContent)
-      if (!stallName) stallName = name
-      if (!stallSummary) stallSummary = description
+      if (!listingName) listingName = name
+      if (!listingSummary) listingSummary = description
     } catch (err) {
       log('Error extracting HTML metadata:', err)
     }
@@ -131,77 +134,97 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, onEvent =
     log('No blossom servers configured, will use relay-based file upload (irfs)')
   }
 
-  const useBlossom = healthyBlossomServers.length > 0
+  const uploadService = healthyBlossomServers.length > 0 ? 'blossom' : 'irfs'
+
+  // Helper: upload a data URL to the chosen service, returns { rootHash, mimeType }
+  const uploadMediaFromDataUrl = async (dataUrl, mediaName) => {
+    const res = await fetch(dataUrl)
+    const blob = await res.blob()
+    const mimeType = blob.type
+    const extension = mimeType.split('/')[1] || 'bin'
+    const filename = `${mediaName}.${extension}`
+
+    if (uploadService === 'blossom') {
+      const { uploadedFiles, failedFiles } = await uploadFilesToBlossom({
+        fileList: [Object.assign(blob, { webkitRelativePath: `_/${filename}` })],
+        servers: healthyBlossomServers,
+        signer: nostrSigner,
+        shouldReupload,
+        log
+      })
+      if (failedFiles.length > 0) throw new Error(`Blossom upload failed for ${mediaName}`)
+      return { rootHash: uploadedFiles[0].sha256, mimeType }
+    }
+
+    const nmmr = new NMMR()
+    const stream = blob.stream()
+    let chunkLength = 0
+    for await (const chunk of streamToChunks(stream, 51000)) {
+      chunkLength++
+      await nmmr.append(chunk)
+    }
+    if (!chunkLength) return null
+    ;({ pause } = (await uploadBinaryDataChunks({ nmmr, signer: nostrSigner, filename, chunkLength, log, pause, mimeType, shouldReupload })))
+    return { rootHash: nmmr.getRoot(), mimeType }
+  }
 
-  const hasIconUpload = Boolean(nappJson.stallIcon?.[0]?.[0])
-  _totalSteps = fileList.length + (hasIconUpload ? 1 : 0) + 2
+  // Count media uploads for progress tracking
+  const hasIconUpload = Boolean(nappJson.icon?.[0]?.[0])
+  const keyArtEntries = nappJson.keyArt || []
+  const screenshotEntries = nappJson.screenshot || []
+  const mediaUploadCount = (hasIconUpload ? 1 : 0) + keyArtEntries.length + screenshotEntries.length
+  _totalSteps = fileList.length + mediaUploadCount + 2
   emit({ type: 'init', totalFiles: fileList.length, totalSteps: _totalSteps, dTag, relayCount: writeRelays.length, blossomCount: healthyBlossomServers.length })
 
   // Upload icon from napp.json if present
-  if (nappJson.stallIcon?.[0]?.[0]) {
+  if (nappJson.icon?.[0]?.[0]) {
     try {
-      const dataUrl = nappJson.stallIcon[0][0]
-      const res = await fetch(dataUrl)
-      const blob = await res.blob()
-      const mimeType = blob.type
-      const extension = mimeType.split('/')[1] || 'bin'
-      const filename = `icon.${extension}`
-
       log('Uploading icon from napp.json')
-
-      if (useBlossom) {
-        const { uploadedFiles, failedFiles } = await uploadFilesToBlossom({
-          fileList: [Object.assign(blob, { webkitRelativePath: `_/${filename}` })],
-          servers: healthyBlossomServers,
-          signer: nostrSigner,
-          shouldReupload,
-          log
-        })
-        if (uploadedFiles.length > 0) {
-          iconMetadata = {
-            rootHash: uploadedFiles[0].sha256,
-            mimeType,
-            service: 'b' // blossom
-          }
-        } else if (failedFiles.length > 0) {
-          log('Blossom icon upload failed, falling back to relay upload')
-        }
-      }
-
-      if (!iconMetadata) {
-        nmmr = new NMMR()
-        const stream = blob.stream()
-        let chunkLength = 0
-        for await (const chunk of streamToChunks(stream, 51000)) {
-          chunkLength++
-          await nmmr.append(chunk)
-        }
-
-        if (chunkLength) {
-          ;({ pause } = (await uploadBinaryDataChunks({ nmmr, signer: nostrSigner, filename, chunkLength, log, pause, mimeType, shouldReupload })))
-          iconMetadata = {
-            rootHash: nmmr.getRoot(),
-            mimeType,
-            service: 'i' // relay (irfs)
-          }
-        }
-      }
+      iconMetadata = await uploadMediaFromDataUrl(nappJson.icon[0][0], 'icon')
     } catch (e) {
       log('Failed to upload icon from napp.json', e)
     }
+    _steps++
+    emit({ type: 'media-uploaded', mediaType: 'icon', service: iconMetadata ? uploadService : null })
   }
 
-  if (hasIconUpload) {
+  // Upload key art from napp.json
+  const keyArtMetadata = []
+  for (const entry of keyArtEntries) {
+    const dataUrl = entry[0]
+    const country = entry[1]
+    if (!dataUrl) { _steps++; emit({ type: 'media-uploaded', mediaType: 'key_art', service: null }); continue }
+    try {
+      log(`Uploading key art from napp.json${country ? ` (${country})` : ''}`)
+      const uploaded = await uploadMediaFromDataUrl(dataUrl, 'key_art')
+      if (uploaded) keyArtMetadata.push({ ...uploaded, country })
+    } catch (e) {
+      log('Failed to upload key art from napp.json', e)
+    }
     _steps++
-    emit({ type: 'icon-uploaded', service: iconMetadata?.service === 'b' ? 'blossom' : iconMetadata ? 'irfs' : null })
+    emit({ type: 'media-uploaded', mediaType: 'key_art', service: keyArtMetadata.length > 0 ? uploadService : null })
   }
 
-  log(`Processing ${fileList.length} files`)
+  // Upload screenshots from napp.json
+  const screenshotMetadata = []
+  for (const entry of screenshotEntries) {
+    const dataUrl = entry[0]
+    const country = entry[1]
+    if (!dataUrl) { _steps++; emit({ type: 'media-uploaded', mediaType: 'screenshot', service: null }); continue }
+    try {
+      log(`Uploading screenshot from napp.json${country ? ` (${country})` : ''}`)
+      const uploaded = await uploadMediaFromDataUrl(dataUrl, 'screenshot')
+      if (uploaded) screenshotMetadata.push({ ...uploaded, country })
+    } catch (e) {
+      log('Failed to upload screenshot from napp.json', e)
+    }
+    _steps++
+    emit({ type: 'media-uploaded', mediaType: 'screenshot', service: screenshotMetadata.length > 0 ? uploadService : null })
+  }
 
-  // Files to upload via relay (irfs) — either all files or blossom failures
-  let irfsFileList = fileList
+  log(`Processing ${fileList.length} files`)
 
-  if (useBlossom) {
+  if (uploadService === 'blossom') {
     const { uploadedFiles, failedFiles } = await uploadFilesToBlossom({
       fileList,
       servers: healthyBlossomServers,
@@ -210,80 +233,77 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, onEvent =
       log
     })
 
+    if (failedFiles.length > 0) {
+      throw new Error(`${failedFiles.length} file(s) failed to upload to blossom`)
+    }
+
     for (const uploaded of uploadedFiles) {
       fileMetadata.push({
         rootHash: uploaded.sha256,
         filename: uploaded.filename,
-        mimeType: uploaded.mimeType,
-        service: 'b'
+        mimeType: uploaded.mimeType
       })
 
       if (faviconFile && uploaded.file === faviconFile) {
         iconMetadata = {
           rootHash: uploaded.sha256,
-          mimeType: uploaded.mimeType,
-          service: 'b'
+          mimeType: uploaded.mimeType
         }
       }
 
       _steps++
       emit({ type: 'file-uploaded', filename: uploaded.filename, service: 'blossom' })
     }
-
-    if (failedFiles.length > 0) {
-      log(`${failedFiles.length} files failed blossom upload, falling back to relay upload (irfs)`)
-      irfsFileList = failedFiles.map(f => f.file)
-    } else {
-      irfsFileList = []
-    }
-  }
-
-  for (const file of irfsFileList) {
-    nmmr = new NMMR()
-    const stream = file.stream()
-
-    let chunkLength = 0
-    for await (const chunk of streamToChunks(stream, 51000)) {
-      chunkLength++
-      await nmmr.append(chunk)
-    }
-    if (chunkLength) {
-      // remove root dir
-      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, mimeType: file.type || 'application/octet-stream', shouldReupload })))
-      fileMetadata.push({
-        rootHash: nmmr.getRoot(),
-        filename,
-        mimeType: file.type || 'application/octet-stream',
-        service: 'i'
-      })
-
-      if (faviconFile && file === faviconFile) {
-        iconMetadata = {
+  } else {
+    for (const file of fileList) {
+      const nmmr = new NMMR()
+      const stream = file.stream()
+
+      let chunkLength = 0
+      for await (const chunk of streamToChunks(stream, 51000)) {
+        chunkLength++
+        await nmmr.append(chunk)
+      }
+      if (chunkLength) {
+        // remove root dir
+        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, mimeType: file.type || 'application/octet-stream', shouldReupload })))
+        fileMetadata.push({
           rootHash: nmmr.getRoot(),
-          mimeType: file.type || 'application/octet-stream',
-          service: 'i'
+          filename,
+          mimeType: file.type || 'application/octet-stream'
+        })
+
+        if (faviconFile && file === faviconFile) {
+          iconMetadata = {
+            rootHash: nmmr.getRoot(),
+            mimeType: file.type || 'application/octet-stream'
+          }
         }
-      }
 
-      _steps++
-      emit({ type: 'file-uploaded', filename, service: 'irfs' })
+        _steps++
+        emit({ type: 'file-uploaded', filename, service: 'irfs' })
+      }
     }
   }
 
-  log(`Uploading stall event for ${dTag}`)
-  ;({ pause } = (await maybeUploadStall({
+  log(`Uploading app listing event for ${dTag}`)
+  ;({ pause } = (await maybeUploadAppListing({
     dTag,
     channel,
-    name: stallName,
-    nameLang: nappJson.stallName?.[0]?.[1],
-    isNameAuto: !nappJson.stallName?.[0]?.[0],
-    summary: stallSummary,
-    summaryLang: nappJson.stallSummary?.[0]?.[1],
-    isSummaryAuto: !nappJson.stallSummary?.[0]?.[0],
+    name: listingName,
+    nameLang: nappJson.name?.[0]?.[1],
+    isNameAuto: !nappJson.name?.[0]?.[0],
+    summary: listingSummary,
+    summaryLang: nappJson.summary?.[0]?.[1],
+    isSummaryAuto: !nappJson.summary?.[0]?.[0],
     icon: iconMetadata,
-    isIconAuto: !nappJson.stallIcon?.[0]?.[0],
+    isIconAuto: !nappJson.icon?.[0]?.[0],
+    descriptions: nappJson.description,
+    keyArt: keyArtMetadata,
+    screenshots: screenshotMetadata,
+    uploadService,
     signer: nostrSigner,
     writeRelays,
     log,
@@ -295,35 +315,36 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, onEvent =
     hashtags: nappJson.hashtag
   })))
   _steps++
-  emit({ type: 'stall-published' })
+  emit({ type: 'listing-published' })
 
-  log(`Uploading bundle ${dTag}`)
-  const bundle = await uploadBundle({ dTag, channel, fileMetadata, signer: nostrSigner, pause, shouldReupload, log })
+  log(`Uploading site manifest ${dTag}`)
+  const manifest = await uploadSiteManifest({ dTag, channel, fileMetadata, uploadService, signer: nostrSigner, pause, shouldReupload, log })
 
   const appEntity = appEncode({
-    dTag: bundle.tags.find(v => v[0] === 'd')[1],
-    pubkey: bundle.pubkey,
+    dTag: manifest.tags.find(v => v[0] === 'd')[1],
+    pubkey: manifest.pubkey,
     relays: [],
-    kind: bundle.kind
+    kind: manifest.kind
   })
   _steps++
-  emit({ type: 'bundle-published' })
+  emit({ type: 'manifest-published' })
 
   log(`Visit at https://44billion.net/${appEntity}`)
   emit({ type: 'complete', napp: appEntity })
 }
 
-async function uploadBundle ({ dTag, channel, fileMetadata, signer, pause = 0, shouldReupload = false, log = () => {} }) {
+async function uploadSiteManifest ({ dTag, channel, fileMetadata, uploadService, signer, pause = 0, shouldReupload = false, log = () => {} }) {
   const kind = {
-    main: 37448, // stable
-    next: 37449, // insider
-    draft: 37450 // vibe coded preview
-  }[channel] ?? 37448
+    main: 35128, // stable
+    next: 35129, // insider
+    draft: 35130 // vibe coded preview
+  }[channel] ?? 35128
 
-  const fileTags = fileMetadata.map(v => ['file', v.rootHash, v.filename, v.mimeType, v.service || 'i'])
+  const pathTags = fileMetadata.map(v => ['path', v.rootHash, v.filename, v.mimeType])
   const tags = [
     ['d', dTag],
-    ...fileTags
+    ...pathTags,
+    ['service', uploadService]
   ]
 
   const writeRelays = [...new Set([...(await signer.getRelays()).write, ...nappRelays].map(r => r.trim().replace(/\/$/, '')))]
@@ -347,21 +368,24 @@ async function uploadBundle ({ dTag, channel, fileMetadata, signer, pause = 0, s
   }
 
   if (!shouldReupload && mostRecentEvent) {
-    const recentFileTags = mostRecentEvent.tags
-      .filter(t => t[0] === 'file' && t[2] !== '.well-known/napp.json')
+    const recentPathTags = mostRecentEvent.tags
+      .filter(t => t[0] === 'path' && t[2] !== '.well-known/napp.json')
       .sort((a, b) => (a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0))
 
-    const currentFileTags = fileTags
+    const currentPathTags = pathTags
       .filter(t => t[2] !== '.well-known/napp.json')
       .sort((a, b) => (a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0))
 
-    const isSame = currentFileTags.length === recentFileTags.length && currentFileTags.every((t, i) => {
-      const rt = recentFileTags[i]
-      return rt.length >= 4 && rt[1] === t[1] && rt[2] === t[2] && rt[3] === t[3] && (rt[4] || 'i') === (t[4] || 'i')
+    const recentServiceTag = mostRecentEvent.tags.find(t => t[0] === 'service')
+    const serviceChanged = recentServiceTag?.[1] !== uploadService
+
+    const isSame = !serviceChanged && currentPathTags.length === recentPathTags.length && currentPathTags.every((t, i) => {
+      const rt = recentPathTags[i]
+      return rt.length >= 4 && rt[1] === t[1] && rt[2] === t[2] && rt[3] === t[3]
     })
 
     if (isSame) {
-      log(`Bundle based on ${fileTags.length} files is up-to-date (id: ${mostRecentEvent.id} - created_at: ${new Date(mostRecentEvent.created_at * 1000).toISOString()})`)
+      log(`Site manifest based on ${pathTags.length} files is up-to-date (id: ${mostRecentEvent.id} - created_at: ${new Date(mostRecentEvent.created_at * 1000).toISOString()})`)
 
       const matchingEvents = events.filter(e => e.id === mostRecentEvent.id)
       const coveredRelays = new Set(matchingEvents.map(e => e.meta?.relay).filter(Boolean))
@@ -369,9 +393,7 @@ async function uploadBundle ({ dTag, channel, fileMetadata, signer, pause = 0, s
 
       if (missingRelays.length === 0) return mostRecentEvent
 
-      // nostrRelays.getEvents currently doesn't tell us which event came from which relay,
-      // so we re-upload to all relays to ensure consistency
-      log(`Re-uploading existing bundle event to ${missingRelays.length} missing relays (out of ${writeRelays.length})`)
+      log(`Re-uploading existing site manifest event to ${missingRelays.length} missing relays (out of ${writeRelays.length})`)
       await throttledSendEvent(mostRecentEvent, missingRelays, { pause, trailingPause: true, log, minSuccessfulRelays: 0 })
       return mostRecentEvent
     }
@@ -382,18 +404,18 @@ async function uploadBundle ({ dTag, channel, fileMetadata, signer, pause = 0, s
   const maxCreatedAt = createdAt + 172800 // 2 days ahead
   if (effectiveCreatedAt > maxCreatedAt) effectiveCreatedAt = maxCreatedAt
 
-  const appBundle = {
+  const siteManifest = {
     kind,
     tags,
     content: '',
     created_at: effectiveCreatedAt
   }
-  const event = await signer.signEvent(appBundle)
+  const event = await signer.signEvent(siteManifest)
   await throttledSendEvent(event, writeRelays, { pause, trailingPause: true, log })
   return event
 }
 
-async function maybeUploadStall ({
+async function maybeUploadAppListing ({
   dTag,
   channel,
   name,
@@ -404,6 +426,10 @@ async function maybeUploadStall ({
   isSummaryAuto,
   icon,
   isIconAuto,
+  descriptions,
+  keyArt,
+  screenshots,
+  uploadService,
   signer,
   writeRelays,
   log,
@@ -418,20 +444,20 @@ async function maybeUploadStall ({
   const trimmedSummary = typeof summary === 'string' ? summary.trim() : ''
   const iconRootHash = icon?.rootHash
   const iconMimeType = icon?.mimeType
-  const iconService = icon?.service || 'i'
   const hasMetadata = Boolean(trimmedName) || Boolean(trimmedSummary) || Boolean(iconRootHash) ||
-    Boolean(self) || (countries && countries.length > 0) || (categories && categories.length > 0) || (hashtags && hashtags.length > 0)
+    Boolean(self) || (countries && countries.length > 0) || (categories && categories.length > 0) || (hashtags && hashtags.length > 0) ||
+    (descriptions && descriptions.length > 0) || (keyArt && keyArt.length > 0) || (screenshots && screenshots.length > 0)
 
   const relays = [...new Set([...writeRelays, ...nappRelays].map(r => r.trim().replace(/\/$/, '')))]
 
-  const previousResult = await getPreviousStall(dTag, relays, signer, channel)
+  const previousResult = await getPreviousAppListing(dTag, relays, signer, channel)
   const previous = previousResult?.previous
   if (!previous && !hasMetadata) {
-    if (shouldReupload) log('Skipping stall event upload: No previous event found and no metadata provided.')
+    if (shouldReupload) log('Skipping app listing event upload: No previous event found and no metadata provided.')
     return { pause }
   }
 
-  const publishStall = async (event) => {
+  const publishListing = async (event) => {
     const signedEvent = await signer.signEvent(event)
     return await throttledSendEvent(signedEvent, relays, { pause, log, trailingPause: true })
   }
@@ -443,6 +469,39 @@ async function maybeUploadStall ({
     draft: 37350
   }[channel] ?? 37348
 
+  // Helper to push media-related tags (icon, key_art, screenshot, service)
+  const pushMediaTags = (tags) => {
+    let hasMedia = false
+
+    if (iconRootHash && iconMimeType) {
+      tags.push(['icon', iconRootHash, iconMimeType])
+      if (isIconAuto) tags.push(['auto', 'icon'])
+      hasMedia = true
+    }
+
+    if (keyArt && keyArt.length > 0) {
+      for (const ka of keyArt) {
+        const row = ['key_art', ka.rootHash, ka.mimeType]
+        if (ka.country) row.push(ka.country)
+        tags.push(row)
+      }
+      hasMedia = true
+    }
+
+    if (screenshots && screenshots.length > 0) {
+      for (const ss of screenshots) {
+        const row = ['screenshot', ss.rootHash, ss.mimeType]
+        if (ss.country) row.push(ss.country)
+        tags.push(row)
+      }
+      hasMedia = true
+    }
+
+    if (hasMedia) tags.push(['service', uploadService])
+
+    return { hasIcon: Boolean(iconRootHash && iconMimeType) }
+  }
+
   if (!previous) {
     const tags = [
       ['d', dTag]
@@ -481,14 +540,9 @@ async function maybeUploadStall ({
       })
     }
 
-    let hasIcon = false
-    let hasName = false
-    if (iconRootHash && iconMimeType) {
-      hasIcon = true
-      tags.push(['icon', iconRootHash, iconMimeType, iconService])
-      if (isIconAuto) tags.push(['auto', 'icon'])
-    }
+    const { hasIcon } = pushMediaTags(tags)
 
+    let hasName = false
     if (trimmedName) {
       hasName = true
       const row = ['name', trimmedName]
@@ -504,12 +558,22 @@ async function maybeUploadStall ({
       if (isSummaryAuto) tags.push(['auto', 'summary'])
     }
 
+    if (descriptions) {
+      for (const [text, lang] of descriptions) {
+        if (text) {
+          const row = ['description', text]
+          if (lang) row.push(lang)
+          tags.push(row)
+        }
+      }
+    }
+
     if (!hasIcon || !hasName) {
-      log(`Skipping stall event creation: Missing required metadata.${!hasName ? ' Name is missing.' : ''}${!hasIcon ? ' Icon is missing.' : ''}`)
+      log(`Skipping app listing event creation: Missing required metadata.${!hasName ? ' Name is missing.' : ''}${!hasIcon ? ' Icon is missing.' : ''}`)
       return { pause }
     }
 
-    return await publishStall({
+    return await publishListing({
       kind,
       tags,
       content: '',
@@ -589,6 +653,41 @@ async function maybeUploadStall ({
     changed = true
   }
 
+  // Update descriptions
+  if (descriptions) {
+    removeTags('description')
+    for (const [text, lang] of descriptions) {
+      if (text) {
+        const row = ['description', text]
+        if (lang) row.push(lang)
+        tags.push(row)
+      }
+    }
+    changed = true
+  }
+
+  // Update key art
+  if (keyArt && keyArt.length > 0) {
+    removeTags('key_art')
+    for (const ka of keyArt) {
+      const row = ['key_art', ka.rootHash, ka.mimeType]
+      if (ka.country) row.push(ka.country)
+      tags.push(row)
+    }
+    changed = true
+  }
+
+  // Update screenshots
+  if (screenshots && screenshots.length > 0) {
+    removeTags('screenshot')
+    for (const ss of screenshots) {
+      const row = ['screenshot', ss.rootHash, ss.mimeType]
+      if (ss.country) row.push(ss.country)
+      tags.push(row)
+    }
+    changed = true
+  }
+
   const ensureTagValue = (key, updater) => {
     const index = tags.findIndex(tag => Array.isArray(tag) && tag[0] === key)
     if (index === -1) {
@@ -655,12 +754,18 @@ async function maybeUploadStall ({
   if (iconRootHash && iconMimeType) {
     if (!isIconAuto || hasAuto('icon')) {
       ensureTagValue('icon', (_) => {
-        return ['icon', iconRootHash, iconMimeType, iconService]
+        return ['icon', iconRootHash, iconMimeType]
       })
       if (!isIconAuto) removeAuto('icon')
     }
   }
 
+  // Update service tag if any media exists
+  const hasMedia = Boolean(iconRootHash) || (keyArt && keyArt.length > 0) || (screenshots && screenshots.length > 0)
+  if (hasMedia) {
+    ensureTagValue('service', () => ['service', uploadService])
+  }
+
   if (!changed && !shouldReupload) {
     const { storedEvents } = previousResult
 
@@ -670,7 +775,7 @@ async function maybeUploadStall ({
 
     if (missingRelays.length === 0) return { pause }
 
-    log(`Re-uploading existing stall event to ${missingRelays.length} missing relays (out of ${relays.length})`)
+    log(`Re-uploading existing app listing event to ${missingRelays.length} missing relays (out of ${relays.length})`)
     return await throttledSendEvent(previous, missingRelays, { pause, log, trailingPause: true, minSuccessfulRelays: 0 })
   }
 
@@ -678,7 +783,7 @@ async function maybeUploadStall ({
   const maxCreatedAt = createdAt + 172800 // 2 days ahead
   if (effectiveCreatedAt > maxCreatedAt) effectiveCreatedAt = maxCreatedAt
 
-  return await publishStall({
+  return await publishListing({
     kind,
     tags,
     content: typeof previous.content === 'string' ? previous.content : '',
@@ -686,7 +791,7 @@ async function maybeUploadStall ({
   })
 }
 
-async function getPreviousStall (dTagValue, relays, signer, channel) {
+async function getPreviousAppListing (dTagValue, relays, signer, channel) {
   const kind = {
     main: 37348,
     next: 37349,