@xenonbyte/da-vinci-workflow 0.1.25 → 0.1.26

package/lib/pencil-session.js

@@ -1,9 +1,13 @@
 const fs = require("fs");
 const path = require("path");
+const { readJsonFile } = require("./utils");
 const {
   ensurePenFile,
   writePenFromPayloadFiles,
   comparePenSync,
+  comparePenBaselineAlignment,
+  formatPenBaselineAlignmentReport,
+  syncPenSource,
   writeJsonFileAtomic
 } = require("./pen-persistence");
 const {
@@ -11,6 +15,7 @@ const {
   releasePencilLock,
   getPencilLockStatus
 } = require("./pencil-lock");
+const { runModuleExportInWorker } = require("./async-offload");
 
 function resolveProjectRoot(projectPath) {
   return path.resolve(projectPath || process.cwd());
@@ -25,7 +30,7 @@ function readSessionState(projectPath) {
   if (!fs.existsSync(sessionStatePath)) {
     return null;
   }
-  return JSON.parse(fs.readFileSync(sessionStatePath, "utf8"));
+  return readJsonFile(sessionStatePath, `Pencil session state JSON at ${sessionStatePath}`);
 }
 
 function writeSessionState(projectPath, payload) {
@@ -59,42 +64,170 @@ function assertLockHeldByProject(projectPath, options = {}) {
   return status;
 }
 
+function releaseLockQuietly(projectPath, options = {}) {
+  try {
+    return releasePencilLock({
+      projectPath,
+      homeDir: options.homeDir,
+      force: options.force
+    });
+  } catch (error) {
+    return {
+      lockPath: null,
+      released: false,
+      hadLock: null,
+      lock: null,
+      releaseError: error
+    };
+  }
+}
+
+function createSessionLifecycleError(message, cause, extra = {}) {
+  const wrapped = new Error(message);
+  if (cause && typeof cause === "object") {
+    wrapped.cause = cause;
+  }
+  Object.assign(wrapped, extra);
+  return wrapped;
+}
+
 function beginPencilSession(options) {
   const projectRoot = resolveProjectRoot(options.projectPath);
-  const ensureResult = ensurePenFile({
-    outputPath: options.penPath,
-    version: options.version,
-    verifyWithPencil: options.verifyWithPencil,
-    pencilBin: options.pencilBin
-  });
+  const baselinePaths = Array.isArray(options.baselinePaths) ? options.baselinePaths : [];
+  const hasBaselinePaths = baselinePaths.length > 0;
+  const hasPreferredSource = Boolean(options.preferredSource);
+  const shouldSyncPreferredSource = options.syncPreferredSource === true;
+
+  if (hasPreferredSource && !hasBaselinePaths) {
+    throw new Error(
+      "Baseline preference requires comparison paths. Provide at least one `--baseline <path>`."
+    );
+  }
+
+  if (shouldSyncPreferredSource && !hasPreferredSource) {
+    throw new Error("`--sync-preferred-source` requires `--prefer-source <path>`.");
+  }
+
+  if (shouldSyncPreferredSource && !hasBaselinePaths) {
+    throw new Error(
+      "`--sync-preferred-source` requires baseline comparison input. Provide `--baseline <path>`."
+    );
+  }
+
   const lockResult = acquirePencilLock({
     projectPath: projectRoot,
     owner: options.owner,
     waitMs: options.waitMs,
     homeDir: options.homeDir
   });
+  let ensureResult = null;
+  let baselineCheck = null;
+  let baselineSync = null;
 
-  const session = buildSessionState(projectRoot, {
-    status: "active",
-    beganAt: new Date().toISOString(),
-    penPath: path.resolve(options.penPath),
-    lockPath: lockResult.lockPath,
-    lockOwner: lockResult.lock.owner,
-    penStatePath: ensureResult.statePath,
-    lastPersistedHash: ensureResult.state.snapshotHash,
-    lastPersistedAt: ensureResult.state.persistedAt,
-    lastTopLevelCount: ensureResult.state.topLevelCount
-  });
-  const sessionStatePath = writeSessionState(projectRoot, session);
+  try {
+    ensureResult = ensurePenFile({
+      outputPath: options.penPath,
+      version: options.version,
+      verifyWithPencil: options.verifyWithPencil,
+      pencilBin: options.pencilBin
+    });
 
-  return {
-    projectRoot,
-    penPath: ensureResult.outputPath,
-    session,
-    sessionStatePath,
-    ensureResult,
-    lockResult
-  };
+    if (hasBaselinePaths) {
+      baselineCheck = comparePenBaselineAlignment({
+        penPath: ensureResult.outputPath,
+        baselinePaths,
+        preferredSource: options.preferredSource
+      });
+
+      if (
+        baselineCheck.status === "BLOCK" &&
+        baselineCheck.decision === "diverged_prefer_external" &&
+        options.syncPreferredSource === true &&
+        baselineCheck.preferredSourcePath
+      ) {
+        baselineSync = syncPenSource({
+          sourcePath: baselineCheck.preferredSourcePath,
+          targetPath: ensureResult.outputPath,
+          stateSource: "pencil-session:begin-sync"
+        });
+        ensureResult = {
+          ...ensureResult,
+          statePath: baselineSync.statePath,
+          state: baselineSync.state
+        };
+        baselineCheck = comparePenBaselineAlignment({
+          penPath: ensureResult.outputPath,
+          baselinePaths,
+          preferredSource: options.preferredSource
+        });
+      }
+
+      if (baselineCheck.status === "BLOCK") {
+        throw new Error(
+          [
+            "Pencil baseline alignment failed before session start.",
+            formatPenBaselineAlignmentReport(baselineCheck)
+          ].join("\n")
+        );
+      }
+    }
+
+    const beganAt = new Date().toISOString();
+    const session = buildSessionState(projectRoot, {
+      status: "active",
+      beganAt,
+      lastActivityAt: beganAt,
+      penPath: path.resolve(options.penPath),
+      lockPath: lockResult.lockPath,
+      lockOwner: lockResult.lock.owner,
+      penStatePath: ensureResult.statePath,
+      lastPersistedHash: ensureResult.state.snapshotHash,
+      lastPersistedAt: ensureResult.state.persistedAt,
+      lastTopLevelCount: ensureResult.state.topLevelCount,
+      baselineCheck: baselineCheck
+        ? {
+            checkedAt: new Date().toISOString(),
+            status: baselineCheck.status,
+            decision: baselineCheck.decision,
+            preferredSourcePath: baselineCheck.preferredSourcePath,
+            baselinePaths: baselineCheck.baselinePaths,
+            inSync: baselineCheck.inSync
+          }
+        : null,
+      baselineSync: baselineSync
+        ? {
+            syncedAt: new Date().toISOString(),
+            sourcePath: baselineSync.sourcePath,
+            targetPath: baselineSync.targetPath,
+            snapshotHash: baselineSync.state.snapshotHash
+          }
+        : null
+    });
+    const sessionStatePath = writeSessionState(projectRoot, session);
+
+    return {
+      projectRoot,
+      penPath: ensureResult.outputPath,
+      session,
+      sessionStatePath,
+      ensureResult,
+      lockResult
+    };
+  } catch (error) {
+    const releaseResult = releaseLockQuietly(projectRoot, {
+      homeDir: options.homeDir
+    });
+    if (releaseResult.releaseError) {
+      throw createSessionLifecycleError(
+        `${error.message}\nAlso failed to release lock during begin rollback: ${releaseResult.releaseError.message}`,
+        error,
+        {
+          rollbackReleaseError: releaseResult.releaseError
+        }
+      );
+    }
+    throw error;
+  }
 }
 
 function persistPencilSession(options) {
@@ -132,6 +265,7 @@ function persistPencilSession(options) {
     version: options.version
   });
 
+  const persistedAt = new Date().toISOString();
   const updatedSession = buildSessionState(projectRoot, {
     ...session,
     status: "active",
@@ -140,7 +274,8 @@ function persistPencilSession(options) {
     lastPersistedHash: writeResult.state.snapshotHash,
     lastPersistedAt: writeResult.state.persistedAt,
     lastTopLevelCount: writeResult.state.topLevelCount,
-    lastSyncVerifiedAt: new Date().toISOString(),
+    lastSyncVerifiedAt: persistedAt,
+    lastActivityAt: persistedAt,
     inSync: syncResult.inSync
   });
   const sessionStatePath = writeSessionState(projectRoot, updatedSession);
@@ -163,6 +298,8 @@ function endPencilSession(options) {
     throw new Error("No Pencil session state exists for this project. Run `pencil-session begin` first.");
   }
 
+  assertLockHeldByProject(projectRoot, { homeDir: options.homeDir });
+
   const resolvedPenPath = path.resolve(options.penPath || session.penPath || "");
   if (!resolvedPenPath) {
     throw new Error("A registered `.pen` path is required for session shutdown.");
@@ -188,21 +325,44 @@ function endPencilSession(options) {
     }
   }
 
-  const releaseResult = releasePencilLock({
-    projectPath: projectRoot,
-    homeDir: options.homeDir,
-    force: options.force
-  });
+  const endedWithForce = options.force === true;
+  const forceWithoutSync = endedWithForce && !syncResult;
 
+  const endedAt = new Date().toISOString();
   const updatedSession = buildSessionState(projectRoot, {
     ...session,
     status: "closed",
     penPath: resolvedPenPath,
-    endedAt: new Date().toISOString(),
-    lastSyncVerifiedAt: syncResult ? new Date().toISOString() : session.lastSyncVerifiedAt || null,
+    endedAt,
+    endedWithForce,
+    forceWithoutSync,
+    lastSyncVerifiedAt: syncResult ? endedAt : session.lastSyncVerifiedAt || null,
+    lastActivityAt: endedAt,
     inSync: syncResult ? syncResult.inSync : session.inSync === true
   });
   const sessionStatePath = writeSessionState(projectRoot, updatedSession);
+  let releaseResult;
+  try {
+    releaseResult = releasePencilLock({
+      projectPath: projectRoot,
+      homeDir: options.homeDir,
+      force: options.force
+    });
+  } catch (releaseError) {
+    let rollbackError = null;
+    try {
+      writeSessionState(projectRoot, session);
+    } catch (error) {
+      rollbackError = error;
+    }
+    throw createSessionLifecycleError(
+      rollbackError
+        ? `Failed to release Pencil lock while ending session: ${releaseError.message}\nAlso failed to restore active session state: ${rollbackError.message}`
+        : `Failed to release Pencil lock while ending session: ${releaseError.message}`,
+      releaseError,
+      rollbackError ? { sessionRollbackError: rollbackError } : {}
+    );
+  }
 
   return {
     projectRoot,
@@ -224,12 +384,32 @@ function getPencilSessionStatus(options = {}) {
   };
 }
 
+function beginPencilSessionAsync(options = {}) {
+  return runModuleExportInWorker(__filename, "beginPencilSession", [options]);
+}
+
+function persistPencilSessionAsync(options = {}) {
+  return runModuleExportInWorker(__filename, "persistPencilSession", [options]);
+}
+
+function endPencilSessionAsync(options = {}) {
+  return runModuleExportInWorker(__filename, "endPencilSession", [options]);
+}
+
+function getPencilSessionStatusAsync(options = {}) {
+  return runModuleExportInWorker(__filename, "getPencilSessionStatus", [options]);
+}
+
 module.exports = {
   getSessionStatePath,
   readSessionState,
   writeSessionState,
   beginPencilSession,
+  beginPencilSessionAsync,
   persistPencilSession,
+  persistPencilSessionAsync,
   endPencilSession,
-  getPencilSessionStatus
+  endPencilSessionAsync,
+  getPencilSessionStatus,
+  getPencilSessionStatusAsync
 };

package/lib/supervisor-review.js

@@ -3,6 +3,17 @@ const path = require("path");
 const os = require("os");
 const { execFile } = require("child_process");
 const {
+  escapeRegExp,
+  isPlainObject,
+  parseJsonText,
+  pathExists,
+  readTextIfExists,
+  writeFileAtomic
+} = require("./utils");
+const {
+  hasMarkdownHeading,
+  getMarkdownSection,
+  isAcceptedWarnOutcome,
   parseCheckpointStatusMap,
   getConfiguredDesignSupervisorReviewers
 } = require("./audit-parsers");
@@ -14,14 +25,8 @@ const REVIEW_STATUS_SEVERITY = Object.freeze({
   WARN: 1,
   BLOCK: 2
 });
-
-function pathExists(targetPath) {
-  return fs.existsSync(targetPath);
-}
-
-function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+const DEFAULT_REVIEWER_EXEC_MAX_BUFFER = 50 * 1024 * 1024;
+const DEFAULT_REVIEWER_RETRY_MAX_DELAY_MS = 5000;
 
 function normalizeStatus(status) {
   if (!status) {
@@ -46,13 +51,6 @@ function normalizeReviewSource(source) {
   return normalized;
 }
 
-function readTextIfExists(filePath) {
-  if (!pathExists(filePath)) {
-    return "";
-  }
-  return fs.readFileSync(filePath, "utf8");
-}
-
 function parseReviewerList(value) {
   return String(value || "")
     .split(/[,\n;]/)
@@ -114,7 +112,13 @@ function buildReviewerPrompt({ reviewer, projectRoot, changeId, pencilDesignPath
 }
 
 function parseReviewerPayload(rawText) {
-  const payload = JSON.parse(String(rawText || "").trim());
+  const payload = parseJsonText(String(rawText || "").trim(), "reviewer JSON payload");
+  if (!isPlainObject(payload)) {
+    throw new Error("Invalid reviewer JSON payload: expected a JSON object.");
+  }
+  if (!payload.status) {
+    throw new Error("Invalid reviewer JSON payload: missing required `status`.");
+  }
   const status = normalizeStatus(payload.status);
   const issues = Array.isArray(payload.issues)
     ? payload.issues.map((issue) => String(issue || "").trim()).filter(Boolean)
@@ -161,8 +165,14 @@ async function runReviewerWithCodexOnce(options = {}) {
     changeId,
     pencilDesignPath,
     screenshotPaths,
-    timeoutMs
+    timeoutMs,
+    maxBuffer
   } = options;
+  const configuredMaxBuffer = Number(maxBuffer);
+  const resolvedMaxBuffer =
+    Number.isFinite(configuredMaxBuffer) && configuredMaxBuffer > 0
+      ? configuredMaxBuffer
+      : DEFAULT_REVIEWER_EXEC_MAX_BUFFER;
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-supervisor-runner-"));
   const outputPath = path.join(tmpDir, "review.json");
   const schemaPath = path.join(tmpDir, "schema.json");
@@ -224,7 +234,7 @@ async function runReviewerWithCodexOnce(options = {}) {
     try {
       await execFileAsync(codexBin, args, {
         encoding: "utf8",
-        maxBuffer: 8 * 1024 * 1024,
+        maxBuffer: resolvedMaxBuffer,
         timeout: timeoutValue > 0 ? timeoutValue : undefined
       });
     } catch (error) {
@@ -249,6 +259,12 @@ async function runReviewerWithCodex(options = {}) {
   const reviewer = String(options.reviewer || "").trim();
   const retries = normalizePositiveInt(options.retries, 1, 0, 8);
   const retryDelayMs = normalizePositiveInt(options.retryDelayMs, 400, 0, 60000);
+  const retryMaxDelayMs = normalizePositiveInt(
+    options.retryMaxDelayMs,
+    DEFAULT_REVIEWER_RETRY_MAX_DELAY_MS,
+    0,
+    60000
+  );
   const maxAttempts = retries + 1;
   let attempt = 0;
   let lastError = null;
@@ -266,7 +282,7 @@ async function runReviewerWithCodex(options = {}) {
       if (attempt >= maxAttempts) {
         break;
       }
-      const backoffDelay = retryDelayMs * Math.pow(2, attempt - 1);
+      const backoffDelay = Math.min(retryDelayMs * Math.pow(2, attempt - 1), retryMaxDelayMs);
       await sleep(backoffDelay);
     }
   }
@@ -369,14 +385,12 @@ function resolvePencilDesignPath(projectRoot, options = {}) {
 }
 
 function extractMcpRuntimeGateStatus(markdownText) {
-  const sectionMatch = String(markdownText || "").match(
-    /(?:^|\n)##\s+MCP Runtime Gate\s*\n([\s\S]*?)(?=\n##\s+|\s*$)/i
-  );
-  if (!sectionMatch) {
+  const section = getMarkdownSection(markdownText, "MCP Runtime Gate");
+  if (!section) {
     return "";
   }
 
-  const statusMatch = String(sectionMatch[1]).match(
+  const statusMatch = String(section).match(
     /(?:^|\n)\s*-\s*(?:Status|状态)\s*:\s*`?(PASS|WARN|BLOCK)`?\b/i
   );
   return statusMatch ? String(statusMatch[1]).toUpperCase() : "";
@@ -396,13 +410,11 @@ function inferReview(markdownText, options = {}) {
   const designCheckpointStatus =
     checkpointStatuses["design checkpoint"] || extractCheckpointStatus(markdownText, "Design checkpoint");
   const runtimeGateStatus = extractMcpRuntimeGateStatus(markdownText);
-  const hasScreenshotRecords = /(?:^|\n)##\s+Screenshot Review Records\b/i.test(
-    String(markdownText || "")
-  );
+  const hasScreenshotRecords = hasMarkdownHeading(markdownText, "Screenshot Review Records");
   let status = "PASS";
 
   if (!hasScreenshotRecords) {
-    issues.push("Missing `## Screenshot Review Records` evidence.");
+    issues.push("Missing `Screenshot Review Records` evidence.");
     status = "BLOCK";
   }
 
@@ -446,9 +458,7 @@ function inferReview(markdownText, options = {}) {
 }
 
 function hasAcceptedWarn(revisionOutcome) {
-  return /(accepted|accepted with follow-up|accepted warning|warn accepted|接受|已接受|接受警告)/i.test(
-    String(revisionOutcome || "")
-  );
+  return isAcceptedWarnOutcome(revisionOutcome);
 }
 
 function buildReviewSection(review) {
@@ -505,6 +515,12 @@ async function runDesignSupervisorReview(options = {}) {
   const reviewConcurrency = normalizePositiveInt(options.reviewConcurrency, 2, 1, 16);
   const reviewerRetries = normalizePositiveInt(options.reviewerRetries, 1, 0, 8);
   const reviewerRetryDelayMs = normalizePositiveInt(options.reviewerRetryDelayMs, 400, 0, 60000);
+  const reviewerRetryMaxDelayMs = normalizePositiveInt(
+    options.reviewerRetryMaxDelayMs,
+    DEFAULT_REVIEWER_RETRY_MAX_DELAY_MS,
+    0,
+    60000
+  );
   const manualStatus = normalizeStatus(options.status);
   const reviewerAttempts = {};
   let review = null;
@@ -531,10 +547,11 @@ async function runDesignSupervisorReview(options = {}) {
           pencilDesignPath,
           screenshotPaths,
           timeoutMs: options.reviewerTimeoutMs,
+          maxBuffer: options.reviewerMaxBuffer,
           retries: reviewerRetries,
-          retryDelayMs: reviewerRetryDelayMs
+          retryDelayMs: reviewerRetryDelayMs,
+          retryMaxDelayMs: reviewerRetryMaxDelayMs
         });
-        reviewerAttempts[reviewer] = finding.attempts || 1;
         return {
           reviewer,
           ...finding
@@ -542,6 +559,9 @@ async function runDesignSupervisorReview(options = {}) {
       },
       reviewConcurrency
     );
+    for (const finding of findings) {
+      reviewerAttempts[finding.reviewer] = finding.attempts || 1;
+    }
 
     const aggregated = aggregateReviewerFindings(findings, {
       acceptWarn: options.acceptWarn
@@ -608,7 +628,7 @@ async function runDesignSupervisorReview(options = {}) {
   if (options.write) {
     fs.mkdirSync(path.dirname(pencilDesignPath), { recursive: true });
     const nextText = appendReviewSection(existingText, review);
-    fs.writeFileSync(pencilDesignPath, nextText);
+    writeFileAtomic(pencilDesignPath, nextText);
     wrote = true;
   }
 
@@ -627,6 +647,7 @@ async function runDesignSupervisorReview(options = {}) {
     reviewConcurrency: runReviewers ? reviewConcurrency : 0,
     reviewerRetries: runReviewers ? reviewerRetries : 0,
     reviewerRetryDelayMs: runReviewers ? reviewerRetryDelayMs : 0,
+    reviewerRetryMaxDelayMs: runReviewers ? reviewerRetryMaxDelayMs : 0,
     reviewerAttempts: runReviewers ? reviewerAttempts : {},
     wrote
   };
@@ -657,6 +678,7 @@ function formatDesignSupervisorReviewReport(result) {
     lines.push(`Review concurrency: ${result.reviewConcurrency}`);
     lines.push(`Reviewer retries: ${result.reviewerRetries}`);
     lines.push(`Reviewer retry delay (ms): ${result.reviewerRetryDelayMs}`);
+    lines.push(`Reviewer retry max delay (ms): ${result.reviewerRetryMaxDelayMs}`);
     const reviewerAttemptTokens = Object.entries(result.reviewerAttempts || {}).map(
       ([reviewer, attempts]) => `${reviewer}:${attempts}`
     );

package/lib/utils.js

@@ -0,0 +1,121 @@
+const fs = require("fs");
+const path = require("path");
+
+const HAS_SYNC_WAIT =
+  typeof SharedArrayBuffer === "function" &&
+  typeof Atomics === "object" &&
+  Atomics !== null &&
+  typeof Atomics.wait === "function";
+const SYNC_SLEEP_ARRAY = HAS_SYNC_WAIT ? new Int32Array(new SharedArrayBuffer(4)) : null;
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function pathExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function readTextIfExists(targetPath, options = {}) {
+  const encoding = options.encoding || "utf8";
+  if (!pathExists(targetPath)) {
+    return "";
+  }
+  return fs.readFileSync(targetPath, encoding);
+}
+
+function uniqueValues(values) {
+  return Array.from(new Set((values || []).filter(Boolean)));
+}
+
+function parseJsonText(raw, context = "JSON payload") {
+  try {
+    return JSON.parse(String(raw));
+  } catch (error) {
+    const wrapped = new Error(
+      `Invalid ${context}: ${error && error.message ? error.message : String(error)}`
+    );
+    if (error && typeof error === "object") {
+      wrapped.cause = error;
+    }
+    throw wrapped;
+  }
+}
+
+function readJsonFile(targetPath, context = null) {
+  const resolvedTargetPath = path.resolve(targetPath);
+  const label = context || `JSON file at ${resolvedTargetPath}`;
+  return parseJsonText(fs.readFileSync(resolvedTargetPath, "utf8"), label);
+}
+
+function sleepSync(durationMs, context = "perform synchronous sleep") {
+  const timeoutMs = Math.max(0, Number(durationMs) || 0);
+  if (timeoutMs === 0) {
+    return;
+  }
+
+  if (!HAS_SYNC_WAIT || !SYNC_SLEEP_ARRAY) {
+    throw new Error(`Unable to ${context}: Atomics.wait is unavailable in this runtime.`);
+  }
+
+  try {
+    Atomics.wait(SYNC_SLEEP_ARRAY, 0, 0, timeoutMs);
+  } catch (error) {
+    const wrapped = new Error(
+      `Unable to ${context}: ${error && error.message ? error.message : String(error)}`
+    );
+    if (error && typeof error === "object") {
+      wrapped.cause = error;
+    }
+    throw wrapped;
+  }
+}
+
+function buildAtomicTempPath(targetPath) {
+  const resolvedTargetPath = path.resolve(targetPath);
+  return path.join(
+    path.dirname(resolvedTargetPath),
+    `.${path.basename(resolvedTargetPath)}.tmp-${process.pid}-${Date.now()}-${Math.random()
+      .toString(16)
+      .slice(2)}`
+  );
+}
+
+function writeFileAtomic(targetPath, content, options = {}) {
+  const resolvedTargetPath = path.resolve(targetPath);
+  const encoding = options.encoding || "utf8";
+  const tempPath = buildAtomicTempPath(resolvedTargetPath);
+  fs.mkdirSync(path.dirname(resolvedTargetPath), { recursive: true });
+  fs.writeFileSync(tempPath, content, encoding);
+  fs.renameSync(tempPath, resolvedTargetPath);
+}
+
+function writeFileExclusiveAtomic(targetPath, content, options = {}) {
+  const resolvedTargetPath = path.resolve(targetPath);
+  const encoding = options.encoding || "utf8";
+  const tempPath = buildAtomicTempPath(resolvedTargetPath);
+  fs.mkdirSync(path.dirname(resolvedTargetPath), { recursive: true });
+  fs.writeFileSync(tempPath, content, encoding);
+  try {
+    fs.linkSync(tempPath, resolvedTargetPath);
+  } finally {
+    fs.rmSync(tempPath, { force: true });
+  }
+}
+
+module.exports = {
+  isPlainObject,
+  escapeRegExp,
+  pathExists,
+  readTextIfExists,
+  uniqueValues,
+  parseJsonText,
+  readJsonFile,
+  sleepSync,
+  writeFileAtomic,
+  writeFileExclusiveAtomic
+};