@absolutejs/absolute 0.20.0-beta.122 → 0.20.0-beta.124

package/dist/cli/{dev-pdefc9ac.js → dev-s7kct3xq.js}

@@ -12,6 +12,9 @@ import {
 import {
   scanListeners
 } from "./index-fhaf3tdk.js";
+import {
+  resolveDevBunExecutable
+} from "./index-hty8111z.js";
 import {
   stripStringsAndComments
 } from "./index-fc9vxw56.js";
@@ -1504,6 +1507,8 @@ var dev = async (serverEntry, configPath, options = {}) => {
   let selectedRemoteMacProfile;
   let expoDevProject;
   markBoot("dev command entered");
+  const bunExecutable = await resolveDevBunExecutable();
+  markBoot("dev bun runtime selected");
   let prescanConfig;
   try {
     const config = await loadConfig(configPath);
@@ -2499,7 +2504,7 @@ var dev = async (serverEntry, configPath, options = {}) => {
     markBoot("dev child spawn requested");
     const prescanForSpawn = prescan;
     prescan = null;
-    const proc = nodeSpawn("bun", [
+    const proc = nodeSpawn(bunExecutable, [
       "--hot",
       "--no-clear-screen",
       ...heapSnapshotEnabled ? ["--preload", heapPreloadPath] : [],

package/dist/cli/index-hty8111z.js

@@ -0,0 +1,410 @@
+// @bun
+// src/cli/patchedBun.ts
+import { spawnSync } from "child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createInterface } from "readline/promises";
+import { inflateRawSync } from "zlib";
+var PATCHED_BUN_RELEASE = {
+  bunVersion: "1.4.0",
+  issue: "https://github.com/oven-sh/bun/issues/32919",
+  repo: "absolutejs/patched-bun",
+  sha256: {
+    "bun-darwin-aarch64": "940d8c7eadb9fb4f39f06b0a086bbb6851d1bf3bc164bd3ba3a6966f8229f53c",
+    "bun-darwin-x64": "847f215cdd147431d025ffec94063467d1e4e80a5e4c311efff4570e04fa06ed",
+    "bun-freebsd-aarch64": "6d1c6c51cb782a1f9d2f4e2481aa7b856eff05be430094fa3b8fb86adf4067a3",
+    "bun-freebsd-x64": "c5395cd411bf3df75c3943e6ebb7722b5dd369df9a97c622449d36129cc6277a",
+    "bun-linux-aarch64": "fd5931bf59ff2bbaeab5fa37a1b003a3f10ada6b7fee2d3d8f15e606adad61f9",
+    "bun-linux-aarch64-android": "ab560ea72357554c93b4b0390b869ec62769c9b5f676ab196ecb3b0e328d7126",
+    "bun-linux-aarch64-musl": "b9c3f9936f4c7b6b0b749090f70806a1f73ca48d5a9762709ef9a4e9a5b0fed8",
+    "bun-linux-x64": "d36584f9aa71773fada3831ddf01a34c6089988988b900fd968586db099a0567",
+    "bun-linux-x64-android": "1a9712c77516fc224ed3307e083a12ea6e4f1a2956e920b9590bf12e4f59304e",
+    "bun-linux-x64-musl": "061a8bd6afad866f807d93125508c303f16c2dbf000387c91d22dd777c072951",
+    "bun-windows-aarch64": "91ed75e937b191eaf18bb361040acc24cd363b38f7bdaab5228fadd813f2a9ea",
+    "bun-windows-x64": "f7a7a22349dc7d4df0347da3f3058fe746763e22950bc77f4ae8021dab75a7b3"
+  },
+  tag: "bun-v1.4.0-absolute.2"
+};
+var HOURS_PER_DAY = 24;
+var MS_PER_HOUR = 3600000;
+var ASK_LATER_MS = HOURS_PER_DAY * MS_PER_HOUR;
+var PREFERENCE_FILE = "patched-bun.json";
+var EXECUTABLE_MODE = 493;
+var VERSION_PARTS = 3;
+var PROBE_TIMEOUT_MS = 30000;
+var MUSL_LOADERS = ["/lib/ld-musl-x86_64.so.1", "/lib/ld-musl-aarch64.so.1"];
+var DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies"
+];
+var ZIP = {
+  directoryEntry: 33639248,
+  endDirectoryOffset: 16,
+  endEntryCount: 10,
+  endOfDirectory: 101010256,
+  endRecordSize: 22,
+  entryCommentLength: 32,
+  entryCompressedSize: 20,
+  entryExtraLength: 30,
+  entryHeaderSize: 46,
+  entryLocalOffset: 42,
+  entryMethod: 10,
+  entryNameLength: 28,
+  localExtraLength: 28,
+  localHeader: 67324752,
+  localHeaderSize: 30,
+  localNameLength: 26,
+  methodDeflate: 8,
+  methodStored: 0
+};
+var isAsset = (name) => Object.hasOwn(PATCHED_BUN_RELEASE.sha256, name);
+var detectLibc = () => {
+  if (process.platform === "android")
+    return "android";
+  if (MUSL_LOADERS.some((loader) => existsSync(loader)))
+    return "musl";
+  return "glibc";
+};
+var absoluteHome = (home) => join(home, ".absolutejs");
+var compareVersions = (left, right) => {
+  const parse = (version) => version.split("-")[0]?.split(".").map(Number) ?? [];
+  const leftParts = parse(left);
+  const rightParts = parse(right);
+  const differences = Array.from({ length: VERSION_PARTS }, (_, index) => (leftParts[index] ?? 0) - (rightParts[index] ?? 0));
+  return differences.find((difference) => difference !== 0) ?? 0;
+};
+var preferencePath = (home) => join(absoluteHome(home), PREFERENCE_FILE);
+var installedPatchedBun = (home = homedir()) => {
+  const asset = patchedBunAsset();
+  if (!asset)
+    return null;
+  const path = patchedBunPath(asset, home);
+  return existsSync(path) ? path : null;
+};
+var patchedBunAsset = (platform = process.platform, arch = process.arch, libc = detectLibc()) => {
+  const cpu = { arm64: "aarch64", x64: "x64" }[arch];
+  const system = {
+    android: "linux",
+    darwin: "darwin",
+    freebsd: "freebsd",
+    linux: "linux",
+    win32: "windows"
+  }[platform];
+  if (!cpu || !system)
+    return null;
+  const abi = system === "linux" && libc !== "glibc" ? `-${libc}` : "";
+  const name = `bun-${system}-${cpu}${abi}`;
+  return isAsset(name) ? name : null;
+};
+var patchedBunPath = (asset, home = homedir()) => join(absoluteHome(home), "bun", PATCHED_BUN_RELEASE.tag, asset, asset.startsWith("bun-windows") ? "bun.exe" : "bun");
+var runtimeSupportsReactFastRefresh = () => {
+  const options = { loader: "tsx", reactFastRefresh: true };
+  try {
+    return new Bun.Transpiler(options).transformSync("export function Probe(){return null;}").includes("$RefreshReg$");
+  } catch {
+    return false;
+  }
+};
+var parsePreference = (parsed) => {
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  if (!("decision" in parsed))
+    return null;
+  if (parsed.decision === "never") {
+    const never = { decision: "never" };
+    return never;
+  }
+  if (parsed.decision !== "later" || !("askAfter" in parsed) || typeof parsed.askAfter !== "string")
+    return null;
+  const later = { askAfter: parsed.askAfter, decision: "later" };
+  return later;
+};
+var patchedBunOfferState = (context) => {
+  if (context.supported)
+    return "runtime-supports-refresh";
+  if (context.installed)
+    return "installed";
+  if (!context.usesReact)
+    return "not-a-react-project";
+  if (!context.asset)
+    return "unsupported-platform";
+  if (compareVersions(context.bunVersion, PATCHED_BUN_RELEASE.bunVersion) > 0)
+    return "runtime-newer";
+  if (context.preference?.decision === "never")
+    return "declined";
+  if (context.preference?.decision === "later" && new Date(context.preference.askAfter) > context.now)
+    return "asked-recently";
+  if (context.ci || !context.interactive)
+    return "non-interactive";
+  return "offer";
+};
+var readPatchedBunPreference = (home = homedir()) => {
+  try {
+    return parsePreference(JSON.parse(readFileSync(preferencePath(home), "utf-8")));
+  } catch {
+    return null;
+  }
+};
+var findEndOfDirectory = (view) => {
+  for (let offset = view.byteLength - ZIP.endRecordSize;offset >= 0; offset--) {
+    if (view.getUint32(offset, true) === ZIP.endOfDirectory)
+      return offset;
+  }
+  throw new Error("Not a zip archive.");
+};
+var inflateEntry = (data, method) => {
+  if (method === ZIP.methodStored)
+    return data;
+  if (method === ZIP.methodDeflate)
+    return new Uint8Array(inflateRawSync(data));
+  throw new Error(`Unsupported zip compression method ${method}.`);
+};
+var readEntryData = (archive, view, entry) => {
+  if (view.getUint32(entry.localOffset, true) !== ZIP.localHeader)
+    throw new Error("Corrupt zip entry.");
+  const dataStart = entry.localOffset + ZIP.localHeaderSize + view.getUint16(entry.localOffset + ZIP.localNameLength, true) + view.getUint16(entry.localOffset + ZIP.localExtraLength, true);
+  return inflateEntry(archive.subarray(dataStart, dataStart + entry.compressedSize), entry.method);
+};
+var readZipEntry = (archive, entryName) => {
+  const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const end = findEndOfDirectory(view);
+  const entries = view.getUint16(end + ZIP.endEntryCount, true);
+  const decoder = new TextDecoder;
+  let cursor = view.getUint32(end + ZIP.endDirectoryOffset, true);
+  for (let index = 0;index < entries; index++) {
+    if (view.getUint32(cursor, true) !== ZIP.directoryEntry)
+      throw new Error("Corrupt zip directory.");
+    const nameLength = view.getUint16(cursor + ZIP.entryNameLength, true);
+    const nameStart = cursor + ZIP.entryHeaderSize;
+    const name = decoder.decode(archive.subarray(nameStart, nameStart + nameLength));
+    const entry = {
+      compressedSize: view.getUint32(cursor + ZIP.entryCompressedSize, true),
+      localOffset: view.getUint32(cursor + ZIP.entryLocalOffset, true),
+      method: view.getUint16(cursor + ZIP.entryMethod, true)
+    };
+    if (name === entryName)
+      return readEntryData(archive, view, entry);
+    cursor += ZIP.entryHeaderSize + nameLength + view.getUint16(cursor + ZIP.entryExtraLength, true) + view.getUint16(cursor + ZIP.entryCommentLength, true);
+  }
+  throw new Error(`${entryName} is not in the archive.`);
+};
+var writePatchedBunPreference = (preference, home = homedir()) => {
+  const path = preferencePath(home);
+  if (preference === null) {
+    rmSync(path, { force: true });
+    return;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(preference, null, "\t")}
+`);
+};
+var sha256 = (bytes) => new Bun.CryptoHasher("sha256").update(bytes).digest("hex");
+var projectUsesReact = (projectDir) => {
+  const hasReact = (deps) => typeof deps === "object" && deps !== null && Object.hasOwn(deps, "react");
+  try {
+    const manifest = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf-8"));
+    if (typeof manifest !== "object" || manifest === null)
+      return false;
+    return DEPENDENCY_FIELDS.some((field) => hasReact(Reflect.get(manifest, field)));
+  } catch {
+    return false;
+  }
+};
+var PATCHED_BUN_EXPLANATION = [
+  "React edits reload the page and lose component state on this Bun.",
+  `Stock Bun ignores \`reactFastRefresh\` on Bun.Transpiler (${PATCHED_BUN_RELEASE.issue}),`,
+  "so React Fast Refresh cannot keep state across edits. Until Bun ships the fix,",
+  `AbsoluteJS publishes Bun ${PATCHED_BUN_RELEASE.bunVersion} with only that fix: https://github.com/${PATCHED_BUN_RELEASE.repo}`,
+  "It installs to ~/.absolutejs/bun and only `absolute dev` uses it; your `bun` is unchanged."
+];
+var installPatchedBun = async (options = {}) => {
+  const asset = options.asset ?? patchedBunAsset();
+  if (!asset)
+    throw new Error(`No patched Bun build for ${process.platform}-${process.arch}.`);
+  const home = options.home ?? homedir();
+  const log = options.log ?? console.log;
+  const url = patchedBunDownloadUrl(asset);
+  log(`Downloading ${url}`);
+  const response = await (options.fetchImpl ?? fetch)(url);
+  if (!response.ok)
+    throw new Error(`Download failed: ${url} answered ${response.status}.`);
+  const archive = new Uint8Array(await response.arrayBuffer());
+  const expected = (options.checksums ?? PATCHED_BUN_RELEASE.sha256)[asset];
+  const actual = sha256(archive);
+  if (actual !== expected)
+    throw new Error(`${asset}.zip does not match its pinned SHA-256 (expected ${expected}, got ${actual}); not installing it.`);
+  const target = patchedBunPath(asset, home);
+  const binary = readZipEntry(archive, `${asset}/${target.endsWith(".exe") ? "bun.exe" : "bun"}`);
+  mkdirSync(dirname(target), { recursive: true });
+  const staging = `${target}.${process.pid}.tmp`;
+  writeFileSync(staging, binary);
+  chmodSync(staging, EXECUTABLE_MODE);
+  renameSync(staging, target);
+  log(`Installed patched Bun ${PATCHED_BUN_RELEASE.bunVersion} at ${target}`);
+  return target;
+};
+var parsePatchedBunChoice = (answer) => {
+  const normalized = answer.trim().toLowerCase();
+  const choices = [
+    {
+      choice: "install",
+      matches: normalized === "" || normalized === "1" || normalized.startsWith("i")
+    },
+    {
+      choice: "later",
+      matches: normalized === "2" || normalized.startsWith("l")
+    },
+    {
+      choice: "never",
+      matches: normalized === "3" || normalized.startsWith("d") || normalized.startsWith("n")
+    }
+  ];
+  return choices.find(({ matches }) => matches)?.choice ?? null;
+};
+var patchedBunDownloadUrl = (asset) => `https://github.com/${PATCHED_BUN_RELEASE.repo}/releases/download/${PATCHED_BUN_RELEASE.tag}/${asset}.zip`;
+var verifyPatchedBun = (path) => {
+  const probe = spawnSync(path, [
+    "-e",
+    'console.log(Bun.version, new Bun.Transpiler({loader:"tsx",reactFastRefresh:true}).transformSync("export function P(){return null}").includes("$RefreshReg$"))'
+  ], { encoding: "utf-8", timeout: PROBE_TIMEOUT_MS });
+  return probe.status === 0 && probe.stdout.trim() === `${PATCHED_BUN_RELEASE.bunVersion} true`;
+};
+var askUntilAnswered = async (prompt) => {
+  const choice = parsePatchedBunChoice(await prompt.question("Choose [1-3] (default 1): "));
+  return choice ?? askUntilAnswered(prompt);
+};
+var askForChoice = async () => {
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log(`
+${PATCHED_BUN_EXPLANATION.join(`
+`)}
+`);
+    console.log(`  1) Install now
+  2) Ask me later
+  3) Don't ask again
+`);
+    return await askUntilAnswered(prompt);
+  } finally {
+    prompt.close();
+  }
+};
+var installVerified = async (home) => {
+  const path = await installPatchedBun({ home });
+  if (!verifyPatchedBun(path)) {
+    rmSync(path, { force: true });
+    throw new Error("the installed binary did not pass its check; removed it");
+  }
+  writePatchedBunPreference(null, home);
+  return path;
+};
+var recordDecline = (choice, home) => {
+  if (choice === "never") {
+    writePatchedBunPreference({ decision: "never" }, home);
+    console.log("OK, not asking again. `absolute bun-patch install` installs it any time; `absolute bun-patch reset` asks again.");
+    return;
+  }
+  writePatchedBunPreference({
+    askAfter: new Date(Date.now() + ASK_LATER_MS).toISOString(),
+    decision: "later"
+  }, home);
+  console.log("OK, asking again tomorrow. `absolute bun-patch install` installs it any time.");
+};
+var resolveDevBunExecutable = async (projectDir = process.cwd(), home = homedir()) => {
+  if (process.env.ABSOLUTE_PATCHED_BUN === "0")
+    return "bun";
+  const installed = installedPatchedBun(home);
+  if (installed) {
+    console.log(`Using AbsoluteJS patched Bun ${PATCHED_BUN_RELEASE.bunVersion} for React Fast Refresh (${installed}).`);
+    return installed;
+  }
+  const state = patchedBunOfferState({
+    asset: patchedBunAsset(),
+    bunVersion: Bun.version,
+    ci: Boolean(process.env.CI),
+    installed: false,
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    now: new Date,
+    preference: readPatchedBunPreference(home),
+    supported: runtimeSupportsReactFastRefresh(),
+    usesReact: projectUsesReact(projectDir)
+  });
+  if (state === "non-interactive")
+    console.log(`React edits will reload the page: stock Bun lacks the reactFastRefresh fix (${PATCHED_BUN_RELEASE.issue}). Run \`absolute bun-patch install\` to use AbsoluteJS's patched Bun.`);
+  if (state !== "offer")
+    return "bun";
+  const choice = await askForChoice();
+  if (choice !== "install") {
+    recordDecline(choice, home);
+    return "bun";
+  }
+  try {
+    return await installVerified(home);
+  } catch (error) {
+    console.error(`Could not install the patched Bun (${error instanceof Error ? error.message : String(error)}). Continuing with your bun; React edits will reload the page.`);
+    return "bun";
+  }
+};
+var describePreference = (preference) => {
+  if (preference === null)
+    return "will ask";
+  if (preference.decision === "never")
+    return "won't ask again";
+  return `asking again after ${preference.askAfter}`;
+};
+var describeInstalled = (installed) => {
+  if (!installed)
+    return "no";
+  if (verifyPatchedBun(installed))
+    return installed;
+  return `${installed} (FAILED its check; run \`absolute bun-patch install\`)`;
+};
+var printStatus = (home) => {
+  const supported = runtimeSupportsReactFastRefresh();
+  console.log(`Release: ${PATCHED_BUN_RELEASE.tag} (${PATCHED_BUN_RELEASE.issue})`);
+  console.log(`Platform build: ${patchedBunAsset() ?? "none for this platform"}`);
+  console.log(`Your bun: ${Bun.version} (${supported ? "already has the fix" : "stock, no fix"})`);
+  console.log(`Installed: ${describeInstalled(installedPatchedBun(home))}`);
+  console.log(`Prompt: ${describePreference(readPatchedBunPreference(home))}`);
+};
+var bunPatch = async (args, home = homedir()) => {
+  const [action = "status"] = args;
+  if (action === "status") {
+    printStatus(home);
+    return;
+  }
+  if (action === "install") {
+    await installVerified(home);
+    console.log("`absolute dev` will use it from now on.");
+    return;
+  }
+  if (action === "remove") {
+    rmSync(join(absoluteHome(home), "bun"), {
+      force: true,
+      recursive: true
+    });
+    console.log("Removed the patched Bun. `absolute dev` uses your bun again.");
+    return;
+  }
+  if (action === "reset") {
+    writePatchedBunPreference(null, home);
+    console.log("`absolute dev` will offer the patched Bun again.");
+    return;
+  }
+  throw new Error(`Unknown bun-patch action "${action}". Use status, install, remove or reset.`);
+};
+
+export { PATCHED_BUN_RELEASE, installedPatchedBun, patchedBunAsset, patchedBunPath, runtimeSupportsReactFastRefresh, patchedBunOfferState, readPatchedBunPreference, readZipEntry, writePatchedBunPreference, PATCHED_BUN_EXPLANATION, installPatchedBun, parsePatchedBunChoice, patchedBunDownloadUrl, verifyPatchedBun, resolveDevBunExecutable, bunPatch };

package/dist/cli/index.js

@@ -58,13 +58,16 @@ if (command === "dev") {
   }
   const positionalArgs = stripNamedArgs("--config", "--android-device", "--ios-device").filter((arg) => arg !== "--no-mobile" && arg !== "--eager");
   const serverEntry = positionalArgs[0] ?? DEFAULT_SERVER_ENTRY;
-  const { dev } = await import("./dev-pdefc9ac.js");
+  const { dev } = await import("./dev-s7kct3xq.js");
   await dev(serverEntry, configPath, {
     androidDevice,
     eager: args.includes("--eager"),
     iosDevice,
     mobile: !args.includes("--no-mobile")
   });
+} else if (command === "bun-patch") {
+  const { bunPatch } = await import("./patchedBun-zjtrn2s4.js");
+  await bunPatch(args);
 } else if (command === "start") {
   sendTelemetryEvent("cli:command", { command });
   const outdir = parseNamedArg("--outdir");
@@ -208,7 +211,7 @@ if (command === "dev") {
   sendTelemetryEvent("cli:command", {
     command: `mobile:${workspaceCommand ?? "unknown"}`
   });
-  const { runMobile } = await import("./mobile-00bqw12c.js");
+  const { runMobile } = await import("./mobile-6kdsrhxy.js");
   try {
     await runMobile(args);
   } catch (error) {
@@ -267,6 +270,7 @@ if (command === "dev") {
   console.error("  routes [--json] List every route (pages + API) of a running dev server");
   console.error("  typecheck     Run type checkers for all frameworks");
   console.error("  migrate       Report what moving this project to AbsoluteJS involves");
+  console.error("  bun-patch [status|install|remove|reset] Bun with the React Fast Refresh fix (oven-sh/bun#32919)");
   console.error("  telemetry     Manage anonymous telemetry");
   console.error("  tunnel-relay  Run the public reverse-tunnel relay (for webhook dev)");
   process.exit(1);

package/dist/cli/patchedBun-zjtrn2s4.js

@@ -0,0 +1,38 @@
+// @bun
+import {
+  PATCHED_BUN_EXPLANATION,
+  PATCHED_BUN_RELEASE,
+  bunPatch,
+  installPatchedBun,
+  installedPatchedBun,
+  parsePatchedBunChoice,
+  patchedBunAsset,
+  patchedBunDownloadUrl,
+  patchedBunOfferState,
+  patchedBunPath,
+  readPatchedBunPreference,
+  readZipEntry,
+  resolveDevBunExecutable,
+  runtimeSupportsReactFastRefresh,
+  verifyPatchedBun,
+  writePatchedBunPreference
+} from "./index-hty8111z.js";
+import"./index-mywsk201.js";
+export {
+  PATCHED_BUN_EXPLANATION,
+  PATCHED_BUN_RELEASE,
+  bunPatch,
+  installPatchedBun,
+  installedPatchedBun,
+  parsePatchedBunChoice,
+  patchedBunAsset,
+  patchedBunDownloadUrl,
+  patchedBunOfferState,
+  patchedBunPath,
+  readPatchedBunPreference,
+  readZipEntry,
+  resolveDevBunExecutable,
+  runtimeSupportsReactFastRefresh,
+  verifyPatchedBun,
+  writePatchedBunPreference
+};

package/dist/dev/client/handlers/react.ts

@@ -7,7 +7,6 @@ import type {} from '../../../types/globals';
 import { hideErrorOverlay } from '../errorOverlay';
 import { detectCurrentFramework } from '../frameworkDetect';
 import { sendAbsoluteHmrTiming } from '../hmrTiming';
-import { swapCSSStylesheet } from '../cssUtils';
 
 const reloadReactPage = () => {
 	const url = new URL(window.location.href);
@@ -21,7 +20,9 @@ export const handleReactUpdate = (message: {
 		hasCSSChanges?: boolean;
 		hasComponentChanges?: boolean;
 		manifest?: Record<string, string>;
+		moduleUrls?: string[];
 		pageModuleUrl?: string;
+		pageModuleUrls?: Record<string, string>;
 		primarySource?: string;
 		serverDuration?: number;
 	};
@@ -30,30 +31,26 @@ export const handleReactUpdate = (message: {
 	const currentFramework = detectCurrentFramework();
 	if (currentFramework !== 'react') return;
 
-	const hasComponentChanges = message.data.hasComponentChanges !== false;
-	const hasCSSChanges = message.data.hasCSSChanges === true;
-	const cssPath =
-		message.data.manifest && message.data.manifest.ReactExampleCSS;
-	if (!hasComponentChanges && hasCSSChanges && cssPath) {
-		const clientStart = performance.now();
-		void reloadReactCSS(cssPath).then((applied) => {
-			sendAbsoluteHmrTiming({
-				clientStart,
-				kind: 'css',
-				outcome: applied ? 'applied' : 'failed',
-				serverMs: message.data.serverDuration,
-				updateId: message.timestamp
-			});
-		});
-
-		return;
-	}
+	// BUN-REACT-REFRESH-LEGACY: the remount/reload fallback for a dev server on
+	// stock Bun, which cannot emit React Fast Refresh registrations. Remove it,
+	// and the fastRefreshSupported message field, once the minimum Bun has the fix.
 	if (message.data.fastRefreshSupported === false) {
-		const { pageModuleUrl } = message.data;
+		// The remount re-renders the whole page, so it needs this page's
+		// module; a changed child's module would be rendered as the page.
+		const componentKey = window.__REACT_COMPONENT_KEY__;
+		const pageUrls = message.data.pageModuleUrls;
+		if (pageUrls && componentKey && !pageUrls[componentKey]) {
+			// This edit does not reach the page on screen.
+			return;
+		}
+		const remountUrl =
+			pageUrls && componentKey
+				? pageUrls[componentKey]
+				: message.data.pageModuleUrl;
 		const remount = window.__ABS_REACT_REMOUNT__;
-		if (pageModuleUrl && remount) {
+		if (remountUrl && remount) {
 			applyRemountImport(
-				pageModuleUrl,
+				remountUrl,
 				remount,
 				message.data.serverDuration,
 				message.timestamp
@@ -75,10 +72,15 @@ export const handleReactUpdate = (message: {
 	const refreshRuntime = window.$RefreshRuntime$;
 	const { serverDuration } = message.data;
 	const { pageModuleUrl } = message.data;
+	const fallbackUrls = pageModuleUrl ? [pageModuleUrl] : [];
+	const moduleUrls =
+		message.data.moduleUrls && message.data.moduleUrls.length > 0
+			? message.data.moduleUrls
+			: fallbackUrls;
 
-	if (pageModuleUrl && refreshRuntime) {
+	if (moduleUrls.length > 0 && refreshRuntime) {
 		applyRefreshImport(
-			pageModuleUrl,
+			moduleUrls,
 			refreshRuntime,
 			serverDuration,
 			message.timestamp
@@ -117,13 +119,16 @@ const finishUpdate = (
 };
 
 const applyRefreshImport = (
-	moduleUrl: string,
+	moduleUrls: string[],
 	refreshRuntime: { performReactRefresh: () => unknown },
 	serverDuration?: number,
 	updateId?: number
 ) => {
 	const clientStart = performance.now();
-	import(`${moduleUrl}?t=${Date.now()}`)
+	const stamp = Date.now();
+	// Every edited module has to run before the refresh, or a page that
+	// now renders a new child refreshes without it.
+	Promise.all(moduleUrls.map((url) => import(`${url}?t=${stamp}`)))
 		.then(() => {
 			refreshRuntime.performReactRefresh();
 			finishUpdate(clientStart, serverDuration, updateId);
@@ -175,16 +180,3 @@ const applyRemountImport = (
 			reloadReactPage();
 		});
 };
-
-const reloadReactCSS = (cssPath: string) =>
-	swapCSSStylesheet(cssPath, (href) => {
-		const hrefBase = (href.split('?')[0] ?? '').split('/').pop() ?? '';
-		const cssPathBase =
-			(cssPath.split('?')[0] ?? '').split('/').pop() ?? '';
-
-		return (
-			hrefBase === cssPathBase ||
-			href.includes('react-example') ||
-			cssPathBase.includes(hrefBase)
-		);
-	});

package/dist/dev/client/hmrClient.ts

@@ -200,6 +200,7 @@ type HMRMessage = {
 		affectedFrameworks?: string[];
 		column?: number;
 		error?: string;
+		// BUN-REACT-REFRESH-LEGACY: false only on stock Bun (see handlers/react.ts).
 		fastRefreshSupported?: boolean;
 		file?: string;
 		framework?: string;
@@ -209,8 +210,10 @@ type HMRMessage = {
 		line?: number;
 		lineText?: string;
 		manifest?: Record<string, string>;
+		moduleUrls?: string[];
 		moduleVersions?: Record<string, number>;
 		pageModuleUrl?: string;
+		pageModuleUrls?: Record<string, string>;
 		primarySource?: string;
 		scriptUrl?: string;
 		serverDuration?: number;

package/dist/dev/serverBootstrap.js

@@ -633,6 +633,16 @@ var markBootAt = (label, epochMs) => {
 };
 var processStartEpochMs = () => Date.now() - process.uptime() * MILLISECONDS_IN_A_SECOND;
 
+// src/dev/hotRejectionGuard.ts
+var installHotRejectionGuard = () => {
+  if (globalThis.__absoluteHotRejectionGuard)
+    return;
+  globalThis.__absoluteHotRejectionGuard = true;
+  process.on("unhandledRejection", (reason) => {
+    console.error(reason);
+  });
+};
+
 // src/dev/importCost/hint.ts
 var ENTRY_GRAPH_START = "server entry import start";
 var ENTRY_GRAPH_END = "framework runtime imported";
@@ -733,6 +743,7 @@ var isStaleAbsoluteServerEntryCopy = (name, currentPid = process.pid, ownerIsAli
 adoptParentBootMarks();
 markBootAt("child process start", processStartEpochMs());
 markBoot("bootstrap imports evaluated");
+installHotRejectionGuard();
 var originalEntry = process.env.ABSOLUTE_SERVER_ENTRY;
 if (!originalEntry) {
   throw new Error("ABSOLUTE_SERVER_ENTRY is required by the AbsoluteJS dev bootstrap");