nappup 2.0.0 → 2.1.0

package/README.md

@@ -33,6 +33,7 @@ nappup [directory] [options]
 | `--main` | Publish to the **main** release channel. This is the default behavior. |
 | `--next` | Publish to the **next** release channel. Ideal for beta testing or staging builds. |
 | `--draft` | Publish to the **draft** release channel. Use this for internal testing or work-in-progress builds. |
+| `--dotenv-private-key <hex>` | Use a 32-byte hex private key to decrypt and manage encrypted credentials in `.env`. Prefer `DOTENV_PRIVATE_KEY_NAPPUP` because command-line arguments can be visible in shell history and process listings. |
 
 ## Authentication
 
@@ -47,6 +48,7 @@ Napp Up! supports multiple ways to provide your Nostr secret key:
    ```bash
    nappup -s 'bunker://<pubkey>?relay=wss://relay.example.com&secret=<token>'
    ```
+   Napp Up! creates a persistent NIP-46 client key before connecting. For URLs passed with `-s`, the latest session is stored as `LAST_CLI_BUNKER_SESSION` in the project's `.env`. A URL without `secret` is also valid when the remote signer uses its public key as the access capability.
 
 3. **Environment variable**: Set `NOSTR_SECRET_KEY` in your environment or a `.env` file (also supports `bunker://` URLs):
    ```bash
@@ -56,6 +58,37 @@ Napp Up! supports multiple ways to provide your Nostr secret key:
 
 4. **Auto-generated key**: If no key is provided, Napp Up! will generate a new keypair automatically and store it (as nsec) in your project's `.env` file for future use.
 
+When `NOSTR_SECRET_KEY` in `.env` is a bunker URL, Napp Up! adds the local client key as a `#client_key=...` URI fragment while retaining the query-string `secret` for compatibility fallback. Reconnects first use the same client key without the token and retry with the token only if necessary.
+
+Napp Up! stores `NOSTR_SECRET_KEY` and `LAST_CLI_BUNKER_SESSION` in the official dotenvx `encrypted:<base64>` format, using the compressed public key in `DOTENV_PUBLIC_KEY_NAPPUP`. The private key is selected from `--dotenv-private-key`, then `DOTENV_PRIVATE_KEY_NAPPUP` in the process environment, and finally a built-in fallback. The public key is selected from the `.env`, then the process environment, and finally derived from the selected private key.
+
+The built-in fallback makes migration automatic, but is public knowledge and therefore only hides plaintext; use an explicit private key for confidentiality. Generate one locally for storage in your secret manager with:
+
+```bash
+nappup env keygen
+```
+
+Alternatively, generate and export one directly into the current shell:
+
+```bash
+export DOTENV_PRIVATE_KEY_NAPPUP="$(nappup env keygen)"
+```
+
+`env keygen` writes only the generated 64-character lowercase hex key to standard output, writes a reminder to standard error, and never reads or modifies `.env`. Store the result in a secret manager; nappup cannot recover it.
+
+Because encryption itself requires only the public key, the following command can safely replace the Nostr secret without receiving the private key:
+
+```bash
+nappup env set NOSTR_SECRET_KEY
+printf '%s\n' 'nsec1...' | nappup env set NOSTR_SECRET_KEY
+```
+
+The interactive form hides and confirms the value. Redirected stdin and a positional value are also accepted; the positional form emits a warning because it may be exposed through shell history or process listings. With only `DOTENV_PUBLIC_KEY_NAPPUP`, `env set` can encrypt a replacement, while commands that need an existing value fail clearly without the matching private key.
+
+Existing plaintext values are encrypted automatically when used. If an explicit private key does not match the stored public key, it becomes authoritative: recoverable values are re-encrypted and inaccessible credentials are reset with a warning naming only the affected variables. This can result in a new publisher identity or bunker client key.
+
+Use `DOTENV_CONFIG_PATH` to select a different dotenv file. The private key must come from the process environment or CLI and is rejected if stored inside that file.
+
 ### Examples
 
 Upload the current directory to the main channel:

package/bin/nappup/helpers.js

