@absolutejs/absolute 0.20.0-beta.13 → 0.20.0-beta.15

package/dist/index.js

@@ -13198,9 +13198,392 @@ var isTestSourcePath = (file2) => {
   return normalized.includes("/__tests__/") || /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(normalized);
 };
 
+// node_modules/@absolutejs/sync/dist/client/index.js
+var RUNTIME_TRANSPORT, host, isRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations")), registry, SyncLocalDataPolicyError, SyncLocalStoreSchemaError, positiveVersion = (value, label) => {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new SyncLocalStoreSchemaError("INVALID_PLAN", `${label} must be a positive safe integer`);
+  return value;
+}, isSchemaBundle = (schema) => ("components" in schema), validatePolicyMatch = (match, label) => {
+  if (match.length === 0 || match.trim() !== match || /^\*+$/.test(match) || match.includes("**"))
+    throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.match must be an exact name or a non-empty glob without adjacent wildcards.`);
+}, validateSyncLocalDataPolicy = (policy, label = "localData") => {
+  if (policy.maxBytesPerNamespace !== undefined && (!Number.isSafeInteger(policy.maxBytesPerNamespace) || policy.maxBytesPerNamespace < 1))
+    throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.maxBytesPerNamespace must be a positive safe integer.`);
+  for (const [index, rule] of (policy.collections ?? []).entries()) {
+    validatePolicyMatch(rule.match, `${label}.collections[${index}]`);
+    if (rule.maxAgeMs !== undefined && (!Number.isSafeInteger(rule.maxAgeMs) || rule.maxAgeMs < 1))
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}].maxAgeMs must be a positive safe integer.`);
+    if (rule.persistence === "memory-only" && rule.protection === "required")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}] cannot require at-rest protection when it is memory-only.`);
+    if (rule.sensitivity !== undefined && rule.sensitivity !== "public" && rule.protection !== "required" && rule.persistence !== "memory-only")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}] declares ${rule.sensitivity} data without required protection or memory-only persistence.`);
+  }
+  for (const [index, rule] of (policy.mutations ?? []).entries()) {
+    validatePolicyMatch(rule.match, `${label}.mutations[${index}]`);
+    if (rule.sensitivity !== undefined && rule.sensitivity !== "public" && rule.protection !== "required" && rule.persistence !== "memory-only")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}] declares ${rule.sensitivity} arguments without required protection.`);
+  }
+  return policy;
+}, normalizeSyncLocalSchemaComponents = (schema = { version: 1 }) => {
+  const components = isSchemaBundle(schema) ? [...schema.components] : [{ ...schema, id: "@absolutejs/app" }];
+  const ids = new Set;
+  for (const component of components) {
+    if (typeof component.id !== "string" || component.id.trim() !== component.id || component.id.length === 0)
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", "Sync schema component id must be non-empty and trimmed");
+    if (ids.has(component.id))
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", `Sync schema component "${component.id}" is declared more than once`);
+    ids.add(component.id);
+    if (component.localData)
+      validateSyncLocalDataPolicy(component.localData, `${component.id}.localData`);
+  }
+  return components.sort((a, b2) => a.id.localeCompare(b2.id));
+}, resolveSyncLocalSchemaComponents = (storedVersions, schema = { version: 1 }) => {
+  const components = normalizeSyncLocalSchemaComponents(schema).map((component) => {
+    const current = resolveSyncLocalMigrations(component.version, component);
+    return {
+      id: component.id,
+      ...resolveSyncLocalMigrations(storedVersions[component.id] ?? current.minimumCompatibleVersion, component)
+    };
+  });
+  const active = new Set(components.map((component) => component.id));
+  const orphanedComponents = Object.keys(storedVersions).filter((id) => !active.has(id)).sort();
+  return { components, orphanedComponents };
+}, resolveSyncLocalMigrations = (storedVersion, schema = { version: 1 }) => {
+  positiveVersion(storedVersion, "Stored Sync schema version");
+  const targetVersion = positiveVersion(schema.version, "Target Sync schema version");
+  const migrations = [...schema.migrations ?? []].sort((a, b2) => a.toVersion - b2.toVersion);
+  const versions = new Set;
+  for (const migration of migrations) {
+    positiveVersion(migration.toVersion, "Sync migration toVersion");
+    if (versions.has(migration.toVersion))
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", `Sync migration ${migration.toVersion} is declared more than once`);
+    versions.add(migration.toVersion);
+  }
+  const inferredMinimum = migrations[0] ? migrations[0].toVersion - 1 : targetVersion;
+  const minimumCompatibleVersion = positiveVersion(schema.minimumCompatibleVersion ?? inferredMinimum, "Minimum compatible Sync schema version");
+  if (minimumCompatibleVersion > targetVersion)
+    throw new SyncLocalStoreSchemaError("INVALID_PLAN", "Minimum compatible Sync schema version cannot exceed its target");
+  if (storedVersion > targetVersion)
+    throw new SyncLocalStoreSchemaError("SCHEMA_TOO_NEW", `Stored Sync schema ${storedVersion} is newer than this runtime's schema ${targetVersion}`, { storedVersion, targetVersion });
+  if (storedVersion < minimumCompatibleVersion)
+    throw new SyncLocalStoreSchemaError("SCHEMA_TOO_OLD", `Stored Sync schema ${storedVersion} is older than the minimum compatible schema ${minimumCompatibleVersion}`, { storedVersion, targetVersion });
+  const steps = [];
+  for (let version = storedVersion + 1;version <= targetVersion; version++) {
+    const migration = migrations.find((candidate) => candidate.toVersion === version);
+    if (migration === undefined)
+      throw new SyncLocalStoreSchemaError("MIGRATION_MISSING", `Sync migration ${version - 1} -> ${version} is missing`, { storedVersion, targetVersion });
+    steps.push(migration);
+  }
+  return { minimumCompatibleVersion, steps, targetVersion };
+};
+var init_client = __esm(() => {
+  RUNTIME_TRANSPORT = Symbol.for("@absolutejs/sync/client-runtime-transport");
+  host = globalThis;
+  registry = (() => {
+    const existing = host[RUNTIME_TRANSPORT];
+    if (isRegistry(existing))
+      return existing;
+    const created = { installations: [] };
+    Object.defineProperty(host, RUNTIME_TRANSPORT, {
+      configurable: false,
+      enumerable: false,
+      value: created,
+      writable: false
+    });
+    return created;
+  })();
+  SyncLocalDataPolicyError = class SyncLocalDataPolicyError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "SyncLocalDataPolicyError";
+      this.code = code;
+    }
+  };
+  SyncLocalStoreSchemaError = class SyncLocalStoreSchemaError extends Error {
+    code;
+    storedVersion;
+    targetVersion;
+    constructor(code, message, versions = {}) {
+      super(message);
+      this.name = "SyncLocalStoreSchemaError";
+      this.code = code;
+      this.storedVersion = versions.storedVersion;
+      this.targetVersion = versions.targetVersion;
+    }
+  };
+});
+
+// src/mobile/syncSchema.ts
+import { readFileSync as readFileSync17 } from "fs";
+import { dirname as dirname16, join as join29, resolve as resolve25 } from "path";
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value), manifestAt = (path) => {
+  try {
+    const value = JSON.parse(readFileSync17(path, "utf8"));
+    return object(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}, localSchemaMetadata = (manifest) => {
+  const absolutejs = Reflect.get(manifest, "absolutejs");
+  if (!object(absolutejs))
+    return;
+  const sync = Reflect.get(absolutejs, "sync");
+  if (!object(sync))
+    return;
+  return Reflect.get(sync, "localSchema");
+}, packageManifestPath = (projectRoot, packageName) => {
+  let directory = resolve25(projectRoot);
+  while (true) {
+    const candidate = join29(directory, "node_modules", packageName, "package.json");
+    const manifest = manifestAt(candidate);
+    if (manifest && Reflect.get(manifest, "name") === packageName)
+      return candidate;
+    const parent = dirname16(directory);
+    if (parent === directory)
+      return;
+    directory = parent;
+  }
+}, metadataError = (id, detail) => new TypeError(`Invalid AbsoluteJS Sync schema metadata for ${id}: ${detail}`), positiveVersion2 = (value, id, field) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+    throw metadataError(id, `${field} must be a positive safe integer.`);
+  return value;
+}, nonEmpty = (value, id, field) => {
+  if (typeof value !== "string" || value.trim() !== value || value.length === 0)
+    throw metadataError(id, `${field} must be a non-empty trimmed string.`);
+  return value;
+}, requireObject = (value, id, detail) => {
+  if (!object(value))
+    throw metadataError(id, detail);
+  return value;
+}, unknownField = (record, key) => record[key], normalizeJsonValue2 = (value, id, field) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return value;
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (Array.isArray(value))
+    return value.map((entry) => normalizeJsonValue2(entry, id, field));
+  if (object(value))
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      normalizeJsonValue2(entry, id, field)
+    ]));
+  throw metadataError(id, `${field} must be JSON-safe.`);
+}, operation = (value, id, index) => {
+  const record = requireObject(value, id, `migration operation ${index} must be an object.`);
+  const type = Reflect.get(record, "type");
+  const collection = nonEmpty(Reflect.get(record, "collection"), id, `operation ${index}.collection`);
+  if (type === "delete-collection")
+    return { collection, type };
+  if (type === "rename-field")
+    return {
+      collection,
+      from: nonEmpty(Reflect.get(record, "from"), id, `operation ${index}.from`),
+      to: nonEmpty(Reflect.get(record, "to"), id, `operation ${index}.to`),
+      type
+    };
+  const field = nonEmpty(Reflect.get(record, "field"), id, `operation ${index}.field`);
+  if (type === "remove-field")
+    return { collection, field, type };
+  if (type === "set-default")
+    return {
+      collection,
+      field,
+      type,
+      value: normalizeJsonValue2(Reflect.get(record, "value"), id, `operation ${index}.value`)
+    };
+  throw metadataError(id, `operation ${index}.type is not supported.`);
+}, migration = (value, id, index) => {
+  const record = requireObject(value, id, `migration ${index} must be an object.`);
+  const allowed = new Set(["operations", "toVersion"]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `migration ${index}.${unsupported} is not declarative metadata.`);
+  const declaredOperations = Reflect.get(record, "operations");
+  if (declaredOperations !== undefined && !Array.isArray(declaredOperations))
+    throw metadataError(id, `migration ${index}.operations must be an array.`);
+  const operations = Array.isArray(declaredOperations) ? declaredOperations : [];
+  return {
+    operations: operations.map((entry, operationIndex) => operation(entry, id, operationIndex)),
+    toVersion: positiveVersion2(Reflect.get(record, "toVersion"), id, `migration ${index}.toVersion`)
+  };
+}, localDataPolicy = (value, id) => {
+  const record = requireObject(value, id, "localData must be an object.");
+  const allowed = new Set([
+    "collections",
+    "maxBytesPerNamespace",
+    "mutations"
+  ]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `localData.${unsupported} is not supported.`);
+  const collectionRules = Reflect.get(record, "collections");
+  const mutationRules = Reflect.get(record, "mutations");
+  if (collectionRules !== undefined && !Array.isArray(collectionRules))
+    throw metadataError(id, "localData.collections must be an array.");
+  if (mutationRules !== undefined && !Array.isArray(mutationRules))
+    throw metadataError(id, "localData.mutations must be an array.");
+  const collections = Array.isArray(collectionRules) ? collectionRules.map((entry, index) => {
+    const rule = requireObject(entry, id, `localData.collections[${index}] must be an object.`);
+    const allowedRuleKeys = new Set([
+      "evictionPriority",
+      "match",
+      "maxAgeMs",
+      "onProtectionUnavailable",
+      "persistence",
+      "protection",
+      "sensitivity"
+    ]);
+    const unsupportedRuleKey = Object.keys(rule).find((key) => !allowedRuleKeys.has(key));
+    if (unsupportedRuleKey)
+      throw metadataError(id, `localData.collections[${index}].${unsupportedRuleKey} is not supported.`);
+    const match = nonEmpty(Reflect.get(rule, "match"), id, `localData.collections[${index}].match`);
+    const persistence = unknownField(rule, "persistence");
+    const sensitivity = unknownField(rule, "sensitivity");
+    const protection = unknownField(rule, "protection");
+    const onProtectionUnavailable = unknownField(rule, "onProtectionUnavailable");
+    const evictionPriority = unknownField(rule, "evictionPriority");
+    const maxAge = unknownField(rule, "maxAgeMs");
+    if (persistence !== undefined && persistence !== "durable" && persistence !== "memory-only")
+      throw metadataError(id, `localData.collections[${index}].persistence is invalid.`);
+    if (sensitivity !== undefined && sensitivity !== "public" && sensitivity !== "private" && sensitivity !== "secret")
+      throw metadataError(id, `localData.collections[${index}].sensitivity is invalid.`);
+    if (protection !== undefined && protection !== "none" && protection !== "required")
+      throw metadataError(id, `localData.collections[${index}].protection is invalid.`);
+    if (onProtectionUnavailable !== undefined && onProtectionUnavailable !== "error" && onProtectionUnavailable !== "memory-only")
+      throw metadataError(id, `localData.collections[${index}].onProtectionUnavailable is invalid.`);
+    if (evictionPriority !== undefined && evictionPriority !== "critical" && evictionPriority !== "normal" && evictionPriority !== "disposable")
+      throw metadataError(id, `localData.collections[${index}].evictionPriority is invalid.`);
+    return {
+      match,
+      ...sensitivity ? { sensitivity } : {},
+      ...persistence ? { persistence } : {},
+      ...protection ? { protection } : {},
+      ...onProtectionUnavailable ? {
+        onProtectionUnavailable
+      } : {},
+      ...evictionPriority ? { evictionPriority } : {},
+      ...maxAge === undefined ? {} : {
+        maxAgeMs: positiveVersion2(maxAge, id, `localData.collections[${index}].maxAgeMs`)
+      }
+    };
+  }) : undefined;
+  const mutations = Array.isArray(mutationRules) ? mutationRules.map((entry, index) => {
+    const rule = requireObject(entry, id, `localData.mutations[${index}] must be an object.`);
+    const allowedRuleKeys = new Set([
+      "match",
+      "persistence",
+      "protection",
+      "sensitivity"
+    ]);
+    const unsupportedRuleKey = Object.keys(rule).find((key) => !allowedRuleKeys.has(key));
+    if (unsupportedRuleKey)
+      throw metadataError(id, `localData.mutations[${index}].${unsupportedRuleKey} is not supported.`);
+    const protection = unknownField(rule, "protection");
+    const sensitivity = unknownField(rule, "sensitivity");
+    const persistence = unknownField(rule, "persistence");
+    if (protection !== undefined && protection !== "none" && protection !== "required")
+      throw metadataError(id, `localData.mutations[${index}].protection is invalid.`);
+    if (sensitivity !== undefined && sensitivity !== "public" && sensitivity !== "private" && sensitivity !== "secret")
+      throw metadataError(id, `localData.mutations[${index}].sensitivity is invalid.`);
+    if (persistence !== undefined && persistence !== "durable" && persistence !== "memory-only")
+      throw metadataError(id, `localData.mutations[${index}].persistence is invalid.`);
+    return {
+      match: nonEmpty(Reflect.get(rule, "match"), id, `localData.mutations[${index}].match`),
+      ...sensitivity ? { sensitivity } : {},
+      ...persistence ? {
+        persistence
+      } : {},
+      ...protection ? { protection } : {}
+    };
+  }) : undefined;
+  const quota = Reflect.get(record, "maxBytesPerNamespace");
+  return {
+    ...collections ? { collections } : {},
+    ...mutations ? { mutations } : {},
+    ...quota === undefined ? {} : {
+      maxBytesPerNamespace: positiveVersion2(quota, id, "localData.maxBytesPerNamespace")
+    }
+  };
+}, component = (id, value) => {
+  const record = requireObject(value, id, "localSchema must be an object.");
+  const allowed = new Set([
+    "localData",
+    "migrations",
+    "minimumCompatibleVersion",
+    "version"
+  ]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `${unsupported} is not supported.`);
+  const version = positiveVersion2(Reflect.get(record, "version"), id, "version");
+  const declaredMinimum = Reflect.get(record, "minimumCompatibleVersion");
+  const minimumCompatibleVersion = declaredMinimum === undefined ? Math.max(1, version - 2) : positiveVersion2(declaredMinimum, id, "minimumCompatibleVersion");
+  const declaredMigrations = Reflect.get(record, "migrations");
+  const declaredLocalData = Reflect.get(record, "localData");
+  if (declaredMigrations !== undefined && !Array.isArray(declaredMigrations))
+    throw metadataError(id, "migrations must be an array.");
+  const migrations = Array.isArray(declaredMigrations) ? declaredMigrations : undefined;
+  return {
+    id,
+    ...declaredLocalData === undefined ? {} : { localData: localDataPolicy(declaredLocalData, id) },
+    minimumCompatibleVersion,
+    ...Array.isArray(migrations) ? {
+      migrations: migrations.map((entry, index) => migration(entry, id, index))
+    } : {},
+    version
+  };
+}, dependencyNames = (manifest) => [
+  Reflect.get(manifest, "dependencies"),
+  Reflect.get(manifest, "optionalDependencies"),
+  Reflect.get(manifest, "devDependencies"),
+  Reflect.get(manifest, "peerDependencies")
+].flatMap((dependencies) => object(dependencies) ? Object.keys(dependencies) : []).filter((name, index, names) => names.indexOf(name) === index).sort(), discoverAbsoluteSyncSchema = (projectRoot) => {
+  const appManifestPath = join29(resolve25(projectRoot), "package.json");
+  const appManifest = manifestAt(appManifestPath);
+  if (!appManifest)
+    return {
+      components: [
+        {
+          id: "@absolutejs/app",
+          minimumCompatibleVersion: 1,
+          version: 1
+        }
+      ],
+      sources: []
+    };
+  const appMetadata = localSchemaMetadata(appManifest);
+  const components = [
+    appMetadata === undefined ? { id: "@absolutejs/app", minimumCompatibleVersion: 1, version: 1 } : component("@absolutejs/app", appMetadata)
+  ];
+  const sources = [
+    { id: "@absolutejs/app", manifestPath: appManifestPath }
+  ];
+  for (const name of dependencyNames(appManifest)) {
+    const manifestPath = packageManifestPath(projectRoot, name);
+    if (!manifestPath)
+      continue;
+    const manifest = manifestAt(manifestPath);
+    if (!manifest)
+      continue;
+    const metadata2 = localSchemaMetadata(manifest);
+    if (metadata2 === undefined)
+      continue;
+    components.push(component(name, metadata2));
+    sources.push({ id: name, manifestPath });
+  }
+  components.sort((left, right) => left.id.localeCompare(right.id));
+  sources.sort((left, right) => left.id.localeCompare(right.id));
+  resolveSyncLocalSchemaComponents({}, { components });
+  return { components, sources };
+};
+var init_syncSchema = __esm(() => {
+  init_client();
+});
+
 // src/build/pwa.ts
 import { mkdir as mkdir8, rm as rm7, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname16, join as join29 } from "path";
+import { dirname as dirname17, join as join30 } from "path";
 var BOOTSTRAP_PUBLIC_PATH = "/__absolute/pwa/bootstrap.js", BOOTSTRAP_MARKER = "data-absolute-pwa", publicFilePath = (value, fallback, field) => {
   const input = value ?? fallback;
   if (!input.startsWith("/") || input.startsWith("//")) {
@@ -13227,7 +13610,7 @@ var BOOTSTRAP_PUBLIC_PATH = "/__absolute/pwa/bootstrap.js", BOOTSTRAP_MARKER = "
     }
   }
   return url.pathname;
