blun-king-cli 9.1.586 → 9.1.588

package/bin/telemetry-spool-policy.cjs

@@ -1,57 +0,0 @@
-'use strict';
-
-const TELEMETRY_RETRY_MAX_FILES = 16;
-const TELEMETRY_SPOOL_MAX_FILES = 512;
-const TELEMETRY_SPOOL_MAX_BYTES = 16 * 1024 * 1024;
-const TELEMETRY_SPOOL_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-
-function isFailedTelemetryEntry(entry) {
-  return entry !== null
-    && typeof entry === 'object'
-    && /^failed_[^.]+\.jsonl$/u.test(entry.name ?? '')
-    && Number.isFinite(entry.mtimeMs)
-    && Number.isFinite(entry.size)
-    && entry.size >= 0;
-}
-
-function oldestFirst(left, right) {
-  return left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name);
-}
-
-function newestFirst(left, right) {
-  return right.mtimeMs - left.mtimeMs || right.name.localeCompare(left.name);
-}
-
-function selectTelemetryRetryEntries(entries, maxFiles = TELEMETRY_RETRY_MAX_FILES) {
-  if (!Number.isSafeInteger(maxFiles) || maxFiles < 0) return [];
-  return entries.filter(isFailedTelemetryEntry).sort(oldestFirst).slice(0, maxFiles);
-}
-
-function selectTelemetrySpoolPruneEntries(entries, now = Date.now()) {
-  const failed = entries.filter(isFailedTelemetryEntry);
-  const expired = failed.filter((entry) => now - entry.mtimeMs > TELEMETRY_SPOOL_MAX_AGE_MS);
-  const expiredNames = new Set(expired.map((entry) => entry.name));
-  const live = failed.filter((entry) => !expiredNames.has(entry.name)).sort(newestFirst);
-  const keptNames = new Set();
-  let keptBytes = 0;
-
-  for (const entry of live) {
-    if (keptNames.size >= TELEMETRY_SPOOL_MAX_FILES) continue;
-    if (keptBytes + entry.size > TELEMETRY_SPOOL_MAX_BYTES) continue;
-    keptNames.add(entry.name);
-    keptBytes += entry.size;
-  }
-
-  return failed
-    .filter((entry) => expiredNames.has(entry.name) || !keptNames.has(entry.name))
-    .sort(oldestFirst);
-}
-
-module.exports = {
-  TELEMETRY_RETRY_MAX_FILES,
-  TELEMETRY_SPOOL_MAX_AGE_MS,
-  TELEMETRY_SPOOL_MAX_BYTES,
-  TELEMETRY_SPOOL_MAX_FILES,
-  selectTelemetryRetryEntries,
-  selectTelemetrySpoolPruneEntries,
-};

package/bin/thinking-activity-status-policy.cjs