@@ -6,12 +6,15 @@ import mime from 'mime-types'
 import { fileTypeFromFile } from 'file-type'
 
 export function parseArgs (args) {
+  if (args[0] === 'env') return parseEnvArgs(args)
+
   let dir = null
   let sk = null
   let dTag = null
   let channel = null
   let shouldReupload = false
   let yes = false
+  let dotenvPrivateKey = null
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '-s' && args[i + 1]) {
@@ -30,19 +33,123 @@ export function parseArgs (args) {
       shouldReupload = true
     } else if (args[i] === '-y') {
       yes = true
+    } else if (args[i] === '--dotenv-private-key' && args[i + 1]) {
+      dotenvPrivateKey = args[i + 1]
+      i++
+    } else if (args[i] === '--dotenv-private-key') {
+      throw new Error('--dotenv-private-key requires a value')
     } else if (!args[i].startsWith('-') && dir === null) {
       dir = args[i]
     }
   }
 
   return {
+    command: 'upload',
     dir: path.resolve(dir ?? '.'),
     sk,
     dTag,
     channel: channel || 'main',
     shouldReupload,
-    yes
+    yes,
+    dotenvPrivateKey
+  }
+}
+
+function parseEnvArgs (args) {
+  if (args[1] === 'keygen') {
+    if (args.length !== 2) throw new Error('Expected: nappup env keygen')
+    return { command: 'env-keygen' }
+  }
+  if (args[1] !== 'set') throw new Error('Expected: nappup env set NOSTR_SECRET_KEY [value]')
+  if (args[2] !== 'NOSTR_SECRET_KEY') throw new Error('Only NOSTR_SECRET_KEY can be set')
+
+  let value = null
+  let dotenvPrivateKey = null
+  for (let i = 3; i < args.length; i++) {
+    if (args[i] === '--dotenv-private-key') {
+      if (!args[i + 1]) throw new Error('--dotenv-private-key requires a value')
+      dotenvPrivateKey = args[++i]
+    } else if (args[i] === '--') {
+      if (value !== null || !args[i + 1] || i + 2 !== args.length) throw new Error('Expected one NOSTR_SECRET_KEY value')
+      value = args[++i]
+    } else if (value === null) {
+      value = args[i]
+    } else {
+      throw new Error('Expected one NOSTR_SECRET_KEY value')
+    }
   }
+
+  return {
+    command: 'env-set',
+    name: 'NOSTR_SECRET_KEY',
+    value,
+    dotenvPrivateKey
+  }
+}
+
+function hiddenQuestion (query, { input, output }) {
+  return new Promise((resolve, reject) => {
+    const wasRaw = Boolean(input.isRaw)
+    const wasPaused = input.isPaused?.() ?? false
+    let value = ''
+
+    function cleanup () {
+      input.off('keypress', onKeypress)
+      input.setRawMode(wasRaw)
+      if (wasPaused) input.pause()
+    }
+
+    function onKeypress (text, key = {}) {
+      if (key.ctrl && key.name === 'c') {
+        cleanup()
+        output.write('\n')
+        const error = new Error('Operation cancelled by user')
+        error.code = 'ABORT_ERR'
+        reject(error)
+      } else if (key.name === 'return' || key.name === 'enter') {
+        cleanup()
+        output.write('\n')
+        resolve(value)
+      } else if (key.name === 'backspace') {
+        value = value.slice(0, -1)
+      } else if (text && !key.ctrl && !key.meta) {
+        value += text
+      }
+    }
+
+    readline.emitKeypressEvents(input)
+    input.setRawMode(true)
+    input.resume()
+    input.on('keypress', onKeypress)
+    output.write(query)
+  })
+}
+
+async function readPipedValue (input) {
+  let value = ''
+  for await (const chunk of input) {
+    value += chunk
+    if (value.length > 65536) throw new Error('NOSTR_SECRET_KEY input is too large')
+  }
+  return value.replace(/(?:\r\n|\n)$/, '')
+}
+
+export async function readEnvSetValue (args, {
+  input = process.stdin,
+  output = process.stdout,
+  errorOutput = process.stderr
+} = {}) {
+  if (args.value !== null) {
+    errorOutput.write('Warning: a plaintext value passed as an argument may be visible in shell history and process listings.\n')
+    return args.value
+  }
+  if (!input.isTTY) return readPipedValue(input)
+  if (typeof input.setRawMode !== 'function') throw new Error('Cannot hide input on this terminal')
+
+  const first = await hiddenQuestion('NOSTR_SECRET_KEY: ', { input, output })
+  const second = await hiddenQuestion('Confirm NOSTR_SECRET_KEY: ', { input, output })
+  if (first !== second) throw new Error('NOSTR_SECRET_KEY values do not match')
+  return first
 }
 
 export async function confirmArgs (args) {

package/bin/nappup/index.js

@@ -1,51 +1,85 @@
 #!/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,
+  readEnvSetValue,
   toFileList,
   getFiles
 } from './helpers.js'
-import toApp from '#index.js'
 
 const args = parseArgs(process.argv.slice(2))
 
-let { dTag } = args
-const { dir, sk, channel, shouldReupload } = 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)
-    }
+if (args.command === 'env-keygen') {
+  const { keypair } = await import('@dotenvx/primitives')
+  const { privateKey } = keypair()
+  console.error('Keep this dotenv private key secret; nappup has not stored it.')
+  process.stdout.write(`${privateKey}\n`)
+} else {
+  const dotenv = await import('#services/dotenv.js')
+  const dotenvState = dotenv.initializeDotenv({
+    privateKey: args.dotenvPrivateKey,
+    loadNostrSecretKey: args.command === 'upload' && !args.sk,
+    reconcilePrivateKey: args.command === 'upload'
+  })
+
+  if (args.command === 'env-set') {
+    const { validateNostrSecretKey } = await import('#services/nostr-secret-key.js')
+    const value = await readEnvSetValue(args)
+    validateNostrSecretKey(value)
+    dotenv.setEncryptedDotenvValue(args.name, value, {
+      filePath: dotenvState.filePath,
+      updateProcessEnv: false
+    })
+    console.log(`Set encrypted ${args.name} in ${dotenvState.filePath}`)
+  } else {
+    await upload(args, dotenvState)
   }
-  dTag = folderName
 }
-args.dTag = dTag
 
-await confirmArgs(args)
+async function upload (args, dotenvState) {
+  let { dTag } = args
+  const { dir, sk, channel, shouldReupload } = args
 
-const fileList = await toFileList(getFiles(dir), dir)
+  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
+  }
+  args.dTag = dTag
 
-const bunkerUrl = sk?.startsWith('bunker://') ? sk : (!sk && process.env.NOSTR_SECRET_KEY?.startsWith('bunker://')) ? process.env.NOSTR_SECRET_KEY : null
+  await confirmArgs(args)
+  const fileList = await toFileList(getFiles(dir), dir)
+  const bunkerUrl = sk?.startsWith('bunker://')
+    ? sk
+    : !sk && process.env.NOSTR_SECRET_KEY?.startsWith('bunker://')
+        ? process.env.NOSTR_SECRET_KEY
+        : null
 
-let signer
-if (bunkerUrl) {
-  const { default: NostrBunkerSigner } = await import('#services/bunker-signer.js')
-  signer = await NostrBunkerSigner.create(bunkerUrl)
-} else {
-  signer = await NostrSigner.create(sk)
-}
+  let signer
+  if (bunkerUrl) {
+    const { default: NostrBunkerSigner } = await import('#services/bunker-signer.js')
+    signer = await NostrBunkerSigner.create(bunkerUrl, {
+      source: sk ? 'cli' : dotenvState.nostrSecretKeySource === 'dotenv' ? 'dotenv' : 'cli'
+    })
+  } else {
+    const { default: NostrSigner } = await import('#services/nostr-signer.js')
+    signer = await NostrSigner.create(sk)
+  }
 
