@codyswann/lisa 4.28.5 → 4.29.0

package/dist/configs/vitest/scratch-authority.js

@@ -0,0 +1,107 @@
+/**
+ * Filesystem authority for destructive scratch cleanup.
+ *
+ * Every removal is constrained to one direct child of a canonical, uid-owned,
+ * mode-0700 `lisa-scratch` namespace. The child is renamed to a random
+ * quarantine name inside that same namespace, then its inode and owner token
+ * are revalidated before a no-follow recursive unlink.
+ * @module configs/vitest/scratch-authority
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { classifyScratchOwner, readScratchOwnerRecord, } from "./scratch-owner.js";
+import { SCRATCH_QUARANTINE_PREFIX, authorityForExistingScratchNamespace, readBoundedScratchNamespace, } from "./scratch-namespace-authority.js";
+import { removeAuthorizedScratchRoot } from "./scratch-bound-root-cleanup.js";
+/**
+ * Whether a marker is bound to the exact root and namespace inspected.
+ * @param authority - Pinned namespace authority
+ * @param root - Direct namespace child
+ * @param allowQuarantine - Whether the root canonical path may reflect quarantine
+ * @returns Parsed marker and whether every authority fact matches
+ */
+function ownerMatchesPath(authority, root, allowQuarantine) {
+    const owner = readScratchOwnerRecord(root);
+    const stat = fs.lstatSync(root);
+    const matches = owner.namespace.canonicalPath === authority.namespace.canonicalPath &&
+        owner.namespace.dev === authority.namespace.dev &&
+        owner.namespace.ino === authority.namespace.ino &&
+        owner.root.dev === stat.dev &&
+        owner.root.ino === stat.ino &&
+        (allowQuarantine || owner.root.canonicalPath === fs.realpathSync(root));
+    return { owner, matches };
+}
+/**
+ * Remove a marked entry only when ownership says its process is gone or reused.
+ * @param authority - Pinned namespace authority
+ * @param name - Direct child basename
+ * @param root - Direct child path
+ * @param quarantine - Whether the child is an interrupted quarantine
+ * @param options - Process probes and self name
+ * @returns Removal disposition
+ */
+function sweepMarkedEntry(authority, name, root, quarantine, options) {
+    const marked = ownerMatchesPath(authority, root, quarantine);
+    if (!marked.matches)
+        return "kept";
+    const disposition = classifyScratchOwner(marked.owner, options);
+    if (disposition === "preserve")
+        return "kept";
+    removeAuthorizedScratchRoot({
+        authority,
+        basename: name,
+        expectedToken: marked.owner.token,
+    });
+    return "removed";
+}
+/**
+ * Judge one direct namespace entry without ever following a symlink.
+ * @param authority - Pinned namespace authority
+ * @param name - Direct child basename
+ * @param options - Process probes and self name
+ * @returns Removal disposition
+ */
+function sweepAuthorizedEntry(authority, name, options) {
+    if (name === options.selfName)
+        return "kept";
+    const root = path.join(authority.namespace.canonicalPath, name);
+    try {
+        const stat = fs.lstatSync(root);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            return "kept";
+    }
+    catch (error) {
+        return error.code === "ENOENT"
+            ? "removed"
+            : "kept";
+    }
+    const quarantine = name.startsWith(SCRATCH_QUARANTINE_PREFIX);
+    const recognized = /^run-\d+-\d+-[^/\\]+$/u.test(name);
+    if (!recognized && !quarantine)
+        return "kept";
+    try {
+        return sweepMarkedEntry(authority, name, root, quarantine, options);
+    }
+    catch {
+        // A recognizable name is never deletion authority. Missing, malformed,
+        // unreadable, oversized, or identity-mismatched markers remain in place
+        // for the namespace audit to refuse with an actionable diagnosis.
+        return "kept";
+    }
+}
+/**
+ * Sweep one canonical namespace using durable owner/process-birth authority.
+ * @param options - Namespace and process probes
+ * @returns Names removed and preserved
+ */
+export function sweepAuthorizedScratchNamespace(options) {
+    const authority = authorityForExistingScratchNamespace();
+    if (authority === undefined)
+        return { removed: [], kept: [] };
+    return readBoundedScratchNamespace(authority.namespace.canonicalPath).reduce((result, name) => sweepAuthorizedEntry(authority, name, options) === "removed"
+        ? { removed: [...result.removed, name], kept: result.kept }
+        : { removed: result.removed, kept: [...result.kept, name] }, { removed: [], kept: [] });
+}
+export { BOUND_DIRECTORY_CLEANUP_PROGRAM, removeAuthorizedScratchChild, removeAuthorizedScratchChildren, } from "./scratch-bound-cleanup.js";
+export { removeAuthorizedScratchRoot };
+export { DEFAULT_RECLAIM_AGE_MS, MAX_SCRATCH_NAMESPACE_NAME_BYTES, MAX_SCRATCH_NAMESPACE_SCAN_ENTRIES, RUN_ROOT_PREFIX, SCRATCH_DIRECT_ENTRY_LIMIT, SCRATCH_DIRECT_NAME_BYTES, SCRATCH_QUARANTINE_PREFIX, SCRATCH_NAMESPACE, assertScratchNamespaceAuthority, collectBoundedScratchNames, collectBoundedScratchNamespaceNames, createScratchNamespaceAuthority, parseRunRootName, readBoundedScratchNames, readBoundedScratchNamespace, runRootName, scratchBaseDir, scratchNamespaceDir, } from "./scratch-namespace-authority.js";
+//# sourceMappingURL=scratch-authority.js.map