@@ -1,132 +0,0 @@
-'use strict';
-
-const ACTIVITY_CHANGE_INTERVAL_MS = 3_000;
-
-const THINKING_ACTIVITY_WORDS = Object.freeze({
-  Thinking: Object.freeze([
-    'Thinkering', 'Reasoning', 'Pondering', 'Analyzing', 'Exploring',
-    'Connecting', 'Unraveling', 'Imagining', 'Envisioning', 'Strategizing',
-    'Deciphering', 'Framing', 'Ideating', 'Synthesizing', 'Reflecting',
-  ]),
-  Planning: Object.freeze([
-    'Architecting', 'Blueprinting', 'Structuring', 'Orchestrating', 'Sequencing',
-    'Scoping', 'Prioritizing', 'Coordinating', 'Decomposing', 'Aligning',
-    'Roadmapping', 'Modeling', 'Designing', 'Drafting', 'Preparing',
-  ]),
-  Researching: Object.freeze([
-    'Searching', 'Browsing', 'Discovering', 'Investigating', 'Examining',
-    'Inspecting', 'Tracing', 'Comparing', 'Verifying', 'Cross-checking',
-    'Fact-finding', 'Source-hunting', 'Deep-diving', 'Contextualizing', 'Evidence-gathering',
-  ]),
-  Building: Object.freeze([
-    'Building', 'Crafting', 'Coding', 'Engineering', 'Assembling',
-    'Integrating', 'Implementing', 'Wiring', 'Configuring', 'Compiling',
-    'Rendering', 'Generating', 'Prototyping', 'Shaping', 'Forging',
-  ]),
-  Solving: Object.freeze([
-    'Debugging', 'Diagnosing', 'Troubleshooting', 'Untangling', 'Repairing',
-    'Patching', 'Resolving', 'Reworking', 'Refining', 'Optimizing',
-    'Simplifying', 'Stabilizing', 'Recovering', 'Calibrating', 'Tuning',
-  ]),
-  Validating: Object.freeze([
-    'Testing', 'Validating', 'Reviewing', 'Auditing', 'Proofreading',
-    'Measuring', 'Benchmarking', 'Stress-testing', 'Safeguarding', 'Hardening',
-    'Polishing', 'Fine-tuning', 'Checking', 'Confirming', 'Certifying',
-  ]),
-  Processing: Object.freeze([
-    'Reading', 'Parsing', 'Indexing', 'Remembering', 'Recalling',
-    'Organizing', 'Classifying', 'Filtering', 'Sorting', 'Matching',
-    'Merging', 'Summarizing', 'Compressing', 'Transforming', 'Learning',
-  ]),
-  Collaborating: Object.freeze([
-    'Delegating', 'Collaborating', 'Consulting', 'Briefing', 'Dispatching',
-    'Synchronizing', 'Negotiating', 'Handshaking', 'Queuing', 'Routing',
-    'Supervising', 'Monitoring', 'Reconciling', 'Reporting', 'Converging',
-  ]),
-  Creating: Object.freeze([
-    'Writing', 'Rewriting', 'Translating', 'Localizing', 'Narrating',
-    'Explaining', 'Illustrating', 'Visualizing', 'Formatting', 'Styling',
-    'Presenting', 'Documenting', 'Captioning', 'Storyboarding', 'Publishing',
-  ]),
-  'BLUN Magic': Object.freeze([
-    'BLUNing', 'Sparkering', 'Wondermaking', 'Dreamweaving', 'Futurecrafting',
-    'Brightening', 'Flowing', 'Accelerating', 'Automating', 'Empowering',
-    'Launching', 'Scaling', 'Evolving', 'Delivering', 'Finishing',
-  ]),
-});
-
-const EVIDENCE_KEYS = new Set([
-  'command', 'cmd', 'description', 'file', 'file_path', 'path', 'pattern',
-  'prompt', 'query', 'task', 'title', 'url',
-]);
-
-function activityEvidence(toolCall) {
-  if (!toolCall || typeof toolCall !== 'object') return '';
-  const values = [toolCall.name];
-  const args = toolCall.args;
-  if (args && typeof args === 'object' && !Array.isArray(args)) {
-    for (const [key, value] of Object.entries(args)) {
-      if (!EVIDENCE_KEYS.has(key.toLowerCase())) continue;
-      if (typeof value === 'string') values.push(value.slice(0, 2_000));
-    }
-  } else if (typeof toolCall.argumentsText === 'string') {
-    values.push(toolCall.argumentsText.slice(0, 2_000));
-  }
-  return values.filter(Boolean).join(' ').toLowerCase();
-}
-
-function matchesAny(text, patterns) {
-  return patterns.some((pattern) => text.includes(pattern));
-}
-
-function inferThinkingActivityGroup(toolCall, options = {}) {
-  if (options.completing === true) return 'BLUN Magic';
-  if (options.retrying === true || options.failed === true) return 'Solving';
-
-  const name = typeof toolCall?.name === 'string' ? toolCall.name.toLowerCase() : '';
-  const evidence = activityEvidence(toolCall);
-  if (!name) return 'Thinking';
-  if (name === 'todolist' || matchesAny(evidence, [' plan', 'roadmap', 'architect', 'scope'])) return 'Planning';
-  if (matchesAny(name, ['agent', 'swarm', 'telegram']) || matchesAny(evidence, ['delegate', 'handoff', 'telegram', 'report to'])) return 'Collaborating';
-  if (matchesAny(name, ['memory', 'compact']) || matchesAny(evidence, ['memory', 'compact', 'summar', 'index'])) return 'Processing';
-  if (matchesAny(name, ['grep', 'glob', 'search', 'webfetch', 'web_fetch', 'websearch', 'web_search', 'ls']) || matchesAny(evidence, ['search', 'find ', 'inspect', 'trace'])) return 'Researching';
-  if (matchesAny(evidence, ['publish', 'release', 'deploy', 'launch', 'deliver', 'finish'])) return 'BLUN Magic';
-  if (matchesAny(evidence, ['error', 'fail', 'debug', 'diagnos', 'repair', 'patch', 'fix ', 'recover', 'troubleshoot'])) return 'Solving';
-  if (matchesAny(evidence, ['test', 'check', 'verify', 'validat', 'audit', 'benchmark', 'measure', 'compare', 'sha256', 'diff '])) return 'Validating';
-  if (name === 'read' || name === 'readbatch') return 'Processing';
-  if (name === 'write' || name === 'edit') {
-    if (matchesAny(evidence, ['.md', '.txt', 'readme', 'changelog', 'document', 'translat', 'localiz'])) return 'Creating';
-    return 'Building';
-  }
-  if (matchesAny(name, ['bash', 'shell', 'programmatictool']) || matchesAny(evidence, ['build', 'compile', 'npm ', 'node ', 'code'])) return 'Building';
-  return 'Processing';
-}
-
-class ThinkingActivityRotator {
-  constructor(changeIntervalMs = ACTIVITY_CHANGE_INTERVAL_MS) {
-    this.changeIntervalMs = Math.max(ACTIVITY_CHANGE_INTERVAL_MS, Number(changeIntervalMs) || 0);
-    this.currentWord = undefined;
-    this.changedAtMs = undefined;
-    this.nextIndexByGroup = new Map();
-  }
-
-  resolve(group, nowMs = Date.now()) {
-    const safeGroup = Object.hasOwn(THINKING_ACTIVITY_WORDS, group) ? group : 'Thinking';
-    const now = Number.isFinite(nowMs) ? nowMs : Date.now();
-    if (this.currentWord !== undefined && now - this.changedAtMs < this.changeIntervalMs) return this.currentWord;
-
-    const words = THINKING_ACTIVITY_WORDS[safeGroup];
-    const index = this.nextIndexByGroup.get(safeGroup) ?? 0;
-    this.currentWord = words[index % words.length];
-    this.nextIndexByGroup.set(safeGroup, (index + 1) % words.length);
-    this.changedAtMs = now;
-    return this.currentWord;
-  }
-}
-
-module.exports = {
-  ACTIVITY_CHANGE_INTERVAL_MS,
-  THINKING_ACTIVITY_WORDS,
-  ThinkingActivityRotator,
-  inferThinkingActivityGroup,
-};

