@absolutejs/absolute 0.20.0-beta.74 → 0.20.0-beta.76

package/dist/cli/{doctor-a8afwvf9.js → doctor-mbh9bk05.js}

@@ -22,7 +22,6 @@ import"./index-mywsk201.js";
 // src/cli/scripts/doctor.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { arch, platform } from "os";
 import { join as join2 } from "path";
 
 // src/cli/typeGraphCoherence.ts
@@ -274,11 +273,6 @@ var checkAbsolute = () => {
   const version = resolveVersion("@absolutejs/absolute");
   return version === null ? check("fail", "@absolutejs/absolute", "not resolvable here") : check("ok", "@absolutejs/absolute", `v${version}`);
 };
-var checkNative = () => {
-  const target = `@absolutejs/native-${platform()}-${arch()}`;
-  const version = resolveVersion(target);
-  return version === null ? check("warn", "Native binary", `${target} not installed`) : check("ok", "Native binary", `v${version}`);
-};
 var loadConfigOrNull = async () => {
   try {
     return await loadRawConfig();
@@ -355,7 +349,6 @@ var gatherChecks = async () => {
   return [
     checkBun(),
     checkAbsolute(),
-    checkNative(),
     typeGraphCheck(),
     configCheck,
     ...config === null ? [] : frameworkChecks(config),

package/dist/cli/index.js

@@ -168,7 +168,7 @@ if (command === "dev") {
   await runLogs(args);
 } else if (command === "doctor") {
   sendTelemetryEvent("cli:command", { command: "doctor" });
-  const { runDoctor } = await import("./doctor-a8afwvf9.js");
+  const { runDoctor } = await import("./doctor-mbh9bk05.js");
   await runDoctor(args);
 } else if (command === "routes") {
   sendTelemetryEvent("cli:command", { command: "routes" });

package/dist/dev/importCostReport.js

@@ -187,6 +187,15 @@ var dominatedByEdge = (edges, root, fromIndex, toIndex, reachable = reachableFro
   }
   return dominated;
 };
+var dominatedByEdges = (edges, root, fromIndex, targets, reachable) => {
+  const without = reachableWithoutEdges(edges, root, fromIndex, targets);
+  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)
@@ -201,6 +210,30 @@ var reachableFrom = (edges, root, skipFrom = NOT_FOUND, skipTo = NOT_FOUND) => {
   }
   return seen;
 };
+var reachableWithoutEdges = (edges, root, skipFrom, skipTargets) => {
+  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;
+    pushNeighboursExcept(edges[current] ?? [], seen, stack, current === skipFrom ? skipTargets : null);
+  }
+  return seen;
+};
+var pushNeighboursExcept = (targets, seen, stack, skip) => {
+  for (const target of targets) {
+    if (skip?.has(target) === true)
+      continue;
+    if (seen[target] === 1)
+      continue;
+    seen[target] = 1;
+    stack.push(target);
+  }
+};
 var sumSelfMs = (selfMs, indexes) => indexes.reduce((total, index) => total + (selfMs[index] ?? 0), 0);
 var accumulate = (selfMs, reachable, attributed) => {
   const totals = {
@@ -251,10 +284,17 @@ var summarizeImportSavings = (input) => {
     });
   }
   const totals = accumulate(input.selfMs, reachable, attributed);
+  const inGroup = (candidate) => input.groupSpecifiers === undefined || input.groupSpecifiers.has(candidate.specifier);
+  const groupTargets = new Set(input.candidates.filter(inGroup).map((candidate) => candidate.target).filter((target) => target >= 0));
+  const groupDominated = dominatedByEdges(input.edges, input.root, input.entry, groupTargets, reachable);
   const result = {
     attributedCount: totals.attributedCount,
     attributedMs: totals.attributedMs,
     candidates: savings,
+    combined: {
+      count: groupDominated.length,
+      savingMs: sumSelfMs(input.selfMs, groupDominated)
+    },
     reachableCount: totals.reachableCount,
     sharedBaseCount: totals.reachableCount - totals.attributedCount,
     sharedBaseMs: totals.totalMs - totals.attributedMs,
@@ -322,6 +362,8 @@ AbsoluteJS import cost \u2014 ${report.entryLabel}`,
     "",
     `  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.",
+    `  all together: deferring every deferrable import at once removes ${formatMs(report.combinedMs)}`,
+    `  across ${report.combinedCount} modules \u2014 each row above is measured alone, so they do not sum to this.`,
     ...caveats(report),
     ""
   ].join(`
@@ -674,6 +716,7 @@ var buildReport = (recorder) => {
     candidates,
     edges,
     entry,
+    groupSpecifiers: new Set(candidates.filter((_candidate, index) => (declared[index]?.verdict ?? "deferrable") === "deferrable").map((candidate) => candidate.specifier)),
     root,
     selfMs
   });
@@ -687,6 +730,8 @@ var buildReport = (recorder) => {
     verdict: declared[index]?.verdict ?? "deferrable"
   })).sort((left, right) => right.savingMs - left.savingMs);
   const report = {
+    combinedCount: savings.combined.count,
+    combinedMs: savings.combined.savingMs,
     entryBodyMs: entryMs,
     entryLabel: relative(process.cwd(), entryPath) || entryPath,
     incomplete: times.incomplete.filter((index) => index !== root).length,

package/dist/index.js

@@ -10592,16 +10592,30 @@ var DEFAULT_BATCH_SIZE = 12, DEFAULT_POLL_MS = 25, DEFAULT_MAX_PAUSE_MS = 2000,
       waited += pollMs;
     }
   };
+  const launchBatch = async (pending) => {
+    const launched = [];
+    while (pending.length > 0 && !cancelled) {
+      if (launched.length > 0 && options.isBusy())
+        break;
+      const task = pending.shift();
+      if (task === undefined)
+        break;
+      launched.push(Promise.resolve(task()));
+      await sleep(0);
+    }
+    await Promise.all(launched);
+    return launched.length;
+  };
   const run = async () => {
     let completed = 0;
     const iterator = tasks[Symbol.iterator]();
+    let pending = [];
     while (!cancelled) {
       await waitForIdle();
-      const batch = cancelled ? [] : takeBatch(iterator, batchSize);
-      if (batch.length === 0)
+      pending = pending.length === 0 && !cancelled ? takeBatch(iterator, batchSize) : pending;
+      if (pending.length === 0)
         break;
-      await Promise.all(batch.map((task) => task()));
-      completed += batch.length;
+      completed += await launchBatch(pending);
       await sleep(0);
     }
     return completed;
@@ -43581,5 +43595,5 @@ export {
   wrapPageHandlerWithStreamingSlots
 };
 
-//# debugId=64994B5103FBB83764756E2164756E21
+//# debugId=6F1D3AD5600A3EC864756E2164756E21
 //# sourceMappingURL=index.js.map