@mh-gg/host 0.1.1-alpha.20260626T104441232Z

package/src/hostClients/frontendChunkRequests.cjs

@@ -0,0 +1,124 @@
+const fs = require("node:fs");
+const { PROTOCOL } = require("@mh-gg/host-config");
+const { sendToClient } = require("@mh-gg/host-ipc");
+const { frontendChunkLength } = require("./frontendChunkSizing.cjs");
+const { frontendManifestFile } = require("./frontendManifestFiles.cjs");
+const { frontendBundleFile: findFrontendBundleFile } = require("./frontendSelection.cjs");
+const { nowMs } = require("./frontendTransferMetrics.cjs");
+
+function readFrontendChunk(file, offset, byteLength) {
+  const buffer = byteLength > 0 ? Buffer.allocUnsafe(byteLength) : Buffer.alloc(0);
+  if (byteLength <= 0) return buffer;
+  const fd = fs.openSync(file, "r");
+  try {
+    fs.readSync(fd, buffer, 0, byteLength, offset);
+  } finally {
+    fs.closeSync(fd);
+  }
+  return buffer;
+}
+
+function dynamicBundleSnapshot(frontendBundle, message) {
+  if (message.path || typeof message.integrity !== "string") return undefined;
+  const snapshot = frontendBundle?.dynamicBundleSnapshots?.get(message.integrity);
+  if (!snapshot) return undefined;
+  if (message.frontendId && snapshot.id !== message.frontendId) return undefined;
+  return snapshot;
+}
+
+function readSnapshotChunk(snapshot, offset, byteLength) {
+  if (byteLength <= 0) return Buffer.alloc(0);
+  return snapshot.buffer.subarray(offset, offset + byteLength);
+}
+
+function frontendChunkResponse({ data, frontend, message, offset, byteLength, totalBytes, store }) {
+  return {
+    type: "host/frontend-chunk",
+    protocol: PROTOCOL,
+    roomName: store.roomName,
+    frontendId: frontend.id,
+    integrity: frontend.integrity,
+    ...(message.path ? { path: message.path } : {}),
+    offset,
+    byteLength,
+    totalBytes,
+    encoding: "base64",
+    data,
+    done: offset + byteLength >= totalBytes
+  };
+}
+
+function createFrontendChunkRequestHandler({ chunkProgress, frontendBundle, frontendForRequest, frontendTransferMetrics, rejectRoomMismatch, sendFrontendUnavailable, store }) {
+  return function handleFrontendChunkRequest(socket, peerId, message) {
+    const startedAt = nowMs();
+    if (message.protocol !== PROTOCOL || message.roomName !== store.roomName) {
+      rejectRoomMismatch(socket, peerId, false);
+      return;
+    }
+    const lookupStartedAt = nowMs();
+    const snapshot = dynamicBundleSnapshot(frontendBundle, message);
+    const frontend = snapshot
+      ? { id: snapshot.id, integrity: snapshot.integrity, byteLength: snapshot.byteLength, chunkSize: snapshot.chunkSize, name: snapshot.name }
+      : frontendForRequest(message, { refreshDynamic: false });
+    const lookupMs = nowMs() - lookupStartedAt;
+    if (!frontend) {
+      sendFrontendUnavailable(socket, peerId);
+      return;
+    }
+
+    let statMs = 0;
+    let totalBytes;
+    let buffer;
+    const offset = message.offset || 0;
+    if (snapshot) {
+      totalBytes = snapshot.byteLength;
+      const byteLength = frontendChunkLength({ requestedLength: message.length, frontendChunkSize: frontend.chunkSize, remainingBytes: totalBytes - offset });
+      const readStartedAt = nowMs();
+      buffer = readSnapshotChunk(snapshot, offset, byteLength);
+      const readMs = nowMs() - readStartedAt;
+      const encodeStartedAt = nowMs();
+      const data = buffer.toString("base64");
+      const encodeMs = nowMs() - encodeStartedAt;
+      const sendStartedAt = nowMs();
+      sendToClient(socket, peerId, frontendChunkResponse({ data, frontend, message, offset, byteLength, totalBytes, store }));
+      const transferMetric = frontendTransferMetrics.record({
+        peerId, frontend, message, offset, byteLength, totalBytes, lookupMs, statMs, readMs,
+        encodeMs, sendMs: nowMs() - sendStartedAt, handlerMs: nowMs() - startedAt
+      });
+      chunkProgress.update({ completed: transferMetric.completed, total: totalBytes, currentItem: frontend.name || frontend.id });
+      if (transferMetric.complete) chunkProgress.stop();
+      return;
+    }
+
+    const file = frontendManifestFile({ frontend, frontendBundle, bundleFile: findFrontendBundleFile(frontend, frontendBundle), filePath: message.path });
+    if (!file || !fs.existsSync(file)) {
+      sendFrontendUnavailable(socket, peerId);
+      return;
+    }
+    const statStartedAt = nowMs();
+    const stat = fs.statSync(file);
+    statMs = nowMs() - statStartedAt;
+    totalBytes = stat.size;
+    const byteLength = frontendChunkLength({ requestedLength: message.length, frontendChunkSize: frontend.chunkSize, remainingBytes: totalBytes - offset });
+    const readStartedAt = nowMs();
+    buffer = readFrontendChunk(file, offset, byteLength);
+    const readMs = nowMs() - readStartedAt;
+    const encodeStartedAt = nowMs();
+    const data = buffer.toString("base64");
+    const encodeMs = nowMs() - encodeStartedAt;
+    const sendStartedAt = nowMs();
+    sendToClient(socket, peerId, frontendChunkResponse({ data, frontend, message, offset, byteLength, totalBytes, store }));
+    const transferMetric = frontendTransferMetrics.record({
+      peerId, frontend, message, offset, byteLength, totalBytes, lookupMs, statMs, readMs,
+      encodeMs, sendMs: nowMs() - sendStartedAt, handlerMs: nowMs() - startedAt
+    });
+    chunkProgress.update({ completed: transferMetric.completed, total: totalBytes, currentItem: frontend.name || frontend.id });
+    if (transferMetric.complete) chunkProgress.stop();
+  };
+}
+
+module.exports = {
+  createFrontendChunkRequestHandler,
+  frontendChunkResponse,
+  readFrontendChunk
+};

