synabun 2.0.0 → 2.0.7

package/neural-interface/lib/file-explorer-watch.js

@@ -0,0 +1,239 @@
+// ── The File Explorer's watcher ──
+// Tells the page which of the folders it shows changed on disk, and when the
+// git state of the project may have, without the page asking again and again.
+// It costs nothing while nothing changes: the operating system reports changes,
+// nothing is polled.
+//
+// Two ways to watch, by what the system offers:
+//   recursive  one watcher on the project's folder (macOS and Windows have it
+//              natively). Every change below the folder arrives; the ones the
+//              page did not ask about are dropped here.
+//   folders    one watcher per folder the page shows (Linux, where a recursive
+//              watch is a watch per sub-folder), plus one on .git.
+// Changes are collected for a moment and sent together. Dependencies are
+// injected: the tests drive it with real folders and with a fake `watch`.
+//
+// A watcher that exists is not a watch that works: the system may have no
+// watches left (ENOSPC on Linux), or lose one it had. `state()` says what is
+// really watched, and `onState` when that changes, so the page can read again
+// by itself where nothing will tell it.
+//
+// A watch that failed is not asked for again at once. A watch that is lost
+// each time it is opened would otherwise be opened, lost and opened again as
+// fast as the page and the system can answer one another. It is tried again
+// after a wait that doubles (a second, two, four, ... a minute at most) and
+// starts over once a watch has held for a minute; until then it stays a watch
+// that is not there, whatever folders the page shows meanwhile.
+
+import { existsSync, watch as fsWatch } from 'node:fs';
+import { dirname, join, relative, sep } from 'node:path';
+
+export const MAX_WATCHED_DIRS = 600;
+/** A watch that failed is tried again after this long, then after twice that, and so on. */
+export const RETRY_FIRST_MS = 1000;
+/** ... and never less often than this. */
+export const RETRY_MAX_MS = 60000;
+/** A watch that held this long was no part of a run of failures: the next wait is the first one again. */
+export const RETRY_QUIET_MS = 60000;
+/** The files of .git whose change means "commit, stage, checkout or merge": the git state is read again. */
+const GIT_STATE_FILES = /^(index|HEAD|ORIG_HEAD|MERGE_HEAD|CHERRY_PICK_HEAD|REVERT_HEAD|packed-refs)$/;
+/** A folder that is not there (any more) is no watch that failed: its next listing says what is true. */
+const NOT_THERE = new Set(['ENOENT', 'ENOTDIR']);
+
+/** Which way this system is watched. */
+export function watchStrategy(platform = process.platform) {
+  return platform === 'darwin' || platform === 'win32' ? 'recursive' : 'folders';
+}
+
+/**
+ * @param {object} o
+ * @param {string} o.root the project's folder, canonical
+ * @param {'recursive' | 'folders'} [o.strategy]
+ * @param {(change: { dirs: string[], git: boolean }) => void} o.onChange `dirs`: watched folders (canonical) whose
+ *   entries changed; `git`: the git state may have changed
+ * @param {(error: Error) => void} [o.onError] the watch on the project's folder was lost
+ * @param {(state: { scope: 'tree' | 'folders', live: 'full' | 'partial' | 'none' }) => void} [o.onState] what is
+ *   really watched changed (see `state()`); not called for the state it starts in
+ * @param {(relativePath: string) => boolean} [o.ignoresGit] a path git ignores: a change there is no change of state
+ * @param {typeof fsWatch} [o.watch] @param {(path: string) => boolean} [o.exists]
+ * @param {number} [o.debounceMs] @param {number} [o.maxWaitMs]
+ * @param {() => number} [o.now] @param {(fn: () => void, ms: number) => any} [o.setTimer] @param {(timer: any) => void} [o.clearTimer]
+ *   the clock of the waits between two attempts at a watch that failed (a test moves it by hand)
+ * @returns {{ setDirs: (dirs: string[]) => void, close: () => void, count: () => number, strategy: string,
+ *   state: () => { scope: 'tree' | 'folders', live: 'full' | 'partial' | 'none' } }}
+ */
+export function createTreeWatcher({
+  root, strategy = watchStrategy(), onChange, onError = () => {}, onState = () => {}, ignoresGit = () => false,
+  watch = fsWatch, exists = existsSync, debounceMs = 120, maxWaitMs = 500,
+  now = () => Date.now(), setTimer = (fn, ms) => setTimeout(fn, ms), clearTimer = (timer) => clearTimeout(timer),
+}) {
+  let closed = false;
+  let wanted = new Set([root]);        // the folders the page shows
+  let capped = false;                  // the page shows more folders than are watched
+  const watchers = new Map();          // what is watched → FSWatcher
+  const failed = new Set();            // what should be watched and is not (no watches left, a watch that was lost)
+  const openedAt = new Map();          // what is watched → when that watch was opened
+  let retryMs = 0;                     // the wait that is running, or ran last
+  let retryAt = 0;                     // nothing that failed is asked for again before this
+  let retryTimer = null;
+  let refused = false;                 // the system refused a watch in the pass that is under way
+  let said = null;                     // the `live` that was last reported
+  const pending = new Set();
+  let pendingGit = false;
+  let timer = null;
+  let firstAt = 0;
+
+  const slashed = (path) => (sep === '/' ? path : path.split(sep).join('/'));
+
+  function flush() {
+    timer = null;
+    if (closed || (!pending.size && !pendingGit)) return;
+    const change = { dirs: [...pending], git: pendingGit };
+    pending.clear();
+    pendingGit = false;
+    try { onChange(change); } catch { /* a listener's failure is not the watcher's */ }
+  }
+
+  // Sent a moment after the last change, and never later than `maxWaitMs` after the first of a burst.
+  function schedule() {
+    const now = Date.now();
+    if (!timer) firstAt = now;
+    else clearTimeout(timer);
+    const wait = Math.max(0, Math.min(debounceMs, firstAt + maxWaitMs - now));
+    timer = setTimeout(flush, wait);
+    timer.unref?.();
+  }
+
+  // One change, by its path below the root ('' is the root itself).
+  function note(rel) {
+    if (closed) return;
+    const path = slashed(rel || '');
+    if (path === '.git' || path.startsWith('.git/')) {
+      const inside = path.slice(5);
+      if (GIT_STATE_FILES.test(inside) || inside.startsWith('refs/')) pendingGit = true;
+    } else if (!path || !ignoresGit(path)) {
+      pendingGit = true;
+    }
+    const parent = path.includes('/') ? join(root, dirname(path)) : root;
+    if (wanted.has(parent)) pending.add(parent);
+    // A watched folder that was itself removed or renamed: whoever shows it reads it again and finds out.
+    const self = path ? join(root, path) : root;
+    if (self !== parent && wanted.has(self)) pending.add(self);
+    if (pending.size || pendingGit) schedule();
+  }
+
+  /**
+   * What is really watched. `scope`: every change below the project (`tree`), or only changes in the folders the
+   * page shows and in git's own files (`folders`: a change inside a closed folder is not seen). `live`: `full`
+   * when all of that is watched, `partial` when some of it could not be, `none` when the project's folder is not.
+   */
+  const state = () => ({
+    scope: strategy === 'recursive' ? 'tree' : 'folders',
+    live: failed.has(root) || !watchers.has(root) ? 'none' : failed.size || capped ? 'partial' : 'full',
+  });
+  function report() {
+    if (closed) return;
+    const is = state();
+    if (is.live === said) return;
+    said = is.live;
+    try { onState(is); } catch { /* a listener's failure is not the watcher's */ }
+  }
+
+  // Something that should be watched is not: everything that failed is asked for again together, after a wait.
+  // One wait covers whatever fails while it runs; the next one is twice as long, unless the watch that failed
+  // had held for a while (`heldSince`): that was no part of a run of failures.
+  function backOff(heldSince) {
+    const at = now();
+    if (retryTimer !== null && at < retryAt) return;
+    if (heldSince !== undefined && at - heldSince >= RETRY_QUIET_MS) retryMs = 0;
+    retryMs = retryMs ? Math.min(retryMs * 2, RETRY_MAX_MS) : RETRY_FIRST_MS;
+    retryAt = at + retryMs;
+    if (retryTimer !== null) clearTimer(retryTimer);
+    retryTimer = setTimer(() => { retryTimer = null; if (closed) return; sync(); report(); }, retryMs);
+    retryTimer?.unref?.();
+  }
+
+  function open(key, path, options, handler) {
+    if (watchers.has(key) || closed) return;
+    // Still in its wait: the folders the page shows do not ask the system again for a watch it just refused or lost.
+    if (failed.has(key) && now() < retryAt) return;
+    let watcher;
+    try { watcher = watch(path, { persistent: false, ...options }, handler); }
+    catch (error) {
+      // A folder that is gone says so in its next listing. Anything else (no watches left) is a change nobody
+      // will be told of: it is counted, and the page reads again by itself.
+      if (key === root || !NOT_THERE.has(error?.code)) { failed.add(key); refused = true; }
+      return;
+    }
+    failed.delete(key);
+    openedAt.set(key, now());
+    watcher.on?.('error', () => {
+      try { watcher.close(); } catch { /* already closed */ }
+      if (watchers.get(key) !== watcher) return;   // let go of since: not a watch that was lost
+      watchers.delete(key);
+      if (closed) return;
+      // Tried again after its wait; until then it is a watch that is not there.
+      if (key === root || exists(path)) { failed.add(key); backOff(openedAt.get(key)); }
+      report();
+      if (key === root) { try { onError(new Error('The watch on the project folder was lost.')); } catch { /* as above */ } } else note(relative(root, path));
+    });
+    watchers.set(key, watcher);
+  }
+
+  function sync() {
+    if (closed) return;
+    refused = false;
+    try { place(); } finally { if (refused) backOff(); }
+  }
+
+  function place() {
+    if (strategy === 'recursive') {
+      open(root, root, { recursive: true }, (type, name) => note(name ? String(name) : ''));
+      return;
+    }
+    for (const [key, watcher] of watchers) {
+      if (key === '.git' || wanted.has(key)) continue;
+      try { watcher.close(); } catch { /* already closed */ }
+      watchers.delete(key);
+      openedAt.delete(key);
+    }
+    for (const key of failed) if (key !== '.git' && !wanted.has(key)) failed.delete(key);
+    for (const dir of wanted) {
+      const rel = relative(root, dir);
+      open(dir, dir, {}, (type, name) => note(name ? join(rel, String(name)) : rel));
+    }
+    open('.git', join(root, '.git'), {}, (type, name) => { if (name) note(join('.git', String(name))); });
+  }
+
+  sync();
+  said = state().live;
+
+  return {
+    strategy,
+    /** The folders the page shows now (canonical paths, the root or below it). */
+    setDirs(dirs) {
+      const next = new Set([root]);
+      capped = false;
+      for (const dir of dirs || []) {
+        if (typeof dir !== 'string' || !(dir === root || dir.startsWith(root.endsWith(sep) ? root : root + sep)) || next.has(dir)) continue;
+        if (next.size >= MAX_WATCHED_DIRS) { capped = strategy !== 'recursive'; break; }
+        next.add(dir);
+      }
+      wanted = next;
+      sync();
+      report();
+    },
+    state,
+    count: () => watchers.size,
+    close() {
+      closed = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+      if (retryTimer !== null) clearTimer(retryTimer);
+      retryTimer = null;
+      for (const watcher of watchers.values()) { try { watcher.close(); } catch { /* already closed */ } }
+      watchers.clear();
+      pending.clear();
+    },
+  };
+}