package/bin/thinking-only-guard.cjs

@@ -1,79 +0,0 @@
-'use strict';
-
-const DEFAULT_THINKING_ONLY_LIMIT_MS = 2 * 60 * 1000;
-const FORCE_ANSWER_PROMPT = [
-  'Stop hidden thinking now and take the next concrete action.',
-  'If a tool is required, call it now; otherwise answer with the concrete finding, blocker, or next action.',
-].join(' ');
-
-function appendBoundaryMessages(messages, suffix) {
-  if (!Array.isArray(suffix) || suffix.length === 0) return messages;
-  return [...messages, ...suffix];
-}
-
-function createThinkingOnlyGuard(options = {}) {
-  const maxMs = options.maxMs ?? DEFAULT_THINKING_ONLY_LIMIT_MS;
-  const now = options.now ?? Date.now;
-  const setTimer = options.setTimer ?? setTimeout;
-  const clearTimer = options.clearTimer ?? clearTimeout;
-  const onTimeout = options.onTimeout ?? (() => {});
-  let timer;
-  let startedAt;
-  let substantiveOutput = false;
-
-  function disarm() {
-    if (timer !== undefined) clearTimer(timer);
-    timer = undefined;
-    startedAt = undefined;
-  }
-
-  function beginAttempt() {
-    disarm();
-    substantiveOutput = false;
-  }
-
-  function noteThinking() {
-    if (substantiveOutput || timer !== undefined) return;
-    startedAt = now();
-    timer = setTimer(() => {
-      timer = undefined;
-      const elapsedMs = Math.max(0, now() - startedAt);
-      startedAt = undefined;
-      onTimeout({ reason: 'thinking_only_timeout', elapsedMs });
-    }, maxMs);
-    timer?.unref?.();
-  }
-
-  function noteSubstantiveOutput() {
-    substantiveOutput = true;
-    disarm();
-  }
-
-  return {
-    beginAttempt,
-    noteThinking,
-    noteSubstantiveOutput,
-    stop: disarm,
-  };
-}
-
-function forceAnswerParams(params) {
-  const forceAnswerMessage = {
-    role: 'user',
-    content: [{ type: 'text', text: FORCE_ANSWER_PROMPT }],
-    toolCalls: [],
-  };
-  return {
-    ...params,
-    messages: [...params.messages, forceAnswerMessage],
-    boundaryMessageSuffix: [...(params.boundaryMessageSuffix ?? []), forceAnswerMessage],
-  };
-}
-
-module.exports = {
-  DEFAULT_THINKING_ONLY_LIMIT_MS,
-  FORCE_ANSWER_PROMPT,
-  appendBoundaryMessages,
-  createThinkingOnlyGuard,
-  forceAnswerParams,
-};

