token-goat 2.9.29 → 2.9.30

package/dist/token-goat-chunk-5KDMCMF2.mjs

@@ -0,0 +1,362 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  atomicWriteText,
+  ensureDirSync,
+  extractErrorMessage,
+  withFileLock
+} from "./token-goat-chunk-GOLEOXZP.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-VES7EL7O.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/worker_lifecycle.ts
+init_define_import_meta_env();
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/env_proxy.ts
+init_define_import_meta_env();
+var PROXY_VARS = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"];
+function proxyConfigured(env = process.env) {
+  return PROXY_VARS.some((k) => (env[k] ?? "").trim() !== "");
+}
+function nodeFetchHonoursEnvProxy(version = process.versions.node) {
+  const [major = 0, minor = 0] = version.split(".").map((n) => Number.parseInt(n, 10));
+  if (major >= 24) return true;
+  return major === 22 && minor >= 21;
+}
+function fetchBypassesProxy(env = process.env, nodeVersion = process.versions.node) {
+  return env["NODE_USE_ENV_PROXY"] === void 0 && proxyConfigured(env) && nodeFetchHonoursEnvProxy(nodeVersion);
+}
+function rerunWithEnvProxy(spawn2, argv = process.argv, env = process.env, nodeVersion = process.versions.node) {
+  if (!fetchBypassesProxy(env, nodeVersion)) return null;
+  const result = spawn2(process.execPath, [...process.execArgv, ...argv.slice(1)], { env: withEnvProxyEnabled(env, nodeVersion), stdio: "inherit" });
+  return result.status ?? 1;
+}
+function withEnvProxyEnabled(env, nodeVersion = process.versions.node) {
+  if (env["NODE_USE_ENV_PROXY"] !== void 0 || !proxyConfigured(env) || !nodeFetchHonoursEnvProxy(nodeVersion)) return env;
+  return { ...env, NODE_USE_ENV_PROXY: "1" };
+}
+
+// src/worker_lifecycle.ts
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+function resolvePollIntervalMs(explicit) {
+  if (explicit !== void 0) return explicit;
+  const parsed = parseInt(process.env["TG_WORKER_POLL_MS"] ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_POLL_INTERVAL_MS;
+}
+var WORKER_HEARTBEAT_STALE_MS = 6e4;
+var WORKER_HEARTBEAT_REFRESH_MS = 5e3;
+var WORKER_STARTUP_GRACE_MS = 1e4;
+var heartbeatWriteTimes = /* @__PURE__ */ new Map();
+function drainHeartbeatPathFor(dir) {
+  return path.join(dir, "queue", "drain-heartbeat");
+}
+function writeDrainHeartbeat(dir, force = false) {
+  const now = Date.now();
+  if (!force && now - (heartbeatWriteTimes.get(dir) ?? 0) < WORKER_HEARTBEAT_REFRESH_MS) return;
+  try {
+    atomicWriteText(drainHeartbeatPathFor(dir), `${process.pid}
+`);
+    heartbeatWriteTimes.set(dir, now);
+  } catch {
+  }
+}
+function hasFreshWorkerHeartbeat(dir, pid) {
+  try {
+    const heartbeatPath = drainHeartbeatPathFor(dir);
+    if (Date.now() - fs.statSync(heartbeatPath).mtimeMs > WORKER_HEARTBEAT_STALE_MS) return false;
+    return fs.readFileSync(heartbeatPath, "utf8").trim() === String(pid);
+  } catch {
+    return false;
+  }
+}
+function pidFileIsWithinStartupGrace(dir) {
+  try {
+    return Date.now() - fs.statSync(workerPidPath(dir)).mtimeMs < WORKER_STARTUP_GRACE_MS;
+  } catch {
+    return false;
+  }
+}
+function workerPidPath(dir = dataDir()) {
+  return path.join(dir, "worker.pid");
+}
+function workerStampPath(dir = dataDir()) {
+  return path.join(dir, "worker.stamp");
+}
+function workerErrorLogPath(dir) {
+  return path.join(dir, "worker-errors.log");
+}
+function oneLogLine(line) {
+  return displaySafeText(line.replace(/[\n\r]+$/, "")) + "\n";
+}
+function appendWorkerErrorLog(dir, line) {
+  try {
+    fs.appendFileSync(workerErrorLogPath(dir), oneLogLine(line));
+  } catch {
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function readPidFile(dir) {
+  try {
+    const raw = fs.readFileSync(workerPidPath(dir), "utf8").trim();
+    if (!/^\d+$/.test(raw)) return null;
+    return parseInt(raw, 10);
+  } catch {
+    return null;
+  }
+}
+function isWorkerRunning(dir = dataDir()) {
+  const pid = readPidFile(dir);
+  if (pid === null) return false;
+  return pidAlive(pid) && hasFreshWorkerHeartbeat(dir, pid);
+}
+function workerHealthCheckMarkerPath(dir) {
+  return path.join(dir, "worker-healthcheck.marker");
+}
+var WORKER_HEALTHCHECK_MIN_INTERVAL_MS = 5 * 60 * 1e3;
+function ensureWorkerAlive(dir = dataDir()) {
+  if (process.env["TOKEN_GOAT_NO_WORKER_SPAWN"] === "1") return;
+  const markerPath = workerHealthCheckMarkerPath(dir);
+  try {
+    const stat = fs.statSync(markerPath);
+    if (Date.now() - stat.mtimeMs < WORKER_HEALTHCHECK_MIN_INTERVAL_MS) return;
+  } catch {
+  }
+  try {
+    ensureDirSync(dir);
+    fs.writeFileSync(markerPath, "");
+  } catch {
+  }
+  const livePid = readPidFile(dir);
+  if (livePid !== null && pidAlive(livePid) && hasFreshWorkerHeartbeat(dir, livePid)) {
+    if (workerBundleMatches(dir)) return;
+    stopWorker(dir, livePid);
+    const nowPid = readPidFile(dir);
+    if (nowPid !== null && nowPid !== livePid) return;
+  }
+  try {
+    startDetachedWorker({ dataDir: dir });
+  } catch (e) {
+    if (e instanceof WorkerAlreadyRunningError) return;
+    try {
+      appendWorkerErrorLog(
+        dir,
+        `${(/* @__PURE__ */ new Date()).toISOString()} ensureWorkerAlive: auto-restart failed: ${extractErrorMessage(e)}
+`
+      );
+    } catch {
+    }
+  }
+}
+function stopWorker(dir = dataDir(), expectedPid) {
+  const pid = readPidFile(dir);
+  if (pid === null) return false;
+  if (expectedPid !== void 0 && pid !== expectedPid) return false;
+  const running = isWorkerRunning(dir);
+  if (running) {
+    try {
+      process.kill(pid);
+    } catch {
+    }
+  }
+  if (readPidFile(dir) === pid) {
+    try {
+      fs.rmSync(workerPidPath(dir), { force: true });
+    } catch {
+    }
+  }
+  return running;
+}
+var WorkerAlreadyRunningError = class extends Error {
+  constructor(message = "worker already running") {
+    super(message);
+    this.name = "WorkerAlreadyRunningError";
+  }
+};
+var WorkerDataDirUnwritableError = class extends Error {
+  constructor(dir, cause) {
+    super(`the data directory ${displaySafeText(dir)} cannot be written (${extractErrorMessage(cause)}), and the worker keeps its pid file, queue and index there; make it writable and run \`token-goat worker start\` again`, { cause });
+    this.name = "WorkerDataDirUnwritableError";
+  }
+};
+function dataDirWriteRefusal(dir) {
+  const probe = path.join(dir, `.write-probe-${process.pid}`);
+  try {
+    fs.writeFileSync(probe, "");
+  } catch (e) {
+    return e;
+  }
+  try {
+    fs.rmSync(probe, { force: true });
+  } catch {
+  }
+  return void 0;
+}
+function discardSpawnedWorker(child, pid) {
+  try {
+    process.kill(pid);
+  } catch {
+  }
+  child.unref();
+}
+function claimWorkerPidFile(dir, pid) {
+  const pidPath = workerPidPath(dir);
+  try {
+    fs.writeFileSync(pidPath, `${pid}
+`, { flag: "wx" });
+    return true;
+  } catch (e) {
+    if (e.code !== "EEXIST") throw e;
+  }
+  return withFileLock(`${pidPath}.reclaim`, () => reclaimStalePidFile(dir, pid), { waitMs: 0 }) ?? false;
+}
+function reclaimStalePidFile(dir, pid) {
+  const pidPath = workerPidPath(dir);
+  const existingPid = readPidFile(dir);
+  if (existingPid !== null && pidAlive(existingPid) && (hasFreshWorkerHeartbeat(dir, existingPid) || pidFileIsWithinStartupGrace(dir))) {
+    return false;
+  }
+  try {
+    fs.rmSync(pidPath, { force: true });
+  } catch {
+  }
+  try {
+    fs.writeFileSync(pidPath, `${pid}
+`, { flag: "wx" });
+    return true;
+  } catch (e2) {
+    if (e2.code === "EEXIST") return false;
+    throw e2;
+  }
+}
+function daemonEntryScript() {
+  const self = fileURLToPath(import.meta.url);
+  const launcher = path.join(path.dirname(self), "token-goat.mjs");
+  try {
+    if (fs.existsSync(launcher)) return launcher;
+  } catch {
+  }
+  return self;
+}
+function currentDaemonStamp() {
+  const entry = daemonEntryScript();
+  try {
+    const st = fs.statSync(entry);
+    return `${entry}|${st.size}|${Math.trunc(st.mtimeMs)}`;
+  } catch {
+    return entry;
+  }
+}
+function workerBundleMatches(dir) {
+  let raw;
+  try {
+    raw = fs.readFileSync(workerStampPath(dir), "utf8").trim();
+  } catch {
+    return false;
+  }
+  const parts = raw.split("|");
+  if (parts.length !== 3) return false;
+  const [entry, sizeStr, mtimeStr] = parts;
+  if (entry !== daemonEntryScript()) return true;
+  const size = Number(sizeStr);
+  const mtimeMs = Number(mtimeStr);
+  if (!Number.isFinite(size) || !Number.isFinite(mtimeMs)) return false;
+  try {
+    const st = fs.statSync(entry);
+    return st.size === size && Math.trunc(st.mtimeMs) === mtimeMs;
+  } catch {
+    return false;
+  }
+}
+function startDetachedWorker(opts) {
+  const pollIntervalMs = resolvePollIntervalMs(opts?.pollIntervalMs);
+  const dir = path.resolve(opts?.dataDir ?? dataDir());
+  try {
+    ensureDirSync(dir);
+  } catch (e) {
+    if (e.code !== "EEXIST" || !fs.existsSync(dir)) throw e;
+  }
+  const refusal = dataDirWriteRefusal(dir);
+  if (refusal !== void 0) throw new WorkerDataDirUnwritableError(dir, refusal);
+  const cwd = fs.existsSync(os.tmpdir()) ? os.tmpdir() : dir;
+  const child = spawn(
+    process.execPath,
+    [daemonEntryScript(), "--worker-daemon"],
+    {
+      cwd,
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: {
+        ...withEnvProxyEnabled(process.env),
+        TG_WORKER_POLL_MS: String(pollIntervalMs),
+        TG_WORKER_DATA_DIR: dir
+      }
+    }
+  );
+  child.on("error", () => void 0);
+  const pid = child.pid;
+  if (pid === void 0) {
+    throw new Error("startDetachedWorker: spawn produced no pid");
+  }
+  let claimed;
+  try {
+    claimed = claimWorkerPidFile(dir, pid);
+  } catch (e) {
+    discardSpawnedWorker(child, pid);
+    throw e;
+  }
+  if (!claimed) {
+    discardSpawnedWorker(child, pid);
+    throw new WorkerAlreadyRunningError();
+  }
+  try {
+    fs.writeFileSync(workerStampPath(dir), currentDaemonStamp());
+  } catch {
+  }
+  child.unref();
+  return pid;
+}
+
+export {
+  proxyConfigured,
+  nodeFetchHonoursEnvProxy,
+  fetchBypassesProxy,
+  rerunWithEnvProxy,
+  resolvePollIntervalMs,
+  drainHeartbeatPathFor,
+  writeDrainHeartbeat,
+  workerPidPath,
+  workerStampPath,
+  workerErrorLogPath,
+  oneLogLine,
+  appendWorkerErrorLog,
+  readPidFile,
+  isWorkerRunning,
+  ensureWorkerAlive,
+  stopWorker,
+  WorkerAlreadyRunningError,
+  WorkerDataDirUnwritableError,
+  dataDirWriteRefusal,
+  claimWorkerPidFile,
+  currentDaemonStamp,
+  startDetachedWorker
+};

package/dist/token-goat-chunk-5RG5SBL6.mjs

@@ -0,0 +1,221 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/code_fold.ts
+init_define_import_meta_env();
+var FOLDABLE_KINDS = /* @__PURE__ */ new Set(["function", "method", "func", "def", "fn", "procedure", "constructor", "variable"]);
+var MIN_FOLDED_ROWS = 3;
+function planBodyFolds(rows, spans, keep, minSpan) {
+  if (rows.length === 0 || spans.length === 0 || keep < 1) return [];
+  const rowAt = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (row !== void 0) rowAt.set(row.no, i);
+  }
+  const ordered = [...spans].sort((a, b) => a.lineStart - b.lineStart || b.lineEnd - a.lineEnd);
+  let firstDeliveredLine = null;
+  for (const line of rowAt.keys()) if (firstDeliveredLine === null || line < firstDeliveredLine) firstDeliveredLine = line;
+  const folds = [];
+  let foldedThrough = -1;
+  for (const span of ordered) {
+    if (!FOLDABLE_KINDS.has(span.kind)) continue;
+    if (span.lineEnd - span.lineStart + 1 < minSpan) continue;
+    if (span.lineStart <= foldedThrough) continue;
+    if (firstDeliveredLine !== null && span.lineStart < firstDeliveredLine) continue;
+    const firstFolded = span.lineStart + keep;
+    if (firstFolded > span.lineEnd) continue;
+    let startIdx = -1;
+    let endIdx = -1;
+    for (let line = firstFolded; line <= span.lineEnd; line++) {
+      const idx = rowAt.get(line);
+      if (idx === void 0) continue;
+      if (startIdx < 0) startIdx = idx;
+      endIdx = idx;
+    }
+    if (startIdx < 0 || endIdx < startIdx) continue;
+    const len = endIdx - startIdx + 1;
+    const firstRow = rows[startIdx];
+    const lastRow = rows[endIdx];
+    if (firstRow === void 0 || lastRow === void 0) continue;
+    if (lastRow.no - firstRow.no + 1 !== len) continue;
+    if (len < MIN_FOLDED_ROWS) continue;
+    folds.push({ startIdx, len, name: span.name, kind: "body", declLine: span.lineStart, firstLine: firstRow.no, lastLine: lastRow.no });
+    foldedThrough = span.lineEnd;
+  }
+  return folds;
+}
+var SLASH_STAR = { line: ["//"], open: "/*", close: "*/" };
+function advanceTemplateState(text, inTemplate) {
+  let t = inTemplate;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "`") {
+      t = !t;
+      continue;
+    }
+    if (t) continue;
+    if (c === "/" && text[i + 1] === "/") return t;
+    if (c === "'" || c === '"') {
+      const q = c;
+      i++;
+      while (i < text.length && text[i] !== q) {
+        if (text[i] === "\\") i++;
+        i++;
+      }
+    }
+  }
+  return t;
+}
+var HASH = { line: ["#"] };
+var DOUBLE_DASH = { line: ["--"] };
+var COMMENT_SYNTAX = new Map([
+  ...["ts", "tsx", "js", "jsx", "mjs", "cjs", "java", "c", "h", "cc", "cpp", "hpp", "cs", "go", "rs", "swift", "kt", "scala", "php", "dart"].map(
+    (ext) => [ext, SLASH_STAR]
+  ),
+  ...["py", "rb", "sh", "bash", "zsh", "pl", "r"].map((ext) => [ext, HASH]),
+  ...["sql", "lua", "hs"].map((ext) => [ext, DOUBLE_DASH])
+]);
+function commentSyntaxFor(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot < 0) return null;
+  return COMMENT_SYNTAX.get(path.slice(dot + 1).toLowerCase()) ?? null;
+}
+function planCommentFolds(rows, syntax, commentKeep, commentMinBlock, occupied) {
+  if (syntax === null || rows.length === 0 || commentKeep < 1 || commentMinBlock < 1) return [];
+  const folds = [];
+  let i = 0;
+  let inBlock = false;
+  const tracksTemplates = syntax.open === "/*";
+  let inTemplate = false;
+  while (i < rows.length) {
+    const start = i;
+    while (i < rows.length) {
+      const text = rows[i]?.text ?? "";
+      const trimmed = text.trim();
+      if (tracksTemplates) {
+        const wasInTemplate = inTemplate;
+        inTemplate = advanceTemplateState(text, inTemplate);
+        if (wasInTemplate || inTemplate) {
+          inBlock = false;
+          break;
+        }
+      }
+      if (inBlock) {
+        if (syntax.close !== void 0 && trimmed.includes(syntax.close)) inBlock = false;
+        i++;
+        continue;
+      }
+      if (syntax.open !== void 0 && trimmed.startsWith(syntax.open)) {
+        if (syntax.close === void 0 || !trimmed.slice(syntax.open.length).includes(syntax.close)) inBlock = true;
+        i++;
+        continue;
+      }
+      if (syntax.line.some((p) => trimmed.startsWith(p))) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    const runLen = i - start;
+    if (runLen >= commentMinBlock) {
+      const foldStart = start + commentKeep;
+      const len = i - foldStart;
+      const firstRow = rows[foldStart];
+      const lastRow = rows[i - 1];
+      if (len >= MIN_FOLDED_ROWS && firstRow !== void 0 && lastRow !== void 0 && lastRow.no - firstRow.no + 1 === len) {
+        let clear = true;
+        for (let k = foldStart; k < i; k++) {
+          if (occupied.has(k)) {
+            clear = false;
+            break;
+          }
+        }
+        if (clear) folds.push({ startIdx: foldStart, len, name: "comment", kind: "comment", firstLine: firstRow.no, lastLine: lastRow.no });
+      }
+    }
+    if (i === start) i++;
+  }
+  return folds;
+}
+function mergeFolds(body, comment) {
+  const merged = [...body, ...comment].sort((a, b) => a.startIdx - b.startIdx || b.len - a.len);
+  const out = [];
+  let through = -1;
+  for (const fold of merged) {
+    if (fold.startIdx <= through) continue;
+    out.push(fold);
+    through = fold.startIdx + fold.len - 1;
+  }
+  return out;
+}
+var MAX_FOLD_DETAIL = 400;
+var FOLD_DETAIL_SUFFIX_BUDGET = 16;
+var PROSE_FOLD_MIN_CHARS = 400;
+var PROSE_FOLD_MAX_KEEP_RATIO = 0.6;
+var PROSE_FOLD_MIN_SENTENCE = 40;
+var PROSE_STRUCTURAL_RE = /^\s*(?:#{1,6}\s|```|~~~|\||>|\d+[.)]\s*$|[-*+]\s*$)/;
+var PROSE_FENCE_RE = /^\s*(?:```|~~~)/;
+var PROSE_ABBREV_RE = /(?:\b(?:e\.g|i\.e|vs|cf|etc|approx|al|Dr|Mr|Ms|St|Fig|No)\.|\b[^\W\d_]\.)$/;
+function proseSentenceEnd(text) {
+  for (const m of text.matchAll(/[.!?][*_`)\]"'”’]*(?=\s|$)/gu)) {
+    const term = m.index + 1;
+    const end = m.index + m[0].length;
+    if (end < PROSE_FOLD_MIN_SENTENCE) continue;
+    if (PROSE_ABBREV_RE.test(text.slice(0, term))) continue;
+    return end;
+  }
+  return null;
+}
+function planProseFolds(rows, claimed) {
+  const folds = [];
+  let inFence = false;
+  for (let i = 0; i < rows.length; i++) {
+    if (claimed.has(i)) continue;
+    const row = rows[i];
+    if (row === void 0) continue;
+    const text = row.text;
+    if (PROSE_FENCE_RE.test(text)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    if (text.length < PROSE_FOLD_MIN_CHARS) continue;
+    if (PROSE_STRUCTURAL_RE.test(text)) continue;
+    const end = proseSentenceEnd(text);
+    if (end === null || end > text.length * PROSE_FOLD_MAX_KEEP_RATIO) continue;
+    folds.push({ startIdx: i, len: 1, name: "paragraph", kind: "prose", keep: text.slice(0, end), firstLine: row.no, lastLine: row.no });
+  }
+  return folds;
+}
+function foldDetail(path, folds, maxLen = MAX_FOLD_DETAIL) {
+  const head = `${path}::`;
+  const ids = folds.map((f) => f.kind === "body" ? f.name : `#${f.firstLine}-${f.lastLine}`);
+  const budget = maxLen - head.length - FOLD_DETAIL_SUFFIX_BUDGET;
+  const kept = [];
+  let used = 0;
+  for (const id of ids) {
+    const add = kept.length === 0 ? id.length : id.length + 1;
+    if (used + add > budget) break;
+    kept.push(id);
+    used += add;
+  }
+  const dropped = ids.length - kept.length;
+  if (kept.length === 0) return `${head}+${ids.length} folds`;
+  return dropped > 0 ? `${head}${kept.join(",")},+${dropped} more` : `${head}${kept.join(",")}`;
+}
+
+export {
+  planBodyFolds,
+  commentSyntaxFor,
+  planCommentFolds,
+  mergeFolds,
+  planProseFolds,
+  foldDetail
+};

package/dist/{token-goat-chunk-RRNZMM3A.mjs → token-goat-chunk-5Y6ZYL6U.mjs}

@@ -3107,6 +3107,21 @@ function encodePng(width, height, rgba) {
   const iendChunk = makePngChunk("IEND", Buffer.alloc(0));
   return Buffer.concat([signature, ihdrChunk, idatChunk, iendChunk]);
 }
+function bmpHasAlpha(buf, layout) {
+  const { compression, bpp, pixelOffset, rowStride, width, height } = layout;
+  if (bpp !== 32) return false;
+  const dibSize = buf.readUInt32LE(14);
+  if (compression === 3 && dibSize >= 56 && buf.length >= 14 + 56) {
+    return buf.readUInt32LE(14 + 52) !== 0;
+  }
+  for (let y = 0; y < height; y++) {
+    const rowOffset = pixelOffset + y * rowStride;
+    for (let x = 0; x < width; x++) {
+      if (buf[rowOffset + x * 4 + 3] !== 0) return true;
+    }
+  }
+  return false;
+}
 function decodeBmp(buf) {
   if (buf.length < 54 || buf[0] !== 66 || buf[1] !== 77) {
     throw new Error("Invalid BMP signature");
@@ -3125,8 +3140,12 @@ function decodeBmp(buf) {
     throw new Error("Unsupported BMP bit depth: " + bpp);
   }
   assertDecodableSize("BMP", width, height, 4);
-  const outRgba = Buffer.alloc(width * height * 4);
   const rowStride = Math.floor((bpp * width + 31) / 32) * 4;
+  if (pixelOffset + (height - 1) * rowStride + width * (bpp / 8) > buf.length) {
+    throw new Error("BMP pixel data truncated");
+  }
+  const outRgba = Buffer.alloc(width * height * 4);
+  const alphaIsReal = bmpHasAlpha(buf, { compression, bpp, pixelOffset, rowStride, width, height });
   for (let y = 0; y < height; y++) {
     const srcY = topDown ? y : height - 1 - y;
     const rowOffset = pixelOffset + srcY * rowStride;
@@ -3143,7 +3162,7 @@ function decodeBmp(buf) {
         outRgba[outIdx] = buf[pxOffset + 2] ?? 0;
         outRgba[outIdx + 1] = buf[pxOffset + 1] ?? 0;
         outRgba[outIdx + 2] = buf[pxOffset] ?? 0;
-        outRgba[outIdx + 3] = buf[pxOffset + 3] ?? 255;
+        outRgba[outIdx + 3] = alphaIsReal ? buf[pxOffset + 3] ?? 255 : 255;
       }
     }
   }

package/dist/{token-goat-chunk-GLXRTTLE.mjs → token-goat-chunk-64FBPDTK.mjs}

@@ -10,18 +10,22 @@ import {
   querySheet,
   rangeSheet,
   xlsxColumns
-} from "./token-goat-chunk-PYSUADX4.mjs";
-import "./token-goat-chunk-DNSPXQXQ.mjs";
+} from "./token-goat-chunk-RZRTDST7.mjs";
+import "./token-goat-chunk-N2NMER56.mjs";
 import "./token-goat-chunk-3BTK54F3.mjs";
-import "./token-goat-chunk-UXSXQQIY.mjs";
+import "./token-goat-chunk-4FVIAHSI.mjs";
+import "./token-goat-chunk-7IN2MKDS.mjs";
+import "./token-goat-chunk-U4N3BN2W.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-IVKIZWAB.mjs";
 import "./token-goat-chunk-XTQAOTSO.mjs";
 import "./token-goat-chunk-AH6QILZM.mjs";
-import "./token-goat-chunk-XYWPOSCN.mjs";
-import "./token-goat-chunk-TCQANXYC.mjs";
-import "./token-goat-chunk-NMTKNYGF.mjs";
-import "./token-goat-chunk-MELOKFDJ.mjs";
 import "./token-goat-chunk-Y4AFKTHK.mjs";
-import "./token-goat-chunk-JTKCQMQA.mjs";
+import "./token-goat-chunk-GOLEOXZP.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-VES7EL7O.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {
   XlsxScanTooLargeError,