package/neural-interface/lib/git-bash/bzip2.js

@@ -0,0 +1,339 @@
+// ═══════════════════════════════════════════
+// SynaBun — bzip2, read
+// ═══════════════════════════════════════════
+//
+// Git for Windows publishes its full installation as a .tar.bz2, and Node has
+// no bzip2. A Windows 10 tar.exe may not have one either (older builds stop at
+// "unable to run program bzip2 -d"), so SynaBun reads the file itself, the same
+// way on the build machine and on the user's: this decoder, then the tar
+// reader in install.js.
+//
+// The whole format of bzip2 1.0 (Julian Seward's): one stream or several
+// concatenated, each "BZh1".."BZh9", blocks of Huffman-coded move-to-front
+// values with their runs, the inverse Burrows-Wheeler transform, the final run
+// decoding. Every block's CRC is compared with the one it carries, and every
+// stream's combined CRC with its trailer: a block that decodes to anything else
+// than what was compressed stops the read. A "randomised" block (written only
+// by bzip2 0.9.0, before 1998) is refused rather than guessed at.
+//
+// What it hands out is the decompressed bytes, block by block
+// (bunzip2Blocks: a generator, so a caller can stop at any block, and see how
+// far into the file it got). Every problem is a Bzip2Error.
+//
+// No imports: install.js and the extraction worker load it, and so does a
+// build, from the application it stages.
+
+export class Bzip2Error extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'Bzip2Error';
+    this.code = 'unpack';
+  }
+}
+
+const BLOCK_MAGIC_HI = 0x314159;   // π
+const BLOCK_MAGIC_LO = 0x265359;
+const END_MAGIC_HI = 0x177245;     // √π
+const END_MAGIC_LO = 0x385090;
+const MAX_GROUPS = 6;
+const MAX_ALPHA = 258;
+const MAX_CODE_LEN = 20;
+const MAX_SELECTORS = 18002;
+const RUNA = 0;
+const RUNB = 1;
+const GROUP_SIZE = 50;
+
+/** CRC-32 as bzip2 has it: polynomial 0x04c11db7, most significant bit first. */
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i << 24;
+    for (let k = 0; k < 8; k++) c = (c & 0x80000000) ? (c << 1) ^ 0x04c11db7 : c << 1;
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+
+/** Reads a Buffer bit by bit, most significant bit first. */
+class BitReader {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.pos = 0;      // the next byte to take
+    this.bits = 0;     // what is held, in the low `count` bits
+    this.count = 0;
+  }
+
+  /** `n` bits (1 to 24) as a number. */
+  read(n) {
+    while (this.count < n) {
+      if (this.pos >= this.buffer.length) throw new Bzip2Error('The archive ends inside a compressed block.');
+      this.bits = ((this.bits << 8) | this.buffer[this.pos++]) >>> 0;
+      this.count += 8;
+    }
+    this.count -= n;
+    const value = (this.bits >>> this.count) & ((1 << n) - 1);
+    this.bits &= (1 << this.count) - 1;
+    return value;
+  }
+
+  bit() {
+    if (this.count === 0) {
+      if (this.pos >= this.buffer.length) throw new Bzip2Error('The archive ends inside a compressed block.');
+      this.bits = this.buffer[this.pos++];
+      this.count = 8;
+    }
+    this.count--;
+    const value = (this.bits >>> this.count) & 1;
+    this.bits &= (1 << this.count) - 1;
+    return value;
+  }
+
+  read32() {
+    return ((this.read(16) << 16) | this.read(16)) >>> 0;
+  }
+
+  /** Drop what is left of the current byte (a stream ends on a byte boundary). */
+  align() {
+    this.bits = 0;
+    this.count = 0;
+  }
+
+  get done() {
+    return this.count === 0 && this.pos >= this.buffer.length;
+  }
+}
+
+/** Canonical Huffman decoding tables of one group, as bzip2's hbCreateDecodeTables makes them. */
+function decodeTables(lengths, alphaSize) {
+  let minLen = 32;
+  let maxLen = 0;
+  for (let i = 0; i < alphaSize; i++) {
+    if (lengths[i] > maxLen) maxLen = lengths[i];
+    if (lengths[i] < minLen) minLen = lengths[i];
+  }
+  const perm = new Int32Array(MAX_ALPHA);
+  const base = new Int32Array(MAX_CODE_LEN + 2);
+  const limit = new Int32Array(MAX_CODE_LEN + 1).fill(-1);
+  let pp = 0;
+  for (let len = minLen; len <= maxLen; len++) for (let j = 0; j < alphaSize; j++) if (lengths[j] === len) perm[pp++] = j;
+  for (let i = 0; i < alphaSize; i++) base[lengths[i] + 1]++;
+  for (let i = 1; i < base.length; i++) base[i] += base[i - 1];
+  let vec = 0;
+  for (let len = minLen; len <= maxLen; len++) {
+    vec += base[len + 1] - base[len];
+    limit[len] = vec - 1;
+    vec <<= 1;
+  }
+  for (let len = minLen + 1; len <= maxLen; len++) base[len] = ((limit[len - 1] + 1) << 1) - base[len];
+  return { minLen, maxLen, perm, base, limit };
+}
+
+/** The next symbol of a group's code. */
+function nextSymbol(reader, table) {
+  let len = table.minLen;
+  let code = reader.read(len);
+  while (len <= table.maxLen && code > table.limit[len]) {
+    len++;
+    code = (code << 1) | reader.bit();
+  }
+  if (len > table.maxLen) throw new Bzip2Error('The archive holds a code its tables do not know.');
+  const index = code - table.base[len];
+  if (index < 0 || index >= MAX_ALPHA) throw new Bzip2Error('The archive holds a code its tables do not know.');
+  return table.perm[index];
+}
+
+/**
+ * One block, from just after its magic: its bytes (the final run decoding done) and the CRC it carries.
+ * `tt` is the block's workspace, as large as the stream's block size.
+ */
+function decodeBlock(reader, tt, blockSize) {
+  const storedCrc = reader.read32();
+  if (reader.bit()) throw new Bzip2Error('The archive has a randomised block (bzip2 0.9.0), which this reader does not read.');
+  const origPtr = reader.read(24);
+
+  // Which byte values the block uses.
+  const used = [];
+  const inUse16 = reader.read(16);
+  for (let i = 0; i < 16; i++) {
+    if (!(inUse16 & (0x8000 >>> i))) continue;
+    const bits = reader.read(16);
+    for (let j = 0; j < 16; j++) if (bits & (0x8000 >>> j)) used.push(i * 16 + j);
+  }
+  if (!used.length) throw new Bzip2Error('The archive has a block that uses no byte value.');
+  const alphaSize = used.length + 2;
+  const eob = used.length + 1;
+
+  // The Huffman groups and which one codes each run of fifty symbols.
+  const groups = reader.read(3);
+  if (groups < 2 || groups > MAX_GROUPS) throw new Bzip2Error('The archive has a block with an impossible number of code tables.');
+  const selectorCount = reader.read(15);
+  if (selectorCount < 1) throw new Bzip2Error('The archive has a block without code selectors.');
+  const mtfGroups = [0, 1, 2, 3, 4, 5].slice(0, groups);
+  const selectors = new Uint8Array(Math.min(selectorCount, MAX_SELECTORS));
+  for (let i = 0; i < selectorCount; i++) {
+    let j = 0;
+    while (reader.bit()) {
+      j++;
+      if (j >= groups) throw new Bzip2Error('The archive has a block with an impossible code selector.');
+    }
+    // Selectors past the most a block can use are read and dropped, as bzip2 1.0.8 does.
+    if (i >= MAX_SELECTORS) continue;
+    const value = mtfGroups[j];
+    for (let k = j; k > 0; k--) mtfGroups[k] = mtfGroups[k - 1];
+    mtfGroups[0] = value;
+    selectors[i] = value;
+  }
+
+  const tables = [];
+  for (let t = 0; t < groups; t++) {
+    const lengths = new Uint8Array(alphaSize);
+    let current = reader.read(5);
+    for (let i = 0; i < alphaSize; i++) {
+      for (;;) {
+        if (current < 1 || current > MAX_CODE_LEN) throw new Bzip2Error('The archive has a block with an impossible code length.');
+        if (!reader.bit()) break;
+        current += reader.bit() ? -1 : 1;
+      }
+      lengths[i] = current;
+    }
+    tables.push(decodeTables(lengths, alphaSize));
+  }
+
+  // The move-to-front values and their runs: the block before the inverse transform.
+  const counts = new Int32Array(256);
+  const order = new Uint8Array(256);
+  for (let i = 0; i < 256; i++) order[i] = i;
+  let length = 0;
+  let selector = 0;
+  let left = 0;
+  let table = null;
+  const next = () => {
+    if (left === 0) {
+      if (selector >= selectors.length) throw new Bzip2Error('The archive has a block that runs past its code selectors.');
+      table = tables[selectors[selector++]];
+      left = GROUP_SIZE;
+    }
+    left--;
+    return nextSymbol(reader, table);
+  };
+  let symbol = next();
+  for (;;) {
+    if (symbol === eob) break;
+    if (symbol === RUNA || symbol === RUNB) {
+      let run = 0;
+      let weight = 1;
+      do {
+        run += (symbol === RUNA ? 1 : 2) * weight;
+        weight <<= 1;
+        if (run > blockSize) throw new Bzip2Error('The archive has a block larger than its stream says blocks are.');
+        symbol = next();
+      } while (symbol === RUNA || symbol === RUNB);
+      const value = used[order[0]];
+      if (length + run > blockSize) throw new Bzip2Error('The archive has a block larger than its stream says blocks are.');
+      counts[value] += run;
+      tt.fill(value, length, length + run);
+      length += run;
+      continue;
+    }
+    if (length >= blockSize) throw new Bzip2Error('The archive has a block larger than its stream says blocks are.');
+    const index = symbol - 1;
+    const front = order[index];
+    order.copyWithin(1, 0, index);
+    order[0] = front;
+    const value = used[front];
+    counts[value]++;
+    tt[length++] = value;
+    symbol = next();
+  }
+  if (origPtr >= length) throw new Bzip2Error('The archive has a block whose start lies outside it.');
+
+  // The inverse Burrows-Wheeler transform: each byte's successor in the upper 24 bits.
+  const start = new Int32Array(256);
+  for (let i = 0, sum = 0; i < 256; i++) { start[i] = sum; sum += counts[i]; }
+  for (let i = 0; i < length; i++) {
+    const value = tt[i] & 0xff;
+    tt[start[value]++] |= i << 8;
+  }
+
+  // The final run decoding (four equal bytes and a count), with the CRC over what comes out.
+  let out = Buffer.allocUnsafe(Math.max(1024, length + (length >>> 2)));
+  let at = 0;
+  let crc = 0xffffffff;
+  const room = (need) => {
+    const bigger = Buffer.allocUnsafe(Math.max(need, out.length * 2));
+    out.copy(bigger, 0, 0, at);
+    out = bigger;
+  };
+  let pos = tt[origPtr] >>> 8;
+  let last = -1;
+  let same = 0;
+  for (let i = 0; i < length; i++) {
+    const entry = tt[pos];
+    const byte = entry & 0xff;
+    pos = entry >>> 8;
+    if (same === 4) {
+      if (at + byte > out.length) room(at + byte);
+      for (let k = 0; k < byte; k++) {
+        out[at++] = last;
+        crc = (crc << 8) ^ CRC_TABLE[((crc >>> 24) ^ last) & 0xff];
+      }
+      same = 0;
+      last = -1;
+      continue;
+    }
+    if (byte === last) same++;
+    else { last = byte; same = 1; }
+    if (at === out.length) room(at + 1);
+    out[at++] = byte;
+    crc = (crc << 8) ^ CRC_TABLE[((crc >>> 24) ^ byte) & 0xff];
+  }
+  crc = (~crc) >>> 0;
+  if (crc !== storedCrc) throw new Bzip2Error('A block of the archive does not decode to what was compressed (CRC mismatch).');
+  return { data: out.subarray(0, at), crc };
+}
+
+/**
+ * The decompressed bytes of `buffer` (one or more concatenated bzip2 streams), one block at a time. `progress`,
+ * when given, is told after each block how far into `buffer` the reader is.
+ * @param {Buffer} buffer
+ * @param {{ progress?: (consumed: number, total: number) => void }} [o]
+ */
+export function* bunzip2Blocks(buffer, { progress } = {}) {
+  const reader = new BitReader(buffer);
+  let streams = 0;
+  while (!reader.done) {
+    // Zero bytes after the last stream are padding some writers leave; anything else has to be a stream.
+    if (streams > 0 && buffer.subarray(reader.pos).every((byte) => byte === 0)) break;
+    if (reader.read(8) !== 0x42 || reader.read(8) !== 0x5a || reader.read(8) !== 0x68) throw new Bzip2Error(streams ? 'The archive has something after its last stream.' : 'The archive is not a bzip2 file.');
+    const level = reader.read(8) - 0x30;
+    if (level < 1 || level > 9) throw new Bzip2Error('The archive names an impossible block size.');
+    const blockSize = level * 100000;
+    const tt = new Uint32Array(blockSize);
+    let combined = 0;
+    for (;;) {
+      const hi = reader.read(24);
+      const lo = reader.read(24);
+      if (hi === BLOCK_MAGIC_HI && lo === BLOCK_MAGIC_LO) {
+        const block = decodeBlock(reader, tt, blockSize);
+        combined = (((combined << 1) | (combined >>> 31)) ^ block.crc) >>> 0;
+        progress?.(reader.pos, buffer.length);
+        if (block.data.length) yield block.data;
+        continue;
+      }
+      if (hi === END_MAGIC_HI && lo === END_MAGIC_LO) {
+        if (reader.read32() !== combined) throw new Bzip2Error('The archive does not decode to what was compressed (stream CRC mismatch).');
+        reader.align();
+        break;
+      }
+      throw new Bzip2Error('The archive has something that is not a bzip2 block.');
+    }
+    streams++;
+  }
+  if (!streams) throw new Bzip2Error('The archive is empty.');
+}
+
+/** All of `buffer`, decompressed (tests and small files). */
+export function bunzip2(buffer) {
+  const parts = [...bunzip2Blocks(buffer)];
+  return Buffer.concat(parts);
+}