package/src/hostClients/frontendChunkSizing.cjs

@@ -0,0 +1,14 @@
+const { DEFAULT_FRONTEND_CHUNK_BYTES } = require("./constants.cjs");
+
+const DEFAULT_FRONTEND_BULK_CHUNK_BYTES = 128 * 1024;
+
+function frontendChunkLength({ requestedLength, frontendChunkSize, remainingBytes }) {
+  const requested = requestedLength || frontendChunkSize || DEFAULT_FRONTEND_CHUNK_BYTES;
+  const maxLength = frontendChunkSize || DEFAULT_FRONTEND_BULK_CHUNK_BYTES;
+  return Math.max(0, Math.min(Math.max(1, requested), maxLength, remainingBytes));
+}
+
+module.exports = {
+  DEFAULT_FRONTEND_BULK_CHUNK_BYTES,
+  frontendChunkLength
+};

package/src/hostClients/frontendManifestFiles.cjs

@@ -0,0 +1,17 @@
+const path = require("node:path");
+
+function frontendManifestFile({ frontend, frontendBundle, bundleFile, filePath }) {
+  if (!filePath) return bundleFile;
+  const manifest = frontend.manifest || frontendBundle?.manifest;
+  const files = Array.isArray(manifest?.files) ? manifest.files : [];
+  if (!files.some((candidate) => candidate?.path === filePath)) return undefined;
+  const base = path.dirname(bundleFile || frontendBundle?.manifestFile || "");
+  if (!base) return undefined;
+  const file = path.resolve(base, filePath);
+  if (file !== base && !file.startsWith(base + path.sep)) return undefined;
+  return file;
+}
+
+module.exports = {
+  frontendManifestFile
+};

package/src/hostClients/frontendRequests.cjs

