dsh-session-recall 0.7.4 → 0.7.5

package/README.md

@@ -125,8 +125,22 @@ Plugin row config (all optional):
     cjkHint: true           # explain CJK zero-hit results
     cjkFallback: true       # CJK zero-hit → exact substring scan over session text
     cjkFallbackScanMax: 50  # max sessions scanned per cross-session fallback (1..500)
+    rawScanFallback: true     # degraded mode: when the index itself fails, scan logs directly
+    rawScanMaxSessions: 200   # degraded scan budget: sessions visited (1..2000)
+    rawScanMaxDurationMs: 20000  # degraded scan wall-clock ceiling (1000..120000)
+    rawScanMaxSessionBytes: 8388608  # per-log compressed-size cap in the degraded scan
 ```
 
+## Degraded mode (v0.7.5)
+
+When the session index itself fails — most notably `SESSION_QUERY_PERSISTENCE_FAILED`, where a single un-migratable session artifact fails *every* indexed search (the v0→v1 migration gate rejecting `subagent/descriptor` version 2, [deepseek-harness discussion #7995](https://github.com/deepseek-ai/deepseek-harness/discussions/7995)) — the `recall` tool degrades to scanning the persisted session logs directly (`$DSH_HOME/sessions`) instead of failing the call:
+
+- **Tolerant by construction**: each log is decompressed with a bundled pure-JS zstd decoder and parsed line by line; a corrupt line or unreadable log is skipped and counted, never fatal. The exact session shape that bricks the upstream migration is searchable here.
+- **Affordable**: session headers are read through a streaming decompressor (milliseconds each) so cwd/time/session_id scope filters run before any full decompression; a byte-level term prefilter avoids line parsing for non-matching logs; a wall-clock budget (default 20s) and a per-log size cap (default 8 MiB compressed — pure-JS zstd decompresses ~2 MB/s) keep the tool responsive. Sessions are visited newest-first, and when the budget trips, the result says which portion of the store was covered.
+- **Honest**: results carry `diagnostics.source: "raw-scan"` and a hint explaining the degraded provenance, unreadable/oversized skips, and partial coverage. Live (not yet persisted) sessions are not included.
+
+Disable with `rawScanFallback: false` to restore the pre-v0.7.5 fail-fast behavior.
+
 ## Failure behavior
 
 Every failure returns a friendly `hint` instead of a raw exception: a disabled index explains the two config keys needed, a stale cursor tells the model to restart without one, an unknown `session_id` suggests discovering sessions first. Title enrichment is best-effort — a failed title batch degrades to untitled rows, never a failed search.

package/README.zh.md

@@ -124,8 +124,22 @@ dsh plugin --profile web add github:kittimzhe/dsh-session-recall
     cjkHint: true           # CJK 零命中的提示开关
     cjkFallback: true       # CJK 零命中 → 对会话文本做精确子串扫描
     cjkFallbackScanMax: 50  # 跨会话回退时最多扫描的会话数（1..500）
+    rawScanFallback: true        # 降级模式：索引整体故障时直扫会话日志
+    rawScanMaxSessions: 200      # 降级扫描预算：访问会话数（1..2000）
+    rawScanMaxDurationMs: 20000  # 降级扫描墙钟上限（1000..120000）
+    rawScanMaxSessionBytes: 8388608  # 降级扫描单日志压缩体积上限（字节）
 ```
 
