@absolutejs/absolute 0.19.0-beta.1116 → 0.19.0-beta.1118

package/dist/cli/index.js

@@ -1158,6 +1158,356 @@ var init_devCert = __esm(() => {
   KEY_PATH = join5(CERT_DIR, "key.pem");
 });
 
+// src/cli/scripts/eslint.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync8,
+  renameSync,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION = "1", CACHE_FINGERPRINT_SUFFIX = ".fingerprint", flagValue = (args, flag) => {
+  const assignment = args.find((arg) => arg.startsWith(`${flag}=`));
+  if (assignment)
+    return assignment.slice(flag.length + 1);
+  const index = args.indexOf(flag);
+  return index < 0 ? undefined : args[index + 1];
+}, getCacheLocation = (args) => flagValue(args, "--cache-location")?.trim() || process.env.ABSOLUTE_ESLINT_CACHE?.trim() || DEFAULT_CACHE_LOCATION, CONFIG_CANDIDATES, FLAG_VALUE_FLAGS, hasUserPositional = (args) => {
+  for (let index = 0;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === undefined)
+      continue;
+    if (arg.startsWith("-")) {
+      if (arg.includes("="))
+        continue;
+      if (FLAG_VALUE_FLAGS.has(arg))
+        index++;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}, findConfigPath = (cwd = process.cwd()) => {
+  for (const name of CONFIG_CANDIDATES) {
+    const candidate = resolve4(cwd, name);
+    if (existsSync6(candidate))
+      return candidate;
+  }
+  return null;
+}, fingerprintLocation = (cacheLocation, cwd) => {
+  const absolute = resolve4(cwd, cacheLocation);
+  return /[\\/]$/.test(cacheLocation) ? resolve4(absolute, CACHE_FINGERPRINT_SUFFIX.slice(1)) : `${absolute}${CACHE_FINGERPRINT_SUFFIX}`;
+}, addFileToFingerprint = (hash, path, label) => {
+  if (!existsSync6(path))
+    return;
+  hash.update(label);
+  hash.update("\x00");
+  hash.update(readFileSync8(path));
+  hash.update("\x00");
+}, packageNameFor = (specifier) => {
+  if (specifier.startsWith("@"))
+    return specifier.split("/").slice(0, 2).join("/");
+  const [name = specifier] = specifier.split("/");
+  return name;
+}, configPackageNames = (configPath2) => {
+  if (!configPath2)
+    return [];
+  const source = readFileSync8(configPath2, "utf-8");
+  const names = new Set;
+  for (const match of source.matchAll(/(?:from\s+|import\s*(?:\(\s*)?|require\s*\(\s*)(['"])([^'".][^'"]*)\1/g)) {
+    const [, , specifier] = match;
+    if (specifier)
+      names.add(packageNameFor(specifier));
+  }
+  return [...names];
+}, manifestDependencyNames = (manifest) => {
+  if (manifest === null || typeof manifest !== "object")
+    return [];
+  return Object.entries(manifest).flatMap(([key, value]) => {
+    if (key !== "dependencies" && key !== "devDependencies")
+      return [];
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+      return [];
+    return Object.keys(value);
+  });
+}, lintDependencyNames = (cwd, configPath2) => {
+  const manifestPath = resolve4(cwd, "package.json");
+  if (!existsSync6(manifestPath))
+    return configPackageNames(configPath2);
+  try {
+    const manifest = JSON.parse(readFileSync8(manifestPath, "utf-8"));
+    const lintPackages = manifestDependencyNames(manifest).filter((name) => /eslint|typescript/.test(name));
+    return [
+      ...new Set([...lintPackages, ...configPackageNames(configPath2)])
+    ];
+  } catch {
+    return configPackageNames(configPath2);
+  }
+}, findInstalledManifest = (cwd, dependency) => {
+  let directory = cwd;
+  while (true) {
+    const candidate = resolve4(directory, "node_modules", dependency, "package.json");
+    if (existsSync6(candidate))
+      return candidate;
+    const parent = dirname3(directory);
+    if (parent === directory)
+      return null;
+    directory = parent;
+  }
+}, createEslintCacheFingerprint = (cwd = process.cwd()) => {
+  const hash = createHash("sha256");
+  hash.update(`absolute-eslint-cache:${CACHE_CONTRACT_VERSION}\x00`);
+  const configPath2 = findConfigPath(cwd);
+  if (configPath2)
+    addFileToFingerprint(hash, configPath2, configPath2);
+  for (const dependency of lintDependencyNames(cwd, configPath2).sort()) {
+    const manifestPath = findInstalledManifest(cwd, dependency);
+    if (manifestPath)
+      addFileToFingerprint(hash, manifestPath, dependency);
+  }
+  return hash.digest("hex");
+}, writeFingerprint = (path, fingerprint) => {
+  mkdirSync5(dirname3(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync5(temporary, `${fingerprint}
+`);
+  renameSync(temporary, path);
+}, prepareEslintCache = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const cachePath = resolve4(cwd, options.cacheLocation);
+  const metadataPath = fingerprintLocation(options.cacheLocation, cwd);
+  const fingerprint = options.fingerprint ?? createEslintCacheFingerprint(cwd);
+  const prior = existsSync6(metadataPath) ? readFileSync8(metadataPath, "utf-8").trim() : null;
+  if (prior === fingerprint)
+    return false;
+  rmSync3(cachePath, { force: true, recursive: true });
+  if (metadataPath !== cachePath)
+    rmSync3(metadataPath, { force: true, recursive: true });
+  writeFingerprint(metadataPath, fingerprint);
+  return true;
+}, hasKey = (objectLiteralSource, key) => {
+  const pattern = new RegExp(`(^|[\\s,{])${key}\\s*:`, "m");
+  return pattern.test(objectLiteralSource);
+}, NON_GLOBAL_IGNORE_KEYS, isGlobalIgnoresBlock = (block) => {
+  if (!hasKey(block, "ignores"))
+    return false;
+  return !NON_GLOBAL_IGNORE_KEYS.some((key) => hasKey(block, key));
+}, extractTopLevelObjectLiterals = (source) => {
+  const arrayStart = source.search(/defineConfig\s*\(\s*\[|export\s+default\s*\[/);
+  if (arrayStart === -1)
+    return [];
+  const fromArray = source.slice(arrayStart);
+  const openBracket = fromArray.indexOf("[");
+  if (openBracket === -1)
+    return [];
+  const blocks = [];
+  let depth = 0;
+  let blockStart = -1;
+  let inString = null;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = openBracket;i < fromArray.length; i++) {
+    const char = fromArray[i];
+    const next = fromArray[i + 1];
+    if (inLineComment) {
+      if (char === `
+`)
+        inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (char === "\\") {
+        i++;
+        continue;
+      }
+      if (char === inString)
+        inString = null;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      inLineComment = true;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      inString = char;
+      continue;
+    }
+    if (char === "{") {
+      if (depth === 0)
+        blockStart = i;
+      depth++;
+    } else if (char === "}") {
+      depth--;
+      if (depth === 0 && blockStart !== -1) {
+        blocks.push(fromArray.slice(blockStart, i + 1));
+        blockStart = -1;
+      }
+    } else if (char === "]" && depth === 0) {
+      break;
+    }
+  }
+  return blocks;
+}, checkForMisplacedIgnores = () => {
+  const configPath2 = findConfigPath();
+  if (!configPath2)
+    return;
+  let source;
+  try {
+    source = readFileSync8(configPath2, "utf-8");
+  } catch {
+    return;
+  }
+  const blocks = extractTopLevelObjectLiterals(source);
+  if (blocks.some(isGlobalIgnoresBlock))
+    return;
+  let offenderCount = 0;
+  for (const block of blocks) {
+    if (hasKey(block, "ignores") && hasKey(block, "files")) {
+      offenderCount++;
+    }
+  }
+  if (offenderCount === 0)
+    return;
+  const yellow = "\x1B[33m";
+  const reset = "\x1B[0m";
+  const bold = "\x1B[1m";
+  console.warn(`${yellow}${bold}\u26A0 ESLint flat-config warning${reset}${yellow}: found ${offenderCount} config block(s) where \`ignores\` lives alongside \`files\`. In ESLint v9, \`ignores\` is only a *global* ignore when it's the sole key in its config object \u2014 otherwise it just suppresses that block's own rules and ESLint still walks every other directory (including node_modules), making lint extremely slow.
+
+Move ignores into a standalone block at the top of your config:
+
+  export default defineConfig([
+    { ignores: ['node_modules/**', 'dist/**', 'build/**', '.absolutejs/**'] },
+    pluginJs.configs.recommended,
+    ...
+  ]);
+
+Detected at: ${configPath2}${reset}`);
+}, formatDuration = (durationMs) => {
+  if (durationMs < 1000)
+    return `${durationMs}ms`;
+  if (durationMs < 60000)
+    return `${(durationMs / 1000).toFixed(2)}s`;
+  const minutes = Math.floor(durationMs / 60000);
+  const seconds = Math.round(durationMs % 60000 / 1000);
+  return `${minutes}m ${seconds}s`;
+}, handleClearCache = (cacheLocation, cwd = process.cwd()) => {
+  try {
+    const cachePath = resolve4(cwd, cacheLocation);
+    const metadataPath = fingerprintLocation(cacheLocation, cwd);
+    rmSync3(cachePath, { force: true, recursive: true });
+    rmSync3(metadataPath, { force: true, recursive: true });
+    console.log(`\x1B[32m\u2713\x1B[0m Cleared cache: ${cacheLocation}`);
+  } catch (err) {
+    console.error(`\x1B[31m\u2717\x1B[0m Failed to clear cache at ${cacheLocation}:`, err);
+    process.exit(1);
+  }
+}, buildEslintCommand = (args, cacheLocation) => {
+  const cacheEnabled = !args.includes("--no-cache");
+  const hasCacheLocation = args.some((arg) => arg === "--cache-location" || arg.startsWith("--cache-location="));
+  const hasCacheStrategy = args.some((arg) => arg === "--cache-strategy" || arg.startsWith("--cache-strategy="));
+  return [
+    "bun",
+    "eslint",
+    ...cacheEnabled ? ["--cache"] : [],
+    ...cacheEnabled && !hasCacheLocation ? ["--cache-location", cacheLocation] : [],
+    ...cacheEnabled && !hasCacheStrategy ? ["--cache-strategy", "content"] : [],
+    ...args,
+    ...hasUserPositional(args) ? [] : ["."]
+  ];
+}, eslint = async (args) => {
+  const cacheLocation = getCacheLocation(args);
+  if (args.includes("--clear-cache")) {
+    handleClearCache(cacheLocation);
+    return;
+  }
+  if (!existsSync6(resolve4("node_modules", ".bin", "eslint"))) {
+    console.error("\x1B[31m\u2717\x1B[0m ESLint is not installed in this project. Add it (and a flat `eslint.config.*`): bun add -d eslint");
+    process.exit(1);
+  }
+  checkForMisplacedIgnores();
+  const cacheEnabled = !args.includes("--no-cache");
+  if (cacheEnabled)
+    prepareEslintCache({ cacheLocation });
+  const command = buildEslintCommand(args, cacheLocation);
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  console.log(cacheEnabled ? `${dim}cache: ${cacheLocation} (content-aware; lint-tool changes invalidate automatically)${reset}` : `${dim}cache: disabled${reset}`);
+  const startedAt = Date.now();
+  const proc = Bun.spawn(command, {
+    stderr: "inherit",
+    stdout: "inherit"
+  });
+  const exitCode = await proc.exited;
+  const elapsed = formatDuration(Date.now() - startedAt);
+  if (exitCode !== 0) {
+    console.log(`${dim}elapsed: ${elapsed}${reset}`);
+    process.exit(exitCode);
+  }
+  console.log(`\x1B[32m\u2713\x1B[0m Passed ${dim}(${elapsed})${reset}`);
+};
+var init_eslint = __esm(() => {
+  CONFIG_CANDIDATES = [
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs",
+    "eslint.config.ts",
+    "eslint.config.mts",
+    "eslint.config.cts"
+  ];
+  FLAG_VALUE_FLAGS = new Set([
+    "-c",
+    "--config",
+    "--cache-location",
+    "--cache-strategy",
+    "--ignore-path",
+    "--ignore-pattern",
+    "--rule",
+    "--rulesdir",
+    "--ext",
+    "-f",
+    "--format",
+    "--max-warnings",
+    "--parser",
+    "--parser-options",
+    "--plugin",
+    "--global",
+    "--env",
+    "--report-unused-disable-directives-severity",
+    "--resolve-plugins-relative-to",
+    "-o",
+    "--output-file",
+    "--flag",
+    "--inspect-config",
+    "--stats",
+    "--concurrency"
+  ]);
+  NON_GLOBAL_IGNORE_KEYS = [
+    "files",
+    "rules",
+    "plugins",
+    "languageOptions",
+    "linterOptions",
+    "processor",
+    "settings",
+    "extends"
+  ];
+});
+
 // src/utils/stripStringsAndComments.ts
 var stripStringsAndComments = (source) => {
   const { length } = source;
@@ -171289,10 +171639,198 @@ var init_build = __esm(() => {
   FRAMEWORK_KEYS = ["react", "vue", "svelte", "angular", "html", "htmx"];
 });
 
+// src/cli/scripts/lintProof.ts
+var exports_lintProof = {};
+__export(exports_lintProof, {
+  writeLintProof: () => writeLintProof,
+  verifyLintProof: () => verifyLintProof,
+  runLintProof: () => runLintProof,
+  createLintSourceTree: () => createLintSourceTree,
+  createLintProof: () => createLintProof
+});
+import { createHash as createHash2 } from "crypto";
+import {
+  existsSync as existsSync11,
+  lstatSync,
+  mkdirSync as mkdirSync8,
+  mkdtempSync,
+  readFileSync as readFileSync14,
+  renameSync as renameSync2,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync7
+} from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { delimiter, dirname as dirname5, relative as relative2, resolve as resolve11 } from "path";
+var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSION = 1, runGit = (args, options) => {
+  const proc = Bun.spawnSync(["git", ...args], {
+    cwd: options.cwd,
+    env: { ...process.env, ...options.env },
+    stderr: "pipe",
+    stdout: "pipe"
+  });
+  if (proc.exitCode !== 0) {
+    const detail = proc.stderr.toString().trim();
+    throw new Error(detail || `git ${args.join(" ")} failed`);
+  }
+  return proc.stdout.toString().trim();
+}, gitRoot = (cwd) => resolve11(runGit(["rev-parse", "--show-toplevel"], { cwd })), createLintSourceTree = (cwd = process.cwd(), proofLocation = DEFAULT_PROOF_LOCATION) => {
+  const root = gitRoot(cwd);
+  const proofPath = resolve11(cwd, proofLocation);
+  const proofRelative = relative2(root, proofPath).replaceAll("\\", "/");
+  if (proofRelative === ".." || proofRelative.startsWith("../") || proofRelative === "") {
+    throw new Error("lint proof must live inside the Git working tree");
+  }
+  const temporaryDirectory = mkdtempSync(resolve11(tmpdir2(), "absolute-lint-proof-"));
+  const temporaryIndex = resolve11(temporaryDirectory, "index");
+  const temporaryObjects = resolve11(temporaryDirectory, "objects");
+  mkdirSync8(temporaryObjects, { recursive: true });
+  const repositoryObjectsPath = runGit(["rev-parse", "--git-path", "objects"], { cwd: root });
+  const repositoryObjects = resolve11(root, repositoryObjectsPath);
+  const existingAlternates = process.env.GIT_ALTERNATE_OBJECT_DIRECTORIES?.trim();
+  const env3 = {
+    GIT_ALTERNATE_OBJECT_DIRECTORIES: [
+      repositoryObjects,
+      ...existingAlternates ? [existingAlternates] : []
+    ].join(delimiter),
+    GIT_INDEX_FILE: temporaryIndex,
+    GIT_OBJECT_DIRECTORY: temporaryObjects
+  };
+  try {
+    runGit(["read-tree", "--empty"], { cwd: root, env: env3 });
+    const files = runGit(["ls-files", "--cached", "--others", "--exclude-standard", "-z"], { cwd: root }).split("\x00").filter((path) => {
+      if (!path || path === proofRelative)
+        return false;
+      try {
+        lstatSync(resolve11(root, path));
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    for (let index = 0;index < files.length; index += 200) {
+      runGit(["add", "-f", "--", ...files.slice(index, index + 200)], {
+        cwd: root,
+        env: env3
+      });
+    }
+    return runGit(["write-tree"], { cwd: root, env: env3 });
+  } finally {
+    rmSync5(temporaryDirectory, { force: true, recursive: true });
+  }
+}, proofFingerprint = (cwd) => createHash2("sha256").update(`absolute-lint-proof:${PROOF_CONTRACT_VERSION}\x00`).update(createEslintCacheFingerprint(cwd)).digest("hex"), createLintProof = (command, options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
+  return {
+    command,
+    contractVersion: PROOF_CONTRACT_VERSION,
+    createdAt: new Date().toISOString(),
+    lintFingerprint: proofFingerprint(cwd),
+    sourceTree: createLintSourceTree(cwd, proofLocation)
+  };
+}, writeLintProof = (command, options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
+  const path = resolve11(cwd, proofLocation);
+  const temporary = `${path}.${process.pid}.tmp`;
+  const proof = createLintProof(command, { cwd, proofLocation });
+  mkdirSync8(dirname5(path), { recursive: true });
+  writeFileSync7(temporary, `${JSON.stringify(proof, null, 2)}
+`);
+  renameSync2(temporary, path);
+  return proof;
+}, isLintProof = (value) => {
+  if (value === null || typeof value !== "object")
+    return false;
+  const proof = value;
+  return proof.contractVersion === PROOF_CONTRACT_VERSION && Array.isArray(proof.command) && proof.command.every((part) => typeof part === "string") && typeof proof.createdAt === "string" && typeof proof.lintFingerprint === "string" && typeof proof.sourceTree === "string";
+}, verifyLintProof = (command, options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
+  const path = resolve11(cwd, proofLocation);
+  if (!existsSync11(path))
+    return { reason: `missing lint proof: ${proofLocation}`, valid: false };
+  let proof;
+  try {
+    proof = JSON.parse(readFileSync14(path, "utf-8"));
+  } catch {
+    return { reason: `invalid lint proof: ${proofLocation}`, valid: false };
+  }
+  if (!isLintProof(proof))
+    return { reason: "unsupported lint proof contract", valid: false };
+  if (JSON.stringify(proof.command) !== JSON.stringify(command))
+    return {
+      reason: "lint command differs from the recorded command",
+      valid: false
+    };
+  if (proof.lintFingerprint !== proofFingerprint(cwd))
+    return {
+      reason: "ESLint configuration or toolchain changed",
+      valid: false
+    };
+  if (proof.sourceTree !== createLintSourceTree(cwd, proofLocation))
+    return {
+      reason: "source tree changed since lint passed",
+      valid: false
+    };
+  return { proof, valid: true };
+}, parseArgs = (args) => {
+  const separator = args.indexOf("--");
+  const controlArgs = separator === -1 ? args : args.slice(0, separator);
+  const command = separator === -1 ? [] : args.slice(separator + 1);
+  const proofFlag = controlArgs.indexOf("--proof");
+  const proofLocation = proofFlag === -1 ? DEFAULT_PROOF_LOCATION : controlArgs[proofFlag + 1];
+  if (!proofLocation)
+    throw new Error("--proof requires a path");
+  return { command, proofLocation };
+}, runLintProof = async (args) => {
+  const [operation] = args;
+  if (operation !== "run" && operation !== "verify") {
+    console.error("Usage: absolute lint-proof <run|verify> [--proof path] -- <lint command>");
+    return 2;
+  }
+  let parsed;
+  try {
+    parsed = parseArgs(args.slice(1));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 2;
+  }
+  if (parsed.command.length === 0) {
+    console.error("A lint command is required after --");
+    return 2;
+  }
+  if (operation === "verify") {
+    const result = verifyLintProof(parsed.command, {
+      proofLocation: parsed.proofLocation
+    });
+    if (!result.valid) {
+      console.error(`\x1B[31m\u2717\x1B[0m ${result.reason}`);
+      return 1;
+    }
+    console.log(`\x1B[32m\u2713\x1B[0m Lint proof matches the source tree, command, and lint toolchain`);
+    return 0;
+  }
+  const proc = Bun.spawn(parsed.command, {
+    stderr: "inherit",
+    stdout: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    console.error("\x1B[31m\u2717\x1B[0m Lint failed; proof was not updated");
+    return exitCode;
+  }
+  writeLintProof(parsed.command, { proofLocation: parsed.proofLocation });
+  console.log(`\x1B[32m\u2713\x1B[0m Wrote exact-source lint proof: ${parsed.proofLocation}`);
+  return 0;
+};
+var init_lintProof = __esm(() => {
+  init_eslint();
+});
+
 // src/build/scanConventions.ts
 import { basename as basename4 } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 var CONVENTION_RE, classifyFile = (file, pageFiles, defaults, pages) => {
   const fileName = basename4(file);
   const match = CONVENTION_RE.exec(fileName);
@@ -171317,7 +171855,7 @@ var CONVENTION_RE, classifyFile = (file, pageFiles, defaults, pages) => {
   else if (kind === "loading")
     pages[pageName].loading = file;
 }, scanConventions = async (pagesDir, pattern) => {
-  if (!existsSync11(pagesDir)) {
+  if (!existsSync12(pagesDir)) {
     const pageFiles2 = [];
     return { conventions: undefined, pageFiles: pageFiles2 };
   }
@@ -171352,8 +171890,8 @@ var exports_ls = {};
 __export(exports_ls, {
   runLs: () => runLs
 });
-import { existsSync as existsSync12, readFileSync as readFileSync14, statSync } from "fs";
-import { basename as basename5, extname as extname2, join as join13, relative as relative2 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync15, statSync } from "fs";
+import { basename as basename5, extname as extname2, join as join13, relative as relative3 } from "path";
 var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELDS, readStringField = (source, key) => {
   const value = Reflect.get(source, key);
   return typeof value === "string" ? value : undefined;
@@ -171368,7 +171906,7 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
   } catch {
     return null;
   }
-}, relativeOrSelf = (target) => relative2(process.cwd(), target) || target, configCandidates = (raw) => isWorkspaceConfig(raw) ? Object.values(raw).map((service) => ({
+}, relativeOrSelf = (target) => relative3(process.cwd(), target) || target, configCandidates = (raw) => isWorkspaceConfig(raw) ? Object.values(raw).map((service) => ({
   baseDir: readStringField(service, "cwd") ?? ".",
   source: service
 })) : [{ baseDir: ".", source: raw }], specsFor = (source, baseDir) => FRAMEWORK_FIELDS.flatMap((framework) => {
@@ -171403,10 +171941,10 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
     return pages ? [{ label, pages: sortPages(pages) }] : [];
   });
 }, resolveDiskPath = (buildDir, value) => {
-  if (existsSync12(value))
+  if (existsSync13(value))
     return value;
   const underBuild = join13(buildDir, value);
-  if (existsSync12(underBuild))
+  if (existsSync13(underBuild))
     return underBuild;
   return join13(process.cwd(), value);
 }, fileSize = (diskPath) => {
@@ -171416,7 +171954,7 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
     return 0;
   }
 }, readManifestSizes = (manifestDir) => {
-  const manifest = JSON.parse(readFileSync14(join13(manifestDir, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync15(join13(manifestDir, "manifest.json"), "utf-8"));
   const sizes = new Map;
   Object.entries(manifest).forEach(([key, value]) => {
     sizes.set(key, fileSize(resolveDiskPath(manifestDir, value)));
@@ -171534,7 +172072,7 @@ ${colors.dim}${frameworkCount} ${frameworkCount === 1 ? "framework" : "framework
   }
   const sizesDir = resolveSizesDir(args, candidates);
   const manifestPath = join13(sizesDir, "manifest.json");
-  if (!existsSync12(manifestPath)) {
+  if (!existsSync13(manifestPath)) {
     printDim(`No build at ${relativeOrSelf(manifestPath)}. Run \`absolute build\` first, or pass \`--outdir <dir>\`.`);
     return;
   }
@@ -171658,21 +172196,21 @@ var init_discoverInstances = __esm(() => {
 import { createConnection as createConnection2 } from "net";
 var {$: $4 } = globalThis.Bun;
 var displayHost = (host) => host === "0.0.0.0" || host === "::" ? "localhost" : host, probePort = (host, port) => {
-  const { promise, resolve: resolve11 } = Promise.withResolvers();
+  const { promise, resolve: resolve12 } = Promise.withResolvers();
   const socket = createConnection2({ host: displayHost(host), port });
   const timeout = setTimeout(() => {
     socket.destroy();
-    resolve11(false);
+    resolve12(false);
   }, INSTANCE_PROBE_TIMEOUT_MS);
   socket.once("connect", () => {
     clearTimeout(timeout);
     socket.end();
-    resolve11(true);
+    resolve12(true);
   });
   socket.once("error", () => {
     clearTimeout(timeout);
     socket.destroy();
-    resolve11(false);
+    resolve12(false);
   });
   return promise;
 }, probeStatus = async (record) => {
@@ -172384,9 +172922,9 @@ var exports_heapDiff = {};
 __export(exports_heapDiff, {
   runHeapDiff: () => runHeapDiff
 });
-import { existsSync as existsSync13, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
 var TOP = 15, STRING_TYPES, aggregate = (path) => {
-  const data = JSON.parse(readFileSync15(path, "utf-8"));
+  const data = JSON.parse(readFileSync16(path, "utf-8"));
   const { nodes, strings } = data;
   const { node_fields: fields, node_types: nodeTypes } = data.snapshot.meta;
   const [typeNames] = nodeTypes;
@@ -172415,7 +172953,7 @@ var TOP = 15, STRING_TYPES, aggregate = (path) => {
     return;
   }
   for (const path of [beforePath, afterPath]) {
-    if (existsSync13(path))
+    if (existsSync14(path))
       continue;
     process.stdout.write(`${colors.red}No such file: ${path}${colors.reset}
 `);
@@ -172535,16 +173073,16 @@ var isRecord3 = (value) => typeof value === "object" && value !== null && !Array
 
 // src/cli/config/schema/fromType.ts
 import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync16,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync17,
   statSync as statSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 var import_typescript3, VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFrameworkRepo = (cwd) => {
   try {
-    const pkg = JSON.parse(readFileSync16(resolve11(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync17(resolve12(cwd, "package.json"), "utf-8"));
     return pkg?.name === "@absolutejs/absolute";
   } catch {
     return false;
@@ -172565,14 +173103,14 @@ var import_typescript3, VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DE
   };
 }, SCHEMA_VERSION = 1, packageVersion = (cwd, specifier) => {
   const candidates = specifier === "@absolutejs/absolute" ? [
-    resolve11(cwd, "node_modules", "@absolutejs", "absolute", "package.json"),
-    resolve11(cwd, "package.json")
+    resolve12(cwd, "node_modules", "@absolutejs", "absolute", "package.json"),
+    resolve12(cwd, "package.json")
   ] : [
-    resolve11(cwd, "node_modules", ...specifier.split("/"), "package.json")
+    resolve12(cwd, "node_modules", ...specifier.split("/"), "package.json")
   ];
   for (const candidate of candidates) {
     try {
-      const { version: version2 } = JSON.parse(readFileSync16(candidate, "utf-8"));
+      const { version: version2 } = JSON.parse(readFileSync17(candidate, "utf-8"));
       if (typeof version2 === "string")
         return version2;
     } catch {}
@@ -172583,16 +173121,16 @@ var import_typescript3, VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DE
   if (local) {
     const file = typeName === "PackageJson" ? "packageJson.ts" : "build.ts";
     try {
-      signature += `:${statSync2(resolve11(cwd, "types", file)).mtimeMs}`;
+      signature += `:${statSync2(resolve12(cwd, "types", file)).mtimeMs}`;
     } catch {}
   }
   return signature;
 }, cacheSlug = (specifier) => specifier.replace("@", "").split("/").join("-"), cacheFile = (cwd, typeName, specifier) => {
   const name = specifier === "@absolutejs/absolute" ? typeName : `${typeName}.${cacheSlug(specifier)}`;
-  return resolve11(cwd, ".absolutejs", "config-schema", `${name}.json`);
+  return resolve12(cwd, ".absolutejs", "config-schema", `${name}.json`);
 }, readDiskCache = (cwd, typeName, signature, specifier) => {
   try {
-    const cached = JSON.parse(readFileSync16(cacheFile(cwd, typeName, specifier), "utf-8"));
+    const cached = JSON.parse(readFileSync17(cacheFile(cwd, typeName, specifier), "utf-8"));
     if (isRecord3(cached) && cached.signature === signature && Array.isArray(cached.fields)) {
       return cached.fields;
     }
@@ -172600,10 +173138,10 @@ var import_typescript3, VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DE
   return null;
 }, writeDiskCache = (cwd, typeName, signature, fields, specifier) => {
   try {
-    mkdirSync8(resolve11(cwd, ".absolutejs", "config-schema"), {
+    mkdirSync9(resolve12(cwd, ".absolutejs", "config-schema"), {
       recursive: true
     });
-    writeFileSync7(cacheFile(cwd, typeName, specifier), JSON.stringify({ fields, signature }));
+    writeFileSync8(cacheFile(cwd, typeName, specifier), JSON.stringify({ fields, signature }));
   } catch {}
 }, docOf = (symbol, checker) => import_typescript3.default.displayPartsToString(symbol.getDocumentationComment(checker)).trim(), typeOfSymbol = (symbol, checker) => {
   const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
@@ -172687,7 +173225,7 @@ var import_typescript3, VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DE
   }
   return opaque();
 }, introspectFrom = (cwd, specifier, typeName, options, exclude) => {
-  const virtualPath = resolve11(cwd, VIRTUAL_NAME);
+  const virtualPath = resolve12(cwd, VIRTUAL_NAME);
   const source = `import type { ${typeName} } from '${specifier}';
 declare const value: ${typeName};
 export { value };
@@ -172730,7 +173268,7 @@ export { value };
   const cached = cache.get(cacheKey);
   if (cached)
     return cached;
-  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync14(resolve11(cwd, "types/index.ts"));
+  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync15(resolve12(cwd, "types/index.ts"));
   const signature = cacheSignature(cwd, typeName, local, specifier);
   const fromDisk = readDiskCache(cwd, typeName, signature, specifier);
   if (fromDisk) {
@@ -172758,16 +173296,16 @@ var init_fromType = __esm(() => {
 });
 
 // src/cli/config/absolute/resolveAbsoluteConfig.ts
-import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
-import { resolve as resolve12 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync18 } from "fs";
+import { resolve as resolve13 } from "path";
 var import_typescript4, CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath2 = (cwd, override) => {
   if (override) {
-    const resolved = resolve12(cwd, override);
-    return existsSync15(resolved) ? resolved : null;
+    const resolved = resolve13(cwd, override);
+    return existsSync16(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES2) {
-    const candidate = resolve12(cwd, name);
-    if (existsSync15(candidate))
+    const candidate = resolve13(cwd, name);
+    if (existsSync16(candidate))
       return candidate;
   }
   return null;
@@ -172788,7 +173326,7 @@ var import_typescript4, CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath2 = (c
   }
   return null;
 }, parseConfigObject = (configPath2) => {
-  const text = readFileSync17(configPath2, "utf-8");
+  const text = readFileSync18(configPath2, "utf-8");
   return { object: findConfigObject(parseSource(configPath2, text)), text };
 }, evalLiteral = (node) => {
   if (import_typescript4.default.isStringLiteralLike(node)) {
@@ -173000,8 +173538,8 @@ var init_frameworks = __esm(() => {
 });
 
 // src/cli/generate/context.ts
-import { dirname as dirname5, isAbsolute, join as join14, relative as relative3, resolve as resolve13 } from "path";
-var asString = (value) => typeof value === "string" ? value : undefined, isRecord4 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute(value) ? value : resolve13(cwd, value), resolveStylesDir = (cwd, config) => {
+import { dirname as dirname6, isAbsolute, join as join14, relative as relative4, resolve as resolve14 } from "path";
+var asString = (value) => typeof value === "string" ? value : undefined, isRecord4 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute(value) ? value : resolve14(cwd, value), resolveStylesDir = (cwd, config) => {
   const styles = config.stylesConfig;
   if (typeof styles === "string")
     return resolveDir(cwd, styles);
@@ -173010,10 +173548,10 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
     if (indexes)
       return resolveDir(cwd, indexes);
   }
-  return resolve13(cwd, "src/frontend/styles/indexes");
+  return resolve14(cwd, "src/frontend/styles/indexes");
 }, configuredFrameworks = (project) => FRAMEWORK_KEYS2.filter((key) => project.frameworkDirs[key] !== undefined), frontendRootFor = (project, framework) => {
   const dir = project.frameworkDirs[framework];
-  return dir ? dirname5(dir) : resolve13(project.cwd, "src/frontend");
+  return dir ? dirname6(dir) : resolve14(project.cwd, "src/frontend");
 }, resolveProject = async (cwd, configOverride) => {
   const loaded = await loadConfig(configOverride);
   const config = isRecord4(loaded) ? loaded : {};
@@ -173064,7 +173602,7 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
     ok: false
   };
 }, sharedDirFor = (project, framework) => join14(frontendRootFor(project, framework), "shared"), toModuleSpecifier = (fromDir, toFileNoExt) => {
-  const rel = relative3(fromDir, toFileNoExt).split("\\").join("/");
+  const rel = relative4(fromDir, toFileNoExt).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 };
 var init_context = __esm(() => {
@@ -173091,8 +173629,8 @@ var emptyOutcome = () => ({
 });
 
 // src/cli/generate/routeWiring.ts
-import { existsSync as existsSync16, readFileSync as readFileSync18, readdirSync as readdirSync4, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname6, join as join15 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync19, readdirSync as readdirSync4, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname7, join as join15 } from "path";
 var import_typescript5, DEFAULT_SEPARATOR = `
 		`, BOUNDARY_USE, applyEdits = (text, edits) => {
   const ordered = [...edits].sort((first, second) => second.start - first.start);
@@ -173240,13 +173778,13 @@ ${newLines.join(`
   return lines.join(`
 `);
 }, hasChain = (path) => {
-  if (!existsSync16(path))
+  if (!existsSync17(path))
     return false;
-  const sourceFile = parse2(path, readFileSync18(path, "utf-8"));
+  const sourceFile = parse2(path, readFileSync19(path, "utf-8"));
   const found = findElysiaNew(sourceFile);
   return found !== null;
 }, firstChainFile = (pluginsDir) => {
-  if (!existsSync16(pluginsDir))
+  if (!existsSync17(pluginsDir))
     return null;
   for (const name of readdirSync4(pluginsDir)) {
     if (!name.endsWith(".ts"))
@@ -173257,7 +173795,7 @@ ${newLines.join(`
   }
   return null;
 }, findRoutingFile = (serverEntry) => {
-  const pluginsDir = join15(dirname6(serverEntry), "plugins");
+  const pluginsDir = join15(dirname7(serverEntry), "plugins");
   const preferred = join15(pluginsDir, "pagesPlugin.ts");
   if (hasChain(preferred))
     return preferred;
@@ -173268,7 +173806,7 @@ ${newLines.join(`
     return serverEntry;
   return null;
 }, buildRouteContext = (input, routingFile) => {
-  const specifier = `${toModuleSpecifier(dirname6(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
+  const specifier = `${toModuleSpecifier(dirname7(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
   return {
     cssAssetKey: input.cssAssetKey,
     indexKey: input.indexKey,
@@ -173291,7 +173829,7 @@ ${newLines.join(`
   };
   if (!hasChain(serverEntry))
     return fallback;
-  const text = readFileSync18(serverEntry, "utf-8");
+  const text = readFileSync19(serverEntry, "utf-8");
   const sourceFile = parse2(serverEntry, text);
   const newExpr = findElysiaNew(sourceFile);
   if (!newExpr)
@@ -173304,7 +173842,7 @@ ${newLines.join(`
     start: offset,
     text: `${separator}.use(${pluginName})`
   });
-  writeFileSync8(serverEntry, applyEdits(text, edits), "utf-8");
+  writeFileSync9(serverEntry, applyEdits(text, edits), "utf-8");
   return { kind: "edited", routingFile: serverEntry };
 }, wireRoute = (input) => {
   const routingFile = findRoutingFile(input.serverEntry);
@@ -173320,7 +173858,7 @@ ${newLines.join(`
 ${routeExpr}`
     };
   }
-  const text = readFileSync18(routingFile, "utf-8");
+  const text = readFileSync19(routingFile, "utf-8");
   const sourceFile = parse2(routingFile, text);
   const newExpr = findElysiaNew(sourceFile);
   if (!newExpr) {
@@ -173340,7 +173878,7 @@ ${routeExpr}`
     start: offset,
     text: `${separator}${routeExpr}`
   });
-  writeFileSync8(routingFile, applyEdits(text, edits), "utf-8");
+  writeFileSync9(routingFile, applyEdits(text, edits), "utf-8");
   return { kind: "edited", routingFile };
 };
 var init_routeWiring = __esm(() => {
@@ -173350,8 +173888,8 @@ var init_routeWiring = __esm(() => {
 });
 
 // src/cli/generate/generateApi.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname7, join as join16 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname8, join as join16 } from "path";
 var apiPluginTemplate = (pluginName, base) => `import { Elysia } from 'elysia';
 
 export const ${pluginName} = new Elysia()
@@ -173363,16 +173901,16 @@ export const ${pluginName} = new Elysia()
   const pluginName = `${camel}Plugin`;
   const base = `/api/${kebab}`;
   const outcome = { ...emptyOutcome(), route: base };
-  const pluginsDir = join16(dirname7(project.serverEntry), "plugins");
+  const pluginsDir = join16(dirname8(project.serverEntry), "plugins");
   const fileAbs = join16(pluginsDir, `${pluginName}.ts`);
-  if (existsSync17(fileAbs)) {
+  if (existsSync18(fileAbs)) {
     outcome.notes.push(`${pluginName} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
-  mkdirSync9(pluginsDir, { recursive: true });
-  writeFileSync9(fileAbs, apiPluginTemplate(pluginName, base), "utf-8");
+  mkdirSync10(pluginsDir, { recursive: true });
+  writeFileSync10(fileAbs, apiPluginTemplate(pluginName, base), "utf-8");
   outcome.created.push(fileAbs);
-  const specifier = toModuleSpecifier(dirname7(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
+  const specifier = toModuleSpecifier(dirname8(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
   const wired = wirePluginUse(project.serverEntry, pluginName, specifier);
   if (wired.kind === "edited")
     outcome.updated.push(wired.routingFile);
@@ -173438,8 +173976,8 @@ var init_componentTemplates = __esm(() => {
 });
 
 // src/cli/generate/generateComponent.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname8, join as join17 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname9, join as join17 } from "path";
 var generateComponent = (project, framework, rawName) => {
   const def = frameworks2[framework];
   const pascal = toPascalCase(rawName);
@@ -173451,12 +173989,12 @@ var generateComponent = (project, framework, rawName) => {
     return outcome;
   }
   const fileAbs = join17(frameworkDir, "components", def.componentFile({ kebab, pascal }));
-  if (existsSync18(fileAbs)) {
+  if (existsSync19(fileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
-  mkdirSync10(dirname8(fileAbs), { recursive: true });
-  writeFileSync10(fileAbs, componentTemplates[framework]({
+  mkdirSync11(dirname9(fileAbs), { recursive: true });
+  writeFileSync11(fileAbs, componentTemplates[framework]({
     kebab,
     pascal,
     title: toTitleCase(rawName)
@@ -173470,7 +174008,7 @@ var init_generateComponent = __esm(() => {
 });
 
 // src/cli/generate/cssStrategy.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { join as join18 } from "path";
 var import_typescript6, CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
 	margin: 0 auto;
@@ -173518,7 +174056,7 @@ var import_typescript6, CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `
     return {
       assetKey: sharedKey,
       contents: DEFAULT_CSS,
-      create: !existsSync19(cssFileAbs2),
+      create: !existsSync20(cssFileAbs2),
       cssFileAbs: cssFileAbs2,
       shared: true
     };
@@ -173527,7 +174065,7 @@ var import_typescript6, CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `
   return {
     assetKey: `${pascal}${CSS_SUFFIX}`,
     contents: DEFAULT_CSS,
-    create: !existsSync19(cssFileAbs),
+    create: !existsSync20(cssFileAbs),
     cssFileAbs,
     shared: false
   };
@@ -173537,8 +174075,8 @@ var init_cssStrategy = __esm(() => {
 });
 
 // src/cli/generate/navData.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname9 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname10 } from "path";
 var import_typescript7, NAV_DATA_TEMPLATE = `type NavItem = {
 	href: string;
 	label: string;
@@ -173576,9 +174114,9 @@ export const navData: NavItem[] = [];
   }
   return items;
 }, readNavItems = (navDataPath) => {
-  if (!existsSync20(navDataPath))
+  if (!existsSync21(navDataPath))
     return [];
-  const text = readFileSync19(navDataPath, "utf-8");
+  const text = readFileSync20(navDataPath, "utf-8");
   const sourceFile = import_typescript7.default.createSourceFile(navDataPath, text, import_typescript7.default.ScriptTarget.Latest, true);
   const array = findNavArray(sourceFile);
   return array ? parseNavItems(array) : [];
@@ -173613,22 +174151,22 @@ ${indentOf(text, array.getStart(sourceFile))}`;
 ${indent}${entry}`;
   return text.slice(0, insertAt) + insertion + text.slice(insertAt);
 }, upsertNavItem = (navDataPath, item) => {
-  const created = !existsSync20(navDataPath);
+  const created = !existsSync21(navDataPath);
   if (created) {
-    mkdirSync11(dirname9(navDataPath), { recursive: true });
-    writeFileSync11(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
+    mkdirSync12(dirname10(navDataPath), { recursive: true });
+    writeFileSync12(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
   }
   const existing = readNavItems(navDataPath);
   if (existing.some((candidate) => candidate.href === item.href)) {
     return { changed: created, created, items: existing };
   }
-  const text = readFileSync19(navDataPath, "utf-8");
+  const text = readFileSync20(navDataPath, "utf-8");
   const sourceFile = import_typescript7.default.createSourceFile(navDataPath, text, import_typescript7.default.ScriptTarget.Latest, true);
   const array = findNavArray(sourceFile);
   if (!array)
     return { changed: created, created, items: existing };
   const entry = `{ href: '${item.href}', label: '${item.label}' }`;
-  writeFileSync11(navDataPath, insertElement(text, array, sourceFile, entry), "utf-8");
+  writeFileSync12(navDataPath, insertElement(text, array, sourceFile, entry), "utf-8");
   return { changed: true, created, items: [...existing, item] };
 };
 var init_navData = __esm(() => {
@@ -173781,25 +174319,25 @@ var init_pageTemplates = __esm(() => {
 
 // src/cli/generate/generatePage.ts
 import {
-  existsSync as existsSync21,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync20,
+  existsSync as existsSync22,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync21,
   readdirSync as readdirSync5,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname10, join as join19, relative as relative4 } from "path";
+import { dirname as dirname11, join as join19, relative as relative5 } from "path";
 var writeNew = (path, contents) => {
-  mkdirSync12(dirname10(path), { recursive: true });
-  writeFileSync12(path, contents, "utf-8");
+  mkdirSync13(dirname11(path), { recursive: true });
+  writeFileSync13(path, contents, "utf-8");
 }, toHref = (fromDir, toFile) => {
-  const rel = relative4(fromDir, toFile).split("\\").join("/");
+  const rel = relative5(fromDir, toFile).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
-}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join19(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync21(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join19(pagesDir, name))), resyncPage = (file, items) => {
-  const html = readFileSync20(file, "utf-8");
+}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join19(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync22(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join19(pagesDir, name))), resyncPage = (file, items) => {
+  const html = readFileSync21(file, "utf-8");
   const synced = syncStaticNav(html, items);
   if (synced === null || synced === html)
     return false;
-  writeFileSync12(file, synced, "utf-8");
+  writeFileSync13(file, synced, "utf-8");
   return true;
 }, resyncStaticPages = (project, items, skipFile) => {
   const updated = [];
@@ -173823,18 +174361,18 @@ var writeNew = (path, contents) => {
     return outcome;
   }
   const pageFileAbs = join19(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
-  if (existsSync21(pageFileAbs)) {
+  if (existsSync22(pageFileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${pageFileAbs} \u2014 skipped.`);
     return outcome;
   }
   const routingFile = findRoutingFile(project.serverEntry);
-  const routingText = routingFile ? readFileSync20(routingFile, "utf-8") : "";
+  const routingText = routingFile ? readFileSync21(routingFile, "utf-8") : "";
   const css = planCss(routingText, project.stylesDir, pascal, kebab);
   const navDataPath = join19(sharedDirFor(project, framework), "navData.ts");
   const nav = upsertNavItem(navDataPath, { href: route, label: title });
-  const navImportPath = toModuleSpecifier(dirname10(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
+  const navImportPath = toModuleSpecifier(dirname11(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
   writeNew(pageFileAbs, pageTemplates[framework]({
-    cssHref: toHref(dirname10(pageFileAbs), css.cssFileAbs),
+    cssHref: toHref(dirname11(pageFileAbs), css.cssFileAbs),
     kebab,
     navImportPath,
     navItems: nav.items,
@@ -173884,7 +174422,7 @@ var exports_generate = {};
 __export(exports_generate, {
   runGenerate: () => runGenerate
 });
-import { relative as relative5 } from "path";
+import { relative as relative6 } from "path";
 var SUBCOMMANDS, write = (text) => process.stdout.write(`${text}
 `), fail = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -173916,7 +174454,7 @@ var SUBCOMMANDS, write = (text) => process.stdout.write(`${text}
     return;
   write(`  ${colors.dim}${label}${colors.reset}`);
   for (const path of paths)
-    write(`    ${relative5(cwd, path)}`);
+    write(`    ${relative6(cwd, path)}`);
 }, printSummary = (title, outcome, cwd) => {
   for (const note of outcome.notes) {
     write(`${colors.yellow}!${colors.reset} ${note}`);
@@ -174016,7 +174554,7 @@ ${indent.repeat(level)}}`;
 var init_serialize = () => {};
 
 // src/cli/config/absolute/editAbsoluteConfig.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync13 } from "fs";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "fs";
 var import_typescript8, lineStartOffset = (text, position) => {
   let index = position;
   while (index > 0 && text[index - 1] !== `
@@ -174025,7 +174563,7 @@ var import_typescript8, lineStartOffset = (text, position) => {
   return index;
 }, indentBefore2 = (text, position) => text.slice(lineStartOffset(text, position), position), findProperty = (object, name) => object.properties.find((property) => import_typescript8.default.isPropertyAssignment(property) && (import_typescript8.default.isIdentifier(property.name) || import_typescript8.default.isStringLiteral(property.name)) && property.name.text === name), applyAbsoluteConfigEdit = (configPath2, request) => {
   try {
-    const text = readFileSync21(configPath2, "utf-8");
+    const text = readFileSync22(configPath2, "utf-8");
     const sourceFile = import_typescript8.default.createSourceFile(configPath2, text, import_typescript8.default.ScriptTarget.Latest, true);
     const object = findConfigObject(sourceFile);
     if (!object) {
@@ -174045,14 +174583,14 @@ var import_typescript8, lineStartOffset = (text, position) => {
       if (text[end] === `
 `)
         end += 1;
-      writeFileSync13(configPath2, text.slice(0, start2) + text.slice(end), "utf-8");
+      writeFileSync14(configPath2, text.slice(0, start2) + text.slice(end), "utf-8");
       return { message: `Removed ${request.name}`, ok: true };
     }
     const valueText = serializeValue(request.value);
     if (existing) {
       const start2 = existing.initializer.getStart(sourceFile);
       const end = existing.initializer.getEnd();
-      writeFileSync13(configPath2, text.slice(0, start2) + valueText + text.slice(end), "utf-8");
+      writeFileSync14(configPath2, text.slice(0, start2) + valueText + text.slice(end), "utf-8");
       return { message: `Updated ${request.name}`, ok: true };
     }
     const { properties } = object;
@@ -174072,14 +174610,14 @@ var import_typescript8, lineStartOffset = (text, position) => {
         insertionIndex += 1;
       const insertion = `${hasComma ? "" : ","}
 ${indent}${entry}`;
-      writeFileSync13(configPath2, text.slice(0, insertionIndex) + insertion + text.slice(insertionIndex), "utf-8");
+      writeFileSync14(configPath2, text.slice(0, insertionIndex) + insertion + text.slice(insertionIndex), "utf-8");
     } else {
       const insertionIndex = object.getStart(sourceFile) + 1;
       const indent = `${indentBefore2(text, object.getStart(sourceFile))}	`;
       const insertion = `
 ${indent}${entry}
 ${indentBefore2(text, object.getStart(sourceFile))}`;
-      writeFileSync13(configPath2, text.slice(0, insertionIndex) + insertion + text.slice(insertionIndex), "utf-8");
+      writeFileSync14(configPath2, text.slice(0, insertionIndex) + insertion + text.slice(insertionIndex), "utf-8");
     }
     return { message: `Updated ${request.name}`, ok: true };
   } catch (error) {
@@ -174209,14 +174747,14 @@ var init_catalog = __esm(() => {
 });
 
 // src/cli/integrations/addPlugin.ts
-import { existsSync as existsSync22, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync23 } from "fs";
 import { join as join20 } from "path";
 var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readPackageJson = (cwd) => {
   const path = join20(cwd, "package.json");
-  if (!existsSync22(path))
+  if (!existsSync23(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync22(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync23(path, "utf-8"));
     return isRecord5(parsed) ? parsed : null;
   } catch {
     return null;
@@ -174707,16 +175245,16 @@ var init_authCatalog = __esm(() => {
 });
 
 // src/cli/config/auth/resolveAuthSettings.ts
-import { existsSync as existsSync23, readFileSync as readFileSync23 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync24 } from "fs";
+import { resolve as resolve15 } from "path";
 var import_typescript9, AUTH_PACKAGE = "@absolutejs/auth", CONFIG_CANDIDATES3, findAuthSettingsPath = (cwd, override) => {
   if (override) {
-    const resolved = resolve14(cwd, override);
-    return existsSync23(resolved) ? resolved : null;
+    const resolved = resolve15(cwd, override);
+    return existsSync24(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES3) {
-    const candidate = resolve14(cwd, name);
-    if (existsSync23(candidate))
+    const candidate = resolve15(cwd, name);
+    if (existsSync24(candidate))
       return candidate;
   }
   return null;
@@ -174737,7 +175275,7 @@ var import_typescript9, AUTH_PACKAGE = "@absolutejs/auth", CONFIG_CANDIDATES3, f
   }
   return null;
 }, parseAuthSettingsObject = (configPath2) => {
-  const text = readFileSync23(configPath2, "utf-8");
+  const text = readFileSync24(configPath2, "utf-8");
   return {
     object: findAuthSettingsObject(parseSource2(configPath2, text)),
     text
@@ -174812,13 +175350,13 @@ var init_resolveAuthSettings = __esm(() => {
 });
 
 // src/cli/config/auth/resolveAuthState.ts
-import { existsSync as existsSync24, readdirSync as readdirSync6, readFileSync as readFileSync24 } from "fs";
-import { join as join21, relative as relative6, resolve as resolve15 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync6, readFileSync as readFileSync25 } from "fs";
+import { join as join21, relative as relative7, resolve as resolve16 } from "path";
 var import_typescript10, AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutejs/absolute-auth", NPM_URL = "https://www.npmjs.com/package/@absolutejs/auth", SKIP_DIRS, MAX_FILES = 4000, SETUP_EXPORTS, isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
-  if (!existsSync24(path))
+  if (!existsSync25(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync24(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync25(path, "utf-8"));
     return isRecord6(parsed) ? parsed : null;
   } catch {
     return null;
@@ -174911,7 +175449,7 @@ var import_typescript10, AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https:/
   return { keys: new Set, providerCount: null, usesSpread: true };
 }, readFileOrNull = (path) => {
   try {
-    return readFileSync24(path, "utf-8");
+    return readFileSync25(path, "utf-8");
   } catch {
     return null;
   }
@@ -174944,7 +175482,7 @@ var import_typescript10, AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https:/
   scaffoldable: isScaffoldableFeature(feature.id)
 })), resolveAuthState = (cwd) => {
   const installedVersion = installedVersionFor(cwd);
-  const root = existsSync24(join21(cwd, "src")) ? join21(cwd, "src") : cwd;
+  const root = existsSync25(join21(cwd, "src")) ? join21(cwd, "src") : cwd;
   let match = null;
   let setupPath = null;
   for (const file of candidateFiles(root)) {
@@ -174952,7 +175490,7 @@ var import_typescript10, AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https:/
     if (found === null)
       continue;
     match = found;
-    setupPath = relative6(cwd, resolve15(file));
+    setupPath = relative7(cwd, resolve16(file));
     break;
   }
   const keys = match?.keys ?? new Set;
@@ -174990,8 +175528,8 @@ var init_resolveAuthState = __esm(() => {
 });
 
 // src/cli/config/auth/scaffoldAuthFeature.ts
-import { existsSync as existsSync25, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname11, join as join22, relative as relative7, resolve as resolve16 } from "path";
+import { existsSync as existsSync26, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname12, join as join22, relative as relative8, resolve as resolve17 } from "path";
 var renderScaffold = (scaffold) => {
   const importNames = [...scaffold.imports, `type ${scaffold.typeName}`];
   const importLine = `import { ${importNames.join(", ")} } from '@absolutejs/auth';`;
@@ -175016,9 +175554,9 @@ ${body}
 }, targetDir = (cwd) => {
   const { setupPath } = resolveAuthState(cwd);
   if (setupPath)
-    return dirname11(resolve16(cwd, setupPath));
+    return dirname12(resolve17(cwd, setupPath));
   const src = join22(cwd, "src");
-  return existsSync25(src) ? src : cwd;
+  return existsSync26(src) ? src : cwd;
 }, spreadFor = (scaffold) => `import { ${scaffold.exportName} } from './${scaffold.exportName}';
 // add to your auth() call:
 ${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
@@ -175032,8 +175570,8 @@ ${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
   if (!scaffold)
     return failure2(`Unknown auth feature "${id}".`);
   const filePath = join22(targetDir(cwd), `${scaffold.exportName}.ts`);
-  const relPath = relative7(cwd, filePath);
-  if (existsSync25(filePath)) {
+  const relPath = relative8(cwd, filePath);
+  if (existsSync26(filePath)) {
     return {
       created: null,
       installed: false,
@@ -175044,7 +175582,7 @@ ${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
   }
   const install = options.install ?? true;
   const installOk = install && scaffold.packages.length > 0 ? installPackages(cwd, scaffold.packages) : true;
-  writeFileSync14(filePath, renderScaffold(scaffold));
+  writeFileSync15(filePath, renderScaffold(scaffold));
   return {
     created: relPath,
     installed: installOk,
@@ -175060,13 +175598,13 @@ var init_scaffoldAuthFeature = __esm(() => {
 });
 
 // src/cli/htmx/install.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync13, readFileSync as readFileSync25, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync26, writeFileSync as writeFileSync16 } from "fs";
 import { join as join23 } from "path";
 var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   join23(import.meta.dir, "htmx.min.js"),
   join23(import.meta.dir, "htmx", "htmx.min.js"),
   join23(import.meta.dir, "..", "htmx", "htmx.min.js")
-].find((path) => existsSync26(path)) ?? null, detectHtmxVersion = (content) => {
+].find((path) => existsSync27(path)) ?? null, detectHtmxVersion = (content) => {
   const match = content.match(/version:"([0-9.]+)"/);
   return match ? match[1] : null;
 }, fetchHtmx = async (version2) => {
@@ -175078,16 +175616,16 @@ var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   return response.text();
 }, installedHtmxVersion = (htmxDir) => {
   const file = join23(htmxDir, "htmx.min.js");
-  if (!existsSync26(file))
+  if (!existsSync27(file))
     return null;
-  return detectHtmxVersion(readFileSync25(file, "utf-8"));
+  return detectHtmxVersion(readFileSync26(file, "utf-8"));
 }, readVendoredHtmx = () => {
   const file = vendoredHtmxFile();
-  return file ? readFileSync25(file, "utf-8") : null;
+  return file ? readFileSync26(file, "utf-8") : null;
 }, writeHtmx = (htmxDir, content) => {
-  mkdirSync13(htmxDir, { recursive: true });
+  mkdirSync14(htmxDir, { recursive: true });
   const file = join23(htmxDir, "htmx.min.js");
-  writeFileSync15(file, content, "utf-8");
+  writeFileSync16(file, content, "utf-8");
   return file;
 };
 var init_install = () => {};
@@ -175097,7 +175635,7 @@ var exports_add = {};
 __export(exports_add, {
   runAdd: () => runAdd
 });
-import { dirname as dirname12, join as join24, relative as relative8 } from "path";
+import { dirname as dirname13, join as join24, relative as relative9 } from "path";
 var write2 = (text) => process.stdout.write(`${text}
 `), fail2 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -175108,11 +175646,11 @@ var write2 = (text) => process.stdout.write(`${text}
     return;
   write2(`  ${colors.dim}${label}${colors.reset}`);
   for (const path of paths)
-    write2(`    ${relative8(cwd, path)}`);
+    write2(`    ${relative9(cwd, path)}`);
 }, frontendRoot = (project, cwd) => {
   const [firstKey] = configuredFrameworks(project);
   const firstDir = firstKey ? project.frameworkDirs[firstKey] : undefined;
-  return firstDir ? dirname12(firstDir) : join24(cwd, "src", "frontend");
+  return firstDir ? dirname13(firstDir) : join24(cwd, "src", "frontend");
 }, addIntegrationCli = (id, install) => {
   const result = addIntegration(process.cwd(), id, { install });
   if (!result.ok) {
@@ -175177,7 +175715,7 @@ var write2 = (text) => process.stdout.write(`${text}
     return;
   }
   const dirAbs = join24(frontendRoot(project, cwd), framework);
-  const dirRel = `./${relative8(cwd, dirAbs).split("\\").join("/")}`;
+  const dirRel = `./${relative9(cwd, dirAbs).split("\\").join("/")}`;
   let depNote = "Skipped dependency install (--no-install).";
   if (!noInstall) {
     write2(`${colors.dim}Installing ${frameworks2[framework].label} dependencies\u2026${colors.reset}`);
@@ -175246,8 +175784,8 @@ var exports_analyze = {};
 __export(exports_analyze, {
   runAnalyze: () => runAnalyze
 });
-import { existsSync as existsSync27, readFileSync as readFileSync26, statSync as statSync3, writeFileSync as writeFileSync16 } from "fs";
-import { join as join25, resolve as resolve17 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync27, statSync as statSync3, writeFileSync as writeFileSync17 } from "fs";
+import { join as join25, resolve as resolve18 } from "path";
 var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_WIDTH = 16, SIZE_WIDTH = 12, CHANGE_WIDTH = 10, CATEGORY_ORDER, categoryOf = (key) => {
   if (key.startsWith("Island"))
     return "Islands";
@@ -175268,9 +175806,9 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   }
 }, readSizes = (manifestDir) => {
   const manifestPath = join25(manifestDir, "manifest.json");
-  if (!existsSync27(manifestPath))
+  if (!existsSync28(manifestPath))
     return null;
-  const manifest = JSON.parse(readFileSync26(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync27(manifestPath, "utf-8"));
   const sizes = {};
   for (const [key, value] of Object.entries(manifest)) {
     sizes[key] = fileSize2(join25(manifestDir, value.replace(/^\//, "")));
@@ -175278,10 +175816,10 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   return sizes;
 }, readBaseline = (cwd) => {
   const path = join25(cwd, BASELINE_FILE);
-  if (!existsSync27(path))
+  if (!existsSync28(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync26(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync27(path, "utf-8"));
     return parsed;
   } catch {
     return null;
@@ -175359,14 +175897,14 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   const config = await loadConfig(configIndex >= 0 ? args[configIndex + 1] : undefined);
   const outdirIndex = args.indexOf("--outdir");
   const outdir = outdirIndex >= 0 ? args[outdirIndex + 1] : config.buildDirectory;
-  const sizes = readSizes(resolve17(cwd, outdir ?? "build"));
+  const sizes = readSizes(resolve18(cwd, outdir ?? "build"));
   if (sizes === null) {
     process.stdout.write(`${colors.dim}No build found. Run \`absolute build\` first.${colors.reset}
 `);
     return;
   }
   if (args.includes("--save")) {
-    writeFileSync16(join25(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
+    writeFileSync17(join25(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
 `);
     process.stdout.write(`${colors.green}\u2713${colors.reset} Saved size baseline (${Object.keys(sizes).length} entries) to ${BASELINE_FILE}
 `);
@@ -175612,8 +176150,8 @@ var exports_remove = {};
 __export(exports_remove, {
   runRemove: () => runRemove
 });
-import { existsSync as existsSync28, readFileSync as readFileSync27 } from "fs";
-import { relative as relative9 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync28 } from "fs";
+import { relative as relative10 } from "path";
 var write3 = (text) => process.stdout.write(`${text}
 `), fail3 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -175623,10 +176161,10 @@ var write3 = (text) => process.stdout.write(`${text}
   const candidates = [findRoutingFile(serverEntry), serverEntry];
   const seen = new Set;
   return candidates.filter((file) => {
-    if (file === null || seen.has(file) || !existsSync28(file))
+    if (file === null || seen.has(file) || !existsSync29(file))
       return false;
     seen.add(file);
-    return readFileSync27(file, "utf-8").includes(handler);
+    return readFileSync28(file, "utf-8").includes(handler);
   });
 }, runRemove = async (args) => {
   const [framework] = args.filter((arg) => !arg.startsWith("--"));
@@ -175662,10 +176200,10 @@ var write3 = (text) => process.stdout.write(`${text}
   }
   write3(`${colors.green}\u2713${colors.reset} Removed ${framework}Directory from absolute.config.ts
 `);
-  write3(`  ${colors.dim}Kept${colors.reset}  ${relative9(cwd, frameworkDir)} \u2014 delete its source manually if no longer needed.`);
+  write3(`  ${colors.dim}Kept${colors.reset}  ${relative10(cwd, frameworkDir)} \u2014 delete its source manually if no longer needed.`);
   const refs = referencingFiles(project.serverEntry, HANDLER_NAME[framework]);
   for (const file of refs) {
-    write3(`  ${colors.yellow}Still references${colors.reset}  ${relative9(cwd, file)} (calls ${HANDLER_NAME[framework]})`);
+    write3(`  ${colors.yellow}Still references${colors.reset}  ${relative10(cwd, file)} (calls ${HANDLER_NAME[framework]})`);
   }
   const deps = frameworkDependencyNames(framework);
   if (prune && deps.length > 0) {
@@ -175753,15 +176291,15 @@ __export(exports_env, {
   runEnv: () => runEnv,
   collectEnvVars: () => collectEnvVars
 });
-import { existsSync as existsSync29, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync29 } from "fs";
 import { join as join26 } from "path";
 var {env: env3, Glob: Glob3 } = globalThis.Bun;
-var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync29(join26(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
+var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync30(join26(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
   const scans = scanPatterns().map((pattern) => Array.fromAsync(new Glob3(pattern).scan({ cwd: process.cwd() })));
   const files = (await Promise.all(scans)).flat();
   const usage = new Map;
   files.forEach((file) => {
-    keysInFile(readFileSync28(file, "utf-8")).forEach((key) => {
+    keysInFile(readFileSync29(file, "utf-8")).forEach((key) => {
       usage.set(key, [...usage.get(key) ?? [], file]);
     });
   });
@@ -175822,7 +176360,7 @@ __export(exports_db, {
   conflictClause: () => conflictClause,
   chunkRows: () => chunkRows
 });
-import { existsSync as existsSync30, mkdirSync as mkdirSync14, readFileSync as readFileSync29, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync15, readFileSync as readFileSync30, writeFileSync as writeFileSync18 } from "fs";
 import { join as join27 } from "path";
 var {env: env4, spawn: spawn2, SQL } = globalThis.Bun;
 var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA_TYPES, SEED_CANDIDATES, VALUE_FLAGS, paint = (text, color) => `${color}${text}${colors.reset}`, chunkRows = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, idx) => items.slice(idx * size, idx * size + size)), quoteIdent = (name) => `"${name.replace(/"/g, '""')}"`, resolveUrl = (explicit) => {
@@ -175934,18 +176472,18 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
     v: BACKUP_FORMAT_VERSION
   };
   const dir = options.out ?? join27(process.cwd(), "backups");
-  mkdirSync14(dir, { recursive: true });
+  mkdirSync15(dir, { recursive: true });
   const json = JSON.stringify(payload, (_, value) => typeof value === "bigint" ? value.toString() : value);
   const file = join27(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
-  writeFileSync17(file, json);
-  writeFileSync17(join27(dir, "latest.json"), json);
+  writeFileSync18(file, json);
+  writeFileSync18(join27(dir, "latest.json"), json);
   const total = chosen.reduce((sum, name) => sum + (tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 backup \u2192 ${file}`, colors.green));
   console.log(paint(`  ${chosen.length} tables, ${total} rows`, colors.dim));
 }, runRestore = async (file, options) => {
-  if (!existsSync30(file))
+  if (!existsSync31(file))
     throw new Error(`Backup not found: ${file}`);
-  const payload = JSON.parse(readFileSync29(file, "utf-8"));
+  const payload = JSON.parse(readFileSync30(file, "utf-8"));
   const names = Object.keys(payload.tables).filter((name) => keepTable(name, options));
   const sql = new SQL(options.url);
   const order = dependencyOrder(names, await foreignLinks(sql));
@@ -175967,7 +176505,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
   const total = order.reduce((sum, name) => sum + (payload.tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 restored ${order.length} tables, ${total} rows (idempotent upsert by primary key)`, colors.green));
 }, runSeed = async (entry) => {
-  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync30(join27(process.cwd(), candidate)));
+  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync31(join27(process.cwd(), candidate)));
   if (target === undefined)
     throw new Error(`No seed script found (looked for ${SEED_CANDIDATES.join(", ")}). Pass a path: absolute db seed <file>.`);
   console.log(paint(`seeding via ${target}\u2026`, colors.cyan));
@@ -176028,7 +176566,7 @@ __export(exports_logs, {
 });
 import {
   closeSync as closeSync2,
-  existsSync as existsSync31,
+  existsSync as existsSync32,
   openSync as openSync4,
   readSync as readSync2,
   statSync as statSync4,
@@ -176095,7 +176633,7 @@ var DEFAULT_LINES = 40, POLL_MS = 250, LINES_FLAG_SPAN = 2, readFrom = (path, st
     printAvailable(instances);
     return;
   }
-  if (match.logFile === null || !existsSync31(match.logFile)) {
+  if (match.logFile === null || !existsSync32(match.logFile)) {
     printDim3(`"${name}" has no captured log (untracked, or started outside the CLI).`);
     return;
   }
@@ -176115,17 +176653,17 @@ var init_logs = __esm(() => {
 
 // src/cli/typeGraphCoherence.ts
 import {
-  existsSync as existsSync32,
-  readFileSync as readFileSync30,
+  existsSync as existsSync33,
+  readFileSync as readFileSync31,
   realpathSync,
-  rmSync as rmSync5,
-  writeFileSync as writeFileSync18
+  rmSync as rmSync6,
+  writeFileSync as writeFileSync19
 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname13, join as join28, resolve as resolve18, sep } from "path";
+import { dirname as dirname14, join as join28, resolve as resolve19, sep } from "path";
 var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   try {
-    const parsed = JSON.parse(readFileSync30(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync31(path, "utf-8"));
     return isRecord3(parsed) ? parsed : null;
   } catch {
     return null;
@@ -176142,13 +176680,13 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   const version2 = Reflect.get(manifest, "version");
   return typeof version2 === "string" ? version2 : "unknown";
 }, packageJsonFromEntry = (entry, expectedName) => {
-  let directory = dirname13(entry);
+  let directory = dirname14(entry);
   for (;; ) {
     const candidate = join28(directory, "package.json");
     const manifest = readManifest(candidate);
     if (manifest && manifestName(manifest, "") === expectedName)
       return candidate;
-    const parent = dirname13(directory);
+    const parent = dirname14(directory);
     if (parent === directory)
       return null;
     directory = parent;
@@ -176164,25 +176702,25 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
     }
   }
 }, findInstallRoot = (cwd) => {
-  let directory = resolve18(cwd);
+  let directory = resolve19(cwd);
   for (;; ) {
-    if (existsSync32(join28(directory, "bun.lock")) || existsSync32(join28(directory, "bun.lockb"))) {
+    if (existsSync33(join28(directory, "bun.lock")) || existsSync33(join28(directory, "bun.lockb"))) {
       return directory;
     }
-    const parent = dirname13(directory);
+    const parent = dirname14(directory);
     if (parent === directory)
-      return resolve18(cwd);
+      return resolve19(cwd);
     directory = parent;
   }
 }, findProjectManifest = (cwd, installRoot) => {
-  let directory = resolve18(cwd);
+  let directory = resolve19(cwd);
   for (;; ) {
     const candidate = join28(directory, "package.json");
-    if (existsSync32(candidate))
+    if (existsSync33(candidate))
       return candidate;
     if (directory === installRoot)
       return join28(installRoot, "package.json");
-    const parent = dirname13(directory);
+    const parent = dirname14(directory);
     if (parent === directory)
       return join28(installRoot, "package.json");
     directory = parent;
@@ -176275,7 +176813,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   }
   if (changes.length > 0) {
     Reflect.set(manifest, "overrides", overrides);
-    writeFileSync18(manifestPath, `${JSON.stringify(manifest, null, "\t")}
+    writeFileSync19(manifestPath, `${JSON.stringify(manifest, null, "\t")}
 `);
   }
   return changes;
@@ -176292,7 +176830,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   for (const stalePath of stalePaths) {
     if (!stalePath.startsWith(installPrefix) || !stalePath.includes(nodeModulesSegment))
       continue;
-    rmSync5(dirname13(stalePath), { force: true, recursive: true });
+    rmSync6(dirname14(stalePath), { force: true, recursive: true });
     removed.push(stalePath);
   }
   return removed;
@@ -176319,7 +176857,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync33, mkdirSync as mkdirSync15, readFileSync as readFileSync31, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync16, readFileSync as readFileSync32, writeFileSync as writeFileSync20 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { arch as arch4, platform as platform5 } from "os";
 import { join as join29 } from "path";
@@ -176357,7 +176895,7 @@ var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
     return [];
   const label = `${field.replace("Directory", "")} pages`;
   return [
-    existsSync33(join29(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
+    existsSync34(join29(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
   ];
 }), envCheck = async () => {
   const vars = await collectEnvVars();
@@ -176419,9 +176957,9 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const fixes = [];
   for (const field of FRAMEWORK_FIELDS2) {
     const dir = readString(config, field);
-    if (dir === undefined || existsSync33(join29(cwd, dir)))
+    if (dir === undefined || existsSync34(join29(cwd, dir)))
       continue;
-    mkdirSync15(join29(cwd, dir, "pages"), { recursive: true });
+    mkdirSync16(join29(cwd, dir, "pages"), { recursive: true });
     fixes.push(`created ${dir}/pages`);
   }
   return fixes;
@@ -176430,7 +176968,7 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   if (missing.length === 0)
     return null;
   const envExample = join29(cwd, ".env.example");
-  const existing = existsSync33(envExample) ? readFileSync31(envExample, "utf-8") : "";
+  const existing = existsSync34(envExample) ? readFileSync32(envExample, "utf-8") : "";
   const existingKeys = new Set(existing.split(`
 `).map((line) => line.split("=")[0]?.trim()));
   const toAdd = missing.filter((entry) => !existingKeys.has(entry.key));
@@ -176439,7 +176977,7 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const prefix = existing === "" || existing.endsWith(`
 `) ? existing : `${existing}
 `;
-  writeFileSync19(envExample, `${prefix}${toAdd.map((entry) => `${entry.key}=`).join(`
+  writeFileSync20(envExample, `${prefix}${toAdd.map((entry) => `${entry.key}=`).join(`
 `)}
 `);
   return `added ${toAdd.length} key(s) to .env.example`;
@@ -176804,10 +177342,10 @@ var init_inspect = __esm(() => {
 });
 
 // src/build/scanEntryPoints.ts
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 var {Glob: Glob4 } = globalThis.Bun;
 var scanEntryPoints = async (dir, pattern) => {
-  if (!existsSync34(dir))
+  if (!existsSync35(dir))
     return [];
   const entryPaths = [];
   const glob = new Glob4(pattern);
@@ -176889,8 +177427,8 @@ var init_sourceMetadata = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync32 } from "fs";
-import { dirname as dirname14, resolve as resolve19 } from "path";
+import { readFileSync as readFileSync33 } from "fs";
+import { dirname as dirname15, resolve as resolve20 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -176910,8 +177448,8 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve19(dirname14(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve19(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve20(dirname15(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve20(resolvedSource));
   }
   return lookup;
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage2) => {
@@ -176924,13 +177462,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve19(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve20(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync32(filePath, "utf-8");
+    const source = readFileSync33(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve19(filePath), {
+    pageMetadata.set(resolve20(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve19(filePath)
+      pagePath: resolve20(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -176959,14 +177497,14 @@ var exports_islands = {};
 __export(exports_islands, {
   runIslands: () => runIslands
 });
-import { existsSync as existsSync35, readFileSync as readFileSync33, statSync as statSync5 } from "fs";
-import { join as join30, relative as relative10, resolve as resolve20 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync34, statSync as statSync5 } from "fs";
+import { join as join30, relative as relative11, resolve as resolve21 } from "path";
 var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.write(`${colors.dim}${message}${colors.reset}
 `), hostFrameworkOf = (pagePath, cwd, config) => {
-  const resolved = resolve20(cwd, pagePath);
+  const resolved = resolve21(cwd, pagePath);
   for (const [framework, key] of Object.entries(FRAMEWORK_DIR_KEY)) {
     const dir = config[key];
-    if (typeof dir === "string" && resolved.startsWith(resolve20(cwd, dir))) {
+    if (typeof dir === "string" && resolved.startsWith(resolve21(cwd, dir))) {
       return framework;
     }
   }
@@ -176979,9 +177517,9 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
   }
 }, readManifestSizes2 = (manifestDir) => {
   const manifestPath = join30(manifestDir, "manifest.json");
-  if (!existsSync35(manifestPath))
+  if (!existsSync36(manifestPath))
     return null;
-  const manifest = JSON.parse(readFileSync33(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync34(manifestPath, "utf-8"));
   const sizes = new Map;
   for (const [key, value] of Object.entries(manifest)) {
     sizes.set(key, fileSize3(join30(manifestDir, value.replace(/^\//, ""))));
@@ -176991,7 +177529,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
   const registryPath = config.islands?.registry;
   if (typeof registryPath !== "string")
     return null;
-  const buildInfo = await loadIslandRegistryBuildInfo(resolve20(cwd, registryPath));
+  const buildInfo = await loadIslandRegistryBuildInfo(resolve21(cwd, registryPath));
   const pageMetadata = await loadPageIslandMetadata(config);
   const usages = [...pageMetadata.values()].flatMap((meta) => meta.islands.map((island) => ({ ...island, page: meta.pagePath })));
   return buildInfo.definitions.map((definition) => {
@@ -177001,7 +177539,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
         crossFramework: hostFramework !== null && hostFramework !== definition.framework,
         hostFramework,
         hydrate: usage2.hydrate ?? "load",
-        page: relative10(cwd, resolve20(cwd, usage2.page))
+        page: relative11(cwd, resolve21(cwd, usage2.page))
       };
     });
     const key = getIslandManifestKey(definition.framework, definition.component);
@@ -177040,7 +177578,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
     `  ${color}\u2B21${colors.reset} ${colors.bold}${island.component}${colors.reset}  ${meta}${sizeText}`
   ];
   if (island.source) {
-    lines.push(`    ${colors.dim}${relative10(cwd, island.source)}${colors.reset}`);
+    lines.push(`    ${colors.dim}${relative11(cwd, island.source)}${colors.reset}`);
   }
   if (pages.length === 0) {
     lines.push(`    ${colors.dim}(registered but not mounted on any page)${colors.reset}`);
@@ -177070,7 +177608,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
   }
   const outdirIndex = args.indexOf("--outdir");
   const outdir = outdirIndex >= 0 ? args[outdirIndex + 1] : config.buildDirectory;
-  const sizes = args.includes("--sizes") ? readManifestSizes2(resolve20(cwd, outdir ?? "build")) : null;
+  const sizes = args.includes("--sizes") ? readManifestSizes2(resolve21(cwd, outdir ?? "build")) : null;
   const islands = await collectIslands(cwd, config, sizes);
   if (islands === null) {
     printDim6('No island registry configured. Set `islands: { registry: "..." }` in absolute.config.ts.');
@@ -177119,13 +177657,13 @@ var init_islands2 = __esm(() => {
 });
 
 // src/build/externalAssetPlugin.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync36, mkdirSync as mkdirSync16, statSync as statSync6 } from "fs";
-import { basename as basename6, dirname as dirname15, join as join31, resolve as resolve21 } from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync37, mkdirSync as mkdirSync17, statSync as statSync6 } from "fs";
+import { basename as basename6, dirname as dirname16, join as join31, resolve as resolve22 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
   setup(bld) {
     const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
-    const skipRoots = userSourceRoots.map((root) => resolve21(root));
+    const skipRoots = userSourceRoots.map((root) => resolve22(root));
     const isUserSource = (path) => skipRoots.some((root) => path.startsWith(`${root}/`));
     bld.onLoad({ filter: /\.[mc]?[jt]sx?$/ }, async (args) => {
       if (isUserSource(args.path))
@@ -177135,20 +177673,20 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         return;
       urlPattern.lastIndex = 0;
       let match;
-      const sourceDir = dirname15(args.path);
+      const sourceDir = dirname16(args.path);
       while ((match = urlPattern.exec(source)) !== null) {
         const relPath = match[1];
         if (!relPath)
           continue;
-        const assetPath = resolve21(sourceDir, relPath);
-        if (!existsSync36(assetPath))
+        const assetPath = resolve22(sourceDir, relPath);
+        if (!existsSync37(assetPath))
           continue;
         if (!statSync6(assetPath).isFile())
           continue;
         const targetPath = join31(outDir, basename6(assetPath));
-        if (existsSync36(targetPath))
+        if (existsSync37(targetPath))
           continue;
-        mkdirSync16(dirname15(targetPath), { recursive: true });
+        mkdirSync17(dirname16(targetPath), { recursive: true });
         copyFileSync2(assetPath, targetPath);
       }
       return;
@@ -177166,23 +177704,23 @@ __export(exports_compile, {
 var {env: env5 } = globalThis.Bun;
 import {
   cpSync,
-  existsSync as existsSync37,
-  mkdirSync as mkdirSync17,
+  existsSync as existsSync38,
+  mkdirSync as mkdirSync18,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync34,
-  rmSync as rmSync6,
+  readFileSync as readFileSync35,
+  rmSync as rmSync7,
   statSync as statSync7,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync20
+  writeFileSync as writeFileSync21
 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import {
   basename as basename7,
-  dirname as dirname16,
+  dirname as dirname17,
   isAbsolute as isAbsolute2,
   join as join32,
-  relative as relative11,
-  resolve as resolve22
+  relative as relative12,
+  resolve as resolve23
 } from "path";
 var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, compileBanner = (version2) => {
   const resolvedVersion = version2 || "unknown";
@@ -177204,7 +177742,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   return result;
 }, INLINE_SOURCE_MAP_RE, rebaseInlineSourceMap = (filePath) => {
-  const source = readFileSync34(filePath, "utf-8");
+  const source = readFileSync35(filePath, "utf-8");
   const match = source.match(INLINE_SOURCE_MAP_RE);
   const encoded = match?.[1];
   if (!encoded)
@@ -177215,7 +177753,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!Array.isArray(map.sources))
     return;
   const sourceRoot = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
-  const bundleDirectory = dirname16(filePath);
+  const bundleDirectory = dirname17(filePath);
   map.sources = map.sources.map((entry) => {
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(entry))
       return entry;
@@ -177224,11 +177762,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(sourceRoot)) {
       return new URL(entry, sourceRoot).href;
     }
-    return resolve22(bundleDirectory, sourceRoot, entry);
+    return resolve23(bundleDirectory, sourceRoot, entry);
   });
   delete map.sourceRoot;
   const rebased = Buffer.from(JSON.stringify(map)).toString("base64");
-  writeFileSync20(filePath, source.replace(encoded, rebased));
+  writeFileSync21(filePath, source.replace(encoded, rebased));
 }, SERVER_RUNTIME_ASSET_RE, SERVER_RUNTIME_IMPORT_META_DIR_JOIN_RE, SERVER_RUNTIME_STRING_ARG_RE, SERVER_RUNTIME_SOURCE_EXTENSIONS, SERVER_RUNTIME_SCAN_SKIP_DIRS, hasSourceExtension = (filePath) => SERVER_RUNTIME_SOURCE_EXTENSIONS.has(filePath.slice(filePath.lastIndexOf("."))), normalizeServerRuntimeAssetPath = (parts) => {
   if (parts.length === 0)
     return null;
@@ -177254,22 +177792,22 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return result;
 }, copyServerRuntimeAssetReferences = (outdir) => {
   const copied = new Set;
-  const normalizedOutdir = resolve22(outdir);
+  const normalizedOutdir = resolve23(outdir);
   const copyReference = (filePath, relPath) => {
-    const assetSource = resolve22(dirname16(filePath), relPath);
-    if (!existsSync37(assetSource) || !statSync7(assetSource).isFile())
+    const assetSource = resolve23(dirname17(filePath), relPath);
+    if (!existsSync38(assetSource) || !statSync7(assetSource).isFile())
       return;
-    const assetTarget = resolve22(normalizedOutdir, relPath.replace(/^\.\//, ""));
+    const assetTarget = resolve23(normalizedOutdir, relPath.replace(/^\.\//, ""));
     if (assetTarget !== normalizedOutdir && !assetTarget.startsWith(`${normalizedOutdir}/`))
       return;
     if (copied.has(assetTarget))
       return;
     copied.add(assetTarget);
-    mkdirSync17(dirname16(assetTarget), { recursive: true });
+    mkdirSync18(dirname17(assetTarget), { recursive: true });
     cpSync(assetSource, assetTarget, { force: true });
   };
   for (const filePath of collectProjectSourceFiles(process.cwd())) {
-    const source = readFileSync34(filePath, "utf-8");
+    const source = readFileSync35(filePath, "utf-8");
     SERVER_RUNTIME_ASSET_RE.lastIndex = 0;
     let match;
     while ((match = SERVER_RUNTIME_ASSET_RE.exec(source)) !== null) {
@@ -177298,7 +177836,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
 }, readPackageVersion4 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync34(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync35(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -177333,18 +177871,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return resolveBuildModule3(remaining);
 }, resolveJsxDevRuntimeCompatPath2 = () => {
   const candidates = [
-    resolve22(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve22(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve22(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
-    resolve22(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve22(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve22(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve23(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve23(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve23(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
+    resolve23(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve23(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve23(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync37(candidate))
+    if (existsSync38(candidate))
       return candidate;
   }
-  return resolve22(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
+  return resolve23(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
 }, jsxDevRuntimeCompatPath2, shouldEmbedCompiledAsset = (relativePath, skip = new Set) => {
   if (skip.has(relativePath))
     return false;
@@ -177369,7 +177907,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return true;
 }), requireForCompile, resolveNativeAssetForRuntime = (specifier) => {
   if (specifier.startsWith("."))
-    return resolve22(process.cwd(), specifier);
+    return resolve23(process.cwd(), specifier);
   if (specifier.startsWith("/"))
     return specifier;
   return requireForCompile.resolve(specifier, { paths: [process.cwd()] });
@@ -177381,11 +177919,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return nativeAssetEnv;
 }, tryReadNodePackageJson = (packageDir) => {
   try {
-    return JSON.parse(readFileSync34(join32(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(readFileSync35(join32(packageDir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
-}, resolveProjectPackageDir = (specifier) => resolve22(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
+}, resolveProjectPackageDir = (specifier) => resolve23(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
   if (seen.has(specifier))
     return;
   const srcDir = resolveProjectPackageDir(specifier);
@@ -177394,12 +177932,12 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     return;
   seen.add(specifier);
   const destDir = join32(outdir, "node_modules", ...specifier.split("/"));
-  rmSync6(destDir, { force: true, recursive: true });
+  rmSync7(destDir, { force: true, recursive: true });
   cpSync(srcDir, destDir, {
     force: true,
     recursive: true,
     filter(source) {
-      const rel = relative11(srcDir, source);
+      const rel = relative12(srcDir, source);
       const [firstSegment] = rel.split(/[\\/]/);
       return firstSegment !== "node_modules" && firstSegment !== ".git";
     }
@@ -177415,8 +177953,8 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
 }, copyAngularRuntimePackages = (buildConfig, outdir) => {
   if (!buildConfig.angularDirectory)
     return;
-  const angularScopeDir = resolve22(process.cwd(), "node_modules", "@angular");
-  const angularPackages = existsSync37(angularScopeDir) ? readdirSync7(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
+  const angularScopeDir = resolve23(process.cwd(), "node_modules", "@angular");
+  const angularPackages = existsSync38(angularScopeDir) ? readdirSync7(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
   const roots = new Set([...angularPackages, "rxjs", "tslib", "typescript"]);
   const seen = new Set;
   for (const specifier of roots) {
@@ -177435,7 +177973,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   copyChunkReferencedPackages(outdir, seen);
 }, collectRuntimePackageSpecifiers = (distDir) => {
   const nodeModulesDir = join32(distDir, "node_modules");
-  if (!existsSync37(nodeModulesDir))
+  if (!existsSync38(nodeModulesDir))
     return [];
   const specifiers = [];
   for (const entry of readdirSync7(nodeModulesDir, { withFileTypes: true })) {
@@ -177456,7 +177994,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   return specifiers.sort((firstSpecifier, secondSpecifier) => secondSpecifier.length - firstSpecifier.length);
 }, ensureRelativeModuleSpecifier = (fromFile, toFile) => {
-  const rel = relative11(dirname16(fromFile), toFile).replace(/\\/g, "/");
+  const rel = relative12(dirname17(fromFile), toFile).replace(/\\/g, "/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }, pickExportEntry = (value) => {
   if (typeof value === "string")
@@ -177476,11 +178014,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const packageDir = join32(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
   const subPackageDir = subpath ? join32(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync37(join32(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const resolvedPackageDir = subPackageDir && existsSync38(join32(subPackageDir, "package.json")) ? subPackageDir : packageDir;
   const packageJsonPath = join32(resolvedPackageDir, "package.json");
-  if (!existsSync37(packageJsonPath))
+  if (!existsSync38(packageJsonPath))
     return null;
-  const pkg = JSON.parse(readFileSync34(packageJsonPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync35(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir !== subPackageDir && subpath ? `.${subpath}` : ".";
   const rootExport = pkg.exports?.[exportKey];
   const entry = pickExportEntry(rootExport) ?? (resolvedPackageDir === subPackageDir || !subpath ? pkg.module ?? pkg.main ?? "index.js" : `.${subpath}`);
@@ -177501,12 +178039,12 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   ];
   return candidates.find((filePath) => isRuntimeJsFile(filePath) && isFile(filePath)) ?? null;
 }, findContainingRuntimePackageDir = (filePath) => {
-  let dir = dirname16(filePath);
-  while (dir !== dirname16(dir)) {
-    if (isNodeModulesPath(dir) && existsSync37(join32(dir, "package.json"))) {
+  let dir = dirname17(filePath);
+  while (dir !== dirname17(dir)) {
+    if (isNodeModulesPath(dir) && existsSync38(join32(dir, "package.json"))) {
       return dir;
     }
-    dir = dirname16(dir);
+    dir = dirname17(dir);
   }
   return null;
 }, resolvePackageImportEntryFile = (fromFile, specifier) => {
@@ -177521,11 +178059,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     return null;
   return join32(packageDir, entry);
 }, collectRuntimeRewriteRoots = (distDir) => collectFiles2(distDir).filter((filePath) => isRuntimeJsFile(filePath) && !isNodeModulesPath(filePath)), toTopLevelPackage = (specifier) => specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/"), FRAMEWORK_PACKAGE_NAME = "@absolutejs/absolute", copyChunkReferencedPackages = (distDir, seen) => {
-  const distRoot = resolve22(distDir);
+  const distRoot = resolve23(distDir);
   for (const filePath of collectRuntimeRewriteRoots(distDir)) {
-    if (resolve22(dirname16(filePath)) === distRoot)
+    if (resolve23(dirname17(filePath)) === distRoot)
       continue;
-    const source = readFileSync34(filePath, "utf-8");
+    const source = readFileSync35(filePath, "utf-8");
     for (const match of source.matchAll(MODULE_SPECIFIER_RE)) {
       const [, , , specifier] = match;
       if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || specifier.startsWith("node:") || specifier.startsWith("bun:")) {
@@ -177555,11 +178093,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!filePath || seen.has(filePath))
       continue;
     seen.add(filePath);
-    const source = readFileSync34(filePath, "utf-8");
+    const source = readFileSync35(filePath, "utf-8");
     const { masked, restore } = maskLiterals(source);
     const rewrittenMasked = masked.replace(MODULE_SPECIFIER_RE, (match, prefix, quote, specifier) => {
       if (typeof specifier === "string" && specifier.startsWith(".")) {
-        enqueue(resolveRuntimeJsFile(resolve22(dirname16(filePath), specifier)));
+        enqueue(resolveRuntimeJsFile(resolve23(dirname17(filePath), specifier)));
         return match;
       }
       const packageImportTarget = resolveRuntimeJsFile(resolvePackageImportEntryFile(filePath, specifier) ?? "");
@@ -177575,7 +178113,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     });
     const rewritten = restore(rewrittenMasked);
     if (rewritten !== source) {
-      writeFileSync20(filePath, rewritten);
+      writeFileSync21(filePath, rewritten);
     }
   }
 }, generateEntrypoint = (distDir, serverEntry, prerenderMap, version2, buildConfig) => {
@@ -177588,12 +178126,12 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     "_compile_entrypoint.ts"
   ]);
   const embeddedFiles = allFiles.filter((file) => {
-    const rel = relative11(distDir, file);
+    const rel = relative12(distDir, file);
     if (embeddedSkip.has(rel))
       return false;
     return true;
   });
-  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative11(distDir, file), assetSkip));
+  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative12(distDir, file), assetSkip));
   const imports = [];
   const nativeImports = [];
   const nativeMappings = [];
@@ -177603,19 +178141,19 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const nativeAssets = resolveCompileNativeAssets(buildConfig);
   nativeAssets.forEach((asset, idx) => {
     const varName = `__native${idx}`;
-    const importSpecifier = asset.import.startsWith(".") ? resolve22(process.cwd(), asset.import) : asset.import;
+    const importSpecifier = asset.import.startsWith(".") ? resolve23(process.cwd(), asset.import) : asset.import;
     nativeImports.push(`import ${varName} from ${JSON.stringify(importSpecifier)} with { type: "file" };`);
     nativeMappings.push(`	[${JSON.stringify(asset.env)}, resolveNativeAssetPath(${varName})],`);
   });
   embeddedFiles.forEach((filePath, idx) => {
-    const rel = relative11(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative12(distDir, filePath).replace(/\\/g, "/");
     const varName = `__a${idx}`;
     embeddedVarMap.set(rel, varName);
     imports.push(`import ${varName} from "./${rel}" with { type: "file" };`);
     embeddedMappings.push(`	["${rel}", ${varName}],`);
   });
   clientFiles.forEach((filePath) => {
-    const rel = relative11(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative12(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (!varName)
       return;
@@ -177629,7 +178167,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const pageVarMap = new Map;
   const prerenderEntries = Array.from(prerenderMap.entries());
   prerenderEntries.forEach(([route, filePath]) => {
-    const rel = relative11(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative12(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (varName)
       pageVarMap.set(route, varName);
@@ -177662,7 +178200,7 @@ import { websocket as elysiaWebsocket } from "elysia/ws";
 const SERVER_MODULE = (runtimeDir: string) => import(pathToFileURL(join(runtimeDir, ${JSON.stringify(serverBundleName)})).href);
 const RUNTIME_BUILD_ID = ${JSON.stringify(runtimeBuildId)};
 const RUNTIME_CONFIG_SOURCE = ${JSON.stringify(runtimeConfigSource)};
-const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve22(distDir))};
+const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve23(distDir))};
 const ORIGINAL_BUILD_DIR_NORMALIZED = ORIGINAL_BUILD_DIR.replace(/\\\\/g, "/");
 
 const resolveNativeAssetPath = (assetPath: string) => {
@@ -178094,16 +178632,16 @@ console.log(\`
   }),
   ...collectUserServerExternals(buildConfig)
 ], compile = async (serverEntry, outdir, outfile, configPath2) => {
-  const resolvedOutdir = resolve22(outdir ?? "dist");
+  const resolvedOutdir = resolve23(outdir ?? "dist");
   await withBuildDirectoryLock(resolvedOutdir, () => compileUnlocked(serverEntry, resolvedOutdir, outfile, configPath2));
 }, compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath2) => {
   const prerenderPort = Number(env5.COMPILE_PORT) || Number(env5.PORT) || findFreePort();
   killStaleProcesses(prerenderPort);
   const entryName = basename7(serverEntry).replace(/\.[^.]+$/, "");
-  const resolvedOutfile = resolve22(outfile ?? "compiled-server");
+  const resolvedOutfile = resolve23(outfile ?? "compiled-server");
   const absoluteVersion = resolvePackageVersion3([
-    resolve22(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve22(import.meta.dir, "..", "..", "package.json")
+    resolve23(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve23(import.meta.dir, "..", "..", "package.json")
   ]);
   compileBanner(absoluteVersion);
   const totalStart = performance.now();
@@ -178114,8 +178652,8 @@ console.log(\`
   buildConfig.mode = "production";
   try {
     const build2 = await resolveBuildModule3([
-      resolve22(import.meta.dir, "..", "..", "core", "build"),
-      resolve22(import.meta.dir, "..", "build")
+      resolve23(import.meta.dir, "..", "..", "core", "build"),
+      resolve23(import.meta.dir, "..", "build")
     ]);
     if (!build2)
       throw new Error("Could not locate build module");
@@ -178137,10 +178675,10 @@ console.log(\`
     buildConfig.htmxDirectory
   ].filter((dir) => Boolean(dir));
   const islandRegistrySpec = buildConfig.islands?.registry;
-  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve22(islandRegistrySpec))) : undefined;
+  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve23(islandRegistrySpec))) : undefined;
   const serverBundle = await Bun.build({
     define: { "process.env.NODE_ENV": '"production"' },
-    entrypoints: [resolve22(serverEntry)],
+    entrypoints: [resolve23(serverEntry)],
     external: resolveServerBundleExternals(buildConfig),
     outdir: resolvedOutdir,
     plugins: [
@@ -178163,13 +178701,13 @@ console.log(\`
     console.error(cliTag4("\x1B[31m", "Server bundle failed."));
     process.exit(1);
   }
-  const outputPath = resolve22(resolvedOutdir, `${entryName}.js`);
-  if (!existsSync37(outputPath)) {
+  const outputPath = resolve23(resolvedOutdir, `${entryName}.js`);
+  if (!existsSync38(outputPath)) {
     console.error(cliTag4("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync37(resolve22(resolvedOutdir, "angular", "vendor", "server"))) {
-    const vendorDir = resolve22(resolvedOutdir, "angular", "vendor", "server");
+  if (existsSync38(resolve23(resolvedOutdir, "angular", "vendor", "server"))) {
+    const vendorDir = resolve23(resolvedOutdir, "angular", "vendor", "server");
     const vendorEntries = readdirSync7(vendorDir).filter((fileName) => fileName.endsWith(".js"));
     const angularServerVendorPaths = {};
     for (const file of vendorEntries) {
@@ -178178,7 +178716,7 @@ console.log(\`
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = relative11(dirname16(outputPath), resolve22(vendorDir, file));
+      const relPath = relative12(dirname17(outputPath), resolve23(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
@@ -178190,7 +178728,7 @@ console.log(\`
   copyServerRuntimeAssetReferences(resolvedOutdir);
   const prerenderStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Pre-rendering pages"));
-  rmSync6(join32(resolvedOutdir, "_prerendered"), {
+  rmSync7(join32(resolvedOutdir, "_prerendered"), {
     force: true,
     recursive: true
   });
@@ -178213,7 +178751,7 @@ console.log(\`
   const entrypointCode = generateEntrypoint(resolvedOutdir, serverEntry, prerenderMap, absoluteVersion, buildConfig);
   const entrypointPath = join32(resolvedOutdir, "_compile_entrypoint.ts");
   await Bun.write(entrypointPath, entrypointCode);
-  mkdirSync17(dirname16(resolvedOutfile), { recursive: true });
+  mkdirSync18(dirname17(resolvedOutfile), { recursive: true });
   const result = await Bun.build({
     compile: { outfile: resolvedOutfile },
     define: { "process.env.NODE_ENV": '"production"' },
@@ -178311,11 +178849,11 @@ var exports_typecheck = {};
 __export(exports_typecheck, {
   typecheck: () => typecheck
 });
-import { resolve as resolve23, join as join33 } from "path";
-import { existsSync as existsSync38, readFileSync as readFileSync35 } from "fs";
+import { resolve as resolve24, join as join33 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync36 } from "fs";
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve23(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
-  if (!existsSync38(resolveConfigPath(configPath2))) {
+var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve24(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
+  if (!existsSync39(resolveConfigPath(configPath2))) {
     const defaultService = {};
     return [defaultService];
   }
@@ -178336,8 +178874,8 @@ var isCommandService3 = (service) => service.kind === "command" || Array.isArray
   const exitCode = await proc.exited;
   return { exitCode, name, output: (stdout + stderr).trim() };
 }, shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`, runShell = async (name, command) => run(name, ["/bin/bash", "-lc", command]), findBin = (name) => {
-  const local = resolve23("node_modules", ".bin", name);
-  return existsSync38(local) ? local : null;
+  const local = resolve24("node_modules", ".bin", name);
+  return existsSync39(local) ? local : null;
 }, ANSI_COLOR_REGEX, ANSI_PURPLE_REGEX, ANSI_CYAN_REGEX, ANSI_TOKEN_END_REGEX, stripAnsi3 = (str) => str.replace(ANSI_COLOR_REGEX, ""), formatSvelteOutput = (output) => {
   const cwd = `${process.cwd()}/`;
   const summaryMatch = stripAnsi3(output).match(/svelte-check found (\d+) error/);
@@ -178384,15 +178922,15 @@ Found ${errorCount} error${suffix}.`;
   return formatted;
 }, ABSOLUTE_INTERNAL_EXCLUDES, resolveAbsoluteTypeFile = (fileName) => {
   const candidates = [
-    resolve23("node_modules/@absolutejs/absolute/dist/types", fileName),
-    resolve23(import.meta.dir, "../types", fileName),
-    resolve23(import.meta.dir, "../../types", fileName),
-    resolve23(import.meta.dir, "../../../types", fileName)
+    resolve24("node_modules/@absolutejs/absolute/dist/types", fileName),
+    resolve24(import.meta.dir, "../types", fileName),
+    resolve24(import.meta.dir, "../../types", fileName),
+    resolve24(import.meta.dir, "../../../types", fileName)
   ];
-  return candidates.find((candidate) => existsSync38(candidate)) ?? candidates[0];
+  return candidates.find((candidate) => existsSync39(candidate)) ?? candidates[0];
 }, ABSOLUTE_TYPECHECK_FILES, readProjectTsconfig = () => {
   try {
-    return JSON.parse(readFileSync35(resolve23("tsconfig.json"), "utf-8"));
+    return JSON.parse(readFileSync36(resolve24("tsconfig.json"), "utf-8"));
   } catch {
     return {};
   }
@@ -178426,13 +178964,13 @@ Found ${errorCount} error${suffix}.`;
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve23("tsconfig.json"),
+    extends: resolve24("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("vue-tsc", [
     vueTscBin,
     "--noEmit",
     "--project",
-    resolve23(vueTsconfigPath),
+    resolve24(vueTsconfigPath),
     "--incremental",
     "--tsBuildInfoFile",
     join33(cacheDir, "vue-tsc.tsbuildinfo"),
@@ -178454,10 +178992,10 @@ Found ${errorCount} error${suffix}.`;
       rootDir: ".."
     },
     exclude: ABSOLUTE_INTERNAL_EXCLUDES.map(toGeneratedConfigPath),
-    extends: resolve23("tsconfig.json"),
+    extends: resolve24("tsconfig.json"),
     include: [`../${angularDir}/**/*`]
   }, null, "\t"));
-  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve23(angularTsconfigPath))}`);
+  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve24(angularTsconfigPath))}`);
 }, buildTscCheck = (cacheDir) => {
   const tscBin = findBin("tsc");
   if (!tscBin) {
@@ -178470,13 +179008,13 @@ Found ${errorCount} error${suffix}.`;
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve23("tsconfig.json"),
+    extends: resolve24("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("tsc", [
     tscBin,
     "--noEmit",
     "--project",
-    resolve23(tscConfigPath),
+    resolve24(tscConfigPath),
     "--incremental",
     "--tsBuildInfoFile",
     join33(cacheDir, "tsc.tsbuildinfo"),
@@ -178490,14 +179028,14 @@ Found ${errorCount} error${suffix}.`;
   }
   const svelteTsconfigPath = join33(cacheDir, "tsconfig.svelte-check.json");
   await writeFile(svelteTsconfigPath, JSON.stringify({
-    extends: resolve23("tsconfig.json"),
+    extends: resolve24("tsconfig.json"),
     files: ABSOLUTE_TYPECHECK_FILES,
     include: [`../${svelteDir}/**/*`]
   }, null, "\t"));
   return run("svelte-check", [
     svelteBin,
     "--tsconfig",
-    resolve23(svelteTsconfigPath),
+    resolve24(svelteTsconfigPath),
     "--threshold",
     "error",
     "--compiler-warnings",
@@ -178691,11 +179229,11 @@ var DEFAULT_RELAY_PORT = 8787, DEFAULT_REQUEST_TIMEOUT_MS = 30000, headersToObje
         url: url.pathname + url.search,
         ...bodyBytes && bodyBytes.length > 0 ? { bodyBase64: Buffer.from(bodyBytes).toString("base64") } : {}
       };
-      const responsePromise = new Promise((resolve24) => {
-        pending.set(id, resolve24);
+      const responsePromise = new Promise((resolve25) => {
+        pending.set(id, resolve25);
       });
       client.send(encodeTunnelMessage(message));
-      const timeout = new Promise((resolve24) => setTimeout(() => resolve24({ id, message: "timeout", type: "error" }), requestTimeoutMs));
+      const timeout = new Promise((resolve25) => setTimeout(() => resolve25({ id, message: "timeout", type: "error" }), requestTimeoutMs));
       const result = await Promise.race([responsePromise, timeout]);
       pending.delete(id);
       if (result.type === "error") {
@@ -179990,377 +180528,8 @@ var dev = async (serverEntry, configPath2) => {
   await monitorServer();
 };
 
-// src/cli/scripts/eslint.ts
-import { createHash } from "crypto";
-import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync8,
-  renameSync,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync5
-} from "fs";
-import { dirname as dirname3, resolve as resolve4 } from "path";
-var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache";
-var CACHE_CONTRACT_VERSION = "1";
-var CACHE_FINGERPRINT_SUFFIX = ".fingerprint";
-var flagValue = (args, flag) => {
-  const assignment = args.find((arg) => arg.startsWith(`${flag}=`));
-  if (assignment)
-    return assignment.slice(flag.length + 1);
-  const index = args.indexOf(flag);
-  return index < 0 ? undefined : args[index + 1];
-};
-var getCacheLocation = (args) => flagValue(args, "--cache-location")?.trim() || process.env.ABSOLUTE_ESLINT_CACHE?.trim() || DEFAULT_CACHE_LOCATION;
-var CONFIG_CANDIDATES = [
-  "eslint.config.js",
-  "eslint.config.mjs",
-  "eslint.config.cjs",
-  "eslint.config.ts",
-  "eslint.config.mts",
-  "eslint.config.cts"
-];
-var FLAG_VALUE_FLAGS = new Set([
-  "-c",
-  "--config",
-  "--cache-location",
-  "--cache-strategy",
-  "--ignore-path",
-  "--ignore-pattern",
-  "--rule",
-  "--rulesdir",
-  "--ext",
-  "-f",
-  "--format",
-  "--max-warnings",
-  "--parser",
-  "--parser-options",
-  "--plugin",
-  "--global",
-  "--env",
-  "--report-unused-disable-directives-severity",
-  "--resolve-plugins-relative-to",
-  "-o",
-  "--output-file",
-  "--flag",
-  "--inspect-config",
-  "--stats",
-  "--concurrency"
-]);
-var hasUserPositional = (args) => {
-  for (let index = 0;index < args.length; index++) {
-    const arg = args[index];
-    if (arg === undefined)
-      continue;
-    if (arg.startsWith("-")) {
-      if (arg.includes("="))
-        continue;
-      if (FLAG_VALUE_FLAGS.has(arg))
-        index++;
-      continue;
-    }
-    return true;
-  }
-  return false;
-};
-var findConfigPath = (cwd = process.cwd()) => {
-  for (const name of CONFIG_CANDIDATES) {
-    const candidate = resolve4(cwd, name);
-    if (existsSync6(candidate))
-      return candidate;
-  }
-  return null;
-};
-var fingerprintLocation = (cacheLocation, cwd) => {
-  const absolute = resolve4(cwd, cacheLocation);
-  return /[\\/]$/.test(cacheLocation) ? resolve4(absolute, CACHE_FINGERPRINT_SUFFIX.slice(1)) : `${absolute}${CACHE_FINGERPRINT_SUFFIX}`;
-};
-var addFileToFingerprint = (hash, path, label) => {
-  if (!existsSync6(path))
-    return;
-  hash.update(label);
-  hash.update("\x00");
-  hash.update(readFileSync8(path));
-  hash.update("\x00");
-};
-var packageNameFor = (specifier) => {
-  if (specifier.startsWith("@"))
-    return specifier.split("/").slice(0, 2).join("/");
-  const [name = specifier] = specifier.split("/");
-  return name;
-};
-var configPackageNames = (configPath2) => {
-  if (!configPath2)
-    return [];
-  const source = readFileSync8(configPath2, "utf-8");
-  const names = new Set;
-  for (const match of source.matchAll(/(?:from\s+|import\s*(?:\(\s*)?|require\s*\(\s*)(['"])([^'".][^'"]*)\1/g)) {
-    const [, , specifier] = match;
-    if (specifier)
-      names.add(packageNameFor(specifier));
-  }
-  return [...names];
-};
-var manifestDependencyNames = (manifest) => {
-  if (manifest === null || typeof manifest !== "object")
-    return [];
-  return Object.entries(manifest).flatMap(([key, value]) => {
-    if (key !== "dependencies" && key !== "devDependencies")
-      return [];
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-      return [];
-    return Object.keys(value);
-  });
-};
-var lintDependencyNames = (cwd, configPath2) => {
-  const manifestPath = resolve4(cwd, "package.json");
-  if (!existsSync6(manifestPath))
-    return configPackageNames(configPath2);
-  try {
-    const manifest = JSON.parse(readFileSync8(manifestPath, "utf-8"));
-    const lintPackages = manifestDependencyNames(manifest).filter((name) => /eslint|typescript/.test(name));
-    return [
-      ...new Set([...lintPackages, ...configPackageNames(configPath2)])
-    ];
-  } catch {
-    return configPackageNames(configPath2);
-  }
-};
-var findInstalledManifest = (cwd, dependency) => {
-  let directory = cwd;
-  while (true) {
-    const candidate = resolve4(directory, "node_modules", dependency, "package.json");
-    if (existsSync6(candidate))
-      return candidate;
-    const parent = dirname3(directory);
-    if (parent === directory)
-      return null;
-    directory = parent;
-  }
-};
-var createEslintCacheFingerprint = (cwd = process.cwd()) => {
-  const hash = createHash("sha256");
-  hash.update(`absolute-eslint-cache:${CACHE_CONTRACT_VERSION}\x00`);
-  const configPath2 = findConfigPath(cwd);
-  if (configPath2)
-    addFileToFingerprint(hash, configPath2, configPath2);
-  for (const dependency of lintDependencyNames(cwd, configPath2).sort()) {
-    const manifestPath = findInstalledManifest(cwd, dependency);
-    if (manifestPath)
-      addFileToFingerprint(hash, manifestPath, dependency);
-  }
-  return hash.digest("hex");
-};
-var writeFingerprint = (path, fingerprint) => {
-  mkdirSync5(dirname3(path), { recursive: true });
-  const temporary = `${path}.${process.pid}.tmp`;
-  writeFileSync5(temporary, `${fingerprint}
-`);
-  renameSync(temporary, path);
-};
-var prepareEslintCache = (options) => {
-  const cwd = options.cwd ?? process.cwd();
-  const cachePath = resolve4(cwd, options.cacheLocation);
-  const metadataPath = fingerprintLocation(options.cacheLocation, cwd);
-  const fingerprint = options.fingerprint ?? createEslintCacheFingerprint(cwd);
-  const prior = existsSync6(metadataPath) ? readFileSync8(metadataPath, "utf-8").trim() : null;
-  if (prior === fingerprint)
-    return false;
-  rmSync3(cachePath, { force: true, recursive: true });
-  if (metadataPath !== cachePath)
-    rmSync3(metadataPath, { force: true, recursive: true });
-  writeFingerprint(metadataPath, fingerprint);
-  return true;
-};
-var hasKey = (objectLiteralSource, key) => {
-  const pattern = new RegExp(`(^|[\\s,{])${key}\\s*:`, "m");
-  return pattern.test(objectLiteralSource);
-};
-var NON_GLOBAL_IGNORE_KEYS = [
-  "files",
-  "rules",
-  "plugins",
-  "languageOptions",
-  "linterOptions",
-  "processor",
-  "settings",
-  "extends"
-];
-var isGlobalIgnoresBlock = (block) => {
-  if (!hasKey(block, "ignores"))
-    return false;
-  return !NON_GLOBAL_IGNORE_KEYS.some((key) => hasKey(block, key));
-};
-var extractTopLevelObjectLiterals = (source) => {
-  const arrayStart = source.search(/defineConfig\s*\(\s*\[|export\s+default\s*\[/);
-  if (arrayStart === -1)
-    return [];
-  const fromArray = source.slice(arrayStart);
-  const openBracket = fromArray.indexOf("[");
-  if (openBracket === -1)
-    return [];
-  const blocks = [];
-  let depth = 0;
-  let blockStart = -1;
-  let inString = null;
-  let inLineComment = false;
-  let inBlockComment = false;
-  for (let i = openBracket;i < fromArray.length; i++) {
-    const char = fromArray[i];
-    const next = fromArray[i + 1];
-    if (inLineComment) {
-      if (char === `
-`)
-        inLineComment = false;
-      continue;
-    }
-    if (inBlockComment) {
-      if (char === "*" && next === "/") {
-        inBlockComment = false;
-        i++;
-      }
-      continue;
-    }
-    if (inString) {
-      if (char === "\\") {
-        i++;
-        continue;
-      }
-      if (char === inString)
-        inString = null;
-      continue;
-    }
-    if (char === "/" && next === "/") {
-      inLineComment = true;
-      continue;
-    }
-    if (char === "/" && next === "*") {
-      inBlockComment = true;
-      i++;
-      continue;
-    }
-    if (char === '"' || char === "'" || char === "`") {
-      inString = char;
-      continue;
-    }
-    if (char === "{") {
-      if (depth === 0)
-        blockStart = i;
-      depth++;
-    } else if (char === "}") {
-      depth--;
-      if (depth === 0 && blockStart !== -1) {
-        blocks.push(fromArray.slice(blockStart, i + 1));
-        blockStart = -1;
-      }
-    } else if (char === "]" && depth === 0) {
-      break;
-    }
-  }
-  return blocks;
-};
-var checkForMisplacedIgnores = () => {
-  const configPath2 = findConfigPath();
-  if (!configPath2)
-    return;
-  let source;
-  try {
-    source = readFileSync8(configPath2, "utf-8");
-  } catch {
-    return;
-  }
-  const blocks = extractTopLevelObjectLiterals(source);
-  if (blocks.some(isGlobalIgnoresBlock))
-    return;
-  let offenderCount = 0;
-  for (const block of blocks) {
-    if (hasKey(block, "ignores") && hasKey(block, "files")) {
-      offenderCount++;
-    }
-  }
-  if (offenderCount === 0)
-    return;
-  const yellow = "\x1B[33m";
-  const reset = "\x1B[0m";
-  const bold = "\x1B[1m";
-  console.warn(`${yellow}${bold}\u26A0 ESLint flat-config warning${reset}${yellow}: found ${offenderCount} config block(s) where \`ignores\` lives alongside \`files\`. In ESLint v9, \`ignores\` is only a *global* ignore when it's the sole key in its config object \u2014 otherwise it just suppresses that block's own rules and ESLint still walks every other directory (including node_modules), making lint extremely slow.
-
-Move ignores into a standalone block at the top of your config:
-
-  export default defineConfig([
-    { ignores: ['node_modules/**', 'dist/**', 'build/**', '.absolutejs/**'] },
-    pluginJs.configs.recommended,
-    ...
-  ]);
-
-Detected at: ${configPath2}${reset}`);
-};
-var formatDuration = (durationMs) => {
-  if (durationMs < 1000)
-    return `${durationMs}ms`;
-  if (durationMs < 60000)
-    return `${(durationMs / 1000).toFixed(2)}s`;
-  const minutes = Math.floor(durationMs / 60000);
-  const seconds = Math.round(durationMs % 60000 / 1000);
-  return `${minutes}m ${seconds}s`;
-};
-var handleClearCache = (cacheLocation, cwd = process.cwd()) => {
-  try {
-    const cachePath = resolve4(cwd, cacheLocation);
-    const metadataPath = fingerprintLocation(cacheLocation, cwd);
-    rmSync3(cachePath, { force: true, recursive: true });
-    rmSync3(metadataPath, { force: true, recursive: true });
-    console.log(`\x1B[32m\u2713\x1B[0m Cleared cache: ${cacheLocation}`);
-  } catch (err) {
-    console.error(`\x1B[31m\u2717\x1B[0m Failed to clear cache at ${cacheLocation}:`, err);
-    process.exit(1);
-  }
-};
-var buildEslintCommand = (args, cacheLocation) => {
-  const cacheEnabled = !args.includes("--no-cache");
-  const hasCacheLocation = args.some((arg) => arg === "--cache-location" || arg.startsWith("--cache-location="));
-  const hasCacheStrategy = args.some((arg) => arg === "--cache-strategy" || arg.startsWith("--cache-strategy="));
-  return [
-    "bun",
-    "eslint",
-    ...cacheEnabled ? ["--cache"] : [],
-    ...cacheEnabled && !hasCacheLocation ? ["--cache-location", cacheLocation] : [],
-    ...cacheEnabled && !hasCacheStrategy ? ["--cache-strategy", "content"] : [],
-    ...args,
-    ...hasUserPositional(args) ? [] : ["."]
-  ];
-};
-var eslint = async (args) => {
-  const cacheLocation = getCacheLocation(args);
-  if (args.includes("--clear-cache")) {
-    handleClearCache(cacheLocation);
-    return;
-  }
-  if (!existsSync6(resolve4("node_modules", ".bin", "eslint"))) {
-    console.error("\x1B[31m\u2717\x1B[0m ESLint is not installed in this project. Add it (and a flat `eslint.config.*`): bun add -d eslint");
-    process.exit(1);
-  }
-  checkForMisplacedIgnores();
-  const cacheEnabled = !args.includes("--no-cache");
-  if (cacheEnabled)
-    prepareEslintCache({ cacheLocation });
-  const command = buildEslintCommand(args, cacheLocation);
-  const dim = "\x1B[2m";
-  const reset = "\x1B[0m";
-  console.log(cacheEnabled ? `${dim}cache: ${cacheLocation} (content-aware; lint-tool changes invalidate automatically)${reset}` : `${dim}cache: disabled${reset}`);
-  const startedAt = Date.now();
-  const proc = Bun.spawn(command, {
-    stderr: "inherit",
-    stdout: "inherit"
-  });
-  const exitCode = await proc.exited;
-  const elapsed = formatDuration(Date.now() - startedAt);
-  if (exitCode !== 0) {
-    console.log(`${dim}elapsed: ${elapsed}${reset}`);
-    process.exit(exitCode);
-  }
-  console.log(`\x1B[32m\u2713\x1B[0m Passed ${dim}(${elapsed})${reset}`);
-};
+// src/cli/index.ts
+init_eslint();
 
 // src/cli/scripts/info.ts
 init_constants();
@@ -182470,6 +182639,10 @@ if (command === "dev") {
 } else if (command === "eslint") {
   sendTelemetryEvent("cli:command", { command });
   await eslint(args);
+} else if (command === "lint-proof") {
+  sendTelemetryEvent("cli:command", { command });
+  const { runLintProof: runLintProof2 } = await Promise.resolve().then(() => (init_lintProof(), exports_lintProof));
+  process.exitCode = await runLintProof2(args);
 } else if (command === "prettier") {
   sendTelemetryEvent("cli:command", { command });
   await prettier(args);
@@ -182585,6 +182758,7 @@ if (command === "dev") {
   console.error("  analyze [--save] [--json] Bundle size breakdown + diff vs a saved baseline");
   console.error("  api [--open] [--json] Show the API surface or open the OpenAPI UI (@elysiajs/openapi)");
   console.error("  eslint        Run ESLint (cached)");
+  console.error("  lint-proof <run|verify> -- <command> Record or verify an exact-source local lint pass");
   console.error("  generate <page|api|component> <name> [--framework <fw>] Scaffold a page, API plugin, or component");
   console.error("  htmx [version] Self-host htmx \u2014 report or install/upgrade the pinned copy");
   console.error("  info          Print system info for bug reports");