@@ -0,0 +1,116 @@
+const { PROTOCOL } = require("@mh-gg/host-config");
+const { sendToClient } = require("@mh-gg/host-ipc");
+const { frontendCacheStatus, logFrontendCacheStatus } = require("./frontendCacheStatus.cjs");
+const { createDynamicFrontendRefresher } = require("./frontendBundleRefresh.cjs");
+const { frontendBundleFile: findFrontendBundleFile, frontendForMessage } = require("./frontendSelection.cjs");
+const { createFrontendTransferMetrics } = require("./frontendTransferMetrics.cjs");
+const { sendFrontendUnavailable } = require("./frontendUnavailable.cjs");
+const { createInlineProgressLoader } = require("../inlineProgressBar.cjs");
+const { createFrontendChunkRequestHandler } = require("./frontendChunkRequests.cjs");
+
+function ensureValidProtocolAndRoom(store, socket, peerId, message, rejectRoomMismatch) {
+  if (message.protocol !== PROTOCOL || message.roomName !== store.roomName) {
+    rejectRoomMismatch(socket, peerId, false);
+    return false;
+  }
+  return true;
+}
+
+function resolveFrontendForManifestResponse(store, frontendForRequest, message, dynamicFrontend) {
+  const refresh = message?.protocol === PROTOCOL;
+  if (refresh && message) dynamicFrontend.refreshDynamicFrontends();
+  return frontendForRequest(message, { refreshDynamic: refresh });
+}
+
+function createRoomInfoResponsePayload(store, cache, message, frontend) {
+  const response = {
+    type: "room.info",
+    protocol: PROTOCOL,
+    roomName: store.roomName,
+    runtimeMode: store.runtimeMode,
+    roomMetadata: store.roomMetadata,
+    roomApp: store.roomApp
+  };
+  if (message.clientId) response.clientId = message.clientId;
+  if (cache) response.frontendCache = cache;
+  return response;
+}
+
+function createFrontendRequestHandlers({ store, frontendBundle, logger = console, rejectRoomMismatch, onRoomAppChange = () => {}, frontendProgress, progressStream }) {
+  const dynamicFrontend = createDynamicFrontendRefresher({ store, frontendBundle, onRoomAppChange });
+  const chunkProgress = frontendProgress || createInlineProgressLoader("Loading frontend chunks...", {
+    stream: progressStream,
+    width: 32
+  });
+
+  function debug(message, details) {
+    if (process.env.MATTERHORN_DEBUG !== "1") return;
+    const line = `matterhorn host debug: ${message} ${JSON.stringify(details)}`;
+    if (process.stderr?.write) process.stderr.write(`\n${line}\n`);
+    else logger.error ? logger.error(line) : logger.log(line);
+  }
+
+  const frontendTransferMetrics = createFrontendTransferMetrics({ store, debug });
+
+  function frontendForRequest(message, options = {}) {
+    if (options.refreshDynamic !== false) dynamicFrontend.refreshDynamicFrontends();
+    const frontends = Array.isArray(store.roomApp?.frontends) ? store.roomApp.frontends : [];
+    return frontendForMessage(frontends, message);
+  }
+
+  function handleFrontendManifestRequest(socket, peerId, message) {
+    if (!ensureValidProtocolAndRoom(store, socket, peerId, message, rejectRoomMismatch)) return;
+    const frontend = resolveFrontendForManifestResponse(store, frontendForRequest, message, dynamicFrontend);
+    if (!frontend) {
+      sendFrontendUnavailable(socket, peerId);
+      return;
+    }
+    const cache = frontendCacheStatus(frontend, message);
+    logFrontendCacheStatus({ debug, store, source: "manifest", peerId, frontend, cache });
+    sendToClient(socket, peerId, {
+      type: "host/frontend-manifest",
+      protocol: PROTOCOL,
+      roomName: store.roomName,
+      frontend,
+      frontendCache: cache,
+      frontends: store.roomApp?.frontends || []
+    });
+  }
+
+  function handleRoomInfoRequest(socket, peerId, message) {
+    if (!ensureValidProtocolAndRoom(store, socket, peerId, message, rejectRoomMismatch)) return;
+    dynamicFrontend.refreshDynamicFrontends();
+    if (!store.roomApp) {
+      sendFrontendUnavailable(socket, peerId, "Room app information is not available from this host.");
+      return;
+    }
+    const frontend = Array.isArray(store.roomApp.frontends) ? store.roomApp.frontends[0] : undefined;
+    const cache = frontend ? frontendCacheStatus(frontend, message) : undefined;
+    if (frontend && cache) logFrontendCacheStatus({ debug, store, source: "room.info", peerId, frontend, cache });
+    const response = createRoomInfoResponsePayload(store, cache, message, frontend);
+    sendToClient(socket, peerId, response);
+  }
+
+  const handleFrontendChunkRequest = createFrontendChunkRequestHandler({
+    chunkProgress,
+    frontendBundle,
+    frontendForRequest,
+    frontendTransferMetrics,
+    rejectRoomMismatch,
+    sendFrontendUnavailable,
+    store
+  });
+
+  return {
+    frontendBundleFile: (frontend) => findFrontendBundleFile(frontend, frontendBundle),
+    frontendForRequest,
+    handleFrontendChunkRequest,
+    handleFrontendManifestRequest,
+    handleRoomInfoRequest,
+    sendFrontendUnavailable
+  };
+}
+
+module.exports = {
+  createFrontendRequestHandlers
+};