-try {
-  await toApp(fileList, signer, { log: console.log.bind(console), dTag, channel, shouldReupload })
-} finally {
-  await signer.close?.()
+  try {
+    const { default: toApp } = await import('#index.js')
+    await toApp(fileList, signer, { log: console.log.bind(console), dTag, channel, shouldReupload })
+  } finally {
+    await signer.close?.()
+  }
 }

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "MIT",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {
@@ -17,11 +17,12 @@
     "nappup": "bin/nappup/index.js"
   },
   "dependencies": {
+    "@dotenvx/primitives": "^2.1.0",
     "@noble/curves": "^2.0.0",
     "@noble/hashes": "^2.0.0",
     "dotenv": "^17.2.0",
     "file-type": "^21.0.0",
-    "libp2r2p": "^0.2.0",
+    "libp2r2p": "^0.3.0",
     "mime-types": "^3.0.1",
     "nmmr": "^2.0.0",
     "nostr-tools": "^2.23.3"

package/src/services/bunker-session-codec.js

@@ -0,0 +1,64 @@
+import { getPublicKey } from 'nostr-tools/pure'
+import { base16ToBytes } from 'libp2r2p/base16'
+import { base64UrlToBytes, bytesToBase64Url } from 'libp2r2p/base64'
+
+const HEX_32 = /^[0-9a-f]{64}$/
+const BASE64_URL = /^[A-Za-z0-9_-]+$/
+
+export function normalizeClientKey (value) {
+  if (typeof value !== 'string') throw new Error('Invalid bunker client key')
+  const normalized = value.toLowerCase()
+  if (!HEX_32.test(normalized)) throw new Error('Invalid bunker client key')
+  try {
+    getPublicKey(base16ToBytes(normalized))
+  } catch {
+    throw new Error('Invalid bunker client key')
+  }
+  return normalized
+}
+
+function normalizePubkey (value) {
+  const normalized = typeof value === 'string' ? value.toLowerCase() : ''
+  if (!HEX_32.test(normalized)) throw new Error('Invalid CLI bunker session')
+  return normalized
+}
+
+function uniqueStrings (values) {
+  return [...new Set(values.filter(value => typeof value === 'string' && value))]
+}
+
+export function encodeCliSession (session) {
+  const value = JSON.stringify({
+    remoteSignerPubkey: session.remoteSignerPubkey,
+    relays: session.relays,
+    secret: session.secret,
+    clientKey: session.clientKey
+  })
+  return bytesToBase64Url(new TextEncoder().encode(value))
+}
+
+export function decodeCliSession (encoded) {
+  if (typeof encoded !== 'string' || !BASE64_URL.test(encoded)) throw new Error('Invalid CLI bunker session')
+  const bytes = base64UrlToBytes(encoded)
+  if (bytesToBase64Url(bytes) !== encoded) throw new Error('Invalid CLI bunker session')
+
+  let value
+  try {
+    value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes))
+  } catch {
+    throw new Error('Invalid CLI bunker session')
+  }
+
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid CLI bunker session')
+  const remoteSignerPubkey = normalizePubkey(value.remoteSignerPubkey)
+  const relays = uniqueStrings(Array.isArray(value.relays) ? value.relays : [])
+  if (!relays.length) throw new Error('Invalid CLI bunker session')
+  let secret = null
+  if (value.secret !== null) {
+    if (typeof value.secret !== 'string' || !value.secret) throw new Error('Invalid CLI bunker session')
+    secret = value.secret
+  }
+  const clientKey = normalizeClientKey(value.clientKey)
+
+  return { remoteSignerPubkey, relays, secret, clientKey }
+}

package/src/services/bunker-session.js

@@ -0,0 +1,96 @@
+import { generateSecretKey } from 'nostr-tools/pure'
+import { bytesToBase16 } from 'libp2r2p/base16'
+import { toBunkerUrl } from 'libp2r2p/nip46'
+import {
+  dotenvPath,
+  DotenvDecryptionError,
+  readEncryptedDotenvValue,
+  setEncryptedDotenvValue
+} from '#services/dotenv.js'
+import {
+  decodeCliSession,
+  encodeCliSession,
+  normalizeClientKey
+} from '#services/bunker-session-codec.js'
+import { parseBunkerSessionUrl } from '#services/bunker-url.js'
+
+export const LAST_CLI_BUNKER_SESSION = 'LAST_CLI_BUNKER_SESSION'
+
+function uniqueStrings (values) {
+  return [...new Set(values.filter(value => typeof value === 'string' && value))]
+}
+
+function readCliSession (filePath, onWarning) {
+  let encoded
+  try {
+    encoded = readEncryptedDotenvValue(LAST_CLI_BUNKER_SESSION, { filePath, onWarning })
+  } catch (error) {
+    if (error instanceof DotenvDecryptionError) throw error
+    onWarning?.(`Ignoring invalid ${LAST_CLI_BUNKER_SESSION}: ${error.message}`)
+    return null
+  }
+  if (!encoded) return null
+  try {
+    return decodeCliSession(encoded)
+  } catch (error) {
+    onWarning?.(`Ignoring invalid ${LAST_CLI_BUNKER_SESSION}: ${error.message}`)
+    return null
+  }
+}
+
+function cacheMatchesInput (cache, parsed) {
+  if (!cache || cache.remoteSignerPubkey !== parsed.pointer.remoteSignerPubkey) return false
+  if (parsed.clientKey) return cache.clientKey === parsed.clientKey
+  return parsed.pointer.secret ? cache.secret === parsed.pointer.secret : true
+}
+
+export function persistBunkerSession (session) {
+  if (session.source === 'dotenv') {
+    const url = new URL(toBunkerUrl({
+      remoteSignerPubkey: session.remoteSignerPubkey,
+      relays: session.relays,
+      secret: session.secret
+    }))
+    url.hash = new URLSearchParams({ client_key: session.clientKey }).toString()
+    setEncryptedDotenvValue('NOSTR_SECRET_KEY', url.toString(), {
+      filePath: session.filePath,
+      updateProcessEnv: true
+    })
+    return
+  }
+
+  setEncryptedDotenvValue(LAST_CLI_BUNKER_SESSION, encodeCliSession(session), {
+    filePath: session.filePath,
+    updateProcessEnv: true
+  })
+}
+
+export { parseBunkerSessionUrl } from '#services/bunker-url.js'
+
+export function prepareBunkerSession (bunkerUrl, {
+  source = 'cli',
+  filePath = dotenvPath,
+  onWarning = console.warn,
+  generateClientKey = generateSecretKey
+} = {}) {
+  if (source !== 'cli' && source !== 'dotenv') throw new Error('Invalid bunker session source')
+  const parsed = parseBunkerSessionUrl(bunkerUrl)
+  const cache = source === 'cli' ? readCliSession(filePath, onWarning) : null
+  const matchingCache = cacheMatchesInput(cache, parsed) ? cache : null
+
+  let clientKey = parsed.clientKey || matchingCache?.clientKey || null
+  const reusedClientKey = Boolean(clientKey)
+  if (!clientKey) clientKey = normalizeClientKey(bytesToBase16(generateClientKey()))
+
+  const session = {
+    source,
+    filePath,
+    remoteSignerPubkey: parsed.pointer.remoteSignerPubkey,
+    relays: uniqueStrings([...parsed.pointer.relays, ...(matchingCache?.relays || [])]),
+    secret: parsed.pointer.secret || matchingCache?.secret || null,
+    clientKey,
+    reusedClientKey
+  }
+  persistBunkerSession(session)
+  return session
+}