package/neural-interface/lib/git-bash/claude-settings.js

@@ -0,0 +1,73 @@
+// ═══════════════════════════════════════════
+// SynaBun — Git Bash for the user's own `claude`
+// ═══════════════════════════════════════════
+//
+// Every Claude Code that SynaBun starts gets its Git Bash in its environment
+// (resolver.js gitBashChildEnv). A `claude` the user starts in another
+// terminal does not: on a PC whose only Git Bash is SynaBun's copy, that one
+// is named in the `env` block of ~/.claude/settings.json, which Claude Code
+// applies before it looks for Git Bash (checked in its 2.1.302 build:
+// applySafeConfigEnvironmentVariables applies the user settings' env in full,
+// in init(), before the Git Bash lookup).
+//
+//   SynaBun's copy is in use   env.CLAUDE_CODE_GIT_BASH_PATH = its bash.exe,
+//                              unless the user put a value of their own there
+//   it is not                  a value that is SynaBun's (a path inside one of
+//                              its copies) is removed; any other is left
+//
+// Windows only. The file is read and written by the caller's functions
+// (server.js readClaudeSettingsForWrite / writeClaudeSettings: a file that is
+// not JSON is never written over, and the write is atomic). Never throws.
+
+import { GIT_BASH_ENV, insideAny } from './resolver.js';
+
+/**
+ * Bring the user's settings in line with the Git Bash in use.
+ * @param {object} o
+ * @param {{ source: string|null, path: string|null }} o.resolution  resolver.js resolveGitBash()
+ * @param {string} o.settingsPath   ~/.claude/settings.json
+ * @param {(path: string) => object} o.read    {} when the file does not exist; throws when it is not JSON
+ * @param {(path: string, settings: object) => void} o.write
+ * @param {string[]} o.ownRoots     SynaBun's own Git folders
+ * @returns {{ state: 'skipped' | 'unchanged' | 'written' | 'removed' | 'kept-user-value' | 'error', value?: string|null, message?: string }}
+ */
+export function syncClaudeSettingsGitBash({ resolution, settingsPath, read, write, ownRoots = [], platform = process.platform }) {
+  if (platform !== 'win32' || !settingsPath) return { state: 'skipped' };
+  const ours = resolution?.source === 'bundled' || resolution?.source === 'downloaded' ? resolution.path : null;
+  let settings;
+  try { settings = read(settingsPath); } catch (error) {
+    return { state: 'error', message: String(error?.message || error) };
+  }
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)) return { state: 'error', message: `${settingsPath} does not hold a settings object.` };
+  const env = settings.env && typeof settings.env === 'object' && !Array.isArray(settings.env) ? settings.env : null;
+  const current = typeof env?.[GIT_BASH_ENV] === 'string' ? env[GIT_BASH_ENV] : null;
+  const isOurs = current !== null && insideAny(current, ownRoots);
+
+  if (ours) {
+    if (current === ours) return { state: 'unchanged', value: ours };
+    // A value of the user's own (one that does not work, or the resolver would have taken it) is theirs to change.
+    if (current !== null && !isOurs) return { state: 'kept-user-value', value: current };
+    settings.env = { ...(env || {}), [GIT_BASH_ENV]: ours };
+  } else {
+    if (!isOurs) return { state: 'unchanged', value: current };
+    const rest = { ...env };
+    delete rest[GIT_BASH_ENV];
+    if (Object.keys(rest).length) settings.env = rest;
+    else delete settings.env;
+  }
+  try {
+    write(settingsPath, settings);
+  } catch (error) {
+    return { state: 'error', message: String(error?.message || error) };
+  }
+  return ours ? { state: 'written', value: ours } : { state: 'removed', value: null };
+}
+
+/** The user's own value of CLAUDE_CODE_GIT_BASH_PATH in their settings, or null (what the resolver weighs). */
+export function settingsGitBashValue({ settingsPath, read }) {
+  try {
+    const settings = read(settingsPath);
+    const value = settings?.env?.[GIT_BASH_ENV];
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+  } catch { return null; }
+}

