sparkforensics-cli 0.1.0

package/vendor-core/shs-fetch.js

@@ -0,0 +1,196 @@
+import { unzipSync, Gunzip } from './vendor/fflate.js';
+import { createLz4BlockDecoder } from './lz4-block.js';
+import { Decompress as ZstdDecompress } from './vendor/fzstd.js';
+import { createSnappyBlockDecoder } from './snappy-block.js';
+import { buildProxyRequestUrl, isShsErrorCode } from './shs-request.js';
+import { dispatchLine, buildChunkDecoder, emitParseCompletion,                  } from './event-handlers.js';
+import { ShsProxyErrorBodySchema } from './shs-schemas.js';
+import { naturalCompare, reassembleRollingEntries } from './rolling-log-reassembly.js';
+
+export { naturalCompare, reassembleRollingEntries };
+
+// Sniff a compression codec from leading magic bytes: gzip (1f 8b), Zstandard
+// (28 b5 2f fd), Spark's custom "LZ4Block" framing, or Spark's Snappy framing
+// (org.xerial.snappy's "\x82SNAPPY\0" header). Returns 'gz' | 'zstd' | 'lz4' |
+// 'snappy' | null. More robust than a filename suffix: a dropped SHS log may
+// have no extension.
+export function sniffCodec(bytes            )                                          {
+  if (bytes.length >= 2 && bytes[0] === 0x1f && bytes[1] === 0x8b) return 'gz';
+  if (bytes.length >= 4 && bytes[0] === 0x28 && bytes[1] === 0xb5 && bytes[2] === 0x2f && bytes[3] === 0xfd) return 'zstd';
+  const LZ4_MAGIC = [76, 90, 52, 66, 108, 111, 99, 107]; // "LZ4Block"
+  if (bytes.length >= 8 && LZ4_MAGIC.every((b, i) => bytes[i] === b)) return 'lz4';
+  const SNAPPY_MAGIC = [0x82, 0x53, 0x4e, 0x41, 0x50, 0x50, 0x59, 0x00]; // 0x82 'S' 'N' 'A' 'P' 'P' 'Y' 0x00
+  if (bytes.length >= 8 && SNAPPY_MAGIC.every((b, i) => bytes[i] === b)) return 'snappy';
+  return null;
+}
+
+// Streams one already-in-memory zip entry through its codec's block-by-block
+// decoder, invoking `onChunk` per decompressed piece; never materializes the
+// whole decompressed entry as one buffer. A giant single-segment zstd frame
+// (or gzip member) declares its full content size in the header; one-shotting
+// it (fzstd's `decompress()`, fflate's `gunzipSync()`) allocates that entire
+// size as a single ArrayBuffer up front, which can exceed what the browser
+// will allocate for a multi-GB event log ("Array buffer allocation failed").
+// fflate's Gunzip and fzstd's Decompress are untyped vendor JS (plain
+// prototype classes, not `class` declarations), so TS can't infer a
+// construct signature for them; this local shape is just enough to type
+// the two call sites below without touching the vendored files.
+                                                                           
+                                                                                           
+
+function decodeEntry(name        , raw            , onChunk                             )       {
+  const codec = sniffCodec(raw);
+  if (codec === 'lz4' || name.endsWith('.lz4')) {
+    const lz4 = createLz4BlockDecoder(onChunk);
+    lz4.push(raw);
+    lz4.end();
+  } else if (codec === 'gz' || name.endsWith('.gz')) {
+    new (Gunzip                                   )(onChunk).push(raw, true);
+  } else if (codec === 'zstd' || name.endsWith('.zstd') || name.endsWith('.zst')) {
+    new (ZstdDecompress                                   )(onChunk).push(raw, true);
+  } else if (codec === 'snappy' || name.endsWith('.snappy')) {
+    const snappy = createSnappyBlockDecoder(onChunk);
+    snappy.push(raw);
+    snappy.end();
+  } else {
+    onChunk(raw);
+  }
+}
+
+                                     
+
+function emitShsError(emit        , code        )       {
+  emit({ type: 'error', source: 'shs', code });
+}
+
+export async function runParseFromUrl(
+  request         ,
+  state             ,
+  { fetchImpl = fetch, emit = (msg         ) => self.postMessage(msg) }                                              = {}
+)                {
+  // buildProxyRequestUrl is still-untyped JS (./shs-request.js, a plain
+  // untyped .js sibling); `request`'s real shape isn't pinned down here.
+  const url = buildProxyRequestUrl(request                                              );
+
+  let res;
+  try {
+    res = await fetchImpl(url);
+  } catch {
+    emitShsError(emit, 'local-server-unavailable');
+    return;
+  }
+  if (res.status === 404) {
+    emitShsError(emit, 'local-server-unavailable');
+    return;
+  }
+  if (!res.ok) {
+    let code = 'access-or-upstream-failure';
+    try {
+      const body = ShsProxyErrorBodySchema.parse(await res.json());
+      if (isShsErrorCode(body.code)) code = body.code;
+    } catch { /* Malformed proxy errors, or a body that fails schema validation, retain the generic safe code: same silent-skip treatment as a log-line validation failure. */ }
+    emitShsError(emit, code);
+    return;
+  }
+
+  if (!res.body) {
+    emitShsError(emit, 'invalid-event-log');
+    return;
+  }
+
+  let zipBytes;
+  let total;
+  try {
+    total = Number(res.headers.get('content-length')) || null;
+    const reader = res.body.getReader();
+    const chunks = [];
+    let received = 0;
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      received += value.length;
+      if (!total || received < total) {
+        emit({ type: 'progress', pct: total ? (received / total) * 0.5 : null, linesProcessed: 0 });
+      }
+    }
+    zipBytes = new Uint8Array(received);
+    let writeOffset = 0;
+    for (const chunk of chunks) { zipBytes.set(chunk, writeOffset); writeOffset += chunk.length; }
+  } catch {
+    emitShsError(emit, 'local-server-unavailable');
+    return;
+  }
+
+  const contentType = res.headers.get('content-type') || '';
+  if (contentType.startsWith('text/html')) {
+    emitShsError(emit, 'local-server-unavailable');
+    return;
+  }
+
+  // The in-loop guard above intentionally withholds the tick for the chunk that
+  // completes the download (received === total), to avoid double-emitting it here.
+  // Emit it now that we know the download is complete: this is the one place a
+  // determinate download is guaranteed to reach pct 0.5. Indeterminate downloads
+  // (no Content-Length) already got their final tick from inside the loop, since
+  // the loop's guard never withholds when total is null.
+  if (total) {
+    emit({ type: 'progress', pct: 0.5, linesProcessed: 0 });
+  }
+  decodeShsArchive(zipBytes, state, emit);
+}
+
+export function decodeShsArchive(zipBytes            , state             , emit        )       {
+  let entries                            ;
+  try {
+    entries = unzipSync(zipBytes);
+  } catch {
+    emitShsError(emit, 'invalid-event-log');
+    return;
+  }
+  const allNames = Object.keys(entries);
+  const isRolling = allNames.some(n => /^events_\d+_/.test(n));
+  let names;
+  if (isRolling) {
+    try {
+      names = reassembleRollingEntries(allNames);
+    } catch {
+      emitShsError(emit, 'invalid-event-log');
+      return;
+    }
+  } else {
+    names = allNames.filter(n => n.toLowerCase() !== 'appstatus').sort(naturalCompare);
+  }
+  if (names.length === 0) {
+    emitShsError(emit, 'invalid-event-log');
+    return;
+  }
+
+  const decoder = buildChunkDecoder();
+  let linesProcessed = 0;
+  for (const name of names) {
+    try {
+      decodeEntry(name, entries[name], (bytes) => {
+        for (const line of decoder.decode(bytes)) {
+          dispatchLine(line, state, emit);
+          linesProcessed++;
+          if (linesProcessed % 2000 === 0) {
+            emit({ type: 'progress', pct: null, linesProcessed });
+          }
+        }
+      });
+    } catch {
+      emitShsError(emit, 'invalid-event-log');
+      return;
+    }
+  }
+  for (const line of decoder.flush()) {
+    dispatchLine(line, state, emit);
+  }
+
+  if (!state.app) {
+    emitShsError(emit, 'invalid-event-log');
+    return;
+  }
+  emitParseCompletion(state, emit, linesProcessed);
+}