package/bin/todo-list-turn-policy.cjs

@@ -1,131 +0,0 @@
-'use strict';
-
-const TODO_LIST_TOOL_NAME = 'TodoList';
-const MAX_TODO_ITEMS = 32;
-const BASE_TODO_REFRESH_WORK_CALL_LIMIT = 8;
-const MAX_TODO_REFRESH_WORK_CALL_LIMIT = 64;
-const TODO_STALLED_WARNING_STREAK = 3;
-
-function canonicalStoredTodos(todos) {
-  if (!Array.isArray(todos)) return [];
-  return todos
-    .filter((todo) => todo?.status !== 'done')
-    .map((todo) => ({
-      title: String(todo?.title ?? ''),
-      status: String(todo?.status ?? ''),
-    }));
-}
-
-function semanticTodoFingerprint(todos) {
-  return JSON.stringify(canonicalStoredTodos(todos)
-    .map((todo) => `${todo.status}\0${todo.title}`)
-    .sort());
-}
-
-function todoTitleCounts(todos) {
-  const counts = new Map();
-  for (const todo of Array.isArray(todos) ? todos : []) {
-    const title = String(todo?.title ?? '');
-    counts.set(title, (counts.get(title) ?? 0) + 1);
-  }
-  return counts;
-}
-
-function sameTitleCounts(left, right) {
-  if (left.size !== right.size) return false;
-  for (const [title, count] of left) {
-    if (right.get(title) !== count) return false;
-  }
-  return true;
-}
-
-function assessTodoListBounds(input) {
-  const currentTodos = canonicalStoredTodos(input?.currentTodos);
-  const nextTodos = canonicalStoredTodos(input?.nextTodos);
-  if (currentTodos.length > MAX_TODO_ITEMS) {
-    const currentTitles = todoTitleCounts(currentTodos);
-    const submittedTitles = todoTitleCounts(input?.nextTodos);
-    if (!sameTitleCounts(currentTitles, submittedTitles)) {
-      return {
-        block: true,
-        reason: `An oversized legacy TodoList may remove an unresolved legacy item only by submitting it as done. Do not add, omit, or rename items until the visible list is at or below ${String(MAX_TODO_ITEMS)}.`,
-      };
-    }
-
-    if (nextTodos.length > currentTodos.length) {
-      return {
-        block: true,
-        reason: `An oversized legacy TodoList must stay unchanged or shrink toward ${String(MAX_TODO_ITEMS)} visible items.`,
-      };
-    }
-
-    return undefined;
-  }
-
-  if (nextTodos.length <= MAX_TODO_ITEMS) return undefined;
-  return {
-    block: true,
-    reason: `TodoList accepts at most ${String(MAX_TODO_ITEMS)} visible items. Group the work into task-specific phases before continuing.`,
-  };
-}
-
-function todoRefreshWorkCallLimit(unchangedRefreshStreak) {
-  const exponent = Math.min(Math.max(Number(unchangedRefreshStreak) || 0, 0), 3);
-  return Math.min(
-    MAX_TODO_REFRESH_WORK_CALL_LIMIT,
-    BASE_TODO_REFRESH_WORK_CALL_LIMIT * (2 ** exponent),
-  );
-}
-
-function assessTodoMaintenanceUpdate(input) {
-  const changed = semanticTodoFingerprint(input?.currentTodos)
-    !== semanticTodoFingerprint(input?.nextTodos);
-  if (changed) {
-    return {
-      changed: true,
-      unchangedRefreshStreak: 0,
-      refreshWorkCallLimit: BASE_TODO_REFRESH_WORK_CALL_LIMIT,
-      preserveRecentEvidence: false,
-      requireConcreteProgress: false,
-      emitStalledWarning: false,
-    };
-  }
-
-  const previousStreak = Math.max(Number(input?.unchangedRefreshStreak) || 0, 0);
-  const hasNewEvidence = (Number(input?.recentEvidenceCount) || 0) > 0;
-  const unchangedRefreshStreak = hasNewEvidence ? previousStreak + 1 : previousStreak;
-  return {
-    changed: false,
-    unchangedRefreshStreak,
-    refreshWorkCallLimit: todoRefreshWorkCallLimit(unchangedRefreshStreak),
-    preserveRecentEvidence: true,
-    requireConcreteProgress: unchangedRefreshStreak >= 2,
-    emitStalledWarning: hasNewEvidence
-      && unchangedRefreshStreak === TODO_STALLED_WARNING_STREAK,
-  };
-}
-
-function enforceSingleTodoWritePerStep(context) {
-  if (context?.toolCall?.name !== TODO_LIST_TOOL_NAME) return undefined;
-  if (!Array.isArray(context.args?.todos)) return undefined;
-
-  const todoWrites = Array.isArray(context.toolCalls)
-    ? context.toolCalls.filter((call) => call?.name === TODO_LIST_TOOL_NAME)
-    : [];
-  if (todoWrites.length <= 1) return undefined;
-  if (context.toolCall.id === todoWrites[0]?.id) return undefined;
-
-  return {
-    block: true,
-    reason: 'Only one TodoList write is allowed per model step. Use the first update, then continue from its stored result in the next step.',
-  };
-}
-
-module.exports = {
-  MAX_TODO_ITEMS,
-  assessTodoListBounds,
-  assessTodoMaintenanceUpdate,
-  canonicalStoredTodos,
-  enforceSingleTodoWritePerStep,
-  todoRefreshWorkCallLimit,
-};

