@absolutejs/absolute 0.20.0-beta.17 → 0.20.0-beta.19

package/dist/mobile/index.js

@@ -3927,7 +3927,7 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
 };
 // src/mobile/buildPipeline.ts
 import { readFile as readFile13 } from "fs/promises";
-import { join as join13, resolve as resolve11 } from "path";
+import { join as join14, resolve as resolve12 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
@@ -4598,16 +4598,51 @@ var sourceAssetPath = (buildDirectory, bundlePath) => {
   }
   return asset;
 };
-var buildShellBootstrap = async (staging, auth, sync) => {
+var importEntryTarget = (entry) => {
+  if (typeof entry === "string")
+    return entry;
+  if (typeof entry === "object" && entry !== null)
+    return Reflect.get(entry, "import");
+  return;
+};
+var resolveProjectImport = async (projectRoot, specifier) => {
+  const segments = specifier.split("/");
+  const packageName = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0] ?? "";
+  const subpath = specifier.slice(packageName.length);
+  const packageDirectory = join9(resolve9(projectRoot), "node_modules", packageName);
+  const manifest = JSON.parse(await readFile11(join9(packageDirectory, "package.json"), "utf8"));
+  const exports = typeof manifest === "object" && manifest !== null ? Reflect.get(manifest, "exports") : undefined;
+  const entry = typeof exports === "object" && exports !== null ? Reflect.get(exports, subpath ? `.${subpath}` : ".") : undefined;
+  const target = importEntryTarget(entry);
+  if (typeof target !== "string" || !target.startsWith("./"))
+    throw new TypeError(`${specifier} does not publish an import entry.`);
+  const resolved = resolve9(packageDirectory, target);
+  if (!resolved.startsWith(`${resolve9(packageDirectory)}/`))
+    throw new TypeError(`${specifier} has an unsafe import entry.`);
+  return resolved;
+};
+var buildShellBootstrap = async (staging, auth, sync, storagePrefix, deviceCapabilities, projectRoot) => {
   const modulePath = shellBootstrapModule();
   const authImport = auth ? `import { createAbsoluteMobileShellAuth } from ${JSON.stringify(shellAuthModule())};
 ` : "";
   const options = auth ? `{ createAuth: createAbsoluteMobileShellAuth${sync ? ", installSync: installAbsoluteMobileShellSync" : ""} }` : "";
   const syncImport = sync ? `import { installAbsoluteMobileShellSync } from ${JSON.stringify(shellSyncModule())};
 ` : "";
+  const capabilityImports = (await Promise.all(deviceCapabilities.capabilities.map(async (name, index) => {
+    const provider = deviceCapabilities.providers[name];
+    if (!provider)
+      throw new TypeError(`Missing device capability provider ${name}.`);
+    return `import { ${provider.factory} as absoluteDeviceCapability${index} } from ${JSON.stringify(await resolveProjectImport(projectRoot, provider.module))};`;
+  }))).join(`
+`);
+  const capabilityOptions = deviceCapabilities.capabilities.map((name, index) => `${JSON.stringify(name)}: absoluteDeviceCapability${index}()`).join(", ");
   const entryPath = join9(staging, ".absolute-mobile-entry.ts");
+  const baseAdapterModule = await resolveProjectImport(projectRoot, "@absolutejs/devices-capacitor");
   await writeFile10(entryPath, `import { startAbsoluteMobileShell } from ${JSON.stringify(modulePath)};
-${authImport}${syncImport}void startAbsoluteMobileShell(${options});
+import { installCapacitorDeviceAdapterIfNative } from ${JSON.stringify(baseAdapterModule)};
+${authImport}${syncImport}${capabilityImports}
+installCapacitorDeviceAdapterIfNative({ storagePrefix: ${JSON.stringify(storagePrefix)}${capabilityOptions ? `, ${capabilityOptions}` : ""} });
+void startAbsoluteMobileShell(${options});
 `);
   const build = await Bun.build({
     entrypoints: [entryPath],
@@ -4745,6 +4780,7 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       appName: options.config.appName,
       deepLinkHosts: options.config.deepLinkHosts,
       deepLinkScheme: options.config.deepLinkScheme,
+      deviceCapabilities: options.deviceCapabilities.capabilities,
       entry: options.config.entry,
       format: ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT,
       pages,
@@ -4770,7 +4806,7 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
       writeFile10(join9(staging, MANIFEST_FILE), `${JSON.stringify(manifest, null, "\t")}
 `),
       writeFile10(join9(staging, INDEX_FILE), indexHtml(options.config.appName)),
-      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true)
+      buildShellBootstrap(staging, options.auth !== undefined, options.auth !== undefined && options.sync === true, `absolutejs.${options.auth?.clientId ?? options.config.appId}.`, options.deviceCapabilities, options.projectRoot)
     ]);
     await installBundle(staging, destination);
     return manifest;
@@ -5011,6 +5047,216 @@ var serializeAbsoluteMobileAuthEnvironment = (config, auth) => auth === undefine
 
 // src/mobile/buildPipeline.ts
 init_syncSchema();