package/dist/configs/vitest/scratch-authority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-authority.js","sourceRoot":"","sources":["../../../src/configs/vitest/scratch-authority.ts"],"names":[],"mappings":"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"}

package/dist/configs/vitest/scratch-bound-cleanup-programs.d.ts

@@ -0,0 +1,5 @@
+/** Synchronous deletion program whose cwd is bound before traversal. */
+export declare const BOUND_DIRECTORY_CLEANUP_PROGRAM: string;
+/** Parent-cwd-bound program removing every preclassified direct child. */
+export declare const BOUND_CHILDREN_CLEANUP_PROGRAM: string;
+//# sourceMappingURL=scratch-bound-cleanup-programs.d.ts.map

package/dist/configs/vitest/scratch-bound-cleanup-programs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-bound-cleanup-programs.d.ts","sourceRoot":"","sources":["../../../src/configs/vitest/scratch-bound-cleanup-programs.ts"],"names":[],"mappings":"AAIA,wEAAwE;AACxE,eAAO,MAAM,+BAA+B,QAuE3C,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,8BAA8B,QA4I1C,CAAC"}

package/dist/configs/vitest/scratch-bound-cleanup-programs.js

@@ -0,0 +1,219 @@
+/** Inert CommonJS programs executed in kernel-bound scratch cwd handles. */
+/** Exit status used when the child cwd does not match the expected inode. */
+const BOUND_CLEANUP_IDENTITY_EXIT = 73;
+/** Synchronous deletion program whose cwd is bound before traversal. */
+export const BOUND_DIRECTORY_CLEANUP_PROGRAM = String.raw `
+const fs = require("node:fs");
+const path = require("node:path");
+const expectedDev = process.argv[1];
+const expectedIno = process.argv[2];
+const root = fs.lstatSync(".");
+if (!root.isDirectory() || root.isSymbolicLink() || String(root.dev) !== expectedDev || String(root.ino) !== expectedIno) {
+  process.stderr.write("scratch directory identity changed before bound cleanup\n");
+  process.exit(${String(BOUND_CLEANUP_IDENTITY_EXIT)});
+}
+const deadline = Date.now() + 30000;
+let entries = 0;
+const readChildren = candidate => {
+  const handle = fs.opendirSync(candidate);
+  const names = [];
+  try {
+    for (;;) {
+      const entry = handle.readSync();
+      if (entry === null) break;
+      if (Buffer.byteLength(entry.name, "utf8") > 1024) throw new Error("scratch cleanup basename exceeds 1024 bytes");
+      entries += 1;
+      if (entries > 100000) throw new Error("scratch cleanup entry bound exceeded");
+      names.push(entry.name);
+    }
+  } finally {
+    handle.closeSync();
+  }
+  return names;
+};
+const pending = [{ candidate: ".", depth: 0 }];
+const scanned = [];
+while (pending.length > 0) {
+  if (Date.now() > deadline) throw new Error("scratch cleanup time bound exceeded");
+  const item = pending.pop();
+  if (item.depth > 128) throw new Error("scratch cleanup depth bound exceeded");
+  let stat;
+  try {
+    stat = fs.lstatSync(item.candidate);
+  } catch (error) {
+    if (error.code === "ENOENT") continue;
+    throw error;
+  }
+  if (item.candidate !== ".") {
+    scanned.push({ candidate: item.candidate, depth: item.depth, dev: String(stat.dev), ino: String(stat.ino), directory: stat.isDirectory(), symlink: stat.isSymbolicLink() });
+  }
+  if (stat.isDirectory() && !stat.isSymbolicLink()) {
+    for (const child of readChildren(item.candidate)) {
+      pending.push({ candidate: path.join(item.candidate, child), depth: item.depth + 1 });
+    }
+  }
+}
+scanned.sort((left, right) => right.depth - left.depth);
+for (const item of scanned) {
+  let stat;
+  try {
+    stat = fs.lstatSync(item.candidate);
+  } catch (error) {
+    if (error.code === "ENOENT") continue;
+    throw error;
+  }
+  if (String(stat.dev) !== item.dev || String(stat.ino) !== item.ino || stat.isDirectory() !== item.directory || stat.isSymbolicLink() !== item.symlink) {
+    process.stderr.write("scratch entry identity changed before bound cleanup: " + item.candidate + "\n");
+    process.exit(${String(BOUND_CLEANUP_IDENTITY_EXIT)});
+  }
+  try {
+    if (item.directory && !item.symlink) fs.rmdirSync(item.candidate);
+    else fs.unlinkSync(item.candidate);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+`;
+/** Parent-cwd-bound program removing every preclassified direct child. */
+export const BOUND_CHILDREN_CLEANUP_PROGRAM = String.raw `
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+const expectedDev = process.argv[1];
+const expectedIno = process.argv[2];
+const parent = fs.lstatSync(".");
+if (!parent.isDirectory() || parent.isSymbolicLink() || String(parent.dev) !== expectedDev || String(parent.ino) !== expectedIno) {
+  process.stderr.write("scratch parent identity changed before bound cleanup\n");
+  process.exit(${String(BOUND_CLEANUP_IDENTITY_EXIT)});
+}
+const items = JSON.parse(fs.readFileSync(0, "utf8"));
+const deadline = Date.now() + 30000;
+let entries = 0;
+const readChildren = candidate => {
+  const handle = fs.opendirSync(candidate);
+  const names = [];
+  try {
+    for (;;) {
+      const entry = handle.readSync();
+      if (entry === null) break;
+      if (Buffer.byteLength(entry.name, "utf8") > 1024) throw new Error("scratch cleanup basename exceeds 1024 bytes");
+      entries += 1;
+      if (entries > 100000) throw new Error("scratch cleanup entry bound exceeded");
+      names.push(entry.name);
+    }
+  } finally {
+    handle.closeSync();
+  }
+  return names;
+};
+const scanDirectory = rootName => {
+  const pending = [{ candidate: rootName, relative: "", depth: 0 }];
+  const scanned = [];
+  while (pending.length > 0) {
+    if (Date.now() > deadline) throw new Error("scratch cleanup time bound exceeded");
+    const item = pending.pop();
+    if (item.depth > 128) throw new Error("scratch cleanup depth bound exceeded");
+    let stat;
+    try {
+      stat = fs.lstatSync(item.candidate);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    if (item.relative !== "") {
+      scanned.push({ relative: item.relative, depth: item.depth, dev: String(stat.dev), ino: String(stat.ino), directory: stat.isDirectory(), symlink: stat.isSymbolicLink() });
+    }
+    if (stat.isDirectory() && !stat.isSymbolicLink()) {
+      for (const child of readChildren(item.candidate)) {
+        pending.push({ candidate: path.join(item.candidate, child), relative: item.relative === "" ? child : path.join(item.relative, child), depth: item.depth + 1 });
+      }
+    }
+  }
+  return scanned;
+};
+const prepared = [];
+for (const item of items) {
+  if (typeof item.basename !== "string" || item.basename === "" || path.basename(item.basename) !== item.basename || Buffer.byteLength(item.basename, "utf8") > 1024) {
+    throw new Error("scratch cleanup candidate must be a bounded direct basename");
+  }
+  let before;
+  try {
+    before = fs.lstatSync(item.basename);
+  } catch (error) {
+    if (error.code === "ENOENT") continue;
+    throw error;
+  }
+  if (String(before.dev) !== item.dev || String(before.ino) !== item.ino || before.isDirectory() !== item.directory || before.isSymbolicLink() !== item.symlink) {
+    process.stderr.write("scratch child identity changed before bound cleanup: " + item.basename + "\n");
+    process.exit(${String(BOUND_CLEANUP_IDENTITY_EXIT)});
+  }
+  prepared.push({ item });
+}
+for (const preparedItem of prepared) {
+  const item = preparedItem.item;
+  let before;
+  try {
+    before = fs.lstatSync(item.basename);
+  } catch (error) {
+    if (error.code === "ENOENT") continue;
+    throw error;
+  }
+  if (String(before.dev) !== item.dev || String(before.ino) !== item.ino || before.isDirectory() !== item.directory || before.isSymbolicLink() !== item.symlink) {
+    process.stderr.write("scratch child identity changed before quarantine: " + item.basename + "\n");
+    process.exit(${String(BOUND_CLEANUP_IDENTITY_EXIT)});
+  }
+  // Deterministic seam for the scan-after-quarantine control, in the shape the
+  // rest of this subsystem already uses for protocol faults. It writes only
+  // inside a child already authorized for deletion, and only under an explicit
+  // environment opt-in, so it cannot fire in a real run.
+  if (process.env.LISA_TEST_SCRATCH_CLEANUP_FAULT === "write-before-quarantine" && item.directory && !item.symlink) {
+    fs.writeFileSync(path.join(item.basename, "late-writer.txt"), "late");
+  }
+  const quarantine = ".lisa-child-quarantine-" + crypto.randomBytes(16).toString("hex");
+  fs.renameSync(item.basename, quarantine);
+  const quarantined = fs.lstatSync(quarantine);
+  if (String(quarantined.dev) !== item.dev || String(quarantined.ino) !== item.ino) {
+    process.stderr.write("scratch child identity changed during quarantine: " + item.basename + "\n");
+    process.exit(${String(BOUND_CLEANUP_IDENTITY_EXIT)});
+  }
+  if (item.directory && !item.symlink) {
+    // Scanned AFTER the quarantine rename, never before it. A pre-rename scan
+    // leaves a window in which a writer creates an entry that is therefore
+    // absent from the recorded list, never deleted, and left to fail the final
+    // rmdirSync with ENOTEMPTY -- so the cleanup that exists to remove a tree
+    // leaves the whole quarantined tree behind. After the rename the directory
+    // sits at an unguessable name no other writer holds a path to, so what is
+    // scanned here is what is there.
+    const scanned = scanDirectory(quarantine).sort((left, right) => right.depth - left.depth);
+    for (const child of scanned) {
+      const candidate = path.join(quarantine, child.relative);
+      let stat;
+      try {
+        stat = fs.lstatSync(candidate);
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        throw error;
+      }
+      if (String(stat.dev) !== child.dev || String(stat.ino) !== child.ino || stat.isDirectory() !== child.directory || stat.isSymbolicLink() !== child.symlink) {
+        process.stderr.write("scratch descendant identity changed during bound cleanup: " + item.basename + "\n");
+        process.exit(${String(BOUND_CLEANUP_IDENTITY_EXIT)});
+      }
+      try {
+        if (child.directory && !child.symlink) fs.rmdirSync(candidate);
+        else fs.unlinkSync(candidate);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+    const after = fs.lstatSync(quarantine);
+    if (String(after.dev) !== item.dev || String(after.ino) !== item.ino) {
+      process.stderr.write("scratch child identity changed during bound cleanup: " + item.basename + "\n");
+      process.exit(${String(BOUND_CLEANUP_IDENTITY_EXIT)});
+    }
+    fs.rmdirSync(quarantine);
+  } else {
+    fs.unlinkSync(quarantine);
+  }
+}
+`;
+//# sourceMappingURL=scratch-bound-cleanup-programs.js.map