package/bin/tool-call-loop-policy.cjs

@@ -1,51 +0,0 @@
-'use strict';
-
-const { createHash } = require('node:crypto');
-
-const NUMBER_VALUE = '<number>';
-const NUMBER_TEXT = /[-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[-+]?\d+)?/giu;
-
-function normalizeLoopText(value) {
-  return String(value).toLowerCase().replace(NUMBER_TEXT, NUMBER_VALUE);
-}
-
-function normalizeLoopValue(value) {
-  if (typeof value === 'number' || typeof value === 'bigint') return NUMBER_VALUE;
-  if (typeof value === 'string') return normalizeLoopText(value);
-  if (Array.isArray(value)) return value.map(normalizeLoopValue);
-  if (value === null || typeof value !== 'object') return value;
-
-  const normalized = {};
-  for (const key of Object.keys(value).sort((left, right) => left.localeCompare(right))) {
-    normalized[key.toLowerCase()] = normalizeLoopValue(value[key]);
-  }
-  return normalized;
-}
-
-function createToolCallLoopKey(toolName, args) {
-  return `${normalizeLoopText(toolName)} ${JSON.stringify(normalizeLoopValue(args))}`;
-}
-
-function hashToolResult(result) {
-  const normalized = normalizeResultValue({
-    isError: result?.isError === true,
-    output: result?.output,
-  });
-  return createHash('sha256').update(JSON.stringify(normalized)).digest('hex');
-}
-
-function normalizeResultValue(value) {
-  if (Array.isArray(value)) return value.map(normalizeResultValue);
-  if (value === null || typeof value !== 'object') return value;
-  const normalized = {};
-  for (const key of Object.keys(value).sort((left, right) => left.localeCompare(right))) {
-    normalized[key] = normalizeResultValue(value[key]);
-  }
-  return normalized;
-}
-
-module.exports = {
-  createToolCallLoopKey,
-  hashToolResult,
-  normalizeLoopValue,
-};

package/bin/tool-file-persistence.cjs