+
+// src/mobile/deviceCapabilities.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { extname as extname3, join as join13, relative as relative9, resolve as resolve11 } from "path";
+import ts from "typescript";
+var DEVICES_PACKAGE = "@absolutejs/devices";
+var CAPACITOR_ADAPTER = "@absolutejs/devices-capacitor";
+var SOURCE_GLOB = new Bun.Glob("**/*.{js,jsx,ts,tsx,svelte,vue}");
+var IGNORED_DIRECTORIES = new Set([
+  ".absolutejs",
+  ".git",
+  ".test-builds",
+  ".test-shards",
+  "build",
+  "dist",
+  "node_modules",
+  "test",
+  "tests"
+]);
+var IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/u;
+var CAPACITOR_MODULE_PATTERN = /^@absolutejs\/devices-capacitor\/[a-z][a-z0-9-]*$/u;
+var CAPACITOR_PACKAGE_PATTERN = /^@capacitor\/[a-z][a-z0-9-]*@\d+\.\d+\.\d+$/u;
+var ANDROID_PERMISSION_PATTERN = /^android\.permission\.[A-Z][A-Z0-9_]*$/u;
+var IOS_USAGE_DESCRIPTIONS = new Set([
+  "camera",
+  "photo-library",
+  "photo-library-add"
+]);
+var object2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readJson = (path) => {
+  const value = JSON.parse(readFileSync4(path, "utf8"));
+  if (!object2(value))
+    throw new TypeError(`${path} must contain an object.`);
+  return value;
+};
+var text = (value, field) => {
+  if (typeof value !== "string" || value.length === 0)
+    throw new TypeError(`${field} must be a non-empty string.`);
+  return value;
+};
+var androidPermissions = (value, field) => {
+  if (value === undefined)
+    return;
+  if (!object2(value))
+    throw new TypeError(`${field} must be an object.`);
+  const { permissions } = value;
+  if (!Array.isArray(permissions) || !permissions.every((permission) => typeof permission === "string" && ANDROID_PERMISSION_PATTERN.test(permission)))
+    throw new TypeError(`${field}.permissions must contain Android permission names.`);
+  return [...permissions];
+};
+var iosUsageDescriptions = (value, field) => {
+  if (value === undefined)
+    return;
+  if (!object2(value))
+    throw new TypeError(`${field} must be an object.`);
+  const { usageDescriptions } = value;
+  if (!Array.isArray(usageDescriptions) || !usageDescriptions.every((purpose) => typeof purpose === "string" && IOS_USAGE_DESCRIPTIONS.has(purpose)))
+    throw new TypeError(`${field}.usageDescriptions contains an unsupported purpose.`);
+  return [...usageDescriptions];
+};
+var parseProvider = (name, value) => {
+  if (!IDENTIFIER_PATTERN.test(name))
+    throw new TypeError("Device capability names must be identifiers.");
+  if (!object2(value))
+    throw new TypeError(`Device capability ${name} must be an object.`);
+  const factory = text(value.factory, `${name}.factory`);
+  const module = text(value.module, `${name}.module`);
+  if (!IDENTIFIER_PATTERN.test(factory))
+    throw new TypeError(`${name}.factory must be a JavaScript identifier.`);
+  if (!CAPACITOR_MODULE_PATTERN.test(module))
+    throw new TypeError(`${name}.module must be an official devices-capacitor subpath.`);
+  if (!Array.isArray(value.packages) || !value.packages.every((spec) => typeof spec === "string" && CAPACITOR_PACKAGE_PATTERN.test(spec)))
+    throw new TypeError(`${name}.packages must contain exact official Capacitor package versions.`);
+  let native;
+  const { native: nativeMetadata } = value;
+  if (nativeMetadata !== undefined) {
+    if (!object2(nativeMetadata))
+      throw new TypeError(`${name}.native must be an object.`);
+    const { android, ios } = nativeMetadata;
+    const permissions = androidPermissions(android, `${name}.native.android`);
+    const usageDescriptions = iosUsageDescriptions(ios, `${name}.native.ios`);
+    native = {
+      ...permissions === undefined ? {} : { android: { permissions } },
+      ...usageDescriptions === undefined ? {} : { ios: { usageDescriptions } }
+    };
+  }
+  return {
+    factory,
+    module,
+    ...native === undefined ? {} : { native },
+    packages: [...value.packages]
+  };
+};
+var absoluteDeviceNativeRequirements = (plan) => ({
+  androidPermissions: [
+    ...new Set(plan.capabilities.flatMap((name) => plan.providers[name]?.native?.android?.permissions ?? []))
+  ].sort(),
+  iosUsageDescriptions: [
+    ...new Set(plan.capabilities.flatMap((name) => plan.providers[name]?.native?.ios?.usageDescriptions ?? []))
+  ].sort()
+});
+var loadAbsoluteDeviceCapabilityProviders = (projectRoot) => {
+  const path = join13(resolve11(projectRoot), "node_modules", CAPACITOR_ADAPTER, "package.json");
+  const manifest = readJson(path);
+  const { absolutejs } = manifest;
+  const devices = object2(absolutejs) ? absolutejs.devices : undefined;
+  if (!object2(devices) || devices.format !== 1 || devices.provider !== "capacitor" || !object2(devices.capabilities))
+    throw new TypeError(`${CAPACITOR_ADAPTER} does not publish supported capability metadata.`);
+  const entries = Object.entries(devices.capabilities).map(([name, provider]) => ({
+    name,
+    provider: parseProvider(name, provider)
+  }));
+  return Object.fromEntries(entries.sort((left, right) => left.name.localeCompare(right.name)).map(({ name, provider }) => [name, provider]));
+};
+var isIgnored = (path) => path.split("/").some((segment) => IGNORED_DIRECTORIES.has(segment));
+var importedCapabilities = (source, file) => {
+  const names = new Set;
+  const namespaces = new Set;
+  const visit = (node) => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && !node.importClause?.isTypeOnly) {
+      const bindings = node.importClause?.namedBindings;
+      if (bindings && ts.isNamedImports(bindings)) {
+        for (const element of bindings.elements)
+          if (!element.isTypeOnly)
+            names.add((element.propertyName ?? element.name).text);
+      }
+      if (bindings && ts.isNamespaceImport(bindings))
+        namespaces.add(bindings.name.text);
+    }
+    if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== undefined && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === DEVICES_PACKAGE && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const element of node.exportClause.elements)
+        if (!element.isTypeOnly)
+          names.add((element.propertyName ?? element.name).text);
+    }
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && namespaces.has(node.expression.text))
+      names.add(node.name.text);
+    ts.forEachChild(node, visit);
+  };
+  const extension = extname3(file).toLowerCase();
+  const sources = extension === ".svelte" || extension === ".vue" ? [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/giu)].map((match) => match[1]).filter((value) => value !== undefined) : [source];
+  for (const [index, script] of sources.entries())
+    visit(ts.createSourceFile(`${file}#script-${index}`, script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX));
+  return names;
+};
+var assertAbsoluteDeviceCapabilityPackages = (projectRoot, plan) => {
+  const missing = missingAbsoluteDeviceCapabilityPackages(plan, directAbsoluteProjectPackages(projectRoot));
+  const mismatched = plan.requiredPackages.filter((spec) => {
+    const separator = spec.lastIndexOf("@");
+    const packageName = spec.slice(0, separator);
+    if (missing.includes(spec))
+      return false;
+    try {
+      return readJson(join13(resolve11(projectRoot), "node_modules", packageName, "package.json")).version !== spec.slice(separator + 1);
+    } catch {
+      return true;
+    }
+  });
+  const unmet = [...missing, ...mismatched];
+  if (unmet.length > 0)
+    throw new TypeError(`Device capabilities ${plan.capabilities.join(", ")} require ${unmet.join(", ")}. Run absolute mobile sync and approve the detected capability plugins.`);
+};
+var directAbsoluteProjectPackages = (projectRoot) => {
+  const manifest = readJson(join13(resolve11(projectRoot), "package.json"));
+  const packages = new Set;
+  for (const field of ["dependencies", "devDependencies"]) {
+    const dependencies = manifest[field];
+    if (object2(dependencies))
+      for (const name of Object.keys(dependencies))
+        packages.add(name);
+  }
+  return packages;
+};
+var discoverAbsoluteDeviceCapabilities = (projectRoot, providers = loadAbsoluteDeviceCapabilityProviders(projectRoot)) => {
+  const root = resolve11(projectRoot);
+  const known = new Set(Object.keys(providers));
+  const capabilities = new Set;
+  for (const path of SOURCE_GLOB.scanSync({ cwd: root })) {
+    const portable = relative9(root, resolve11(root, path)).replaceAll("\\", "/");
+    if (isIgnored(portable))
+      continue;
+    const source = readFileSync4(resolve11(root, portable), "utf8");
+    for (const name of importedCapabilities(source, portable))
+      if (known.has(name))
+        capabilities.add(name);
+  }
+  return [...capabilities].sort();
+};
+var missingAbsoluteDeviceCapabilityPackages = (plan, directPackages) => plan.requiredPackages.filter((spec) => {
+  const packageName = spec.slice(0, spec.lastIndexOf("@"));
+  return !directPackages.has(packageName);
+});
+var resolveAbsoluteDeviceCapabilityPlan = (projectRoot) => {
+  const allProviders = loadAbsoluteDeviceCapabilityProviders(projectRoot);
+  const capabilities = discoverAbsoluteDeviceCapabilities(projectRoot, allProviders);
+  const providers = {};
+  for (const name of capabilities) {
+    const provider = allProviders[name];
+    if (provider)
+      providers[name] = provider;
+  }
+  return {
+    capabilities,
+    providers,
+    requiredPackages: [
+      ...new Set(capabilities.flatMap((name) => providers[name]?.packages ?? []))
+    ].sort()
+  };
+};
+
+// 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) => {
@@ -5044,11 +5290,11 @@ var loadServerApp = async (producerPath) => {
   return { app, exportName };
 };
 var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve11(options.buildDirectory);