package/neural-interface/lib/git-bash/extract-worker.js

@@ -0,0 +1,34 @@
+// ═══════════════════════════════════════════
+// SynaBun — Git for Windows: the unpacking, in a thread of its own
+// ═══════════════════════════════════════════
+//
+// install.js unpackInWorker() starts this with what unpackAndCheck() takes and
+// a shared flag the server raises to stop it. The reading of the .tar.bz2, the
+// writing of some ten thousand files and the digest of what was written take
+// about a minute of CPU: here, they never hold the server's event loop. The
+// thread answers with messages: `step`, `progress` (a few times a second at
+// most), then `done` with the result or `error` with a GitBashError's code.
+
+import { parentPort, workerData } from 'node:worker_threads';
+import { asGitBashError, unpackAndCheck } from './install.js';
+
+const { flag, ...options } = workerData;
+let last = 0;
+
+try {
+  const result = unpackAndCheck({
+    ...options,
+    stopped: () => Atomics.load(flag, 0) === 1,
+    onStep: (step) => parentPort.postMessage({ type: 'step', step }),
+    onProgress: (progress) => {
+      const now = Date.now();
+      if (progress.consumed !== progress.total && now - last < 250) return;
+      last = now;
+      parentPort.postMessage({ type: 'progress', progress });
+    },
+  });
+  parentPort.postMessage({ type: 'done', result });
+} catch (failure) {
+  const error = asGitBashError(failure, 'unpack', 'The archive could not be unpacked.');
+  parentPort.postMessage({ type: 'error', code: error.code, message: error.message, detail: error.detail || null });
+}