@absolutejs/absolute 0.19.0-beta.999 → 0.20.0-beta.1

package/dist/mobile/index.js

@@ -0,0 +1,3058 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/constants.ts
+var ANGULAR_INIT_TIMEOUT_MS = 500, ANSI_ESCAPE_CODE = 27, ANSI_ESCAPE_LENGTH = 3, ASCII_SPACE = 32, BASE_36_RADIX = 36, BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet", TAILWIND_BUN_CSS_WARNING_PATTERN, BODY_SLICE_LENGTH = 2000, BYTES_PER_KILOBYTE = 1024, CLI_ARGS_OFFSET = 3, CSS_ERROR_RESOLVE_DELAY_MS = 50, CSS_MAX_CHECK_ATTEMPTS = 10, CSS_MAX_PARSE_TIMEOUT_MS = 500, CSS_SHEET_READY_TIMEOUT_MS = 100, DEFAULT_CHUNK_SIZE = 16384, DEFAULT_DEBOUNCE_MS = 15, DEFAULT_PORT = 3000, DEV_SERVER_RESTART_DEBOUNCE_MS = 100, DOM_UPDATE_DELAY_MS = 50, FILE_PROTOCOL_PREFIX_LENGTH = 7, FOCUS_ID_PREFIX_LENGTH = 3, FOCUS_IDX_PREFIX_LENGTH = 4, FOCUS_NAME_PREFIX_LENGTH = 5, ESLINT_STUDIO_DEFAULT_HOST = "eslint.absolute.localhost", ESLINT_STUDIO_DEFAULT_PORT = 4099, CONFIG_DEFAULT_HOST = "config.absolute.localhost", CONFIG_DEFAULT_PORT = 4099, HMR_UPDATE_TIMEOUT_MS = 2000, HOOK_SIGNATURE_LENGTH = 12, EXCLUDE_LAST_OFFSET = -1, HTTP_STATUS_OK = 200, HTTP_STATUS_BAD_REQUEST = 400, HTTP_STATUS_NOT_FOUND = 404, HOURS_IN_DAY = 24, HOURS_IN_HALF_DAY = 12, IMAGE_DEFAULT_DEVICE_SIZES, IMAGE_DEFAULT_IMAGE_SIZES, IMAGE_DEFAULT_QUALITY = 75, IMAGE_GLOB_SUFFIX_LENGTH = 2, INSTANCE_PROBE_TIMEOUT_MS = 250, MAX_ERROR_LENGTH = 200, MAX_RECONNECT_ATTEMPTS = 60, MILLISECONDS_IN_A_SECOND = 1000, MINUTES_IN_AN_HOUR = 60, SECONDS_IN_A_MINUTE = 60, MILLISECONDS_IN_A_MINUTE, MILLISECONDS_IN_A_DAY, OVERLAY_FADE_DURATION_MS = 150, PING_INTERVAL_MS = 30000, LIST_LOG_TAIL_MAX_BYTES = 65536, LIST_TUI_COLUMN_GAP = 2, LIST_TUI_DEFAULT_HEIGHT = 28, LIST_TUI_DEFAULT_WIDTH = 100, LIST_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, LIST_TUI_FOOTER_LINE_COUNT = 2, LIST_TUI_MARKER_WIDTH = 2, LIST_TUI_MIN_LOG_HEIGHT = 3, LIST_TUI_MIN_URL_WIDTH = 16, LIST_TUI_RENDER_DEBOUNCE_MS = 16, LIST_TUI_STATUS_MESSAGE_TIMEOUT_MS = 4000, LIST_WATCH_REFRESH_MS = 1000, RAF_BATCH_COUNT = 3, RANDOM_ID_END_INDEX = 11, REBUILD_BATCH_DELAY_MS = 10, REBUILD_RELOAD_DELAY_MS = 200, RECONNECT_INITIAL_DELAY_MS = 500, RECONNECT_POLL_INTERVAL_MS = 300, REACT_STREAM_SLOT_FAST_DELAY_MS = 5, REACT_STREAM_SLOT_SLOW_DELAY_MS = 20, SIGINT_EXIT_CODE = 130, SIGTERM_EXIT_CODE = 143, SVELTE_CSS_LOAD_TIMEOUT_MS = 500, TIME_PRECISION = 2, TWO_THIRDS, UNFOUND_INDEX = -1, WEBSOCKET_NORMAL_CLOSURE = 1000, DEFAULT_WEBSOCKET_IDLE_TIMEOUT_SECONDS = 240, DEFAULT_HTTP_IDLE_TIMEOUT_SECONDS = 240, MAX_HTTP_IDLE_TIMEOUT_SECONDS = 255, WORKSPACE_COMMAND_ARGS_OFFSET = 3, WORKSPACE_FAILURE_LOG_PRINT_LIMIT = 30, WORKSPACE_FAILURE_RECENT_LOG_LIMIT = 60, WORKSPACE_READY_ATTEMPT_TIMEOUT_MS = 5000, WORKSPACE_READY_PROBE_INTERVAL_MS = 250, WORKSPACE_READY_TIMEOUT_MS = 30000, WORKSPACE_SHUTDOWN_TIMEOUT_MS = 1e4, WORKSPACE_TUI_DEFAULT_HEIGHT = 28, WORKSPACE_TUI_DEFAULT_WIDTH = 100, WORKSPACE_TUI_ESCAPE_SEQUENCE_TIMEOUT_MS = 30, WORKSPACE_TUI_FOOTER_LINE_COUNT = 3, WORKSPACE_TUI_MIN_LOG_HEIGHT = 3, WORKSPACE_TUI_MIN_SERVICE_NAME_WIDTH = 7, WORKSPACE_TUI_MIN_TARGET_WIDTH = 8, WORKSPACE_TUI_MIN_WRAP_WIDTH = 12, WORKSPACE_TUI_PROMPT_CURSOR_OFFSET = 3, WORKSPACE_TUI_RECENT_LOG_LIMIT = 40, WORKSPACE_TUI_RENDER_DEBOUNCE_MS = 16, WORKSPACE_TUI_STATUS_WIDTH = 10, WORKSPACE_TUI_TARGET_PADDING_WIDTH = 6, WORKSPACE_TUI_VISIBILITY_WIDTH = 8;
+var init_constants = __esm(() => {
+  TAILWIND_BUN_CSS_WARNING_PATTERN = /invalid @ rule encountered: '@(theme|tailwind|source|utility|variant|custom-variant|apply|reference|plugin|config)'/;
+  IMAGE_DEFAULT_DEVICE_SIZES = [
+    640,
+    750,
+    828,
+    1080,
+    1200,
+    1920,
+    2048,
+    3840
+  ];
+  IMAGE_DEFAULT_IMAGE_SIZES = [16, 32, 48, 64, 96, 128, 256, 384];
+  MILLISECONDS_IN_A_MINUTE = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE;
+  MILLISECONDS_IN_A_DAY = MILLISECONDS_IN_A_SECOND * SECONDS_IN_A_MINUTE * MINUTES_IN_AN_HOUR * HOURS_IN_DAY;
+  TWO_THIRDS = 2 / 3;
+});
+
+// src/utils/getDurationString.ts
+var getDurationString = (duration) => {
+  let durationString;
+  if (duration < MILLISECONDS_IN_A_SECOND) {
+    durationString = `${duration.toFixed(TIME_PRECISION)}ms`;
+  } else if (duration < MILLISECONDS_IN_A_MINUTE) {
+    durationString = `${(duration / MILLISECONDS_IN_A_SECOND).toFixed(TIME_PRECISION)}s`;
+  } else {
+    const totalSeconds = Math.round(duration / MILLISECONDS_IN_A_SECOND);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    durationString = seconds === 0 ? `${minutes}m` : `${minutes}m ${seconds}s`;
+  }
+  return durationString;
+};
+var init_getDurationString = __esm(() => {
+  init_constants();
+});
+
+// src/utils/startupBanner.ts
+var colors, MONTHS, formatTimestamp = () => {
+  const now = new Date;
+  const month = MONTHS[now.getMonth()];
+  const day = now.getDate().toString().padStart(2, "0");
+  let hours = now.getHours();
+  const minutes = now.getMinutes().toString().padStart(2, "0");
+  const seconds = now.getSeconds().toString().padStart(2, "0");
+  const ampm = hours >= HOURS_IN_HALF_DAY ? "PM" : "AM";
+  hours = hours % HOURS_IN_HALF_DAY || HOURS_IN_HALF_DAY;
+  return `${month} ${day} ${hours}:${minutes}:${seconds} ${ampm}`;
+}, startupBanner = (options) => {
+  const {
+    version,
+    readyDuration,
+    buildDuration,
+    port,
+    host,
+    networkUrl,
+    protocol = "http"
+  } = options;
+  const name = `${colors.cyan}${colors.bold}ABSOLUTEJS${colors.reset}`;
+  const ver = `${colors.dim}v${version}${colors.reset}`;
+  const time = `${colors.dim}ready in${colors.reset} ${colors.bold}${getDurationString(readyDuration)}${colors.reset}`;
+  const build = typeof buildDuration === "number" && Number.isFinite(buildDuration) ? ` ${colors.dim}(build ${getDurationString(buildDuration)})${colors.reset}` : "";
+  console.log("");
+  console.log(`  ${name} ${ver}  ${time}${build}`);
+  console.log("");
+  console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Local:${colors.reset}   ${protocol}://${host === "0.0.0.0" ? "localhost" : host}:${port}/`);
+  if (networkUrl) {
+    console.log(`  ${colors.green}\u279C${colors.reset}  ${colors.bold}Network:${colors.reset} ${networkUrl}`);
+  }
+  console.log("");
+};
+var init_startupBanner = __esm(() => {
+  init_constants();
+  init_getDurationString();
+  colors = {
+    bold: "\x1B[1m",
+    cyan: "\x1B[36m",
+    dim: "\x1B[2m",
+    green: "\x1B[32m",
+    reset: "\x1B[0m"
+  };
+  MONTHS = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+});
+
+// src/mobile/artifactStore.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  writeFile
+} from "fs/promises";
+import { join, resolve as resolvePath } from "path";
+
+// src/mobile/releaseArtifact.ts
+import { createHash } from "crypto";
+var ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT = 1;
+var ABSOLUTE_MOBILE_RETAINED_GENERATIONS = 3;
+var SHA_256 = "sha256";
+var RELEASE_ID_PREFIX = "amc_";
+var MODULE_SEGMENT_PARENT = "..";
+var EXPORT_NAME_PATTERN = /^[A-Z_a-z]\w*$/;
+var frameworks = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var isCanonicalRecord = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var enterCanonicalValue = (value, ancestors) => {
+  if (ancestors.has(value)) {
+    throw new TypeError("Compatibility metadata cannot contain cycles.");
+  }
+  ancestors.add(value);
+};
+var normalizeCanonicalArray = (value, ancestors) => {
+  enterCanonicalValue(value, ancestors);
+  const normalized = value.map((item) => normalizeCanonicalValue(item, ancestors));
+  ancestors.delete(value);
+  return normalized;
+};
+var normalizeCanonicalRecord = (value, ancestors) => {
+  enterCanonicalValue(value, ancestors);
+  const normalized = Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [
+    key,
+    normalizeCanonicalValue(item, ancestors)
+  ]));
+  ancestors.delete(value);
+  return normalized;
+};
+var normalizeCanonicalValue = (value, ancestors) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (Array.isArray(value))
+    return normalizeCanonicalArray(value, ancestors);
+  if (isCanonicalRecord(value)) {
+    return normalizeCanonicalRecord(value, ancestors);
+  }
+  throw new TypeError("Compatibility metadata must contain only finite JSON values.");
+};
+var canonicalJson = (value) => JSON.stringify(normalizeCanonicalValue(value, new Set));
+var hashCanonicalValue = (value) => createHash(SHA_256).update(canonicalJson(value)).digest("hex");
+var requireNonEmpty = (value, field) => {
+  if (!value.trim()) {
+    throw new TypeError(`${field} must not be empty.`);
+  }
+  return value;
+};
+var isPageFramework = (value) => typeof value === "string" && frameworks.has(value);
+var readString = (value, field) => {
+  if (typeof value !== "string") {
+    throw new TypeError(`${field} must be a string.`);
+  }
+  return value;
+};
+var parseCompatibilityPage = (value) => {
+  if (!isCanonicalRecord(value) || !isPageFramework(value.framework)) {
+    throw new TypeError("Compatibility artifact contains an invalid page.");
+  }
+  return {
+    bundleHash: readString(value.bundleHash, "page.bundleHash"),
+    bundlePath: readString(value.bundlePath, "page.bundlePath"),
+    contract: readString(value.contract, "page.contract"),
+    framework: value.framework,
+    pageId: readString(value.pageId, "page.pageId"),
+    propsSchemaHash: readString(value.propsSchemaHash, "page.propsSchemaHash")
+  };
+};
+var parseCompatibilityRoute = (value) => {
+  if (!isCanonicalRecord(value) || value.method !== "GET" && value.method !== "HEAD") {
+    throw new TypeError("Compatibility artifact contains an invalid route.");
+  }
+  return {
+    method: value.method,
+    pageId: readString(value.pageId, "route.pageId"),
+    pattern: readString(value.pattern, "route.pattern")
+  };
+};
+var parseCompatibilityProducer = (value) => {
+  if (!isCanonicalRecord(value) || typeof value.bytes !== "number") {
+    throw new TypeError("Compatibility artifact contains an invalid producer.");
+  }
+  return {
+    bundleHash: readString(value.bundleHash, "producer.bundleHash"),
+    bytes: value.bytes,
+    exportName: readString(value.exportName, "producer.exportName"),
+    module: readString(value.module, "producer.module")
+  };
+};
+var validateProducerModule = (module) => {
+  requireNonEmpty(module, "producer.module");
+  const segments = module.split("/");
+  if (module.startsWith("/") || module.includes("\\") || segments.includes(MODULE_SEGMENT_PARENT)) {
+    throw new TypeError("producer.module must be a safe relative path.");
+  }
+  return module;
+};
+var normalizePage = (page) => ({
+  bundleHash: requireNonEmpty(page.bundleHash, "page.bundleHash"),
+  bundlePath: requireNonEmpty(page.bundlePath, "page.bundlePath"),
+  contract: requireNonEmpty(page.contract, "page.contract"),
+  framework: page.framework,
+  pageId: requireNonEmpty(page.pageId, "page.pageId"),
+  propsSchemaHash: requireNonEmpty(page.propsSchemaHash, "page.propsSchemaHash")
+});
+var normalizeRoute = (route) => {
+  if (!route.pattern.startsWith("/")) {
+    throw new TypeError("route.pattern must start with /.");
+  }
+  return {
+    method: route.method,
+    pageId: requireNonEmpty(route.pageId, "route.pageId"),
+    pattern: route.pattern
+  };
+};
+var assertUnique = (values, field) => {
+  if (new Set(values).size !== values.length) {
+    throw new TypeError(`${field} values must be unique.`);
+  }
+};
+var normalizeArtifactContent = (input) => {
+  if (!Number.isSafeInteger(input.generation) || input.generation < 1) {
+    throw new TypeError("generation must be a positive safe integer.");
+  }
+  if (!Number.isSafeInteger(input.producer.bytes) || input.producer.bytes < 1) {
+    throw new TypeError("producer.bytes must be a positive safe integer.");
+  }
+  const pages = input.pages.map(normalizePage).sort((left, right) => left.pageId.localeCompare(right.pageId));
+  const routes = input.routes.map(normalizeRoute).sort((left, right) => `${left.pattern}:${left.method}`.localeCompare(`${right.pattern}:${right.method}`));
+  assertUnique(pages.map(({ pageId }) => pageId), "page.pageId");
+  assertUnique(routes.map(({ method, pattern }) => `${method}:${pattern}`), "route method and pattern");
+  const pageIds = new Set(pages.map(({ pageId }) => pageId));
+  const missingPage = routes.find(({ pageId }) => !pageIds.has(pageId));
+  if (missingPage) {
+    throw new TypeError(`Route ${missingPage.pattern} references unknown page ${missingPage.pageId}.`);
+  }
+  if (!EXPORT_NAME_PATTERN.test(input.producer.exportName)) {
+    throw new TypeError("producer.exportName must be a JavaScript identifier.");
+  }
+  return {
+    appBuild: requireNonEmpty(input.appBuild, "appBuild"),
+    appId: requireNonEmpty(input.appId, "appId"),
+    format: ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT,
+    generation: input.generation,
+    pages,
+    producer: {
+      bundleHash: requireNonEmpty(input.producer.bundleHash, "producer.bundleHash"),
+      bytes: input.producer.bytes,
+      exportName: input.producer.exportName,
+      module: validateProducerModule(input.producer.module)
+    },
+    routes,
+    runtime: requireNonEmpty(input.runtime, "runtime")
+  };
+};
+var createAbsoluteMobileCompatibilityArtifact = (input) => {
+  const content = normalizeArtifactContent(input);
+  return {
+    ...content,
+    releaseId: `${RELEASE_ID_PREFIX}${hashCanonicalValue(content)}`
+  };
+};
+var hashAbsoluteMobilePropsSchema = (schema) => hashCanonicalValue(schema);
+var parseAbsoluteMobileCompatibilityArtifact = (value) => {
+  if (!isCanonicalRecord(value) || value.format !== ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT || typeof value.generation !== "number" || !Array.isArray(value.pages) || !Array.isArray(value.routes)) {
+    throw new TypeError("Invalid mobile compatibility artifact.");
+  }
+  const releaseId = readString(value.releaseId, "releaseId");
+  const artifact = createAbsoluteMobileCompatibilityArtifact({
+    appBuild: readString(value.appBuild, "appBuild"),
+    appId: readString(value.appId, "appId"),
+    generation: value.generation,
+    pages: value.pages.map(parseCompatibilityPage),
+    producer: parseCompatibilityProducer(value.producer),
+    routes: value.routes.map(parseCompatibilityRoute),
+    runtime: readString(value.runtime, "runtime")
+  });
+  if (artifact.releaseId !== releaseId) {
+    throw new TypeError("Mobile compatibility artifact integrity failed.");
+  }
+  return artifact;
+};
+var resolveAbsoluteMobileCompatibilityRelease = (client, artifacts) => {
+  const artifact = artifacts.find((candidate) => candidate.appBuild === client.appBuild && candidate.runtime === client.runtime);
+  if (!artifact) {
+    return {
+      kind: "upgrade-required",
+      result: {
+        kind: "upgrade-required",
+        pageId: client.pageId,
+        reason: "app-release"
+      }
+    };
+  }
+  const page = artifact.pages.find((candidate) => candidate.pageId === client.pageId && candidate.bundleHash === client.pageBundle && client.pageContracts.includes(candidate.contract));
+  if (!page) {
+    return {
+      kind: "upgrade-required",
+      result: {
+        kind: "upgrade-required",
+        pageId: client.pageId,
+        reason: "page-contract",
+        supportedContracts: artifact.pages.filter(({ pageId }) => pageId === client.pageId).map(({ contract }) => contract)
+      }
+    };
+  }
+  return { artifact, kind: "retained", page };
+};
+var retainAbsoluteMobileCompatibilityArtifacts = (artifacts) => {
+  const appIds = new Set(artifacts.map(({ appId }) => appId));
+  if (appIds.size > 1) {
+    throw new TypeError("Cannot retain compatibility artifacts for multiple apps.");
+  }
+  assertUnique(artifacts.map(({ appBuild }) => appBuild), "appBuild");
+  assertUnique(artifacts.map(({ generation }) => String(generation)), "generation");
+  return [...artifacts].sort((left, right) => right.generation - left.generation).slice(0, ABSOLUTE_MOBILE_RETAINED_GENERATIONS);
+};
+
+// src/mobile/artifactStore.ts
+var DEFAULT_MAX_PRODUCER_BYTES = 134217728;
+var SHA_2562 = "sha256";
+var ARTIFACT_FILE = "artifact.json";
+var RELEASE_ID_PATTERN = /^amc_[a-f0-9]{64}$/;
+var DEFAULT_BLOB_PREFIX = "absolutejs/mobile-compatibility";
+var hashBlob = async (blob) => {
+  const bytes = new Uint8Array(await blob.arrayBuffer());
+  return createHash2(SHA_2562).update(bytes).digest("hex");
+};
+var blobFromBytes = (bytes) => {
+  const buffer = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(buffer).set(bytes);
+  return new Blob([buffer]);
+};
+var errorHasCode = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
+var appDirectoryName = (appId) => createHash2(SHA_2562).update(appId).digest("hex");
+var requireReleaseId = (releaseId) => {
+  if (!RELEASE_ID_PATTERN.test(releaseId)) {
+    throw new TypeError("Invalid mobile compatibility release id.");
+  }
+  return releaseId;
+};
+var readStoredArtifact = async (releaseDirectory) => {
+  const serialized = await readFile(join(releaseDirectory, ARTIFACT_FILE), "utf8");
+  const parsed = JSON.parse(serialized);
+  return parseAbsoluteMobileCompatibilityArtifact(parsed);
+};
+var validateStoredIdentity = (artifact, appId, releaseId) => {
+  if (artifact.appId !== appId || artifact.releaseId !== releaseId) {
+    throw new TypeError("Stored mobile compatibility identity does not match.");
+  }
+  return artifact;
+};
+var listBlobKeys = async (store, prefix, cursor, keys = []) => {
+  const result = await store.list({ cursor, prefix });
+  const collected = [...keys, ...result.objects.map(({ key }) => key)];
+  if (!result.truncated)
+    return collected;
+  if (!result.cursor) {
+    throw new TypeError("Truncated blob listing did not provide a cursor.");
+  }
+  return listBlobKeys(store, prefix, result.cursor, collected);
+};
+var normalizeBlobPrefix = (prefix) => {
+  const normalized = prefix.replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized.split("/").includes("..")) {
+    throw new TypeError("Mobile compatibility blob prefix is invalid.");
+  }
+  return normalized;
+};
+var carryForwardAbsoluteMobileCompatibilityReleases = async (input) => {
+  await verifyAbsoluteMobileCompatibilityProducer(input.current);
+  await input.store.write(input.current);
+  const available = await input.store.list(input.current.artifact.appId);
+  const retained = retainAbsoluteMobileCompatibilityArtifacts(available);
+  if (retained[0]?.releaseId !== input.current.artifact.releaseId) {
+    throw new TypeError("Current mobile release generation must be newer than stored history.");
+  }
+  const releases = await Promise.all(retained.map(({ releaseId }) => input.store.read(input.current.artifact.appId, releaseId)));
+  return Promise.all(releases.map((release) => {
+    if (!release) {
+      throw new TypeError("Compatibility store listed a release it could not read.");
+    }
+    return verifyAbsoluteMobileCompatibilityProducer(release);
+  }));
+};
+var createAbsoluteMobileBlobArtifactStore = (options) => {
+  const prefix = normalizeBlobPrefix(options.prefix ?? DEFAULT_BLOB_PREFIX);
+  const maxProducerBytes = options.maxProducerBytes ?? DEFAULT_MAX_PRODUCER_BYTES;
+  const appPrefix = (appId) => `${prefix}/${appDirectoryName(appId)}/releases`;
+  const releasePrefix = (appId, releaseId) => `${appPrefix(appId)}/${requireReleaseId(releaseId)}`;
+  const artifactKey = (appId, releaseId) => `${releasePrefix(appId, releaseId)}/${ARTIFACT_FILE}`;
+  const producerKey = (artifact) => `${releasePrefix(artifact.appId, artifact.releaseId)}/${artifact.producer.module}`;
+  const readArtifact = async (appId, releaseId) => {
+    const bytes = await options.store.get(artifactKey(appId, releaseId));
+    if (!bytes)
+      return null;
+    const parsed = JSON.parse(new TextDecoder().decode(bytes));
+    return validateStoredIdentity(parseAbsoluteMobileCompatibilityArtifact(parsed), appId, releaseId);
+  };
+  return {
+    delete: async (appId, releaseId) => {
+      const artifact = await readArtifact(appId, releaseId);
+      if (artifact)
+        await options.store.delete(producerKey(artifact));
+      await options.store.delete(artifactKey(appId, releaseId));
+    },
+    list: async (appId) => {
+      const releaseRoot = `${appPrefix(appId)}/`;
+      const keys = await listBlobKeys(options.store, releaseRoot);
+      const releaseIds = keys.filter((key) => key.endsWith(`/${ARTIFACT_FILE}`)).map((key) => key.slice(releaseRoot.length).split("/")[0]).filter((releaseId) => typeof releaseId === "string" && RELEASE_ID_PATTERN.test(releaseId));
+      const artifacts = await Promise.all([...new Set(releaseIds)].map((releaseId) => readArtifact(appId, releaseId)));
+      return artifacts.filter((artifact) => artifact !== null).sort((left, right) => right.generation - left.generation);
+    },
+    read: async (appId, releaseId) => {
+      const artifact = await readArtifact(appId, releaseId);
+      if (!artifact)
+        return null;
+      const bytes = await options.store.get(producerKey(artifact));
+      if (!bytes) {
+        throw new TypeError("Mobile compatibility artifact is missing its producer.");
+      }
+      return { artifact, producer: blobFromBytes(bytes) };
+    },
+    write: async (release) => {
+      const artifact = parseAbsoluteMobileCompatibilityArtifact(release.artifact);
+      const validated = await verifyAbsoluteMobileCompatibilityProducer({ artifact, producer: release.producer }, maxProducerBytes);
+      await options.store.put(producerKey(validated.artifact), validated.producer.stream(), {
+        contentType: "text/javascript; charset=utf-8",
+        maxBytes: maxProducerBytes,
+        metadata: {
+          appId: validated.artifact.appId,
+          releaseId: validated.artifact.releaseId,
+          sha256: validated.artifact.producer.bundleHash
+        }
+      });
+      await options.store.put(artifactKey(validated.artifact.appId, validated.artifact.releaseId), `${JSON.stringify(validated.artifact, null, "\t")}
+`, { contentType: "application/json" });
+    }
+  };
+};
+var createAbsoluteMobileFileArtifactStore = (options) => {
+  const root = resolvePath(options.root);
+  const maxProducerBytes = options.maxProducerBytes ?? DEFAULT_MAX_PRODUCER_BYTES;
+  const appDirectory = (appId) => join(root, appDirectoryName(appId));
+  const releaseDirectory = (appId, releaseId) => join(appDirectory(appId), requireReleaseId(releaseId));
+  const acceptExistingRelease = async (error, artifact) => {
+    if (!errorHasCode(error, "EEXIST") && !errorHasCode(error, "ENOTEMPTY")) {
+      return false;
+    }
+    const existing = await readStoredArtifact(releaseDirectory(artifact.appId, artifact.releaseId));
+    return existing.releaseId === artifact.releaseId;
+  };
+  return {
+    delete: async (appId, releaseId) => {
+      await rm(releaseDirectory(appId, releaseId), {
+        force: true,
+        recursive: true
+      });
+    },
+    list: async (appId) => {
+      let entries;
+      try {
+        entries = await readdir(appDirectory(appId), {
+          withFileTypes: true
+        });
+      } catch (error) {
+        if (errorHasCode(error, "ENOENT"))
+          return [];
+        throw error;
+      }
+      const artifacts = await Promise.all(entries.filter((entry) => entry.isDirectory() && RELEASE_ID_PATTERN.test(entry.name)).map(async ({ name }) => validateStoredIdentity(await readStoredArtifact(releaseDirectory(appId, name)), appId, name)));
+      return artifacts.sort((left, right) => right.generation - left.generation);
+    },
+    read: async (appId, releaseId) => {
+      const directory = releaseDirectory(appId, releaseId);
+      let artifact;
+      try {
+        artifact = validateStoredIdentity(await readStoredArtifact(directory), appId, releaseId);
+      } catch (error) {
+        if (errorHasCode(error, "ENOENT"))
+          return null;
+        throw error;
+      }
+      return {
+        artifact,
+        producer: Bun.file(join(directory, artifact.producer.module))
+      };
+    },
+    write: async (release) => {
+      const validatedArtifact = parseAbsoluteMobileCompatibilityArtifact(release.artifact);
+      const validated = await verifyAbsoluteMobileCompatibilityProducer({ artifact: validatedArtifact, producer: release.producer }, maxProducerBytes);
+      const parent = appDirectory(validated.artifact.appId);
+      await mkdir(parent, { recursive: true });
+      const staging = await mkdtemp(join(parent, ".stage-"));
+      const producerPath = join(staging, validated.artifact.producer.module);
+      try {
+        await mkdir(resolvePath(producerPath, ".."), {
+          recursive: true
+        });
+        await Promise.all([
+          writeFile(join(staging, ARTIFACT_FILE), `${JSON.stringify(validated.artifact, null, "\t")}
+`),
+          writeFile(producerPath, new Uint8Array(await validated.producer.arrayBuffer()))
+        ]);
+        await rename(staging, releaseDirectory(validated.artifact.appId, validated.artifact.releaseId));
+      } catch (error) {
+        await rm(staging, { force: true, recursive: true });
+        if (await acceptExistingRelease(error, validated.artifact))
+          return;
+        throw error;
+      }
+    }
+  };
+};
+var verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes = DEFAULT_MAX_PRODUCER_BYTES) => {
+  const { artifact, producer } = release;
+  if (producer.size !== artifact.producer.bytes || producer.size > maxProducerBytes) {
+    throw new TypeError("Mobile compatibility producer size does not match its artifact.");
+  }
+  if (await hashBlob(producer) !== artifact.producer.bundleHash) {
+    throw new TypeError("Mobile compatibility producer hash does not match its artifact.");
+  }
+  return release;
+};
+// src/mobile/androidRelease.ts
+import { createHash as createHash3 } from "crypto";
+import {
+  access as access3,
+  copyFile as copyFile2,
+  mkdir as mkdir3,
+  mkdtemp as mkdtemp2,
+  readFile as readFile4,
+  rename as rename4,
+  rm as rm3,
+  stat,
+  writeFile as writeFile4
+} from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, relative as relative3, resolve as resolve3, sep as sep2 } from "path";
+
+// src/mobile/emulatorDoctor.ts
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/cli/utils.ts
+import { existsSync, readFileSync } from "fs";
+init_constants();
+init_startupBanner();
+var isWSLEnvironment = () => {
+  try {
+    const release = readFileSync("/proc/version", "utf-8");
+    return /microsoft|wsl/i.test(release);
+  } catch {
+    return false;
+  }
+};
+
+// src/mobile/emulatorDoctor.ts
+var windowsPathToWsl = (path) => {
+  const match = /^([a-z]):[\\/](.*)$/i.exec(path.trim());
+  if (!match)
+    return path.trim().replaceAll("\\", "/");
+  return `/mnt/${match[1]?.toLowerCase()}/${match[2]?.replaceAll("\\", "/")}`;
+};
+var windowsLocalAppDataFromWsl = () => {
+  try {
+    const result = Bun.spawnSync(["cmd.exe", "/d", "/c", "echo", "%LOCALAPPDATA%"], { stderr: "ignore", stdout: "pipe" });
+    if (result.exitCode !== 0)
+      return;
+    const output = result.stdout.toString().trim();
+    if (!output || output === "%LOCALAPPDATA%")
+      return;
+    return windowsPathToWsl(output);
+  } catch {
+    return;
+  }
+};
+var absoluteManagedAndroidSdkRoot = (host, env = process.env) => {
+  if (host === "windows") {
+    return join2(env.LOCALAPPDATA ?? join2(homedir(), "AppData", "Local"), "AbsoluteJS", "Android", "Sdk");
+  }
+  if (host === "wsl") {
+    const localAppData = windowsLocalAppDataFromWsl();
+    if (localAppData) {
+      return join2(localAppData, "AbsoluteJS", "Android", "Sdk");
+    }
+  }
+  return join2(homedir(), ".absolutejs", "android-sdk");
+};
+var detectAbsoluteMobileHost = (platform = process.platform, wsl = isWSLEnvironment()) => {
+  if (platform === "darwin")
+    return "macos";
+  if (platform === "win32")
+    return "windows";
+  if (platform === "linux" && wsl)
+    return "wsl";
+  return "linux";
+};
+
+// src/mobile/androidEmulatorController.ts
+import {
+  access as access2,
+  copyFile,
+  lstat,
+  mkdir as mkdir2,
+  readFile as readFile3,
+  readdir as readdir2,
+  readlink,
+  realpath,
+  rename as rename3,
+  rm as rm2,
+  writeFile as writeFile3
+} from "fs/promises";
+import {
+  dirname,
+  isAbsolute,
+  join as join3,
+  relative as relative2,
+  resolve as resolve2,
+  sep,
+  win32
+} from "path";
+
+// src/mobile/capacitorProject.ts
+import { access, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { relative, resolve } from "path";
+var CONFIG_FILE = "capacitor.config.ts";
+var portableRelative = (root, path) => relative(root, path).replaceAll("\\", "/");
+var capacitorConfigSource = (config, projectRoot) => `import type { CapacitorConfig } from '@capacitor/cli';
+
+const config: CapacitorConfig = {
+	appId: ${JSON.stringify(config.appId)},
+	appName: ${JSON.stringify(config.appName)},
+	webDir: ${JSON.stringify(portableRelative(projectRoot, config.bundleDirectory))},
+	android: {
+		path: ${JSON.stringify(portableRelative(projectRoot, `${config.nativeProjectDirectory}/android`))}
+	},
+	ios: {
+		path: ${JSON.stringify(portableRelative(projectRoot, `${config.nativeProjectDirectory}/ios`))}
+	}
+};
+
+export default config;
+`;
+var exists = async (path) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var writeAbsoluteCapacitorConfig = async (config, options) => {
+  const projectRoot = resolve(options.projectRoot);
+  const destination = resolve(projectRoot, CONFIG_FILE);
+  const source = capacitorConfigSource(config, projectRoot);
+  if (await exists(destination)) {
+    const current = await readFile2(destination, "utf8");
+    if (current === source)
+      return { changed: false, path: destination };
+    if (!options.force) {
+      throw new TypeError(`${CONFIG_FILE} already exists and differs; rerun with --force only after reviewing it.`);
+    }
+  }
+  const temporary = `${destination}.${crypto.randomUUID()}.tmp`;
+  await writeFile2(temporary, source, { flag: "wx" });
+  await rename2(temporary, destination);
+  return { changed: true, path: destination };
+};
+
+// src/mobile/androidEmulatorController.ts
+init_getDurationString();
+var HASH_RADIX = 16;
+var CAPACITOR_PROJECT_DIRECTORY_PATTERN = /project\(['"](:[^'"]+)['"]\)\.projectDir\s*=\s*new File\(['"]([^'"]+)['"]\)/gu;
+var pathExists = async (path) => {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var forwardCommandOutput = (stream, destination) => stream.pipeTo(new WritableStream({
+  write: (chunk) => {
+    destination.write(chunk);
+  }
+}));
+var runCommand = async (command, options = {}) => {
+  const subprocess = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env,
+    signal: options.signal,
+    stderr: "pipe",
+    stdin: "ignore",
+    stdout: "pipe"
+  });
+  const [exitCode] = await Promise.all([
+    subprocess.exited,
+    forwardCommandOutput(subprocess.stdout, process.stdout),
+    forwardCommandOutput(subprocess.stderr, process.stderr)
+  ]);
+  return exitCode;
+};
+var captureCommand = (command, options = {}) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      cwd: options.cwd,
+      env: options.env,
+      stderr: "pipe",
+      stdout: "pipe"
+    });
+    return {
+      exitCode: result.exitCode,
+      stderr: result.stderr.toString(),
+      stdout: result.stdout.toString()
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : String(error),
+      stdout: ""
+    };
+  }
+};
+var ASCII_ESCAPE = 27;
+var ANSI_SEQUENCE_PATTERN = new RegExp(`${String.fromCharCode(ASCII_ESCAPE)}(?:\\[[0-?]*[ -/]*[@-~]|[@-_])`, "gu");
+var requireSuccess = async (command, label, run, options) => {
+  const exitCode = await run(command, options);
+  throwIfAborted(options?.signal);
+  if (exitCode !== 0)
+    throw new Error(`${label} failed (exit ${exitCode}).`);
+};
+var throwIfAborted = (signal) => {
+  if (!signal?.aborted)
+    return;
+  throw new DOMException("Android development startup was cancelled.", "AbortError");
+};
+var windowsPathFromWsl = (path, capture) => {
+  const result = capture(["wslpath", "-w", path]);
+  if (result.exitCode !== 0 || !result.stdout.trim()) {
+    throw new Error(`Could not translate WSL path for Windows: ${path}`);
+  }
+  return result.stdout.trim();
+};
+var mirroredCapacitorDependencies = async (project, capture) => {
+  const settingsPath = join3(project.nativeDirectory, "capacitor.settings.gradle");
+  const settings = await readFile3(settingsPath, "utf8");
+  const dependencies = [];
+  const rewrittenSettings = settings.replace(CAPACITOR_PROJECT_DIRECTORY_PATTERN, (_statement, projectName, sourcePath) => {
+    const name = projectName.slice(1).replaceAll(/[^a-zA-Z0-9_.-]/gu, "_");
+    const source = resolve2(project.nativeDirectory, sourcePath);
+    dependencies.push({
+      name,
+      windowsSource: windowsPathFromWsl(source, capture)
+    });
+    return `project('${projectName}').projectDir = new File('./.absolutejs-dependencies/${name}')`;
+  });
+  if (dependencies.length === 0) {
+    throw new Error("Capacitor Android settings did not declare any native dependencies.");
+  }
+  return { dependencies, rewrittenSettings };
+};
+var encodedWindowsGradleCommand = (windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task) => {
+  const sourceDirectory = Buffer.from(windowsSource, "utf8").toString("base64");
+  const buildDirectory = Buffer.from(windowsDirectory, "utf8").toString("base64");
+  const androidRoot = Buffer.from(windowsAndroidRoot, "utf8").toString("base64");
+  const dependencyData = Buffer.from(JSON.stringify(dependencies), "utf8").toString("base64");
+  const settingsData = Buffer.from(rewrittenSettings, "utf8").toString("base64");
+  const source = [
+    "$ErrorActionPreference = 'Stop'",
+    `$source = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${sourceDirectory}'))`,
+    `$directory = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${buildDirectory}'))`,
+    `$androidHome = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${androidRoot}'))`,
+    `$dependencies = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${dependencyData}')) | ConvertFrom-Json`,
+    `$settings = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${settingsData}'))`,
+    "$env:ANDROID_HOME = $androidHome",
+    "$env:ANDROID_SDK_ROOT = $androidHome",
+    "New-Item -ItemType Directory -Force -Path $directory | Out-Null",
+    "& robocopy.exe $source $directory /MIR /XD .gradle build .absolutejs-dependencies /NFL /NDL /NJH /NJS /NP",
+    "$copyExit = $LASTEXITCODE",
+    "if ($copyExit -ge 8) { exit $copyExit }",
+    "foreach ($dependency in @($dependencies)) { $target = Join-Path $directory ('.absolutejs-dependencies\\' + $dependency.name); New-Item -ItemType Directory -Force -Path $target | Out-Null; & robocopy.exe $dependency.windowsSource $target /MIR /XD .gradle build /NFL /NDL /NJH /NJS /NP; if ($LASTEXITCODE -ge 8) { exit $LASTEXITCODE } }",
+    "[IO.File]::WriteAllText((Join-Path $directory 'capacitor.settings.gradle'), $settings)",
+    "$wrapper = Join-Path $directory 'gradlew.bat'",
+    `& $wrapper --no-daemon --console=plain -p $directory ${task}`,
+    "if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }",
+    "exit 0"
+  ].join("; ");
+  return Buffer.from(source, "utf16le").toString("base64");
+};
+var gradleArtifactPath = (nativeDirectory, task, windows = false) => {
+  const pathJoin = windows ? win32.join : join3;
+  if (task === "assembleDebug") {
+    return pathJoin(nativeDirectory, "app", "build", "outputs", "apk", "debug", "app-debug.apk");
+  }
+  if (task === "assembleRelease") {
+    return pathJoin(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release.apk");
+  }
+  return pathJoin(nativeDirectory, "app", "build", "outputs", "bundle", "release", "app-release.aab");
+};
+var resolveGradleArtifactPath = async (nativeDirectory, task) => {
+  const primary = gradleArtifactPath(nativeDirectory, task);
+  if (task !== "assembleRelease" || await pathExists(primary)) {
+    return primary;
+  }
+  return join3(nativeDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk");
+};
+var buildAbsoluteAndroidGradleArtifact = async (options) => {
+  const { project, task } = options;
+  const capture = options.capture ?? captureCommand;
+  const run = options.run ?? runCommand;
+  const env = options.env ?? process.env;
+  if (project.host === "wsl") {
+    const windowsSource = windowsPathFromWsl(project.nativeDirectory, capture);
+    const buildId = Bun.hash(project.projectRoot).toString(HASH_RADIX);
+    const managedBuildDirectory = resolve2(project.androidRoot, "..", "..", "Builds", `${project.config.appId}-${buildId}`);
+    const windowsDirectory = windowsPathFromWsl(managedBuildDirectory, capture);
+    const windowsAndroidRoot = windowsPathFromWsl(project.androidRoot, capture);
+    const { dependencies, rewrittenSettings } = await mirroredCapacitorDependencies(project, capture);
+    await requireSuccess([
+      "powershell.exe",
+      "-NoProfile",
+      "-EncodedCommand",
+      encodedWindowsGradleCommand(windowsSource, windowsDirectory, windowsAndroidRoot, dependencies, rewrittenSettings, task)
+    ], "Android Gradle build", run, { env, signal: options.signal });
+    const artifactPath2 = await resolveGradleArtifactPath(managedBuildDirectory, task);
+    const unsigned = artifactPath2.endsWith("-unsigned.apk");
+    return {
+      artifactPath: artifactPath2,
+      installPath: unsigned ? win32.join(windowsDirectory, "app", "build", "outputs", "apk", "release", "app-release-unsigned.apk") : gradleArtifactPath(windowsDirectory, task, true)
+    };
+  }
+  const wrapper = project.host === "windows" ? "gradlew.bat" : "./gradlew";
+  await requireSuccess([wrapper, "--no-daemon", "--console=plain", task], "Android Gradle build", run, { cwd: project.nativeDirectory, env, signal: options.signal });
+  const artifactPath = await resolveGradleArtifactPath(project.nativeDirectory, task);
+  return { artifactPath, installPath: artifactPath };
+};
+
+// src/mobile/androidRelease.ts
+var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var requireManifest = (value) => {
+  if (!isRecord(value) || typeof value.appBuild !== "string" || typeof value.appId !== "string" || typeof value.runtime !== "string") {
+    throw new TypeError("Invalid embedded AbsoluteJS mobile manifest.");
+  }
+  return {
+    appBuild: value.appBuild,
+    appId: value.appId,
+    runtime: value.runtime
+  };
+};
+var pathExists2 = async (path) => {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var defaultCapture = (command, options = {}) => {
+  try {
+    const result = Bun.spawnSync(command, {
+      cwd: options.cwd,
+      env: options.env,
+      stderr: "pipe",
+      stdin: "ignore",
+      stdout: "pipe"
+    });
+    return {
+      exitCode: result.exitCode,
+      stderr: result.stderr.toString(),
+      stdout: result.stdout.toString()
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stderr: error instanceof Error ? error.message : String(error),
+      stdout: ""
+    };
+  }
+};
+var verifyAabSignature = (artifactPath, capture, jarsigner) => {
+  const executable = jarsigner === undefined ? Bun.which("jarsigner") : jarsigner;
+  if (!executable)
+    return null;
+  const result = capture([
+    executable,
+    "-J-Duser.language=en",
+    "-J-Duser.country=US",
+    "-verify",
+    artifactPath
+  ]);
+  return result.exitCode === 0 && /jar verified/iu.test(result.stdout);
+};
+var sha256File = async (path) => createHash3("sha256").update(await readFile4(path)).digest("hex");
+var safeOutputDirectory = (projectRoot, requested) => {
+  const root = resolve3(projectRoot);
+  const output = resolve3(root, requested ?? ".absolutejs/mobile/releases/android");
+  const projectRelative = relative3(root, output);
+  if (projectRelative === ".." || projectRelative.startsWith(`..${sep2}`) || isAbsolute2(projectRelative)) {
+    throw new TypeError("mobile build --outdir must remain inside the project.");
+  }
+  return output;
+};
+var installRelease = async (artifactPath, metadata, outputRoot) => {
+  const releaseRoot = join4(outputRoot, metadata.releaseId);
+  const artifactName = "app-release.aab";
+  const destination = join4(releaseRoot, artifactName);
+  if (await pathExists2(releaseRoot)) {
+    const existing = requireManifestIdentity(JSON.parse(await readFile4(join4(releaseRoot, "release.json"), "utf8")), metadata);
+    const [installedBytes, installedSha256] = await Promise.all([
+      stat(destination).then(({ size }) => size),
+      sha256File(destination)
+    ]);
+    if (installedBytes !== metadata.bytes || installedSha256 !== metadata.sha256) {
+      throw new TypeError(`Immutable Android release ${metadata.releaseId} artifact is missing or modified.`);
+    }
+    return { artifactPath: destination, metadata: existing, releaseRoot };
+  }
+  await mkdir3(dirname2(releaseRoot), { recursive: true });
+  const staging = await mkdtemp2(join4(dirname2(releaseRoot), ".android-stage-"));
+  try {
+    await copyFile2(artifactPath, join4(staging, artifactName));
+    const complete = {
+      ...metadata,
+      artifact: artifactName
+    };
+    await writeFile4(join4(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+`, { flag: "wx" });
+    await rename4(staging, releaseRoot);
+    return { artifactPath: destination, metadata: complete, releaseRoot };
+  } finally {
+    await rm3(staging, { force: true, recursive: true }).catch(() => {
+      return;
+    });
+  }
+};
+var requireManifestIdentity = (value, expected) => {
+  if (!isRecord(value)) {
+    throw new TypeError("Existing Android release metadata is invalid.");
+  }
+  const { artifact } = value;
+  if (artifact !== "app-release.aab" || Object.entries(expected).some(([key, expectedValue]) => Reflect.get(value, key) !== expectedValue)) {
+    throw new TypeError(`Immutable Android release ${expected.releaseId} does not match its content.`);
+  }
+  return { ...expected, artifact };
+};
+var buildAbsoluteAndroidRelease = async (options) => {
+  const projectRoot = resolve3(options.projectRoot);
+  const host = options.host ?? detectAbsoluteMobileHost();
+  const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host);
+  const nativeDirectory = join4(options.config.nativeProjectDirectory, "android");
+  const { artifactPath } = await buildAbsoluteAndroidGradleArtifact({
+    capture: options.capture,
+    project: {
+      androidRoot,
+      config: options.config,
+      host,
+      nativeDirectory,
+      projectRoot
+    },
+    run: options.run,
+    task: "bundleRelease"
+  });
+  if (!await pathExists2(artifactPath)) {
+    throw new TypeError(`Android Gradle did not produce the expected App Bundle: ${artifactPath}`);
+  }
+  const capture = options.capture ?? defaultCapture;
+  const signed = verifyAabSignature(artifactPath, capture, options.jarsigner);
+  if (signed === null && !options.allowUnsigned) {
+    throw new TypeError("Could not verify the Android App Bundle signature because jarsigner is unavailable. Install a JDK, or use --unsigned only for a non-publishable build.");
+  }
+  if (!signed && !options.allowUnsigned) {
+    throw new TypeError("Android Gradle produced an unsigned App Bundle. Configure the release signingConfig in the source-owned Android project (prefer external Gradle properties), or pass --unsigned only for a non-publishable build.");
+  }
+  const manifest = requireManifest(JSON.parse(await readFile4(join4(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.");
+  }
+  const [bytes, sha256] = await Promise.all([
+    stat(artifactPath).then(({ size }) => size),
+    sha256File(artifactPath)
+  ]);
+  const releaseId = `amobile_android_${sha256}`;
+  const metadata = {
+    appBuild: manifest.appBuild,
+    appId: manifest.appId,
+    bytes,
+    engine: "capacitor",
+    format: ABSOLUTE_ANDROID_RELEASE_FORMAT,
+    platform: "android",
+    releaseId,
+    runtime: manifest.runtime,
+    sha256,
+    signed: signed === true,
+    type: "aab"
+  };
+  return installRelease(artifactPath, metadata, safeOutputDirectory(projectRoot, options.outputDirectory));
+};
+// src/mobile/associationFiles.ts
+import {
+  access as access4,
+  mkdir as mkdir4,
+  readFile as readFile5,
+  rename as rename5,
+  rm as rm4,
+  writeFile as writeFile5
+} from "fs/promises";
+import { resolve as resolve5 } from "path";
+import { Elysia } from "elysia";
+
+// src/mobile/config.ts
+import { resolve as resolve4 } from "path";
+var APP_ID_PATTERN = /^[A-Za-z][\w]*(?:\.[A-Za-z][\w]*)+$/;
+var SCHEME_PATTERN = /^[a-z][a-z0-9+.-]*$/;
+var APPLE_APP_ID_PREFIX_PATTERN = /^[A-Z0-9]{10}$/;
+var CERTIFICATE_FINGERPRINT_PATTERN = /^[0-9A-F]{64}$/;
+var HOSTNAME_PATTERN = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?))*$/;
+var resolveProjectPath = (projectRoot, value, field) => {
+  const root = resolve4(projectRoot);
+  const path = resolve4(root, value);
+  if (path !== root && !path.startsWith(`${root}/`)) {
+    throw new TypeError(`${field} must remain inside the project root.`);
+  }
+  return path;
+};
+var requireText = (value, field) => {
+  const normalized = value.trim();
+  if (!normalized)
+    throw new TypeError(`${field} must not be empty.`);
+  return normalized;
+};
+var normalizeEntry = (entry) => {
+  const normalized = requireText(entry ?? "/", "mobile.entry");
+  if (!normalized.startsWith("/") || normalized.startsWith("//")) {
+    throw new TypeError("mobile.entry must be an absolute application path.");
+  }
+  return normalized;
+};
+var normalizeProductionOrigin = (value) => {
+  const parsed = new URL(requireText(value, "mobile.server.productionOrigin"));
+  if (parsed.protocol !== "https:") {
+    throw new TypeError("mobile.server.productionOrigin must use HTTPS in production.");
+  }
+  if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+    throw new TypeError("mobile.server.productionOrigin must be an origin without credentials, path, query, or hash.");
+  }
+  return parsed.origin;
+};
+var normalizePlatforms = (platforms) => {
+  const normalized = [
+    ...new Set(platforms ?? ["ios", "android"])
+  ];
+  if (normalized.length === 0) {
+    throw new TypeError("mobile.platforms must contain at least one platform.");
+  }
+  return normalized;
+};
+var normalizeHosts = (hosts, productionOrigin) => {
+  const normalizeHostname = (host) => {
+    const value = requireText(host, "mobile.deepLinks.hosts").toLowerCase();
+    if (!HOSTNAME_PATTERN.test(value)) {
+      throw new TypeError("mobile.deepLinks.hosts entries must be valid hostnames without ports, wildcards, or paths.");
+    }
+    return value;
+  };
+  const normalized = new Set([
+    normalizeHostname(new URL(productionOrigin).hostname)
+  ]);
+  for (const host of hosts ?? []) {
+    normalized.add(normalizeHostname(host));
+  }
+  return [...normalized].sort();
+};
+var normalizeAppleAppIdPrefix = (value) => {
+  if (value === undefined)
+    return;
+  const normalized = requireText(value, "mobile.deepLinks.apple.appIdPrefix").toUpperCase();
+  if (!APPLE_APP_ID_PREFIX_PATTERN.test(normalized)) {
+    throw new TypeError("mobile.deepLinks.apple.appIdPrefix must contain ten letters or digits.");
+  }
+  return normalized;
+};
+var normalizeCertificateFingerprints = (values) => [
+  ...new Set((values ?? []).map((value) => requireText(value, "mobile.deepLinks.android.sha256CertificateFingerprints").replaceAll(":", "").toUpperCase()).map((value) => {
+    if (!CERTIFICATE_FINGERPRINT_PATTERN.test(value)) {
+      throw new TypeError("mobile.deepLinks.android.sha256CertificateFingerprints entries must be SHA-256 certificate fingerprints.");
+    }
+    return value.match(/.{2}/g)?.join(":") ?? value;
+  }))
+].sort();
+var normalizeAbsoluteMobileConfig = (config, projectRoot) => {
+  const appId = requireText(config.appId, "mobile.appId");
+  if (!APP_ID_PATTERN.test(appId)) {
+    throw new TypeError("mobile.appId must use reverse-domain notation, for example com.example.app.");
+  }
+  const productionOrigin = normalizeProductionOrigin(config.server.productionOrigin);
+  const deepLinkScheme = config.deepLinks?.scheme?.trim().toLowerCase();
+  if (deepLinkScheme && !SCHEME_PATTERN.test(deepLinkScheme)) {
+    throw new TypeError("mobile.deepLinks.scheme is not a valid URL scheme.");
+  }
+  return {
+    androidCertificateFingerprints: normalizeCertificateFingerprints(config.deepLinks?.android?.sha256CertificateFingerprints),
+    appId,
+    appleAppIdPrefix: normalizeAppleAppIdPrefix(config.deepLinks?.apple?.appIdPrefix),
+    appName: requireText(config.appName, "mobile.appName"),
+    bundleDirectory: resolveProjectPath(projectRoot, config.bundleDirectory ?? ".absolutejs/mobile/web", "mobile.bundleDirectory"),
+    deepLinkHosts: normalizeHosts(config.deepLinks?.hosts, productionOrigin),
+    deepLinkScheme,
+    engine: "capacitor",
+    entry: normalizeEntry(config.entry),
+    nativeProjectDirectory: resolveProjectPath(projectRoot, config.nativeProject?.directory ?? "mobile", "mobile.nativeProject.directory"),
+    platforms: normalizePlatforms(config.platforms),
+    productionOrigin
+  };
+};
+
+// src/mobile/associationFiles.ts
+var JSON_HEADERS = {
+  "cache-control": "public, max-age=300, must-revalidate",
+  "content-type": "application/json; charset=utf-8"
+};
+var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json";
+var HTTP_OK = 200;
+var VERIFY_TIMEOUT_MS = 1e4;
+var ANDROID_ASSOCIATION_PATH = "/.well-known/assetlinks.json";
+var APPLE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association";
+var missingIdentity = (field, platform) => new TypeError(`${field} is required to publish ${platform} deep-link association files.`);
+var createAppleDocument = (config, requireAll) => {
+  if (!config.platforms.includes("ios"))
+    return;
+  if (!config.appleAppIdPrefix && requireAll) {
+    throw missingIdentity("mobile.deepLinks.apple.appIdPrefix", "iOS");
+  }
+  if (!config.appleAppIdPrefix)
+    return;
+  return {
+    applinks: {
+      details: [
+        {
+          appIDs: [
+            `${config.appleAppIdPrefix}.${config.appId}`
+          ],
+          components: [{ "/": "/*" }]
+        }
+      ]
+    }
+  };
+};
+var createAndroidDocument = (config, requireAll) => {
+  if (!config.platforms.includes("android"))
+    return;
+  if (config.androidCertificateFingerprints.length === 0 && requireAll) {
+    throw missingIdentity("mobile.deepLinks.android.sha256CertificateFingerprints", "Android");
+  }
+  if (config.androidCertificateFingerprints.length === 0)
+    return;
+  return [
+    {
+      relation: ["delegate_permission/common.handle_all_urls"],
+      target: {
+        namespace: "android_app",
+        package_name: config.appId,
+        sha256_cert_fingerprints: config.androidCertificateFingerprints
+      }
+    }
+  ];
+};
+var createAbsoluteMobileAssociationDocuments = (config, options = {}) => {
+  const documents = {};
+  const requireAll = options.requireAll === true;
+  const android = createAndroidDocument(config, requireAll);
+  const apple = createAppleDocument(config, requireAll);
+  if (android)
+    documents.android = android;
+  if (apple)
+    documents.apple = apple;
+  return documents;
+};
+var jsonResponse = (value) => new Response(`${JSON.stringify(value)}
+`, { headers: JSON_HEADERS });
+var createAbsoluteMobileAssociationPlugin = (mobile, projectRoot, options = {}) => {
+  const plugin = new Elysia({ name: "absolutejs-mobile-associations" });
+  if (!mobile)
+    return plugin;
+  const config = normalizeAbsoluteMobileConfig(mobile, projectRoot);
+  const documents = createAbsoluteMobileAssociationDocuments(config, options);
+  if (documents.apple) {
+    plugin.get(APPLE_ASSOCIATION_PATH, () => jsonResponse(documents.apple));
+  }
+  if (documents.android) {
+    plugin.get(ANDROID_ASSOCIATION_PATH, () => jsonResponse(documents.android));
+  }
+  return plugin;
+};
+var writeAtomic = async (path, source) => {
+  let current;
+  try {
+    current = await readFile5(path, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile5(temporary, source, { flag: "wx" });
+  await rename5(temporary, path);
+  return true;
+};
+var exists2 = async (path) => {
+  try {
+    await access4(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var assertOwnedOutput = async (root) => {
+  const path = resolve5(root, OWNERSHIP_FILE);
+  let ownership;
+  try {
+    ownership = JSON.parse(await readFile5(path, "utf8"));
+  } catch {
+    throw new TypeError(`Association output ${root} already exists and is not owned by AbsoluteJS.`);
+  }
+  if (typeof ownership !== "object" || ownership === null || Reflect.get(ownership, "format") !== 1) {
+    throw new TypeError(`Association output ${root} has an unsupported ownership manifest.`);
+  }
+};
+var publishGeneratedDirectory = async (temporary, root) => {
+  const hasCurrent = await exists2(root);
+  if (hasCurrent)
+    await assertOwnedOutput(root);
+  const backup = `${root}.${crypto.randomUUID()}.previous`;
+  if (hasCurrent)
+    await rename5(root, backup);
+  try {
+    await rename5(temporary, root);
+  } catch (error) {
+    if (hasCurrent)
+      await rename5(backup, root);
+    throw error;
+  }
+  if (hasCurrent)
+    await rm4(backup, { force: true, recursive: true });
+};
+var materializeHost = async (root, host, files) => {
+  const directory = resolve5(root, host, ".well-known");
+  await mkdir4(directory, { recursive: true });
+  return Promise.all(files.map(async ([name, document]) => {
+    const path = resolve5(directory, name);
+    await writeAtomic(path, `${JSON.stringify(document, null, 2)}
+`);
+    return path;
+  }));
+};
+var associationEndpoints = (config, documents) => config.deepLinkHosts.flatMap((host) => {
+  const endpoints = [];
+  if (documents.android)
+    endpoints.push({
+      document: documents.android,
+      host,
+      path: ANDROID_ASSOCIATION_PATH,
+      platform: "Android"
+    });
+  if (documents.apple)
+    endpoints.push({
+      document: documents.apple,
+      host,
+      path: APPLE_ASSOCIATION_PATH,
+      platform: "Apple"
+    });
+  return endpoints;
+});
+var materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
+  const root = resolve5(outputDirectory);
+  const temporary = `${root}.${crypto.randomUUID()}.tmp`;
+  const documents = createAbsoluteMobileAssociationDocuments(config, {
+    requireAll: true
+  });
+  const files = [];
+  if (documents.android)
+    files.push(["assetlinks.json", documents.android]);
+  if (documents.apple) {
+    files.push(["apple-app-site-association", documents.apple]);
+  }
+  await mkdir4(temporary, { recursive: true });
+  try {
+    const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
+    await writeAtomic(resolve5(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+`);
+    await publishGeneratedDirectory(temporary, root);
+    const written = temporaryPaths.map((path) => resolve5(root, path.slice(temporary.length + 1)));
+    return { root, written };
+  } catch (error) {
+    await rm4(temporary, { force: true, recursive: true });
+    throw error;
+  }
+};
+var verifyAbsoluteMobileAssociationFiles = async (config, request = globalThis.fetch) => {
+  const documents = createAbsoluteMobileAssociationDocuments(config, {
+    requireAll: true
+  });
+  const results = await Promise.all(associationEndpoints(config, documents).map(async (endpoint) => {
+    const url = `https://${endpoint.host}${endpoint.path}`;
+    const response = await request(url, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(VERIFY_TIMEOUT_MS)
+    });
+    if (response.status !== HTTP_OK) {
+      throw new TypeError(`${endpoint.platform} association verification failed for ${url}: HTTP ${response.status}; redirects are not allowed.`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().startsWith("application/json")) {
+      throw new TypeError(`${endpoint.platform} association verification failed for ${url}: expected application/json.`);
+    }
+    let document;
+    try {
+      document = await response.json();
+    } catch {
+      throw new TypeError(`${endpoint.platform} association verification failed for ${url}: invalid JSON.`);
+    }
+    if (JSON.stringify(document) !== JSON.stringify(endpoint.document)) {
+      throw new TypeError(`${endpoint.platform} association verification failed for ${url}: the hosted identity does not match mobile config.`);
+    }
+    return { platform: endpoint.platform, url };
+  }));
+  return { results };
+};
+// src/mobile/buildMetadata.ts
+var ABSOLUTE_MOBILE_ROUTE_DETAIL = "x-absolute-mobile";
+var frameworks2 = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPageFramework2 = (value) => typeof value === "string" && frameworks2.has(value);
+var parseAbsoluteMobileBuildPageMetadata = (value) => {
+  if (!isRecord2(value))
+    return;
+  if (typeof value.bundleKey !== "string" || typeof value.contract !== "string" || !isPageFramework2(value.framework) || typeof value.pageId !== "string" || typeof value.propsSchemaHash !== "string") {
+    return;
+  }
+  return {
+    bundleKey: value.bundleKey,
+    contract: value.contract,
+    framework: value.framework,
+    pageId: value.pageId,
+    propsSchemaHash: value.propsSchemaHash
+  };
+};
+// src/mobile/buildPipeline.ts
+import { readFile as readFile9 } from "fs/promises";
+import { join as join8, resolve as resolve8 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+
+// src/mobile/buildRelease.ts
+import { createHash as createHash4 } from "crypto";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join5, relative as relative4, resolve as resolve6 } from "path";
+var sha256 = (bytes) => createHash4("sha256").update(bytes).digest("hex");
+var readPageMetadata = (route) => parseAbsoluteMobileBuildPageMetadata(route.hooks?.detail?.[ABSOLUTE_MOBILE_ROUTE_DETAIL]);
+var resolveAssetPath = (buildDirectory, assetPath) => {
+  const resolvedBuildDirectory = resolve6(buildDirectory);
+  const resolvedAsset = resolve6(assetPath);
+  if (resolvedAsset.startsWith(`${resolvedBuildDirectory}/`)) {
+    return resolvedAsset;
+  }
+  return join5(buildDirectory, assetPath.replace(/^\/+/, ""));
+};
+var 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 = `/${relative4(resolve6(buildDirectory), resolvedAssetPath).replaceAll("\\", "/")}`;
+  return {
+    bundleHash: sha256(bytes),
+    bundlePath,
+    contract: metadata.contract,
+    framework: metadata.framework,
+    pageId: metadata.pageId,
+    propsSchemaHash: metadata.propsSchemaHash
+  };
+};
+var buildAbsoluteMobileCompatibilityRelease = async (options) => {
+  const [captured, producerBytes] = await Promise.all([
+    captureAbsoluteMobileRouteGraph(options.app),
+    readFile6(options.producerPath)
+  ]);
+  if (captured.length === 0) {
+    throw new TypeError("No instrumented AbsoluteJS mobile page routes were found in the finalized Elysia route graph.");
+  }
+  const metadataByPage = new Map;
+  for (const { metadata } of captured) {
+    const prior = metadataByPage.get(metadata.pageId);
+    if (prior && JSON.stringify(prior) !== JSON.stringify(metadata)) {
+      throw new TypeError(`Mobile page ${metadata.pageId} has inconsistent generated contracts.`);
+    }
+    metadataByPage.set(metadata.pageId, metadata);
+  }
+  const pages = await Promise.all([...metadataByPage.values()].map((metadata) => pageFor(metadata, options.manifest, options.buildDirectory)));
+  const producerHash = sha256(producerBytes);
+  const appBuild = `ambuild_${sha256(new TextEncoder().encode(JSON.stringify({
+    pages: pages.map(({ bundleHash, bundlePath, contract, pageId }) => ({
+      bundleHash,
+      bundlePath,
+      contract,
+      pageId
+    })),
+    producerHash,
+    runtime: options.runtime
+  })))}`;
+  const priorAppIds = new Set((options.previousArtifacts ?? []).map(({ appId }) => appId));
+  if (priorAppIds.size > 1 || priorAppIds.size === 1 && !priorAppIds.has(options.appId)) {
+    throw new TypeError("Previous mobile compatibility artifacts belong to another app.");
+  }
+  const unchanged = options.previousArtifacts?.find((artifact2) => artifact2.appBuild === appBuild && artifact2.runtime === options.runtime);
+  const generation = unchanged?.generation ?? Math.max(0, ...(options.previousArtifacts ?? []).map((artifact2) => artifact2.generation)) + 1;
+  const artifact = createAbsoluteMobileCompatibilityArtifact({
+    appBuild,
+    appId: options.appId,
+    generation,
+    pages,
+    producer: {
+      bundleHash: producerHash,
+      bytes: producerBytes.byteLength,
+      exportName: options.producerExport ?? "server",
+      module: options.producerModule ?? "producer.js"
+    },
+    routes: captured.map(({ route }) => route),
+    runtime: options.runtime
+  });
+  return { artifact, producer: new Blob([producerBytes]) };
+};
+var captureAbsoluteMobileRouteGraph = async (app) => {
+  if (app.modules)
+    await app.modules;
+  app.compile();
+  const captured = app.routes.flatMap((route) => {
+    const metadata = readPageMetadata(route);
+    if (!metadata || route.method !== "GET" && route.method !== "HEAD") {
+      return [];
+    }
+    return [
+      {
+        metadata,
+        route: {
+          method: route.method === "GET" ? "GET" : "HEAD",
+          pageId: metadata.pageId,
+          pattern: route.path
+        }
+      }
+    ];
+  });
+  const identities = new Map;
+  for (const { metadata, route } of captured) {
+    const prior = identities.get(`${route.method}:${route.pattern}`);
+    if (prior && prior !== metadata.pageId) {
+      throw new TypeError(`Mobile route ${route.method} ${route.pattern} resolves to multiple pages.`);
+    }
+    identities.set(`${route.method}:${route.pattern}`, metadata.pageId);
+  }
+  return captured;
+};
+
+// src/mobile/capacitorBundle.ts
+import {
+  copyFile as copyFile3,
+  mkdir as mkdir5,
+  mkdtemp as mkdtemp3,
+  readFile as readFile7,
+  rename as rename6,
+  rm as rm5,
+  writeFile as writeFile6
+} from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { basename, dirname as dirname3, extname, join as join6, resolve as resolve7 } from "path";
+
+// src/mobile/routeMatcher.ts
+var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
+var routeSegmentPattern = (segment) => {
+  if (segment === "*")
+    return ".*";
+  if (segment.startsWith(":") && segment.endsWith("?"))
+    return "[^/]*";
+  if (segment.startsWith(":"))
+    return "[^/]+";
+  return segment.replace(REGEXP_SPECIAL_CHARACTERS, "\\$&");
+};
+var matchesAbsoluteMobileRoutePattern = (pattern, pathname) => {
+  const expression = pattern.split("/").map(routeSegmentPattern).join("/");
+  return new RegExp(`^${expression}/?$`).test(pathname);
+};
+var resolveAbsoluteMobileRoute = (routes, pathname, method = "GET") => routes.find((route) => route.method === method && matchesAbsoluteMobileRoutePattern(route.pattern, pathname));
+
+// src/mobile/producerContextState.ts
+var ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY = Symbol.for("absolutejs.mobileProducerAsyncLocalStorage");
+var frameworks3 = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var isCompatibilityPage = (value) => typeof value === "object" && value !== null && ("bundleHash" in value) && typeof value.bundleHash === "string" && ("contract" in value) && typeof value.contract === "string" && ("framework" in value) && typeof value.framework === "string" && frameworks3.has(value.framework) && ("pageId" in value) && typeof value.pageId === "string" && ("propsSchemaHash" in value) && typeof value.propsSchemaHash === "string";
+var getCurrentAbsoluteMobileProducerContext = () => {
+  const value = Reflect.get(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY);
+  if (typeof value !== "object" || value === null || !("getStore" in value) || typeof value.getStore !== "function") {
+    return;
+  }
+  const context = value.getStore();
+  if (typeof context !== "object" || context === null || !("page" in context) || !isCompatibilityPage(context.page) || !("releaseId" in context) || typeof context.releaseId !== "string") {
+    return;
+  }
+  return { page: context.page, releaseId: context.releaseId };
+};
+
+// src/mobile/pageProtocol.ts
+var ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE = "application/vnd.absolute.page+json";
+var ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION = 1;
+var BAD_REQUEST_STATUS = 400;
+var OK_STATUS = 200;
+var SERVER_ERROR_STATUS = 500;
+var UPGRADE_REQUIRED_STATUS = 426;
+var MOBILE_PAGE_REQUEST_HEADERS = {
+  appBuild: "x-absolute-mobile-app-build",
+  pageBundle: "x-absolute-mobile-page-bundle",
+  pageContracts: "x-absolute-mobile-page-contracts",
+  pageId: "x-absolute-mobile-page-id",
+  protocol: "x-absolute-mobile-protocol",
+  runtime: "x-absolute-mobile-runtime"
+};
+var parseMediaType = (value) => value.split(";", 1)[0]?.trim().toLowerCase();
+var acceptsAbsoluteMobilePage = (request) => {
+  if (!request)
+    return false;
+  return (request.headers.get("accept") ?? "").split(",").some((value) => parseMediaType(value) === ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
+};
+var readRequiredHeader = (request, name) => {
+  const value = request.headers.get(name)?.trim();
+  return value ? value : undefined;
+};
+var parseAbsoluteMobilePageRequest = (request) => {
+  if (!request || !acceptsAbsoluteMobilePage(request)) {
+    return { kind: "not-mobile" };
+  }
+  const protocolValue = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.protocol);
+  const runtime = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.runtime);
+  const appBuild = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.appBuild);
+  const pageBundle = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageBundle);
+  const pageContractsValue = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageContracts);
+  const pageId = readRequiredHeader(request, MOBILE_PAGE_REQUEST_HEADERS.pageId);
+  if (!protocolValue || !/^\d+$/.test(protocolValue)) {
+    return {
+      kind: "invalid",
+      message: `Missing or invalid ${MOBILE_PAGE_REQUEST_HEADERS.protocol} header.`
+    };
+  }
+  if (!runtime) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.runtime} header.`
+    };
+  }
+  if (!appBuild) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.appBuild} header.`
+    };
+  }
+  if (!pageBundle) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageBundle} header.`
+    };
+  }
+  if (!pageContractsValue) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageContracts} header.`
+    };
+  }
+  if (!pageId) {
+    return {
+      kind: "invalid",
+      message: `Missing ${MOBILE_PAGE_REQUEST_HEADERS.pageId} header.`
+    };
+  }
+  const pageContracts = [
+    ...new Set(pageContractsValue.split(",").map((value) => value.trim()).filter(Boolean))
+  ];
+  if (pageContracts.length === 0) {
+    return {
+      kind: "invalid",
+      message: `${MOBILE_PAGE_REQUEST_HEADERS.pageContracts} must contain at least one contract.`
+    };
+  }
+  return {
+    client: {
+      appBuild,
+      pageBundle,
+      pageContracts,
+      pageId,
+      protocol: Number(protocolValue),
+      runtime
+    },
+    kind: "mobile"
+  };
+};
+var responseHeaders = () => {
+  const headers = new Headers({
+    "cache-control": "no-store",
+    "content-type": `${ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE}; version=${ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION}`
+  });
+  headerVaryValues.forEach((value) => headers.append("vary", value));
+  return headers;
+};
+var headerVaryValues = [
+  "Accept",
+  MOBILE_PAGE_REQUEST_HEADERS.protocol,
+  MOBILE_PAGE_REQUEST_HEADERS.runtime,
+  MOBILE_PAGE_REQUEST_HEADERS.appBuild,
+  MOBILE_PAGE_REQUEST_HEADERS.pageBundle,
+  MOBILE_PAGE_REQUEST_HEADERS.pageContracts,
+  MOBILE_PAGE_REQUEST_HEADERS.pageId
+];
+var envelopeResponse = (response, status) => new Response(JSON.stringify({
+  protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+  response
+}), { headers: responseHeaders(), status });
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeJsonValue = (value) => {
+  const serialized = JSON.stringify(value);
+  if (serialized === undefined) {
+    throw new TypeError("Mobile page props must be JSON-serializable.");
+  }
+  const parsed = JSON.parse(serialized);
+  if (!isRecord3(parsed)) {
+    throw new TypeError("Mobile page props must serialize to an object.");
+  }
+  return parsed;
+};
+var finalizeArchivedMobilePage = (context, input) => {
+  const { page } = context;
+  if (page.pageId !== input.compatibility.pageId || page.framework !== input.compatibility.framework) {
+    return envelopeResponse({
+      kind: "invalid-request",
+      message: "Archived producer page identity does not match its release artifact."
+    }, BAD_REQUEST_STATUS);
+  }
+  try {
+    const [currentRepresentation] = input.compatibility.representations;
+    if (!currentRepresentation) {
+      throw new TypeError("Mobile page has no current representation.");
+    }
+    return envelopeResponse({
+      contract: page.contract,
+      framework: page.framework,
+      kind: "page",
+      pageId: page.pageId,
+      props: normalizeJsonValue(currentRepresentation.mapProps(input.props)),
+      status: input.status ?? OK_STATUS
+    }, input.status ?? OK_STATUS);
+  } catch (error) {
+    console.error(`[Mobile] Archived producer ${context.releaseId} failed for ${page.pageId}:`, error);
+    return createAbsoluteMobilePageErrorResponse(page.pageId);
+  }
+};
+var createAbsoluteMobileInvalidRequestResponse = (message) => envelopeResponse({ kind: "invalid-request", message }, BAD_REQUEST_STATUS);
+var createAbsoluteMobilePageErrorResponse = (pageId) => envelopeResponse({
+  code: "representation-failed",
+  kind: "error",
+  pageId,
+  status: SERVER_ERROR_STATUS
+}, SERVER_ERROR_STATUS);
+var createAbsoluteMobileUpgradeResponse = (result) => envelopeResponse(result, UPGRADE_REQUIRED_STATUS);
+var finalizeAbsoluteMobilePage = (input) => {
+  const parsed = parseAbsoluteMobilePageRequest(input.request);
+  if (parsed.kind === "not-mobile")
+    return;
+  if (parsed.kind === "invalid") {
+    return envelopeResponse({ kind: "invalid-request", message: parsed.message }, BAD_REQUEST_STATUS);
+  }
+  const { client } = parsed;
+  if (client.pageId !== input.compatibility.pageId) {
+    return envelopeResponse({
+      kind: "invalid-request",
+      message: `Requested mobile page ${client.pageId} does not match ${input.compatibility.pageId}.`
+    }, BAD_REQUEST_STATUS);
+  }
+  const producerContext = getCurrentAbsoluteMobileProducerContext();
+  if (producerContext)
+    return finalizeArchivedMobilePage(producerContext, input);
+  if (client.protocol !== ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION) {
+    return envelopeResponse({
+      kind: "upgrade-required",
+      pageId: input.compatibility.pageId,
+      reason: "protocol"
+    }, UPGRADE_REQUIRED_STATUS);
+  }
+  if (!input.compatibility.runtimes.includes(client.runtime)) {
+    return envelopeResponse({
+      kind: "upgrade-required",
+      pageId: input.compatibility.pageId,
+      reason: "runtime",
+      supportedRuntimes: [...input.compatibility.runtimes]
+    }, UPGRADE_REQUIRED_STATUS);
+  }
+  const clientContracts = new Set(client.pageContracts);
+  const representation = input.compatibility.representations.find(({ contract }) => clientContracts.has(contract));
+  if (!representation) {
+    return envelopeResponse({
+      kind: "upgrade-required",
+      pageId: input.compatibility.pageId,
+      reason: "page-contract",
+      supportedContracts: input.compatibility.representations.map(({ contract }) => contract)
+    }, UPGRADE_REQUIRED_STATUS);
+  }
+  try {
+    return envelopeResponse({
+      contract: representation.contract,
+      framework: input.compatibility.framework,
+      kind: "page",
+      pageId: input.compatibility.pageId,
+      props: normalizeJsonValue(representation.mapProps(input.props)),
+      status: input.status ?? OK_STATUS
+    }, input.status ?? OK_STATUS);
+  } catch (error) {
+    console.error(`[Mobile] Failed to produce ${input.compatibility.pageId} representation ${representation.contract}:`, error);
+    return envelopeResponse({
+      code: "representation-failed",
+      kind: "error",
+      pageId: input.compatibility.pageId,
+      status: SERVER_ERROR_STATUS
+    }, SERVER_ERROR_STATUS);
+  }
+};
+
+// src/mobile/client.ts
+class AbsoluteMobilePageProtocolError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "AbsoluteMobilePageProtocolError";
+    this.code = code;
+  }
+}
+var frameworks4 = new Set([
+  "angular",
+  "ember",
+  "html",
+  "htmx",
+  "react",
+  "svelte",
+  "vue"
+]);
+var upgradeReasons = new Set([
+  "app-release",
+  "page-contract",
+  "protocol",
+  "runtime"
+]);
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isFramework = (value) => typeof value === "string" && frameworks4.has(value);
+var isUpgradeReason = (value) => typeof value === "string" && upgradeReasons.has(value);
+var parsePageResult = (value) => {
+  if (typeof value.contract !== "string" || !isFramework(value.framework) || typeof value.pageId !== "string" || typeof value.status !== "number") {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The mobile page response is missing required page metadata.");
+  }
+  if (!isRecord4(value.props)) {
+    throw new AbsoluteMobilePageProtocolError("invalid-props", "The mobile page response must contain an object props value.");
+  }
+  return {
+    contract: value.contract,
+    framework: value.framework,
+    kind: "page",
+    pageId: value.pageId,
+    props: value.props,
+    status: value.status
+  };
+};
+var parseUpgradeResult = (value) => {
+  if (typeof value.pageId !== "string" || !isUpgradeReason(value.reason)) {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The update response is missing its page or reason.");
+  }
+  return {
+    kind: "upgrade-required",
+    pageId: value.pageId,
+    reason: value.reason,
+    supportedContracts: Array.isArray(value.supportedContracts) ? value.supportedContracts.filter((contract) => typeof contract === "string") : undefined,
+    supportedRuntimes: Array.isArray(value.supportedRuntimes) ? value.supportedRuntimes.filter((runtime) => typeof runtime === "string") : undefined
+  };
+};
+var activateAbsoluteMobilePage = async (value, options) => {
+  const envelope = parseAbsoluteMobilePageEnvelope(value);
+  if (envelope.response.kind === "upgrade-required") {
+    return envelope.response;
+  }
+  if (envelope.response.kind !== "page") {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "Expected a renderable mobile page response.");
+  }
+  const target = options.target ?? window;
+  target.__INITIAL_PROPS__ = envelope.response.props;
+  target.__ABSOLUTE_PAGE_RENDER_MODE__ = "client";
+  await options.loadPage({
+    contract: envelope.response.contract,
+    pageId: envelope.response.pageId
+  });
+  return {
+    contract: envelope.response.contract,
+    kind: "rendered",
+    pageId: envelope.response.pageId
+  };
+};
+var parseAbsoluteMobilePageEnvelope = (value) => {
+  if (!isRecord4(value) || !isRecord4(value.response)) {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", "The server did not return an AbsoluteJS mobile page envelope.");
+  }
+  if (value.protocol !== ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION) {
+    throw new AbsoluteMobilePageProtocolError("invalid-envelope", `Unsupported mobile page protocol ${String(value.protocol)}.`);
+  }
+  const { kind } = value.response;
+  if (kind === "page") {
+    return {
+      protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+      response: parsePageResult(value.response)
+    };
+  }
+  if (kind === "upgrade-required") {
+    return {
+      protocol: ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+      response: parseUpgradeResult(value.response)
+    };
+  }
+  if (kind === "invalid-request") {
+    throw new AbsoluteMobilePageProtocolError("server-rejected-request", typeof value.response.message === "string" ? value.response.message : "The server rejected the mobile page request.");
+  }
+  if (kind === "error") {
+    throw new AbsoluteMobilePageProtocolError("server-error", "The server could not create a compatible mobile page representation.");
+  }
+  throw new AbsoluteMobilePageProtocolError("invalid-envelope", `Unknown mobile page response kind ${String(kind)}.`);
+};
+
+// src/mobile/transport.ts
+var ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT = 1;
+var pageForPathname = (manifest, pathname) => {
+  const route = resolveAbsoluteMobileRoute(manifest.routes, pathname);
+  if (!route) {
+    throw new TypeError(`No embedded mobile page owns ${pathname}.`);
+  }
+  const page = manifest.pages.find((candidate) => candidate.pageId === route.pageId);
+  if (!page) {
+    throw new TypeError(`Mobile route ${route.pattern} references missing page ${route.pageId}.`);
+  }
+  return page;
+};
+var canonicalBackendUrl = (manifest, path) => {
+  const origin = new URL(manifest.productionOrigin);
+  const url = new URL(path, `${origin.origin}/`);
+  if (url.origin !== origin.origin) {
+    throw new TypeError("Mobile transport cannot leave productionOrigin.");
+  }
+  url.hash = "";
+  return url;
+};
+var createAbsoluteMobilePageRequest = (manifest, path, options = {}) => {
+  const url = canonicalBackendUrl(manifest, path);
+  const page = pageForPathname(manifest, url.pathname);
+  const headers = new Headers(options.headers);
+  headers.set("accept", ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.appBuild, manifest.appBuild);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageBundle, page.bundleHash);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageContracts, page.contract);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.pageId, page.pageId);
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.protocol, String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION));
+  headers.set(MOBILE_PAGE_REQUEST_HEADERS.runtime, manifest.runtime);
+  return new Request(url, { headers, method: "GET" });
+};
+var fetchAbsoluteMobilePage = async (manifest, path, options = {}) => {
+  const request = createAbsoluteMobilePageRequest(manifest, path, options);
+  const response = await (options.fetch ?? globalThis.fetch)(request);
+  const value = await response.json();
+  return value;
+};
+var navigateAbsoluteMobilePage = async (manifest, path, options) => {
+  const envelope = await fetchAbsoluteMobilePage(manifest, path, options);
+  return activateAbsoluteMobilePage(envelope, options);
+};
+var resolveAbsoluteMobileDeepLink = (manifest, value) => {
+  const url = new URL(value);
+  if (url.username || url.password) {
+    throw new TypeError("Mobile deep links cannot contain credentials.");
+  }
+  const isHttpsHost = url.protocol === "https:" && manifest.deepLinkHosts.includes(url.hostname.toLowerCase());
+  const isCustomScheme = manifest.deepLinkScheme !== undefined && url.protocol === `${manifest.deepLinkScheme}:`;
+  if (!isHttpsHost && !isCustomScheme) {
+    throw new TypeError("Mobile deep link is outside the configured app URLs.");
+  }
+  return `${url.pathname || "/"}${url.search}${url.hash}`;
+};
+
+// src/mobile/capacitorBundle.ts
+var MANIFEST_FILE = "absolute-mobile-manifest.json";
+var BOOTSTRAP_FILE = "absolute-mobile-bootstrap.js";
+var INDEX_FILE = "index.html";
+var CLIENT_IMPORT_PATTERN = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s*)["'](\/[^"']+)["']/gu;
+var errorHasCode2 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
+var shellBootstrapModule = () => {
+  const candidate = ["js", "ts"].map((extension) => join6(import.meta.dir, `shellBootstrap.${extension}`)).find(existsSync2);
+  if (candidate)
+    return candidate;
+  throw new TypeError("AbsoluteJS mobile shell bootstrap module is missing.");
+};
+var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var indexHtml = (appName) => `<!doctype html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
+		<meta name="color-scheme" content="light dark">
+		<title>${escapeHtml(appName)}</title>
+	</head>
+	<body>
+		<main id="absolute-mobile-status" role="status">Starting\u2026</main>
+		<script type="module" src="./${BOOTSTRAP_FILE}"></script>
+	</body>
+</html>
+`;
+var sourceAssetPath = (buildDirectory, bundlePath) => {
+  const root = resolve7(buildDirectory);
+  const asset = resolve7(root, bundlePath.replace(/^\/+/, ""));
+  if (!asset.startsWith(`${root}/`)) {
+    throw new TypeError("Mobile page bundle escaped the build directory.");
+  }
+  return asset;
+};
+var buildShellBootstrap = async (staging) => {
+  const modulePath = shellBootstrapModule();
+  const entryPath = join6(staging, ".absolute-mobile-entry.ts");
+  await writeFile6(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
+void startAbsoluteMobileShell();
+`);
+  const build = await Bun.build({
+    entrypoints: [entryPath],
+    minify: true,
+    outdir: staging,
+    target: "browser"
+  });
+  if (!build.success || build.outputs.length !== 1) {
+    throw new AggregateError(build.logs, "Failed to build the AbsoluteJS Capacitor shell.");
+  }
+  await rename6(build.outputs[0]?.path ?? "", join6(staging, BOOTSTRAP_FILE));
+  await rm5(entryPath, { force: true });
+};
+var removePreviousBundle = async (backup, moved) => {
+  if (!moved)
+    return;
+  await rm5(backup, { force: true, recursive: true });
+};
+var restorePreviousBundle = async (backup, destination, moved) => {
+  if (!moved)
+    return;
+  await rename6(backup, destination);
+};
+var installBundle = async (staging, destination) => {
+  const backup = `${destination}.previous-${crypto.randomUUID()}`;
+  let movedPrevious = false;
+  try {
+    await rename6(destination, backup);
+    movedPrevious = true;
+  } catch (error) {
+    if (!errorHasCode2(error, "ENOENT"))
+      throw error;
+  }
+  try {
+    await rename6(staging, destination);
+    await removePreviousBundle(backup, movedPrevious);
+  } catch (error) {
+    await restorePreviousBundle(backup, destination, movedPrevious);
+    throw error;
+  }
+};
+var copyClientPage = async (page, buildDirectory, staging, copiedDependencies) => {
+  if (page.framework !== "react") {
+    throw new TypeError(`Capacitor spike currently supports React pages; ${page.pageId} is ${page.framework}.`);
+  }
+  const extension = extname(page.bundlePath) || ".js";
+  const localBundlePath = `./pages/${page.bundleHash}${extension}`;
+  const source = sourceAssetPath(buildDirectory, page.bundlePath);
+  await copyFile3(source, join6(staging, localBundlePath));
+  await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
+  return { ...page, localBundlePath };
+};
+var absoluteClientImports = async (sourcePath) => {
+  const source = await readFile7(sourcePath, "utf8");
+  return [...source.matchAll(CLIENT_IMPORT_PATTERN)].flatMap((match) => {
+    const [specifier] = match.slice(1);
+    return specifier ? [specifier.split(/[?#]/u, 1)[0] ?? specifier] : [];
+  });
+};
+var copyAbsoluteClientDependency = async (specifier, buildDirectory, staging, copied) => {
+  if (copied.has(specifier))
+    return;
+  copied.add(specifier);
+  const source = sourceAssetPath(buildDirectory, specifier);
+  const destination = join6(staging, specifier.replace(/^\/+/, ""));
+  await mkdir5(dirname3(destination), { recursive: true });
+  await copyFile3(source, destination);
+  await copyAbsoluteClientDependencies(source, buildDirectory, staging, copied);
+};
+var copyAbsoluteClientDependencies = async (sourcePath, buildDirectory, staging, copied) => {
+  const dependencies = await absoluteClientImports(sourcePath);
+  await Promise.all(dependencies.map((specifier) => copyAbsoluteClientDependency(specifier, buildDirectory, staging, copied)));
+};
+var materializeAbsoluteCapacitorWebBundle = async (options) => {
+  if (!resolveAbsoluteMobileRoute(options.artifact.routes, new URL(options.config.entry, "https://absolute.invalid").pathname)) {
+    throw new TypeError(`mobile.entry ${options.config.entry} is not a captured mobile page route.`);
+  }
+  const destination = options.config.bundleDirectory;
+  await mkdir5(dirname3(destination), { recursive: true });
+  const staging = await mkdtemp3(join6(dirname3(destination), `.${basename(destination)}.stage-`));
+  try {
+    const pageDirectory = join6(staging, "pages");
+    await mkdir5(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 = {
+      appBuild: options.artifact.appBuild,
+      appId: options.config.appId,
+      appName: options.config.appName,
+      deepLinkHosts: options.config.deepLinkHosts,
+      deepLinkScheme: options.config.deepLinkScheme,
+      entry: options.config.entry,
+      format: ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+      pages,
+      productionOrigin: options.config.productionOrigin,
+      routes: options.artifact.routes,
+      runtime: options.artifact.runtime
+    };
+    await Promise.all([
+      writeFile6(join6(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
+`),
+      writeFile6(join6(staging, INDEX_FILE), indexHtml(options.config.appName)),
+      buildShellBootstrap(staging)
+    ]);
+    await installBundle(staging, destination);
+    return manifest;
+  } catch (error) {
+    await rm5(staging, { force: true, recursive: true });
+    throw error;
+  }
+};
+
+// src/mobile/materializedBundle.ts
+import { createHash as createHash5 } from "crypto";
+import {
+  access as access5,
+  mkdir as mkdir6,
+  mkdtemp as mkdtemp4,
+  readFile as readFile8,
+  rename as rename7,
+  rm as rm6,
+  writeFile as writeFile7
+} from "fs/promises";
+import { dirname as dirname4, join as join7, resolve as resolvePath2 } from "path";
+import { pathToFileURL } from "url";
+var ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT = 1;
+var CURRENT_BUNDLE_FILE = "current.json";
+var BUNDLES_DIRECTORY = "bundles";
+var ARTIFACT_FILE2 = "artifact.json";
+var BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var errorHasCode3 = (error, code) => typeof error === "object" && error !== null && Reflect.get(error, "code") === code;
+var bundleIdFor = (currentReleaseId, releases) => {
+  const identity = JSON.stringify({
+    currentReleaseId,
+    releases: releases.map(({ releaseId }) => releaseId)
+  });
+  return `amb_${createHash5("sha256").update(identity).digest("hex")}`;
+};
+var parseBundleIndex = (value) => {
+  if (!isRecord5(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.");
+  }
+  const releases = value.releases.map(parseAbsoluteMobileCompatibilityArtifact);
+  const retained = retainAbsoluteMobileCompatibilityArtifacts(releases);
+  if (retained.length !== releases.length || retained.some(({ releaseId }, index) => releaseId !== releases[index]?.releaseId)) {
+    throw new TypeError("Materialized mobile bundle releases are not a retained generation window.");
+  }
+  const expectedBundleId = bundleIdFor(value.currentReleaseId, releases);
+  if (value.bundleId !== expectedBundleId) {
+    throw new TypeError("Materialized mobile bundle integrity failed.");
+  }
+  if (releases[0]?.releaseId !== value.currentReleaseId) {
+    throw new TypeError("Materialized mobile bundle current release is not its newest generation.");
+  }
+  return {
+    bundleId: value.bundleId,
+    currentReleaseId: value.currentReleaseId,
+    format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
+    releases
+  };
+};
+var writeRelease = async (root, release) => {
+  const directory = join7(root, release.artifact.releaseId);
+  const producerPath = join7(directory, release.artifact.producer.module);
+  await mkdir6(dirname4(producerPath), { recursive: true });
+  await Promise.all([
+    writeFile7(join7(directory, ARTIFACT_FILE2), `${JSON.stringify(release.artifact, null, "\t")}
+`),
+    writeFile7(producerPath, new Uint8Array(await release.producer.arrayBuffer()))
+  ]);
+};
+var installImmutableBundle = async (bundlesRoot, bundleId, releases) => {
+  const destination = join7(bundlesRoot, bundleId);
+  try {
+    await access5(destination);
+    return destination;
+  } catch (error) {
+    if (!errorHasCode3(error, "ENOENT"))
+      throw error;
+  }
+  const staging = await mkdtemp4(join7(bundlesRoot, ".stage-"));
+  try {
+    await Promise.all(releases.map((release) => writeRelease(staging, release)));
+    await rename7(staging, destination);
+  } catch (error) {
+    await rm6(staging, { force: true, recursive: true });
+    if (errorHasCode3(error, "EEXIST") || errorHasCode3(error, "ENOTEMPTY")) {
+      return destination;
+    }
+    throw error;
+  }
+  return destination;
+};
+var readCompatibilityModule = (modulePath) => import(pathToFileURL(modulePath).href);
+var resolveProducerHandler = (loaded, exportName) => {
+  const value = loaded[exportName];
+  if (!isRecord5(value) || typeof value.handle !== "function") {
+    throw new TypeError(`Compatibility producer export ${exportName} must expose handle(request).`);
+  }
+  const { handle } = value;
+  return {
+    handle: async (request) => {
+      const response = await Reflect.apply(handle, value, [
+        request
+      ]);
+      if (!(response instanceof Response)) {
+        throw new TypeError(`Compatibility producer ${exportName} returned a non-Response value.`);
+      }
+      return response;
+    }
+  };
+};
+var loadAbsoluteMobileMaterializedBundle = async (root) => {
+  const resolvedRoot = resolvePath2(root);
+  const serialized = await readFile8(join7(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+  const parsed = JSON.parse(serialized);
+  const index = parseBundleIndex(parsed);
+  const bundleRoot = join7(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+  return {
+    artifacts: index.releases,
+    currentReleaseId: index.currentReleaseId,
+    loadProducer: async (artifact) => {
+      const modulePath = join7(bundleRoot, artifact.releaseId, artifact.producer.module);
+      await verifyAbsoluteMobileCompatibilityProducer({
+        artifact,
+        producer: Bun.file(modulePath)
+      });
+      const loaded = await readCompatibilityModule(modulePath);
+      return resolveProducerHandler(loaded, artifact.producer.exportName);
+    }
+  };
+};
+var materializeAbsoluteMobileCompatibilityBundle = async (input) => {
+  const releases = await Promise.all(input.releases.map((release) => verifyAbsoluteMobileCompatibilityProducer(release)));
+  const artifacts = retainAbsoluteMobileCompatibilityArtifacts(releases.map(({ artifact }) => artifact));
+  if (artifacts.length !== releases.length) {
+    throw new TypeError("Materialization input must already contain only retained releases.");
+  }
+  if (artifacts[0]?.releaseId !== input.currentReleaseId) {
+    throw new TypeError("Materialization current release must be the newest generation.");
+  }
+  const orderedReleases = artifacts.map((artifact) => {
+    const release = releases.find((candidate) => candidate.artifact.releaseId === artifact.releaseId);
+    if (!release) {
+      throw new TypeError("Materialization input is missing a producer.");
+    }
+    return release;
+  });
+  const root = resolvePath2(input.root);
+  const bundlesRoot = join7(root, BUNDLES_DIRECTORY);
+  await mkdir6(bundlesRoot, { recursive: true });
+  const bundleId = bundleIdFor(input.currentReleaseId, artifacts);
+  await installImmutableBundle(bundlesRoot, bundleId, orderedReleases);
+  const index = {
+    bundleId,
+    currentReleaseId: input.currentReleaseId,
+    format: ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
+    releases: artifacts
+  };
+  const pointerPath = join7(root, CURRENT_BUNDLE_FILE);
+  const temporaryPointerPath = join7(root, `.current-${crypto.randomUUID()}.json`);
+  await writeFile7(temporaryPointerPath, `${JSON.stringify(index, null, "\t")}
+`, { flag: "wx" });
+  await rename7(temporaryPointerPath, pointerPath);
+  return index;
+};
+var readAbsoluteMobileMaterializedReleases = async (root) => {
+  const resolvedRoot = resolvePath2(root);
+  try {
+    const serialized = await readFile8(join7(resolvedRoot, CURRENT_BUNDLE_FILE), "utf8");
+    const parsed = JSON.parse(serialized);
+    const index = parseBundleIndex(parsed);
+    const bundleRoot = join7(resolvedRoot, BUNDLES_DIRECTORY, index.bundleId);
+    return Promise.all(index.releases.map(async (artifact) => {
+      const producer = Bun.file(join7(bundleRoot, artifact.releaseId, artifact.producer.module));
+      await verifyAbsoluteMobileCompatibilityProducer({
+        artifact,
+        producer
+      });
+      return { artifact, producer };
+    }));
+  } catch (error) {
+    if (errorHasCode3(error, "ENOENT"))
+      return [];
+    throw error;
+  }
+};
+
+// src/mobile/buildPipeline.ts
+var isElysiaApp = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "compile") === "function" && Array.isArray(Reflect.get(value, "routes"));
+var isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
+var serverExportName = (loaded, app) => {
+  if (loaded.server === app)
+    return "server";
+  if (loaded.app === app)
+    return "app";
+  return "default";
+};
+var restoreBuildDirectory = (previous) => {
+  if (previous !== undefined) {
+    process.env.ABSOLUTE_BUILD_DIR = previous;
+    return;
+  }
+  delete process.env.ABSOLUTE_BUILD_DIR;
+};
+var requireRelease = (releases, releaseId) => {
+  const release = releases.get(releaseId);
+  if (!release) {
+    throw new TypeError(`Missing retained mobile release ${releaseId}.`);
+  }
+  return release;
+};
+var loadServerApp = async (producerPath) => {
+  const loaded = await import(`${pathToFileURL2(producerPath).href}?absolute-mobile-capture=${crypto.randomUUID()}`);
+  const candidates = [loaded.server, loaded.app, loaded.default];
+  const app = candidates.find(isElysiaApp);
+  if (!app) {
+    throw new TypeError("Mobile builds require the server entry to export its Elysia app as server, app, or default.");
+  }
+  const exportName = serverExportName(loaded, app);
+  return { app, exportName };
+};
+var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
+  const buildDirectory = resolve8(options.buildDirectory);
+  const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
+  const root = join8(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const [manifestSource, previous] = await Promise.all([
+    readFile9(join8(buildDirectory, "manifest.json"), "utf8"),
+    readAbsoluteMobileMaterializedReleases(root)
+  ]);
+  const manifest = JSON.parse(manifestSource);
+  if (!isStringRecord(manifest)) {
+    throw new TypeError("Invalid AbsoluteJS build manifest for mobile capture.");
+  }
+  const previousBuildDirectory = process.env.ABSOLUTE_BUILD_DIR;
+  process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
+  let loaded;
+  try {
+    loaded = await loadServerApp(resolve8(options.producerPath));
+  } finally {
+    restoreBuildDirectory(previousBuildDirectory);
+  }
+  const current = await buildAbsoluteMobileCompatibilityRelease({
+    app: loaded.app,
+    appId: mobile.appId,
+    buildDirectory,
+    manifest,
+    previousArtifacts: previous.map(({ artifact }) => artifact),
+    producerExport: loaded.exportName,
+    producerPath: resolve8(options.producerPath),
+    runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
+  });
+  const releasesById = new Map([current, ...previous].map((release) => [
+    release.artifact.releaseId,
+    release
+  ]));
+  const retained = retainAbsoluteMobileCompatibilityArtifacts([...releasesById.values()].map(({ artifact }) => artifact));
+  await materializeAbsoluteMobileCompatibilityBundle({
+    currentReleaseId: current.artifact.releaseId,
+    releases: retained.map((artifact) => requireRelease(releasesById, artifact.releaseId)),
+    root
+  });
+  await materializeAbsoluteCapacitorWebBundle({
+    artifact: current.artifact,
+    buildDirectory,
+    config: mobile
+  });
+  return current.artifact;
+};
+// src/mobile/compatibilityDispatcher.ts
+import { Elysia as Elysia2 } from "elysia";
+
+// src/mobile/producerContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+var isProducerStorage = (value) => typeof value === "object" && value !== null && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";
+var getProducerStorage = () => {
+  const value = Reflect.get(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY);
+  return isProducerStorage(value) ? value : undefined;
+};
+var ensureProducerStorage = () => {
+  const existing = getProducerStorage();
+  if (existing)
+    return existing;
+  const storage = new AsyncLocalStorage;
+  Reflect.set(globalThis, ABSOLUTE_MOBILE_PRODUCER_STORAGE_KEY, storage);
+  return storage;
+};
+var runWithAbsoluteMobileProducer = (context, callback) => ensureProducerStorage().run(context, callback);
+
+// src/mobile/compatibilityDispatcher.ts
+var artifactOwnsRequest = (artifact, pageId, request) => {
+  const { pathname } = new URL(request.url);
+  return artifact.routes.some((route) => route.pageId === pageId && route.method === request.method && matchesAbsoluteMobileRoutePattern(route.pattern, pathname));
+};
+var createProducerResolver = (loadProducer) => {
+  const producers = new Map;
+  return (artifact) => {
+    const cached = producers.get(artifact.releaseId);
+    if (cached)
+      return cached;
+    const loading = loadProducer(artifact).catch((error) => {
+      producers.delete(artifact.releaseId);
+      throw error;
+    });
+    producers.set(artifact.releaseId, loading);
+    return loading;
+  };
+};
+var createAbsoluteMobileCompatibilityDispatcher = (options) => {
+  const artifacts = retainAbsoluteMobileCompatibilityArtifacts(options.artifacts);
+  if (!artifacts.some(({ releaseId }) => releaseId === options.currentReleaseId)) {
+    throw new TypeError("currentReleaseId must identify a retained compatibility artifact.");
+  }
+  const resolveProducer = createProducerResolver(options.loadProducer);
+  return new Elysia2({ name: "absolutejs-mobile-compatibility-dispatcher" }).request(async ({ request }) => {
+    if (getCurrentAbsoluteMobileProducerContext())
+      return;
+    const parsed = parseAbsoluteMobilePageRequest(request);
+    if (parsed.kind !== "mobile")
+      return;
+    const resolved = resolveAbsoluteMobileCompatibilityRelease(parsed.client, artifacts);
+    if (resolved.kind === "upgrade-required") {
+      return createAbsoluteMobileUpgradeResponse(resolved.result);
+    }
+    if (!artifactOwnsRequest(resolved.artifact, parsed.client.pageId, request)) {
+      return createAbsoluteMobileInvalidRequestResponse("The requested URL is not assigned to this mobile page.");
+    }
+    if (resolved.artifact.releaseId === options.currentReleaseId) {
+      return;
+    }
+    try {
+      const producer = await resolveProducer(resolved.artifact);
+      return runWithAbsoluteMobileProducer({
+        page: resolved.page,
+        releaseId: resolved.artifact.releaseId
+      }, () => producer.handle(request));
+    } catch (error) {
+      console.error(`[Mobile] Failed to load retained producer ${resolved.artifact.releaseId}:`, error);
+      return createAbsoluteMobilePageErrorResponse(parsed.client.pageId);
+    }
+  }).as("global");
+};
+// src/mobile/nativeDeepLinks.ts
+import { readFile as readFile10, rename as rename8, writeFile as writeFile8 } from "fs/promises";
+import { join as join9 } from "path";
+var START_MARKER = "<!-- absolutejs:deep-links:start -->";
+var END_MARKER = "<!-- absolutejs:deep-links:end -->";
+var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
+var NOT_FOUND = -1;
+var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var writeChangedFile = async (path, source) => {
+  const current = await readFile10(path, "utf8");
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile8(temporary, source, { flag: "wx" });
+  await rename8(temporary, path);
+  return true;
+};
+var replaceManagedRegion = (source, region, insertAt) => {
+  const start = source.indexOf(START_MARKER);
+  const end = source.indexOf(END_MARKER);
+  if (start === NOT_FOUND !== (end === NOT_FOUND) || start !== NOT_FOUND && end < start) {
+    throw new TypeError("AbsoluteJS deep-link ownership markers are malformed.");
+  }
+  if (start !== NOT_FOUND) {
+    const lineStart = source.lastIndexOf(`
+`, start) + 1;
+    const nextLine = source.indexOf(`
+`, end + END_MARKER.length);
+    const lineEnd = nextLine === NOT_FOUND ? source.length : nextLine + 1;
+    return `${source.slice(0, lineStart)}${region}${source.slice(lineEnd)}`;
+  }
+  const index = insertAt();
+  if (index === NOT_FOUND) {
+    throw new TypeError("Could not find a safe native project location for deep-link configuration.");
+  }
+  return `${source.slice(0, index)}${region}${source.slice(index)}`;
+};
+var androidRegion = (config) => {
+  const hosts = config.deepLinkHosts.map((host) => `                <data android:scheme="https" android:host="${escapeXml(host)}" />`).join(`
+`);
+  const customScheme = config.deepLinkScheme ? `
+
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="${escapeXml(config.deepLinkScheme)}" />
+            </intent-filter>` : "";
+  return `            ${START_MARKER}
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+${hosts}
+            </intent-filter>${customScheme}
+            ${END_MARKER}
+`;
+};
+var configureAndroid = async (config) => {
+  const path = join9(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile10(path, "utf8");
+  const mainActivity = source.indexOf('android:name=".MainActivity"');
+  if (mainActivity === NOT_FOUND) {
+    throw new TypeError("Android MainActivity was not found.");
+  }
+  const activityEnd = source.indexOf("</activity>", mainActivity);
+  const updated = replaceManagedRegion(source, androidRegion(config), () => activityEnd === NOT_FOUND ? NOT_FOUND : source.lastIndexOf(`
+`, activityEnd) + 1);
+  return writeChangedFile(path, updated);
+};
+var iosSchemeRegion = (scheme) => `	${START_MARKER}
+	<key>CFBundleURLTypes</key>
+	<array>
+		<dict>
+			<key>CFBundleURLName</key>
+			<string>absolutejs</string>
+			<key>CFBundleURLSchemes</key>
+			<array>
+				<string>${escapeXml(scheme)}</string>
+			</array>
+		</dict>
+	</array>
+	${END_MARKER}
+`;
+var configureIosInfo = async (config) => {
+  const path = join9(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile10(path, "utf8");
+  const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
+	${END_MARKER}
+`;
+  const updated = replaceManagedRegion(source, region, () => source.lastIndexOf("</dict>"));
+  return writeChangedFile(path, updated);
+};
+var iosEntitlementsSource = (config) => {
+  const domains = config.deepLinkHosts.map((host) => `		<string>applinks:${escapeXml(host)}</string>`).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.developer.associated-domains</key>
+	<array>
+${domains}
+	</array>
+</dict>
+</plist>
+`;
+};
+var configureIosEntitlements = async (config) => {
+  const path = join9(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  let current = "";
+  try {
+    current = await readFile10(path, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const source = iosEntitlementsSource(config);
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile8(temporary, source, { flag: "wx" });
+  await rename8(temporary, path);
+  return true;
+};
+var configureIosProject = async (config) => {
+  const path = join9(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const source = await readFile10(path, "utf8");
+  const declarations = [
+    ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
+  ].map((match) => match[1]);
+  if (declarations.some((value) => value !== IOS_ENTITLEMENTS)) {
+    throw new TypeError("The iOS target already uses a different entitlements file; merge associated domains there before continuing.");
+  }
+  if (declarations.length > 0)
+    return false;
+  let count = 0;
+  const updated = source.replaceAll("INFOPLIST_FILE = App/Info.plist;", () => {
+    count += 1;
+    return `CODE_SIGN_ENTITLEMENTS = ${IOS_ENTITLEMENTS};
+				INFOPLIST_FILE = App/Info.plist;`;
+  });
+  if (count === 0) {
+    throw new TypeError("The iOS application target build settings were not found.");
+  }
+  return writeChangedFile(path, updated);
+};
+var configureIos = async (config) => {
+  const changed = await Promise.all([
+    configureIosInfo(config),
+    configureIosEntitlements(config),
+    configureIosProject(config)
+  ]);
+  return changed.some(Boolean);
+};
+var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms) => {
+  const results = await Promise.all(platforms.map(async (platform) => {
+    const didChange = platform === "android" ? await configureAndroid(config) : await configureIos(config);
+    return { didChange, platform };
+  }));
+  return {
+    changed: results.filter(({ didChange }) => didChange).map(({ platform }) => platform)
+  };
+};
+// src/mobile/routeMetadataTransform.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname5, extname as extname2, relative as relative5, resolve as resolve9 } from "path";
+import ts from "typescript";
+var ROUTE_METHODS = new Set(["get", "head"]);
+var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
+var PAGE_HANDLER = "handleReactPageRequest";
+var posixPath = (value) => value.replace(/\\/g, "/");
+var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname5(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var createProgram = (entry, projectRoot) => {
+  const configPath = findTsconfig(entry, projectRoot);
+  if (!configPath) {
+    return ts.createProgram([entry], {
+      allowJs: true,
+      jsx: ts.JsxEmit.ReactJSX,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      target: ts.ScriptTarget.ESNext
+    });
+  }
+  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync2(path, "utf8")).config, ts.sys, dirname5(configPath));
+  if (!parsed.fileNames.includes(entry))
+    parsed.fileNames.push(entry);
+  return ts.createProgram(parsed.fileNames, parsed.options);
+};
+var propertyName = (property) => {
+  if (!("name" in property) || !property.name)
+    return;
+  if (ts.isIdentifier(property.name))
+    return property.name.text;
+  if (ts.isStringLiteralLike(property.name))
+    return property.name.text;
+  return;
+};
+var objectPropertyExpression = (object, name) => {
+  const property = object.properties.find((candidate) => propertyName(candidate) === name);
+  if (property && ts.isPropertyAssignment(property)) {
+    return property.initializer;
+  }
+  if (property && ts.isShorthandPropertyAssignment(property)) {
+    return property.name;
+  }
+  return;
+};
+var serializeType = (type, checker, ancestors = new Set) => {
+  if (type.flags & ts.TypeFlags.Any)
+    return { type: "any" };
+  if (type.flags & ts.TypeFlags.Unknown)
+    return { type: "unknown" };
+  if (type.flags & ts.TypeFlags.Never)
+    return { type: "never" };
+  if (type.flags & ts.TypeFlags.StringLike)
+    return { type: "string" };
+  if (type.flags & ts.TypeFlags.NumberLike)
+    return { type: "number" };
+  if (type.flags & ts.TypeFlags.BooleanLike)
+    return { type: "boolean" };
+  if (type.flags & ts.TypeFlags.BigIntLike)
+    return { type: "bigint" };
+  if (type.flags & ts.TypeFlags.Null)
+    return { type: "null" };
+  if (type.flags & ts.TypeFlags.Undefined)
+    return { type: "undefined" };
+  if (type.isUnion()) {
+    return {
+      anyOf: type.types.map((member) => serializeType(member, checker, ancestors)).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))
+    };
+  }
+  if (type.isIntersection()) {
+    return {
+      allOf: type.types.map((member) => serializeType(member, checker, ancestors)).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))
+    };
+  }
+  if (ancestors.has(type)) {
+    return {
+      ref: checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)
+    };
+  }
+  ancestors.add(type);
+  const arrayElement = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+  const properties = checker.getPropertiesOfType(type);
+  let schema;
+  if (arrayElement && properties.some(({ name }) => name === "length")) {
+    schema = {
+      items: serializeType(arrayElement, checker, ancestors),
+      type: "array"
+    };
+  } else if (properties.length > 0) {
+    const entries = properties.filter(({ name }) => !name.startsWith("__")).map((property) => {
+      const declaration = property.valueDeclaration ?? property.declarations?.[0];
+      const propertyType = declaration ? checker.getTypeOfSymbolAtLocation(property, declaration) : checker.getDeclaredTypeOfSymbol(property);
+      return [
+        property.name,
+        {
+          optional: Boolean(property.flags & ts.SymbolFlags.Optional),
+          schema: serializeType(propertyType, checker, ancestors)
+        }
+      ];
+    }).sort(([left], [right]) => left.localeCompare(right));
+    schema = { properties: Object.fromEntries(entries), type: "object" };
+  } else {
+    schema = {
+      type: checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)
+    };
+  }
+  ancestors.delete(type);
+  return schema;
+};
+var pagePropsType = (pageExpression, propsExpression, checker) => {
+  const pageType = checker.getTypeAtLocation(pageExpression);
+  const [signature] = pageType.getCallSignatures();
+  const [parameter] = signature?.parameters ?? [];
+  const declaration = parameter?.valueDeclaration ?? parameter?.declarations?.[0];
+  if (parameter && declaration) {
+    return checker.getTypeOfSymbolAtLocation(parameter, declaration);
+  }
+  return propsExpression ? checker.getTypeAtLocation(propsExpression) : checker.getTypeAtLocation(pageExpression);
+};
+var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
+  let symbol = checker.getSymbolAtLocation(expression);
+  if (symbol?.flags && symbol.flags & ts.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
+  }
+  const declaration = symbol?.declarations?.[0];
+  const file = declaration?.getSourceFile().fileName ?? sourceFile.fileName;
+  const exportedName = symbol?.name ?? expression.getText(sourceFile);
+  const source = posixPath(relative5(projectRoot, file));
+  return `${source}#${exportedName}`;
+};
+var resolveAlias = (symbol, checker) => {
+  if (!(symbol.flags & ts.SymbolFlags.Alias))
+    return symbol;
+  return checker.getAliasedSymbol(symbol);
+};
+var assetKey = (expression, checker, seen = new Set) => {
+  if (!expression)
+    return;
+  if (ts.isIdentifier(expression)) {
+    const unresolved = ts.isShorthandPropertyAssignment(expression.parent) ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
+    if (!unresolved)
+      return;
+    const symbol = resolveAlias(unresolved, checker);
+    if (seen.has(symbol))
+      return;
+    seen.add(symbol);
+    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    if (!declaration || !ts.isVariableDeclaration(declaration))
+      return;
+    return assetKey(declaration.initializer, checker, seen);
+  }
+  if (!ts.isCallExpression(expression))
+    return;
+  if (!ts.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
+    return;
+  }
+  const [, key] = expression.arguments;
+  return key && ts.isStringLiteralLike(key) ? key.text : undefined;
+};
+var findPageCall = (nodes) => {
+  let found;
+  const visit = (candidate) => {
+    if (found)
+      return;
+    if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && candidate.expression.text === PAGE_HANDLER) {
+      found = candidate;
+      return;
+    }
+    ts.forEachChild(candidate, visit);
+  };
+  for (const node of nodes)
+    visit(node);
+  return found;
+};
+var isProjectSource = (sourceFile, resolvedFile, projectRoot) => !sourceFile.isDeclarationFile && !resolvedFile.includes("/node_modules/") && resolvedFile.startsWith(`${projectRoot}/`);
+var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
+  const callee = node.expression;
+  if (!ts.isPropertyAccessExpression(callee))
+    return;
+  if (!ROUTE_METHODS.has(callee.name.text))
+    return;
+  const [routePath] = node.arguments;
+  if (!routePath || !ts.isStringLiteralLike(routePath))
+    return;
+  const pageCall = findPageCall(node.arguments.slice(1));
+  const [input] = pageCall?.arguments ?? [];
+  if (!pageCall || !input || !ts.isObjectLiteralExpression(input)) {
+    return;
+  }
+  const page = objectPropertyExpression(input, "Page");
+  if (!page)
+    return;
+  const props = objectPropertyExpression(input, "props");
+  const index = objectPropertyExpression(input, "index");
+  const bundleKey = assetKey(index, checker);
+  if (!bundleKey)
+    return;
+  const pageId = resolvePageIdentity(page, sourceFile, checker, projectRoot);
+  const schema = serializeType(pagePropsType(page, props, checker), checker);
+  const propsSchemaHash = hashAbsoluteMobilePropsSchema(schema);
+  const metadata = {
+    bundleKey,
+    contract: `react:${pageId}:${propsSchemaHash}`,
+    framework: "react",
+    pageId,
+    propsSchemaHash
+  };
+  const result = {
+    metadata,
+    pageCallStart: pageCall.getStart(sourceFile),
+    routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
+  };
+  return result;
+};
+var analyzeSourceFile = (sourceFile, checker, projectRoot) => {
+  const analysis = {
+    byPageCall: new Map,
+    byRouteCall: new Map
+  };
+  const visit = (node) => {
+    const result = ts.isCallExpression(node) ? analyzeRouteCall(node, sourceFile, checker, projectRoot) : undefined;
+    if (result) {
+      analysis.byPageCall.set(result.pageCallStart, result);
+      analysis.byRouteCall.set(result.routeCallSpan, result);
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(sourceFile, visit);
+  return analysis;
+};
+var analyzeProgram = (program, projectRoot) => {
+  const checker = program.getTypeChecker();
+  const analyzed = new Map;
+  for (const sourceFile of program.getSourceFiles()) {
+    const resolvedFile = resolve9(sourceFile.fileName);
+    if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
+      continue;
+    const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
+    if (analysis.byPageCall.size > 0)
+      analyzed.set(resolvedFile, analysis);
+  }
+  return analyzed;
+};
+var metadataExpression = (metadata) => ts.factory.createObjectLiteralExpression(Object.entries(metadata).map(([key, item]) => ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(key), ts.factory.createStringLiteral(item))), false);
+var routeOptions = (existing, metadata) => {
+  const detail = ts.factory.createObjectLiteralExpression([
+    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
+  ]);
+  if (!existing) {
+    return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("detail", detail)
+    ]);
+  }
+  return ts.factory.createObjectLiteralExpression([
+    ts.factory.createSpreadAssignment(existing),
+    ts.factory.createPropertyAssignment("detail", ts.factory.createObjectLiteralExpression([
+      ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(existing, "detail")),
+      ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
+    ]))
+  ]);
+};
+var transformPageCall = (node, page) => {
+  if (!page)
+    return;
+  const [input] = node.arguments;
+  if (!input || !ts.isObjectLiteralExpression(input))
+    return;
+  return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+    ts.factory.updateObjectLiteralExpression(input, [
+      ...input.properties,
+      ts.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+    ]),
+    ...node.arguments.slice(1)
+  ]);
+};
+var transformRouteCall = (node, route) => {
+  if (!route)
+    return;
+  const [path, maybeOptions, maybeHandler, ...rest] = node.arguments;
+  if (!path || !maybeOptions)
+    return;
+  const options = maybeHandler ? maybeOptions : undefined;
+  const handler = maybeHandler ?? maybeOptions;
+  return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [path, routeOptions(options, route.metadata), handler, ...rest]);
+};
+var transformFile = (source, fileName, analysis) => {
+  const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const transformer = (context) => {
+    const visit = (node) => {
+      if (!ts.isCallExpression(node)) {
+        return ts.visitEachChild(node, visit, context);
+      }
+      const transformedChildren = ts.visitEachChild(node, visit, context);
+      const page = analysis.byPageCall.get(node.getStart(sourceFile));
+      const transformedPage = transformPageCall(transformedChildren, page);
+      if (transformedPage)
+        return transformedPage;
+      const route = analysis.byRouteCall.get(`${node.getStart(sourceFile)}:${node.end}`);
+      const transformedRoute = transformRouteCall(transformedChildren, route);
+      if (transformedRoute)
+        return transformedRoute;
+      return transformedChildren;
+    };
+    return (node) => ts.visitNode(node, visit, ts.isSourceFile) ?? node;
+  };
+  const result = ts.transform(sourceFile, [transformer]);
+  try {
+    const [transformed] = result.transformed;
+    if (!transformed)
+      throw new TypeError("Mobile route transform failed.");
+    return ts.createPrinter().printFile(transformed);
+  } finally {
+    result.dispose();
+  }
+};
+var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
+var createAbsoluteMobileRouteMetadataPlugin = (options) => {
+  const projectRoot = resolve9(options.projectRoot ?? process.cwd());
+  const entry = resolve9(options.entry);
+  const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
+  return {
+    name: "absolute-mobile-route-metadata",
+    setup(build) {
+      build.onLoad({ filter: SOURCE_FILTER }, async ({ path }) => {
+        const analysis = analyzed.get(resolve9(path));
+        if (!analysis)
+          return;
+        const source = await Bun.file(path).text();
+        return {
+          contents: transformFile(source, path, analysis),
+          loader: extname2(path).endsWith("x") ? "tsx" : "ts"
+        };
+      });
+    }
+  };
+};
+var inspectAbsoluteMobileRouteMetadata = (options) => {
+  const projectRoot = resolve9(options.projectRoot ?? process.cwd());
+  const entry = resolve9(options.entry);
+  const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
+  return [...analyzed.entries()].flatMap(([file, analysis]) => [...analysis.byRouteCall.values()].map(({ metadata }) => ({
+    file: posixPath(relative5(projectRoot, file)),
+    metadata
+  })));
+};
+export {
+  writeAbsoluteCapacitorConfig,
+  verifyAbsoluteMobileCompatibilityProducer,
+  verifyAbsoluteMobileAssociationFiles,
+  runWithAbsoluteMobileProducer,
+  retainAbsoluteMobileCompatibilityArtifacts,
+  resolveAbsoluteMobileRoute,
+  resolveAbsoluteMobileDeepLink,
+  resolveAbsoluteMobileCompatibilityRelease,
+  readAbsoluteMobileMaterializedReleases,
+  parseAbsoluteMobilePageRequest,
+  parseAbsoluteMobilePageEnvelope,
+  parseAbsoluteMobileCompatibilityArtifact,
+  parseAbsoluteMobileBuildPageMetadata,
+  normalizeAbsoluteMobileConfig,
+  navigateAbsoluteMobilePage,
+  materializeAbsoluteMobileCompatibilityBundle,
+  materializeAbsoluteMobileAssociationFiles,
+  materializeAbsoluteCapacitorWebBundle,
+  matchesAbsoluteMobileRoutePattern,
+  loadAbsoluteMobileMaterializedBundle,
+  inspectAbsoluteMobileRouteMetadata,
+  hashAbsoluteMobilePropsSchema,
+  getCurrentAbsoluteMobileProducerContext,
+  finalizeAbsoluteMobilePage,
+  finalizeAbsoluteMobileCompatibilityBuild,
+  fetchAbsoluteMobilePage,
+  createAbsoluteMobileUpgradeResponse,
+  createAbsoluteMobileRouteMetadataPlugin,
+  createAbsoluteMobilePageRequest,
+  createAbsoluteMobilePageErrorResponse,
+  createAbsoluteMobileInvalidRequestResponse,
+  createAbsoluteMobileFileArtifactStore,
+  createAbsoluteMobileCompatibilityDispatcher,
+  createAbsoluteMobileCompatibilityArtifact,
+  createAbsoluteMobileBlobArtifactStore,
+  createAbsoluteMobileAssociationPlugin,
+  createAbsoluteMobileAssociationDocuments,
+  carryForwardAbsoluteMobileCompatibilityReleases,
+  captureAbsoluteMobileRouteGraph,
+  buildAbsoluteMobileCompatibilityRelease,
+  buildAbsoluteAndroidRelease,
+  applyAbsoluteNativeDeepLinks,
+  activateAbsoluteMobilePage,
+  acceptsAbsoluteMobilePage,
+  MOBILE_PAGE_REQUEST_HEADERS,
+  AbsoluteMobilePageProtocolError,
+  APPLE_ASSOCIATION_PATH,
+  ANDROID_ASSOCIATION_PATH,
+  ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL,
+  ABSOLUTE_MOBILE_ROUTE_DETAIL,
+  ABSOLUTE_MOBILE_RETAINED_GENERATIONS,
+  ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION,
+  ABSOLUTE_MOBILE_PAGE_MEDIA_TYPE,
+  ABSOLUTE_MOBILE_MATERIALIZED_BUNDLE_FORMAT,
+  ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT,
+  ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
+  ABSOLUTE_ANDROID_RELEASE_FORMAT
+};
+
+//# debugId=EC6A042BA6D550B864756E2164756E21
+//# sourceMappingURL=index.js.map