-}, destinationFor = (buildPath, publicPath) => join29(buildPath, ...publicPath.split("/").filter(Boolean)), bootstrapEntrySource = ({
+}, destinationFor = (buildPath, publicPath) => join30(buildPath, ...publicPath.split("/").filter(Boolean)), bootstrapEntrySource = ({
   clientModule,
   manifestPath,
   serviceWorkerPath,
@@ -13239,7 +13622,7 @@ manifest.setAttribute('href', ${JSON.stringify(manifestPath)});
 if (!manifest.isConnected) document.head.append(manifest);
 ` : ""}await registerServiceWorker(${JSON.stringify(serviceWorkerPath)}, {
 	deferUntilLoad: false${sync ? `,
-	sync: ${JSON.stringify(sync === true ? {} : sync)}` : ""}
+	sync: ${JSON.stringify(sync)}` : ""}
 });
 `, injectionSource = () => `if (typeof window !== 'undefined') {
 	await import(new URL(${JSON.stringify(BOOTSTRAP_PUBLIC_PATH)}, window.location.origin).href);
@@ -13257,6 +13640,7 @@ if (!manifest.isConnected) document.head.append(manifest);
   buildPath,
   config,
   generatedRoot,
+  projectRoot,
   write: write2 = true
 }) => {
   const serviceWorkerPath = publicFilePath(config.serviceWorkerPath, "/sw.js", "pwa.serviceWorkerPath");
@@ -13272,9 +13656,10 @@ if (!manifest.isConnected) document.head.append(manifest);
   };
   if (!write2)
     return artifacts;
+  const syncSchema = config.sync ? discoverAbsoluteSyncSchema(projectRoot) : undefined;
   const { createWebAppManifest, pushServiceWorker } = await import("@absolutejs/pwa");
   const workerDestination = destinationFor(buildPath, serviceWorkerPath);
