pear-electron 0.0.1

package/gui/index.js

@@ -0,0 +1,2 @@
+'use strict'
+module.exports = process.type === 'renderer' ? require('./preload') : require('./gui')

package/gui/preload.js

@@ -0,0 +1,366 @@
+/* eslint-env browser */
+'use strict'
+const streamx = require('streamx')
+const { EventEmitter } = require('events')
+const Iambus = require('iambus')
+const electron = require('electron')
+const noop = () => {}
+class Worker extends require('pear-api/worker') {
+  #ipc = null
+  constructor ({ ref = noop, unref = noop, ipc } = {}) {
+    super({ ref, unref })
+    this.#ipc = ipc
+  }
+
+  run (link, args = []) { return this.#ipc.workerRun(link, args) }
+}
+
+module.exports = class PearGUI {
+  constructor ({ API, state }) {
+    const id = this.id = electron.ipcRenderer.sendSync('id')
+
+    this.ipc = new IPC()
+    electron.ipcRenderer.on('ipc', (e, data) => {
+      this.ipc.stream.push(Buffer.from(data))
+    })
+
+    const teardown = async (fn) => {
+      if (state.isDecal) return
+      const action = await this.ipc.unloading({ id }) // only resolves when unloading occurs
+      await fn()
+      await this.ipc.completeUnload({ id, action })
+      if (action.type === 'reload') location.reload()
+      else if (action.type === 'nav') location.href = action.url
+    }
+
+    API = class extends API {
+      static UI = Symbol('ui')
+      constructor (ipc, state) {
+        const worker = new Worker({ ipc })
+        super(ipc, state, { teardown, worker })
+        this[Symbol.for('pear.ipc')] = ipc
+        const media = {
+          status: {
+            microphone: () => ipc.getMediaAccessStatus({ id, media: 'microphone' }),
+            camera: () => ipc.getMediaAccessStatus({ id, media: 'camera' }),
+            screen: () => ipc.getMediaAccessStatus({ id, media: 'screen' })
+          },
+          access: {
+            microphone: () => ipc.askForMediaAccess({ id, media: 'microphone' }),
+            camera: () => ipc.askForMediaAccess({ id, media: 'camera' }),
+            screen: () => ipc.askForMediaAccess({ id, media: 'screen' })
+          },
+          desktopSources: (options = {}) => ipc.desktopSources(options)
+        }
+
+        const kGuiCtrl = Symbol('gui:ctrl')
+
+        class Parent extends EventEmitter {
+          #id
+          constructor (id) {
+            super()
+            this.#id = id
+            electron.ipcRenderer.on('send', (e, ...args) => {
+              this.emit('message', ...args)
+            })
+          }
+
+          send (...args) { return electron.ipcRenderer.send('send-to', this.#id, ...args) }
+          focus (options = null) { return ipc.parent({ act: 'focus', id: this.#id, options }) }
+          blur () { return ipc.parent({ act: 'blur', id: this.#id }) }
+          show () { return ipc.parent({ act: 'show', id: this.#id }) }
+          hide () { return ipc.parent({ act: 'hide', id: this.#id }) }
+          minimize () { return ipc.parent({ act: 'minimize', id: this.#id }) }
+          maximize () { return ipc.parent({ act: 'maximize', id: this.#id }) }
+          fullscreen () { return ipc.parent({ act: 'fullscreen', id: this.#id }) }
+          restore () { return ipc.parent({ act: 'restore', id: this.#id }) }
+          dimensions (options = null) { return ipc.parent({ act: 'dimensions', id: this.#id, options }) }
+          isVisible () { return ipc.parent({ act: 'isVisible', id: this.#id }) }
+          isMinimized () { return ipc.parent({ act: 'isMinimized', id: this.#id }) }
+          isMaximized () { return ipc.parent({ act: 'isMaximized', id: this.#id }) }
+          isFullscreen () { return ipc.parent({ act: 'isFullscreen', id: this.#id }) }
+          isClosed () { return ipc.parent({ act: 'isClosed', id: this.#id }) }
+        }
+
+        class Self {
+          constructor (id) { this.id = id }
+          focus (options = null) { return ipc.focus({ id: this.id, options }) }
+          blur () { return ipc.blur({ id: this.id }) }
+          show () { return ipc.show({ id: this.id }) }
+          hide () { return ipc.hide({ id: this.id }) }
+          minimize () { return ipc.minimize({ id: this.id }) }
+          maximize () { return ipc.maximize({ id: this.id }) }
+          fullscreen () { return ipc.fullscreen({ id: this.id }) }
+          restore () { return ipc.restore({ id: this.id }) }
+          close () { return ipc.close({ id: this.id }) }
+          dimensions (options = null) { return ipc.dimensions({ id: this.id, options }) }
+          isVisible () { return ipc.isVisible({ id: this.id }) }
+          isMinimized () { return ipc.isMinimized({ id: this.id }) }
+          isMaximized () { return ipc.isMaximized({ id: this.id }) }
+          isFullscreen () { return ipc.isFullscreen({ id: this.id }) }
+        }
+
+        class GuiCtrl extends EventEmitter {
+          #listener = null
+
+          static get parent () {
+            Object.defineProperty(this, 'parent', {
+              value: new Parent(electron.ipcRenderer.sendSync('parentId'))
+            })
+            return this.parent
+          }
+
+          static get self () {
+            Object.defineProperty(this, 'self', {
+              value: new Self(electron.ipcRenderer.sendSync('id'))
+            })
+            return this.self
+          }
+
+          constructor (entry, at, options = at) {
+            super()
+            if (options === at) {
+              if (typeof at === 'string') options = { at }
+            }
+            if (!entry) throw new Error(`No path provided, cannot open ${this.constructor[kGuiCtrl]}`)
+            this.entry = entry
+            this.options = options
+            this.id = null
+          }
+
+          #rxtx () {
+            this.#listener = (e, ...args) => this.emit('message', ...args)
+            electron.ipcRenderer.on('send', this.#listener)
+          }
+
+          #unrxtx () {
+            if (this.#listener === null) return
+            electron.ipcRenderer.removeListener('send', this.#listener)
+            this.#listener = null
+          }
+
+          async open (opts) {
+            if (this.id === null) {
+              await new Promise(setImmediate) // needed for windows/views opening on app load
+              this.#rxtx()
+              this.id = await ipc.ctrl({
+                parentId: this.self.id,
+                type: this.constructor[kGuiCtrl],
+                entry: this.entry,
+                options: this.options,
+                state: this.state,
+                openOptions: opts
+              })
+              return true
+            }
+            return await ipc.open({ id: this.id })
+          }
+
+          async close () {
+            const result = await ipc.close({ id: this.id })
+            this.#unrxtx()
+            this.id = null
+            return result
+          }
+
+          show () { return ipc.show({ id: this.id }) }
+          hide () { return ipc.hide({ id: this.id }) }
+          focus (options = null) { return ipc.focus({ id: this.id, options }) }
+          blur () { return ipc.blur({ id: this.id }) }
+
+          dimensions (options = null) { return ipc.dimensions({ id: this.id, options }) }
+          minimize () {
+            if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be minimized')
+            return ipc.minimize({ id: this.id })
+          }
+
+          maximize () {
+            if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be maximized')
+            return ipc.maximize({ id: this.id })
+          }
+
+          fullscreen () {
+            if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be fullscreened')
+            return ipc.fullscreen({ id: this.id })
+          }
+
+          restore () { return ipc.restore({ id: this.id }) }
+
+          isVisible () { return ipc.isVisible({ id: this.id }) }
+
+          isMinimized () {
+            if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be minimized')
+            return ipc.isMinimized({ id: this.id })
+          }
+
+          isMaximized () {
+            if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be maximized')
+            return ipc.isMaximized({ id: this.id })
+          }
+
+          isFullscreen () {
+            if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be maximized')
+            return ipc.isFullscreen({ id: this.id })
+          }
+
+          isClosed () { return ipc.isClosed({ id: this.id }) }
+
+          send (...args) { return electron.ipcRenderer.send('send-to', this.id, ...args) }
+        }
+
+        class Window extends GuiCtrl {
+          static [kGuiCtrl] = 'window'
+        }
+
+        class View extends GuiCtrl { static [kGuiCtrl] = 'view' }
+
+        class PearElectron {
+          Window = Window
+          View = View
+          media = media
+          static DECAL = Symbol('decal')
+          warming () {
+            electron.ipcRenderer.send('warming')
+            const stream = new streamx.Readable()
+            electron.ipcRenderer.on('warming', (e, data) => { stream.push(data) })
+            return stream
+          }
+
+          constructor () {
+            if (state.isDecal) {
+              this[this.constructor.DECAL] = {
+                ipc,
+                'hypercore-id-encoding': require('hypercore-id-encoding'),
+                'pear-api/constants': require('pear-api/constants')
+              }
+            }
+          }
+        }
+
+        this[this.constructor.UI] = new PearElectron()
+      }
+
+      get media () {
+        console.warn('Pear.media is deprecated use require(\'pear-electron\').media')
+        return this[this.constructor.UI].media
+      }
+
+      get Window () {
+        console.warn('Pear.Window is deprecated use require(\'pear-electron\').Window')
+        return this[this.constructor.UI].Window
+      }
+
+      get View () {
+        console.warn('Pear.View is deprecated use require(\'pear-electron\').View')
+        return this[this.constructor.UI].View
+      }
+
+      exit = (code) => {
+        process.exitCode = code
+        electron.ipcRenderer.sendSync('exit', code)
+      }
+    }
+    this.api = new API(this.ipc, state, teardown)
+  }
+}
+
+class IPC {
+  getMediaAccessStatus (...args) { return electron.ipcRenderer.invoke('getMediaAccessStatus', ...args) }
+  askForMediaAccess (...args) { return electron.ipcRenderer.invoke('askForMediaAccess', ...args) }
+  desktopSources (...args) { return electron.ipcRenderer.invoke('desktopSources', ...args) }
+  chrome (...args) { return electron.ipcRenderer.invoke('chrome', ...args) }
+  ctrl (...args) { return electron.ipcRenderer.invoke('ctrl', ...args) }
+  parent (...args) { return electron.ipcRenderer.invoke('parent', ...args) }
+  open (...args) { return electron.ipcRenderer.invoke('open', ...args) }
+  close (...args) { return electron.ipcRenderer.invoke('close', ...args) }
+  show (...args) { return electron.ipcRenderer.invoke('show', ...args) }
+  hide (...args) { return electron.ipcRenderer.invoke('hide', ...args) }
+  minimize (...args) { return electron.ipcRenderer.invoke('minimize', ...args) }
+  maximize (...args) { return electron.ipcRenderer.invoke('maximize', ...args) }
+  setMaximizable (...args) { return electron.ipcRenderer.invoke('setMaximizable', ...args) }
+  setMinimizable (...args) { return electron.ipcRenderer.invoke('setMinimizable', ...args) }
+  fullscreen (...args) { return electron.ipcRenderer.invoke('fullscreen', ...args) }
+  restore (...args) { return electron.ipcRenderer.invoke('restore', ...args) }
+  focus (...args) { return electron.ipcRenderer.invoke('focus', ...args) }
+  blur (...args) { return electron.ipcRenderer.invoke('blur', ...args) }
+  dimensions (...args) { return electron.ipcRenderer.invoke('dimensions', ...args) }
+  isVisible (...args) { return electron.ipcRenderer.invoke('isVisible', ...args) }
+  isClosed (...args) { return electron.ipcRenderer.invoke('isClosed', ...args) }
+  isMinimized (...args) { return electron.ipcRenderer.invoke('isMinimized', ...args) }
+  isMaximized (...args) { return electron.ipcRenderer.invoke('isMaximized', ...args) }
+  isFullscreen (...args) { return electron.ipcRenderer.invoke('isFullscreen', ...args) }
+  setSize (...args) { return electron.ipcRenderer.invoke('setSize', ...args) }
+  permit (...args) { return electron.ipcRenderer.invoke('permit', ...args) }
+  unloading (...args) { return electron.ipcRenderer.invoke('unloading', ...args) }
+  completeUnload (...args) { return electron.ipcRenderer.invoke('completeUnload', ...args) }
+  attachMainView (...args) { return electron.ipcRenderer.invoke('attachMainView', ...args) }
+  detachMainView (...args) { return electron.ipcRenderer.invoke('detachMainView', ...args) }
+  afterViewLoaded (...args) { return electron.ipcRenderer.invoke('afterViewLoaded', ...args) }
+  setWindowButtonPosition (...args) { return electron.ipcRenderer.invoke('setWindowButtonPosition', ...args) }
+  setWindowButtonVisibility (...args) { return electron.ipcRenderer.invoke('setWindowButtonVisibility', ...args) }
+  async requestIdentity (...args) {
+    const publicKey = await electron.ipcRenderer.invoke('requestIdentity', ...args)
+    return Buffer.from(publicKey)
+  }
+
+  shareIdentity (...args) { return electron.ipcRenderer.invoke('shareIdentity', ...args) }
+  clearIdentity (...args) { return electron.ipcRenderer.invoke('clearIdentity', ...args) }
+  message (...args) { return electron.ipcRenderer.invoke('message', ...args) }
+  checkpoint (...args) { return electron.ipcRenderer.invoke('checkpoint', ...args) }
+  versions (...args) { return electron.ipcRenderer.invoke('versions', ...args) }
+  restart (...args) { return electron.ipcRenderer.invoke('restart', ...args) }
+
+  messages (pattern) {
+    electron.ipcRenderer.send('messages', pattern)
+    const bus = new Iambus()
+    electron.ipcRenderer.on('messages', (e, msg) => {
+      if (msg === null) bus.end()
+      else bus.pub(msg)
+    })
+    const stream = bus.sub(pattern)
+    return stream
+  }
+
+  warming () {
+    electron.ipcRenderer.send('warming')
+    const stream = new streamx.Readable()
+    electron.ipcRenderer.on('warming', (e, data) => { stream.push(data) })
+    return stream
+  }
+
+  reports () {
+    electron.ipcRenderer.send('reports')
+    const stream = new streamx.Readable()
+    electron.ipcRenderer.on('reports', (e, data) => { stream.push(data) })
+    return stream
+  }
+
+  workerRun (link, args) {
+    const id = electron.ipcRenderer.sendSync('workerPipeId')
+    electron.ipcRenderer.send('workerRun', link, args)
+    const stream = new streamx.Duplex({
+      write (data, cb) {
+        electron.ipcRenderer.send('workerPipeWrite', id, data)
+        cb()
+      },
+      final (cb) {
+        electron.ipcRenderer.send('workerPipeEnd', id)
+        cb()
+      }
+    })
+    electron.ipcRenderer.on('workerPipeError', (e, stack) => {
+      stream.emit('error', new Error('Worker PipeError (from electron-main): ' + stack))
+    })
+    electron.ipcRenderer.on('workerPipeClose', () => { stream.destroy() })
+    electron.ipcRenderer.on('workerPipeEnd', () => { stream.end() })
+    stream.once('close', () => {
+      electron.ipcRenderer.send('workerPipeClose', id)
+    })
+
+    electron.ipcRenderer.on('workerPipeData', (e, data) => { stream.push(data) })
+    return stream
+  }
+
+  ref () {}
+  unref () {}
+}

package/index.js

@@ -0,0 +1,3 @@
+/** @typedef {import('pear-interface')} */ /* global Pear */
+'use strict'
+module.exports = Pear.constructor.UI ? Pear[Pear.constructor.UI] : require('./runtime')

package/lib/bootstrap.js

@@ -0,0 +1,155 @@
+'use strict'
+const { platform, arch, isWindows } = require('which-runtime')
+const path = require('path')
+const { command, flag, rest } = require('paparam')
+const Corestore = require('corestore')
+const Localdrive = require('localdrive')
+const Hyperdrive = require('hyperdrive')
+const Hyperswarm = require('hyperswarm')
+const goodbye = global.Pear?.teardown || require('graceful-goodbye')
+const byteSize = require('tiny-byte-size')
+const { decode } = require('hypercore-id-encoding')
+const Rache = require('rache')
+const speedometer = require('speedometer')
+const isTTY = global.Pear ? false : process.stdout.isTTY // TODO: support Pear
+const argv = global.Pear?.config.args || global.Bare?.argv || global.process.argv
+const parser = command('bootstrap',
+  flag('--archdump'),
+  flag('--dlruntime'),
+  flag('--external-corestore'),
+  rest('rest')
+)
+const cmd = parser.parse(argv.slice(2), { sync: true })
+
+const ARCHDUMP = cmd.flags.archdump === true
+const DLRUNTIME = cmd.flags.dlruntime === true
+const RUNTIMES_DRIVE_KEY = cmd.rest?.[0] || 'gd4n8itmfs6x7tzioj6jtxexiu4x4ijiu3grxdjwkbtkczw5dwho'
+const CORESTORE = `/tmp/pear-archdump/${RUNTIMES_DRIVE_KEY}`
+const ROOT = global.Pear ? path.join(new URL(global.Pear.config.applink).pathname, __dirname) : __dirname
+const ADDON_HOST = require.addon?.host || platform + '-' + arch
+const SWAP = path.join(ROOT, '..')
+const HOST = path.join(SWAP, 'by-arch', ADDON_HOST)
+
+module.exports = (all = true) => download(RUNTIMES_DRIVE_KEY, all)
+module.exports.ARCHDUMP = ARCHDUMP
+module.exports.DLRUNTIME = DLRUNTIME
+module.exports.HOST = HOST
+
+async function download (key, all = false) {
+  if (all) console.log('🍐 Fetching all runtimes from: \n   ' + key)
+  else console.log('🍐 [ localdev ] - no local runtime: fetching runtime')
+
+  const store = CORESTORE
+
+  const maxCacheSize = 65536
+  const globalCache = new Rache({ maxSize: maxCacheSize })
+
+  const corestore = new Corestore(store, { globalCache })
+  let runtimes = new Hyperdrive(corestore, decode(key))
+
+  const swarm = new Hyperswarm()
+  goodbye(() => swarm.destroy())
+
+  swarm.on('connection', (socket) => { runtimes.corestore.replicate(socket) })
+
+  await runtimes.ready()
+
+  swarm.join(runtimes.discoveryKey, { server: false, client: true })
+  const done = runtimes.corestore.findingPeers()
+  swarm.flush().then(done, done)
+
+  await runtimes.core.update() // make sure we have latest version
+
+  runtimes = runtimes.checkout(runtimes.version)
+  goodbye(() => runtimes.close())
+
+  console.log(`\n  Extracting platform runtime${all ? 's' : ''} to disk`)
+
+  const runtime = runtimes.mirror(new Localdrive(SWAP), {
+    prefix: '/by-arch' + (all ? '' : '/' + ADDON_HOST)
+  })
+
+  const monitor = monitorDrive(runtimes)
+  goodbye(() => monitor.stop())
+
+  for await (const { op, key, bytesAdded } of runtime) {
+    if (isTTY) monitor.clear()
+    if (op === 'add') {
+      console.log('\x1B[32m+\x1B[39m ' + key + ' [' + byteSize(bytesAdded) + ']')
+    } else if (op === 'change') {
+      console.log('\x1B[33m~\x1B[39m ' + key + ' [' + byteSize(bytesAdded) + ']')
+    } else if (op === 'remove') {
+      console.log('\x1B[31m-\x1B[39m ' + key + ' [' + byteSize(bytesAdded) + ']')
+    }
+  }
+
+  monitor.stop()
+
+  console.log('\x1B[2K\x1B[200D  Runtime extraction complete\x1b[K\n')
+
+  await runtimes.close()
+  await swarm.destroy()
+  await corestore.close()
+
+  const tick = isWindows ? '^' : '✔'
+
+  if (all) console.log('\x1B[32m' + tick + '\x1B[39m Download complete\n')
+  else console.log('\x1B[32m' + tick + '\x1B[39m Download complete, initalizing...\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n')
+}
+
+/**
+ * @param {Hyperdrive} drive
+ */
+function monitorDrive (drive) {
+  if (!isTTY) {
+    return {
+      clear: () => null,
+      stop: () => null
+    }
+  }
+
+  const downloadSpeedometer = speedometer()
+  const uploadSpeedometer = speedometer()
+  let peers = 0
+  let downloadedBytes = 0
+  let uploadedBytes = 0
+
+  drive.getBlobs().then(blobs => {
+    blobs.core.on('download', (_index, bytes) => {
+      downloadedBytes += bytes
+      downloadSpeedometer(bytes)
+    })
+    blobs.core.on('upload', (_index, bytes) => {
+      uploadedBytes += bytes
+      uploadSpeedometer(bytes)
+    })
+    blobs.core.on('peer-add', () => {
+      peers = blobs.core.peers.length
+    })
+    blobs.core.on('peer-remove', () => {
+      peers = blobs.core.peers.length
+    })
+  }).catch(() => {
+    // ignore
+  })
+
+  const clear = () => {
+    process.stdout.clearLine()
+    process.stdout.cursorTo(0)
+  }
+
+  const interval = setInterval(() => {
+    clear()
+    process.stdout.write(`[⬇ ${byteSize(downloadedBytes)} - ${byteSize(downloadSpeedometer())}/s - ${peers} peers] [⬆ ${byteSize(uploadedBytes)} - ${byteSize(uploadSpeedometer())}/s - ${peers} peers]`)
+  }, 500)
+
+  const stop = () => {
+    clearInterval(interval)
+    clear()
+  }
+
+  return {
+    clear,
+    stop
+  }
+}

package/lib/bundle.js

@@ -0,0 +1,33 @@
+'use strict'
+const Bundle = require('bare-bundle')
+const Localdrive = require('localdrive')
+const DriveBundler = require('drive-bundler')
+const path = require('path')
+const fs = require('fs')
+const dirname = global.Pear?.config.applink ? new URL(global.Pear.config.applink + '/').pathname : path.join(__dirname, '/..')
+async function bundle () {
+  const drive = new Localdrive(dirname)
+  const b = new Bundle()
+
+  const cache = {}
+  const res = {}
+
+  const { entrypoint, resolutions, sources } = await DriveBundler.bundle(drive, { cache, cwd: dirname, entrypoint: '/boot.js', absoluteFiles: false })
+
+  for (const [key, map] of Object.entries(resolutions)) {
+    res[key] = map
+  }
+
+  for (const [key, source] of Object.entries(sources)) {
+    cache[key] = true
+    b.write(key, source)
+  }
+
+  b.main = entrypoint
+  b.resolutions = res
+
+  await fs.promises.writeFile(dirname + 'boot.bundle', b.toBuffer())
+  console.log('boot.bundle generated')
+}
+
+module.exports = bundle

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "pear-electron",
+  "version": "0.0.1",
+  "description": "Pear User-Interface Library for Electron",
+  "main": "index.js",
+  "bin": "bin.js",
+  "scripts": {
+    "archdump": "node scripts/bootstrap.js --archdump",
+    "bootstrap": "node scripts/bootstrap.js",
+    "decal": "node scripts/decal.js",
+    "bundle": "node scripts/bundle.js",
+    "generate": "npm run decal && npm run bundle",
+    "prestage": "npm run archdump && npm run generate"
+  },
+  "files": [
+    "bin.js",
+    "scripts/",
+    "lib/",
+    "boot.js",
+    "decal.html",
+    "electron-main.js",
+    "fonts.css",
+    "gui/",
+    "index.js",
+    "preload.js",
+    "runtime.js"
+  ],
+  "pear": {
+    "runtimes": "pear://0.2356.pqbzjhqyonxprx8hghxexnmctw75mr91ewqw5dxe1zmntfyaddqy",
+    "name": "pear-electron",
+    "stage": {
+      "ignore": [
+        ".git",
+        ".gitignore",
+        ".github",
+        ".DS_Store",
+        ".vscode",
+        ".npmrc",
+        "scripts",
+        "package-lock.json",
+        "node_modules",
+        "node_modules",
+        "gui",
+        "boot.js",
+        "decal.html",
+        "electron-main.js",
+        "fonts.css",
+        "index.js",
+        "preload.js",
+        "README.md",
+        "runtime.js"
+      ]
+    }
+  },
+  "keywords": [
+    "pear",
+    "runtime",
+    "electron",
+    "Pear Runtime",
+    "peer-to-peer",
+    "user-interface",
+    "UI",
+    "interface"
+  ],
+  "author": "Holepunch",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "bare-env": "^3.0.0",
+    "bare-fs": "^4.0.1",
+    "bare-os": "^3.3.0",
+    "bare-path": "^3.0.0",
+    "bare-subprocess": "^4.0.3",
+    "bare-tty": "^4.0.2",
+    "corestore": "^6.18.4",
+    "fs": "npm:bare-node-fs@^1.0.2",
+    "hypercore-id-encoding": "^1.3.0",
+    "hyperdrive": "^11.13.3",
+    "hyperswarm": "^4.8.4",
+    "iambus": "^1.0.3",
+    "localdrive": "^1.12.1",
+    "paparam": "^1.6.1",
+    "path": "npm:bare-node-path@^1.0.1",
+    "pear-api": "^0.0.17",
+    "pear-interface": "^1.0.3",
+    "pear-ipc": "^3.0.3",
+    "pear-link": "^2.0.6",
+    "pear-updater-bootstrap": "github:holepunchto/pear-updater-bootstrap#corestore-option",
+    "rache": "^1.0.0",
+    "safety-catch": "^1.0.2",
+    "script-linker": "^2.5.3",
+    "streamx": "^2.20.2",
+    "tiny-byte-size": "^1.1.0",
+    "url-file-url": "^1.0.4",
+    "which-runtime": "^1.2.1"
+  },
+  "devDependencies": {
+    "@fontsource/open-sans": "^5.1.0",
+    "graceful-goodbye": "^1.3.2",
+    "redhat-overpass-font": "^1.0.0"
+  }
+}