package/vendor-core/shs-load.js

@@ -0,0 +1,121 @@
+import { validateShsRequest } from './shs-request.js';
+import { fetchShsEventLog } from './proxy.js';
+import { decodeShsArchive } from './parser-worker.js';
+import { collectViaDispatch } from './cli/collect-run.js';
+import { deriveEvidenceAvailability } from './evidence-availability.js';
+import { mcpError } from './mcp-error.js';
+                                           
+
+function envInt(name        , fallback        )         {
+  const v = Number(process.env[name]);
+  return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+
+export const DEFAULT_MAX_ARCHIVE_BYTES = envInt('SPARKFORENSICS_MAX_ARCHIVE_BYTES', 1024 * 1024 * 1024);
+// Same knob the proxy uses: fetchShsEventLog covers the header phase; this
+// covers the body, per chunk, so progressing downloads of any size are fine.
+export const DEFAULT_IDLE_TIMEOUT_MS = envInt('SPARKFORENSICS_SHS_TIMEOUT_MS', 30_000);
+
+function collectShsAppModel(zipBytes            )                                                        {
+  return collectViaDispatch(
+    (state, emit) => decodeShsArchive(zipBytes, state, emit),
+    (msg) => {
+      const m = msg                                       ;
+      return mcpError(m?.code ?? 'invalid-event-log', m?.message ?? 'Failed to decode SHS archive.');
+    },
+  );
+}
+
+// Races one reader.read() against a fresh idle timer. The losing read() stays
+// pending after a timeout; reader.cancel() in the caller settles it.
+function readWithIdleTimeout(
+  reader                                         ,
+  idleTimeoutMs        ,
+)                                                {
+  let timer                               ;
+  const stalled                 = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(mcpError(
+      'upstream-unreachable',
+      `SHS archive body stalled for ${idleTimeoutMs} ms (override with SPARKFORENSICS_SHS_TIMEOUT_MS).`,
+    )), idleTimeoutMs);
+  });
+  return Promise.race([reader.read(), stalled]).finally(() => clearTimeout(timer));
+}
+
+// Reads the archive body with a byte cap: an unbounded arrayBuffer() on a
+// hostile or misconfigured SHS response would OOM the long-running process.
+// The per-chunk idle timeout keeps a stalled body from hanging the call
+// forever with headers already received.
+async function readArchiveBytes(upstream          , maxBytes        , idleTimeoutMs        )                      {
+  const tooLarge = () => mcpError(
+    'archive-too-large',
+    `SHS archive exceeds the ${maxBytes}-byte cap (override with SPARKFORENSICS_MAX_ARCHIVE_BYTES).`,
+  );
+  const declared = Number(upstream.headers?.get?.('content-length'));
+  if (Number.isFinite(declared) && declared > maxBytes) throw tooLarge();
+
+  // fetchShsEventLog (./proxy.js, a plain untyped .js sibling)
+  // already checks `!upstream.body` and returns `{ ok: false }` before ever
+  // returning `{ ok: true, upstream }`, so `body` is guaranteed present here
+  // even though DOM's Response.body type is nullable.
+  const reader = upstream.body .getReader();
+  // Grown geometrically instead of preallocated at `maxBytes`: a typical
+  // archive is nowhere near the cap, so starting small (or at the declared
+  // content-length, when trustworthy) and doubling on demand keeps peak
+  // memory close to the actual download size. Chunks are copied straight into
+  // this buffer as they arrive rather than buffered in an array and copied
+  // once at the end, so the previous ~2x-of-total peak (chunk array + a
+  // freshly allocated same-size output buffer, both live during the final
+  // copy) no longer happens.
+  let buf = new Uint8Array(Number.isFinite(declared) && declared > 0 ? Math.min(declared, maxBytes) : 65536);
+  let total = 0;
+  for (;;) {
+    let done                     , value                        ;
+    try {
+      ({ done, value } = await readWithIdleTimeout(reader, idleTimeoutMs));
+    } catch (err) {
+      await reader.cancel().catch(() => {});
+      throw err;
+    }
+    if (done) break;
+    if (value) {
+      const newTotal = total + value.byteLength;
+      if (newTotal > maxBytes) {
+        await reader.cancel().catch(() => {});
+        throw tooLarge();
+      }
+      if (newTotal > buf.length) {
+        const grown = new Uint8Array(Math.min(maxBytes, Math.max(newTotal, buf.length * 2)));
+        grown.set(buf);
+        buf = grown;
+      }
+      buf.set(value, total);
+      total = newTotal;
+    }
+  }
+  return buf.subarray(0, total);
+}
+
+// ./proxy.js is a plain, untyped .js file whose exported fetchShsEventLog
+// TS can only infer a loose shape for. Its real (verified by reading
+// proxy.js) contract is this
+// discriminated union (either branch, never a mix), so it's asserted here
+// once at the boundary rather than widening every downstream read.
+                                                                                      
+
+export async function resolveFromShs(
+  shsBaseUrl        ,
+  appId        ,
+  attemptId         ,
+  opts                                                                                 = {},
+)                    {
+  const { fetchImpl = fetch, maxArchiveBytes = DEFAULT_MAX_ARCHIVE_BYTES, idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS } = opts;
+  const validated = validateShsRequest({ baseUrl: shsBaseUrl, appId, attemptId: attemptId ?? '' });
+  if (!validated.request) throw mcpError('access-or-upstream-failure', 'Invalid SHS request parameters.');
+  const fetched = await fetchShsEventLog(validated.request, { fetchImpl })                   ;
+  if (!fetched.ok) throw mcpError(fetched.code, `SHS fetch failed: ${fetched.code}`);
+  const zipBytes = await readArchiveBytes(fetched.upstream, maxArchiveBytes, idleTimeoutMs);
+  const { appModel, skippedLines } = await collectShsAppModel(zipBytes);
+  appModel.evidenceAvailability = deriveEvidenceAvailability(appModel, { skippedLines });
+  return appModel;
+}