package/src/hostClients/frontendSelection.cjs

@@ -0,0 +1,21 @@
+function frontendForMessage(frontends, message) {
+  if (message.frontendId && message.integrity) {
+    return frontends.find((frontend) => frontend.id === message.frontendId && frontend.integrity === message.integrity)
+      || frontends.find((frontend) => frontend.integrity === message.integrity);
+  }
+  if (message.frontendId) return frontends.find((frontend) => frontend.id === message.frontendId);
+  if (message.integrity) return frontends.find((frontend) => frontend.integrity === message.integrity);
+  return frontends[0];
+}
+
+function frontendBundleFile(frontend, frontendBundle) {
+  if (!frontendBundle?.file) return undefined;
+  if (frontendBundle.id && frontendBundle.id !== frontend.id) return undefined;
+  if (!frontendBundle.dynamic && frontendBundle.integrity && frontendBundle.integrity !== frontend.integrity) return undefined;
+  return frontendBundle.file;
+}
+
+module.exports = {
+  frontendBundleFile,
+  frontendForMessage
+};

package/src/hostClients/frontendTransferMetrics.cjs

@@ -0,0 +1,111 @@
+const { performance } = require("node:perf_hooks");
+
+const FRONTEND_TRANSFER_METRIC_INTERVAL_MS = 2000;
+
+function nowMs() {
+  return performance.now();
+}
+
+function roundMs(value) {
+  return Number(value.toFixed(2));
+}
+
+function rateMiBps(bytes, elapsedMs) {
+  if (!Number.isFinite(elapsedMs) || elapsedMs <= 0) return 0;
+  return Number(((bytes / 1024 / 1024) / (elapsedMs / 1000)).toFixed(2));
+}
+
+function averageMs(total, count) {
+  if (!count) return 0;
+  return Number((total / count).toFixed(2));
+}
+
+function percentServed(bytes, total) {
+  if (!Number.isFinite(total) || total <= 0) return 100;
+  return Number(((Math.min(bytes, total) / total) * 100).toFixed(1));
+}
+
+function createFrontendTransferMetrics({ store, debug }) {
+  const frontendTransfers = new Map();
+
+  function transferKey(peerId, frontend, message) {
+    return [peerId, frontend.id, frontend.integrity, message.path || ""].join("\0");
+  }
+
+  function record(details) {
+    const key = transferKey(details.peerId, details.frontend, details.message);
+    const now = nowMs();
+    let transfer = frontendTransfers.get(key);
+    if (!transfer) {
+      transfer = {
+        startedAt: now,
+        lastLogAt: now,
+        responses: 0,
+        uniqueBytes: 0,
+        completedBytes: 0,
+        seenOffsets: new Set(),
+        lookupMs: 0,
+        statMs: 0,
+        readMs: 0,
+        encodeMs: 0,
+        sendMs: 0,
+        handlerMs: 0
+      };
+      frontendTransfers.set(key, transfer);
+    }
+
+    transfer.responses += 1;
+    if (!transfer.seenOffsets.has(details.offset)) {
+      transfer.seenOffsets.add(details.offset);
+      transfer.uniqueBytes += details.byteLength;
+    }
+    transfer.completedBytes = Math.max(transfer.completedBytes, details.offset + details.byteLength);
+    transfer.lookupMs += details.lookupMs;
+    transfer.statMs += details.statMs;
+    transfer.readMs += details.readMs;
+    transfer.encodeMs += details.encodeMs;
+    transfer.sendMs += details.sendMs;
+    transfer.handlerMs += details.handlerMs;
+
+    const elapsedMs = Math.max(1, now - transfer.startedAt);
+    const complete = transfer.completedBytes >= details.totalBytes;
+    const shouldLog = complete || now - transfer.lastLogAt >= FRONTEND_TRANSFER_METRIC_INTERVAL_MS;
+    if (!shouldLog) return { completed: transfer.completedBytes, complete };
+
+    transfer.lastLogAt = now;
+    debug("frontend transfer metrics", {
+      peerId: details.peerId,
+      roomName: store.roomName,
+      frontendId: details.frontend.id,
+      path: details.message.path,
+      totalBytes: details.totalBytes,
+      servedBytes: transfer.uniqueBytes,
+      remainingBytes: Math.max(0, details.totalBytes - transfer.completedBytes),
+      completedBytes: transfer.completedBytes,
+      percentServed: percentServed(transfer.uniqueBytes, details.totalBytes),
+      chunks: transfer.seenOffsets.size,
+      responses: transfer.responses,
+      retries: transfer.responses - transfer.seenOffsets.size,
+      avgChunkBytes: Math.round(transfer.uniqueBytes / transfer.seenOffsets.size),
+      elapsedMs: roundMs(elapsedMs),
+      throughputMiBps: rateMiBps(transfer.uniqueBytes, elapsedMs),
+      lastOffset: details.offset,
+      lastChunkBytes: details.byteLength,
+      lastHandlerMs: details.handlerMs,
+      avgHandlerMs: averageMs(transfer.handlerMs, transfer.responses),
+      avgReadMs: averageMs(transfer.readMs, transfer.responses),
+      avgEncodeMs: averageMs(transfer.encodeMs, transfer.responses),
+      avgSendEnqueueMs: averageMs(transfer.sendMs, transfer.responses),
+      complete
+    });
+    if (complete) frontendTransfers.delete(key);
+    return { completed: transfer.completedBytes, complete };
+  }
+
+  return { record };
+}
+
+module.exports = {
+  createFrontendTransferMetrics,
+  nowMs
+};