package/dist/configs/vitest/scratch-bound-cleanup-programs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-bound-cleanup-programs.js","sourceRoot":"","sources":["../../../src/configs/vitest/scratch-bound-cleanup-programs.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,6EAA6E;AAC7E,MAAM,2BAA2B,GAAG,EAAE,CAAC;AAEvC,wEAAwE;AACxE,MAAM,CAAC,MAAM,+BAA+B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;iBAQxC,MAAM,CAAC,2BAA2B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsDjC,MAAM,CAAC,2BAA2B,CAAC;;;;;;;;;CASrD,CAAC;AAEF,0EAA0E;AAC1E,MAAM,CAAC,MAAM,8BAA8B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;iBASvC,MAAM,CAAC,2BAA2B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA6DjC,MAAM,CAAC,2BAA2B,CAAC;;;;;;;;;;;;;;;mBAenC,MAAM,CAAC,2BAA2B,CAAC;;;;;;;;;;;;;;mBAcnC,MAAM,CAAC,2BAA2B,CAAC;;;;;;;;;;;;;;;;;;;;;;uBAsB/B,MAAM,CAAC,2BAA2B,CAAC;;;;;;;;;;;;qBAYrC,MAAM,CAAC,2BAA2B,CAAC;;;;;;;CAOvD,CAAC"}

