@yetanotheraryan/coldstart 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aryan Tiwari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-7HD2T2AD.mjs

@@ -0,0 +1,261 @@
+// src/tracer.ts
+import { monitorEventLoopDelay } from "perf_hooks";
+var Tracer = class {
+  events = [];
+  startTime = performance.now();
+  histogram = null;
+  constructor() {
+    try {
+      this.histogram = monitorEventLoopDelay({ resolution: 5 });
+      this.histogram.enable();
+    } catch {
+      this.histogram = null;
+    }
+  }
+  /**
+   * Called by cjs.ts for every require() interception.
+   * Appends to the flat event list — tree is built lazily on report().
+   */
+  record(event) {
+    this.events.push(event);
+  }
+  /**
+   * Mark startup as complete and return the full report.
+   * Call this after your server/app signals it's ready.
+   */
+  report() {
+    const totalStartupMs = performance.now() - this.startTime;
+    if (this.histogram) {
+      this.histogram.disable();
+    }
+    const tree = this.buildTree();
+    const flat = this.flatten(tree).sort((a, b) => b.inclusiveMs - a.inclusiveMs);
+    const slowest = [...flat].filter((n) => !n.cached && !n.isBuiltin).sort((a, b) => b.exclusiveMs - a.exclusiveMs).slice(0, 10);
+    const nodeModuleTime = flat.filter((n) => n.isNodeModule && !n.cached).reduce((sum, n) => sum + n.exclusiveMs, 0);
+    const firstPartyTime = flat.filter((n) => !n.isNodeModule && !n.isBuiltin && !n.cached).reduce((sum, n) => sum + n.exclusiveMs, 0);
+    return {
+      totalStartupMs,
+      eventLoop: {
+        maxBlockMs: this.histogram ? this.histogram.max / 1e6 : 0,
+        meanBlockMs: this.histogram ? this.histogram.mean / 1e6 : 0,
+        p99BlockMs: this.histogram ? this.histogram.percentile(99) / 1e6 : 0
+      },
+      tree,
+      flat,
+      slowest,
+      nodeModuleTime,
+      firstPartyTime,
+      totalModulesLoaded: this.events.length,
+      cachedModulesCount: this.events.filter((e) => e.cached).length
+    };
+  }
+  /**
+   * Build the parent→child tree from the flat event list.
+   *
+   * Strategy:
+   * 1. Create a ModuleNode for each event
+   * 2. Wire children to parents using parentPath
+   * 3. Compute exclusive time = inclusive - sum(children inclusive)
+   * 4. Assign depth via BFS from roots
+   */
+  buildTree() {
+    const nodes = this.events.map((e) => ({
+      id: e.id,
+      request: e.request,
+      resolvedPath: e.resolvedPath,
+      parentPath: e.parentPath,
+      inclusiveMs: e.durationMs,
+      exclusiveMs: e.durationMs,
+      // will be adjusted below
+      cached: e.cached,
+      isNodeModule: e.isNodeModule,
+      isBuiltin: e.isBuiltin,
+      children: [],
+      depth: 0
+    }));
+    const byPath = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const existing = byPath.get(node.resolvedPath) ?? [];
+      existing.push(node);
+      byPath.set(node.resolvedPath, existing);
+    }
+    const roots = [];
+    for (const node of nodes) {
+      if (node.parentPath === "<entry>") {
+        roots.push(node);
+        continue;
+      }
+      const parentNodes = byPath.get(node.parentPath);
+      if (parentNodes && parentNodes.length > 0) {
+        parentNodes[parentNodes.length - 1].children.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+    const computeExclusive = (node) => {
+      for (const child of node.children) {
+        computeExclusive(child);
+      }
+      const childrenInclusiveSum = node.children.reduce(
+        (sum, c) => sum + c.inclusiveMs,
+        0
+      );
+      node.exclusiveMs = Math.max(0, node.inclusiveMs - childrenInclusiveSum);
+    };
+    for (const root of roots) {
+      computeExclusive(root);
+    }
+    const assignDepth = (node, depth) => {
+      node.depth = depth;
+      for (const child of node.children) {
+        assignDepth(child, depth + 1);
+      }
+    };
+    for (const root of roots) {
+      assignDepth(root, 0);
+    }
+    return roots;
+  }
+  /**
+   * Flatten the tree into a list (pre-order DFS).
+   */
+  flatten(nodes) {
+    const result = [];
+    const visit = (node) => {
+      result.push(node);
+      for (const child of node.children) {
+        visit(child);
+      }
+    };
+    for (const node of nodes) {
+      visit(node);
+    }
+    return result;
+  }
+  /**
+   * Reset — useful for testing multiple startups in the same process.
+   */
+  reset() {
+    this.events = [];
+    this.startTime = performance.now();
+    if (this.histogram) {
+      this.histogram.reset();
+      this.histogram.enable();
+    }
+  }
+  /** Expose raw events for testing */
+  getRawEvents() {
+    return [...this.events];
+  }
+};
+var tracer = new Tracer();
+
+// src/cjs.ts
+import { Module } from "module";
+var originalLoad = Module._load;
+var callStack = [];
+Module._load = function coldstartLoad(request, parent, isMain) {
+  let resolvedFilename;
+  try {
+    resolvedFilename = Module._resolveFilename(request, parent, isMain);
+  } catch {
+    return originalLoad.apply(this, arguments);
+  }
+  const isCached = !!Module._cache[resolvedFilename];
+  const isBuiltin = Module.isBuiltin?.(request) ?? isBuiltinModule(request);
+  const parentFilename = callStack.length > 0 ? callStack[callStack.length - 1] : parent?.filename ?? "<entry>";
+  callStack.push(resolvedFilename);
+  const startTime = performance.now();
+  let result;
+  try {
+    result = originalLoad.apply(this, arguments);
+  } finally {
+    callStack.pop();
+    if (!isBuiltin) {
+      const duration = performance.now() - startTime;
+      tracer.record({
+        id: resolvedFilename,
+        request,
+        // original string passed to require()
+        resolvedPath: resolvedFilename,
+        parentPath: parentFilename,
+        durationMs: duration,
+        startTime,
+        cached: isCached,
+        isNodeModule: resolvedFilename.includes("node_modules"),
+        isBuiltin: false
+      });
+    }
+  }
+  return result;
+};
+var originalResolveFilename = Module._resolveFilename;
+Module._resolveFilename = function coldstartResolve(request, parent, isMain, options) {
+  if (Module.isBuiltin?.(request) ?? isBuiltinModule(request)) {
+    const parentFilename = callStack.length > 0 ? callStack[callStack.length - 1] : parent?.filename ?? "<entry>";
+    tracer.record({
+      id: `builtin:${request}`,
+      request,
+      resolvedPath: `builtin:${request}`,
+      parentPath: parentFilename,
+      durationMs: 0,
+      startTime: performance.now(),
+      cached: true,
+      isNodeModule: false,
+      isBuiltin: true
+    });
+  }
+  return originalResolveFilename.apply(this, arguments);
+};
+function isBuiltinModule(name) {
+  const builtins = /* @__PURE__ */ new Set([
+    "assert",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "module",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "repl",
+    "stream",
+    "string_decoder",
+    "sys",
+    "timers",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib"
+  ]);
+  const stripped = name.startsWith("node:") ? name.slice(5) : name;
+  return builtins.has(stripped);
+}
+
+export {
+  tracer
+};

package/dist/chunk-B5TADGOF.mjs

@@ -0,0 +1,12 @@
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
+
+export {
+  __dirname,
+  __filename
+};

package/dist/chunk-IGYROJNQ.mjs

@@ -0,0 +1,170 @@
+// src/reporter/text.ts
+var BAR_WIDTH = 18;
+var ANSI_RESET = "\x1B[0m";
+var ANSI_RED = "\x1B[31m";
+var ANSI_YELLOW = "\x1B[33m";
+var ANSI_GREEN = "\x1B[32m";
+var ANSI_DIM = "\x1B[2m";
+function renderTextReport(report, options = {}) {
+  const color = options.color ?? true;
+  const barWidth = options.barWidth ?? BAR_WIDTH;
+  const showSummary = options.showSummary ?? true;
+  const displayTree = collapseDisplayNoise(report.tree);
+  const maxInclusiveMs = Math.max(
+    1,
+    ...report.flat.filter((node) => !node.cached).map((node) => node.inclusiveMs)
+  );
+  const lines = [
+    `coldstart - ${formatDuration(report.totalStartupMs)} total startup`,
+    ""
+  ];
+  for (let index = 0; index < displayTree.length; index += 1) {
+    const isLastRoot = index === displayTree.length - 1;
+    const root = displayTree[index];
+    lines.push(...renderNode(root, "", isLastRoot, maxInclusiveMs, barWidth, color));
+  }
+  if (showSummary) {
+    if (displayTree.length > 0) {
+      lines.push("");
+    }
+    lines.push(
+      `${dim("event loop")} max ${formatDuration(report.eventLoop.maxBlockMs)}, p99 ${formatDuration(report.eventLoop.p99BlockMs)}, mean ${formatDuration(report.eventLoop.meanBlockMs)}`,
+      `${dim("modules")} ${report.totalModulesLoaded} total, ${report.cachedModulesCount} cached`,
+      `${dim("time split")} ${formatDuration(report.firstPartyTime)} first-party, ${formatDuration(report.nodeModuleTime)} node_modules`
+    );
+  }
+  return lines.join("\n");
+  function dim(value) {
+    return colorize(value, ANSI_DIM, color);
+  }
+}
+function collapseDisplayNoise(nodes) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const collapsedChildren = collapseDisplayNoise(node.children);
+    const collapsedNode = {
+      ...node,
+      children: collapsedChildren
+    };
+    if (shouldCollapseBuiltinNode(collapsedNode)) {
+      const key = [
+        collapsedNode.request,
+        collapsedNode.depth
+      ].join("|");
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+    }
+    result.push(collapsedNode);
+  }
+  return result;
+}
+function shouldCollapseBuiltinNode(node) {
+  return node.isBuiltin && node.cached && node.inclusiveMs === 0 && node.children.length === 0;
+}
+function renderNode(node, prefix, isLast, maxInclusiveMs, barWidth, color) {
+  const branch = prefix.length === 0 ? isLast ? "\u2514\u2500 " : "\u250C\u2500 " : `${prefix}${isLast ? "\u2514\u2500 " : "\u251C\u2500 "}`;
+  const nextPrefix = prefix.length === 0 ? isLast ? "   " : "\u2502  " : `${prefix}${isLast ? "   " : "\u2502  "}`;
+  const label = formatLabel(node);
+  const duration = formatDuration(node.inclusiveMs).padStart(6);
+  const durationColor = getDurationColor(node.inclusiveMs);
+  const bar = renderBar(node.inclusiveMs, maxInclusiveMs, barWidth);
+  const suffix = node.inclusiveMs >= 100 ? `  ${colorize("! slow", ANSI_RED, color)}` : "";
+  const line = `${branch}${label.padEnd(18)} ${colorize(duration, durationColor, color)}  ${colorize(bar, durationColor, color)}${suffix}`;
+  const lines = [line];
+  for (let index = 0; index < node.children.length; index += 1) {
+    const child = node.children[index];
+    const isLastChild = index === node.children.length - 1;
+    lines.push(...renderNode(child, nextPrefix, isLastChild, maxInclusiveMs, barWidth, color));
+  }
+  return lines;
+}
+function formatLabel(node) {
+  if (node.isBuiltin) {
+    return node.request.replace(/^node:/, "");
+  }
+  if (node.isNodeModule) {
+    return packageNameFromRequest(node.request);
+  }
+  const normalizedPath = normalizeModulePath(node);
+  const segments = normalizedPath.split("/");
+  const base = segments[segments.length - 1] ?? "";
+  return base.length > 0 ? base : node.request;
+}
+function normalizeModulePath(node) {
+  if (looksLikeRelativeRequest(node.request)) {
+    return node.request.replace(/\\/g, "/");
+  }
+  if (node.resolvedPath.startsWith("file://")) {
+    try {
+      return decodeURIComponent(new URL(node.resolvedPath).pathname).replace(/\\/g, "/");
+    } catch {
+      return node.resolvedPath.replace(/\\/g, "/");
+    }
+  }
+  return node.resolvedPath.replace(/\\/g, "/");
+}
+function looksLikeRelativeRequest(request) {
+  return request.startsWith("./") || request.startsWith("../") || request.startsWith("/");
+}
+function packageNameFromRequest(request) {
+  if (request.startsWith("@")) {
+    const [scope, name2] = request.split("/");
+    return name2 ? `${scope}/${name2}` : request;
+  }
+  const [name] = request.split("/");
+  return name || request;
+}
+function renderBar(durationMs, maxInclusiveMs, barWidth) {
+  const filled = Math.max(1, Math.round(durationMs / maxInclusiveMs * barWidth));
+  return `${"\u2588".repeat(Math.min(barWidth, filled))}${"\u2591".repeat(Math.max(0, barWidth - filled))}`;
+}
+function formatDuration(valueMs) {
+  if (!Number.isFinite(valueMs)) {
+    return "0ms";
+  }
+  if (valueMs >= 1e3) {
+    return `${Math.round(valueMs)}ms`;
+  }
+  if (valueMs >= 100) {
+    return `${Math.round(valueMs)}ms`;
+  }
+  if (valueMs >= 10) {
+    return `${valueMs.toFixed(1).replace(/\.0$/, "")}ms`;
+  }
+  return `${valueMs.toFixed(2).replace(/0+$/, "").replace(/\.$/, "")}ms`;
+}
+function getDurationColor(durationMs) {
+  if (durationMs > 100) {
+    return ANSI_RED;
+  }
+  if (durationMs >= 20) {
+    return ANSI_YELLOW;
+  }
+  return ANSI_GREEN;
+}
+function colorize(value, code, enabled) {
+  if (!enabled) {
+    return value;
+  }
+  return `${code}${value}${ANSI_RESET}`;
+}
+
+// src/reporter/json.ts
+function renderJsonReport(report, options = {}) {
+  return `${JSON.stringify(report, jsonReplacer, options.pretty === false ? 0 : 2)}
+`;
+}
+function jsonReplacer(_key, value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return 0;
+  }
+  return value;
+}
+
+export {
+  renderTextReport,
+  renderJsonReport
+};

package/dist/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node