@absolutejs/absolute 0.20.0-beta.3 → 0.20.0-beta.4

package/dist/cli/index.js

@@ -3379,6 +3379,548 @@ var init_iosSimulatorController = __esm(() => {
   ];
 });
 
+// src/mobile/remoteMacWire.ts
+var ABSOLUTE_REMOTE_MAC_EVENT_PREFIX = "ABSOLUTE_REMOTE_MAC\t", ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION = 1;
+
+// src/mobile/remoteMacProtocol.ts
+import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
+import { chmod, mkdir as mkdir5, readFile as readFile6, rename as rename5, writeFile as writeFile5 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import {
+  dirname as dirname6,
+  isAbsolute as isAbsolute4,
+  join as join10,
+  posix,
+  relative as relative5,
+  resolve as resolvePath,
+  sep as sep4
+} from "path";
+var PROFILE_FORMAT = 1, PROFILE_NAME, SSH_DESTINATION, defaultProfilePath = () => join10(homedir4(), ".absolutejs", "mobile", "remote-macs.json"), emptyStore = () => ({
+  format: PROFILE_FORMAT,
+  profiles: {}
+}), loadStore = async (path = defaultProfilePath()) => {
+  try {
+    const parsed = JSON.parse(await readFile6(path, "utf8"));
+    if (parsed.format !== PROFILE_FORMAT || typeof parsed.profiles !== "object" || parsed.profiles === null || Array.isArray(parsed.profiles))
+      throw new Error("Unsupported remote Mac profile format.");
+    for (const [key, profile] of Object.entries(parsed.profiles)) {
+      if (typeof profile !== "object" || profile === null || validateAbsoluteRemoteMacProfileName(key) !== key || profile.name !== key || validateAbsoluteSshDestination(profile.destination) !== profile.destination || validatePort(profile.port) !== profile.port || typeof profile.createdAt !== "string" || !profile.createdAt || typeof profile.bunPath !== "string" || !profile.bunPath.startsWith("/") || /[\r\n\0]/u.test(profile.bunPath) || typeof profile.workspaceRoot !== "string" || !profile.workspaceRoot.startsWith("/") || profile.workspaceRoot === "/" || /[\r\n\0]/u.test(profile.workspaceRoot) || typeof profile.xcodeVersion !== "string" || !profile.xcodeVersion.startsWith("Xcode "))
+        throw new Error(`Remote Mac profile ${JSON.stringify(key)} is invalid.`);
+    }
+    if (parsed.defaultProfile !== undefined && !parsed.profiles[parsed.defaultProfile])
+      throw new Error("The default remote Mac profile does not exist.");
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return emptyStore();
+    throw error;
+  }
+}, saveStore = async (store, path = defaultProfilePath()) => {
+  await mkdir5(dirname6(path), { recursive: true });
+  const temporary = `${path}.${randomUUID3()}.tmp`;
+  await writeFile5(temporary, `${JSON.stringify(store, null, 2)}
+`, {
+    mode: 384
+  });
+  await rename5(temporary, path);
+  await chmod(path, 384);
+}, validateAbsoluteRemoteMacProfileName = (name) => {
+  const normalized = name.trim().toLowerCase();
+  if (!PROFILE_NAME.test(normalized))
+    throw new TypeError("Remote Mac profile names must use 1-64 lowercase letters, digits, dots, dashes, or underscores.");
+  return normalized;
+}, validateAbsoluteSshDestination = (destination) => {
+  const normalized = destination.trim();
+  if (!SSH_DESTINATION.test(normalized) || normalized.startsWith("-"))
+    throw new TypeError("Remote Mac SSH destination must be a host, SSH alias, or user@host without command-line options.");
+  return normalized;
+}, validatePort = (port) => {
+  if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
+    throw new TypeError("Remote Mac SSH port must be between 1 and 65535.");
+  return port;
+}, shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`, absoluteRemoteMacSshBase = (profile, options = {}) => [
+  "ssh",
+  "-o",
+  "BatchMode=yes",
+  "-o",
+  "ConnectTimeout=10",
+  "-o",
+  "ServerAliveInterval=15",
+  "-o",
+  "ServerAliveCountMax=3",
+  "-o",
+  `StrictHostKeyChecking=${options.acceptNew ? "accept-new" : "yes"}`,
+  ...profile.port ? ["-p", String(profile.port)] : [],
+  profile.destination
+], localCapture = async (command) => {
+  const process2 = Bun.spawn(command, {
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    process2.exited,
+    new Response(process2.stdout).text(),
+    new Response(process2.stderr).text()
+  ]);
+  return { exitCode, stderr, stdout };
+}, defaultTransport, requireRemoteSuccess = (result, label) => {
+  if (result.exitCode !== 0)
+    throw new Error(`${label} failed: ${(result.stderr || result.stdout).trim() || `status ${result.exitCode}`}`);
+  return result.stdout.trim();
+}, getAbsoluteRemoteMacProfile = async (name, profilePath) => {
+  const store = await loadStore(profilePath);
+  const selected = name ?? process.env.ABSOLUTE_IOS_REMOTE ?? store.defaultProfile;
+  if (!selected)
+    return;
+  const profile = store.profiles[selected];
+  if (!profile)
+    throw new Error(`Remote Mac profile ${JSON.stringify(selected)} was not found.`);
+  return profile;
+}, inspectAbsoluteRemoteMac = async (destination, options = {}) => {
+  const profile = {
+    destination: validateAbsoluteSshDestination(destination),
+    port: validatePort(options.port)
+  };
+  const capture = options.transport?.capture ?? defaultTransport.capture;
+  const command = [
+    ...absoluteRemoteMacSshBase(profile, {
+      acceptNew: options.acceptNew === true
+    }),
+    "/bin/sh -lc",
+    shellQuote(`bun_path="$(command -v bun || true)"; if [ -z "$bun_path" ] && [ -x "$HOME/.bun/bin/bun" ]; then bun_path="$HOME/.bun/bin/bun"; fi; printf '%s\\n' "$(uname -s)" "$HOME" "$bun_path" "$(/usr/bin/xcodebuild -version 2>/dev/null | tr '\\n' ' ' || true)"`)
+  ];
+  const lines = requireRemoteSuccess(await capture(command), "Remote Mac handshake").split(/\r?\n/u);
+  const [operatingSystem, home, bunPath, xcodeVersion] = lines;
+  if (operatingSystem !== "Darwin")
+    throw new Error("The SSH target is not a Mac.");
+  if (!home?.startsWith("/") || !bunPath?.startsWith("/"))
+    throw new Error("The remote Mac must have Bun installed and available to SSH.");
+  if (!xcodeVersion?.startsWith("Xcode "))
+    throw new Error("The remote Mac must have full Xcode installed and selected.");
+  return { bunPath, home, os: operatingSystem, xcodeVersion };
+}, listAbsoluteRemoteMacProfiles = async (profilePath) => {
+  const store = await loadStore(profilePath);
+  return {
+    defaultProfile: store.defaultProfile,
+    profiles: Object.values(store.profiles).sort((left, right) => left.name.localeCompare(right.name))
+  };
+}, pairAbsoluteRemoteMac = async (options) => {
+  const name = validateAbsoluteRemoteMacProfileName(options.name);
+  const destination = validateAbsoluteSshDestination(options.destination);
+  const port = validatePort(options.port);
+  const inspection = await inspectAbsoluteRemoteMac(destination, {
+    acceptNew: true,
+    port,
+    transport: options.transport
+  });
+  const workspaceRoot = options.workspaceRoot ? options.workspaceRoot.trim() : posix.join(inspection.home, ".absolutejs", "remote-ios");
+  if (!workspaceRoot.startsWith("/") || workspaceRoot === "/" || /[\r\n\0]/u.test(workspaceRoot))
+    throw new TypeError("Remote Mac workspace must be an absolute macOS path.");
+  const profile = {
+    bunPath: inspection.bunPath,
+    createdAt: new Date().toISOString(),
+    destination,
+    name,
+    ...port ? { port } : {},
+    workspaceRoot,
+    xcodeVersion: inspection.xcodeVersion
+  };
+  const store = await loadStore(options.profilePath);
+  store.profiles[name] = profile;
+  store.defaultProfile = name;
+  await saveStore(store, options.profilePath);
+  return profile;
+}, removeAbsoluteRemoteMacProfile = async (name, profilePath) => {
+  const normalized = validateAbsoluteRemoteMacProfileName(name);
+  const store = await loadStore(profilePath);
+  if (!store.profiles[normalized])
+    return false;
+  delete store.profiles[normalized];
+  if (store.defaultProfile === normalized) {
+    const [nextDefault] = Object.keys(store.profiles).sort();
+    store.defaultProfile = nextDefault;
+  }
+  await saveStore(store, profilePath);
+  return true;
+}, projectIdentity = (projectRoot, appId) => createHash5("sha256").update(`${resolvePath(projectRoot)}\x00${appId}`).digest("hex").slice(0, 20), createAbsoluteRemoteIosDevProject = (config, projectRoot, profile) => ({
+  cap: join10(resolvePath(projectRoot), "node_modules", ".bin", "cap"),
+  config,
+  nativeDirectory: join10(config.nativeProjectDirectory, "ios"),
+  profile,
+  projectRoot: resolvePath(projectRoot),
+  remote: true,
+  remoteProjectRoot: posix.join(profile.workspaceRoot, "projects", projectIdentity(projectRoot, config.appId), "current"),
+  xcodebuild: "remote:xcodebuild",
+  xcrun: "remote:xcrun"
+}), installAbsoluteRemoteMacAgent = async (project) => {
+  const artifact = await materializeAbsoluteRemoteMacAgent(project.projectRoot);
+  const directory = posix.join(project.profile.workspaceRoot, "agents", `protocol-${ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION}`, artifact.sha256);
+  const remotePath = posix.join(directory, "agent.js");
+  const verifyScript = `test -f ${shellQuote(remotePath)} && ` + `test "$(shasum -a 256 ${shellQuote(remotePath)} | awk '{print $1}')" = ${shellQuote(artifact.sha256)}`;
+  const verified = await defaultTransport.capture([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(verifyScript)
+  ]);
+  if (verified.exitCode === 0)
+    return { ...artifact, remotePath, uploaded: false };
+  const temporary = posix.join(directory, `.agent-${randomUUID3()}.tmp`);
+  const installScript = [
+    "set -eu",
+    "umask 077",
+    `mkdir -p ${shellQuote(directory)}`,
+    `cat > ${shellQuote(temporary)}`,
+    `test "$(shasum -a 256 ${shellQuote(temporary)} | awk '{print $1}')" = ${shellQuote(artifact.sha256)}`,
+    `chmod 600 ${shellQuote(temporary)}`,
+    `mv ${shellQuote(temporary)} ${shellQuote(remotePath)}`
+  ].join("; ");
+  const upload = Bun.spawn([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(installScript)
+  ], {
+    stderr: "pipe",
+    stdin: Bun.file(artifact.path),
+    stdout: "pipe"
+  });
+  const [exitCode, stderr] = await Promise.all([
+    upload.exited,
+    new Response(upload.stderr).text()
+  ]);
+  if (exitCode !== 0)
+    throw new Error(`Remote Mac agent installation failed: ${stderr.trim() || `status ${exitCode}`}`);
+  return { ...artifact, remotePath, uploaded: true };
+}, materializeAbsoluteRemoteMacAgent = async (projectRoot) => {
+  const shippedCandidates = [
+    join10(import.meta.dir, "remoteMacAgentEntry.js"),
+    join10(import.meta.dir, "..", "mobile", "remoteMacAgentEntry.js")
+  ];
+  let path;
+  for (const candidate of shippedCandidates) {
+    if (await Bun.file(candidate).exists()) {
+      path = candidate;
+      break;
+    }
+  }
+  if (!path) {
+    const sourceCandidates = [
+      join10(import.meta.dir, "remoteMacAgentEntry.ts"),
+      join10(import.meta.dir, "..", "..", "src", "mobile", "remoteMacAgentEntry.ts")
+    ];
+    const source = await sourceCandidates.reduce(async (found, candidate) => await found ?? (await Bun.file(candidate).exists() ? candidate : undefined), Promise.resolve(undefined));
+    if (!source)
+      throw new Error("The AbsoluteJS installation does not contain its remote Mac agent artifact.");
+    const outdir = join10(resolvePath(projectRoot), ".absolutejs", "mobile", "remote-agent");
+    await mkdir5(outdir, { recursive: true });
+    const result = await Bun.build({
+      entrypoints: [source],
+      minify: true,
+      outdir,
+      target: "bun"
+    });
+    if (!result.success)
+      throw new AggregateError(result.logs, "Failed to build the AbsoluteJS remote Mac agent.");
+    path = join10(outdir, "remoteMacAgentEntry.js");
+  }
+  const bytes = await Bun.file(path).arrayBuffer();
+  const sha256 = createHash5("sha256").update(new Uint8Array(bytes)).digest("hex");
+  return { bytes: bytes.byteLength, path, sha256 };
+}, portableRelativePath = (root, path) => relative5(root, path).split(sep4).join(posix.sep), portableMobileConfig = (project) => ({
+  appId: project.config.appId,
+  appName: project.config.appName,
+  bundleDirectory: portableRelativePath(project.projectRoot, project.config.bundleDirectory),
+  ...project.config.deepLinkScheme || project.config.deepLinkHosts.length > 1 || project.config.appleAppIdPrefix ? {
+    deepLinks: {
+      ...project.config.deepLinkScheme ? { scheme: project.config.deepLinkScheme } : {},
+      hosts: project.config.deepLinkHosts,
+      ...project.config.appleAppIdPrefix ? {
+        apple: {
+          appIdPrefix: project.config.appleAppIdPrefix
+        }
+      } : {}
+    }
+  } : {},
+  entry: project.config.entry,
+  ...project.config.iosVersion ? { ios: { version: project.config.iosVersion } } : {},
+  nativeProject: {
+    directory: portableRelativePath(project.projectRoot, project.config.nativeProjectDirectory),
+    mode: "source"
+  },
+  platforms: ["ios"],
+  server: { productionOrigin: project.config.productionOrigin }
+}), absoluteRemoteProjectSyncCommands = (project) => {
+  const current = project.remoteProjectRoot;
+  const parent = posix.dirname(current);
+  const staging = posix.join(parent, `.incoming-${randomUUID3()}`);
+  const previous = posix.join(parent, ".previous");
+  const script = [
+    "set -eu",
+    `mkdir -p ${shellQuote(staging)}`,
+    `tar -xf - -C ${shellQuote(staging)}`,
+    `if [ -d ${shellQuote(posix.join(current, "node_modules"))} ]; then mv ${shellQuote(posix.join(current, "node_modules"))} ${shellQuote(posix.join(staging, "node_modules"))}; fi`,
+    `if [ -d ${shellQuote(posix.join(current, ".absolutejs"))} ]; then mv ${shellQuote(posix.join(current, ".absolutejs"))} ${shellQuote(posix.join(staging, ".absolutejs"))}; fi`,
+    `rm -rf ${shellQuote(previous)}`,
+    `if [ -d ${shellQuote(current)} ]; then mv ${shellQuote(current)} ${shellQuote(previous)}; fi`,
+    `mv ${shellQuote(staging)} ${shellQuote(current)}`,
+    `rm -rf ${shellQuote(previous)}`
+  ].join("; ");
+  return {
+    remote: [
+      ...absoluteRemoteMacSshBase(project.profile),
+      "/bin/sh -lc",
+      shellQuote(script)
+    ],
+    tar: [
+      "tar",
+      "--exclude=.git",
+      "--exclude=node_modules",
+      "--exclude=build",
+      "--exclude=.absolutejs",
+      "-cf",
+      "-",
+      "-C",
+      project.projectRoot,
+      "."
+    ]
+  };
+}, syncAbsoluteRemoteMacProject = async (project) => {
+  const commands = absoluteRemoteProjectSyncCommands(project);
+  const archive = Bun.spawn(commands.tar, {
+    stderr: "pipe",
+    stdout: "pipe"
+  });
+  const upload = Bun.spawn(commands.remote, {
+    stderr: "pipe",
+    stdin: archive.stdout,
+    stdout: "pipe"
+  });
+  const [archiveExit, uploadExit, archiveError, uploadError] = await Promise.all([
+    archive.exited,
+    upload.exited,
+    new Response(archive.stderr).text(),
+    new Response(upload.stderr).text()
+  ]);
+  if (archiveExit !== 0 || uploadExit !== 0)
+    throw new Error(`Remote Mac project synchronization failed: ${(archiveError || uploadError).trim()}`);
+  const install = await defaultTransport.capture([
+    ...absoluteRemoteMacSshBase(project.profile),
+    "/bin/sh -lc",
+    shellQuote(`cd ${shellQuote(project.remoteProjectRoot)} && ${shellQuote(project.profile.bunPath)} install --frozen-lockfile`)
+  ]);
+  requireRemoteSuccess(install, "Remote Mac dependency installation");
+}, consumeLines2 = async (stream, onLine) => {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffered += decoder.decode(value, { stream: true });
+      const lines = buffered.split(/\r?\n/u);
+      buffered = lines.pop() ?? "";
+      lines.forEach(onLine);
+    }
+    buffered += decoder.decode();
+    if (buffered)
+      onLine(buffered);
+  } finally {
+    reader.releaseLock();
+  }
+}, startAbsoluteRemoteIosDevSession = async (options) => {
+  const startedAt = performance.now();
+  const transport = options.transport ?? defaultTransport;
+  const installAgent = options.installAgent ?? installAbsoluteRemoteMacAgent;
+  const syncProject = options.syncProject ?? syncAbsoluteRemoteMacProject;
+  const agentStartedAt = performance.now();
+  const agent = await installAgent(options.project);
+  const agentDuration = performance.now() - agentStartedAt;
+  const syncStartedAt = performance.now();
+  await syncProject(options.project);
+  const syncDuration = performance.now() - syncStartedAt;
+  const encodedConfig = Buffer.from(JSON.stringify(portableMobileConfig(options.project))).toString("base64url");
+  const remoteCommand = [
+    `cd ${shellQuote(options.project.remoteProjectRoot)}`,
+    "&&",
+    "exec",
+    shellQuote(options.project.profile.bunPath),
+    shellQuote(agent.remotePath),
+    "--port",
+    String(options.port),
+    "--mobile-config",
+    shellQuote(encodedConfig),
+    ...options.https ? ["--https"] : []
+  ].join(" ");
+  const command = [
+    ...absoluteRemoteMacSshBase(options.project.profile),
+    "-o",
+    "ExitOnForwardFailure=yes",
+    "-R",
+    `${options.port}:127.0.0.1:${options.port}`,
+    "/bin/sh -lc",
+    shellQuote(remoteCommand)
+  ];
+  const connectStartedAt = performance.now();
+  const process2 = transport.spawn(command, { signal: options.signal });
+  let state = "syncing";
+  let ready;
+  let fatal;
+  const pending = new Map;
+  let resolveReady;
+  let rejectReady;
+  const readyPromise = new Promise((resolve8, reject) => {
+    resolveReady = resolve8;
+    rejectReady = reject;
+  });
+  const handleEvent = (event) => {
+    if (event.v !== ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION) {
+      rejectReady(new Error("Remote Mac protocol version mismatch."));
+      return;
+    }
+    if (event.type === "log")
+      options.log?.(event.message);
+    if (event.type === "native-log")
+      options.nativeLog?.(event.entry);
+    if (event.type === "state") {
+      ({ state } = event);
+      options.onStateChange?.(state);
+    }
+    if (event.type === "timing")
+      options.onPhaseTiming?.(event);
+    if (event.type === "ready") {
+      ready = event;
+      resolveReady();
+    }
+    if (event.type === "fatal") {
+      fatal = new Error(event.error);
+      rejectReady(fatal);
+    }
+    if (event.type === "response") {
+      const request2 = pending.get(event.id);
+      if (!request2)
+        return;
+      pending.delete(event.id);
+      if (event.ok)
+        request2.resolve(event.result);
+      else
+        request2.reject(new Error(event.error ?? "Remote command failed."));
+    }
+  };
+  const stdoutDone = consumeLines2(process2.stdout, (line) => {
+    if (!line.startsWith(ABSOLUTE_REMOTE_MAC_EVENT_PREFIX))
+      return;
+    try {
+      handleEvent(JSON.parse(line.slice(ABSOLUTE_REMOTE_MAC_EVENT_PREFIX.length)));
+    } catch {
+      options.log?.(`Remote Mac emitted an invalid protocol event.`);
+    }
+  }).catch((error) => {
+    fatal = error instanceof Error ? error : new Error("Failed to read the remote Mac protocol stream.");
+    rejectReady(fatal);
+  });
+  const stderrDone = consumeLines2(process2.stderr, (line) => options.log?.(`[remote] ${line}`)).catch((error) => options.log?.(`[remote] ${error instanceof Error ? error.message : "Failed to read SSH stderr."}`));
+  process2.exited.then(async (exitCode) => {
+    await Promise.all([stdoutDone, stderrDone]);
+    const error = fatal ?? new Error(`Remote Mac connection closed with status ${exitCode}.`);
+    if (!ready)
+      rejectReady(error);
+    pending.forEach(({ reject }) => reject(error));
+    pending.clear();
+    return;
+  });
+  await readyPromise;
+  if (!ready)
+    throw fatal ?? new Error("Remote Mac did not become ready.");
+  const totalDuration = performance.now() - startedAt;
+  let currentReady = {
+    ...ready,
+    timings: {
+      ...ready.timings,
+      "remote-agent": agentDuration,
+      "remote-connect": performance.now() - connectStartedAt,
+      "remote-sync": syncDuration,
+      total: totalDuration
+    }
+  };
+  options.log?.(`Remote Mac connected (${options.project.profile.name}); agent ${agent.uploaded ? "uploaded" : "cache hit"}, project synced, and iOS ready in ${totalDuration.toFixed(2)}ms.`);
+  const request = (commandName) => {
+    const id = randomUUID3();
+    const response = new Promise((resolve8, reject) => pending.set(id, { reject, resolve: resolve8 }));
+    process2.stdin.write(`${JSON.stringify({ command: commandName, id, v: 1 })}
+`);
+    process2.stdin.flush();
+    return response;
+  };
+  let closed = false;
+  const close = async () => {
+    if (closed)
+      return;
+    closed = true;
+    await request("close").catch(() => {
+      return;
+    });
+    process2.stdin.end();
+    await process2.exited.catch(() => {
+      return;
+    });
+  };
+  const makeSession = () => ({
+    close,
+    nativeCacheHit: currentReady.nativeCacheHit,
+    startedSimulator: currentReady.startedSimulator,
+    timings: currentReady.timings,
+    udid: currentReady.udid,
+    rebuild: async () => {
+      const rebuildStartedAt = performance.now();
+      const rebuildSyncStartedAt = performance.now();
+      await syncProject(options.project);
+      const rebuildSyncDuration = performance.now() - rebuildSyncStartedAt;
+      const result = await request("rebuild");
+      currentReady = {
+        ...result,
+        timings: {
+          ...result.timings,
+          "remote-sync": rebuildSyncDuration,
+          total: performance.now() - rebuildStartedAt
+        }
+      };
+      return makeSession();
+    },
+    relaunch: async () => {
+      await request("relaunch");
+    },
+    screenshot: async (destination) => {
+      const result = await request("screenshot");
+      const target = resolvePath(options.project.projectRoot, destination);
+      const targetRelative = relative5(options.project.projectRoot, target);
+      if (targetRelative.startsWith("..") || isAbsolute4(targetRelative))
+        throw new Error("iOS screenshot must remain inside the project.");
+      await mkdir5(dirname6(target), { recursive: true });
+      await writeFile5(target, Buffer.from(result.data, "base64"));
+      return target;
+    },
+    get state() {
+      return state;
+    }
+  });
+  return makeSession();
+};
+var init_remoteMacProtocol = __esm(() => {
+  PROFILE_NAME = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/u;
+  SSH_DESTINATION = /^(?:[A-Za-z0-9._-]+@)?[A-Za-z0-9._:-]+$/u;
+  defaultTransport = {
+    capture: localCapture,
+    spawn: (command, options) => Bun.spawn(command, {
+      signal: options.signal,
+      stderr: "pipe",
+      stdin: "pipe",
+      stdout: "pipe"
+    })
+  };
+});
+
 // src/dev/devCert.ts
 var exports_devCert = {};
 __export(exports_devCert, {
@@ -3396,7 +3938,7 @@ import {
   rmSync
 } from "fs";
 import { platform as platform2 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`), devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`), certFilesExist = () => existsSync4(CERT_PATH) && existsSync4(KEY_PATH), isCertExpired = () => {
   try {
     const certPem = readFileSync6(CERT_PATH, "utf-8");
@@ -3608,13 +4150,13 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
   const caRoot = mkcertCaRoot();
   if (!caRoot)
     return false;
-  const rootCa = join10(caRoot, "rootCA.pem");
+  const rootCa = join11(caRoot, "rootCA.pem");
   if (!existsSync4(rootCa))
     return false;
   const winTemp = windowsTempDir();
   if (!winTemp)
     return false;
-  const staged = join10(winTemp, "absolutejs-mkcert-rootCA.crt");
+  const staged = join11(winTemp, "absolutejs-mkcert-rootCA.crt");
   try {
     copyFileSync(rootCa, staged);
   } catch {
@@ -3650,7 +4192,7 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
       devLog("Trusted the local CA in the Windows store \u2014 Chrome/Edge on Windows now accept dev HTTPS");
     } else {
       const caRoot = mkcertCaRoot();
-      const hint = caRoot ? toWindowsPath(join10(caRoot, "rootCA.pem")) : null;
+      const hint = caRoot ? toWindowsPath(join11(caRoot, "rootCA.pem")) : null;
       devWarn("Could not auto-trust the local CA on Windows; Windows browsers may warn.");
       if (hint) {
         console.log(`  Run in PowerShell: Import-Certificate -FilePath "${hint}" -CertStoreLocation Cert:\\CurrentUser\\Root`);
@@ -3666,9 +4208,9 @@ var CERT_DIR, CERT_PATH, KEY_PATH, CERT_VALIDITY_DAYS = 365, devLog = (msg) => c
   return true;
 };
 var init_devCert = __esm(() => {
-  CERT_DIR = join10(process.cwd(), ".absolutejs");
-  CERT_PATH = join10(CERT_DIR, "cert.pem");
-  KEY_PATH = join10(CERT_DIR, "key.pem");
+  CERT_DIR = join11(process.cwd(), ".absolutejs");
+  CERT_PATH = join11(CERT_DIR, "cert.pem");
+  KEY_PATH = join11(CERT_DIR, "key.pem");
 });
 
 // src/cli/scripts/eslintChunked.ts
@@ -3683,7 +4225,7 @@ __export(exports_eslintChunked, {
   eslintChunked: () => eslintChunked
 });
 import { existsSync as existsSync6 } from "fs";
-import { relative as relative5, resolve as resolve9 } from "path";
+import { relative as relative6, resolve as resolve9 } from "path";
 var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAULT_REPORT = ".absolutejs/lint-report.txt", CHILD_HEAP_MB = 4096, DJB2_SEED = 5381, DJB2_MULTIPLIER = 33, MS_PER_SECOND = 1000, SUMMARY_RULE_WIDTH = 60, SUMMARY_COUNT_PAD = 5, PORCELAIN_STATUS_WIDTH = 3, RENAME_ARROW = " -> ", ASCII_ESC = 27, LINTABLE_EXTENSIONS, ANSI_COLOR, stripAnsi = (text) => text.replace(ANSI_COLOR, ""), shardOf = (path, shards) => [...path].reduce((accumulator, character) => (Math.imul(accumulator, DJB2_MULTIPLIER) ^ character.charCodeAt(0)) >>> 0, DJB2_SEED) % shards, gitLines = (cmd, cwd) => Bun.spawnSync(cmd, { cwd }).stdout.toString().split(`
 `).map((line) => line.trimEnd()).filter(Boolean), applyChangedBase = (parsed, base) => {
   parsed.changedOnly = true;
@@ -3764,7 +4306,7 @@ var DEFAULT_CHUNK_SIZE = 20, DEFAULT_SHARDS = 4, DEFAULT_CONCURRENCY = 2, DEFAUL
   const fingerprint = createEslintCacheFingerprint(cwd);
   for (let shard = 0;shard < parsed.shards; shard++)
     prepareEslintCache({
-      cacheLocation: relative5(cwd, resolve9(cwd, `${cachePrefix}${shard}`)),
+      cacheLocation: relative6(cwd, resolve9(cwd, `${cachePrefix}${shard}`)),
       cwd,
       fingerprint
     });
@@ -3890,7 +4432,7 @@ var init_eslintChunked = __esm(() => {
 });
 
 // src/cli/scripts/eslint.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import {
   existsSync as existsSync7,
   mkdirSync as mkdirSync5,
@@ -3899,7 +4441,7 @@ import {
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
-import { dirname as dirname6, relative as relative6, resolve as resolve10 } from "path";
+import { dirname as dirname7, relative as relative7, resolve as resolve10 } from "path";
 var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION = "1", CACHE_FINGERPRINT_SUFFIX = ".fingerprint", flagValue = (args, flag) => {
   const assignment = args.find((arg) => arg.startsWith(`${flag}=`));
   if (assignment)
@@ -3983,13 +4525,13 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
     const candidate = resolve10(directory, "node_modules", dependency, "package.json");
     if (existsSync7(candidate))
       return candidate;
-    const parent = dirname6(directory);
+    const parent = dirname7(directory);
     if (parent === directory)
       return null;
     directory = parent;
   }
 }, createEslintCacheFingerprint = (cwd = process.cwd()) => {
-  const hash = createHash5("sha256");
+  const hash = createHash6("sha256");
   hash.update(`absolute-eslint-cache:${CACHE_CONTRACT_VERSION}\x00`);
   const configPath2 = findEslintConfigPath(cwd);
   for (const dependency of lintDependencyNames(cwd, configPath2).sort()) {
@@ -3999,14 +4541,14 @@ var DEFAULT_CACHE_LOCATION = ".absolutejs/eslint-cache", CACHE_CONTRACT_VERSION
   }
   return hash.digest("hex");
 }, createEslintConfigDigest = (cwd = process.cwd()) => {
-  const hash = createHash5("sha256");
+  const hash = createHash6("sha256");
   hash.update(`absolute-eslint-config:${CACHE_CONTRACT_VERSION}\x00`);
   const configPath2 = findEslintConfigPath(cwd);
   if (configPath2)
-    addFileToFingerprint(hash, configPath2, relative6(cwd, configPath2));
+    addFileToFingerprint(hash, configPath2, relative7(cwd, configPath2));
   return hash.digest("hex");
 }, writeFingerprint = (path, fingerprint) => {
-  mkdirSync5(dirname6(path), { recursive: true });
+  mkdirSync5(dirname7(path), { recursive: true });
   const temporary = `${path}.${process.pid}.tmp`;
   writeFileSync5(temporary, `${fingerprint}
 `);
@@ -4371,7 +4913,7 @@ var isRecord4 = (value) => typeof value === "object" && value !== null, getIslan
 var init_islands = () => {};
 
 // src/build/islandEntries.ts
-import { dirname as dirname7, extname, join as join13, relative as relative7, resolve as resolve12 } from "path";
+import { dirname as dirname8, extname, join as join14, relative as relative8, resolve as resolve12 } from "path";
 import ts from "typescript";
 var frameworks, isRecord5 = (value) => typeof value === "object" && value !== null, resolveRegistryExport = (mod) => {
   if (isRecord5(mod.islandRegistry))
@@ -4383,7 +4925,7 @@ var frameworks, isRecord5 = (value) => typeof value === "object" && value !== nu
   if (sourcePath.startsWith("file://")) {
     return new URL(sourcePath).pathname;
   }
-  return resolve12(dirname7(registryPath), sourcePath);
+  return resolve12(dirname8(registryPath), sourcePath);
 }, getObjectPropertyName = (name) => {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
     return name.text;
@@ -4863,7 +5405,7 @@ var init_buildMetadata = __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, frameworks3, isCanonicalRecord = (value) => {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
@@ -4900,7 +5442,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.`);
   }