package/dist/configs/vitest/scratch-bound-cleanup.d.ts

@@ -0,0 +1,28 @@
+import { type ScratchPathIdentity } from "./scratch-owner.js";
+export { BOUND_DIRECTORY_CLEANUP_PROGRAM } from "./scratch-bound-cleanup-programs.js";
+/** Options for removing one direct child of an already-owned run root. */
+export interface RemoveAuthorizedScratchChildOptions {
+    readonly parent: ScratchPathIdentity;
+    readonly basename: string;
+    readonly beforeIdentityCheck?: (candidate: string) => void;
+    readonly afterIdentityCheck?: (candidate: string) => void;
+}
+/** Options for one batched removal under an already-owned run root. */
+export interface RemoveAuthorizedScratchChildrenOptions {
+    readonly parent: ScratchPathIdentity;
+    readonly basenames: readonly string[];
+    readonly beforeIdentityCheck?: (candidate: string) => void;
+    readonly afterIdentityCheck?: (candidate: string) => void;
+    readonly beforeBoundCleanup?: () => void;
+}
+/**
+ * Remove direct children through one process bound to the parent inode.
+ * @param options - Batched child-removal options
+ */
+export declare function removeAuthorizedScratchChildren(options: RemoveAuthorizedScratchChildrenOptions): void;
+/**
+ * Remove one direct child through the batched authority.
+ * @param options - Single child-removal options
+ */
+export declare function removeAuthorizedScratchChild(options: RemoveAuthorizedScratchChildOptions): void;
+//# sourceMappingURL=scratch-bound-cleanup.d.ts.map

