feiyu-memory 0.0.0-stage → 0.3.6

package/src/core/render-diary.mjs

@@ -0,0 +1,171 @@
+/**
+ * 人读版日记 —— 把 JSONL 渲染成 markdown。
+ *
+ * ── 为什么是"派生视图"而不是"再存一份" ──
+ *
+ * 双写两个真相源 = bug 工厂。这条我们已经踩过一次了：
+ * 索引原本要落盘，后来砍成纯派生的，就是因为"索引和日记不同步"这类 bug
+ * 极难发现、极难复现。
+ *
+ * 所以这份 markdown 的定位和索引一样：**单向生成、只读、随时可重建**。
+ * 唯一的区别是它值得留在磁盘上（用户想直接打开看），而索引留在内存里就够了。
+ *
+ * 推论：**改它没用，下次对话就被覆盖。** 文件头会写清楚这一点。
+ *
+ * JSONL 仍然是唯一真相源：追加安全、坏一行只丢一行。
+ */
+
+import { calendarDaysBetween } from './timeline.mjs';
+
+const KINDS = {
+  failure: '搞砸了',
+  win: '干得不错',
+  chat: '闲聊',
+  disclosure: '他说了点自己的事',
+  grievance: '他不高兴了',
+  note: '我自己写的',
+};
+
+const pad = (n) => String(n).padStart(2, '0');
+
+/** 本地时间的 YYYY-MM-DD */
+function localDate(ts) {
+  const d = new Date(ts);
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+/** 本地时间的 HH:MM */
+function localTime(ts) {
+  const d = new Date(ts);
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+/** 认识多久了，说人话 */
+function humanDuration(fromTs, now) {
+  // 自然日，跟注入层、面板用同一把尺子（timeline.mjs）
+  const days = calendarDaysBetween(fromTs, now);
+  if (days < 1) return '今天刚认识';
+  if (days < 30) return `认识 ${days} 天`;
+  const months = Math.floor(days / 30);
+  if (months < 12) return `认识 ${months} 个月`;
+  return `认识 ${Math.floor(days / 365)} 年`;
+}
+
+/**
+ * 渲染成人读的 markdown。
+ *
+ * @param {object} archive
+ * @param {{now?: number, generatedAt?: number}} [options]
+ * @returns {string}
+ */
+export function renderDiaryMarkdown(archive, options = {}) {
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  const generatedAt = Number.isFinite(options.generatedAt) ? options.generatedAt : now;
+  const diary = Array.isArray(archive?.diary) ? archive.diary : [];
+  const rel = archive?.relationship ?? {};
+  const out = [];
+
+  out.push('# 肥鱼日记');
+  out.push('');
+  out.push('> **这份文件是自动生成的，改它没用** —— 下一次对话就会被覆盖。');
+  out.push('> ');
+  out.push('> · 想改人格：编辑 `persona.md`');
+  out.push('> · 想删某条记忆：编辑 `diary/*.jsonl` 删掉那一行');
+  out.push('> · 这里只是给**人**看的窗口，真正的数据是那些 `.jsonl`');
+  out.push('');
+  out.push(
+    `记了 **${diary.length}** 条 · ${humanDuration(Number(archive?.manifest?.created_at) || now, now)}` +
+      ` · 生成于 ${localDate(generatedAt)} ${localTime(generatedAt)}`,
+  );
+  out.push('');
+
+  // ── 我们 ──
+  const relLines = [];
+  if (typeof rel.nickname === 'string' && rel.nickname.trim() !== '') {
+    relLines.push(`- 他管我叫「${rel.nickname.trim()}」`);
+  }
+  const traits = (rel.traits ?? [])
+    .filter((t) => t && t.value)
+    .sort((a, b) => (b.salience ?? 0) - (a.salience ?? 0))
+    .slice(0, 8);
+  if (traits.length > 0) {
+    relLines.push(`- 他：${traits.map((t) => t.value).join('；')}`);
+  }
+  // 「我还欠着他的」/「已经翻篇的」两行随功能一起删了（2026-10-24）。
+
+  if (relLines.length > 0) {
+    out.push('## 我们');
+    out.push('');
+    out.push(...relLines);
+    out.push('');
+  }
+
+  const lexicon = (archive?.lexicon?.items ?? [])
+    .filter((i) => i && typeof i.term === 'string' && (i.salience ?? 0) >= 0.25)
+    .sort((a, b) => (b.salience ?? 0) - (a.salience ?? 0))
+    .slice(0, 12);
+  if (lexicon.length > 0) {
+    out.push('## 我最近常说的');
+    out.push('');
+    out.push(lexicon.map((i) => i.term).join('、'));
+    out.push('');
+  }
+
+  if (diary.length === 0) {
+    out.push('---');
+    out.push('');
+    out.push('## 还没有日记');
+    out.push('');
+    out.push('聊点值得记的事，这里就会有东西了。');
+    out.push('');
+    return out.join('\n');
+  }
+
+  // ── 日记：按月分组，月内倒序（打开就想看最近的） ──
+  const byMonth = new Map();
+  for (const entry of diary) {
+    const month = (entry.date ?? localDate(entry.created_at ?? now)).slice(0, 7);
+    const list = byMonth.get(month) ?? [];
+    list.push(entry);
+    byMonth.set(month, list);
+  }
+
+  const months = [...byMonth.keys()].sort().reverse();
+  for (const month of months) {
+    const list = [...(byMonth.get(month) ?? [])].sort(
+      (a, b) => (b.created_at ?? 0) - (a.created_at ?? 0),
+    );
+    const [y, m] = month.split('-');
+    out.push('---');
+    out.push('');
+    out.push(`## ${y} 年 ${Number(m)} 月`);
+    out.push('');
+
+    for (const entry of list) {
+      const kind = KINDS[entry.kind] ?? '记一笔';
+      const when = entry.created_at ? localTime(entry.created_at) : '';
+      const day = entry.date ? Number(entry.date.slice(8, 10)) : '';
+      out.push(`### ${day} 日 ${when} · ${kind}`);
+      out.push('');
+      out.push(String(entry.text ?? '').trim());
+      out.push('');
+
+      const meta = [];
+      if (Number.isFinite(entry.salience)) meta.push(`重要度 ${entry.salience.toFixed(2)}`);
+      if (Array.isArray(entry.tags) && entry.tags.length > 0) meta.push(entry.tags.join('、'));
+      if (entry.kind === 'failure') meta.push(entry.resolved === true ? '已解决' : '还欠着');
+      if (typeof entry.id === 'string') meta.push(entry.id);
+      if (meta.length > 0) {
+        out.push(`<sub>${meta.join(' · ')}</sub>`);
+        out.push('');
+      }
+    }
+  }
+
+  return out.join('\n');
+}
+
+/** 给文件用：末尾保证一个换行 */
+export function renderDiaryFile(archive, options) {
+  return `${renderDiaryMarkdown(archive, options).trimEnd()}\n`;
+}

package/src/core/timeline.mjs

@@ -0,0 +1,127 @@
+/**
+ * 时间怎么说人话 —— **"一天"和"时间词"的唯一真相源**。
+ *
+ * ─────────────────────────────────────────────────────────────
+ * 这个模块是一次真实事故的产物，别把它拆回去。
+ *
+ * 有位读者（另一个 DSH 会话）从**渲染输出那一侧**读到了这么一块：
+ *
+ *     我们：认识 1 天
+ *     最近的事：
+ *     - 昨天：他今天正式给了我一条规矩……
+ *     - 2 天前：今天他让我介绍自己……
+ *
+ * 两个毛病，都不是遗忘机制能管的，也不会随时间自愈：
+ *
+ * 【一】时间词写了两遍
+ * 正文里的"今天"（写入时模型写的）+ 前缀里的"昨天："（渲染时加的）
+ * → 读出来是"昨天，他今天……"。人不会这么记事儿。
+ *
+ * 更难看的是根因在我自己：`consolidate.mjs` 的**正例**里明明白白写着
+ * `"text":"今天他让我写个东西……"` —— **我在教模型写"今天"。**
+ *
+ * 【二】"一天"在一个文件里有三种算法
+ *   renderRelationship： floor((now − since) / 86400000)   ← 整 24 小时
+ *   dayLabel：          round((当日零点差) / 86400000)      ← 自然日
+ *   softWhen：          (now − t) / 86400000                ← 带小数
+ *
+ * 晚上 23:00 认识、次日上午 9:00 看：前一个算出"认识 1 天"，
+ * 后一个算出"2 天前"。**这俩永远会打架**，因为一把尺子从小时算、
+ * 一把从零点算。
+ *
+ * 所以这里只干一件事：把"一天"定死成**自然日**（人的直觉 ——
+ * 前天见的就是"认识 2 天"），所有需要日期的地方都从这儿取。
+ * ─────────────────────────────────────────────────────────────
+ */
+
+/** 某时刻所在那一天的零点 */
+export function startOfDay(ts) {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+
+/**
+ * 两个时刻相差几个**自然日**。
+ *
+ * 这是全项目唯一允许出现的"一天"算法。想加新的日期逻辑，用这个，
+ * 别再写第四种。
+ */
+export function calendarDaysBetween(from, to) {
+  if (!Number.isFinite(from) || !Number.isFinite(to)) return 0;
+  return Math.round((startOfDay(to) - startOfDay(from)) / 86400000);
+}
+
+/**
+ * 「最近的事」用的日期标签：今天 / 昨天 / 3 天前 / 10-05
+ *
+ * 语气偏准确 —— 这一栏是"我本来就知道的事"，说清楚是哪天很正常。
+ */
+export function dayLabel(createdAt, now = Date.now()) {
+  if (!Number.isFinite(createdAt)) return '';
+  const days = calendarDaysBetween(createdAt, now);
+  if (days <= 0) return '今天';
+  if (days === 1) return '昨天';
+  if (days < 7) return `${days} 天前`;
+  const d = new Date(createdAt);
+  return `${d.getMonth() + 1}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+/**
+ * 「突然想起来」用的时间词：前两天 / 前阵子 / 上个月前后 / 很久以前
+ *
+ * 语气故意含糊 —— 鱼不会说"根据 10 月 12 日的记录"。
+ * **但它和 dayLabel 用同一把尺子**（自然日），只是换了个说法。
+ * 词汇差异是有意的，算法差异是 bug。
+ */
+export function softWhen(createdAt, now = Date.now()) {
+  if (!Number.isFinite(createdAt)) return '';
+  const days = calendarDaysBetween(createdAt, now);
+  if (days <= 0) return '';
+  if (days <= 3) return '前两天';
+  if (days <= 14) return '前阵子';
+  if (days <= 60) return '上个月前后';
+  return '很久以前';
+}
+
+/**
+ * 会跟前缀打架的时间词。
+ *
+ * 判据很具体：**这些词是在断言"相对于写下它的那一刻"是哪天**，
+ * 而前缀断言的又是"相对于现在"。两个断言放在一起就自相矛盾。
+ *
+ * 刻意**不在**这一列的：
+ *  - "那天 / 这天" —— 叙述性的，读起来不跟前缀打架
+ *  - "生日 / 春节" 之类的名词 —— 那是事件不是时点
+ */
+const DEICTIC = /(今天|今日|今儿|昨天|昨日|昨儿|前天|前日|今早|今晨|今上午|今晚|昨早|昨晚|刚才|刚刚)/g;
+
+/** 句首的时间词要连它后面的顿挫一起吃掉，免得留下一个光秃秃的逗号 */
+const DEICTIC_LEADING =
+  /^\s*(?:今天|今日|今儿|昨天|昨日|昨儿|前天|前日|今早|今晨|今上午|今晚|昨早|昨晚|刚才|刚刚)\s*[，,、]*\s*/;
+
+/**
+ * 把正文里"相对于写入时刻"的时间词摘掉。
+ *
+ * 为什么在**渲染时**摘、而不是只靠提示词约束：
+ *
+ *  1. 老档案里已经烤进去一堆"今天"，不可能为此重写用户的记忆
+ *  2. 模型不可能 100% 听话，得有一道兜底
+ *  3. 摘掉之后正文变成"他让我写个东西……"，而时间由前缀给 ——
+ *     **时间只在一处生成**，这才是那个读者要的东西
+ *
+ * @param {string} text
+ * @returns {string} 摘干净之后仍然像人话的正文
+ */
+export function stripTimeWords(text) {
+  if (typeof text !== 'string') return '';
+  const original = text.trim();
+  let s = original.replace(DEICTIC_LEADING, '');
+  s = s.replace(DEICTIC, '');
+  s = s.replace(/^\s*[，,、]+\s*/, '').replace(/\s{2,}/g, ' ').trim();
+
+  // 兜底：摘没了、或者摘得只剩几个字，就别动它。
+  // 宁可留一个多余的"今天"，也不要把一条记忆变成空壳。
+  if (s.length < 4) return original;
+  return s;
+}

package/src/core/tokenize.mjs

@@ -0,0 +1,70 @@
+/**
+ * 极简 token 估算 —— 用于注入预算裁剪，不追求精确，只要求"不会严重低估"。
+ *
+ * 设计取舍：
+ * - 中日韩字符按 1 字符 ≈ 1 token 计（DeepSeek 系分词器对 CJK 大致如此，略保守）
+ * - 拉丁字母/数字按 4 字符 ≈ 1 token 计
+ * - 标点与空白按 3 字符 ≈ 1 token 计
+ * - 结果向上取整，宁可多算不可少算 —— 预算超了会挤掉系统提示，代价比浪费几十 token 大得多
+ *
+ * 为什么不用真分词器：会引入依赖，且插件每次注入都要算，纯启发式足够。
+ */
+
+/** 判断是否 CJK / 全角标点（这些字符通常一个字符一个 token） */
+function isWide(code) {
+  return (
+    (code >= 0x3000 && code <= 0x303f) || // CJK 标点
+    (code >= 0x3040 && code <= 0x30ff) || // 假名
+    (code >= 0x3400 && code <= 0x4dbf) || // CJK 扩展 A
+    (code >= 0x4e00 && code <= 0x9fff) || // CJK 基本区
+    (code >= 0xac00 && code <= 0xd7af) || // 谚文
+    (code >= 0xf900 && code <= 0xfaff) || // CJK 兼容
+    (code >= 0xff00 && code <= 0xffef) // 全角形式
+  );
+}
+
+/**
+ * 估算一段文本的 token 数。
+ * @param {string} text
+ * @returns {number} 非负整数
+ */
+export function estimateTokens(text) {
+  if (!text) return 0;
+  let wide = 0;
+  let narrow = 0;
+  for (const ch of text) {
+    const code = ch.codePointAt(0);
+    if (isWide(code)) wide += 1;
+    else narrow += 1;
+  }
+  return wide + Math.ceil(narrow / 3.5);
+}
+
+/**
+ * 按 token 预算截断文本（在字符边界上截，不切断代理对）。
+ * 截断处补一个省略号，并保证结果不超过预算。
+ *
+ * @param {string} text
+ * @param {number} budget 最大 token 数
+ * @param {string} [ellipsis]
+ * @returns {string}
+ */
+export function truncateToTokens(text, budget, ellipsis = '……') {
+  if (budget <= 0) return '';
+  if (estimateTokens(text) <= budget) return text;
+
+  const ellipsisCost = estimateTokens(ellipsis);
+  const room = budget - ellipsisCost;
+  if (room <= 0) return truncateToTokens(ellipsis, budget, '');
+
+  // 二分找最长前缀
+  const chars = [...text];
+  let lo = 0;
+  let hi = chars.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (estimateTokens(chars.slice(0, mid).join('')) <= room) lo = mid;
+    else hi = mid - 1;
+  }
+  return chars.slice(0, lo).join('') + ellipsis;
+}

package/src/core/zip.mjs

@@ -0,0 +1,239 @@
+/**
+ * 零依赖的极小 ZIP 读写 —— `.dshpack` 就是一个 zip。
+ *
+ * 为什么不装依赖：
+ *   DSH 插件应该能被人一眼读完、离线审计。为了打个包引入几百 KB 的依赖不值得。
+ *
+ * 能力边界（刻意的）：
+ *   写：只写 store（不压缩）。档案本体是文本，压缩收益小，而 store 的格式简单到不会出错。
+ *   读：store + deflate 都读（因为别人/别的工具打的包可能是 deflate）。
+ *   不支持 Zip64。档案是私人日记，几十 MB 已经是十年量级；超限时明确报错而不是静默截断。
+ *
+ * 所有 CRC 都实际计算 —— 一个损坏的档案必须能被发现，而不是解出一半乱码。
+ */
+import { inflateRawSync, deflateRawSync } from 'node:zlib';
+
+const SIG_LOCAL = 0x04034b50;
+const SIG_CENTRAL = 0x02014b50;
+const SIG_EOCD = 0x06054b50;
+const FLAG_UTF8 = 0x0800;
+const METHOD_STORE = 0;
+const METHOD_DEFLATE = 8;
+
+const MAX_UINT32 = 0xffffffff;
+
+/** CRC-32（IEEE）查表 */
+const CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[i] = c >>> 0;
+  }
+  return t;
+})();
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {number} 无符号 32 位 CRC
+ */
+export function crc32(bytes) {
+  let c = 0xffffffff;
+  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+/** 把 Date 编码成 DOS 时间/日期（本地时区，ZIP 传统） */
+function dosDateTime(date) {
+  const y = Math.max(1980, date.getFullYear());
+  return {
+    time: (date.getHours() << 11) | (date.getMinutes() << 5) | (date.getSeconds() >> 1),
+    date: ((y - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+  };
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8');
+
+/**
+ * 打一个 zip 包。
+ *
+ * @param {Array<{name: string, data: string | Uint8Array}>} entries 路径用正斜杠
+ * @param {{date?: Date, compress?: boolean}} [options]
+ * @returns {Uint8Array}
+ */
+export function zipSync(entries, options = {}) {
+  const date = options.date ?? new Date();
+  const compress = options.compress === true;
+  const { time, date: dosDate } = dosDateTime(date);
+
+  /** @type {Uint8Array[]} */
+  const chunks = [];
+  /** @type {Array<{nameBytes: Uint8Array, method: number, crc: number, csize: number, usize: number, offset: number, time: number, date: number}>} */
+  const central = [];
+  let offset = 0;
+
+  for (const entry of entries) {
+    const nameBytes = encoder.encode(entry.name);
+    const raw = typeof entry.data === 'string' ? encoder.encode(entry.data) : entry.data;
+    const crc = crc32(raw);
+
+    let method = METHOD_STORE;
+    let payload = raw;
+    if (compress && raw.length > 256) {
+      const deflated = new Uint8Array(deflateRawSync(raw, { level: 6 }));
+      if (deflated.length < raw.length) {
+        method = METHOD_DEFLATE;
+        payload = deflated;
+      }
+    }
+
+    if (raw.length > MAX_UINT32 || payload.length > MAX_UINT32) {
+      throw new Error(`zipSync: 条目过大，不支持 Zip64：${entry.name}`);
+    }
+
+    const local = new Uint8Array(30 + nameBytes.length);
+    const lv = new DataView(local.buffer);
+    lv.setUint32(0, SIG_LOCAL, true);
+    lv.setUint16(4, 20, true); // version needed
+    lv.setUint16(6, FLAG_UTF8, true);
+    lv.setUint16(8, method, true);
+    lv.setUint16(10, time, true);
+    lv.setUint16(12, dosDate, true);
+    lv.setUint32(14, crc, true);
+    lv.setUint32(18, payload.length, true);
+    lv.setUint32(22, raw.length, true);
+    lv.setUint16(26, nameBytes.length, true);
+    lv.setUint16(28, 0, true); // extra len
+    local.set(nameBytes, 30);
+
+    chunks.push(local, payload);
+    central.push({
+      nameBytes,
+      method,
+      crc,
+      csize: payload.length,
+      usize: raw.length,
+      offset,
+      time,
+      date: dosDate,
+    });
+    offset += local.length + payload.length;
+  }
+
+  const cdStart = offset;
+  for (const e of central) {
+    const rec = new Uint8Array(46 + e.nameBytes.length);
+    const rv = new DataView(rec.buffer);
+    rv.setUint32(0, SIG_CENTRAL, true);
+    rv.setUint16(4, 20, true); // version made by
+    rv.setUint16(6, 20, true); // version needed
+    rv.setUint16(8, FLAG_UTF8, true);
+    rv.setUint16(10, e.method, true);
+    rv.setUint16(12, e.time, true);
+    rv.setUint16(14, e.date, true);
+    rv.setUint32(16, e.crc, true);
+    rv.setUint32(20, e.csize, true);
+    rv.setUint32(24, e.usize, true);
+    rv.setUint16(28, e.nameBytes.length, true);
+    rv.setUint16(30, 0, true); // extra
+    rv.setUint16(32, 0, true); // comment
+    rv.setUint16(34, 0, true); // disk start
+    rv.setUint16(36, 0, true); // internal attrs
+    rv.setUint32(38, 0, true); // external attrs
+    rv.setUint32(42, e.offset, true);
+    rec.set(e.nameBytes, 46);
+    chunks.push(rec);
+    offset += rec.length;
+  }
+
+  const cdSize = offset - cdStart;
+  const eocd = new Uint8Array(22);
+  const ev = new DataView(eocd.buffer);
+  ev.setUint32(0, SIG_EOCD, true);
+  ev.setUint16(4, 0, true);
+  ev.setUint16(6, 0, true);
+  ev.setUint16(8, central.length, true);
+  ev.setUint16(10, central.length, true);
+  ev.setUint32(12, cdSize, true);
+  ev.setUint32(16, cdStart, true);
+  ev.setUint16(20, 0, true);
+  chunks.push(eocd);
+
+  const total = chunks.reduce((s, c) => s + c.length, 0);
+  const out = new Uint8Array(total);
+  let p = 0;
+  for (const c of chunks) {
+    out.set(c, p);
+    p += c.length;
+  }
+  return out;
+}
+
+/**
+ * 解一个 zip 包。返回值按需解压，条目解压失败会抛错（不静默返回坏数据）。
+ *
+ * @param {Uint8Array} bytes
+ * @returns {Array<{name: string, size: number, bytes: () => Uint8Array, text: () => string}>}
+ */
+export function unzipSync(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  // 从尾部往前找 EOCD（注释最长 65535）
+  let eocd = -1;
+  const scanFrom = Math.max(0, bytes.length - 22 - 0xffff);
+  for (let i = bytes.length - 22; i >= scanFrom; i--) {
+    if (view.getUint32(i, true) === SIG_EOCD) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new Error('unzipSync: 找不到 EOCD，不是有效的 zip');
+
+  const count = view.getUint16(eocd + 10, true);
+  const cdSize = view.getUint32(eocd + 12, true);
+  const cdOffset = view.getUint32(eocd + 16, true);
+  if (cdOffset === MAX_UINT32 || cdSize === MAX_UINT32 || count === 0xffff) {
+    throw new Error('unzipSync: 疑似 Zip64，不支持');
+  }
+  if (cdOffset + cdSize > bytes.length) throw new Error('unzipSync: 中央目录越界，档案已损坏');
+
+  const out = [];
+  let p = cdOffset;
+  for (let i = 0; i < count; i++) {
+    if (view.getUint32(p, true) !== SIG_CENTRAL) throw new Error('unzipSync: 中央目录条目签名错误');
+    const method = view.getUint16(p + 10, true);
+    const crc = view.getUint32(p + 16, true);
+    const csize = view.getUint32(p + 20, true);
+    const usize = view.getUint32(p + 24, true);
+    const nameLen = view.getUint16(p + 28, true);
+    const extraLen = view.getUint16(p + 30, true);
+    const commentLen = view.getUint16(p + 32, true);
+    const localOffset = view.getUint32(p + 42, true);
+    const name = decoder.decode(bytes.subarray(p + 46, p + 46 + nameLen));
+    p += 46 + nameLen + extraLen + commentLen;
+
+    const readBytes = () => {
+      if (view.getUint32(localOffset, true) !== SIG_LOCAL) {
+        throw new Error(`unzipSync: 本地头签名错误：${name}`);
+      }
+      const lNameLen = view.getUint16(localOffset + 26, true);
+      const lExtraLen = view.getUint16(localOffset + 28, true);
+      const dataStart = localOffset + 30 + lNameLen + lExtraLen;
+      if (dataStart + csize > bytes.length) throw new Error(`unzipSync: 数据越界：${name}`);
+      const raw = bytes.subarray(dataStart, dataStart + csize);
+
+      let data;
+      if (method === METHOD_STORE) data = raw;
+      else if (method === METHOD_DEFLATE) data = new Uint8Array(inflateRawSync(raw));
+      else throw new Error(`unzipSync: 不支持的压缩方法 ${method}：${name}`);
+
+      if (data.length !== usize) throw new Error(`unzipSync: 长度不符：${name}`);
+      if (crc32(data) !== crc) throw new Error(`unzipSync: CRC 校验失败，档案已损坏：${name}`);
+      return data;
+    };
+
+    out.push({ name, size: usize, bytes: readBytes, text: () => decoder.decode(readBytes()) });
+  }
+  return out;
+}