package/src/hostClients/frontendUnavailable.cjs

@@ -0,0 +1,15 @@
+const { PROTOCOL } = require("@mh-gg/host-config");
+const { sendToClient } = require("@mh-gg/host-ipc");
+
+function sendFrontendUnavailable(socket, peerId, message = "The room frontend bundle is not available from this host.") {
+  sendToClient(socket, peerId, {
+    type: "host/error",
+    protocol: PROTOCOL,
+    code: "frontend-unavailable",
+    message
+  });
+}
+
+module.exports = {
+  sendFrontendUnavailable
+};

package/src/hostClients/index.cjs

@@ -0,0 +1,68 @@
+const { validateClientMessage } = require("@mh-gg/relay");
+const { createFrontendRequestHandlers } = require("./frontendRequests.cjs");
+const { rejectInvalidMessage, rejectRoomMismatch } = require("./rejections.cjs");
+
+function createHostClients(options) {
+  const {
+    store,
+    logger = console,
+    frontendBundle,
+    frontendProgress,
+    onStoreChange = () => {}
+  } = options;
+  const connectionRoles = new Map();
+  const pendingJoinConnections = new Map();
+  const frontend = createFrontendRequestHandlers({ store, frontendBundle, frontendProgress, logger, rejectRoomMismatch, onRoomAppChange: onStoreChange });
+
+  function debug(message, ...args) {
+    if (process.env.MATTERHORN_DEBUG === "1") logger.log(message, ...args);
+  }
+
+  function messageDebugSummary(peerId, message) {
+    const keys = message && typeof message === "object" && !Array.isArray(message) ? Object.keys(message).sort() : [];
+    return {
+      peerId,
+      type: message?.type,
+      roomName: message?.roomName,
+      clientId: message?.clientId,
+      keys
+    };
+  }
+
+  function handleClientMessage(socket, peerId, message) {
+    const validation = validateClientMessage(message);
+    if (!validation.ok) {
+      debug("Invalid client message", validation.message, messageDebugSummary(peerId, message));
+      rejectInvalidMessage(socket, peerId, validation);
+      return;
+    }
+    if (message.type === "client/frontend-manifest") {
+      frontend.handleFrontendManifestRequest(socket, peerId, message);
+      return;
+    }
+    if (message.type === "client/frontend-chunk") {
+      frontend.handleFrontendChunkRequest(socket, peerId, message);
+      return;
+    }
+    if (message.type === "client/room-info") {
+      frontend.handleRoomInfoRequest(socket, peerId, message);
+      return;
+    }
+    debug("Unsupported host client message", messageDebugSummary(peerId, message));
+  }
+
+  function removeConnection(peerId) {
+    connectionRoles.delete(peerId);
+  }
+
+  return {
+    connectionRoles,
+    handleClientMessage,
+    pendingJoinConnections,
+    removeConnection
+  };
+}
+
+module.exports = {
+  createHostClients
+};