package/vendor-core/shs-request.js

@@ -0,0 +1,101 @@
+export const SHS_ERROR_CODES = new Set([
+  'local-server-unavailable',
+  'upstream-unreachable',
+  'application-not-found',
+  'access-or-upstream-failure',
+  'invalid-event-log',
+]);
+
+const APP_ID_PATTERNS = [
+  /^application_\d+_\d+$/,
+  /^local-\d+$/,
+  /^app-[A-Za-z0-9][A-Za-z0-9._-]*$/,
+  /^spark-[A-Za-z0-9][A-Za-z0-9._~-]*$/,
+  /^driver-\d+$/,
+];
+const ATTEMPT_ID_RE = /^(?!\.{1,2}$)[A-Za-z0-9][A-Za-z0-9._~-]*$/;
+
+function trimString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeBaseUrl(value) {
+  const baseUrl = trimString(value);
+  if (!baseUrl || baseUrl.includes('?') || baseUrl.includes('#')) return null;
+
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    return null;
+  }
+
+  if (
+    (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+    || parsed.username
+    || parsed.password
+    || parsed.search
+    || parsed.hash
+  ) return null;
+
+  parsed.pathname = `${parsed.pathname.replace(/\/+$/, '')}/`;
+  return parsed.toString();
+}
+
+function isValidAppId(appId) {
+  return APP_ID_PATTERNS.some((pattern) => pattern.test(appId));
+}
+
+function isValidAttemptId(attemptId) {
+  return ATTEMPT_ID_RE.test(attemptId);
+}
+
+export function validateShsRequest({ baseUrl = '', appId = '', attemptId = '' } = {}) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const normalizedAppId = trimString(appId);
+  const normalizedAttemptId = trimString(attemptId);
+  const errors = {
+    baseUrl: normalizedBaseUrl ? null : 'Enter an absolute HTTP(S) base URL without credentials, query, or fragment.',
+    appId: isValidAppId(normalizedAppId) ? null : 'Enter a supported Spark application ID.',
+    attemptId: !normalizedAttemptId || isValidAttemptId(normalizedAttemptId)
+      ? null
+      : 'Enter a URL-path-safe attempt ID.',
+  };
+
+  if (errors.baseUrl || errors.appId || errors.attemptId) return { request: null, errors };
+
+  return {
+    request: {
+      baseUrl: normalizedBaseUrl,
+      appId: normalizedAppId,
+      attemptId: normalizedAttemptId || null,
+    },
+    errors,
+  };
+}
+
+export function isShsRequestValid(result) {
+  // validateShsRequest guarantees `request` is null iff any field errored,
+  // so a non-null request already implies every error is null.
+  return result?.request != null;
+}
+
+export function buildProxyRequestUrl({ baseUrl, appId, attemptId }) {
+  const params = [
+    ['baseUrl', baseUrl],
+    ['appId', appId],
+  ];
+  if (attemptId !== null) params.push(['attemptId', attemptId]);
+  return `/shs-proxy?${params.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join('&')}`;
+}
+
+export function buildUpstreamUrl({ baseUrl, appId, attemptId }) {
+  const segments = ['api', 'v1', 'applications', appId];
+  if (attemptId) segments.push(attemptId);
+  segments.push('logs');
+  return new URL(segments.map(encodeURIComponent).join('/'), baseUrl).toString();
+}
+
+export function isShsErrorCode(value) {
+  return typeof value === 'string' && SHS_ERROR_CODES.has(value);
+}

