npm - @absolutejs/absolute - Versions diffs - 0.20.0-beta.2 → 0.20.0-beta.20 - Mend

@absolutejs/absolute 0.20.0-beta.2 → 0.20.0-beta.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

package/README.md +135 -0
package/dist/angular/components/core/streamingSlotRegistrar.js +1 -1
package/dist/angular/components/core/streamingSlotRegistry.js +2 -2
package/dist/angular/index.js +341 -22
package/dist/angular/index.js.map +8 -5
package/dist/angular/server.js +341 -22
package/dist/angular/server.js.map +8 -5
package/dist/build.js +1254 -598
package/dist/build.js.map +16 -13
package/dist/cli/index.js +4995 -1614
package/dist/dev/client/cssUtils.ts +16 -2
package/dist/dev/client/handlers/rebuild.ts +11 -1
package/dist/dev/client/hmrClient.ts +9 -3
package/dist/dev/client/hmrTiming.ts +14 -7
package/dist/dev/client/syncDevtools.ts +237 -0
package/dist/index.js +1628 -862
package/dist/index.js.map +24 -21
package/dist/mobile/browser.js +123 -1
package/dist/mobile/browser.js.map +6 -4
package/dist/mobile/index.js +3361 -298
package/dist/mobile/index.js.map +27 -13
package/dist/mobile/remoteMacAgentEntry.js +29 -0
package/dist/mobile/shellAuth.js +35 -0
package/dist/mobile/shellBootstrap.js +585 -0
package/dist/mobile/shellSync.js +123 -0
package/dist/src/angular/pageHandler.d.ts +3 -0
package/dist/src/build/pwa.d.ts +16 -0
package/dist/src/cli/config/server.d.ts +1 -1
package/dist/src/core/pageHandlers.d.ts +11 -2
package/dist/src/core/prepare.d.ts +6 -0
package/dist/src/dev/clientManager.d.ts +2 -0
package/dist/src/mobile/androidEmulatorController.d.ts +6 -1
package/dist/src/mobile/browser.d.ts +1 -0
package/dist/src/mobile/buildPipeline.d.ts +1 -0
package/dist/src/mobile/capacitorBundle.d.ts +22 -1
package/dist/src/mobile/client.d.ts +4 -0
package/dist/src/mobile/deviceCapabilities.d.ts +33 -0
package/dist/src/mobile/index.d.ts +9 -0
package/dist/src/mobile/iosConformance.d.ts +15 -0
package/dist/src/mobile/iosNativeWatcher.d.ts +19 -0
package/dist/src/mobile/iosRelease.d.ts +2 -2
package/dist/src/mobile/iosSimulatorController.d.ts +89 -0
package/dist/src/mobile/nativeAuth.d.ts +17 -0
package/dist/src/mobile/nativeBackgroundSync.d.ts +4 -0
package/dist/src/mobile/nativeDeviceCapabilities.d.ts +6 -0
package/dist/src/mobile/releaseArtifact.d.ts +2 -0
package/dist/src/mobile/remoteMacAgent.d.ts +2 -0
package/dist/src/mobile/remoteMacAgentEntry.d.ts +1 -0
package/dist/src/mobile/remoteMacProtocol.d.ts +114 -0
package/dist/src/mobile/remoteMacWire.d.ts +2 -0
package/dist/src/mobile/shellAuth.d.ts +13 -0
package/dist/src/mobile/shellBootstrap.d.ts +18 -1
package/dist/src/mobile/shellSync.d.ts +19 -0
package/dist/src/mobile/staticDocument.d.ts +5 -0
package/dist/src/mobile/syncRemediation.d.ts +10 -0
package/dist/src/mobile/syncSchema.d.ts +9 -0
package/dist/src/mobile/transport.d.ts +16 -1
package/dist/src/plugins/hmr.d.ts +3 -0
package/dist/src/plugins/imageOptimizer.d.ts +1 -1
package/dist/src/svelte/pageHandler.d.ts +3 -0
package/dist/src/utils/loadConfig.d.ts +1 -0
package/dist/src/vue/pageHandler.d.ts +3 -0
package/dist/svelte/index.js +312 -23
package/dist/svelte/index.js.map +7 -4
package/dist/svelte/server.js +307 -18
package/dist/svelte/server.js.map +7 -4
package/dist/types/build.d.ts +14 -0
package/dist/vue/index.js +312 -23
package/dist/vue/index.js.map +7 -4
package/dist/vue/server.js +307 -18
package/dist/vue/server.js.map +7 -4
package/package.json +29 -9

package/dist/build.js CHANGED Viewed

@@ -969,9 +969,10 @@ var indexContentCache, resolveDevClientDir = () => {
       `}
 `,
       `// Attempt hydration with error handling`,
+      `const shouldClientRender = window.__ABSOLUTE_PAGE_RENDER_MODE__ === 'client';`,
       `// Use document (not document.body) when the page renders <html><head><body>`,
       `// to avoid "In HTML, <html> cannot be a child of <body>" hydration error`,
-      `const container = typeof document !== 'undefined' ? document : null;`,
+      `const container = typeof document !== 'undefined' ? (shouldClientRender ? document.getElementById('root') : document) : null;`,
       `if (!container) {`,
       `	throw new Error('React root container not found: document is null');`,
       `}
@@ -997,7 +998,6 @@ var indexContentCache, resolveDevClientDir = () => {
       `if (!window.__REACT_ROOT__) {`,
       `	let root;`,
       `	// Mobile data envelopes and dirty HMR pages have no matching SSR markup.`,
-      `	const shouldClientRender = window.__ABSOLUTE_PAGE_RENDER_MODE__ === 'client';`,
       `	if (window.__SSR_DIRTY__ || shouldClientRender) {`,
       `		root = createRoot(container);`,
       `		root.render(${isDev ? `createElement(ErrorBoundary, null, createElement(PageComponent, mergedProps))` : `createElement(PageComponent, mergedProps)`});`,
@@ -1077,6 +1077,15 @@ var indexContentCache, resolveDevClientDir = () => {
       `		};`,
       `	}`,
       `}`,
+      `if (typeof window !== 'undefined') {`,
+      `	window.__ABSOLUTE_PAGE_READY__ = Promise.resolve();`,
+      `	window.__ABSOLUTE_PAGE_DISPOSE__ = function() {`,
+      `		if (window.__REACT_ROOT__ && typeof window.__REACT_ROOT__.unmount === 'function') {`,
+      `			window.__REACT_ROOT__.unmount();`,
+      `		}`,
+      `		window.__REACT_ROOT__ = null;`,
+      `	};`,
+      `}`,
       ...isDev ? [
         `
 // Pre-warm: import the page module from the module server`,
@@ -12355,7 +12364,8 @@ var heldLocks, HELD_LOCKS_ENV = "ABSOLUTE_HELD_BUILD_DIRECTORY_LOCKS", exitHandl
   });
   process.on("uncaughtException", (err) => {
     releaseAllSync();
-    throw err;
+    console.error(err);
+    process.exit(1);
   });
 }, isAlreadyExistsError = (error) => error instanceof Error && ("code" in error) && Reflect.get(error, "code") === "EEXIST", lockPathForBuildDirectory = (buildDirectory) => join23(dirname12(buildDirectory), ".absolutejs", "build.lock"), readHeldLockEnv = () => new Set((process.env[HELD_LOCKS_ENV] ?? "").split(`
 `).filter((entry) => entry.length > 0)), writeHeldLockEnv = (locks) => {
@@ -12849,13 +12859,566 @@ var isTestSourcePath = (file) => {
   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")) && Array.isArray(Reflect.get(value, "clients")), 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.conflict !== undefined && rule.conflict.strategy !== "client-wins" && rule.conflict.strategy !== "manual" && rule.conflict.strategy !== "server-wins")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.strategy is invalid.`);
+    if (rule.conflict?.maxAttempts !== undefined && (!Number.isSafeInteger(rule.conflict.maxAttempts) || rule.conflict.maxAttempts < 1))
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.maxAttempts must be a positive safe integer.`);
+    if (rule.conflict?.maxAttempts !== undefined && rule.conflict.strategy !== "client-wins")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.maxAttempts is only valid for client-wins.`);
+    if (rule.persistence === "memory-only" && rule.protection === "required")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${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}.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;
+    if (typeof existing === "object" && existing !== null && Array.isArray(Reflect.get(existing, "installations"))) {
+      Reflect.set(existing, "clients", []);
+      return existing;
+    }
+    const created = { clients: [], 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 readFileSync13 } from "fs";
+import { dirname as dirname13, join as join24, resolve as resolve20 } from "path";
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value), manifestAt = (path) => {
+  try {
+    const value = JSON.parse(readFileSync13(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 = resolve20(projectRoot);
+  while (true) {
+    const candidate = join24(directory, "node_modules", packageName, "package.json");
+    const manifest = manifestAt(candidate);
+    if (manifest && Reflect.get(manifest, "name") === packageName)
+      return candidate;
+    const parent = dirname13(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], normalizeJsonValue = (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) => normalizeJsonValue(entry, id, field));
+  if (object(value))
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      normalizeJsonValue(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: normalizeJsonValue(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([
+      "conflict",
+      "match",
+      "onProtectionUnavailable",
+      "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");
+    const onProtectionUnavailable = unknownField(rule, "onProtectionUnavailable");
+    const declaredConflict = unknownField(rule, "conflict");
+    let conflict;
+    if (declaredConflict !== undefined) {
+      const conflictRecord = requireObject(declaredConflict, id, `localData.mutations[${index}].conflict must be an object.`);
+      const unsupportedConflictKey = Object.keys(conflictRecord).find((key) => key !== "maxAttempts" && key !== "strategy");
+      if (unsupportedConflictKey)
+        throw metadataError(id, `localData.mutations[${index}].conflict.${unsupportedConflictKey} is not supported.`);
+      const strategy = unknownField(conflictRecord, "strategy");
+      if (strategy !== "client-wins" && strategy !== "manual" && strategy !== "server-wins")
+        throw metadataError(id, `localData.mutations[${index}].conflict.strategy is invalid.`);
+      const maxAttempts = unknownField(conflictRecord, "maxAttempts");
+      if (maxAttempts !== undefined && strategy !== "client-wins")
+        throw metadataError(id, `localData.mutations[${index}].conflict.maxAttempts requires client-wins.`);
+      conflict = {
+        strategy,
+        ...maxAttempts === undefined ? {} : {
+          maxAttempts: positiveVersion2(maxAttempts, id, `localData.mutations[${index}].conflict.maxAttempts`)
+        }
+      };
+    }
+    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 (onProtectionUnavailable !== undefined && onProtectionUnavailable !== "error" && onProtectionUnavailable !== "memory-only")
+      throw metadataError(id, `localData.mutations[${index}].onProtectionUnavailable 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`),
+      ...conflict ? { conflict } : {},
+      ...sensitivity ? { sensitivity } : {},
+      ...onProtectionUnavailable ? { onProtectionUnavailable } : {},
+      ...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 = join24(resolve20(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 metadata = localSchemaMetadata(manifest);
+    if (metadata === undefined)
+      continue;
+    components.push(component(name, metadata));
+    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 mkdir5, rm as rm4, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname14, join as join25 } 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("//")) {
+    throw new TypeError(`${field} must be an absolute same-origin path.`);
+  }
+  let url;
+  try {
+    url = new URL(input, "https://absolute.invalid");
+  } catch {
+    throw new TypeError(`${field} must be an absolute same-origin path.`);
+  }
+  if (url.origin !== "https://absolute.invalid" || url.search || url.hash || url.pathname === "/") {
+    throw new TypeError(`${field} must be a file path without query or hash.`);
+  }
+  for (const part of input.split("/")) {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(part);
+    } catch {
+      throw new TypeError(`${field} contains invalid URL encoding.`);
+    }
+    if (decoded === "." || decoded === ".." || decoded.includes("\\")) {
+      throw new TypeError(`${field} must not contain traversal segments.`);
+    }
+  }
+  return url.pathname;
+}, destinationFor = (buildPath, publicPath) => join25(buildPath, ...publicPath.split("/").filter(Boolean)), bootstrapEntrySource = ({
+  clientModule,
+  manifestPath,
+  serviceWorkerPath,
+  sync
+}) => `import { registerServiceWorker } from ${JSON.stringify(clientModule)};
+${manifestPath ? `const manifest = document.querySelector('link[rel="manifest"]') ?? document.createElement('link');
+manifest.setAttribute('rel', 'manifest');
+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)}` : ""}
+});
+`, injectionSource = () => `if (typeof window !== 'undefined') {
+	await import(new URL(${JSON.stringify(BOOTSTRAP_PUBLIC_PATH)}, window.location.origin).href);
+}
+`, injectPwaBootstrapHtml = (html) => {
+  if (html.includes(BOOTSTRAP_MARKER))
+    return html;
+  const script = `<script type="module" src="${BOOTSTRAP_PUBLIC_PATH}" ${BOOTSTRAP_MARKER}></script>`;
+  const closingHead = html.toLowerCase().indexOf("</head>");
+  if (closingHead >= 0) {
+    return `${html.slice(0, closingHead)}${script}${html.slice(closingHead)}`;
+  }
+  return `${script}${html}`;
+}, materializeAbsolutePwa = async ({
+  buildPath,
+  config,
+  generatedRoot,
+  projectRoot,
+  write: write2 = true
+}) => {
+  const serviceWorkerPath = publicFilePath(config.serviceWorkerPath, "/sw.js", "pwa.serviceWorkerPath");
+  if (serviceWorkerPath.slice(1).includes("/")) {
+    throw new TypeError("pwa.serviceWorkerPath must be a root-level file so its default service-worker scope covers the application.");
+  }
+  const manifestPath = config.manifest ? publicFilePath(config.manifest.path, "/manifest.webmanifest", "pwa.manifest.path") : undefined;
+  const artifacts = {
+    bootstrapBanner: injectionSource(),
+    bootstrapPublicPath: BOOTSTRAP_PUBLIC_PATH,
+    manifestPath,
+    serviceWorkerPath
+  };
+  if (!write2)
+    return artifacts;
+  const syncSchema = config.sync ? discoverAbsoluteSyncSchema(projectRoot) : undefined;
+  const { createWebAppManifest, pushServiceWorker } = await import("@absolutejs/pwa");
+  const workerDestination = destinationFor(buildPath, serviceWorkerPath);
+  await mkdir5(dirname14(workerDestination), { recursive: true });
+  await writeFile5(workerDestination, `${pushServiceWorker({
+    ...config.serviceWorker ?? {},
+    sync: Boolean(config.sync)
+  })}
+`);
+  if (config.manifest && manifestPath) {
+    const { path: _path, ...manifestConfig } = config.manifest;
+    const manifestDestination = destinationFor(buildPath, manifestPath);
+    await mkdir5(dirname14(manifestDestination), { recursive: true });
+    await writeFile5(manifestDestination, `${JSON.stringify(createWebAppManifest(manifestConfig), null, "\t")}
+`);
+  }
+  const generatedDirectory = join25(generatedRoot, "pwa");
+  const bootstrapEntry = join25(generatedDirectory, "bootstrap.ts");
+  const clientModule = Bun.resolveSync("@absolutejs/pwa/client", import.meta.dir);
+  await mkdir5(generatedDirectory, { recursive: true });
+  await writeFile5(bootstrapEntry, bootstrapEntrySource({
+    clientModule,
+    manifestPath,
+    serviceWorkerPath,
+    sync: config.sync ? {
+      ...config.sync === true ? {} : config.sync,
+      storageSchema: {
+        components: syncSchema?.components ?? []
+      }
+    } : config.sync
+  }));
+  const browserDirectory = destinationFor(buildPath, "/__absolute/pwa");
+  await rm4(browserDirectory, { force: true, recursive: true });
+  await mkdir5(browserDirectory, { recursive: true });
+  const result = await Bun.build({
+    entrypoints: [bootstrapEntry],
+    format: "esm",
+    minify: true,
+    naming: {
+      asset: "asset-[hash].[ext]",
+      chunk: "chunk-[hash].[ext]",
+      entry: "bootstrap.js"
+    },
+    outdir: browserDirectory,
+    splitting: true,
+    target: "browser"
+  });
+  if (!result.success) {
+    throw new AggregateError(result.logs, "Failed to build the AbsoluteJS PWA bootstrap.");
+  }
+  return artifacts;
+};
+var init_pwa = __esm(() => {
+  init_syncSchema();
+});
 // src/build/scanVueSsrOnlyPages.ts
 var exports_scanVueSsrOnlyPages = {};
 __export(exports_scanVueSsrOnlyPages, {
   scanVueSsrOnlyPages: () => scanVueSsrOnlyPages
 });
-import { readdirSync as readdirSync2, readFileSync as readFileSync13 } from "fs";
-import { join as join24 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync14 } from "fs";
+import { join as join26 } from "path";
 import ts8 from "typescript";
 var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind3 = (filePath) => {
   if (filePath.endsWith(".tsx"))
@@ -12888,9 +13451,9 @@ var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind3 = (filePath) => {
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join24(dir, entry.name));
+        stack.push(join26(dir, entry.name));
       } else if (entry.isFile() && hasSourceExtension2(entry.name)) {
-        out.push(join24(dir, entry.name));
+        out.push(join26(dir, entry.name));
       }
     }
   }
@@ -12957,7 +13520,7 @@ var SKIP_DIRS2, SOURCE_EXTENSIONS2, getScriptKind3 = (filePath) => {
 }, extractFromFile = (filePath, out) => {
   let source;
   try {
-    source = readFileSync13(filePath, "utf-8");
+    source = readFileSync14(filePath, "utf-8");
   } catch {
     return;
   }
@@ -13001,8 +13564,8 @@ var init_scanVueSsrOnlyPages = __esm(() => {
 });
 // src/build/scanAngularHandlerCalls.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync14 } from "fs";
-import { join as join25 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync15 } from "fs";
+import { join as join27 } 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"))
@@ -13035,9 +13598,9 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS3, SOURCE_EXTENSIONS3, SERVER_ENTRY_COPY_PRE
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join25(dir, entry.name));
+        stack.push(join27(dir, entry.name));
       } else if (entry.isFile() && !entry.name.startsWith(SERVER_ENTRY_COPY_PREFIX) && hasSourceExtension3(entry.name)) {
-        out.push(join25(dir, entry.name));
+        out.push(join27(dir, entry.name));
       }
     }
   }