package/dist/configs/vitest/scratch-bound-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-bound-cleanup.d.ts","sourceRoot":"","sources":["../../../src/configs/vitest/scratch-bound-cleanup.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,+BAA+B,EAAE,MAAM,qCAAqC,CAAC;AAEtF,0EAA0E;AAC1E,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3D;AAED,uEAAuE;AACvE,MAAM,WAAW,sCAAsC;IACrD,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;CAC1C;AA+HD;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,sCAAsC,GAC9C,IAAI,CAwBN;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,mCAAmC,GAC3C,IAAI,CAWN"}

package/dist/configs/vitest/scratch-bound-cleanup.js

@@ -0,0 +1,155 @@
+/** Kernel-bound deletion programs for scratch roots and their direct children. */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { scratchPathIdentity, } from "./scratch-owner.js";
+import { BOUND_CHILDREN_CLEANUP_PROGRAM } from "./scratch-bound-cleanup-programs.js";
+export { BOUND_DIRECTORY_CLEANUP_PROGRAM } from "./scratch-bound-cleanup-programs.js";
+/** Exit status used when the child cwd does not match the expected inode. */
+const BOUND_CLEANUP_IDENTITY_EXIT = 73;
+/**
+ * Demand one inert direct basename, never a path.
+ * @param basename - Candidate direct-child name
+ */
+function validateBasename(basename) {
+    if (basename === "" ||
+        basename === "." ||
+        basename === ".." ||
+        path.basename(basename) !== basename ||
+        basename.includes("/") ||
+        basename.includes("\\")) {
+        throw new Error(`Scratch candidate must be a direct basename: ${basename}`);
+    }
+    if (Buffer.byteLength(basename, "utf8") > 1_024) {
+        throw new Error("Scratch candidate basename exceeds 1024 bytes");
+    }
+}
+/**
+ * Read one candidate without converting absence into an exception.
+ * @param candidate - Candidate path
+ * @returns Candidate metadata, or undefined when already absent
+ */
+function lstatIfPresent(candidate) {
+    try {
+        return fs.lstatSync(candidate);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+/**
+ * Assert that an already-owned parent still has its pinned identity.
+ * @param expected - Pinned parent identity
+ */
+function assertScratchPathIdentity(expected) {
+    const current = scratchPathIdentity(expected.canonicalPath);
+    if (current.canonicalPath !== expected.canonicalPath ||
+        current.dev !== expected.dev ||
+        current.ino !== expected.ino) {
+        throw new Error("Scratch parent identity changed before child cleanup");
+    }
+}
+/**
+ * Inspect a direct child after its pinned parent passes revalidation.
+ * @param parent - Pinned parent identity
+ * @param basename - Direct-child name
+ * @param child - Candidate path
+ * @returns Candidate metadata, or undefined when already absent
+ */
+function inspectAuthorizedScratchChild(parent, basename, child) {
+    validateBasename(basename);
+    assertScratchPathIdentity(parent);
+    return lstatIfPresent(child);
+}
+/**
+ * Capture every present candidate while the parent remains pinned.
+ * @param options - Batched child-removal options
+ * @returns Bound cleanup descriptions for present children
+ */
+function collectAuthorizedChildren(options) {
+    assertScratchPathIdentity(options.parent);
+    return options.basenames.flatMap(basename => {
+        const child = path.join(options.parent.canonicalPath, basename);
+        options.beforeIdentityCheck?.(child);
+        const stat = inspectAuthorizedScratchChild(options.parent, basename, child);
+        if (stat === undefined)
+            return [];
+        options.afterIdentityCheck?.(child);
+        return [
+            {
+                basename,
+                dev: String(stat.dev),
+                ino: String(stat.ino),
+                directory: stat.isDirectory(),
+                symlink: stat.isSymbolicLink(),
+            },
+        ];
+    });
+}
+/**
+ * Execute the inode-bound child-cleanup worker.
+ * @param options - Batched child-removal options
+ * @param input - Validated serialized child descriptions
+ * @returns Worker result
+ */
+function executeBoundChildrenCleanup(options, input) {
+    options.beforeBoundCleanup?.();
+    return spawnSync(process.execPath, [
+        "--input-type=commonjs",
+        "--eval",
+        BOUND_CHILDREN_CLEANUP_PROGRAM,
+        String(options.parent.dev),
+        String(options.parent.ino),
+    ], {
+        cwd: options.parent.canonicalPath,
+        encoding: "utf8",
+        input,
+        maxBuffer: 64 * 1024,
+    });
+}
+/**
+ * Remove direct children through one process bound to the parent inode.
+ * @param options - Batched child-removal options
+ */
+export function removeAuthorizedScratchChildren(options) {
+    if (new Set(options.basenames).size !== options.basenames.length) {
+        throw new Error("Scratch child cleanup refuses duplicate basenames");
+    }
+    const items = collectAuthorizedChildren(options);
+    if (items.length === 0)
+        return;
+    const input = JSON.stringify(items);
+    if (Buffer.byteLength(input, "utf8") > 32 * 1024 * 1024) {
+        throw new Error("Scratch child cleanup batch exceeds 33554432 bytes");
+    }
+    const result = executeBoundChildrenCleanup(options, input);
+    if (result.error !== undefined)
+        throw result.error;
+    if (result.status === BOUND_CLEANUP_IDENTITY_EXIT) {
+        throw new Error(result.stderr.trim() ||
+            "Scratch child identity changed before bound cleanup");
+    }
+    if (result.status !== 0 || result.signal !== null) {
+        throw new Error(`Scratch bound cleanup failed: ${result.stderr.trim() || result.signal || String(result.status)}`);
+    }
+    assertScratchPathIdentity(options.parent);
+}
+/**
+ * Remove one direct child through the batched authority.
+ * @param options - Single child-removal options
+ */
+export function removeAuthorizedScratchChild(options) {
+    removeAuthorizedScratchChildren({
+        parent: options.parent,
+        basenames: [options.basename],
+        ...(options.beforeIdentityCheck === undefined
+            ? {}
+            : { beforeIdentityCheck: options.beforeIdentityCheck }),
+        ...(options.afterIdentityCheck === undefined
+            ? {}
+            : { afterIdentityCheck: options.afterIdentityCheck }),
+    });
+}
+//# sourceMappingURL=scratch-bound-cleanup.js.map

package/dist/configs/vitest/scratch-bound-cleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-bound-cleanup.js","sourceRoot":"","sources":["../../../src/configs/vitest/scratch-bound-cleanup.ts"],"names":[],"mappings":"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"}

package/dist/configs/vitest/scratch-bound-root-cleanup.d.ts

@@ -0,0 +1,17 @@
+import { type ScratchNamespaceAuthority } from "./scratch-namespace-authority.js";
+import { type ScratchPathIdentity } from "./scratch-owner.js";
+/** Options for an authorised root removal. */
+export interface RemoveAuthorizedScratchRootOptions {
+    readonly authority: ScratchNamespaceAuthority;
+    readonly basename: string;
+    readonly expectedToken?: string;
+    readonly expectedIdentity?: ScratchPathIdentity;
+    readonly afterIdentityCheck?: (candidate: string) => void;
+}
+/**
+ * Quarantine and delete one direct owned root.
+ * @param options - Authorized root-removal options
+ * @returns Whether an existing root was removed
+ */
+export declare function removeAuthorizedScratchRoot(options: RemoveAuthorizedScratchRootOptions): boolean;
+//# sourceMappingURL=scratch-bound-root-cleanup.d.ts.map

package/dist/configs/vitest/scratch-bound-root-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratch-bound-root-cleanup.d.ts","sourceRoot":"","sources":["../../../src/configs/vitest/scratch-bound-root-cleanup.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,yBAAyB,EAC/B,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAE5B,8CAA8C;AAC9C,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,mBAAmB,CAAC;IAChD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3D;AAsJD;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,kCAAkC,GAC1C,OAAO,CA8BT"}