-  await mkdir8(dirname16(workerDestination), { recursive: true });
+  await mkdir8(dirname17(workerDestination), { recursive: true });
   await writeFile8(workerDestination, `${pushServiceWorker({
     ...config.serviceWorker ?? {},
     sync: Boolean(config.sync)
@@ -13283,19 +13668,24 @@ if (!manifest.isConnected) document.head.append(manifest);
   if (config.manifest && manifestPath) {
     const { path: _path, ...manifestConfig } = config.manifest;
     const manifestDestination = destinationFor(buildPath, manifestPath);
-    await mkdir8(dirname16(manifestDestination), { recursive: true });
+    await mkdir8(dirname17(manifestDestination), { recursive: true });
     await writeFile8(manifestDestination, `${JSON.stringify(createWebAppManifest(manifestConfig), null, "\t")}
 `);
   }
-  const generatedDirectory = join29(generatedRoot, "pwa");
-  const bootstrapEntry = join29(generatedDirectory, "bootstrap.ts");
+  const generatedDirectory = join30(generatedRoot, "pwa");
+  const bootstrapEntry = join30(generatedDirectory, "bootstrap.ts");
   const clientModule = Bun.resolveSync("@absolutejs/pwa/client", import.meta.dir);
   await mkdir8(generatedDirectory, { recursive: true });
   await writeFile8(bootstrapEntry, bootstrapEntrySource({
     clientModule,
     manifestPath,
     serviceWorkerPath,
-    sync: config.sync
+    sync: config.sync ? {
+      ...config.sync === true ? {} : config.sync,
+      storageSchema: {
+        components: syncSchema?.components ?? []
+      }
+    } : config.sync
   }));
   const browserDirectory = destinationFor(buildPath, "/__absolute/pwa");
   await rm7(browserDirectory, { force: true, recursive: true });
@@ -13318,15 +13708,17 @@ if (!manifest.isConnected) document.head.append(manifest);
   }
   return artifacts;
 };
-var init_pwa = () => {};
+var init_pwa = __esm(() => {
+  init_syncSchema();
+});
 
 // src/build/scanVueSsrOnlyPages.ts
 var exports_scanVueSsrOnlyPages = {};
 __export(exports_scanVueSsrOnlyPages, {
   scanVueSsrOnlyPages: () => scanVueSsrOnlyPages
 });
-import { readdirSync as readdirSync2, readFileSync as readFileSync17 } from "fs";
-import { join as join30 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync18 } from "fs";
+import { join as join31 } from "path";
 import ts8 from "typescript";
 var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind3 = (filePath) => {
   if (filePath.endsWith(".tsx"))
@@ -13359,9 +13751,9 @@ var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind3 = (filePath) => {
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join30(dir, entry.name));
+        stack.push(join31(dir, entry.name));
       } else if (entry.isFile() && hasSourceExtension2(entry.name)) {
-        out.push(join30(dir, entry.name));
+        out.push(join31(dir, entry.name));
       }
     }
   }
@@ -13428,7 +13820,7 @@ var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind3 = (filePath) => {
 }, extractFromFile = (filePath, out) => {
   let source;
   try {
-    source = readFileSync17(filePath, "utf-8");
+    source = readFileSync18(filePath, "utf-8");
   } catch {
     return;
   }
@@ -13472,8 +13864,8 @@ var init_scanVueSsrOnlyPages = __esm(() => {
 });
 
 // src/build/scanAngularHandlerCalls.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync18 } from "fs";
-import { join as join31 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync19 } from "fs";
+import { join as join32 } from "path";
 import ts9 from "typescript";
 var ELYSIA_ROUTE_METHODS2, SKIP_DIRS3, SOURCE_EXTENSIONS3, SERVER_ENTRY_COPY_PREFIX = ".absolutejs-hmr-", getScriptKind4 = (filePath) => {
   if (filePath.endsWith(".tsx"))
@@ -13506,9 +13898,9 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS3, SOURCE_EXTENSIONS3, SERVER_ENTRY_COPY_PRE
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join31(dir, entry.name));
+        stack.push(join32(dir, entry.name));
       } else if (entry.isFile() && !entry.name.startsWith(SERVER_ENTRY_COPY_PREFIX) && hasSourceExtension3(entry.name)) {
-        out.push(join31(dir, entry.name));
+        out.push(join32(dir, entry.name));
       }
     }
   }
@@ -13543,7 +13935,7 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS3, SOURCE_EXTENSIONS3, SERVER_ENTRY_COPY_PRE
 }, extractCallsFromFile = (filePath, out) => {
   let source;
   try {
-    source = readFileSync18(filePath, "utf-8");
+    source = readFileSync19(filePath, "utf-8");
   } catch {
     return;
   }
@@ -13622,8 +14014,8 @@ var init_scanAngularHandlerCalls = __esm(() => {
 });
 
 // src/build/scanAngularPageRoutes.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync19 } from "fs";
-import { basename as basename9, join as join32 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync20 } from "fs";
+import { basename as basename9, join as join33 } from "path";
 import ts10 from "typescript";
 var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
   const idx = filePath.lastIndexOf(".");
@@ -13663,9 +14055,9 @@ var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join32(dir, entry.name));
+        stack.push(join33(dir, entry.name));
       } else if (entry.isFile() && isPageFile(entry.name)) {
-        out.push(join32(dir, entry.name));
+        out.push(join33(dir, entry.name));
       }
     }
   }
@@ -13694,7 +14086,7 @@ var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
   for (const file2 of files) {
     let source;
     try {
-      source = readFileSync19(file2, "utf-8");
+      source = readFileSync20(file2, "utf-8");
     } catch {
       continue;
     }
@@ -13741,8 +14133,8 @@ var exports_parseAngularConfigImports = {};
 __export(exports_parseAngularConfigImports, {
   parseAngularProvidersImport: () => parseAngularProvidersImport
 });
-import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname17, isAbsolute as isAbsolute3, join as join33 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import { dirname as dirname18, isAbsolute as isAbsolute3, join as join34 } from "path";
 import ts11 from "typescript";
 var findDefineConfigCall = (sf) => {
   let result = null;
@@ -13760,8 +14152,8 @@ var findDefineConfigCall = (sf) => {
   };
   ts11.forEachChild(sf, visit);
   return result;
-}, findPropertyInitializer = (object, name) => {
-  for (const prop of object.properties) {
+}, findPropertyInitializer = (object2, name) => {
+  for (const prop of object2.properties) {
     if (!ts11.isPropertyAssignment(prop))
       continue;
     if (!prop.name)
@@ -13797,15 +14189,15 @@ var findDefineConfigCall = (sf) => {
 }, resolveConfigPath = (projectRoot) => {
   const envOverride = process.env.ABSOLUTE_CONFIG;
   if (envOverride) {
-    const resolved = isAbsolute3(envOverride) ? envOverride : join33(projectRoot, envOverride);
+    const resolved = isAbsolute3(envOverride) ? envOverride : join34(projectRoot, envOverride);
     if (existsSync23(resolved))
       return resolved;
   }
   const candidates = [
-    join33(projectRoot, "absolute.config.ts"),
-    join33(projectRoot, "absolute.config.mts"),
-    join33(projectRoot, "absolute.config.js"),
-    join33(projectRoot, "absolute.config.mjs")
+    join34(projectRoot, "absolute.config.ts"),
+    join34(projectRoot, "absolute.config.mts"),
+    join34(projectRoot, "absolute.config.js"),
+    join34(projectRoot, "absolute.config.mjs")
   ];
   for (const candidate of candidates) {
     if (existsSync23(candidate))
@@ -13816,7 +14208,7 @@ var findDefineConfigCall = (sf) => {
   const configPath2 = resolveConfigPath(projectRoot);
   if (!configPath2)
     return null;
-  const source = readFileSync20(configPath2, "utf-8");
+  const source = readFileSync21(configPath2, "utf-8");
   if (!source.includes("angular"))
     return null;
   if (!source.includes("providers"))
@@ -13837,8 +14229,8 @@ var findDefineConfigCall = (sf) => {
   const importInfo = findImportForBinding(sf, binding);
   if (!importInfo)
     return null;
-  const configDir2 = dirname17(configPath2);
-  const absolutePath = importInfo.source.startsWith(".") ? join33(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
+  const configDir2 = dirname18(configPath2);
+  const absolutePath = importInfo.source.startsWith(".") ? join34(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
   return {
     absolutePath,
     bindingName: binding,
@@ -13853,7 +14245,7 @@ __export(exports_renderToReadableStream, {
   renderToReadableStream: () => renderToReadableStream,
   SVELTE_PAGE_ROOT_ID: () => SVELTE_PAGE_ROOT_ID
 });
-var SVELTE_PAGE_ROOT_ID = "__absolute_svelte_root__", renderToReadableStream = async (component, props, {
+var SVELTE_PAGE_ROOT_ID = "__absolute_svelte_root__", renderToReadableStream = async (component2, props, {
   bootstrapScriptContent,
   bootstrapScripts = [],
   bootstrapModules = [],
@@ -13867,7 +14259,7 @@ var SVELTE_PAGE_ROOT_ID = "__absolute_svelte_root__", renderToReadableStream = a
   try {
     const { render } = await import("svelte/server");
     const renderComponent = render;
-    const rendered = typeof props === "undefined" ? await renderComponent(component) : await renderComponent(component, { props });
+    const rendered = typeof props === "undefined" ? await renderComponent(component2) : await renderComponent(component2, { props });
     const { head, body } = rendered;
     const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
     const scripts = (bootstrapScriptContent ? `<script${nonceAttr}>${escapeScriptContent(bootstrapScriptContent)}</script>` : "") + bootstrapScripts.map((src) => `<script${nonceAttr} src="${src}"></script>`).join("") + bootstrapModules.map((src) => `<script${nonceAttr} type="module" src="${src}"></script>`).join("");
@@ -13912,11 +14304,11 @@ __export(exports_compileSvelte, {
 import { existsSync as existsSync24 } from "fs";
 import { mkdir as mkdir9, stat as stat2 } from "fs/promises";
 import {
-  dirname as dirname18,
-  join as join34,
+  dirname as dirname19,
+  join as join35,
   basename as basename10,
   extname as extname7,
-  resolve as resolve25,
+  resolve as resolve26,
   relative as relative11,
   sep as sep2
 } from "path";
@@ -13924,14 +14316,14 @@ import { env as env2 } from "process";
 var {write: write2, file: file2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve25(import.meta.dir, "../dev/client");
+  const fromSource = resolve26(import.meta.dir, "../dev/client");
   if (existsSync24(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve25(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve26(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync24(fromNodeModules))
     return fromNodeModules;
-  return resolve25(import.meta.dir, "./dev/client");
+  return resolve26(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
@@ -13961,7 +14353,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve25(dirname18(from), spec);
+  const basePath = resolve26(dirname19(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -13972,14 +14364,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join34(basePath, "index.ts"),
-    join34(basePath, "index.js"),
-    join34(basePath, "index.mjs"),
-    join34(basePath, "index.cjs"),
-    join34(basePath, "index.json"),
-    join34(basePath, "index.svelte"),
-    join34(basePath, "index.svelte.ts"),
-    join34(basePath, "index.svelte.js")
+    join35(basePath, "index.ts"),
+    join35(basePath, "index.js"),
+    join35(basePath, "index.mjs"),
+    join35(basePath, "index.cjs"),
+    join35(basePath, "index.json"),
+    join35(basePath, "index.svelte"),
+    join35(basePath, "index.svelte.ts"),
+    join35(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists2));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -13988,7 +14380,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve25(dirname18(from), spec);
+  const basePath = resolve26(dirname19(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -14018,9 +14410,9 @@ var resolveDevClientDir2 = () => {
 }, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev2 = false, stylePreprocessors) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
   const generatedDir = getFrameworkGeneratedDir("svelte");
-  const clientDir = join34(generatedDir, "client");
-  const indexDir = join34(generatedDir, "indexes");
-  const serverDir = join34(generatedDir, "server");
+  const clientDir = join35(generatedDir, "client");
+  const indexDir = join35(generatedDir, "indexes");
+  const serverDir = join35(generatedDir, "server");
   await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir9(dir, { recursive: true })));
   const dev = env2.NODE_ENV !== "production";
   const build2 = async (src) => {
@@ -14048,8 +14440,8 @@ var resolveDevClientDir2 = () => {
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
     const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedServer) : preprocessedServer;
     const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler3.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname18(relative11(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative11(process.cwd(), dirname18(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname19(relative11(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative11(process.cwd(), dirname19(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename10(src).replace(/\.svelte(\.(ts|js))?$/, "");
     const importPaths = Array.from(transpiledServer.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
     const resolvedModuleImports = await Promise.all(importPaths.map((importPath) => resolveRelativeModule2(importPath, src)));
@@ -14058,8 +14450,8 @@ var resolveDevClientDir2 = () => {
     const childBuilt = await Promise.all(childSources.map((child) => build2(child)));
     const hasAwaitSlotFromChildren = childBuilt.some((child) => child.hasAwaitSlot);
     const externalRewrites = new Map;
-    const ssrOutputDir = dirname18(join34(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname18(join34(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname19(join35(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname19(join35(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -14124,11 +14516,11 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return { code, map: compiledJs.map };
     };
-    const ssrPath = join34(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join34(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join35(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join35(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir9(dirname18(ssrPath), { recursive: true }),
-      mkdir9(dirname18(clientPath), { recursive: true })
+      mkdir9(dirname19(ssrPath), { recursive: true }),
+      mkdir9(dirname19(clientPath), { recursive: true })
     ]);
     const inlineMap = (map) => map ? `
 //# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}
@@ -14163,10 +14555,10 @@ var resolveDevClientDir2 = () => {
   const roots = await Promise.all(entryPoints.map(build2));
   const componentRoots = roots.filter((root) => !root.isModule);
   await Promise.all(componentRoots.map(async ({ client: client2, hasAwaitSlot }) => {
-    const relClientDir = dirname18(relative11(clientDir, client2));
+    const relClientDir = dirname19(relative11(clientDir, client2));
     const name = basename10(client2, extname7(client2));
-    const indexPath = join34(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative11(dirname18(indexPath), client2).split(sep2).join("/");
+    const indexPath = join35(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative11(dirname19(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -14255,14 +14647,14 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir9(dirname18(indexPath), { recursive: true });
+    await mkdir9(dirname19(indexPath), { recursive: true });
     return write2(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: componentRoots.map(({ client: client2 }) => {
-      const rel = dirname18(relative11(clientDir, client2));
-      return join34(indexDir, rel, basename10(client2));
+      const rel = dirname19(relative11(clientDir, client2));
+      return join35(indexDir, rel, basename10(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -14277,7 +14669,7 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join34(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join35(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
@@ -14344,7 +14736,7 @@ __export(exports_chainInlineSourcemaps, {
   chainBundleInlineSourcemap: () => chainBundleInlineSourcemap,
   buildLineRemap: () => buildLineRemap
 });
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync8 } from "fs";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync8 } from "fs";
 var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", BASE64_TO_INT, decodeVlq = (str, startPos) => {
   let result = 0;
   let shift = 0;
@@ -14635,7 +15027,7 @@ var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567
     version: 3
   };
 }, chainBundleInlineSourcemap = (bundleFilePath) => {
-  const text = readFileSync21(bundleFilePath, "utf-8");
+  const text = readFileSync22(bundleFilePath, "utf-8");
   const outerMap = extractInlineMap(text);
   if (!outerMap)
     return;
@@ -14655,7 +15047,7 @@ var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567
 }, chainExternalSourcemap = (mapFilePath) => {
   let outerMap;
   try {
-    outerMap = JSON.parse(readFileSync21(mapFilePath, "utf-8"));
+    outerMap = JSON.parse(readFileSync22(mapFilePath, "utf-8"));
   } catch {
     return;
   }
@@ -14754,27 +15146,27 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
-import { existsSync as existsSync25, readFileSync as readFileSync22, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync23, realpathSync as realpathSync2 } from "fs";
 import { mkdir as mkdir10 } from "fs/promises";
 import {
   basename as basename11,
-  dirname as dirname19,
+  dirname as dirname20,
   isAbsolute as isAbsolute4,
-  join as join35,
+  join as join36,
   relative as relative12,
-  resolve as resolve26
+  resolve as resolve27
 } from "path";
 var {file: file3, write: write3, Transpiler: Transpiler3 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve26(import.meta.dir, "../dev/client");
+  const fromSource = resolve27(import.meta.dir, "../dev/client");
   if (existsSync25(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve26(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve27(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync25(fromNodeModules))
     return fromNodeModules;
-  return resolve26(import.meta.dir, "./dev/client");
+  return resolve27(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler4, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -14824,19 +15216,19 @@ var resolveDevClientDir3 = () => {
   visited.add(resolved);
   const importRegex = /@import\s+(?:url\(\s*)?(['"])(\.{1,2}\/[^'"]+)\1\s*\)?\s*;?/g;
   return cssContent.replace(importRegex, (match, _quote, relPath) => {
-    const importedPath = resolve26(dirname19(cssFilePath), relPath);
+    const importedPath = resolve27(dirname20(cssFilePath), relPath);
     if (!existsSync25(importedPath))
       return match;
-    const importedContent = readFileSync22(importedPath, "utf-8");
+    const importedContent = readFileSync23(importedPath, "utf-8");
     return inlineCssImports(importedContent, importedPath, visited);
   });
 }, resolveHelperTsPath = (sourceDir, helper) => {
   if (helper.endsWith(".ts"))
-    return resolve26(sourceDir, helper);
-  const direct = resolve26(sourceDir, `${helper}.ts`);
+    return resolve27(sourceDir, helper);
+  const direct = resolve27(sourceDir, `${helper}.ts`);
   if (existsSync25(direct))
     return direct;
-  const indexed = resolve26(sourceDir, helper, "index.ts");
+  const indexed = resolve27(sourceDir, helper, "index.ts");
   if (existsSync25(indexed))
     return indexed;
   return direct;
@@ -14847,15 +15239,15 @@ var resolveDevClientDir3 = () => {
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve26(sourceDir, filePath);
+      return resolve27(sourceDir, filePath);
     }
     return filePath;
   }
   if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-    const directTs = resolve26(sourceDir, `${filePath}.ts`);
+    const directTs = resolve27(sourceDir, `${filePath}.ts`);
     if (existsSync25(directTs))
       return `${filePath}.js`;
-    const indexedTs = resolve26(sourceDir, filePath, "index.ts");
+    const indexedTs = resolve27(sourceDir, filePath, "index.ts");
     if (existsSync25(indexedTs))
       return `${filePath}/index.js`;
   }
@@ -14946,19 +15338,19 @@ const ${localName} = (source) => ${importedName}(
   const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
   const packageComponentPaths = Array.from(resolvedPackageVueImports.entries());
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue") && !isStylePath(path));
-  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute4(path)) && isStylePath(path)).map((path) => isAbsolute4(path) ? path : resolve26(dirname19(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute4(path)) && isStylePath(path)).map((path) => isAbsolute4(path) ? path : resolve27(dirname20(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve26(dirname19(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve27(dirname20(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
     ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors))
   ]);
   const hasScript = descriptor.script || descriptor.scriptSetup;
   const compiledScript = hasScript ? compiler.compileScript(descriptor, {
     fs: {
       fileExists: existsSync25,
-      readFile: (file4) => existsSync25(file4) ? readFileSync22(file4, "utf-8") : undefined,
+      readFile: (file4) => existsSync25(file4) ? readFileSync23(file4, "utf-8") : undefined,
       realpath: realpathSync2
     },
     id: componentId,
@@ -14966,7 +15358,7 @@ const ${localName} = (source) => ${importedName}(
     sourceMap: true
   }) : { bindings: {}, content: "export default {};", map: undefined };
   const strippedScript = stripExports2(compiledScript.content);
-  const sourceDir = dirname19(sourceFilePath);
+  const sourceDir = dirname20(sourceFilePath);
   const transpiledScript = transpiler4.transformSync(strippedScript).replace(/(['"])(\.{1,2}\/[^'"]+)(['"])/g, (_2, quoteStart, relativeImport, quoteEnd) => `${quoteStart}${toJs(relativeImport, sourceDir)}${quoteEnd}`);
   const packageImportRewrites = new Map;
   for (const [bareImport, absolutePath] of packageComponentPaths) {
@@ -15011,8 +15403,8 @@ const ${localName} = (source) => ${importedName}(
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join35(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir10(dirname19(cssOutputFile), { recursive: true });
+    const cssOutputFile = join36(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    await mkdir10(dirname20(cssOutputFile), { recursive: true });
     await write3(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -15042,21 +15434,21 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const clientCode = assembleModule(generateRenderFunction(false), "render", true) + islandMetadataExports;
   const serverCode = wrapServerAsyncComponentLoader(assembleModule(generateRenderFunction(true), "ssrRender", false)) + islandMetadataExports;
-  const clientOutputPath = join35(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join35(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join36(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join36(outputDirs.server, `${relativeWithoutExtension}.js`);
   const rewritePackageImports = (code, outputPath, mode) => {
     let result2 = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative12(dirname19(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative12(dirname20(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
     }
     return result2;
   };
-  await mkdir10(dirname19(clientOutputPath), { recursive: true });
-  await mkdir10(dirname19(serverOutputPath), { recursive: true });
+  await mkdir10(dirname20(clientOutputPath), { recursive: true });
+  await mkdir10(dirname20(serverOutputPath), { recursive: true });
   const clientFinal = rewritePackageImports(clientCode, clientOutputPath, "client");
   const serverFinal = rewritePackageImports(serverCode, serverOutputPath, "server");
   const inlineSourceMapFor = (finalContent) => {
@@ -15079,7 +15471,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     serverPath: serverOutputPath,
     spaRoutes: spaRoutes.length > 0 ? spaRoutes : undefined,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolveHelperTsPath(dirname19(sourceFilePath), helper)),
+      ...helperModulePaths.map((helper) => resolveHelperTsPath(dirname20(sourceFilePath), helper)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -15089,10 +15481,10 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 }, compileVue = async (entryPoints, vueRootDir, isDev2 = false, stylePreprocessors, ssrOnlyEntries) => {
   const compiler = await loadVueCompiler();
   const generatedDir = getFrameworkGeneratedDir("vue");
-  const clientOutputDir = join35(generatedDir, "client");
-  const indexOutputDir = join35(generatedDir, "indexes");
-  const serverOutputDir = join35(generatedDir, "server");
-  const cssOutputDir = join35(generatedDir, "compiled");
+  const clientOutputDir = join36(generatedDir, "client");
+  const indexOutputDir = join36(generatedDir, "indexes");
+  const serverOutputDir = join36(generatedDir, "server");
+  const cssOutputDir = join36(generatedDir, "compiled");
   await Promise.all([
     mkdir10(clientOutputDir, { recursive: true }),
     mkdir10(indexOutputDir, { recursive: true }),
@@ -15102,7 +15494,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const expandSpaRouteChildren = async (entries) => {
-    const expanded = new Set(entries.map((entry) => resolve26(entry)));
+    const expanded = new Set(entries.map((entry) => resolve27(entry)));
     const queue2 = [...expanded];
     while (queue2.length > 0) {
       const entryPath = queue2.pop();
@@ -15119,7 +15511,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       });
       const routes = parseVueSpaRoutes(descriptor.script?.content ?? "");
       for (const { importPath } of routes) {
-        const childPath = resolve26(dirname19(entryPath), importPath);
+        const childPath = resolve27(dirname20(entryPath), importPath);
         if (expanded.has(childPath) || !existsSync25(childPath)) {
           continue;
         }
@@ -15131,7 +15523,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const expandedEntryPoints = await expandSpaRouteChildren(entryPoints);
   const compiledPages = await Promise.all(expandedEntryPoints.map(async (entryPath) => {
-    const resolvedEntryPath = resolve26(entryPath);
+    const resolvedEntryPath = resolve27(entryPath);
     const result = await compileVueFile(resolvedEntryPath, {
       client: clientOutputDir,
       css: cssOutputDir,
@@ -15149,16 +15541,16 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       };
     }
     const entryBaseName = basename11(entryPath, ".vue");
-    const indexOutputFile = join35(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join35(clientOutputDir, relative12(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir10(dirname19(indexOutputFile), { recursive: true });
+    const indexOutputFile = join36(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join36(clientOutputDir, relative12(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir10(dirname20(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write3(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative12(dirname19(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative12(dirname20(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -15320,7 +15712,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     if (!tsPath)
       continue;
     const sourceCode = await file3(tsPath).text();
-    const helperDir = dirname19(tsPath);
+    const helperDir = dirname20(tsPath);
     for (const dep of extractImports(sourceCode)) {
       if (!dep.startsWith(".") || isStylePath(dep) || dep.endsWith(".vue")) {
         continue;
@@ -15339,10 +15731,10 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     const transpiledCode = transpiler4.transformSync(sourceCode);
     const withMap = transpiledCode + inlineLineMapComment(tsPath, sourceCode, transpiledCode);
     const relativeJsPath = relative12(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join35(clientOutputDir, relativeJsPath);
-    const outServerPath = join35(serverOutputDir, relativeJsPath);
-    await mkdir10(dirname19(outClientPath), { recursive: true });
-    await mkdir10(dirname19(outServerPath), { recursive: true });
+    const outClientPath = join36(clientOutputDir, relativeJsPath);
+    const outServerPath = join36(serverOutputDir, relativeJsPath);
+    await mkdir10(dirname20(outClientPath), { recursive: true });
+    await mkdir10(dirname20(outServerPath), { recursive: true });
     await write3(outClientPath, withMap);
     await write3(outServerPath, withMap);
   }));
@@ -15372,7 +15764,7 @@ var init_compileVue = __esm(() => {
   init_vueAutoRouterTransform();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join35(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join36(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -15853,8 +16245,8 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync26, readFileSync as readFileSync23, promises as fs5 } from "fs";
-import { join as join36, basename as basename12, sep as sep3, dirname as dirname20, resolve as resolve27, relative as relative13 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync24, promises as fs5 } from "fs";
+import { join as join37, basename as basename12, sep as sep3, dirname as dirname21, resolve as resolve28, relative as relative13 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
 import ts13 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata2) => {
@@ -15862,10 +16254,10 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata2) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve27(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve28(process.cwd(), "tsconfig.json");
     const config = ts13.readConfigFile(configPath2, ts13.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve27(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve28(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -15885,7 +16277,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     const wildcardValue = exactMatch ? "" : specifier.slice(prefix.length, specifier.length - suffix.length);
     for (const replacement of alias.replacements) {
       const candidate = replacement.replace("*", wildcardValue);
-      const resolved = resolveSourceFile(resolve27(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve28(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -15897,20 +16289,20 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join36(candidate, "index.ts"),
-    join36(candidate, "index.tsx"),
-    join36(candidate, "index.js"),
-    join36(candidate, "index.jsx")
+    join37(candidate, "index.ts"),
+    join37(candidate, "index.tsx"),
+    join37(candidate, "index.js"),
+    join37(candidate, "index.jsx")
   ];
   return candidates.find((file4) => existsSync26(file4));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve27(rootDir);
+  const baseDir = resolve28(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
   const transpiler5 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve27(fromDir, specifier));
+      return resolveSourceFile(resolve28(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -15919,7 +16311,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve27(resolved);
+      const absolute = resolve28(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -15935,7 +16327,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve27(actualPath);
+    const resolved = resolve28(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -15964,7 +16356,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve27(actualPath);
+    const resolved = resolve28(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -15972,7 +16364,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname20(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname21(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -15982,14 +16374,14 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve27(import.meta.dir, "../dev/client");
+  const fromSource = resolve28(import.meta.dir, "../dev/client");
   if (existsSync26(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve27(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve28(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync26(fromNodeModules))
     return fromNodeModules;
-  return resolve27(import.meta.dir, "./dev/client");
+  return resolve28(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts13.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -16031,12 +16423,12 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname20(importerOutputPath);
-  const fileCandidate = resolve27(importerDir, `${path}.js`);
+  const importerDir = dirname21(importerOutputPath);
+  const fileCandidate = resolve28(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync26(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve27(importerDir, path, "index.js");
+  const indexCandidate = resolve28(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync26(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -16064,18 +16456,18 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve27(dirname20(fromFile), specifier);
+  const basePath = resolve28(dirname21(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join36(basePath, "index.ts"),
-    join36(basePath, "index.tsx"),
-    join36(basePath, "index.mts"),
-    join36(basePath, "index.cts")
+    join37(basePath, "index.ts"),
+    join37(basePath, "index.tsx"),
+    join37(basePath, "index.mts"),
+    join37(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve27(candidate)).find((candidate) => existsSync26(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve28(candidate)).find((candidate) => existsSync26(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile9) => {
   const hostSource = readFile9?.(fileName);
   if (typeof hostSource === "string")
@@ -16099,18 +16491,18 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join36(fileDir, templateUrlMatch[1]));
+    paths.push(join37(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join36(fileDir, styleUrlMatch[1]));
+    paths.push(join37(fileDir, styleUrlMatch[1]));
   const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
   const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
   if (urlMatches) {
     for (const urlMatch of urlMatches) {
-      paths.push(join36(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join37(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve27(path));
+  return paths.map((path) => resolve28(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs5.readFile(cachePath, "utf-8"));
@@ -16122,13 +16514,13 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs5.mkdir(dirname20(cachePath), { recursive: true });
+  await fs5.mkdir(dirname21(cachePath), { recursive: true });
   await fs5.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname20(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname21(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs5.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -16141,7 +16533,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join36(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join37(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile9, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -16152,7 +16544,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve27(filePath);
+    const resolvedPath = resolve28(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -16168,7 +16560,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname20(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname21(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -16187,18 +16579,18 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve27(join36(outDir, relative13(process.cwd(), resolve27(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve28(join37(outDir, relative13(process.cwd(), resolve28(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
-      buildIslandMetadataExports(readFileSync23(inputPath, "utf-8"))
+      buildIslandMetadataExports(readFileSync24(inputPath, "utf-8"))
     ];
   })), { entries: inputPaths.length });
   await traceAngularPhase("aot/preload-compiler", () => import("@angular/compiler"));
   const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
   const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
     const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname20(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve27(tsRootDir, "lib");
+    const tsRootDir = dirname21(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve28(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -16223,30 +16615,30 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   options.incremental = false;
   options.tsBuildInfoFile = undefined;
   options.rootDir = process.cwd();
-  const host = await traceAngularPhase("aot/create-compiler-host", () => ts13.createCompilerHost(options));
-  const originalGetDefaultLibLocation = host.getDefaultLibLocation;
-  host.getDefaultLibLocation = () => tsLibDir || (originalGetDefaultLibLocation ? originalGetDefaultLibLocation() : "");
-  const originalGetDefaultLibFileName = host.getDefaultLibFileName;
-  host.getDefaultLibFileName = (opts) => {
+  const host2 = await traceAngularPhase("aot/create-compiler-host", () => ts13.createCompilerHost(options));
+  const originalGetDefaultLibLocation = host2.getDefaultLibLocation;
+  host2.getDefaultLibLocation = () => tsLibDir || (originalGetDefaultLibLocation ? originalGetDefaultLibLocation() : "");
+  const originalGetDefaultLibFileName = host2.getDefaultLibFileName;
+  host2.getDefaultLibFileName = (opts) => {
     const fileName = originalGetDefaultLibFileName ? originalGetDefaultLibFileName(opts) : "lib.d.ts";
     return basename12(fileName);
   };
-  const originalGetSourceFile = host.getSourceFile;
-  host.getSourceFile = (fileName, languageVersion, onError) => {
+  const originalGetSourceFile = host2.getSourceFile;
+  host2.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join36(tsLibDir, fileName);
-      return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
+      const resolvedPath = join37(tsLibDir, fileName);
+      return originalGetSourceFile?.call(host2, resolvedPath, languageVersion, onError);
     }
-    return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
+    return originalGetSourceFile?.call(host2, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve27(outDir);
-  host.writeFile = (fileName, text) => {
+  const resolvedOutDir = resolve28(outDir);
+  host2.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
   };
-  const originalReadFile = host.readFile;
-  const { stats: aotResourceTransformStats, transformedSources } = await traceAngularPhase("aot/precompute-resources", () => precomputeAotResourceTransforms(inputPaths, originalReadFile?.bind(host), stylePreprocessors), { entries: inputPaths.length });
+  const originalReadFile = host2.readFile;
+  const { stats: aotResourceTransformStats, transformedSources } = await traceAngularPhase("aot/precompute-resources", () => precomputeAotResourceTransforms(inputPaths, originalReadFile?.bind(host2), stylePreprocessors), { entries: inputPaths.length });
   await traceAngularPhase("aot/resource-cache-summary", () => {
     return;
   }, {
@@ -16255,43 +16647,43 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
     filesVisited: aotResourceTransformStats.filesVisited,
     transformedFiles: aotResourceTransformStats.transformedFiles
   });
-  host.readFile = (fileName) => {
-    const source = originalReadFile ? originalReadFile.call(host, fileName) : undefined;
+  host2.readFile = (fileName) => {
+    const source = originalReadFile ? originalReadFile.call(host2, fileName) : undefined;
     if (typeof source !== "string")
       return source;
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve27(fileName);
+    const resolvedPath = resolve28(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
-  const originalGetSourceFileForCompile = host.getSourceFile;
-  host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve27(fileName));
+  const originalGetSourceFileForCompile = host2.getSourceFile;
+  host2.getSourceFile = (fileName, languageVersion, onError) => {
+    const source = transformedSources.get(resolve28(fileName));
     if (source) {
       return ts13.createSourceFile(fileName, source, languageVersion, true);
     }
-    return originalGetSourceFileForCompile?.call(host, fileName, languageVersion, onError);
+    return originalGetSourceFileForCompile?.call(host2, fileName, languageVersion, onError);
   };
   let diagnostics;
   try {
     ({ diagnostics } = await traceAngularPhase("aot/perform-compilation", () => performCompilation({
       emitFlags: EmitFlags.Default,
-      host,
+      host: host2,
       options,
       rootNames: inputPaths
     }), { entries: inputPaths.length }));
   } finally {
-    host.readFile = originalReadFile;
-    host.getSourceFile = originalGetSourceFileForCompile;
+    host2.readFile = originalReadFile;
+    host2.getSourceFile = originalGetSourceFileForCompile;
   }
   await traceAngularPhase("aot/check-diagnostics", () => throwOnCompilationErrors(diagnostics));
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join36(outDir, fileName)
+      target: join37(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve27(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve28(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -16306,17 +16698,17 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
         return cleaned ? `import { ${cleaned}, InternalInjectFlags } from '@angular/core'` : `import { InternalInjectFlags } from '@angular/core'`;
       });
       processedContent = processedContent.replace(/\b(?<!Internal)InjectFlags\b/g, "InternalInjectFlags");
-      processedContent += islandMetadataByOutputPath.get(resolve27(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve28(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs5.mkdir(dirname20(target), { recursive: true });
+    await fs5.mkdir(dirname21(target), { recursive: true });
     await fs5.writeFile(target, content, "utf-8");
   })), { outputs: entries.length });
   return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
 }, compileAngularFile = async (inputPath, outDir, stylePreprocessors) => compileAngularFiles([inputPath], outDir, stylePreprocessors), jitContentCache, invalidateAngularJitCache = (filePath) => {
-  jitContentCache.delete(resolve27(filePath));
+  jitContentCache.delete(resolve28(filePath));
 }, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), findUncommentedMatch = (source, pattern) => {
   const re2 = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
   let match;
@@ -16329,7 +16721,7 @@ var traceAngularPhase = async (name, fn2, metadata2) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve27(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve28(import.meta.dir, "../angular/components/index.ts");
   if (existsSync26(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -16466,7 +16858,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join36(fileDir, templateUrlMatch[1]);
+    const templatePath = join37(fileDir, templateUrlMatch[1]);
     if (!existsSync26(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -16497,11 +16889,11 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join36(fileDir, templateUrlMatch[1]);
+    const templatePath = join37(fileDir, templateUrlMatch[1]);
     if (!existsSync26(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw2 = readFileSync23(templatePath, "utf-8");
+    const templateRaw2 = readFileSync24(templatePath, "utf-8");
     const lowered2 = lowerAngularDeferSyntax(templateRaw2);
     const escaped2 = escapeTemplateContent(lowered2.template);
     const replacedSource2 = source.slice(0, templateUrlMatch.index) + `template: \`${escaped2}\`` + source.slice(templateUrlMatch.index + templateUrlMatch[0].length);
@@ -16534,7 +16926,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join36(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join37(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -16545,7 +16937,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join36(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join37(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -16619,10 +17011,10 @@ ${fields}
     return "";
   }
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve27(inputPath);
+  const entryPath = resolve28(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve27(rootDir ?? process.cwd());
+  const baseDir = resolve28(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -16641,16 +17033,16 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join36(candidate, "index.ts"),
-      join36(candidate, "index.tsx"),
-      join36(candidate, "index.js"),
-      join36(candidate, "index.jsx")
+      join37(candidate, "index.ts"),
+      join37(candidate, "index.tsx"),
+      join37(candidate, "index.js"),
+      join37(candidate, "index.jsx")
     ];
     return candidates.find((file4) => existsSync26(file4));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve27(fromDir, specifier));
+      return resolveSourceFile2(resolve28(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -16659,7 +17051,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve27(resolved);
+      const absolute = resolve28(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -16668,13 +17060,13 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname20(sourcePath);
+    const inputDir = dirname21(sourcePath);
     const fileBase = basename12(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep3}`)) {
-      return join36(inputDir, fileBase);
+      return join37(inputDir, fileBase);
     }
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    return join36(outDir, relativeDir, fileBase);
+    return join37(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -16711,21 +17103,21 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve27(actualPath) === entryPath) {
+    if (resolve28(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve27(filePath);
+    const resolved = resolve28(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
     if (resolved.endsWith(".json") && existsSync26(resolved)) {
-      const inputDir2 = dirname20(resolved);
+      const inputDir2 = dirname21(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join36(outDir, relativeDir2);
-      const targetPath2 = join36(targetDir2, basename12(resolved));
+      const targetDir2 = join37(outDir, relativeDir2);
+      const targetPath2 = join37(targetDir2, basename12(resolved));
       await fs5.mkdir(targetDir2, { recursive: true });
       await fs5.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -16737,12 +17129,12 @@ ${fields}
     if (!existsSync26(actualPath))
       return;
     let sourceCode = await fs5.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname20(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname20(actualPath)).source;
-    const inputDir = dirname20(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname21(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname21(actualPath)).source;
+    const inputDir = dirname21(actualPath);
     const fileBase = basename12(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
     const targetPath = toOutputPath(actualPath);
-    const targetDir = dirname20(targetPath);
+    const targetDir = dirname21(targetPath);
     const relativeDir = relative13(outDir, targetDir).replace(/\\/g, "/");
     const localImports = [];
     const importRewrites = new Map;
@@ -16769,7 +17161,7 @@ ${fields}
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve27(actualPath) === resolve27(entryPath);
+    const isEntry = resolve28(actualPath) === resolve28(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync26(targetPath);
@@ -16804,13 +17196,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join36(compiledParent, "indexes");
+  const indexesDir = join37(compiledParent, "indexes");
   await traceAngularPhase("setup/create-indexes-dir", () => fs5.mkdir(indexesDir, { recursive: true }));
-  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve27(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve28(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
-      const angularSrcDir = resolve27(outRoot);
+      const angularSrcDir = resolve28(outRoot);
       if (!existsSync26(angularSrcDir))
         return;
       const jsonGlob = new Glob6("**/*.json");
@@ -16818,17 +17210,17 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join36(angularSrcDir, rel);
+        const sourcePath = join37(angularSrcDir, rel);
         const cwdRel = relative13(cwd, sourcePath);
-        const targetPath = join36(compiledRoot, cwdRel);
-        await fs5.mkdir(dirname20(targetPath), { recursive: true });
+        const targetPath = join37(compiledRoot, cwdRel);
+        await fs5.mkdir(dirname21(targetPath), { recursive: true });
         await fs5.copyFile(sourcePath, targetPath);
       }
     });
   }
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve27(entry);
+    const resolvedEntry = resolve28(entry);
     const relativeEntry = relative13(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
@@ -16837,13 +17229,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename12(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join36(compiledRoot, relativeEntry),
-      join36(compiledRoot, "pages", jsName),
-      join36(compiledRoot, jsName)
-    ].map((file4) => resolve27(file4));
+      join37(compiledRoot, relativeEntry),
+      join37(compiledRoot, "pages", jsName),
+      join37(compiledRoot, jsName)
+    ].map((file4) => resolve28(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file4) => resolve27(file4)),
+        ...candidatePaths.map((file4) => resolve28(file4)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file4) => existsSync26(file4) && file4.endsWith(`${sep3}${relativeEntry}`));
@@ -16890,7 +17282,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       let providersSourceContent = "";
       if (providersInjection.appProvidersSource) {
         try {
-          providersSourceContent = readFileSync23(providersInjection.appProvidersSource, "utf-8");
+          providersSourceContent = readFileSync24(providersInjection.appProvidersSource, "utf-8");
         } catch {}
       }
       return JSON.stringify({
@@ -16901,7 +17293,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     })() : "no-providers";
     const serverContentHash = `${Bun.hash(original).toString(BASE_36_RADIX)}.${Bun.hash(providersHashInput).toString(BASE_36_RADIX)}`;
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join36(indexesDir, jsName);
+    const clientFile = join37(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync26(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -16933,13 +17325,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       const fragments = [];
       if (providersInjection.appProvidersSource) {
         const compiledAppProvidersPath = (() => {
-          const angularDirAbs = resolve27(outRoot);
-          const appSourceAbs = resolve27(providersInjection.appProvidersSource);
+          const angularDirAbs = resolve28(outRoot);
+          const appSourceAbs = resolve28(providersInjection.appProvidersSource);
           const rel = relative13(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
-          return join36(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
+          return join37(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
         })();
         const appProvidersSpec = (() => {
-          const rel = relative13(dirname20(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
+          const rel = relative13(dirname21(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
           return rel.startsWith(".") ? rel : `./${rel}`;
         })();
         importLines.push(`import { appProviders as __abs_globalProviders } from "${appProvidersSpec}";`);
@@ -17191,7 +17583,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join36(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join37(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
   PROVIDERS_INJECTION_BLOCK_RE = /\n\/\* __ABS_PROVIDERS_INJECTION_START \*\/[\s\S]*?\/\* __ABS_PROVIDERS_INJECTION_END \*\/\n?/;
@@ -17915,8 +18307,8 @@ __export(exports_fastHmrCompiler, {
   primeComponentFingerprint: () => primeComponentFingerprint,
   invalidateFingerprintCache: () => invalidateFingerprintCache
 });
-import { existsSync as existsSync27, readFileSync as readFileSync24, statSync as statSync2 } from "fs";
-import { dirname as dirname21, extname as extname8, relative as relative14, resolve as resolve28 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync25, statSync as statSync2 } from "fs";
+import { dirname as dirname22, extname as extname8, relative as relative14, resolve as resolve29 } from "path";
 import ts17 from "typescript";
 var fail = (reason, detail, location) => ({
   detail,
@@ -18046,7 +18438,7 @@ var fail = (reason, detail, location) => ({
         continue;
       const decoratorMeta = readDecoratorMeta(args);
       const { inputs, outputs } = extractInputsAndOutputs(stmt, null);
-      const componentDir = dirname21(componentFilePath);
+      const componentDir = dirname22(componentFilePath);
       const fingerprint = extractFingerprint(stmt, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
       fingerprintCache.set(id, fingerprint);
     } else {
@@ -18231,7 +18623,7 @@ var fail = (reason, detail, location) => ({
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return true;
     }
-    const base = resolve28(componentDir, spec);
+    const base = resolve29(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -18243,7 +18635,7 @@ var fail = (reason, detail, location) => ({
         continue;
       let content;
       try {
-        content = readFileSync24(candidate, "utf-8");
+        content = readFileSync25(candidate, "utf-8");
       } catch {
         continue;
       }
@@ -18529,7 +18921,7 @@ var fail = (reason, detail, location) => ({
   listeners: {},
   properties: {},
   specialAttributes: {}
-}), parseHostObjectInto = (host, args, hostExprNode, compiler) => {
+}), parseHostObjectInto = (host2, args, hostExprNode, compiler) => {
   const hostNode = getProperty(args, "host");
   if (!hostNode || !ts17.isObjectLiteralExpression(hostNode)) {
     if (!hostExprNode)
@@ -18553,14 +18945,14 @@ var fail = (reason, detail, location) => ({
     const propMatch = ATTR_BINDING_RE.exec(key);
     const evtMatch = EVENT_BINDING_RE.exec(key);
     if (propMatch) {
-      host.properties[propMatch[1] ?? ""] = prop.initializer.getText().replace(/^['"]|['"]$/g, "");
+      host2.properties[propMatch[1] ?? ""] = prop.initializer.getText().replace(/^['"]|['"]$/g, "");
     } else if (evtMatch) {
-      host.listeners[evtMatch[1] ?? ""] = prop.initializer.getText().replace(/^['"]|['"]$/g, "");
+      host2.listeners[evtMatch[1] ?? ""] = prop.initializer.getText().replace(/^['"]|['"]$/g, "");
     } else {
-      host.attributes[key] = new compiler.WrappedNodeExpr(prop.initializer);
+      host2.attributes[key] = new compiler.WrappedNodeExpr(prop.initializer);
     }
   }
-}, mergeMemberHostDecorators = (host, cls) => {
+}, mergeMemberHostDecorators = (host2, cls) => {
   for (const member of cls.members) {
     if (!ts17.canHaveDecorators(member))
       continue;
@@ -18580,7 +18972,7 @@ var fail = (reason, detail, location) => ({
         const propertyName2 = member.name.text;
         const [target] = expr.arguments;
         const key = target && ts17.isStringLiteral(target) ? target.text : propertyName2;
-        host.properties[key] = propertyName2;
+        host2.properties[key] = propertyName2;
       } else if (functionNode.text === "HostListener") {
         if (!ts17.isMethodDeclaration(member))
           continue;
@@ -18598,7 +18990,7 @@ var fail = (reason, detail, location) => ({
               argsList.push(element.text);
           }
         }
-        host.listeners[event] = `${methodName}(${argsList.join(", ")})`;
+        host2.listeners[event] = `${methodName}(${argsList.join(", ")})`;
       }
     }
   }
@@ -18789,9 +19181,9 @@ var fail = (reason, detail, location) => ({
   }
   return out.length > 0 ? out : null;
 }, extractAdvancedMetadata = (cls, decoratorArgs, compiler) => {
-  const host = emptyHost();
-  parseHostObjectInto(host, decoratorArgs, null, compiler);
-  mergeMemberHostDecorators(host, cls);
+  const host2 = emptyHost();
+  parseHostObjectInto(host2, decoratorArgs, null, compiler);
+  mergeMemberHostDecorators(host2, cls);
   const decoratorQueries = extractDecoratorQueries(cls, compiler);
   const signalQueries = extractSignalQueries(cls, compiler);
   const contentQueries = [
@@ -18812,7 +19204,7 @@ var fail = (reason, detail, location) => ({
     animations,
     contentQueries,
     exportAs: extractExportAs(decoratorArgs),
-    host,
+    host: host2,
     hostDirectives: extractHostDirectives(decoratorArgs, compiler),
     providers,
     viewProviders,
@@ -18831,7 +19223,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let source;
   try {
-    source = readFileSync24(filePath, "utf-8");
+    source = readFileSync25(filePath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -18885,7 +19277,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let content;
   try {
-    content = readFileSync24(dtsPath, "utf-8");
+    content = readFileSync25(dtsPath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -19008,7 +19400,7 @@ var fail = (reason, detail, location) => ({
     return null;
   let content;
   try {
-    content = readFileSync24(startDtsPath, "utf-8");
+    content = readFileSync25(startDtsPath, "utf-8");
   } catch {
     return null;
   }
@@ -19027,7 +19419,7 @@ var fail = (reason, detail, location) => ({
     });
     if (!names.includes(className))
       continue;
-    const nextDts = resolveDtsFromSpec(fromPath, dirname21(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname22(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -19037,7 +19429,7 @@ var fail = (reason, detail, location) => ({
   const starReExportRe = /export\s*\*\s*from\s*["']([^"']+)["']/g;
   while ((item = starReExportRe.exec(content)) !== null) {
     const fromPath = item[1] || "";
-    const nextDts = resolveDtsFromSpec(fromPath, dirname21(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname22(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -19047,7 +19439,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveDtsFromSpec = (spec, fromDir) => {
   const stripped = spec.replace(/\.[mc]?js$/, "");
-  const base = resolve28(fromDir, stripped);
+  const base = resolve29(fromDir, stripped);
   const candidates = [
     `${base}.d.ts`,
     `${base}.d.mts`,
@@ -19071,7 +19463,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveChildComponentInfo = (className, spec, componentDir, projectRoot) => {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const base = resolve28(componentDir, spec);
+    const base = resolve29(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -19226,7 +19618,7 @@ var fail = (reason, detail, location) => ({
     return cached.hasProviders;
   let source;
   try {
-    source = readFileSync24(filePath, "utf8");
+    source = readFileSync25(filePath, "utf8");
   } catch {
     return true;
   }
@@ -19290,13 +19682,13 @@ var fail = (reason, detail, location) => ({
     }
     if (!matches)
       continue;
-    const resolved = resolve28(componentDir, spec);
+    const resolved = resolve29(componentDir, spec);
     for (const ext of TS_EXTENSIONS) {
       const candidate = resolved + ext;
       if (existsSync27(candidate))
         return candidate;
     }
-    const indexCandidate = resolve28(resolved, "index.ts");
+    const indexCandidate = resolve29(resolved, "index.ts");
     if (existsSync27(indexCandidate))
       return indexCandidate;
   }
@@ -19534,12 +19926,12 @@ ${transpiled}
     }
 }${staticPatch}`;
 }, STYLE_PREPROCESSED_EXT, resolveAndReadStyleResource = (componentDir, url) => {
-  const abs = resolve28(componentDir, url);
+  const abs = resolve29(componentDir, url);
   if (!existsSync27(abs))
     return null;
   const ext = extname8(abs).toLowerCase();
   if (!STYLE_PREPROCESSED_EXT.has(ext) || ext === ".css") {
-    return readFileSync24(abs, "utf8");
+    return readFileSync25(abs, "utf8");
   }
   try {
     return compileStyleFileIfNeededSync(abs);
@@ -19573,11 +19965,11 @@ ${block}
   const cached = projectOptionsCache.get(projectRoot);
   if (cached !== undefined)
     return cached;
-  const tsconfigPath = resolve28(projectRoot, "tsconfig.json");
+  const tsconfigPath = resolve29(projectRoot, "tsconfig.json");
   const opts = {};
   if (existsSync27(tsconfigPath)) {
     try {
-      const text = readFileSync24(tsconfigPath, "utf8");
+      const text = readFileSync25(tsconfigPath, "utf8");
       const parsed = ts17.parseConfigFileTextToJson(tsconfigPath, text);
       if (!parsed.error && parsed.config) {
         const cfg = parsed.config;
@@ -19611,7 +20003,7 @@ ${block}
   } catch (err) {
     return fail("unexpected-error", `import @angular/compiler: ${err}`);
   }
-  const tsSource = readFileSync24(componentFilePath, "utf8");
+  const tsSource = readFileSync25(componentFilePath, "utf8");
   const sourceFile = ts17.createSourceFile(componentFilePath, tsSource, ts17.ScriptTarget.ES2022, true, ts17.ScriptKind.TS);
   const classNode = findClassDeclaration(sourceFile, className);
   if (!classNode) {
@@ -19638,7 +20030,7 @@ ${block}
       rebootstrapRequired: false
     };
   }
-  if (inheritsDecoratedClass(classNode, sourceFile, dirname21(componentFilePath), projectRoot)) {
+  if (inheritsDecoratedClass(classNode, sourceFile, dirname22(componentFilePath), projectRoot)) {
     return fail("inherits-decorated-class");
   }
   const decorator = findComponentDecorator(classNode);
@@ -19650,18 +20042,18 @@ ${block}
   const projectDefaults = readProjectAngularCompilerOptions(projectRoot);
   const decoratorMeta = readDecoratorMeta(decoratorArgs, projectDefaults);
   const advancedMetadata = extractAdvancedMetadata(classNode, decoratorArgs, compiler);
-  const componentDir = dirname21(componentFilePath);
+  const componentDir = dirname22(componentFilePath);
   let templateText;
   let templatePath;
   if (decoratorMeta.template !== null) {
     templateText = decoratorMeta.template;
     templatePath = componentFilePath;
   } else if (decoratorMeta.templateUrl) {
-    const tplAbs = resolve28(componentDir, decoratorMeta.templateUrl);
+    const tplAbs = resolve29(componentDir, decoratorMeta.templateUrl);
     if (!existsSync27(tplAbs)) {
       return fail("template-resource-not-found", `Template file not found: ${tplAbs}`, { file: componentFilePath });
     }
-    templateText = readFileSync24(tplAbs, "utf8");
+    templateText = readFileSync25(tplAbs, "utf8");
     templatePath = tplAbs;
   } else {
     return fail("unsupported-decorator-args", "missing template/templateUrl");
@@ -20420,7 +20812,7 @@ __export(exports_compileEmber, {
   getEmberServerCompiledDir: () => getEmberServerCompiledDir,
   getEmberCompiledRoot: () => getEmberCompiledRoot,
   getEmberClientCompiledDir: () => getEmberClientCompiledDir,
-  dirname: () => dirname22,
+  dirname: () => dirname23,
   compileEmberFileSource: () => compileEmberFileSource,
   compileEmberFile: () => compileEmberFile,
   compileEmber: () => compileEmber,
@@ -20429,7 +20821,7 @@ __export(exports_compileEmber, {
 });
 import { existsSync as existsSync28 } from "fs";
 import { mkdir as mkdir11, rm as rm8 } from "fs/promises";
-import { basename as basename13, dirname as dirname22, extname as extname9, join as join37, resolve as resolve29 } from "path";
+import { basename as basename13, dirname as dirname23, extname as extname9, join as join38, resolve as resolve30 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler4, write: write4, file: file4 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -20525,7 +20917,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve29(dirname22(originalImporter), args.path);
+        const candidateBase = resolve30(dirname23(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -20548,7 +20940,7 @@ export const importSync = (specifier) => {
     build2.onResolve({ filter: /^@(?:ember|glimmer|simple-dom)\// }, (args) => {
       if (standalonePackages.has(args.path))
         return;
-      const internal = join37(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join38(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync28(internal))
         return { path: internal };
       return;
@@ -20584,7 +20976,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve29(entry);
+  const resolvedEntry = resolve30(entry);
   const source = await file4(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -20596,16 +20988,16 @@ export default PageComponent;
   }
   const transpiled = transpiler5.transformSync(preprocessed);
   const baseName = basename13(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
-  const tmpDir = join37(compiledRoot, "_tmp");
-  const serverDir = join37(compiledRoot, "server");
-  const clientDir = join37(compiledRoot, "client");
+  const tmpDir = join38(compiledRoot, "_tmp");
+  const serverDir = join38(compiledRoot, "server");
+  const clientDir = join38(compiledRoot, "client");
   await Promise.all([
     mkdir11(tmpDir, { recursive: true }),
     mkdir11(serverDir, { recursive: true }),
     mkdir11(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve29(join37(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve29(join37(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve30(join38(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve30(join38(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write4(tmpPagePath, transpiled),
     write4(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -20613,7 +21005,7 @@ export default PageComponent;
   const stagedSourceMap = new Map([
     [tmpPagePath, resolvedEntry]
   ]);
-  const serverPath = join37(serverDir, `${baseName}.js`);
+  const serverPath = join38(serverDir, `${baseName}.js`);
   const buildResult = await bunBuild2({
     entrypoints: [tmpHarnessPath],
     format: "esm",
@@ -20630,7 +21022,7 @@ export default PageComponent;
     console.warn(`\u26A0\uFE0F Ember server build for ${baseName} had errors:`, buildResult.logs);
   }
   await rm8(tmpDir, { force: true, recursive: true });
-  const clientPath = join37(clientDir, `${baseName}.js`);
+  const clientPath = join38(clientDir, `${baseName}.js`);
   await write4(clientPath, transpiled);
   return { clientPath, serverPath };
 }, compileEmber = async (entries, emberDir, cwd = process.cwd(), _hmr = false) => {
@@ -20647,7 +21039,7 @@ export default PageComponent;
     serverPaths: outputs.map((o3) => o3.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve29(entry);
+  const resolvedEntry = resolve30(entry);
   const source = await file4(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -20658,7 +21050,7 @@ export default PageComponent;
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
   return transpiler5.transformSync(preprocessed);
-}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join37(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join37(getEmberCompiledRoot(emberDir), "client");
+}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join38(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join38(getEmberCompiledRoot(emberDir), "client");
 var init_compileEmber = __esm(() => {
   init_generatedDir();
   transpiler5 = new Transpiler4({
@@ -20680,24 +21072,24 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync29, mkdirSync as mkdirSync8 } from "fs";
-import { join as join38, resolve as resolve30 } from "path";
+import { join as join39, resolve as resolve31 } from "path";
 import { rm as rm9 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve30(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve30(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve30(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve30(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve30(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve30(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve31(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve31(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve31(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve31(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve31(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve31(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync29(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve30(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve31(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, jsxRuntimeCompatPath, reactSpecifiers, toSafeFileName = (specifier) => specifier.replace(/\//g, "_"), computeVendorPaths = () => {
   const paths = {};
   for (const specifier of reactSpecifiers) {
@@ -20730,14 +21122,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join38(buildDir, "react", "vendor");
+  const vendorDir = join39(buildDir, "react", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join38(buildDir, "_vendor_tmp");
+  const tmpDir = join39(buildDir, "_vendor_tmp");
   mkdirSync8(tmpDir, { recursive: true });
   const specifiers = reactSpecifiers;
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName(specifier);
-    const entryPath = join38(tmpDir, `${safeName}.ts`);
+    const entryPath = join39(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -20805,7 +21197,7 @@ __export(exports_buildAngularVendor, {
   buildAngularServerVendor: () => buildAngularServerVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 import { rm as rm10 } from "fs/promises";
 var {build: bunBuild4, Glob: Glob7 } = globalThis.Bun;
 var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => jitMode ? [...REQUIRED_ANGULAR_SPECIFIERS_BASE, "@angular/compiler"] : REQUIRED_ANGULAR_SPECIFIERS_BASE, SERVER_ONLY_ANGULAR_SPECIFIERS, BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES, isBuildOnlyAngularSpecifier = (spec) => BUILD_ONLY_ANGULAR_SPECIFIER_PREFIXES.some((prefix) => spec === prefix || spec.startsWith(`${prefix}/`)), SCAN_SKIP_DIRS, isResolvable = (specifier) => {
@@ -20842,7 +21234,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   }
   return { angular, transitiveRoots };
 }, PARTIAL_DECL_MARKERS, containsPartialDeclarations = (source) => PARTIAL_DECL_MARKERS.some((marker) => source.includes(marker)), collectTransitiveAngularSpecs = async (roots, angularFound) => {
-  const { readFileSync: readFileSync25 } = await import("fs");
+  const { readFileSync: readFileSync26 } = await import("fs");
   const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
@@ -20863,7 +21255,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let content;
       try {
-        content = readFileSync25(resolved, "utf-8");
+        content = readFileSync26(resolved, "utf-8");
       } catch {
         continue;
       }
@@ -20902,14 +21294,14 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   await collectTransitiveAngularSpecs([...angular, ...transitiveRoots], angular);
   return Array.from(angular).filter(isResolvable);
 }, buildAngularVendor = async (buildDir, directories = [], linkerJitMode = false, depVendorSpecifiers = []) => {
-  const vendorDir = join39(buildDir, "angular", "vendor");
+  const vendorDir = join40(buildDir, "angular", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join39(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join40(buildDir, "_angular_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join39(tmpDir, `${safeName}.ts`);
+    const entryPath = join40(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -20940,9 +21332,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = await resolveAngularSpecifiers(directories, linkerJitMode);
   return computeAngularVendorPaths(specifiers);
 }, buildAngularServerVendor = async (buildDir, directories = [], linkerJitMode = false) => {
-  const vendorDir = join39(buildDir, "angular", "vendor", "server");
+  const vendorDir = join40(buildDir, "angular", "vendor", "server");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join39(buildDir, "_angular_server_vendor_tmp");
+  const tmpDir = join40(buildDir, "_angular_server_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
@@ -20953,7 +21345,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   const specifiers = Array.from(allSpecs);
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName2(specifier);
-    const entryPath = join39(tmpDir, `${safeName}.ts`);
+    const entryPath = join40(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -20975,9 +21367,9 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join39(buildDir, "angular", "vendor", "server");
+  const vendorDir = join40(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join39(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join40(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -21033,17 +21425,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import { rm as rm11 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join40(buildDir, "vue", "vendor");
+  const vendorDir = join41(buildDir, "vue", "vendor");
   mkdirSync10(vendorDir, { recursive: true });
-  const tmpDir = join40(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join41(buildDir, "_vue_vendor_tmp");
   mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join40(tmpDir, `${safeName}.ts`);
+    const entryPath = join41(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -21068,11 +21460,11 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync25, writeFileSync: writeFileSync9, readdirSync: readdirSync5 } = await import("fs");
+  const { readFileSync: readFileSync26, writeFileSync: writeFileSync9, readdirSync: readdirSync5 } = await import("fs");
   const files = readdirSync5(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file5 of files) {
-    const filePath = join40(vendorDir, file5);
-    const content = readFileSync25(filePath, "utf-8");
+    const filePath = join41(vendorDir, file5);
+    const content = readFileSync26(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
     const patched = content.replace(/getGlobalThis\(\)\.__VUE_HMR_RUNTIME__\s*=\s*\{/, "getGlobalThis().__VUE_HMR_RUNTIME__ = getGlobalThis().__VUE_HMR_RUNTIME__ || {");
@@ -21098,7 +21490,7 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 import { rm as rm12 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable2 = (specifier) => {
@@ -21112,13 +21504,13 @@ var svelteSpecifiers, isResolvable2 = (specifier) => {
   const specifiers = resolveVendorSpecifiers();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join41(buildDir, "svelte", "vendor");
+  const vendorDir = join42(buildDir, "svelte", "vendor");
   mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join41(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join42(buildDir, "_svelte_vendor_tmp");
   mkdirSync11(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join41(tmpDir, `${safeName}.ts`);
+    const entryPath = join42(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -21163,13 +21555,13 @@ import {
   existsSync as existsSync30,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync25,
+  readFileSync as readFileSync26,
   renameSync,
   rmSync as rmSync2,
   statSync as statSync3,
   writeFileSync as writeFileSync9
 } from "fs";
-import { basename as basename14, dirname as dirname23, extname as extname10, join as join42, relative as relative15, resolve as resolve31 } from "path";
+import { basename as basename14, dirname as dirname24, extname as extname10, join as join43, relative as relative15, resolve as resolve32 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild7, Glob: Glob8 } = globalThis.Bun;
 var isBuildTraceEnabled = () => {
@@ -21252,7 +21644,7 @@ var isBuildTraceEnabled = () => {
 }, REACT_VENDOR_SPECIFIERS, findBareReactImports = (path, importRegex) => {
   let content;
   try {
-    content = readFileSync25(path, "utf-8");
+    content = readFileSync26(path, "utf-8");
   } catch {
     return [];
   }
@@ -21303,8 +21695,8 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   mkdirSync12(htmxDestDir, { recursive: true });
   const glob = new Glob8("htmx*.min.js");
   for (const relPath of glob.scanSync({ cwd: htmxDir })) {
-    const src = join42(htmxDir, relPath);
-    const dest = join42(htmxDestDir, "htmx.min.js");
+    const src = join43(htmxDir, relPath);
+    const dest = join43(htmxDestDir, "htmx.min.js");
     copyFileSync2(src, dest);
     return;
   }
@@ -21316,8 +21708,8 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve31(import.meta.dir, "..", "..", "package.json"),
-    resolve31(import.meta.dir, "..", "package.json")
+    resolve32(import.meta.dir, "..", "..", "package.json"),
+    resolve32(import.meta.dir, "..", "package.json")
   ];
   const resolveCandidate = async (remaining) => {
     const [candidate, ...rest] = remaining;
@@ -21333,7 +21725,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS5, addWorkerPathIfExists = (file5, relPath, workerPaths) => {
-  const absPath = resolve31(file5, "..", relPath);
+  const absPath = resolve32(file5, "..", relPath);
   try {
     statSync3(absPath);
     workerPaths.add(absPath);
@@ -21348,7 +21740,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
     addWorkerPathIfExists(file5, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file5, patterns, workerPaths) => {
-  const content = readFileSync25(file5, "utf-8");
+  const content = readFileSync26(file5, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file5, workerPaths);
   }
@@ -21381,7 +21773,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join42(buildPath, "_src_indexes");
+  const devIndexDir = join43(buildPath, "_src_indexes");
   mkdirSync12(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -21397,37 +21789,37 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file5) => file5.endsWith(".tsx"));
-  const pagesRel = relative15(process.cwd(), resolve31(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative15(process.cwd(), resolve32(reactPagesPath)).replace(/\\/g, "/");
   for (const file5 of indexFiles) {
-    let content = readFileSync25(join42(reactIndexesPath, file5), "utf-8");
+    let content = readFileSync26(join43(reactIndexesPath, file5), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync9(join42(devIndexDir, file5), content);
+    writeFileSync9(join43(devIndexDir, file5), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join42(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file5) => resolve31(file5).startsWith(resolve31(sveltePagesPath)));
+  const svelteIndexDir = join43(getFrameworkGeneratedDir("svelte"), "indexes");
+  const sveltePageEntries = svelteEntries.filter((file5) => resolve32(file5).startsWith(resolve32(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename14(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join42(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join43(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync30(indexFile))
       continue;
-    let content = readFileSync25(indexFile, "utf-8");
-    const srcRel = relative15(process.cwd(), resolve31(entry)).replace(/\\/g, "/");
+    let content = readFileSync26(indexFile, "utf-8");
+    const srcRel = relative15(process.cwd(), resolve32(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync9(join42(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync9(join43(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join42(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file5) => resolve31(file5).startsWith(resolve31(vuePagesPath)));
+  const vueIndexDir = join43(getFrameworkGeneratedDir("vue"), "indexes");
+  const vuePageEntries = vueEntries.filter((file5) => resolve32(file5).startsWith(resolve32(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename14(entry, ".vue");
-    const indexFile = join42(vueIndexDir, `${name}.js`);
+    const indexFile = join43(vueIndexDir, `${name}.js`);
     if (!existsSync30(indexFile))
       continue;
-    let content = readFileSync25(indexFile, "utf-8");
-    const srcRel = relative15(process.cwd(), resolve31(entry)).replace(/\\/g, "/");
+    let content = readFileSync26(indexFile, "utf-8");
+    const srcRel = relative15(process.cwd(), resolve32(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp(?:\s*,\s*\*\s+as\s+\w+)?\s+from\s+['"]([^'"]+)['"]/, (match) => match.replace(/from\s+['"][^'"]+['"]/, `from "/@src/${srcRel}"`));
-    writeFileSync9(join42(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync9(join43(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -21438,7 +21830,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve31(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve32(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -21475,7 +21867,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync25(outputPath, "utf-8");
+  let content = readFileSync26(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -21525,7 +21917,7 @@ ${content.slice(firstUseIdx)}`;
 }, rewriteUrlReferences = (outputPaths, urlFileMap) => {
   const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
   for (const outputPath of outputPaths) {
-    let content = readFileSync25(outputPath, "utf-8");
+    let content = readFileSync26(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename14(relPath);
@@ -21665,10 +22057,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join42(buildPath2, ".absolute-trace");
+    const traceDir = join43(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     mkdirSync12(traceDir, { recursive: true });
-    writeFileSync9(join42(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    writeFileSync9(join43(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -21699,16 +22091,16 @@ ${content.slice(firstUseIdx)}`;
   const stylesPath = typeof stylesConfig === "string" ? stylesConfig : stylesConfig?.path;
   const stylesIgnore = typeof stylesConfig === "object" ? stylesConfig.ignore : undefined;
   const stylesDir = stylesPath && validateSafePath(stylesPath, projectRoot);
-  const reactIndexesPath = reactDir && join42(getFrameworkGeneratedDir("react"), "indexes");
-  const reactPagesPath = reactDir && join42(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join42(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join42(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join42(svelteDir, "pages");
-  const vuePagesPath = vueDir && join42(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join42(htmxDir, "pages");
-  const htmxScriptsPath = htmxDir && join42(htmxDir, "scripts");
-  const angularPagesPath = angularDir && join42(angularDir, "pages");
-  const emberPagesPath = emberDir && join42(emberDir, "pages");
+  const reactIndexesPath = reactDir && join43(getFrameworkGeneratedDir("react"), "indexes");
+  const reactPagesPath = reactDir && join43(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join43(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join43(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join43(svelteDir, "pages");
+  const vuePagesPath = vueDir && join43(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join43(htmxDir, "pages");
+  const htmxScriptsPath = htmxDir && join43(htmxDir, "scripts");
+  const angularPagesPath = angularDir && join43(angularDir, "pages");
+  const emberPagesPath = emberDir && join43(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -21741,7 +22133,7 @@ ${content.slice(firstUseIdx)}`;
   const sourceClientRoots = [
     htmlDir,
     htmxDir,
-    islandBootstrapPath && dirname23(islandBootstrapPath)
+    islandBootstrapPath && dirname24(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const usesGenerated = Boolean(reactDir) || Boolean(svelteDir) || Boolean(vueDir) || Boolean(angularDir);
   if (usesGenerated)
@@ -21769,8 +22161,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join42(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join42(buildPath, basename14(firstEntry.dir));
+    serverRoot = join43(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join43(buildPath, basename14(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -21783,18 +22175,19 @@ ${content.slice(firstUseIdx)}`;
     buildPath,
     config: pwa,
     generatedRoot,
+    projectRoot,
     write: !isIncremental
   })) : undefined;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve31(f2)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve32(f2)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve31(sourceFile)))
+      if (!normalizedIncremental.has(resolve32(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -21804,7 +22197,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("react/index-generation", () => generateReactIndexFiles(reactPagesPath, reactIndexesPath, hmr));
   }
   if (assetsPath && (!isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/assets/")))) {
-    await tracePhase("assets/copy", () => cpSync(assetsPath, join42(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join43(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -21918,11 +22311,11 @@ ${content.slice(firstUseIdx)}`;
     }
   }
   if (htmlDefaults.error || htmlDefaults.notFound || htmlDefaults.loading || Object.keys(htmlPages).length > 0) {
-    const htmlConventionsOutDir = join42(buildPath, "conventions", "html");
+    const htmlConventionsOutDir = join43(buildPath, "conventions", "html");
     mkdirSync12(htmlConventionsOutDir, { recursive: true });
     const htmlPathRemap = new Map;
     for (const sourcePath of htmlConventionSources) {
-      const dest = join42(htmlConventionsOutDir, basename14(sourcePath));
+      const dest = join43(htmlConventionsOutDir, basename14(sourcePath));
       cpSync(sourcePath, dest, { force: true });
       htmlPathRemap.set(sourcePath, dest);
     }
@@ -21963,9 +22356,9 @@ ${content.slice(firstUseIdx)}`;
   }
   const shouldIncludeHtmlAssets = !isIncremental || normalizedIncrementalFiles?.some((f2) => f2.includes("/html/") && (f2.endsWith(".html") || isStylePath(f2)));
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
-    if (entry.startsWith(resolve31(reactIndexesPath))) {
+    if (entry.startsWith(resolve32(reactIndexesPath))) {
       const pageName = basename14(entry, ".tsx");
-      return join42(reactPagesPath, `${pageName}.tsx`);
+      return join43(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -21997,7 +22390,7 @@ ${content.slice(firstUseIdx)}`;
     for (const entry of vueEntries) {
       const name = basename14(entry, ".vue");
       if (ssrOnlyPageNames.has(name)) {
-        resolved.add(resolve31(entry));
+        resolved.add(resolve32(entry));
       }
     }
     return resolved;
@@ -22134,7 +22527,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve31(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve32(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -22142,7 +22535,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve31(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve32(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -22150,7 +22543,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve31(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve32(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -22161,7 +22554,7 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join42(buildPath, "conventions", "react");
+      const destDir = join43(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync12(destDir, { recursive: true });
       const destPaths = await Promise.all(reactConventionSources.map(async (source, idx) => {
@@ -22176,7 +22569,7 @@ ${content.slice(firstUseIdx)}`;
             stylePreprocessorPlugin2,
             createBunStringRawUnicodePlugin()
           ],
-          root: dirname23(source),
+          root: dirname24(source),
           target: "bun",
           throw: false,
           tsconfig: "./tsconfig.json"
@@ -22204,7 +22597,7 @@ ${content.slice(firstUseIdx)}`;
       angularConventionSources.length > 0 && angularDir ? tracePhase("compile/convention-angular", () => Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularConventionSources, angularDir, hmr, styleTransformConfig))) : { serverPaths: emptyStringArray }
     ]);
     const bundleConventionFiles = async (framework, compiledPaths) => {
-      const destDir = join42(buildPath, "conventions", framework);
+      const destDir = join43(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync12(destDir, { recursive: true });
       const destPaths = await Promise.all(compiledPaths.map(async (compiledPath, idx) => {
@@ -22265,7 +22658,7 @@ ${content.slice(firstUseIdx)}`;
     ...islandBootstrapPath ? [islandBootstrapPath] : []
   ];
   const [onlyWorkerClientEntry] = urlReferencedFiles;
-  const workerClientRoot = urlReferencedFiles.length === 1 && onlyWorkerClientEntry ? dirname23(onlyWorkerClientEntry) : commonAncestor(urlReferencedFiles.map((file5) => dirname23(file5)), projectRoot);
+  const workerClientRoot = urlReferencedFiles.length === 1 && onlyWorkerClientEntry ? dirname24(onlyWorkerClientEntry) : commonAncestor(urlReferencedFiles.map((file5) => dirname24(file5)), projectRoot);
   const islandEntryResult = islandBuildInfo ? await tracePhase("islands/client-entry-generation", () => generateIslandEntryPoints({
     buildInfo: islandBuildInfo,
     buildPath,
@@ -22276,7 +22669,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join42(buildPath, "_island_entries")
+    generatedRoot: join43(buildPath, "_island_entries")
   };
   const islandClientEntryPoints = islandEntryResult.entries.map((entry) => entry.entryPath);
   if (serverEntryPoints.length === 0 && reactClientEntryPoints.length === 0 && nonReactClientEntryPoints.length === 0 && urlReferencedFiles.length === 0 && islandClientEntryPoints.length === 0 && htmxDir === undefined && htmlDir === undefined) {
@@ -22312,7 +22705,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join42(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join43(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -22423,19 +22816,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join42(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join43(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join42(buildPath, "angular", "indexes"), {
+    rmSync2(join43(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join42(buildPath, "islands"), {
+    rmSync2(join43(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -22549,7 +22942,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join42(buildPath, basename14(stylesDir)) : buildPath,
+      outdir: stylesDir ? join43(buildPath, basename14(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -22558,7 +22951,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join42(buildPath, assetsPath ? basename14(assetsPath) : "assets", "css"),
+      outdir: join43(buildPath, assetsPath ? basename14(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -22582,18 +22975,18 @@ ${content.slice(firstUseIdx)}`;
   }
   if (!isDev2 && resolveClientSourcemap(sourcemaps, isDev2) === "external") {
     const { chainExternalSourcemap: chainExternalSourcemap2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
-    const sourcemapDir = join42(projectRoot, "sourcemaps");
+    const sourcemapDir = join43(projectRoot, "sourcemaps");
     mkdirSync12(sourcemapDir, { recursive: true });
     const mapFiles = readdirSync5(buildPath, {
       encoding: "utf8",
       recursive: true
-    }).filter((entry) => entry.endsWith(".js.map") && !entry.includes("node_modules")).map((entry) => join42(buildPath, entry));
+    }).filter((entry) => entry.endsWith(".js.map") && !entry.includes("node_modules")).map((entry) => join43(buildPath, entry));
     for (const mapPath of mapFiles) {
       chainExternalSourcemap2(mapPath);
-      renameSync(mapPath, join42(sourcemapDir, basename14(mapPath)));
+      renameSync(mapPath, join43(sourcemapDir, basename14(mapPath)));
       const jsPath = mapPath.slice(0, -4);
       try {
-        const javascript = readFileSync25(jsPath, "utf-8").replace(/\n?\/\/# sourceMappingURL=[^\n]*\s*$/, `
+        const javascript = readFileSync26(jsPath, "utf-8").replace(/\n?\/\/# sourceMappingURL=[^\n]*\s*$/, `
 `);
         writeFileSync9(jsPath, javascript);
       } catch {}
@@ -22664,7 +23057,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("postprocess/island-vendor-imports", () => rewriteBuildOutputs2(islandClientOutputs, allIslandVendorPaths));
   }
   if (!hmr) {
-    const reactVendorDir = join42(buildPath, "react", "vendor");
+    const reactVendorDir = join43(buildPath, "react", "vendor");
     const vendorChunkPaths = existsSync30(reactVendorDir) ? [
       ...new Glob8("**/*.js").scanSync({
         absolute: true,
@@ -22681,7 +23074,7 @@ ${content.slice(firstUseIdx)}`;
   if (serverOutputs.length > 0 && angularServerVendorPaths2 && Object.keys(angularServerVendorPaths2).length > 0) {
     const { rewriteBuildOutputsWith: rewriteBuildOutputsWith2 } = await Promise.resolve().then(() => (init_rewriteImportsPlugin(), exports_rewriteImportsPlugin));
     await tracePhase("postprocess/server-angular-vendor-imports", () => rewriteBuildOutputsWith2(serverOutputs, (artifact) => {
-      const fileDir = dirname23(artifact.path);
+      const fileDir = dirname24(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
         const rel = relative15(fileDir, absolute);
@@ -22809,7 +23202,7 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync25(filePath, "utf-8");
+    let html = readFileSync26(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
@@ -22820,7 +23213,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join42(buildPath, "pages") : join42(buildPath, basename14(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join43(buildPath, "pages") : join43(buildPath, basename14(htmlDir), "pages");
     mkdirSync12(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -22836,7 +23229,7 @@ ${content.slice(firstUseIdx)}`;
       if (hmr)
         injectHMRIntoHTMLFile(htmlFile, "html");
       if (pwaArtifacts) {
-        const source = readFileSync25(htmlFile, "utf8");
+        const source = readFileSync26(htmlFile, "utf8");
         writeFileSync9(htmlFile, injectPwaBootstrapHtml(source));
       }
       const fileName = basename14(htmlFile, ".html");
@@ -22849,14 +23242,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join42(buildPath, "pages") : join42(buildPath, basename14(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join43(buildPath, "pages") : join43(buildPath, basename14(htmxDir), "pages");
     mkdirSync12(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join42(buildPath, basename14(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join43(buildPath, basename14(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -22869,7 +23262,7 @@ ${content.slice(firstUseIdx)}`;
       if (hmr)
         injectHMRIntoHTMLFile(htmxFile, "htmx");
       if (pwaArtifacts) {
-        const source = readFileSync25(htmxFile, "utf8");
+        const source = readFileSync26(htmxFile, "utf8");
         writeFileSync9(htmxFile, injectPwaBootstrapHtml(source));
       }
       const fileName = basename14(htmxFile, ".html");
@@ -22932,22 +23325,22 @@ ${content.slice(firstUseIdx)}`;
     angularDir ? Promise.resolve().then(() => (init_staticAnalyzeSpaRoutes(), exports_staticAnalyzeSpaRoutes)).then((module) => module.analyzeAngularSpaRoutes(angularDir)) : []
   ]);
   const spaRouteHosts = [
-    ...reactSpaHosts.map((host) => ({
-      ...host,
+    ...reactSpaHosts.map((host2) => ({
+      ...host2,
       framework: "react"
     })),
-    ...svelteSpaHosts.map((host) => ({
-      ...host,
+    ...svelteSpaHosts.map((host2) => ({
+      ...host2,
       framework: "svelte"
     })),
-    ...vueSpaHosts.map((host) => ({ ...host, framework: "vue" })),
-    ...angularSpaHosts.map((host) => ({
-      ...host,
+    ...vueSpaHosts.map((host2) => ({ ...host2, framework: "vue" })),
+    ...angularSpaHosts.map((host2) => ({
+      ...host2,
       framework: "angular"
     }))
   ];
   setSpaRouteManifest(spaRouteHosts);
-  writeFileSync9(join42(buildPath, "spa-routes.json"), JSON.stringify(spaRouteHosts, null, "\t"));
+  writeFileSync9(join43(buildPath, "spa-routes.json"), JSON.stringify(spaRouteHosts, null, "\t"));
   if (isIncremental) {
     writeBuildTrace(buildPath);
     return {
@@ -22956,9 +23349,9 @@ ${content.slice(firstUseIdx)}`;
       manifest
     };
   }
-  writeFileSync9(join42(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync9(join43(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync9(join42(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync9(join43(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (mode === "production") {
@@ -23092,7 +23485,7 @@ var init_build = __esm(() => {
 
 // src/build/buildEmberVendor.ts
 import { mkdirSync as mkdirSync13, existsSync as existsSync31 } from "fs";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 import { rm as rm13 } from "fs/promises";
 var {build: bunBuild8 } = globalThis.Bun;
 var toSafeFileName5 = (specifier) => specifier.replace(/^@/, "").replace(/\//g, "_"), generateMacrosShim = () => `// Generated shim for @embroider/macros \u2014 provides minimal runtime
@@ -23144,7 +23537,7 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join43(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  const emberInternalPath = join44(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
   if (!existsSync31(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
@@ -23176,7 +23569,7 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join43(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join44(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync31(internal)) {
         return { path: internal };
       }
@@ -23184,16 +23577,16 @@ export const importSync = (specifier) => {
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join43(buildDir, "ember", "vendor");
+  const vendorDir = join44(buildDir, "ember", "vendor");
   mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join43(buildDir, "_ember_vendor_tmp");
+  const tmpDir = join44(buildDir, "_ember_vendor_tmp");
   mkdirSync13(tmpDir, { recursive: true });
-  const macrosShimPath = join43(tmpDir, "embroider_macros_shim.js");
+  const macrosShimPath = join44(tmpDir, "embroider_macros_shim.js");
   await Bun.write(macrosShimPath, generateMacrosShim());
   const resolutions = REQUIRED_EMBER_SPECIFIERS.map((specifier) => resolveEmberSpecifier(specifier, cwd2));
   const entrypoints = await Promise.all(resolutions.map(async (resolution) => {
     const safeName = toSafeFileName5(resolution.specifier);
-    const entryPath = join43(tmpDir, `${safeName}.js`);
+    const entryPath = join44(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -23349,9 +23742,9 @@ __export(exports_dependencyGraph, {
   buildInitialDependencyGraph: () => buildInitialDependencyGraph,
   addFileToGraph: () => addFileToGraph
 });
-import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync27 } from "fs";
 var {Glob: Glob9 } = globalThis.Bun;
-import { resolve as resolve32 } from "path";
+import { resolve as resolve33 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -23365,8 +23758,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve32(fromFile, "..");
-  const normalized = resolve32(fromDir, importPath);
+  const fromDir = resolve33(fromFile, "..");
+  const normalized = resolve33(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -23396,7 +23789,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve32(filePath);
+  const normalizedPath = resolve33(filePath);
   if (!existsSync32(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
@@ -23423,10 +23816,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob9("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve32(dir)).filter((dir) => existsSync32(dir));
+  const resolvedDirs = directories.map((dir) => resolve33(dir)).filter((dir) => existsSync32(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file5 of allFiles) {
-    const fullPath = resolve32(file5);
+    const fullPath = resolve33(file5);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -23520,15 +23913,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync26(filePath, "utf-8");
+    const content = readFileSync27(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync26(filePath, "utf-8");
+    const content = readFileSync27(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync26(filePath, "utf-8");
+    const content = readFileSync27(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -23539,7 +23932,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve32(changedFile);
+  const normalizedPath = resolve33(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -23570,7 +23963,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, removeDependentsForFile = (graph, normalizedPath) => {
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve32(filePath);
+  const normalizedPath = resolve33(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -23613,12 +24006,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve33 } from "path";
+import { resolve as resolve34 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve33(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve33(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve34(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve34(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -23676,8 +24069,8 @@ var init_clientManager = __esm(() => {
 });
 
 // src/dev/pathUtils.ts
-import { existsSync as existsSync33, readdirSync as readdirSync6, readFileSync as readFileSync27 } from "fs";
-import { dirname as dirname24, resolve as resolve34 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync6, readFileSync as readFileSync28 } from "fs";
+import { dirname as dirname25, resolve as resolve35 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -23753,7 +24146,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   return "unknown";
 }, collectAngularResourceDirs = (angularDir) => {
   const out = new Set;
-  const angularRoot = resolve34(angularDir);
+  const angularRoot = resolve35(angularDir);
   const angularRootNormalized = normalizePath2(angularRoot);
   const walk = (dir) => {
     let entries;
@@ -23766,7 +24159,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = resolve34(dir, entry.name);
+      const full = resolve35(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -23776,7 +24169,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       }
       let source;
       try {
-        source = readFileSync27(full, "utf8");
+        source = readFileSync28(full, "utf8");
       } catch {
         continue;
       }
@@ -23805,10 +24198,10 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
             refs.push(strMatch[1]);
         }
       }
-      const componentDir = dirname24(full);
+      const componentDir = dirname25(full);
       for (const ref of refs) {
-        const refAbs = normalizePath2(resolve34(componentDir, ref));
-        const refDir = normalizePath2(dirname24(refAbs));
+        const refAbs = normalizePath2(resolve35(componentDir, ref));
+        const refDir = normalizePath2(dirname25(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(`${angularRootNormalized}/`)) {
           continue;
         }
@@ -23824,7 +24217,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath2(resolve34(cwd2, path));
+    const abs = normalizePath2(resolve35(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -23849,7 +24242,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.assetsDir);
   push(cfg.stylesDir);
   for (const candidate of ["src", "db", "assets", "styles"]) {
-    const abs = normalizePath2(resolve34(cwd2, candidate));
+    const abs = normalizePath2(resolve35(cwd2, candidate));
     if (existsSync33(abs) && !roots.includes(abs))
       roots.push(abs);
   }
@@ -23860,7 +24253,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
         continue;
       if (entry.name.startsWith("."))
         continue;
-      const abs = normalizePath2(resolve34(cwd2, entry.name));
+      const abs = normalizePath2(resolve35(cwd2, entry.name));
       if (roots.includes(abs))
         continue;
       if (shouldIgnorePath(abs, resolved))
@@ -23944,7 +24337,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync34, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
-import { dirname as dirname25, join as join44, resolve as resolve35 } from "path";
+import { dirname as dirname26, join as join45, resolve as resolve36 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -23976,7 +24369,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     for (const name of entries) {
       if (shouldSkipFilename(name, isStylesDir))
         continue;
-      const child = join44(eventDir, name).replace(/\\/g, "/");
+      const child = join45(eventDir, name).replace(/\\/g, "/");
       let st2;
       try {
         st2 = statSync4(child);
@@ -23997,7 +24390,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       return;
     if (shouldSkipFilename(filename, isStylesDir)) {
       if (event === "rename") {
-        const eventDir = dirname25(join44(absolutePath, filename)).replace(/\\/g, "/");
+        const eventDir = dirname26(join45(absolutePath, filename)).replace(/\\/g, "/");
         atomicRecoveryScan(eventDir);
         for (const delay of [25, 100]) {
           const timer = setTimeout(() => atomicRecoveryScan(eventDir), delay);
@@ -24006,7 +24399,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       }
       return;
     }
-    const fullPath = join44(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join45(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
@@ -24024,7 +24417,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve35(path).replace(/\\/g, "/");
+    const absolutePath = resolve36(path).replace(/\\/g, "/");
     if (!existsSync34(absolutePath)) {
       return;
     }
@@ -24035,7 +24428,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve35(path).replace(/\\/g, "/");
+    const absolutePath = resolve36(path).replace(/\\/g, "/");
     if (!existsSync34(absolutePath)) {
       return;
     }
@@ -24054,13 +24447,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve36 } from "path";
+import { resolve as resolve37 } from "path";
 import { readdir as readdir5, unlink } from "fs/promises";
 var mimeTypes, getMimeType = (filePath) => {
   const ext = filePath.slice(filePath.lastIndexOf("."));
   return mimeTypes[ext] ?? "application/octet-stream";
 }, HASHED_FILE_RE, stripHash = (webPath) => webPath.replace(/\.[a-z0-9]{8}(\.(js|css|mjs))$/, "$1"), processWalkEntry = (entry, dir, liveByIdentity, walkAndClean) => {
-  const fullPath = resolve36(dir, entry.name);
+  const fullPath = resolve37(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -24076,10 +24469,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve36(buildDir, webPath.slice(1));
+    const diskPath = resolve37(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve36(buildDir);
+  const absBuildDir = resolve37(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -24097,7 +24490,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve36(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve37(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -24106,7 +24499,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve36(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve37(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -24128,7 +24521,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve36(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve37(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -24173,10 +24566,10 @@ var init_assetStore = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync28 } from "fs";
+import { readFileSync as readFileSync29 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync28(filePath);
+    const fileContent = readFileSync29(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -24212,9 +24605,9 @@ var cache, importers, getTransformed = (filePath) => cache.get(filePath)?.conten
     set.add(filePath);
   }
 }, invalidationVersions, isComponentFile = (filePath) => filePath.endsWith(".tsx") || filePath.endsWith(".jsx"), processParents = (parents, queue) => {
-  const component = [...parents].find(isComponentFile);
-  if (component !== undefined)
-    return component;
+  const component2 = [...parents].find(isComponentFile);
+  if (component2 !== undefined)
+    return component2;
   for (const parent of parents)
     queue.push(parent);
   return;
@@ -24269,9 +24662,9 @@ var init_transformCache = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve37(filePath);
+  const normalizedPath = resolve38(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -24283,7 +24676,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename15, resolve as resolve38 } from "path";
+import { basename as basename15, resolve as resolve39 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -24293,7 +24686,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve38(sourceFile);
+  const normalizedFile = resolve39(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -24329,7 +24722,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve38(sourceFile);
+  const normalizedFile = resolve39(sourceFile);
   const fileName = basename15(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -24385,7 +24778,7 @@ var init_moduleMapper = __esm(() => {
 
 // src/utils/spaRouteCss.ts
 import { readFile as readFile9 } from "fs/promises";
-import { dirname as dirname26, isAbsolute as isAbsolute5, resolve as resolve39 } from "path";
+import { dirname as dirname27, isAbsolute as isAbsolute5, resolve as resolve40 } from "path";
 var sideManifestCache, readSideManifest = async (sideManifestPath) => {
   const cached = sideManifestCache.get(sideManifestPath);
   if (cached !== undefined)
@@ -24423,7 +24816,7 @@ var sideManifestCache, readSideManifest = async (sideManifestPath) => {
 }, readChildCss = async (cssPath, sideManifestPath) => {
   if (!cssPath)
     return "";
-  const resolvedCssPath = isAbsolute5(cssPath) ? cssPath : resolve39(dirname26(sideManifestPath), cssPath);
+  const resolvedCssPath = isAbsolute5(cssPath) ? cssPath : resolve40(dirname27(sideManifestPath), cssPath);
   const cached = childCssCache.get(resolvedCssPath);
   if (cached !== undefined)
     return cached;
@@ -24506,8 +24899,8 @@ __export(exports_resolveOwningComponents, {
   resolveDescendantsOfParent: () => resolveDescendantsOfParent,
   invalidateResourceIndex: () => invalidateResourceIndex
 });
-import { readdirSync as readdirSync8, readFileSync as readFileSync29, statSync as statSync5 } from "fs";
-import { dirname as dirname27, extname as extname11, join as join45, resolve as resolve40 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync30, statSync as statSync5 } from "fs";
+import { dirname as dirname28, extname as extname11, join as join46, resolve as resolve41 } from "path";
 import ts18 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") || file5.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -24522,7 +24915,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = join45(dir, entry.name);
+      const full = join46(dir, entry.name);
       if (entry.isDirectory()) {
         visit(full);
       } else if (entry.isFile() && isAngularSourceFile(entry.name)) {
@@ -24566,7 +24959,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
 }, parseDecoratedClasses = (filePath) => {
   let source;
   try {
-    source = readFileSync29(filePath, "utf8");
+    source = readFileSync30(filePath, "utf8");
   } catch {
     return [];
   }
@@ -24620,7 +25013,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
   };
   visit(sourceFile);
   return out;
-}, safeNormalize = (path) => resolve40(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+}, safeNormalize = (path) => resolve41(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
   const { changedFilePath, userAngularRoot } = params;
   const changedAbs = safeNormalize(changedFilePath);
   const out = [];
@@ -24656,12 +25049,12 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
 }, indexByRoot, resolveParentClassFile = (parentName, childFilePath, angularRoot) => {
   let source;
   try {
-    source = readFileSync29(childFilePath, "utf8");
+    source = readFileSync30(childFilePath, "utf8");
   } catch {
     return null;
   }
   const sourceFile = ts18.createSourceFile(childFilePath, source, ts18.ScriptTarget.ES2022, true, ts18.ScriptKind.TS);
-  const childDir = dirname27(childFilePath);
+  const childDir = dirname28(childFilePath);
   for (const stmt of sourceFile.statements) {
     if (!ts18.isImportDeclaration(stmt))
       continue;
@@ -24689,7 +25082,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return null;
     }
-    const base = resolve40(childDir, spec);
+    const base = resolve41(childDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -24718,7 +25111,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
   const parentFile = new Map;
   for (const tsPath of walkAngularSourceFiles(userAngularRoot)) {
     const classes = parseDecoratedClasses(tsPath);
-    const componentDir = dirname27(tsPath);
+    const componentDir = dirname28(tsPath);
     for (const cls of classes) {
       const entity = {
         className: cls.className,
@@ -24727,7 +25120,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file5) => file5.endsWith(".ts") ||
       };
       if (cls.kind === "component") {
         for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-          const abs = safeNormalize(resolve40(componentDir, url));
+          const abs = safeNormalize(resolve41(componentDir, url));
           const existing = resource.get(abs);
           if (existing)
             existing.push(entity);
@@ -24969,8 +25362,8 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync35, readFileSync as readFileSync30, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
-import { basename as basename16, dirname as dirname28, extname as extname12, join as join46, resolve as resolve41, relative as relative16 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync31, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
+import { basename as basename16, dirname as dirname29, extname as extname12, join as join47, resolve as resolve42, relative as relative16 } from "path";
 var SRC_PREFIX = "/@src/", BROWSER_DEFINE, jsTranspiler2, legacyDecoratorTsconfig, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -24990,10 +25383,10 @@ var SRC_PREFIX = "/@src/", BROWSER_DEFINE, jsTranspiler2, legacyDecoratorTsconfi
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const directHit = extensions.find((ext) => existsSync35(resolve41(projectRoot, srcPath + ext)));
+  const directHit = extensions.find((ext) => existsSync35(resolve42(projectRoot, srcPath + ext)));
   if (directHit)
     return srcPath + directHit;
-  const indexHit = extensions.find((ext) => existsSync35(resolve41(projectRoot, srcPath, `index${ext}`)));
+  const indexHit = extensions.find((ext) => existsSync35(resolve42(projectRoot, srcPath, `index${ext}`)));
   if (indexHit)
     return `${srcPath}/index${indexHit}`;
   return srcPath;
@@ -25016,7 +25409,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve41(projectRoot, relPath);
+  const absPath = resolve42(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -25028,12 +25421,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve41(fileDir, relPath);
+  const absPath = resolve42(fileDir, relPath);
   const rel = relative16(projectRoot, absPath);
   const extension = extname12(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname12(srcPath) === ".svelte") {
-    srcPath = relative16(projectRoot, resolveSvelteModulePath(resolve41(projectRoot, srcPath)));
+    srcPath = relative16(projectRoot, resolveSvelteModulePath(resolve42(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -25052,13 +25445,13 @@ ${stubs}
       const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
-        const pkgDir = resolve41(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join46(pkgDir, "package.json");
+        const pkgDir = resolve42(projectRoot, "node_modules", packageName ?? "");
+        const pkgJsonPath = join47(pkgDir, "package.json");
         if (existsSync35(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync30(pkgJsonPath, "utf-8"));
+          const pkg = JSON.parse(readFileSync31(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve41(pkgDir, esmEntry);
+            const resolved = resolve42(pkgDir, esmEntry);
             if (existsSync35(resolved))
               return relative16(projectRoot, resolved);
           }
@@ -25096,7 +25489,7 @@ ${stubs}
   };
   result = result.replace(/^((?:import\s+[^"'`;]+?\s+from|export\s+[^"'`;]+?\s+from|import)\s*["'])([^"'./][^"']*)(["'])/gm, stubReplace);
   result = result.replace(/(import\s*\(\s*["'])([^"'./][^"']*)(["']\s*\))/g, stubReplace);
-  const fileDir = dirname28(filePath);
+  const fileDir = dirname29(filePath);
   result = result.replace(/(from\s*["'])(\.\.?\/[^"']+)(["'])/g, (_match, prefix, relPath, suffix) => isRealImport(relPath) ? `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}` : _match);
   result = result.replace(/(import\s*\(\s*["'])(\.\.?\/[^"']+)(["']\s*\))/g, (_match, prefix, relPath, suffix) => isRealImport(relPath) ? `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, IMPORT_EXTENSIONS)}${suffix}` : _match);
   result = result.replace(/(import\s*["'])(\.\.?\/[^"']+)(["']\s*;?)/g, (_match, prefix, relPath, suffix) => isRealImport(relPath) ? `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, SIDE_EFFECT_EXTENSIONS)}${suffix}` : _match);
@@ -25111,12 +25504,12 @@ ${stubs}
   result = result.replace(/((?:from|import)\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["'])/g, rewriteAbsoluteToSrc);
   result = result.replace(/(import\s*\(\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["']\s*\))/g, rewriteAbsoluteToSrc);
   result = result.replace(/new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g, (_match, relPath) => {
-    const absPath = resolve41(fileDir, relPath);
+    const absPath = resolve42(fileDir, relPath);
     const rel = relative16(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve41(fileDir, relPath);
+    const absPath = resolve42(fileDir, relPath);
     const rel = relative16(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
@@ -25162,7 +25555,7 @@ ${code}`;
   reactFastRefreshWarningEmitted = true;
   logWarn("React HMR is blocked: this Bun build ignores " + "`reactFastRefresh` on Bun.Transpiler, so component state " + "cannot be preserved across edits. Tracking " + "https://github.com/oven-sh/bun/pull/28312 \u2014 if it still has " + "not merged, leave a \uD83D\uDC4D on the PR so the Bun team knows it " + "is blocking you. Until then, React edits trigger a targeted " + "page remount instead of a state-preserving fast refresh.");
 }, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync30(filePath, "utf-8");
+  const raw = readFileSync31(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -25178,7 +25571,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync30(filePath, "utf-8");
+  const raw = readFileSync31(filePath, "utf-8");
   const ext = extname12(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -25344,7 +25737,7 @@ ${code}`;
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
   return code.replace(/import\.meta\.hot\.accept\(/g, "__hmr_accept(");
 }, transformSvelteFile = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const raw = readFileSync30(filePath, "utf-8");
+  const raw = readFileSync31(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -25410,7 +25803,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync30(filePath, "utf-8");
+  const rawSource = readFileSync31(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await loadVueCompiler();
@@ -25423,7 +25816,7 @@ ${code}`;
     fs: {
       fileExists: existsSync35,
       realpath: realpathSync3,
-      readFile: (file5) => existsSync35(file5) ? readFileSync30(file5, "utf-8") : undefined
+      readFile: (file5) => existsSync35(file5) ? readFileSync31(file5, "utf-8") : undefined
     },
     id: componentId,
     inlineTemplate: false
@@ -25438,7 +25831,7 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve41(vueDir) : projectRoot;
+  const hmrBase = vueDir ? resolve42(vueDir) : projectRoot;
   const hmrId = relative16(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
@@ -25470,7 +25863,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync30(filePath, "utf-8");
+  const raw = readFileSync31(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -25602,7 +25995,7 @@ export default {};
   const escaped = virtualCss.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return jsResponse(`var s=document.createElement('style');s.textContent=\`${escaped}\`;s.dataset.svelteHmr=${JSON.stringify(cssCheckPath)};var p=document.querySelector('style[data-svelte-hmr="${cssCheckPath}"]');if(p)p.remove();document.head.appendChild(s);`);
 }, resolveSourcePath = (relPath, projectRoot) => {
-  const filePath = resolve41(projectRoot, relPath);
+  const filePath = resolve42(projectRoot, relPath);
   const ext = extname12(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -25639,14 +26032,14 @@ export default {};
           const absoluteCandidate = `/${tail.replace(/^\/+/, "")}`;
           const candidates = [
             absoluteCandidate,
-            resolve41(projectRoot, tail)
+            resolve42(projectRoot, tail)
           ];
           try {
             const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_loadConfig(), exports_loadConfig));
             const cfg = await loadConfig2();
-            const angularDir = cfg.angularDirectory && resolve41(projectRoot, cfg.angularDirectory);
+            const angularDir = cfg.angularDirectory && resolve42(projectRoot, cfg.angularDirectory);
             if (angularDir)
-              candidates.push(resolve41(angularDir, tail));
+              candidates.push(resolve42(angularDir, tail));
           } catch {}
           for (const candidate of candidates) {
             if (await fileExists(candidate)) {
@@ -25677,7 +26070,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat3 = statSync6(filePath);
-  const resolvedVueDir = vueDir ? resolve41(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve42(vueDir) : undefined;
   let content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
   const isAngularGeneratedJs = ext === ".js" && filePath.replace(/\\/g, "/").includes("/.absolutejs/generated/angular/");
   if (isAngularGeneratedJs) {
@@ -25736,7 +26129,7 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve41(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve42(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -25752,11 +26145,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve41(projectRoot, match[1]));
+      files.push(resolve42(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve41(filePath);
+  const resolved = resolve42(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -25919,7 +26312,7 @@ __export(exports_hmrCompiler, {
   getApplyMetadataModule: () => getApplyMetadataModule,
   encodeHmrComponentId: () => encodeHmrComponentId
 });
-import { dirname as dirname29, relative as relative17, resolve as resolve42 } from "path";
+import { dirname as dirname30, relative as relative17, resolve as resolve43 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var encodeHmrComponentId = (absoluteFilePath, className) => {
   const projectRel = relative17(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
@@ -25931,7 +26324,7 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
     return null;
   const filePathRel = decoded.slice(0, separatorIndex);
   const className = decoded.slice(separatorIndex + 1);
-  const componentFilePath = resolve42(process.cwd(), filePathRel);
+  const componentFilePath = resolve43(process.cwd(), filePathRel);
   const projectRelPath = relative17(process.cwd(), componentFilePath).replace(/\\/g, "/");
   const cacheKey2 = encodeURIComponent(`${projectRelPath}@${className}`);
   const { takePendingModule: takePendingModule2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
@@ -25942,7 +26335,7 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const owners = resolveOwningComponents2({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname29(componentFilePath)
+    userAngularRoot: dirname30(componentFilePath)
   });
   const owner = owners.find((o3) => o3.className === className);
   const kind = owner?.kind ?? "component";
@@ -26100,11 +26493,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve43 } from "path";
+import { resolve as resolve44 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve43(htmlFilePath);
+    const resolvedPath = resolve44(htmlFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -26130,11 +26523,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve44 } from "path";
+import { resolve as resolve45 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve44(htmxFilePath);
+    const resolvedPath = resolve45(htmxFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -26159,9 +26552,9 @@ var init_simpleHTMXHMR = () => {};
 import { existsSync as existsSync36, readdirSync as readdirSync9, rmSync as rmSync3 } from "fs";
 import {
   basename as basename17,
-  dirname as dirname30,
+  dirname as dirname31,
   isAbsolute as isAbsolute6,
-  join as join47,
+  join as join48,
   relative as relative18,
   resolve as resolvePath3,
   sep as sep4
@@ -26288,8 +26681,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     const relJs = `${rel.slice(0, -ext[0].length)}.js`;
     const generatedDir = getFrameworkGeneratedDir(framework, cwd2);
     for (const candidate of [
-      join47(generatedDir, relJs),
-      `${join47(generatedDir, relJs)}.map`
+      join48(generatedDir, relJs),
+      `${join48(generatedDir, relJs)}.map`
     ]) {
       try {
         rmSync3(candidate, { force: true });
@@ -26524,7 +26917,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
       const { buildDir } = state.resolvedPaths;
       const destPath = resolvePath3(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
       const { mkdir: mkdir12, copyFile, readFile: readFile10 } = await import("fs/promises");
-      await mkdir12(dirname30(destPath), { recursive: true });
+      await mkdir12(dirname31(destPath), { recursive: true });
       await copyFile(absSource, destPath);
       const bytes = await readFile10(destPath);
       const webPath = urlPrefix ? `/${urlPrefix}/${relFromDir}` : `/${relFromDir}`;
@@ -26705,7 +27098,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const keepStemsByDir = new Map;
   const prefixByDir = new Map;
   for (const artifact of freshOutputs) {
-    const dir = dirname30(artifact.path);
+    const dir = dirname31(artifact.path);
     const name = basename17(artifact.path);
     const [prefix] = name.split(".");
     if (!prefix)
@@ -27068,8 +27461,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve45) => {
-        ctx.debouncedResolve = resolve45;
+      ctx.debouncedPromise = new Promise((resolve46) => {
+        ctx.debouncedResolve = resolve46;
       });
     }
     const scheduled = ctx.debouncedPromise;
@@ -27191,7 +27584,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
         const entries = await readdir6(dir, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
-          const full = join47(dir, entry.name);
+          const full = join48(dir, entry.name);
           if (entry.isDirectory()) {
             files.push(...await walk(full));
           } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -27601,8 +27994,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return () => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve45) => {
-        ctx.debouncedResolve = resolve45;
+      ctx.debouncedPromise = new Promise((resolve46) => {
+        ctx.debouncedResolve = resolve46;
       });
     }
     if (ctx.debounceTimer)
@@ -27751,7 +28144,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   } = await compileVue2(vueFiles, vueDir, true, getStyleTransformConfig(state.config));
   const serverEntries = [...vueServerPaths];
   const clientEntries = [...vueIndexPaths, ...vueClientPaths];
-  const cssOutDir = join47(buildDir, state.resolvedPaths.assetsDir ? basename17(state.resolvedPaths.assetsDir) : "assets", "css");
+  const cssOutDir = join48(buildDir, state.resolvedPaths.assetsDir ? basename17(state.resolvedPaths.assetsDir) : "assets", "css");
   const { serverRoot, serverOutDir } = await computeServerOutPaths(state.resolvedPaths, "vue");
   const serverExternals = await getServerBundleExternals();
   const clientVendorPaths = await getClientVendorPaths();
@@ -27876,8 +28269,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return () => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve45) => {
-        ctx.debouncedResolve = resolve45;
+      ctx.debouncedPromise = new Promise((resolve46) => {
+        ctx.debouncedResolve = resolve46;
       });
     }
     if (ctx.debounceTimer)
@@ -28027,7 +28420,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolvePath3(dirname30(buildInfo.resolvedRegistryPath), buildReference.source);
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolvePath3(dirname31(buildInfo.resolvedRegistryPath), buildReference.source);
   islandFiles.add(resolvePath3(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
@@ -28840,7 +29233,7 @@ __export(exports_buildDepVendor, {
 });
 import { mkdirSync as mkdirSync14 } from "fs";
 import { isBuiltin } from "module";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 import { rm as rm14 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob10 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
@@ -28899,8 +29292,8 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable3)
   };
 }, collectBareImportsFromFile = async (entryPath, transpiler6, maxDepth = 8) => {
-  const { readFileSync: readFileSync31 } = await import("fs");
-  const { dirname: dirname31 } = await import("path");
+  const { readFileSync: readFileSync32 } = await import("fs");
+  const { dirname: dirname32 } = await import("path");
   const seenFiles = new Set;
   const bareOut = new Set;
   const queue = [
@@ -28915,7 +29308,7 @@ var toSafeFileName6 = (specifier) => {
       continue;
     let content;
     try {
-      content = readFileSync31(path, "utf-8");
+      content = readFileSync32(path, "utf-8");
     } catch {
       continue;
     }
@@ -28925,7 +29318,7 @@ var toSafeFileName6 = (specifier) => {
     } catch {
       continue;
     }
-    const fromDir = dirname31(path);
+    const fromDir = dirname32(path);
     for (const imp of imports) {
       const child = imp.path;
       if (child.startsWith(".") || child.startsWith("/")) {
@@ -28989,7 +29382,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join48(tmpDir, `${safeName}.ts`);
+    const entryPath = join49(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -29080,9 +29473,9 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join48(buildDir, "vendor");
+  const vendorDir = join49(buildDir, "vendor");
   mkdirSync14(vendorDir, { recursive: true });
-  const tmpDir = join48(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join49(buildDir, "_dep_vendor_tmp");
   mkdirSync14(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -29165,7 +29558,7 @@ __export(exports_devBuild, {
 });
 import { readdir as readdir6 } from "fs/promises";
 import { statSync as statSync7 } from "fs";
-import { resolve as resolve45 } from "path";
+import { resolve as resolve46 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -29188,7 +29581,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve45(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve46(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -29300,7 +29693,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     });
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync7(resolve45(Bun.main)).mtimeMs;
+  const serverMtime = statSync7(resolve46(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -29337,8 +29730,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve45(import.meta.dir, "..", "..", "package.json"),
-    resolve45(import.meta.dir, "..", "package.json")
+    resolve46(import.meta.dir, "..", "..", "package.json"),
+    resolve46(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -29364,7 +29757,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const entries = await readdir6(vendorDir).catch(() => emptyStringArray);
   await Promise.all(entries.filter((entry) => entry.endsWith(".js")).map(async (entry) => {
     const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve45(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve46(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -29503,11 +29896,11 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve45(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve45(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve45(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve45(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve45(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve46(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve46(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve46(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve46(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve46(state.resolvedPaths.buildDir, "vendor");
   const { buildDepVendor: buildDepVendor2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
   const [, angularSpecs, , , , , depPaths] = await Promise.all([
     config.reactDirectory ? buildReactVendor(state.resolvedPaths.buildDir) : Promise.resolve(undefined),
@@ -29585,7 +29978,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync7(resolve45(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync7(resolve46(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -29734,8 +30127,8 @@ var STORE_KEY = "__elysiaStore", restoredStores, getGlobalValue = (key) => Refle
     return null;
   if (!pathname.startsWith("/"))
     return null;
-  const { resolve: resolve46, normalize } = await import("path");
-  const candidate = resolve46(buildDir, pathname.slice(1));
+  const { resolve: resolve47, normalize } = await import("path");
+  const candidate = resolve47(buildDir, pathname.slice(1));
   const normalizedBuild = normalize(buildDir);
   if (!candidate.startsWith(normalizedBuild))
     return null;
@@ -29831,17 +30224,17 @@ __export(exports_devtoolsJson, {
   normalizeDevtoolsWorkspaceRoot: () => normalizeDevtoolsWorkspaceRoot,
   devtoolsJson: () => devtoolsJson
 });
-import { existsSync as existsSync37, mkdirSync as mkdirSync15, readFileSync as readFileSync31, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname31, join as join49, resolve as resolve46 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync15, readFileSync as readFileSync32, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname32, join as join50, resolve as resolve47 } from "path";
 import { Elysia as Elysia6 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve46(uuidCachePath ?? join49(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve47(uuidCachePath ?? join50(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
   if (!existsSync37(cachePath))
     return null;
   try {
-    const value = readFileSync31(cachePath, "utf-8").trim();
+    const value = readFileSync32(cachePath, "utf-8").trim();
     return isUuidV4(value) ? value : null;
   } catch {
     return null;
@@ -29859,11 +30252,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync15(dirname31(cachePath), { recursive: true });
+  mkdirSync15(dirname32(cachePath), { recursive: true });
   writeFileSync10(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
-  const rootPath = resolve46(options.projectRoot ?? process.cwd());
+  const rootPath = resolve47(options.projectRoot ?? process.cwd());
   const root = options.normalizeForWindowsContainer === false ? rootPath : normalizeDevtoolsWorkspaceRoot(rootPath);
   const uuid = getOrCreateUuid(buildDir, options);
   return new Elysia6({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
@@ -29876,11 +30269,11 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (process.env.WSL_DISTRO_NAME) {
     const distro = process.env.WSL_DISTRO_NAME;
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join49("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
+    return join50("\\\\wsl.localhost", distro, withoutLeadingSlash).replace(/\//g, "\\");
   }
   if (process.env.DOCKER_DESKTOP && !root.startsWith("\\\\")) {
     const withoutLeadingSlash = root.replace(/^\//, "");
-    return join49("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
+    return join50("\\\\wsl.localhost", "docker-desktop-data", withoutLeadingSlash).replace(/\//g, "\\");
   }
   return root;
 };
@@ -29892,7 +30285,7 @@ __export(exports_imageOptimizer, {
   imageOptimizer: () => imageOptimizer
 });
 import { existsSync as existsSync38 } from "fs";
-import { resolve as resolve47 } from "path";
+import { resolve as resolve48 } from "path";
 import { Elysia as Elysia7 } from "elysia";
 var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
   try {
@@ -29905,7 +30298,7 @@ var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avi
   }
 }, resolveLocalImage = (url, buildDir) => {
   const cleanPath = url.startsWith("/") ? url.slice(1) : url;
-  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve47(process.cwd()));
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve48(process.cwd()));
 }, parseQueryParams = (query, allowedSizes, defaultQuality) => {
   const url = typeof query["url"] === "string" ? query["url"] : undefined;
   const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
@@ -30182,15 +30575,15 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync32 } from "fs";
-import { join as join50 } from "path";
+import { mkdirSync as mkdirSync16, readFileSync as readFileSync33 } from "fs";
+import { join as join51 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, DEFAULT_FETCH_TIMEOUT_MS = 1e4, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync32(metaPath, "utf-8");
+    const content = readFileSync33(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -30253,7 +30646,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     if (!isCompleteHtml(html))
       return false;
     const fileName = routeToFilename(route);
-    const filePath = join50(prerenderDir, fileName);
+    const filePath = join51(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -30283,13 +30676,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     return;
   }
   const fileName = routeToFilename(route);
-  const filePath = join50(prerenderDir, fileName);
+  const filePath = join51(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log2?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log2) => {
-  const prerenderDir = join50(outDir, "_prerendered");
+  const prerenderDir = join51(outDir, "_prerendered");
   mkdirSync16(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -30410,15 +30803,15 @@ import {
   copyFileSync as copyFileSync4,
   existsSync as existsSync41,
   readdirSync as readdirSync12,
-  readFileSync as readFileSync36,
+  readFileSync as readFileSync37,
   statSync as statSync8,
   watch as watch2
 } from "fs";
 import { createHash as createHash9 } from "crypto";
-import { dirname as dirname32, join as join54, resolve as resolve48 } from "path";
+import { dirname as dirname33, join as join55, resolve as resolve49 } from "path";
 var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ENTRY_IMPORT_RETRY_DELAY_MS = 250, MAX_ENTRY_IMPORT_ATTEMPTS = 3, WATCH_FALLBACK_INTERVAL_MS = 250, ATOMIC_WRITE_TEMP_PATTERNS2, isAtomicWriteTemp = (filename) => filename.endsWith(".tmp") || filename.includes(".tmp.") || filename.endsWith("~") || filename.startsWith(".#") || filename.startsWith(".absolutejs-hmr-") || ATOMIC_WRITE_TEMP_PATTERNS2.some((pattern) => pattern.test(filename)), fileHash = (path) => {
   try {
-    return createHash9("sha256").update(readFileSync36(path)).digest("hex");
+    return createHash9("sha256").update(readFileSync37(path)).digest("hex");
   } catch {
     return null;
   }
@@ -30443,11 +30836,11 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ENTRY_IMPORT_RETR
     return;
   globalThis.__absoluteEntryWatcherStarted = true;
   globalThis.__absoluteEntryWatcherReady = false;
-  const entryPath = resolve48(originalEntry);
-  const entryDir = dirname32(entryPath);
+  const entryPath = resolve49(originalEntry);
+  const entryDir = dirname33(entryPath);
   const entryBase = entryPath.slice(entryDir.length + 1);
-  const configPath2 = resolve48(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
-  const configDir2 = dirname32(configPath2);
+  const configPath2 = resolve49(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const configDir2 = dirname33(configPath2);
   const configBase = configPath2.slice(configDir2.length + 1);
   const recentlyHandled = new Map;
   let entryReloadTimer = null;
@@ -30457,7 +30850,7 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ENTRY_IMPORT_RETR
   let pendingEntryCause = null;
   let siblingSequence = 0;
   const importFreshEntry = async (attempt = 1) => {
-    const siblingPath = join54(entryDir, `.absolutejs-hmr-${process.pid}-${siblingSequence++}.ts`);
+    const siblingPath = join55(entryDir, `.absolutejs-hmr-${process.pid}-${siblingSequence++}.ts`);
     let failure;
     try {
       copyFileSync4(entryPath, siblingPath);
@@ -30570,7 +30963,7 @@ var ATOMIC_RECOVERY_WINDOW_MS = 1000, RELOAD_DEBOUNCE_MS = 80, ENTRY_IMPORT_RETR
         continue;
       let st2;
       try {
-        st2 = statSync8(join54(dir, entry.name));
+        st2 = statSync8(join55(dir, entry.name));
       } catch {
         continue;
       }
@@ -31438,8 +31831,8 @@ var handleHTMXPageRequest = async (pagePath, options = {}) => {
 };
 // src/core/prepare.ts
 import { createHash as createHash8 } from "crypto";
-import { existsSync as existsSync39, readdirSync as readdirSync10, readFileSync as readFileSync33 } from "fs";
-import { basename as basename18, join as join51, relative as relative19, resolve as resolvePath4 } from "path";
+import { existsSync as existsSync39, readdirSync as readdirSync10, readFileSync as readFileSync34 } from "fs";
+import { basename as basename18, join as join52, relative as relative19, resolve as resolvePath4 } from "path";
 import { Elysia as Elysia9, NotFound } from "elysia";
 
 // src/plugins/openApiPlugin.ts
@@ -32743,8 +33136,8 @@ var MS_PER_SECOND2 = 1000;
 var DEFAULT_PORT2 = 3000;
 var MAX_STATIC_ROUTE_COUNT = Number.MAX_SAFE_INTEGER;
 var STATIC_PLUGIN_RETRY_DELAY_MS = 50;
-var waitForStaticPluginRetry = () => new Promise((resolve48) => {
-  setTimeout(resolve48, STATIC_PLUGIN_RETRY_DELAY_MS);
+var waitForStaticPluginRetry = () => new Promise((resolve49) => {
+  setTimeout(resolve49, STATIC_PLUGIN_RETRY_DELAY_MS);
 });
 var retryStaticPlugin = async (createStaticPlugin, options) => {
   try {
@@ -32840,10 +33233,10 @@ var registerIconVersioning = (buildDir) => {
     if (cached !== undefined)
       return cached;
     const path = href.split("?")[0] ?? href;
-    const filePath = join51(buildDir, path);
+    const filePath = join52(buildDir, path);
     let versioned = href;
     if (existsSync39(filePath)) {
-      const hash = createHash8("sha256").update(readFileSync33(filePath)).digest("hex").slice(0, ICON_HASH_LENGTH);
+      const hash = createHash8("sha256").update(readFileSync34(filePath)).digest("hex").slice(0, ICON_HASH_LENGTH);
       versioned = href.includes("?") ? `${href}&v=${hash}` : `${href}?v=${hash}`;
     }
     cache2.set(href, versioned);
@@ -32970,13 +33363,13 @@ var loadPrerenderMap = (prerenderDir) => {
       continue;
     const name = basename18(entry, ".html");
     const route = name === "index" ? "/" : `/${name}`;
-    map.set(route, join51(prerenderDir, entry));
+    map.set(route, join52(prerenderDir, entry));
   }
   return map;
 };
 var loadMobileCompatibilityPlugin = async (buildDir) => {
-  const root = join51(buildDir, ".absolutejs", "mobile-compatibility");
-  if (!existsSync39(join51(root, "current.json"))) {
+  const root = join52(buildDir, ".absolutejs", "mobile-compatibility");
+  if (!existsSync39(join52(root, "current.json"))) {
     return new Elysia9({ name: "absolutejs-mobile-compatibility-empty" });
   }
   const options = await loadAbsoluteMobileMaterializedBundle(root);
@@ -33029,7 +33422,7 @@ var prepare = async (configOrPath) => {
     return result;
   }
   stepStartedAt = performance.now();
-  const manifest = JSON.parse(readFileSync33(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync34(`${buildDir}/manifest.json`, "utf-8"));
   setCurrentIslandManifest(manifest);
   if (config.islands?.registry) {
     setCurrentIslandRegistry(await loadIslandRegistry(config.islands.registry));
@@ -33037,14 +33430,14 @@ var prepare = async (configOrPath) => {
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
-  const conventionsPath = join51(buildDir, "conventions.json");
+  const conventionsPath = join52(buildDir, "conventions.json");
   if (existsSync39(conventionsPath)) {
-    const conventions2 = JSON.parse(readFileSync33(conventionsPath, "utf-8"));
+    const conventions2 = JSON.parse(readFileSync34(conventionsPath, "utf-8"));
     setConventions(conventions2);
   }
-  const spaRoutesPath = join51(buildDir, "spa-routes.json");
+  const spaRoutesPath = join52(buildDir, "spa-routes.json");
   if (existsSync39(spaRoutesPath)) {
-    setSpaRouteManifest(JSON.parse(readFileSync33(spaRoutesPath, "utf-8")));
+    setSpaRouteManifest(JSON.parse(readFileSync34(spaRoutesPath, "utf-8")));
   }
   recordStep("load production conventions", stepStartedAt);
   stepStartedAt = performance.now();
@@ -33055,7 +33448,7 @@ var prepare = async (configOrPath) => {
     prefix: "",
     staticLimit: MAX_STATIC_ROUTE_COUNT
   });
-  const generatedAssetsRoot = join51(buildDir, ".absolutejs");
+  const generatedAssetsRoot = join52(buildDir, ".absolutejs");
   const generatedAssetsPlugin = new Elysia9({
     name: "absolutejs-generated-assets"
   }).get("/.absolutejs/*", async ({ params, set }) => {
@@ -33093,7 +33486,7 @@ var prepare = async (configOrPath) => {
     responseValue.headers.set("cache-control", isFingerprintedAsset(pathname) ? "public, max-age=31536000, immutable" : "public, max-age=0, must-revalidate");
   });
   stepStartedAt = performance.now();
-  const prerenderDir = join51(buildDir, "_prerendered");
+  const prerenderDir = join52(buildDir, "_prerendered");
   const prerenderMap = loadPrerenderMap(prerenderDir);
   const mobileCompatibilityPlugin = await loadMobileCompatibilityPlugin(buildDir);
   const mobileAssociationPlugin = createAbsoluteMobileAssociationPlugin(config.mobile, process.cwd(), { requireAll: true });
@@ -33163,20 +33556,20 @@ import {
   copyFileSync as copyFileSync3,
   existsSync as existsSync40,
   mkdirSync as mkdirSync17,
-  readFileSync as readFileSync34,
+  readFileSync as readFileSync35,
   rmSync as rmSync4
 } from "fs";
-import { join as join52 } from "path";
-var CERT_DIR = join52(process.cwd(), ".absolutejs");
-var CERT_PATH = join52(CERT_DIR, "cert.pem");
-var KEY_PATH = join52(CERT_DIR, "key.pem");
+import { join as join53 } from "path";
+var CERT_DIR = join53(process.cwd(), ".absolutejs");
+var CERT_PATH = join53(CERT_DIR, "cert.pem");
+var KEY_PATH = join53(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
 var certFilesExist = () => existsSync40(CERT_PATH) && existsSync40(KEY_PATH);
 var isCertExpired = () => {
   try {
-    const certPem = readFileSync34(CERT_PATH, "utf-8");
+    const certPem = readFileSync35(CERT_PATH, "utf-8");
     const proc = Bun.spawnSync(["openssl", "x509", "-enddate", "-noout"], {
       stdin: new TextEncoder().encode(certPem)
     });
@@ -33272,8 +33665,8 @@ var loadDevCert = () => {
     return null;
   try {
     return {
-      cert: readFileSync34(paths.cert, "utf-8"),
-      key: readFileSync34(paths.key, "utf-8")
+      cert: readFileSync35(paths.cert, "utf-8"),
+      key: readFileSync35(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -33283,18 +33676,18 @@ var loadDevCert = () => {
 // src/utils/instanceRegistry.ts
 import {
   mkdirSync as mkdirSync18,
-  readFileSync as readFileSync35,
+  readFileSync as readFileSync36,
   readdirSync as readdirSync11,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync11
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename19, join as join53 } from "path";
+import { basename as basename19, join as join54 } from "path";
 var registeredPids = new Set;
 var exitHandlerRegistered = false;
-var instanceFilePath = (pid) => join53(instanceRegistryDir(), `${pid}.json`);
-var instanceLogPath = (pid) => join53(instanceRegistryDir(), `${pid}.log`);
-var instanceRegistryDir = () => join53(homedir2(), ".absolutejs", "instances");
+var instanceFilePath = (pid) => join54(instanceRegistryDir(), `${pid}.json`);
+var instanceLogPath = (pid) => join54(instanceRegistryDir(), `${pid}.log`);
+var instanceRegistryDir = () => join54(homedir2(), ".absolutejs", "instances");
 var removeInstanceFilesSync = (pid) => {
   try {
     unlinkSync2(instanceFilePath(pid));
@@ -33316,7 +33709,7 @@ var registerExitHandlerOnce = () => {
 };
 var readJsonFile = (path) => {
   try {
-    return JSON.parse(readFileSync35(path, "utf-8"));
+    return JSON.parse(readFileSync36(path, "utf-8"));
   } catch {
     return null;
   }
@@ -33329,7 +33722,7 @@ var registerInstance = (record) => {
   return record;
 };
 var resolveProjectName = (cwd2) => {
-  const parsed = readJsonFile(join53(cwd2, "package.json"));
+  const parsed = readJsonFile(join54(cwd2, "package.json"));
   if (parsed !== null && typeof parsed === "object" && typeof parsed.name === "string" && parsed.name.trim().length > 0) {
     return parsed.name;
   }
@@ -33356,7 +33749,7 @@ var getLocalIPAddress = () => {
 
 // src/plugins/networking.ts
 init_startupBanner();
-var host = env4.ABSOLUTE_HOST ?? env4.HOST ?? "localhost";
+var host2 = env4.ABSOLUTE_HOST ?? env4.HOST ?? "localhost";
 var port = env4.ABSOLUTE_PORT ?? env4.PORT ?? DEFAULT_PORT;
 var visibility = env4.ABSOLUTE_WORKSPACE_SERVICE_VISIBILITY ?? "public";
 var managedByWorkspace = env4.ABSOLUTE_WORKSPACE_MANAGED === "1";
@@ -33365,7 +33758,7 @@ var args = argv;
 var hostFlag = args.includes("--host");
 if (hostFlag) {
   localIP = getLocalIPAddress();
-  host = "0.0.0.0";
+  host2 = "0.0.0.0";
 }
 var loadTls = () => {
   if (env4.NODE_ENV !== "development")
@@ -33403,7 +33796,7 @@ var selfRegisterInstance = () => {
     controllerPid: process.pid,
     cwd: process.cwd(),
     frameworks: [],
-    host,
+    host: host2,
     https: protocol === "https",
     logFile: null,
     name: resolveProjectName(process.cwd()),
@@ -33445,7 +33838,7 @@ var networking = (app) => {
     return app;
   }
   const listened = app.listen({
-    hostname: host,
+    hostname: host2,
     idleTimeout: httpIdleTimeout,
     port,
     ...tls ? {
@@ -33469,7 +33862,7 @@ var networking = (app) => {
     const version = globalThis.__absoluteVersion || env4.ABSOLUTE_VERSION || "";
     startupBanner({
       buildDuration,
-      host,
+      host: host2,
       networkUrl: hostFlag ? `${protocol}://${localIP}:${port}/` : undefined,
       port,
       protocol,
@@ -33639,8 +34032,8 @@ var generateHeadElement = ({
 };
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
-import { existsSync as existsSync42, readFileSync as readFileSync37 } from "fs";
-import { resolve as resolve49 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync38 } from "fs";
+import { resolve as resolve50 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var exports_value = {};
@@ -38107,9 +38500,9 @@ class ValueCastError extends TypeBoxError {
 }
 function ScoreUnion(schema, references, value) {
   if (schema[Kind] === "Object" && typeof value === "object" && !IsNull2(value)) {
-    const object = schema;
+    const object2 = schema;
     const keys = Object.getOwnPropertyNames(value);
-    const entries = Object.entries(object.properties);
+    const entries = Object.entries(object2.properties);
     return entries.reduce((acc, [key, schema2]) => {
       const literal = schema2[Kind] === "Literal" && schema2.const === value[key] ? 100 : 0;
       const checks = Check(schema2, references, value[key]) ? 10 : 0;
@@ -39228,8 +39621,8 @@ class ValuePointerRootDeleteError extends TypeBoxError {
     this.path = path;
   }
 }
-function Escape2(component) {
-  return component.indexOf("~") === -1 ? component : component.replace(/~1/g, "/").replace(/~0/g, "~");
+function Escape2(component2) {
+  return component2.indexOf("~") === -1 ? component2 : component2.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 function* Format(pointer) {
   if (pointer === "")
@@ -39255,12 +39648,12 @@ function Set4(value, pointer, update) {
   if (pointer === "")
     throw new ValuePointerRootSetError(value, pointer, update);
   let [owner, next, key] = [null, value, ""];
-  for (const component of Format(pointer)) {
-    if (next[component] === undefined)
-      next[component] = {};
+  for (const component2 of Format(pointer)) {
+    if (next[component2] === undefined)
+      next[component2] = {};
     owner = next;
-    next = next[component];
-    key = component;
+    next = next[component2];
+    key = component2;
   }
   owner[key] = update;
 }
@@ -39268,12 +39661,12 @@ function Delete3(value, pointer) {
   if (pointer === "")
     throw new ValuePointerRootDeleteError(value, pointer);
   let [owner, next, key] = [null, value, ""];
-  for (const component of Format(pointer)) {
-    if (next[component] === undefined || next[component] === null)
+  for (const component2 of Format(pointer)) {
+    if (next[component2] === undefined || next[component2] === null)
       return;
     owner = next;
-    next = next[component];
-    key = component;
+    next = next[component2];
+    key = component2;
   }
   if (Array.isArray(owner)) {
     const index = parseInt(key);
@@ -39286,12 +39679,12 @@ function Has3(value, pointer) {
   if (pointer === "")
     return true;
   let [owner, next, key] = [null, value, ""];
-  for (const component of Format(pointer)) {
-    if (next[component] === undefined)
+  for (const component2 of Format(pointer)) {
+    if (next[component2] === undefined)
       return false;
     owner = next;
-    next = next[component];
-    key = component;
+    next = next[component2];
+    key = component2;
   }
   return Object.getOwnPropertyNames(owner).includes(key);
 }
@@ -39299,10 +39692,10 @@ function Get3(value, pointer) {
   if (pointer === "")
     return value;
   let current = value;
-  for (const component of Format(pointer)) {
-    if (current[component] === undefined)
+  for (const component2 of Format(pointer)) {
+    if (current[component2] === undefined)
       return;
-    current = current[component];
+    current = current[component2];
   }
   return current;
 }
@@ -39576,7 +39969,7 @@ class ParseError extends TypeBoxError {
 }
 var ParseRegistry;
 (function(ParseRegistry2) {
-  const registry = new Map([
+  const registry2 = new Map([
     ["Assert", (type, references, value) => {
       Assert(type, references, value);
       return value;
@@ -39590,15 +39983,15 @@ var ParseRegistry;
     ["Encode", (type, references, value) => HasTransform(type, references) ? TransformEncode(type, references, value) : value]
   ]);
   function Delete5(key) {
-    registry.delete(key);
+    registry2.delete(key);
   }
   ParseRegistry2.Delete = Delete5;
   function Set5(key, callback) {
-    registry.set(key, callback);
+    registry2.set(key, callback);
   }
   ParseRegistry2.Set = Set5;
   function Get4(key) {
-    return registry.get(key);
+    return registry2.get(key);
   }
   ParseRegistry2.Get = Get4;
 })(ParseRegistry || (ParseRegistry = {}));
@@ -39612,10 +40005,10 @@ var ParseDefault = [
 ];
 function ParseValue(operations, type, references, value) {
   return operations.reduce((value2, operationKey) => {
-    const operation = ParseRegistry.Get(operationKey);
-    if (IsUndefined2(operation))
+    const operation2 = ParseRegistry.Get(operationKey);
+    if (IsUndefined2(operation2))
       throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
-    return operation(type, references, value2);
+    return operation2(type, references, value2);
   }, value);
 }
 function Parse(...args2) {
@@ -39675,19 +40068,19 @@ ${lines.join(`
 };
 var checkEnvFileSecurity = (properties) => {
   const cwd2 = process.cwd();
-  const envPath = resolve49(cwd2, ".env");
+  const envPath = resolve50(cwd2, ".env");
   if (!existsSync42(envPath))
     return;
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
   if (sensitiveKeys.length === 0)
     return;
-  const envContent = readFileSync37(envPath, "utf-8");
+  const envContent = readFileSync38(envPath, "utf-8");
   const presentKeys = sensitiveKeys.filter((key) => envContent.includes(`${key}=`));
   if (presentKeys.length === 0)
     return;
-  const gitignorePath = resolve49(cwd2, ".gitignore");
+  const gitignorePath = resolve50(cwd2, ".gitignore");
   if (existsSync42(gitignorePath)) {
-    const gitignore = readFileSync37(gitignorePath, "utf-8");
+    const gitignore = readFileSync38(gitignorePath, "utf-8");
     if (gitignore.split(`
 `).some((line) => line.trim() === ".env"))
       return;
@@ -39720,7 +40113,7 @@ var getEnv = (key) => {
 };
 // src/utils/projectRoot.ts
 import { existsSync as existsSync43 } from "fs";
-import { dirname as dirname33, resolve as resolve50 } from "path";
+import { dirname as dirname34, resolve as resolve51 } from "path";
 var CONFIG_CANDIDATES = [
   "absolute.config.ts",
   "absolute.config.js",
@@ -39729,7 +40122,7 @@ var CONFIG_CANDIDATES = [
   "absolute.config.mts",
   "absolute.config.cts"
 ];
-var hasAbsoluteConfig = (directory) => CONFIG_CANDIDATES.some((name) => existsSync43(resolve50(directory, name)));
+var hasAbsoluteConfig = (directory) => CONFIG_CANDIDATES.some((name) => existsSync43(resolve51(directory, name)));
 var findProjectRoot = () => {
   const start = process.cwd();
   let packageRoot = null;
@@ -39738,10 +40131,10 @@ var findProjectRoot = () => {
     if (hasAbsoluteConfig(directory)) {
       return directory;
     }
-    if (packageRoot === null && existsSync43(resolve50(directory, "package.json"))) {
+    if (packageRoot === null && existsSync43(resolve51(directory, "package.json"))) {
       packageRoot = directory;
     }
-    const parent = dirname33(directory);
+    const parent = dirname34(directory);
     if (parent === directory) {
       return packageRoot ?? start;
     }
@@ -39987,5 +40380,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=C36F3DE38F8FB23964756E2164756E21
+//# debugId=6C5F45490109F7A064756E2164756E21
 //# sourceMappingURL=index.js.map