dsh-live-compact 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-live-compact",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "In-place newest-turn compaction for DeepSeek Harness. Compress while the task runs and keep the prefix.",
   "license": "MIT",
   "author": "MerkyorLynn <268568828+MerkyorLynn@users.noreply.github.com>",
@@ -17,6 +17,7 @@
     "./shadow-search": "./shadow-search.js"
   },
   "files": [
+    "CHANGELOG.md",
     "shell.js",
     "adapter.js",
     "settings.js",
@@ -26,6 +27,7 @@
     "plan.js",
     "raw.js",
     "shadow.js",
+    "shadow-save-worker.mjs",
     "shadow-search.js",
     "cooldown.js",
     "thunder.js",
@@ -41,7 +43,8 @@
     "compaction"
   ],
   "scripts": {
-    "test:gate": "node test/p0-gate.mjs && node test/p0-blockers.mjs && node test/excerpt.mjs && node --test test/public-exports.test.mjs test/cooldown.test.mjs test/gate-config.test.mjs test/drain-stopline.mjs test/scan-once.mjs test/issue-19.mjs test/issue-20.mjs test/windows-acl.test.mjs test/issue-27.mjs test/issue-29.mjs test/issue-29-notice.mjs test/client-settings.test.mjs test/settings-integration.test.mjs test/runtime-lifecycle.mjs test/shadow-lifecycle.mjs test/finalize-over-32000.mjs",
+    "test:gate": "node test/p0-gate.mjs && node test/p0-blockers.mjs && node test/excerpt.mjs && node test/shadow-worker.mjs && node test/shadow-worker-pool.mjs && node test/shadow-worker-fuse.mjs && node --test test/failed-diagnostics.test.mjs test/public-exports.test.mjs test/cooldown.test.mjs test/gate-config.test.mjs test/drain-stopline.mjs test/scan-once.mjs test/issue-19.mjs test/issue-20.mjs test/issue-34.mjs test/windows-acl.test.mjs test/issue-27.mjs test/issue-29.mjs test/issue-29-notice.mjs test/client-settings.test.mjs test/settings-integration.test.mjs test/runtime-lifecycle.mjs test/shadow-lifecycle.mjs test/finalize-over-32000.mjs",
+    "test:compat41": "node test/compat-cordis41.mjs",
     "test:live-gate": "python3 -B -m unittest discover -s test/live-fill -p test_*.py"
   },
   "engines": {

package/plan.js

@@ -241,6 +241,8 @@ function failureBody(text) {
   if (raw.startsWith("{")) {
     try {
       const parsed = JSON.parse(raw);
+      // A bounded failed result keeps every field, not only the two streams.
+      if (raw.length <= TOOL_BUDGET) return raw;
       const streams = [];
       for (const [label, value] of [["stderr", parsed?.stderr?.text], ["stdout", parsed?.stdout?.text]]) {
         if (typeof value === "string" && value.trim()) {
@@ -257,8 +259,9 @@ function failureBody(text) {
 
 export function failureKeptLines(text) {
   const useful = usefulLines(failureBody(text));
-  if (useful.join("\n").length <= TOOL_BUDGET) return useful.map(shorten);
-  const marked = useful.filter((line) => FAILURE_LINE.test(line)).slice(-8).map(shorten);
+  if (useful.join("\n").length <= TOOL_BUDGET) return useful;
+  const markedLines = useful.filter((line) => FAILURE_LINE.test(line));
+  const marked = (markedLines.length > 8 ? [markedLines[0], ...markedLines.slice(-7)] : markedLines).map(shorten);
   const causes = useful.filter((line) => /(?:root|stderr|stdout)[ _-]*cause\b|CAUSE\b/i.test(line)).slice(-4).map(shorten);
   const edges = [...useful.slice(0, 1), ...useful.slice(-2)].map(shorten);
   const picked = [];
@@ -538,9 +541,10 @@ export function roundHasLongRead(events, round) {
   return false;
 }
 
-export function keptToolRounds(events, limit = 3) {
+export function keptToolRounds(events, limit = 3, afterIndex = -1) {
   const count = Number.isInteger(limit) && limit > 0 ? limit : 3;
-  const rounds = finishedToolRounds(events).filter((round) => !roundHasLongRead(events, round));
+  const floor = Number.isInteger(afterIndex) ? afterIndex : -1;
+  const rounds = finishedToolRounds(events).filter((round) => round.start > floor && !roundHasLongRead(events, round));
   return rounds.slice(-count);
 }
 
@@ -767,7 +771,8 @@ export function resolveProviderBaseURL({
   if (fromConfig) return fromConfig;
   const fromPatch = providerURLFromPatch(patchText, provider);
   if (fromPatch) return fromPatch;
-  if (provider === "deepseek-account" && launchURL) return String(launchURL);
+  const launch = String(launchURL || "").trim();
+  if (provider === "deepseek-account" && launch) return launch;
   const fallback = fallbackProviderURL(provider);
   if (fallback) return fallback;
   return catalogProviderURL(provider, catalog);
@@ -947,7 +952,7 @@ export function pointerOnlyText(pieces) {
   const lines = tools.map((piece) => {
     const cmd = piece.command || piece.name || "tool";
     const call = Number.isInteger(piece.callSeq) ? piece.callSeq : "?";
-    const flag = piece.isError ? " error" : "";
+    const flag = isToolFailure(piece.text, piece.isError) ? " error" : "";
     return `* ${piece.name || "tool"} "${cmd}" (seq ${call} -> result ${piece.seq}${flag})`;
   });
   const userBlock = users.length
@@ -1033,9 +1038,15 @@ function toolBlock(span) {
   if (command) prefix.push(command);
   const exitCode = failed ? exitCodeOf(text) : null;
   if (exitCode !== null) prefix.push(`[exit code: ${exitCode}]`);
-  if (small) return { block: [...prefix, ...lines.map((line) => `│ ${line}`)].join("\n"), failed, needsBackup: false, hardLines, ordinaryLines };
-  if (failed) return { block: [...prefix, ...failureKeptLines(text).map((line) => `│ ${line}`)].join("\n"), failed, needsBackup: true, hardLines, ordinaryLines };
-  return { block: [...prefix, ...unknownKeptLines(text).map((line) => `│ ${line}`)].join("\n"), failed, needsBackup: true, hardLines, ordinaryLines };
+  if (small) return { block: [...prefix, ...lines.map((line) => `│ ${line}`)].join("\n"), failed, failureDiagnosticsComplete: true, needsBackup: false, hardLines, ordinaryLines };
+  if (failed) {
+    const original = text.trim();
+    const diagnostic = usefulLines(original.startsWith("{") ? original : failureBody(text));
+    const kept = failureKeptLines(text);
+    const failureDiagnosticsComplete = diagnostic.length === kept.length && diagnostic.every((line, index) => line === kept[index]);
+    return { block: [...prefix, ...kept.map((line) => `│ ${line}`)].join("\n"), failed, failureDiagnosticsComplete, needsBackup: true, hardLines, ordinaryLines };
+  }
+  return { block: [...prefix, ...unknownKeptLines(text).map((line) => `│ ${line}`)].join("\n"), failed, failureDiagnosticsComplete: true, needsBackup: true, hardLines, ordinaryLines };
 }
 
 export function fitFailure(block, budget) {
@@ -1051,7 +1062,7 @@ export function fitFailure(block, budget) {
 
 export function toolExcerpt(spans, backupId = "") {
   const tools = (spans || []).filter((span) => sourceRole(span.role) === "tool" && String(span.text || "").trim().length > 0);
-  if (tools.length === 0) return { text: "", omitted: 0, needsBackup: false, excerpts: [], stats: [] };
+  if (tools.length === 0) return { text: "", omitted: 0, needsBackup: false, failureDiagnosticsComplete: true, incompleteFailures: [], excerpts: [], stats: [] };
   let lastFailure = -1;
   tools.forEach((span, index) => {
     if (isToolFailure(span.text, span.isError)) lastFailure = index;
@@ -1067,15 +1078,22 @@ export function toolExcerpt(spans, backupId = "") {
   });
   const chosen = [];
   const stats = [];
+  const incompleteFailures = new Map();
   let used = 0;
   let needsBackup = false;
   for (const item of ranked) {
     const built = toolBlock(item.span);
+    const incomplete = (reason) => {
+      if (built.failed && !incompleteFailures.has(item.index)) incompleteFailures.set(item.index, { sourceId: item.span.id, reason });
+    };
+    if (!built.failureDiagnosticsComplete) incomplete("failed-tool-lines-truncated");
     let block = built.block;
     if (item.index === lastFailure && used + block.length > TOOL_BUDGET) {
+      incomplete("failed-tool-budget-truncated");
       block = fitFailure(block, Math.max(0, TOOL_BUDGET - used));
     }
     if (used + block.length > TOOL_BUDGET) {
+      incomplete("failed-tool-budget-omitted");
       needsBackup = true;
       stats.push({ sourceId: item.span.id, hardLines: built.hardLines, omittedOrdinaryToolLines: built.ordinaryLines.length });
       continue;
@@ -1107,6 +1125,8 @@ export function toolExcerpt(spans, backupId = "") {
     text: parts.join("\n"),
     omitted: skipped,
     needsBackup,
+    failureDiagnosticsComplete: incompleteFailures.size === 0,
+    incompleteFailures: [...incompleteFailures.values()],
     excerpts: chosen.map(({ sourceId, text }) => ({ sourceId, text })),
     stats,
   };
@@ -1151,7 +1171,7 @@ function pointerLines(spans) {
     if (Number.isInteger(span.seq)) {
       const cmd = span.command || span.name || "tool";
       const call = Number.isInteger(span.callSeq) ? span.callSeq : "?";
-      const flag = span.isError ? " error" : "";
+      const flag = isToolFailure(span.text, span.isError) ? " error" : "";
       lines.push(`* ${span.name || "tool"} "${cmd}" (seq ${call} -> result ${span.seq}${flag})`);
       continue;
     }
@@ -1281,6 +1301,15 @@ export function buildCard(
     requiredLines: hard,
     keptLines: kept.map((item) => ({ sourceId: item.sourceId, text: item.line })),
   });
+  const incompleteFailures = tools.incompleteFailures.filter((item) => sourceById.has(item.sourceId));
+  for (const item of incompleteFailures) {
+    coverage.ok = false;
+    coverage.missing.push({
+      sourceId: item.sourceId,
+      text: `failed-tool-diagnostics-not-retained (seq ${sourceById.get(item.sourceId).seq ?? "?"})`,
+      reason: "failed-tool-diagnostics-not-retained",
+    });
+  }
 
   // 保留既有助手决策否决；助手正文既不进 Kept，也不能为其他来源提供证据。
   for (const source of sources) {
@@ -1341,6 +1370,7 @@ export function buildCard(
 
   return {
     ok: coverage.ok,
+    failureDiagnosticsComplete: incompleteFailures.length === 0,
     scope: TRUNK_SCOPE,
     hardLines: hard.map((item) => item.line),
     hardCount: hard.length,

package/raw.js

@@ -62,12 +62,14 @@ function readExisting(file, toolCallId) {
 
 // Restart recovery is read-only: never manufacture an original from the surface.
 // Resolve only the requested ID, with the same permissions/meta checks as capture.
-export function readRawToolResult({ dir, toolCallId, access = {} }) {
+export function readRawToolResult({ dir, toolCallId, access = {}, tighten = true }) {
   const file = join(dir, rawName(toolCallId));
   if (!existsSync(file)) return { ok: false, reason: "missing-file", toolCallId };
-  ensureShadowDir(dir, access);
-  tightenShadow(file, "file", access);
-  if (existsSync(`${file}.meta.json`)) tightenShadow(`${file}.meta.json`, "file", access);
+  if (tighten) {
+    ensureShadowDir(dir, access);
+    tightenShadow(file, "file", access);
+    if (existsSync(`${file}.meta.json`)) tightenShadow(`${file}.meta.json`, "file", access);
+  }
   return readExisting(file, toolCallId);
 }
 

package/shadow-save-worker.mjs

@@ -0,0 +1,24 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { attachShadowAccessFuse, saveShadowTransaction } from "./shadow.js";
+
+const managed = workerData?.spineWorker === 1;
+if (managed) attachShadowAccessFuse(workerData.accessFuse);
+
+async function handle(id, payload) {
+  try {
+    const result = saveShadowTransaction(payload);
+    parentPort.postMessage({ id, ok: true, result });
+  } catch (error) {
+    parentPort.postMessage({ id, ok: false, error: {
+      name: error?.name || "Error",
+      message: error?.message || String(error),
+      code: error?.code,
+    } });
+  }
+}
+
+let queue = Promise.resolve();
+if (workerData && !managed) handle(0, workerData);
+parentPort.on("message", ({ id, payload }) => {
+  queue = queue.then(() => handle(id, payload));
+});

package/shadow.js

@@ -38,7 +38,7 @@ const PLUGIN_NAME = /^(?:(?:cut|official|shadow)-\d+-[0-9a-f]{8}|raw-[0-9a-f]{16
 let cachedSid = "";
 const lockedDirs = new Map();
 const lockedFiles = new Map();
-let shadowFuse = false;
+let shadowFuseState = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
 const shadowWarnings = new Set();
 
 // No shared byte ledger. A positively dead holder leaves an immutable fence:
@@ -89,17 +89,78 @@ function touchExclusive(file, body = "") {
 }
 
 function readRotationOwner(file) {
+  if (!lstatSync(file).isFile()) throw new Error("shadow owner is not a regular file");
   const fd = openSync(file, "r");
   try {
-    const buffer = Buffer.alloc(49);
+    const info = fstatSync(fd, { bigint: true });
+    if (!info.isFile() || info.size <= 0n || info.size > 256n) throw new Error("invalid shadow owner size");
+    const buffer = Buffer.alloc(257);
     const count = readSync(fd, buffer, 0, buffer.length, 0);
-    const token = buffer.subarray(0, count).toString("utf8");
-    return /^[0-9a-f]{48}$/.test(token) ? token : "";
+    const text = buffer.subarray(0, count).toString("utf8");
+    const record = JSON.parse(text);
+    if (count !== Number(info.size) || record?.v !== 1 ||
+        !Number.isSafeInteger(record.pid) || record.pid <= 0 || record.pid > 0x7fffffff ||
+        !/^[0-9a-f]{48}$/.test(record.id) || `${JSON.stringify({ v: 1, pid: record.pid, id: record.id })}\n` !== text) {
+      throw new Error("invalid shadow owner record");
+    }
+    return record;
   } finally {
     closeSync(fd);
   }
 }
 
+function rotationOwnerText(record) {
+  return `${JSON.stringify({ v: 1, pid: record.pid, id: record.id })}\n`;
+}
+
+function publishRotationOwner(file, record) {
+  const temp = `${file}.${randomBytes(24).toString("hex")}.tmp`;
+  let fd;
+  try {
+    fd = openSync(temp, "wx", 0o600);
+    writeFileSync(fd, rotationOwnerText(record));
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    // The rotation lock serializes owner claims. Remove only the stale owner
+    // after its PID was proven dead, then publish the complete replacement.
+    try { unlinkSync(file); } catch (error) { if (error?.code !== "ENOENT") throw error; }
+    renameSync(temp, file);
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    try { unlinkSync(temp); } catch {}
+  }
+}
+
+function ownerProcessAlive(record) {
+  try {
+    process.kill(record.pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== "ESRCH";
+  }
+}
+
+function claimRotationOwner(file) {
+  const next = { pid: process.pid, id: rotationOwner };
+  let current;
+  try {
+    current = readRotationOwner(file);
+  } catch (error) {
+    if (error?.code !== "ENOENT") return false;
+  }
+  if (current) {
+    if (current.pid === next.pid && current.id === next.id) return true;
+    if (ownerProcessAlive(current)) return false;
+  }
+  try {
+    publishRotationOwner(file, next);
+    return readRotationOwner(file).pid === next.pid && readRotationOwner(file).id === next.id;
+  } catch {
+    return false;
+  }
+}
+
 function rotationRecordText(record) {
   return `${JSON.stringify({ v: 1, pid: record.pid, id: record.id })}\n`;
 }
@@ -390,12 +451,18 @@ export function withShadowRoot(dir, action) {
     const optedIn = guard.owned && dedicatedRoot(root, identity);
     const owner = join(root, ROTATION_OWNER);
     let token = "";
-    if (optedIn && !existsSync(owner) && !existsSync(shared)) {
+    let currentOwner;
+    try { currentOwner = readRotationOwner(owner); } catch {}
+    const ownsCurrent = currentOwner?.pid === process.pid && currentOwner?.id === rotationOwner;
+    if (optedIn && !existsSync(shared) && !ownsCurrent) {
       shadowUsage = null;
-      touchExclusive(owner, rotationOwner);
+      if (!claimRotationOwner(owner)) touchExclusive(shared);
     }
     if (existsSync(owner)) {
-      try { token = readRotationOwner(owner); } catch {}
+      try {
+        const record = readRotationOwner(owner);
+        token = record.pid === process.pid && record.id === rotationOwner ? record.id : "";
+      } catch {}
       if (token !== rotationOwner || !optedIn) touchExclusive(shared);
     }
     const exclusive = optedIn && token === rotationOwner && !existsSync(shared);
@@ -420,16 +487,31 @@ export function resetShadowAccessState() {
   cachedSid = "";
   lockedDirs.clear();
   lockedFiles.clear();
-  shadowFuse = false;
+  // Test/restart helper only: callers must have no in-flight workers. Keep the
+  // same shared buffer so idle worker retirement never creates a new fuse domain.
+  Atomics.store(shadowFuseState, 0, 0);
   shadowWarnings.clear();
 }
 
 export function shadowAccessFused() {
-  return shadowFuse;
+  return Atomics.load(shadowFuseState, 0) !== 0;
+}
+
+export function shadowAccessFuseBuffer() {
+  return shadowFuseState.buffer;
+}
+
+export function attachShadowAccessFuse(buffer) {
+  if (!(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== Int32Array.BYTES_PER_ELEMENT) {
+    throw new TypeError("spine: invalid shared shadow access fuse");
+  }
+  const alreadyFused = shadowAccessFused();
+  shadowFuseState = new Int32Array(buffer);
+  if (alreadyFused) Atomics.store(shadowFuseState, 0, 1);
 }
 
 function tripFuse() {
-  shadowFuse = true;
+  Atomics.store(shadowFuseState, 0, 1);
 }
 
 function envValue(env, name) {
@@ -766,7 +848,7 @@ export function defaultShadowAccessRunner({
     return true;
   }
 
-  if (shadowFuse) {
+  if (shadowAccessFused()) {
     const error = new Error("spine: shadow permission already failed");
     error.code = "ESHADOWACCESS";
     throw error;
@@ -846,7 +928,7 @@ export function defaultShadowAccessRunner({
 export function tightenShadow(path, kind = "dir", access = {}) {
   const platform = access.platform ?? process.platform;
   const windows = platform === "win32" && !access.runner;
-  if (windows && shadowFuse) {
+  if (windows && shadowAccessFused()) {
     const error = new Error("spine: shadow permission action failed; backup refused");
     error.code = "ESHADOWACCESS";
     throw error;
@@ -891,7 +973,7 @@ export function ensureShadowDir(dir, access = {}) {
 }
 
 export function tightenCreatedShadow(file, fd, access, { remember = true } = {}) {
-  if ((access.platform ?? process.platform) === "win32" && !access.runner && !shadowFuse) {
+  if ((access.platform ?? process.platform) === "win32" && !access.runner && !shadowAccessFused()) {
     try {
       if (shadowDirLocked(dirname(file))) {
         const entry = accessEntry(file, "file");
@@ -1049,7 +1131,12 @@ function readSessionKey(file) {
   }
 }
 
-export function listPluginShadows(dir, { readdir = readdirSync, stat = statSync, onError } = {}) {
+export function listPluginShadows(dir, {
+  readdir = readdirSync,
+  stat = statSync,
+  onError,
+  includeSessionKey = true,
+} = {}) {
   let names = [];
   try {
     names = readdir(dir);
@@ -1069,7 +1156,7 @@ export function listPluginShadows(dir, { readdir = readdirSync, stat = statSync,
         path,
         size: info.size,
         mtimeMs: info.mtimeMs,
-        sessionKey: readSessionKey(path),
+        sessionKey: includeSessionKey ? readSessionKey(path) : "",
       });
     } catch { onError?.(); }
   }
@@ -1080,7 +1167,12 @@ function byAge(left, right) {
   return left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name);
 }
 
-export function listShadowEntries(dir, alive = processAlive, { readdir = readdirSync, stat = statSync, onError } = {}) {
+export function listShadowEntries(dir, alive = processAlive, {
+  readdir = readdirSync,
+  stat = statSync,
+  onError,
+  includeSessionKey = false,
+} = {}) {
   const entries = [];
   let names = [];
   try {
@@ -1113,7 +1205,7 @@ export function listShadowEntries(dir, alive = processAlive, { readdir = readdir
     if (owner > 0) {
       try { live = alive(owner) !== false; } catch { live = true; }
     }
-    for (const file of listPluginShadows(path, { readdir, stat, onError })) {
+    for (const file of listPluginShadows(path, { readdir, stat, onError, includeSessionKey })) {
       // The directory and its owner define deletion authority. Raw tool output
       // is untrusted data and may itself start with a spine-session marker.
       entries.push({ ...file, legacy: false, live, sessionKey: entry.name });
@@ -1130,6 +1222,65 @@ export function rotateShadow(options) {
   return withShadowRoot(options.dir, () => rotateShadowLocked(options));
 }
 
+// Complete backup transaction used by both the synchronous compatibility API
+// and the optional root-writer worker. The rotation lock stays held from the
+// full reconcile through ACL-protected body publication; callers must not move
+// only the scan to a worker and release the lock before the write.
+export function saveShadowTransaction({
+  shadow,
+  file,
+  body,
+  required = false,
+  protectPaths = [],
+  sessionKey = "default",
+  cap,
+  access = {},
+  rotationIO = {},
+} = {}) {
+  ensureShadowDir(shadow, access);
+  const dir = sessionDir(shadow, sessionKey);
+  ensureShadowDir(dir, access);
+  return withShadowRoot(shadow, () => {
+    const owner = join(dir, "owner");
+    const ownerExisted = existsSync(owner);
+    let ownerWritten = false;
+    try {
+      writeShadowOwner(dir, access, shadow);
+      ownerWritten = true;
+      const incoming = Buffer.byteLength(body);
+      const rotation = rotateShadow({
+        ...rotationIO,
+        dir: shadow,
+        incomingBytes: incoming,
+        protectPath: file,
+        protectPaths,
+        sessionKey,
+        cap,
+      });
+      if (!rotation.ok) {
+        if (rotation.reason) {
+          const incomplete = rotation.reason === "scan-incomplete";
+          const error = Object.assign(new Error(incomplete
+            ? "spine: shadow capacity scan is incomplete; backup refused; leaving the span"
+            : "spine: shadow capacity measurement is invalid; backup refused; leaving the span"), {
+            code: incomplete ? "ESHADOWSCAN" : "ESHADOWMETER",
+          });
+          if (required) throw error;
+          return { ok: false, skipped: true, reason: rotation.reason, rotation };
+        }
+        if (required) throw new Error("spine: shadow backup is full; leaving the span");
+        return { ok: false, skipped: true, reason: "full", rotation };
+      }
+      writeShadowFile(file, body, access, { root: shadow });
+      if (!existsSync(file)) throw new Error("spine: shadow backup was not written");
+      return { ok: true, file, rotation };
+    } catch (error) {
+      if (ownerWritten && !ownerExisted) discardShadowFiles([owner], error);
+      throw error;
+    }
+  });
+}
+
 function rotationTime(now) {
   try {
     const value = now();

package/shell.js

@@ -68,9 +68,11 @@ function releaseCompaction(ctx, previous) {
   const store = ctx?.reflect?.store;
   const key = ctx?.[Symbol.for("cordis.isolate")]?.compaction;
   const current = compactionRecord(ctx);
-  if (!current || current === previous || current.fiber !== ctx.fiber) return false;
+  const currentFiber = current?.fiber ?? current?.ctx?.fiber;
+  const contextFiber = ctx?.fiber;
+  if (!current || current === previous || currentFiber !== contextFiber) return false;
   delete store[key];
-  if (ctx.fiber?.store?.compaction === current) delete ctx.fiber.store.compaction;
+  if (contextFiber?.store?.compaction === current) delete contextFiber.store.compaction;
   return true;
 }