package/src/hostClients/rejections.cjs

@@ -0,0 +1,37 @@
+const { PROTOCOL } = require("@mh-gg/host-config");
+const { closeClient, sendToClient } = require("@mh-gg/host-ipc");
+
+function rejectRoomMismatch(socket, peerId, closeConnection) {
+  sendToClient(socket, peerId, {
+    type: "host/error",
+    protocol: PROTOCOL,
+    code: "room-mismatch",
+    message: "Wrong room or protocol."
+  });
+  if (closeConnection) closeClient(socket, peerId);
+}
+
+function rejectInvalidMessage(socket, peerId, validation) {
+  sendToClient(socket, peerId, {
+    type: "host/error",
+    protocol: PROTOCOL,
+    code: validation.code,
+    message: validation.message
+  });
+}
+
+function sendHostError(socket, peerId, code, message, extra = {}) {
+  sendToClient(socket, peerId, {
+    type: "host/error",
+    protocol: PROTOCOL,
+    code,
+    message,
+    ...extra
+  });
+}
+
+module.exports = {
+  rejectInvalidMessage,
+  rejectRoomMismatch,
+  sendHostError
+};

package/src/hostClients/sourceMtime.cjs

@@ -0,0 +1,68 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function isIgnoredSourcePath(candidate, ignoredRoots) {
+  const base = path.basename(candidate);
+  if (base === "node_modules" || base === ".git") return true;
+  const resolved = path.resolve(candidate);
+  return ignoredRoots.some((ignoredRoot) => {
+    const relative = path.relative(ignoredRoot, resolved);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+  });
+}
+
+function directSourceMtime(root, ignoredRoots) {
+  const stat = fs.existsSync(root) ? fs.statSync(root) : undefined;
+  if (!stat?.isFile()) return undefined;
+  return isIgnoredSourcePath(root, ignoredRoots) ? 0 : stat.mtimeMs;
+}
+
+function entrySourceMtime(entryPath, entry, pending, ignoredRoots) {
+  if (isIgnoredSourcePath(entryPath, ignoredRoots)) return 0;
+  if (entry.isDirectory()) {
+    pending.push(entryPath);
+    return 0;
+  }
+  if (!entry.isFile()) return 0;
+  try {
+    return fs.statSync(entryPath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function listDirectoryEntries(directory) {
+  try {
+    return fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function collectMtimeFromEntries(current, entries, pending, ignoredRoots) {
+  let latest = 0;
+  for (const entry of entries) {
+    const entryPath = path.join(current, entry.name);
+    latest = Math.max(latest, entrySourceMtime(entryPath, entry, pending, ignoredRoots));
+  }
+  return latest;
+}
+
+function latestSourceMtime(root, ignoredRoots) {
+  const directMtime = directSourceMtime(root, ignoredRoots);
+  if (directMtime !== undefined) return directMtime;
+  let latest = 0;
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || isIgnoredSourcePath(current, ignoredRoots)) continue;
+    latest = Math.max(latest, collectMtimeFromEntries(current, listDirectoryEntries(current), pending, ignoredRoots));
+  }
+  return latest;
+}
+
+function latestSourceRootsMtime(roots, ignoredRoots) {
+  return roots.reduce((latest, root) => Math.max(latest, latestSourceMtime(root, ignoredRoots)), 0);
+}
+
+module.exports = { latestSourceRootsMtime };