+## 降级模式（v0.7.5）
+
+当会话索引本身故障——最典型的是 `SESSION_QUERY_PERSISTENCE_FAILED`：一个无法迁移的会话工件让**所有**索引查询全部失败（v0→v1 迁移闸门拒绝 `subagent/descriptor` version 2，见 [deepseek-harness 讨论 #7995](https://github.com/deepseek-ai/deepseek-harness/discussions/7995)）——`recall` 工具降级为直接扫描持久化会话日志（`$DSH_HOME/sessions`），而不是让整个调用失败：
+
+- **天生容错**：日志用内置的纯 JS zstd 解码器解压、逐行解析；坏行或不可读日志跳过并计数，绝不致命。上游迁移器认不了的那个会话形状，在这里照样可搜。
+- **算得起**：会话 header 走流式解压（毫秒级），cwd/时间/session_id 过滤先于任何全量解压；字节级关键词预过滤让不含关键词的日志免去逐行解析；墙钟预算（默认 20 秒）与单日志体积上限（默认压缩后 8 MiB——纯 JS zstd 解压约 2 MB/s）保证工具响应性。会话按最新优先访问，预算用尽时结果会说明覆盖了哪部分。
+- **诚实**：结果带 `diagnostics.source: "raw-scan"` 和降级来源提示（不可读/超限跳过数、部分覆盖说明）。未落盘的活跃会话不包含在内。
+
+设 `rawScanFallback: false` 可恢复 v0.7.5 之前的快速失败行为。
+
 ## 失败行为
 
 所有失败都返回友好的 `hint` 而不是裸异常：索引未开启会说明需要哪两个配置键；游标失效会告诉模型不带游标重开一次；`session_id` 不存在会建议先做跨会话搜索。标题补全是尽力而为——标题批量读取失败只降级为"无标题"行，绝不让搜索失败。

package/lib/esm-DyxhIKe9.js

@@ -0,0 +1,662 @@
+//#region node_modules/fzstd/esm/index.mjs
+var ab = ArrayBuffer;
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i16 = Int16Array;
+var i32 = Int32Array;
+var slc = function(v, s, e) {
+	if (u8.prototype.slice) return u8.prototype.slice.call(v, s, e);
+	if (s == null || s < 0) s = 0;
+	if (e == null || e > v.length) e = v.length;
+	var n = new u8(e - s);
+	n.set(v.subarray(s, e));
+	return n;
+};
+var fill = function(v, n, s, e) {
+	if (u8.prototype.fill) return u8.prototype.fill.call(v, n, s, e);
+	if (s == null || s < 0) s = 0;
+	if (e == null || e > v.length) e = v.length;
+	for (; s < e; ++s) v[s] = n;
+	return v;
+};
+var cpw = function(v, t, s, e) {
+	if (u8.prototype.copyWithin) return u8.prototype.copyWithin.call(v, t, s, e);
+	if (s == null || s < 0) s = 0;
+	if (e == null || e > v.length) e = v.length;
+	while (s < e) v[t++] = v[s++];
+};
+/**
+* Codes for errors generated within this library
+*/
+var ZstdErrorCode = {
+	InvalidData: 0,
+	WindowSizeTooLarge: 1,
+	InvalidBlockType: 2,
+	FSEAccuracyTooHigh: 3,
+	DistanceTooFarBack: 4,
+	UnexpectedEOF: 5
+};
+var ec = [
+	"invalid zstd data",
+	"window size too large (>2046MB)",
+	"invalid block type",
+	"FSE accuracy too high",
+	"match distance too far back",
+	"unexpected EOF"
+];
+var err = function(ind, msg, nt) {
+	var e = new Error(msg || ec[ind]);
+	e.code = ind;
+	if (Error.captureStackTrace) Error.captureStackTrace(e, err);
+	if (!nt) throw e;
+	return e;
+};
+var rb = function(d, b, n) {
+	var i = 0, o = 0;
+	for (; i < n; ++i) o |= d[b++] << (i << 3);
+	return o;
+};
+var b4 = function(d, b) {
+	return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var rzfh = function(dat, w) {
+	var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
+	if (n3 == 3126568 && dat[3] == 253) {
+		var flg = dat[4];
+		var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
+		if (flg & 8) err(0);
+		var bt = 6 - ss;
+		var db = df == 3 ? 4 : df;
+		var di = rb(dat, bt, db);
+		bt += db;
+		var fsb = fcf ? 1 << fcf : ss;
+		var fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
+		var ws = fss;
+		if (!ss) {
+			var wb = 1 << 10 + (dat[5] >> 3);
+			ws = wb + (wb >> 3) * (dat[5] & 7);
+		}
+		if (ws > 2145386496) err(1);
+		var buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
+		buf[0] = 1, buf[4] = 4, buf[8] = 8;
+		return {
+			b: bt + fsb,
+			y: 0,
+			l: 0,
+			d: di,
+			w: w && w != 1 ? w : buf.subarray(12),
+			e: ws,
+			o: new i32(buf.buffer, 0, 3),
+			u: fss,
+			c: cc,
+			m: Math.min(131072, ws)
+		};
+	} else if ((n3 >> 4 | dat[3] << 20) == 25481893) return b4(dat, 4) + 8;
+	err(0);
+};
+var msb = function(val) {
+	var bits = 0;
+	for (; 1 << bits <= val; ++bits);
+	return bits - 1;
+};
+var rfse = function(dat, bt, mal) {
+	var tpos = (bt << 3) + 4;
+	var al = (dat[bt] & 15) + 5;
+	if (al > mal) err(3);
+	var sz = 1 << al;
+	var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
+	var buf = new ab(512 + (sz << 2));
+	var freq = new i16(buf, 0, 256);
+	var dstate = new u16(buf, 0, 256);
+	var nstate = new u16(buf, 512, sz);
+	var bb1 = 512 + (sz << 1);
+	var syms = new u8(buf, bb1, sz);
+	var nbits = new u8(buf, bb1 + sz);
+	while (sym < 255 && probs > 0) {
+		var bits = msb(probs + 1);
+		var cbt = tpos >> 3;
+		var msk = (1 << bits + 1) - 1;
+		var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
+		var msk1fb = (1 << bits) - 1;
+		var msv = msk - probs - 1;
+		var sval = val & msk1fb;
+		if (sval < msv) tpos += bits, val = sval;
+		else {
+			tpos += bits + 1;
+			if (val > msk1fb) val -= msv;
+		}
+		freq[++sym] = --val;
+		if (val == -1) {
+			probs += val;
+			syms[--ht] = sym;
+		} else probs -= val;
+		if (!val) do {
+			var rbt = tpos >> 3;
+			re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
+			tpos += 2;
+			sym += re;
+		} while (re == 3);
+	}
+	if (sym > 255 || probs) err(0);
+	var sympos = 0;
+	var sstep = (sz >> 1) + (sz >> 3) + 3;
+	var smask = sz - 1;
+	for (var s = 0; s <= sym; ++s) {
+		var sf = freq[s];
+		if (sf < 1) {
+			dstate[s] = -sf;
+			continue;
+		}
+		for (i = 0; i < sf; ++i) {
+			syms[sympos] = s;
+			do
+				sympos = sympos + sstep & smask;
+			while (sympos >= ht);
+		}
+	}
+	if (sympos) err(0);
+	for (i = 0; i < sz; ++i) {
+		var ns = dstate[syms[i]]++;
+		var nb = nbits[i] = al - msb(ns);
+		nstate[i] = (ns << nb) - sz;
+	}
+	return [tpos + 7 >> 3, {
+		b: al,
+		s: syms,
+		n: nbits,
+		t: nstate
+	}];
+};
+var rhu = function(dat, bt) {
+	var i = 0, wc = -1;
+	var buf = new u8(292), hb = dat[bt];
+	var hw = buf.subarray(0, 256);
+	var rc = buf.subarray(256, 268);
+	var ri = new u16(buf.buffer, 268);
+	if (hb < 128) {
+		var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
+		bt += hb;
+		var epos = ebt << 3;
+		var lb = dat[bt];
+		if (!lb) err(0);
+		var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
+		var fpos = (++bt << 3) - 8 + msb(lb);
+		for (;;) {
+			fpos -= btr1;
+			if (fpos < epos) break;
+			var cbt = fpos >> 3;
+			st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
+			hw[++wc] = fdt.s[st1];
+			fpos -= btr2;
+			if (fpos < epos) break;
+			cbt = fpos >> 3;
+			st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
+			hw[++wc] = fdt.s[st2];
+			btr1 = fdt.n[st1];
+			st1 = fdt.t[st1];
+			btr2 = fdt.n[st2];
+			st2 = fdt.t[st2];
+		}
+		if (++wc > 255) err(0);
+	} else {
+		wc = hb - 127;
+		for (; i < wc; i += 2) {
+			var byte = dat[++bt];
+			hw[i] = byte >> 4;
+			hw[i + 1] = byte & 15;
+		}
+		++bt;
+	}
+	var wes = 0;
+	for (i = 0; i < wc; ++i) {
+		var wt = hw[i];
+		if (wt > 11) err(0);
+		wes += wt && 1 << wt - 1;
+	}
+	var mb = msb(wes) + 1;
+	var ts = 1 << mb;
+	var rem = ts - wes;
+	if (rem & rem - 1) err(0);
+	hw[wc++] = msb(rem) + 1;
+	for (i = 0; i < wc; ++i) {
+		var wt = hw[i];
+		++rc[hw[i] = wt && mb + 1 - wt];
+	}
+	var hbuf = new u8(ts << 1);
+	var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
+	ri[mb] = 0;
+	for (i = mb; i > 0; --i) {
+		var pv = ri[i];
+		fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
+	}
+	if (ri[0] != ts) err(0);
+	for (i = 0; i < wc; ++i) {
+		var bits = hw[i];
+		if (bits) {
+			var code = ri[bits];
+			fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
+		}
+	}
+	return [bt, {
+		n: nb,
+		b: mb,
+		s: syms
+	}];
+};
+var dllt = (/*#__PURE__*/ rfse(/*#__PURE__*/ new u8([
+	81,
+	16,
+	99,
+	140,
+	49,
+	198,
+	24,
+	99,
+	12,
+	33,
+	196,
+	24,
+	99,
+	102,
+	102,
+	134,
+	70,
+	146,
+	4
+]), 0, 6))[1];
+var dmlt = (/*#__PURE__*/ rfse(/*#__PURE__*/ new u8([
+	33,
+	20,
+	196,
+	24,
+	99,
+	140,
+	33,
+	132,
+	16,
+	66,
+	8,
+	33,
+	132,
+	16,
+	66,
+	8,
+	33,
+	68,
+	68,
+	68,
+	68,
+	68,
+	68,
+	68,
+	68,
+	36,
+	9
+]), 0, 6))[1];
+var doct = (/*#__PURE__ */ rfse(/*#__PURE__*/ new u8([
+	32,
+	132,
+	16,
+	66,
+	102,
+	70,
+	68,
+	68,
+	68,
+	68,
+	36,
+	73,
+	2
+]), 0, 5))[1];
+var b2bl = function(b, s) {
+	var len = b.length, bl = new i32(len);
+	for (var i = 0; i < len; ++i) {
+		bl[i] = s;
+		s += 1 << b[i];
+	}
+	return bl;
+};
+var llb = /*#__PURE__ */ new u8((/*#__PURE__ */ new i32([
+	0,
+	0,
+	0,
+	0,
+	16843009,
+	50528770,
+	134678020,
+	202050057,
+	269422093
+])).buffer, 0, 36);
+var llbl = /*#__PURE__ */ b2bl(llb, 0);
+var mlb = /*#__PURE__ */ new u8((/*#__PURE__ */ new i32([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	16843009,
+	50528770,
+	117769220,
+	185207048,
+	252579084,
+	16
+])).buffer, 0, 53);
+var mlbl = /*#__PURE__ */ b2bl(mlb, 3);
+var dhu = function(dat, out, hu) {
+	var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
+	if (!lb) err(0);
+	var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
+	for (; pos > eb && i < ss;) {
+		var cbt = pos >> 3;
+		var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
+		st = (st << btr | val) & msk;
+		out[++i] = hu.s[st];
+		pos -= btr = hu.n[st];
+	}
+	if (pos != eb || i + 1 != ss) err(0);
+};
+var dhu4 = function(dat, out, hu) {
+	var bt = 6;
+	var sz1 = out.length + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
+	dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
+	dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
+	dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
+	dhu(dat.subarray(bt), out.subarray(sz3), hu);
+};
+var rzb = function(dat, st, out) {
+	var _a;
+	var bt = st.b;
+	var b0 = dat[bt], btype = b0 >> 1 & 3;
+	st.l = b0 & 1;
+	var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
+	var ebt = (bt += 3) + sz;
+	if (btype == 1) {
+		if (bt >= dat.length) return;
+		st.b = bt + 1;
+		if (out) {
+			fill(out, dat[bt], st.y, st.y += sz);
+			return out;
+		}
+		return fill(new u8(sz), dat[bt]);
+	}
+	if (ebt > dat.length) return;
+	if (btype == 0) {
+		st.b = ebt;
+		if (out) {
+			out.set(dat.subarray(bt, ebt), st.y);
+			st.y += sz;
+			return out;
+		}
+		return slc(dat, bt, ebt);
+	}
+	if (btype == 2) {
+		var b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
+		var lss = b3 >> 4, lcs = 0, s4 = 0;
+		if (lbt < 2) {
+			if (sf & 1) lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
+			else lss = b3 >> 3;
+		} else {
+			s4 = sf;
+			if (sf < 2) lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
+			else if (sf == 2) lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
+			else lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
+		}
+		++bt;
+		var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
+		var spl = buf.length - lss;
+		if (lbt == 0) buf.set(dat.subarray(bt, bt += lss), spl);
+		else if (lbt == 1) fill(buf, dat[bt++], spl);
+		else {
+			var hu = st.h;
+			if (lbt == 2) {
+				var hud = rhu(dat, bt);
+				lcs += bt - (bt = hud[0]);
+				st.h = hu = hud[1];
+			} else if (!hu) err(0);
+			(s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
+		}
+		var ns = dat[bt++];
+		if (ns) {
+			if (ns == 255) ns = (dat[bt++] | dat[bt++] << 8) + 32512;
+			else if (ns > 127) ns = ns - 128 << 8 | dat[bt++];
+			var scm = dat[bt++];
+			if (scm & 3) err(0);
+			var dts = [
+				dmlt,
+				doct,
+				dllt
+			];
+			for (var i = 2; i > -1; --i) {
+				var md = scm >> (i << 1) + 2 & 3;
+				if (md == 1) {
+					var rbuf = new u8([
+						0,
+						0,
+						dat[bt++]
+					]);
+					dts[i] = {
+						s: rbuf.subarray(2, 3),
+						n: rbuf.subarray(0, 1),
+						t: new u16(rbuf.buffer, 0, 1),
+						b: 0
+					};
+				} else if (md == 2) _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
+				else if (md == 3) {
+					if (!st.t) err(0);
+					dts[i] = st.t[i];
+				}
+			}
+			var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
+			var lb = dat[ebt - 1];
+			if (!lb) err(0);
+			var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
+			var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
+			cbt = (spos -= oct.b) >> 3;
+			var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
+			cbt = (spos -= mlt.b) >> 3;
+			var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
+			for (++ns; --ns;) {
+				var llc = llt.s[lst];
+				var lbtr = llt.n[lst];
+				var mlc = mlt.s[mst];
+				var mbtr = mlt.n[mst];
+				var ofc = oct.s[ost];
+				var obtr = oct.n[ost];
+				cbt = (spos -= ofc) >> 3;
+				var ofp = 1 << ofc;
+				var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
+				cbt = (spos -= mlb[mlc]) >> 3;
+				var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
+				cbt = (spos -= llb[llc]) >> 3;
+				var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
+				cbt = (spos -= lbtr) >> 3;
+				lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
+				cbt = (spos -= mbtr) >> 3;
+				mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
+				cbt = (spos -= obtr) >> 3;
+				ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
+				if (off > 3) {
+					st.o[2] = st.o[1];
+					st.o[1] = st.o[0];
+					st.o[0] = off -= 3;
+				} else {
+					var idx = off - (ll != 0);
+					if (idx) {
+						off = idx == 3 ? st.o[0] - 1 : st.o[idx];
+						if (idx > 1) st.o[2] = st.o[1];
+						st.o[1] = st.o[0];
+						st.o[0] = off;
+					} else off = st.o[0];
+				}
+				for (var i = 0; i < ll; ++i) buf[oubt + i] = buf[spl + i];
+				oubt += ll, spl += ll;
+				var stin = oubt - off;
+				if (stin < 0) {
+					var len = -stin;
+					var bs = st.e + stin;
+					if (len > ml) len = ml;
+					for (var i = 0; i < len; ++i) buf[oubt + i] = st.w[bs + i];
+					oubt += len, ml -= len, stin = 0;
+				}
+				for (var i = 0; i < ml; ++i) buf[oubt + i] = buf[stin + i];
+				oubt += ml;
+			}
+			if (oubt != spl) while (spl < buf.length) buf[oubt++] = buf[spl++];
+			else oubt = buf.length;
+			if (out) st.y += oubt;
+			else buf = slc(buf, 0, oubt);
+		} else if (out) {
+			st.y += lss;
+			if (spl) for (var i = 0; i < lss; ++i) buf[i] = buf[spl + i];
+		} else if (spl) buf = slc(buf, spl);
+		st.b = ebt;
+		return buf;
+	}
+	err(2);
+};
+var cct = function(bufs, ol) {
+	if (bufs.length == 1) return bufs[0];
+	var buf = new u8(ol);
+	for (var i = 0, b = 0; i < bufs.length; ++i) {
+		var chk = bufs[i];
+		buf.set(chk, b);
+		b += chk.length;
+	}
+	return buf;
+};
+/**
+* Decompresses Zstandard data
+* @param dat The input data
+* @param buf The output buffer. If unspecified, the function will allocate
+*            exactly enough memory to fit the decompressed data. If your
+*            data has multiple frames and you know the output size, specifying
+*            it will yield better performance.
+* @returns The decompressed data
+*/
+function decompress(dat, buf) {
+	var bufs = [], nb = +!buf;
+	var bt = 0, ol = 0;
+	for (; dat.length;) {
+		var st = rzfh(dat, nb || buf);
+		if (typeof st == "object") {
+			if (nb) {
+				buf = null;
+				if (st.w.length == st.u) {
+					bufs.push(buf = st.w);
+					ol += st.u;
+				}
+			} else {
+				bufs.push(buf);
+				st.e = 0;
+			}
+			for (; !st.l;) {
+				var blk = rzb(dat, st, buf);
+				if (!blk) err(5);
+				if (buf) st.e = st.y;
+				else {
+					bufs.push(blk);
+					ol += blk.length;
+					cpw(st.w, 0, blk.length);
+					st.w.set(blk, st.w.length - blk.length);
+				}
+			}
+			bt = st.b + st.c * 4;
+		} else bt = st;
+		dat = dat.subarray(bt);
+	}
+	return cct(bufs, ol);
+}
+/**
+* Decompressor for Zstandard streamed data
+*/
+var Decompress = /* @__PURE__ */ function() {
+	/**
+	* Creates a Zstandard decompressor
+	* @param ondata The handler for stream data
+	*/
+	function Decompress(ondata) {
+		this.ondata = ondata;
+		this.c = [];
+		this.l = 0;
+		this.z = 0;
+	}
+	/**
+	* Pushes data to be decompressed
+	* @param chunk The chunk of data to push
+	* @param final Whether or not this is the last chunk in the stream
+	*/
+	Decompress.prototype.push = function(chunk, final) {
+		if (typeof this.s == "number") {
+			var sub = Math.min(chunk.length, this.s);
+			chunk = chunk.subarray(sub);
+			this.s -= sub;
+		}
+		var ncs = chunk.length + this.l;
+		if (!this.s) {
+			if (final) {
+				if (!ncs) {
+					this.ondata(new u8(0), true);
+					return;
+				}
+				if (ncs < 5) err(5);
+			} else if (ncs < 18) {
+				this.c.push(chunk);
+				this.l = ncs;
+				return;
+			}
+			if (this.l) {
+				this.c.push(chunk);
+				chunk = cct(this.c, ncs);
+				this.c = [];
+				this.l = 0;
+			}
+			if (typeof (this.s = rzfh(chunk)) == "number") return this.push(chunk, final);
+		}
+		if (typeof this.s != "number") {
+			if (ncs < (this.z || 3)) {
+				if (final) err(5);
+				this.c.push(chunk);
+				this.l = ncs;
+				return;
+			}
+			if (this.l) {
+				this.c.push(chunk);
+				chunk = cct(this.c, ncs);
+				this.c = [];
+				this.l = 0;
+			}
+			if (!this.z && ncs < (this.z = chunk[this.s.b] & 2 ? 4 : 3 + (chunk[this.s.b] >> 3 | chunk[this.s.b + 1] << 5 | chunk[this.s.b + 2] << 13))) {
+				if (final) err(5);
+				this.c.push(chunk);
+				this.l = ncs;
+				return;
+			} else this.z = 0;
+			for (;;) {
+				var blk = rzb(chunk, this.s);
+				if (!blk) {
+					if (final) err(5);
+					var adc = chunk.subarray(this.s.b);
+					this.s.b = 0;
+					this.c.push(adc), this.l += adc.length;
+					return;
+				} else {
+					this.ondata(blk, false);
+					cpw(this.s.w, 0, blk.length);
+					this.s.w.set(blk, this.s.w.length - blk.length);
+				}
+				if (this.s.l) {
+					var rest = chunk.subarray(this.s.b);
+					this.s = this.s.c * 4;
+					this.push(rest, final);
+					return;
+				}
+			}
+		} else if (final) err(5);
+	};
+	return Decompress;
+}();
+//#endregion
+export { Decompress, ZstdErrorCode, decompress };