@@ -1,141 +0,0 @@
-'use strict';
-
-const { randomBytes } = require('node:crypto');
-const fs = require('node:fs/promises');
-const path = require('node:path');
-
-const WINDOWS_RENAME_RETRY_CODES = new Set(['EACCES', 'EBUSY', 'EPERM']);
-const DEFAULT_WINDOWS_RENAME_DELAYS_MS = Object.freeze([10, 25, 50, 100]);
-
-function isAbortError(error) {
-  return error instanceof Error && error.name === 'AbortError';
-}
-
-function throwIfAborted(signal) {
-  if (!signal?.aborted) return;
-  const error = new Error('Atomic tool write aborted before publication.');
-  error.name = 'AbortError';
-  throw error;
-}
-
-function isMissing(error) {
-  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
-}
-
-async function existingFileMode(filePath, statFile) {
-  try {
-    const info = await statFile(filePath);
-    if (!info.isFile()) throw Object.assign(new Error(`Cannot replace non-file target: ${filePath}`), { code: 'EISDIR' });
-    return typeof info.mode === 'number' ? info.mode & 0o777 : undefined;
-  } catch (error) {
-    if (isMissing(error)) return undefined;
-    throw error;
-  }
-}
-
-async function resolvePublicationPath(filePath, operations) {
-  try {
-    return await operations.realpathFile(filePath);
-  } catch (error) {
-    if (!isMissing(error)) throw error;
-  }
-
-  try {
-    const linkInfo = await operations.lstatFile(filePath);
-    if (linkInfo.isSymbolicLink()) {
-      throw Object.assign(new Error(`Refused atomic replacement through dangling symbolic link: ${filePath}`), { code: 'ELOOP' });
-    }
-  } catch (error) {
-    if (!isMissing(error)) throw error;
-  }
-
-  const realParent = await operations.realpathFile(path.dirname(filePath));
-  return path.join(realParent, path.basename(filePath));
-}
-
-async function renameWithWindowsRetry(source, target, options) {
-  const delays = options.platform === 'win32'
-    ? options.windowsRenameDelaysMs
-    : [];
-  let attempt = 0;
-  while (true) {
-    try {
-      await options.renameFile(source, target);
-      return;
-    } catch (error) {
-      const delayMs = delays[attempt];
-      if (delayMs === undefined || !WINDOWS_RENAME_RETRY_CODES.has(error?.code)) throw error;
-      attempt += 1;
-      throwIfAborted(options.signal);
-      await options.sleep(delayMs);
-    }
-  }
-}
-
-async function writeToolTextAtomic(filePath, content, options = {}) {
-  if (typeof filePath !== 'string' || filePath.length === 0) throw new TypeError('filePath must be a non-empty string');
-  if (typeof content !== 'string' && !Buffer.isBuffer(content)) throw new TypeError('content must be a string or Buffer');
-
-  const openFile = options.openFile || fs.open;
-  const renameFile = options.renameFile || fs.rename;
-  const unlinkFile = options.unlinkFile || fs.unlink;
-  const statFile = options.statFile || fs.stat;
-  const lstatFile = options.lstatFile || fs.lstat;
-  const realpathFile = options.realpathFile || fs.realpath;
-  const syncHandle = options.syncHandle || ((handle) => handle.sync());
-  const sleep = options.sleep || ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
-  const signal = options.signal;
-  const platform = options.platform || process.platform;
-  const windowsRenameDelaysMs = options.windowsRenameDelaysMs || DEFAULT_WINDOWS_RENAME_DELAYS_MS;
-
-  throwIfAborted(signal);
-  const publicationPath = await resolvePublicationPath(filePath, { lstatFile, realpathFile });
-  const mode = await existingFileMode(publicationPath, statFile);
-  const suffix = `${process.pid}.${randomBytes(6).toString('hex')}`;
-  const temporaryPath = path.join(path.dirname(publicationPath), `.${path.basename(publicationPath)}.${suffix}.tmp`);
-  let handle;
-  let published = false;
-
-  try {
-    handle = await openFile(temporaryPath, 'wx', mode ?? 0o666);
-    await handle.writeFile(content, typeof content === 'string' ? { encoding: 'utf8', signal } : { signal });
-    await syncHandle(handle);
-    if (mode !== undefined && platform !== 'win32') await handle.chmod(mode);
-    await handle.close();
-    handle = undefined;
-
-    throwIfAborted(signal);
-    await renameWithWindowsRetry(temporaryPath, publicationPath, {
-      platform,
-      renameFile,
-      signal,
-      sleep,
-      windowsRenameDelaysMs,
-    });
-    published = true;
-    return { bytesWritten: Buffer.byteLength(content) };
-  } finally {
-    if (handle !== undefined) {
-      try {
-        await handle.close();
-      } catch {}
-    }
-    if (!published) {
-      try {
-        await unlinkFile(temporaryPath);
-      } catch (error) {
-        if (!isMissing(error)) {
-          // The primary write error remains authoritative; stale temp names are unique and never read.
-        }
-      }
-    }
-  }
-}
-
-module.exports = {
-  DEFAULT_WINDOWS_RENAME_DELAYS_MS,
-  WINDOWS_RENAME_RETRY_CODES,
-  renameWithWindowsRetry,
-  resolvePublicationPath,
-  writeToolTextAtomic,
-};