package/src/services/bunker-signer.js

@@ -1,8 +1,69 @@
-import { generateSecretKey } from 'nostr-tools/pure'
-import { BunkerSigner, parseBunkerInput } from 'nostr-tools/nip46'
+import { BunkerSigner } from 'libp2r2p/nip46'
+import { base16ToBytes } from 'libp2r2p/base16'
 import { getRelays } from '#helpers/signer.js'
+import {
+  persistBunkerSession,
+  prepareBunkerSession
+} from '#services/bunker-session.js'
 
 const createToken = Symbol('createToken')
+const DEFAULT_CONNECT_TIMEOUT = 5_000
+const DEFAULT_REQUEST_TIMEOUT = 30_000
+
+function alreadyConnected (error) {
+  return /already connected/i.test(typeof error === 'string' ? error : error?.message || '')
+}
+
+async function closeQuietly (bunker) {
+  try {
+    await bunker?.close()
+  } catch {}
+}
+
+async function runWithDeadline (operation, timeout, timeoutMessage, onFailure) {
+  const controller = new AbortController()
+  let timer
+  const deadline = new Promise((resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(timeoutMessage)), timeout)
+  })
+  const pending = Promise.resolve().then(() => operation(controller.signal))
+
+  try {
+    return await Promise.race([pending, deadline])
+  } catch (error) {
+    controller.abort()
+    await onFailure?.()
+    await pending.catch(() => {})
+    throw error
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+async function openBunker (session, secret, {
+  bunkerFactory,
+  connectTimeout
+}) {
+  const bunker = bunkerFactory(base16ToBytes(session.clientKey), {
+    remoteSignerPubkey: session.remoteSignerPubkey,
+    relays: session.relays,
+    secret
+  })
+
+  await runWithDeadline(async signal => {
+    try {
+      await bunker.connect({
+        clientMetadata: { name: 'nappup' },
+        signal
+      })
+    } catch (error) {
+      if (!alreadyConnected(error)) throw error
+      await bunker.getPublicKey({ signal })
+    }
+  }, connectTimeout, 'Bunker connection timed out', () => closeQuietly(bunker))
+
+  return bunker
+}
 
 export default class NostrBunkerSigner {
   #bunker
@@ -14,28 +75,53 @@ export default class NostrBunkerSigner {
     this.#publicKey = publicKey
   }
 
-  static async create (bunkerUrl, { connectTimeout = 30_000 } = {}) {
-    const bp = await parseBunkerInput(bunkerUrl)
-    if (!bp) throw new Error('Invalid bunker URL')
-    if (bp.relays.length === 0) throw new Error('Bunker URL must include at least one relay (?relay=wss://...)')
+  static async create (bunkerUrl, {
+    source = 'cli',
+    dotenvFilePath,
+    connectTimeout = DEFAULT_CONNECT_TIMEOUT,
+    requestTimeout = DEFAULT_REQUEST_TIMEOUT,
+    onWarning = console.warn,
+    generateClientKey,
+    bunkerFactory = (clientKey, pointer) => BunkerSigner.fromBunker(clientKey, pointer)
+  } = {}) {
+    const session = prepareBunkerSession(bunkerUrl, {
+      source,
+      ...(dotenvFilePath ? { filePath: dotenvFilePath } : {}),
+      onWarning,
+      ...(generateClientKey ? { generateClientKey } : {})
+    })
 
-    const clientSk = generateSecretKey()
-    const bunker = BunkerSigner.fromBunker(clientSk, bp)
-
-    let timeoutHandle
+    let bunker
     try {
-      await Promise.race([
-        bunker.connect(),
-        new Promise((resolve, reject) => {
-          timeoutHandle = setTimeout(() => reject(new Error('Bunker connection timed out')), connectTimeout)
-        })
-      ])
-    } finally {
-      clearTimeout(timeoutHandle)
-    }
+      if (session.reusedClientKey) {
+        try {
+          bunker = await openBunker(session, null, { bunkerFactory, connectTimeout })
+        } catch (error) {
+          if (!session.secret) throw error
+          bunker = await openBunker(session, session.secret, { bunkerFactory, connectTimeout })
+        }
+      } else {
+        bunker = await openBunker(session, session.secret, { bunkerFactory, connectTimeout })
+      }
 
-    const publicKey = await bunker.getPublicKey()
-    return new this(createToken, bunker, publicKey)
+      const publicKey = await runWithDeadline(
+        signal => bunker.getPublicKey({ timeout: requestTimeout, signal }),
+        requestTimeout,
+        'Bunker public key request timed out',
+        () => closeQuietly(bunker)
+      )
+
+      session.relays = [...bunker.pointer.relays]
+      try {
+        persistBunkerSession(session)
+      } catch (error) {
+        onWarning?.(`Could not persist updated bunker session: ${error.message}`)
+      }
+      return new this(createToken, bunker, publicKey)
+    } catch (error) {
+      await closeQuietly(bunker)
+      throw error
+    }
   }
 
   getPublicKey () {

package/src/services/bunker-url.js

@@ -0,0 +1,32 @@
+import { parseBunkerUrl } from 'libp2r2p/nip46'
+import { normalizeClientKey } from '#services/bunker-session-codec.js'
+
+export function parseBunkerSessionUrl (input) {
+  let url
+  try {
+    url = new URL(input)
+  } catch {
+    throw new Error('Invalid bunker URL')
+  }
+  if (url.protocol !== 'bunker:') throw new Error('Invalid bunker URL')
+  if (url.searchParams.getAll('secret').length > 1) throw new Error('Bunker URL must not contain multiple secrets')
+  if (url.searchParams.getAll('relay').length === 0) {
+    throw new Error('Bunker URL must include at least one relay (?relay=wss://...)')
+  }
+
+  let clientKey = null
+  if (url.hash) {
+    const fragment = new URLSearchParams(url.hash.slice(1))
+    const keys = [...fragment.keys()]
+    const values = fragment.getAll('client_key')
+    if (keys.some(key => key !== 'client_key') || values.length !== 1) {
+      throw new Error('Invalid bunker URL fragment')
+    }
+    clientKey = normalizeClientKey(values[0])
+    url.hash = ''
+  }
+
+  const pointer = parseBunkerUrl(url.toString())
+  if (!pointer) throw new Error('Invalid bunker URL')
+  return { pointer, clientKey }
+}

package/src/services/dotenv.js

@@ -0,0 +1,356 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { randomUUID } from 'node:crypto'
+import * as dotenv from 'dotenv'
+import { decrypt, derive, encrypt } from '@dotenvx/primitives'
+import { base64ToBytes, bytesToBase64 } from 'libp2r2p/base64'
+import { decodeCliSession } from '#services/bunker-session-codec.js'
+import { validateNostrSecretKey } from '#services/nostr-secret-key.js'
+
+export const DOTENV_PRIVATE_KEY_NAME = 'DOTENV_PRIVATE_KEY_NAPPUP'
+export const DOTENV_PUBLIC_KEY_NAME = 'DOTENV_PUBLIC_KEY_NAPPUP'
+export const LAST_CLI_BUNKER_SESSION = 'LAST_CLI_BUNKER_SESSION'
+export const DEFAULT_DOTENV_PRIVATE_KEY = '0000000000000000000000000000000000000000000000000000000000000001'
+export const dotenvPath = path.resolve(process.env.DOTENV_CONFIG_PATH ?? path.join(process.cwd(), '.env'))
+
+const MANAGED_NAMES = new Set(['NOSTR_SECRET_KEY', LAST_CLI_BUNKER_SESSION])
+const ENCRYPTED_PREFIX = 'encrypted:'
+const MIN_ECIES_PAYLOAD_BYTES = 97
+
+let configuration = {
+  privateKey: DEFAULT_DOTENV_PRIVATE_KEY,
+  privateKeyExplicit: false,
+  externalPublicKey: null,
+  processEnv: process.env,
+  initialized: false
+}
+
+export class DotenvDecryptionError extends Error {
+  constructor (name, cause) {
+    super(`Unable to decrypt ${name} with the selected dotenv private key`, { cause })
+    this.name = 'DotenvDecryptionError'
+    this.code = 'DOTENV_DECRYPTION_FAILED'
+  }
+}
+
+function normalizePrivateKey (value) {
+  const normalized = typeof value === 'string' ? value.toLowerCase() : ''
+  if (!/^[0-9a-f]{64}$/.test(normalized)) throw new Error('Invalid dotenv private key')
+  try {
+    derive(normalized)
+  } catch {
+    throw new Error('Invalid dotenv private key')
+  }
+  return normalized
+}
+
+function normalizePublicKey (value) {
+  const normalized = typeof value === 'string' ? value.toLowerCase() : ''
+  if (!/^(02|03)[0-9a-f]{64}$/.test(normalized)) throw new Error('Invalid dotenv public key')
+  try {
+    encrypt(normalized, '')
+  } catch {
+    throw new Error('Invalid dotenv public key')
+  }
+  return normalized
+}
+
+function isEncrypted (value) {
+  return typeof value === 'string' && value.startsWith(ENCRYPTED_PREFIX)
+}
+
+function validateEncryptedValue (value) {
+  if (!isEncrypted(value)) throw new Error('Invalid encrypted dotenv value')
+  const encoded = value.slice(ENCRYPTED_PREFIX.length)
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) throw new Error('Invalid encrypted dotenv value')
+  let bytes
+  try {
+    bytes = base64ToBytes(encoded)
+  } catch {
+    throw new Error('Invalid encrypted dotenv value')
+  }
+  if (bytes.length < MIN_ECIES_PAYLOAD_BYTES || bytesToBase64(bytes) !== encoded) {
+    throw new Error('Invalid encrypted dotenv value')
+  }
+}
+
+function validateManagedValue (name, value) {
+  if (name === 'NOSTR_SECRET_KEY') return validateNostrSecretKey(value)
+  if (name === LAST_CLI_BUNKER_SESSION) {
+    decodeCliSession(value)
+    return value
+  }
+  throw new Error(`Unsupported managed dotenv variable: ${name}`)
+}
+
+export function readDotenvValues (filePath = dotenvPath) {
+  try {
+    return dotenv.parse(fs.readFileSync(filePath))
+  } catch (error) {
+    if (error?.code === 'ENOENT') return {}
+    throw error
+  }
+}
+
+function readDotenvFile (filePath) {
+  try {
+    return {
+      contents: fs.readFileSync(filePath, 'utf8'),
+      mode: fs.statSync(filePath).mode & 0o777
+    }
+  } catch (error) {
+    if (error?.code === 'ENOENT') return { contents: '', mode: 0o600 }
+    throw error
+  }
+}
+
+function writeDotenvChanges (changes, { filePath = dotenvPath } = {}) {
+  const { contents, mode } = readDotenvFile(filePath)
+  const eol = contents.includes('\r\n') ? '\r\n' : '\n'
+  const lines = contents ? contents.split(/\r?\n/) : []
+  if (lines.at(-1) === '') lines.pop()
+
+  const names = [...changes.keys()]
+  const assignments = new Map(names.map(name => [
+    name,
+    new RegExp(`^\\s*(?:export\\s+)?${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=`)
+  ]))
+  const written = new Set()
+  const nextLines = []
+
+  for (const line of lines) {
+    const name = names.find(candidate => assignments.get(candidate).test(line))
+    if (!name) {
+      nextLines.push(line)
+      continue
+    }
+    if (written.has(name)) continue
+    written.add(name)
+    const value = changes.get(name)
+    if (value !== null) nextLines.push(`${name}=${JSON.stringify(value)}`)
+  }
+  for (const [name, value] of changes) {
+    if (!written.has(name) && value !== null) nextLines.push(`${name}=${JSON.stringify(value)}`)
+  }
+
+  const nextContents = `${nextLines.join(eol)}${eol}`
+  const directory = path.dirname(filePath)
+  const temporaryPath = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`)
+  try {
+    fs.writeFileSync(temporaryPath, nextContents, { encoding: 'utf8', flag: 'wx', mode })
+    fs.chmodSync(temporaryPath, mode)
+    fs.renameSync(temporaryPath, filePath)
+  } finally {
+    try {
+      fs.unlinkSync(temporaryPath)
+    } catch {}
+  }
+}
+
+function decryptManagedValue (name, value, privateKey) {
+  try {
+    validateEncryptedValue(value)
+    return decrypt(privateKey, value)
+  } catch (error) {
+    throw new DotenvDecryptionError(name, error)
+  }
+}
+
+function warnKeyMismatch (names, onWarning, replacingName) {
+  const details = []
+  if (replacingName) details.push(`${replacingName} will be replaced by the supplied value`)
+  if (names.includes('NOSTR_SECRET_KEY')) {
+    details.push('a new publisher identity will be generated unless -s or an environment NOSTR_SECRET_KEY is provided')
+  }
+  if (names.includes(LAST_CLI_BUNKER_SESSION)) {
+    details.push('the next CLI bunker connection will generate a new client key and may require authorization')
+  }
+  const discarded = names.length ? ` Inaccessible values reset: ${names.join(', ')}.` : ''
+  const consequences = details.length ? ` ${details.join('; ')}.` : ''
+  onWarning?.(`The explicit dotenv private key does not match the stored public key; adopting the explicit key.${discarded}${consequences}`)
+}
+
+function reconcileExplicitPrivateKey (filePath, onWarning, replacement) {
+  if (!configuration.privateKeyExplicit) return false
+  const values = readDotenvValues(filePath)
+  const derivedPublicKey = derive(configuration.privateKey)
+  const existingPublicValue = values[DOTENV_PUBLIC_KEY_NAME]
+  if (!existingPublicValue) return false
+
+  let existingPublicKey
+  try {
+    existingPublicKey = normalizePublicKey(existingPublicValue)
+  } catch {
+    existingPublicKey = null
+  }
+  if (existingPublicKey === derivedPublicKey) {
+    if (existingPublicValue !== derivedPublicKey) {
+      writeDotenvChanges(new Map([[DOTENV_PUBLIC_KEY_NAME, derivedPublicKey]]), { filePath })
+    }
+    return false
+  }
+
+  const fallbackPublicKey = derive(DEFAULT_DOTENV_PRIVATE_KEY)
+  const fallbackUpgrade = existingPublicKey === fallbackPublicKey
+  const changes = new Map([[DOTENV_PUBLIC_KEY_NAME, derivedPublicKey]])
+  const discarded = []
+
+  for (const name of MANAGED_NAMES) {
+    const stored = values[name]
+    if (stored === undefined) continue
+    if (replacement?.name === name) continue
+    let plaintext
+    try {
+      if (isEncrypted(stored)) {
+        try {
+          plaintext = decryptManagedValue(name, stored, configuration.privateKey)
+        } catch (error) {
+          if (!fallbackUpgrade) throw error
+          plaintext = decryptManagedValue(name, stored, DEFAULT_DOTENV_PRIVATE_KEY)
+        }
+      } else {
+        plaintext = stored
+      }
+      validateManagedValue(name, plaintext)
+      changes.set(name, encrypt(derivedPublicKey, plaintext))
+    } catch (error) {
+      if (fallbackUpgrade) throw error
+      changes.set(name, null)
+      discarded.push(name)
+    }
+  }
+
+  if (replacement) changes.set(replacement.name, encrypt(derivedPublicKey, replacement.value))
+  if (!fallbackUpgrade) warnKeyMismatch(discarded, onWarning, replacement?.name)
+  writeDotenvChanges(changes, { filePath })
+  return true
+}
+
+function getPublicKeyForFile (filePath) {
+  const values = readDotenvValues(filePath)
+  const stored = values[DOTENV_PUBLIC_KEY_NAME]
+  if (stored) return normalizePublicKey(stored)
+  if (configuration.externalPublicKey) return configuration.externalPublicKey
+  return derive(configuration.privateKey)
+}
+
+export function setDotenvValue (name, value, {
+  filePath = dotenvPath,
+  updateProcessEnv = true
+} = {}) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new Error('Invalid dotenv variable name')
+  if (MANAGED_NAMES.has(name)) throw new Error(`Use setEncryptedDotenvValue for ${name}`)
+  if (typeof value !== 'string') throw new TypeError('Dotenv value should be a string')
+  writeDotenvChanges(new Map([[name, value]]), { filePath })
+  if (updateProcessEnv) configuration.processEnv[name] = value
+}
+
+export function setEncryptedDotenvValue (name, value, {
+  filePath = dotenvPath,
+  updateProcessEnv = true,
+  onWarning = console.warn
+} = {}) {
+  if (!MANAGED_NAMES.has(name)) throw new Error(`Unsupported managed dotenv variable: ${name}`)
+  if (typeof value !== 'string') throw new TypeError('Dotenv value should be a string')
+  validateManagedValue(name, value)
+  const reconciled = reconcileExplicitPrivateKey(filePath, onWarning, { name, value })
+  if (reconciled) {
+    if (updateProcessEnv) configuration.processEnv[name] = value
+    return
+  }
+  const publicKey = getPublicKeyForFile(filePath)
+  writeDotenvChanges(new Map([
+    [DOTENV_PUBLIC_KEY_NAME, publicKey],
+    [name, encrypt(publicKey, value)]
+  ]), { filePath })
+  if (updateProcessEnv) configuration.processEnv[name] = value
+}
+
+export function readEncryptedDotenvValue (name, {
+  filePath = dotenvPath,
+  migratePlaintext = true,
+  onWarning = console.warn
+} = {}) {
+  if (!MANAGED_NAMES.has(name)) throw new Error(`Unsupported managed dotenv variable: ${name}`)
+  reconcileExplicitPrivateKey(filePath, onWarning)
+  const values = readDotenvValues(filePath)
+  const stored = values[name]
+  if (stored === undefined) return null
+
+  if (!isEncrypted(stored)) {
+    validateManagedValue(name, stored)
+    if (migratePlaintext) {
+      setEncryptedDotenvValue(name, stored, { filePath, updateProcessEnv: false, onWarning })
+    }
+    return stored
+  }
+
+  const publicKey = values[DOTENV_PUBLIC_KEY_NAME]
+    ? normalizePublicKey(values[DOTENV_PUBLIC_KEY_NAME])
+    : derive(configuration.privateKey)
+  if (derive(configuration.privateKey) !== publicKey) {
+    throw new DotenvDecryptionError(name, new Error('The selected private key does not match DOTENV_PUBLIC_KEY_NAPPUP'))
+  }
+  const plaintext = decryptManagedValue(name, stored, configuration.privateKey)
+  validateManagedValue(name, plaintext)
+  return plaintext
+}
+
+export function initializeDotenv ({
+  privateKey,
+  filePath = dotenvPath,
+  processEnv = process.env,
+  loadNostrSecretKey = true,
+  reconcilePrivateKey = true,
+  onWarning = console.warn
+} = {}) {
+  const hadNostrSecretKey = Object.hasOwn(processEnv, 'NOSTR_SECRET_KEY')
+  const environmentPrivateKey = Object.hasOwn(processEnv, DOTENV_PRIVATE_KEY_NAME)
+    ? processEnv[DOTENV_PRIVATE_KEY_NAME]
+    : null
+  const environmentPublicKey = Object.hasOwn(processEnv, DOTENV_PUBLIC_KEY_NAME)
+    ? processEnv[DOTENV_PUBLIC_KEY_NAME]
+    : null
+  const selectedPrivateKey = normalizePrivateKey(privateKey ?? environmentPrivateKey ?? DEFAULT_DOTENV_PRIVATE_KEY)
+
+  const initialValues = readDotenvValues(filePath)
+  if (Object.hasOwn(initialValues, DOTENV_PRIVATE_KEY_NAME)) {
+    throw new Error(`${DOTENV_PRIVATE_KEY_NAME} must not be stored in ${filePath}`)
+  }
+
+  configuration = {
+    privateKey: selectedPrivateKey,
+    privateKeyExplicit: (privateKey !== undefined && privateKey !== null) || environmentPrivateKey !== null,
+    externalPublicKey: environmentPublicKey ? normalizePublicKey(environmentPublicKey) : null,
+    processEnv,
+    initialized: true
+  }
+
+  if (reconcilePrivateKey) reconcileExplicitPrivateKey(filePath, onWarning)
+  const values = readDotenvValues(filePath)
+  for (const [name, value] of Object.entries(values)) {
+    if (name === DOTENV_PRIVATE_KEY_NAME || MANAGED_NAMES.has(name)) continue
+    if (!Object.hasOwn(processEnv, name)) processEnv[name] = value
+  }
+
+  let nostrSecretKeySource = hadNostrSecretKey ? 'process' : null
+  if (!hadNostrSecretKey && loadNostrSecretKey) {
+    const value = readEncryptedDotenvValue('NOSTR_SECRET_KEY', { filePath, onWarning })
+    if (value !== null) {
+      processEnv.NOSTR_SECRET_KEY = value
+      nostrSecretKeySource = 'dotenv'
+    }
+  }
+
+  return {
+    filePath,
+    nostrSecretKeySource,
+    privateKeyExplicit: configuration.privateKeyExplicit,
+    publicKey: getPublicKeyForFile(filePath)
+  }
+}
+
+export function ensureDotenvInitialized (options) {
+  if (!configuration.initialized) return initializeDotenv(options)
+  return null
+}

package/src/services/nostr-secret-key.js

@@ -0,0 +1,24 @@
+import { getPublicKey } from 'nostr-tools/pure'
+import { base16ToBytes } from 'libp2r2p/base16'
+import { nsecDecode } from 'libp2r2p/nip19'
+import { parseBunkerSessionUrl } from '#services/bunker-url.js'
+
+const HEX_32 = /^[0-9a-f]{64}$/i
+
+export function validateNostrSecretKey (value) {
+  if (typeof value !== 'string' || !value) throw new Error('Invalid NOSTR_SECRET_KEY')
+  if (value.startsWith('bunker://')) {
+    parseBunkerSessionUrl(value)
+    return value
+  }
+
+  let hex = value
+  try {
+    if (value.startsWith('nsec1')) hex = nsecDecode(value)
+    if (!HEX_32.test(hex)) throw new Error()
+    getPublicKey(base16ToBytes(hex))
+  } catch {
+    throw new Error('Invalid NOSTR_SECRET_KEY')
+  }
+  return value
+}

package/src/services/nostr-signer.js

@@ -1,7 +1,3 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import * as dotenv from 'dotenv'
 import { getPublicKey } from 'nostr-tools/pure'
 import { getConversationKey, encrypt, decrypt } from 'nostr-tools/nip44'
 import nostrRelays, { seedRelays, freeRelays } from '#services/nostr-relays.js'
@@ -9,13 +5,7 @@ import { getRelays } from '#helpers/signer.js'
 import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
 import { finalizeEvent } from '#helpers/nip01.js'
 import { nsecDecode, nsecEncode } from 'libp2r2p/nip19'
-const __dirname = fileURLToPath(new URL('.', import.meta.url))
-
-const dotenvPath = process.env.DOTENV_CONFIG_PATH ?? `${__dirname}/../../.env`
-dotenv.config({
-  path: dotenvPath,
-  quiet: true
-})
+import { ensureDotenvInitialized, setEncryptedDotenvValue } from '#services/dotenv.js'
 
 const nip44 = {
   getConversationKey,
@@ -42,6 +32,7 @@ export default class NostrSigner {
       return new this(createToken, base16ToBytes(sk))
     }
 
+    ensureDotenvInitialized()
     let skBytes
     let isNewSk = false
     if (process.env.NOSTR_SECRET_KEY) {
@@ -52,7 +43,7 @@ export default class NostrSigner {
     } else {
       isNewSk = true
       sk = generateSecretKey()
-      fs.appendFileSync(path.resolve(dotenvPath), `NOSTR_SECRET_KEY=${nsecEncode(sk)}\n`)
+      setEncryptedDotenvValue('NOSTR_SECRET_KEY', nsecEncode(sk))
       skBytes = base16ToBytes(sk)
     }
     const ret = new this(createToken, skBytes)

package/src/services/site-manifest.js

@@ -10,6 +10,7 @@ const MANAGED_MANIFEST_TAGS = new Set([
 export function normalizeManifestPath (value) {
   if (typeof value !== 'string') throw new TypeError('Manifest path must be a string')
   const path = value.startsWith('/') ? value.slice(1) : value
+  // eslint-disable-next-line no-control-regex
   if (!path || path.includes('\\') || /[\u0000-\u001f\u007f]/.test(path)) {
     throw new Error(`Unsafe manifest path: ${JSON.stringify(value)}`)
   }

package/src/helpers/base36.js

@@ -1,74 +0,0 @@
-import { base16ToBytes, bytesToBase16 } from '#helpers/base16.js'
-import { base62ToBytes, bytesToBase62 } from '#helpers/base62.js'
-
-export const BASE36_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
-const BASE = BigInt(BASE36_ALPHABET.length)
-const LEADER = BASE36_ALPHABET[0]
-const CHAR_MAP = new Map([...BASE36_ALPHABET].map((char, index) => [char, BigInt(index)]))
-const BASE36_REGEX = /^[0-9a-z]+$/
-
-export function isBase36 (str) {
-  if (typeof str !== 'string') return false
-  return BASE36_REGEX.test(str)
-}
-
-export function bytesToBase36 (bytes, padLength = 0) {
-  return base16ToBase36(bytesToBase16(bytes), padLength)
-}
-
-export function base16ToBase36 (hex, padLength = 0) {
-  return bigIntToBase36(base16ToBigInt(hex), padLength)
-}
-
-export function base62ToBase36 (base62str, padLength = 0) {
-  return bytesToBase36(base62ToBytes(base62str), padLength)
-}
-
-export function base36ToBytes (base36str) {
-  return base16ToBytes(base36ToBase16(base36str))
-}
-
-export function base36ToBase16 (base36str) {
-  return bigIntToBase16(base36ToBigInt(base36str))
-}
-
-export function base36ToBase62 (base36str, padLength = 0) {
-  return bytesToBase62(base36ToBytes(base36str), padLength)
-}
-
-function base36ToBigInt (base36str) {
-  if (typeof base36str !== 'string') {
-    throw new Error('Input must be a string.')
-  }
-
-  let result = 0n
-  for (const char of base36str) {
-    const value = CHAR_MAP.get(char)
-    if (value === undefined) {
-      throw new Error(`Invalid character in Base36 string: ${char}`)
-    }
-    result = result * BASE + value
-  }
-  return result
-}
-
-function bigIntToBase36 (num, padLength) {
-  if (typeof num !== 'bigint') throw new Error('Input must be a BigInt.')
-  if (num < 0n) throw new Error('Can\'t be signed BigInt')
-
-  return num.toString(36).padStart(padLength, LEADER)
-}
-
-function bigIntToBase16 (num) {
-  if (typeof num !== 'bigint') throw new Error('Input must be a BigInt.')
-  if (num < 0n) throw new Error('Can\'t be signed BigInt')
-
-  let hexString = num.toString(16)
-  if (hexString.length % 2 !== 0) hexString = `0${hexString}`
-  return hexString
-}
-
-function base16ToBigInt (hex) {
-  if (typeof hex !== 'string') throw new Error('Input must be a string.')
-  return BigInt(`0x${hex}`)
-}

package/src/helpers/base62.js

@@ -1,59 +0,0 @@
-export const BASE62_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-const BASE = BigInt(BASE62_ALPHABET.length)
-const LEADER = BASE62_ALPHABET[0]
-const CHAR_MAP = new Map([...BASE62_ALPHABET].map((char, index) => [char, BigInt(index)]))
-
-export function bytesToBase62 (bytes, padLength = 0) {
-  if (bytes.length === 0) return ''.padStart(padLength, LEADER)
-
-  let num = 0n
-  for (const byte of bytes) {
-    num = (num << 8n) + BigInt(byte)
-  }
-
-  let result = ''
-  if (num === 0n) return LEADER.padStart(padLength, LEADER)
-
-  while (num > 0n) {
-    const remainder = num % BASE
-    result = BASE62_ALPHABET[Number(remainder)] + result
-    num = num / BASE
-  }
-
-  for (const byte of bytes) {
-    if (byte !== 0) break
-
-    result = LEADER + result
-  }
-
-  return result.padStart(padLength, LEADER)
-}
-
-export function base62ToBytes (base62Str) {
-  if (typeof base62Str !== 'string') { throw new Error('base62ToBytes requires a string argument') }
-  if (base62Str.length === 0) return new Uint8Array()
-
-  let leadingZeros = 0
-  for (let i = 0; i < base62Str.length; i++) {
-    if (base62Str[i] !== LEADER) break
-
-    leadingZeros++
-  }
-
-  let num = 0n
-  for (const char of base62Str) {
-    const value = CHAR_MAP.get(char)
-    if (value === undefined) { throw new Error(`Invalid character in Base62 string: ${char}`) }
-    num = num * BASE + value
-  }
-
-  const bytes = []
-  while (num > 0n) {
-    bytes.unshift(Number(num & 0xffn))
-    num = num >> 8n
-  }
-
-  const result = new Uint8Array(leadingZeros + bytes.length)
-  result.set(bytes, leadingZeros)
-  return result
-}