@absolutejs/absolute 0.20.0-beta.72 → 0.20.0-beta.73

package/dist/dev/importCostReport.js

@@ -0,0 +1,730 @@
+// @bun
+// src/dev/importCost/report.ts
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname as dirname2, relative } from "path";
+
+// src/dev/importCost/deferability.ts
+import ts from "typescript";
+var DEFERRED = "deferred";
+var scriptKindFor = (fileName) => {
+  if (fileName.endsWith(".tsx"))
+    return ts.ScriptKind.TSX;
+  if (fileName.endsWith(".jsx"))
+    return ts.ScriptKind.JSX;
+  if (fileName.endsWith(".js") || fileName.endsWith(".mjs")) {
+    return ts.ScriptKind.JS;
+  }
+  return ts.ScriptKind.TS;
+};
+var namedBindings = (clause) => {
+  const names = clause.name === undefined ? [] : [clause.name.text];
+  const { namedBindings: bindings } = clause;
+  if (bindings === undefined)
+    return names;
+  if (ts.isNamespaceImport(bindings))
+    return [...names, bindings.name.text];
+  return [
+    ...names,
+    ...bindings.elements.filter((element) => !element.isTypeOnly).map((element) => element.name.text)
+  ];
+};
+var declarationFrom = (statement, source) => {
+  const specifier = statement.moduleSpecifier;
+  if (!ts.isStringLiteral(specifier))
+    return null;
+  const clause = statement.importClause;
+  const bindings = clause === undefined ? [] : namedBindings(clause);
+  const declaration = {
+    bindings,
+    line: ts.getLineAndCharacterOfPosition(source, statement.getStart(source)).line + 1,
+    sideEffect: clause === undefined,
+    specifier: specifier.text,
+    typeOnly: clause !== undefined && (clause.isTypeOnly || bindings.length === 0)
+  };
+  return declaration;
+};
+var isTypePosition = (node) => ts.isTypeNode(node) && !ts.isExpressionWithTypeArguments(node);
+var isDeferredPosition = (current, child) => {
+  if (Reflect.get(current, "body") === child)
+    return true;
+  const parameters = Reflect.get(current, "parameters");
+  return Array.isArray(parameters) && parameters.some((parameter) => parameter === child);
+};
+var classifyAncestor = (current, child) => {
+  if (ts.isExportSpecifier(current))
+    return "re-exported by the entry";
+  if (ts.isDecorator(current))
+    return "decorator";
+  if (ts.isPropertyDeclaration(current) && current.initializer === child) {
+    return "class field initializer";
+  }
+  if (isTypePosition(current))
+    return DEFERRED;
+  if (ts.isFunctionLike(current) && isDeferredPosition(current, child)) {
+    return DEFERRED;
+  }
+  if (ts.isSourceFile(current))
+    return "module scope";
+  return null;
+};
+var classifyUsage = (node) => {
+  let child = node;
+  let current = node.parent;
+  let pending = null;
+  while (current !== undefined) {
+    const verdict = classifyAncestor(current, child);
+    if (verdict === DEFERRED)
+      return DEFERRED;
+    if (verdict !== null && pending === null)
+      pending = verdict;
+    child = current;
+    current = current.parent;
+  }
+  return pending ?? "module scope";
+};
+var isDeclarationName = (parent, node) => {
+  if (ts.isExportSpecifier(parent))
+    return false;
+  if (ts.isShorthandPropertyAssignment(parent))
+    return false;
+  return Reflect.get(parent, "name") === node;
+};
+var isReferencePosition = (node) => {
+  const { parent } = node;
+  if (parent === undefined)
+    return false;
+  if (ts.isQualifiedName(parent) && parent.right === node)
+    return false;
+  return !isDeclarationName(parent, node);
+};
+var recordUsage = (node, owners, reasons) => {
+  const owner = owners.get(node.text);
+  if (owner === undefined || reasons.has(owner))
+    return;
+  if (!isReferencePosition(node))
+    return;
+  const verdict = classifyUsage(node);
+  if (verdict !== DEFERRED)
+    reasons.set(owner, verdict);
+};
+var collectUnsafeReasons = (source, owners) => {
+  const reasons = new Map;
+  const visit = (node) => {
+    if (ts.isImportDeclaration(node))
+      return;
+    if (ts.isIdentifier(node))
+      recordUsage(node, owners, reasons);
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(source, visit);
+  return reasons;
+};
+var verdictFor = (declaration, reason) => {
+  if (declaration.sideEffect)
+    return "side-effect import";
+  if (declaration.typeOnly)
+    return "type-only";
+  if (reason !== undefined)
+    return "used at module scope";
+  return "deferrable";
+};
+var reExportOf = (statement, source) => {
+  const specifier = statement.moduleSpecifier;
+  if (specifier === undefined || !ts.isStringLiteral(specifier))
+    return null;
+  if (statement.isTypeOnly)
+    return null;
+  const entry = {
+    line: ts.getLineAndCharacterOfPosition(source, statement.getStart(source)).line + 1,
+    reason: "re-exported by the entry",
+    specifier: specifier.text,
+    verdict: "used at module scope"
+  };
+  return entry;
+};
+var analyzeEntryImports = (sourceText, fileName) => {
+  const source = ts.createSourceFile(fileName, sourceText, ts.ScriptTarget.ESNext, true, scriptKindFor(fileName));
+  const declarations = source.statements.filter(ts.isImportDeclaration).map((statement) => declarationFrom(statement, source)).filter((declaration) => declaration !== null);
+  const reExports = source.statements.filter(ts.isExportDeclaration).map((statement) => reExportOf(statement, source)).filter((entry) => entry !== null);
+  const owners = new Map;
+  declarations.forEach((declaration, index) => {
+    for (const binding of declaration.bindings)
+      owners.set(binding, index);
+  });
+  const reasons = collectUnsafeReasons(source, owners);
+  const imports = declarations.map((declaration, index) => {
+    const reason = reasons.get(index);
+    const verdict = verdictFor(declaration, reason);
+    const entry = {
+      line: declaration.line,
+      reason: verdict === "deferrable" ? null : reason ?? null,
+      specifier: declaration.specifier,
+      verdict
+    };
+    return entry;
+  });
+  return [...imports, ...reExports].sort((left, right) => left.line - right.line);
+};
+
+// src/dev/importCost/dominators.ts
+var NOT_FOUND = -1;
+var pushNeighbours = (targets, seen, stack, skip) => {
+  for (const target of targets) {
+    if (target === skip)
+      continue;
+    if (seen[target] === 1)
+      continue;
+    seen[target] = 1;
+    stack.push(target);
+  }
+};
+var dominatedByEdge = (edges, root, fromIndex, toIndex, reachable = reachableFrom(edges, root)) => {
+  const without = reachableFrom(edges, root, fromIndex, toIndex);
+  const dominated = [];
+  for (let index = 0;index < edges.length; index += 1) {
+    if (reachable[index] === 1 && without[index] !== 1)
+      dominated.push(index);
+  }
+  return dominated;
+};
+var reachableFrom = (edges, root, skipFrom = NOT_FOUND, skipTo = NOT_FOUND) => {
+  const seen = new Uint8Array(edges.length);
+  if (root < 0 || root >= edges.length)
+    return seen;
+  seen[root] = 1;
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === undefined)
+      break;
+    pushNeighbours(edges[current] ?? [], seen, stack, current === skipFrom ? skipTo : NOT_FOUND);
+  }
+  return seen;
+};
+var sumSelfMs = (selfMs, indexes) => indexes.reduce((total, index) => total + (selfMs[index] ?? 0), 0);
+var accumulate = (selfMs, reachable, attributed) => {
+  const totals = {
+    attributedCount: 0,
+    attributedMs: 0,
+    reachableCount: 0,
+    totalMs: 0
+  };
+  for (let index = 0;index < reachable.length; index += 1) {
+    if (reachable[index] !== 1)
+      continue;
+    totals.reachableCount += 1;
+    totals.totalMs += selfMs[index] ?? 0;
+    if (attributed[index] !== 1)
+      continue;
+    totals.attributedCount += 1;
+    totals.attributedMs += selfMs[index] ?? 0;
+  }
+  return totals;
+};
+var targetCounts = (candidates) => {
+  const counts = new Map;
+  for (const candidate of candidates) {
+    counts.set(candidate.target, (counts.get(candidate.target) ?? 0) + 1);
+  }
+  return counts;
+};
+var dominatedRows = (input, reachable) => {
+  const counts = targetCounts(input.candidates);
+  const skip = (candidate) => candidate.target < 0 || (counts.get(candidate.target) ?? 0) > 1;
+  return input.candidates.map((candidate) => ({
+    candidate,
+    dominated: skip(candidate) ? [] : dominatedByEdge(input.edges, input.root, input.entry, candidate.target, reachable)
+  }));
+};
+var summarizeImportSavings = (input) => {
+  const reachable = reachableFrom(input.edges, input.root);
+  const attributed = new Uint8Array(input.edges.length);
+  const savings = [];
+  for (const { candidate, dominated } of dominatedRows(input, reachable)) {
+    for (const index of dominated)
+      attributed[index] = 1;
+    savings.push({
+      count: dominated.length,
+      savingMs: sumSelfMs(input.selfMs, dominated),
+      specifier: candidate.specifier,
+      target: candidate.target
+    });
+  }
+  const totals = accumulate(input.selfMs, reachable, attributed);
+  const result = {
+    attributedCount: totals.attributedCount,
+    attributedMs: totals.attributedMs,
+    candidates: savings,
+    reachableCount: totals.reachableCount,
+    sharedBaseCount: totals.reachableCount - totals.attributedCount,
+    sharedBaseMs: totals.totalMs - totals.attributedMs,
+    totalMs: totals.totalMs
+  };
+  return result;
+};
+
+// src/dev/importCost/format.ts
+var MAX_ROWS = 12;
+var MIN_ROW_MS = 15;
+var SPECIFIER_WIDTH = 42;
+var SAVING_WIDTH = 8;
+var COUNT_WIDTH = 8;
+var ELLIPSIS = "\u2026";
+var formatMs = (value) => `${Math.round(value)}ms`;
+var truncate = (value, width) => {
+  if (value.length <= width)
+    return value;
+  return ELLIPSIS + value.slice(value.length - width + 1);
+};
+var renderRow = (row) => `  ${formatMs(row.savingMs).padStart(SAVING_WIDTH)}${String(row.count).padStart(COUNT_WIDTH)}  ${truncate(row.specifier, SPECIFIER_WIDTH).padEnd(SPECIFIER_WIDTH)}  ${row.verdict}`;
+var visibleRows = (rows) => rows.filter((row) => row.savingMs >= MIN_ROW_MS).slice(0, MAX_ROWS);
+var remainderLine = (rows, shown) => {
+  const rest = rows.filter((row) => !shown.includes(row));
+  if (rest.length === 0)
+    return [];
+  const restMs = rest.reduce((total, row) => total + row.savingMs, 0);
+  return [
+    `  ${`${rest.length} more`.padStart(SAVING_WIDTH)}${"".padStart(COUNT_WIDTH)}  imports below ${MIN_ROW_MS}ms \u2014 ${formatMs(restMs)} between them`
+  ];
+};
+var caveats = (report) => {
+  const lines = [];
+  if (report.entryBodyMs >= MIN_ROW_MS) {
+    lines.push(`  ${formatMs(report.entryBodyMs)} was the entry's own body \u2014 the work it does after its imports,`);
+    lines.push("  including the boot build it waits on. No import can move that.");
+  }
+  if (report.outsideMs >= MIN_ROW_MS) {
+    lines.push(`  ${formatMs(report.outsideMs)} more ran outside the instrumented modules (CommonJS dependencies, native`);
+    lines.push("  modules, the concurrent boot build) and is credited to no import.");
+  }
+  if (report.overheadMs >= MIN_ROW_MS) {
+    lines.push(`  ${formatMs(report.overheadMs)} of that boot was this diagnostic reading and rewriting sources; it is excluded above.`);
+  }
+  if (report.incomplete > 0) {
+    lines.push(`  ${report.incomplete} modules never ran their exit hook (CommonJS top-level return, or a throw); their self time is approximate.`);
+  }
+  if (report.interleaved > 0) {
+    lines.push(`  ${report.interleaved} out-of-order module exits (top-level await); self times around those are approximate.`);
+  }
+  return lines;
+};
+var formatImportCostReport = (report) => {
+  const shown = visibleRows(report.rows);
+  const header = `  ${"saving".padStart(SAVING_WIDTH)}${"modules".padStart(COUNT_WIDTH)}  ${"import".padEnd(SPECIFIER_WIDTH)}  verdict`;
+  return [
+    `
+AbsoluteJS import cost \u2014 ${report.entryLabel}`,
+    `${formatMs(report.totalMs)} of module evaluation across ${report.moduleCount} modules, ${report.rows.length} top-level imports.`,
+    "",
+    header,
+    ...shown.map(renderRow),
+    ...remainderLine(report.rows, shown),
+    "",
+    `  shared base: ${formatMs(report.sharedBaseMs)} across ${report.sharedBaseCount} modules \u2014 reached through more than one`,
+    "  import (or loaded before the entry), so deferring any single import does not remove it.",
+    ...caveats(report),
+    ""
+  ].join(`
+`);
+};
+
+// src/dev/importCost/moduleGraph.ts
+import { readFileSync } from "fs";
+import { dirname } from "path";
+
+// src/dev/importCost/instrument.ts
+var BYTE_ORDER_MARK = 65279;
+var NOT_FOUND2 = -1;
+var PROLOGUE_TOKEN = /\s+|\/\/[^\n]*|\/\*[\s\S]*?\*\/|(['"])use [^'"\n]*\1[ \t]*;?/y;
+var prologueEnd = (source) => {
+  let index = source.charCodeAt(0) === BYTE_ORDER_MARK ? 1 : 0;
+  if (source.startsWith("#!", index)) {
+    const newline = source.indexOf(`
+`, index);
+    index = newline === NOT_FOUND2 ? source.length : newline + 1;
+  }
+  for (;; ) {
+    PROLOGUE_TOKEN.lastIndex = index;
+    if (PROLOGUE_TOKEN.exec(source) === null)
+      return index;
+    index = PROLOGUE_TOKEN.lastIndex;
+  }
+};
+var TYPESCRIPT_EXTENSION = /\.[cm]?ts$/;
+var JS_LOADER = "js";
+var JSX_LOADER = "jsx";
+var TS_LOADER = "ts";
+var TSX_LOADER = "tsx";
+var importCostLoader = (path) => {
+  if (path.endsWith(".tsx"))
+    return TSX_LOADER;
+  if (path.endsWith(".jsx"))
+    return JSX_LOADER;
+  if (TYPESCRIPT_EXTENSION.test(path))
+    return TS_LOADER;
+  return JS_LOADER;
+};
+var instrumentModuleSource = (source, moduleIndex) => {
+  const insertAt = prologueEnd(source);
+  const enter = `globalThis.__absoluteImportCostEnter?.(${moduleIndex});`;
+  const exit = `
+;globalThis.__absoluteImportCostExit?.(${moduleIndex});`;
+  return `${source.slice(0, insertAt)}${enter}${source.slice(insertAt)}${exit}`;
+};
+
+// src/dev/importCost/recorder.ts
+var IMPORT_COST_EVENT = {
+  enter: 2,
+  exit: 3,
+  loadEnd: 1,
+  loadStart: 0
+};
+var IMPORT_COST_EVENT_KINDS = 4;
+var ensureImportCostRecorder = () => {
+  const existing = globalThis.__absoluteImportCost;
+  if (existing !== undefined)
+    return existing;
+  const created = {
+    entryModule: null,
+    entryOriginalModule: null,
+    events: [],
+    moduleIds: [],
+    moduleIndexes: new Map,
+    recording: true,
+    rootModule: null
+  };
+  globalThis.__absoluteImportCost = created;
+  return created;
+};
+
+// src/dev/importCost/moduleGraph.ts
+var EVENT_STRIDE = 2;
+var transpilers = new Map;
+var transpilerFor = (loader) => {
+  const existing = transpilers.get(loader);
+  if (existing !== undefined)
+    return existing;
+  const created = new Bun.Transpiler({ loader });
+  transpilers.set(loader, created);
+  return created;
+};
+var scanSpecifiers = (path) => {
+  try {
+    const loader = importCostLoader(path);
+    return transpilerFor(loader).scanImports(readFileSync(path, "utf8")).map((entry) => entry.path);
+  } catch {
+    return [];
+  }
+};
+var resolveSpecifier = (specifier, fromDirectory) => {
+  try {
+    return Bun.resolveSync(specifier, fromDirectory);
+  } catch {
+    return null;
+  }
+};
+var BUILTIN = /^(?:node|bun|cloudflare):/;
+var linkSpecifier = (specifier, context, index) => {
+  if (BUILTIN.test(specifier))
+    return;
+  const resolved = resolveSpecifier(specifier, context.fromDirectory);
+  if (resolved === null)
+    return;
+  const target = context.indexes.get(resolved);
+  if (target === undefined) {
+    context.hasUninstrumentedImports[index] = 1;
+    return;
+  }
+  if (target !== index)
+    context.targets.add(target);
+};
+var buildStaticEdges = (moduleIds) => {
+  const indexes = new Map(moduleIds.map((id, index) => [id, index]));
+  const hasUninstrumentedImports = new Uint8Array(moduleIds.length);
+  const edges = moduleIds.map((id, index) => {
+    const targets = new Set;
+    const context = {
+      fromDirectory: dirname(id),
+      hasUninstrumentedImports,
+      indexes,
+      targets
+    };
+    for (const specifier of scanSpecifiers(id)) {
+      linkSpecifier(specifier, context, index);
+    }
+    return [...targets];
+  });
+  const graph = { edges, hasUninstrumentedImports };
+  return graph;
+};
+var markImporters = (edges, hasImporter) => {
+  for (const targets of edges) {
+    for (const target of targets)
+      hasImporter[target] = 1;
+  }
+};
+var applyInferEvent = (state, kind, moduleIndex) => {
+  if (kind === IMPORT_COST_EVENT.exit) {
+    const position = state.stack.lastIndexOf(moduleIndex);
+    if (position !== -1)
+      state.stack.length = position;
+    return;
+  }
+  if (kind !== IMPORT_COST_EVENT.enter)
+    return;
+  const importer = state.stack[state.stack.length - 1];
+  const orphan = state.entered[moduleIndex] !== 1 && state.hasImporter[moduleIndex] !== 1 && moduleIndex !== state.root && importer !== undefined;
+  if (orphan && importer !== undefined) {
+    state.inferred.push([importer, moduleIndex]);
+  }
+  state.entered[moduleIndex] = 1;
+  state.stack.push(moduleIndex);
+};
+var inferDynamicEdges = (edges, events, root) => {
+  const hasImporter = new Uint8Array(edges.length);
+  markImporters(edges, hasImporter);
+  const state = {
+    entered: new Uint8Array(edges.length),
+    hasImporter,
+    inferred: [],
+    root,
+    stack: []
+  };
+  for (let cursor = 0;cursor + 1 < events.length; cursor += EVENT_STRIDE) {
+    const code = events[cursor];
+    if (code === undefined)
+      break;
+    applyInferEvent(state, code % IMPORT_COST_EVENT_KINDS, Math.floor(code / IMPORT_COST_EVENT_KINDS));
+  }
+  return state.inferred;
+};
+
+// src/dev/importCost/selfTimes.ts
+var EVENT_STRIDE2 = 2;
+var NONE = -1;
+var add = (into, index, amount) => {
+  into[index] = (into[index] ?? 0) + amount;
+};
+var charge = (state, timeMs) => {
+  const elapsed = timeMs - state.previousMs;
+  state.previousMs = timeMs;
+  if (state.inCallback) {
+    state.overheadMs += elapsed;
+    return;
+  }
+  if (state.pendingParse !== NONE) {
+    add(state.parseMs, state.pendingParse, elapsed);
+    return;
+  }
+  const top = state.stack[state.stack.length - 1];
+  if (top === undefined) {
+    state.unownedMs += elapsed;
+    return;
+  }
+  add(state.evalMs, top, elapsed);
+};
+var enterModule = (state, moduleIndex, timeMs) => {
+  state.pendingParse = NONE;
+  state.stack.push(moduleIndex);
+  if (Number.isNaN(state.firstEnterMs[moduleIndex] ?? Number.NaN)) {
+    state.firstEnterMs[moduleIndex] = timeMs;
+  }
+};
+var exitModule = (state, moduleIndex) => {
+  const position = state.stack.lastIndexOf(moduleIndex);
+  if (position === NONE) {
+    state.interleaved += 1;
+    return;
+  }
+  if (position !== state.stack.length - 1)
+    state.interleaved += 1;
+  state.stack.length = position;
+};
+var applyEvent = (state, kind, moduleIndex, timeMs) => {
+  if (kind === IMPORT_COST_EVENT.loadStart)
+    state.inCallback = true;
+  else if (kind === IMPORT_COST_EVENT.loadEnd) {
+    state.inCallback = false;
+    state.pendingParse = moduleIndex;
+  } else if (kind === IMPORT_COST_EVENT.enter) {
+    enterModule(state, moduleIndex, timeMs);
+  } else
+    exitModule(state, moduleIndex);
+};
+var computeSelfTimes = (events, moduleCount) => {
+  const state = {
+    evalMs: new Array(moduleCount).fill(0),
+    firstEnterMs: new Array(moduleCount).fill(Number.NaN),
+    inCallback: false,
+    interleaved: 0,
+    overheadMs: 0,
+    parseMs: new Array(moduleCount).fill(0),
+    pendingParse: NONE,
+    previousMs: events[1] ?? 0,
+    stack: [],
+    unownedMs: 0
+  };
+  for (let cursor = 0;cursor + 1 < events.length; cursor += EVENT_STRIDE2) {
+    const code = events[cursor];
+    const timeMs = events[cursor + 1];
+    if (code === undefined || timeMs === undefined)
+      break;
+    charge(state, timeMs);
+    applyEvent(state, code % IMPORT_COST_EVENT_KINDS, Math.floor(code / IMPORT_COST_EVENT_KINDS), timeMs);
+  }
+  const result = {
+    evalMs: state.evalMs,
+    firstEnterMs: state.firstEnterMs,
+    incomplete: [...new Set(state.stack)],
+    interleaved: state.interleaved,
+    overheadMs: state.overheadMs,
+    parseMs: state.parseMs,
+    selfMs: state.evalMs.map((value, index) => value + (state.parseMs[index] ?? 0)),
+    unownedMs: state.unownedMs
+  };
+  return result;
+};
+
+// src/dev/importCost/report.ts
+var NOT_FOUND3 = -1;
+var NO_DATA = `
+[absolute] import cost: nothing was recorded. The dev child was not preloaded with the import-cost plugin.
+`;
+var linkEdge = (edges, fromIndex, toIndex) => {
+  const targets = edges[fromIndex];
+  if (targets === undefined || fromIndex === toIndex)
+    return;
+  if (!targets.includes(toIndex))
+    targets.push(toIndex);
+};
+var resolveTarget = (specifier, fromDirectory, indexes) => {
+  try {
+    return indexes.get(Bun.resolveSync(specifier, fromDirectory)) ?? NOT_FOUND3;
+  } catch {
+    return NOT_FOUND3;
+  }
+};
+var readEntrySource = (paths) => {
+  for (const path of paths) {
+    const text = readSource(path);
+    if (text !== null)
+      return text;
+  }
+  return null;
+};
+var readSource = (path) => {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return null;
+  }
+};
+var rootIndexOf = (recorder) => {
+  const known = moduleIndexOf(recorder, recorder.rootModule);
+  if (known !== NOT_FOUND3)
+    return known;
+  const created = recorder.moduleIds.length;
+  recorder.moduleIds.push(recorder.rootModule ?? "<dev bootstrap>");
+  return created;
+};
+var moduleIndexOf = (recorder, path) => path === null ? NOT_FOUND3 : recorder.moduleIndexes.get(path) ?? NOT_FOUND3;
+var linkOrphansToRoot = (edges, root) => {
+  const imported = new Uint8Array(edges.length);
+  for (const targets of edges) {
+    for (const target of targets)
+      imported[target] = 1;
+  }
+  for (let index = 0;index < edges.length; index += 1) {
+    if (imported[index] === 1 || index === root)
+      continue;
+    linkEdge(edges, root, index);
+  }
+};
+var creditableSelfMs = (times, hasUninstrumentedImports) => times.evalMs.map((value, index) => hasUninstrumentedImports[index] === 1 ? value : value + (times.parseMs[index] ?? 0));
+var buildReport = (recorder) => {
+  const { events, moduleIds, moduleIndexes } = recorder;
+  const entry = moduleIndexOf(recorder, recorder.entryModule);
+  if (moduleIds.length === 0 || entry === NOT_FOUND3)
+    return NO_DATA;
+  const root = rootIndexOf(recorder);
+  const entryPath = recorder.entryOriginalModule ?? recorder.entryModule ?? "";
+  const source = readEntrySource([entryPath, recorder.entryModule ?? ""]);
+  if (source === null)
+    return NO_DATA;
+  const times = computeSelfTimes(events, moduleIds.length);
+  const { edges, hasUninstrumentedImports } = buildStaticEdges(moduleIds);
+  while (edges.length < moduleIds.length)
+    edges.push([]);
+  const selfMs = creditableSelfMs(times, hasUninstrumentedImports);
+  linkEdge(edges, root, entry);
+  for (const [importer, imported] of inferDynamicEdges(edges, events, root)) {
+    linkEdge(edges, importer, imported);
+  }
+  linkOrphansToRoot(edges, root);
+  const declared = analyzeEntryImports(source, entryPath).filter((item) => item.verdict !== "type-only");
+  const fromDirectory = dirname2(recorder.entryModule ?? entryPath);
+  const candidates = declared.map((item) => {
+    const candidate = {
+      specifier: item.specifier,
+      target: resolveTarget(item.specifier, fromDirectory, moduleIndexes)
+    };
+    return candidate;
+  });
+  const savings = summarizeImportSavings({
+    candidates,
+    edges,
+    entry,
+    root,
+    selfMs
+  });
+  const loadedMs = times.selfMs.reduce((total, value) => total + value, 0);
+  const rootMs = selfMs[root] ?? 0;
+  const entryMs = selfMs[entry] ?? 0;
+  const rows = savings.candidates.map((saving, index) => ({
+    count: saving.count,
+    savingMs: saving.savingMs,
+    specifier: saving.specifier,
+    verdict: declared[index]?.verdict ?? "deferrable"
+  })).sort((left, right) => right.savingMs - left.savingMs);
+  const report = {
+    entryBodyMs: entryMs,
+    entryLabel: relative(process.cwd(), entryPath) || entryPath,
+    incomplete: times.incomplete.filter((index) => index !== root).length,
+    interleaved: times.interleaved,
+    moduleCount: savings.reachableCount - 2,
+    outsideMs: loadedMs - savings.totalMs + rootMs + times.unownedMs,
+    overheadMs: times.overheadMs,
+    rows,
+    sharedBaseCount: savings.sharedBaseCount - 2,
+    sharedBaseMs: savings.sharedBaseMs - rootMs - entryMs,
+    totalMs: savings.totalMs - rootMs - entryMs
+  };
+  return formatImportCostReport(report);
+};
+var dumpRecorder = (recorder) => {
+  const path = process.env.ABSOLUTE_DEV_IMPORT_COST_DUMP;
+  if (path === undefined)
+    return;
+  writeFileSync(path, JSON.stringify({
+    entryModule: recorder.entryModule,
+    entryOriginalModule: recorder.entryOriginalModule,
+    events: recorder.events,
+    moduleIds: recorder.moduleIds,
+    rootModule: recorder.rootModule
+  }));
+};
+var reportImportCost = () => {
+  const recorder = globalThis.__absoluteImportCost;
+  if (recorder === undefined)
+    return;
+  recorder.recording = false;
+  try {
+    dumpRecorder(recorder);
+    console.log(buildReport(recorder));
+  } catch (error) {
+    console.error(`[absolute] import-cost report failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+export {
+  reportImportCost
+};