+  const buildDirectory = resolve12(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join13(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join14(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile13(join13(buildDirectory, "manifest.json"), "utf8"),
+    readFile13(join14(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -5061,11 +5307,11 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
   process.env.ABSOLUTE_COMPILED_RUNTIME = "1";
   if (options.configPath) {
-    process.env.ABSOLUTE_CONFIG = resolve11(options.projectRoot, options.configPath);
+    process.env.ABSOLUTE_CONFIG = resolve12(options.projectRoot, options.configPath);
   }
   let loaded;
   try {
-    loaded = await loadServerApp(resolve11(options.producerPath));
+    loaded = await loadServerApp(resolve12(options.producerPath));
   } finally {
     restoreEnvironmentVariable("ABSOLUTE_BUILD_DIR", previousBuildDirectory);
     restoreEnvironmentVariable("ABSOLUTE_COMPILED_RUNTIME", previousCompiledRuntime);
@@ -5078,12 +5324,14 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve11(options.producerPath),
+    producerPath: resolve12(options.producerPath),
     runtime: String(ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION)
   });
   const auth = resolveAbsoluteMobileAuthManifest(options.projectRoot, mobile);
   const sync = auth !== undefined && projectUsesAbsoluteSync(options.projectRoot);
   const syncSchema = sync ? discoverAbsoluteSyncSchema(options.projectRoot) : undefined;
+  const deviceCapabilities = resolveAbsoluteDeviceCapabilityPlan(options.projectRoot);
+  assertAbsoluteDeviceCapabilityPackages(options.projectRoot, deviceCapabilities);
   if (auth && !loaded.app.routes.some((route) => route.path === "/.well-known/openid-configuration")) {
     throw new TypeError("@absolutejs/auth is installed, but its OIDC provider is not mounted. Native authentication requires the auth oidc configuration so AbsoluteJS can provision a public PKCE client.");
   }
@@ -5102,6 +5350,8 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     ...auth ? { auth } : {},
     buildDirectory,
     config: mobile,
+    deviceCapabilities,
+    projectRoot: options.projectRoot,
     ...sync ? { sync: true } : {},
     ...syncSchema ? { syncSchema: { components: syncSchema.components } } : {}
   });
@@ -5359,7 +5609,7 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
 };
 // src/mobile/nativeDeepLinks.ts
 import { readFile as readFile14, rename as rename11, writeFile as writeFile12 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->";
 var END_MARKER = "<!-- absolutejs:deep-links:end -->";
 var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
@@ -5416,7 +5666,7 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join14(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const path = join15(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
   const source = await readFile14(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
@@ -5442,7 +5692,7 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join14(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const path = join15(config.nativeProjectDirectory, "ios/App/App/Info.plist");
   const source = await readFile14(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
@@ -5466,7 +5716,7 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join14(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join15(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
     current = await readFile14(path, "utf8");
@@ -5484,7 +5734,7 @@ var configureIosEntitlements = async (config) => {
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join14(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const path = join15(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
   const source = await readFile14(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
@@ -5522,9 +5772,93 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
     changed: results.filter(({ didChange }) => didChange).map(({ platform }) => platform)
   };
 };
+// src/mobile/nativeDeviceCapabilities.ts
+import { readFile as readFile15, rename as rename12, writeFile as writeFile13 } from "fs/promises";
+import { join as join16 } from "path";
+var START_MARKER2 = "<!-- absolutejs:device-capabilities:start -->";
+var END_MARKER2 = "<!-- absolutejs:device-capabilities:end -->";
+var NOT_FOUND2 = -1;
+var escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var writeChangedFile2 = async (path, source) => {
+  const current = await readFile15(path, "utf8");
+  if (current === source)
+    return false;
+  const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+  await writeFile13(temporary, source, { flag: "wx" });
+  await rename12(temporary, path);
+  return true;
+};
+var managed = (source, region, insertion) => {
+  const start = source.indexOf(START_MARKER2);
+  const end = source.indexOf(END_MARKER2);
+  if (start === NOT_FOUND2 !== (end === NOT_FOUND2) || start !== NOT_FOUND2 && end < start)
+    throw new TypeError("AbsoluteJS device-capability ownership markers are malformed.");
+  if (start !== NOT_FOUND2) {
+    const lineStart = source.lastIndexOf(`
+`, start) + 1;
+    const nextLine = source.indexOf(`
+`, end + END_MARKER2.length);
+    const lineEnd = nextLine === NOT_FOUND2 ? source.length : nextLine + 1;
+    return `${source.slice(0, lineStart)}${region}${source.slice(lineEnd)}`;
+  }
+  if (region.length === 0)
+    return source;
+  if (insertion === NOT_FOUND2)
+    throw new TypeError("Could not find a safe native project location for device permissions.");
+  return `${source.slice(0, insertion)}${region}${source.slice(insertion)}`;
+};
+var IOS_KEYS = {
+  camera: "NSCameraUsageDescription",
+  "photo-library": "NSPhotoLibraryUsageDescription",
+  "photo-library-add": "NSPhotoLibraryAddUsageDescription"
+};
+var iosDescription = (appName, purpose) => {
+  if (purpose === "camera")
+    return `${appName} uses your camera when you choose to take a photo.`;
+  if (purpose === "photo-library")
+    return `${appName} accesses your photo library only for photo actions you choose.`;
+  return `${appName} adds to your photo library only for photo actions you choose.`;
+};
+var configureIos2 = async (config, plan) => {
+  const path = join16(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const source = await readFile15(path, "utf8");
+  const requirements = absoluteDeviceNativeRequirements(plan);
+  const content = requirements.iosUsageDescriptions.map((purpose) => `	<key>${IOS_KEYS[purpose]}</key>
+	<string>${escapeXml2(iosDescription(config.appName, purpose))}</string>`).join(`
+`);
+  const region = content ? `	${START_MARKER2}
+${content}
+	${END_MARKER2}
+` : "";
+  return writeChangedFile2(path, managed(source, region, source.lastIndexOf("</dict>")));
+};
+var configureAndroid2 = async (config, plan) => {
+  const path = join16(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const source = await readFile15(path, "utf8");
+  const permissions = absoluteDeviceNativeRequirements(plan).androidPermissions;
+  const content = permissions.map((permission) => `    <uses-permission android:name="${escapeXml2(permission)}" />`).join(`
+`);
+  const region = content ? `    ${START_MARKER2}
+${content}
+    ${END_MARKER2}
+` : "";
+  const application = source.indexOf("<application");
+  const insertion = application === NOT_FOUND2 ? NOT_FOUND2 : source.lastIndexOf(`
+`, application) + 1;
+  return writeChangedFile2(path, managed(source, region, insertion));
+};
+var applyAbsoluteNativeDeviceCapabilities = async (projectRoot, config, platforms = config.platforms, plan = resolveAbsoluteDeviceCapabilityPlan(projectRoot)) => {
+  const results = await Promise.all(platforms.map(async (platform) => ({
+    didChange: platform === "ios" ? await configureIos2(config, plan) : await configureAndroid2(config, plan),
+    platform
+  })));
+  return {
+    changed: results.filter(({ didChange }) => didChange).map(({ platform }) => platform)
+  };
+};
 // src/mobile/releasePublisher.ts
 import { access as access9 } from "fs/promises";
-import { isAbsolute as isAbsolute6, relative as relative9, resolve as resolve12, sep as sep6 } from "path";
+import { isAbsolute as isAbsolute6, relative as relative10, resolve as resolve13, sep as sep6 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -5550,9 +5884,9 @@ var prepareAbsoluteAndroidRelease = async (publisher, options) => {
 var isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isPublisher = (value) => isRecord8(value) && typeof value.publish === "function";
 var publisherModulePath = (projectRoot, requested) => {
-  const root = resolve12(projectRoot);
-  const path = resolve12(root, requested);
-  const projectRelative = relative9(root, path);
+  const root = resolve13(projectRoot);
+  const path = resolve13(root, requested);
+  const projectRelative = relative10(root, path);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute6(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
   }
@@ -5621,9 +5955,9 @@ var publishAbsoluteIosRelease = async (options) => {
   return publication;
 };
 // src/mobile/routeMetadataTransform.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname10, extname as extname3, relative as relative10, resolve as resolve13 } from "path";
-import ts from "typescript";
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname10, extname as extname4, relative as relative11, resolve as resolve14 } from "path";
+import ts2 from "typescript";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
 var PAGE_HANDLERS = new Map([
@@ -5673,60 +6007,60 @@ var PAGE_HANDLERS = new Map([
   ]
 ]);
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname10(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => ts2.findConfigFile(dirname10(entry), existsSync3, "tsconfig.json") ?? ts2.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
-    return ts.createProgram([entry], {
+    return ts2.createProgram([entry], {
       allowJs: true,
-      jsx: ts.JsxEmit.ReactJSX,
-      module: ts.ModuleKind.ESNext,
-      moduleResolution: ts.ModuleResolutionKind.Bundler,
-      target: ts.ScriptTarget.ESNext
+      jsx: ts2.JsxEmit.ReactJSX,
+      module: ts2.ModuleKind.ESNext,
+      moduleResolution: ts2.ModuleResolutionKind.Bundler,
+      target: ts2.ScriptTarget.ESNext
     });
   }
-  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync4(path, "utf8")).config, ts.sys, dirname10(configPath));
+  const parsed = ts2.parseJsonConfigFileContent(ts2.readConfigFile(configPath, (path) => readFileSync5(path, "utf8")).config, ts2.sys, dirname10(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
-  return ts.createProgram(parsed.fileNames, parsed.options);
+  return ts2.createProgram(parsed.fileNames, parsed.options);
 };
 var propertyName = (property) => {
   if (!("name" in property) || !property.name)
     return;
-  if (ts.isIdentifier(property.name))
+  if (ts2.isIdentifier(property.name))
     return property.name.text;
-  if (ts.isStringLiteralLike(property.name))
+  if (ts2.isStringLiteralLike(property.name))
     return property.name.text;
   return;
 };
-var objectPropertyExpression = (object2, name) => {
-  const property = object2.properties.find((candidate) => propertyName(candidate) === name);
-  if (property && ts.isPropertyAssignment(property)) {
+var objectPropertyExpression = (object3, name) => {
+  const property = object3.properties.find((candidate) => propertyName(candidate) === name);
+  if (property && ts2.isPropertyAssignment(property)) {
     return property.initializer;
   }
-  if (property && ts.isShorthandPropertyAssignment(property)) {
+  if (property && ts2.isShorthandPropertyAssignment(property)) {
     return property.name;
   }
   return;
 };
 var serializeType = (type, checker, ancestors = new Set) => {
-  if (type.flags & ts.TypeFlags.Any)
+  if (type.flags & ts2.TypeFlags.Any)
     return { type: "any" };
-  if (type.flags & ts.TypeFlags.Unknown)
+  if (type.flags & ts2.TypeFlags.Unknown)
     return { type: "unknown" };
-  if (type.flags & ts.TypeFlags.Never)
+  if (type.flags & ts2.TypeFlags.Never)
     return { type: "never" };
-  if (type.flags & ts.TypeFlags.StringLike)
+  if (type.flags & ts2.TypeFlags.StringLike)
     return { type: "string" };
-  if (type.flags & ts.TypeFlags.NumberLike)
+  if (type.flags & ts2.TypeFlags.NumberLike)
     return { type: "number" };
-  if (type.flags & ts.TypeFlags.BooleanLike)
+  if (type.flags & ts2.TypeFlags.BooleanLike)
     return { type: "boolean" };
-  if (type.flags & ts.TypeFlags.BigIntLike)
+  if (type.flags & ts2.TypeFlags.BigIntLike)
     return { type: "bigint" };
-  if (type.flags & ts.TypeFlags.Null)
+  if (type.flags & ts2.TypeFlags.Null)
     return { type: "null" };
-  if (type.flags & ts.TypeFlags.Undefined)
+  if (type.flags & ts2.TypeFlags.Undefined)
     return { type: "undefined" };
   if (type.isUnion()) {
     return {
@@ -5740,11 +6074,11 @@ var serializeType = (type, checker, ancestors = new Set) => {
   }
   if (ancestors.has(type)) {
     return {
-      ref: checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)
+      ref: checker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation)
     };
   }
   ancestors.add(type);
-  const arrayElement = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+  const arrayElement = checker.getIndexTypeOfType(type, ts2.IndexKind.Number);
   const properties = checker.getPropertiesOfType(type);
   let schema;
   if (arrayElement && properties.some(({ name }) => name === "length")) {
@@ -5759,7 +6093,7 @@ var serializeType = (type, checker, ancestors = new Set) => {
       return [
         property.name,
         {
-          optional: Boolean(property.flags & ts.SymbolFlags.Optional),
+          optional: Boolean(property.flags & ts2.SymbolFlags.Optional),
           schema: serializeType(propertyType, checker, ancestors)
         }
       ];
@@ -5767,7 +6101,7 @@ var serializeType = (type, checker, ancestors = new Set) => {
     schema = { properties: Object.fromEntries(entries), type: "object" };
   } else {
     schema = {
-      type: checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation)
+      type: checker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation)
     };
   }
   ancestors.delete(type);
@@ -5785,25 +6119,25 @@ var pagePropsType = (pageExpression, propsExpression, checker) => {
 };
 var resolvePageIdentity = (expression, sourceFile, checker, projectRoot) => {
   let symbol = checker.getSymbolAtLocation(expression);
-  if (symbol?.flags && symbol.flags & ts.SymbolFlags.Alias) {
+  if (symbol?.flags && symbol.flags & ts2.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(relative10(projectRoot, file));
+  const source = posixPath(relative11(projectRoot, file));
   return `${source}#${exportedName}`;
 };
 var resolveAlias = (symbol, checker) => {
-  if (!(symbol.flags & ts.SymbolFlags.Alias))
+  if (!(symbol.flags & ts2.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 (ts2.isIdentifier(expression)) {
+    const unresolved = ts2.isShorthandPropertyAssignment(expression.parent) ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
     if (!unresolved)
       return;
     const symbol = resolveAlias(unresolved, checker);
@@ -5811,26 +6145,26 @@ var assetKey = (expression, checker, seen = new Set) => {
       return;
     seen.add(symbol);
     const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
-    if (!declaration || !ts.isVariableDeclaration(declaration))
+    if (!declaration || !ts2.isVariableDeclaration(declaration))
       return;
     return assetKey(declaration.initializer, checker, seen);
   }
-  if (!ts.isCallExpression(expression))
+  if (!ts2.isCallExpression(expression))
     return;
-  if (!ts.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
+  if (!ts2.isIdentifier(expression.expression) || expression.expression.text !== "asset") {
     return;
   }
   const [, key] = expression.arguments;
-  return key && ts.isStringLiteralLike(key) ? key.text : undefined;
+  return key && ts2.isStringLiteralLike(key) ? key.text : undefined;
 };
 var staticString = (expression, bindings) => {
-  if (ts.isStringLiteralLike(expression))
+  if (ts2.isStringLiteralLike(expression))
     return expression.text;
-  if (ts.isIdentifier(expression))
+  if (ts2.isIdentifier(expression))
     return bindings.get(expression.text);
-  if (ts.isNoSubstitutionTemplateLiteral(expression))
+  if (ts2.isNoSubstitutionTemplateLiteral(expression))
     return expression.text;
-  if (!ts.isTemplateExpression(expression))
+  if (!ts2.isTemplateExpression(expression))
     return;
   let value = expression.head.text;
   for (const span of expression.templateSpans) {
@@ -5844,7 +6178,7 @@ var staticString = (expression, bindings) => {
 var assetKeyWithBindings = (expression, checker, bindings = new Map) => {
   if (!expression)
     return;
-  if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "asset") {
+  if (ts2.isCallExpression(expression) && ts2.isIdentifier(expression.expression) && expression.expression.text === "asset") {
     const [, key] = expression.arguments;
     return key ? staticString(key, bindings) : undefined;
   }
@@ -5855,16 +6189,16 @@ var callableObject = (call, checker) => {
   const resolved = symbol ? resolveAlias(symbol, checker) : undefined;
   const declaration = resolved?.valueDeclaration ?? resolved?.declarations?.[0];
   let callable;
-  if (declaration && ts.isFunctionDeclaration(declaration)) {
+  if (declaration && ts2.isFunctionDeclaration(declaration)) {
     callable = declaration;
-  } else if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) {
+  } else if (declaration && ts2.isVariableDeclaration(declaration) && declaration.initializer && (ts2.isArrowFunction(declaration.initializer) || ts2.isFunctionExpression(declaration.initializer))) {
     callable = declaration.initializer;
   }
   if (!callable)
     return;
   const bindings = new Map;
   callable.parameters.forEach((parameter, index) => {
-    if (!ts.isIdentifier(parameter.name))
+    if (!ts2.isIdentifier(parameter.name))
       return;
     const argument = call.arguments[index];
     if (!argument)
@@ -5876,35 +6210,35 @@ var callableObject = (call, checker) => {
   const { body } = callable;
   if (!body)
     return;
-  const expressionBody = ts.isParenthesizedExpression(body) ? body.expression : body;
-  if (ts.isObjectLiteralExpression(expressionBody)) {
+  const expressionBody = ts2.isParenthesizedExpression(body) ? body.expression : body;
+  if (ts2.isObjectLiteralExpression(expressionBody)) {
     return { bindings, object: expressionBody };
   }
-  if (ts.isBlock(body)) {
-    const returned = body.statements.find(ts.isReturnStatement)?.expression;
-    if (returned && ts.isObjectLiteralExpression(returned)) {
+  if (ts2.isBlock(body)) {
+    const returned = body.statements.find(ts2.isReturnStatement)?.expression;
+    if (returned && ts2.isObjectLiteralExpression(returned)) {
       return { bindings, object: returned };
     }
   }
   return;
 };
 var spreadObject = (expression, checker, bindings) => {
-  if (ts.isObjectLiteralExpression(expression)) {
+  if (ts2.isObjectLiteralExpression(expression)) {
     return { bindings, object: expression };
   }
-  if (!ts.isCallExpression(expression))
+  if (!ts2.isCallExpression(expression))
     return;
   return callableObject(expression, checker);
 };
-var objectAssetKey = (object2, name, checker, bindings = new Map) => {
-  for (const property of [...object2.properties].reverse()) {
-    if (propertyName(property) === name && ts.isShorthandPropertyAssignment(property)) {
+var objectAssetKey = (object3, name, checker, bindings = new Map) => {
+  for (const property of [...object3.properties].reverse()) {
+    if (propertyName(property) === name && ts2.isShorthandPropertyAssignment(property)) {
       return assetKeyWithBindings(property.name, checker, bindings);
     }
-    if (propertyName(property) === name && ts.isPropertyAssignment(property)) {
+    if (propertyName(property) === name && ts2.isPropertyAssignment(property)) {
       return assetKeyWithBindings(property.initializer, checker, bindings);
     }
-    if (!ts.isSpreadAssignment(property))
+    if (!ts2.isSpreadAssignment(property))
       continue;
     const nestedObject = spreadObject(property.expression, checker, bindings);
     if (!nestedObject)
@@ -5920,14 +6254,14 @@ var findPageCall = (nodes) => {
   const visit = (candidate) => {
     if (found)
       return;
-    if (ts.isCallExpression(candidate) && ts.isIdentifier(candidate.expression) && PAGE_HANDLERS.has(candidate.expression.text)) {
+    if (ts2.isCallExpression(candidate) && ts2.isIdentifier(candidate.expression) && PAGE_HANDLERS.has(candidate.expression.text)) {
       const definition = PAGE_HANDLERS.get(candidate.expression.text);
       if (!definition)
         return;
       found = { definition, node: candidate };
       return;
     }
-    ts.forEachChild(candidate, visit);
+    ts2.forEachChild(candidate, visit);
   };
   for (const node of nodes)
     visit(node);
@@ -5936,12 +6270,12 @@ var findPageCall = (nodes) => {
 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))
+  if (!ts2.isPropertyAccessExpression(callee))
     return;
   if (!ROUTE_METHODS.has(callee.name.text))
     return;
   const [routePath] = node.arguments;
-  if (!routePath || !ts.isStringLiteralLike(routePath))
+  if (!routePath || !ts2.isStringLiteralLike(routePath))
     return;
   const foundPageCall = findPageCall(node.arguments.slice(1));
   const pageCall = foundPageCall?.node;
@@ -5974,7 +6308,7 @@ var analyzeRouteCall = (node, sourceFile, checker, projectRoot) => {
       routeCallSpan: `${node.getStart(sourceFile)}:${node.end}`
     };
   }
-  if (!ts.isObjectLiteralExpression(input) || !definition.bundleProperty) {
+  if (!ts2.isObjectLiteralExpression(input) || !definition.bundleProperty) {
     return;
   }
   const page = definition.pageProperty ? objectPropertyExpression(input, definition.pageProperty) : undefined;
@@ -6016,21 +6350,21 @@ var analyzeSourceFile = (sourceFile, checker, projectRoot) => {
     byRouteCall: new Map
   };
   const visit = (node) => {
-    const result = ts.isCallExpression(node) ? analyzeRouteCall(node, sourceFile, checker, projectRoot) : undefined;
+    const result = ts2.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);
+    ts2.forEachChild(node, visit);
   };
-  ts.forEachChild(sourceFile, visit);
+  ts2.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 = resolve13(sourceFile.fileName);
+    const resolvedFile = resolve14(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -6039,21 +6373,21 @@ var analyzeProgram = (program, projectRoot) => {
   }
   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 metadataExpression = (metadata) => ts2.factory.createObjectLiteralExpression(Object.entries(metadata).map(([key, item]) => ts2.factory.createPropertyAssignment(ts2.factory.createStringLiteral(key), ts2.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))
+  const detail = ts2.factory.createObjectLiteralExpression([
+    ts2.factory.createPropertyAssignment(ts2.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
   ]);
   if (!existing) {
-    return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("detail", detail)
+    return ts2.factory.createObjectLiteralExpression([
+      ts2.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))
+  return ts2.factory.createObjectLiteralExpression([
+    ts2.factory.createSpreadAssignment(existing),
+    ts2.factory.createPropertyAssignment("detail", ts2.factory.createObjectLiteralExpression([
+      ts2.factory.createSpreadAssignment(ts2.factory.createPropertyAccessExpression(existing, "detail")),
+      ts2.factory.createPropertyAssignment(ts2.factory.createStringLiteral(ABSOLUTE_MOBILE_ROUTE_DETAIL), metadataExpression(metadata))
     ]))
   ]);
 };
@@ -6064,19 +6398,19 @@ var transformPageCall = (node, page) => {
     const [pagePath, existingOptions, ...rest] = node.arguments;
     if (!pagePath)
       return;
-    const options = ts.factory.createObjectLiteralExpression([
-      ...existingOptions ? [ts.factory.createSpreadAssignment(existingOptions)] : [],
-      ts.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+    const options = ts2.factory.createObjectLiteralExpression([
+      ...existingOptions ? [ts2.factory.createSpreadAssignment(existingOptions)] : [],
+      ts2.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
     ]);
-    return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [pagePath, options, ...rest]);
+    return ts2.factory.updateCallExpression(node, node.expression, node.typeArguments, [pagePath, options, ...rest]);
   }
   const [input] = node.arguments;
-  if (!input || !ts.isObjectLiteralExpression(input))
+  if (!input || !ts2.isObjectLiteralExpression(input))
     return;
-  return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [
-    ts.factory.updateObjectLiteralExpression(input, [
+  return ts2.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+    ts2.factory.updateObjectLiteralExpression(input, [
       ...input.properties,
-      ts.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
+      ts2.factory.createPropertyAssignment("__absoluteMobile", metadataExpression(page.metadata))
     ]),
     ...node.arguments.slice(1)
   ]);
@@ -6089,16 +6423,16 @@ var transformRouteCall = (node, route) => {
     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]);
+  return ts2.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 sourceFile = ts2.createSourceFile(fileName, source, ts2.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS);
   const transformer = (context) => {
     const visit = (node) => {
-      if (!ts.isCallExpression(node)) {
-        return ts.visitEachChild(node, visit, context);
+      if (!ts2.isCallExpression(node)) {
+        return ts2.visitEachChild(node, visit, context);
       }
-      const transformedChildren = ts.visitEachChild(node, visit, context);
+      const transformedChildren = ts2.visitEachChild(node, visit, context);
       const page = analysis.byPageCall.get(node.getStart(sourceFile));
       const transformedPage = transformPageCall(transformedChildren, page);
       if (transformedPage)
@@ -6109,45 +6443,45 @@ var transformFile = (source, fileName, analysis) => {
         return transformedRoute;
       return transformedChildren;
     };
-    return (node) => ts.visitNode(node, visit, ts.isSourceFile) ?? node;
+    return (node) => ts2.visitNode(node, visit, ts2.isSourceFile) ?? node;
   };
-  const result = ts.transform(sourceFile, [transformer]);
+  const result = ts2.transform(sourceFile, [transformer]);
   try {
     const [transformed] = result.transformed;
     if (!transformed)
       throw new TypeError("Mobile route transform failed.");
-    return ts.createPrinter().printFile(transformed);
+    return ts2.createPrinter().printFile(transformed);
   } finally {
     result.dispose();
   }
 };
 var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
 var createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve13(options.projectRoot ?? process.cwd());
-  const entry = resolve13(options.entry);
+  const projectRoot = resolve14(options.projectRoot ?? process.cwd());
+  const entry = resolve14(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(resolve13(path));
+        const analysis = analyzed.get(resolve14(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
         return {
           contents: transformFile(source, path, analysis),
-          loader: extname3(path).endsWith("x") ? "tsx" : "ts"
+          loader: extname4(path).endsWith("x") ? "tsx" : "ts"
         };
       });
     }
   };
 };
 var inspectAbsoluteMobileRouteMetadata = (options) => {
-  const projectRoot = resolve13(options.projectRoot ?? process.cwd());
-  const entry = resolve13(options.entry);
+  const projectRoot = resolve14(options.projectRoot ?? process.cwd());
+  const entry = resolve14(options.entry);
   const analyzed = analyzeProgram(createProgram(entry, projectRoot), projectRoot);
   return [...analyzed.entries()].flatMap(([file, analysis]) => [...analysis.byRouteCall.values()].map(({ metadata }) => ({
-    file: posixPath(relative10(projectRoot, file)),
+    file: posixPath(relative11(projectRoot, file)),
     metadata
   })));
 };
@@ -6169,6 +6503,7 @@ export {
   resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
   resolveAbsoluteMobileAuthManifest,
+  resolveAbsoluteDeviceCapabilityPlan,
   repairAbsoluteIosDevSession,
   removeAbsoluteRemoteMacProfile,
   redactAbsoluteIosLog,
@@ -6192,6 +6527,7 @@ export {
   pairAbsoluteRemoteMac,
   normalizeAbsoluteMobileConfig,
   navigateAbsoluteMobilePage,
+  missingAbsoluteDeviceCapabilityPackages,
   materializeAbsoluteRemoteMacAgent,
   materializeAbsoluteMobileCompatibilityBundle,
   materializeAbsoluteMobileAssociationFiles,
@@ -6199,6 +6535,7 @@ export {
   matchesAbsoluteMobileRoutePattern,
   loadAbsoluteNativeReleasePublisher,
   loadAbsoluteMobileMaterializedBundle,
+  loadAbsoluteDeviceCapabilityProviders,
   listAbsoluteRemoteMacProfiles,
   isAbsoluteIosNativeRootInput,
   installAbsoluteRemoteMacAgent,
@@ -6217,6 +6554,8 @@ export {
   fetchAbsoluteMobilePage,
   disposeAbsoluteMobilePage,
   discoverAbsoluteSyncSchema,
+  discoverAbsoluteDeviceCapabilities,
+  directAbsoluteProjectPackages,
   createAbsoluteRemoteIosDevProject,
   createAbsoluteMobileUpgradeResponse,
   createAbsoluteMobileRouteMetadataPlugin,
@@ -6236,11 +6575,14 @@ export {
   buildAbsoluteMobileCompatibilityRelease,
   buildAbsoluteIosRelease,
   buildAbsoluteAndroidRelease,
+  assertAbsoluteDeviceCapabilityPackages,
+  applyAbsoluteNativeDeviceCapabilities,
   applyAbsoluteNativeDeepLinks,
   activateAbsoluteMobilePage,
   acceptsAbsoluteMobilePage,
   absoluteRemoteProjectSyncCommands,
   absoluteRemoteMacSshBase,
+  absoluteDeviceNativeRequirements,
   MOBILE_PAGE_REQUEST_HEADERS,
   AbsoluteMobilePageProtocolError,
   APPLE_ASSOCIATION_PATH,
@@ -6264,5 +6606,5 @@ export {
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=1458CD3F41FC684D64756E2164756E21
+//# debugId=8F3479AD17C2968F64756E2164756E21
 //# sourceMappingURL=index.js.map