@@ -13072,7 +13635,7 @@ var ELYSIA_ROUTE_METHODS2, SKIP_DIRS3, SOURCE_EXTENSIONS3, SERVER_ENTRY_COPY_PRE
 }, extractCallsFromFile = (filePath, out) => {
   let source;
   try {
-    source = readFileSync14(filePath, "utf-8");
+    source = readFileSync15(filePath, "utf-8");
   } catch {
     return;
   }
@@ -13151,8 +13714,8 @@ var init_scanAngularHandlerCalls = __esm(() => {
 });
 // src/build/scanAngularPageRoutes.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync15 } from "fs";
-import { basename as basename9, join as join26 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync16 } from "fs";
+import { basename as basename9, join as join28 } from "path";
 import ts10 from "typescript";
 var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
   const idx = filePath.lastIndexOf(".");
@@ -13192,9 +13755,9 @@ var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
           continue;
         if (entry.name.startsWith("."))
           continue;
-        stack.push(join26(dir, entry.name));
+        stack.push(join28(dir, entry.name));
       } else if (entry.isFile() && isPageFile(entry.name)) {
-        out.push(join26(dir, entry.name));
+        out.push(join28(dir, entry.name));
       }
     }
   }
@@ -13223,7 +13786,7 @@ var SOURCE_EXTENSIONS4, SKIP_DIRS4, hasSourceExtension4 = (filePath) => {
   for (const file of files) {
     let source;
     try {
-      source = readFileSync15(file, "utf-8");
+      source = readFileSync16(file, "utf-8");
     } catch {
       continue;
     }
@@ -13270,8 +13833,8 @@ var exports_parseAngularConfigImports = {};
 __export(exports_parseAngularConfigImports, {
   parseAngularProvidersImport: () => parseAngularProvidersImport
 });
-import { existsSync as existsSync20, readFileSync as readFileSync16 } from "fs";
-import { dirname as dirname13, isAbsolute as isAbsolute3, join as join27 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
+import { dirname as dirname15, isAbsolute as isAbsolute3, join as join29 } from "path";
 import ts11 from "typescript";
 var findDefineConfigCall = (sf) => {
   let result = null;
@@ -13289,8 +13852,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)
@@ -13326,15 +13889,15 @@ var findDefineConfigCall = (sf) => {
 }, resolveConfigPath = (projectRoot) => {
   const envOverride = process.env.ABSOLUTE_CONFIG;
   if (envOverride) {
-    const resolved = isAbsolute3(envOverride) ? envOverride : join27(projectRoot, envOverride);
+    const resolved = isAbsolute3(envOverride) ? envOverride : join29(projectRoot, envOverride);
     if (existsSync20(resolved))
       return resolved;
   }
   const candidates = [
-    join27(projectRoot, "absolute.config.ts"),
-    join27(projectRoot, "absolute.config.mts"),
-    join27(projectRoot, "absolute.config.js"),
-    join27(projectRoot, "absolute.config.mjs")
+    join29(projectRoot, "absolute.config.ts"),
+    join29(projectRoot, "absolute.config.mts"),
+    join29(projectRoot, "absolute.config.js"),
+    join29(projectRoot, "absolute.config.mjs")
   ];
   for (const candidate of candidates) {
     if (existsSync20(candidate))
@@ -13345,7 +13908,7 @@ var findDefineConfigCall = (sf) => {
   const configPath2 = resolveConfigPath(projectRoot);
   if (!configPath2)
     return null;
-  const source = readFileSync16(configPath2, "utf-8");
+  const source = readFileSync17(configPath2, "utf-8");
   if (!source.includes("angular"))
     return null;
   if (!source.includes("providers"))
@@ -13366,8 +13929,8 @@ var findDefineConfigCall = (sf) => {
   const importInfo = findImportForBinding(sf, binding);
   if (!importInfo)
     return null;
-  const configDir2 = dirname13(configPath2);
-  const absolutePath = importInfo.source.startsWith(".") ? join27(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
+  const configDir2 = dirname15(configPath2);
+  const absolutePath = importInfo.source.startsWith(".") ? join29(configDir2, importInfo.source).replace(/\.[cm]?[tj]sx?$/, "") : isAbsolute3(importInfo.source) ? importInfo.source.replace(/\.[cm]?[tj]sx?$/, "") : importInfo.source;
   return {
     absolutePath,
     bindingName: binding,
@@ -13382,8 +13945,8 @@ var islandFrameworks2, islandHydrationModes2, isIslandFramework2 = (value) => is
   const componentMatch = attributeString.match(/\bcomponent\s*=\s*["']([^"']+)["']/);
   const hydrateMatch = attributeString.match(/\bhydrate\s*=\s*["']([^"']+)["']/);
   const framework = frameworkMatch?.[1];
-  const component = componentMatch?.[1];
-  if (!framework || !component) {
+  const component2 = componentMatch?.[1];
+  if (!framework || !component2) {
     return null;
   }
   if (!isIslandFramework2(framework)) {
@@ -13391,7 +13954,7 @@ var islandFrameworks2, islandHydrationModes2, isIslandFramework2 = (value) => is
   }
   const hydrateCandidate = hydrateMatch?.[1];
   return {
-    component,
+    component: component2,
     framework,
     hydrate: hydrateCandidate && isIslandHydrate(hydrateCandidate) ? hydrateCandidate : undefined
   };
@@ -13400,12 +13963,12 @@ var islandFrameworks2, islandHydrationModes2, isIslandFramework2 = (value) => is
     return;
   usageMap.set(normalizeUsage(usage), usage);
 }, addRenderCallUsage = (usageMap, match) => {
-  const [, framework, component, hydrate] = match;
-  if (!framework || !component || !isIslandFramework2(framework)) {
+  const [, framework, component2, hydrate] = match;
+  if (!framework || !component2 || !isIslandFramework2(framework)) {
     return;
   }
   addUsage(usageMap, {
-    component,
+    component: component2,
     framework,
     hydrate: hydrate && isIslandHydrate(hydrate) ? hydrate : undefined
   });
@@ -13459,7 +14022,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 = [],
@@ -13473,7 +14036,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("");
@@ -13516,13 +14079,13 @@ __export(exports_compileSvelte, {
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
 import { existsSync as existsSync21 } from "fs";
-import { mkdir as mkdir5, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir6, stat as stat2 } from "fs/promises";
 import {
-  dirname as dirname14,
-  join as join28,
+  dirname as dirname16,
+  join as join30,
   basename as basename10,
   extname as extname7,
-  resolve as resolve20,
+  resolve as resolve21,
   relative as relative11,
   sep as sep2
 } from "path";
@@ -13530,14 +14093,14 @@ import { env } from "process";
 var {write: write2, file, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve20(import.meta.dir, "../dev/client");
+  const fromSource = resolve21(import.meta.dir, "../dev/client");
   if (existsSync21(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve20(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve21(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync21(fromNodeModules))
     return fromNodeModules;
-  return resolve20(import.meta.dir, "./dev/client");
+  return resolve21(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
@@ -13567,7 +14130,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve20(dirname14(from), spec);
+  const basePath = resolve21(dirname16(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -13578,14 +14141,14 @@ var resolveDevClientDir2 = () => {
     `${basePath}.svelte`,
     `${basePath}.svelte.ts`,
     `${basePath}.svelte.js`,
-    join28(basePath, "index.ts"),
-    join28(basePath, "index.js"),
-    join28(basePath, "index.mjs"),
-    join28(basePath, "index.cjs"),
-    join28(basePath, "index.json"),
-    join28(basePath, "index.svelte"),
-    join28(basePath, "index.svelte.ts"),
-    join28(basePath, "index.svelte.js")
+    join30(basePath, "index.ts"),
+    join30(basePath, "index.js"),
+    join30(basePath, "index.mjs"),
+    join30(basePath, "index.cjs"),
+    join30(basePath, "index.json"),
+    join30(basePath, "index.svelte"),
+    join30(basePath, "index.svelte.ts"),
+    join30(basePath, "index.svelte.js")
   ];
   const checks = await Promise.all(candidates.map(exists));
   return candidates.find((_2, index) => checks[index]) ?? null;
@@ -13594,7 +14157,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve20(dirname14(from), spec);
+  const basePath = resolve21(dirname16(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -13624,10 +14187,10 @@ 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 = join28(generatedDir, "client");
-  const indexDir = join28(generatedDir, "indexes");
-  const serverDir = join28(generatedDir, "server");
-  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir5(dir, { recursive: true })));
+  const clientDir = join30(generatedDir, "client");
+  const indexDir = join30(generatedDir, "indexes");
+  const serverDir = join30(generatedDir, "server");
+  await Promise.all([clientDir, indexDir, serverDir].map((dir) => mkdir6(dir, { recursive: true })));
   const dev = env.NODE_ENV !== "production";
   const build = async (src) => {
     const memoized = cache.get(src);
@@ -13654,8 +14217,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 = dirname14(relative11(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative11(process.cwd(), dirname14(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname16(relative11(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative11(process.cwd(), dirname16(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)));
@@ -13664,8 +14227,8 @@ var resolveDevClientDir2 = () => {
     const childBuilt = await Promise.all(childSources.map((child) => build(child)));
     const hasAwaitSlotFromChildren = childBuilt.some((child) => child.hasAwaitSlot);
     const externalRewrites = new Map;
-    const ssrOutputDir = dirname14(join28(serverDir, relDir, `${baseName}.js`));
-    const clientOutputDir = dirname14(join28(clientDir, relDir, `${baseName}.js`));
+    const ssrOutputDir = dirname16(join30(serverDir, relDir, `${baseName}.js`));
+    const clientOutputDir = dirname16(join30(clientDir, relDir, `${baseName}.js`));
     for (let idx = 0;idx < importPaths.length; idx++) {
       const rawSpec = importPaths[idx];
       if (!rawSpec)
@@ -13730,11 +14293,11 @@ var resolveDevClientDir2 = () => {
       code += islandMetadataExports;
       return { code, map: compiledJs.map };
     };
-    const ssrPath = join28(serverDir, relDir, `${baseName}.js`);
-    const clientPath = join28(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join30(serverDir, relDir, `${baseName}.js`);
+    const clientPath = join30(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir5(dirname14(ssrPath), { recursive: true }),
-      mkdir5(dirname14(clientPath), { recursive: true })
+      mkdir6(dirname16(ssrPath), { recursive: true }),
+      mkdir6(dirname16(clientPath), { recursive: true })
     ]);
     const inlineMap = (map) => map ? `
 //# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}
@@ -13769,10 +14332,10 @@ var resolveDevClientDir2 = () => {
   const roots = await Promise.all(entryPoints.map(build));
   const componentRoots = roots.filter((root) => !root.isModule);
   await Promise.all(componentRoots.map(async ({ client, hasAwaitSlot }) => {
-    const relClientDir = dirname14(relative11(clientDir, client));
+    const relClientDir = dirname16(relative11(clientDir, client));
     const name = basename10(client, extname7(client));
-    const indexPath = join28(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative11(dirname14(indexPath), client).split(sep2).join("/");
+    const indexPath = join30(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative11(dirname16(indexPath), client).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -13783,8 +14346,9 @@ import { hydrate, mount, unmount } from "svelte";
 var initialProps = (typeof window !== "undefined" && window.__INITIAL_PROPS__) ? window.__INITIAL_PROPS__ : {};
 var isHMR = typeof window !== "undefined" && window.__SVELTE_COMPONENT__ !== undefined;
 var isSsrDirty = typeof window !== "undefined" && window.__SSR_DIRTY__;
+var isClientRender = typeof window !== "undefined" && window.__ABSOLUTE_PAGE_RENDER_MODE__ === "client";
 var hasIslandHtml = false;
-var shouldHydrate = typeof window === "undefined" ? false : ${hasAwaitSlot ? "false" : "true"};
+var shouldHydrate = typeof window === "undefined" || isClientRender ? false : ${hasAwaitSlot ? "false" : "true"};
 var component;
 var target = document.getElementById(${JSON.stringify(SVELTE_PAGE_ROOT_ID)}) || document.body;
@@ -13815,6 +14379,8 @@ if (isHMR) {
   }
   component = mount(Component, { target, props: mergedProps });
   window.__HMR_PRESERVED_STATE__ = undefined;
+} else if (isClientRender) {
+  component = mount(Component, { target, props: initialProps });
 } else if (!shouldHydrate) {
   component = undefined;
 } else if (isSsrDirty || hasIslandHtml) {
@@ -13826,6 +14392,13 @@ if (isHMR) {
 if (typeof window !== "undefined") {
   window.__SVELTE_COMPONENT__ = component;
   window.__SVELTE_UNMOUNT__ = function() { if (component) { unmount(component); } };
+  window.__ABSOLUTE_PAGE_READY__ = Promise.resolve();
+  window.__ABSOLUTE_PAGE_DISPOSE__ = function() {
+    if (component) { unmount(component); }
+    component = undefined;
+    window.__SVELTE_COMPONENT__ = undefined;
+    window.__SVELTE_UNMOUNT__ = undefined;
+  };
   window.__SVELTE_REMOUNT__ = function(props) {
     if (typeof window.__SVELTE_UNMOUNT__ === "function") {
       try { window.__SVELTE_UNMOUNT__(); } catch (err) { /* ignore */ }
@@ -13851,14 +14424,14 @@ if (typeof window !== "undefined") {
     setTimeout(releaseStreamingSlots, 0);
   }
 }`;
-    await mkdir5(dirname14(indexPath), { recursive: true });
+    await mkdir6(dirname16(indexPath), { recursive: true });
     return write2(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client }) => client),
     svelteIndexPaths: componentRoots.map(({ client }) => {
-      const rel = dirname14(relative11(clientDir, client));
-      return join28(indexDir, rel, basename10(client));
+      const rel = dirname16(relative11(clientDir, client));
+      return join30(indexDir, rel, basename10(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -13873,7 +14446,7 @@ var init_compileSvelte = __esm(() => {
   init_lowerAwaitSlotSyntax();
   init_renderToReadableStream();
   devClientDir2 = resolveDevClientDir2();
-  hmrClientPath3 = join28(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath3 = join30(devClientDir2, "hmrClient.ts").replace(/\\/g, "/");
   persistentCache = new Map;
   sourceHashCache = new Map;
   transpiler3 = new Transpiler2({ loader: "ts", target: "browser" });
@@ -13940,7 +14513,7 @@ __export(exports_chainInlineSourcemaps, {
   chainBundleInlineSourcemap: () => chainBundleInlineSourcemap,
   buildLineRemap: () => buildLineRemap
 });
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "fs";
 var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", BASE64_TO_INT, decodeVlq = (str, startPos) => {
   let result = 0;
   let shift = 0;
@@ -14231,7 +14804,7 @@ var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567
     version: 3
   };
 }, chainBundleInlineSourcemap = (bundleFilePath) => {
-  const text = readFileSync17(bundleFilePath, "utf-8");
+  const text = readFileSync18(bundleFilePath, "utf-8");
   const outerMap = extractInlineMap(text);
   if (!outerMap)
     return;
@@ -14251,7 +14824,7 @@ var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567
 }, chainExternalSourcemap = (mapFilePath) => {
   let outerMap;
   try {
-    outerMap = JSON.parse(readFileSync17(mapFilePath, "utf-8"));
+    outerMap = JSON.parse(readFileSync18(mapFilePath, "utf-8"));
   } catch {
     return;
   }
@@ -14350,27 +14923,27 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
-import { existsSync as existsSync22, readFileSync as readFileSync18, realpathSync as realpathSync2 } from "fs";
-import { mkdir as mkdir6 } from "fs/promises";
+import { existsSync as existsSync22, readFileSync as readFileSync19, realpathSync as realpathSync2 } from "fs";
+import { mkdir as mkdir7 } from "fs/promises";
 import {
   basename as basename11,
-  dirname as dirname15,
+  dirname as dirname17,
   isAbsolute as isAbsolute4,
-  join as join29,
+  join as join31,
   relative as relative12,
-  resolve as resolve21
+  resolve as resolve22
 } from "path";
 var {file: file2, write: write3, Transpiler: Transpiler3 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve21(import.meta.dir, "../dev/client");
+  const fromSource = resolve22(import.meta.dir, "../dev/client");
   if (existsSync22(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve21(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve22(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync22(fromNodeModules))
     return fromNodeModules;
-  return resolve21(import.meta.dir, "./dev/client");
+  return resolve22(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler4, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -14420,19 +14993,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 = resolve21(dirname15(cssFilePath), relPath);
+    const importedPath = resolve22(dirname17(cssFilePath), relPath);
     if (!existsSync22(importedPath))
       return match;
-    const importedContent = readFileSync18(importedPath, "utf-8");
+    const importedContent = readFileSync19(importedPath, "utf-8");
     return inlineCssImports(importedContent, importedPath, visited);
   });
 }, resolveHelperTsPath = (sourceDir, helper) => {
   if (helper.endsWith(".ts"))
-    return resolve21(sourceDir, helper);
-  const direct = resolve21(sourceDir, `${helper}.ts`);
+    return resolve22(sourceDir, helper);
+  const direct = resolve22(sourceDir, `${helper}.ts`);
   if (existsSync22(direct))
     return direct;
-  const indexed = resolve21(sourceDir, helper, "index.ts");
+  const indexed = resolve22(sourceDir, helper, "index.ts");
   if (existsSync22(indexed))
     return indexed;
   return direct;
@@ -14443,15 +15016,15 @@ var resolveDevClientDir3 = () => {
     return filePath.replace(/\.ts$/, ".js");
   if (isStylePath(filePath)) {
     if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-      return resolve21(sourceDir, filePath);
+      return resolve22(sourceDir, filePath);
     }
     return filePath;
   }
   if (sourceDir && (filePath.startsWith("./") || filePath.startsWith("../"))) {
-    const directTs = resolve21(sourceDir, `${filePath}.ts`);
+    const directTs = resolve22(sourceDir, `${filePath}.ts`);
     if (existsSync22(directTs))
       return `${filePath}.js`;
-    const indexedTs = resolve21(sourceDir, filePath, "index.ts");
+    const indexedTs = resolve22(sourceDir, filePath, "index.ts");
     if (existsSync22(indexedTs))
       return `${filePath}/index.js`;
   }
@@ -14542,19 +15115,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 : resolve21(dirname15(sourceFilePath), path));
+  const stylePathsImported = importPaths.filter((path) => (path.startsWith(".") || isAbsolute4(path)) && isStylePath(path)).map((path) => isAbsolute4(path) ? path : resolve22(dirname17(sourceFilePath), path));
   for (const stylePath of stylePathsImported) {
     addStyleImporter(sourceFilePath, stylePath);
   }
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve21(dirname15(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve22(dirname17(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: existsSync22,
-      readFile: (file3) => existsSync22(file3) ? readFileSync18(file3, "utf-8") : undefined,
+      readFile: (file3) => existsSync22(file3) ? readFileSync19(file3, "utf-8") : undefined,
       realpath: realpathSync2
     },
     id: componentId,
@@ -14562,7 +15135,7 @@ const ${localName} = (source) => ${importedName}(
     sourceMap: true
   }) : { bindings: {}, content: "export default {};", map: undefined };
   const strippedScript = stripExports2(compiledScript.content);
-  const sourceDir = dirname15(sourceFilePath);
+  const sourceDir = dirname17(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) {
@@ -14607,8 +15180,8 @@ const ${localName} = (source) => ${importedName}(
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join29(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
-    await mkdir6(dirname15(cssOutputFile), { recursive: true });
+    const cssOutputFile = join31(outputDirs.css, `${toKebab(fileBaseName)}-compiled.css`);
+    await mkdir7(dirname17(cssOutputFile), { recursive: true });
     await write3(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -14638,21 +15211,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 = join29(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join29(outputDirs.server, `${relativeWithoutExtension}.js`);
+  const clientOutputPath = join31(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join31(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(dirname15(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative12(dirname17(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
     }
     return result2;
   };
-  await mkdir6(dirname15(clientOutputPath), { recursive: true });
-  await mkdir6(dirname15(serverOutputPath), { recursive: true });
+  await mkdir7(dirname17(clientOutputPath), { recursive: true });
+  await mkdir7(dirname17(serverOutputPath), { recursive: true });
   const clientFinal = rewritePackageImports(clientCode, clientOutputPath, "client");
   const serverFinal = rewritePackageImports(serverCode, serverOutputPath, "server");
   const inlineSourceMapFor = (finalContent) => {
@@ -14675,7 +15248,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     serverPath: serverOutputPath,
     spaRoutes: spaRoutes.length > 0 ? spaRoutes : undefined,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolveHelperTsPath(dirname15(sourceFilePath), helper)),
+      ...helperModulePaths.map((helper) => resolveHelperTsPath(dirname17(sourceFilePath), helper)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -14685,20 +15258,20 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
 }, compileVue = async (entryPoints, vueRootDir, isDev2 = false, stylePreprocessors, ssrOnlyEntries) => {
   const compiler = await loadVueCompiler();
   const generatedDir = getFrameworkGeneratedDir("vue");
-  const clientOutputDir = join29(generatedDir, "client");
-  const indexOutputDir = join29(generatedDir, "indexes");
-  const serverOutputDir = join29(generatedDir, "server");
-  const cssOutputDir = join29(generatedDir, "compiled");
+  const clientOutputDir = join31(generatedDir, "client");
+  const indexOutputDir = join31(generatedDir, "indexes");
+  const serverOutputDir = join31(generatedDir, "server");
+  const cssOutputDir = join31(generatedDir, "compiled");
   await Promise.all([
-    mkdir6(clientOutputDir, { recursive: true }),
-    mkdir6(indexOutputDir, { recursive: true }),
-    mkdir6(serverOutputDir, { recursive: true }),
-    mkdir6(cssOutputDir, { recursive: true })
+    mkdir7(clientOutputDir, { recursive: true }),
+    mkdir7(indexOutputDir, { recursive: true }),
+    mkdir7(serverOutputDir, { recursive: true }),
+    mkdir7(cssOutputDir, { recursive: true })
   ]);
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const expandSpaRouteChildren = async (entries) => {
-    const expanded = new Set(entries.map((entry) => resolve21(entry)));
+    const expanded = new Set(entries.map((entry) => resolve22(entry)));
     const queue2 = [...expanded];
     while (queue2.length > 0) {
       const entryPath = queue2.pop();
@@ -14715,7 +15288,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       });
       const routes = parseVueSpaRoutes(descriptor.script?.content ?? "");
       for (const { importPath } of routes) {
-        const childPath = resolve21(dirname15(entryPath), importPath);
+        const childPath = resolve22(dirname17(entryPath), importPath);
         if (expanded.has(childPath) || !existsSync22(childPath)) {
           continue;
         }
@@ -14727,7 +15300,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   };
   const expandedEntryPoints = await expandSpaRouteChildren(entryPoints);
   const compiledPages = await Promise.all(expandedEntryPoints.map(async (entryPath) => {
-    const resolvedEntryPath = resolve21(entryPath);
+    const resolvedEntryPath = resolve22(entryPath);
     const result = await compileVueFile(resolvedEntryPath, {
       client: clientOutputDir,
       css: cssOutputDir,
@@ -14745,16 +15318,16 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       };
     }
     const entryBaseName = basename11(entryPath, ".vue");
-    const indexOutputFile = join29(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join29(clientOutputDir, relative12(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir6(dirname15(indexOutputFile), { recursive: true });
+    const indexOutputFile = join31(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join31(clientOutputDir, relative12(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir7(dirname17(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
       `import "${hmrClientPath4}";`
     ] : [];
     await write3(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp, * as PageModule from "${relative12(dirname15(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp, * as PageModule from "${relative12(dirname17(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -14801,7 +15374,8 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       "// client-side navigation after mount.",
       'const isHMR = typeof window !== "undefined" && sessionStorage.getItem("__HMR_ACTIVE__");',
       'const isSsrDirty = typeof window !== "undefined" && window.__SSR_DIRTY__;',
-      'const shouldHydrate = typeof window === "undefined" ? false : !(isHMR || isSsrDirty || hasSpaRoutes);',
+      'const isClientRender = typeof window !== "undefined" && window.__ABSOLUTE_PAGE_RENDER_MODE__ === "client";',
+      'const shouldHydrate = typeof window === "undefined" ? false : !(isHMR || isSsrDirty || hasSpaRoutes || isClientRender);',
       "const app = shouldHydrate ? createSSRApp(Comp, mergedProps) : createApp(Comp, mergedProps);",
       "",
       "async function bootstrapApp() {",
@@ -14819,11 +15393,17 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
       "  }",
       '  app.mount("#root");',
       "}",
-      "bootstrapApp();",
+      "const absolutePageReady = bootstrapApp();",
       "",
       "// Store app instance for HMR - used for manual component updates",
       'if (typeof window !== "undefined") {',
       "  window.__VUE_APP__ = app;",
+      "  window.__ABSOLUTE_PAGE_READY__ = absolutePageReady;",
+      "  window.__ABSOLUTE_PAGE_DISPOSE__ = async function() {",
+      "    await absolutePageReady;",
+      "    app.unmount();",
+      "    window.__VUE_APP__ = undefined;",
+      "  };",
       "}",
       "",
       "// Post-mount: Apply preserved state to reactive refs in component tree",
@@ -14909,7 +15489,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     if (!tsPath)
       continue;
     const sourceCode = await file2(tsPath).text();
-    const helperDir = dirname15(tsPath);
+    const helperDir = dirname17(tsPath);
     for (const dep of extractImports(sourceCode)) {
       if (!dep.startsWith(".") || isStylePath(dep) || dep.endsWith(".vue")) {
         continue;
@@ -14928,10 +15508,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 = join29(clientOutputDir, relativeJsPath);
-    const outServerPath = join29(serverOutputDir, relativeJsPath);
-    await mkdir6(dirname15(outClientPath), { recursive: true });
-    await mkdir6(dirname15(outServerPath), { recursive: true });
+    const outClientPath = join31(clientOutputDir, relativeJsPath);
+    const outServerPath = join31(serverOutputDir, relativeJsPath);
+    await mkdir7(dirname17(outClientPath), { recursive: true });
+    await mkdir7(dirname17(outServerPath), { recursive: true });
     await write3(outClientPath, withMap);
     await write3(outServerPath, withMap);
   }));
@@ -14961,7 +15541,7 @@ var init_compileVue = __esm(() => {
   init_vueAutoRouterTransform();
   init_stylePreprocessor();
   devClientDir3 = resolveDevClientDir3();
-  hmrClientPath4 = join29(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath4 = join31(devClientDir3, "hmrClient.ts").replace(/\\/g, "/");
   transpiler4 = new Transpiler3({ loader: "ts", target: "browser" });
   scriptCache = new Map;
   scriptSetupCache = new Map;
@@ -15442,8 +16022,8 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync23, readFileSync as readFileSync19, promises as fs5 } from "fs";
-import { join as join30, basename as basename12, sep as sep3, dirname as dirname16, resolve as resolve22, relative as relative13 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync20, promises as fs5 } from "fs";
+import { join as join32, basename as basename12, sep as sep3, dirname as dirname18, resolve as resolve23, relative as relative13 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
 import ts13 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata) => {
@@ -15451,10 +16031,10 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath2 = resolve22(process.cwd(), "tsconfig.json");
+    const configPath2 = resolve23(process.cwd(), "tsconfig.json");
     const config = ts13.readConfigFile(configPath2, ts13.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve22(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve23(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -15474,7 +16054,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     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(resolve22(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve23(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -15486,20 +16066,20 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join30(candidate, "index.ts"),
-    join30(candidate, "index.tsx"),
-    join30(candidate, "index.js"),
-    join30(candidate, "index.jsx")
+    join32(candidate, "index.ts"),
+    join32(candidate, "index.tsx"),
+    join32(candidate, "index.js"),
+    join32(candidate, "index.jsx")
   ];
   return candidates.find((file3) => existsSync23(file3));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve22(rootDir);
+  const baseDir = resolve23(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(resolve22(fromDir, specifier));
+      return resolveSourceFile(resolve23(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -15508,7 +16088,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve22(resolved);
+      const absolute = resolve23(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -15524,7 +16104,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve22(actualPath);
+    const resolved = resolve23(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -15553,7 +16133,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve22(actualPath);
+    const resolved = resolve23(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -15561,7 +16141,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname16(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname18(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -15571,14 +16151,14 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve22(import.meta.dir, "../dev/client");
+  const fromSource = resolve23(import.meta.dir, "../dev/client");
   if (existsSync23(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve22(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve23(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync23(fromNodeModules))
     return fromNodeModules;
-  return resolve22(import.meta.dir, "./dev/client");
+  return resolve23(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts13.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -15620,12 +16200,12 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname16(importerOutputPath);
-  const fileCandidate = resolve22(importerDir, `${path}.js`);
+  const importerDir = dirname18(importerOutputPath);
+  const fileCandidate = resolve23(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync23(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve22(importerDir, path, "index.js");
+  const indexCandidate = resolve23(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync23(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -15653,18 +16233,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve22(dirname16(fromFile), specifier);
+  const basePath = resolve23(dirname18(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join30(basePath, "index.ts"),
-    join30(basePath, "index.tsx"),
-    join30(basePath, "index.mts"),
-    join30(basePath, "index.cts")
+    join32(basePath, "index.ts"),
+    join32(basePath, "index.tsx"),
+    join32(basePath, "index.mts"),
+    join32(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve22(candidate)).find((candidate) => existsSync23(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve23(candidate)).find((candidate) => existsSync23(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile6) => {
   const hostSource = readFile6?.(fileName);
   if (typeof hostSource === "string")
@@ -15688,18 +16268,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join30(fileDir, templateUrlMatch[1]));
+    paths.push(join32(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join30(fileDir, styleUrlMatch[1]));
+    paths.push(join32(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(join30(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join32(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve22(path));
+  return paths.map((path) => resolve23(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs5.readFile(cachePath, "utf-8"));
@@ -15711,13 +16291,13 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs5.mkdir(dirname16(cachePath), { recursive: true });
+  await fs5.mkdir(dirname18(cachePath), { recursive: true });
   await fs5.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname16(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname18(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs5.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -15730,7 +16310,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey2 = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join30(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
+  return join32(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey2}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile6, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -15741,7 +16321,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve22(filePath);
+    const resolvedPath = resolve23(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -15757,7 +16337,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname16(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname18(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -15776,18 +16356,18 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve22(join30(outDir, relative13(process.cwd(), resolve22(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve23(join32(outDir, relative13(process.cwd(), resolve23(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
-      buildIslandMetadataExports(readFileSync19(inputPath, "utf-8"))
+      buildIslandMetadataExports(readFileSync20(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 = dirname16(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve22(tsRootDir, "lib");
+    const tsRootDir = dirname18(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve23(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -15812,30 +16392,30 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   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 = join30(tsLibDir, fileName);
-      return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
+      const resolvedPath = join32(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 = resolve22(outDir);
-  host.writeFile = (fileName, text) => {
+  const resolvedOutDir = resolve23(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;
   }, {
@@ -15844,43 +16424,43 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     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 = resolve22(fileName);
+    const resolvedPath = resolve23(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
-  const originalGetSourceFileForCompile = host.getSourceFile;
-  host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve22(fileName));
+  const originalGetSourceFileForCompile = host2.getSourceFile;
+  host2.getSourceFile = (fileName, languageVersion, onError) => {
+    const source = transformedSources.get(resolve23(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: join30(outDir, fileName)
+      target: join32(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve22(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve23(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -15895,17 +16475,17 @@ var traceAngularPhase = async (name, fn2, metadata) => {
         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(resolve22(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve23(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs5.mkdir(dirname16(target), { recursive: true });
+    await fs5.mkdir(dirname18(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(resolve22(filePath));
+  jitContentCache.delete(resolve23(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;
@@ -15918,7 +16498,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve22(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve23(import.meta.dir, "../angular/components/index.ts");
   if (existsSync23(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -16055,7 +16635,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join30(fileDir, templateUrlMatch[1]);
+    const templatePath = join32(fileDir, templateUrlMatch[1]);
     if (!existsSync23(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -16086,11 +16666,11 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join30(fileDir, templateUrlMatch[1]);
+    const templatePath = join32(fileDir, templateUrlMatch[1]);
     if (!existsSync23(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
-    const templateRaw2 = readFileSync19(templatePath, "utf-8");
+    const templateRaw2 = readFileSync20(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);
@@ -16123,7 +16703,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join30(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join32(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -16134,7 +16714,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join30(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join32(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -16208,10 +16788,10 @@ ${fields}
     return "";
   }
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve22(inputPath);
+  const entryPath = resolve23(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve22(rootDir ?? process.cwd());
+  const baseDir = resolve23(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -16230,16 +16810,16 @@ ${fields}
       `${candidate}.js`,
       `${candidate}.jsx`,
       `${candidate}.json`,
-      join30(candidate, "index.ts"),
-      join30(candidate, "index.tsx"),
-      join30(candidate, "index.js"),
-      join30(candidate, "index.jsx")
+      join32(candidate, "index.ts"),
+      join32(candidate, "index.tsx"),
+      join32(candidate, "index.js"),
+      join32(candidate, "index.jsx")
     ];
     return candidates.find((file3) => existsSync23(file3));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve22(fromDir, specifier));
+      return resolveSourceFile2(resolve23(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -16248,7 +16828,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve22(resolved);
+      const absolute = resolve23(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -16257,13 +16837,13 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname16(sourcePath);
+    const inputDir = dirname18(sourcePath);
     const fileBase = basename12(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
     if (inputDir === outDir || inputDir.startsWith(`${outDir}${sep3}`)) {
-      return join30(inputDir, fileBase);
+      return join32(inputDir, fileBase);
     }
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    return join30(outDir, relativeDir, fileBase);
+    return join32(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -16300,21 +16880,21 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve22(actualPath) === entryPath) {
+    if (resolve23(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve22(filePath);
+    const resolved = resolve23(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
     if (resolved.endsWith(".json") && existsSync23(resolved)) {
-      const inputDir2 = dirname16(resolved);
+      const inputDir2 = dirname18(resolved);
       const relativeDir2 = inputDir2.startsWith(baseDir) ? inputDir2.substring(baseDir.length + 1) : inputDir2;
-      const targetDir2 = join30(outDir, relativeDir2);
-      const targetPath2 = join30(targetDir2, basename12(resolved));
+      const targetDir2 = join32(outDir, relativeDir2);
+      const targetPath2 = join32(targetDir2, basename12(resolved));
       await fs5.mkdir(targetDir2, { recursive: true });
       await fs5.copyFile(resolved, targetPath2);
       allOutputs.push(targetPath2);
@@ -16326,12 +16906,12 @@ ${fields}
     if (!existsSync23(actualPath))
       return;
     let sourceCode = await fs5.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname16(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname16(actualPath)).source;
-    const inputDir = dirname16(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname18(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname18(actualPath)).source;
+    const inputDir = dirname18(actualPath);
     const fileBase = basename12(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
     const targetPath = toOutputPath(actualPath);
-    const targetDir = dirname16(targetPath);
+    const targetDir = dirname18(targetPath);
     const relativeDir = relative13(outDir, targetDir).replace(/\\/g, "/");
     const localImports = [];
     const importRewrites = new Map;
@@ -16358,7 +16938,7 @@ ${fields}
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve22(actualPath) === resolve22(entryPath);
+    const isEntry = resolve23(actualPath) === resolve23(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey2) !== contentHash || !existsSync23(targetPath);
@@ -16393,13 +16973,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join30(compiledParent, "indexes");
+  const indexesDir = join32(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) => resolve22(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve23(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   if (!hmr) {
     await traceAngularPhase("aot/copy-json-resources", async () => {
       const cwd = process.cwd();
-      const angularSrcDir = resolve22(outRoot);
+      const angularSrcDir = resolve23(outRoot);
       if (!existsSync23(angularSrcDir))
         return;
       const jsonGlob = new Glob6("**/*.json");
@@ -16407,17 +16987,17 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
         absolute: false,
         cwd: angularSrcDir
       })) {
-        const sourcePath = join30(angularSrcDir, rel);
+        const sourcePath = join32(angularSrcDir, rel);
         const cwdRel = relative13(cwd, sourcePath);
-        const targetPath = join30(compiledRoot, cwdRel);
-        await fs5.mkdir(dirname16(targetPath), { recursive: true });
+        const targetPath = join32(compiledRoot, cwdRel);
+        await fs5.mkdir(dirname18(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 = resolve22(entry);
+    const resolvedEntry = resolve23(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, {
@@ -16426,13 +17006,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename12(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join30(compiledRoot, relativeEntry),
-      join30(compiledRoot, "pages", jsName),
-      join30(compiledRoot, jsName)
-    ].map((file3) => resolve22(file3));
+      join32(compiledRoot, relativeEntry),
+      join32(compiledRoot, "pages", jsName),
+      join32(compiledRoot, jsName)
+    ].map((file3) => resolve23(file3));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file3) => resolve22(file3)),
+        ...candidatePaths.map((file3) => resolve23(file3)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file3) => existsSync23(file3) && file3.endsWith(`${sep3}${relativeEntry}`));
@@ -16479,7 +17059,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       let providersSourceContent = "";
       if (providersInjection.appProvidersSource) {
         try {
-          providersSourceContent = readFileSync19(providersInjection.appProvidersSource, "utf-8");
+          providersSourceContent = readFileSync20(providersInjection.appProvidersSource, "utf-8");
         } catch {}
       }
       return JSON.stringify({
@@ -16490,7 +17070,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 = join30(indexesDir, jsName);
+    const clientFile = join32(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync23(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -16522,13 +17102,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
       const fragments = [];
       if (providersInjection.appProvidersSource) {
         const compiledAppProvidersPath = (() => {
-          const angularDirAbs = resolve22(outRoot);
-          const appSourceAbs = resolve22(providersInjection.appProvidersSource);
+          const angularDirAbs = resolve23(outRoot);
+          const appSourceAbs = resolve23(providersInjection.appProvidersSource);
           const rel = relative13(angularDirAbs, appSourceAbs).replace(/\\/g, "/");
-          return join30(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
+          return join32(compiledParent, rel).replace(/\.[cm]?[tj]sx?$/, ".js");
         })();
         const appProvidersSpec = (() => {
-          const rel = relative13(dirname16(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
+          const rel = relative13(dirname18(rawServerFile), compiledAppProvidersPath).replace(/\\/g, "/");
           return rel.startsWith(".") ? rel : `./${rel}`;
         })();
         importLines.push(`import { appProviders as __abs_globalProviders } from "${appProvidersSpec}";`);
@@ -16576,6 +17156,7 @@ var requestContext = Object.prototype.hasOwnProperty.call(window, '__ABS_ANGULAR
 var pageHasIslands = Boolean(pageModule.__ABSOLUTE_PAGE_HAS_ISLANDS__) || Boolean(document.querySelector('[data-island="true"]'));
 var pageHasRawStreamingSlots = Boolean(document.querySelector('[data-absolute-raw-slot="true"]'));
 var pageHasStreamingSlots = Boolean(document.querySelector('[data-absolute-slot="true"]'));
+var isClientRender = window.__ABSOLUTE_PAGE_RENDER_MODE__ === 'client';
 var contextProviders = [{ provide: REQUEST_CONTEXT, useValue: requestContext }];
 // Page-level providers are injected directly into the page module's
 // server output by \`compileAngular\`'s providers-injection step
@@ -16626,13 +17207,14 @@ if (!document.querySelector(_sel)) {
 }
 var providers = [provideZonelessChangeDetection()];
-if (!window.__HMR_SKIP_HYDRATION__ && !pageHasIslands) {
+if (!isClientRender && !window.__HMR_SKIP_HYDRATION__ && !pageHasIslands) {
     providers.push(provideClientHydration(withHttpTransferCacheOptions(absoluteHttpTransferCacheOptions)));
 }
 delete window.__HMR_SKIP_HYDRATION__;
 providers.push.apply(providers, pageProviders);
 providers.push.apply(providers, contextProviders);
 window.__ABS_SLOT_HYDRATION_PENDING__ = pageHasRawStreamingSlots;
+var absolutePageReady = Promise.resolve();
 if (pageHasRawStreamingSlots) {
     window.__ABS_SLOT_HYDRATION_PENDING__ = false;
@@ -16642,7 +17224,7 @@ if (pageHasRawStreamingSlots) {
         });
     }
 } else {
-    bootstrapApplication(${componentClassName}, {
+    absolutePageReady = bootstrapApplication(${componentClassName}, {
         providers: providers
     }).then(function (appRef) {
         window.__ANGULAR_APP__ = appRef;
@@ -16652,8 +17234,17 @@ if (pageHasRawStreamingSlots) {
                 window.__ABS_SLOT_FLUSH__();
             });
         }
+        return appRef;
     });
 }
+window.__ABSOLUTE_PAGE_READY__ = absolutePageReady;
+window.__ABSOLUTE_PAGE_DISPOSE__ = async function() {
+    await absolutePageReady;
+    if (window.__ANGULAR_APP__) {
+        window.__ANGULAR_APP__.destroy();
+        window.__ANGULAR_APP__ = null;
+    }
+};
 `.trim() : `
 import '@angular/compiler';
 import { bootstrapApplication } from '@angular/platform-browser';
@@ -16672,6 +17263,7 @@ var requestContext = Object.prototype.hasOwnProperty.call(window, '__ABS_ANGULAR
 var pageHasIslands = Boolean(pageModule.__ABSOLUTE_PAGE_HAS_ISLANDS__) || Boolean(document.querySelector('[data-island="true"]'));
 var pageHasRawStreamingSlots = Boolean(document.querySelector('[data-absolute-raw-slot="true"]'));
 var pageHasStreamingSlots = Boolean(document.querySelector('[data-absolute-slot="true"]'));
+var isClientRender = window.__ABSOLUTE_PAGE_RENDER_MODE__ === 'client';
 var contextProviders = [{ provide: REQUEST_CONTEXT, useValue: requestContext }];
 // Page-level providers are injected directly into the page module's
 // server output by \`compileAngular\`'s providers-injection step
@@ -16691,11 +17283,21 @@ var absoluteHttpTransferCacheOptions = {
 enableProdMode();
+// Production mobile/client-only activation starts from AbsoluteJS's empty
+// #root shell rather than server-rendered Angular markup. Create the page's
+// actual Angular host from its compiled selector so application authors do
+// not need framework-specific mobile configuration.
+var _sel = ${componentClassName}.\u0275cmp?.selectors?.[0]?.[0] || 'ng-app';
+if (!document.querySelector(_sel)) {
+    (document.getElementById('root') || document.body).appendChild(document.createElement(_sel));
+}
 var providers = [provideZonelessChangeDetection()].concat(pageProviders).concat(contextProviders);
-if (!pageHasIslands) {
+if (!isClientRender && !pageHasIslands) {
     providers.unshift(provideClientHydration(withHttpTransferCacheOptions(absoluteHttpTransferCacheOptions)));
 }
 window.__ABS_SLOT_HYDRATION_PENDING__ = pageHasRawStreamingSlots;
+var absolutePageReady = Promise.resolve();
 if (pageHasRawStreamingSlots) {
     window.__ABS_SLOT_HYDRATION_PENDING__ = false;
@@ -16705,7 +17307,7 @@ if (pageHasRawStreamingSlots) {
         });
     }
 } else {
-    bootstrapApplication(${componentClassName}, {
+    absolutePageReady = bootstrapApplication(${componentClassName}, {
         providers: providers
     }).then(function (appRef) {
         window.__ANGULAR_APP__ = appRef;
@@ -16715,8 +17317,17 @@ if (pageHasRawStreamingSlots) {
                 window.__ABS_SLOT_FLUSH__();
             });
         }
+        return appRef;
     });
 }
+window.__ABSOLUTE_PAGE_READY__ = absolutePageReady;
+window.__ABSOLUTE_PAGE_DISPOSE__ = async function() {
+    await absolutePageReady;
+    if (window.__ANGULAR_APP__) {
+        window.__ANGULAR_APP__.destroy();
+        window.__ANGULAR_APP__ = null;
+    }
+};
 `.trim();
     const indexHash = Bun.hash(hydration).toString(BASE_36_RADIX);
     const indexUnchanged = cachedWrapper?.indexHash === indexHash;
@@ -16749,7 +17360,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
-  hmrClientPath5 = join30(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath5 = join32(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?/;
@@ -17473,8 +18084,8 @@ __export(exports_fastHmrCompiler, {
   primeComponentFingerprint: () => primeComponentFingerprint,
   invalidateFingerprintCache: () => invalidateFingerprintCache
 });
-import { existsSync as existsSync24, readFileSync as readFileSync20, statSync as statSync2 } from "fs";
-import { dirname as dirname17, extname as extname8, relative as relative14, resolve as resolve23 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync21, statSync as statSync2 } from "fs";
+import { dirname as dirname19, extname as extname8, relative as relative14, resolve as resolve24 } from "path";
 import ts17 from "typescript";
 var fail = (reason, detail, location) => ({
   detail,
@@ -17604,7 +18215,7 @@ var fail = (reason, detail, location) => ({
         continue;
       const decoratorMeta = readDecoratorMeta(args);
       const { inputs, outputs } = extractInputsAndOutputs(stmt, null);
-      const componentDir = dirname17(componentFilePath);
+      const componentDir = dirname19(componentFilePath);
       const fingerprint = extractFingerprint(stmt, className, decoratorMeta, inputs, outputs, sourceFile, componentDir);
       fingerprintCache.set(id, fingerprint);
     } else {
@@ -17789,7 +18400,7 @@ var fail = (reason, detail, location) => ({
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return true;
     }
-    const base = resolve23(componentDir, spec);
+    const base = resolve24(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -17801,7 +18412,7 @@ var fail = (reason, detail, location) => ({
         continue;
       let content;
       try {
-        content = readFileSync20(candidate, "utf-8");
+        content = readFileSync21(candidate, "utf-8");
       } catch {
         continue;
       }
@@ -18087,7 +18698,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)
@@ -18111,14 +18722,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;
@@ -18138,7 +18749,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;
@@ -18156,7 +18767,7 @@ var fail = (reason, detail, location) => ({
               argsList.push(element.text);
           }
         }
-        host.listeners[event] = `${methodName}(${argsList.join(", ")})`;
+        host2.listeners[event] = `${methodName}(${argsList.join(", ")})`;
       }
     }
   }
@@ -18347,9 +18958,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 = [
@@ -18370,7 +18981,7 @@ var fail = (reason, detail, location) => ({
     animations,
     contentQueries,
     exportAs: extractExportAs(decoratorArgs),
-    host,
+    host: host2,
     hostDirectives: extractHostDirectives(decoratorArgs, compiler),
     providers,
     viewProviders,
@@ -18389,7 +19000,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let source;
   try {
-    source = readFileSync20(filePath, "utf-8");
+    source = readFileSync21(filePath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -18443,7 +19054,7 @@ var fail = (reason, detail, location) => ({
     return cached.info;
   let content;
   try {
-    content = readFileSync20(dtsPath, "utf-8");
+    content = readFileSync21(dtsPath, "utf-8");
   } catch {
     childComponentInfoCache.set(cacheKey2, {
       info: null,
@@ -18566,7 +19177,7 @@ var fail = (reason, detail, location) => ({
     return null;
   let content;
   try {
-    content = readFileSync20(startDtsPath, "utf-8");
+    content = readFileSync21(startDtsPath, "utf-8");
   } catch {
     return null;
   }
@@ -18585,7 +19196,7 @@ var fail = (reason, detail, location) => ({
     });
     if (!names.includes(className))
       continue;
-    const nextDts = resolveDtsFromSpec(fromPath, dirname17(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname19(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -18595,7 +19206,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, dirname17(startDtsPath));
+    const nextDts = resolveDtsFromSpec(fromPath, dirname19(startDtsPath));
     if (!nextDts)
       continue;
     const found = findDtsContainingClass(nextDts, className, visited);
@@ -18605,7 +19216,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveDtsFromSpec = (spec, fromDir) => {
   const stripped = spec.replace(/\.[mc]?js$/, "");
-  const base = resolve23(fromDir, stripped);
+  const base = resolve24(fromDir, stripped);
   const candidates = [
     `${base}.d.ts`,
     `${base}.d.mts`,
@@ -18629,7 +19240,7 @@ var fail = (reason, detail, location) => ({
   return null;
 }, resolveChildComponentInfo = (className, spec, componentDir, projectRoot) => {
   if (spec.startsWith(".") || spec.startsWith("/")) {
-    const base = resolve23(componentDir, spec);
+    const base = resolve24(componentDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -18784,7 +19395,7 @@ var fail = (reason, detail, location) => ({
     return cached.hasProviders;
   let source;
   try {
-    source = readFileSync20(filePath, "utf8");
+    source = readFileSync21(filePath, "utf8");
   } catch {
     return true;
   }
@@ -18848,13 +19459,13 @@ var fail = (reason, detail, location) => ({
     }
     if (!matches)
       continue;
-    const resolved = resolve23(componentDir, spec);
+    const resolved = resolve24(componentDir, spec);
     for (const ext of TS_EXTENSIONS) {
       const candidate = resolved + ext;
       if (existsSync24(candidate))
         return candidate;
     }
-    const indexCandidate = resolve23(resolved, "index.ts");
+    const indexCandidate = resolve24(resolved, "index.ts");
     if (existsSync24(indexCandidate))
       return indexCandidate;
   }
@@ -19092,12 +19703,12 @@ ${transpiled}
     }
 }${staticPatch}`;
 }, STYLE_PREPROCESSED_EXT, resolveAndReadStyleResource = (componentDir, url) => {
-  const abs = resolve23(componentDir, url);
+  const abs = resolve24(componentDir, url);
   if (!existsSync24(abs))
     return null;
   const ext = extname8(abs).toLowerCase();
   if (!STYLE_PREPROCESSED_EXT.has(ext) || ext === ".css") {
-    return readFileSync20(abs, "utf8");
+    return readFileSync21(abs, "utf8");
   }
   try {
     return compileStyleFileIfNeededSync(abs);
@@ -19131,11 +19742,11 @@ ${block}
   const cached = projectOptionsCache.get(projectRoot);
   if (cached !== undefined)
     return cached;
-  const tsconfigPath = resolve23(projectRoot, "tsconfig.json");
+  const tsconfigPath = resolve24(projectRoot, "tsconfig.json");
   const opts = {};
   if (existsSync24(tsconfigPath)) {
     try {
-      const text = readFileSync20(tsconfigPath, "utf8");
+      const text = readFileSync21(tsconfigPath, "utf8");
       const parsed = ts17.parseConfigFileTextToJson(tsconfigPath, text);
       if (!parsed.error && parsed.config) {
         const cfg = parsed.config;
@@ -19169,7 +19780,7 @@ ${block}
   } catch (err) {
     return fail("unexpected-error", `import @angular/compiler: ${err}`);
   }
-  const tsSource = readFileSync20(componentFilePath, "utf8");
+  const tsSource = readFileSync21(componentFilePath, "utf8");
   const sourceFile = ts17.createSourceFile(componentFilePath, tsSource, ts17.ScriptTarget.ES2022, true, ts17.ScriptKind.TS);
   const classNode = findClassDeclaration(sourceFile, className);
   if (!classNode) {
@@ -19196,7 +19807,7 @@ ${block}
       rebootstrapRequired: false
     };
   }
-  if (inheritsDecoratedClass(classNode, sourceFile, dirname17(componentFilePath), projectRoot)) {
+  if (inheritsDecoratedClass(classNode, sourceFile, dirname19(componentFilePath), projectRoot)) {
     return fail("inherits-decorated-class");
   }
   const decorator = findComponentDecorator(classNode);
@@ -19208,18 +19819,18 @@ ${block}
   const projectDefaults = readProjectAngularCompilerOptions(projectRoot);
   const decoratorMeta = readDecoratorMeta(decoratorArgs, projectDefaults);
   const advancedMetadata = extractAdvancedMetadata(classNode, decoratorArgs, compiler);
-  const componentDir = dirname17(componentFilePath);
+  const componentDir = dirname19(componentFilePath);
   let templateText;
   let templatePath;
   if (decoratorMeta.template !== null) {
     templateText = decoratorMeta.template;
     templatePath = componentFilePath;
   } else if (decoratorMeta.templateUrl) {
-    const tplAbs = resolve23(componentDir, decoratorMeta.templateUrl);
+    const tplAbs = resolve24(componentDir, decoratorMeta.templateUrl);
     if (!existsSync24(tplAbs)) {
       return fail("template-resource-not-found", `Template file not found: ${tplAbs}`, { file: componentFilePath });
     }
-    templateText = readFileSync20(tplAbs, "utf8");
+    templateText = readFileSync21(tplAbs, "utf8");
     templatePath = tplAbs;
   } else {
     return fail("unsupported-decorator-args", "missing template/templateUrl");
@@ -19978,7 +20589,7 @@ __export(exports_compileEmber, {
   getEmberServerCompiledDir: () => getEmberServerCompiledDir,
   getEmberCompiledRoot: () => getEmberCompiledRoot,
   getEmberClientCompiledDir: () => getEmberClientCompiledDir,
-  dirname: () => dirname18,
+  dirname: () => dirname20,
   compileEmberFileSource: () => compileEmberFileSource,
   compileEmberFile: () => compileEmberFile,
   compileEmber: () => compileEmber,
@@ -19986,8 +20597,8 @@ __export(exports_compileEmber, {
   basename: () => basename13
 });
 import { existsSync as existsSync25 } from "fs";
-import { mkdir as mkdir7, rm as rm4 } from "fs/promises";
-import { basename as basename13, dirname as dirname18, extname as extname9, join as join31, resolve as resolve24 } from "path";
+import { mkdir as mkdir8, rm as rm5 } from "fs/promises";
+import { basename as basename13, dirname as dirname20, extname as extname9, join as join33, resolve as resolve25 } from "path";
 var {build: bunBuild2, Transpiler: Transpiler4, write: write4, file: file3 } = globalThis.Bun;
 var cachedPreprocessor = null, getPreprocessor = async () => {
   if (cachedPreprocessor)
@@ -20083,7 +20694,7 @@ export const importSync = (specifier) => {
         const originalImporter = stagedSourceMap.get(args.importer);
         if (!originalImporter)
           return;
-        const candidateBase = resolve24(dirname18(originalImporter), args.path);
+        const candidateBase = resolve25(dirname20(originalImporter), args.path);
         const extensionsToTry = ["", ".gts", ".gjs", ".ts", ".js"];
         for (const ext of extensionsToTry) {
           const candidate = candidateBase + ext;
@@ -20106,7 +20717,7 @@ export const importSync = (specifier) => {
     build.onResolve({ filter: /^@(?:ember|glimmer|simple-dom)\// }, (args) => {
       if (standalonePackages.has(args.path))
         return;
-      const internal = join31(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join33(cwd, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync25(internal))
         return { path: internal };
       return;
@@ -20142,7 +20753,7 @@ export const renderToHTML = (props = {}) => {
 export { PageComponent };
 export default PageComponent;
 `, compileEmberFile = async (entry, compiledRoot, cwd = process.cwd()) => {
-  const resolvedEntry = resolve24(entry);
+  const resolvedEntry = resolve25(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -20154,16 +20765,16 @@ export default PageComponent;
   }
   const transpiled = transpiler5.transformSync(preprocessed);
   const baseName = basename13(resolvedEntry).replace(/\.(gjs|gts|ts|js)$/, "");
-  const tmpDir = join31(compiledRoot, "_tmp");
-  const serverDir = join31(compiledRoot, "server");
-  const clientDir = join31(compiledRoot, "client");
+  const tmpDir = join33(compiledRoot, "_tmp");
+  const serverDir = join33(compiledRoot, "server");
+  const clientDir = join33(compiledRoot, "client");
   await Promise.all([
-    mkdir7(tmpDir, { recursive: true }),
-    mkdir7(serverDir, { recursive: true }),
-    mkdir7(clientDir, { recursive: true })
+    mkdir8(tmpDir, { recursive: true }),
+    mkdir8(serverDir, { recursive: true }),
+    mkdir8(clientDir, { recursive: true })
   ]);
-  const tmpPagePath = resolve24(join31(tmpDir, `${baseName}.module.js`));
-  const tmpHarnessPath = resolve24(join31(tmpDir, `${baseName}.harness.js`));
+  const tmpPagePath = resolve25(join33(tmpDir, `${baseName}.module.js`));
+  const tmpHarnessPath = resolve25(join33(tmpDir, `${baseName}.harness.js`));
   await Promise.all([
     write4(tmpPagePath, transpiled),
     write4(tmpHarnessPath, generateServerHarness(tmpPagePath))
@@ -20171,7 +20782,7 @@ export default PageComponent;
   const stagedSourceMap = new Map([
     [tmpPagePath, resolvedEntry]
   ]);
-  const serverPath = join31(serverDir, `${baseName}.js`);
+  const serverPath = join33(serverDir, `${baseName}.js`);
   const buildResult = await bunBuild2({
     entrypoints: [tmpHarnessPath],
     format: "esm",
@@ -20187,8 +20798,8 @@ export default PageComponent;
   if (!buildResult.success) {
     console.warn(`\u26A0\uFE0F Ember server build for ${baseName} had errors:`, buildResult.logs);
   }
-  await rm4(tmpDir, { force: true, recursive: true });
-  const clientPath = join31(clientDir, `${baseName}.js`);
+  await rm5(tmpDir, { force: true, recursive: true });
+  const clientPath = join33(clientDir, `${baseName}.js`);
   await write4(clientPath, transpiled);
   return { clientPath, serverPath };
 }, compileEmber = async (entries, emberDir, cwd = process.cwd(), _hmr = false) => {
@@ -20205,7 +20816,7 @@ export default PageComponent;
     serverPaths: outputs.map((o3) => o3.serverPath)
   };
 }, compileEmberFileSource = async (entry) => {
-  const resolvedEntry = resolve24(entry);
+  const resolvedEntry = resolve25(entry);
   const source = await file3(resolvedEntry).text();
   let preprocessed = source;
   if (isTemplateTagFile(resolvedEntry)) {
@@ -20216,7 +20827,7 @@ export default PageComponent;
     preprocessed = rewriteTemplateEvalToScope(result.code);
   }
   return transpiler5.transformSync(preprocessed);
-}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join31(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join31(getEmberCompiledRoot(emberDir), "client");
+}, clearEmberCompilerCache = () => {}, getEmberCompiledRoot = (_emberDir) => getFrameworkGeneratedDir("ember"), getEmberServerCompiledDir = (emberDir) => join33(getEmberCompiledRoot(emberDir), "server"), getEmberClientCompiledDir = (emberDir) => join33(getEmberCompiledRoot(emberDir), "client");
 var init_compileEmber = __esm(() => {
   init_generatedDir();
   transpiler5 = new Transpiler4({
@@ -20238,24 +20849,24 @@ __export(exports_buildReactVendor, {
   buildReactVendor: () => buildReactVendor
 });
 import { existsSync as existsSync26, mkdirSync as mkdirSync8 } from "fs";
-import { join as join32, resolve as resolve25 } from "path";
-import { rm as rm5 } from "fs/promises";
+import { join as join34, resolve as resolve26 } from "path";
+import { rm as rm6 } from "fs/promises";
 var {build: bunBuild3 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve25(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve25(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve25(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve25(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve25(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve25(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve26(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve26(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve26(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve26(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve26(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve26(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync26(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve25(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve26(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, jsxRuntimeCompatPath, reactSpecifiers, toSafeFileName = (specifier) => specifier.replace(/\//g, "_"), computeVendorPaths = () => {
   const paths = {};
   for (const specifier of reactSpecifiers) {
@@ -20288,14 +20899,14 @@ var resolveJsxDevRuntimeCompatPath = () => {
 `)}
 `;
 }, buildReactVendor = async (buildDir) => {
-  const vendorDir = join32(buildDir, "react", "vendor");
+  const vendorDir = join34(buildDir, "react", "vendor");
   mkdirSync8(vendorDir, { recursive: true });
-  const tmpDir = join32(buildDir, "_vendor_tmp");
+  const tmpDir = join34(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 = join32(tmpDir, `${safeName}.ts`);
+    const entryPath = join34(tmpDir, `${safeName}.ts`);
     const source = await generateEntrySource(specifier);
     await Bun.write(entryPath, source);
     return entryPath;
@@ -20310,7 +20921,7 @@ var resolveJsxDevRuntimeCompatPath = () => {
     target: "browser",
     throw: false
   });
-  await rm5(tmpDir, { force: true, recursive: true });
+  await rm6(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F React vendor build had errors:", result.logs);
   }
@@ -20363,8 +20974,8 @@ __export(exports_buildAngularVendor, {
   buildAngularServerVendor: () => buildAngularServerVendor
 });
 import { mkdirSync as mkdirSync9 } from "fs";
-import { join as join33 } from "path";
-import { rm as rm6 } from "fs/promises";
+import { join as join35 } from "path";
+import { rm as rm7 } 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) => {
   try {
@@ -20400,7 +21011,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: readFileSync21 } = await import("fs");
+  const { readFileSync: readFileSync22 } = await import("fs");
   const transpiler6 = new Bun.Transpiler({ loader: "js" });
   const visited = new Set;
   const frontier = [];
@@ -20421,7 +21032,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
       }
       let content;
       try {
-        content = readFileSync21(resolved, "utf-8");
+        content = readFileSync22(resolved, "utf-8");
       } catch {
         continue;
       }
@@ -20460,14 +21071,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 = join33(buildDir, "angular", "vendor");
+  const vendorDir = join35(buildDir, "angular", "vendor");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join33(buildDir, "_angular_vendor_tmp");
+  const tmpDir = join35(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 = join33(tmpDir, `${safeName}.ts`);
+    const entryPath = join35(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -20483,7 +21094,7 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
     target: "browser",
     throw: false
   });
-  await rm6(tmpDir, { force: true, recursive: true });
+  await rm7(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Angular vendor build had errors:", result.logs);
   }
@@ -20498,9 +21109,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 = join33(buildDir, "angular", "vendor", "server");
+  const vendorDir = join35(buildDir, "angular", "vendor", "server");
   mkdirSync9(vendorDir, { recursive: true });
-  const tmpDir = join33(buildDir, "_angular_server_vendor_tmp");
+  const tmpDir = join35(buildDir, "_angular_server_vendor_tmp");
   mkdirSync9(tmpDir, { recursive: true });
   const browserSpecs = await resolveAngularSpecifiers(directories, linkerJitMode);
   const allSpecs = new Set(browserSpecs);
@@ -20511,7 +21122,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 = join33(tmpDir, `${safeName}.ts`);
+    const entryPath = join35(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return entryPath;
   }));
@@ -20526,16 +21137,16 @@ var REQUIRED_ANGULAR_SPECIFIERS_BASE, requiredAngularSpecifiers = (jitMode) => j
     target: "bun",
     throw: false
   });
-  await rm6(tmpDir, { force: true, recursive: true });
+  await rm7(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Angular server vendor build had errors:", result.logs);
   }
   return specifiers;
 }, computeAngularServerVendorPaths = (buildDir, specifiers) => {
   const paths = {};
-  const vendorDir = join33(buildDir, "angular", "vendor", "server");
+  const vendorDir = join35(buildDir, "angular", "vendor", "server");
   for (const specifier of specifiers) {
-    paths[specifier] = join33(vendorDir, `${toSafeFileName2(specifier)}.js`);
+    paths[specifier] = join35(vendorDir, `${toSafeFileName2(specifier)}.js`);
   }
   return paths;
 }, computeAngularServerVendorPathsAsync = async (buildDir, directories = [], linkerJitMode = true) => {
@@ -20591,17 +21202,17 @@ __export(exports_buildVueVendor, {
   buildVueVendor: () => buildVueVendor
 });
 import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join34 } from "path";
-import { rm as rm7 } from "fs/promises";
+import { join as join36 } from "path";
+import { rm as rm8 } from "fs/promises";
 var {build: bunBuild5 } = globalThis.Bun;
 var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"), buildVueVendor = async (buildDir) => {
-  const vendorDir = join34(buildDir, "vue", "vendor");
+  const vendorDir = join36(buildDir, "vue", "vendor");
   mkdirSync10(vendorDir, { recursive: true });
-  const tmpDir = join34(buildDir, "_vue_vendor_tmp");
+  const tmpDir = join36(buildDir, "_vue_vendor_tmp");
   mkdirSync10(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(vueSpecifiers.map(async (specifier) => {
     const safeName = toSafeFileName3(specifier);
-    const entryPath = join34(tmpDir, `${safeName}.ts`);
+    const entryPath = join36(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -20621,16 +21232,16 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     target: "browser",
     throw: false
   });
-  await rm7(tmpDir, { force: true, recursive: true });
+  await rm8(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync21, writeFileSync: writeFileSync8, readdirSync: readdirSync5 } = await import("fs");
+  const { readFileSync: readFileSync22, writeFileSync: writeFileSync8, readdirSync: readdirSync5 } = await import("fs");
   const files = readdirSync5(vendorDir).filter((f2) => f2.endsWith(".js"));
   for (const file4 of files) {
-    const filePath = join34(vendorDir, file4);
-    const content = readFileSync21(filePath, "utf-8");
+    const filePath = join36(vendorDir, file4);
+    const content = readFileSync22(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__ || {");
@@ -20656,8 +21267,8 @@ __export(exports_buildSvelteVendor, {
   buildSvelteVendor: () => buildSvelteVendor
 });
 import { mkdirSync as mkdirSync11 } from "fs";
-import { join as join35 } from "path";
-import { rm as rm8 } from "fs/promises";
+import { join as join37 } from "path";
+import { rm as rm9 } from "fs/promises";
 var {build: bunBuild6 } = globalThis.Bun;
 var svelteSpecifiers, isResolvable2 = (specifier) => {
   try {
@@ -20670,13 +21281,13 @@ var svelteSpecifiers, isResolvable2 = (specifier) => {
   const specifiers = resolveVendorSpecifiers();
   if (specifiers.length === 0)
     return;
-  const vendorDir = join35(buildDir, "svelte", "vendor");
+  const vendorDir = join37(buildDir, "svelte", "vendor");
   mkdirSync11(vendorDir, { recursive: true });
-  const tmpDir = join35(buildDir, "_svelte_vendor_tmp");
+  const tmpDir = join37(buildDir, "_svelte_vendor_tmp");
   mkdirSync11(tmpDir, { recursive: true });
   const entrypoints = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName4(specifier);
-    const entryPath = join35(tmpDir, `${safeName}.ts`);
+    const entryPath = join37(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, `export * from '${specifier}';
 `);
     return entryPath;
@@ -20691,7 +21302,7 @@ var svelteSpecifiers, isResolvable2 = (specifier) => {
     target: "browser",
     throw: false
   });
-  await rm8(tmpDir, { force: true, recursive: true });
+  await rm9(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Svelte vendor build had errors:", result.logs);
   }
@@ -20721,13 +21332,13 @@ import {
   existsSync as existsSync27,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync21,
+  readFileSync as readFileSync22,
   renameSync,
   rmSync as rmSync2,
   statSync as statSync3,
   writeFileSync as writeFileSync8
 } from "fs";
-import { basename as basename14, dirname as dirname19, extname as extname10, join as join36, relative as relative15, resolve as resolve26 } from "path";
+import { basename as basename14, dirname as dirname21, extname as extname10, join as join38, relative as relative15, resolve as resolve27 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild7, Glob: Glob8 } = globalThis.Bun;
 var isBuildTraceEnabled = () => {
@@ -20810,7 +21421,7 @@ var isBuildTraceEnabled = () => {
 }, REACT_VENDOR_SPECIFIERS, findBareReactImports = (path, importRegex) => {
   let content;
   try {
-    content = readFileSync21(path, "utf-8");
+    content = readFileSync22(path, "utf-8");
   } catch {
     return [];
   }
@@ -20861,8 +21472,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 = join36(htmxDir, relPath);
-    const dest = join36(htmxDestDir, "htmx.min.js");
+    const src = join38(htmxDir, relPath);
+    const dest = join38(htmxDestDir, "htmx.min.js");
     copyFileSync2(src, dest);
     return;
   }
@@ -20874,8 +21485,8 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve26(import.meta.dir, "..", "..", "package.json"),
-    resolve26(import.meta.dir, "..", "package.json")
+    resolve27(import.meta.dir, "..", "..", "package.json"),
+    resolve27(import.meta.dir, "..", "package.json")
   ];
   const resolveCandidate = async (remaining) => {
     const [candidate, ...rest] = remaining;
@@ -20891,7 +21502,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   };
   await resolveCandidate(candidates);
 }, SKIP_DIRS5, addWorkerPathIfExists = (file4, relPath, workerPaths) => {
-  const absPath = resolve26(file4, "..", relPath);
+  const absPath = resolve27(file4, "..", relPath);
   try {
     statSync3(absPath);
     workerPaths.add(absPath);
@@ -20906,7 +21517,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
     addWorkerPathIfExists(file4, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file4, patterns, workerPaths) => {
-  const content = readFileSync21(file4, "utf-8");
+  const content = readFileSync22(file4, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file4, workerPaths);
   }
@@ -20939,7 +21550,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   vuePagesPath
 }) => {
   const { readdirSync: readDir } = await import("fs");
-  const devIndexDir = join36(buildPath, "_src_indexes");
+  const devIndexDir = join38(buildPath, "_src_indexes");
   mkdirSync12(devIndexDir, { recursive: true });
   if (reactIndexesPath && reactPagesPath) {
     copyReactDevIndexes(reactIndexesPath, reactPagesPath, devIndexDir, readDir);
@@ -20955,37 +21566,37 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
-  const pagesRel = relative15(process.cwd(), resolve26(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative15(process.cwd(), resolve27(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync21(join36(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync22(join38(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
-    writeFileSync8(join36(devIndexDir, file4), content);
+    writeFileSync8(join38(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
-  const svelteIndexDir = join36(getFrameworkGeneratedDir("svelte"), "indexes");
-  const sveltePageEntries = svelteEntries.filter((file4) => resolve26(file4).startsWith(resolve26(sveltePagesPath)));
+  const svelteIndexDir = join38(getFrameworkGeneratedDir("svelte"), "indexes");
+  const sveltePageEntries = svelteEntries.filter((file4) => resolve27(file4).startsWith(resolve27(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename14(entry).replace(/\.svelte(\.(ts|js))?$/, "");
-    const indexFile = join36(svelteIndexDir, "pages", `${name}.js`);
+    const indexFile = join38(svelteIndexDir, "pages", `${name}.js`);
     if (!existsSync27(indexFile))
       continue;
-    let content = readFileSync21(indexFile, "utf-8");
-    const srcRel = relative15(process.cwd(), resolve26(entry)).replace(/\\/g, "/");
+    let content = readFileSync22(indexFile, "utf-8");
+    const srcRel = relative15(process.cwd(), resolve27(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
-    writeFileSync8(join36(devIndexDir, `${name}.svelte.js`), content);
+    writeFileSync8(join38(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
-  const vueIndexDir = join36(getFrameworkGeneratedDir("vue"), "indexes");
-  const vuePageEntries = vueEntries.filter((file4) => resolve26(file4).startsWith(resolve26(vuePagesPath)));
+  const vueIndexDir = join38(getFrameworkGeneratedDir("vue"), "indexes");
+  const vuePageEntries = vueEntries.filter((file4) => resolve27(file4).startsWith(resolve27(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename14(entry, ".vue");
-    const indexFile = join36(vueIndexDir, `${name}.js`);
+    const indexFile = join38(vueIndexDir, `${name}.js`);
     if (!existsSync27(indexFile))
       continue;
-    let content = readFileSync21(indexFile, "utf-8");
-    const srcRel = relative15(process.cwd(), resolve26(entry)).replace(/\\/g, "/");
+    let content = readFileSync22(indexFile, "utf-8");
+    const srcRel = relative15(process.cwd(), resolve27(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}"`));
-    writeFileSync8(join36(devIndexDir, `${name}.vue.js`), content);
+    writeFileSync8(join38(devIndexDir, `${name}.vue.js`), content);
   }
 }, resolveVueRuntimeId = (content, firstUseName, outputPath, projectRoot) => {
   const varIdx = content.indexOf(`var ${firstUseName} =`);
@@ -20996,7 +21607,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve26(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve27(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -21033,7 +21644,7 @@ ${offenders.map((o3) => `  \u2022 ${o3}`).join(`
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync21(outputPath, "utf-8");
+  let content = readFileSync22(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -21083,7 +21694,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 = readFileSync21(outputPath, "utf-8");
+    let content = readFileSync22(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename14(relPath);
@@ -21134,6 +21745,8 @@ ${content.slice(firstUseIdx)}`;
   };
   const result = {
     ...merged,
+    banner: [base.banner, sanitized.banner].filter(Boolean).join(`
+`) || undefined,
     define: base.define || sanitized.define ? {
       ...sanitized.define ?? {},
       ...base.define ?? {}
@@ -21155,6 +21768,7 @@ ${content.slice(firstUseIdx)}`;
   htmxDirectory,
   angularDirectory,
   emberDirectory,
+  pwa,
   svelteDirectory,
   vueDirectory,
   stylesConfig,
@@ -21220,10 +21834,10 @@ ${content.slice(firstUseIdx)}`;
       restoreTracePhase();
       return;
     }
-    const traceDir = join36(buildPath2, ".absolute-trace");
+    const traceDir = join38(buildPath2, ".absolute-trace");
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     mkdirSync12(traceDir, { recursive: true });
-    writeFileSync8(join36(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
+    writeFileSync8(join38(traceDir, `build-trace-${timestamp}.json`), JSON.stringify({
       events: traceEvents,
       frameworks: traceFrameworkNames,
       generatedAt: new Date().toISOString(),
@@ -21254,16 +21868,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 && join36(getFrameworkGeneratedDir("react"), "indexes");
-  const reactPagesPath = reactDir && join36(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join36(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join36(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join36(svelteDir, "pages");
-  const vuePagesPath = vueDir && join36(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join36(htmxDir, "pages");
-  const htmxScriptsPath = htmxDir && join36(htmxDir, "scripts");
-  const angularPagesPath = angularDir && join36(angularDir, "pages");
-  const emberPagesPath = emberDir && join36(emberDir, "pages");
+  const reactIndexesPath = reactDir && join38(getFrameworkGeneratedDir("react"), "indexes");
+  const reactPagesPath = reactDir && join38(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join38(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join38(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join38(svelteDir, "pages");
+  const vuePagesPath = vueDir && join38(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join38(htmxDir, "pages");
+  const htmxScriptsPath = htmxDir && join38(htmxDir, "scripts");
+  const angularPagesPath = angularDir && join38(angularDir, "pages");
+  const emberPagesPath = emberDir && join38(emberDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -21288,13 +21902,15 @@ ${content.slice(firstUseIdx)}`;
     framework: frameworkNames[0],
     frameworks: frameworkNames,
     mode: mode ?? (isDev2 ? "development" : "production"),
+    pwa: Boolean(pwa),
+    pwaSync: Boolean(pwa?.sync),
     tailwind: Boolean(tailwind)
   });
   const generatedRoot = getGeneratedRoot(projectRoot);
   const sourceClientRoots = [
     htmlDir,
     htmxDir,
-    islandBootstrapPath && dirname19(islandBootstrapPath)
+    islandBootstrapPath && dirname21(islandBootstrapPath)
   ].filter((dir) => Boolean(dir));
   const usesGenerated = Boolean(reactDir) || Boolean(svelteDir) || Boolean(vueDir) || Boolean(angularDir);
   if (usesGenerated)
@@ -21322,8 +21938,8 @@ ${content.slice(firstUseIdx)}`;
     const [firstEntry] = serverDirMap;
     if (!firstEntry)
       throw new Error("Expected at least one server directory entry");
-    serverRoot = join36(firstEntry.dir, firstEntry.subdir);
-    serverOutDir = join36(buildPath, basename14(firstEntry.dir));
+    serverRoot = join38(firstEntry.dir, firstEntry.subdir);
+    serverOutDir = join38(buildPath, basename14(firstEntry.dir));
   } else if (serverDirMap.length > 1) {
     serverRoot = commonAncestor(serverDirMap.map((entry) => entry.dir), projectRoot);
     serverOutDir = buildPath;
@@ -21332,16 +21948,23 @@ ${content.slice(firstUseIdx)}`;
   await tracePhase("build-dir/create", () => mkdirSync12(buildPath, { recursive: true }));
   if (publicPath)
     await tracePhase("public/copy", () => cpSync(publicPath, buildPath, { force: true, recursive: true }));
+  const pwaArtifacts = pwa ? await tracePhase("pwa/materialize", () => materializeAbsolutePwa({
+    buildPath,
+    config: pwa,
+    generatedRoot,
+    projectRoot,
+    write: !isIncremental
+  })) : undefined;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve26(f2)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f2) => resolve27(f2)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve26(sourceFile)))
+      if (!normalizedIncremental.has(resolve27(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -21351,7 +21974,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, join36(buildPath, "assets"), {
+    await tracePhase("assets/copy", () => cpSync(assetsPath, join38(buildPath, "assets"), {
       force: true,
       recursive: true
     }));
@@ -21465,11 +22088,11 @@ ${content.slice(firstUseIdx)}`;
     }
   }
   if (htmlDefaults.error || htmlDefaults.notFound || htmlDefaults.loading || Object.keys(htmlPages).length > 0) {
-    const htmlConventionsOutDir = join36(buildPath, "conventions", "html");
+    const htmlConventionsOutDir = join38(buildPath, "conventions", "html");
     mkdirSync12(htmlConventionsOutDir, { recursive: true });
     const htmlPathRemap = new Map;
     for (const sourcePath of htmlConventionSources) {
-      const dest = join36(htmlConventionsOutDir, basename14(sourcePath));
+      const dest = join38(htmlConventionsOutDir, basename14(sourcePath));
       cpSync(sourcePath, dest, { force: true });
       htmlPathRemap.set(sourcePath, dest);
     }
@@ -21510,9 +22133,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(resolve26(reactIndexesPath))) {
+    if (entry.startsWith(resolve27(reactIndexesPath))) {
       const pageName = basename14(entry, ".tsx");
-      return join36(reactPagesPath, `${pageName}.tsx`);
+      return join38(reactPagesPath, `${pageName}.tsx`);
     }
     return null;
   }) : allReactEntries;
@@ -21544,7 +22167,7 @@ ${content.slice(firstUseIdx)}`;
     for (const entry of vueEntries) {
       const name = basename14(entry, ".vue");
       if (ssrOnlyPageNames.has(name)) {
-        resolved.add(resolve26(entry));
+        resolved.add(resolve27(entry));
       }
     }
     return resolved;
@@ -21681,7 +22304,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve26(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve27(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -21689,7 +22312,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve26(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve27(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -21697,7 +22320,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve26(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve27(sourcePath), clientPath);
   }
   const reactConventionSources = collectConventionSourceFiles(conventionsMap.react);
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
@@ -21708,7 +22331,7 @@ ${content.slice(firstUseIdx)}`;
     const compileReactConventions = async () => {
       if (reactConventionSources.length === 0)
         return emptyStringArray;
-      const destDir = join36(buildPath, "conventions", "react");
+      const destDir = join38(buildPath, "conventions", "react");
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync12(destDir, { recursive: true });
       const destPaths = await Promise.all(reactConventionSources.map(async (source, idx) => {
@@ -21723,7 +22346,7 @@ ${content.slice(firstUseIdx)}`;
             stylePreprocessorPlugin2,
             createBunStringRawUnicodePlugin()
           ],
-          root: dirname19(source),
+          root: dirname21(source),
           target: "bun",
           throw: false,
           tsconfig: "./tsconfig.json"
@@ -21751,7 +22374,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 = join36(buildPath, "conventions", framework);
+      const destDir = join38(buildPath, "conventions", framework);
       rmSync2(destDir, { force: true, recursive: true });
       mkdirSync12(destDir, { recursive: true });
       const destPaths = await Promise.all(compiledPaths.map(async (compiledPath, idx) => {
@@ -21812,7 +22435,7 @@ ${content.slice(firstUseIdx)}`;
     ...islandBootstrapPath ? [islandBootstrapPath] : []
   ];
   const [onlyWorkerClientEntry] = urlReferencedFiles;
-  const workerClientRoot = urlReferencedFiles.length === 1 && onlyWorkerClientEntry ? dirname19(onlyWorkerClientEntry) : commonAncestor(urlReferencedFiles.map((file4) => dirname19(file4)), projectRoot);
+  const workerClientRoot = urlReferencedFiles.length === 1 && onlyWorkerClientEntry ? dirname21(onlyWorkerClientEntry) : commonAncestor(urlReferencedFiles.map((file4) => dirname21(file4)), projectRoot);
   const islandEntryResult = islandBuildInfo ? await tracePhase("islands/client-entry-generation", () => generateIslandEntryPoints({
     buildInfo: islandBuildInfo,
     buildPath,
@@ -21823,7 +22446,7 @@ ${content.slice(firstUseIdx)}`;
     }
   })) : {
     entries: [],
-    generatedRoot: join36(buildPath, "_island_entries")
+    generatedRoot: join38(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) {
@@ -21859,7 +22482,7 @@ ${content.slice(firstUseIdx)}`;
     return {};
   }
   if (hmr && reactIndexesPath && reactClientEntryPoints.length > 0) {
-    const refreshEntry = join36(reactIndexesPath, "_refresh.tsx");
+    const refreshEntry = join38(reactIndexesPath, "_refresh.tsx");
     if (!reactClientEntryPoints.includes(refreshEntry))
       reactClientEntryPoints.push(refreshEntry);
   }
@@ -21948,6 +22571,7 @@ ${content.slice(firstUseIdx)}`;
   const svelteResolveConditions = svelteDir ? ["svelte", "main"] : undefined;
   const htmlScriptPlugin = hmr ? createHTMLScriptHMRPlugin(htmlDir, htmxDir) : undefined;
   const reactBuildConfig = reactClientEntryPoints.length > 0 ? mergeBunBuildConfig({
+    banner: pwaArtifacts?.bootstrapBanner,
     entrypoints: reactClientEntryPoints,
     ...Object.keys(reactExternalPaths).length > 0 ? { external: Object.keys(reactExternalPaths) } : {},
     format: "esm",
@@ -21969,19 +22593,19 @@ ${content.slice(firstUseIdx)}`;
     throw: false
   }, resolveBunBuildOverride(bunBuildConfig, "reactClient")) : undefined;
   if (reactDir && reactClientEntryPoints.length > 0) {
-    rmSync2(join36(buildPath, "react", "generated", "indexes"), {
+    rmSync2(join38(buildPath, "react", "generated", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (angularDir && angularClientPaths.length > 0) {
-    rmSync2(join36(buildPath, "angular", "indexes"), {
+    rmSync2(join38(buildPath, "angular", "indexes"), {
       force: true,
       recursive: true
     });
   }
   if (islandClientEntryPoints.length > 0) {
-    rmSync2(join36(buildPath, "islands"), {
+    rmSync2(join38(buildPath, "islands"), {
       force: true,
       recursive: true
     });
@@ -22018,6 +22642,7 @@ ${content.slice(firstUseIdx)}`;
     }, resolveBunBuildOverride(bunBuildConfig, "server")))) : undefined,
     reactBuildConfig ? tracePhase("bun/react-client", () => bunBuild7(reactBuildConfig)) : undefined,
     nonReactClientEntryPoints.length > 0 ? tracePhase("bun/non-react-client", () => bunBuild7(mergeBunBuildConfig({
+      banner: pwaArtifacts?.bootstrapBanner,
       conditions: svelteResolveConditions,
       define: vueDirectory ? vueFeatureFlags : undefined,
       entrypoints: nonReactClientEntryPoints,
@@ -22063,6 +22688,7 @@ ${content.slice(firstUseIdx)}`;
       tsconfig: "./tsconfig.json"
     }, resolveBunBuildOverride(bunBuildConfig, "nonReactClient")))) : undefined,
     islandClientEntryPoints.length > 0 ? tracePhase("bun/island-client", () => bunBuild7(mergeBunBuildConfig({
+      banner: pwaArtifacts?.bootstrapBanner,
       conditions: svelteResolveConditions,
       define: vueDirectory ? vueFeatureFlags : undefined,
       entrypoints: islandClientEntryPoints,
@@ -22093,7 +22719,7 @@ ${content.slice(firstUseIdx)}`;
     globalCssEntries.length > 0 ? tracePhase("bun/global-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: globalCssEntries,
       naming: `[dir]/[name].[hash].[ext]`,
-      outdir: stylesDir ? join36(buildPath, basename14(stylesDir)) : buildPath,
+      outdir: stylesDir ? join38(buildPath, basename14(stylesDir)) : buildPath,
       plugins: [stylePreprocessorPlugin2],
       root: stylesDir || clientRoot,
       target: "browser",
@@ -22102,7 +22728,7 @@ ${content.slice(firstUseIdx)}`;
     vueCssPaths.length > 0 ? tracePhase("bun/vue-css", () => bunBuild7(mergeBunBuildConfig({
       entrypoints: vueCssPaths,
       naming: `[name].[hash].[ext]`,
-      outdir: join36(buildPath, assetsPath ? basename14(assetsPath) : "assets", "css"),
+      outdir: join38(buildPath, assetsPath ? basename14(assetsPath) : "assets", "css"),
       target: "browser",
       throw: false
     }, resolveBunBuildOverride(bunBuildConfig, "vueCss")))) : undefined
@@ -22126,18 +22752,18 @@ ${content.slice(firstUseIdx)}`;
   }
   if (!isDev2 && resolveClientSourcemap(sourcemaps, isDev2) === "external") {
     const { chainExternalSourcemap: chainExternalSourcemap2 } = await Promise.resolve().then(() => (init_chainInlineSourcemaps(), exports_chainInlineSourcemaps));
-    const sourcemapDir = join36(projectRoot, "sourcemaps");
+    const sourcemapDir = join38(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) => join36(buildPath, entry));
+    }).filter((entry) => entry.endsWith(".js.map") && !entry.includes("node_modules")).map((entry) => join38(buildPath, entry));
     for (const mapPath of mapFiles) {
       chainExternalSourcemap2(mapPath);
-      renameSync(mapPath, join36(sourcemapDir, basename14(mapPath)));
+      renameSync(mapPath, join38(sourcemapDir, basename14(mapPath)));
       const jsPath = mapPath.slice(0, -4);
       try {
-        const javascript = readFileSync21(jsPath, "utf-8").replace(/\n?\/\/# sourceMappingURL=[^\n]*\s*$/, `
+        const javascript = readFileSync22(jsPath, "utf-8").replace(/\n?\/\/# sourceMappingURL=[^\n]*\s*$/, `
 `);
         writeFileSync8(jsPath, javascript);
       } catch {}
@@ -22208,7 +22834,7 @@ ${content.slice(firstUseIdx)}`;
     await tracePhase("postprocess/island-vendor-imports", () => rewriteBuildOutputs2(islandClientOutputs, allIslandVendorPaths));
   }
   if (!hmr) {
-    const reactVendorDir = join36(buildPath, "react", "vendor");
+    const reactVendorDir = join38(buildPath, "react", "vendor");
     const vendorChunkPaths = existsSync27(reactVendorDir) ? [
       ...new Glob8("**/*.js").scanSync({
         absolute: true,
@@ -22225,7 +22851,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 = dirname19(artifact.path);
+      const fileDir = dirname21(artifact.path);
       const relativePaths = {};
       for (const [specifier, absolute] of Object.entries(angularServerVendorPaths2)) {
         const rel = relative15(fileDir, absolute);
@@ -22353,7 +22979,7 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync21(filePath, "utf-8");
+    let html = readFileSync22(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
@@ -22364,7 +22990,7 @@ ${content.slice(firstUseIdx)}`;
   const processHtmlPages = async () => {
     if (!(htmlDir && htmlPagesPath))
       return;
-    const outputHtmlPages = isSingle ? join36(buildPath, "pages") : join36(buildPath, basename14(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join38(buildPath, "pages") : join38(buildPath, basename14(htmlDir), "pages");
     mkdirSync12(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -22379,6 +23005,10 @@ ${content.slice(firstUseIdx)}`;
     for (const htmlFile of htmlPageFiles) {
       if (hmr)
         injectHMRIntoHTMLFile(htmlFile, "html");
+      if (pwaArtifacts) {
+        const source = readFileSync22(htmlFile, "utf8");
+        writeFileSync8(htmlFile, injectPwaBootstrapHtml(source));
+      }
       const fileName = basename14(htmlFile, ".html");
       if (manifest[fileName] && manifest[fileName] !== htmlFile) {
         warnManifestKeyCollision(fileName, manifest[fileName], htmlFile);
@@ -22389,14 +23019,14 @@ ${content.slice(firstUseIdx)}`;
   const processHtmxPages = async () => {
     if (!(htmxDir && htmxPagesPath))
       return;
-    const outputHtmxPages = isSingle ? join36(buildPath, "pages") : join36(buildPath, basename14(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join38(buildPath, "pages") : join38(buildPath, basename14(htmxDir), "pages");
     mkdirSync12(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
     if (shouldCopyHtmx) {
-      const htmxDestDir = isSingle ? buildPath : join36(buildPath, basename14(htmxDir));
+      const htmxDestDir = isSingle ? buildPath : join38(buildPath, basename14(htmxDir));
       copyHtmxVendor(htmxDir, htmxDestDir);
     }
     if (shouldUpdateHtmxAssetPaths) {
@@ -22408,6 +23038,10 @@ ${content.slice(firstUseIdx)}`;
     for (const htmxFile of htmxPageFiles) {
       if (hmr)
         injectHMRIntoHTMLFile(htmxFile, "htmx");
+      if (pwaArtifacts) {
+        const source = readFileSync22(htmxFile, "utf8");
+        writeFileSync8(htmxFile, injectPwaBootstrapHtml(source));
+      }
       const fileName = basename14(htmxFile, ".html");
       if (manifest[fileName] && manifest[fileName] !== htmxFile) {
         warnManifestKeyCollision(fileName, manifest[fileName], htmxFile);
@@ -22457,7 +23091,9 @@ ${content.slice(firstUseIdx)}`;
   sendTelemetryEvent("build:complete", {
     durationMs: Math.round(performance.now() - buildStart),
     frameworks: frameworkNames,
-    mode: mode ?? (isDev2 ? "development" : "production")
+    mode: mode ?? (isDev2 ? "development" : "production"),
+    pwa: Boolean(pwa),
+    pwaSync: Boolean(pwa?.sync)
   });
   const [reactSpaHosts, svelteSpaHosts, vueSpaHosts, angularSpaHosts] = await Promise.all([
     reactDir ? Promise.resolve().then(() => (init_staticAnalyzeSpaRoutes2(), exports_staticAnalyzeSpaRoutes2)).then((module) => module.analyzeReactSpaRoutes(reactDir)) : [],
@@ -22466,22 +23102,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);
-  writeFileSync8(join36(buildPath, "spa-routes.json"), JSON.stringify(spaRouteHosts, null, "\t"));
+  writeFileSync8(join38(buildPath, "spa-routes.json"), JSON.stringify(spaRouteHosts, null, "\t"));
   if (isIncremental) {
     writeBuildTrace(buildPath);
     return {
@@ -22490,9 +23126,9 @@ ${content.slice(firstUseIdx)}`;
       manifest
     };
   }
-  writeFileSync8(join36(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
+  writeFileSync8(join38(buildPath, "manifest.json"), JSON.stringify(manifest, null, "\t"));
   if (Object.keys(conventionsMap).length > 0) {
-    writeFileSync8(join36(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
+    writeFileSync8(join38(buildPath, "conventions.json"), JSON.stringify(conventionsMap, null, "\t"));
   }
   writeBuildTrace(buildPath);
   if (mode === "production") {
@@ -22563,6 +23199,7 @@ var init_build = __esm(() => {
   init_logger();
   init_validateSafePath();
   init_spaRouteManifest();
+  init_pwa();
   REACT_VENDOR_SPECIFIERS = [
     "react-dom/client",
     "react-refresh/runtime",
@@ -22625,8 +23262,8 @@ var init_build = __esm(() => {
 // src/build/buildEmberVendor.ts
 import { mkdirSync as mkdirSync13, existsSync as existsSync28 } from "fs";
-import { join as join37 } from "path";
-import { rm as rm9 } from "fs/promises";
+import { join as join39 } from "path";
+import { rm as rm10 } 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
 // implementations for macros that would normally be replaced at
@@ -22677,7 +23314,7 @@ export const importSync = (specifier) => {
   if (standaloneSpecifiers.has(specifier)) {
     return { resolveTo: specifier, specifier };
   }
-  const emberInternalPath = join37(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
+  const emberInternalPath = join39(cwd2, "node_modules/ember-source/dist/packages", specifier, "index.js");
   if (!existsSync28(emberInternalPath)) {
     throw new Error(`Ember vendor build: cannot find ${specifier} at ${emberInternalPath}. ` + `Is ember-source installed and at least 6.12?`);
   }
@@ -22709,7 +23346,7 @@ export const importSync = (specifier) => {
       if (standalonePackages.has(args.path)) {
         return;
       }
-      const internal = join37(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
+      const internal = join39(cwd2, "node_modules/ember-source/dist/packages", args.path, "index.js");
       if (existsSync28(internal)) {
         return { path: internal };
       }
@@ -22717,16 +23354,16 @@ export const importSync = (specifier) => {
     });
   }
 }), buildEmberVendor = async (buildDir, cwd2 = process.cwd()) => {
-  const vendorDir = join37(buildDir, "ember", "vendor");
+  const vendorDir = join39(buildDir, "ember", "vendor");
   mkdirSync13(vendorDir, { recursive: true });
-  const tmpDir = join37(buildDir, "_ember_vendor_tmp");
+  const tmpDir = join39(buildDir, "_ember_vendor_tmp");
   mkdirSync13(tmpDir, { recursive: true });
-  const macrosShimPath = join37(tmpDir, "embroider_macros_shim.js");
+  const macrosShimPath = join39(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 = join37(tmpDir, `${safeName}.js`);
+    const entryPath = join39(tmpDir, `${safeName}.js`);
     const source = resolution.specifier === "@embroider/macros" ? `export * from ${JSON.stringify(macrosShimPath)};
 ` : generateVendorEntrySource2(resolution);
     await Bun.write(entryPath, source);
@@ -22743,7 +23380,7 @@ export const importSync = (specifier) => {
     target: "browser",
     throw: false
   });
-  await rm9(tmpDir, { force: true, recursive: true });
+  await rm10(tmpDir, { force: true, recursive: true });
   if (!result.success) {
     console.warn("\u26A0\uFE0F Ember vendor build had errors:", result.logs);
   }
@@ -22882,9 +23519,9 @@ __export(exports_dependencyGraph, {
   buildInitialDependencyGraph: () => buildInitialDependencyGraph,
   addFileToGraph: () => addFileToGraph
 });
-import { existsSync as existsSync29, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync23 } from "fs";
 var {Glob: Glob9 } = globalThis.Bun;
-import { resolve as resolve27 } from "path";
+import { resolve as resolve28 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -22898,8 +23535,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
-  const fromDir = resolve27(fromFile, "..");
-  const normalized = resolve27(fromDir, importPath);
+  const fromDir = resolve28(fromFile, "..");
+  const normalized = resolve28(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -22929,7 +23566,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve27(filePath);
+  const normalizedPath = resolve28(filePath);
   if (!existsSync29(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
@@ -22956,10 +23593,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) => resolve27(dir)).filter((dir) => existsSync29(dir));
+  const resolvedDirs = directories.map((dir) => resolve28(dir)).filter((dir) => existsSync29(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file4 of allFiles) {
-    const fullPath = resolve27(file4);
+    const fullPath = resolve28(file4);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -23053,15 +23690,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync22(filePath, "utf-8");
+    const content = readFileSync23(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync22(filePath, "utf-8");
+    const content = readFileSync23(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync22(filePath, "utf-8");
+    const content = readFileSync23(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -23072,7 +23709,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve27(changedFile);
+  const normalizedPath = resolve28(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -23103,7 +23740,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, removeDependentsForFile = (graph, normalizedPath) => {
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve27(filePath);
+  const normalizedPath = resolve28(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -23146,12 +23783,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 // src/dev/configResolver.ts
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve28(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve28(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve29(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve29(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -23174,6 +23811,7 @@ var init_configResolver = () => {};
 var createHMRState = (config) => ({
   activeFrameworks: new Set,
   assetStore: new Map,
+  clientTargets: new Map,
   config,
   connectedClients: new Set,
   debounceTimeout: null,
@@ -23208,8 +23846,8 @@ var init_clientManager = __esm(() => {
 });
 // src/dev/pathUtils.ts
-import { existsSync as existsSync30, readdirSync as readdirSync6, readFileSync as readFileSync23 } from "fs";
-import { dirname as dirname20, resolve as resolve29 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync6, readFileSync as readFileSync24 } from "fs";
+import { dirname as dirname22, resolve as resolve30 } from "path";
 var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   if (shouldIgnorePath(filePath, resolved)) {
     return "ignored";
@@ -23285,7 +23923,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   return "unknown";
 }, collectAngularResourceDirs = (angularDir) => {
   const out = new Set;
-  const angularRoot = resolve29(angularDir);
+  const angularRoot = resolve30(angularDir);
   const angularRootNormalized = normalizePath(angularRoot);
   const walk = (dir) => {
     let entries;
@@ -23298,7 +23936,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = resolve29(dir, entry.name);
+      const full = resolve30(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
@@ -23308,7 +23946,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
       }
       let source;
       try {
-        source = readFileSync23(full, "utf8");
+        source = readFileSync24(full, "utf8");
       } catch {
         continue;
       }
@@ -23337,10 +23975,10 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
             refs.push(strMatch[1]);
         }
       }
-      const componentDir = dirname20(full);
+      const componentDir = dirname22(full);
       for (const ref of refs) {
-        const refAbs = normalizePath(resolve29(componentDir, ref));
-        const refDir = normalizePath(dirname20(refAbs));
+        const refAbs = normalizePath(resolve30(componentDir, ref));
+        const refDir = normalizePath(dirname22(refAbs));
         if (refDir === angularRootNormalized || refDir.startsWith(`${angularRootNormalized}/`)) {
           continue;
         }
@@ -23356,7 +23994,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   const push = (path) => {
     if (!path)
       return;
-    const abs = normalizePath(resolve29(cwd2, path));
+    const abs = normalizePath(resolve30(cwd2, path));
     if (!roots.includes(abs))
       roots.push(abs);
   };
@@ -23381,7 +24019,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
   push(cfg.assetsDir);
   push(cfg.stylesDir);
   for (const candidate of ["src", "db", "assets", "styles"]) {
-    const abs = normalizePath(resolve29(cwd2, candidate));
+    const abs = normalizePath(resolve30(cwd2, candidate));
     if (existsSync30(abs) && !roots.includes(abs))
       roots.push(abs);
   }
@@ -23392,7 +24030,7 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
         continue;
       if (entry.name.startsWith("."))
         continue;
-      const abs = normalizePath(resolve29(cwd2, entry.name));
+      const abs = normalizePath(resolve30(cwd2, entry.name));
       if (roots.includes(abs))
         continue;
       if (shouldIgnorePath(abs, resolved))
@@ -23476,7 +24114,7 @@ var init_pathUtils = __esm(() => {
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
 import { existsSync as existsSync31, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
-import { dirname as dirname21, join as join38, resolve as resolve30 } from "path";
+import { dirname as dirname23, join as join40, resolve as resolve31 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -23508,7 +24146,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     for (const name of entries) {
       if (shouldSkipFilename(name, isStylesDir))
         continue;
-      const child = join38(eventDir, name).replace(/\\/g, "/");
+      const child = join40(eventDir, name).replace(/\\/g, "/");
       let st2;
       try {
         st2 = statSync4(child);
@@ -23529,7 +24167,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       return;
     if (shouldSkipFilename(filename, isStylesDir)) {
       if (event === "rename") {
-        const eventDir = dirname21(join38(absolutePath, filename)).replace(/\\/g, "/");
+        const eventDir = dirname23(join40(absolutePath, filename)).replace(/\\/g, "/");
         atomicRecoveryScan(eventDir);
         for (const delay of [25, 100]) {
           const timer = setTimeout(() => atomicRecoveryScan(eventDir), delay);
@@ -23538,7 +24176,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
       }
       return;
     }
-    const fullPath = join38(absolutePath, filename).replace(/\\/g, "/");
+    const fullPath = join40(absolutePath, filename).replace(/\\/g, "/");
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
@@ -23556,7 +24194,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve30(path).replace(/\\/g, "/");
+    const absolutePath = resolve31(path).replace(/\\/g, "/");
     if (!existsSync31(absolutePath)) {
       return;
     }
@@ -23567,7 +24205,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve30(path).replace(/\\/g, "/");
+    const absolutePath = resolve31(path).replace(/\\/g, "/");
     if (!existsSync31(absolutePath)) {
       return;
     }
@@ -23586,13 +24224,13 @@ var init_fileWatcher = __esm(() => {
 });
 // src/dev/assetStore.ts
-import { resolve as resolve31 } from "path";
+import { resolve as resolve32 } from "path";
 import { readdir as readdir4, 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 = resolve31(dir, entry.name);
+  const fullPath = resolve32(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -23608,10 +24246,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve31(buildDir, webPath.slice(1));
+    const diskPath = resolve32(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve31(buildDir);
+  const absBuildDir = resolve32(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -23629,7 +24267,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve31(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve32(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -23638,7 +24276,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve31(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve32(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -23660,7 +24298,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve31(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve32(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -23705,8 +24343,8 @@ var init_assetStore = __esm(() => {
 });
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync24 } from "fs";
-import { dirname as dirname22, resolve as resolve32 } from "path";
+import { readFileSync as readFileSync25 } from "fs";
+import { dirname as dirname24, resolve as resolve33 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -23726,15 +24364,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve32(dirname22(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve32(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve33(dirname24(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve33(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata, target) => metadata.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve32(candidate) === target : false;
+  return candidate ? resolve33(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve32(sourcePath);
+  const target = resolve33(sourcePath);
   return [...getCurrentPageIslandMetadata().values()].filter((metadata) => metadataUsesSource(metadata, target)).map((metadata) => metadata.pagePath);
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
   const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
@@ -23746,13 +24384,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve32(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve33(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync24(filePath, "utf-8");
+    const source = readFileSync25(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve32(filePath), {
+    pageMetadata.set(resolve33(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve32(filePath)
+      pagePath: resolve33(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -23779,10 +24417,10 @@ var init_pageMetadata = __esm(() => {
 });
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync26 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync25(filePath);
+    const fileContent = readFileSync26(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -23818,9 +24456,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;
@@ -23875,9 +24513,9 @@ var init_transformCache = __esm(() => {
 });
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve33 } from "path";
+import { resolve as resolve34 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve33(filePath);
+  const normalizedPath = resolve34(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -23889,7 +24527,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 // src/dev/moduleMapper.ts
-import { basename as basename15, resolve as resolve34 } from "path";
+import { basename as basename15, resolve as resolve35 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -23899,7 +24537,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve34(sourceFile);
+  const normalizedFile = resolve35(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -23935,7 +24573,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve34(sourceFile);
+  const normalizedFile = resolve35(sourceFile);
   const fileName = basename15(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -23991,7 +24629,7 @@ var init_moduleMapper = __esm(() => {
 // src/utils/spaRouteCss.ts
 import { readFile as readFile6 } from "fs/promises";
-import { dirname as dirname23, isAbsolute as isAbsolute5, resolve as resolve35 } from "path";
+import { dirname as dirname25, isAbsolute as isAbsolute5, resolve as resolve36 } from "path";
 var sideManifestCache, readSideManifest = async (sideManifestPath) => {
   const cached = sideManifestCache.get(sideManifestPath);
   if (cached !== undefined)
@@ -24029,7 +24667,7 @@ var sideManifestCache, readSideManifest = async (sideManifestPath) => {
 }, readChildCss = async (cssPath, sideManifestPath) => {
   if (!cssPath)
     return "";
-  const resolvedCssPath = isAbsolute5(cssPath) ? cssPath : resolve35(dirname23(sideManifestPath), cssPath);
+  const resolvedCssPath = isAbsolute5(cssPath) ? cssPath : resolve36(dirname25(sideManifestPath), cssPath);
   const cached = childCssCache.get(resolvedCssPath);
   if (cached !== undefined)
     return cached;
@@ -24112,8 +24750,8 @@ __export(exports_resolveOwningComponents, {
   resolveDescendantsOfParent: () => resolveDescendantsOfParent,
   invalidateResourceIndex: () => invalidateResourceIndex
 });
-import { readdirSync as readdirSync8, readFileSync as readFileSync26, statSync as statSync5 } from "fs";
-import { dirname as dirname24, extname as extname11, join as join39, resolve as resolve36 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync27, statSync as statSync5 } from "fs";
+import { dirname as dirname26, extname as extname11, join as join41, resolve as resolve37 } from "path";
 import ts18 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") || file4.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
@@ -24128,7 +24766,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const full = join39(dir, entry.name);
+      const full = join41(dir, entry.name);
       if (entry.isDirectory()) {
         visit(full);
       } else if (entry.isFile() && isAngularSourceFile(entry.name)) {
@@ -24172,7 +24810,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
 }, parseDecoratedClasses = (filePath) => {
   let source;
   try {
-    source = readFileSync26(filePath, "utf8");
+    source = readFileSync27(filePath, "utf8");
   } catch {
     return [];
   }
@@ -24226,7 +24864,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   };
   visit(sourceFile);
   return out;
-}, safeNormalize = (path) => resolve36(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
+}, safeNormalize = (path) => resolve37(path).replace(/\\/g, "/"), resolveOwningComponents = (params) => {
   const { changedFilePath, userAngularRoot } = params;
   const changedAbs = safeNormalize(changedFilePath);
   const out = [];
@@ -24262,12 +24900,12 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
 }, indexByRoot, resolveParentClassFile = (parentName, childFilePath, angularRoot) => {
   let source;
   try {
-    source = readFileSync26(childFilePath, "utf8");
+    source = readFileSync27(childFilePath, "utf8");
   } catch {
     return null;
   }
   const sourceFile = ts18.createSourceFile(childFilePath, source, ts18.ScriptTarget.ES2022, true, ts18.ScriptKind.TS);
-  const childDir = dirname24(childFilePath);
+  const childDir = dirname26(childFilePath);
   for (const stmt of sourceFile.statements) {
     if (!ts18.isImportDeclaration(stmt))
       continue;
@@ -24295,7 +24933,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     if (!spec.startsWith(".") && !spec.startsWith("/")) {
       return null;
     }
-    const base = resolve36(childDir, spec);
+    const base = resolve37(childDir, spec);
     const candidates = [
       `${base}.ts`,
       `${base}.tsx`,
@@ -24324,7 +24962,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   const parentFile = new Map;
   for (const tsPath of walkAngularSourceFiles(userAngularRoot)) {
     const classes = parseDecoratedClasses(tsPath);
-    const componentDir = dirname24(tsPath);
+    const componentDir = dirname26(tsPath);
     for (const cls of classes) {
       const entity = {
         className: cls.className,
@@ -24333,7 +24971,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
       };
       if (cls.kind === "component") {
         for (const url of [...cls.templateUrls, ...cls.styleUrls]) {
-          const abs = safeNormalize(resolve36(componentDir, url));
+          const abs = safeNormalize(resolve37(componentDir, url));
           const existing = resource.get(abs);
           if (existing)
             existing.push(entity);
@@ -24460,6 +25098,7 @@ var MAX_RETAINED_HMR_UPDATES = 100, normalizedHmrTarget = (value) => {
   });
   clientsToRemove.forEach((client) => {
     state.connectedClients.delete(client);
+    state.clientTargets.delete(client);
   });
 }, handleClientConnect = (state, client, manifest) => {
   state.connectedClients.add(client);
@@ -24500,6 +25139,7 @@ var MAX_RETAINED_HMR_UPDATES = 100, normalizedHmrTarget = (value) => {
   }
 }, handleClientDisconnect = (state, client) => {
   state.connectedClients.delete(client);
+  state.clientTargets.delete(client);
 }, parseJsonSafe = (raw) => JSON.parse(raw), parseMessage = (message) => {
   if (typeof message === "string") {
     return parseJsonSafe(message);
@@ -24529,11 +25169,13 @@ var MAX_RETAINED_HMR_UPDATES = 100, normalizedHmrTarget = (value) => {
     case "request-rebuild":
       break;
     case "ready":
+      state.clientTargets.set(client, normalizedHmrTarget(data.target));
       if (data.framework) {
         state.activeFrameworks.add(data.framework);
       }
       break;
     case "hmr-timing": {
+      state.clientTargets.set(client, normalizedHmrTarget(data.target));
       const update = typeof data.updateId === "number" ? state.hmrUpdates.get(data.updateId) : undefined;
       logHmrClientUpdate(update?.path ?? state.lastHmrPath ?? "", update?.framework ?? state.lastHmrFramework, data.duration, normalizedHmrTarget(data.target), data.serverMs, data.clientMs, data.outcome, data.kind);
       sendTelemetryEvent("hmr:client-applied", {
@@ -24589,7 +25231,7 @@ __export(exports_loadConfig, {
   isWorkspaceConfig: () => isWorkspaceConfig,
   getWorkspaceServices: () => getWorkspaceServices
 });
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 var RESERVED_TOP_LEVEL_KEYS, isObject2 = (value) => typeof value === "object" && value !== null, isCommandService = (service) => service.kind === "command" || Array.isArray(service.command), isServiceCandidate = (value) => isObject2(value) && (typeof value.entry === "string" || Array.isArray(value.command)), isWorkspaceConfig = (config) => {
   if (!isObject2(config)) {
     return false;
@@ -24640,7 +25282,7 @@ var RESERVED_TOP_LEVEL_KEYS, isObject2 = (value) => typeof value === "object" &&
   }
   return config;
 }, loadRawConfig = async (configPath2) => {
-  const resolved = resolve37(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const resolved = resolve38(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
   const mod = await import(resolved);
   const config = mod.default ?? mod.config;
   if (!config) {
@@ -24702,8 +25344,8 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync32, readFileSync as readFileSync27, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
-import { basename as basename16, dirname as dirname25, extname as extname12, join as join40, resolve as resolve38, relative as relative16 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync28, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
+import { basename as basename16, dirname as dirname27, extname as extname12, join as join42, resolve as resolve39, 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 = [];
@@ -24723,10 +25365,10 @@ var SRC_PREFIX = "/@src/", BROWSER_DEFINE, jsTranspiler2, legacyDecoratorTsconfi
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const directHit = extensions.find((ext) => existsSync32(resolve38(projectRoot, srcPath + ext)));
+  const directHit = extensions.find((ext) => existsSync32(resolve39(projectRoot, srcPath + ext)));
   if (directHit)
     return srcPath + directHit;
-  const indexHit = extensions.find((ext) => existsSync32(resolve38(projectRoot, srcPath, `index${ext}`)));
+  const indexHit = extensions.find((ext) => existsSync32(resolve39(projectRoot, srcPath, `index${ext}`)));
   if (indexHit)
     return `${srcPath}/index${indexHit}`;
   return srcPath;
@@ -24749,7 +25391,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve38(projectRoot, relPath);
+  const absPath = resolve39(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -24761,12 +25403,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve38(fileDir, relPath);
+  const absPath = resolve39(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(resolve38(projectRoot, srcPath)));
+    srcPath = relative16(projectRoot, resolveSvelteModulePath(resolve39(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -24785,13 +25427,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 = resolve38(projectRoot, "node_modules", packageName ?? "");
-        const pkgJsonPath = join40(pkgDir, "package.json");
+        const pkgDir = resolve39(projectRoot, "node_modules", packageName ?? "");
+        const pkgJsonPath = join42(pkgDir, "package.json");
         if (existsSync32(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync27(pkgJsonPath, "utf-8"));
+          const pkg = JSON.parse(readFileSync28(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve38(pkgDir, esmEntry);
+            const resolved = resolve39(pkgDir, esmEntry);
             if (existsSync32(resolved))
               return relative16(projectRoot, resolved);
           }
@@ -24829,7 +25471,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 = dirname25(filePath);
+  const fileDir = dirname27(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);
@@ -24844,12 +25486,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 = resolve38(fileDir, relPath);
+    const absPath = resolve39(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 = resolve38(fileDir, relPath);
+    const absPath = resolve39(fileDir, relPath);
     const rel = relative16(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
@@ -24895,7 +25537,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 = readFileSync27(filePath, "utf-8");
+  const raw = readFileSync28(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -24911,7 +25553,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync27(filePath, "utf-8");
+  const raw = readFileSync28(filePath, "utf-8");
   const ext = extname12(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -25077,7 +25719,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 = readFileSync27(filePath, "utf-8");
+  const raw = readFileSync28(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -25143,7 +25785,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync27(filePath, "utf-8");
+  const rawSource = readFileSync28(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await loadVueCompiler();
@@ -25156,7 +25798,7 @@ ${code}`;
     fs: {
       fileExists: existsSync32,
       realpath: realpathSync3,
-      readFile: (file4) => existsSync32(file4) ? readFileSync27(file4, "utf-8") : undefined
+      readFile: (file4) => existsSync32(file4) ? readFileSync28(file4, "utf-8") : undefined
     },
     id: componentId,
     inlineTemplate: false
@@ -25171,7 +25813,7 @@ ${code}`;
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve38(vueDir) : projectRoot;
+  const hmrBase = vueDir ? resolve39(vueDir) : projectRoot;
   const hmrId = relative16(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
@@ -25203,7 +25845,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync27(filePath, "utf-8");
+  const raw = readFileSync28(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -25335,7 +25977,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 = resolve38(projectRoot, relPath);
+  const filePath = resolve39(projectRoot, relPath);
   const ext = extname12(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -25372,14 +26014,14 @@ export default {};
           const absoluteCandidate = `/${tail.replace(/^\/+/, "")}`;
           const candidates = [
             absoluteCandidate,
-            resolve38(projectRoot, tail)
+            resolve39(projectRoot, tail)
           ];
           try {
             const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_loadConfig(), exports_loadConfig));
             const cfg = await loadConfig2();
-            const angularDir = cfg.angularDirectory && resolve38(projectRoot, cfg.angularDirectory);
+            const angularDir = cfg.angularDirectory && resolve39(projectRoot, cfg.angularDirectory);
             if (angularDir)
-              candidates.push(resolve38(angularDir, tail));
+              candidates.push(resolve39(angularDir, tail));
           } catch {}
           for (const candidate of candidates) {
             if (await fileExists(candidate)) {
@@ -25410,7 +26052,7 @@ export default {};
   if (!TRANSPILABLE.has(ext))
     return;
   const stat3 = statSync6(filePath);
-  const resolvedVueDir = vueDir ? resolve38(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve39(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) {
@@ -25469,7 +26111,7 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve38(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve39(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
@@ -25485,11 +26127,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve38(projectRoot, match[1]));
+      files.push(resolve39(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve38(filePath);
+  const resolved = resolve39(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -25652,7 +26294,7 @@ __export(exports_hmrCompiler, {
   getApplyMetadataModule: () => getApplyMetadataModule,
   encodeHmrComponentId: () => encodeHmrComponentId
 });
-import { dirname as dirname26, relative as relative17, resolve as resolve39 } from "path";
+import { dirname as dirname28, relative as relative17, resolve as resolve40 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var encodeHmrComponentId = (absoluteFilePath, className) => {
   const projectRel = relative17(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
@@ -25664,7 +26306,7 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
     return null;
   const filePathRel = decoded.slice(0, separatorIndex);
   const className = decoded.slice(separatorIndex + 1);
-  const componentFilePath = resolve39(process.cwd(), filePathRel);
+  const componentFilePath = resolve40(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));
@@ -25675,7 +26317,7 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const owners = resolveOwningComponents2({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname26(componentFilePath)
+    userAngularRoot: dirname28(componentFilePath)
   });
   const owner = owners.find((o3) => o3.className === className);
   const kind = owner?.kind ?? "component";
@@ -25870,11 +26512,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve40 } from "path";
+import { resolve as resolve41 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve40(htmlFilePath);
+    const resolvedPath = resolve41(htmlFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -25900,11 +26542,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve41 } from "path";
+import { resolve as resolve42 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve41(htmxFilePath);
+    const resolvedPath = resolve42(htmxFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -25929,9 +26571,9 @@ var init_simpleHTMXHMR = () => {};
 import { existsSync as existsSync33, readdirSync as readdirSync9, rmSync as rmSync3 } from "fs";
 import {
   basename as basename17,
-  dirname as dirname27,
+  dirname as dirname29,
   isAbsolute as isAbsolute6,
-  join as join41,
+  join as join43,
   relative as relative18,
   resolve as resolvePath,
   sep as sep4
@@ -26058,8 +26700,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     const relJs = `${rel.slice(0, -ext[0].length)}.js`;
     const generatedDir = getFrameworkGeneratedDir(framework, cwd2);
     for (const candidate of [
-      join41(generatedDir, relJs),
-      `${join41(generatedDir, relJs)}.map`
+      join43(generatedDir, relJs),
+      `${join43(generatedDir, relJs)}.map`
     ]) {
       try {
         rmSync3(candidate, { force: true });
@@ -26293,8 +26935,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
       const relFromDir = normalizedSource.slice(normalizedDir.length + 1);
       const { buildDir } = state.resolvedPaths;
       const destPath = resolvePath(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
-      const { mkdir: mkdir8, copyFile, readFile: readFile7 } = await import("fs/promises");
-      await mkdir8(dirname27(destPath), { recursive: true });
+      const { mkdir: mkdir9, copyFile, readFile: readFile7 } = await import("fs/promises");
+      await mkdir9(dirname29(destPath), { recursive: true });
       await copyFile(absSource, destPath);
       const bytes = await readFile7(destPath);
       const webPath = urlPrefix ? `/${urlPrefix}/${relFromDir}` : `/${relFromDir}`;
@@ -26475,7 +27117,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const keepStemsByDir = new Map;
   const prefixByDir = new Map;
   for (const artifact of freshOutputs) {
-    const dir = dirname27(artifact.path);
+    const dir = dirname29(artifact.path);
     const name = basename17(artifact.path);
     const [prefix] = name.split(".");
     if (!prefix)
@@ -26838,8 +27480,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve42) => {
-        ctx.debouncedResolve = resolve42;
+      ctx.debouncedPromise = new Promise((resolve43) => {
+        ctx.debouncedResolve = resolve43;
       });
     }
     const scheduled = ctx.debouncedPromise;
@@ -26961,7 +27603,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
         const entries = await readdir5(dir, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
-          const full = join41(dir, entry.name);
+          const full = join43(dir, entry.name);
           if (entry.isDirectory()) {
             files.push(...await walk(full));
           } else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
@@ -27371,8 +28013,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return () => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve42) => {
-        ctx.debouncedResolve = resolve42;
+      ctx.debouncedPromise = new Promise((resolve43) => {
+        ctx.debouncedResolve = resolve43;
       });
     }
     if (ctx.debounceTimer)
@@ -27521,7 +28163,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   } = await compileVue2(vueFiles, vueDir, true, getStyleTransformConfig(state.config));
   const serverEntries = [...vueServerPaths];
   const clientEntries = [...vueIndexPaths, ...vueClientPaths];
-  const cssOutDir = join41(buildDir, state.resolvedPaths.assetsDir ? basename17(state.resolvedPaths.assetsDir) : "assets", "css");
+  const cssOutDir = join43(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();
@@ -27646,8 +28288,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return () => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve42) => {
-        ctx.debouncedResolve = resolve42;
+      ctx.debouncedPromise = new Promise((resolve43) => {
+        ctx.debouncedResolve = resolve43;
       });
     }
     if (ctx.debounceTimer)
@@ -27733,7 +28375,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     });
   });
   return allModuleUpdates;
-}, handleReactHMR = (state, affectedFrameworks, filesToRebuild, manifest, duration) => {
+}, handleReactHMR = async (state, affectedFrameworks, filesToRebuild, manifest, duration) => {
   if (!affectedFrameworks.includes("react") || !state.resolvedPaths.reactDir) {
     return;
   }
@@ -27745,14 +28387,21 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const sourceFiles = reactPageFiles.length > 0 ? reactPageFiles : reactFiles;
   const [primarySource] = sourceFiles;
   try {
-    const hasComponentChanges = reactFiles.some((file4) => file4.endsWith(".tsx") || file4.endsWith(".ts") || file4.endsWith(".jsx"));
-    const hasCSSChanges = reactFiles.some(isStylePath);
+    const {
+      isReactFastRefreshSupported: isReactFastRefreshSupported2,
+      warnIfReactFastRefreshUnsupported: warnIfReactFastRefreshUnsupported2
+    } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
+    warnIfReactFastRefreshUnsupported2();
+    await handleReactModuleServerPath(state, reactFiles, Date.now() - duration, isReactFastRefreshSupported2(), () => {
+      return;
+    });
+  } catch (err) {
     logHmrUpdate(primarySource ?? reactFiles[0] ?? "", "react", duration);
     broadcastToClients(state, {
       data: {
         framework: "react",
-        hasComponentChanges,
-        hasCSSChanges,
+        hasComponentChanges: true,
+        hasCSSChanges: reactFiles.some(isStylePath),
         manifest,
         primarySource,
         serverDuration: duration,
@@ -27760,7 +28409,6 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
       },
       type: "react-update"
     });
-  } catch (err) {
     console.error("[hmr] react live update failed:", err instanceof Error ? err.message : err);
     sendTelemetryEvent("hmr:error", {
       framework: "react",
@@ -27791,7 +28439,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolvePath(dirname27(buildInfo.resolvedRegistryPath), buildReference.source);
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolvePath(dirname29(buildInfo.resolvedRegistryPath), buildReference.source);
   islandFiles.add(resolvePath(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
@@ -27819,8 +28467,14 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   }
   setCurrentPageIslandMetadata(await loadPageIslandMetadata(config));
   const affectedPages = filesToRebuild.flatMap((file4) => getPagesUsingIslandSource(file4));
+  if (affectedPages.length === 0)
+    return true;
+  const affectedFrameworks = [
+    ...new Set(affectedPages.map((page) => detectFramework(page, state.resolvedPaths)).filter((framework) => framework !== "ignored"))
+  ];
   broadcastToClients(state, {
     data: {
+      affectedFrameworks,
       affectedPages,
       framework: "islands",
       manifest,
@@ -28212,7 +28866,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   }
 }, handleFullBuildHMR = async (state, config, affectedFrameworks, filesToRebuild, manifest, duration) => {
   const allModuleUpdates = collectAllModuleUpdates(affectedFrameworks, filesToRebuild, manifest, state);
-  handleReactHMR(state, affectedFrameworks, filesToRebuild, manifest, duration);
+  await handleReactHMR(state, affectedFrameworks, filesToRebuild, manifest, duration);
   handleHTMLScriptHMR(state, filesToRebuild, manifest, duration);
   await handleHTMLPageHMR(state, config, filesToRebuild, manifest, duration);
   await handleVueHMR(state, config, filesToRebuild, manifest, duration);
@@ -28439,7 +29093,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     message: "Rebuild completed successfully",
     type: "rebuild-complete"
   });
-  if (config.tailwind && filesToRebuild && filesToRebuild.some(isTailwindCandidate)) {
+  const hasDedicatedStyleUpdate = affectedFrameworks.some((framework) => framework === "styles" || framework === "assets");
+  if (config.tailwind && filesToRebuild && filesToRebuild.some(isTailwindCandidate) && !hasDedicatedStyleUpdate) {
     try {
       const outputPath = resolvePath(state.resolvedPaths.buildDir, config.tailwind.output);
       const bytes = await Bun.file(outputPath).bytes();
@@ -28460,6 +29115,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const hasFilesToRebuild = filesToRebuild && filesToRebuild.length > 0;
   const didReloadForIslandChange = hasFilesToRebuild ? await handleIslandSourceReload(state, config, filesToRebuild, manifest, duration) : false;
   if (didReloadForIslandChange) {
+    await runFrameworkFastPaths(state, config, affectedFrameworks, filesToRebuild ?? [], startTime, onRebuildComplete);
     onRebuildComplete({ hmrState: state, manifest });
     return manifest;
   }
@@ -28616,8 +29272,8 @@ __export(exports_buildDepVendor, {
 });
 import { mkdirSync as mkdirSync14 } from "fs";
 import { isBuiltin } from "module";
-import { join as join42 } from "path";
-import { rm as rm10 } from "fs/promises";
+import { join as join44 } from "path";
+import { rm as rm11 } from "fs/promises";
 var {build: bunBuild9, Glob: Glob10 } = globalThis.Bun;
 var toSafeFileName6 = (specifier) => {
   const prefix = specifier.startsWith("@") ? "_" : "";
@@ -28675,8 +29331,8 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable3)
   };
 }, collectBareImportsFromFile = async (entryPath, transpiler6, maxDepth = 8) => {
-  const { readFileSync: readFileSync28 } = await import("fs");
-  const { dirname: dirname28 } = await import("path");
+  const { readFileSync: readFileSync29 } = await import("fs");
+  const { dirname: dirname30 } = await import("path");
   const seenFiles = new Set;
   const bareOut = new Set;
   const queue = [
@@ -28691,7 +29347,7 @@ var toSafeFileName6 = (specifier) => {
       continue;
     let content;
     try {
-      content = readFileSync28(path, "utf-8");
+      content = readFileSync29(path, "utf-8");
     } catch {
       continue;
     }
@@ -28701,7 +29357,7 @@ var toSafeFileName6 = (specifier) => {
     } catch {
       continue;
     }
-    const fromDir = dirname28(path);
+    const fromDir = dirname30(path);
     for (const imp of imports) {
       const child = imp.path;
       if (child.startsWith(".") || child.startsWith("/")) {
@@ -28765,7 +29421,7 @@ var toSafeFileName6 = (specifier) => {
 }), buildDepVendorPass = async (specifiers, vendorDir, tmpDir) => {
   const entries = await Promise.all(specifiers.map(async (specifier) => {
     const safeName = toSafeFileName6(specifier);
-    const entryPath = join42(tmpDir, `${safeName}.ts`);
+    const entryPath = join44(tmpDir, `${safeName}.ts`);
     await Bun.write(entryPath, await generateVendorEntrySource(specifier));
     return { entryPath, specifier };
   }));
@@ -28856,9 +29512,9 @@ var toSafeFileName6 = (specifier) => {
   const { dep: initialSpecs, framework: frameworkRoots } = await scanBareImports(directories);
   if (initialSpecs.length === 0 && frameworkRoots.length === 0)
     return {};
-  const vendorDir = join42(buildDir, "vendor");
+  const vendorDir = join44(buildDir, "vendor");
   mkdirSync14(vendorDir, { recursive: true });
-  const tmpDir = join42(buildDir, "_dep_vendor_tmp");
+  const tmpDir = join44(buildDir, "_dep_vendor_tmp");
   mkdirSync14(tmpDir, { recursive: true });
   const allSpecs = new Set(initialSpecs);
   const alreadyScanned = new Set;
@@ -28878,7 +29534,7 @@ var toSafeFileName6 = (specifier) => {
   if (!success) {
     console.warn("\u26A0\uFE0F Dependency vendor build had errors:", result.logs);
   }
-  await rm10(tmpDir, { force: true, recursive: true });
+  await rm11(tmpDir, { force: true, recursive: true });
   const paths = {};
   for (const specifier of allSpecs) {
     paths[specifier] = `/vendor/${toSafeFileName6(specifier)}.js`;
@@ -28941,7 +29597,7 @@ __export(exports_devBuild, {
 });
 import { readdir as readdir5 } from "fs/promises";
 import { statSync as statSync7 } from "fs";
-import { resolve as resolve42 } from "path";
+import { resolve as resolve43 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -28964,7 +29620,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve42(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve43(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -29076,7 +29732,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     });
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync7(resolve42(Bun.main)).mtimeMs;
+  const serverMtime = statSync7(resolve43(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -29113,8 +29769,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve42(import.meta.dir, "..", "..", "package.json"),
-    resolve42(import.meta.dir, "..", "package.json")
+    resolve43(import.meta.dir, "..", "..", "package.json"),
+    resolve43(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -29140,7 +29796,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const entries = await readdir5(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(resolve42(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve43(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -29149,6 +29805,9 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     await handleCachedReload();
     return cached;
   }
+  if (config.reactDirectory && !globalThis.__reactModuleRef) {
+    globalThis.__reactModuleRef = await import("react");
+  }
   const startupSteps = [];
   const recordStep = (label, startedAt) => {
     const durationMs = performance.now() - startedAt;
@@ -29276,11 +29935,11 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   cleanStaleAssets(state.assetStore, manifest, state.resolvedPaths.buildDir);
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
-  const reactVendorDir = resolve42(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve42(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve42(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve42(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve42(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve43(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve43(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve43(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve43(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve43(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),
@@ -29324,9 +29983,6 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     config.vueDirectory ? loadVendorFiles(state.assetStore, vueVendorDir, "vue") : Promise.resolve(),
     loadVendorFiles(state.assetStore, depVendorDir, "vendor")
   ]);
-  if (config.reactDirectory && !globalThis.__reactModuleRef) {
-    globalThis.__reactModuleRef = await import("react");
-  }
   recordStep("load vendor files", stepStartedAt);
   stepStartedAt = performance.now();
   const { warmCompilers: warmCompilers2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
@@ -29361,7 +30017,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync7(resolve42(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync7(resolve43(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -29398,5 +30054,5 @@ export {
   build
 };
-//# debugId=AEC5AC744032F0A464756E2164756E21
+//# debugId=97F7FEF3814DEF7D64756E2164756E21
 //# sourceMappingURL=build.js.map