package/vendor-core/shs-schemas.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+// Proxy-level error envelope: the JSON body the local server's SHS proxy
+// (./shs-request.js) sends back on a non-OK upstream response, e.g.
+// `{ code: 'shs-unreachable' }`. This is NOT a SparkListener* event shape, so
+// it lives here rather than in event-schemas.ts. `.passthrough()` since the
+// proxy may attach extra debugging fields the consumer doesn't care about;
+// only `code` is read.
+export const ShsProxyErrorBodySchema = z.object({
+  code: z.string(),
+}).passthrough();
+
+                                                                        

package/vendor-core/snappy-block.js

@@ -0,0 +1,140 @@
+// Decoder for the framing used by Spark's SnappyCompressionCodec, which wraps
+// org.xerial.snappy.SnappyOutputStream: an 8-byte magic + 4-byte big-endian
+// version + 4-byte big-endian compatible-version header, followed by a
+// sequence of [4-byte big-endian compressed length][raw Snappy block] pairs.
+// Each raw block is the standard Snappy format (varint uncompressed length +
+// a sequence of literal/copy tagged elements): see
+// https://github.com/google/snappy/blob/main/format_description.txt. This is
+// a different framing from Spark's own LZ4Block format (src/lz4-block.js).
+
+const MAGIC = [0x82, 0x53, 0x4e, 0x41, 0x50, 0x50, 0x59, 0x00]; // 0x82 'S' 'N' 'A' 'P' 'P' 'Y' 0x00
+const HEADER_SIZE = 16; // 8-byte magic + 4-byte version + 4-byte compatible version
+
+function readVarint(bytes            , pos        )                                  {
+  let result = 0, shift = 0, p = pos;
+  for (;;) {
+    const b = bytes[p++];
+    result |= (b & 0x7f) << shift;
+    if ((b & 0x80) === 0) break;
+    shift += 7;
+  }
+  return { value: result >>> 0, next: p };
+}
+
+function readUint32BE(bytes            , offset        )         {
+  return ((bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]) >>> 0;
+}
+
+function checkMagic(bytes            , pos        )       {
+  for (let i = 0; i < 8; i++) {
+    if (bytes[pos + i] !== MAGIC[i]) throw new Error(`Not a Spark SnappyCodec stream: bad magic at offset ${pos}.`);
+  }
+}
+
+// Decompress one raw Snappy block (varint length + literal/copy elements).
+function decompressSnappyBlock(bytes            )             {
+  const { value: outSize, next: start } = readVarint(bytes, 0);
+  const out = new Uint8Array(outSize);
+  let ip = start, op = 0;
+  const n = bytes.length;
+  while (ip < n) {
+    const tag = bytes[ip];
+    const lowType = tag & 0x3;
+    if (lowType === 0) { // literal
+      const lenTag = tag >> 2;
+      let literalLen, headerLen;
+      if (lenTag < 60) {
+        literalLen = lenTag + 1;
+        headerLen = 1;
+      } else {
+        const extraBytes = lenTag - 59;
+        let lenMinus1 = 0;
+        for (let i = 0; i < extraBytes; i++) lenMinus1 |= bytes[ip + 1 + i] << (8 * i);
+        literalLen = (lenMinus1 >>> 0) + 1;
+        headerLen = 1 + extraBytes;
+      }
+      out.set(bytes.subarray(ip + headerLen, ip + headerLen + literalLen), op);
+      ip += headerLen + literalLen;
+      op += literalLen;
+    } else if (lowType === 1) { // copy, 1-byte offset: length [4..11], offset [0..2047]
+      const length = ((tag >> 2) & 0x7) + 4;
+      const offset = ((tag & 0xe0) << 3) | bytes[ip + 1];
+      let matchPos = op - offset;
+      for (let i = 0; i < length; i++) out[op++] = out[matchPos++];
+      ip += 2;
+    } else if (lowType === 2) { // copy, 2-byte offset: length [1..64], offset [0..65535]
+      const length = (tag >> 2) + 1;
+      const offset = bytes[ip + 1] | (bytes[ip + 2] << 8);
+      let matchPos = op - offset;
+      for (let i = 0; i < length; i++) out[op++] = out[matchPos++];
+      ip += 3;
+    } else { // copy, 4-byte offset
+      const length = (tag >> 2) + 1;
+      const offset = (bytes[ip + 1] | (bytes[ip + 2] << 8) | (bytes[ip + 3] << 16) | (bytes[ip + 4] << 24)) >>> 0;
+      let matchPos = op - offset;
+      for (let i = 0; i < length; i++) out[op++] = out[matchPos++];
+      ip += 5;
+    }
+  }
+  return out;
+}
+
+export function decodeSnappyBlock(bytes            )             {
+  checkMagic(bytes, 0);
+  const chunks               = [];
+  let pos = HEADER_SIZE;
+  const n = bytes.length;
+  while (pos < n) {
+    if (n - pos < 4) throw new Error(`Truncated Snappy block length at offset ${pos}.`);
+    const blockLen = readUint32BE(bytes, pos);
+    const bodyStart = pos + 4;
+    if (n - bodyStart < blockLen) throw new Error(`Truncated Snappy block body at offset ${pos}.`);
+    const body = bytes.subarray(bodyStart, bodyStart + blockLen);
+    chunks.push(decompressSnappyBlock(body));
+    pos = bodyStart + blockLen;
+  }
+  const total = chunks.reduce((sum, c) => sum + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) { out.set(c, offset); offset += c.length; }
+  return out;
+}
+
+// Streaming counterpart: push arbitrary byte slices, each fully-received
+// block is decompressed and handed to `onChunk` as it completes. Mirrors
+// createLz4BlockDecoder's shape/contract (see src/lz4-block.js).
+export function createSnappyBlockDecoder(
+  onChunk                             ,
+)                                                 {
+  let buf             = new Uint8Array(0);
+  let headerConsumed = false;
+  return {
+    push(chunk            ) {
+      if (buf.length === 0) buf = chunk;
+      else if (chunk.length) {
+        const merged = new Uint8Array(buf.length + chunk.length);
+        merged.set(buf); merged.set(chunk, buf.length);
+        buf = merged;
+      }
+      let pos = 0;
+      if (!headerConsumed) {
+        if (buf.length < HEADER_SIZE) return;
+        checkMagic(buf, 0);
+        pos = HEADER_SIZE;
+        headerConsumed = true;
+      }
+      while (buf.length - pos >= 4) {
+        const blockLen = readUint32BE(buf, pos);
+        const bodyStart = pos + 4;
+        if (buf.length - bodyStart < blockLen) break; // block not fully arrived yet
+        const body = buf.subarray(bodyStart, bodyStart + blockLen);
+        onChunk(decompressSnappyBlock(body));
+        pos = bodyStart + blockLen;
+      }
+      buf = pos > 0 ? buf.slice(pos) : buf;
+    },
+    end() {
+      if (buf.length !== 0) throw new Error(`Trailing ${buf.length} undecoded bytes in Snappy stream.`);
+    },
+  };
+}