@@ -5049,24 +5591,24 @@ var init_releaseArtifact = __esm(() => {
 });
 
 // src/mobile/buildRelease.ts
-import { createHash as createHash7 } from "crypto";
-import { readFile as readFile6 } from "fs/promises";
-import { join as join14, relative as relative8, resolve as resolve13 } from "path";
-var sha256 = (bytes) => createHash7("sha256").update(bytes).digest("hex"), readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]), resolveAssetPath = (buildDirectory, assetPath) => {
+import { createHash as createHash8 } from "crypto";
+import { readFile as readFile7 } from "fs/promises";
+import { join as join15, relative as relative9, resolve as resolve13 } from "path";
+var sha256 = (bytes) => createHash8("sha256").update(bytes).digest("hex"), readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]), resolveAssetPath = (buildDirectory, assetPath) => {
   const resolvedBuildDirectory = resolve13(buildDirectory);
   const resolvedAsset = resolve13(assetPath);
   if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
     return resolvedAsset;
   }
-  return join14(buildDirectory, assetPath.replace(/^\/+/, ""));
+  return join15(buildDirectory, assetPath.replace(/^\/+/, ""));
 }, pageFor = async (metadata, manifest, buildDirectory) => {
   const assetPath = manifest[metadata.bundleKey];
   if (!assetPath) {
     throw new TypeError(`Mobile page ${metadata.pageId} references missing manifest asset ${metadata.bundleKey}.`);
   }
   const resolvedAssetPath = resolveAssetPath(buildDirectory, assetPath);
-  const bytes = await readFile6(resolvedAssetPath);
-  const bundlePath = `/${relative8(resolve13(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  const bytes = await readFile7(resolvedAssetPath);
+  const bundlePath = `/${relative9(resolve13(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
   return {
     bundleHash: sha256(bytes),
     bundlePath,
@@ -5078,7 +5620,7 @@ var sha256 = (bytes) => createHash7("sha256").update(bytes).digest("hex"), readP
 }, buildAbsoluteMobileCompatibilityRelease = async (options) => {
   const [captured, producerBytes] = await Promise.all([
     captureAbsoluteMobileRouteGraph(options.app),
-    readFile6(options.producerPath)
+    readFile7(options.producerPath)
   ]);
   if (captured.length === 0) {
     throw new TypeError("No instrumented AbsoluteJS mobile page routes were found in the finalized Elysia route graph.");
@@ -5246,17 +5788,17 @@ var init_transport = __esm(() => {
 // src/mobile/capacitorBundle.ts
 import {
   copyFile as copyFile4,
-  mkdir as mkdir6,
+  mkdir as mkdir7,
   mkdtemp as mkdtemp3,
-  readFile as readFile7,
-  rename as rename5,
+  readFile as readFile8,
+  rename as rename6,
   rm as rm5,
-  writeFile as writeFile5
+  writeFile as writeFile6
 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { basename as basename6, dirname as dirname8, extname as extname3, join as join15, resolve as resolve14 } from "path";
+import { basename as basename6, dirname as dirname9, extname as extname3, join as join16, resolve as resolve14 } from "path";
 var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-mobile-bootstrap.js", INDEX_FILE = "index.html", CLIENT_IMPORT_PATTERN, errorHasCode = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code, shellBootstrapModule = () => {
-  const candidate = ["js", "ts"].map((extension) => join15(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync9);
+  const candidate = ["js", "ts"].map((extension) => join16(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync9);
   if (candidate)
     return candidate;
   throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
@@ -5282,8 +5824,8 @@ var MANIFEST_FILE = "absolute-mobile-manifest.json", BOOTSTRAP_FILE = "absolute-
   return asset;
 }, buildShellBootstrap = async (staging) => {
   const modulePath = shellBootstrapModule();
-  const entryPath = join15(staging, ".absolute-mobile-entry.ts");
-  await writeFile5(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+  const entryPath = join16(staging, ".absolute-mobile-entry.ts");
+  await writeFile6(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
 void startAbsoluteMobileShell();
 `);
   const build = await Bun.build({
@@ -5295,7 +5837,7 @@ void startAbsoluteMobileShell();
   if (!build.success || build.outputs.length !== 1) {
     throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
   }
-  await rename5(build.outputs[0]?.path ?? "", join15(staging, BOOTSTRAP_FILE));
+  await rename6(build.outputs[0]?.path ?? "", join16(staging, BOOTSTRAP_FILE));
   await rm5(entryPath, { force: true });
 }, removePreviousBundle = async (backup, moved) => {
   if (!moved)
@@ -5304,19 +5846,19 @@ void startAbsoluteMobileShell();
 }, restorePreviousBundle = async (backup, destination, moved) => {
   if (!moved)
     return;
-  await rename5(backup, destination);
+  await rename6(backup, destination);
 }, installBundle = async (staging, destination) => {
   const backup = `${destination}.previous-${crypto.randomUUID()}`;
   let movedPrevious = false;
   try {
-    await rename5(destination, backup);
+    await rename6(destination, backup);
     movedPrevious = true;
   } catch (error) {
     if (!errorHasCode(error, "ENOENT"))
       throw error;
   }
   try {
-    await rename5(staging, destination);
+    await rename6(staging, destination);
     await removePreviousBundle(backup, movedPrevious);
   } catch (error) {
     await restorePreviousBundle(backup, destination, movedPrevious);
@@ -5329,11 +5871,11 @@ void startAbsoluteMobileShell();
   const extension = extname3(page.bundlePath) || ".js";
   const localBundlePath = `./pages/${page.bundleHash}${extension}`;
   const source = sourceAssetPath(buildDirectory, page.bundlePath);
-  await copyFile4(source, join15(staging, localBundlePath));
+  await copyFile4(source, join16(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
   return { ...page, localBundlePath };
 }, absoluteClientImports = async (sourcePath) => {
-  const source = await readFile7(sourcePath, "utf8");
+  const source = await readFile8(sourcePath, "utf8");
   return [...source.matchAll(CLIENT_IMPORT_PATTERN)].flatMap((match) => {
     const [specifier] = match.slice(1);
     return specifier ? [specifier.split(/[?#]/u, 1)[0] ?? specifier] : [];
@@ -5343,8 +5885,8 @@ void startAbsoluteMobileShell();
     return;
   copied.add(specifier);
   const source = sourceAssetPath(buildDirectory, specifier);
-  const destination = join15(staging, specifier.replace(/^\/+/, ""));
-  await mkdir6(dirname8(destination), { recursive: true });
+  const destination = join16(staging, specifier.replace(/^\/+/, ""));
+  await mkdir7(dirname9(destination), { recursive: true });
   await copyFile4(source, destination);
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
 }, copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
@@ -5355,11 +5897,11 @@ void startAbsoluteMobileShell();
     throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
   }
   const destination = options.config.bundleDirectory;
-  await mkdir6(dirname8(destination), { recursive: true });
-  const staging = await mkdtemp3(join15(dirname8(destination), `.${basename6(destination)}.stage-`));
+  await mkdir7(dirname9(destination), { recursive: true });
+  const staging = await mkdtemp3(join16(dirname9(destination), `.${basename6(destination)}.stage-`));
   try {
-    const pageDirectory = join15(staging, "pages");
-    await mkdir6(pageDirectory, { recursive: true });
+    const pageDirectory = join16(staging, "pages");
+    await mkdir7(pageDirectory, { recursive: true });
     const copiedDependencies = new Set;
     const pages = await Promise.all(options.artifact.pages.map((page) => copyClientPage(page, options.buildDirectory, staging, copiedDependencies)));
     const manifest = {
@@ -5376,9 +5918,9 @@ void startAbsoluteMobileShell();
       runtime: options.artifact.runtime
     };
     await Promise.all([
-      writeFile5(join15(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+      writeFile6(join16(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
-      writeFile5(join15(staging, INDEX_FILE), indexHtml(options.config.appName)),
+      writeFile6(join16(staging, INDEX_FILE), indexHtml(options.config.appName)),
       buildShellBootstrap(staging)
     ]);
     await installBundle(staging, destination);
@@ -5395,10 +5937,10 @@ var init_capacitorBundle = __esm(() => {
 });
 
 // src/mobile/artifactStore.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 var DEFAULT_MAX_PRODUCER_BYTES = 134217728, SHA_2562 = "sha256", hashBlob = async (blob) => {
   const bytes = new Uint8Array(await blob.arrayBuffer());
-  return createHash8(SHA_2562).update(bytes).digest("hex");
+  return createHash9(SHA_2562).update(bytes).digest("hex");
 }, verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes = DEFAULT_MAX_PRODUCER_BYTES) => {
   const { artifact, producer } = release;
   if (producer.size !== artifact.producer.bytes || producer.size > maxProducerBytes) {
@@ -5414,23 +5956,23 @@ var init_artifactStore = __esm(() => {
 });
 
 // src/mobile/materializedBundle.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import {
   access as access6,
-  mkdir as mkdir7,
+  mkdir as mkdir8,
   mkdtemp as mkdtemp4,
-  readFile as readFile8,
-  rename as rename6,
+  readFile as readFile9,
+  rename as rename7,
   rm as rm6,
-  writeFile as writeFile6
+  writeFile as writeFile7
 } from "fs/promises";
-import { dirname as dirname9, join as join16, resolve as resolvePath } from "path";
+import { dirname as dirname10, join as join17, resolve as resolvePath2 } from "path";
 var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "current.json", BUNDLES_DIRECTORY = "bundles", ARTIFACT_FILE = "artifact.json", BUNDLE_ID_PATTERN, isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code, bundleIdFor = (currentReleaseId, releases) => {
   const identity = JSON.stringify({
     currentReleaseId,
     releases: releases.map(({ releaseId }) => releaseId)
   });
-  return `amb_${createHash9("sha256").update(identity).digest("hex")}`;
+  return `amb_${createHash10("sha256").update(identity).digest("hex")}`;
 }, parseBundleIndex = (value) => {
   if (!isRecord7(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.");
@@ -5454,16 +5996,16 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     releases
   };
 }, writeRelease = async (root, release) => {
-  const directory = join16(root, release.artifact.releaseId);
-  const producerPath = join16(directory, release.artifact.producer.module);
-  await mkdir7(dirname9(producerPath), { recursive: true });
+  const directory = join17(root, release.artifact.releaseId);
+  const producerPath = join17(directory, release.artifact.producer.module);
+  await mkdir8(dirname10(producerPath), { recursive: true });
   await Promise.all([
-    writeFile6(join16(directory, ARTIFACT_FILE), `${JSON.stringify(release.artifact, null, "\t")}
+    writeFile7(join17(directory, ARTIFACT_FILE), `${JSON.stringify(release.artifact, null, "\t")}
 `),
-    writeFile6(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+    writeFile7(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
   ]);
 }, installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
-  const destination = join16(bundlesRoot, bundleId);
+  const destination = join17(bundlesRoot, bundleId);
   try {
     await access6(destination);
     return destination;
@@ -5471,10 +6013,10 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     if (!errorHasCode2(error, "ENOENT"))
       throw error;
   }
-  const staging = await mkdtemp4(join16(bundlesRoot, ".stage-"));
+  const staging = await mkdtemp4(join17(bundlesRoot, ".stage-"));
   try {
     await Promise.all(releases.map((release) => writeRelease(staging, release)));
-    await rename6(staging, destination);
+    await rename7(staging, destination);
   } catch (error) {
     await rm6(staging, { force: true, recursive: true });
     if (errorHasCode2(error, "EEXIST") || errorHasCode2(error, "ENOTEMPTY")) {
@@ -5499,9 +6041,9 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     }
     return release;
   });
-  const root = resolvePath(input.root);
-  const bundlesRoot = join16(root, BUNDLES_DIRECTORY);
-  await mkdir7(bundlesRoot, { recursive: true });
+  const root = resolvePath2(input.root);
+  const bundlesRoot = join17(root, BUNDLES_DIRECTORY);
+  await mkdir8(bundlesRoot, { recursive: true });
   const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
   await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
   const index = {
@@ -5510,21 +6052,21 @@ var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1, CURRENT_BUNDLE_FILE = "curre
     format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
     releases: artifacts
   };
-  const pointerPath = join16(root, CURRENT_BUNDLE_FILE);
-  const temporaryPointerPath = join16(root, `.current-${crypto.randomUUID()}.json`);
-  await writeFile6(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+  const pointerPath = join17(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join17(root, `.current-${crypto.randomUUID()}.json`);
+  await writeFile7(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
 `, { flag: "wx" });
-  await rename6(temporaryPointerPath, pointerPath);
+  await rename7(temporaryPointerPath, pointerPath);
   return index;
 }, readAbsoluteMobileMaterializedReleases = async (root) => {
-  const resolvedRoot = resolvePath(root);
+  const resolvedRoot = resolvePath2(root);
   try {
-    const serialized = await readFile8(join16(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const serialized = await readFile9(join17(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
     const parsed = JSON.parse(serialized);
     const index = parseBundleIndex(parsed);
-    const bundleRoot = join16(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    const bundleRoot = join17(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
     return Promise.all(index.releases.map(async (artifact) => {
-      const producer = Bun.file(join16(bundleRoot, artifact.releaseId, artifact.producer.module));
+      const producer = Bun.file(join17(bundleRoot, artifact.releaseId, artifact.producer.module));
       await verifyAbsoluteMobileCompatibilityProducer({
         artifact,
         producer
@@ -5544,8 +6086,8 @@ var init_materializedBundle = __esm(() => {
 });
 
 // src/mobile/buildPipeline.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join17, resolve as resolve15 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { join as join18, resolve as resolve15 } from "path";
 import { pathToFileURL } from "url";
 var isElysiaApp = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "compile") === "function" && Array.isArray(Reflect.get(value, "routes")), isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string"), serverExportName = (loaded, app) => {
   if (loaded.server === app)
@@ -5577,9 +6119,9 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
 }, finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   const buildDirectory = resolve15(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join17(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join18(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile9(join17(buildDirectory, "manifest.json"), "utf8"),
+    readFile10(join18(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -5632,9 +6174,9 @@ var init_buildPipeline = __esm(() => {
 
 // src/mobile/routeMetadataTransform.ts
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname10, extname as extname4, relative as relative9, resolve as resolve16 } from "path";
+import { dirname as dirname11, extname as extname4, relative as relative10, resolve as resolve16 } from "path";
 import ts4 from "typescript";
-var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLER = "handleReactPageRequest", posixPath = (value) => value.replace(/\\/g, "/"), findTsconfig = (entry, projectRoot) => ts4.findConfigFile(dirname10(entry), existsSync10, "tsconfig.json") ?? ts4.findConfigFile(projectRoot, existsSync10, "tsconfig.json"), createProgram = (entry, projectRoot) => {
+var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLER = "handleReactPageRequest", posixPath = (value) => value.replace(/\\/g, "/"), findTsconfig = (entry, projectRoot) => ts4.findConfigFile(dirname11(entry), existsSync10, "tsconfig.json") ?? ts4.findConfigFile(projectRoot, existsSync10, "tsconfig.json"), createProgram = (entry, projectRoot) => {
   const configPath2 = findTsconfig(entry, projectRoot);
   if (!configPath2) {
     return ts4.createProgram([entry], {
@@ -5645,7 +6187,7 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLER = "handleReactPageRequest", posix
       target: ts4.ScriptTarget.ESNext
     });
   }
-  const parsed = ts4.parseJsonConfigFileContent(ts4.readConfigFile(configPath2, (path) => readFileSync10(path, "utf8")).config, ts4.sys, dirname10(configPath2));
+  const parsed = ts4.parseJsonConfigFileContent(ts4.readConfigFile(configPath2, (path) => readFileSync10(path, "utf8")).config, ts4.sys, dirname11(configPath2));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts4.createProgram(parsed.fileNames, parsed.options);
@@ -5746,7 +6288,7 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLER = "handleReactPageRequest", posix
   const declaration = symbol?.declarations?.[0];
   const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
   const exportedName = symbol?.name ?? expression.getText(sourceFile);
-  const source = posixPath(relative9(projectRoot, file));
+  const source = posixPath(relative10(projectRoot, file));
   return `${source}#${exportedName}`;
 }, resolveAlias = (symbol, checker) => {
   if (!(symbol.flags & ts4.SymbolFlags.Alias))
@@ -5950,7 +6492,7 @@ var init_routeMetadataTransform = __esm(() => {
 });
 
 // src/cli/elysiaOpenApiTypeboxPlugin.ts
-import { dirname as dirname11, resolve as resolve17 } from "path";
+import { dirname as dirname12, resolve as resolve17 } from "path";
 var OPENAPI_TYPEBOX_PREFIX = "../node_modules/typebox/", OPENAPI_DISTRIBUTION_SEGMENT = "/@elysia/openapi/dist/", createElysiaOpenApiTypeboxPlugin = () => ({
   name: "absolute-elysia-openapi-typebox",
   setup(build) {
@@ -5960,9 +6502,9 @@ var OPENAPI_TYPEBOX_PREFIX = "../node_modules/typebox/", OPENAPI_DISTRIBUTION_SE
         return;
       }
       const relativePath = args.path.slice(OPENAPI_TYPEBOX_PREFIX.length);
-      const typeboxEntry = Bun.resolveSync("typebox", dirname11(args.importer));
+      const typeboxEntry = Bun.resolveSync("typebox", dirname12(args.importer));
       return {
-        path: resolve17(dirname11(typeboxEntry), "..", relativePath)
+        path: resolve17(dirname12(typeboxEntry), "..", relativePath)
       };
     });
   }
@@ -6023,7 +6565,7 @@ __export(exports_prerender, {
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync11 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, DEFAULT_FETCH_TIMEOUT_MS = 1e4, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
@@ -6093,7 +6635,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     if (!isCompleteHtml(html))
       return false;
     const fileName = routeToFilename(route);
-    const filePath = join18(prerenderDir, fileName);
+    const filePath = join19(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -6123,13 +6665,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     return;
   }
   const fileName = routeToFilename(route);
-  const filePath = join18(prerenderDir, fileName);
+  const filePath = join19(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log) => {
-  const prerenderDir = join18(outDir, "_prerendered");
+  const prerenderDir = join19(outDir, "_prerendered");
   mkdirSync6(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -6565,7 +7107,7 @@ var init_nativeRewrite = __esm(() => {
 
 // src/build/rewriteImportsPlugin.ts
 import { readdir as readdir3 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -6644,7 +7186,7 @@ ${content}`;
       const entries = await readdir3(dir);
       for (const entry of entries) {
         if (entry.endsWith(".js"))
-          allFiles.push(join19(dir, entry));
+          allFiles.push(join20(dir, entry));
       }
     } catch {}
   }
@@ -6720,7 +7262,7 @@ var init_rewriteImports = __esm(() => {
 // src/cli/scripts/start.ts
 var {env: env2 } = globalThis.Bun;
 import { existsSync as existsSync11, readFileSync as readFileSync12, rmSync as rmSync4 } from "fs";
-import { basename as basename7, join as join20, resolve as resolve19 } from "path";
+import { basename as basename7, join as join21, resolve as resolve19 } from "path";
 var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, resolvePackageVersion = (candidates) => {
   for (const candidate of candidates) {
     const version2 = readPackageVersion2(candidate);
@@ -6950,7 +7492,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!build)
       throw new Error("Could not locate build module");
     await build(buildConfig);
-    rmSync4(join20(resolvedOutdir, "_prerendered"), {
+    rmSync4(join21(resolvedOutdir, "_prerendered"), {
       force: true,
       recursive: true
     });
@@ -7251,16 +7793,16 @@ __export(exports_build, {
   build: () => build
 });
 import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync14 } from "fs";
-import { join as join21, resolve as resolve21 } from "path";
+import { join as join22, resolve as resolve21 } from "path";
 var PROFILE_TOP = 15, PROFILE_COL = 8, FRAMEWORK_KEYS, cliTag3 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, printProfile = (buildDir) => {
-  const traceDir = join21(buildDir, ".absolute-trace");
+  const traceDir = join22(buildDir, ".absolute-trace");
   if (!existsSync13(traceDir))
     return;
   const files = readdirSync3(traceDir).filter((file) => file.endsWith(".json")).sort();
   const latest = files[files.length - 1];
   if (latest === undefined)
     return;
-  const trace = JSON.parse(readFileSync14(join21(traceDir, latest), "utf-8"));
+  const trace = JSON.parse(readFileSync14(join22(traceDir, latest), "utf-8"));
   const events = Array.isArray(trace.events) ? trace.events : [];
   if (events.length === 0)
     return;
@@ -7346,7 +7888,7 @@ __export(exports_lintProof, {
   createLintProof: () => createLintProof
 });
 import {
-  createHash as createHash10,
+  createHash as createHash11,
   createPrivateKey,
   createPublicKey,
   sign,
@@ -7364,7 +7906,7 @@ import {
   writeFileSync as writeFileSync7
 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { delimiter, dirname as dirname12, relative as relative10, resolve as resolve22 } from "path";
+import { delimiter, dirname as dirname13, relative as relative11, resolve as resolve22 } from "path";
 var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSION = 2, FLAG_NOT_FOUND = -1, CHUNKED_FLAG = "--chunked", TSCONFIG_PATTERN, ABSOLUTE_BINARY, runGit = (args, options) => {
   const proc = Bun.spawnSync(["git", ...args], {
     cwd: options.cwd,
@@ -7378,7 +7920,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
   }
   return proc.stdout.toString().trim();
 }, gitRoot = (cwd) => resolve22(runGit(["rev-parse", "--show-toplevel"], { cwd })), isInside3 = (parent, candidate) => {
-  const path = relative10(parent, candidate);
+  const path = relative11(parent, candidate);
   return path === "" || !path.startsWith("../") && path !== "..";
 }, attestationPayload = (proof) => Buffer.from([
   "absolute-lint-proof-attestation:1",
@@ -7389,7 +7931,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
     lintFingerprint: proof.lintFingerprint,
     sourceTree: proof.sourceTree
   })
-].join("\x00")), publicKeyId = (key) => createHash10("sha256").update(key.export({ format: "der", type: "spki" })).digest("hex"), readEd25519PrivateKey = (cwd, location) => {
+].join("\x00")), publicKeyId = (key) => createHash11("sha256").update(key.export({ format: "der", type: "spki" })).digest("hex"), readEd25519PrivateKey = (cwd, location) => {
   const path = resolve22(cwd, location);
   if (isInside3(realpathSync(gitRoot(cwd)), realpathSync(path))) {
     throw new Error("lint proof signing key must live outside the Git working tree");
@@ -7428,7 +7970,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
     return null;
   const auxiliary = gitVisibleFiles(root).filter((file) => TSCONFIG_PATTERN.test(file));
   const configPath2 = findEslintConfigPath(root);
-  const configRelative = configPath2 === null ? null : relative10(root, configPath2).replaceAll("\\", "/");
+  const configRelative = configPath2 === null ? null : relative11(root, configPath2).replaceAll("\\", "/");
   return [
     ...new Set([
       ...resolveLintTargets(args, root),
@@ -7439,7 +7981,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
 }, createLintSourceTree = (cwd = process.cwd(), proofLocation = DEFAULT_PROOF_LOCATION, command = []) => {
   const root = gitRoot(cwd);
   const proofPath = resolve22(cwd, proofLocation);
-  const proofRelative = relative10(root, proofPath).replaceAll("\\", "/");
+  const proofRelative = relative11(root, proofPath).replaceAll("\\", "/");
   if (proofRelative === ".." || proofRelative.startsWith("../") || proofRelative === "") {
     throw new Error("lint proof must live inside the Git working tree");
   }
@@ -7483,7 +8025,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
   } finally {
     rmSync5(temporaryDirectory, { force: true, recursive: true });
   }
-}, proofFingerprint = (cwd) => createHash10("sha256").update(`absolute-lint-proof:${PROOF_CONTRACT_VERSION}\x00`).update(createEslintCacheFingerprint(cwd)).update("\x00").update(createEslintConfigDigest(cwd)).digest("hex"), createLintProof = (command, options = {}) => {
+}, proofFingerprint = (cwd) => createHash11("sha256").update(`absolute-lint-proof:${PROOF_CONTRACT_VERSION}\x00`).update(createEslintCacheFingerprint(cwd)).update("\x00").update(createEslintConfigDigest(cwd)).digest("hex"), createLintProof = (command, options = {}) => {
   const cwd = options.cwd ?? process.cwd();
   const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
   return {
@@ -7508,7 +8050,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
       signature: sign(null, attestationPayload(proof), privateKey).toString("base64")
     };
   }
-  mkdirSync8(dirname12(path), { recursive: true });
+  mkdirSync8(dirname13(path), { recursive: true });
   writeFileSync7(temporary, `${JSON.stringify(proof, null, 2)}
 `);
   renameSync2(temporary, path);
@@ -7731,7 +8273,7 @@ __export(exports_ls, {
   runLs: () => runLs
 });
 import { existsSync as existsSync16, readFileSync as readFileSync16, statSync } from "fs";
-import { basename as basename9, extname as extname5, join as join22, relative as relative11 } from "path";
+import { basename as basename9, extname as extname5, join as join23, relative as relative12 } from "path";
 var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELDS, readStringField = (source, key) => {
   const value = Reflect.get(source, key);
   return typeof value === "string" ? value : undefined;
@@ -7746,20 +8288,20 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
   } catch {
     return null;
   }
-}, relativeOrSelf = (target) => relative11(process.cwd(), target) || target, configCandidates = (raw) => isWorkspaceConfig(raw) ? Object.values(raw).map((service) => ({
+}, relativeOrSelf = (target) => relative12(process.cwd(), target) || target, configCandidates = (raw) => isWorkspaceConfig(raw) ? Object.values(raw).map((service) => ({
   baseDir: readStringField(service, "cwd") ?? ".",
   source: service
 })) : [{ baseDir: ".", source: raw }], specsFor = (source, baseDir) => FRAMEWORK_FIELDS.flatMap((framework) => {
   const dir = readStringField(source, framework.field);
   return dir === undefined ? [] : [
     {
-      dir: join22(baseDir, dir),
+      dir: join23(baseDir, dir),
       label: framework.label,
       pattern: framework.pattern
     }
   ];
 }), scanFramework = async (spec) => {
-  const { pageFiles } = await scanConventions(join22(spec.dir, "pages"), spec.pattern);
+  const { pageFiles } = await scanConventions(join23(spec.dir, "pages"), spec.pattern);
   if (pageFiles.length === 0)
     return null;
   const pages = pageFiles.map((file) => ({
@@ -7783,10 +8325,10 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
 }, resolveDiskPath = (buildDir, value) => {
   if (existsSync16(value))
     return value;
-  const underBuild = join22(buildDir, value);
+  const underBuild = join23(buildDir, value);
   if (existsSync16(underBuild))
     return underBuild;
-  return join22(process.cwd(), value);
+  return join23(process.cwd(), value);
 }, fileSize = (diskPath) => {
   try {
     return statSync(diskPath).size;
@@ -7794,7 +8336,7 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
     return 0;
   }
 }, readManifestSizes = (manifestDir) => {
-  const manifest = JSON.parse(readFileSync16(join22(manifestDir, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync16(join23(manifestDir, "manifest.json"), "utf-8"));
   const sizes = new Map;
   Object.entries(manifest).forEach(([key, value]) => {
     sizes.set(key, fileSize(resolveDiskPath(manifestDir, value)));
@@ -7813,7 +8355,7 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
   }))
 })), manifestAge = (manifestPath) => getDurationString(Date.now() - statSync(manifestPath).mtimeMs), firstBuildDir = (candidates) => candidates.map((candidate) => {
   const dir = readStringField(candidate.source, "buildDirectory");
-  return dir === undefined ? undefined : join22(candidate.baseDir, dir);
+  return dir === undefined ? undefined : join23(candidate.baseDir, dir);
 }).find((dir) => dir !== undefined), resolveSizesDir = (args, candidates) => parseFlagValue(args, "--outdir") ?? firstBuildDir(candidates) ?? DEFAULT_BUILD_DIR, formatSize = (bytes) => {
   if (bytes === null || bytes === 0)
     return "-";
@@ -7911,7 +8453,7 @@ ${colors.dim}${frameworkCount} ${frameworkCount === 1 ? "framework" : "framework
     return;
   }
   const sizesDir = resolveSizesDir(args, candidates);
-  const manifestPath = join22(sizesDir, "manifest.json");
+  const manifestPath = join23(sizesDir, "manifest.json");
   if (!existsSync16(manifestPath)) {
     printDim(`No build at ${relativeOrSelf(manifestPath)}. Run \`absolute build\` first, or pass \`--outdir <dir>\`.`);
     return;
@@ -9076,8 +9618,8 @@ export { value };
   host.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => fileName === virtualPath ? ts5.createSourceFile(fileName, source, languageVersion, true) : getSourceFile(fileName, languageVersion, onError, shouldCreate);
   const fileExists = host.fileExists.bind(host);
   host.fileExists = (fileName) => fileName === virtualPath ? true : fileExists(fileName);
-  const readFile10 = host.readFile.bind(host);
-  host.readFile = (fileName) => fileName === virtualPath ? source : readFile10(fileName);
+  const readFile11 = host.readFile.bind(host);
+  host.readFile = (fileName) => fileName === virtualPath ? source : readFile11(fileName);
   const program = ts5.createProgram([virtualPath], options, host);
   const checker = program.getTypeChecker();
   const sourceFile = program.getSourceFile(virtualPath);
@@ -9378,8 +9920,8 @@ var init_frameworks = __esm(() => {
 });
 
 // src/cli/generate/context.ts
-import { dirname as dirname13, isAbsolute as isAbsolute4, join as join23, relative as relative12, resolve as resolve25 } from "path";
-var asString = (value) => typeof value === "string" ? value : undefined, isRecord10 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute4(value) ? value : resolve25(cwd, value), resolveStylesDir = (cwd, config) => {
+import { dirname as dirname14, isAbsolute as isAbsolute5, join as join24, relative as relative13, resolve as resolve25 } from "path";
+var asString = (value) => typeof value === "string" ? value : undefined, isRecord10 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute5(value) ? value : resolve25(cwd, value), resolveStylesDir = (cwd, config) => {
   const styles = config.stylesConfig;
   if (typeof styles === "string")
     return resolveDir(cwd, styles);
@@ -9391,7 +9933,7 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
   return resolve25(cwd, "src/frontend/styles/indexes");
 }, configuredFrameworks = (project) => FRAMEWORK_KEYS2.filter((key) => project.frameworkDirs[key] !== undefined), frontendRootFor = (project, framework) => {
   const dir = project.frameworkDirs[framework];
-  return dir ? dirname13(dir) : resolve25(project.cwd, "src/frontend");
+  return dir ? dirname14(dir) : resolve25(project.cwd, "src/frontend");
 }, resolveProject = async (cwd, configOverride) => {
   const loaded = await loadConfig(configOverride);
   const config = isRecord10(loaded) ? loaded : {};
@@ -9441,8 +9983,8 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
     message: `Multiple frameworks configured (${configured.join(", ")}). Pass --framework <name>.`,
     ok: false
   };
-}, sharedDirFor = (project, framework) => join23(frontendRootFor(project, framework), "shared"), toModuleSpecifier = (fromDir, toFileNoExt) => {
-  const rel = relative12(fromDir, toFileNoExt).split("\\").join("/");
+}, sharedDirFor = (project, framework) => join24(frontendRootFor(project, framework), "shared"), toModuleSpecifier = (fromDir, toFileNoExt) => {
+  const rel = relative13(fromDir, toFileNoExt).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 };
 var init_context = __esm(() => {
@@ -9471,7 +10013,7 @@ var emptyOutcome = () => ({
 // src/cli/generate/routeWiring.ts
 import ts7 from "typescript";
 import { existsSync as existsSync20, readFileSync as readFileSync20, readdirSync as readdirSync4, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname14, join as join24 } from "path";
+import { dirname as dirname15, join as join25 } from "path";
 var DEFAULT_SEPARATOR = `
 		`, BOUNDARY_USE, applyEdits = (text, edits) => {
   const ordered = [...edits].sort((first, second) => second.start - first.start);
@@ -9630,14 +10172,14 @@ ${newLines.join(`
   for (const name of readdirSync4(pluginsDir)) {
     if (!name.endsWith(".ts"))
       continue;
-    const candidate = join24(pluginsDir, name);
+    const candidate = join25(pluginsDir, name);
     if (hasChain(candidate))
       return candidate;
   }
   return null;
 }, findRoutingFile = (serverEntry) => {
-  const pluginsDir = join24(dirname14(serverEntry), "plugins");
-  const preferred = join24(pluginsDir, "pagesPlugin.ts");
+  const pluginsDir = join25(dirname15(serverEntry), "plugins");
+  const preferred = join25(pluginsDir, "pagesPlugin.ts");
   if (hasChain(preferred))
     return preferred;
   const scanned = firstChainFile(pluginsDir);
@@ -9647,7 +10189,7 @@ ${newLines.join(`
     return serverEntry;
   return null;
 }, buildRouteContext = (input, routingFile) => {
-  const specifier = `${toModuleSpecifier(dirname14(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
+  const specifier = `${toModuleSpecifier(dirname15(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
   return {
     cssAssetKey: input.cssAssetKey,
     indexKey: input.indexKey,
@@ -9729,7 +10271,7 @@ var init_routeWiring = __esm(() => {
 
 // src/cli/generate/generateApi.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname15, join as join25 } from "path";
+import { dirname as dirname16, join as join26 } from "path";
 var apiPluginTemplate = (pluginName, base) => `import { Elysia } from 'elysia';
 
 export const ${pluginName} = new Elysia()
@@ -9741,8 +10283,8 @@ export const ${pluginName} = new Elysia()
   const pluginName = `${camel}Plugin`;
   const base = `/api/${kebab}`;
   const outcome = { ...emptyOutcome(), route: base };
-  const pluginsDir = join25(dirname15(project.serverEntry), "plugins");
-  const fileAbs = join25(pluginsDir, `${pluginName}.ts`);
+  const pluginsDir = join26(dirname16(project.serverEntry), "plugins");
+  const fileAbs = join26(pluginsDir, `${pluginName}.ts`);
   if (existsSync21(fileAbs)) {
     outcome.notes.push(`${pluginName} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
@@ -9750,7 +10292,7 @@ export const ${pluginName} = new Elysia()
   mkdirSync10(pluginsDir, { recursive: true });
   writeFileSync10(fileAbs, apiPluginTemplate(pluginName, base), "utf-8");
   outcome.created.push(fileAbs);
-  const specifier = toModuleSpecifier(dirname15(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
+  const specifier = toModuleSpecifier(dirname16(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
   const wired = wirePluginUse(project.serverEntry, pluginName, specifier);
   if (wired.kind === "edited")
     outcome.updated.push(wired.routingFile);
@@ -9817,7 +10359,7 @@ var init_componentTemplates = __esm(() => {
 
 // src/cli/generate/generateComponent.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname16, join as join26 } from "path";
+import { dirname as dirname17, join as join27 } from "path";
 var generateComponent = (project, framework, rawName) => {
   const def = frameworks6[framework];
   const pascal = toPascalCase(rawName);
@@ -9828,12 +10370,12 @@ var generateComponent = (project, framework, rawName) => {
     outcome.manual = { reason: "framework directory missing", snippet: "" };
     return outcome;
   }
-  const fileAbs = join26(frameworkDir, "components", def.componentFile({ kebab, pascal }));
+  const fileAbs = join27(frameworkDir, "components", def.componentFile({ kebab, pascal }));
   if (existsSync22(fileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
-  mkdirSync11(dirname16(fileAbs), { recursive: true });
+  mkdirSync11(dirname17(fileAbs), { recursive: true });
   writeFileSync11(fileAbs, componentTemplates[framework]({
     kebab,
     pascal,
@@ -9850,7 +10392,7 @@ var init_generateComponent = __esm(() => {
 // src/cli/generate/cssStrategy.ts
 import ts8 from "typescript";
 import { existsSync as existsSync23 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
 	margin: 0 auto;
 	max-width: 64rem;
@@ -9889,7 +10431,7 @@ var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
   return null;
 }, fileForKey = (stylesDir, assetKey2) => {
   const base = assetKey2.endsWith(CSS_SUFFIX) ? assetKey2.slice(0, -CSS_SUFFIX.length) : assetKey2;
-  return join27(stylesDir, `${toKebabCase(base)}.css`);
+  return join28(stylesDir, `${toKebabCase(base)}.css`);
 }, planCss = (routingText, stylesDir, pascal, kebab) => {
   const sharedKey = detectSharedKey(routingText);
   if (sharedKey) {
@@ -9902,7 +10444,7 @@ var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
       shared: true
     };
   }
-  const cssFileAbs = join27(stylesDir, `${kebab}.css`);
+  const cssFileAbs = join28(stylesDir, `${kebab}.css`);
   return {
     assetKey: `${pascal}${CSS_SUFFIX}`,
     contents: DEFAULT_CSS,
@@ -9916,7 +10458,7 @@ var init_cssStrategy = () => {};
 // src/cli/generate/navData.ts
 import ts9 from "typescript";
 import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync21, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname17 } from "path";
+import { dirname as dirname18 } from "path";
 var NAV_DATA_TEMPLATE = `type NavItem = {
 	href: string;
 	label: string;
@@ -9993,7 +10535,7 @@ ${indent}${entry}`;
 }, upsertNavItem = (navDataPath, item) => {
   const created = !existsSync24(navDataPath);
   if (created) {
-    mkdirSync12(dirname17(navDataPath), { recursive: true });
+    mkdirSync12(dirname18(navDataPath), { recursive: true });
     writeFileSync12(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
   }
   const existing = readNavItems(navDataPath);
@@ -10163,14 +10705,14 @@ import {
   readdirSync as readdirSync5,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname18, join as join28, relative as relative13 } from "path";
+import { dirname as dirname19, join as join29, relative as relative14 } from "path";
 var writeNew = (path, contents) => {
-  mkdirSync13(dirname18(path), { recursive: true });
+  mkdirSync13(dirname19(path), { recursive: true });
   writeFileSync13(path, contents, "utf-8");
 }, toHref = (fromDir, toFile) => {
-  const rel = relative13(fromDir, toFile).split("\\").join("/");
+  const rel = relative14(fromDir, toFile).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
-}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join28(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync25(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join28(pagesDir, name))), resyncPage = (file, items) => {
+}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join29(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync25(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join29(pagesDir, name))), resyncPage = (file, items) => {
   const html = readFileSync22(file, "utf-8");
   const synced = syncStaticNav(html, items);
   if (synced === null || synced === html)
@@ -10198,7 +10740,7 @@ var writeNew = (path, contents) => {
     outcome.manual = { reason: "framework directory missing", snippet: "" };
     return outcome;
   }
-  const pageFileAbs = join28(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
+  const pageFileAbs = join29(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
   if (existsSync25(pageFileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${pageFileAbs} \u2014 skipped.`);
     return outcome;
@@ -10206,11 +10748,11 @@ var writeNew = (path, contents) => {
   const routingFile = findRoutingFile(project.serverEntry);
   const routingText = routingFile ? readFileSync22(routingFile, "utf-8") : "";
   const css = planCss(routingText, project.stylesDir, pascal, kebab);
-  const navDataPath = join28(sharedDirFor(project, framework), "navData.ts");
+  const navDataPath = join29(sharedDirFor(project, framework), "navData.ts");
   const nav = upsertNavItem(navDataPath, { href: route, label: title });
-  const navImportPath = toModuleSpecifier(dirname18(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
+  const navImportPath = toModuleSpecifier(dirname19(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
   writeNew(pageFileAbs, pageTemplates[framework]({
-    cssHref: toHref(dirname18(pageFileAbs), css.cssFileAbs),
+    cssHref: toHref(dirname19(pageFileAbs), css.cssFileAbs),
     kebab,
     navImportPath,
     navItems: nav.items,
@@ -10260,7 +10802,7 @@ var exports_generate = {};
 __export(exports_generate, {
   runGenerate: () => runGenerate
 });
-import { relative as relative14 } from "path";
+import { relative as relative15 } from "path";
 var SUBCOMMANDS, write = (text) => process.stdout.write(`${text}
 `), fail = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -10292,7 +10834,7 @@ var SUBCOMMANDS, write = (text) => process.stdout.write(`${text}
     return;
   write(`  ${colors.dim}${label}${colors.reset}`);
   for (const path of paths)
-    write(`    ${relative14(cwd, path)}`);
+    write(`    ${relative15(cwd, path)}`);
 }, printSummary = (title, outcome, cwd) => {
   for (const note of outcome.notes) {
     write(`${colors.yellow}!${colors.reset} ${note}`);
@@ -10586,9 +11128,9 @@ var init_catalog = __esm(() => {
 
 // src/cli/integrations/addPlugin.ts
 import { existsSync as existsSync26, readFileSync as readFileSync24 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var isRecord11 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readPackageJson = (cwd) => {
-  const path = join29(cwd, "package.json");
+  const path = join30(cwd, "package.json");
   if (!existsSync26(path))
     return null;
   try {
@@ -11190,7 +11732,7 @@ var init_resolveAuthSettings = __esm(() => {
 // src/cli/config/auth/resolveAuthState.ts
 import ts12 from "typescript";
 import { existsSync as existsSync28, readdirSync as readdirSync6, readFileSync as readFileSync26 } from "fs";
-import { join as join30, relative as relative15, resolve as resolve27 } from "path";
+import { join as join31, relative as relative16, resolve as resolve27 } from "path";
 var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutejs/absolute-auth", NPM_URL = "https://www.npmjs.com/package/@absolutejs/auth", SKIP_DIRS, MAX_FILES = 4000, SETUP_EXPORTS, isRecord12 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
   if (!existsSync28(path))
     return null;
@@ -11204,7 +11746,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
   const value = record?.[key];
   return typeof value === "string" ? value : null;
 }, declaredVersionFor = (cwd) => {
-  const pkg = readJson(join30(cwd, "package.json"));
+  const pkg = readJson(join31(cwd, "package.json"));
   if (!pkg)
     return null;
   for (const field of ["dependencies", "devDependencies"]) {
@@ -11216,14 +11758,14 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
       return version2;
   }
   return null;
-}, installedVersionFor = (cwd) => stringField(readJson(join30(cwd, "node_modules", AUTH_PACKAGE2, "package.json")), "version"), SOURCE_FILE, safeReaddir = (dir) => {
+}, installedVersionFor = (cwd) => stringField(readJson(join31(cwd, "node_modules", AUTH_PACKAGE2, "package.json")), "version"), SOURCE_FILE, safeReaddir = (dir) => {
   try {
     return readdirSync6(dir, { withFileTypes: true });
   } catch {
     return [];
   }
 }, sortEntry = (dir, entry, found, dirs) => {
-  const full = join30(dir, entry.name);
+  const full = join31(dir, entry.name);
   if (entry.isDirectory()) {
     if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
       return;
@@ -11321,7 +11863,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
   scaffoldable: isScaffoldableFeature(feature.id)
 })), resolveAuthState = (cwd) => {
   const installedVersion = installedVersionFor(cwd);
-  const root = existsSync28(join30(cwd, "src")) ? join30(cwd, "src") : cwd;
+  const root = existsSync28(join31(cwd, "src")) ? join31(cwd, "src") : cwd;
   let match = null;
   let setupPath = null;
   for (const file of candidateFiles(root)) {
@@ -11329,7 +11871,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
     if (found === null)
       continue;
     match = found;
-    setupPath = relative15(cwd, resolve27(file));
+    setupPath = relative16(cwd, resolve27(file));
     break;
   }
   const keys = match?.keys ?? new Set;
@@ -11367,7 +11909,7 @@ var init_resolveAuthState = __esm(() => {
 
 // src/cli/config/auth/scaffoldAuthFeature.ts
 import { existsSync as existsSync29, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname19, join as join31, relative as relative16, resolve as resolve28 } from "path";
+import { dirname as dirname20, join as join32, relative as relative17, resolve as resolve28 } from "path";
 var renderScaffold = (scaffold) => {
   const importNames = [...scaffold.imports, `type ${scaffold.typeName}`];
   const importLine = `import { ${importNames.join(", ")} } from '@absolutejs/auth';`;
@@ -11392,8 +11934,8 @@ ${body}
 }, targetDir = (cwd) => {
   const { setupPath } = resolveAuthState(cwd);
   if (setupPath)
-    return dirname19(resolve28(cwd, setupPath));
-  const src = join31(cwd, "src");
+    return dirname20(resolve28(cwd, setupPath));
+  const src = join32(cwd, "src");
   return existsSync29(src) ? src : cwd;
 }, spreadFor = (scaffold) => `import { ${scaffold.exportName} } from './${scaffold.exportName}';
 // add to your auth() call:
@@ -11407,8 +11949,8 @@ ${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
   const scaffold = AUTH_SCAFFOLDS[id];
   if (!scaffold)
     return failure2(`Unknown auth feature "${id}".`);
-  const filePath = join31(targetDir(cwd), `${scaffold.exportName}.ts`);
-  const relPath = relative16(cwd, filePath);
+  const filePath = join32(targetDir(cwd), `${scaffold.exportName}.ts`);
+  const relPath = relative17(cwd, filePath);
   if (existsSync29(filePath)) {
     return {
       created: null,
@@ -11437,11 +11979,11 @@ var init_scaffoldAuthFeature = __esm(() => {
 
 // src/cli/htmx/install.ts
 import { existsSync as existsSync30, mkdirSync as mkdirSync14, readFileSync as readFileSync27, writeFileSync as writeFileSync16 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
-  join32(import.meta.dir, "htmx.min.js"),
-  join32(import.meta.dir, "htmx", "htmx.min.js"),
-  join32(import.meta.dir, "..", "htmx", "htmx.min.js")
+  join33(import.meta.dir, "htmx.min.js"),
+  join33(import.meta.dir, "htmx", "htmx.min.js"),
+  join33(import.meta.dir, "..", "htmx", "htmx.min.js")
 ].find((path) => existsSync30(path)) ?? null, detectHtmxVersion = (content) => {
   const match = content.match(/version:"([0-9.]+)"/);
   return match ? match[1] : null;
@@ -11453,7 +11995,7 @@ var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   }
   return response.text();
 }, installedHtmxVersion = (htmxDir) => {
-  const file = join32(htmxDir, "htmx.min.js");
+  const file = join33(htmxDir, "htmx.min.js");
   if (!existsSync30(file))
     return null;
   return detectHtmxVersion(readFileSync27(file, "utf-8"));
@@ -11462,7 +12004,7 @@ var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   return file ? readFileSync27(file, "utf-8") : null;
 }, writeHtmx = (htmxDir, content) => {
   mkdirSync14(htmxDir, { recursive: true });
-  const file = join32(htmxDir, "htmx.min.js");
+  const file = join33(htmxDir, "htmx.min.js");
   writeFileSync16(file, content, "utf-8");
   return file;
 };
@@ -11473,7 +12015,7 @@ var exports_add = {};
 __export(exports_add, {
   runAdd: () => runAdd
 });
-import { dirname as dirname20, join as join33, relative as relative17 } from "path";
+import { dirname as dirname21, join as join34, relative as relative18 } from "path";
 var write2 = (text) => process.stdout.write(`${text}
 `), fail2 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -11484,11 +12026,11 @@ var write2 = (text) => process.stdout.write(`${text}
     return;
   write2(`  ${colors.dim}${label}${colors.reset}`);
   for (const path of paths)
-    write2(`    ${relative17(cwd, path)}`);
+    write2(`    ${relative18(cwd, path)}`);
 }, frontendRoot = (project, cwd) => {
   const [firstKey] = configuredFrameworks(project);
   const firstDir = firstKey ? project.frameworkDirs[firstKey] : undefined;
-  return firstDir ? dirname20(firstDir) : join33(cwd, "src", "frontend");
+  return firstDir ? dirname21(firstDir) : join34(cwd, "src", "frontend");
 }, addIntegrationCli = (id, install) => {
   const result = addIntegration(process.cwd(), id, { install });
   if (!result.ok) {
@@ -11552,8 +12094,8 @@ var write2 = (text) => process.stdout.write(`${text}
     write2(`${colors.yellow}!${colors.reset} ${frameworks6[framework].label} is already configured \u2014 nothing to do.`);
     return;
   }
-  const dirAbs = join33(frontendRoot(project, cwd), framework);
-  const dirRel = `./${relative17(cwd, dirAbs).split("\\").join("/")}`;
+  const dirAbs = join34(frontendRoot(project, cwd), framework);
+  const dirRel = `./${relative18(cwd, dirAbs).split("\\").join("/")}`;
   let depNote = "Skipped dependency install (--no-install).";
   if (!noInstall) {
     write2(`${colors.dim}Installing ${frameworks6[framework].label} dependencies\u2026${colors.reset}`);
@@ -11623,7 +12165,7 @@ __export(exports_analyze, {
   runAnalyze: () => runAnalyze
 });
 import { existsSync as existsSync31, readFileSync as readFileSync28, statSync as statSync3, writeFileSync as writeFileSync17 } from "fs";
-import { join as join34, resolve as resolve29 } from "path";
+import { join as join35, resolve as resolve29 } from "path";
 var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_WIDTH = 16, SIZE_WIDTH = 12, CHANGE_WIDTH = 10, CATEGORY_ORDER, categoryOf = (key) => {
   if (key.startsWith("Island"))
     return "Islands";
@@ -11643,17 +12185,17 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
     return 0;
   }
 }, readSizes = (manifestDir) => {
-  const manifestPath = join34(manifestDir, "manifest.json");
+  const manifestPath = join35(manifestDir, "manifest.json");
   if (!existsSync31(manifestPath))
     return null;
   const manifest = JSON.parse(readFileSync28(manifestPath, "utf-8"));
   const sizes = {};
   for (const [key, value] of Object.entries(manifest)) {
-    sizes[key] = fileSize2(join34(manifestDir, value.replace(/^\//, "")));
+    sizes[key] = fileSize2(join35(manifestDir, value.replace(/^\//, "")));
   }
   return sizes;
 }, readBaseline = (cwd) => {
-  const path = join34(cwd, BASELINE_FILE);
+  const path = join35(cwd, BASELINE_FILE);
   if (!existsSync31(path))
     return null;
   try {
@@ -11742,7 +12284,7 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
     return;
   }
   if (args.includes("--save")) {
-    writeFileSync17(join34(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
+    writeFileSync17(join35(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
 `);
     process.stdout.write(`${colors.green}\u2713${colors.reset} Saved size baseline (${Object.keys(sizes).length} entries) to ${BASELINE_FILE}
 `);
@@ -11989,7 +12531,7 @@ __export(exports_remove, {
   runRemove: () => runRemove
 });
 import { existsSync as existsSync32, readFileSync as readFileSync29 } from "fs";
-import { relative as relative18 } from "path";
+import { relative as relative19 } from "path";
 var write3 = (text) => process.stdout.write(`${text}
 `), fail3 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -12038,10 +12580,10 @@ var write3 = (text) => process.stdout.write(`${text}
   }
   write3(`${colors.green}\u2713${colors.reset} Removed ${framework}Directory from absolute.config.ts
 `);
-  write3(`  ${colors.dim}Kept${colors.reset}  ${relative18(cwd, frameworkDir)} \u2014 delete its source manually if no longer needed.`);
+  write3(`  ${colors.dim}Kept${colors.reset}  ${relative19(cwd, frameworkDir)} \u2014 delete its source manually if no longer needed.`);
   const refs = referencingFiles(project.serverEntry, HANDLER_NAME[framework]);
   for (const file of refs) {
-    write3(`  ${colors.yellow}Still references${colors.reset}  ${relative18(cwd, file)} (calls ${HANDLER_NAME[framework]})`);
+    write3(`  ${colors.yellow}Still references${colors.reset}  ${relative19(cwd, file)} (calls ${HANDLER_NAME[framework]})`);
   }
   const deps = frameworkDependencyNames(framework);
   if (prune && deps.length > 0) {
@@ -12130,9 +12672,9 @@ __export(exports_env, {
   collectEnvVars: () => collectEnvVars
 });
 import { existsSync as existsSync33, readFileSync as readFileSync30 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var {env: env3, Glob: Glob3 } = globalThis.Bun;
-var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync33(join35(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
+var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync33(join36(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
   const scans = scanPatterns().map((pattern) => Array.fromAsync(new Glob3(pattern).scan({ cwd: process.cwd() })));
   const files = (await Promise.all(scans)).flat();
   const usage = new Map;
@@ -12199,7 +12741,7 @@ __export(exports_db, {
   chunkRows: () => chunkRows
 });
 import { existsSync as existsSync34, mkdirSync as mkdirSync15, readFileSync as readFileSync31, writeFileSync as writeFileSync18 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 var {env: env4, spawn: spawn2, SQL } = globalThis.Bun;
 var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA_TYPES, SEED_CANDIDATES, VALUE_FLAGS, paint = (text, color) => `${color}${text}${colors.reset}`, chunkRows = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, idx) => items.slice(idx * size, idx * size + size)), quoteIdent = (name) => `"${name.replace(/"/g, '""')}"`, resolveUrl = (explicit) => {
   const found = explicit ?? URL_ENV_KEYS.map((key) => env4[key]).find((value) => typeof value === "string" && value !== "");
@@ -12309,12 +12851,12 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
     tables,
     v: BACKUP_FORMAT_VERSION
   };
-  const dir = options.out ?? join36(process.cwd(), "backups");
+  const dir = options.out ?? join37(process.cwd(), "backups");
   mkdirSync15(dir, { recursive: true });
   const json = JSON.stringify(payload, (_, value) => typeof value === "bigint" ? value.toString() : value);
-  const file = join36(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
+  const file = join37(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
   writeFileSync18(file, json);
-  writeFileSync18(join36(dir, "latest.json"), json);
+  writeFileSync18(join37(dir, "latest.json"), json);
   const total = chosen.reduce((sum, name) => sum + (tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 backup \u2192 ${file}`, colors.green));
   console.log(paint(`  ${chosen.length} tables, ${total} rows`, colors.dim));
@@ -12343,7 +12885,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
   const total = order.reduce((sum, name) => sum + (payload.tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 restored ${order.length} tables, ${total} rows (idempotent upsert by primary key)`, colors.green));
 }, runSeed = async (entry) => {
-  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync34(join36(process.cwd(), candidate)));
+  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync34(join37(process.cwd(), candidate)));
   if (target === undefined)
     throw new Error(`No seed script found (looked for ${SEED_CANDIDATES.join(", ")}). Pass a path: absolute db seed <file>.`);
   console.log(paint(`seeding via ${target}\u2026`, colors.cyan));
@@ -12378,7 +12920,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
     return;
   }
   if (sub === "restore") {
-    const file = positionalArgs(rest)[0] ?? join36(process.cwd(), "backups", "latest.json");
+    const file = positionalArgs(rest)[0] ?? join37(process.cwd(), "backups", "latest.json");
     await runRestore(file, parseOptions(rest));
     return;
   }
@@ -12498,7 +13040,7 @@ import {
   writeFileSync as writeFileSync19
 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname21, join as join37, resolve as resolve30, sep as sep4 } from "path";
+import { dirname as dirname22, join as join38, resolve as resolve30, sep as sep5 } from "path";
 var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   try {
     const parsed = JSON.parse(readFileSync32(path, "utf-8"));
@@ -12518,13 +13060,13 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   const version2 = Reflect.get(manifest, "version");
   return typeof version2 === "string" ? version2 : "unknown";
 }, packageJsonFromEntry = (entry, expectedName) => {
-  let directory = dirname21(entry);
+  let directory = dirname22(entry);
   for (;; ) {
-    const candidate = join37(directory, "package.json");
+    const candidate = join38(directory, "package.json");
     const manifest = readManifest(candidate);
     if (manifest && manifestName(manifest, "") === expectedName)
       return candidate;
-    const parent = dirname21(directory);
+    const parent = dirname22(directory);
     if (parent === directory)
       return null;
     directory = parent;
@@ -12542,10 +13084,10 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
 }, findInstallRoot = (cwd) => {
   let directory = resolve30(cwd);
   for (;; ) {
-    if (existsSync36(join37(directory, "bun.lock")) || existsSync36(join37(directory, "bun.lockb"))) {
+    if (existsSync36(join38(directory, "bun.lock")) || existsSync36(join38(directory, "bun.lockb"))) {
       return directory;
     }
-    const parent = dirname21(directory);
+    const parent = dirname22(directory);
     if (parent === directory)
       return resolve30(cwd);
     directory = parent;
@@ -12553,14 +13095,14 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
 }, findProjectManifest = (cwd, installRoot) => {
   let directory = resolve30(cwd);
   for (;; ) {
-    const candidate = join37(directory, "package.json");
+    const candidate = join38(directory, "package.json");
     if (existsSync36(candidate))
       return candidate;
     if (directory === installRoot)
-      return join37(installRoot, "package.json");
-    const parent = dirname21(directory);
+      return join38(installRoot, "package.json");
+    const parent = dirname22(directory);
     if (parent === directory)
-      return join37(installRoot, "package.json");
+      return join38(installRoot, "package.json");
     directory = parent;
   }
 }, appendConsumer = (consumers, consumerPaths, path, manifest) => {
@@ -12598,7 +13140,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   appendConsumer(consumers, consumerPaths, inspection.consumer.path, inspection.consumer.manifest);
 }, inspectTypeGraph = (cwd) => {
   const installRoot = findInstallRoot(cwd);
-  const rootManifestPath = join37(installRoot, "package.json");
+  const rootManifestPath = join38(installRoot, "package.json");
   const rootManifest = readManifest(rootManifestPath) ?? {};
   const consumers = [
     { manifest: rootManifest, path: rootManifestPath }
@@ -12634,7 +13176,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   const duplicates = duplicateTypeGraphPackages(report);
   if (duplicates.length === 0)
     return [];
-  const manifestPath = join37(report.installRoot, "package.json");
+  const manifestPath = join38(report.installRoot, "package.json");
   const manifest = readManifest(manifestPath);
   if (!manifest)
     return [];
@@ -12656,10 +13198,10 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   }
   return changes;
 }, removeDuplicateTypeGraphPackages = (report) => {
-  const manifest = readManifest(join37(report.installRoot, "package.json")) ?? {};
+  const manifest = readManifest(join38(report.installRoot, "package.json")) ?? {};
   const rootName = manifestName(manifest, "<workspace>");
-  const installPrefix = `${realpathSync2(report.installRoot)}${sep4}`;
-  const nodeModulesSegment = `${sep4}node_modules${sep4}`;
+  const installPrefix = `${realpathSync2(report.installRoot)}${sep5}`;
+  const nodeModulesSegment = `${sep5}node_modules${sep5}`;
   const removed = [];
   const stalePaths = duplicateTypeGraphPackages(report).flatMap((duplicate) => {
     const selected = preferredIdentity(duplicate, rootName);
@@ -12668,7 +13210,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   for (const stalePath of stalePaths) {
     if (!stalePath.startsWith(installPrefix) || !stalePath.includes(nodeModulesSegment))
       continue;
-    rmSync6(dirname21(stalePath), { force: true, recursive: true });
+    rmSync6(dirname22(stalePath), { force: true, recursive: true });
     removed.push(stalePath);
   }
   return removed;
@@ -12698,7 +13240,7 @@ __export(exports_doctor, {
 import { existsSync as existsSync37, mkdirSync as mkdirSync16, readFileSync as readFileSync33, writeFileSync as writeFileSync20 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { arch as arch4, platform as platform5 } from "os";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
   detail,
   label,
@@ -12733,7 +13275,7 @@ var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
     return [];
   const label = `${field.replace("Directory", "")} pages`;
   return [
-    existsSync37(join38(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
+    existsSync37(join39(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
   ];
 }), envCheck = async () => {
   const vars = await collectEnvVars();
@@ -12795,9 +13337,9 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const fixes = [];
   for (const field of FRAMEWORK_FIELDS2) {
     const dir = readString2(config, field);
-    if (dir === undefined || existsSync37(join38(cwd, dir)))
+    if (dir === undefined || existsSync37(join39(cwd, dir)))
       continue;
-    mkdirSync16(join38(cwd, dir, "pages"), { recursive: true });
+    mkdirSync16(join39(cwd, dir, "pages"), { recursive: true });
     fixes.push(`created ${dir}/pages`);
   }
   return fixes;
@@ -12805,7 +13347,7 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const missing = (await collectEnvVars()).filter((entry) => !entry.set);
   if (missing.length === 0)
     return null;
-  const envExample = join38(cwd, ".env.example");
+  const envExample = join39(cwd, ".env.example");
   const existing = existsSync37(envExample) ? readFileSync33(envExample, "utf-8") : "";
   const existingKeys = new Set(existing.split(`
 `).map((line) => line.split("=")[0]?.trim()));
@@ -12876,7 +13418,7 @@ var init_doctor = __esm(() => {
     "htmlDirectory",
     "htmxDirectory"
   ];
-  projectRequire = createRequire2(join38(process.cwd(), "package.json"));
+  projectRequire = createRequire2(join39(process.cwd(), "package.json"));
   STATUS_MARK = {
     fail: `${colors.red}\u2717${colors.reset}`,
     ok: `${colors.green}\u2713${colors.reset}`,
@@ -13266,7 +13808,7 @@ var init_sourceMetadata = __esm(() => {
 
 // src/islands/pageMetadata.ts
 import { readFileSync as readFileSync34 } from "fs";
-import { dirname as dirname22, resolve as resolve31 } from "path";
+import { dirname as dirname23, resolve as resolve31 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -13286,7 +13828,7 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve31(dirname22(buildInfo.resolvedRegistryPath), source);
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve31(dirname23(buildInfo.resolvedRegistryPath), source);
     lookup.set(`${definition.framework}:${definition.component}`, resolve31(resolvedSource));
   }
   return lookup;
@@ -13336,7 +13878,7 @@ __export(exports_islands, {
   runIslands: () => runIslands
 });
 import { existsSync as existsSync39, readFileSync as readFileSync35, statSync as statSync5 } from "fs";
-import { join as join39, relative as relative19, resolve as resolve32 } from "path";
+import { join as join40, relative as relative20, resolve as resolve32 } from "path";
 var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.write(`${colors.dim}${message}${colors.reset}
 `), hostFrameworkOf = (pagePath, cwd, config) => {
   const resolved = resolve32(cwd, pagePath);
@@ -13354,13 +13896,13 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
     return 0;
   }
 }, readManifestSizes2 = (manifestDir) => {
-  const manifestPath = join39(manifestDir, "manifest.json");
+  const manifestPath = join40(manifestDir, "manifest.json");
   if (!existsSync39(manifestPath))
     return null;
   const manifest = JSON.parse(readFileSync35(manifestPath, "utf-8"));
   const sizes = new Map;
   for (const [key, value] of Object.entries(manifest)) {
-    sizes.set(key, fileSize3(join39(manifestDir, value.replace(/^\//, ""))));
+    sizes.set(key, fileSize3(join40(manifestDir, value.replace(/^\//, ""))));
   }
   return sizes;
 }, collectIslands = async (cwd, config, sizes) => {
@@ -13377,7 +13919,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
         crossFramework: hostFramework !== null && hostFramework !== definition.framework,
         hostFramework,
         hydrate: usage2.hydrate ?? "load",
-        page: relative19(cwd, resolve32(cwd, usage2.page))
+        page: relative20(cwd, resolve32(cwd, usage2.page))
       };
     });
     const key = getIslandManifestKey(definition.framework, definition.component);
@@ -13416,7 +13958,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
     `  ${color}\u2B21${colors.reset} ${colors.bold}${island.component}${colors.reset}  ${meta}${sizeText}`
   ];
   if (island.source) {
-    lines.push(`    ${colors.dim}${relative19(cwd, island.source)}${colors.reset}`);
+    lines.push(`    ${colors.dim}${relative20(cwd, island.source)}${colors.reset}`);
   }
   if (pages.length === 0) {
     lines.push(`    ${colors.dim}(registered but not mounted on any page)${colors.reset}`);
@@ -13496,7 +14038,7 @@ var init_islands2 = __esm(() => {
 
 // src/build/externalAssetPlugin.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync40, mkdirSync as mkdirSync17, statSync as statSync6 } from "fs";
-import { basename as basename10, dirname as dirname23, join as join40, resolve as resolve33 } from "path";
+import { basename as basename10, dirname as dirname24, join as join41, resolve as resolve33 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
   setup(bld) {
@@ -13511,7 +14053,7 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         return;
       urlPattern.lastIndex = 0;
       let match;
-      const sourceDir = dirname23(args.path);
+      const sourceDir = dirname24(args.path);
       while ((match = urlPattern.exec(source)) !== null) {
         const relPath = match[1];
         if (!relPath)
@@ -13521,10 +14063,10 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
           continue;
         if (!statSync6(assetPath).isFile())
           continue;
-        const targetPath = join40(outDir, basename10(assetPath));
+        const targetPath = join41(outDir, basename10(assetPath));
         if (existsSync40(targetPath))
           continue;
-        mkdirSync17(dirname23(targetPath), { recursive: true });
+        mkdirSync17(dirname24(targetPath), { recursive: true });
         copyFileSync2(assetPath, targetPath);
       }
       return;
@@ -13554,10 +14096,10 @@ import {
 import { createRequire as createRequire3 } from "module";
 import {
   basename as basename11,
-  dirname as dirname24,
-  isAbsolute as isAbsolute5,
-  join as join41,
-  relative as relative20,
+  dirname as dirname25,
+  isAbsolute as isAbsolute6,
+  join as join42,
+  relative as relative21,
   resolve as resolve34
 } from "path";
 var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, compileBanner = (version2) => {
@@ -13572,7 +14114,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join41(entry.parentPath, entry.name);
+    const fullPath = join42(entry.parentPath, entry.name);
     if (entry.isDirectory())
       pending = pending.concat(readdirSync7(fullPath, { withFileTypes: true }));
     else
@@ -13591,11 +14133,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!Array.isArray(map.sources))
     return;
   const sourceRoot = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
-  const bundleDirectory = dirname24(filePath);
+  const bundleDirectory = dirname25(filePath);
   map.sources = map.sources.map((entry) => {
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(entry))
       return entry;
-    if (isAbsolute5(entry))
+    if (isAbsolute6(entry))
       return entry;
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(sourceRoot)) {
       return new URL(entry, sourceRoot).href;
@@ -13618,7 +14160,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join41(entry.parentPath, entry.name);
+    const fullPath = join42(entry.parentPath, entry.name);
     if (entry.isDirectory()) {
       if (SERVER_RUNTIME_SCAN_SKIP_DIRS.has(entry.name))
         continue;
@@ -13632,7 +14174,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const copied = new Set;
   const normalizedOutdir = resolve34(outdir);
   const copyReference = (filePath, relPath) => {
-    const assetSource = resolve34(dirname24(filePath), relPath);
+    const assetSource = resolve34(dirname25(filePath), relPath);
     if (!existsSync41(assetSource) || !statSync7(assetSource).isFile())
       return;
     const assetTarget = resolve34(normalizedOutdir, relPath.replace(/^\.\//, ""));
@@ -13641,7 +14183,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (copied.has(assetTarget))
       return;
     copied.add(assetTarget);
-    mkdirSync18(dirname24(assetTarget), { recursive: true });
+    mkdirSync18(dirname25(assetTarget), { recursive: true });
     cpSync(assetSource, assetTarget, { force: true });
   };
   for (const filePath of collectProjectSourceFiles(process.cwd())) {
@@ -13757,7 +14299,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return nativeAssetEnv;
 }, tryReadNodePackageJson = (packageDir) => {
   try {
-    return JSON.parse(readFileSync36(join41(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(readFileSync36(join42(packageDir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -13769,13 +14311,13 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!pkg)
     return;
   seen.add(specifier);
-  const destDir = join41(outdir, "node_modules", ...specifier.split("/"));
+  const destDir = join42(outdir, "node_modules", ...specifier.split("/"));
   rmSync7(destDir, { force: true, recursive: true });
   cpSync(srcDir, destDir, {
     force: true,
     recursive: true,
     filter(source) {
-      const rel = relative20(srcDir, source);
+      const rel = relative21(srcDir, source);
       const [firstSegment] = rel.split(/[\\/]/);
       return firstSegment !== "node_modules" && firstSegment !== ".git";
     }
@@ -13810,7 +14352,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   copyAngularRuntimePackages(buildConfig, outdir);
   copyChunkReferencedPackages(outdir, seen);
 }, collectRuntimePackageSpecifiers = (distDir) => {
-  const nodeModulesDir = join41(distDir, "node_modules");
+  const nodeModulesDir = join42(distDir, "node_modules");
   if (!existsSync41(nodeModulesDir))
     return [];
   const specifiers = [];
@@ -13818,7 +14360,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!entry.isDirectory())
       continue;
     if (entry.name.startsWith("@")) {
-      const scopeDir = join41(nodeModulesDir, entry.name);
+      const scopeDir = join42(nodeModulesDir, entry.name);
       for (const scopedEntry of readdirSync7(scopeDir, {
         withFileTypes: true
       })) {
@@ -13832,7 +14374,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   return specifiers.sort((firstSpecifier, secondSpecifier) => secondSpecifier.length - firstSpecifier.length);
 }, ensureRelativeModuleSpecifier = (fromFile, toFile) => {
-  const rel = relative20(dirname24(fromFile), toFile).replace(/\\/g, "/");
+  const rel = relative21(dirname25(fromFile), toFile).replace(/\\/g, "/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }, pickExportEntry = (value) => {
   if (typeof value === "string")
@@ -13849,18 +14391,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const packageSpecifier = packageSpecifiers.find((root) => specifier === root || specifier.startsWith(`${root}/`));
   if (!packageSpecifier)
     return null;
-  const packageDir = join41(distDir, "node_modules", ...packageSpecifier.split("/"));
+  const packageDir = join42(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
-  const subPackageDir = subpath ? join41(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync41(join41(subPackageDir, "package.json")) ? subPackageDir : packageDir;
-  const packageJsonPath = join41(resolvedPackageDir, "package.json");
+  const subPackageDir = subpath ? join42(packageDir, ...subpath.slice(1).split("/")) : null;
+  const resolvedPackageDir = subPackageDir && existsSync41(join42(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const packageJsonPath = join42(resolvedPackageDir, "package.json");
   if (!existsSync41(packageJsonPath))
     return null;
   const pkg = JSON.parse(readFileSync36(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir !== subPackageDir && subpath ? `.${subpath}` : ".";
   const rootExport = pkg.exports?.[exportKey];
   const entry = pickExportEntry(rootExport) ?? (resolvedPackageDir === subPackageDir || !subpath ? pkg.module ?? pkg.main ?? "index.js" : `.${subpath}`);
-  return join41(resolvedPackageDir, entry);
+  return join42(resolvedPackageDir, entry);
 }, RUNTIME_JS_EXTENSIONS, MODULE_SPECIFIER_RE, isRuntimeJsFile = (filePath) => RUNTIME_JS_EXTENSIONS.some((extension) => filePath.endsWith(extension)), isNodeModulesPath = (filePath) => filePath.split(/[\\/]/).includes("node_modules"), isFile = (filePath) => {
   try {
     return statSync7(filePath).isFile();
@@ -13873,16 +14415,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const candidates = [
     candidate,
     ...RUNTIME_JS_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-    ...RUNTIME_JS_EXTENSIONS.map((extension) => join41(candidate, `index${extension}`))
+    ...RUNTIME_JS_EXTENSIONS.map((extension) => join42(candidate, `index${extension}`))
   ];
   return candidates.find((filePath) => isRuntimeJsFile(filePath) && isFile(filePath)) ?? null;
 }, findContainingRuntimePackageDir = (filePath) => {
-  let dir = dirname24(filePath);
-  while (dir !== dirname24(dir)) {
-    if (isNodeModulesPath(dir) && existsSync41(join41(dir, "package.json"))) {
+  let dir = dirname25(filePath);
+  while (dir !== dirname25(dir)) {
+    if (isNodeModulesPath(dir) && existsSync41(join42(dir, "package.json"))) {
       return dir;
     }
-    dir = dirname24(dir);
+    dir = dirname25(dir);
   }
   return null;
 }, resolvePackageImportEntryFile = (fromFile, specifier) => {
@@ -13895,11 +14437,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const entry = pickExportEntry(pkg?.imports?.[specifier]);
   if (!entry)
     return null;
-  return join41(packageDir, entry);
+  return join42(packageDir, entry);
 }, collectRuntimeRewriteRoots = (distDir) => collectFiles2(distDir).filter((filePath) => isRuntimeJsFile(filePath) && !isNodeModulesPath(filePath)), toTopLevelPackage = (specifier) => specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/"), FRAMEWORK_PACKAGE_NAME = "@absolutejs/absolute", copyChunkReferencedPackages = (distDir, seen) => {
   const distRoot = resolve34(distDir);
   for (const filePath of collectRuntimeRewriteRoots(distDir)) {
-    if (resolve34(dirname24(filePath)) === distRoot)
+    if (resolve34(dirname25(filePath)) === distRoot)
       continue;
     const source = readFileSync36(filePath, "utf-8");
     for (const match of source.matchAll(MODULE_SPECIFIER_RE)) {
@@ -13935,7 +14477,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const { masked, restore } = maskLiterals(source);
     const rewrittenMasked = masked.replace(MODULE_SPECIFIER_RE, (match, prefix, quote, specifier) => {
       if (typeof specifier === "string" && specifier.startsWith(".")) {
-        enqueue(resolveRuntimeJsFile(resolve34(dirname24(filePath), specifier)));
+        enqueue(resolveRuntimeJsFile(resolve34(dirname25(filePath), specifier)));
         return match;
       }
       const packageImportTarget = resolveRuntimeJsFile(resolvePackageImportEntryFile(filePath, specifier) ?? "");
@@ -13964,12 +14506,12 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     "_compile_entrypoint.ts"
   ]);
   const embeddedFiles = allFiles.filter((file) => {
-    const rel = relative20(distDir, file);
+    const rel = relative21(distDir, file);
     if (embeddedSkip.has(rel))
       return false;
     return true;
   });
-  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative20(distDir, file), assetSkip));
+  const clientFiles = embeddedFiles.filter((file) => shouldEmbedCompiledAsset(relative21(distDir, file), assetSkip));
   const imports = [];
   const nativeImports = [];
   const nativeMappings = [];
@@ -13984,14 +14526,14 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     nativeMappings.push(`	[${JSON.stringify(asset.env)}, resolveNativeAssetPath(${varName})],`);
   });
   embeddedFiles.forEach((filePath, idx) => {
-    const rel = relative20(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative21(distDir, filePath).replace(/\\/g, "/");
     const varName = `__a${idx}`;
     embeddedVarMap.set(rel, varName);
     imports.push(`import ${varName} from "./${rel}" with { type: "file" };`);
     embeddedMappings.push(`	["${rel}", ${varName}],`);
   });
   clientFiles.forEach((filePath) => {
-    const rel = relative20(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative21(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (!varName)
       return;
@@ -14005,7 +14547,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const pageVarMap = new Map;
   const prerenderEntries = Array.from(prerenderMap.entries());
   prerenderEntries.forEach(([route, filePath]) => {
-    const rel = relative20(distDir, filePath).replace(/\\/g, "/");
+    const rel = relative21(distDir, filePath).replace(/\\/g, "/");
     const varName = embeddedVarMap.get(rel);
     if (varName)
       pageVarMap.set(route, varName);
@@ -14501,10 +15043,10 @@ console.log(\`
   ].filter((dir) => Boolean(dir));
   const islandRegistrySpec = buildConfig.islands?.registry;
   const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve34(islandRegistrySpec))) : undefined;
-  const serverBundleEntryDirectory = join41(resolvedOutdir, ".absolutejs-server-entry");
+  const serverBundleEntryDirectory = join42(resolvedOutdir, ".absolutejs-server-entry");
   mkdirSync18(serverBundleEntryDirectory, { recursive: true });
-  const typeboxSetupEntry = join41(serverBundleEntryDirectory, "_typebox_setup.ts");
-  const serverBundleEntry = join41(serverBundleEntryDirectory, basename11(serverEntry));
+  const typeboxSetupEntry = join42(serverBundleEntryDirectory, "_typebox_setup.ts");
+  const serverBundleEntry = join42(serverBundleEntryDirectory, basename11(serverEntry));
   writeFileSync21(typeboxSetupEntry, `import { setupTypebox } from 'elysia';
 import * as compile from 'typebox/compile';
 import * as schema from 'typebox/schema';
@@ -14568,7 +15110,7 @@ export default server;
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = relative20(dirname24(outputPath), resolve34(vendorDir, file));
+      const relPath = relative21(dirname25(outputPath), resolve34(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
@@ -14580,7 +15122,7 @@ export default server;
   copyServerRuntimeAssetReferences(resolvedOutdir);
   const prerenderStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Pre-rendering pages"));
-  rmSync7(join41(resolvedOutdir, "_prerendered"), {
+  rmSync7(join42(resolvedOutdir, "_prerendered"), {
     force: true,
     recursive: true
   });
@@ -14609,9 +15151,9 @@ export default server;
   const compileStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Compiling standalone executable"));
   const entrypointCode = generateEntrypoint(resolvedOutdir, serverEntry, prerenderMap, absoluteVersion, buildConfig);
-  const entrypointPath = join41(resolvedOutdir, "_compile_entrypoint.ts");
+  const entrypointPath = join42(resolvedOutdir, "_compile_entrypoint.ts");
   await Bun.write(entrypointPath, entrypointCode);
-  mkdirSync18(dirname24(resolvedOutfile), { recursive: true });
+  mkdirSync18(dirname25(resolvedOutfile), { recursive: true });
   const result = await Bun.build({
     compile: { outfile: resolvedOutfile },
     define: { "process.env.NODE_ENV": '"production"' },
@@ -14692,15 +15234,15 @@ var init_compile = __esm(() => {
 });
 
 // src/mobile/nativeDeepLinks.ts
-import { readFile as readFile10, rename as rename7, writeFile as writeFile7 } from "fs/promises";
-import { join as join42 } from "path";
+import { readFile as readFile11, rename as rename8, writeFile as writeFile8 } from "fs/promises";
+import { join as join43 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->", END_MARKER = "<!-- absolutejs:deep-links:end -->", IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements", NOT_FOUND = -1, escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"), writeChangedFile = async (path, source) => {
-  const current = await readFile10(path, "utf8");
+  const current = await readFile11(path, "utf8");
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile7(temporary, source, { flag: "wx" });
-  await rename7(temporary, path);
+  await writeFile8(temporary, source, { flag: "wx" });
+  await rename8(temporary, path);
   return true;
 }, replaceManagedRegion = (source, region, insertAt) => {
   const start2 = source.indexOf(START_MARKER);
@@ -14742,8 +15284,8 @@ ${hosts}
             ${END_MARKER}
 `;
 }, configureAndroid = async (config) => {
-  const path = join42(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
-  const source = await readFile10(path, "utf8");
+  const path = join43(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile11(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
     throw new TypeError("Android MainActivity was not found.");
@@ -14766,8 +15308,8 @@ ${hosts}
 	</array>
 	${END_MARKER}
 `, configureIosInfo = async (config) => {
-  const path = join42(config.nativeProjectDirectory, "ios/App/App/Info.plist");
-  const source = await readFile10(path, "utf8");
+  const path = join43(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile11(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
 `;
@@ -14788,10 +15330,10 @@ ${domains}
 </plist>
 `;
 }, configureIosEntitlements = async (config) => {
-  const path = join42(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join43(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
-    current = await readFile10(path, "utf8");
+    current = await readFile11(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -14801,12 +15343,12 @@ ${domains}
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile7(temporary, source, { flag: "wx" });
-  await rename7(temporary, path);
+  await writeFile8(temporary, source, { flag: "wx" });
+  await rename8(temporary, path);
   return true;
 }, configureIosProject = async (config) => {
-  const path = join42(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
-  const source = await readFile10(path, "utf8");
+  const path = join43(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const source = await readFile11(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
   ].map((match) => match[1]);
@@ -14846,11 +15388,11 @@ var init_nativeDeepLinks = () => {};
 // src/mobile/associationFiles.ts
 import {
   access as access7,
-  mkdir as mkdir8,
-  readFile as readFile11,
-  rename as rename8,
+  mkdir as mkdir9,
+  readFile as readFile12,
+  rename as rename9,
   rm as rm7,
-  writeFile as writeFile8
+  writeFile as writeFile9
 } from "fs/promises";
 import { resolve as resolve35 } from "path";
 import { Elysia } from "elysia";
@@ -14905,7 +15447,7 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
 }, writeAtomic = async (path, source) => {
   let current;
   try {
-    current = await readFile11(path, "utf8");
+    current = await readFile12(path, "utf8");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
       throw error;
@@ -14914,8 +15456,8 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
   if (current === source)
     return false;
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile8(temporary, source, { flag: "wx" });
-  await rename8(temporary, path);
+  await writeFile9(temporary, source, { flag: "wx" });
+  await rename9(temporary, path);
   return true;
 }, exists2 = async (path) => {
   try {
@@ -14928,7 +15470,7 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
   const path = resolve35(root, OWNERSHIP_FILE);
   let ownership;
   try {
-    ownership = JSON.parse(await readFile11(path, "utf8"));
+    ownership = JSON.parse(await readFile12(path, "utf8"));
   } catch {
     throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
   }
@@ -14941,19 +15483,19 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
     await assertOwnedOutput(root);
   const backup = `${root}.${crypto.randomUUID()}.previous`;
   if (hasCurrent)
-    await rename8(root, backup);
+    await rename9(root, backup);
   try {
-    await rename8(temporary, root);
+    await rename9(temporary, root);
   } catch (error) {
     if (hasCurrent)
-      await rename8(backup, root);
+      await rename9(backup, root);
     throw error;
   }
   if (hasCurrent)
     await rm7(backup, { force: true, recursive: true });
 }, materializeHost = async (root, host, files) => {
   const directory = resolve35(root, host, ".well-known");
-  await mkdir8(directory, { recursive: true });
+  await mkdir9(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document]) => {
     const path = resolve35(directory, name);
     await writeAtomic(path, `${JSON.stringify(document, null, 2)}
@@ -14989,7 +15531,7 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
   if (documents.apple) {
     files.push(["apple-app-site-association", documents.apple]);
   }
-  await mkdir8(temporary, { recursive: true });
+  await mkdir9(temporary, { recursive: true });
   try {
     const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
     await writeAtomic(resolve35(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
@@ -15036,8 +15578,8 @@ var init_associationFiles = __esm(() => {
 });
 
 // src/mobile/androidWebView.ts
-import { mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname25, resolve as resolve36 } from "path";
+import { mkdir as mkdir10, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname26, resolve as resolve36 } from "path";
 
 class CdpConnection {
   diagnostics = [];
@@ -15309,8 +15851,8 @@ var CDP_COMMAND_TIMEOUT_MS = 1e4, WEBVIEW_ATTACH_TIMEOUT_MS = 30000, WEBVIEW_POL
         throw new Error("Android WebView screenshot returned no image data.");
       }
       const absolutePath = resolve36(path);
-      await mkdir9(dirname25(absolutePath), { recursive: true });
-      await writeFile9(absolutePath, Buffer.from(data, "base64"));
+      await mkdir10(dirname26(absolutePath), { recursive: true });
+      await writeFile10(absolutePath, Buffer.from(data, "base64"));
       return absolutePath;
     }
   };
@@ -15428,8 +15970,8 @@ var DEFAULT_ROUTE_TIMEOUT_MS = 30000, DEFAULT_HMR_TIMEOUT_MS = 30000, routeExpre
 };
 
 // src/mobile/releaseDoctor.ts
-import { access as access8, readFile as readFile12, readdir as readdir4 } from "fs/promises";
-import { extname as extname6, join as join43, relative as relative21 } from "path";
+import { access as access8, readFile as readFile13, readdir as readdir4 } from "fs/promises";
+import { extname as extname6, join as join44, relative as relative22 } from "path";
 var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
   try {
     await access8(path);
@@ -15442,13 +15984,13 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
     return findHmrAsset(path);
   if (!isFile2 || !RELEASE_ASSET_EXTENSIONS.has(extname6(path)))
     return;
-  const source = await readFile12(path, "utf8");
+  const source = await readFile13(path, "utf8");
   return HMR_ASSET_PATTERN.test(source) ? path : undefined;
 }, findHmrAsset = async (root) => {
   if (!await pathExists5(root))
     return;
   const entries = await readdir4(root, { withFileTypes: true });
-  const matches = await Promise.all(entries.map((entry) => inspectReleaseAsset(join43(root, entry.name), entry.isDirectory(), entry.isFile())));
+  const matches = await Promise.all(entries.map((entry) => inspectReleaseAsset(join44(root, entry.name), entry.isDirectory(), entry.isFile())));
   return matches.find((match) => match !== undefined);
 }, pass = (id, detail, path) => ({ detail, id, path, status: "pass" }), fail5 = (id, detail, path, remediation) => ({
   detail,
@@ -15481,23 +16023,23 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
   if (!await pathExists5(nativeConfigPath)) {
     return fail5("android.capacitor-config", "The generated Android Capacitor config is missing.", nativeConfigPath, "Run `absolute mobile sync android` before release validation.");
   }
-  const unsafe = isUnsafeCapacitorConfig(await readFile12(nativeConfigPath, "utf8"));
+  const unsafe = isUnsafeCapacitorConfig(await readFile13(nativeConfigPath, "utf8"));
   return unsafe ? fail5("android.capacitor-config", "Android Capacitor config contains a development server URL, cleartext transport, navigation allowlist, or invalid JSON.", nativeConfigPath, "Run `absolute mobile sync android`; do not ship development transport overrides.") : pass("android.capacitor-config", "Android Capacitor config contains no development transport overrides.", nativeConfigPath);
 }, manifestReleaseCheck = async (manifestPath) => {
   if (!await pathExists5(manifestPath)) {
     return fail5("android.cleartext", "The Android manifest is missing.", manifestPath, "Run `absolute mobile sync android` before release validation.");
   }
-  const source = await readFile12(manifestPath, "utf8");
+  const source = await readFile13(manifestPath, "utf8");
   return /android:usesCleartextTraffic=["']true["']/u.test(source) ? fail5("android.cleartext", "Android explicitly permits cleartext traffic.", manifestPath, 'Remove usesCleartextTraffic="true" from the release manifest.') : pass("android.cleartext", "Android does not explicitly permit cleartext traffic.", manifestPath);
 }, hmrAssetsReleaseCheck = async (publicRoot) => {
   const hmrAsset = await findHmrAsset(publicRoot);
   return hmrAsset ? fail5("android.hmr-assets", "A packaged Android asset contains the development HMR client.", hmrAsset, "Rebuild the production mobile bundle and run Capacitor sync again.") : pass("android.hmr-assets", "Packaged Android assets contain no development HMR markers.", publicRoot);
 }, inspectAndroidRelease = async (config, projectRoot) => {
-  const androidRoot = join43(config.nativeProjectDirectory, "android");
-  const nativeConfigPath = join43(androidRoot, "app", "src", "main", "assets", "capacitor.config.json");
-  const manifestPath = join43(androidRoot, "app", "src", "main", "AndroidManifest.xml");
-  const publicRoot = join43(androidRoot, "app", "src", "main", "assets", "public");
-  const journalPath = join43(projectRoot, ".absolutejs", "mobile", "dev-session", "journal.json");
+  const androidRoot = join44(config.nativeProjectDirectory, "android");
+  const nativeConfigPath = join44(androidRoot, "app", "src", "main", "assets", "capacitor.config.json");
+  const manifestPath = join44(androidRoot, "app", "src", "main", "AndroidManifest.xml");
+  const publicRoot = join44(androidRoot, "app", "src", "main", "assets", "public");
+  const journalPath = join44(projectRoot, ".absolutejs", "mobile", "dev-session", "journal.json");
   const checks = await Promise.all([
     journalReleaseCheck(journalPath, "android"),
     capacitorConfigReleaseCheck(nativeConfigPath),
@@ -15506,14 +16048,14 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
   ]);
   return checks.map((check2) => ({
     ...check2,
-    path: check2.path ? relative21(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
+    path: check2.path ? relative22(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
   }));
 }, inspectIosRelease = async (config, projectRoot) => {
-  const iosAppRoot = join43(config.nativeProjectDirectory, "ios", "App", "App");
-  const nativeConfigPath = join43(iosAppRoot, "capacitor.config.json");
-  const infoPath = join43(iosAppRoot, "Info.plist");
-  const publicRoot = join43(iosAppRoot, "public");
-  const journalPath = join43(projectRoot, ".absolutejs", "mobile", "ios-dev-session", "journal.json");
+  const iosAppRoot = join44(config.nativeProjectDirectory, "ios", "App", "App");
+  const nativeConfigPath = join44(iosAppRoot, "capacitor.config.json");
+  const infoPath = join44(iosAppRoot, "Info.plist");
+  const publicRoot = join44(iosAppRoot, "public");
+  const journalPath = join44(projectRoot, ".absolutejs", "mobile", "ios-dev-session", "journal.json");
   const checks = [
     await journalReleaseCheck(journalPath, "ios")
   ];
@@ -15524,7 +16066,7 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
   }
   if (!await pathExists5(nativeConfigPath)) {
     checks.push(fail5("ios.capacitor-config", "The generated iOS Capacitor config is missing.", nativeConfigPath, "Run `absolute mobile sync ios` before release validation."));
-  } else if (isUnsafeCapacitorConfig(await readFile12(nativeConfigPath, "utf8"))) {
+  } else if (isUnsafeCapacitorConfig(await readFile13(nativeConfigPath, "utf8"))) {
     checks.push(fail5("ios.capacitor-config", "iOS Capacitor config contains a development server URL, cleartext transport, navigation allowlist, or invalid JSON.", nativeConfigPath, "Run `absolute mobile sync ios`; do not ship development transport overrides."));
   } else {
     checks.push(pass("ios.capacitor-config", "iOS Capacitor config contains no development transport overrides.", nativeConfigPath));
@@ -15532,14 +16074,14 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
   if (!await pathExists5(infoPath)) {
     checks.push(fail5("ios.transport-security", "The iOS Info.plist is missing.", infoPath, "Run `absolute mobile sync ios` before release validation."));
   } else {
-    const info2 = await readFile12(infoPath, "utf8");
+    const info2 = await readFile13(infoPath, "utf8");
     checks.push(/<key>NSAllowsArbitraryLoads<\/key>\s*<true\s*\/>/u.test(info2) ? fail5("ios.transport-security", "iOS App Transport Security permits arbitrary network loads.", infoPath, "Remove NSAllowsArbitraryLoads from the release Info.plist.") : pass("ios.transport-security", "iOS App Transport Security does not permit arbitrary loads.", infoPath));
   }
   const hmrAsset = await findHmrAsset(publicRoot);
   checks.push(hmrAsset ? fail5("ios.hmr-assets", "A packaged iOS asset contains the development HMR client.", hmrAsset, "Rebuild the production mobile bundle and run Capacitor sync again.") : pass("ios.hmr-assets", "Packaged iOS assets contain no development HMR markers.", publicRoot));
   return checks.map((check2) => ({
     ...check2,
-    path: check2.path ? relative21(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
+    path: check2.path ? relative22(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
   }));
 }, inspectAbsoluteMobileRelease = async (config, projectRoot) => {
   const checks = config.platforms.includes("android") ? await inspectAndroidRelease(config, projectRoot) : [];
@@ -15557,19 +16099,19 @@ var init_releaseDoctor = __esm(() => {
 });
 
 // src/mobile/androidRelease.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import {
   access as access9,
   copyFile as copyFile5,
-  mkdir as mkdir10,
+  mkdir as mkdir11,
   mkdtemp as mkdtemp5,
-  readFile as readFile13,
-  rename as rename9,
+  readFile as readFile14,
+  rename as rename10,
   rm as rm8,
   stat as stat2,
-  writeFile as writeFile10
+  writeFile as writeFile11
 } from "fs/promises";
-import { dirname as dirname26, isAbsolute as isAbsolute6, join as join44, relative as relative22, resolve as resolve37, sep as sep5 } from "path";
+import { dirname as dirname27, isAbsolute as isAbsolute7, join as join45, relative as relative23, resolve as resolve37, sep as sep6 } from "path";
 var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), requireManifest2 = (value) => {
   if (!isRecord13(value) || typeof value.appBuild !== "string" || typeof value.appId !== "string" || typeof value.runtime !== "string") {
     throw new TypeError("Invalid embedded AbsoluteJS mobile manifest.");
@@ -15619,20 +16161,20 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
     artifactPath
   ]);
   return result.exitCode === 0 && /jar verified/iu.test(result.stdout);
-}, sha256File2 = async (path) => createHash11("sha256").update(await readFile13(path)).digest("hex"), safeOutputDirectory2 = (projectRoot, requested) => {
+}, sha256File2 = async (path) => createHash12("sha256").update(await readFile14(path)).digest("hex"), safeOutputDirectory2 = (projectRoot, requested) => {
   const root = resolve37(projectRoot);
   const output = resolve37(root, requested ?? ".absolutejs/mobile/releases/android");
-  const projectRelative = relative22(root, output);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep5}`) || isAbsolute6(projectRelative)) {
+  const projectRelative = relative23(root, output);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute7(projectRelative)) {
     throw new TypeError("mobile build --outdir must remain inside the project.");
   }
   return output;
 }, installRelease2 = async (artifactPath, metadata, outputRoot) => {
-  const releaseRoot = join44(outputRoot, metadata.releaseId);
+  const releaseRoot = join45(outputRoot, metadata.releaseId);
   const artifactName = "app-release.aab";
-  const destination = join44(releaseRoot, artifactName);
+  const destination = join45(releaseRoot, artifactName);
   if (await pathExists6(releaseRoot)) {
-    const existing = requireManifestIdentity(JSON.parse(await readFile13(join44(releaseRoot, "release.json"), "utf8")), metadata);
+    const existing = requireManifestIdentity(JSON.parse(await readFile14(join45(releaseRoot, "release.json"), "utf8")), metadata);
     const [installedBytes, installedSha256] = await Promise.all([
       stat2(destination).then(({ size }) => size),
       sha256File2(destination)
@@ -15642,17 +16184,17 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
     }
     return { artifactPath: destination, metadata: existing, releaseRoot };
   }
-  await mkdir10(dirname26(releaseRoot), { recursive: true });
-  const staging = await mkdtemp5(join44(dirname26(releaseRoot), ".android-stage-"));
+  await mkdir11(dirname27(releaseRoot), { recursive: true });
+  const staging = await mkdtemp5(join45(dirname27(releaseRoot), ".android-stage-"));
   try {
-    await copyFile5(artifactPath, join44(staging, artifactName));
+    await copyFile5(artifactPath, join45(staging, artifactName));
     const complete = {
       ...metadata,
       artifact: artifactName
     };
-    await writeFile10(join44(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+    await writeFile11(join45(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
 `, { flag: "wx" });
-    await rename9(staging, releaseRoot);
+    await rename10(staging, releaseRoot);
     return { artifactPath: destination, metadata: complete, releaseRoot };
   } finally {
     await rm8(staging, { force: true, recursive: true }).catch(() => {
@@ -15678,15 +16220,15 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
   const projectRoot = resolve37(options.projectRoot);
   const host = options.host ?? detectAbsoluteMobileHost();
   const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host);
-  const nativeDirectory = join44(options.config.nativeProjectDirectory, "android");
-  const manifest = requireManifest2(JSON.parse(await readFile13(join44(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  const nativeDirectory = join45(options.config.nativeProjectDirectory, "android");
+  const manifest = requireManifest2(JSON.parse(await readFile14(join45(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
   if (manifest.appId !== options.config.appId) {
     throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
   }
   let { versionCode } = options;
   if (options.prepareVersionCode) {
     const nativeFingerprint = await fingerprintAbsoluteAndroidNativeProject({ nativeDirectory });
-    const buildIdentity = createHash11("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}`).digest("hex");
+    const buildIdentity = createHash12("sha256").update(`${manifest.appBuild}\x00${nativeFingerprint}`).digest("hex");
     versionCode = await options.prepareVersionCode(buildIdentity);
   }
   if (versionCode !== undefined && (!Number.isSafeInteger(versionCode) || versionCode < 1 || versionCode > 2100000000)) {
@@ -15743,7 +16285,7 @@ var init_androidRelease = __esm(() => {
 });
 
 // src/mobile/iosConformance.ts
-import { readFile as readFile14, stat as stat3 } from "fs/promises";
+import { readFile as readFile15, stat as stat3 } from "fs/promises";
 var HMR_LINE, parseAbsoluteIosHmrLog = (line) => {
   const match = HMR_LINE.exec(line);
   if (!match)
@@ -15778,7 +16320,7 @@ var HMR_LINE, parseAbsoluteIosHmrLog = (line) => {
     if (Date.now() > deadline)
       throw new Error(`No iOS native HMR acknowledgement was observed within ${timeoutMs}ms.`);
     options.signal?.throwIfAborted();
-    const contents = await readFile14(options.logPath).catch(() => Buffer.alloc(0));
+    const contents = await readFile15(options.logPath).catch(() => Buffer.alloc(0));
     if (contents.byteLength < offset) {
       offset = 0;
       buffered = "";
@@ -15803,7 +16345,7 @@ var init_iosConformance = __esm(() => {
 
 // src/mobile/releasePublisher.ts
 import { access as access10 } from "fs/promises";
-import { isAbsolute as isAbsolute7, relative as relative23, resolve as resolve38, sep as sep6 } from "path";
+import { isAbsolute as isAbsolute8, relative as relative24, resolve as resolve38, sep as sep7 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -15827,8 +16369,8 @@ var prepareAbsoluteIosRelease = async (publisher, options) => {
 }, isRecord14 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), isPublisher = (value) => isRecord14(value) && typeof value.publish === "function", publisherModulePath = (projectRoot, requested) => {
   const root = resolve38(projectRoot);
   const path = resolve38(root, requested);
-  const projectRelative = relative23(root, path);
-  if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute7(projectRelative)) {
+  const projectRelative = relative24(root, path);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep7}`) || isAbsolute8(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
   return path;
@@ -15899,8 +16441,8 @@ var exports_mobile = {};
 __export(exports_mobile, {
   runMobile: () => runMobile
 });
-import { access as access11, mkdir as mkdir11, writeFile as writeFile11 } from "fs/promises";
-import { join as join45, resolve as resolve39 } from "path";
+import { access as access11, mkdir as mkdir12, writeFile as writeFile12 } from "fs/promises";
+import { join as join46, resolve as resolve39 } from "path";
 import { createInterface } from "readline/promises";
 var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), CAPACITOR_PACKAGES, valueAfter = (args, flag) => {
   const index = args.indexOf(flag);
@@ -15914,7 +16456,7 @@ var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value
   }
   return value;
 }, capacitorExecutable = async (projectRoot) => {
-  const executable = join45(projectRoot, "node_modules", ".bin", "cap");
+  const executable = join46(projectRoot, "node_modules", ".bin", "cap");
   try {
     await access11(executable);
     return executable;
@@ -15938,6 +16480,41 @@ var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value
   const config = await loadConfig(configPath2);
   const mobile = normalizeAbsoluteMobileConfig(requireMobileConfig(config.mobile), projectRoot);
   return { mobile, projectRoot };
+}, remoteProfilePath = () => process.env.ABSOLUTE_REMOTE_MAC_PROFILE_PATH || undefined, pairRemoteMac = async (args) => {
+  if (args[0] !== "mac" || !args[1] || !args[2])
+    throw new TypeError("Usage: absolute mobile pair mac <name> <user@host> [--port n] [--workspace path]");
+  const portValue = valueAfter(args, "--port");
+  const port = portValue === undefined ? undefined : Number(portValue);
+  const profile = await pairAbsoluteRemoteMac({
+    destination: args[2],
+    name: args[1],
+    ...port === undefined ? {} : { port },
+    profilePath: remoteProfilePath(),
+    workspaceRoot: valueAfter(args, "--workspace")
+  });
+  sendTelemetryEvent("mobile:remote-mac-paired", {
+    platform: "ios",
+    provider: "ssh"
+  });
+  console.log(`Paired remote Mac ${profile.name} (${profile.xcodeVersion}) and selected it as the default iOS development host.`);
+}, listRemoteMacs = async (args) => {
+  const result = await listAbsoluteRemoteMacProfiles(remoteProfilePath());
+  if (args.includes("--json")) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.profiles.length === 0) {
+    console.log("No remote Macs are paired. Run `absolute mobile pair mac <name> <user@host>`.");
+    return;
+  }
+  for (const profile of result.profiles) {
+    console.log(`${profile.name === result.defaultProfile ? "* " : "  "}${profile.name}  ${profile.destination}  ${profile.xcodeVersion}`);
+  }
+}, unpairRemoteMac = async (args) => {
+  if (args[0] !== "mac" || !args[1])
+    throw new TypeError("Usage: absolute mobile unpair mac <name>");
+  const removed = await removeAbsoluteRemoteMacProfile(args[1], remoteProfilePath());
+  console.log(removed ? `Removed remote Mac profile ${args[1]}.` : `Remote Mac profile ${args[1]} was not found.`);
 }, initialize = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
   const generated = await writeAbsoluteCapacitorConfig(mobile, {
@@ -16188,7 +16765,7 @@ Mobile release transport checks failed.`);
     const durationMs = Math.round(performance.now() - startedAt);
     console.log(`Built ${release.metadata.signed ? "signed" : "unsigned"} Android App Bundle in ${getDurationString(durationMs)}.`);
     console.log(`Artifact: ${release.artifactPath}`);
-    console.log(`Metadata: ${join45(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join46(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:android-release-build", {
@@ -16287,7 +16864,7 @@ Mobile release transport checks failed.`);
     const durationMs = Math.round(performance.now() - startedAt);
     console.log(`Built ${release.metadata.signed ? "signed" : "unsigned"} iOS IPA ${release.metadata.marketingVersion}${release.metadata.buildNumber ? ` (${release.metadata.buildNumber})` : ""} in ${getDurationString(durationMs)}.`);
     console.log(`Artifact: ${release.artifactPath}`);
-    console.log(`Metadata: ${join45(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join46(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:ios-release-build", {
@@ -16349,13 +16926,62 @@ Mobile release transport checks failed.`);
       unsignedAllowed: args.includes("--unsigned")
     });
   }
+}, inspectRemoteMacForDoctor = async (profile) => {
+  try {
+    const inspection = await inspectAbsoluteRemoteMac(profile.destination, {
+      port: profile.port
+    });
+    return [
+      {
+        id: "ios.remote-ssh",
+        label: `Remote Mac ${profile.name} is reachable`,
+        platform: "ios",
+        status: "pass"
+      },
+      {
+        id: "ios.remote-bun",
+        label: `Remote Bun ${inspection.bunPath}`,
+        path: inspection.bunPath,
+        platform: "ios",
+        status: "pass"
+      },
+      {
+        id: "ios.remote-xcode",
+        label: inspection.xcodeVersion,
+        platform: "ios",
+        status: "pass"
+      }
+    ];
+  } catch (error) {
+    return [
+      {
+        id: "ios.remote-ssh",
+        label: `Remote Mac ${profile.name} is unavailable`,
+        platform: "ios",
+        remediation: error instanceof Error ? error.message : String(error),
+        status: "fail"
+      }
+    ];
+  }
 }, doctor = async (args) => {
   if (args.includes("release")) {
     await runReleaseDoctor(args);
     return;
   }
-  const checks = await inspectAbsoluteMobileToolchain();
   const platform6 = args.find((value) => value === "android" || value === "ios");
+  const requestedRemote = valueAfter(args, "--remote");
+  const remoteProfile = platform6 === "ios" && (requestedRemote !== undefined || process.platform !== "darwin") ? await getAbsoluteRemoteMacProfile(requestedRemote, remoteProfilePath()) : undefined;
+  if (remoteProfile) {
+    if (args.includes("--fix"))
+      throw new TypeError("Remote Mac doctor is read-only. Configure Xcode or Bun on the Mac, then rerun doctor.");
+    const selected2 = await inspectRemoteMacForDoctor(remoteProfile);
+    if (args.includes("--json"))
+      console.log(JSON.stringify({ checks: selected2 }, null, 2));
+    else
+      printDoctorChecks(selected2);
+    return;
+  }
+  const checks = await inspectAbsoluteMobileToolchain();
   const selected = platform6 ? checks.filter((check2) => check2.platform === "host" || check2.platform === platform6) : checks;
   if (args.includes("--json")) {
     if (args.includes("--fix")) {
@@ -16483,12 +17109,12 @@ Emulator setup verification:`);
     timeoutMs
   });
 }, writeAndroidFailureArtifacts = async (options) => {
-  await mkdir11(options.artifactRoot, { recursive: true });
-  const screenshot = options.session ? await options.session.screenshot(join45(options.artifactRoot, "android-failure.png")).catch(() => {
+  await mkdir12(options.artifactRoot, { recursive: true });
+  const screenshot = options.session ? await options.session.screenshot(join46(options.artifactRoot, "android-failure.png")).catch(() => {
     return;
   }) : undefined;
-  const diagnosticPath = join45(options.artifactRoot, "android-failure.json");
-  await writeFile11(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join46(options.artifactRoot, "android-failure.json");
+  await writeFile12(diagnosticPath, `${JSON.stringify({
     diagnostics: options.session?.diagnostics ?? [],
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "android",
@@ -16664,8 +17290,8 @@ Emulator setup verification:`);
     throw new Error(`${label} failed: ${result.stderr.trim() || result.stdout.trim() || `status ${result.exitCode}`}`);
   return result;
 }, writeIosFailureArtifacts = async (options) => {
-  await mkdir11(options.artifactRoot, { recursive: true });
-  const screenshot = join45(options.artifactRoot, "ios-failure.png");
+  await mkdir12(options.artifactRoot, { recursive: true });
+  const screenshot = join46(options.artifactRoot, "ios-failure.png");
   const screenshotResult = captureCommand4([
     options.xcrun,
     "simctl",
@@ -16674,8 +17300,8 @@ Emulator setup verification:`);
     "screenshot",
     screenshot
   ]);
-  const diagnosticPath = join45(options.artifactRoot, "ios-failure.json");
-  await writeFile11(diagnosticPath, `${JSON.stringify({
+  const diagnosticPath = join46(options.artifactRoot, "ios-failure.json");
+  await writeFile12(diagnosticPath, `${JSON.stringify({
     appId: options.appId,
     error: options.error instanceof Error ? options.error.message : String(options.error),
     platform: "ios",
@@ -16719,8 +17345,8 @@ Emulator setup verification:`);
       mobile.appId
     ], "iOS app launch");
     await waitForIosHmrClient({ https, port, timeoutMs });
-    await mkdir11(artifactRoot, { recursive: true });
-    const screenshot = join45(artifactRoot, "ios-simulator.png");
+    await mkdir12(artifactRoot, { recursive: true });
+    const screenshot = join46(artifactRoot, "ios-simulator.png");
     requireCapturedIosCommand([xcrun, "simctl", "io", simulator.udid, "screenshot", screenshot], "iOS simulator screenshot");
     const hmrApply = await waitForRequestedIosHmr(args, instance, timeoutMs);
     const report = {
@@ -16765,6 +17391,18 @@ Emulator setup verification:`);
   }
 }, runMobile = async (args) => {
   const [command] = args;
+  if (command === "pair") {
+    await pairRemoteMac(args.slice(1));
+    return;
+  }
+  if (command === "remotes") {
+    await listRemoteMacs(args.slice(1));
+    return;
+  }
+  if (command === "unpair") {
+    await unpairRemoteMac(args.slice(1));
+    return;
+  }
   if (command === "init") {
     await initialize(args.slice(1));
     return;
@@ -16805,7 +17443,7 @@ Emulator setup verification:`);
     await publishIos(args.slice(2));
     return;
   }
-  throw new TypeError("Usage: absolute mobile <init [--no-native] [--force] | sync [ios|android] | associations [--outdir dir] [--verify] | doctor [ios|android|release] [--json|--fix [--yes]] | build <android|ios> [server-entry] [--outdir dir] [--web-outdir dir] [--unsigned] | publish android [server-entry] [--registry module] [--channel name] [--play-track track] [--play-status completed|draft|halted|in-progress] [--play-rollout fraction] [--play-name name] [--play-notes language=text] [--play-update-priority 0..5] [--play-hold-review] [--play-cancel-existing-review] [--outdir dir] [--web-outdir dir] [--unsigned] | publish ios [server-entry] [--registry module] [--channel name] [--testflight-group name-or-id] [--testflight-notes locale=text] [--testflight-submit-review] [--outdir dir] [--web-outdir dir] [--unsigned] | test android [--route path] [--wait-for-hmr] [--timeout ms] [--port n] [--serial id] [--artifacts dir] [--json] | test ios [--wait-for-hmr] [--timeout ms] [--port n] [--udid id] [--artifacts dir] [--json]> [--config path]");
+  throw new TypeError("Usage: absolute mobile <pair mac <name> <user@host> [--port n] [--workspace path] | remotes [--json] | unpair mac <name> | init [--no-native] [--force] | sync [ios|android] | associations [--outdir dir] [--verify] | doctor [ios|android|release] [--remote name] [--json|--fix [--yes]] | build <android|ios> [server-entry] [--outdir dir] [--web-outdir dir] [--unsigned] | publish android [server-entry] [--registry module] [--channel name] [--play-track track] [--play-status completed|draft|halted|in-progress] [--play-rollout fraction] [--play-name name] [--play-notes language=text] [--play-update-priority 0..5] [--play-hold-review] [--play-cancel-existing-review] [--outdir dir] [--web-outdir dir] [--unsigned] | publish ios [server-entry] [--registry module] [--channel name] [--testflight-group name-or-id] [--testflight-notes locale=text] [--testflight-submit-review] [--outdir dir] [--web-outdir dir] [--unsigned] | test android [--route path] [--wait-for-hmr] [--timeout ms] [--port n] [--serial id] [--artifacts dir] [--json] | test ios [--wait-for-hmr] [--timeout ms] [--port n] [--udid id] [--artifacts dir] [--json]> [--config path]");
 };
 var init_mobile = __esm(() => {
   init_capacitorProject();
@@ -16828,6 +17466,7 @@ var init_mobile = __esm(() => {
   init_start();
   init_utils();
   init_getDurationString();
+  init_remoteMacProtocol();
   CAPACITOR_PACKAGES = [
     "@capacitor/core",
     "@capacitor/app",
@@ -16842,9 +17481,9 @@ var exports_typecheck = {};
 __export(exports_typecheck, {
   typecheck: () => typecheck
 });
-import { resolve as resolve40, join as join46 } from "path";
+import { resolve as resolve40, join as join47 } from "path";
 import { existsSync as existsSync42, readFileSync as readFileSync37 } from "fs";
-import { mkdir as mkdir12, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir13, writeFile as writeFile13 } from "fs/promises";
 var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve40(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
   if (!existsSync42(resolveConfigPath(configPath2))) {
     const defaultService = {};
@@ -16951,8 +17590,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m vue-tsc is required for Vue type checking. Install it: bun add -d vue-tsc");
     process.exit(1);
   }
-  const vueTsconfigPath = join46(cacheDir, "tsconfig.vue-check.json");
-  return writeFile12(vueTsconfigPath, JSON.stringify({
+  const vueTsconfigPath = join47(cacheDir, "tsconfig.vue-check.json");
+  return writeFile13(vueTsconfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
@@ -16966,7 +17605,7 @@ Found ${errorCount} error${suffix}.`;
     resolve40(vueTsconfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join46(cacheDir, "vue-tsc.tsbuildinfo"),
+    join47(cacheDir, "vue-tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildAngularCheck = async (cacheDir, angularDir) => {
@@ -16975,8 +17614,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m @angular/compiler-cli is required for Angular type checking. Install it: bun add -d @angular/compiler-cli");
     process.exit(1);
   }
-  const angularTsconfigPath = join46(cacheDir, "tsconfig.angular-check.json");
-  await writeFile12(angularTsconfigPath, JSON.stringify({
+  const angularTsconfigPath = join47(cacheDir, "tsconfig.angular-check.json");
+  await writeFile13(angularTsconfigPath, JSON.stringify({
     angularCompilerOptions: {
       strictTemplates: true
     },
@@ -16995,8 +17634,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m typescript is required for type checking. Install it: bun add -d typescript");
     process.exit(1);
   }
-  const tscConfigPath = join46(cacheDir, "tsconfig.typecheck.json");
-  return writeFile12(tscConfigPath, JSON.stringify({
+  const tscConfigPath = join47(cacheDir, "tsconfig.typecheck.json");
+  return writeFile13(tscConfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
@@ -17010,7 +17649,7 @@ Found ${errorCount} error${suffix}.`;
     resolve40(tscConfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join46(cacheDir, "tsc.tsbuildinfo"),
+    join47(cacheDir, "tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildSvelteCheck = async (cacheDir, svelteDir) => {
@@ -17019,8 +17658,8 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m svelte-check is required for Svelte type checking. Install it: bun add -d svelte-check");
     process.exit(1);
   }
-  const svelteTsconfigPath = join46(cacheDir, "tsconfig.svelte-check.json");
-  await writeFile12(svelteTsconfigPath, JSON.stringify({
+  const svelteTsconfigPath = join47(cacheDir, "tsconfig.svelte-check.json");
+  await writeFile13(svelteTsconfigPath, JSON.stringify({
     extends: resolve40("tsconfig.json"),
     files: ABSOLUTE_TYPECHECK_FILES,
     include: [`../${svelteDir}/**/*`]
@@ -17049,7 +17688,7 @@ Found ${errorCount} error${suffix}.`;
     ...new Set(targets.map((config) => config.angularDirectory).filter((dir) => typeof dir === "string" && dir.length > 0))
   ];
   const cacheDir = ".absolutejs";
-  await mkdir12(cacheDir, { recursive: true });
+  await mkdir13(cacheDir, { recursive: true });
   const checks = [];
   checks.push(hasVue ? buildVueTscCheck(cacheDir) : buildTscCheck(cacheDir));
   for (const svelteDir of hasSvelte ? svelteDirs : []) {
@@ -17278,7 +17917,7 @@ import {
   writeFileSync as writeFileSync4
 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join11, resolve as resolve8 } from "path";
+import { join as join12, resolve as resolve8 } from "path";
 
 // src/dev/tunnel/client.ts
 var RECONNECT_DELAY_MS = 2000;
@@ -17867,6 +18506,7 @@ var isAbsoluteAndroidNativeRootInput = (path) => ROOT_NATIVE_INPUTS.has(basename
 
 // src/cli/scripts/dev.ts
 init_iosSimulatorController();
+init_remoteMacProtocol();
 
 // src/mobile/iosNativeWatcher.ts
 init_iosSimulatorController();
@@ -18135,7 +18775,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           }
         }
         if (ready) {
-          const nativeDirectory = join11(normalized.nativeProjectDirectory, "android");
+          const nativeDirectory = join12(normalized.nativeProjectDirectory, "android");
           let createNativeProject = false;
           if (!existsSync5(nativeDirectory)) {
             createNativeProject = await confirmPrompt("Create the managed Capacitor Android project now?");
@@ -18150,7 +18790,18 @@ var dev = async (serverEntry, configPath2, options = {}) => {
       }
       if (normalized.platforms.includes("ios")) {
         if (detectAbsoluteMobileHost() !== "macos") {
-          console.log(cliTag("\x1B[33m", "iOS simulator skipped because it requires macOS and Xcode."));
+          const remote = await getAbsoluteRemoteMacProfile();
+          if (!remote) {
+            console.log(cliTag("\x1B[33m", "iOS simulator skipped. Pair a Mac with `absolute mobile pair mac <name> <user@host>`."));
+          } else {
+            const nativeDirectory = join12(normalized.nativeProjectDirectory, "ios");
+            if (!existsSync5(nativeDirectory)) {
+              console.log(cliTag("\x1B[33m", "The iOS project is missing. Run `absolute mobile init` before remote development."));
+            } else {
+              iosDevProject = createAbsoluteRemoteIosDevProject(normalized, process.cwd(), remote);
+              console.log(cliTag("\x1B[35m", `Using remote Mac ${remote.name} for iOS development.`));
+            }
+          }
         } else {
           let ready = iosToolchainReady(await inspectAbsoluteMobileToolchain());
           if (!ready) {
@@ -18163,7 +18814,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
             }
           }
           if (ready) {
-            const nativeDirectory = join11(normalized.nativeProjectDirectory, "ios");
+            const nativeDirectory = join12(normalized.nativeProjectDirectory, "ios");
             let createNativeProject = false;
             if (!existsSync5(nativeDirectory)) {
               createNativeProject = await confirmPrompt("Create the managed Capacitor iOS project now?");
@@ -18374,10 +19025,11 @@ var dev = async (serverEntry, configPath2, options = {}) => {
   const iosPhaseTimings = {};
   let iosDevState = "waiting-for-server";
   const iosDevAbort = new AbortController;
-  const publishIosReady = (session) => {
+  const iosTelemetryHost = (project) => project.remote ? "remote-macos" : "macos";
+  const publishIosReady = (session, project) => {
     sendTelemetryEvent("mobile:ios-dev-ready", {
       cacheHit: session.nativeCacheHit,
-      host: "macos",
+      host: iosTelemetryHost(project),
       platform: "ios",
       provider: "capacitor",
       startedSimulator: session.startedSimulator,
@@ -18387,30 +19039,43 @@ var dev = async (serverEntry, configPath2, options = {}) => {
       return;
     sendTelemetryEvent("mobile:native-build", {
       buildMs: session.timings.building,
-      host: "macos",
+      host: iosTelemetryHost(project),
       installMs: session.timings.installing,
       platform: "ios",
       provider: "capacitor",
       success: true
     });
   };
-  const openIosDevSession = (iosProject) => startAbsoluteIosDevSession({
-    https: httpsEnabled,
-    port,
-    project: iosProject,
-    signal: iosDevAbort.signal,
-    log: (message) => printNativeOutput(cliTag("\x1B[35m", message)),
-    nativeLog: (entry) => printNativeOutput(iosLogTag(entry)),
-    onPhaseTiming: ({ durationMs, phase }) => {
-      iosPhaseTimings[phase] = (iosPhaseTimings[phase] ?? 0) + durationMs;
-    },
-    onStateChange: (state) => {
-      iosDevState = state;
-      if (state === "ready" || state === "closed")
-        return;
-      printNativeOutput(cliTag("\x1B[35m", `iOS simulator: ${state}.`));
-    }
-  });
+  const openIosDevSession = (iosProject) => {
+    const sessionOptions = {
+      https: httpsEnabled,
+      port,
+      signal: iosDevAbort.signal,
+      log: (message) => printNativeOutput(cliTag("\x1B[35m", message)),
+      nativeLog: (entry) => printNativeOutput(iosLogTag(entry)),
+      onPhaseTiming: ({
+        durationMs,
+        phase
+      }) => {
+        iosPhaseTimings[phase] = (iosPhaseTimings[phase] ?? 0) + durationMs;
+      },
+      onStateChange: (state) => {
+        iosDevState = state;
+        if (state === "ready" || state === "closed")
+          return;
+        printNativeOutput(cliTag("\x1B[35m", `iOS simulator: ${state}.`));
+      }
+    };
+    if (iosProject.remote)
+      return startAbsoluteRemoteIosDevSession({
+        ...sessionOptions,
+        project: iosProject
+      });
+    return startAbsoluteIosDevSession({
+      ...sessionOptions,
+      project: iosProject
+    });
+  };
   const ensureIosNativeWatcher = async (iosProject) => {
     if (iosNativeWatcher)
       return;
@@ -18429,10 +19094,10 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           return;
         }
         iosDevSession = replacement;
-        publishIosReady(replacement);
+        publishIosReady(replacement, iosProject);
         sendTelemetryEvent("mobile:native-rebuild", {
           cacheHit: replacement.nativeCacheHit,
-          host: "macos",
+          host: iosTelemetryHost(iosProject),
           platform: "ios",
           provider: "capacitor",
           rootInputChanged: change.rootInputChanged,
@@ -18444,7 +19109,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
         iosDevState = "failed";
         printNativeOutput(cliTag("\x1B[31m", `iOS native rebuild failed: ${error instanceof Error ? error.message : String(error)}`));
         sendTelemetryEvent("mobile:native-rebuild", {
-          host: "macos",
+          host: iosTelemetryHost(iosProject),
           platform: "ios",
           provider: "capacitor",
           success: false
@@ -18462,7 +19127,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
         return;
       }
       iosDevSession = session;
-      publishIosReady(session);
+      publishIosReady(session, iosProject);
       await ensureIosNativeWatcher(iosProject);
       return;
     }).catch((error) => {
@@ -18470,7 +19135,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
       if (cleaning && error instanceof Error && error.name === "AbortError")
         return;
       sendTelemetryEvent("mobile:ios-dev-failed", {
-        host: "macos",
+        host: iosTelemetryHost(iosProject),
         phase: iosDevState,
         platform: "ios",
         provider: "capacitor",
@@ -18597,7 +19262,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
     }
     return merged;
   };
-  const heapPreloadPath = join11(tmpdir2(), `absolute-heap-${process.pid}.ts`);
+  const heapPreloadPath = join12(tmpdir2(), `absolute-heap-${process.pid}.ts`);
   let heapSnapshotEnabled = false;
   try {
     writeFileSync4(heapPreloadPath, DEV_CHILD_PRELOAD);
@@ -18694,9 +19359,9 @@ var dev = async (serverEntry, configPath2, options = {}) => {
   };
   try {
     const { watch: watch3 } = await import("fs");
-    const { dirname: dirname6 } = await import("path");
+    const { dirname: dirname7 } = await import("path");
     const absServerEntry = resolve8(serverEntry);
-    const serverEntryDir = dirname6(absServerEntry);
+    const serverEntryDir = dirname7(absServerEntry);
     const ROOT_RESTART_DENY = new Set([
       "build",
       "dist",
@@ -18727,7 +19392,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
       if (now - last < 100)
         return;
       recentlyHandled.set(filename, now);
-      scheduleServerRestart(join11(serverEntryDir, filename));
+      scheduleServerRestart(join12(serverEntryDir, filename));
     };
     const recoveryScan = async () => {
       let entries;
@@ -18746,7 +19411,7 @@ var dev = async (serverEntry, configPath2, options = {}) => {
           continue;
         let fileStat;
         try {
-          fileStat = statSync(join11(serverEntryDir, entry.name));
+          fileStat = statSync(join12(serverEntryDir, entry.name));
         } catch {
           continue;
         }
@@ -18850,9 +19515,10 @@ var dev = async (serverEntry, configPath2, options = {}) => {
     if (iosDevSession) {
       await iosDevSession.close();
     } else if (iosDevProject) {
-      await repairAbsoluteIosDevSession(iosDevProject.projectRoot).catch(() => {
-        return;
-      });
+      if (!iosDevProject.remote)
+        await repairAbsoluteIosDevSession(iosDevProject.projectRoot).catch(() => {
+          return;
+        });
     }
     if (paused)
       sendSignal("SIGCONT");
@@ -19252,8 +19918,8 @@ var info = () => {
 
 // src/cli/cache.ts
 init_constants();
-import { mkdir as mkdir5 } from "fs/promises";
-import { join as join12 } from "path";
+import { mkdir as mkdir6 } from "fs/promises";
+import { join as join13 } from "path";
 var {Glob } = globalThis.Bun;
 var CACHE_DIR = ".absolutejs";
 var MAX_FILES_PER_BATCH = 200;
@@ -19305,7 +19971,7 @@ var hashFiles = async (paths) => {
 };
 var loadCache = async (tool) => {
   try {
-    const path = join12(CACHE_DIR, `${tool}.cache.json`);
+    const path = join13(CACHE_DIR, `${tool}.cache.json`);
     const data = await Bun.file(path).json();
     const result = data;
     return result;
@@ -19351,8 +20017,8 @@ var runTool = async (adapter, args) => {
   console.log("\x1B[32m\u2713\x1B[0m Passed");
 };
 var saveCache = async (tool, data) => {
-  await mkdir5(CACHE_DIR, { recursive: true });
-  const path = join12(CACHE_DIR, `${tool}.cache.json`);
+  await mkdir6(CACHE_DIR, { recursive: true });
+  const path = join13(CACHE_DIR, `${tool}.cache.json`);
   await Bun.write(path, JSON.stringify(data, null, "\t"));
 };
 
@@ -20986,7 +21652,7 @@ if (command === "dev") {
   console.error("  prepare [entry] [--outdir dir] Build production assets and server without launching");
   console.error("  start [entry] [--outdir dir] [--prebuilt] Start production server");
   console.error("  compile [entry] [--outdir dir] [--outfile path] Compile standalone executable");
-  console.error("  mobile <init|sync|associations|doctor|test> Manage Capacitor projects, emulator conformance, guided setup, and deep links");
+  console.error("  mobile <init|sync|pair|remotes|doctor|test> Manage Capacitor projects, local or remote simulators, guided setup, and deep links");
   console.error("  config [--port n] Open the unified config UI (ESLint, tsconfig, Prettier)");
   console.error("  db <backup|restore|seed> Backup/restore any Postgres DB (ORM-agnostic, upsert by PK) or run the seed script");
   console.error("  doctor [--fix] [--json] Diagnose the project (bun, type graph, config, framework dirs, env, port)");