@dimina-kit/fs-core 0.2.0-dev.20260710085051

package/dist/fs-core.worker.js

@@ -0,0 +1,1001 @@
+// src/worker-lib/wal-codec.ts
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes, start2 = 0, end = bytes.length) {
+  let c = 4294967295;
+  for (let i = start2; i < end; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+async function sha256hex(bytes) {
+  const d = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(d)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var SB_MAGIC = 1146569521;
+var SLOT_SIZE = 64;
+function encodeSlot(s) {
+  const buf = new ArrayBuffer(SLOT_SIZE);
+  const dv = new DataView(buf);
+  dv.setUint32(0, SB_MAGIC);
+  dv.setUint32(4, s.epoch);
+  dv.setFloat64(8, s.compactGen);
+  dv.setFloat64(16, s.walStartGen);
+  dv.setUint32(24, s.manifestCrc);
+  dv.setUint32(60, crc32(new Uint8Array(buf, 0, 60)));
+  return new Uint8Array(buf);
+}
+function decodeSlot(bytes) {
+  if (bytes.length < SLOT_SIZE) return null;
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, SLOT_SIZE);
+  if (dv.getUint32(60) !== crc32(bytes, 0, 60)) return null;
+  if (dv.getUint32(0) !== SB_MAGIC) return null;
+  return {
+    epoch: dv.getUint32(4),
+    compactGen: dv.getFloat64(8),
+    walStartGen: dv.getFloat64(16),
+    manifestCrc: dv.getUint32(24)
+  };
+}
+function frameRecord(gen, epoch, opcode, meta) {
+  const metaBytes = enc.encode(JSON.stringify(meta));
+  const len = 8 + 4 + 1 + 2 + metaBytes.length + 4 + 1;
+  const buf = new ArrayBuffer(4 + len);
+  const dv = new DataView(buf);
+  const u8 = new Uint8Array(buf);
+  dv.setUint32(0, len);
+  dv.setBigUint64(4, BigInt(gen));
+  dv.setUint32(12, epoch);
+  dv.setUint8(16, opcode);
+  dv.setUint16(17, metaBytes.length);
+  u8.set(metaBytes, 19);
+  const crcEnd = 19 + metaBytes.length;
+  dv.setUint32(crcEnd, crc32(u8, 4, crcEnd));
+  dv.setUint8(crcEnd + 4, 193);
+  return u8;
+}
+function parseRecord(u8, off) {
+  if (off + 4 > u8.length) return null;
+  const dv = new DataView(u8.buffer, u8.byteOffset);
+  const len = dv.getUint32(off);
+  if (len < 20 || off + 4 + len > u8.length) return null;
+  const gen = Number(dv.getBigUint64(off + 4));
+  const epoch = dv.getUint32(off + 12);
+  const opcode = dv.getUint8(off + 16);
+  const metaLen = dv.getUint16(off + 17);
+  const metaStart = off + 19;
+  const crcAt = metaStart + metaLen;
+  if (crcAt + 5 !== off + 4 + len) return null;
+  if (dv.getUint32(crcAt) !== crc32(u8, off + 4, crcAt)) return null;
+  if (dv.getUint8(crcAt + 4) !== 193) return null;
+  let meta;
+  try {
+    meta = JSON.parse(dec.decode(u8.subarray(metaStart, crcAt)));
+  } catch {
+    return null;
+  }
+  return { rec: { gen, epoch, opcode, meta }, next: off + 4 + len };
+}
+
+// src/worker-lib/paths.ts
+var DERIVED_PREFIXES = ["node_modules/", ".checkpoints/"];
+function normalizePath(p) {
+  if (typeof p !== "string" || !p || p.includes("\0") || p.includes("\\")) return null;
+  if (p.startsWith("/")) return null;
+  const parts = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") return null;
+    parts.push(seg);
+  }
+  return parts.length ? parts.join("/") : null;
+}
+
+// src/worker-lib/engine-shared.ts
+var OP = { WRITE: 1, RM: 2, MV: 3, MKDIR: 4, CHECKPOINT: 5, RESTORE: 6 };
+var OP_NAME = { 1: "write", 2: "rm", 3: "mv", 4: "mkdir", 5: "checkpoint", 6: "restore" };
+var WRITE_OPCODES = /* @__PURE__ */ new Set([OP.WRITE, OP.RM, OP.MV, OP.RESTORE]);
+var GROUP_WINDOW_MS = 50;
+var SEGMENT_ROTATE_BYTES = 4 * 1024 * 1024;
+var OPID_WINDOW = 1024;
+var TURN_DEFAULT_TTL_MS = 12e4;
+var TURN_MAX_OPS = 1e3;
+var AUDIT_CAP = 4096;
+var CHECKPOINT_KEEP = 20;
+function rpcErr(code, message, extra) {
+  const e = new Error(message);
+  e.code = code;
+  if (extra) e.extra = extra;
+  return e;
+}
+function epochFloor(replayed) {
+  return replayed.length ? replayed[replayed.length - 1].epoch : 0;
+}
+
+// src/fs-core-recovery.ts
+async function start(core2, projectId) {
+  core2.projectId = projectId;
+  core2.root = await (await navigator.storage.getDirectory()).getDirectoryHandle(projectId, { create: true });
+  core2.bc = new BroadcastChannel("dwc:" + projectId);
+  core2.bc.onmessage = (e) => core2.onBroadcast(e.data);
+  const granted = new Promise((resolve) => {
+    navigator.locks.request("dwc:writer:" + projectId, { mode: "exclusive" }, (lock) => {
+      resolve(lock);
+      return new Promise((release) => {
+        core2.releaseLock = release;
+      });
+    }).catch(() => resolve(null));
+  });
+  const winner = await Promise.race([granted, new Promise((r) => setTimeout(() => r("timeout"), 3e3))]);
+  if (winner === "timeout") {
+    await core2.recover();
+    core2.mode = "readonly";
+    core2.pushFullToQuery();
+    core2.welcome();
+    granted.then(async (lock) => {
+      if (!lock || core2.mode === "dead") return;
+      await core2.enqueue(async () => {
+        await core2.becomeWriter();
+      });
+    });
+    return;
+  }
+  await core2.becomeWriter();
+  core2.welcome();
+}
+async function becomeWriter(core2) {
+  await core2.recover();
+  core2.sbHandle = await (await core2.root.getFileHandle("superblock", { create: true })).createSyncAccessHandle();
+  core2.epoch += 1;
+  core2.writeSuperblock();
+  const segName = "wal." + core2.lastSegStart;
+  core2.walHandle = await (await core2.root.getFileHandle(segName, { create: true })).createSyncAccessHandle();
+  core2.walOffset = core2.lastSegValidEnd;
+  core2.mode = "writer";
+  core2.pushFullToQuery();
+  core2.event({ evt: "writer-granted", gen: core2.memGen });
+  if (core2.walOffset > SEGMENT_ROTATE_BYTES) core2.enqueue(() => core2.compactNow());
+}
+function writeSuperblock(core2) {
+  const cand = 1 - core2.currentSlot;
+  const bytes = encodeSlot({ epoch: core2.epoch, compactGen: core2.compactGen, walStartGen: core2.walStartGen, manifestCrc: core2.manifestCrc || 0 });
+  const n = core2.sbHandle.write(bytes, { at: cand * SLOT_SIZE });
+  if (n !== SLOT_SIZE) throw new Error("superblock partial write: " + n);
+  core2.sbHandle.flush();
+  core2.currentSlot = cand;
+}
+async function loadSuperblockSlot(core2) {
+  let sb = null;
+  try {
+    const f = await (await core2.root.getFileHandle("superblock")).getFile();
+    const u8 = new Uint8Array(await f.arrayBuffer());
+    const s0 = decodeSlot(u8.subarray(0, SLOT_SIZE));
+    const s1 = u8.length >= 128 ? decodeSlot(u8.subarray(SLOT_SIZE, 2 * SLOT_SIZE)) : null;
+    if (s0 && s1) {
+      sb = s1.compactGen > s0.compactGen || s1.compactGen === s0.compactGen && s1.epoch >= s0.epoch ? s1 : s0;
+      core2.currentSlot = sb === s1 ? 1 : 0;
+    } else if (s0) {
+      sb = s0;
+      core2.currentSlot = 0;
+    } else if (s1) {
+      sb = s1;
+      core2.currentSlot = 1;
+    }
+  } catch {
+  }
+  if (!sb) {
+    sb = { epoch: 0, compactGen: 0, walStartGen: 1, manifestCrc: 0 };
+    core2.currentSlot = 1;
+  }
+  return sb;
+}
+async function loadManifestState(core2, compactGen) {
+  if (compactGen <= 0) return 0;
+  const f = await (await (await core2.root.getDirectoryHandle("manifests")).getFileHandle(compactGen + ".json")).getFile();
+  const bytes = new Uint8Array(await f.arrayBuffer());
+  if (crc32(bytes) !== core2.manifestCrc) throw new Error("manifest CRC mismatch (gen " + compactGen + ")");
+  const m = JSON.parse(dec.decode(bytes));
+  for (const [path, ent] of Object.entries(m.files)) {
+    core2.mirror.set(path, { content: await core2.readBlob(ent.h), rev: ent.rev });
+  }
+  for (const [cpId, entry] of Object.entries(m.checkpoints || {})) core2.checkpoints.set(cpId, entry);
+  return m.gen;
+}
+async function listWalSegmentNumbers(core2) {
+  const segs = [];
+  for await (const [name] of core2.root.entries()) {
+    const m = /^wal\.(\d+)$/.exec(name);
+    if (m && +m[1] >= core2.walStartGen) segs.push(+m[1]);
+  }
+  segs.sort((a, b) => a - b);
+  return segs;
+}
+function shouldStopReplay(p, gen, stopBefore, replayed) {
+  if (!p) return true;
+  if (p.rec.gen !== gen + 1) return true;
+  if (p.rec.gen >= stopBefore) return true;
+  if (p.rec.epoch < epochFloor(replayed)) return true;
+  return false;
+}
+async function replaySegment(core2, segNum, stopBefore, gen, replayed, isLastSeg) {
+  const f = await (await core2.root.getFileHandle("wal." + segNum)).getFile();
+  const u8 = new Uint8Array(await f.arrayBuffer());
+  let off = 0;
+  while (off < u8.length) {
+    const p = parseRecord(u8, off);
+    if (shouldStopReplay(p, gen, stopBefore, replayed)) break;
+    await core2.applyRecord(p.rec);
+    gen = p.rec.gen;
+    replayed.push(p.rec);
+    const m = p.rec.meta;
+    core2.audit({ gen, opcode: p.rec.opcode, actor: m.actor, turnId: m.turnId, path: m.path, from: m.from, to: m.to, cpId: m.cpId });
+    off = p.next;
+    if (isLastSeg) core2.lastSegValidEnd = off;
+  }
+  return gen;
+}
+async function replayWalSegments(core2, segs, gen0) {
+  let gen = gen0;
+  const replayed = [];
+  for (let i = 0; i < segs.length; i++) {
+    const stopBefore = i + 1 < segs.length ? segs[i + 1] : Infinity;
+    gen = await replaySegment(core2, segs[i], stopBefore, gen, replayed, segs[i] === core2.lastSegStart);
+  }
+  return { finalGen: gen, replayed };
+}
+async function recover(core2) {
+  core2.mirror.clear();
+  core2.checkpoints.clear();
+  core2.opIds.clear();
+  core2.auditLog = [];
+  core2.turn = null;
+  const sb = await loadSuperblockSlot(core2);
+  core2.epoch = sb.epoch;
+  core2.compactGen = sb.compactGen;
+  core2.walStartGen = sb.walStartGen;
+  core2.manifestCrc = sb.manifestCrc;
+  let gen = await loadManifestState(core2, core2.compactGen);
+  const segs = await listWalSegmentNumbers(core2);
+  core2.lastSegStart = segs.length ? segs[segs.length - 1] : core2.walStartGen;
+  core2.lastSegValidEnd = 0;
+  const { finalGen, replayed } = await replayWalSegments(core2, segs, gen);
+  gen = finalGen;
+  core2.appendedGen = core2.walGen = core2.memGen = core2.ackGen = gen;
+  core2.trimCheckpoints();
+  for (const r of replayed.slice(-OPID_WINDOW)) {
+    if (r.meta.opId) core2.rememberOpId(r.meta.opId, { gen: r.gen });
+  }
+  if (!segs.length) {
+    await core2.root.getFileHandle("wal." + core2.walStartGen, { create: true });
+  }
+}
+async function applyRecord(core2, r) {
+  const m = r.meta;
+  switch (r.opcode) {
+    case OP.WRITE: {
+      const content = m.payload?.inline !== void 0 ? m.payload.inline : await core2.readBlob(m.payload.h);
+      core2.mirror.set(m.path, { content, rev: r.gen });
+      break;
+    }
+    case OP.RM:
+      core2.mirror.delete(m.path);
+      break;
+    case OP.MV: {
+      const e = core2.mirror.get(m.from);
+      if (e) {
+        core2.mirror.delete(m.from);
+        core2.mirror.set(m.to, { content: e.content, rev: r.gen });
+      }
+      break;
+    }
+    case OP.MKDIR:
+      break;
+    // 目录隐式；记录仅为审计
+    case OP.CHECKPOINT:
+      core2.checkpoints.set(m.cpId, { h: m.h, gen: r.gen });
+      break;
+    case OP.RESTORE: {
+      const map = JSON.parse(await core2.readBlob(m.h));
+      const next = /* @__PURE__ */ new Map();
+      for (const [path, h] of Object.entries(map)) next.set(path, { content: await core2.readBlob(h), rev: r.gen });
+      core2.mirror = next;
+      break;
+    }
+  }
+}
+async function ensureBlob(core2, content) {
+  const bytes = enc.encode(content);
+  const h = await sha256hex(bytes);
+  const d2 = await (await core2.root.getDirectoryHandle("blobs", { create: true })).getDirectoryHandle(h.slice(0, 2), { create: true });
+  try {
+    await d2.getFileHandle(h);
+    return h;
+  } catch {
+  }
+  const fh = await d2.getFileHandle(h, { create: true });
+  const sh = await fh.createSyncAccessHandle();
+  sh.write(bytes);
+  sh.flush();
+  sh.close();
+  return h;
+}
+async function readBlob(core2, h) {
+  const f = await (await (await (await core2.root.getDirectoryHandle("blobs")).getDirectoryHandle(h.slice(0, 2))).getFileHandle(h)).getFile();
+  return f.text();
+}
+function opRead(core2, { path }) {
+  const norm = normalizePath(path);
+  const e = norm && core2.mirror.get(norm);
+  if (!e) throw rpcErr("not-found", String(path));
+  return { content: e.content, rev: e.rev, gen: core2.memGen };
+}
+function opLs(core2) {
+  return { paths: [...core2.mirror.keys()].sort(), gen: core2.memGen };
+}
+function opStatus(core2) {
+  const { mode, appendedGen, walGen, memGen, ackGen, compactGen, epoch, walStartGen } = core2;
+  return {
+    mode,
+    appendedGen,
+    walGen,
+    memGen,
+    ackGen,
+    compactGen,
+    epoch,
+    walStartGen,
+    checkpoints: [...core2.checkpoints.keys()],
+    turn: core2.turn ? { turnId: core2.turn.turnId, cpId: core2.turn.cpId, expiresAt: core2.turn.expiresAt, ops: core2.turn.ops } : null
+  };
+}
+function pushDiff(core2, diff, gen) {
+  if (!core2.queryPort) return;
+  const wire = {};
+  for (const [p, ent] of Object.entries(diff)) wire[p] = ent ? { content: ent.content, rev: ent.rev } : null;
+  core2.queryPort.postMessage({ gen, diff: wire });
+}
+function pushFullToQuery(core2) {
+  if (!core2.queryPort) return;
+  const files = {};
+  for (const [p, ent] of core2.mirror) files[p] = { content: ent.content, rev: ent.rev };
+  core2.queryPort.postMessage({ gen: core2.memGen, full: true, files });
+}
+function event(core2, e) {
+  if (core2.clientPort) core2.clientPort.postMessage(e);
+}
+function welcome(core2) {
+  core2.event({ type: "WELCOME", epoch: core2.epoch, memGen: core2.memGen, readonly: core2.mode !== "writer", mode: core2.mode });
+}
+async function onBroadcast(core2, msg) {
+  if (msg.type === "handover-request" && core2.mode === "writer") {
+    core2.mode = "draining";
+    await core2.enqueue(async () => {
+      core2.flushWindow();
+      core2.walHandle.close();
+      core2.walHandle = null;
+      core2.sbHandle.close();
+      core2.sbHandle = null;
+      core2.mode = "readonly";
+      if (core2.releaseLock) {
+        core2.releaseLock();
+        core2.releaseLock = null;
+      }
+      core2.bc.postMessage({ type: "handover-done", gen: core2.memGen });
+      core2.event({ evt: "writer-lost", gen: core2.memGen });
+    });
+  }
+}
+
+// src/fs-core-write-ops.ts
+function enqueue(core2, fn) {
+  const run = core2.chain.then(fn);
+  core2.chain = run.catch(() => {
+  });
+  return run;
+}
+function appendSync(core2, opcode, meta, checks) {
+  if (core2.mode !== "writer") throw rpcErr("readonly", "fs-core is " + core2.mode);
+  if (checks) checks();
+  if (core2.walOffset > SEGMENT_ROTATE_BYTES) throw rpcErr("rotate-needed", "internal");
+  const gen = core2.appendedGen + 1;
+  const frame = frameRecord(gen, core2.epoch, opcode, meta);
+  const n = core2.walHandle.write(frame, { at: core2.walOffset });
+  if (n !== frame.length) throw new Error("WAL partial write");
+  core2.walOffset += frame.length;
+  core2.appendedGen = gen;
+  core2.audit({ gen, opcode, actor: meta.actor, turnId: meta.turnId, path: meta.path, from: meta.from, to: meta.to, cpId: meta.cpId });
+  return gen;
+}
+function audit(core2, entry) {
+  core2.auditLog.push(entry);
+  if (core2.auditLog.length > AUDIT_CAP) core2.auditLog.splice(0, core2.auditLog.length - AUDIT_CAP);
+}
+function checkTurn(core2, actor, turnId, agentToken) {
+  if (actor !== "agent") return;
+  const t = core2.turn;
+  if (!t || t.turnId !== turnId) throw rpcErr("turn-closed", "agent write requires an active turn (got " + turnId + ")");
+  if (Date.now() > t.expiresAt) {
+    core2.turn = null;
+    throw rpcErr("turn-closed", "turn expired: " + turnId);
+  }
+  if (core2.agentToken !== null && agentToken !== core2.agentToken) {
+    throw rpcErr("agent-token-required", "agent write requires a valid agent token");
+  }
+  if (++t.ops > TURN_MAX_OPS) throw rpcErr("turn-quota", "per-turn op quota exceeded (" + TURN_MAX_OPS + ")");
+}
+function armAgentToken(core2, token) {
+  if (typeof token !== "string" || !token) throw rpcErr("bad-args", "agent token must be a non-empty string");
+  if (core2.agentToken === null) {
+    core2.agentToken = token;
+    return { armed: true };
+  }
+  if (core2.agentToken === token) return { armed: true, idempotent: true };
+  throw rpcErr("agent-token-gate-armed", "agent token gate already armed with a different token");
+}
+function checkRestoreConflict(core2, baseGen) {
+  const oldestGen = core2.auditLog.length ? core2.auditLog[0].gen : core2.appendedGen + 1;
+  if (oldestGen > baseGen + 1) {
+    throw rpcErr("restore-conflict", "audit log does not cover baseGen " + baseGen, { humanPaths: [], auditGap: true });
+  }
+  const humanPaths = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of core2.auditLog) {
+    if (e.gen <= baseGen || e.actor !== "human" || !WRITE_OPCODES.has(e.opcode)) continue;
+    const p = e.opcode === OP.MV ? e.to || e.from : e.opcode === OP.RESTORE ? "(restore:" + e.cpId + ")" : e.path;
+    if (p && !seen.has(p)) {
+      seen.add(p);
+      humanPaths.push(p);
+    }
+  }
+  if (humanPaths.length) throw rpcErr("restore-conflict", "human edits since baseGen " + baseGen, { humanPaths });
+}
+function curOf(core2, path) {
+  return core2.staged.has(path) ? core2.staged.get(path) ?? null : core2.mirror.get(path) || null;
+}
+function checkWrite(core2, path, ifMatch, _actor) {
+  const norm = normalizePath(path);
+  if (!norm) throw rpcErr("bad-path", "invalid path: " + path);
+  for (const p of DERIVED_PREFIXES) if (norm.startsWith(p)) throw rpcErr("derived-readonly", norm + " is derived area");
+  if (core2.mode === "draining") throw rpcErr("draining", "writer is handing over");
+  const cur = core2.curOf(norm);
+  if (ifMatch === null && cur) throw rpcErr("cas-mismatch", norm + " already exists");
+  if (typeof ifMatch === "number" && (!cur || cur.rev !== ifMatch)) {
+    throw rpcErr("cas-mismatch", norm + " rev=" + (cur ? cur.rev : "none") + " ifMatch=" + ifMatch);
+  }
+  return norm;
+}
+async function rotateIfNeeded(core2) {
+  if (core2.walOffset <= SEGMENT_ROTATE_BYTES) return;
+  await core2.compactNow();
+}
+async function newSegment(core2, startGen) {
+  const name = "wal." + startGen;
+  const fh = await core2.root.getFileHandle(name + ".tmp", { create: true });
+  const sh = await fh.createSyncAccessHandle();
+  sh.flush();
+  sh.close();
+  if (fh.move) await fh.move(name);
+  else {
+    await core2.root.getFileHandle(name, { create: true });
+    try {
+      await core2.root.removeEntry(name + ".tmp");
+    } catch {
+    }
+  }
+  core2.walHandle = await (await core2.root.getFileHandle(name)).createSyncAccessHandle();
+  core2.walOffset = 0;
+}
+function flushWindow(core2) {
+  if (core2.flushTimer) {
+    clearTimeout(core2.flushTimer);
+    core2.flushTimer = null;
+  }
+  if (!core2.windowOps.length) return;
+  core2.walHandle.flush();
+  core2.walGen = core2.appendedGen;
+  const diff = {};
+  for (const [path, ent] of core2.staged) {
+    if (ent === null) core2.mirror.delete(path);
+    else core2.mirror.set(path, ent);
+    diff[path] = ent;
+  }
+  core2.staged.clear();
+  core2.memGen = core2.walGen;
+  core2.pushDiff(diff, core2.memGen);
+  const paths = [];
+  let actor = "human";
+  for (const w of core2.windowOps) {
+    core2.ackGen = Math.max(core2.ackGen, w.gen);
+    if (w.opId) core2.rememberOpId(w.opId, { gen: w.gen });
+    w.respond({ ok: true, result: { gen: w.gen, rev: w.gen, ...w.extra } });
+    if (w.path) paths.push(w.path);
+    if (w.actor === "agent") actor = "agent";
+  }
+  core2.windowOps = [];
+  core2.event({ evt: "fs-change", gen: core2.memGen, actor, ...paths.length <= 32 ? { paths } : { count: paths.length } });
+  core2.bc.postMessage({ type: "fs-change", gen: core2.memGen });
+}
+function rememberOpId(core2, opId, v) {
+  core2.opIds.set(opId, v);
+  if (core2.opIds.size > OPID_WINDOW) core2.opIds.delete(core2.opIds.keys().next().value);
+}
+function scheduleFlush(core2, immediate) {
+  if (immediate) {
+    core2.flushWindow();
+    return;
+  }
+  if (!core2.flushTimer) core2.flushTimer = setTimeout(() => core2.enqueue(() => core2.flushWindow()), GROUP_WINDOW_MS);
+}
+async function opWrite(core2, { path, content, ifMatch, actor = "human", turnId, agentToken, opId }, respond) {
+  if (typeof content !== "string") throw rpcErr("bad-args", "content must be string");
+  await core2.rotateIfNeeded();
+  const payload = enc.encode(content).length <= 4096 ? { inline: content } : { h: await core2.ensureBlob(content) };
+  const norm = normalizePath(path);
+  const meta = { opId, path: norm, actor, turnId, ifMatch, payload };
+  const gen = core2.appendSync(OP.WRITE, meta, () => {
+    core2.checkTurn(actor, turnId, agentToken);
+    core2.checkWrite(path, ifMatch, actor);
+  });
+  core2.staged.set(norm, { content, rev: gen });
+  core2.windowOps.push({ respond, gen, path: norm, actor, opId });
+  core2.scheduleFlush(actor === "agent");
+}
+async function opEdit(core2, { path, old, next, ifMatch, actor = "human", turnId, agentToken, opId }, respond) {
+  const norm = normalizePath(path);
+  const cur = norm && core2.curOf(norm);
+  if (!cur) throw rpcErr("not-found", String(path));
+  const idx = cur.content.indexOf(old);
+  if (idx === -1) throw rpcErr("edit-no-match", "old string not found in " + norm);
+  if (cur.content.indexOf(old, idx + 1) !== -1) throw rpcErr("edit-ambiguous", "old string not unique in " + norm);
+  const content = cur.content.slice(0, idx) + next + cur.content.slice(idx + old.length);
+  return core2.opWrite({ path, content, ifMatch: ifMatch !== void 0 ? ifMatch : cur.rev, actor, turnId, agentToken, opId }, respond);
+}
+async function opRm(core2, { path, actor = "human", turnId, agentToken, opId }, respond) {
+  await core2.rotateIfNeeded();
+  const gen = core2.appendSync(OP.RM, { opId, path: normalizePath(path), actor, turnId }, () => {
+    core2.checkTurn(actor, turnId, agentToken);
+    const norm = core2.checkWrite(path, void 0, actor);
+    if (!core2.curOf(norm)) throw rpcErr("not-found", norm);
+  });
+  core2.staged.set(normalizePath(path), null);
+  core2.windowOps.push({ respond, gen, path: normalizePath(path), actor, opId });
+  core2.scheduleFlush(true);
+}
+async function opMv(core2, { from, to, actor = "human", turnId, agentToken, opId }, respond) {
+  await core2.rotateIfNeeded();
+  const nf = normalizePath(from);
+  const nt = normalizePath(to);
+  const gen = core2.appendSync(OP.MV, { opId, from: nf, to: nt, actor, turnId }, () => {
+    core2.checkTurn(actor, turnId, agentToken);
+    core2.checkWrite(from, void 0, actor);
+    core2.checkWrite(to, void 0, actor);
+    if (!core2.curOf(nf)) throw rpcErr("not-found", nf);
+    if (core2.curOf(nt)) throw rpcErr("cas-mismatch", nt + " exists");
+  });
+  const e = core2.curOf(nf);
+  core2.staged.set(nf, null);
+  core2.staged.set(nt, { content: e.content, rev: gen });
+  core2.windowOps.push({ respond, gen, path: nt, actor, opId });
+  core2.scheduleFlush(true);
+}
+async function makeCheckpoint(core2, { opId, actor, turnId }) {
+  core2.flushWindow();
+  await core2.rotateIfNeeded();
+  const map = {};
+  for (const [path, ent] of core2.mirror) map[path] = await core2.ensureBlob(ent.content);
+  const h = await core2.ensureBlob(JSON.stringify(map));
+  const cpId = "cp-" + (core2.appendedGen + 1);
+  const gen = core2.appendSync(OP.CHECKPOINT, { opId, cpId, h, actor, turnId }, () => {
+    if (core2.mode === "draining") throw rpcErr("draining", "handing over");
+  });
+  core2.checkpoints.set(cpId, { h, gen });
+  core2.trimCheckpoints();
+  return { cpId, gen };
+}
+function trimCheckpoints(core2) {
+  while (core2.checkpoints.size > CHECKPOINT_KEEP) {
+    core2.checkpoints.delete(core2.checkpoints.keys().next().value);
+  }
+}
+async function opCheckpoint(core2, { actor = "human", turnId, agentToken, opId }, respond) {
+  core2.checkTurn(actor, turnId, agentToken);
+  const { cpId, gen } = await core2.makeCheckpoint({ opId, actor, turnId });
+  core2.windowOps.push({ respond, gen, actor, opId, extra: { cpId } });
+  core2.scheduleFlush(true);
+}
+async function opTurnBegin(core2, { turnId, ttlMs, opId }, respond) {
+  if (!turnId || typeof turnId !== "string") throw rpcErr("bad-args", "turnId required");
+  if (core2.turn && Date.now() <= core2.turn.expiresAt) {
+    throw rpcErr("turn-active", "a turn is already active: " + core2.turn.turnId);
+  }
+  const { cpId, gen } = await core2.makeCheckpoint({ opId, actor: "agent", turnId });
+  const expiresAt = Date.now() + (ttlMs || TURN_DEFAULT_TTL_MS);
+  core2.turn = { turnId, cpId, expiresAt, ops: 0 };
+  core2.windowOps.push({ respond, gen, actor: "agent", opId, extra: { turnId, cpId, expiresAt } });
+  core2.scheduleFlush(true);
+}
+function opTurnEnd(core2, { turnId }, respond) {
+  const active = !!(core2.turn && core2.turn.turnId === turnId);
+  const ops = active ? core2.turn.ops : 0;
+  if (active) core2.turn = null;
+  respond({ ok: true, result: { turnId, closed: active, ops } });
+}
+function opDiff(core2, { turnId }) {
+  const changes = core2.auditLog.filter((e) => e.turnId === turnId && e.opcode !== OP.CHECKPOINT).map((e) => ({ gen: e.gen, op: OP_NAME[e.opcode], path: e.path, from: e.from, to: e.to }));
+  const cpId = core2.turn && core2.turn.turnId === turnId ? core2.turn.cpId : (core2.auditLog.find((e) => e.turnId === turnId && e.opcode === OP.CHECKPOINT) || {}).cpId;
+  return { turnId, changes, cpId, auditWindow: { cap: AUDIT_CAP, sinceGen: core2.auditLog.length ? core2.auditLog[0].gen : core2.memGen } };
+}
+async function opRestore(core2, { cpId, baseGen, force = false, actor = "human", turnId, agentToken, opId }, respond) {
+  core2.flushWindow();
+  await core2.rotateIfNeeded();
+  const entry = core2.checkpoints.get(cpId);
+  if (!entry) throw rpcErr("not-found", "checkpoint " + cpId);
+  const effectiveBaseGen = typeof baseGen === "number" ? baseGen : entry.gen;
+  const map = JSON.parse(await core2.readBlob(entry.h));
+  const files = {};
+  for (const [path, bh] of Object.entries(map)) files[path] = await core2.readBlob(bh);
+  const gen = core2.appendSync(OP.RESTORE, { opId, cpId, h: entry.h, actor, turnId }, () => {
+    core2.checkTurn(actor, turnId, agentToken);
+    if (core2.mode === "draining") throw rpcErr("draining", "handing over");
+    if (!force) core2.checkRestoreConflict(effectiveBaseGen);
+  });
+  core2.walHandle.flush();
+  core2.walGen = gen;
+  const next = /* @__PURE__ */ new Map();
+  for (const [path, content] of Object.entries(files)) next.set(path, { content, rev: gen });
+  core2.mirror = next;
+  core2.memGen = core2.walGen;
+  core2.ackGen = gen;
+  if (opId) core2.rememberOpId(opId, { gen });
+  core2.pushFullToQuery();
+  respond({ ok: true, result: { gen, restored: Object.keys(files).length } });
+  core2.event({ evt: "fs-change", gen, actor, count: Object.keys(files).length, restore: cpId });
+  core2.bc.postMessage({ type: "fs-change", gen });
+}
+async function opCompact(core2, _args, respond) {
+  const r = await core2.compactNow();
+  respond({ ok: true, result: r });
+}
+async function buildManifestFiles(core2) {
+  const files = {};
+  for (const [path, ent] of core2.mirror) files[path] = { h: await core2.ensureBlob(ent.content), rev: ent.rev };
+  return files;
+}
+async function writeManifestFile(core2, G, manifestBytes) {
+  const mDir = await core2.root.getDirectoryHandle("manifests", { create: true });
+  const mh = await (await mDir.getFileHandle(G + ".json", { create: true })).createSyncAccessHandle();
+  mh.write(manifestBytes);
+  mh.flush();
+  mh.close();
+  return mDir;
+}
+async function listAllSegmentNumbers(core2) {
+  const oldSegs = [];
+  for await (const [name] of core2.root.entries()) {
+    const m = /^wal\.(\d+)$/.exec(name);
+    if (m) oldSegs.push(+m[1]);
+  }
+  return oldSegs;
+}
+async function removeOldSegments(core2, oldSegs) {
+  for (const s of oldSegs) {
+    try {
+      await core2.root.removeEntry("wal." + s);
+    } catch {
+    }
+  }
+}
+async function computeReferencedBlobs(core2, files) {
+  const referenced = new Set(Object.values(files).map((f) => f.h));
+  for (const entry of core2.checkpoints.values()) {
+    referenced.add(entry.h);
+    try {
+      for (const bh of Object.values(JSON.parse(await core2.readBlob(entry.h)))) referenced.add(bh);
+    } catch {
+    }
+  }
+  return referenced;
+}
+async function gcUnreferencedBlobs(core2, referenced) {
+  try {
+    const blobs = await core2.root.getDirectoryHandle("blobs");
+    for await (const [d2name, d2] of blobs.entries()) {
+      void d2name;
+      if (d2.kind !== "directory") continue;
+      for await (const [name] of d2.entries()) {
+        if (!referenced.has(name)) {
+          try {
+            await d2.removeEntry(name);
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function gcOldManifests(core2, mDir, keepName) {
+  try {
+    for await (const [name] of mDir.entries()) {
+      if (name !== keepName) {
+        try {
+          await mDir.removeEntry(name);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function compactNow(core2) {
+  core2.flushWindow();
+  const G = core2.memGen;
+  if (G === core2.compactGen) return { gen: G, skipped: true };
+  const files = await buildManifestFiles(core2);
+  const checkpoints = Object.fromEntries(core2.checkpoints);
+  const manifestBytes = enc.encode(JSON.stringify({ gen: G, epoch: core2.epoch, files, checkpoints }));
+  const mDir = await writeManifestFile(core2, G, manifestBytes);
+  const oldSegs = await listAllSegmentNumbers(core2);
+  core2.walHandle.close();
+  await core2.newSegment(G + 1);
+  core2.lastSegStart = G + 1;
+  core2.manifestCrc = crc32(manifestBytes);
+  core2.compactGen = G;
+  core2.walStartGen = G + 1;
+  core2.writeSuperblock();
+  await removeOldSegments(core2, oldSegs);
+  const referenced = await computeReferencedBlobs(core2, files);
+  await gcUnreferencedBlobs(core2, referenced);
+  await gcOldManifests(core2, mDir, G + ".json");
+  return { gen: G };
+}
+
+// src/fs-core.worker.ts
+var FsCore = class {
+  mode = "starting";
+  mirror = /* @__PURE__ */ new Map();
+  checkpoints = /* @__PURE__ */ new Map();
+  opIds = /* @__PURE__ */ new Map();
+  appendedGen = 0;
+  walGen = 0;
+  memGen = 0;
+  ackGen = 0;
+  compactGen = 0;
+  epoch = 0;
+  walStartGen = 1;
+  staged = /* @__PURE__ */ new Map();
+  windowOps = [];
+  flushTimer = null;
+  chain = Promise.resolve();
+  clientPort = null;
+  queryPort = null;
+  releaseLock = null;
+  walHandle = null;
+  walOffset = 0;
+  sbHandle = null;
+  currentSlot = 0;
+  turn = null;
+  // {turnId, cpId, expiresAt, ops} —— 内存态：worker 重启即失效（安全默认）
+  auditLog = [];
+  // 环形
+  // W4 纵深加固令牌门（docs/k3-terminal-split-plan.md §6 替代方案 A / §8.3）：只有内核持有的
+  // 随机令牌，一次性置位（armAgentToken）。null = 未 arm（门不生效，checkTurn 不额外校验）——
+  // 保证不起内核的裸 fs 场景（fs 域单测/工具，如 test:fs-smoke/test:fs-wal 直连 client）零回归。
+  // 同 worker 重启即失效（内存态，不落 WAL/持久层），与 this.turn 同一安全默认。
+  agentToken = null;
+  projectId;
+  root;
+  bc;
+  lastSegStart;
+  lastSegValidEnd;
+  manifestCrc;
+  // ── 启动/恢复/只读查询（fs-core-recovery.ts） ──
+  start(projectId) {
+    return start(this, projectId);
+  }
+  becomeWriter() {
+    return becomeWriter(this);
+  }
+  writeSuperblock() {
+    writeSuperblock(this);
+  }
+  recover() {
+    return recover(this);
+  }
+  applyRecord(r) {
+    return applyRecord(this, r);
+  }
+  epochFloor(replayed) {
+    return epochFloor(replayed);
+  }
+  ensureBlob(content) {
+    return ensureBlob(this, content);
+  }
+  readBlob(h) {
+    return readBlob(this, h);
+  }
+  opRead(args) {
+    return opRead(this, args);
+  }
+  opLs() {
+    return opLs(this);
+  }
+  opStatus() {
+    return opStatus(this);
+  }
+  pushDiff(diff, gen) {
+    pushDiff(this, diff, gen);
+  }
+  pushFullToQuery() {
+    pushFullToQuery(this);
+  }
+  event(e) {
+    event(this, e);
+  }
+  welcome() {
+    welcome(this);
+  }
+  onBroadcast(msg) {
+    return onBroadcast(this, msg);
+  }
+  // ── 写路径/compaction（fs-core-write-ops.ts） ──
+  enqueue(fn) {
+    return enqueue(this, fn);
+  }
+  appendSync(opcode, meta, checks) {
+    return appendSync(this, opcode, meta, checks);
+  }
+  audit(entry) {
+    audit(this, entry);
+  }
+  checkTurn(actor, turnId, agentToken) {
+    checkTurn(this, actor, turnId, agentToken);
+  }
+  armAgentToken(token) {
+    return armAgentToken(this, token);
+  }
+  checkRestoreConflict(baseGen) {
+    checkRestoreConflict(this, baseGen);
+  }
+  curOf(path) {
+    return curOf(this, path);
+  }
+  checkWrite(path, ifMatch, actor) {
+    return checkWrite(this, path, ifMatch, actor);
+  }
+  rotateIfNeeded() {
+    return rotateIfNeeded(this);
+  }
+  newSegment(startGen) {
+    return newSegment(this, startGen);
+  }
+  flushWindow() {
+    flushWindow(this);
+  }
+  rememberOpId(opId, v) {
+    rememberOpId(this, opId, v);
+  }
+  scheduleFlush(immediate) {
+    scheduleFlush(this, immediate);
+  }
+  opWrite(args, respond) {
+    return opWrite(this, args, respond);
+  }
+  opEdit(args, respond) {
+    return opEdit(this, args, respond);
+  }
+  opRm(args, respond) {
+    return opRm(this, args, respond);
+  }
+  opMv(args, respond) {
+    return opMv(this, args, respond);
+  }
+  makeCheckpoint(args) {
+    return makeCheckpoint(this, args);
+  }
+  trimCheckpoints() {
+    trimCheckpoints(this);
+  }
+  opCheckpoint(args, respond) {
+    return opCheckpoint(this, args, respond);
+  }
+  opTurnBegin(args, respond) {
+    return opTurnBegin(this, args, respond);
+  }
+  opTurnEnd(args, respond) {
+    opTurnEnd(this, args, respond);
+  }
+  opDiff(args) {
+    return opDiff(this, args);
+  }
+  opRestore(args, respond) {
+    return opRestore(this, args, respond);
+  }
+  opCompact(args, respond) {
+    return opCompact(this, args, respond);
+  }
+  compactNow() {
+    return compactNow(this);
+  }
+  handleRpc(msg) {
+    const respond = (r) => this.clientPort.postMessage({ id: msg.id, ...r });
+    const fail = (e) => respond({ ok: false, code: e.code || "internal", error: e.message || String(e), ...e.extra || {} });
+    if (msg.opId && this.opIds.has(msg.opId)) {
+      const known = this.opIds.get(msg.opId);
+      respond({ ok: true, result: { ...known, rev: known.gen, idempotent: true } });
+      return;
+    }
+    const a = { ...msg.args, opId: msg.opId };
+    const table = {
+      write: () => this.opWrite(a, respond),
+      edit: () => this.opEdit(a, respond),
+      rm: () => this.opRm(a, respond),
+      mv: () => this.opMv(a, respond),
+      mkdir: () => {
+        respond({ ok: true, result: { gen: this.memGen } });
+      },
+      // 目录隐式，保留 API
+      checkpoint: () => this.opCheckpoint(a, respond),
+      restore: () => this.opRestore(a, respond),
+      compact: () => this.opCompact(a, respond),
+      turnBegin: () => this.opTurnBegin(a, respond),
+      turnEnd: () => this.opTurnEnd(a, respond),
+      diff: () => respond({ ok: true, result: this.opDiff(a) }),
+      read: () => respond({ ok: true, result: this.opRead(a) }),
+      ls: () => respond({ ok: true, result: this.opLs() }),
+      status: () => respond({ ok: true, result: this.opStatus() }),
+      // W4 令牌门铸造（§6 替代方案 A / §8.3）：纯内存状态置位，无 I/O、不让出，
+      // 不入 WAL 序列化链——同步分支即可（同 read/ls/status），不打扰组提交/恢复逻辑。
+      armAgentTokenGate: () => respond({ ok: true, result: this.armAgentToken(a.token) })
+    };
+    const fn = table[msg.op];
+    if (!fn) {
+      fail(rpcErr("bad-op", String(msg.op)));
+      return;
+    }
+    if (["write", "edit", "rm", "mv", "checkpoint", "restore", "compact", "turnBegin", "turnEnd"].includes(msg.op)) {
+      this.enqueue(async () => {
+        try {
+          await fn();
+        } catch (e) {
+          fail(e);
+        }
+      });
+    } else {
+      try {
+        fn();
+      } catch (e) {
+        fail(e);
+      }
+    }
+  }
+};
+var core = new FsCore();
+self.onmessage = async (e) => {
+  const msg = e.data;
+  if (msg.type === "HELLO") {
+    core.clientPort = self;
+    core.queryPort = msg.queryPort || null;
+    try {
+      await core.start(msg.projectId);
+    } catch (err) {
+      const stack = err instanceof Error ? err.stack : void 0;
+      self.postMessage({ type: "FATAL", error: String(stack || err) });
+    }
+    return;
+  }
+  if (msg.type === "PING") {
+    self.postMessage({ type: "PONG", t: msg.t });
+    return;
+  }
+  if (msg.id !== void 0) core.handleRpc(msg);
+};
+export {
+  FsCore
+};