Holesail Service Daemon + Bin Client

packages/bare-os-seeder/kernel/bin/baretop

@@ -247,6 +247,7 @@ function bareEditCsiToEvent(seq) {
     }
     return { type: 'unknown' }
   }
+  if (last === 'Z') return { type: 'nav', key: 'stab' }
   if (last === 'A' || last === 'B' || last === 'C' || last === 'D') {
     const map = { A: 'up', B: 'down', C: 'right', D: 'left' }
     return { type: 'nav', key: map[last] }
@@ -3684,7 +3685,9 @@ function bareTopTryConsumeMouse(q) {
  *   keyQuit?: string,
  *   keyRefresh?: string,
  *   tab?: number,
- *   overviewJumpPick?: boolean
+ *   overviewJumpPick?: boolean,
+ *   tabCpuIdx?: number,
+ *   tabMemIdx?: number
  * }} o
  */
 function bareTopDrainKeys(q, max, o) {
@@ -3733,11 +3736,14 @@ function bareTopDrainKeys(q, max, o) {
       return { type: 'filter_bs' }
     if (ev.type === 'key' && ev.ch === '\n')
       return o.inFilter ? { type: 'filter_enter' } : { type: 'enter' }
+    if (ev.type === 'key' && ev.ch === '\t')
+      return o.inFilter ? { type: 'filter_char', ch: '\t' } : { type: 'tab_next' }
     if (ev.type === 'nav') {
       if (o.helpPaging) {
         if (ev.key === 'pageup') return { type: 'help_page', dir: -1 }
         if (ev.key === 'pagedown') return { type: 'help_page', dir: 1 }
       }
+      if (ev.key === 'stab' && !o.inFilter) return { type: 'tab_prev' }
       if (ev.key === 'pageup') return { type: 'scroll', dir: -1, amt: 5 }
       if (ev.key === 'pagedown') return { type: 'scroll', dir: 1, amt: 5 }
       if (ev.key === 'home') return { type: 'scroll', dir: 'home' }
@@ -3798,6 +3804,16 @@ function bareTopDrainKeys(q, max, o) {
         !o.inFilter
       )
         return { type: 'overview_jump_arm' }
+      {
+        const tCpu =
+          typeof o.tabCpuIdx === 'number' ? o.tabCpuIdx : -1
+        const tMem =
+          typeof o.tabMemIdx === 'number' ? o.tabMemIdx : -1
+        if (!o.inFilter && ch === 'C' && tCpu >= 0)
+          return { type: 'tab', n: tCpu }
+        if (!o.inFilter && ch === 'M' && tMem >= 0)
+          return { type: 'tab', n: tMem }
+      }
       if (ch >= '1' && ch <= '9') return { type: 'tab', n: ch.charCodeAt(0) - 0x31 }
       if (ch === '0') return { type: 'tab', n: -1 }
       if (ch.length === 1 && ch >= ' ' && ch.charCodeAt(0) > 32)
@@ -5025,8 +5041,9 @@ async function bareOsRunBareTopTui(ctx) {
             '\r\n' +
             '  arrows  Move list / process selection (Up/Down; PgUp/Dn page)\r\n' +
             '  g G     Jump list top / bottom\r\n' +
+            '  Tab     Next tab   Shift+Tab  Prev tab\r\n' +
             '  [ ]     Prev / next tab\r\n' +
-            '  1-9     Jump first tabs; 0 = last tab (disk)\r\n' +
+            '  1-9     Jump tabs 1–9; 0 = disk;  C / M  Cpu / Mem tabs\r\n' +
             '  Esc     Close help or cancel filter\r\n' +
             '\r\n' +
             dim +
@@ -5034,7 +5051,7 @@ async function bareOsRunBareTopTui(ctx) {
             rst +
             '\r\n' +
             '  1 overview  2 processes  3 initd  4 network  5 features  6 diagnostics\r\n' +
-            '  7 operator  8 pear  9 catalog  [ ] host  C/M/D cpu mem disk  0 disk\r\n' +
+            '  7 operator  8 pear  9 catalog  H host  C M cpu mem  0 disk\r\n' +
             '\r\n' +
             dim +
             'Actions (1/2)' +
@@ -5404,6 +5421,8 @@ async function bareOsRunBareTopTui(ctx) {
             else lab = nm.charAt(0).toUpperCase()
           } else if (ti === NTABS - 1) lab = '0:' + nm.slice(0, 2)
           else if (ti === T_HOST) lab = 'H:' + nm.slice(0, 2)
+          else if (ti === T_CPU) lab = 'C:' + nm.slice(0, 2)
+          else if (ti === T_MEM) lab = 'M:' + nm.slice(0, 2)
           else lab = String(ti + 1) + ':' + nm.slice(0, 3)
           const on = ti === tab
           stripParts.push(
@@ -6559,9 +6578,10 @@ async function bareOsRunBareTopTui(ctx) {
       const footProc =
         '^v sel  F6/S sort  V tree  Enter detail  k/F9  / filter  gG  [ ] tab'
       const footOverview =
-        'PgUp/Dn scroll detail  / section filter  h help  [ ] tab  e export'
+        'PgUp/Dn scroll detail  / filter  h help  Tab/[ ] tab  C M  e export'
       const footInitd = 'PgUp/Dn scroll  / filter units  h help'
-      const footDefault = 'PgUp/Dn scroll  [ ] tabs  h help  e export  f full'
+      const footDefault =
+        'PgUp/Dn scroll  Tab/[ ] tabs  C M cpu/mem  h help  e export  f full'
       let footBase = quietFooter
         ? tab === 0
           ? 'ov'
@@ -6977,6 +6997,8 @@ async function bareOsRunBareTopTui(ctx) {
         vi: viKeys,
         inFilter: false,
         tab,
+        tabCpuIdx: TAB_NAMES.indexOf('cpu'),
+        tabMemIdx: TAB_NAMES.indexOf('mem'),
         mouseEnabled:
           mouseOn &&
           !helpMode &&
@@ -7044,9 +7066,15 @@ async function bareOsRunBareTopTui(ctx) {
             }
           }
           if ((mx.btn === 64 || mx.btn === 65) && !mx.release) {
-            const sr = scrollRows[tab] || 0
             const dir = mx.btn === 64 ? -1 : 1
-            scrollRows[tab] = Math.max(0, sr + dir * 3)
+            if (tab === TAB_PROC && !procDetailPid) {
+              const pl = currentProcRows()
+              const maxI = Math.max(0, pl.length - 1)
+              procCursor = Math.max(0, Math.min(maxI, procCursor + dir * 3))
+            } else {
+              const sr = scrollRows[tab] || 0
+              scrollRows[tab] = Math.max(0, sr + dir * 3)
+            }
             draw()
           }
           continue
@@ -7583,7 +7611,7 @@ async function run(ctx, argv) {
         'and optional ctx fast paths. Requires a TTY.\n' +
         '\n' +
         'Tabs (default): 1 overview  2 processes  3 initd  4 network  5 features  6 diagnostics\n' +
-        '  7 operator  8 pear  9 catalog  H:host  C/M/D cpu mem disk  0 last tab (disk)\n' +
+        '  7 operator  8 pear  9 catalog  H host  C cpu  M mem  0 disk  Tab next tab  Shift+Tab prev\n' +
         '  BARE_TOP_TAB_MERGE=netop drops the operator tab (operator lines fold into network).\n' +
         '  F1 help  F2 setup  F3/F4 proc row  F5 refresh  F7 renice  F9 signal  F10 quit\n' +
         '\n' +
@@ -7638,7 +7666,7 @@ async function run(ctx, argv) {
         '  NO_COLOR / COLORTERM       See https://no-color.org/ ; truecolor gated on COLORTERM\n' +
         '\n' +
         'Keys: q F10 quit  r F5 refresh  R sort +/-  sp pause  . step  d delta  e export  E tab export\n' +
-        '  f fullscreen  F follow pid  t clock  [ ] tab prev/next  h ? F1 help  F2 setup\n' +
+        '  f fullscreen  F follow pid  t clock  Tab/[ ] tab next/prev  h ? F1 help  F2 setup\n' +
         '  / filter (overview, initd, processes, features)  V tree  z collapse  a action  k F9 signal\n' +
         '  n F7 renice  c copy pid  = tag  % tagged-only  i o e detail subviews\n' +
         "  ' then 1-9,0  Jump to Nth overview section (on overview tab)\n" +

packages/bare-os-seeder/kernel/bin/btop

@@ -247,6 +247,7 @@ function bareEditCsiToEvent(seq) {
     }
     return { type: 'unknown' }
   }
+  if (last === 'Z') return { type: 'nav', key: 'stab' }
   if (last === 'A' || last === 'B' || last === 'C' || last === 'D') {
     const map = { A: 'up', B: 'down', C: 'right', D: 'left' }
     return { type: 'nav', key: map[last] }
@@ -3684,7 +3685,9 @@ function bareTopTryConsumeMouse(q) {
  *   keyQuit?: string,
  *   keyRefresh?: string,
  *   tab?: number,
- *   overviewJumpPick?: boolean
+ *   overviewJumpPick?: boolean,
+ *   tabCpuIdx?: number,
+ *   tabMemIdx?: number
  * }} o
  */
 function bareTopDrainKeys(q, max, o) {
@@ -3733,11 +3736,14 @@ function bareTopDrainKeys(q, max, o) {
       return { type: 'filter_bs' }
     if (ev.type === 'key' && ev.ch === '\n')
       return o.inFilter ? { type: 'filter_enter' } : { type: 'enter' }
+    if (ev.type === 'key' && ev.ch === '\t')
+      return o.inFilter ? { type: 'filter_char', ch: '\t' } : { type: 'tab_next' }
     if (ev.type === 'nav') {
       if (o.helpPaging) {
         if (ev.key === 'pageup') return { type: 'help_page', dir: -1 }
         if (ev.key === 'pagedown') return { type: 'help_page', dir: 1 }
       }
+      if (ev.key === 'stab' && !o.inFilter) return { type: 'tab_prev' }
       if (ev.key === 'pageup') return { type: 'scroll', dir: -1, amt: 5 }
       if (ev.key === 'pagedown') return { type: 'scroll', dir: 1, amt: 5 }
       if (ev.key === 'home') return { type: 'scroll', dir: 'home' }
@@ -3798,6 +3804,16 @@ function bareTopDrainKeys(q, max, o) {
         !o.inFilter
       )
         return { type: 'overview_jump_arm' }
+      {
+        const tCpu =
+          typeof o.tabCpuIdx === 'number' ? o.tabCpuIdx : -1
+        const tMem =
+          typeof o.tabMemIdx === 'number' ? o.tabMemIdx : -1
+        if (!o.inFilter && ch === 'C' && tCpu >= 0)
+          return { type: 'tab', n: tCpu }
+        if (!o.inFilter && ch === 'M' && tMem >= 0)
+          return { type: 'tab', n: tMem }
+      }
       if (ch >= '1' && ch <= '9') return { type: 'tab', n: ch.charCodeAt(0) - 0x31 }
       if (ch === '0') return { type: 'tab', n: -1 }
       if (ch.length === 1 && ch >= ' ' && ch.charCodeAt(0) > 32)
@@ -5025,8 +5041,9 @@ async function bareOsRunBareTopTui(ctx) {
             '\r\n' +
             '  arrows  Move list / process selection (Up/Down; PgUp/Dn page)\r\n' +
             '  g G     Jump list top / bottom\r\n' +
+            '  Tab     Next tab   Shift+Tab  Prev tab\r\n' +
             '  [ ]     Prev / next tab\r\n' +
-            '  1-9     Jump first tabs; 0 = last tab (disk)\r\n' +
+            '  1-9     Jump tabs 1–9; 0 = disk;  C / M  Cpu / Mem tabs\r\n' +
             '  Esc     Close help or cancel filter\r\n' +
             '\r\n' +
             dim +
@@ -5034,7 +5051,7 @@ async function bareOsRunBareTopTui(ctx) {
             rst +
             '\r\n' +
             '  1 overview  2 processes  3 initd  4 network  5 features  6 diagnostics\r\n' +
-            '  7 operator  8 pear  9 catalog  [ ] host  C/M/D cpu mem disk  0 disk\r\n' +
+            '  7 operator  8 pear  9 catalog  H host  C M cpu mem  0 disk\r\n' +
             '\r\n' +
             dim +
             'Actions (1/2)' +
@@ -5404,6 +5421,8 @@ async function bareOsRunBareTopTui(ctx) {
             else lab = nm.charAt(0).toUpperCase()
           } else if (ti === NTABS - 1) lab = '0:' + nm.slice(0, 2)
           else if (ti === T_HOST) lab = 'H:' + nm.slice(0, 2)
+          else if (ti === T_CPU) lab = 'C:' + nm.slice(0, 2)
+          else if (ti === T_MEM) lab = 'M:' + nm.slice(0, 2)
           else lab = String(ti + 1) + ':' + nm.slice(0, 3)
           const on = ti === tab
           stripParts.push(
@@ -6559,9 +6578,10 @@ async function bareOsRunBareTopTui(ctx) {
       const footProc =
         '^v sel  F6/S sort  V tree  Enter detail  k/F9  / filter  gG  [ ] tab'
       const footOverview =
-        'PgUp/Dn scroll detail  / section filter  h help  [ ] tab  e export'
+        'PgUp/Dn scroll detail  / filter  h help  Tab/[ ] tab  C M  e export'
       const footInitd = 'PgUp/Dn scroll  / filter units  h help'
-      const footDefault = 'PgUp/Dn scroll  [ ] tabs  h help  e export  f full'
+      const footDefault =
+        'PgUp/Dn scroll  Tab/[ ] tabs  C M cpu/mem  h help  e export  f full'
       let footBase = quietFooter
         ? tab === 0
           ? 'ov'
@@ -6977,6 +6997,8 @@ async function bareOsRunBareTopTui(ctx) {
         vi: viKeys,
         inFilter: false,
         tab,
+        tabCpuIdx: TAB_NAMES.indexOf('cpu'),
+        tabMemIdx: TAB_NAMES.indexOf('mem'),
         mouseEnabled:
           mouseOn &&
           !helpMode &&
@@ -7044,9 +7066,15 @@ async function bareOsRunBareTopTui(ctx) {
             }
           }
           if ((mx.btn === 64 || mx.btn === 65) && !mx.release) {
-            const sr = scrollRows[tab] || 0
             const dir = mx.btn === 64 ? -1 : 1
-            scrollRows[tab] = Math.max(0, sr + dir * 3)
+            if (tab === TAB_PROC && !procDetailPid) {
+              const pl = currentProcRows()
+              const maxI = Math.max(0, pl.length - 1)
+              procCursor = Math.max(0, Math.min(maxI, procCursor + dir * 3))
+            } else {
+              const sr = scrollRows[tab] || 0
+              scrollRows[tab] = Math.max(0, sr + dir * 3)
+            }
             draw()
           }
           continue
@@ -7583,7 +7611,7 @@ async function run(ctx, argv) {
         'and optional ctx fast paths. Requires a TTY.\n' +
         '\n' +
         'Tabs (default): 1 overview  2 processes  3 initd  4 network  5 features  6 diagnostics\n' +
-        '  7 operator  8 pear  9 catalog  H:host  C/M/D cpu mem disk  0 last tab (disk)\n' +
+        '  7 operator  8 pear  9 catalog  H host  C cpu  M mem  0 disk  Tab next tab  Shift+Tab prev\n' +
         '  BARE_TOP_TAB_MERGE=netop drops the operator tab (operator lines fold into network).\n' +
         '  F1 help  F2 setup  F3/F4 proc row  F5 refresh  F7 renice  F9 signal  F10 quit\n' +
         '\n' +
@@ -7638,7 +7666,7 @@ async function run(ctx, argv) {
         '  NO_COLOR / COLORTERM       See https://no-color.org/ ; truecolor gated on COLORTERM\n' +
         '\n' +
         'Keys: q F10 quit  r F5 refresh  R sort +/-  sp pause  . step  d delta  e export  E tab export\n' +
-        '  f fullscreen  F follow pid  t clock  [ ] tab prev/next  h ? F1 help  F2 setup\n' +
+        '  f fullscreen  F follow pid  t clock  Tab/[ ] tab next/prev  h ? F1 help  F2 setup\n' +
         '  / filter (overview, initd, processes, features)  V tree  z collapse  a action  k F9 signal\n' +
         '  n F7 renice  c copy pid  = tag  % tagged-only  i o e detail subviews\n' +
         "  ' then 1-9,0  Jump to Nth overview section (on overview tab)\n" +

packages/bare-os-seeder/kernel/bin/edit

@@ -770,6 +770,7 @@ function bareEditCsiToEvent(seq) {
     }
     return { type: 'unknown' }
   }
+  if (last === 'Z') return { type: 'nav', key: 'stab' }
   if (last === 'A' || last === 'B' || last === 'C' || last === 'D') {
     const map = { A: 'up', B: 'down', C: 'right', D: 'left' }
     return { type: 'nav', key: map[last] }

packages/bare-os-seeder/kernel/bin/help

@@ -87,7 +87,7 @@ function bareOsEmitRaw(ctx, chunk) {
   return false
 }
 
-var BARE_OS_HELP_BIN_SPACED = "arch awk baretop base32 base64 basename basenc btop bundlebee cat chgrp chmod chown cksum clear cmp comm cp crontab curl cut date dd df diff dir dircolors dirname du echo edit env exit expand expr factor false find fmt fold getconf getfacl git git-pear grep groups hdms head help hostid hostname hrpc iconv id install join journalctl jq kernel-boot-diff kernel-doctor kernel-explain kernel-fsck kernel-home-snapshot kernel-manifest-validate kernel-preflight kernel-triage kill link ln logger login logname logout ls man md5sum mkdir mkfifo mktemp mount mv nano nice nl nohup nproc numfmt od oidc-publish openssl openssl paste patch pathcap-verify pathchk pear-runtime-matrix pkg-swarm-index pr printenv printf procstat ps pwd readlink realpath rev rm rmdir savevault sed seq setfacl sh sha1sum sha256sum sha512sum shuf sidecar sleep sort split ssh-keygen ssh-keygen sshd sshd stat sum sync systemctl tac tail tar tar tee test theme time timeout touch tr true truncate tsort tty ulimit umount uname unexpand uniq unlink uptime users vdir wc wget which who whoami xargs xattr yes"
+var BARE_OS_HELP_BIN_SPACED = "arch awk baretop base32 base64 basename basenc btop bundlebee cat chgrp chmod chown cksum clear cmp comm cp crontab curl cut date dd df diff dir dircolors dirname du echo edit env exit expand expr factor false find fmt fold getconf getfacl git git-pear grep groups hdms head help holesail hostid hostname hrpc iconv id install join journalctl jq kernel-boot-diff kernel-doctor kernel-explain kernel-fsck kernel-home-snapshot kernel-manifest-validate kernel-preflight kernel-triage kill link ln logger login logname logout ls man md5sum mkdir mkfifo mktemp mount mv nano nice nl nohup nproc numfmt od oidc-publish openssl openssl paste patch pathcap-verify pathchk pear-runtime-matrix pkg-swarm-index pr printenv printf procstat ps pwd readlink realpath rev rm rmdir savevault sed seq setfacl sh sha1sum sha256sum sha512sum shuf sidecar sleep sort split ssh-keygen ssh-keygen sshd sshd stat sum sync systemctl tac tail tar tar tee test theme time timeout touch tr true truncate tsort tty ulimit umount uname unexpand uniq unlink uptime users vdir wc wget which who whoami xargs xattr yes"
 async function run(ctx, argv) {
   ctx.console.log(
     'Bare OS — default user: guest | shell builtins: alias, barerc, cd, command, export, exit, login, logout, readonly, type, umask, unalias, unset, : | /bin: ' +

packages/bare-os-seeder/kernel/bin/holesail

@@ -0,0 +1,100 @@
+/* BARE_OS_BIN_API 1.0.0 — bump when staged /bin script semantics change (see developer guide). */
+/** Shared helpers for drive-resident /bin scripts (prepended before each command). */
+function bareStdin(ctx) {
+  return typeof ctx.shellStdin === 'string' ? ctx.shellStdin : ''
+}
+
+/** @param {number} mode @param {'file' | 'directory' | 'symlink'} type */
+function bareFormatModeString(mode, type) {
+  const typeChar = type === 'directory' ? 'd' : type === 'symlink' ? 'l' : '-'
+  const perm = mode & 0o777
+  const r = (bit) => (perm & bit ? 'r' : '-')
+  const w = (bit) => (perm & bit ? 'w' : '-')
+  const x = (bit) => (perm & bit ? 'x' : '-')
+  return (
+    typeChar +
+    r(0o400) +
+    w(0o200) +
+    x(0o100) +
+    r(0o040) +
+    w(0o020) +
+    x(0o010) +
+    r(0o004) +
+    w(0o002) +
+    x(0o001)
+  )
+}
+
+/** @param {number} mtimeMs @param {number} [nowMs] */
+function bareFormatLsMtime(mtimeMs, nowMs) {
+  const now = nowMs != null ? nowMs : Date.now()
+  const d = new Date(mtimeMs)
+  const months = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec'
+  ]
+  const mon = months[d.getMonth()]
+  const day = String(d.getDate()).padStart(2, ' ')
+  const sixMo = 180 * 24 * 3600 * 1000
+  if (Math.abs(now - mtimeMs) > sixMo) {
+    const yr = String(d.getFullYear()).padStart(4, ' ')
+    return mon + ' ' + day + '  ' + yr
+  }
+  const hh = String(d.getHours()).padStart(2, '0')
+  const mm = String(d.getMinutes()).padStart(2, '0')
+  return mon + ' ' + day + ' ' + hh + ':' + mm
+}
+
+/** @param {number} size */
+function barePosixBlocks(size) {
+  return Math.ceil(Number(size) / 512) || 0
+}
+
+/**
+ * Raw stdout for NUL/binary when **`process.stdout.write`** is missing.
+ * If **`ctx.bareOsBinWrite(Uint8Array|string)`** is set (tests / host), use it.
+ * @param {Record<string, unknown>} ctx
+ * @param {string | Uint8Array} chunk
+ * @returns {boolean}
+ */
+function bareOsEmitRaw(ctx, chunk) {
+  if (typeof ctx.bareOsBinWrite === 'function') {
+    const b4 = ctx.b4a
+    const u8 =
+      typeof chunk === 'string'
+        ? b4 && typeof b4.from === 'function'
+          ? b4.from(chunk)
+          : new TextEncoder().encode(chunk)
+        : chunk
+    ctx.bareOsBinWrite(u8 instanceof Uint8Array ? u8 : new Uint8Array(u8))
+    return true
+  }
+  const w = globalThis.process?.stdout?.write
+  if (typeof w === 'function') {
+    w.call(globalThis.process.stdout, chunk)
+    return true
+  }
+  return false
+}
+
+/* BARE_OS_BIN_API 1.0.0 — delegates to booter holesail-cli when ctx exposes bareOsRunHolesailCli. */
+async function run(ctx, argv) {
+  if (typeof ctx.bareOsRunHolesailCli === 'function') {
+    await ctx.bareOsRunHolesailCli(argv)
+    return
+  }
+  ctx.console.error(
+    'holesail: ctx.bareOsRunHolesailCli missing — run under host booter / upgrade ctx API'
+  )
+  ctx.exitCode = 1
+}

packages/bare-os-seeder/kernel/bin/nano

@@ -770,6 +770,7 @@ function bareEditCsiToEvent(seq) {
     }
     return { type: 'unknown' }
   }
+  if (last === 'Z') return { type: 'nav', key: 'stab' }
   if (last === 'A' || last === 'B' || last === 'C' || last === 'D') {
     const map = { A: 'up', B: 'down', C: 'right', D: 'left' }
     return { type: 'nav', key: map[last] }

packages/bare-os-seeder/kernel/etc/bare-os/kernel.d/.README

@@ -0,0 +1,14 @@
+# Kernel boot snippets (trusted)
+
+Same execution rules as `../rc.d/.README`: only **digit-prefixed** filenames run, in
+lexicographic order, after `rc.local` in the stock kernel boot graph.
+
+## Holesail (bundled `ctx.bare.holesail`)
+
+Guest `/bin` and `/boot/init.js` scripts are **not** Node modules: use **`ctx.bare.holesail`**
+(the class from the drive bundle under `/lib/bare/bundles/holesail.js`), not `require('holesail')`.
+
+Booter-side operators use initd unit **`bare-holesail`** (on by default in managed mode; **`/bin/holesail`**
+for persisted tunnels), or the early booter path — see
+`handbook/04-the-booter-runtime.md` and env vars `BARE_OS_HOLESAIL_*`. Upstream **holesail** is
+**AGPL-3.0**.

packages/bare-os-seeder/kernel/etc/bare-os/posix_utilities.json

@@ -1,7 +1,7 @@
 {
   "schema": 2,
   "profileId": "bare-os-posix-like",
-  "generatedAt": "2026-04-09T02:26:36.652Z",
+  "generatedAt": "2026-04-09T23:26:09.246Z",
   "note": "Sparse POSIX Issue 7 coverage hints for /bin utilities. Omitted command names are not yet profiled here.",
   "commandIndex": [
     {
@@ -196,6 +196,10 @@
       "name": "help",
       "tier": "tier1_bin"
     },
+    {
+      "name": "holesail",
+      "tier": "tier1_bin"
+    },
     {
       "name": "hostid",
       "tier": "tier1_bin"

packages/bare-os-seeder/kernel/etc/bare-os/units/bare-holesail.unit.example

@@ -0,0 +1,16 @@
+# Example drop-in for bare-holesail (copy to ~/.config/bare-os/units/bare-holesail.unit).
+# Stock boot already enables managed bare-holesail (no env required). Use this file for ordering
+# or to document overrides. Disable: BARE_OS_HOLESAIL_INITD=0 or systemctl disable bare-holesail.
+#
+# Single tunnel (turn off managed first):
+#   BARE_OS_HOLESAIL_MANAGED=0
+#   BARE_OS_HOLESAIL_SERVER=1
+#   BARE_OS_HOLESAIL_SECURE=1
+#
+# Multi-tunnel (default; persisted state via /bin/holesail):
+#   # optional: BARE_OS_HOLESAIL_STATE=~/.holesail/state.json
+#
+# Optional ordering override:
+[Unit]
+After=kernel-logger
+# ConditionEnvironment=BARE_OS_HOLESAIL_INITD=1  # optional gate if you disable by default in a custom image

packages/bare-os-seeder/kernel/lib/bare/bare-module-manifest.json

@@ -1182,6 +1182,14 @@
       "optional": true,
       "nativeHint": true,
       "skipReason": "Optional Holepunch bare-*; may be native, platform-specific, or Bare-only"
+    },
+    {
+      "ctxKey": "holesail",
+      "package": "holesail",
+      "export": "default",
+      "bundle": true,
+      "optional": false,
+      "nativeHint": false
     }
   ]
 }

packages/bare-os-seeder/kernel/lib/bare/bundles/bareBluetoothApple.js

@@ -426,10 +426,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareChannel.js

@@ -342,10 +342,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareCrypto.js

@@ -1329,10 +1329,323 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors2 = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors2();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareFileLogger.js

@@ -3137,10 +3137,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareFormData.js

@@ -36,10 +36,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -2959,7 +3272,7 @@ var __bare_os_bundle_exports__ = (() => {
   });
 
   // ../../node_modules/bare-form-data/lib/errors.js
-  var require_errors = __commonJS({
+  var require_errors2 = __commonJS({
     "../../node_modules/bare-form-data/lib/errors.js"(exports, module) {
       module.exports = class FormDataError extends Error {
         constructor(msg, code, fn = FormDataError) {
@@ -2984,7 +3297,7 @@ var __bare_os_bundle_exports__ = (() => {
     "../../node_modules/bare-form-data/index.js"(exports, module) {
       var { ReadableStream } = require_web();
       var { isBuffer } = require_bare_buffer();
-      var errors = require_errors();
+      var errors = require_errors2();
       var FormData = class _FormData {
         constructor() {
           this._entries = [];

packages/bare-os-seeder/kernel/lib/bare/bundles/bareFs.js

@@ -1850,10 +1850,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareHttp1.js

@@ -36,10 +36,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -2431,7 +2744,7 @@ var __bare_os_bundle_exports__ = (() => {
   });
 
   // ../../node_modules/bare-http1/lib/errors.js
-  var require_errors = __commonJS({
+  var require_errors2 = __commonJS({
     "../../node_modules/bare-http1/lib/errors.js"(exports, module) {
       module.exports = class HTTPError extends Error {
         constructor(msg, fn = HTTPError, code = fn.name) {
@@ -2461,7 +2774,7 @@ var __bare_os_bundle_exports__ = (() => {
   var require_outgoing_message = __commonJS({
     "../../node_modules/bare-http1/lib/outgoing-message.js"(exports, module) {
       var { Writable } = require_bare_stream();
-      var errors = require_errors();
+      var errors = require_errors2();
       module.exports = class HTTPOutgoingMessage extends Writable {
         constructor(socket = null) {
           super();
@@ -2517,312 +2830,6 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-events/lib/errors.js
-  var require_errors2 = __commonJS({
-    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
-      module.exports = class EventEmitterError extends Error {
-        constructor(msg, code, fn = EventEmitterError, opts) {
-          super(`${code}: ${msg}`, opts);
-          this.code = code;
-          if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, fn);
-          }
-        }
-        get name() {
-          return "EventEmitterError";
-        }
-        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
-          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
-            cause
-          });
-        }
-        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
-          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
-            cause
-          });
-        }
-      };
-    }
-  });
-
-  // ../../node_modules/bare-events/index.js
-  var require_bare_events = __commonJS({
-    "../../node_modules/bare-events/index.js"(exports, module) {
-      var errors = require_errors2();
-      var EventListener = class {
-        constructor() {
-          this.list = [];
-          this.count = 0;
-        }
-        append(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.push([fn, once]);
-        }
-        prepend(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.unshift([fn, once]);
-        }
-        remove(ctx, name, fn) {
-          for (let i = 0, n = this.list.length; i < n; i++) {
-            const l = this.list[i];
-            if (l[0] === fn) {
-              this.list.splice(i, 1);
-              if (this.count === 1) delete ctx._events[name];
-              ctx.emit("removeListener", name, fn);
-              this.count--;
-              return;
-            }
-          }
-        }
-        removeAll(ctx, name) {
-          const list = [...this.list];
-          this.list = [];
-          if (this.count === list.length) delete ctx._events[name];
-          for (let i = list.length - 1; i >= 0; i--) {
-            ctx.emit("removeListener", name, list[i][0]);
-          }
-          this.count -= list.length;
-        }
-        emit(ctx, name, ...args) {
-          const list = [...this.list];
-          for (let i = 0, n = list.length; i < n; i++) {
-            const l = list[i];
-            if (l[1] === true) this.remove(ctx, name, l[0]);
-            Reflect.apply(l[0], ctx, args);
-          }
-          return list.length > 0;
-        }
-      };
-      function appendListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.append(ctx, name, fn, once);
-        return ctx;
-      }
-      function prependListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.prepend(ctx, name, fn, once);
-        return ctx;
-      }
-      function removeListener(ctx, name, fn) {
-        if (ctx._events === void 0) return ctx;
-        const e = ctx._events[name];
-        if (e !== void 0) e.remove(ctx, name, fn);
-        return ctx;
-      }
-      function throwUnhandledError(...args) {
-        let err;
-        if (args.length > 0) err = args[0];
-        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(err, exports.prototype.emit);
-        }
-        queueMicrotask(() => {
-          throw err;
-        });
-      }
-      module.exports = exports = class EventEmitter {
-        constructor() {
-          this._events = /* @__PURE__ */ Object.create(null);
-        }
-        addListener(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        addOnceListener(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        prependListener(name, fn) {
-          return prependListener(this, name, fn, false);
-        }
-        prependOnceListener(name, fn) {
-          return prependListener(this, name, fn, true);
-        }
-        removeListener(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        on(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        once(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        off(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        emit(name, ...args) {
-          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
-            throwUnhandledError(...args);
-          }
-          if (this._events === void 0) return false;
-          const e = this._events[name];
-          return e === void 0 ? false : e.emit(this, name, ...args);
-        }
-        listeners(name) {
-          if (this._events === void 0) return [];
-          const e = this._events[name];
-          return e === void 0 ? [] : [...e.list];
-        }
-        listenerCount(name) {
-          if (this._events === void 0) return 0;
-          const e = this._events[name];
-          return e === void 0 ? 0 : e.list.length;
-        }
-        getMaxListeners() {
-          return EventEmitter.defaultMaxListeners;
-        }
-        setMaxListeners(n) {
-        }
-        removeAllListeners(name) {
-          if (arguments.length === 0) {
-            for (const key of Reflect.ownKeys(this._events)) {
-              if (key === "removeListener") continue;
-              this.removeAllListeners(key);
-            }
-            this.removeAllListeners("removeListener");
-          } else {
-            const e = this._events[name];
-            if (e !== void 0) e.removeAll(this, name);
-          }
-          return this;
-        }
-      };
-      exports.EventEmitter = exports;
-      exports.errors = errors;
-      exports.defaultMaxListeners = 10;
-      exports.on = function on(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          throw errors.OPERATION_ABORTED(signal.reason);
-        }
-        let error = null;
-        let done = false;
-        const events = [];
-        const promises = [];
-        if (name !== "error") emitter.on("error", onerror);
-        if (signal) signal.addEventListener("abort", onabort);
-        emitter.on(name, onevent);
-        return {
-          next() {
-            if (events.length) {
-              return Promise.resolve({ value: events.shift(), done: false });
-            }
-            if (error) {
-              const err = error;
-              error = null;
-              return Promise.reject(err);
-            }
-            if (done) return onclose();
-            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
-          },
-          return() {
-            return onclose();
-          },
-          throw(err) {
-            return onerror(err);
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        function onevent(...args) {
-          if (promises.length) {
-            promises.shift().resolve({ value: args, done: false });
-          } else {
-            events.push(args);
-          }
-        }
-        function onerror(err) {
-          emitter.off(name, onevent).off("error", onerror);
-          if (promises.length) {
-            promises.shift().reject(err);
-          } else {
-            error = err;
-          }
-          return Promise.resolve({ done: true });
-        }
-        function onabort() {
-          signal.removeEventListener("abort", onabort);
-          onerror(errors.OPERATION_ABORTED(signal.reason));
-        }
-        function onclose() {
-          emitter.off(name, onevent);
-          if (name !== "error") emitter.off("error", onerror);
-          if (signal) signal.removeEventListener("abort", onabort);
-          done = true;
-          if (promises.length) promises.shift().resolve({ done: true });
-          return Promise.resolve({ done: true });
-        }
-      };
-      exports.once = function once(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
-        }
-        return new Promise((resolve, reject) => {
-          if (name !== "error") emitter.on("error", onerror);
-          if (signal) signal.addEventListener("abort", onabort);
-          emitter.once(name, onevent);
-          function onevent(...args) {
-            if (name !== "error") emitter.off("error", onerror);
-            if (signal) signal.removeEventListener("abort", onabort);
-            resolve(args);
-          }
-          function onerror(err) {
-            emitter.off(name, onevent);
-            if (name !== "error") emitter.off("error", onerror);
-            reject(err);
-          }
-          function onabort() {
-            signal.removeEventListener("abort", onabort);
-            onerror(errors.OPERATION_ABORTED(signal.reason));
-          }
-        });
-      };
-      exports.forward = function forward(from, to, names, opts = {}) {
-        if (typeof names === "string") names = [names];
-        const { emit = to.emit.bind(to) } = opts;
-        const listeners = names.map(
-          (name) => function onevent(...args) {
-            emit(name, ...args);
-          }
-        );
-        to.on("newListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.on(name, listeners[i]);
-          }
-        }).on("removeListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.off(name, listeners[i]);
-          }
-        });
-      };
-      exports.listenerCount = function listenerCount(emitter, name) {
-        return emitter.listenerCount(name);
-      };
-      exports.getMaxListeners = function getMaxListeners(emitter) {
-        if (typeof emitter.getMaxListeners === "function") {
-          return emitter.getMaxListeners();
-        }
-        return exports.defaultMaxListeners;
-      };
-      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
-        if (emitters.length === 0) exports.defaultMaxListeners = n;
-        else {
-          for (const emitter of emitters) {
-            if (typeof emitter.setMaxListeners === "function") {
-              emitter.setMaxListeners(n);
-            }
-          }
-        }
-      };
-    }
-  });
-
   // ../../node_modules/bare-dns/binding.js
   var require_binding = __commonJS({
     "../../node_modules/bare-dns/binding.js"(exports, module) {
@@ -4156,7 +4163,7 @@ var __bare_os_bundle_exports__ = (() => {
     "../../node_modules/bare-http1/lib/client-connection.js"(exports, module) {
       var HTTPParser = require_bare_http_parser();
       var HTTPIncomingMessage = require_incoming_message();
-      var errors = require_errors();
+      var errors = require_errors2();
       var {
         constants: { RESPONSE, DATA, END }
       } = HTTPParser;
@@ -4280,7 +4287,7 @@ var __bare_os_bundle_exports__ = (() => {
       var EventEmitter = require_bare_events();
       var tcp = require_bare_tcp();
       var HTTPClientConnection = require_client_connection();
-      var errors = require_errors();
+      var errors = require_errors2();
       var HTTPSocketSet = class {
         constructor() {
           this._sockets = /* @__PURE__ */ new Map();
@@ -4909,7 +4916,7 @@ var __bare_os_bundle_exports__ = (() => {
       exports.ClientRequest = require_client_request();
       exports.ClientConnection = require_client_connection();
       exports.constants = require_constants2();
-      exports.errors = require_errors();
+      exports.errors = require_errors2();
       exports.METHODS = Object.values(exports.constants.method);
       exports.STATUS_CODES = exports.constants.status;
       exports.createServer = function createServer(opts, onrequest) {

packages/bare-os-seeder/kernel/lib/bare/bundles/bareHttps.js

@@ -36,10 +36,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -2431,7 +2744,7 @@ var __bare_os_bundle_exports__ = (() => {
   });
 
   // ../../node_modules/bare-http1/lib/errors.js
-  var require_errors = __commonJS({
+  var require_errors2 = __commonJS({
     "../../node_modules/bare-http1/lib/errors.js"(exports, module) {
       module.exports = class HTTPError extends Error {
         constructor(msg, fn = HTTPError, code = fn.name) {
@@ -2461,7 +2774,7 @@ var __bare_os_bundle_exports__ = (() => {
   var require_outgoing_message = __commonJS({
     "../../node_modules/bare-http1/lib/outgoing-message.js"(exports, module) {
       var { Writable } = require_bare_stream();
-      var errors = require_errors();
+      var errors = require_errors2();
       module.exports = class HTTPOutgoingMessage extends Writable {
         constructor(socket = null) {
           super();
@@ -2517,312 +2830,6 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-events/lib/errors.js
-  var require_errors2 = __commonJS({
-    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
-      module.exports = class EventEmitterError extends Error {
-        constructor(msg, code, fn = EventEmitterError, opts) {
-          super(`${code}: ${msg}`, opts);
-          this.code = code;
-          if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, fn);
-          }
-        }
-        get name() {
-          return "EventEmitterError";
-        }
-        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
-          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
-            cause
-          });
-        }
-        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
-          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
-            cause
-          });
-        }
-      };
-    }
-  });
-
-  // ../../node_modules/bare-events/index.js
-  var require_bare_events = __commonJS({
-    "../../node_modules/bare-events/index.js"(exports, module) {
-      var errors = require_errors2();
-      var EventListener = class {
-        constructor() {
-          this.list = [];
-          this.count = 0;
-        }
-        append(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.push([fn, once]);
-        }
-        prepend(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.unshift([fn, once]);
-        }
-        remove(ctx, name, fn) {
-          for (let i = 0, n = this.list.length; i < n; i++) {
-            const l = this.list[i];
-            if (l[0] === fn) {
-              this.list.splice(i, 1);
-              if (this.count === 1) delete ctx._events[name];
-              ctx.emit("removeListener", name, fn);
-              this.count--;
-              return;
-            }
-          }
-        }
-        removeAll(ctx, name) {
-          const list = [...this.list];
-          this.list = [];
-          if (this.count === list.length) delete ctx._events[name];
-          for (let i = list.length - 1; i >= 0; i--) {
-            ctx.emit("removeListener", name, list[i][0]);
-          }
-          this.count -= list.length;
-        }
-        emit(ctx, name, ...args) {
-          const list = [...this.list];
-          for (let i = 0, n = list.length; i < n; i++) {
-            const l = list[i];
-            if (l[1] === true) this.remove(ctx, name, l[0]);
-            Reflect.apply(l[0], ctx, args);
-          }
-          return list.length > 0;
-        }
-      };
-      function appendListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.append(ctx, name, fn, once);
-        return ctx;
-      }
-      function prependListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.prepend(ctx, name, fn, once);
-        return ctx;
-      }
-      function removeListener(ctx, name, fn) {
-        if (ctx._events === void 0) return ctx;
-        const e = ctx._events[name];
-        if (e !== void 0) e.remove(ctx, name, fn);
-        return ctx;
-      }
-      function throwUnhandledError(...args) {
-        let err;
-        if (args.length > 0) err = args[0];
-        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(err, exports.prototype.emit);
-        }
-        queueMicrotask(() => {
-          throw err;
-        });
-      }
-      module.exports = exports = class EventEmitter {
-        constructor() {
-          this._events = /* @__PURE__ */ Object.create(null);
-        }
-        addListener(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        addOnceListener(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        prependListener(name, fn) {
-          return prependListener(this, name, fn, false);
-        }
-        prependOnceListener(name, fn) {
-          return prependListener(this, name, fn, true);
-        }
-        removeListener(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        on(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        once(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        off(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        emit(name, ...args) {
-          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
-            throwUnhandledError(...args);
-          }
-          if (this._events === void 0) return false;
-          const e = this._events[name];
-          return e === void 0 ? false : e.emit(this, name, ...args);
-        }
-        listeners(name) {
-          if (this._events === void 0) return [];
-          const e = this._events[name];
-          return e === void 0 ? [] : [...e.list];
-        }
-        listenerCount(name) {
-          if (this._events === void 0) return 0;
-          const e = this._events[name];
-          return e === void 0 ? 0 : e.list.length;
-        }
-        getMaxListeners() {
-          return EventEmitter.defaultMaxListeners;
-        }
-        setMaxListeners(n) {
-        }
-        removeAllListeners(name) {
-          if (arguments.length === 0) {
-            for (const key of Reflect.ownKeys(this._events)) {
-              if (key === "removeListener") continue;
-              this.removeAllListeners(key);
-            }
-            this.removeAllListeners("removeListener");
-          } else {
-            const e = this._events[name];
-            if (e !== void 0) e.removeAll(this, name);
-          }
-          return this;
-        }
-      };
-      exports.EventEmitter = exports;
-      exports.errors = errors;
-      exports.defaultMaxListeners = 10;
-      exports.on = function on(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          throw errors.OPERATION_ABORTED(signal.reason);
-        }
-        let error = null;
-        let done = false;
-        const events = [];
-        const promises = [];
-        if (name !== "error") emitter.on("error", onerror);
-        if (signal) signal.addEventListener("abort", onabort);
-        emitter.on(name, onevent);
-        return {
-          next() {
-            if (events.length) {
-              return Promise.resolve({ value: events.shift(), done: false });
-            }
-            if (error) {
-              const err = error;
-              error = null;
-              return Promise.reject(err);
-            }
-            if (done) return onclose();
-            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
-          },
-          return() {
-            return onclose();
-          },
-          throw(err) {
-            return onerror(err);
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        function onevent(...args) {
-          if (promises.length) {
-            promises.shift().resolve({ value: args, done: false });
-          } else {
-            events.push(args);
-          }
-        }
-        function onerror(err) {
-          emitter.off(name, onevent).off("error", onerror);
-          if (promises.length) {
-            promises.shift().reject(err);
-          } else {
-            error = err;
-          }
-          return Promise.resolve({ done: true });
-        }
-        function onabort() {
-          signal.removeEventListener("abort", onabort);
-          onerror(errors.OPERATION_ABORTED(signal.reason));
-        }
-        function onclose() {
-          emitter.off(name, onevent);
-          if (name !== "error") emitter.off("error", onerror);
-          if (signal) signal.removeEventListener("abort", onabort);
-          done = true;
-          if (promises.length) promises.shift().resolve({ done: true });
-          return Promise.resolve({ done: true });
-        }
-      };
-      exports.once = function once(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
-        }
-        return new Promise((resolve, reject) => {
-          if (name !== "error") emitter.on("error", onerror);
-          if (signal) signal.addEventListener("abort", onabort);
-          emitter.once(name, onevent);
-          function onevent(...args) {
-            if (name !== "error") emitter.off("error", onerror);
-            if (signal) signal.removeEventListener("abort", onabort);
-            resolve(args);
-          }
-          function onerror(err) {
-            emitter.off(name, onevent);
-            if (name !== "error") emitter.off("error", onerror);
-            reject(err);
-          }
-          function onabort() {
-            signal.removeEventListener("abort", onabort);
-            onerror(errors.OPERATION_ABORTED(signal.reason));
-          }
-        });
-      };
-      exports.forward = function forward(from, to, names, opts = {}) {
-        if (typeof names === "string") names = [names];
-        const { emit = to.emit.bind(to) } = opts;
-        const listeners = names.map(
-          (name) => function onevent(...args) {
-            emit(name, ...args);
-          }
-        );
-        to.on("newListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.on(name, listeners[i]);
-          }
-        }).on("removeListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.off(name, listeners[i]);
-          }
-        });
-      };
-      exports.listenerCount = function listenerCount(emitter, name) {
-        return emitter.listenerCount(name);
-      };
-      exports.getMaxListeners = function getMaxListeners(emitter) {
-        if (typeof emitter.getMaxListeners === "function") {
-          return emitter.getMaxListeners();
-        }
-        return exports.defaultMaxListeners;
-      };
-      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
-        if (emitters.length === 0) exports.defaultMaxListeners = n;
-        else {
-          for (const emitter of emitters) {
-            if (typeof emitter.setMaxListeners === "function") {
-              emitter.setMaxListeners(n);
-            }
-          }
-        }
-      };
-    }
-  });
-
   // ../../node_modules/bare-dns/binding.js
   var require_binding = __commonJS({
     "../../node_modules/bare-dns/binding.js"(exports, module) {
@@ -4156,7 +4163,7 @@ var __bare_os_bundle_exports__ = (() => {
     "../../node_modules/bare-http1/lib/client-connection.js"(exports, module) {
       var HTTPParser = require_bare_http_parser();
       var HTTPIncomingMessage = require_incoming_message();
-      var errors = require_errors();
+      var errors = require_errors2();
       var {
         constants: { RESPONSE, DATA, END }
       } = HTTPParser;
@@ -4280,7 +4287,7 @@ var __bare_os_bundle_exports__ = (() => {
       var EventEmitter = require_bare_events();
       var tcp = require_bare_tcp();
       var HTTPClientConnection = require_client_connection();
-      var errors = require_errors();
+      var errors = require_errors2();
       var HTTPSocketSet = class {
         constructor() {
           this._sockets = /* @__PURE__ */ new Map();
@@ -4909,7 +4916,7 @@ var __bare_os_bundle_exports__ = (() => {
       exports.ClientRequest = require_client_request();
       exports.ClientConnection = require_client_connection();
       exports.constants = require_constants2();
-      exports.errors = require_errors();
+      exports.errors = require_errors2();
       exports.METHODS = Object.values(exports.constants.method);
       exports.STATUS_CODES = exports.constants.status;
       exports.createServer = function createServer(opts, onrequest) {
@@ -5447,9 +5454,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/lib/constants.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js
   var require_constants5 = __commonJS({
-    "../../node_modules/bare-net/lib/constants.js"(exports, module) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js"(exports, module) {
       module.exports = {
         type: {
           TCP: 1,
@@ -5462,9 +5469,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/index.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js
   var require_bare_net = __commonJS({
-    "../../node_modules/bare-net/index.js"(exports) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js"(exports) {
       var EventEmitter = require_bare_events();
       var { Duplex } = require_bare_stream();
       var tcp = require_bare_tcp();

packages/bare-os-seeder/kernel/lib/bare/bundles/bareInspector.js

@@ -1883,10 +1883,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -6988,9 +6995,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/lib/constants.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js
   var require_constants8 = __commonJS({
-    "../../node_modules/bare-net/lib/constants.js"(exports, module) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js"(exports, module) {
       module.exports = {
         type: {
           TCP: 1,
@@ -7003,9 +7010,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/index.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js
   var require_bare_net = __commonJS({
-    "../../node_modules/bare-net/index.js"(exports) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js"(exports) {
       var EventEmitter = require_bare_events();
       var { Duplex } = require_bare_stream();
       var tcp = require_bare_tcp();

packages/bare-os-seeder/kernel/lib/bare/bundles/bareIpc.js

@@ -342,10 +342,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareMedia.js

@@ -4482,10 +4482,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -11594,9 +11601,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/lib/constants.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js
   var require_constants9 = __commonJS({
-    "../../node_modules/bare-net/lib/constants.js"(exports, module) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js"(exports, module) {
       module.exports = {
         type: {
           TCP: 1,
@@ -11609,9 +11616,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/index.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js
   var require_bare_net = __commonJS({
-    "../../node_modules/bare-net/index.js"(exports) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js"(exports) {
       var EventEmitter = require_bare_events();
       var { Duplex } = require_bare_stream();
       var tcp = require_bare_tcp();

packages/bare-os-seeder/kernel/lib/bare/bundles/bareNet.js

@@ -342,10 +342,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -3773,9 +3780,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/lib/constants.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js
   var require_constants3 = __commonJS({
-    "../../node_modules/bare-net/lib/constants.js"(exports, module) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js"(exports, module) {
       module.exports = {
         type: {
           TCP: 1,
@@ -3788,9 +3795,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/index.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js
   var require_bare_net = __commonJS({
-    "../../node_modules/bare-net/index.js"(exports) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js"(exports) {
       var EventEmitter = require_bare_events();
       var { Duplex } = require_bare_stream();
       var tcp = require_bare_tcp();

packages/bare-os-seeder/kernel/lib/bare/bundles/bareNodeRuntime.js

@@ -1715,10 +1715,323 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors2 = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors2();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -5497,7 +5810,7 @@ var __bare_os_bundle_exports__ = (() => {
   });
 
   // ../../node_modules/bare-encoding/lib/errors.js
-  var require_errors2 = __commonJS({
+  var require_errors3 = __commonJS({
     "../../node_modules/bare-encoding/lib/errors.js"(exports, module) {
       module.exports = class EncodingError extends Error {
         constructor(msg, code, fn = EncodingError) {
@@ -5522,7 +5835,7 @@ var __bare_os_bundle_exports__ = (() => {
     "../../node_modules/bare-encoding/index.js"(exports) {
       var UTF8Decoder = require_utf8_decoder2();
       var PassThroughDecoder = require_pass_through_decoder2();
-      var errors = require_errors2();
+      var errors = require_errors3();
       exports.TextEncoder = class TextEncoder {
         // https://encoding.spec.whatwg.org/#dom-textencoder-encoding
         get encoding() {
@@ -5681,7 +5994,7 @@ var __bare_os_bundle_exports__ = (() => {
   });
 
   // ../../node_modules/bare-http1/lib/errors.js
-  var require_errors3 = __commonJS({
+  var require_errors4 = __commonJS({
     "../../node_modules/bare-http1/lib/errors.js"(exports, module) {
       module.exports = class HTTPError extends Error {
         constructor(msg, fn = HTTPError, code = fn.name) {
@@ -5711,7 +6024,7 @@ var __bare_os_bundle_exports__ = (() => {
   var require_outgoing_message = __commonJS({
     "../../node_modules/bare-http1/lib/outgoing-message.js"(exports, module) {
       var { Writable } = require_bare_stream();
-      var errors = require_errors3();
+      var errors = require_errors4();
       module.exports = class HTTPOutgoingMessage extends Writable {
         constructor(socket = null) {
           super();
@@ -5767,312 +6080,6 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-events/lib/errors.js
-  var require_errors4 = __commonJS({
-    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
-      module.exports = class EventEmitterError extends Error {
-        constructor(msg, code, fn = EventEmitterError, opts) {
-          super(`${code}: ${msg}`, opts);
-          this.code = code;
-          if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, fn);
-          }
-        }
-        get name() {
-          return "EventEmitterError";
-        }
-        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
-          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
-            cause
-          });
-        }
-        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
-          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
-            cause
-          });
-        }
-      };
-    }
-  });
-
-  // ../../node_modules/bare-events/index.js
-  var require_bare_events = __commonJS({
-    "../../node_modules/bare-events/index.js"(exports, module) {
-      var errors = require_errors4();
-      var EventListener = class {
-        constructor() {
-          this.list = [];
-          this.count = 0;
-        }
-        append(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.push([fn, once]);
-        }
-        prepend(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.unshift([fn, once]);
-        }
-        remove(ctx, name, fn) {
-          for (let i = 0, n = this.list.length; i < n; i++) {
-            const l = this.list[i];
-            if (l[0] === fn) {
-              this.list.splice(i, 1);
-              if (this.count === 1) delete ctx._events[name];
-              ctx.emit("removeListener", name, fn);
-              this.count--;
-              return;
-            }
-          }
-        }
-        removeAll(ctx, name) {
-          const list = [...this.list];
-          this.list = [];
-          if (this.count === list.length) delete ctx._events[name];
-          for (let i = list.length - 1; i >= 0; i--) {
-            ctx.emit("removeListener", name, list[i][0]);
-          }
-          this.count -= list.length;
-        }
-        emit(ctx, name, ...args) {
-          const list = [...this.list];
-          for (let i = 0, n = list.length; i < n; i++) {
-            const l = list[i];
-            if (l[1] === true) this.remove(ctx, name, l[0]);
-            Reflect.apply(l[0], ctx, args);
-          }
-          return list.length > 0;
-        }
-      };
-      function appendListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.append(ctx, name, fn, once);
-        return ctx;
-      }
-      function prependListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.prepend(ctx, name, fn, once);
-        return ctx;
-      }
-      function removeListener(ctx, name, fn) {
-        if (ctx._events === void 0) return ctx;
-        const e = ctx._events[name];
-        if (e !== void 0) e.remove(ctx, name, fn);
-        return ctx;
-      }
-      function throwUnhandledError(...args) {
-        let err;
-        if (args.length > 0) err = args[0];
-        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(err, exports.prototype.emit);
-        }
-        queueMicrotask(() => {
-          throw err;
-        });
-      }
-      module.exports = exports = class EventEmitter {
-        constructor() {
-          this._events = /* @__PURE__ */ Object.create(null);
-        }
-        addListener(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        addOnceListener(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        prependListener(name, fn) {
-          return prependListener(this, name, fn, false);
-        }
-        prependOnceListener(name, fn) {
-          return prependListener(this, name, fn, true);
-        }
-        removeListener(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        on(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        once(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        off(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        emit(name, ...args) {
-          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
-            throwUnhandledError(...args);
-          }
-          if (this._events === void 0) return false;
-          const e = this._events[name];
-          return e === void 0 ? false : e.emit(this, name, ...args);
-        }
-        listeners(name) {
-          if (this._events === void 0) return [];
-          const e = this._events[name];
-          return e === void 0 ? [] : [...e.list];
-        }
-        listenerCount(name) {
-          if (this._events === void 0) return 0;
-          const e = this._events[name];
-          return e === void 0 ? 0 : e.list.length;
-        }
-        getMaxListeners() {
-          return EventEmitter.defaultMaxListeners;
-        }
-        setMaxListeners(n) {
-        }
-        removeAllListeners(name) {
-          if (arguments.length === 0) {
-            for (const key of Reflect.ownKeys(this._events)) {
-              if (key === "removeListener") continue;
-              this.removeAllListeners(key);
-            }
-            this.removeAllListeners("removeListener");
-          } else {
-            const e = this._events[name];
-            if (e !== void 0) e.removeAll(this, name);
-          }
-          return this;
-        }
-      };
-      exports.EventEmitter = exports;
-      exports.errors = errors;
-      exports.defaultMaxListeners = 10;
-      exports.on = function on(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          throw errors.OPERATION_ABORTED(signal.reason);
-        }
-        let error = null;
-        let done = false;
-        const events = [];
-        const promises = [];
-        if (name !== "error") emitter.on("error", onerror);
-        if (signal) signal.addEventListener("abort", onabort);
-        emitter.on(name, onevent);
-        return {
-          next() {
-            if (events.length) {
-              return Promise.resolve({ value: events.shift(), done: false });
-            }
-            if (error) {
-              const err = error;
-              error = null;
-              return Promise.reject(err);
-            }
-            if (done) return onclose();
-            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
-          },
-          return() {
-            return onclose();
-          },
-          throw(err) {
-            return onerror(err);
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        function onevent(...args) {
-          if (promises.length) {
-            promises.shift().resolve({ value: args, done: false });
-          } else {
-            events.push(args);
-          }
-        }
-        function onerror(err) {
-          emitter.off(name, onevent).off("error", onerror);
-          if (promises.length) {
-            promises.shift().reject(err);
-          } else {
-            error = err;
-          }
-          return Promise.resolve({ done: true });
-        }
-        function onabort() {
-          signal.removeEventListener("abort", onabort);
-          onerror(errors.OPERATION_ABORTED(signal.reason));
-        }
-        function onclose() {
-          emitter.off(name, onevent);
-          if (name !== "error") emitter.off("error", onerror);
-          if (signal) signal.removeEventListener("abort", onabort);
-          done = true;
-          if (promises.length) promises.shift().resolve({ done: true });
-          return Promise.resolve({ done: true });
-        }
-      };
-      exports.once = function once(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
-        }
-        return new Promise((resolve, reject) => {
-          if (name !== "error") emitter.on("error", onerror);
-          if (signal) signal.addEventListener("abort", onabort);
-          emitter.once(name, onevent);
-          function onevent(...args) {
-            if (name !== "error") emitter.off("error", onerror);
-            if (signal) signal.removeEventListener("abort", onabort);
-            resolve(args);
-          }
-          function onerror(err) {
-            emitter.off(name, onevent);
-            if (name !== "error") emitter.off("error", onerror);
-            reject(err);
-          }
-          function onabort() {
-            signal.removeEventListener("abort", onabort);
-            onerror(errors.OPERATION_ABORTED(signal.reason));
-          }
-        });
-      };
-      exports.forward = function forward(from, to, names, opts = {}) {
-        if (typeof names === "string") names = [names];
-        const { emit = to.emit.bind(to) } = opts;
-        const listeners = names.map(
-          (name) => function onevent(...args) {
-            emit(name, ...args);
-          }
-        );
-        to.on("newListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.on(name, listeners[i]);
-          }
-        }).on("removeListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.off(name, listeners[i]);
-          }
-        });
-      };
-      exports.listenerCount = function listenerCount(emitter, name) {
-        return emitter.listenerCount(name);
-      };
-      exports.getMaxListeners = function getMaxListeners(emitter) {
-        if (typeof emitter.getMaxListeners === "function") {
-          return emitter.getMaxListeners();
-        }
-        return exports.defaultMaxListeners;
-      };
-      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
-        if (emitters.length === 0) exports.defaultMaxListeners = n;
-        else {
-          for (const emitter of emitters) {
-            if (typeof emitter.setMaxListeners === "function") {
-              emitter.setMaxListeners(n);
-            }
-          }
-        }
-      };
-    }
-  });
-
   // ../../node_modules/bare-dns/binding.js
   var require_binding4 = __commonJS({
     "../../node_modules/bare-dns/binding.js"(exports, module) {
@@ -7406,7 +7413,7 @@ var __bare_os_bundle_exports__ = (() => {
     "../../node_modules/bare-http1/lib/client-connection.js"(exports, module) {
       var HTTPParser = require_bare_http_parser();
       var HTTPIncomingMessage = require_incoming_message();
-      var errors = require_errors3();
+      var errors = require_errors4();
       var {
         constants: { RESPONSE, DATA, END }
       } = HTTPParser;
@@ -7530,7 +7537,7 @@ var __bare_os_bundle_exports__ = (() => {
       var EventEmitter = require_bare_events();
       var tcp = require_bare_tcp();
       var HTTPClientConnection = require_client_connection();
-      var errors = require_errors3();
+      var errors = require_errors4();
       var HTTPSocketSet = class {
         constructor() {
           this._sockets = /* @__PURE__ */ new Map();
@@ -8159,7 +8166,7 @@ var __bare_os_bundle_exports__ = (() => {
       exports.ClientRequest = require_client_request();
       exports.ClientConnection = require_client_connection();
       exports.constants = require_constants3();
-      exports.errors = require_errors3();
+      exports.errors = require_errors4();
       exports.METHODS = Object.values(exports.constants.method);
       exports.STATUS_CODES = exports.constants.status;
       exports.createServer = function createServer(opts, onrequest) {
@@ -8697,9 +8704,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/lib/constants.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js
   var require_constants6 = __commonJS({
-    "../../node_modules/bare-net/lib/constants.js"(exports, module) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js"(exports, module) {
       module.exports = {
         type: {
           TCP: 1,
@@ -8712,9 +8719,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/index.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js
   var require_bare_net = __commonJS({
-    "../../node_modules/bare-net/index.js"(exports) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js"(exports) {
       var EventEmitter = require_bare_events();
       var { Duplex } = require_bare_stream();
       var tcp = require_bare_tcp();

packages/bare-os-seeder/kernel/lib/bare/bundles/barePipe.js

@@ -342,10 +342,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareProcess.js

@@ -2074,10 +2074,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareReadline.js

@@ -5,13 +5,7 @@ var __bare_os_bundle_exports__ = (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-  }) : x)(function(x) {
-    if (typeof require !== "undefined") return require.apply(this, arguments);
-    throw Error('Dynamic require of "' + x + '" is not supported');
-  });
-  var __commonJS = (cb, mod) => function __require2() {
+  var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
@@ -36,10 +30,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareRpc.js

@@ -5,13 +5,7 @@ var __bare_os_bundle_exports__ = (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-  }) : x)(function(x) {
-    if (typeof require !== "undefined") return require.apply(this, arguments);
-    throw Error('Dynamic require of "' + x + '" is not supported');
-  });
-  var __commonJS = (cb, mod) => function __require2() {
+  var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
@@ -1585,10 +1579,323 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors2 = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors2();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareStdio.js

@@ -1850,10 +1850,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareStream.js

@@ -5,13 +5,7 @@ var __bare_os_bundle_exports__ = (() => {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-  }) : x)(function(x) {
-    if (typeof require !== "undefined") return require.apply(this, arguments);
-    throw Error('Dynamic require of "' + x + '" is not supported');
-  });
-  var __commonJS = (cb, mod) => function __require2() {
+  var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
@@ -36,10 +30,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareSubprocess.js

@@ -342,10 +342,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareTcp.js

@@ -342,10 +342,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareTls.js

@@ -36,10 +36,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -2375,7 +2688,7 @@ var __bare_os_bundle_exports__ = (() => {
   });
 
   // ../../node_modules/bare-tls/lib/errors.js
-  var require_errors = __commonJS({
+  var require_errors2 = __commonJS({
     "../../node_modules/bare-tls/lib/errors.js"(exports, module) {
       module.exports = class TLSError extends Error {
         constructor(msg, code, fn = TLSError) {
@@ -2395,312 +2708,6 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-events/lib/errors.js
-  var require_errors2 = __commonJS({
-    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
-      module.exports = class EventEmitterError extends Error {
-        constructor(msg, code, fn = EventEmitterError, opts) {
-          super(`${code}: ${msg}`, opts);
-          this.code = code;
-          if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, fn);
-          }
-        }
-        get name() {
-          return "EventEmitterError";
-        }
-        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
-          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
-            cause
-          });
-        }
-        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
-          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
-            cause
-          });
-        }
-      };
-    }
-  });
-
-  // ../../node_modules/bare-events/index.js
-  var require_bare_events = __commonJS({
-    "../../node_modules/bare-events/index.js"(exports, module) {
-      var errors = require_errors2();
-      var EventListener = class {
-        constructor() {
-          this.list = [];
-          this.count = 0;
-        }
-        append(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.push([fn, once]);
-        }
-        prepend(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.unshift([fn, once]);
-        }
-        remove(ctx, name, fn) {
-          for (let i = 0, n = this.list.length; i < n; i++) {
-            const l = this.list[i];
-            if (l[0] === fn) {
-              this.list.splice(i, 1);
-              if (this.count === 1) delete ctx._events[name];
-              ctx.emit("removeListener", name, fn);
-              this.count--;
-              return;
-            }
-          }
-        }
-        removeAll(ctx, name) {
-          const list = [...this.list];
-          this.list = [];
-          if (this.count === list.length) delete ctx._events[name];
-          for (let i = list.length - 1; i >= 0; i--) {
-            ctx.emit("removeListener", name, list[i][0]);
-          }
-          this.count -= list.length;
-        }
-        emit(ctx, name, ...args) {
-          const list = [...this.list];
-          for (let i = 0, n = list.length; i < n; i++) {
-            const l = list[i];
-            if (l[1] === true) this.remove(ctx, name, l[0]);
-            Reflect.apply(l[0], ctx, args);
-          }
-          return list.length > 0;
-        }
-      };
-      function appendListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.append(ctx, name, fn, once);
-        return ctx;
-      }
-      function prependListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.prepend(ctx, name, fn, once);
-        return ctx;
-      }
-      function removeListener(ctx, name, fn) {
-        if (ctx._events === void 0) return ctx;
-        const e = ctx._events[name];
-        if (e !== void 0) e.remove(ctx, name, fn);
-        return ctx;
-      }
-      function throwUnhandledError(...args) {
-        let err;
-        if (args.length > 0) err = args[0];
-        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(err, exports.prototype.emit);
-        }
-        queueMicrotask(() => {
-          throw err;
-        });
-      }
-      module.exports = exports = class EventEmitter {
-        constructor() {
-          this._events = /* @__PURE__ */ Object.create(null);
-        }
-        addListener(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        addOnceListener(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        prependListener(name, fn) {
-          return prependListener(this, name, fn, false);
-        }
-        prependOnceListener(name, fn) {
-          return prependListener(this, name, fn, true);
-        }
-        removeListener(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        on(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        once(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        off(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        emit(name, ...args) {
-          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
-            throwUnhandledError(...args);
-          }
-          if (this._events === void 0) return false;
-          const e = this._events[name];
-          return e === void 0 ? false : e.emit(this, name, ...args);
-        }
-        listeners(name) {
-          if (this._events === void 0) return [];
-          const e = this._events[name];
-          return e === void 0 ? [] : [...e.list];
-        }
-        listenerCount(name) {
-          if (this._events === void 0) return 0;
-          const e = this._events[name];
-          return e === void 0 ? 0 : e.list.length;
-        }
-        getMaxListeners() {
-          return EventEmitter.defaultMaxListeners;
-        }
-        setMaxListeners(n) {
-        }
-        removeAllListeners(name) {
-          if (arguments.length === 0) {
-            for (const key of Reflect.ownKeys(this._events)) {
-              if (key === "removeListener") continue;
-              this.removeAllListeners(key);
-            }
-            this.removeAllListeners("removeListener");
-          } else {
-            const e = this._events[name];
-            if (e !== void 0) e.removeAll(this, name);
-          }
-          return this;
-        }
-      };
-      exports.EventEmitter = exports;
-      exports.errors = errors;
-      exports.defaultMaxListeners = 10;
-      exports.on = function on(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          throw errors.OPERATION_ABORTED(signal.reason);
-        }
-        let error = null;
-        let done = false;
-        const events = [];
-        const promises = [];
-        if (name !== "error") emitter.on("error", onerror);
-        if (signal) signal.addEventListener("abort", onabort);
-        emitter.on(name, onevent);
-        return {
-          next() {
-            if (events.length) {
-              return Promise.resolve({ value: events.shift(), done: false });
-            }
-            if (error) {
-              const err = error;
-              error = null;
-              return Promise.reject(err);
-            }
-            if (done) return onclose();
-            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
-          },
-          return() {
-            return onclose();
-          },
-          throw(err) {
-            return onerror(err);
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        function onevent(...args) {
-          if (promises.length) {
-            promises.shift().resolve({ value: args, done: false });
-          } else {
-            events.push(args);
-          }
-        }
-        function onerror(err) {
-          emitter.off(name, onevent).off("error", onerror);
-          if (promises.length) {
-            promises.shift().reject(err);
-          } else {
-            error = err;
-          }
-          return Promise.resolve({ done: true });
-        }
-        function onabort() {
-          signal.removeEventListener("abort", onabort);
-          onerror(errors.OPERATION_ABORTED(signal.reason));
-        }
-        function onclose() {
-          emitter.off(name, onevent);
-          if (name !== "error") emitter.off("error", onerror);
-          if (signal) signal.removeEventListener("abort", onabort);
-          done = true;
-          if (promises.length) promises.shift().resolve({ done: true });
-          return Promise.resolve({ done: true });
-        }
-      };
-      exports.once = function once(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
-        }
-        return new Promise((resolve, reject) => {
-          if (name !== "error") emitter.on("error", onerror);
-          if (signal) signal.addEventListener("abort", onabort);
-          emitter.once(name, onevent);
-          function onevent(...args) {
-            if (name !== "error") emitter.off("error", onerror);
-            if (signal) signal.removeEventListener("abort", onabort);
-            resolve(args);
-          }
-          function onerror(err) {
-            emitter.off(name, onevent);
-            if (name !== "error") emitter.off("error", onerror);
-            reject(err);
-          }
-          function onabort() {
-            signal.removeEventListener("abort", onabort);
-            onerror(errors.OPERATION_ABORTED(signal.reason));
-          }
-        });
-      };
-      exports.forward = function forward(from, to, names, opts = {}) {
-        if (typeof names === "string") names = [names];
-        const { emit = to.emit.bind(to) } = opts;
-        const listeners = names.map(
-          (name) => function onevent(...args) {
-            emit(name, ...args);
-          }
-        );
-        to.on("newListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.on(name, listeners[i]);
-          }
-        }).on("removeListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.off(name, listeners[i]);
-          }
-        });
-      };
-      exports.listenerCount = function listenerCount(emitter, name) {
-        return emitter.listenerCount(name);
-      };
-      exports.getMaxListeners = function getMaxListeners(emitter) {
-        if (typeof emitter.getMaxListeners === "function") {
-          return emitter.getMaxListeners();
-        }
-        return exports.defaultMaxListeners;
-      };
-      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
-        if (emitters.length === 0) exports.defaultMaxListeners = n;
-        else {
-          for (const emitter of emitters) {
-            if (typeof emitter.setMaxListeners === "function") {
-              emitter.setMaxListeners(n);
-            }
-          }
-        }
-      };
-    }
-  });
-
   // ../../node_modules/bare-dns/binding.js
   var require_binding2 = __commonJS({
     "../../node_modules/bare-dns/binding.js"(exports, module) {
@@ -3813,9 +3820,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/lib/constants.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js
   var require_constants4 = __commonJS({
-    "../../node_modules/bare-net/lib/constants.js"(exports, module) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js"(exports, module) {
       module.exports = {
         type: {
           TCP: 1,
@@ -3828,9 +3835,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/index.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js
   var require_bare_net = __commonJS({
-    "../../node_modules/bare-net/index.js"(exports) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js"(exports) {
       var EventEmitter = require_bare_events();
       var { Duplex } = require_bare_stream();
       var tcp = require_bare_tcp();
@@ -4248,7 +4255,7 @@ var __bare_os_bundle_exports__ = (() => {
       var { Duplex, Writable } = require_bare_stream();
       var binding = require_binding();
       var constants = require_constants();
-      var errors = require_errors();
+      var errors = require_errors2();
       var defaultReadBufferSize = 65536;
       var context = binding.context();
       exports.Socket = class TLSSocket extends Duplex {

packages/bare-os-seeder/kernel/lib/bare/bundles/bareTty.js

@@ -36,10 +36,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -2355,312 +2668,6 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-events/lib/errors.js
-  var require_errors = __commonJS({
-    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
-      module.exports = class EventEmitterError extends Error {
-        constructor(msg, code, fn = EventEmitterError, opts) {
-          super(`${code}: ${msg}`, opts);
-          this.code = code;
-          if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, fn);
-          }
-        }
-        get name() {
-          return "EventEmitterError";
-        }
-        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
-          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
-            cause
-          });
-        }
-        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
-          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
-            cause
-          });
-        }
-      };
-    }
-  });
-
-  // ../../node_modules/bare-events/index.js
-  var require_bare_events = __commonJS({
-    "../../node_modules/bare-events/index.js"(exports, module) {
-      var errors = require_errors();
-      var EventListener = class {
-        constructor() {
-          this.list = [];
-          this.count = 0;
-        }
-        append(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.push([fn, once]);
-        }
-        prepend(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.unshift([fn, once]);
-        }
-        remove(ctx, name, fn) {
-          for (let i = 0, n = this.list.length; i < n; i++) {
-            const l = this.list[i];
-            if (l[0] === fn) {
-              this.list.splice(i, 1);
-              if (this.count === 1) delete ctx._events[name];
-              ctx.emit("removeListener", name, fn);
-              this.count--;
-              return;
-            }
-          }
-        }
-        removeAll(ctx, name) {
-          const list = [...this.list];
-          this.list = [];
-          if (this.count === list.length) delete ctx._events[name];
-          for (let i = list.length - 1; i >= 0; i--) {
-            ctx.emit("removeListener", name, list[i][0]);
-          }
-          this.count -= list.length;
-        }
-        emit(ctx, name, ...args) {
-          const list = [...this.list];
-          for (let i = 0, n = list.length; i < n; i++) {
-            const l = list[i];
-            if (l[1] === true) this.remove(ctx, name, l[0]);
-            Reflect.apply(l[0], ctx, args);
-          }
-          return list.length > 0;
-        }
-      };
-      function appendListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.append(ctx, name, fn, once);
-        return ctx;
-      }
-      function prependListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.prepend(ctx, name, fn, once);
-        return ctx;
-      }
-      function removeListener(ctx, name, fn) {
-        if (ctx._events === void 0) return ctx;
-        const e = ctx._events[name];
-        if (e !== void 0) e.remove(ctx, name, fn);
-        return ctx;
-      }
-      function throwUnhandledError(...args) {
-        let err;
-        if (args.length > 0) err = args[0];
-        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(err, exports.prototype.emit);
-        }
-        queueMicrotask(() => {
-          throw err;
-        });
-      }
-      module.exports = exports = class EventEmitter {
-        constructor() {
-          this._events = /* @__PURE__ */ Object.create(null);
-        }
-        addListener(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        addOnceListener(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        prependListener(name, fn) {
-          return prependListener(this, name, fn, false);
-        }
-        prependOnceListener(name, fn) {
-          return prependListener(this, name, fn, true);
-        }
-        removeListener(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        on(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        once(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        off(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        emit(name, ...args) {
-          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
-            throwUnhandledError(...args);
-          }
-          if (this._events === void 0) return false;
-          const e = this._events[name];
-          return e === void 0 ? false : e.emit(this, name, ...args);
-        }
-        listeners(name) {
-          if (this._events === void 0) return [];
-          const e = this._events[name];
-          return e === void 0 ? [] : [...e.list];
-        }
-        listenerCount(name) {
-          if (this._events === void 0) return 0;
-          const e = this._events[name];
-          return e === void 0 ? 0 : e.list.length;
-        }
-        getMaxListeners() {
-          return EventEmitter.defaultMaxListeners;
-        }
-        setMaxListeners(n) {
-        }
-        removeAllListeners(name) {
-          if (arguments.length === 0) {
-            for (const key of Reflect.ownKeys(this._events)) {
-              if (key === "removeListener") continue;
-              this.removeAllListeners(key);
-            }
-            this.removeAllListeners("removeListener");
-          } else {
-            const e = this._events[name];
-            if (e !== void 0) e.removeAll(this, name);
-          }
-          return this;
-        }
-      };
-      exports.EventEmitter = exports;
-      exports.errors = errors;
-      exports.defaultMaxListeners = 10;
-      exports.on = function on(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          throw errors.OPERATION_ABORTED(signal.reason);
-        }
-        let error = null;
-        let done = false;
-        const events = [];
-        const promises = [];
-        if (name !== "error") emitter.on("error", onerror);
-        if (signal) signal.addEventListener("abort", onabort);
-        emitter.on(name, onevent);
-        return {
-          next() {
-            if (events.length) {
-              return Promise.resolve({ value: events.shift(), done: false });
-            }
-            if (error) {
-              const err = error;
-              error = null;
-              return Promise.reject(err);
-            }
-            if (done) return onclose();
-            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
-          },
-          return() {
-            return onclose();
-          },
-          throw(err) {
-            return onerror(err);
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        function onevent(...args) {
-          if (promises.length) {
-            promises.shift().resolve({ value: args, done: false });
-          } else {
-            events.push(args);
-          }
-        }
-        function onerror(err) {
-          emitter.off(name, onevent).off("error", onerror);
-          if (promises.length) {
-            promises.shift().reject(err);
-          } else {
-            error = err;
-          }
-          return Promise.resolve({ done: true });
-        }
-        function onabort() {
-          signal.removeEventListener("abort", onabort);
-          onerror(errors.OPERATION_ABORTED(signal.reason));
-        }
-        function onclose() {
-          emitter.off(name, onevent);
-          if (name !== "error") emitter.off("error", onerror);
-          if (signal) signal.removeEventListener("abort", onabort);
-          done = true;
-          if (promises.length) promises.shift().resolve({ done: true });
-          return Promise.resolve({ done: true });
-        }
-      };
-      exports.once = function once(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
-        }
-        return new Promise((resolve, reject) => {
-          if (name !== "error") emitter.on("error", onerror);
-          if (signal) signal.addEventListener("abort", onabort);
-          emitter.once(name, onevent);
-          function onevent(...args) {
-            if (name !== "error") emitter.off("error", onerror);
-            if (signal) signal.removeEventListener("abort", onabort);
-            resolve(args);
-          }
-          function onerror(err) {
-            emitter.off(name, onevent);
-            if (name !== "error") emitter.off("error", onerror);
-            reject(err);
-          }
-          function onabort() {
-            signal.removeEventListener("abort", onabort);
-            onerror(errors.OPERATION_ABORTED(signal.reason));
-          }
-        });
-      };
-      exports.forward = function forward(from, to, names, opts = {}) {
-        if (typeof names === "string") names = [names];
-        const { emit = to.emit.bind(to) } = opts;
-        const listeners = names.map(
-          (name) => function onevent(...args) {
-            emit(name, ...args);
-          }
-        );
-        to.on("newListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.on(name, listeners[i]);
-          }
-        }).on("removeListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.off(name, listeners[i]);
-          }
-        });
-      };
-      exports.listenerCount = function listenerCount(emitter, name) {
-        return emitter.listenerCount(name);
-      };
-      exports.getMaxListeners = function getMaxListeners(emitter) {
-        if (typeof emitter.getMaxListeners === "function") {
-          return emitter.getMaxListeners();
-        }
-        return exports.defaultMaxListeners;
-      };
-      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
-        if (emitters.length === 0) exports.defaultMaxListeners = n;
-        else {
-          for (const emitter of emitters) {
-            if (typeof emitter.setMaxListeners === "function") {
-              emitter.setMaxListeners(n);
-            }
-          }
-        }
-      };
-    }
-  });
-
   // ../../node_modules/bare-os/binding.js
   var require_binding = __commonJS({
     "../../node_modules/bare-os/binding.js"(exports, module) {

packages/bare-os-seeder/kernel/lib/bare/bundles/bareUtils.js

@@ -3515,10 +3515,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/bareWs.js

@@ -342,10 +342,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -5447,9 +5454,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/lib/constants.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js
   var require_constants5 = __commonJS({
-    "../../node_modules/bare-net/lib/constants.js"(exports, module) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js"(exports, module) {
       module.exports = {
         type: {
           TCP: 1,
@@ -5462,9 +5469,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/index.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js
   var require_bare_net = __commonJS({
-    "../../node_modules/bare-net/index.js"(exports) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js"(exports) {
       var EventEmitter = require_bare_events();
       var { Duplex } = require_bare_stream();
       var tcp = require_bare_tcp();

packages/bare-os-seeder/kernel/lib/bare/bundles/bareZlib.js

@@ -36,10 +36,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -2371,7 +2684,7 @@ var __bare_os_bundle_exports__ = (() => {
   });
 
   // ../../node_modules/bare-zlib/lib/errors.js
-  var require_errors = __commonJS({
+  var require_errors2 = __commonJS({
     "../../node_modules/bare-zlib/lib/errors.js"(exports, module) {
       module.exports = class ZlibError extends Error {
         constructor(msg, code, fn = ZlibError) {
@@ -2415,7 +2728,7 @@ var __bare_os_bundle_exports__ = (() => {
       var { Transform, Writable } = require_bare_stream();
       var binding = require_binding();
       var constants = require_constants();
-      var errors = require_errors();
+      var errors = require_errors2();
       exports.constants = constants;
       exports.errors = errors;
       var ZlibState = class {

packages/bare-os-seeder/kernel/lib/bare/bundles/bareZmq.js

@@ -342,10 +342,17 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 

packages/bare-os-seeder/kernel/lib/bare/bundles/fetch.js

@@ -36,10 +36,323 @@ var __bare_os_bundle_exports__ = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/bare-events/lib/errors.js
+  var require_errors = __commonJS({
+    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
+      module.exports = class EventEmitterError extends Error {
+        constructor(msg, code, fn = EventEmitterError, opts) {
+          super(`${code}: ${msg}`, opts);
+          this.code = code;
+          if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, fn);
+          }
+        }
+        get name() {
+          return "EventEmitterError";
+        }
+        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
+          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
+            cause
+          });
+        }
+        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
+          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
+            cause
+          });
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/bare-events/index.js
+  var require_bare_events = __commonJS({
+    "../../node_modules/bare-events/index.js"(exports, module) {
+      var errors = require_errors();
+      var EventListener = class {
+        constructor() {
+          this.list = [];
+          this.count = 0;
+        }
+        append(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.push([fn, once]);
+        }
+        prepend(ctx, name, fn, once) {
+          this.count++;
+          ctx.emit("newListener", name, fn);
+          this.list.unshift([fn, once]);
+        }
+        remove(ctx, name, fn) {
+          for (let i = 0, n = this.list.length; i < n; i++) {
+            const l = this.list[i];
+            if (l[0] === fn) {
+              this.list.splice(i, 1);
+              if (this.count === 1) delete ctx._events[name];
+              ctx.emit("removeListener", name, fn);
+              this.count--;
+              return;
+            }
+          }
+        }
+        removeAll(ctx, name) {
+          const list = [...this.list];
+          this.list = [];
+          if (this.count === list.length) delete ctx._events[name];
+          for (let i = list.length - 1; i >= 0; i--) {
+            ctx.emit("removeListener", name, list[i][0]);
+          }
+          this.count -= list.length;
+        }
+        emit(ctx, name, ...args) {
+          const list = [...this.list];
+          for (let i = 0, n = list.length; i < n; i++) {
+            const l = list[i];
+            if (l[1] === true) this.remove(ctx, name, l[0]);
+            Reflect.apply(l[0], ctx, args);
+          }
+          return list.length > 0;
+        }
+      };
+      function appendListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.append(ctx, name, fn, once);
+        return ctx;
+      }
+      function prependListener(ctx, name, fn, once) {
+        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
+        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
+        e.prepend(ctx, name, fn, once);
+        return ctx;
+      }
+      function removeListener(ctx, name, fn) {
+        if (ctx._events === void 0) return ctx;
+        const e = ctx._events[name];
+        if (e !== void 0) e.remove(ctx, name, fn);
+        return ctx;
+      }
+      function throwUnhandledError(...args) {
+        let err;
+        if (args.length > 0) err = args[0];
+        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(err, exports.prototype.emit);
+        }
+        queueMicrotask(() => {
+          throw err;
+        });
+      }
+      module.exports = exports = class EventEmitter {
+        constructor() {
+          this._events = /* @__PURE__ */ Object.create(null);
+        }
+        addListener(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        addOnceListener(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        prependListener(name, fn) {
+          return prependListener(this, name, fn, false);
+        }
+        prependOnceListener(name, fn) {
+          return prependListener(this, name, fn, true);
+        }
+        removeListener(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        on(name, fn) {
+          return appendListener(this, name, fn, false);
+        }
+        once(name, fn) {
+          return appendListener(this, name, fn, true);
+        }
+        off(name, fn) {
+          return removeListener(this, name, fn);
+        }
+        emit(name, ...args) {
+          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
+            throwUnhandledError(...args);
+          }
+          if (this._events === void 0) return false;
+          const e = this._events[name];
+          return e === void 0 ? false : e.emit(this, name, ...args);
+        }
+        listeners(name) {
+          if (this._events === void 0) return [];
+          const e = this._events[name];
+          return e === void 0 ? [] : [...e.list];
+        }
+        listenerCount(name) {
+          if (this._events === void 0) return 0;
+          const e = this._events[name];
+          return e === void 0 ? 0 : e.list.length;
+        }
+        getMaxListeners() {
+          return EventEmitter.defaultMaxListeners;
+        }
+        setMaxListeners(n) {
+        }
+        removeAllListeners(name) {
+          if (arguments.length === 0) {
+            for (const key of Reflect.ownKeys(this._events)) {
+              if (key === "removeListener") continue;
+              this.removeAllListeners(key);
+            }
+            this.removeAllListeners("removeListener");
+          } else {
+            const e = this._events[name];
+            if (e !== void 0) e.removeAll(this, name);
+          }
+          return this;
+        }
+      };
+      exports.EventEmitter = exports;
+      exports.errors = errors;
+      exports.defaultMaxListeners = 10;
+      exports.on = function on(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          throw errors.OPERATION_ABORTED(signal.reason);
+        }
+        let error = null;
+        let done = false;
+        const events = [];
+        const promises = [];
+        if (name !== "error") emitter.on("error", onerror);
+        if (signal) signal.addEventListener("abort", onabort);
+        emitter.on(name, onevent);
+        return {
+          next() {
+            if (events.length) {
+              return Promise.resolve({ value: events.shift(), done: false });
+            }
+            if (error) {
+              const err = error;
+              error = null;
+              return Promise.reject(err);
+            }
+            if (done) return onclose();
+            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
+          },
+          return() {
+            return onclose();
+          },
+          throw(err) {
+            return onerror(err);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+        function onevent(...args) {
+          if (promises.length) {
+            promises.shift().resolve({ value: args, done: false });
+          } else {
+            events.push(args);
+          }
+        }
+        function onerror(err) {
+          emitter.off(name, onevent).off("error", onerror);
+          if (promises.length) {
+            promises.shift().reject(err);
+          } else {
+            error = err;
+          }
+          return Promise.resolve({ done: true });
+        }
+        function onabort() {
+          signal.removeEventListener("abort", onabort);
+          onerror(errors.OPERATION_ABORTED(signal.reason));
+        }
+        function onclose() {
+          emitter.off(name, onevent);
+          if (name !== "error") emitter.off("error", onerror);
+          if (signal) signal.removeEventListener("abort", onabort);
+          done = true;
+          if (promises.length) promises.shift().resolve({ done: true });
+          return Promise.resolve({ done: true });
+        }
+      };
+      exports.once = function once(emitter, name, opts = {}) {
+        const { signal } = opts;
+        if (signal && signal.aborted) {
+          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
+        }
+        return new Promise((resolve, reject) => {
+          if (name !== "error") emitter.on("error", onerror);
+          if (signal) signal.addEventListener("abort", onabort);
+          emitter.once(name, onevent);
+          function onevent(...args) {
+            if (name !== "error") emitter.off("error", onerror);
+            if (signal) signal.removeEventListener("abort", onabort);
+            resolve(args);
+          }
+          function onerror(err) {
+            emitter.off(name, onevent);
+            if (name !== "error") emitter.off("error", onerror);
+            reject(err);
+          }
+          function onabort() {
+            signal.removeEventListener("abort", onabort);
+            onerror(errors.OPERATION_ABORTED(signal.reason));
+          }
+        });
+      };
+      exports.forward = function forward(from, to, names, opts = {}) {
+        if (typeof names === "string") names = [names];
+        const { emit = to.emit.bind(to) } = opts;
+        const listeners = names.map(
+          (name) => function onevent(...args) {
+            emit(name, ...args);
+          }
+        );
+        to.on("newListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.on(name, listeners[i]);
+          }
+        }).on("removeListener", (name) => {
+          const i = names.indexOf(name);
+          if (i !== -1 && to.listenerCount(name) === 0) {
+            from.off(name, listeners[i]);
+          }
+        });
+      };
+      exports.listenerCount = function listenerCount(emitter, name) {
+        return emitter.listenerCount(name);
+      };
+      exports.getMaxListeners = function getMaxListeners(emitter) {
+        if (typeof emitter.getMaxListeners === "function") {
+          return emitter.getMaxListeners();
+        }
+        return exports.defaultMaxListeners;
+      };
+      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
+        if (emitters.length === 0) exports.defaultMaxListeners = n;
+        else {
+          for (const emitter of emitters) {
+            if (typeof emitter.setMaxListeners === "function") {
+              emitter.setMaxListeners(n);
+            }
+          }
+        }
+      };
+    }
+  });
+
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js
+  var require_bare_node_events = __commonJS({
+    "../bare-os-openssh/vendor/bare-node-shims/bare-node-events/index.js"(exports, module) {
+      module.exports = require_bare_events();
+    }
+  });
+
   // ../../node_modules/events-universal/default.js
   var require_default = __commonJS({
     "../../node_modules/events-universal/default.js"(exports, module) {
-      module.exports = __require("events");
+      module.exports = require_bare_node_events();
     }
   });
 
@@ -2431,7 +2744,7 @@ var __bare_os_bundle_exports__ = (() => {
   });
 
   // ../../node_modules/bare-http1/lib/errors.js
-  var require_errors = __commonJS({
+  var require_errors2 = __commonJS({
     "../../node_modules/bare-http1/lib/errors.js"(exports, module) {
       module.exports = class HTTPError extends Error {
         constructor(msg, fn = HTTPError, code = fn.name) {
@@ -2461,7 +2774,7 @@ var __bare_os_bundle_exports__ = (() => {
   var require_outgoing_message = __commonJS({
     "../../node_modules/bare-http1/lib/outgoing-message.js"(exports, module) {
       var { Writable } = require_bare_stream();
-      var errors = require_errors();
+      var errors = require_errors2();
       module.exports = class HTTPOutgoingMessage extends Writable {
         constructor(socket = null) {
           super();
@@ -2517,312 +2830,6 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-events/lib/errors.js
-  var require_errors2 = __commonJS({
-    "../../node_modules/bare-events/lib/errors.js"(exports, module) {
-      module.exports = class EventEmitterError extends Error {
-        constructor(msg, code, fn = EventEmitterError, opts) {
-          super(`${code}: ${msg}`, opts);
-          this.code = code;
-          if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, fn);
-          }
-        }
-        get name() {
-          return "EventEmitterError";
-        }
-        static OPERATION_ABORTED(cause, msg = "Operation aborted") {
-          return new EventEmitterError(msg, "OPERATION_ABORTED", EventEmitterError.OPERATION_ABORTED, {
-            cause
-          });
-        }
-        static UNHANDLED_ERROR(cause, msg = "Unhandled error") {
-          return new EventEmitterError(msg, "UNHANDLED_ERROR", EventEmitterError.UNHANDLED_ERROR, {
-            cause
-          });
-        }
-      };
-    }
-  });
-
-  // ../../node_modules/bare-events/index.js
-  var require_bare_events = __commonJS({
-    "../../node_modules/bare-events/index.js"(exports, module) {
-      var errors = require_errors2();
-      var EventListener = class {
-        constructor() {
-          this.list = [];
-          this.count = 0;
-        }
-        append(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.push([fn, once]);
-        }
-        prepend(ctx, name, fn, once) {
-          this.count++;
-          ctx.emit("newListener", name, fn);
-          this.list.unshift([fn, once]);
-        }
-        remove(ctx, name, fn) {
-          for (let i = 0, n = this.list.length; i < n; i++) {
-            const l = this.list[i];
-            if (l[0] === fn) {
-              this.list.splice(i, 1);
-              if (this.count === 1) delete ctx._events[name];
-              ctx.emit("removeListener", name, fn);
-              this.count--;
-              return;
-            }
-          }
-        }
-        removeAll(ctx, name) {
-          const list = [...this.list];
-          this.list = [];
-          if (this.count === list.length) delete ctx._events[name];
-          for (let i = list.length - 1; i >= 0; i--) {
-            ctx.emit("removeListener", name, list[i][0]);
-          }
-          this.count -= list.length;
-        }
-        emit(ctx, name, ...args) {
-          const list = [...this.list];
-          for (let i = 0, n = list.length; i < n; i++) {
-            const l = list[i];
-            if (l[1] === true) this.remove(ctx, name, l[0]);
-            Reflect.apply(l[0], ctx, args);
-          }
-          return list.length > 0;
-        }
-      };
-      function appendListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.append(ctx, name, fn, once);
-        return ctx;
-      }
-      function prependListener(ctx, name, fn, once) {
-        if (ctx._events === void 0) ctx._events = /* @__PURE__ */ Object.create(null);
-        const e = ctx._events[name] || (ctx._events[name] = new EventListener());
-        e.prepend(ctx, name, fn, once);
-        return ctx;
-      }
-      function removeListener(ctx, name, fn) {
-        if (ctx._events === void 0) return ctx;
-        const e = ctx._events[name];
-        if (e !== void 0) e.remove(ctx, name, fn);
-        return ctx;
-      }
-      function throwUnhandledError(...args) {
-        let err;
-        if (args.length > 0) err = args[0];
-        if (err instanceof Error === false) err = errors.UNHANDLED_ERROR(err);
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(err, exports.prototype.emit);
-        }
-        queueMicrotask(() => {
-          throw err;
-        });
-      }
-      module.exports = exports = class EventEmitter {
-        constructor() {
-          this._events = /* @__PURE__ */ Object.create(null);
-        }
-        addListener(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        addOnceListener(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        prependListener(name, fn) {
-          return prependListener(this, name, fn, false);
-        }
-        prependOnceListener(name, fn) {
-          return prependListener(this, name, fn, true);
-        }
-        removeListener(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        on(name, fn) {
-          return appendListener(this, name, fn, false);
-        }
-        once(name, fn) {
-          return appendListener(this, name, fn, true);
-        }
-        off(name, fn) {
-          return removeListener(this, name, fn);
-        }
-        emit(name, ...args) {
-          if (name === "error" && this._events !== void 0 && this._events.error === void 0) {
-            throwUnhandledError(...args);
-          }
-          if (this._events === void 0) return false;
-          const e = this._events[name];
-          return e === void 0 ? false : e.emit(this, name, ...args);
-        }
-        listeners(name) {
-          if (this._events === void 0) return [];
-          const e = this._events[name];
-          return e === void 0 ? [] : [...e.list];
-        }
-        listenerCount(name) {
-          if (this._events === void 0) return 0;
-          const e = this._events[name];
-          return e === void 0 ? 0 : e.list.length;
-        }
-        getMaxListeners() {
-          return EventEmitter.defaultMaxListeners;
-        }
-        setMaxListeners(n) {
-        }
-        removeAllListeners(name) {
-          if (arguments.length === 0) {
-            for (const key of Reflect.ownKeys(this._events)) {
-              if (key === "removeListener") continue;
-              this.removeAllListeners(key);
-            }
-            this.removeAllListeners("removeListener");
-          } else {
-            const e = this._events[name];
-            if (e !== void 0) e.removeAll(this, name);
-          }
-          return this;
-        }
-      };
-      exports.EventEmitter = exports;
-      exports.errors = errors;
-      exports.defaultMaxListeners = 10;
-      exports.on = function on(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          throw errors.OPERATION_ABORTED(signal.reason);
-        }
-        let error = null;
-        let done = false;
-        const events = [];
-        const promises = [];
-        if (name !== "error") emitter.on("error", onerror);
-        if (signal) signal.addEventListener("abort", onabort);
-        emitter.on(name, onevent);
-        return {
-          next() {
-            if (events.length) {
-              return Promise.resolve({ value: events.shift(), done: false });
-            }
-            if (error) {
-              const err = error;
-              error = null;
-              return Promise.reject(err);
-            }
-            if (done) return onclose();
-            return new Promise((resolve, reject) => promises.push({ resolve, reject }));
-          },
-          return() {
-            return onclose();
-          },
-          throw(err) {
-            return onerror(err);
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          }
-        };
-        function onevent(...args) {
-          if (promises.length) {
-            promises.shift().resolve({ value: args, done: false });
-          } else {
-            events.push(args);
-          }
-        }
-        function onerror(err) {
-          emitter.off(name, onevent).off("error", onerror);
-          if (promises.length) {
-            promises.shift().reject(err);
-          } else {
-            error = err;
-          }
-          return Promise.resolve({ done: true });
-        }
-        function onabort() {
-          signal.removeEventListener("abort", onabort);
-          onerror(errors.OPERATION_ABORTED(signal.reason));
-        }
-        function onclose() {
-          emitter.off(name, onevent);
-          if (name !== "error") emitter.off("error", onerror);
-          if (signal) signal.removeEventListener("abort", onabort);
-          done = true;
-          if (promises.length) promises.shift().resolve({ done: true });
-          return Promise.resolve({ done: true });
-        }
-      };
-      exports.once = function once(emitter, name, opts = {}) {
-        const { signal } = opts;
-        if (signal && signal.aborted) {
-          return Promise.reject(errors.OPERATION_ABORTED(signal.reason));
-        }
-        return new Promise((resolve, reject) => {
-          if (name !== "error") emitter.on("error", onerror);
-          if (signal) signal.addEventListener("abort", onabort);
-          emitter.once(name, onevent);
-          function onevent(...args) {
-            if (name !== "error") emitter.off("error", onerror);
-            if (signal) signal.removeEventListener("abort", onabort);
-            resolve(args);
-          }
-          function onerror(err) {
-            emitter.off(name, onevent);
-            if (name !== "error") emitter.off("error", onerror);
-            reject(err);
-          }
-          function onabort() {
-            signal.removeEventListener("abort", onabort);
-            onerror(errors.OPERATION_ABORTED(signal.reason));
-          }
-        });
-      };
-      exports.forward = function forward(from, to, names, opts = {}) {
-        if (typeof names === "string") names = [names];
-        const { emit = to.emit.bind(to) } = opts;
-        const listeners = names.map(
-          (name) => function onevent(...args) {
-            emit(name, ...args);
-          }
-        );
-        to.on("newListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.on(name, listeners[i]);
-          }
-        }).on("removeListener", (name) => {
-          const i = names.indexOf(name);
-          if (i !== -1 && to.listenerCount(name) === 0) {
-            from.off(name, listeners[i]);
-          }
-        });
-      };
-      exports.listenerCount = function listenerCount(emitter, name) {
-        return emitter.listenerCount(name);
-      };
-      exports.getMaxListeners = function getMaxListeners(emitter) {
-        if (typeof emitter.getMaxListeners === "function") {
-          return emitter.getMaxListeners();
-        }
-        return exports.defaultMaxListeners;
-      };
-      exports.setMaxListeners = function setMaxListeners(n, ...emitters) {
-        if (emitters.length === 0) exports.defaultMaxListeners = n;
-        else {
-          for (const emitter of emitters) {
-            if (typeof emitter.setMaxListeners === "function") {
-              emitter.setMaxListeners(n);
-            }
-          }
-        }
-      };
-    }
-  });
-
   // ../../node_modules/bare-dns/binding.js
   var require_binding = __commonJS({
     "../../node_modules/bare-dns/binding.js"(exports, module) {
@@ -4156,7 +4163,7 @@ var __bare_os_bundle_exports__ = (() => {
     "../../node_modules/bare-http1/lib/client-connection.js"(exports, module) {
       var HTTPParser = require_bare_http_parser();
       var HTTPIncomingMessage = require_incoming_message();
-      var errors = require_errors();
+      var errors = require_errors2();
       var {
         constants: { RESPONSE, DATA, END }
       } = HTTPParser;
@@ -4280,7 +4287,7 @@ var __bare_os_bundle_exports__ = (() => {
       var EventEmitter = require_bare_events();
       var tcp = require_bare_tcp();
       var HTTPClientConnection = require_client_connection();
-      var errors = require_errors();
+      var errors = require_errors2();
       var HTTPSocketSet = class {
         constructor() {
           this._sockets = /* @__PURE__ */ new Map();
@@ -4909,7 +4916,7 @@ var __bare_os_bundle_exports__ = (() => {
       exports.ClientRequest = require_client_request();
       exports.ClientConnection = require_client_connection();
       exports.constants = require_constants2();
-      exports.errors = require_errors();
+      exports.errors = require_errors2();
       exports.METHODS = Object.values(exports.constants.method);
       exports.STATUS_CODES = exports.constants.status;
       exports.createServer = function createServer(opts, onrequest) {
@@ -5447,9 +5454,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/lib/constants.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js
   var require_constants5 = __commonJS({
-    "../../node_modules/bare-net/lib/constants.js"(exports, module) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/lib/constants.js"(exports, module) {
       module.exports = {
         type: {
           TCP: 1,
@@ -5462,9 +5469,9 @@ var __bare_os_bundle_exports__ = (() => {
     }
   });
 
-  // ../../node_modules/bare-net/index.js
+  // ../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js
   var require_bare_net = __commonJS({
-    "../../node_modules/bare-net/index.js"(exports) {
+    "../bare-os-openssh/vendor/bare-node-shims/bare-net/index.js"(exports) {
       var EventEmitter = require_bare_events();
       var { Duplex } = require_bare_stream();
       var tcp = require_bare_tcp();

packages/bare-os-seeder/kernel/lib/bare/shell-completion.json

@@ -1,6 +1,6 @@
 {
   "schema": 1,
-  "atMs": 1775701596651,
+  "atMs": 1775777169246,
   "commands": [
     "arch",
     "awk",
@@ -49,6 +49,7 @@
     "hdms",
     "head",
     "help",
+    "holesail",
     "hostid",
     "hostname",
     "iconv",