@duckmind/dm-linux-x64 0.63.9 → 0.64.6

package/extensions/dm-lens/clients/lsp/workspace-diagnostics-session.js

@@ -0,0 +1,7 @@
+let _sessionStartedAt = Date.now();
+export function resetWorkspaceDiagnosticsCacheSession(startedAt = Date.now()) {
+  _sessionStartedAt = startedAt;
+}
+export function workspaceDiagnosticsCacheSessionStart() {
+  return _sessionStartedAt;
+}

package/extensions/dm-lens/clients/lsp/workspace-sweep-hold.js

@@ -0,0 +1,93 @@
+import { logLatency } from "../latency-logger.js";
+import { getProcessSingleton } from "../process-singletons.js";
+export const SWEEP_IDLE_SAFETY_MARGIN_MS = 60000;
+const WORKSPACE_SWEEP_HOLD_FAMILY = "lsp.workspace-sweep-hold";
+const WORKSPACE_SWEEP_HOLD_VERSION = 1;
+function state() {
+  return getProcessSingleton(WORKSPACE_SWEEP_HOLD_FAMILY, WORKSPACE_SWEEP_HOLD_VERSION, () => ({ holds: new Map, nextHoldId: 1, idleWaiters: [] }));
+}
+function flushIdleWaitersIfEmpty() {
+  const current = state();
+  if (current.holds.size > 0)
+    return;
+  if (current.idleWaiters.length === 0)
+    return;
+  const waiters = current.idleWaiters;
+  current.idleWaiters = [];
+  for (const waiter of waiters) {
+    try {
+      waiter();
+    } catch {}
+  }
+}
+export function getWorkspaceSweepMaxHoldAgeMs() {
+  return getFullScanWallClockMs() + SWEEP_IDLE_SAFETY_MARGIN_MS;
+}
+function reapStaleHolds() {
+  const current = state();
+  if (current.holds.size === 0)
+    return;
+  const maxAgeMs = getWorkspaceSweepMaxHoldAgeMs();
+  const now = Date.now();
+  for (const [holdId, acquiredAt] of current.holds) {
+    const ageMs = now - acquiredAt;
+    if (ageMs <= maxAgeMs)
+      continue;
+    current.holds.delete(holdId);
+    logLatency({
+      type: "phase",
+      phase: "lsp_workspace_sweep_hold_force_released",
+      filePath: "",
+      durationMs: ageMs,
+      metadata: { holdId, maxHoldAgeMs: maxAgeMs }
+    });
+  }
+  flushIdleWaitersIfEmpty();
+}
+export function acquireWorkspaceSweepHold() {
+  const current = state();
+  const holdId = current.nextHoldId++;
+  current.holds.set(holdId, Date.now());
+  return () => {
+    if (!state().holds.delete(holdId))
+      return;
+    flushIdleWaitersIfEmpty();
+  };
+}
+export function isWorkspaceSweepActive() {
+  reapStaleHolds();
+  return state().holds.size > 0;
+}
+export function runWhenWorkspaceSweepIdle(cb) {
+  reapStaleHolds();
+  const current = state();
+  if (current.holds.size === 0) {
+    cb();
+    return;
+  }
+  current.idleWaiters.push(cb);
+}
+export function clearWorkspaceSweepHoldForSessionStart() {
+  const current = state();
+  if (current.holds.size === 0)
+    return;
+  logLatency({
+    type: "phase",
+    phase: "lsp_workspace_sweep_hold_session_reset",
+    filePath: "",
+    durationMs: 0,
+    metadata: { clearedHolds: current.holds.size }
+  });
+  current.holds.clear();
+  flushIdleWaitersIfEmpty();
+}
+export function _resetWorkspaceSweepHoldForTests() {
+  const current = state();
+  current.holds.clear();
+  current.idleWaiters = [];
+  current.nextHoldId = 1;
+}
+export function getFullScanWallClockMs() {
+  const raw = Number(process.env.DM_LENS_LENS_DIAGNOSTICS_FULL_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 300000;
+}

package/extensions/dm-lens/clients/lsp-budget.js

@@ -0,0 +1,86 @@
+import {
+  isInstanceRegistryEnabled,
+  readInstanceRegistry
+} from "./instance-registry.js";
+import { realIsPidAlive, STALE_HEARTBEAT_MS } from "./instance-reaper.js";
+import { logLatency } from "./latency-logger.js";
+export const DEFAULT_LSP_BUDGET_CEILING = 16;
+export const DEFAULT_LSP_BUDGET_IDLE_TIMEOUT_MS = 60000;
+export function isCrossProcessBudgetEnabled() {
+  return process.env.DM_LENS_CROSS_PROCESS_BUDGET !== "0";
+}
+export function getLspBudgetCeiling() {
+  const raw = Number(process.env.DM_LENS_LSP_BUDGET_CEILING);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_LSP_BUDGET_CEILING;
+}
+export function getLspBudgetRssCeilingBytes() {
+  const raw = Number(process.env.DM_LENS_LSP_BUDGET_RSS_MB);
+  return Number.isFinite(raw) && raw > 0 ? raw * 1024 * 1024 : undefined;
+}
+export function getLspBudgetIdleTimeoutMs() {
+  const raw = Number(process.env.DM_LENS_LSP_BUDGET_IDLE_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_LSP_BUDGET_IDLE_TIMEOUT_MS;
+}
+export function decideLspBudget(registry, isPidAlive, ceiling, rssCeilingBytes, now = Date.now()) {
+  const liveInstances = registry.filter((instance) => isPidAlive(instance.pid));
+  const totalLiveLspServers = liveInstances.reduce((sum, instance) => sum + instance.lspChildren.length, 0);
+  const hasCompleteFreshSamples = rssCeilingBytes !== undefined && liveInstances.length > 0 && liveInstances.every((instance) => {
+    const heartbeatMs = Date.parse(instance.heartbeatAt);
+    return Number.isFinite(heartbeatMs) && now - heartbeatMs <= STALE_HEARTBEAT_MS && Number.isFinite(instance.rssBytes) && instance.lspChildren.every((child) => Number.isFinite(child.rssBytes));
+  });
+  const totalRssBytes = hasCompleteFreshSamples ? liveInstances.reduce((sum, instance) => sum + instance.rssBytes + instance.lspChildren.reduce((childSum, child) => childSum + (child.rssBytes ?? 0), 0), 0) : undefined;
+  const rssPressure = totalRssBytes !== undefined && rssCeilingBytes !== undefined && totalRssBytes >= rssCeilingBytes;
+  const overBudget = totalLiveLspServers >= ceiling || rssPressure;
+  return {
+    totalLiveLspServers,
+    ceiling,
+    totalRssBytes,
+    rssCeilingBytes,
+    rssPressure,
+    overBudget,
+    degradeAuxiliary: overBudget,
+    shortenIdleTimeout: overBudget,
+    preferPullOnly: overBudget
+  };
+}
+let cachedDecision;
+export function shouldDegradeAuxiliaryLsp() {
+  return cachedDecision?.degradeAuxiliary ?? false;
+}
+export function shouldShortenLspIdleTimeout() {
+  return cachedDecision?.shortenIdleTimeout ?? false;
+}
+export function shouldPreferPullOnlyDiagnostics() {
+  return cachedDecision?.preferPullOnly ?? false;
+}
+export function _resetLspBudgetDecisionForTests() {
+  cachedDecision = undefined;
+}
+export async function checkCrossProcessLspBudget(testOverrides = {}) {
+  if (!isCrossProcessBudgetEnabled() || !isInstanceRegistryEnabled())
+    return;
+  try {
+    const registry = testOverrides.registry ?? await readInstanceRegistry();
+    if (registry.length === 0)
+      return;
+    const ceiling = getLspBudgetCeiling();
+    const decision = decideLspBudget(registry, testOverrides.isPidAlive ?? realIsPidAlive, ceiling, getLspBudgetRssCeilingBytes());
+    cachedDecision = decision;
+    if (decision.overBudget) {
+      logLatency({
+        type: "phase",
+        phase: "cross_process_lsp_budget_degraded",
+        filePath: "",
+        durationMs: 0,
+        metadata: {
+          totalLiveLspServers: decision.totalLiveLspServers,
+          ceiling: decision.ceiling,
+          totalRssBytes: decision.totalRssBytes,
+          rssCeilingBytes: decision.rssCeilingBytes,
+          rssPressure: decision.rssPressure,
+          instanceCount: registry.length
+        }
+      });
+    }
+  } catch {}
+}

package/extensions/dm-lens/clients/lsp-document-symbols.js

@@ -0,0 +1,93 @@
+import { getLSPService } from "./lsp/index.js";
+export const LSP_DOCUMENT_SYMBOL_TIMEOUT_MS = 150;
+export const SYMBOL_KIND_NAMES = {
+  1: "file",
+  2: "module",
+  3: "namespace",
+  4: "package",
+  5: "class",
+  6: "method",
+  7: "property",
+  8: "field",
+  9: "constructor",
+  10: "enum",
+  11: "interface",
+  12: "function",
+  13: "variable",
+  14: "constant",
+  15: "string",
+  16: "number",
+  17: "boolean",
+  18: "array",
+  19: "object",
+  20: "key",
+  21: "null",
+  22: "enum-member",
+  23: "struct",
+  24: "event",
+  25: "operator",
+  26: "type-parameter"
+};
+export function lspSymbolKindName(kind) {
+  return SYMBOL_KIND_NAMES[kind] ?? `lsp-symbol-${kind}`;
+}
+export async function getOpenDocumentSymbols(filePath, timeoutMs = LSP_DOCUMENT_SYMBOL_TIMEOUT_MS) {
+  const spawned = await getLSPService().getWarmClientForFile(filePath);
+  if (!spawned || !spawned.client.isDocumentOpen(filePath) || !spawned.client.getOperationSupport().documentSymbol) {
+    return;
+  }
+  let timer;
+  try {
+    return await Promise.race([
+      spawned.client.documentSymbol(filePath),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(undefined), timeoutMs);
+      })
+    ]);
+  } catch {
+    return;
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+function symbolRange(symbol) {
+  return symbol.range ?? symbol.location?.range;
+}
+export function findDocumentSymbolAtLine(symbols, oneBasedLine) {
+  const line = oneBasedLine - 1;
+  let best;
+  let bestSpan = Number.POSITIVE_INFINITY;
+  const visit = (items, ancestry) => {
+    for (const symbol of items) {
+      const range = symbolRange(symbol);
+      if (range && range.start.line <= line && range.end.line >= line) {
+        const nextAncestry = [...ancestry, symbol];
+        const span = range.end.line - range.start.line;
+        if (span <= bestSpan) {
+          best = { symbol, ancestry };
+          bestSpan = span;
+        }
+        if (symbol.children)
+          visit(symbol.children, nextAncestry);
+      }
+    }
+  };
+  visit(symbols, []);
+  return best;
+}
+export function containerNameChain(symbol, allSymbols) {
+  const chain = [];
+  const seen = new Set;
+  let container = symbol.containerName;
+  while (container && !seen.has(container) && chain.length < 10) {
+    chain.unshift(container);
+    seen.add(container);
+    container = allSymbols?.find((candidate) => candidate.name === container)?.containerName;
+  }
+  return chain;
+}
+export function qualifiedLspSymbolName(located, allSymbols) {
+  const owners = located.ancestry.length > 0 ? located.ancestry.map((entry) => entry.name) : containerNameChain(located.symbol, allSymbols);
+  return [...owners, located.symbol.name].join(".");
+}

package/extensions/dm-lens/clients/lsp-lazy.js

@@ -0,0 +1,8 @@
+import { createLazyImport } from "./lazy-import.js";
+const lazyLsp = createLazyImport(() => import("./lsp/index.js"));
+export function warmLspService() {
+  return lazyLsp.get();
+}
+export function loadLspService() {
+  return warmLspService();
+}

package/extensions/dm-lens/clients/lsp-mutation.js

@@ -0,0 +1,277 @@
+import * as path from "node:path";
+import { BoundedSet } from "./bounded-cache.js";
+import {
+  createReadGuardEditBatchSummary,
+  getReadGuardCorrelationId,
+  logReadGuardEvent
+} from "./read-guard-logger.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { getMutationBridge } from "./mutation-bridge.js";
+import { noteMutationHandled } from "./observed-mutation.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+let noBridgeDbgLogged = false;
+export function resetLspMutationNoBridgeDbgLatch() {
+  noBridgeDbgLogged = false;
+}
+export function _lspMutationNoBridgeDbgLoggedForTests() {
+  return noBridgeDbgLogged;
+}
+const MAX_SAMPLES = 100;
+const MAX_SUMMARIES_PER_CONTEXT = 100;
+export function newLspMutationCorrelationId(toolCallId) {
+  return getReadGuardCorrelationId(toolCallId ? { toolCallId } : {});
+}
+function allResults(options) {
+  return options.results ?? [];
+}
+function combineResults(results) {
+  const files = new Set;
+  const fileDetails = [];
+  const appliedIndexes = [];
+  const paths = [];
+  let requestedTotal = 0;
+  let appliedTotal = 0;
+  let textEdits = 0;
+  let create = 0;
+  let rename = 0;
+  let deleteCount = 0;
+  for (const result of results) {
+    requestedTotal += result.operationTotal;
+    appliedTotal += result.appliedOperationTotal;
+    textEdits += result.operationCounts.textEdits;
+    create += result.operationCounts.create;
+    rename += result.operationCounts.rename;
+    deleteCount += result.operationCounts.delete;
+    for (const index of result.appliedOperationIndexes)
+      appliedIndexes.push(index);
+    for (const file of result.files) {
+      if (!files.has(file)) {
+        files.add(file);
+        paths.push(file);
+      }
+    }
+    fileDetails.push(...result.fileDetails);
+  }
+  return {
+    requestedTotal,
+    appliedTotal,
+    appliedIndexes,
+    files: [...files],
+    fileDetails,
+    textEdits,
+    create,
+    rename,
+    delete: deleteCount,
+    paths
+  };
+}
+function uniqueDetails(files, fileDetails) {
+  const byPath = new Map;
+  const keyMemo = new Map;
+  const keyFor = (filePath) => {
+    let key = keyMemo.get(filePath);
+    if (key === undefined) {
+      key = normalizeMapKey(path.resolve(filePath));
+      keyMemo.set(filePath, key);
+    }
+    return key;
+  };
+  for (const detail of fileDetails) {
+    const key = keyFor(detail.filePath);
+    const previous = byPath.get(key);
+    if (!previous) {
+      byPath.set(key, detail);
+      continue;
+    }
+    byPath.set(key, {
+      filePath: previous.filePath,
+      range: previous.range && detail.range ? {
+        start: Math.min(previous.range.start, detail.range.start),
+        end: Math.max(previous.range.end, detail.range.end)
+      } : previous.range ?? detail.range,
+      importsChanged: previous.importsChanged || detail.importsChanged
+    });
+  }
+  return files.map((filePath) => byPath.get(keyFor(filePath)) ?? {
+    filePath,
+    range: { start: 1, end: 1 },
+    importsChanged: true
+  });
+}
+function bookkeepLspMutation(context, files, fileDetails) {
+  const details = uniqueDetails(files, fileDetails);
+  const useBridgeFallback = !context.runtime || !context.cacheManager;
+  for (const detail of details) {
+    const filePath = path.resolve(detail.filePath);
+    if (context.isRecordable && !context.isRecordable(filePath)) {
+      context.dbg?.(`lsp mutation not recordable, skipping ${filePath}`);
+      continue;
+    }
+    if (context.readGuard) {
+      try {
+        context.readGuard.recordWritten(filePath);
+      } catch (err) {
+        context.dbg?.(`lsp mutation read-guard stamp failed for ${filePath}: ${err}`);
+      }
+    }
+    if (useBridgeFallback) {
+      const bridge = getMutationBridge();
+      if (!bridge) {
+        recordDegradationOnce({
+          kind: "lsp-mutation-bridge-unmounted",
+          subject: "lsp-mutation:no-bridge",
+          reason: "workspace/applyEdit bookkeeping fell back to the mutation " + "bridge, but no bridge is mounted in this process (e.g. the " + "MCP server, which never runs pi's extension activation) — " + "the write is unrecorded (no read-guard stamp, no turn-state " + "entry, no change-log receipt)."
+        });
+        if (!noBridgeDbgLogged) {
+          noBridgeDbgLogged = true;
+          context.dbg?.(`lsp mutation bridge unavailable, dropping bookkeeping for ${filePath}`);
+        }
+      } else {
+        try {
+          const recorded = bridge.recordMutation({
+            filePath,
+            kind: "edit",
+            editRanges: detail.range ? [[detail.range.start, detail.range.end]] : undefined,
+            consumer: context.tool,
+            importsChanged: detail.importsChanged ?? true,
+            deferAutofix: false
+          });
+          if (!recorded) {
+            context.dbg?.(`lsp mutation bridge dropped ${filePath} (recordMutation() ` + "returned false — see the mutation_bridge debug output " + "for the reason: malformed entry, out-of-scope path, or " + "a bookkeeping error)");
+          }
+        } catch (err) {
+          context.dbg?.(`lsp mutation bridge fallback failed for ${filePath}: ${err}`);
+        }
+      }
+    } else {
+      const runtime = context.runtime;
+      runtime?.recordProjectMutation?.({
+        filePath,
+        source: context.source,
+        cwd: context.cwd,
+        changedRange: detail.range,
+        onAppendError: (err) => context.dbg?.(`lsp mutation project change append failed for ${filePath}: ${err}`)
+      });
+      if (context.cacheManager) {
+        try {
+          context.cacheManager.addModifiedRange(filePath, detail.range ?? { start: 1, end: 1 }, detail.importsChanged ?? true, context.cwd, runtime?.telemetrySessionId, undefined, runtime?.projectRoot ?? context.cwd);
+        } catch (err) {
+          context.dbg?.(`lsp mutation modified-range tracking failed for ${filePath}: ${err}`);
+        }
+      }
+      noteMutationHandled(filePath);
+    }
+    if (context.recordAutofix && context.source === "autofix") {
+      const key = normalizeMapKey(filePath);
+      const seen = context.autofixRecordedPaths ?? new BoundedSet(MAX_SAMPLES);
+      context.autofixRecordedPaths = seen;
+      if (!seen.has(key)) {
+        seen.add(key);
+        context.recordAutofix(filePath);
+      }
+    }
+  }
+  if (context.publishFilesTouched && files.length > 0) {
+    context.publishFilesTouched(files);
+  }
+}
+function telemetryFor(context, options) {
+  const combined = combineResults(allResults(options));
+  const requestedTotal = options.requestedTotal ?? combined.requestedTotal;
+  const appliedTotal = combined.appliedTotal;
+  const requestedIndexes = Array.from({ length: Math.min(requestedTotal, MAX_SAMPLES) }, (_, index) => index);
+  const rejectedTotal = Math.max(0, requestedTotal - appliedTotal);
+  const rejectedReasons = Array.from({ length: Math.min(rejectedTotal, MAX_SAMPLES) }, (_, index) => ({ index, code: "write_failed" }));
+  const status = options.status ?? (appliedTotal > 0 ? "success" : "skipped");
+  const editBatchSummary = createReadGuardEditBatchSummary({
+    requestedIndexes,
+    requestedTotal,
+    resolvedIndexes: requestedIndexes,
+    resolvedTotal: requestedTotal,
+    rejectedReasons,
+    rejectedTotal,
+    appliedIndexes: combined.appliedIndexes,
+    appliedTotal,
+    participantIds: [context.correlationId],
+    participantTotal: 1,
+    commitStatus: status === "failed" ? "failed" : appliedTotal > 0 ? "committed" : "no_changes",
+    terminalStatus: status
+  });
+  return {
+    editBatchSummary,
+    operationCounts: {
+      requested: requestedTotal,
+      applied: appliedTotal,
+      textEdits: combined.textEdits,
+      create: combined.create,
+      rename: combined.rename,
+      delete: combined.delete
+    },
+    sampledPaths: combined.paths.slice(0, MAX_SAMPLES),
+    sampledPathsTotal: combined.paths.length,
+    sampledPathsTruncated: combined.paths.length > MAX_SAMPLES,
+    considered: options.considered,
+    completed: options.completed,
+    failedCount: options.failedCount
+  };
+}
+export function recordLspMutation(context, options = {}) {
+  const results = allResults(options);
+  const combined = combineResults(results);
+  if (options.bookkeep !== false && combined.files.length > 0) {
+    bookkeepLspMutation(context, combined.files, combined.fileDetails);
+  }
+  const telemetry = telemetryFor(context, options);
+  if (context.emitSummary !== false) {
+    const summaryCount = context.summaryCount ?? 0;
+    context.summaryEmitted = true;
+    if (summaryCount < MAX_SUMMARIES_PER_CONTEXT) {
+      context.summaryCount = summaryCount + 1;
+      logReadGuardEvent({
+        event: "edit_batch_summary",
+        correlationId: context.correlationId,
+        filePath: combined.files[0] ?? context.cwd,
+        metadata: {
+          tool: context.tool,
+          source: context.source,
+          outcome: telemetry.editBatchSummary.terminalStatus,
+          summaryIndex: summaryCount,
+          editBatchSummary: telemetry.editBatchSummary,
+          operationCounts: telemetry.operationCounts,
+          sampledPaths: telemetry.sampledPaths,
+          sampledPathsTotal: telemetry.sampledPathsTotal,
+          sampledPathsTruncated: telemetry.sampledPathsTruncated,
+          considered: telemetry.considered,
+          completed: telemetry.completed,
+          failedCount: telemetry.failedCount
+        }
+      });
+    } else if (!context.summaryOverflowed) {
+      context.summaryOverflowed = true;
+      logReadGuardEvent({
+        event: "edit_batch_summary_overflow",
+        correlationId: context.correlationId,
+        filePath: combined.files[0] ?? context.cwd,
+        metadata: {
+          tool: context.tool,
+          source: context.source,
+          summaryLimit: MAX_SUMMARIES_PER_CONTEXT,
+          suppressedSummaries: "one or more"
+        }
+      });
+    }
+  }
+  return telemetry;
+}
+export function recordLspMutationBatch(context, options) {
+  const previous = context.emitSummary;
+  context.emitSummary = true;
+  try {
+    return recordLspMutation(context, options);
+  } finally {
+    context.emitSummary = previous;
+  }
+}
+export function recordLspMutationOutcome(context, status) {
+  return recordLspMutation(context, { status, requestedTotal: 0 });
+}

package/extensions/dm-lens/clients/lsp-status.js

@@ -0,0 +1,37 @@
+import { getFileKindsForExtension } from "./file-kinds.js";
+import { LSP_SERVERS } from "./lsp/server.js";
+function serverById(id) {
+  return LSP_SERVERS.find((s) => s.id === id);
+}
+export function selectLspStatus(aliveServerIds, failedServerIds, sessionKinds) {
+  const aliveSet = new Set(aliveServerIds);
+  const aliveLangExts = new Set;
+  for (const s of LSP_SERVERS) {
+    if (s.role === "auxiliary" || !aliveSet.has(s.id))
+      continue;
+    for (const ext of s.extensions)
+      aliveLangExts.add(ext.toLowerCase());
+  }
+  const sessionKindSet = new Set(sessionKinds);
+  const failedIds = [];
+  const seen = new Set;
+  for (const id of failedServerIds) {
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    const server = serverById(id);
+    if (!server || server.role === "auxiliary")
+      continue;
+    const exts = server.extensions.map((e) => e.toLowerCase());
+    if (exts.some((e) => aliveLangExts.has(e)))
+      continue;
+    const kinds = new Set;
+    for (const e of exts)
+      for (const k of getFileKindsForExtension(e))
+        kinds.add(k);
+    if (![...kinds].some((k) => sessionKindSet.has(k)))
+      continue;
+    failedIds.push(id);
+  }
+  return { activeIds: [...aliveServerIds], failedIds };
+}

package/extensions/dm-lens/clients/map-with-concurrency.js

@@ -0,0 +1,16 @@
+export async function mapWithConcurrency(items, concurrency, mapper) {
+  if (items.length === 0)
+    return;
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  const worker = async () => {
+    while (true) {
+      const index = nextIndex++;
+      if (index >= items.length)
+        return;
+      await mapper(items[index]);
+    }
+  };
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+}