@absolutejs/absolute 0.20.0-beta.80 → 0.20.0-beta.82

package/dist/build.js

@@ -27618,10 +27618,14 @@ var DEFAULT_BATCH_SIZE = 12, DEFAULT_POLL_MS = 25, DEFAULT_MAX_PAUSE_MS = 2000,
 };
 
 // src/mobile/config.ts
+var exports_config = {};
+__export(exports_config, {
+  normalizeAbsoluteMobileConfig: () => normalizeAbsoluteMobileConfig
+});
 import { readFileSync as readFileSync35 } from "fs";
 import { resolve as resolve44 } from "path";
 import { createHash as createHash5, createPublicKey, X509Certificate } from "crypto";
-var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FINGERPRINT_PATTERN, UPDATE_NAME_PATTERN, UPDATE_PUBLIC_KEY_PATTERN, DEFAULT_UPDATE_BOOT_TIMEOUT_MS = 20000, MINIMUM_UPDATE_BOOT_TIMEOUT_MS = 5000, MAXIMUM_UPDATE_BOOT_TIMEOUT_MS = 120000, HOSTNAME_PATTERN, EXPO_RESERVED_ROUTE_PREFIXES, resolveProjectPath = (projectRoot, value, field) => {
+var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FINGERPRINT_PATTERN, UPDATE_NAME_PATTERN, UPDATE_PUBLIC_KEY_PATTERN, ENVIRONMENT_NAME_PATTERN, DEFAULT_UPDATE_BOOT_TIMEOUT_MS = 20000, MINIMUM_UPDATE_BOOT_TIMEOUT_MS = 5000, MAXIMUM_UPDATE_BOOT_TIMEOUT_MS = 120000, HOSTNAME_PATTERN, EXPO_RESERVED_ROUTE_PREFIXES, resolveProjectPath = (projectRoot, value, field) => {
   const root = resolve44(projectRoot);
   const path = resolve44(root, value);
   if (path !== root && !path.startsWith(`${root}/`)) {
@@ -27806,6 +27810,48 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     publicKeys,
     ...expoCodeSigning ? { expoCodeSigning } : {}
   };
+}, normalizeUpdateServer = (config, productionOrigin, projectRoot, updates) => {
+  if (!updates || !config.updates)
+    return;
+  const registryModule = requireText(config.updates.server?.registry ?? "mobile.update.ts", "mobile.updates.server.registry");
+  resolveProjectPath(projectRoot, registryModule, "mobile.updates.server.registry");
+  const expoPrivateKeyEnv = requireText(config.updates.server?.expoPrivateKeyEnv ?? "ABSOLUTE_EXPO_UPDATE_PRIVATE_KEY", "mobile.updates.server.expoPrivateKeyEnv");
+  if (!ENVIRONMENT_NAME_PATTERN.test(expoPrivateKeyEnv))
+    throw new TypeError("mobile.updates.server.expoPrivateKeyEnv must be a valid environment variable name.");
+  const autoMount = config.updates.server?.autoMount ?? true;
+  if (autoMount) {
+    const manifest = new URL(updates.manifestUrl);
+    if (manifest.origin !== productionOrigin)
+      throw new TypeError("mobile.updates.manifestUrl must use mobile.server.productionOrigin while mobile.updates.server.autoMount is enabled.");
+    if (!manifest.pathname.endsWith("/update.json"))
+      throw new TypeError("mobile.updates.manifestUrl must end in /update.json while mobile.updates.server.autoMount is enabled.");
+  }
+  const expoCodeSigningKeys = {};
+  if (updates.expoCodeSigning)
+    expoCodeSigningKeys[updates.expoCodeSigning.keyId] = {
+      certificatePem: updates.expoCodeSigning.certificatePem,
+      privateKeyEnv: expoPrivateKeyEnv
+    };
+  for (const [keyId, key] of Object.entries(config.updates.server?.expoCodeSigningKeys ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+    if (!updates.expoCodeSigning)
+      throw new TypeError("mobile.updates.server.expoCodeSigningKeys requires the Expo engine and expoCodeSigning.");
+    if (!UPDATE_NAME_PATTERN.test(keyId))
+      throw new TypeError("mobile.updates.server.expoCodeSigningKeys contains an invalid key ID.");
+    if (expoCodeSigningKeys[keyId])
+      throw new TypeError(`mobile.updates.server.expoCodeSigningKeys.${keyId} duplicates the active Expo key.`);
+    const privateKeyEnv = requireText(key.privateKeyEnv, `mobile.updates.server.expoCodeSigningKeys.${keyId}.privateKeyEnv`);
+    if (!ENVIRONMENT_NAME_PATTERN.test(privateKeyEnv))
+      throw new TypeError(`mobile.updates.server.expoCodeSigningKeys.${keyId}.privateKeyEnv must be a valid environment variable name.`);
+    const certificatePath = resolveProjectPath(projectRoot, requireText(key.certificatePath, `mobile.updates.server.expoCodeSigningKeys.${keyId}.certificatePath`), `mobile.updates.server.expoCodeSigningKeys.${keyId}.certificatePath`);
+    const { certificate, certificatePem } = readExpoCodeSigningCertificate(certificatePath);
+    if (certificate.publicKey.asymmetricKeyType !== "rsa" || certificate.issuer !== certificate.subject || !certificate.verify(certificate.publicKey))
+      throw new TypeError(`mobile.updates.server.expoCodeSigningKeys.${keyId} certificate must be a self-signed RSA root.`);
+    const now = Date.now();
+    if (now < Date.parse(certificate.validFrom) || now > Date.parse(certificate.validTo))
+      throw new TypeError(`mobile.updates.server.expoCodeSigningKeys.${keyId} certificate is not currently valid.`);
+    expoCodeSigningKeys[keyId] = { certificatePem, privateKeyEnv };
+  }
+  return { autoMount, expoCodeSigningKeys, registryModule };
 }, validateExpoNativeRouteSegment = (path, segment, index, count, parameters) => {
   if (segment === "*" && (index !== count - 1 || count === 1)) {
     throw new TypeError(`mobile.routes.native route ${path} must use * once, as the final segment after a static or parameterized prefix.`);
@@ -27865,6 +27911,7 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     throw new TypeError("mobile.deepLinks.scheme is not a valid URL scheme.");
   }
   const updates = normalizeUpdates(config, productionOrigin, projectRoot);
+  const updateServer = normalizeUpdateServer(config, productionOrigin, projectRoot, updates);
   const observability = normalizeObservability(config, productionOrigin);
   return {
     androidCertificateFingerprints: normalizeCertificateFingerprints(config.deepLinks?.android?.sha256CertificateFingerprints),
@@ -27884,7 +27931,8 @@ var APP_ID_PATTERN, SCHEME_PATTERN, APPLE_APP_ID_PREFIX_PATTERN, CERTIFICATE_FIN
     platforms: normalizePlatforms(config.platforms),
     productionOrigin,
     pushAndroidGoogleServicesFile: resolveProjectPath(projectRoot, config.pushNotifications?.android?.googleServicesFile ?? "google-services.json", "mobile.pushNotifications.android.googleServicesFile"),
-    ...updates ? { updates } : {}
+    ...updates ? { updates } : {},
+    ...updateServer ? { updateServer } : {}
   };
 };
 var init_config = __esm(() => {
@@ -27894,6 +27942,7 @@ var init_config = __esm(() => {
   CERTIFICATE_FINGERPRINT_PATTERN = /^[0-9A-F]{64}$/;
   UPDATE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
   UPDATE_PUBLIC_KEY_PATTERN = /^[A-Za-z0-9+/]+={0,2}$/u;
+  ENVIRONMENT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/u;
   HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/;
   EXPO_RESERVED_ROUTE_PREFIXES = new Set([
     "_expo",
@@ -28412,6 +28461,919 @@ var init_mobilePreviewClientBundle = __esm(() => {
   init_rewriteImportsPlugin();
 });
 
+// node_modules/@absolutejs/deploy/dist/mobileUpdate.js
+var exports_mobileUpdate = {};
+__export(exports_mobileUpdate, {
+  MOBILE_UPDATE_REGISTRY_FORMAT: () => MOBILE_UPDATE_REGISTRY_FORMAT,
+  MobileUpdateRegistryError: () => MobileUpdateRegistryError,
+  createMobileUpdateHandler: () => createMobileUpdateHandler,
+  createMobileUpdateRegistry: () => createMobileUpdateRegistry,
+  parseMobileUpdateManifest: () => parseMobileUpdateManifest
+});
+import {
+  createHash as createHash6,
+  createPrivateKey,
+  createPublicKey as createPublicKey2,
+  sign,
+  verify,
+  X509Certificate as X509Certificate2
+} from "crypto";
+import { readFile as readFile9, stat as stat3 } from "fs/promises";
+import path from "path";
+var MOBILE_UPDATE_REGISTRY_FORMAT = 1, DEFAULT_PREFIX = "absolutejs/mobile-updates", MAX_FILE_BYTES, MAX_TOTAL_BYTES, HASH, RELEASE, APP_ID, NAME, EXPO_DESCRIPTOR = "_absolute/expo-update.json", EXPO_CODE_SIGNING_ALGORITHM = "rsa-v1_5-sha256", MobileUpdateRegistryError, object3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), text2 = (value, field) => {
+  if (typeof value !== "string" || value.length === 0)
+    throw new MobileUpdateRegistryError(`Mobile update ${field} is invalid`);
+  return value;
+}, iso = (value) => typeof value === "string" && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value, safePath = (value) => {
+  const file5 = text2(value, "file path").replaceAll("\\", "/");
+  if (file5.startsWith("/") || file5.split("/").some((segment) => !segment || segment === "." || segment === ".."))
+    throw new MobileUpdateRegistryError("Mobile update file path is invalid");
+  return file5;
+}, expoAsset = (value) => {
+  if (!object3(value))
+    throw new MobileUpdateRegistryError("Expo update asset is invalid");
+  const assetPath = safePath(value.path);
+  if (value.extension !== undefined && (typeof value.extension !== "string" || !/^[A-Za-z0-9]+$/.test(value.extension)))
+    throw new MobileUpdateRegistryError("Expo update asset extension is invalid");
+  return {
+    ...typeof value.extension === "string" ? { extension: value.extension } : {},
+    path: assetPath
+  };
+}, parseExpoUpdateDescriptor = (bytes) => {
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    throw new MobileUpdateRegistryError("Expo update descriptor is invalid");
+  }
+  if (!object3(value) || value.engine !== "expo" || value.format !== 1 || !object3(value.expoConfig) || !object3(value.platforms) || typeof value.runtimeVersion !== "string" || !HASH.test(value.runtimeVersion))
+    throw new MobileUpdateRegistryError("Expo update descriptor is invalid");
+  const platforms = {};
+  for (const name of ["android", "ios"]) {
+    const candidate = value.platforms[name];
+    if (candidate === undefined)
+      continue;
+    if (!object3(candidate) || !Array.isArray(candidate.assets) || !object3(candidate.launchAsset))
+      throw new MobileUpdateRegistryError("Expo update platform descriptor is invalid");
+    platforms[name] = {
+      assets: candidate.assets.map(expoAsset),
+      launchAsset: expoAsset(candidate.launchAsset)
+    };
+  }
+  if (Object.keys(platforms).length === 0)
+    throw new MobileUpdateRegistryError("Expo update descriptor has no native platforms");
+  return {
+    engine: "expo",
+    expoConfig: value.expoConfig,
+    format: 1,
+    platforms,
+    runtimeVersion: value.runtimeVersion
+  };
+}, parseMobileUpdateManifest = (value) => {
+  if (!object3(value) || value.format !== 1)
+    throw new MobileUpdateRegistryError("Mobile update manifest is invalid");
+  const appId = text2(value.appId, "appId");
+  const channel = text2(value.channel, "channel");
+  const releaseId = text2(value.releaseId, "releaseId");
+  const runtimeFingerprint = text2(value.runtimeFingerprint, "runtime");
+  if (!APP_ID.test(appId) || !NAME.test(channel) || !RELEASE.test(releaseId))
+    throw new MobileUpdateRegistryError("Mobile update identity is invalid");
+  if (!HASH.test(runtimeFingerprint) || !iso(value.createdAt))
+    throw new MobileUpdateRegistryError("Mobile update runtime or timestamp is invalid");
+  if (value.classification !== "bug-fix" && value.classification !== "content" && value.classification !== "security")
+    throw new MobileUpdateRegistryError("Mobile update classification is invalid");
+  if (value.withinSubmittedPurpose !== true)
+    throw new MobileUpdateRegistryError("Mobile update policy attestation is missing");
+  if (!Array.isArray(value.files) || value.files.length === 0)
+    throw new MobileUpdateRegistryError("Mobile update file inventory is invalid");
+  const files = value.files.map((candidate) => {
+    if (!object3(candidate))
+      throw new MobileUpdateRegistryError("Mobile update file is invalid");
+    const filePath = safePath(candidate.path);
+    if (!Number.isSafeInteger(candidate.bytes) || Number(candidate.bytes) < 0 || Number(candidate.bytes) > MAX_FILE_BYTES || typeof candidate.sha256 !== "string" || !HASH.test(candidate.sha256))
+      throw new MobileUpdateRegistryError(`Mobile update file ${filePath} is invalid`);
+    return {
+      bytes: Number(candidate.bytes),
+      path: filePath,
+      sha256: candidate.sha256
+    };
+  });
+  if (files.reduce((total, file5) => total + file5.bytes, 0) > MAX_TOTAL_BYTES || new Set(files.map((file5) => file5.path)).size !== files.length || files.some((file5, index) => index > 0 ? file5.path.localeCompare(files[index - 1]?.path ?? "") <= 0 : false))
+    throw new MobileUpdateRegistryError("Mobile update file inventory is invalid");
+  const signatureKeyId = object3(value.signature) ? text2(value.signature.keyId, "signature key") : "";
+  const signatureValue = object3(value.signature) ? text2(value.signature.value, "signature") : "";
+  if (!object3(value.signature) || value.signature.algorithm !== "ecdsa-p256-sha256" || !NAME.test(signatureKeyId) || !/^[A-Za-z0-9+/]+={0,2}$/.test(signatureValue) || Buffer.from(signatureValue, "base64").byteLength !== 64 || Buffer.from(signatureValue, "base64").toString("base64") !== signatureValue)
+    throw new MobileUpdateRegistryError("Mobile update signature is invalid");
+  return {
+    appId,
+    channel,
+    classification: value.classification,
+    createdAt: value.createdAt,
+    files,
+    format: 1,
+    releaseId,
+    runtimeFingerprint,
+    signature: {
+      algorithm: "ecdsa-p256-sha256",
+      keyId: signatureKeyId,
+      value: signatureValue
+    },
+    withinSubmittedPurpose: true
+  };
+}, canonicalValue = (value) => {
+  if (Array.isArray(value))
+    return value.map(canonicalValue);
+  if (!object3(value))
+    return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalValue(value[key])]));
+}, verifyManifestSignature = (manifest, publicKeys) => {
+  const encoded = publicKeys[manifest.signature.keyId];
+  if (!encoded)
+    throw new MobileUpdateRegistryError("Mobile update signing key is not trusted");
+  let publicKey;
+  try {
+    const der = Buffer.from(encoded, "base64");
+    if (der.toString("base64") !== encoded)
+      throw new Error("invalid base64");
+    publicKey = createPublicKey2({ format: "der", key: der, type: "spki" });
+  } catch {
+    throw new MobileUpdateRegistryError("Mobile update trusted public key is invalid");
+  }
+  if (publicKey.asymmetricKeyType !== "ec" || publicKey.asymmetricKeyDetails?.namedCurve !== "prime256v1")
+    throw new MobileUpdateRegistryError("Mobile update trusted public key must use ECDSA P-256");
+  const { signature: _signature, ...unsigned } = manifest;
+  if (!verify("sha256", new TextEncoder().encode(JSON.stringify(canonicalValue(unsigned))), { dsaEncoding: "ieee-p1363", key: publicKey }, Buffer.from(manifest.signature.value, "base64")))
+    throw new MobileUpdateRegistryError("Mobile update signature verification failed");
+}, parseChannel = (value) => {
+  if (!object3(value) || value.format !== MOBILE_UPDATE_REGISTRY_FORMAT)
+    throw new MobileUpdateRegistryError("Mobile update channel is invalid");
+  const appId = text2(value.appId, "channel appId");
+  const channel = text2(value.channel, "channel");
+  if (!APP_ID.test(appId) || !NAME.test(channel) || !iso(value.promotedAt) || typeof value.rollout !== "number" || value.rollout < 0 || value.rollout > 1 || value.releaseId !== undefined && (typeof value.releaseId !== "string" || !RELEASE.test(value.releaseId)) || value.fallbackReleaseId !== undefined && (typeof value.fallbackReleaseId !== "string" || !RELEASE.test(value.fallbackReleaseId)) || value.activationId !== undefined && (typeof value.activationId !== "string" || !HASH.test(value.activationId)) || value.activatedAt !== undefined && !iso(value.activatedAt) || value.activationId === undefined !== (value.activatedAt === undefined))
+    throw new MobileUpdateRegistryError("Mobile update channel is invalid");
+  return {
+    ...value.activationId ? { activationId: value.activationId } : {},
+    ...value.activatedAt ? { activatedAt: value.activatedAt } : {},
+    appId,
+    channel,
+    ...value.fallbackReleaseId ? { fallbackReleaseId: value.fallbackReleaseId } : {},
+    format: MOBILE_UPDATE_REGISTRY_FORMAT,
+    promotedAt: value.promotedAt,
+    ...value.releaseId ? { releaseId: value.releaseId } : {},
+    rollout: value.rollout
+  };
+}, normalizedPrefix = (value) => {
+  const prefix = value.replace(/^\/+|\/+$/g, "");
+  if (!prefix || prefix.split("/").some((segment) => segment === "." || segment === ".."))
+    throw new MobileUpdateRegistryError("Mobile update prefix is invalid");
+  return prefix;
+}, appHash = (appId) => createHash6("sha256").update(appId).digest("hex"), digest = (bytes) => createHash6("sha256").update(bytes).digest("hex"), json = (value) => new TextEncoder().encode(`${JSON.stringify(value, null, 2)}
+`), decode = (value) => JSON.parse(new TextDecoder().decode(value)), fileDigest = async (file5) => {
+  const hasher = new Bun.CryptoHasher("sha256");
+  for await (const chunk of file5.stream())
+    hasher.update(chunk);
+  return hasher.digest("hex");
+}, rolloutMember = (input) => {
+  if (input.rollout === 0)
+    return false;
+  if (input.rollout === 1)
+    return true;
+  const value = createHash6("sha256").update(`${input.appId}\x00${input.channel}\x00${input.releaseId}\x00${input.installationId}`).digest().readUInt32BE(0);
+  return value / 4294967296 < input.rollout;
+}, createMobileUpdateRegistry = (options) => {
+  const prefix = normalizedPrefix(options.prefix ?? DEFAULT_PREFIX);
+  const clock = options.clock ?? (() => new Date);
+  const root = (appId) => `${prefix}/${appHash(appId)}`;
+  const releaseRoot = (manifest) => `${root(manifest.appId)}/releases/${manifest.releaseId}`;
+  const manifestKey = (manifest) => `${releaseRoot(manifest)}/update.json`;
+  const fileKey = (manifest, file5) => `${releaseRoot(manifest)}/files/${file5.path}`;
+  const channelKey = (appId, channel) => {
+    if (!APP_ID.test(appId) || !NAME.test(channel))
+      throw new MobileUpdateRegistryError("Mobile update channel identity is invalid");
+    return `${root(appId)}/channels/${channel}.json`;
+  };
+  const readManifest2 = async (appId, releaseId) => {
+    const key = manifestKey({ appId, releaseId });
+    const bytes = await options.store.get(key);
+    if (!bytes)
+      return null;
+    const head = await options.store.head(key);
+    if (!head || head.size !== bytes.byteLength || head.metadata?.sha256 !== digest(bytes))
+      throw new MobileUpdateRegistryError("Stored mobile update manifest integrity failed");
+    const manifest = parseMobileUpdateManifest(decode(bytes));
+    verifyManifestSignature(manifest, options.publicKeys);
+    if (manifest.appId !== appId || manifest.releaseId !== releaseId)
+      throw new MobileUpdateRegistryError("Stored mobile update identity changed");
+    return { key, manifest };
+  };
+  const readChannel = async (appId, channel) => {
+    const bytes = await options.store.get(channelKey(appId, channel));
+    if (!bytes)
+      return null;
+    const value = parseChannel(decode(bytes));
+    if (value.appId !== appId || value.channel !== channel)
+      throw new MobileUpdateRegistryError("Stored mobile update channel identity changed");
+    return value;
+  };
+  const writeChannel = async (input, signal) => {
+    const value = {
+      ...input,
+      format: MOBILE_UPDATE_REGISTRY_FORMAT,
+      promotedAt: clock().toISOString()
+    };
+    const bytes = json(value);
+    await options.store.put(channelKey(value.appId, value.channel), bytes, {
+      cacheControl: "no-cache",
+      contentType: "application/json",
+      maxBytes: bytes.byteLength,
+      metadata: {
+        channel: value.channel,
+        ...value.releaseId ? { releaseId: value.releaseId } : {},
+        sha256: digest(bytes)
+      },
+      signal
+    });
+    return value;
+  };
+  const promoteUpdate = async (input) => {
+    input.signal?.throwIfAborted();
+    if (input.rollout <= 0 || input.rollout > 1)
+      throw new MobileUpdateRegistryError("Mobile update rollout is invalid");
+    const release = await readManifest2(input.appId, input.releaseId);
+    if (!release || release.manifest.channel !== input.channel)
+      throw new MobileUpdateRegistryError("Mobile update was not published to this channel");
+    const existing = await readChannel(input.appId, input.channel);
+    await writeChannel({
+      appId: input.appId,
+      channel: input.channel,
+      ...existing?.releaseId && existing.releaseId !== input.releaseId ? { fallbackReleaseId: existing.releaseId } : existing?.fallbackReleaseId ? { fallbackReleaseId: existing.fallbackReleaseId } : {},
+      releaseId: input.releaseId,
+      rollout: input.rollout
+    }, input.signal);
+    return {
+      appId: input.appId,
+      channel: input.channel,
+      releaseId: input.releaseId,
+      rollout: input.rollout,
+      stage: "promoted"
+    };
+  };
+  const resolveUpdateState = async (input) => {
+    const channel = await readChannel(input.appId, input.channel);
+    if (!channel?.releaseId)
+      return { status: "empty" };
+    const selected = rolloutMember({
+      appId: input.appId,
+      channel: input.channel,
+      installationId: input.installationId,
+      releaseId: channel.releaseId,
+      rollout: channel.rollout
+    }) ? channel.releaseId : channel.fallbackReleaseId;
+    if (!selected)
+      return { status: "empty" };
+    const release = await readManifest2(input.appId, selected);
+    if (!release || release.manifest.runtimeFingerprint !== input.runtimeFingerprint)
+      return { status: "incompatible" };
+    return {
+      ...selected === channel.releaseId && channel.activationId && channel.activatedAt ? {
+        activationId: channel.activationId,
+        activatedAt: channel.activatedAt
+      } : {},
+      manifest: release.manifest,
+      manifestKey: release.key,
+      status: "selected"
+    };
+  };
+  return {
+    publishUpdate: async (input) => {
+      input.signal?.throwIfAborted();
+      const manifest = parseMobileUpdateManifest(input.manifest);
+      verifyManifestSignature(manifest, options.publicKeys);
+      const localRoot = path.resolve(input.releaseDirectory);
+      const localManifest = parseMobileUpdateManifest(JSON.parse(await readFile9(path.join(localRoot, "update.json"), "utf8")));
+      if (JSON.stringify(localManifest) !== JSON.stringify(manifest))
+        throw new MobileUpdateRegistryError("Local mobile update manifest changed");
+      const existing = await readManifest2(manifest.appId, manifest.releaseId);
+      let reused = existing !== null;
+      if (existing && JSON.stringify(existing.manifest) !== JSON.stringify(manifest))
+        throw new MobileUpdateRegistryError("Published mobile update is immutable");
+      if (!existing) {
+        for (const file5 of manifest.files) {
+          const local = path.join(localRoot, "files", file5.path);
+          const metadata = await stat3(local).catch(() => null);
+          if (!metadata?.isFile() || metadata.size !== file5.bytes)
+            throw new MobileUpdateRegistryError(`Mobile update file ${file5.path} size changed`);
+          if (await fileDigest(Bun.file(local)) !== file5.sha256)
+            throw new MobileUpdateRegistryError(`Mobile update file ${file5.path} integrity failed`);
+          const key = fileKey(manifest, file5);
+          const stored = await options.store.head(key);
+          if (!stored) {
+            await options.store.put(key, Bun.file(local).stream(), {
+              cacheControl: "public, max-age=31536000, immutable",
+              contentType: "application/octet-stream",
+              maxBytes: file5.bytes,
+              metadata: { releaseid: manifest.releaseId, sha256: file5.sha256 },
+              signal: input.signal
+            });
+          } else if (stored.size !== file5.bytes || stored.metadata?.sha256 !== file5.sha256 || (stored.metadata?.releaseid ?? stored.metadata?.releaseId) !== manifest.releaseId)
+            throw new MobileUpdateRegistryError("Stored mobile update file identity changed");
+        }
+        const bytes = json(manifest);
+        await options.store.put(manifestKey(manifest), bytes, {
+          cacheControl: "public, max-age=31536000, immutable",
+          contentType: "application/json",
+          maxBytes: bytes.byteLength,
+          metadata: { releaseid: manifest.releaseId, sha256: digest(bytes) },
+          signal: input.signal
+        });
+        if (!await readManifest2(manifest.appId, manifest.releaseId))
+          throw new MobileUpdateRegistryError("Mobile update publication verification failed");
+        reused = false;
+      }
+      await promoteUpdate({
+        appId: manifest.appId,
+        channel: manifest.channel,
+        releaseId: manifest.releaseId,
+        rollout: input.rollout,
+        signal: input.signal
+      });
+      return {
+        appId: manifest.appId,
+        channel: manifest.channel,
+        releaseId: manifest.releaseId,
+        reused,
+        rollout: input.rollout,
+        stage: "published"
+      };
+    },
+    promoteUpdate,
+    rollbackUpdate: async (input) => {
+      input.signal?.throwIfAborted();
+      const existing = await readChannel(input.appId, input.channel);
+      if (!existing)
+        throw new MobileUpdateRegistryError("Mobile update channel does not exist");
+      if (input.releaseId) {
+        const release = await readManifest2(input.appId, input.releaseId);
+        if (!release || release.manifest.channel !== input.channel)
+          throw new MobileUpdateRegistryError("Mobile rollback release was not published");
+      }
+      const activatedAt = clock().toISOString();
+      await writeChannel({
+        ...input.releaseId ? {
+          activationId: digest(new TextEncoder().encode(`${input.appId}\x00${input.channel}\x00${input.releaseId}\x00${activatedAt}`)),
+          activatedAt
+        } : {},
+        appId: input.appId,
+        channel: input.channel,
+        ...existing.releaseId ? { fallbackReleaseId: existing.releaseId } : {},
+        ...input.releaseId ? { releaseId: input.releaseId } : {},
+        rollout: input.releaseId ? 1 : 0
+      }, input.signal);
+      return {
+        appId: input.appId,
+        channel: input.channel,
+        ...input.releaseId ? { releaseId: input.releaseId } : {},
+        stage: "rolled-back"
+      };
+    },
+    resolveUpdate: async (input) => {
+      const resolution = await resolveUpdateState(input);
+      return resolution.status === "selected" ? { manifest: resolution.manifest, manifestKey: resolution.manifestKey } : null;
+    },
+    resolveUpdateState,
+    readUpdateFile: async (input) => {
+      const release = await readManifest2(input.appId, input.releaseId);
+      if (!release)
+        return null;
+      const requested = safePath(input.path);
+      const file5 = release.manifest.files.find((candidate) => candidate.path === requested);
+      if (!file5)
+        return null;
+      const key = fileKey(release.manifest, file5);
+      const [bytes, head] = await Promise.all([
+        options.store.get(key),
+        options.store.head(key)
+      ]);
+      if (!bytes || !head)
+        return null;
+      if (bytes.byteLength !== file5.bytes || head.size !== file5.bytes || head.metadata?.sha256 !== file5.sha256 || (head.metadata?.releaseid ?? head.metadata?.releaseId) !== release.manifest.releaseId || digest(bytes) !== file5.sha256)
+        throw new MobileUpdateRegistryError("Stored mobile update file integrity failed");
+      return { bytes, file: file5 };
+    }
+  };
+}, expoUpdateId = (releaseId) => {
+  const hash = RELEASE.test(releaseId) ? releaseId.slice("amu_".length, "amu_".length + 32) : createHash6("sha256").update(releaseId).digest("hex").slice(0, 32);
+  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20)}`;
+}, expoContentType = (extension, launch) => {
+  if (launch)
+    return "application/javascript";
+  const normalized = extension?.toLowerCase();
+  if (normalized === "png")
+    return "image/png";
+  if (normalized === "jpg" || normalized === "jpeg")
+    return "image/jpeg";
+  if (normalized === "webp")
+    return "image/webp";
+  if (normalized === "gif")
+    return "image/gif";
+  if (normalized === "svg")
+    return "image/svg+xml";
+  if (normalized === "json")
+    return "application/json";
+  if (normalized === "ttf")
+    return "font/ttf";
+  if (normalized === "otf")
+    return "font/otf";
+  if (normalized === "woff")
+    return "font/woff";
+  if (normalized === "woff2")
+    return "font/woff2";
+  return "application/octet-stream";
+}, encodeUpdatePath = (value) => value.split("/").map(encodeURIComponent).join("/"), expoProtocolHeaders, resolveExpoCodeSigning = (value) => {
+  if (!value)
+    return;
+  const entries = Object.entries(value.keys);
+  if (entries.length === 0)
+    throw new MobileUpdateRegistryError("Expo code signing requires at least one key");
+  return new Map(entries.map(([keyId, material]) => {
+    if (!NAME.test(keyId))
+      throw new MobileUpdateRegistryError("Expo code-signing key ID is invalid");
+    let certificate;
+    let privateKey;
+    try {
+      certificate = new X509Certificate2(material.certificate);
+      privateKey = createPrivateKey(material.privateKey);
+    } catch (error) {
+      throw new MobileUpdateRegistryError("Expo code-signing certificate or private key is invalid", { cause: error });
+    }
+    if (certificate.publicKey.asymmetricKeyType !== "rsa" || privateKey.asymmetricKeyType !== "rsa" || certificate.issuer !== certificate.subject || !certificate.verify(certificate.publicKey))
+      throw new MobileUpdateRegistryError("Expo code signing requires a self-signed RSA root and private key");
+    const certificatePublicKey = certificate.publicKey.export({
+      format: "der",
+      type: "spki"
+    });
+    const privatePublicKey = createPublicKey2(privateKey).export({
+      format: "der",
+      type: "spki"
+    });
+    if (!certificatePublicKey.equals(privatePublicKey))
+      throw new MobileUpdateRegistryError("Expo code-signing private key does not match its certificate");
+    const now = Date.now();
+    if (now < Date.parse(certificate.validFrom) || now > Date.parse(certificate.validTo))
+      throw new MobileUpdateRegistryError("Expo code-signing certificate is not currently valid");
+    return [keyId, { keyId, privateKey }];
+  }));
+}, expoSignatureExpectation = (value) => {
+  const fields = new Map;
+  for (const raw of value.split(",")) {
+    const match = /^\s*([a-z][a-z0-9_-]*)(?:=(\?1|\?0|"[^"\\]*"|[a-z0-9._-]+))?\s*$/u.exec(raw);
+    if (!match || fields.has(match[1]))
+      throw new MobileUpdateRegistryError("Expo code-signing expectation is invalid");
+    const encoded = match[2];
+    fields.set(match[1], encoded === undefined || encoded === "?1" ? true : encoded.startsWith('"') ? encoded.slice(1, -1) : encoded);
+  }
+  return fields;
+}, expoExtraParam = (request, key) => {
+  const value = request.headers.get("expo-extra-params");
+  if (!value)
+    return null;
+  for (const raw of value.split(",")) {
+    const match = /^\s*([a-z][a-z0-9_.*-]*)=(?:"((?:[^"\\]|\\["\\])*)"|([^\s,]+))\s*$/u.exec(raw);
+    if (!match || match[1] !== key)
+      continue;
+    return match[2] !== undefined ? match[2].replace(/\\(["\\])/gu, "$1") : match[3] ?? null;
+  }
+  return null;
+}, requestedExpoSignature = (request, codeSigning) => {
+  const expectation = request.headers.get("expo-expect-signature");
+  if (!expectation)
+    return;
+  if (!codeSigning)
+    throw new MobileUpdateRegistryError("Expo end-to-end code signing is not configured");
+  const fields = expoSignatureExpectation(expectation);
+  const keyId = fields.get("keyid");
+  const algorithm = fields.get("alg");
+  const signatureRequested = fields.get("sig") === true;
+  if (!signatureRequested || keyId !== undefined && typeof keyId !== "string" || algorithm !== undefined && algorithm !== EXPO_CODE_SIGNING_ALGORITHM)
+    throw new MobileUpdateRegistryError("Requested Expo code-signing parameters are unsupported");
+  const selected = typeof keyId === "string" ? codeSigning.get(keyId) : codeSigning.size === 1 ? codeSigning.values().next().value : undefined;
+  if (!selected)
+    throw new MobileUpdateRegistryError("Requested Expo code-signing key is unavailable");
+  return selected;
+}, expoSignatureHeader = (body, codeSigning) => {
+  const signature = sign("RSA-SHA256", Buffer.from(body), codeSigning.privateKey);
+  return `sig="${signature.toString("base64")}", keyid="${codeSigning.keyId}", alg="${EXPO_CODE_SIGNING_ALGORITHM}"`;
+}, expoRollbackResponse = (request, codeSigning) => {
+  const current = request.headers.get("expo-current-update-id");
+  const embedded = request.headers.get("expo-embedded-update-id");
+  if (!current || current === embedded)
+    return new Response(null, { status: 204 });
+  const boundary = `absolutejs-${crypto.randomUUID()}`;
+  const directive = JSON.stringify({
+    parameters: { commitTime: new Date().toISOString() },
+    type: "rollBackToEmbedded"
+  });
+  const body = [
+    `--${boundary}`,
+    'content-disposition: form-data; name="directive"',
+    "content-type: application/json; charset=utf-8",
+    ...codeSigning ? [`expo-signature: ${expoSignatureHeader(directive, codeSigning)}`] : [],
+    "",
+    directive,
+    `--${boundary}--`,
+    ""
+  ].join(`\r
+`);
+  return new Response(body, {
+    headers: {
+      ...expoProtocolHeaders,
+      "content-type": `multipart/mixed; boundary=${boundary}`
+    }
+  });
+}, createMobileUpdateHandler = (options) => {
+  const route = (options.route ?? `/__absolute/mobile/updates/${options.channel}`).replace(/^\/+|\/+$/g, "");
+  const allowedOrigins = new Set(options.allowedOrigins ?? ["capacitor://localhost", "https://localhost"]);
+  const expoCodeSigning = resolveExpoCodeSigning(options.expoCodeSigning);
+  return async (request) => {
+    const origin = request.headers.get("origin");
+    const cors = origin && allowedOrigins.has(origin) ? { "access-control-allow-origin": origin, vary: "Origin" } : {};
+    if (request.method === "OPTIONS") {
+      if (!origin || !allowedOrigins.has(origin))
+        return new Response(null, { status: 403 });
+      return new Response(null, {
+        headers: {
+          ...cors,
+          "access-control-allow-headers": "x-absolute-mobile-app,x-absolute-mobile-channel,x-absolute-mobile-installation,x-absolute-mobile-release,x-absolute-mobile-runtime",
+          "access-control-allow-methods": "GET,OPTIONS",
+          "access-control-max-age": "600"
+        },
+        status: 204
+      });
+    }
+    if (request.method !== "GET")
+      return new Response(null, { status: 405 });
+    const pathname = new URL(request.url).pathname.replace(/^\/+/, "");
+    const relative19 = pathname.startsWith(`${route}/`) ? pathname.slice(route.length + 1) : "";
+    if (relative19 === "update.json") {
+      const expoProtocolVersion = request.headers.get("expo-protocol-version");
+      const expoProtocol = expoProtocolVersion !== null;
+      if (expoProtocol && expoProtocolVersion !== "1")
+        return Response.json({
+          error: `Unsupported Expo Updates protocol version: ${expoProtocolVersion}`
+        }, { status: 406 });
+      const appId = request.headers.get("x-absolute-mobile-app");
+      const channel = request.headers.get("x-absolute-mobile-channel");
+      const installationId = expoProtocol ? expoExtraParam(request, "absolute-installation") ?? request.headers.get("x-absolute-mobile-installation") : request.headers.get("x-absolute-mobile-installation");
+      const runtimeFingerprint = expoProtocol ? request.headers.get("expo-runtime-version") : request.headers.get("x-absolute-mobile-runtime");
+      if (appId !== options.appId || channel !== options.channel || !installationId || !runtimeFingerprint)
+        return new Response(null, { status: 400 });
+      const resolution = options.registry.resolveUpdateState ? await options.registry.resolveUpdateState({
+        appId,
+        channel,
+        installationId,
+        runtimeFingerprint
+      }) : undefined;
+      const selected = resolution ? resolution.status === "selected" ? resolution : null : await options.registry.resolveUpdate({
+        appId,
+        channel,
+        installationId,
+        runtimeFingerprint
+      });
+      if (expoProtocol) {
+        let requestedCodeSigning;
+        try {
+          requestedCodeSigning = requestedExpoSignature(request, expoCodeSigning);
+        } catch (error) {
+          return Response.json({
+            error: error instanceof Error ? error.message : "Expo code-signing negotiation failed"
+          }, { status: expoCodeSigning ? 406 : 400 });
+        }
+        if (!selected) {
+          if (resolution?.status === "incompatible")
+            return new Response(null, { status: 204 });
+          return expoRollbackResponse(request, requestedCodeSigning);
+        }
+        const platform2 = request.headers.get("expo-platform");
+        if (platform2 !== "android" && platform2 !== "ios")
+          return new Response(null, { status: 400 });
+        const updateId = expoUpdateId((resolution?.status === "selected" ? resolution.activationId : undefined) ?? selected.manifest.releaseId);
+        if (request.headers.get("expo-current-update-id") === updateId)
+          return new Response(null, { status: 204 });
+        const descriptorFile = await options.registry.readUpdateFile({
+          appId,
+          path: EXPO_DESCRIPTOR,
+          releaseId: selected.manifest.releaseId
+        });
+        if (!descriptorFile)
+          return new Response(null, { status: 409 });
+        const descriptor = parseExpoUpdateDescriptor(descriptorFile.bytes);
+        const platformUpdate = descriptor.platforms[platform2];
+        if (!platformUpdate || descriptor.runtimeVersion !== runtimeFingerprint)
+          return new Response(null, { status: 204 });
+        const origin2 = new URL(request.url).origin;
+        const releaseRoute = `${origin2}/${route}/${selected.manifest.releaseId}/files`;
+        const protocolAsset = (asset, launch = false) => {
+          const file22 = selected.manifest.files.find((candidate) => candidate.path === asset.path);
+          if (!file22)
+            throw new MobileUpdateRegistryError(`Expo update references missing signed asset ${asset.path}`);
+          return {
+            contentType: expoContentType(asset.extension, launch),
+            ...asset.extension ? { fileExtension: `.${asset.extension}` } : {},
+            key: file22.sha256,
+            hash: Buffer.from(file22.sha256, "hex").toString("base64url"),
+            url: `${releaseRoute}/${encodeUpdatePath(asset.path)}`
+          };
+        };
+        const manifest = JSON.stringify({
+          assets: platformUpdate.assets.map((asset) => protocolAsset(asset)),
+          createdAt: (resolution?.status === "selected" ? resolution.activatedAt : undefined) ?? selected.manifest.createdAt,
+          extra: {
+            absolutejs: {
+              channel: selected.manifest.channel,
+              releaseId: selected.manifest.releaseId
+            },
+            expoClient: descriptor.expoConfig
+          },
+          id: updateId,
+          launchAsset: protocolAsset(platformUpdate.launchAsset, true),
+          metadata: {
+            channel: selected.manifest.channel,
+            releaseId: selected.manifest.releaseId
+          },
+          runtimeVersion: descriptor.runtimeVersion
+        });
+        return new Response(manifest, {
+          headers: {
+            ...expoProtocolHeaders,
+            ...requestedCodeSigning ? {
+              "expo-signature": expoSignatureHeader(manifest, requestedCodeSigning)
+            } : {}
+          }
+        });
+      }
+      if (!selected)
+        return new Response(null, { status: 204 });
+      return Response.json(selected.manifest, {
+        headers: {
+          ...cors,
+          "cache-control": "no-store",
+          etag: `"${selected.manifest.releaseId}"`
+        }
+      });
+    }
+    const match = /^(amu_[a-f0-9]{64})\/files\/(.+)$/.exec(relative19);
+    if (!match?.[1] || !match[2])
+      return new Response(null, { status: 404 });
+    const file5 = await options.registry.readUpdateFile({
+      appId: options.appId,
+      path: decodeURIComponent(match[2]),
+      releaseId: match[1]
+    });
+    if (!file5)
+      return new Response(null, { status: 404 });
+    return new Response(new Blob([new Uint8Array(file5.bytes).buffer]), {
+      headers: {
+        ...cors,
+        "cache-control": "public, max-age=31536000, immutable",
+        "content-length": String(file5.file.bytes),
+        "content-type": expoContentType(file5.file.path.includes(".") ? file5.file.path.slice(file5.file.path.lastIndexOf(".") + 1) : undefined, false),
+        etag: `"${file5.file.sha256}"`
+      }
+    });
+  };
+};
+var init_mobileUpdate = __esm(() => {
+  MAX_FILE_BYTES = 32 * 1024 * 1024;
+  MAX_TOTAL_BYTES = 128 * 1024 * 1024;
+  HASH = /^[a-f0-9]{64}$/;
+  RELEASE = /^amu_[a-f0-9]{64}$/;
+  APP_ID = /^[A-Za-z][\w]*(?:\.[A-Za-z][\w]*)+$/;
+  NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+  MobileUpdateRegistryError = class MobileUpdateRegistryError extends Error {
+  };
+  expoProtocolHeaders = {
+    "cache-control": "private, max-age=0",
+    "content-type": "application/expo+json",
+    "expo-protocol-version": "1",
+    "expo-sfv-version": "0"
+  };
+});
+
+// src/mobile/updateServer.ts
+var exports_updateServer = {};
+__export(exports_updateServer, {
+  ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT: () => ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT,
+  DEFAULT_MOBILE_UPDATE_REGISTRY_MODULE: () => DEFAULT_MOBILE_UPDATE_REGISTRY_MODULE,
+  createAbsoluteMobileUpdateServerPlugin: () => createAbsoluteMobileUpdateServerPlugin,
+  inspectAbsoluteMobileUpdateServer: () => inspectAbsoluteMobileUpdateServer,
+  loadAbsoluteMobileUpdateServerModule: () => loadAbsoluteMobileUpdateServerModule,
+  renderAbsoluteMobileUpdateRegistry: () => renderAbsoluteMobileUpdateRegistry,
+  writeAbsoluteMobileUpdateRegistry: () => writeAbsoluteMobileUpdateRegistry
+});
+import {
+  createPrivateKey as createPrivateKey2,
+  createPublicKey as createPublicKey3,
+  X509Certificate as X509Certificate3
+} from "crypto";
+import { access as access4, mkdir as mkdir13 } from "fs/promises";
+import { dirname as dirname31, isAbsolute as isAbsolute8, relative as relative19, resolve as resolve46, sep as sep4 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import { Elysia as Elysia5 } from "elysia";
+var ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT = 1, DEFAULT_MOBILE_UPDATE_REGISTRY_MODULE = "mobile.update.ts", object4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), projectPath = (projectRoot, requested) => {
+  const root = resolve46(projectRoot);
+  const path2 = resolve46(root, requested);
+  const projectRelative = relative19(root, path2);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep4}`) || isAbsolute8(projectRelative))
+    throw new TypeError("mobile.updates.server.registry must remain inside the project.");
+  return path2;
+}, isRegistry2 = (value) => object4(value) && [
+  "publishUpdate",
+  "promoteUpdate",
+  "rollbackUpdate",
+  "resolveUpdate",
+  "readUpdateFile"
+].every((method) => typeof value[method] === "function"), serverMetadata = (value) => {
+  if (!object4(value))
+    throw new TypeError("Mobile update registry must export valid absoluteMobileUpdateServer metadata. Run `absolute mobile update provision`.");
+  const { format, provider, storage } = value;
+  if (format !== ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT || storage !== "local" && storage !== "durable" || typeof provider !== "string" || !provider)
+    throw new TypeError("Mobile update registry must export valid absoluteMobileUpdateServer metadata. Run `absolute mobile update provision`.");
+  const metadata = {
+    format: ABSOLUTE_MOBILE_UPDATE_SERVER_FORMAT,
+    provider,
+    storage
+  };
+  return metadata;
+}, loadAbsoluteMobileUpdateServerModule = async (projectRoot, requestedModulePath = DEFAULT_MOBILE_UPDATE_REGISTRY_MODULE) => {
+  const modulePath = projectPath(projectRoot, requestedModulePath);
+  await access4(modulePath).catch(() => {
+    throw new TypeError(`Mobile update server registry does not exist: ${modulePath}. Run \`absolute mobile update provision\`.`);
+  });
+  const loaded = await import(pathToFileURL3(modulePath).href);
+  if (!object4(loaded))
+    throw new TypeError("Mobile update registry module has no exports.");
+  const registry2 = loaded.default ?? loaded.registry;
+  if (!isRegistry2(registry2))
+    throw new TypeError("Mobile update registry must implement publication, promotion, rollback, resolution, and file reads.");
+  const metadata = serverMetadata(loaded.absoluteMobileUpdateServer);
+  const verifier = loaded.verifyAbsoluteMobileUpdateServer;
+  if (metadata.storage === "durable" && typeof verifier !== "function")
+    throw new TypeError("Mobile update registries marked durable must export verifyAbsoluteMobileUpdateServer(). Re-run `absolute mobile update provision --storage s3 --force` or provide an active durability check.");
+  return {
+    metadata,
+    registry: registry2,
+    ...typeof verifier === "function" ? {
+      verifyDurability: async () => {
+        await verifier();
+      }
+    } : {}
+  };
+}, verifyDurableModule = async (module) => {
+  if (module.metadata.storage !== "durable")
+    throw new TypeError("Mobile production updates require durable object storage. Re-run `absolute mobile update provision --storage s3 --force` or configure a durable adapter.");
+  try {
+    await module.verifyDurability?.();
+  } catch (error) {
+    throw new TypeError(`Durable mobile update storage verification failed for ${module.metadata.provider}. Check the bucket, endpoint, credentials, and read/write/delete permissions.`, { cause: error });
+  }
+}, expoSigningOptions = (config) => {
+  if (!config.updates?.expoCodeSigning)
+    return;
+  const entries = Object.entries(config.updateServer?.expoCodeSigningKeys ?? {});
+  const keys = Object.fromEntries(entries.map(([keyId, key]) => {
+    const privateKey = process.env[key.privateKeyEnv];
+    if (!privateKey)
+      throw new TypeError(`Expo update serving requires ${key.privateKeyEnv} on the trusted server.`);
+    try {
+      const certificate = new X509Certificate3(key.certificatePem);
+      const expected = certificate.publicKey.export({
+        format: "der",
+        type: "spki"
+      });
+      const actual = createPublicKey3(createPrivateKey2(privateKey)).export({
+        format: "der",
+        type: "spki"
+      });
+      if (!expected.equals(actual))
+        throw new Error("key mismatch");
+    } catch (error) {
+      throw new TypeError(`${key.privateKeyEnv} must contain the RSA private key matching Expo update key ${keyId}.`, { cause: error });
+    }
+    return [keyId, { certificate: key.certificatePem, privateKey }];
+  }));
+  return { keys };
+}, createAbsoluteMobileUpdateServerPlugin = async (config, projectRoot, options = {}) => {
+  const { updates, updateServer: server } = config;
+  if (!updates || !server?.autoMount)
+    return new Elysia5({ name: "absolutejs-mobile-updates-disabled" });
+  const module = await loadAbsoluteMobileUpdateServerModule(projectRoot, server.registryModule);
+  if (options.production)
+    await verifyDurableModule(module);
+  const manifest = new URL(updates.manifestUrl);
+  if (!manifest.pathname.endsWith("/update.json"))
+    throw new TypeError("Auto-mounted mobile update manifests must end in /update.json.");
+  const route = manifest.pathname.slice(0, -"/update.json".length);
+  const { createMobileUpdateHandler: createMobileUpdateHandler2 } = await Promise.resolve().then(() => (init_mobileUpdate(), exports_mobileUpdate));
+  const handler = createMobileUpdateHandler2({
+    appId: config.appId,
+    channel: updates.channel,
+    ...config.engine === "expo" ? { expoCodeSigning: expoSigningOptions(config) } : {},
+    registry: module.registry,
+    route
+  });
+  return new Elysia5({ name: "absolutejs-mobile-updates" }).all(`${route}/*`, ({ request }) => handler(request));
+}, inspectAbsoluteMobileUpdateServer = async (config, projectRoot) => {
+  if (!config.updates)
+    return;
+  const module = await loadAbsoluteMobileUpdateServerModule(projectRoot, config.updateServer?.registryModule);
+  await verifyDurableModule(module);
+  if (config.engine === "expo")
+    expoSigningOptions(config);
+  return module.metadata;
+}, publicKeysSource = (publicKeys) => JSON.stringify(publicKeys, null, "\t"), renderAbsoluteMobileUpdateRegistry = (options) => {
+  const metadata = `export const absoluteMobileUpdateServer = {
+	format: 1,
+	provider: '${options.storage}',
+	storage: '${options.storage === "local" ? "local" : "durable"}'
+} as const;`;
+  if (options.storage === "local")
+    return `import { fileURLToPath } from 'node:url';
+import { localBlobStore } from '@absolutejs/blob/local';
+import { createMobileUpdateRegistry } from '@absolutejs/deploy/mobile-update';
+
+${metadata}
+
+const store = localBlobStore({
+	root: process.env.ABSOLUTE_MOBILE_UPDATE_LOCAL_ROOT ??
+		fileURLToPath(new URL('./.absolutejs/mobile/update-registry/', import.meta.url))
+});
+
+export default createMobileUpdateRegistry({
+	publicKeys: ${publicKeysSource(options.publicKeys)},
+	store
+});
+`;
+  return `import { randomUUID } from 'node:crypto';
+import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { awsS3BlobStore } from '@absolutejs/blob/aws-s3';
+import { createMobileUpdateRegistry } from '@absolutejs/deploy/mobile-update';
+
+${metadata}
+
+const required = (name: string) => {
+	const value = process.env[name];
+	if (!value) throw new Error(\`Missing \${name}\`);
+	return value;
+};
+
+const bucket = required('ABSOLUTE_MOBILE_UPDATE_S3_BUCKET');
+const client = new S3Client({
+	region: process.env.ABSOLUTE_MOBILE_UPDATE_S3_REGION ?? 'auto',
+	forcePathStyle: process.env.ABSOLUTE_MOBILE_UPDATE_S3_FORCE_PATH_STYLE === '1',
+	...(process.env.ABSOLUTE_MOBILE_UPDATE_S3_ENDPOINT
+		? { endpoint: process.env.ABSOLUTE_MOBILE_UPDATE_S3_ENDPOINT }
+		: {})
+});
+const store = awsS3BlobStore({ bucket, client });
+
+export const verifyAbsoluteMobileUpdateServer = async () => {
+	const key = \`absolutejs/mobile-updates/_health/\${randomUUID()}\`;
+	const expected = randomUUID();
+	let stored = false;
+	try {
+		await client.send(new PutObjectCommand({ Bucket: bucket, Key: key, Body: expected }));
+		stored = true;
+		const response = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+		if ((await response.Body?.transformToString()) !== expected)
+			throw new Error('Durability probe read did not match its write.');
+	} finally {
+		if (stored) await client.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }));
+	}
+};
+
+export default createMobileUpdateRegistry({
+	publicKeys: ${publicKeysSource(options.publicKeys)},
+	store
+});
+`;
+}, writeAbsoluteMobileUpdateRegistry = async (options) => {
+  const path2 = projectPath(options.projectRoot, options.modulePath ?? DEFAULT_MOBILE_UPDATE_REGISTRY_MODULE);
+  if (!options.force) {
+    await access4(path2).then(() => {
+      throw new TypeError(`Mobile update registry already exists: ${path2}. Pass --force to replace it.`);
+    }, () => {
+      return;
+    });
+  }
+  await mkdir13(dirname31(path2), { recursive: true });
+  await Bun.write(path2, renderAbsoluteMobileUpdateRegistry({
+    publicKeys: options.publicKeys,
+    storage: options.storage
+  }));
+  return path2;
+};
+var init_updateServer = () => {};
+
 // src/react/bridgeInternals.ts
 var INTERNALS_KEYS, isRecord8 = (val) => typeof val === "object" && val !== null, findInternals = (mod) => {
   for (const key of INTERNALS_KEYS) {
@@ -28457,10 +29419,10 @@ __export(exports_hmrCompiler, {
   encodeHmrComponentId: () => encodeHmrComponentId,
   getApplyMetadataModule: () => getApplyMetadataModule
 });
-import { dirname as dirname31, relative as relative19, resolve as resolve46 } from "path";
+import { dirname as dirname32, relative as relative20, resolve as resolve47 } from "path";
 import { performance as performance2 } from "perf_hooks";
 var encodeHmrComponentId = (absoluteFilePath, className) => {
-  const projectRel = relative19(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
+  const projectRel = relative20(process.cwd(), absoluteFilePath).replace(/\\/g, "/");
   return `${projectRel}@${className}`;
 }, getApplyMetadataModule = async (encodedId) => {
   const decoded = decodeURIComponent(encodedId);
@@ -28469,8 +29431,8 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
     return null;
   const filePathRel = decoded.slice(0, separatorIndex);
   const className = decoded.slice(separatorIndex + 1);
-  const componentFilePath = resolve46(process.cwd(), filePathRel);
-  const projectRelPath = relative19(process.cwd(), componentFilePath).replace(/\\/g, "/");
+  const componentFilePath = resolve47(process.cwd(), filePathRel);
+  const projectRelPath = relative20(process.cwd(), componentFilePath).replace(/\\/g, "/");
   const cacheKey3 = encodeURIComponent(`${projectRelPath}@${className}`);
   const { takePendingModule: takePendingModule2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
   const cached = takePendingModule2(cacheKey3);
@@ -28480,7 +29442,7 @@ var encodeHmrComponentId = (absoluteFilePath, className) => {
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const owners = resolveOwningComponents2({
     changedFilePath: componentFilePath,
-    userAngularRoot: dirname31(componentFilePath)
+    userAngularRoot: dirname32(componentFilePath)
   });
   const owner = owners.find((o3) => o3.className === className);
   const kind = owner?.kind ?? "component";
@@ -28502,7 +29464,7 @@ var exports_hmr = {};
 __export(exports_hmr, {
   hmr: () => hmr
 });
-import Elysia5 from "elysia";
+import Elysia6 from "elysia";
 import { websocket } from "elysia/websocket";
 var STORE_KEY = "__elysiaStore", restoredStores, getGlobalValue = (key) => Reflect.get(globalThis, key), restoreStore = (store) => {
   if (!store || typeof store !== "object")
@@ -28578,8 +29540,8 @@ var STORE_KEY = "__elysiaStore", restoredStores, getGlobalValue = (key) => Refle
     return null;
   if (!pathname.startsWith("/"))
     return null;
-  const { resolve: resolve47, normalize } = await import("path");
-  const candidate = resolve47(buildDir, pathname.slice(1));
+  const { resolve: resolve48, normalize } = await import("path");
+  const candidate = resolve48(buildDir, pathname.slice(1));
   const normalizedBuild = normalize(buildDir);
   if (!candidate.startsWith(normalizedBuild))
     return null;
@@ -28598,7 +29560,7 @@ var STORE_KEY = "__elysiaStore", restoredStores, getGlobalValue = (key) => Refle
       return candidate;
   }
   return null;
-}, hmr = (hmrState, manifest, moduleServerHandler) => new Elysia5({ name: "absolutejs-hmr" }).use(websocket({
+}, hmr = (hmrState, manifest, moduleServerHandler) => new Elysia6({ name: "absolutejs-hmr" }).use(websocket({
   idleTimeout: DEFAULT_WEBSOCKET_IDLE_TIMEOUT_SECONDS,
   sendPings: true
 })).request(async ({ request, store }) => {
@@ -28685,12 +29647,12 @@ __export(exports_devtoolsJson, {
   resolveDevtoolsUuidCachePath: () => resolveDevtoolsUuidCachePath
 });
 import { existsSync as existsSync43, mkdirSync as mkdirSync14, readFileSync as readFileSync37, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname32, join as join54, resolve as resolve47 } from "path";
-import { Elysia as Elysia6 } from "elysia";
+import { dirname as dirname33, join as join54, resolve as resolve48 } from "path";
+import { Elysia as Elysia7 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve47(uuidCachePath ?? join54(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve48(uuidCachePath ?? join54(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
   if (!existsSync43(cachePath))
     return null;
   try {
@@ -28712,14 +29674,14 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   if (cachedUuid)
     return setGlobalUuid(cachedUuid);
   const uuid = crypto.randomUUID();
-  mkdirSync14(dirname32(cachePath), { recursive: true });
+  mkdirSync14(dirname33(cachePath), { recursive: true });
   writeFileSync10(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
-  const rootPath = resolve47(options.projectRoot ?? process.cwd());
+  const rootPath = resolve48(options.projectRoot ?? process.cwd());
   const root = options.normalizeForWindowsContainer === false ? rootPath : normalizeDevtoolsWorkspaceRoot(rootPath);
   const uuid = getOrCreateUuid(buildDir, options);
-  return new Elysia6({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
+  return new Elysia7({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
     workspace: {
       root,
       uuid
@@ -28745,11 +29707,11 @@ __export(exports_imageOptimizer, {
   imageOptimizer: () => imageOptimizer
 });
 import { existsSync as existsSync44 } from "fs";
-import { resolve as resolve48 } from "path";
-import { Elysia as Elysia7 } from "elysia";
-var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
+import { resolve as resolve49 } from "path";
+import { Elysia as Elysia8 } from "elysia";
+var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path2, baseDir) => {
   try {
-    const resolved = validateSafePath(path, baseDir);
+    const resolved = validateSafePath(path2, baseDir);
     if (existsSync44(resolved))
       return resolved;
     return null;
@@ -28758,7 +29720,7 @@ var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avi
   }
 }, resolveLocalImage = (url, buildDir) => {
   const cleanPath = url.startsWith("/") ? url.slice(1) : url;
-  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve48(process.cwd()));
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve49(process.cwd()));
 }, parseQueryParams = (query, allowedSizes, defaultQuality) => {
   const url = typeof query["url"] === "string" ? query["url"] : undefined;
   const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
@@ -28859,7 +29821,7 @@ var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avi
     }
   });
 }, imageOptimizer = (config, buildDir) => {
-  const plugin = new Elysia7({ name: "image-optimizer" });
+  const plugin = new Elysia8({ name: "image-optimizer" });
   if (!config && config !== undefined)
     return plugin;
   if (config?.unoptimized)
@@ -28960,16 +29922,16 @@ var exports_requestInspector = {};
 __export(exports_requestInspector, {
   requestInspector: () => requestInspector
 });
-import { Elysia as Elysia8 } from "elysia";
+import { Elysia as Elysia9 } from "elysia";
 var RING_MAX = 200, DEFAULT_STATUS = 200, ASSET_EXTENSION, requestLog = () => {
   globalThis.__absoluteRequestLog ??= [];
   return globalThis.__absoluteRequestLog;
-}, classify = (path) => {
-  if (path.startsWith("/@") || path.includes("/__hmr"))
+}, classify = (path2) => {
+  if (path2.startsWith("/@") || path2.includes("/__hmr"))
     return "hmr";
-  if (path.startsWith("/api"))
+  if (path2.startsWith("/api"))
     return "api";
-  if (ASSET_EXTENSION.test(path) || path.startsWith("/assets/"))
+  if (ASSET_EXTENSION.test(path2) || path2.startsWith("/assets/"))
     return "asset";
   return "page";
 }, pathOf = (url) => {
@@ -28996,7 +29958,7 @@ var RING_MAX = 200, DEFAULT_STATUS = 200, ASSET_EXTENSION, requestLog = () => {
 var init_requestInspector = __esm(() => {
   ASSET_EXTENSION = /\.(?:avif|css|gif|ico|jpe?g|js|json|map|mjs|otf|png|svg|ttf|txt|wasm|webp|woff2?)$/i;
   pending = new WeakMap;
-  requestInspector = new Elysia8({
+  requestInspector = new Elysia9({
     name: "absolute-request-inspector"
   }).get("/__absolute/requests", () => requestLog()).request(({ request }) => {
     noteDevRequestStart();
@@ -29006,17 +29968,17 @@ var init_requestInspector = __esm(() => {
     });
   }).afterResponse(({ request, set, responseValue }) => {
     noteDevRequestEnd();
-    const path = pathOf(request.url);
-    if (path.startsWith("/__absolute"))
+    const path2 = pathOf(request.url);
+    if (path2.startsWith("/__absolute"))
       return;
     const entry = pending.get(request);
     const log2 = requestLog();
     log2.push({
       at: Date.now(),
       durationMs: entry === undefined ? 0 : performance.now() - entry.start,
-      kind: classify(path),
+      kind: classify(path2),
       method: request.method,
-      path,
+      path: path2,
       query: new URL(request.url).search,
       requestHeaders: entry?.headers ?? {},
       responseHeaders: toHeaderRecord(set.headers),
@@ -29029,7 +29991,7 @@ var init_requestInspector = __esm(() => {
 });
 
 // src/mobile/releaseArtifact.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT = 1, ABSOLUTE_MOBILE_RETAINED_GENERATIONS = 3, SHA_256 = "sha256", RELEASE_ID_PREFIX = "amc_", MODULE_SEGMENT_PARENT = "..", EXPORT_NAME_PATTERN, frameworks2, isCanonicalRecord = (value) => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
@@ -29066,7 +30028,7 @@ var ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT = 1, ABSOLUTE_MOBILE_RETAINED_GENERATIO
     return normalizeCanonicalRecord(value, ancestors);
   }
   throw new TypeError("Compatibility metadata must contain only finite JSON values.");
-}, canonicalJson = (value) => JSON.stringify(normalizeCanonicalValue(value, new Set)), hashCanonicalValue = (value) => createHash6(SHA_256).update(canonicalJson(value)).digest("hex"), requireNonEmpty = (value, field) => {
+}, canonicalJson = (value) => JSON.stringify(normalizeCanonicalValue(value, new Set)), hashCanonicalValue = (value) => createHash7(SHA_256).update(canonicalJson(value)).digest("hex"), requireNonEmpty = (value, field) => {
   if (!value.trim()) {
     throw new TypeError(`${field} must not be empty.`);
   }
@@ -29255,11 +30217,11 @@ var init_releaseArtifact = __esm(() => {
 });
 
 // src/mobile/artifactStore.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import {
-  mkdir as mkdir13,
+  mkdir as mkdir14,
   mkdtemp as mkdtemp2,
-  readFile as readFile9,
+  readFile as readFile10,
   readdir as readdir5,
   rename as rename5,
   rm as rm13,
@@ -29268,18 +30230,18 @@ import {
 import { join as join55, resolve as resolvePath } from "path";
 var DEFAULT_MAX_PRODUCER_BYTES = 134217728, SHA_2562 = "sha256", ARTIFACT_FILE = "artifact.json", RELEASE_ID_PATTERN, DEFAULT_BLOB_PREFIX = "absolutejs/mobile-compatibility", hashBlob = async (blob) => {
   const bytes = new Uint8Array(await blob.arrayBuffer());
-  return createHash7(SHA_2562).update(bytes).digest("hex");
+  return createHash8(SHA_2562).update(bytes).digest("hex");
 }, blobFromBytes = (bytes) => {
   const buffer = new ArrayBuffer(bytes.byteLength);
   new Uint8Array(buffer).set(bytes);
   return new Blob([buffer]);
-}, errorHasCode = (error, code2) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code2, appDirectoryName = (appId) => createHash7(SHA_2562).update(appId).digest("hex"), requireReleaseId = (releaseId) => {
+}, errorHasCode = (error, code2) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code2, appDirectoryName = (appId) => createHash8(SHA_2562).update(appId).digest("hex"), requireReleaseId = (releaseId) => {
   if (!RELEASE_ID_PATTERN.test(releaseId)) {
     throw new TypeError("Invalid mobile compatibility release id.");
   }
   return releaseId;
 }, readStoredArtifact = async (releaseDirectory) => {
-  const serialized = await readFile9(join55(releaseDirectory, ARTIFACT_FILE), "utf8");
+  const serialized = await readFile10(join55(releaseDirectory, ARTIFACT_FILE), "utf8");
   const parsed = JSON.parse(serialized);
   return parseAbsoluteMobileCompatibilityArtifact(parsed);
 }, validateStoredIdentity = (artifact, appId, releaseId) => {
@@ -29423,11 +30385,11 @@ var DEFAULT_MAX_PRODUCER_BYTES = 134217728, SHA_2562 = "sha256", ARTIFACT_FILE =
       const validatedArtifact = parseAbsoluteMobileCompatibilityArtifact(release.artifact);
       const validated = await verifyAbsoluteMobileCompatibilityProducer({ artifact: validatedArtifact, producer: release.producer }, maxProducerBytes);
       const parent = appDirectory(validated.artifact.appId);
-      await mkdir13(parent, { recursive: true });
+      await mkdir14(parent, { recursive: true });
       const staging = await mkdtemp2(join55(parent, ".stage-"));
       const producerPath = join55(staging, validated.artifact.producer.module);
       try {
-        await mkdir13(resolvePath(producerPath, ".."), {
+        await mkdir14(resolvePath(producerPath, ".."), {
           recursive: true
         });
         await Promise.all([
@@ -29467,24 +30429,24 @@ __export(exports_materializedBundle, {
   materializeAbsoluteMobileCompatibilityBundle: () => materializeAbsoluteMobileCompatibilityBundle,
   readAbsoluteMobileMaterializedReleases: () => readAbsoluteMobileMaterializedReleases
 });
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import {
-  access as access4,
-  mkdir as mkdir14,
+  access as access5,
+  mkdir as mkdir15,
   mkdtemp as mkdtemp3,
-  readFile as readFile10,
+  readFile as readFile11,
   rename as rename6,
   rm as rm14,
   writeFile as writeFile12
 } from "fs/promises";
-import { dirname as dirname33, join as join56, resolve as resolvePath2 } from "path";
-import { pathToFileURL as pathToFileURL3 } from "url";
+import { dirname as dirname34, join as join56, resolve as resolvePath2 } from "path";
+import { pathToFileURL as pathToFileURL4 } from "url";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "current.json", BUNDLES_DIRECTORY = "bundles", ARTIFACT_FILE2 = "artifact.json", BUNDLE_ID_PATTERN, isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), errorHasCode2 = (error, code2) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code2, bundleIdFor = (currentReleaseId, releases) => {
   const identity = JSON.stringify({
     currentReleaseId,
     releases: releases.map(({ releaseId }) => releaseId)
   });
-  return `amb_${createHash8("sha256").update(identity).digest("hex")}`;
+  return `amb_${createHash9("sha256").update(identity).digest("hex")}`;
 }, parseBundleIndex = (value) => {
   if (!isRecord9(value) || value.format !== ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT || typeof value.bundleId !== "string" || !BUNDLE_ID_PATTERN.test(value.bundleId) || typeof value.currentReleaseId !== "string" || !Array.isArray(value.releases)) {
     throw new TypeError("Invalid materialized mobile compatibility bundle.");
@@ -29510,7 +30472,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
 }, writeRelease = async (root, release) => {
   const directory = join56(root, release.artifact.releaseId);
   const producerPath = join56(directory, release.artifact.producer.module);
-  await mkdir14(dirname33(producerPath), { recursive: true });
+  await mkdir15(dirname34(producerPath), { recursive: true });
   await Promise.all([
     writeFile12(join56(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
 `),
@@ -29519,7 +30481,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
 }, installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
   const destination = join56(bundlesRoot, bundleId);
   try {
-    await access4(destination);
+    await access5(destination);
     return destination;
   } catch (error) {
     if (!errorHasCode2(error, "ENOENT"))
@@ -29537,7 +30499,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     throw error;
   }
   return destination;
-}, readCompatibilityModule = (modulePath) => import(pathToFileURL3(modulePath).href), resolveProducerHandler = (loaded, exportName) => {
+}, readCompatibilityModule = (modulePath) => import(pathToFileURL4(modulePath).href), resolveProducerHandler = (loaded, exportName) => {
   const value = loaded[exportName];
   if (!isRecord9(value) || typeof value.handle !== "function") {
     throw new TypeError(`Compatibility producer export ${exportName} must expose handle(request).`);
@@ -29556,7 +30518,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
   };
 }, loadAbsoluteMobileMaterializedBundle = async (root) => {
   const resolvedRoot = resolvePath2(root);
-  const serialized = await readFile10(join56(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+  const serialized = await readFile11(join56(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
   const parsed = JSON.parse(serialized);
   const index = parseBundleIndex(parsed);
   const bundleRoot = join56(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
@@ -29591,7 +30553,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
   });
   const root = resolvePath2(input.root);
   const bundlesRoot = join56(root, BUNDLES_DIRECTORY);
-  await mkdir14(bundlesRoot, { recursive: true });
+  await mkdir15(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
   const index = {
@@ -29609,7 +30571,7 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
 }, readAbsoluteMobileMaterializedReleases = async (root) => {
   const resolvedRoot = resolvePath2(root);
   try {
-    const serialized = await readFile10(join56(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const serialized = await readFile11(join56(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
     const parsed = JSON.parse(serialized);
     const index = parseBundleIndex(parsed);
     const bundleRoot = join56(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
@@ -30022,7 +30984,7 @@ var exports_compatibilityDispatcher = {};
 __export(exports_compatibilityDispatcher, {
   createAbsoluteMobileCompatibilityDispatcher: () => createAbsoluteMobileCompatibilityDispatcher
 });
-import { Elysia as Elysia9 } from "elysia";
+import { Elysia as Elysia10 } from "elysia";
 var MOBILE_WEBVIEW_ORIGINS, MOBILE_REQUEST_HEADER_NAMES, MOBILE_CORS_ALLOW_HEADERS, MOBILE_CORS_METHODS, mobileWebViewOrigin = (request) => {
   const origin = request.headers.get("origin");
   return origin && MOBILE_WEBVIEW_ORIGINS.has(origin) ? origin : undefined;
@@ -30077,7 +31039,7 @@ var MOBILE_WEBVIEW_ORIGINS, MOBILE_REQUEST_HEADER_NAMES, MOBILE_CORS_ALLOW_HEADE
     throw new TypeError("currentReleaseId must identify a retained compatibility artifact.");
   }
   const resolveProducer = createProducerResolver(options.loadProducer);
-  return new Elysia9({ name: "absolutejs-mobile-compatibility-dispatcher" }).request(async ({ request }) => {
+  return new Elysia10({ name: "absolutejs-mobile-compatibility-dispatcher" }).request(async ({ request }) => {
     if (getCurrentAbsoluteMobileProducerContext())
       return;
     const preflight = mobilePreflightResponse(request);
@@ -30237,8 +31199,8 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     links.push(href);
   }
   return links;
-}, fetchRoute = async (baseUrl, path) => {
-  const res = await fetchWithTimeout(`${baseUrl}${path}`, {
+}, fetchRoute = async (baseUrl, path2) => {
+  const res = await fetchWithTimeout(`${baseUrl}${path2}`, {
     redirect: "manual"
   });
   if (!res.ok)
@@ -30252,21 +31214,21 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   const queue = ["/"];
   const routes = [];
   const crawlNextRoute = async () => {
-    const path = queue.shift();
-    if (!path) {
+    const path2 = queue.shift();
+    if (!path2) {
       return;
     }
-    if (visited.has(path)) {
+    if (visited.has(path2)) {
       await crawlNextRoute();
       return;
     }
-    visited.add(path);
-    const html = await fetchRoute(baseUrl, path).catch(() => null);
+    visited.add(path2);
+    const html = await fetchRoute(baseUrl, path2).catch(() => null);
     if (!html) {
       await crawlNextRoute();
       return;
     }
-    routes.push(path);
+    routes.push(path2);
     queue.push(...extractLinks(html, visited));
     await crawlNextRoute();
   };
@@ -30387,10 +31349,10 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
   };
   read();
 }, formatServerOutput = (output) => {
-  const text2 = output.join("").trim();
-  if (!text2)
+  const text3 = output.join("").trim();
+  if (!text3)
     return "";
-  return text2.length > SERVER_OUTPUT_LIMIT ? text2.slice(-SERVER_OUTPUT_LIMIT) : text2;
+  return text3.length > SERVER_OUTPUT_LIMIT ? text3.slice(-SERVER_OUTPUT_LIMIT) : text3;
 }, createServerStartupError = (output) => {
   const serverOutput = formatServerOutput(output);
   const message = serverOutput ? `Server failed to start for pre-rendering.
@@ -30437,18 +31399,18 @@ __export(exports_prepare, {
   prepare: () => prepare,
   startDevPrebuild: () => startDevPrebuild
 });
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { existsSync as existsSync45, readdirSync as readdirSync12, readFileSync as readFileSync39 } from "fs";
-import { basename as basename19, join as join58, relative as relative20, resolve as resolvePath3 } from "path";
-import { Elysia as Elysia10, NotFound } from "elysia";
-var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_PLUGIN_RETRY_DELAY_MS = 50, waitForStaticPluginRetry = () => new Promise((resolve49) => {
-  setTimeout(resolve49, STATIC_PLUGIN_RETRY_DELAY_MS);
+import { basename as basename19, join as join58, relative as relative21, resolve as resolvePath3 } from "path";
+import { Elysia as Elysia11, NotFound } from "elysia";
+var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_PLUGIN_RETRY_DELAY_MS = 50, waitForStaticPluginRetry = () => new Promise((resolve50) => {
+  setTimeout(resolve50, STATIC_PLUGIN_RETRY_DELAY_MS);
 }), retryStaticPlugin = async (createStaticPlugin, options) => {
   try {
     return await createStaticPlugin(options);
   } catch (error) {
     logWarn(`Static asset routes were skipped this cycle \u2014 a build file was unavailable mid-rebuild: ${error instanceof Error ? error.message : String(error)}`);
-    return new Elysia10({ name: "absolutejs-static-fallback" });
+    return new Elysia11({ name: "absolutejs-static-fallback" });
   }
 }, mountStaticPlugin = async (createStaticPlugin, options) => {
   try {
@@ -30459,7 +31421,7 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
   }
 }, MOBILE_DEV_MODULE_HEADERS, NATIVE_DEVICE_ADAPTER_PATH = "/__absolute/native-device-adapter.js", MOBILE_PREVIEW_CLIENT_PATH = "/__absolute/mobile-preview-client.js", loadMobileDevPlugin = async (mobile) => {
   if (!mobile)
-    return new Elysia10({ name: "absolutejs-mobile-disabled" });
+    return new Elysia11({ name: "absolutejs-mobile-disabled" });
   const [
     { createAbsoluteMobileAssociationPlugin: createAbsoluteMobileAssociationPlugin2 },
     { createAbsoluteMobilePreviewPlugin: createAbsoluteMobilePreviewPlugin2 }
@@ -30470,19 +31432,33 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
   let nativeDevAdapterBundle;
   const getNativeDevAdapterBundle = () => nativeDevAdapterBundle ??= Promise.resolve().then(() => (init_devDeviceAdapter(), exports_devDeviceAdapter)).then(({ buildAbsoluteNativeDevAdapter: buildAbsoluteNativeDevAdapter2 }) => buildAbsoluteNativeDevAdapter2(process.cwd(), mobile));
   const getMobilePreviewClientBundle = () => Promise.resolve().then(() => (init_mobilePreviewClientBundle(), exports_mobilePreviewClientBundle)).then(({ getAbsoluteMobilePreviewClientBundle: getAbsoluteMobilePreviewClientBundle2 }) => getAbsoluteMobilePreviewClientBundle2());
-  return new Elysia10({ name: "absolutejs-mobile-dev" }).use(createAbsoluteMobileAssociationPlugin2(mobile, process.cwd())).use(createAbsoluteMobilePreviewPlugin2(mobile)).get(NATIVE_DEVICE_ADAPTER_PATH, async () => new Response(await getNativeDevAdapterBundle(), {
+  return new Elysia11({ name: "absolutejs-mobile-dev" }).use(createAbsoluteMobileAssociationPlugin2(mobile, process.cwd())).use(createAbsoluteMobilePreviewPlugin2(mobile)).get(NATIVE_DEVICE_ADAPTER_PATH, async () => new Response(await getNativeDevAdapterBundle(), {
     headers: MOBILE_DEV_MODULE_HEADERS
   })).get(MOBILE_PREVIEW_CLIENT_PATH, async () => new Response(await getMobilePreviewClientBundle(), {
     headers: MOBILE_DEV_MODULE_HEADERS
   }));
 }, loadMobileAssociationPlugin = async (mobile) => {
   if (!mobile) {
-    return new Elysia10({ name: "absolutejs-mobile-associations-disabled" });
+    return new Elysia11({ name: "absolutejs-mobile-associations-disabled" });
   }
   const { createAbsoluteMobileAssociationPlugin: createAbsoluteMobileAssociationPlugin2 } = await Promise.resolve().then(() => (init_associationFiles(), exports_associationFiles));
   return createAbsoluteMobileAssociationPlugin2(mobile, process.cwd(), {
     requireAll: true
   });
+}, loadMobileUpdatePlugin = async (mobile, production) => {
+  if (!mobile?.updates)
+    return new Elysia11({ name: "absolutejs-mobile-updates-unconfigured" });
+  const [
+    { normalizeAbsoluteMobileConfig: normalizeAbsoluteMobileConfig2 },
+    { createAbsoluteMobileUpdateServerPlugin: createAbsoluteMobileUpdateServerPlugin2 }
+  ] = await Promise.all([
+    Promise.resolve().then(() => (init_config(), exports_config)),
+    Promise.resolve().then(() => (init_updateServer(), exports_updateServer))
+  ]);
+  const normalized = normalizeAbsoluteMobileConfig2(mobile, process.cwd());
+  return createAbsoluteMobileUpdateServerPlugin2(normalized, process.cwd(), {
+    production
+  });
 }, buildPrewarmDirs = (config) => {
   const dirs = [];
   if (config.svelteDirectory) {
@@ -30514,7 +31490,7 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
   return files;
 }, PREWARM_MAX_PAUSE_MS = 60000, toWarmTasks = function* (files, warmCache, srcUrlPrefix) {
   for (const file5 of files) {
-    const rel = relative20(process.cwd(), file5).replace(/\\/g, "/");
+    const rel = relative21(process.cwd(), file5).replace(/\\/g, "/");
     yield () => warmCache(`${srcUrlPrefix}${rel}`);
   }
 }, builtPageSources = () => {
@@ -30555,7 +31531,7 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
     const srcPath = resolvePath3(devIndexDir, fileName);
     if (!existsSync45(srcPath))
       continue;
-    const rel = relative20(process.cwd(), srcPath).replace(/\\/g, "/");
+    const rel = relative21(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
   }
 }, ICON_HASH_LENGTH = 8, registerIconVersioning = (buildDir) => {
@@ -30566,11 +31542,11 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
     const cached = cache2.get(href);
     if (cached !== undefined)
       return cached;
-    const path = href.split("?")[0] ?? href;
-    const filePath = join58(buildDir, path);
+    const path2 = href.split("?")[0] ?? href;
+    const filePath = join58(buildDir, path2);
     let versioned = href;
     if (existsSync45(filePath)) {
-      const hash = createHash9("sha256").update(readFileSync39(filePath)).digest("hex").slice(0, ICON_HASH_LENGTH);
+      const hash = createHash10("sha256").update(readFileSync39(filePath)).digest("hex").slice(0, ICON_HASH_LENGTH);
       versioned = href.includes("?") ? `${href}&v=${hash}` : `${href}?v=${hash}`;
     }
     cache2.set(href, versioned);
@@ -30675,12 +31651,13 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
   const { requestInspector: requestInspector2 } = await Promise.resolve().then(() => (init_requestInspector(), exports_requestInspector));
   const { serverTiming } = await import("@elysia/server-timing");
   const mobileDevPlugin = await loadMobileDevPlugin(config.mobile);
-  const absolutejs = new Elysia10({ name: "absolutejs-runtime" }).use(requestInspector2).use(absoluteRequestContext).use(serverTiming()).use(devtoolsJson2(buildDir, {
+  const mobileUpdatePlugin = await loadMobileUpdatePlugin(config.mobile, false);
+  const absolutejs = new Elysia11({ name: "absolutejs-runtime" }).use(requestInspector2).use(absoluteRequestContext).use(serverTiming()).use(devtoolsJson2(buildDir, {
     normalizeForWindowsContainer: config.dev?.devtools?.normalizeForWindowsContainer,
     projectRoot: config.dev?.devtools?.projectRoot,
     uuid: config.dev?.devtools?.uuid,
     uuidCachePath: config.dev?.devtools?.uuidCachePath
-  })).use(imageOptimizer2(config.images, buildDir)).use(mobileDevPlugin).use(await mountStaticPlugin(staticPlugin, {
+  })).use(imageOptimizer2(config.images, buildDir)).use(mobileDevPlugin).use(mobileUpdatePlugin).use(await mountStaticPlugin(staticPlugin, {
     alwaysStatic: true,
     assets: buildDir,
     directive: "no-cache",
@@ -30719,7 +31696,7 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
 }, loadMobileCompatibilityPlugin = async (buildDir) => {
   const root = join58(buildDir, ".absolutejs", "mobile-compatibility");
   if (!existsSync45(join58(root, "current.json"))) {
-    return new Elysia10({ name: "absolutejs-mobile-compatibility-empty" });
+    return new Elysia11({ name: "absolutejs-mobile-compatibility-empty" });
   }
   const [
     { loadAbsoluteMobileMaterializedBundle: loadAbsoluteMobileMaterializedBundle2 },
@@ -30730,12 +31707,12 @@ var MS_PER_SECOND2 = 1000, DEFAULT_PORT2 = 3000, MAX_STATIC_ROUTE_COUNT, STATIC_
   ]);
   const options = await loadAbsoluteMobileMaterializedBundle2(root);
   return createAbsoluteMobileCompatibilityDispatcher2(options);
-}, createNotFoundPlugin = () => new Elysia10({ name: "absolutejs-not-found" }).error("global", NotFound, async () => {
+}, createNotFoundPlugin = () => new Elysia11({ name: "absolutejs-not-found" }).error("global", NotFound, async () => {
   const response = await renderFirstNotFound();
   if (response)
     return response;
   return;
-}), createBuildErrorRecoveryPlugin = () => new Elysia10({ name: "absolutejs-build-error-recovery" }).error("global", async ({ error }) => {
+}), createBuildErrorRecoveryPlugin = () => new Elysia11({ name: "absolutejs-build-error-recovery" }).error("global", async ({ error }) => {
   const message = error instanceof Error ? error.message : String(error);
   const assetMatch = /^Asset "(.+)" not found in manifest\.$/.exec(message);
   if (!assetMatch)
@@ -30802,11 +31779,11 @@ This usually means a build-time error in a source file. Check the dev-server ter
     staticLimit: MAX_STATIC_ROUTE_COUNT
   });
   const generatedAssetsRoot = join58(buildDir, ".absolutejs");
-  const generatedAssetsPlugin = new Elysia10({
+  const generatedAssetsPlugin = new Elysia11({
     name: "absolutejs-generated-assets"
   }).get("/.absolutejs/*", async ({ params, set }) => {
     const requestedPath = resolvePath3(generatedAssetsRoot, params["*"]);
-    if (relative20(generatedAssetsRoot, requestedPath).startsWith("..")) {
+    if (relative21(generatedAssetsRoot, requestedPath).startsWith("..")) {
       set.status = 404;
       return "Not Found";
     }
@@ -30826,7 +31803,7 @@ This usually means a build-time error in a source file. Check the dev-server ter
     const hash = base.match(/[.-]([0-9a-z]{6,12})\.[0-9a-z]+$/i)?.[1];
     return hash ? /[0-9]/.test(hash) && /[a-z]/i.test(hash) : false;
   };
-  const assetCachePlugin = new Elysia10({
+  const assetCachePlugin = new Elysia11({
     name: "absolutejs-asset-cache"
   }).afterHandle("global", ({ request, responseValue }) => {
     if (!(responseValue instanceof Response))
@@ -30843,13 +31820,14 @@ This usually means a build-time error in a source file. Check the dev-server ter
   const prerenderMap = loadPrerenderMap(prerenderDir);
   const mobileCompatibilityPlugin = await loadMobileCompatibilityPlugin(buildDir);
   const mobileAssociationPlugin = await loadMobileAssociationPlugin(config.mobile);
+  const mobileUpdatePlugin = await loadMobileUpdatePlugin(config.mobile, true);
   recordStep("load prerender map", stepStartedAt);
   if (prerenderMap.size > 0) {
     const { PRERENDER_BYPASS_HEADER: PRERENDER_BYPASS_HEADER2, readTimestamp: readTimestamp2, rerenderRoute: rerenderRoute2 } = await Promise.resolve().then(() => (init_prerender(), exports_prerender));
     const revalidateMs = config.static?.revalidate ? config.static.revalidate * MS_PER_SECOND2 : 0;
     const port = Number(process.env.PORT) || DEFAULT_PORT2;
     const rerendering = new Set;
-    const prerenderPlugin = new Elysia10({
+    const prerenderPlugin = new Elysia11({
       name: "prerendered-pages"
     }).request(({ request }) => {
       const url = new URL(request.url);
@@ -30872,7 +31850,7 @@ This usually means a build-time error in a source file. Check the dev-server ter
     });
     stepStartedAt = performance.now();
     const { imageOptimizer: imageOptimizer3 } = await Promise.resolve().then(() => (init_imageOptimizer(), exports_imageOptimizer));
-    const absolutejs2 = new Elysia10({ name: "absolutejs-runtime" }).use(absoluteRequestContext).use(mobileAssociationPlugin).use(mobileCompatibilityPlugin).use(assetCachePlugin).use(imageOptimizer3(config.images, buildDir)).use(prerenderPlugin).use(staticFiles).use(generatedAssetsPlugin).use(createNotFoundPlugin());
+    const absolutejs2 = new Elysia11({ name: "absolutejs-runtime" }).use(absoluteRequestContext).use(mobileAssociationPlugin).use(mobileCompatibilityPlugin).use(mobileUpdatePlugin).use(assetCachePlugin).use(imageOptimizer3(config.images, buildDir)).use(prerenderPlugin).use(staticFiles).use(generatedAssetsPlugin).use(createNotFoundPlugin());
     await withOpenApi(absolutejs2, config, process.cwd(), false);
     await withTelemetry(absolutejs2, config, process.cwd());
     recordStep("assemble production runtime", stepStartedAt);
@@ -30881,7 +31859,7 @@ This usually means a build-time error in a source file. Check the dev-server ter
   }
   stepStartedAt = performance.now();
   const { imageOptimizer: imageOptimizer2 } = await Promise.resolve().then(() => (init_imageOptimizer(), exports_imageOptimizer));
-  const absolutejs = new Elysia10({ name: "absolutejs-runtime" }).use(absoluteRequestContext).use(mobileAssociationPlugin).use(mobileCompatibilityPlugin).use(assetCachePlugin).use(imageOptimizer2(config.images, buildDir)).use(staticFiles).use(generatedAssetsPlugin).use(createNotFoundPlugin());
+  const absolutejs = new Elysia11({ name: "absolutejs-runtime" }).use(absoluteRequestContext).use(mobileAssociationPlugin).use(mobileCompatibilityPlugin).use(mobileUpdatePlugin).use(assetCachePlugin).use(imageOptimizer2(config.images, buildDir)).use(staticFiles).use(generatedAssetsPlugin).use(createNotFoundPlugin());
   await withOpenApi(absolutejs, config, process.cwd(), false);
   await withTelemetry(absolutejs, config, process.cwd());
   recordStep("assemble production runtime", stepStartedAt);
@@ -30961,7 +31939,7 @@ __export(exports_moduleServer, {
   warnIfReactFastRefreshUnsupported: () => warnIfReactFastRefreshUnsupported
 });
 import { existsSync as existsSync46, readFileSync as readFileSync40, realpathSync as realpathSync3, statSync as statSync7 } from "fs";
-import { basename as basename20, dirname as dirname34, extname as extname15, join as join59, resolve as resolve49, relative as relative21 } from "path";
+import { basename as basename20, dirname as dirname35, extname as extname15, join as join59, resolve as resolve50, relative as relative22 } 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 = [];
@@ -30981,10 +31959,10 @@ var SRC_PREFIX = "/@src/", BROWSER_DEFINE, jsTranspiler2, legacyDecoratorTsconfi
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const directHit = extensions.find((ext) => existsSync46(resolve49(projectRoot, srcPath + ext)));
+  const directHit = extensions.find((ext) => existsSync46(resolve50(projectRoot, srcPath + ext)));
   if (directHit)
     return srcPath + directHit;
-  const indexHit = extensions.find((ext) => existsSync46(resolve49(projectRoot, srcPath, `index${ext}`)));
+  const indexHit = extensions.find((ext) => existsSync46(resolve50(projectRoot, srcPath, `index${ext}`)));
   if (indexHit)
     return `${srcPath}/index${indexHit}`;
   return srcPath;
@@ -31013,7 +31991,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve49(projectRoot, relPath);
+  const absPath = resolve50(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -31025,12 +32003,12 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve49(fileDir, relPath);
-  const rel = relative21(projectRoot, absPath);
+  const absPath = resolve50(fileDir, relPath);
+  const rel = relative22(projectRoot, absPath);
   const extension = extname15(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname15(srcPath) === ".svelte") {
-    srcPath = relative21(projectRoot, resolveSvelteModulePath(resolve49(projectRoot, srcPath)));
+    srcPath = relative22(projectRoot, resolveSvelteModulePath(resolve50(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, NODE_BUILTIN_RE, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
@@ -31042,27 +32020,27 @@ ${stubs}
       "import"
     ]);
     if (fromExports)
-      return relative21(projectRoot, fromExports);
+      return relative22(projectRoot, fromExports);
     try {
       const isScoped = specifier.startsWith("@");
       const parts = specifier.split("/");
       const packageName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
       const subpath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
       if (!subpath) {
-        const pkgDir = resolve49(projectRoot, "node_modules", packageName ?? "");
+        const pkgDir = resolve50(projectRoot, "node_modules", packageName ?? "");
         const pkgJsonPath = join59(pkgDir, "package.json");
         if (existsSync46(pkgJsonPath)) {
           const pkg = JSON.parse(readFileSync40(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
-            const resolved = resolve49(pkgDir, esmEntry);
+            const resolved = resolve50(pkgDir, esmEntry);
             if (existsSync46(resolved))
-              return relative21(projectRoot, resolved);
+              return relative22(projectRoot, resolved);
           }
         }
       }
     } catch {}
-    return relative21(projectRoot, Bun.resolveSync(specifier, projectRoot));
+    return relative22(projectRoot, Bun.resolveSync(specifier, projectRoot));
   } catch {
     return;
   }
@@ -31095,28 +32073,28 @@ ${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 = dirname34(filePath);
+  const fileDir = dirname35(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);
   const rewriteAbsoluteToSrc = (_match, prefix, absPath, _ext, suffix) => {
     if (absPath.startsWith(projectRoot)) {
-      const rel2 = relative21(projectRoot, absPath).replace(/\\/g, "/");
+      const rel2 = relative22(projectRoot, absPath).replace(/\\/g, "/");
       return `${prefix}${srcUrl(rel2, projectRoot)}${suffix}`;
     }
-    const rel = relative21(projectRoot, absPath).replace(/\\/g, "/");
+    const rel = relative22(projectRoot, absPath).replace(/\\/g, "/");
     return `${prefix}${srcUrl(rel, projectRoot)}${suffix}`;
   };
   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 = resolve49(fileDir, relPath);
-    const rel = relative21(projectRoot, absPath);
+    const absPath = resolve50(fileDir, relPath);
+    const rel = relative22(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
-    const absPath = resolve49(fileDir, relPath);
-    const rel = relative21(projectRoot, absPath);
+    const absPath = resolve50(fileDir, relPath);
+    const rel = relative22(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
   return result;
@@ -31172,7 +32150,7 @@ ${code2}`;
   transpiled = `var $RefreshReg$ = window.$RefreshReg$ || function(){};
 ` + `var $RefreshSig$ = window.$RefreshSig$ || function(){ return function(t){ return t; }; };
 ${transpiled}`;
-  const relPath = relative21(projectRoot, filePath).replace(/\\/g, "/");
+  const relPath = relative22(projectRoot, filePath).replace(/\\/g, "/");
   transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
@@ -31333,11 +32311,11 @@ ${code2}`;
   if (compiled.css?.code) {
     const cssPath = `${filePath}.css`;
     svelteExternalCss.set(cssPath, compiled.css.code);
-    const cssUrl = srcUrl(relative21(projectRoot, cssPath), projectRoot);
+    const cssUrl = srcUrl(relative22(projectRoot, cssPath), projectRoot);
     code2 = `import "${cssUrl}";
 ${code2}`;
   }
-  const moduleUrl = `${SRC_PREFIX}${relative21(projectRoot, filePath).replace(/\\/g, "/")}`;
+  const moduleUrl = `${SRC_PREFIX}${relative22(projectRoot, filePath).replace(/\\/g, "/")}`;
   code2 = code2.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
 ` + `  if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
@@ -31437,8 +32415,8 @@ ${code2}`;
   code2 = injectVueHmr(code2, filePath, projectRoot, vueDir);
   return rewriteImports(code2, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code2, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve49(vueDir) : projectRoot;
-  const hmrId = relative21(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  const hmrBase = vueDir ? resolve50(vueDir) : projectRoot;
+  const hmrId = relative22(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code2.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
     "",
@@ -31451,14 +32429,14 @@ ${code2}`;
   ].join(`
 `);
   return result;
-}, resolveSvelteModulePath = (path) => {
-  if (existsSync46(path))
-    return path;
-  if (existsSync46(`${path}.ts`))
-    return `${path}.ts`;
-  if (existsSync46(`${path}.js`))
-    return `${path}.js`;
-  return path;
+}, resolveSvelteModulePath = (path2) => {
+  if (existsSync46(path2))
+    return path2;
+  if (existsSync46(`${path2}.ts`))
+    return `${path2}.ts`;
+  if (existsSync46(`${path2}.js`))
+    return `${path2}.js`;
+  return path2;
 }, jsResponse = (body) => {
   const etag = `"${Bun.hash(body).toString(BASE_36_RADIX)}"`;
   return new Response(body, {
@@ -31598,7 +32576,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);`);
 }, resolveSourcePath2 = (relPath, projectRoot) => {
-  const filePath = resolve49(projectRoot, relPath);
+  const filePath = resolve50(projectRoot, relPath);
   const ext = extname15(filePath);
   if (ext === ".svelte")
     return { ext, filePath: resolveSvelteModulePath(filePath) };
@@ -31616,10 +32594,10 @@ export default {};
     return jsResponse(handleCssRequest(filePath));
   if (ext === ".json") {
     try {
-      const { readFile: readFile11, stat: stat4 } = await import("fs/promises");
+      const { readFile: readFile12, stat: stat5 } = await import("fs/promises");
       const fileExists2 = async (p2) => {
         try {
-          await stat4(p2);
+          await stat5(p2);
           return true;
         } catch {
           return false;
@@ -31635,14 +32613,14 @@ export default {};
           const absoluteCandidate = `/${tail.replace(/^\/+/, "")}`;
           const candidates = [
             absoluteCandidate,
-            resolve49(projectRoot, tail)
+            resolve50(projectRoot, tail)
           ];
           try {
             const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_loadConfig(), exports_loadConfig));
             const cfg = await loadConfig2();
-            const angularDir = cfg.angularDirectory && resolve49(projectRoot, cfg.angularDirectory);
+            const angularDir = cfg.angularDirectory && resolve50(projectRoot, cfg.angularDirectory);
             if (angularDir)
-              candidates.push(resolve49(angularDir, tail));
+              candidates.push(resolve50(angularDir, tail));
           } catch {}
           for (const candidate of candidates) {
             if (await fileExists2(candidate)) {
@@ -31652,9 +32630,9 @@ export default {};
           }
         }
       }
-      const text2 = await readFile11(sourcePath, "utf-8");
-      JSON.parse(text2);
-      return jsResponse(`export default ${text2};`);
+      const text3 = await readFile12(sourcePath, "utf-8");
+      JSON.parse(text3);
+      return jsResponse(`export default ${text3};`);
     } catch (err) {
       return new Response(`console.error('[ModuleServer] JSON load error in ${filePath}:', ${JSON.stringify(String(err))});`, {
         headers: { "Content-Type": "application/javascript" },
@@ -31672,8 +32650,8 @@ export default {};
     return transformAndCacheVue(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
   if (!TRANSPILABLE.has(ext))
     return;
-  const stat3 = statSync7(filePath);
-  const resolvedVueDir = vueDir ? resolve49(vueDir) : undefined;
+  const stat4 = statSync7(filePath);
+  const resolvedVueDir = vueDir ? resolve50(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) {
@@ -31692,7 +32670,7 @@ export default {};
       }
     }
   }
-  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, cachedAngularUserRoot, getAngularUserRoot = async (_projectRoot) => {
   if (cachedAngularUserRoot !== undefined)
@@ -31700,14 +32678,14 @@ export default {};
   cachedAngularUserRoot = configuredAngularUserRoot ?? null;
   return cachedAngularUserRoot;
 }, configuredAngularUserRoot, transformAndCacheSvelte = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const stat3 = statSync7(filePath);
+  const stat4 = statSync7(filePath);
   const content = await transformSvelteFile(filePath, projectRoot, rewriter, stylePreprocessors);
-  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformAndCacheVue = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const stat3 = statSync7(filePath);
+  const stat4 = statSync7(filePath);
   const content = await transformVueFile(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
-  setTransformed(filePath, content, stat3.mtimeMs, extractImportedFiles(content, projectRoot));
+  setTransformed(filePath, content, stat4.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformErrorResponse = (err) => {
   const errMsg = err instanceof Error ? err.message : String(err);
@@ -31732,7 +32710,7 @@ export default {};
     const relPath = pathname.slice(SRC_PREFIX.length);
     if (relPath === "bun:wrap" || relPath.startsWith("bun:wrap?"))
       return handleBunWrapRequest();
-    const virtualCssResponse = handleVirtualSvelteCss(resolve49(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve50(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath2(relPath, projectRoot);
@@ -31748,11 +32726,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve49(projectRoot, match[1]));
+      files.push(resolve50(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve49(filePath);
+  const resolved = resolve50(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -31815,7 +32793,7 @@ export default {};
     return false;
   }
   const { patchManifestIndexes: patchManifestIndexes2 } = await Promise.resolve().then(() => (init_prepare(), exports_prepare));
-  patchManifestIndexes2(cached.manifest, resolve49(state.resolvedPaths.buildDir, "_src_indexes"), SRC_PREFIX);
+  patchManifestIndexes2(cached.manifest, resolve50(state.resolvedPaths.buildDir, "_src_indexes"), SRC_PREFIX);
   logPageBuild(entry.source, entry.framework, Math.round(durationMs));
   logStartupTimingBlock("AbsoluteJS on-demand page build", [
     { durationMs, label: entry.name }
@@ -31947,7 +32925,7 @@ __export(exports_rewriteImports, {
   rewriteVendorDirectories: () => rewriteVendorDirectories2
 });
 var rewriteImports2 = async (outputPaths, vendorPaths) => {
-  const jsFiles = outputPaths.filter((path) => path.endsWith(".js"));
+  const jsFiles = outputPaths.filter((path2) => path2.endsWith(".js"));
   if (jsFiles.length === 0)
     return;
   if (Object.keys(vendorPaths).length === 0)
@@ -31981,13 +32959,13 @@ var init_rewriteImports = __esm(() => {
 });
 
 // src/core/pageResponseCache.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 var STREAMING_PAGE_HEADER = "x-absolute-stream", HTML_CONTENT_TYPE = "text/html", streamingPageHeaders = (extra) => {
   const headers = new Headers(extra);
   headers.set("content-type", HTML_CONTENT_TYPE);
   headers.set(STREAMING_PAGE_HEADER, "1");
   return headers;
-}, computeEtag = (html) => `W/"${createHash10("sha1").update(html).digest("base64url")}"`, withPageCacheHeaders = async (response, request, options) => {
+}, computeEtag = (html) => `W/"${createHash11("sha1").update(html).digest("base64url")}"`, withPageCacheHeaders = async (response, request, options) => {
   const contentType = response.headers.get("content-type") ?? "";
   if (!contentType.includes(HTML_CONTENT_TYPE))
     return response;
@@ -32055,7 +33033,7 @@ var init_routeAssets = __esm(() => {
 });
 
 // src/ember/pageHandler.ts
-import { pathToFileURL as pathToFileURL4 } from "url";
+import { pathToFileURL as pathToFileURL5 } from "url";
 var resolveRequestPathname2 = (request) => {
   if (!request)
     return;
@@ -32077,7 +33055,7 @@ var resolveRequestPathname2 = (request) => {
 }, emberCacheBuster = 0, buildRuntimeModuleSpecifier = (modulePath) => {
   if (emberCacheBuster === 0)
     return modulePath;
-  const moduleUrl = new URL(pathToFileURL4(modulePath).href);
+  const moduleUrl = new URL(pathToFileURL5(modulePath).href);
   moduleUrl.searchParams.set("t", String(emberCacheBuster));
   return moduleUrl.href;
 }, invalidateEmberSsrCache = () => {
@@ -32178,11 +33156,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve50 } from "path";
+import { resolve as resolve51 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve50(htmlFilePath);
+    const resolvedPath = resolve51(htmlFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -32208,11 +33186,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve51 } from "path";
+import { resolve as resolve52 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve51(htmxFilePath);
+    const resolvedPath = resolve52(htmxFilePath);
     const file5 = Bun.file(resolvedPath);
     if (!await file5.exists()) {
       return null;
@@ -32243,12 +33221,12 @@ __export(exports_rebuildTrigger, {
 import { existsSync as existsSync47, readdirSync as readdirSync13, rmSync as rmSync4 } from "fs";
 import {
   basename as basename21,
-  dirname as dirname35,
-  isAbsolute as isAbsolute8,
+  dirname as dirname36,
+  isAbsolute as isAbsolute9,
   join as join60,
-  relative as relative22,
+  relative as relative23,
   resolve as resolvePath4,
-  sep as sep4
+  sep as sep5
 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSsrCssCaches = () => {
   clearSpaRouteCssCaches();
@@ -32607,14 +33585,14 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
       const relFromDir = normalizedSource.slice(normalizedDir.length + 1);
       const { buildDir } = state.resolvedPaths;
       const destPath = resolvePath4(buildDir, urlPrefix ? `${urlPrefix}/${relFromDir}` : relFromDir);
-      const { mkdir: mkdir15, copyFile, readFile: readFile11 } = await import("fs/promises");
-      await mkdir15(dirname35(destPath), { recursive: true });
+      const { mkdir: mkdir16, copyFile, readFile: readFile12 } = await import("fs/promises");
+      await mkdir16(dirname36(destPath), { recursive: true });
       await copyFile(absSource, destPath);
-      const bytes = await readFile11(destPath);
+      const bytes = await readFile12(destPath);
       const webPath = urlPrefix ? `/${urlPrefix}/${relFromDir}` : `/${relFromDir}`;
       state.assetStore.set(webPath, new Uint8Array(bytes));
       state.fileHashes.set(absSource, currentHash);
-      logHmrUpdate(relative22(process.cwd(), filePath));
+      logHmrUpdate(relative23(process.cwd(), filePath));
       broadcastToClients(state, {
         data: {
           framework: urlPrefix || "public",
@@ -32634,7 +33612,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     return;
   if (framework === "unknown") {
     invalidate(resolvePath4(filePath));
-    const relPath = relative22(process.cwd(), filePath);
+    const relPath = relative23(process.cwd(), filePath);
     logHmrUpdate(relPath);
     const { angularDir } = state.resolvedPaths;
     let hasAngularDependent = false;
@@ -32790,7 +33768,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const keepStemsByDir = new Map;
   const prefixByDir = new Map;
   for (const artifact of freshOutputs) {
-    const dir = dirname35(artifact.path);
+    const dir = dirname36(artifact.path);
     const name = basename21(artifact.path);
     const [prefix] = name.split(".");
     if (!prefix)
@@ -33156,8 +34134,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve52) => {
-        ctx.debouncedResolve = resolve52;
+      ctx.debouncedPromise = new Promise((resolve53) => {
+        ctx.debouncedResolve = resolve53;
       });
     }
     const scheduled = ctx.debouncedPromise;
@@ -33183,7 +34161,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     const angularDirAbs = resolvePath4(angularDir);
     const filesUnderAngular = Array.from(editedFiles).filter((file5) => {
       const abs = resolvePath4(file5);
-      return abs === angularDirAbs || abs.startsWith(angularDirAbs + sep4);
+      return abs === angularDirAbs || abs.startsWith(angularDirAbs + sep5);
     });
     if (filesUnderAngular.length === 0)
       return;
@@ -33226,7 +34204,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
       try {
         const { invalidateModule: invalidateModule2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
         for (const tsFile of tsFilesToRefresh) {
-          const rel = relative22(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
+          const rel = relative23(angularDirAbs, tsFile).replace(/\\/g, "/").replace(/\.[tj]sx?$/, ".js");
           const compiledFile = resolvePath4(compiledRoot, rel);
           invalidateModule2(compiledFile);
         }
@@ -33381,7 +34359,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
 }, getModuleUrl = async (pageFile) => {
   const { invalidateModule: invalidateModule2, warmCache: warmCache2, SRC_URL_PREFIX: SRC_URL_PREFIX3 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   invalidateModule2(pageFile);
-  const rel = relative22(process.cwd(), pageFile).replace(/\\/g, "/");
+  const rel = relative23(process.cwd(), pageFile).replace(/\\/g, "/");
   const url = `${SRC_URL_PREFIX3}${rel}`;
   await warmCache2(url);
   return url;
@@ -33409,7 +34387,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const pageModuleUrl = await getReactModuleUrl(broadcastTarget);
   if (pageModuleUrl) {
     const serverDuration = Date.now() - startTime;
-    state.lastHmrPath = relative22(process.cwd(), primaryFile).replace(/\\/g, "/");
+    state.lastHmrPath = relative23(process.cwd(), primaryFile).replace(/\\/g, "/");
     state.lastHmrFramework = "react";
     broadcastToClients(state, {
       data: {
@@ -33702,8 +34680,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return () => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve52) => {
-        ctx.debouncedResolve = resolve52;
+      ctx.debouncedPromise = new Promise((resolve53) => {
+        ctx.debouncedResolve = resolve53;
       });
     }
     if (ctx.debounceTimer)
@@ -33914,7 +34892,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   if (vueSpaRoutesBySource.size > 0) {
     const spaManifestEntries = await writeSpaSideManifests(vueSpaRoutesBySource, (pascalName) => {
       const fromManifest = state.manifest[pascalName];
-      return typeof fromManifest === "string" && isAbsolute8(fromManifest) && fromManifest.endsWith(".js") ? fromManifest : undefined;
+      return typeof fromManifest === "string" && isAbsolute9(fromManifest) && fromManifest.endsWith(".js") ? fromManifest : undefined;
     });
     Object.assign(state.manifest, spaManifestEntries);
   }
@@ -33984,8 +34962,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   };
   return () => {
     if (!ctx.debouncedPromise) {
-      ctx.debouncedPromise = new Promise((resolve52) => {
-        ctx.debouncedResolve = resolve52;
+      ctx.debouncedPromise = new Promise((resolve53) => {
+        ctx.debouncedResolve = resolve53;
       });
     }
     if (ctx.debounceTimer)
@@ -34038,7 +35016,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const duration = Date.now() - startTime;
   const [primary] = emberFiles;
   if (primary) {
-    state.lastHmrPath = relative22(process.cwd(), primary).replace(/\\/g, "/");
+    state.lastHmrPath = relative23(process.cwd(), primary).replace(/\\/g, "/");
     state.lastHmrFramework = "ember";
     logHmrUpdate(primary, "ember", duration);
   }
@@ -34135,7 +35113,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolvePath4(dirname35(buildInfo.resolvedRegistryPath), buildReference.source);
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolvePath4(dirname36(buildInfo.resolvedRegistryPath), buildReference.source);
   islandFiles.add(resolvePath4(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
@@ -34307,7 +35285,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
-  const hmrId = vueRoot ? relative22(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+  const hmrId = vueRoot ? relative23(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
@@ -34521,10 +35499,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   if (sourceVersion !== undefined) {
     moduleVersions[update.sourceFile] = sourceVersion;
   }
-  Object.values(update.modulePaths).forEach((path) => {
-    const pathVersion = moduleVersionsStore.get(path);
+  Object.values(update.modulePaths).forEach((path2) => {
+    const pathVersion = moduleVersionsStore.get(path2);
     if (pathVersion !== undefined) {
-      moduleVersions[path] = pathVersion;
+      moduleVersions[path2] = pathVersion;
     }
   });
 }, handleModuleUpdates = (state, allModuleUpdates, manifest) => {
@@ -34986,7 +35964,7 @@ var toSafeFileName6 = (specifier) => {
   } catch {
     return false;
   }
-}, isBareSpecifier3 = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), isAbsolutePackageSpecifier = (spec) => spec === "@absolutejs/absolute" || spec.startsWith("@absolutejs/absolute/"), FRAMEWORK_SPECIFIERS, FRAMEWORK_NAMESPACE_PREFIXES, isFrameworkSpecifier = (spec) => FRAMEWORK_SPECIFIERS.has(spec) || FRAMEWORK_NAMESPACE_PREFIXES.some((prefix) => spec.startsWith(prefix)), FRAMEWORK_EXTERNALS, isSkippedFile = (file5) => file5.includes("node_modules") || file5.includes("/build/") || file5.includes("/dist/") || file5.includes("/indexes/") || isTestSourcePath(file5), isDepSpecifier = (path) => isBareSpecifier3(path) && !isBuiltin2(path) && !isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), isFrameworkRootCandidate = (path) => isBareSpecifier3(path) && isFrameworkSpecifier(path) && !isAbsolutePackageSpecifier(path), readFileSpecifiers = async (file5, transpiler7) => {
+}, isBareSpecifier3 = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !spec.startsWith("@src/"), isAbsolutePackageSpecifier = (spec) => spec === "@absolutejs/absolute" || spec.startsWith("@absolutejs/absolute/"), FRAMEWORK_SPECIFIERS, FRAMEWORK_NAMESPACE_PREFIXES, isFrameworkSpecifier = (spec) => FRAMEWORK_SPECIFIERS.has(spec) || FRAMEWORK_NAMESPACE_PREFIXES.some((prefix) => spec.startsWith(prefix)), FRAMEWORK_EXTERNALS, isSkippedFile = (file5) => file5.includes("node_modules") || file5.includes("/build/") || file5.includes("/dist/") || file5.includes("/indexes/") || isTestSourcePath(file5), isDepSpecifier = (path2) => isBareSpecifier3(path2) && !isBuiltin2(path2) && !isFrameworkSpecifier(path2) && !isAbsolutePackageSpecifier(path2), isFrameworkRootCandidate = (path2) => isBareSpecifier3(path2) && isFrameworkSpecifier(path2) && !isAbsolutePackageSpecifier(path2), readFileSpecifiers = async (file5, transpiler7) => {
   const dep = [];
   const framework = [];
   try {
@@ -35030,22 +36008,22 @@ var toSafeFileName6 = (specifier) => {
   };
 }, collectBareImportsFromFile = async (entryPath, transpiler7, maxDepth = 8) => {
   const { readFileSync: readFileSync41 } = await import("fs");
-  const { dirname: dirname36 } = await import("path");
+  const { dirname: dirname37 } = await import("path");
   const seenFiles = new Set;
   const bareOut = new Set;
   const queue = [
     { depth: 0, path: entryPath }
   ];
   while (queue.length > 0) {
-    const { path, depth } = queue.shift();
-    if (seenFiles.has(path))
+    const { path: path2, depth } = queue.shift();
+    if (seenFiles.has(path2))
       continue;
-    seenFiles.add(path);
+    seenFiles.add(path2);
     if (depth > maxDepth)
       continue;
     let content;
     try {
-      content = readFileSync41(path, "utf-8");
+      content = readFileSync41(path2, "utf-8");
     } catch {
       continue;
     }
@@ -35055,7 +36033,7 @@ var toSafeFileName6 = (specifier) => {
     } catch {
       continue;
     }
-    const fromDir = dirname36(path);
+    const fromDir = dirname37(path2);
     for (const imp of imports) {
       const child = imp.path;
       if (child.startsWith(".") || child.startsWith("/")) {
@@ -35075,7 +36053,7 @@ var toSafeFileName6 = (specifier) => {
   }
   return Array.from(bareOut);
 }, MAX_DISCOVERY_FILES = 2000, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { dirname: dirname36 } = await import("path");
+  const { dirname: dirname37 } = await import("path");
   const transpiler7 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   const queue = [...specs].map((spec) => ({ from: process.cwd(), spec }));
@@ -35096,7 +36074,7 @@ var toSafeFileName6 = (specifier) => {
     }
     visited += 1;
     const bareImports = await collectBareImportsFromFile(resolved, transpiler7);
-    const importerDirectory = dirname36(resolved);
+    const importerDirectory = dirname37(resolved);
     for (const child of bareImports) {
       if (!isBareSpecifier3(child))
         continue;
@@ -35159,11 +36137,11 @@ var toSafeFileName6 = (specifier) => {
       const output = lastResult.outputs[0];
       if (!output)
         return lastResult;
-      const text2 = await output.text();
+      const text3 = await output.text();
       REQUIRE_CALL_RE.lastIndex = 0;
       const requiredSpecs = new Set;
       let match;
-      while ((match = REQUIRE_CALL_RE.exec(text2)) !== null) {
+      while ((match = REQUIRE_CALL_RE.exec(text3)) !== null) {
         const requiredSpec = match[1];
         if (requiredSpec && externalsSet.has(requiredSpec)) {
           requiredSpecs.add(requiredSpec);
@@ -35310,7 +36288,7 @@ __export(exports_vendorCache, {
   saveVendorCache: () => saveVendorCache,
   vendorCacheEnabled: () => vendorCacheEnabled
 });
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import {
   copyFileSync as copyFileSync4,
   existsSync as existsSync48,
@@ -35318,10 +36296,10 @@ import {
   readdirSync as readdirSync14,
   readFileSync as readFileSync41
 } from "fs";
-import { mkdir as mkdir15, readFile as readFile11, rename as rename7, rm as rm16, writeFile as writeFile13 } from "fs/promises";
-import { basename as basename22, join as join62, resolve as resolve52 } from "path";
+import { mkdir as mkdir16, readFile as readFile12, rename as rename7, rm as rm16, writeFile as writeFile13 } from "fs/promises";
+import { basename as basename22, join as join62, resolve as resolve53 } from "path";
 var CACHE_ROOT2, CACHE_FORMAT_VERSION3 = 1, KEY_LENGTH = 32, LOCKFILES, computeVendorCacheKey = (inputs) => {
-  const hash = createHash11("sha256");
+  const hash = createHash12("sha256");
   hash.update(String(CACHE_FORMAT_VERSION3));
   hash.update("\x00");
   hash.update(inputs.lockfileHash);
@@ -35339,19 +36317,19 @@ var CACHE_ROOT2, CACHE_FORMAT_VERSION3 = 1, KEY_LENGTH = 32, LOCKFILES, computeV
   }
   for (const dir of inputs.vendorDirs) {
     hash.update("\x00v");
-    hash.update(basename22(resolve52(dir, "..")));
+    hash.update(basename22(resolve53(dir, "..")));
   }
   return hash.digest("hex").slice(0, KEY_LENGTH);
 }, readLockfileHash = (projectRoot = process.cwd()) => {
-  const hash = createHash11("sha256");
+  const hash = createHash12("sha256");
   let found = false;
   for (const name of LOCKFILES) {
-    const path = join62(projectRoot, name);
-    if (!existsSync48(path))
+    const path2 = join62(projectRoot, name);
+    if (!existsSync48(path2))
       continue;
     found = true;
     hash.update(name);
-    hash.update(readFileSync41(path));
+    hash.update(readFileSync41(path2));
   }
   return found ? hash.digest("hex") : null;
 }, vendorCacheEnabled = () => process.env.ABSOLUTE_DEV_VENDOR_CACHE !== "0", copyTree = (fromDir, toDir) => {
@@ -35378,13 +36356,13 @@ var CACHE_ROOT2, CACHE_FORMAT_VERSION3 = 1, KEY_LENGTH = 32, LOCKFILES, computeV
       continue;
     copyTree(dir, join62(stagingDir, slotName(index, dir)));
   }
-}, isVendorCachePayload = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "depPaths") === "object", cacheDirFor = (key, projectRoot) => resolve52(projectRoot, CACHE_ROOT2, key), slotName = (index, dir) => `${index}-${basename22(resolve52(dir, ".."))}`, restoreVendorCache = async (key, vendorDirs, projectRoot = process.cwd()) => {
+}, isVendorCachePayload = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "depPaths") === "object", cacheDirFor = (key, projectRoot) => resolve53(projectRoot, CACHE_ROOT2, key), slotName = (index, dir) => `${index}-${basename22(resolve53(dir, ".."))}`, restoreVendorCache = async (key, vendorDirs, projectRoot = process.cwd()) => {
   const cacheDir2 = cacheDirFor(key, projectRoot);
   const payloadPath = join62(cacheDir2, "payload.json");
   if (!existsSync48(payloadPath))
     return null;
   try {
-    const payload = JSON.parse(await readFile11(payloadPath, "utf8"));
+    const payload = JSON.parse(await readFile12(payloadPath, "utf8"));
     if (!isVendorCachePayload(payload))
       return null;
     copySlotsInto(cacheDir2, vendorDirs);
@@ -35399,7 +36377,7 @@ var CACHE_ROOT2, CACHE_FORMAT_VERSION3 = 1, KEY_LENGTH = 32, LOCKFILES, computeV
   const stagingDir = `${cacheDir2}.${process.pid}.tmp`;
   try {
     await rm16(stagingDir, { force: true, recursive: true });
-    await mkdir15(stagingDir, { recursive: true });
+    await mkdir16(stagingDir, { recursive: true });
     copySlotsFrom(stagingDir, vendorDirs);
     await writeFile13(join62(stagingDir, "payload.json"), JSON.stringify(payload));
     await rm16(cacheDir2, { force: true, recursive: true });
@@ -35430,8 +36408,8 @@ __export(exports_devBuild, {
 });
 import { readdir as readdir6 } from "fs/promises";
 import { existsSync as existsSync49, statSync as statSync8 } from "fs";
-import { resolve as resolve53 } from "path";
-var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.dir, "../dev/client"), collectDepVendorSourceDirs = (config) => {
+import { resolve as resolve54 } from "path";
+var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve54(import.meta.dir, "../dev/client"), collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     ...collectConfigVendorSourceDirs(config),
     devClientVendorSourceDir()
@@ -35454,7 +36432,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.d
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve53(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve54(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -35506,7 +36484,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.d
     setEmberVendorPaths(computeEmberVendorPaths());
   }
   const newWatchPaths = getWatchPaths(state.config, state.resolvedPaths);
-  const addedPaths = newWatchPaths.filter((path) => !oldWatchPaths.has(path));
+  const addedPaths = newWatchPaths.filter((path2) => !oldWatchPaths.has(path2));
   if (addedPaths.length > 0) {
     buildInitialDependencyGraph(state.dependencyGraph, addedPaths);
     addFileWatchers(state, addedPaths, (filePath) => {
@@ -35569,7 +36547,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.d
     });
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync8(resolve53(Bun.main)).mtimeMs;
+  const serverMtime = statSync8(resolve54(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -35601,8 +36579,8 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.d
     return;
   await detectConfigChanges(cached);
   await rebuildManifest(cached);
-}, tryReadPackageVersion = async (path) => {
-  const pkg = await Bun.file(path).json().catch(() => null);
+}, tryReadPackageVersion = async (path2) => {
+  const pkg = await Bun.file(path2).json().catch(() => null);
   if (!pkg || pkg.name !== "@absolutejs/absolute") {
     return false;
   }
@@ -35610,8 +36588,8 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.d
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve53(import.meta.dir, "..", "..", "package.json"),
-    resolve53(import.meta.dir, "..", "package.json")
+    resolve54(import.meta.dir, "..", "..", "package.json"),
+    resolve54(import.meta.dir, "..", "package.json")
   ];
   const [candidate, ...remaining] = candidates;
   if (!candidate) {
@@ -35637,7 +36615,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.d
   const entries = await readdir6(vendorDir).catch(() => emptyStringArray);
   await Promise.all(entries.filter((entry) => entry.endsWith(".js")).map(async (entry) => {
     const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve53(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve54(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -35823,11 +36801,11 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.d
   }
   stepStartedAt = performance.now();
   setBootPhase("build vendor bundles");
-  const reactVendorDir = resolve53(state.resolvedPaths.buildDir, "react", "vendor");
-  const angularVendorDir = resolve53(state.resolvedPaths.buildDir, "angular", "vendor");
-  const svelteVendorDir = resolve53(state.resolvedPaths.buildDir, "svelte", "vendor");
-  const vueVendorDir = resolve53(state.resolvedPaths.buildDir, "vue", "vendor");
-  const depVendorDir = resolve53(state.resolvedPaths.buildDir, "vendor");
+  const reactVendorDir = resolve54(state.resolvedPaths.buildDir, "react", "vendor");
+  const angularVendorDir = resolve54(state.resolvedPaths.buildDir, "angular", "vendor");
+  const svelteVendorDir = resolve54(state.resolvedPaths.buildDir, "svelte", "vendor");
+  const vueVendorDir = resolve54(state.resolvedPaths.buildDir, "vue", "vendor");
+  const depVendorDir = resolve54(state.resolvedPaths.buildDir, "vendor");
   const { buildDepVendor: buildDepVendor2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
   const activeVendorDirs = [
     config.reactDirectory ? reactVendorDir : null,
@@ -35950,7 +36928,7 @@ var FRAMEWORK_DIR_KEYS, devClientVendorSourceDir = () => resolve53(import.meta.d
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync8(resolve53(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync8(resolve54(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -35991,5 +36969,5 @@ export {
   devBuild
 };
 
-//# debugId=45E97F77A3254DD664756E2164756E21
+//# debugId=7849DC008DCD28AC64756E2164756E21
 //# sourceMappingURL=build.js.map