@absolutejs/absolute 0.20.0-beta.113 → 0.20.0-beta.115

package/dist/cli/{index-0zcebhm4.js → index-dr21p6ae.js}

@@ -12,17 +12,17 @@ import {
 
 // src/mobile/expoProject.ts
 import {
-  access,
-  mkdir,
+  access as access2,
+  mkdir as mkdir2,
   mkdtemp,
   readdir,
-  readFile,
-  rename,
-  rm,
-  writeFile
+  readFile as readFile2,
+  rename as rename2,
+  rm as rm2,
+  writeFile as writeFile2
 } from "fs/promises";
-import { createHash as createHash2 } from "crypto";
-import { basename, dirname as dirname2, join as join5, relative as relative2, resolve as resolve3, sep } from "path";
+import { createHash as createHash3 } from "crypto";
+import { basename, dirname as dirname3, join as join6, relative as relative3, resolve as resolve4, sep } from "path";
 
 // src/mobile/syncSchema.ts
 import { readFileSync } from "fs";
@@ -1671,14 +1671,490 @@ var absoluteExpoActivityResultRecoveryFiles = (project) => new Map([
   ]
 ]);
 
+// src/mobile/branding.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  access,
+  copyFile,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  writeFile
+} from "fs/promises";
+import { dirname as dirname2, join as join5, relative as relative2, resolve as resolve3 } from "path";
+var ABSOLUTE_MOBILE_BRANDING_FORMAT = 1;
+var ABSOLUTE_CAPACITOR_ASSETS_VERSION = "3.0.5";
+var ABSOLUTE_CAPACITOR_ASSETS_SPEC = `@capacitor/assets@${ABSOLUTE_CAPACITOR_ASSETS_VERSION}`;
+var MAX_SOURCE_BYTES = 32 * 1024 * 1024;
+var ICON_SIZE = 1024;
+var SPLASH_SIZE = 2732;
+var ANDROID_ADAPTIVE_SIZES = [
+  ["ldpi", 81],
+  ["mdpi", 108],
+  ["hdpi", 162],
+  ["xhdpi", 216],
+  ["xxhdpi", 324],
+  ["xxxhdpi", 432]
+];
+var exists = async (path) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var portableRelative = (root, path) => relative2(root, path).replaceAll("\\", "/");
+var absoluteMobileBrandingManifestPath = (projectRoot) => join5(resolve3(projectRoot), ".absolutejs", "mobile", "branding", "manifest.json");
+var brandingEntries = (branding) => [
+  { kind: "icon", path: branding.icon, size: ICON_SIZE },
+  branding.android.foreground ? {
+    kind: "android-foreground",
+    path: branding.android.foreground,
+    size: ICON_SIZE
+  } : undefined,
+  branding.android.backgroundImage ? {
+    kind: "android-background",
+    path: branding.android.backgroundImage,
+    size: ICON_SIZE
+  } : undefined,
+  branding.android.monochrome ? {
+    kind: "android-monochrome",
+    path: branding.android.monochrome,
+    size: ICON_SIZE
+  } : undefined,
+  branding.ios.darkIcon ? {
+    kind: "ios-dark",
+    path: branding.ios.darkIcon,
+    size: ICON_SIZE
+  } : undefined,
+  branding.ios.tintedIcon ? {
+    kind: "ios-tinted",
+    path: branding.ios.tintedIcon,
+    size: ICON_SIZE
+  } : undefined,
+  branding.splash.image ? {
+    kind: "splash-light",
+    path: branding.splash.image,
+    size: SPLASH_SIZE
+  } : undefined,
+  branding.splash.darkImage ? {
+    kind: "splash-dark",
+    path: branding.splash.darkImage,
+    size: SPLASH_SIZE
+  } : undefined
+].filter((entry) => entry !== undefined);
+var inspectSource = async (projectRoot, entry) => {
+  const buffer = await readFile(entry.path);
+  if (buffer.byteLength > MAX_SOURCE_BYTES)
+    throw new TypeError(`mobile.branding ${entry.kind} exceeds the 32 MiB source limit.`);
+  let metadata;
+  try {
+    metadata = await new Bun.Image(buffer, {
+      maxPixels: SPLASH_SIZE * SPLASH_SIZE * 4
+    }).metadata();
+  } catch (error) {
+    throw new TypeError(`mobile.branding ${entry.kind} must be a readable PNG image.`, { cause: error });
+  }
+  if (metadata.format !== "png")
+    throw new TypeError(`mobile.branding ${entry.kind} must be PNG.`);
+  if (metadata.width !== metadata.height || metadata.width < entry.size || metadata.height < entry.size)
+    throw new TypeError(`mobile.branding ${entry.kind} must be square and at least ${entry.size}x${entry.size}.`);
+  return {
+    bytes: buffer.byteLength,
+    height: metadata.height,
+    kind: entry.kind,
+    path: portableRelative(projectRoot, entry.path),
+    sha256: createHash2("sha256").update(buffer).digest("hex"),
+    width: metadata.width
+  };
+};
+var manifestFingerprint = (config, sources) => {
+  const { branding } = config;
+  if (!branding)
+    throw new TypeError("mobile.branding is not configured.");
+  return createHash2("sha256").update(JSON.stringify({
+    androidBackgroundColor: branding.android.backgroundColor,
+    engine: config.engine,
+    format: ABSOLUTE_MOBILE_BRANDING_FORMAT,
+    platforms: config.platforms,
+    sources: sources.map(({ kind, sha256 }) => ({ kind, sha256 })),
+    splashBackgroundColor: branding.splash.backgroundColor,
+    splashDarkBackgroundColor: branding.splash.darkBackgroundColor,
+    splashLogoScale: branding.splash.logoScale
+  })).digest("hex");
+};
+var createAbsoluteMobileBrandingManifest = async (config, projectRoot) => {
+  if (!config.branding)
+    throw new TypeError("absolute.config.ts must define mobile.branding before generating mobile assets.");
+  const sources = await Promise.all(brandingEntries(config.branding).map((entry) => inspectSource(projectRoot, entry)));
+  return {
+    engine: config.engine,
+    fingerprint: manifestFingerprint(config, sources),
+    format: ABSOLUTE_MOBILE_BRANDING_FORMAT,
+    platforms: [...config.platforms],
+    sources
+  };
+};
+var writeManifest = async (projectRoot, manifest) => {
+  const destination = absoluteMobileBrandingManifestPath(projectRoot);
+  await mkdir(dirname2(destination), { recursive: true });
+  const temporary = `${destination}.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(manifest, null, 2)}
+`, {
+    flag: "wx"
+  });
+  await rename(temporary, destination);
+  return destination;
+};
+var copyManaged = async (source, destination) => {
+  await mkdir(dirname2(destination), { recursive: true });
+  await copyFile(source, destination);
+};
+var absoluteExpoBrandingConfig = (config) => {
+  const { branding } = config;
+  if (!branding)
+    return;
+  const root = "./assets/absolute-branding";
+  const iosIcon = branding.ios.darkIcon || branding.ios.tintedIcon ? {
+    ...branding.ios.darkIcon ? { dark: `${root}/ios-dark.png` } : {},
+    light: `${root}/icon.png`,
+    ...branding.ios.tintedIcon ? { tinted: `${root}/ios-tinted.png` } : {}
+  } : `${root}/icon.png`;
+  return {
+    android: {
+      adaptiveIcon: {
+        backgroundColor: branding.android.backgroundColor,
+        ...branding.android.backgroundImage ? { backgroundImage: `${root}/android-background.png` } : {},
+        foregroundImage: branding.android.foreground ? `${root}/android-foreground.png` : `${root}/icon.png`,
+        ...branding.android.monochrome ? { monochromeImage: `${root}/android-monochrome.png` } : {}
+      },
+      icon: `${root}/icon.png`
+    },
+    icon: `${root}/icon.png`,
+    ios: { icon: iosIcon },
+    splashPlugin: [
+      "expo-splash-screen",
+      {
+        backgroundColor: branding.splash.backgroundColor,
+        dark: {
+          backgroundColor: branding.splash.darkBackgroundColor,
+          image: branding.splash.darkImage ? `${root}/splash-dark.png` : `${root}/icon.png`
+        },
+        image: branding.splash.image ? `${root}/splash-light.png` : `${root}/icon.png`,
+        imageWidth: Math.round(1024 * branding.splash.logoScale)
+      }
+    ]
+  };
+};
+var writeAbsoluteExpoBrandingInputs = async (config, projectRoot) => {
+  const { branding } = config;
+  if (!branding)
+    return;
+  const manifest = await createAbsoluteMobileBrandingManifest(config, projectRoot);
+  const destination = join5(config.nativeProjectDirectory, "assets", "absolute-branding");
+  await rm(destination, { force: true, recursive: true });
+  await mkdir(destination, { recursive: true });
+  await copyManaged(branding.icon, join5(destination, "icon.png"));
+  const copies = [
+    [branding.android.backgroundImage, "android-background.png"],
+    [branding.android.foreground, "android-foreground.png"],
+    [branding.android.monochrome, "android-monochrome.png"],
+    [branding.ios.darkIcon, "ios-dark.png"],
+    [branding.ios.tintedIcon, "ios-tinted.png"],
+    [branding.splash.image, "splash-light.png"],
+    [branding.splash.darkImage, "splash-dark.png"]
+  ];
+  await Promise.all(copies.map(([source, name]) => source ? copyManaged(source, join5(destination, name)) : undefined));
+  await writeManifest(projectRoot, manifest);
+  return { manifest, path: destination };
+};
+var stageCapacitorInputs = async (branding, projectRoot) => {
+  const destination = join5(projectRoot, ".absolutejs", "mobile", "branding", "input");
+  await rm(destination, { force: true, recursive: true });
+  await mkdir(destination, { recursive: true });
+  await copyManaged(branding.icon, join5(destination, "logo.png"));
+  if (branding.splash.image)
+    await copyManaged(branding.splash.image, join5(destination, "splash.png"));
+  if (branding.splash.darkImage)
+    await copyManaged(branding.splash.darkImage, join5(destination, "splash-dark.png"));
+  return destination;
+};
+var defaultRunner = async (command, options) => {
+  const child = Bun.spawn(command, {
+    cwd: options.cwd,
+    stderr: "pipe",
+    stdin: "inherit",
+    stdout: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text()
+  ]);
+  if (stdout)
+    process.stdout.write(stdout);
+  if (stderr)
+    process.stderr.write(stderr);
+  if (exitCode !== 0)
+    throw new TypeError(`Capacitor asset generation exited with status ${exitCode}.`);
+  if (/Unable to generate assets|Unable to load source image|Asset directory not found|No assets found|No platforms found|skipping (?:iOS|android) generation/iu.test(`${stdout}
+${stderr}`))
+    throw new TypeError("Capacitor asset generation reported an incomplete projection.");
+};
+var resizePng = async (source, destination, size) => {
+  const output = await new Bun.Image(await readFile(source)).resize(size, size).png({ compressionLevel: 9 }).toBuffer();
+  await mkdir(dirname2(destination), { recursive: true });
+  await writeFile(destination, output);
+};
+var applyAndroidLayers = async (branding, nativeDirectory) => {
+  const resources = join5(nativeDirectory, "android", "app", "src", "main", "res");
+  await Promise.all(ANDROID_ADAPTIVE_SIZES.flatMap(([density, size]) => [
+    ...branding.android.foreground ? [
+      resizePng(branding.android.foreground, join5(resources, `mipmap-${density}`, "ic_launcher_foreground.png"), size)
+    ] : [],
+    ...branding.android.backgroundImage ? [
+      resizePng(branding.android.backgroundImage, join5(resources, `mipmap-${density}`, "ic_launcher_background.png"), size)
+    ] : [],
+    ...branding.android.monochrome ? [
+      resizePng(branding.android.monochrome, join5(resources, `mipmap-${density}`, "ic_launcher_monochrome.png"), size)
+    ] : []
+  ]));
+  if (!branding.android.monochrome)
+    return;
+  const iconXml = `<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@mipmap/ic_launcher_background" />
+    <foreground android:drawable="@mipmap/ic_launcher_foreground" />
+    <monochrome android:drawable="@mipmap/ic_launcher_monochrome" />
+</adaptive-icon>
+`;
+  await Promise.all(["ic_launcher.xml", "ic_launcher_round.xml"].map((name) => writeFile(join5(resources, "mipmap-anydpi-v26", name), iconXml)));
+};
+var applyIosAppearances = async (branding, nativeDirectory) => {
+  if (!branding.ios.darkIcon && !branding.ios.tintedIcon)
+    return;
+  const assetSet = join5(nativeDirectory, "ios", "App", "App", "Assets.xcassets", "AppIcon.appiconset");
+  const contentsPath = join5(assetSet, "Contents.json");
+  const contents = JSON.parse(await readFile(contentsPath, "utf8"));
+  const images = typeof contents === "object" && contents !== null ? Reflect.get(contents, "images") : undefined;
+  if (typeof contents !== "object" || contents === null || !Array.isArray(images))
+    throw new TypeError("Generated iOS AppIcon Contents.json is invalid.");
+  const appearanceSources = [
+    ["dark", branding.ios.darkIcon],
+    ["tinted", branding.ios.tintedIcon]
+  ];
+  const generated = await Promise.all(appearanceSources.map(async ([appearance, source]) => {
+    if (!source)
+      return;
+    const filename = `AppIcon-1024-${appearance}.png`;
+    await resizePng(source, join5(assetSet, filename), ICON_SIZE);
+    return {
+      appearances: [{ appearance: "luminosity", value: appearance }],
+      filename,
+      idiom: "universal",
+      platform: "ios",
+      size: "1024x1024"
+    };
+  }));
+  const retained = images.filter((entry) => {
+    if (typeof entry !== "object" || entry === null)
+      return true;
+    const filename = Reflect.get(entry, "filename");
+    return filename !== "AppIcon-1024-dark.png" && filename !== "AppIcon-1024-tinted.png";
+  });
+  Reflect.set(contents, "images", [
+    ...retained,
+    ...generated.filter((entry) => entry !== undefined)
+  ]);
+  await writeFile(contentsPath, `${JSON.stringify(contents, null, 2)}
+`);
+};
+var nativeBrandingSentinels = (config, platforms) => platforms.map((platform) => platform === "android" ? join5(config.nativeProjectDirectory, "android", "app", "src", "main", "res", "mipmap-xxxhdpi", "ic_launcher.png") : join5(config.nativeProjectDirectory, "ios", "App", "App", "Assets.xcassets", "AppIcon.appiconset", "AppIcon-512@2x.png"));
+var requireGeneratedBranding = async (config, platforms) => {
+  const missing = (await Promise.all(nativeBrandingSentinels(config, platforms).map(async (path) => ({
+    path,
+    present: await exists(path)
+  })))).filter(({ present }) => !present);
+  if (missing.length > 0)
+    throw new TypeError(`Capacitor asset generation did not produce ${missing.map(({ path }) => path).join(", ")}.`);
+};
+var reusableManifestPlatforms = (value, fingerprint) => {
+  if (typeof value !== "object" || value === null || Reflect.get(value, "format") !== ABSOLUTE_MOBILE_BRANDING_FORMAT || Reflect.get(value, "fingerprint") !== fingerprint)
+    return [];
+  const platforms = Reflect.get(value, "platforms");
+  if (!Array.isArray(platforms))
+    return [];
+  return platforms.flatMap((platform) => platform === "android" || platform === "ios" ? [platform] : []);
+};
+var completedManifestPlatforms = async (manifest, manifestPath, generated) => {
+  let previousPlatforms = [];
+  try {
+    const previous = JSON.parse(await readFile(manifestPath, "utf8"));
+    previousPlatforms = reusableManifestPlatforms(previous, manifest.fingerprint);
+  } catch {}
+  const completed = new Set([...generated, ...previousPlatforms]);
+  return manifest.platforms.filter((platform) => completed.has(platform));
+};
+var generateAbsoluteCapacitorBranding = async (config, projectRoot, options = {}) => {
+  const { branding } = config;
+  if (!branding)
+    throw new TypeError("absolute.config.ts must define mobile.branding before generating mobile assets.");
+  if (config.engine !== "capacitor")
+    throw new TypeError("Capacitor branding requires mobile.engine: capacitor.");
+  const manifest = await createAbsoluteMobileBrandingManifest(config, projectRoot);
+  const input = await stageCapacitorInputs(branding, projectRoot);
+  const platforms = options.platforms ?? config.platforms;
+  const command = [
+    "bun",
+    "x",
+    "--no-install",
+    "capacitor-assets",
+    "generate",
+    ...platforms.map((platform) => `--${platform}`),
+    "--assetPath",
+    portableRelative(projectRoot, input),
+    "--androidProject",
+    portableRelative(projectRoot, join5(config.nativeProjectDirectory, "android")),
+    "--iosProject",
+    portableRelative(projectRoot, join5(config.nativeProjectDirectory, "ios", "App")),
+    "--iconBackgroundColor",
+    branding.android.backgroundColor,
+    "--splashBackgroundColor",
+    branding.splash.backgroundColor,
+    "--splashBackgroundColorDark",
+    branding.splash.darkBackgroundColor,
+    "--logoSplashScale",
+    String(branding.splash.logoScale)
+  ];
+  await (options.runner ?? defaultRunner)(command, { cwd: projectRoot });
+  await requireGeneratedBranding(config, platforms);
+  if (platforms.includes("android"))
+    await applyAndroidLayers(branding, config.nativeProjectDirectory);
+  if (platforms.includes("ios"))
+    await applyIosAppearances(branding, config.nativeProjectDirectory);
+  const manifestPath = absoluteMobileBrandingManifestPath(projectRoot);
+  const completedPlatforms = await completedManifestPlatforms(manifest, manifestPath, platforms);
+  await writeManifest(projectRoot, {
+    ...manifest,
+    platforms: completedPlatforms
+  });
+  return {
+    manifest: { ...manifest, platforms: completedPlatforms },
+    manifestPath,
+    platforms
+  };
+};
+var parseManifestState = (value) => {
+  const fingerprint = typeof value === "object" && value !== null ? Reflect.get(value, "fingerprint") : undefined;
+  if (typeof value !== "object" || value === null || Reflect.get(value, "format") !== ABSOLUTE_MOBILE_BRANDING_FORMAT || typeof fingerprint !== "string")
+    throw new TypeError("Mobile branding manifest is invalid.");
+  const platforms = Reflect.get(value, "platforms");
+  if (!Array.isArray(platforms) || platforms.some((platform) => platform !== "android" && platform !== "ios"))
+    throw new TypeError("Mobile branding manifest platforms are invalid.");
+  const validPlatforms = platforms.flatMap((platform) => platform === "android" || platform === "ios" ? [platform] : []);
+  return { fingerprint, platforms: new Set(validPlatforms) };
+};
+var brandingInspection = (value) => value;
+var inspectAbsoluteMobileBranding = async (config, projectRoot) => {
+  const manifestPath = absoluteMobileBrandingManifestPath(projectRoot);
+  if (!config.branding)
+    return brandingInspection({
+      configured: false,
+      detail: "Mobile branding is not configured; native template artwork may be shipped.",
+      manifestPath,
+      ready: false,
+      status: "absent"
+    });
+  let expected;
+  try {
+    expected = await createAbsoluteMobileBrandingManifest(config, projectRoot);
+  } catch (error) {
+    return brandingInspection({
+      configured: true,
+      detail: error instanceof Error ? error.message : "Mobile branding sources are invalid.",
+      manifestPath,
+      ready: false,
+      status: "invalid"
+    });
+  }
+  try {
+    const current = parseManifestState(JSON.parse(await readFile(manifestPath, "utf8")));
+    if (current.fingerprint !== expected.fingerprint)
+      return brandingInspection({
+        configured: true,
+        detail: "Mobile branding sources changed after the last native projection.",
+        manifestPath,
+        ready: false,
+        status: "stale"
+      });
+    const missingPlatforms = config.platforms.filter((platform) => !current.platforms.has(platform));
+    if (missingPlatforms.length > 0)
+      return brandingInspection({
+        configured: true,
+        detail: `Mobile branding has not been projected for ${missingPlatforms.join(", ")}.`,
+        manifestPath,
+        ready: false,
+        status: "stale"
+      });
+    const nativeSentinels = config.engine === "expo" ? [
+      join5(config.nativeProjectDirectory, "assets", "absolute-branding", "icon.png")
+    ] : nativeBrandingSentinels(config, config.platforms);
+    if ((await Promise.all(nativeSentinels.map((path) => exists(path)))).some((present) => !present))
+      return brandingInspection({
+        configured: true,
+        detail: "The generated native branding projection is missing.",
+        manifestPath,
+        ready: false,
+        status: "stale"
+      });
+    return brandingInspection({
+      configured: true,
+      detail: `Mobile branding ${expected.fingerprint.slice(0, 12)} is current for ${config.engine}.`,
+      manifestPath,
+      ready: true,
+      status: "ready"
+    });
+  } catch {
+    return brandingInspection({
+      configured: true,
+      detail: "Mobile branding has not been projected into the native app.",
+      manifestPath,
+      ready: false,
+      status: "stale"
+    });
+  }
+};
+var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderAbsoluteMobileBrandingPreview = async (config, projectRoot) => {
+  const manifest = await createAbsoluteMobileBrandingManifest(config, projectRoot);
+  const { branding } = config;
+  if (!branding)
+    throw new TypeError("mobile.branding is not configured.");
+  const destination = join5(projectRoot, ".absolutejs", "mobile", "branding", "preview.html");
+  const icon = `data:image/png;base64,${(await readFile(branding.icon)).toString("base64")}`;
+  const appName = escapeHtml(config.appName);
+  const html = `<!doctype html>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width">
+<title>${appName} mobile branding</title>
+<style>body{font:16px system-ui;margin:2rem;background:#eee;color:#111}main{display:flex;flex-wrap:wrap;gap:2rem}.card{background:white;border-radius:20px;padding:1.5rem;box-shadow:0 8px 30px #0002}.icon{width:192px;height:192px;object-fit:cover}.circle{border-radius:50%}.squircle{border-radius:24%}.splash{width:240px;height:480px;display:grid;place-items:center;background:${branding.splash.backgroundColor}}.splash img{width:${branding.splash.logoScale * 100}%}code{display:block;margin-top:1rem}</style>
+<h1>${appName}</h1><main><section class="card"><img class="icon squircle" src="${icon}" alt="Square app icon preview"><code>Apple / legacy Android</code></section><section class="card"><img class="icon circle" src="${icon}" alt="Circular Android icon preview"><code>Android circular mask</code></section><section class="card splash"><img src="${icon}" alt="Launch screen preview"></section></main><p>Fingerprint: <code>${manifest.fingerprint}</code></p>
+`;
+  await mkdir(dirname2(destination), { recursive: true });
+  await writeFile(destination, html);
+  return destination;
+};
+
 // src/mobile/expoProject.ts
 var EXPO_GENERATED_HEADER = `// Generated by AbsoluteJS. Edit absolute.config.ts, then run absolute mobile sync.
 `;
 var EXPO_ASSET_EXTENSION = ".absasset";
 var EXPO_PROJECT_MARKER = ".absolutejs-expo-project";
-var exists = async (path) => {
+var exists2 = async (path) => {
   try {
-    await access(path);
+    await access2(path);
     return true;
   } catch {
     return false;
@@ -1734,8 +2210,8 @@ var expoNativeDataManifest = (value) => {
     runtime: requireManifestString(value.runtime, "runtime")
   };
 };
-var portableRelative = (from, destination) => {
-  const value = relative2(from, destination).replaceAll("\\", "/");
+var portableRelative2 = (from, destination) => {
+  const value = relative3(from, destination).replaceAll("\\", "/");
   return value.startsWith(".") ? value : `./${value}`;
 };
 var routeSegments = (route) => {
@@ -1751,12 +2227,12 @@ var routeSegments = (route) => {
     return segment;
   });
 };
-var routeFile = (project, route) => join5(project, "app", ...routeSegments(route), "index.tsx");
+var routeFile = (project, route) => join6(project, "app", ...routeSegments(route), "index.tsx");
 var packageDependencies = (plan) => Object.fromEntries(plan.requiredPackages.map((spec) => {
   const separator = spec.lastIndexOf("@");
   return [spec.slice(0, separator), spec.slice(separator + 1)];
 }));
-var expoPackage = (auth, sync, devices, updates) => ({
+var expoPackage = (auth, branding, sync, devices, updates) => ({
   dependencies: {
     "@absolutejs/devices": "0.7.0",
     "@absolutejs/devices-expo": "0.0.11",
@@ -1784,6 +2260,7 @@ var expoPackage = (auth, sync, devices, updates) => ({
     } : {},
     ...updates || sync ? { "expo-updates": "~57.0.19" } : {},
     "expo-router": "~57.0.17",
+    ...branding ? { "expo-splash-screen": "~57.0.9" } : {},
     ...auth || updates ? {
       "expo-secure-store": "~57.0.2",
       ...auth ? { "expo-web-browser": "~57.0.2" } : {}
@@ -1810,6 +2287,7 @@ var expoPackage = (auth, sync, devices, updates) => ({
   version: "0.0.0"
 });
 var expoAppConfig = (config, auth, sync, devices, runtimeFingerprint) => {
+  const branding = absoluteExpoBrandingConfig(config);
   const requirements = absoluteDeviceNativeRequirements(devices);
   const usageKey = (purpose) => {
     if (purpose === "camera")
@@ -1860,6 +2338,7 @@ var expoAppConfig = (config, auth, sync, devices, runtimeFingerprint) => {
   return {
     expo: {
       android: {
+        ...branding?.android ?? {},
         ...devicePlugins.includes("expo-image-picker") ? {
           blockedPermissions: [
             "android.permission.READ_EXTERNAL_STORAGE",
@@ -1878,6 +2357,7 @@ var expoAppConfig = (config, auth, sync, devices, runtimeFingerprint) => {
       },
       experiments: { typedRoutes: true },
       ios: {
+        ...branding?.ios ?? {},
         associatedDomains: config.deepLinkHosts.map((host2) => `applinks:${host2}`),
         bundleIdentifier: config.appId,
         infoPlist: descriptions,
@@ -1892,9 +2372,11 @@ var expoAppConfig = (config, auth, sync, devices, runtimeFingerprint) => {
         ...config.iosVersion ? { buildNumber: config.iosVersion } : {}
       },
       name: config.appName,
+      ...branding ? { icon: branding.icon } : {},
       plugins: [
         "expo-router",
         ["expo-dev-client", { launchMode: "most-recent" }],
+        ...branding ? [branding.splashPlugin] : [],
         "./plugins/withAbsoluteActivityResultRecovery",
         ...auth || config.updates ? ["expo-secure-store"] : [],
         ...sync ? [
@@ -2305,7 +2787,7 @@ ${push ? `absoluteExpoAuth.onPrincipalChange(principal => {
 `;
 };
 var authRuntimeSource = (auth, appId) => {
-  const storageIdentity = createHash2("sha256").update(appId).digest("hex").slice(0, 24);
+  const storageIdentity = createHash3("sha256").update(appId).digest("hex").slice(0, 24);
   return `${EXPO_GENERATED_HEADER}import { createAbsoluteExpoAuthClient } from '@absolutejs/auth-expo';
 import { createMobileAuthTransport, installAuthClientRuntimeTransport } from '@absolutejs/auth/client/mobile';
 
@@ -2337,7 +2819,7 @@ export const startAbsoluteExpoAuth = () => {
 `;
 };
 var syncRuntimeSource = (config, schema) => {
-  const storageIdentity = createHash2("sha256").update(config.appId).digest("hex").slice(0, 24);
+  const storageIdentity = createHash3("sha256").update(config.appId).digest("hex").slice(0, 24);
   const backgroundEndpoint = new URL("/__absolute/sync/background", config.productionOrigin).href;
   const backgroundTask = `${config.appId}.absolutejs.sync`;
   return `${EXPO_GENERATED_HEADER}import { runHeadlessSync } from '@absolutejs/sync/client/headless';
@@ -2996,8 +3478,8 @@ const styles = StyleSheet.create({
 	error: { color: '#b91c1c', fontSize: 16, textAlign: 'center' }
 });
 `;
-var nativeWrapperSource = (wrapper, module, runtime2, route) => `${EXPO_GENERATED_HEADER}import ApplicationNativeRoute from ${JSON.stringify(portableRelative(dirname2(wrapper), module).replace(/\.(?:[cm]?[jt]sx?)$/u, ""))};
-import { createAbsoluteNativeRoute, createAbsoluteNativeRouteErrorBoundary } from ${JSON.stringify(portableRelative(dirname2(wrapper), runtime2).replace(/\.(?:[cm]?[jt]sx?)$/u, ""))};
+var nativeWrapperSource = (wrapper, module, runtime2, route) => `${EXPO_GENERATED_HEADER}import ApplicationNativeRoute from ${JSON.stringify(portableRelative2(dirname3(wrapper), module).replace(/\.(?:[cm]?[jt]sx?)$/u, ""))};
+import { createAbsoluteNativeRoute, createAbsoluteNativeRouteErrorBoundary } from ${JSON.stringify(portableRelative2(dirname3(wrapper), runtime2).replace(/\.(?:[cm]?[jt]sx?)$/u, ""))};
 
 export const ErrorBoundary = createAbsoluteNativeRouteErrorBoundary(${JSON.stringify(route)});
 export default createAbsoluteNativeRoute(ApplicationNativeRoute, ${JSON.stringify(route)});
@@ -3029,7 +3511,7 @@ var expoTsConfig = (projectRoot, project, auth, sync) => ({
       } : {},
       "*": [
         "./node_modules/*",
-        `${portableRelative(project, projectRoot)}/node_modules/*`
+        `${portableRelative2(project, projectRoot)}/node_modules/*`
       ],
       react: ["./node_modules/@types/react/index.d.ts"],
       "react/*": ["./node_modules/@types/react/*"]
@@ -3039,9 +3521,9 @@ var expoTsConfig = (projectRoot, project, auth, sync) => ({
   extends: "expo/tsconfig.base"
 });
 var writeManagedFile = async (path, source, force) => {
-  await mkdir(dirname2(path), { recursive: true });
-  if (await exists(path)) {
-    const current = await readFile(path, "utf8");
+  await mkdir2(dirname3(path), { recursive: true });
+  if (await exists2(path)) {
+    const current = await readFile2(path, "utf8");
     if (current === source)
       return false;
     if (!force && !current.startsWith(EXPO_GENERATED_HEADER)) {
@@ -3049,32 +3531,32 @@ var writeManagedFile = async (path, source, force) => {
     }
   }
   const temporary = `${path}.${crypto.randomUUID()}.tmp`;
-  await writeFile(temporary, source, { flag: "wx" });
-  await rename(temporary, path);
+  await writeFile2(temporary, source, { flag: "wx" });
+  await rename2(temporary, path);
   return true;
 };
 var pruneManagedFiles = async (paths) => {
   const removed = await Promise.all(paths.map(async (path) => {
-    if (!await exists(path))
+    if (!await exists2(path))
       return false;
-    const source = await readFile(path, "utf8");
+    const source = await readFile2(path, "utf8");
     if (!source.startsWith(EXPO_GENERATED_HEADER) && !path.endsWith("expo-module.config.json"))
       return false;
-    await rm(path, { force: true });
+    await rm2(path, { force: true });
     return true;
   }));
   return removed.filter(Boolean).length;
 };
 var pruneStaleManagedExpoRoutes = async (project, expected) => {
-  const appDirectory = join5(project, "app");
-  if (!await exists(appDirectory))
+  const appDirectory = join6(project, "app");
+  if (!await exists2(appDirectory))
     return 0;
   const files = await walkFiles(appDirectory);
   const stale = (await Promise.all(files.map(async (path) => ({
-    managed: path.endsWith(".tsx") && (await readFile(path, "utf8")).startsWith(EXPO_GENERATED_HEADER),
+    managed: path.endsWith(".tsx") && (await readFile2(path, "utf8")).startsWith(EXPO_GENERATED_HEADER),
     path
   })))).filter(({ managed, path }) => managed && !expected.has(path));
-  await Promise.all(stale.map(({ path }) => rm(path, { force: true })));
+  await Promise.all(stale.map(({ path }) => rm2(path, { force: true })));
   return stale.length;
 };
 var jsonSource = (value) => `${JSON.stringify(value, null, "\t")}
@@ -3097,7 +3579,7 @@ export const ABSOLUTE_MOBILE_MANIFEST: AbsoluteMobileManifest | undefined = unde
 var writeAbsoluteExpoProject = async (config, options) => {
   if (config.engine !== "expo")
     throw new TypeError("Expo project generation requires mobile.engine: expo.");
-  const projectRoot = resolve3(options.projectRoot);
+  const projectRoot = resolve4(options.projectRoot);
   const project = config.nativeProjectDirectory;
   const auth = resolveAbsoluteMobileAuthManifest(projectRoot, config);
   const devices = resolveAbsoluteDeviceCapabilityPlan(projectRoot, "expo");
@@ -3106,7 +3588,7 @@ var writeAbsoluteExpoProject = async (config, options) => {
   const runtimeFingerprint = resolveAbsoluteMobileUpdateRuntime(config, projectRoot).fingerprint;
   const routeModules = Object.entries(config.expoNativeRoutes);
   const moduleChecks = await Promise.all(routeModules.map(async ([route, module]) => ({
-    exists: await exists(module),
+    exists: await exists2(module),
     module,
     route
   })));
@@ -3114,20 +3596,20 @@ var writeAbsoluteExpoProject = async (config, options) => {
   if (missing) {
     throw new TypeError(`Expo native route ${missing.route} references missing module ${missing.module}.`);
   }
-  const marker = join5(project, EXPO_PROJECT_MARKER);
-  if (await exists(project) && !await exists(marker)) {
+  const marker = join6(project, EXPO_PROJECT_MARKER);
+  if (await exists2(project) && !await exists2(marker)) {
     const entries = await readdir(project);
     if (entries.length > 0 && !options.force) {
       throw new TypeError(`Expo project directory ${project} is not AbsoluteJS-managed; rerun with --force only after reviewing it.`);
     }
   }
-  await mkdir(project, { recursive: true });
-  await writeFile(marker, `format=1
+  await mkdir2(project, { recursive: true });
+  await writeFile2(marker, `format=1
 `);
   const authEnabled = Boolean(auth);
   const files = new Map([
     [
-      join5(project, ".gitignore"),
+      join6(project, ".gitignore"),
       `.expo/
 android/
 ios/
@@ -3135,45 +3617,45 @@ node_modules/
 `
     ],
     [
-      join5(project, "app.json"),
+      join6(project, "app.json"),
       jsonSource(expoAppConfig(config, authEnabled, syncEnabled, devices, runtimeFingerprint))
     ],
-    [join5(project, "app.config.js"), expoDynamicAppConfig],
+    [join6(project, "app.config.js"), expoDynamicAppConfig],
     [
-      join5(project, "package.json"),
-      jsonSource(expoPackage(authEnabled, syncEnabled, devices, config.updates !== undefined))
+      join6(project, "package.json"),
+      jsonSource(expoPackage(authEnabled, config.branding !== undefined, syncEnabled, devices, config.updates !== undefined))
     ],
-    [join5(project, "metro.config.js"), metroConfig(projectRoot)],
+    [join6(project, "metro.config.js"), metroConfig(projectRoot)],
     [
-      join5(project, "plugins", "withAbsoluteDevelopmentCa.js"),
+      join6(project, "plugins", "withAbsoluteDevelopmentCa.js"),
       expoDevelopmentCaPlugin
     ],
     [
-      join5(project, "plugins", "withAbsoluteActivityResultRecovery.js"),
+      join6(project, "plugins", "withAbsoluteActivityResultRecovery.js"),
       expoActivityResultRecoveryPlugin
     ],
     [
-      join5(project, "tsconfig.json"),
+      join6(project, "tsconfig.json"),
       jsonSource(expoTsConfig(projectRoot, project, authEnabled, syncEnabled))
     ],
     [
-      join5(project, "app", "_layout.tsx"),
+      join6(project, "app", "_layout.tsx"),
       layoutSource(authEnabled, syncEnabled, config.updates !== undefined, config.observability !== undefined)
     ],
     [
-      join5(project, "app", "__absolute", "native", "index.tsx"),
+      join6(project, "app", "__absolute", "native", "index.tsx"),
       nativeDiagnosticSource
     ],
     [
-      join5(project, "src", "generated", "AbsoluteDevices.ts"),
+      join6(project, "src", "generated", "AbsoluteDevices.ts"),
       devicesRuntimeSource(config, devices, authEnabled)
     ],
     [
-      join5(project, "src", "generated", "AbsoluteNativeRoute.tsx"),
+      join6(project, "src", "generated", "AbsoluteNativeRoute.tsx"),
       nativeRouteRuntimeSource(authEnabled)
     ],
     [
-      join5(project, "src", "generated", "AbsoluteWebHost.tsx"),
+      join6(project, "src", "generated", "AbsoluteWebHost.tsx"),
       webHostSource(config, auth, syncEnabled)
     ]
   ]);
@@ -3184,40 +3666,41 @@ node_modules/
       files.set(path, source);
   }
   if (config.updates) {
-    files.set(join5(project, "src", "generated", "AbsoluteUpdates.ts"), updatesRuntimeSource(config));
+    files.set(join6(project, "src", "generated", "AbsoluteUpdates.ts"), updatesRuntimeSource(config));
   }
   const expoCodeSigning = config.updates?.expoCodeSigning;
   if (expoCodeSigning)
-    files.set(join5(project, "certs", "absolute-mobile-update.pem"), expoCodeSigning.certificatePem);
+    files.set(join6(project, "certs", "absolute-mobile-update.pem"), expoCodeSigning.certificatePem);
   if (auth) {
-    files.set(join5(project, "src", "generated", "AbsoluteAuth.ts"), authRuntimeSource(auth, config.appId));
+    files.set(join6(project, "src", "generated", "AbsoluteAuth.ts"), authRuntimeSource(auth, config.appId));
   }
   if (syncSchema) {
-    files.set(join5(project, "src", "generated", "AbsoluteSync.ts"), syncRuntimeSource(config, syncSchema));
+    files.set(join6(project, "src", "generated", "AbsoluteSync.ts"), syncRuntimeSource(config, syncSchema));
   }
-  const webAssetsPath = join5(project, "src", "generated", "webAssets.ts");
-  if (!await exists(webAssetsPath)) {
+  const webAssetsPath = join6(project, "src", "generated", "webAssets.ts");
+  if (!await exists2(webAssetsPath)) {
     files.set(webAssetsPath, emptyWebAssetsSource);
   }
   if (!config.expoNativeRoutes["/"]) {
-    files.set(join5(project, "app", "index.tsx"), webRouteSource);
+    files.set(join6(project, "app", "index.tsx"), webRouteSource);
   }
-  files.set(join5(project, "app", "[...absolute].tsx"), catchAllRouteSource);
-  const nativeRouteRuntime = join5(project, "src", "generated", "AbsoluteNativeRoute.tsx");
+  files.set(join6(project, "app", "[...absolute].tsx"), catchAllRouteSource);
+  const nativeRouteRuntime = join6(project, "src", "generated", "AbsoluteNativeRoute.tsx");
   for (const [route, module] of routeModules) {
-    const wrapper = route === "/" ? join5(project, "app", "index.tsx") : routeFile(project, route);
+    const wrapper = route === "/" ? join6(project, "app", "index.tsx") : routeFile(project, route);
     files.set(wrapper, nativeWrapperSource(wrapper, module, nativeRouteRuntime, route));
   }
-  const removedRoutes = await pruneStaleManagedExpoRoutes(project, new Set([...files.keys()].filter((path) => path.startsWith(`${join5(project, "app")}${sep}`))));
+  const removedRoutes = await pruneStaleManagedExpoRoutes(project, new Set([...files.keys()].filter((path) => path.startsWith(`${join6(project, "app")}${sep}`))));
   const removedObservability = config.observability ? 0 : await pruneManagedFiles(absoluteExpoNativeObservabilityPaths(project));
   const changes = await Promise.all([...files].map(([path, source]) => writeManagedFile(path, source, true)));
+  await writeAbsoluteExpoBrandingInputs(config, projectRoot);
   const changed = removedRoutes + removedObservability + changes.filter(Boolean).length;
   return { changed, path: project, written: [...files.keys()] };
 };
 var walkFiles = async (root, directory = root) => {
   const entries = await readdir(directory, { withFileTypes: true });
   const nested = await Promise.all(entries.map((entry) => {
-    const path = join5(directory, entry.name);
+    const path = join6(directory, entry.name);
     if (entry.isDirectory())
       return walkFiles(root, path);
     if (entry.isFile())
@@ -3228,7 +3711,7 @@ var walkFiles = async (root, directory = root) => {
 };
 var renameIfPresent = async (source, destination) => {
   try {
-    await rename(source, destination);
+    await rename2(source, destination);
     return true;
   } catch (error) {
     if (typeof error === "object" && error !== null && Reflect.get(error, "code") === "ENOENT") {
@@ -3241,12 +3724,12 @@ var installStagedDirectory = async (staging, destination) => {
   const backup = `${destination}.previous-${crypto.randomUUID()}`;
   const moved = await renameIfPresent(destination, backup);
   try {
-    await rename(staging, destination);
+    await rename2(staging, destination);
     if (moved)
-      await rm(backup, { force: true, recursive: true });
+      await rm2(backup, { force: true, recursive: true });
   } catch (error) {
     if (moved)
-      await rename(backup, destination);
+      await rename2(backup, destination);
     throw error;
   }
 };
@@ -3321,27 +3804,27 @@ export const materializeAbsoluteWebBundle = async () => {
 var syncAbsoluteExpoWebAssets = async (config) => {
   if (config.engine !== "expo")
     throw new TypeError("Expo asset sync requires mobile.engine: expo.");
-  const marker = join5(config.nativeProjectDirectory, EXPO_PROJECT_MARKER);
-  if (!await exists(marker)) {
+  const marker = join6(config.nativeProjectDirectory, EXPO_PROJECT_MARKER);
+  if (!await exists2(marker)) {
     throw new TypeError("Expo asset sync requires an AbsoluteJS-managed Expo project. Run mobile init first.");
   }
-  const manifestPath = join5(config.bundleDirectory, "absolute-mobile-manifest.json");
-  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  const manifestPath = join6(config.bundleDirectory, "absolute-mobile-manifest.json");
+  const manifest = JSON.parse(await readFile2(manifestPath, "utf8"));
   const nativeDataManifest = expoNativeDataManifest(manifest);
   const { appBuild } = nativeDataManifest;
   const files = await walkFiles(config.bundleDirectory);
-  const bundleHash = createHash2("sha256");
-  const filesWithContents = await Promise.all(files.map(async (file) => ({ contents: await readFile(file), file })));
+  const bundleHash = createHash3("sha256");
+  const filesWithContents = await Promise.all(files.map(async (file) => ({ contents: await readFile2(file), file })));
   filesWithContents.forEach(({ contents, file }) => {
-    bundleHash.update(relative2(config.bundleDirectory, file).replaceAll("\\", "/"));
+    bundleHash.update(relative3(config.bundleDirectory, file).replaceAll("\\", "/"));
     bundleHash.update("\x00");
     bundleHash.update(contents);
     bundleHash.update("\x00");
   });
   const bundleId = `amexpo_${bundleHash.digest("hex")}`;
-  const destination = join5(config.nativeProjectDirectory, "assets", "absolute");
-  await mkdir(dirname2(destination), { recursive: true });
-  const staging = await mkdtemp(join5(dirname2(destination), `.${basename(destination)}.stage-`));
+  const destination = join6(config.nativeProjectDirectory, "assets", "absolute");
+  await mkdir2(dirname3(destination), { recursive: true });
+  const staging = await mkdtemp(join6(dirname3(destination), `.${basename(destination)}.stage-`));
   let assets;
   let archiveAsset;
   try {
@@ -3350,22 +3833,22 @@ var syncAbsoluteExpoWebAssets = async (config) => {
       const entry = {
         length: contents.byteLength,
         offset,
-        path: relative2(config.bundleDirectory, file).replaceAll("\\", "/")
+        path: relative3(config.bundleDirectory, file).replaceAll("\\", "/")
       };
       offset += contents.byteLength;
       return entry;
     });
     const name = `bundle${EXPO_ASSET_EXTENSION}`;
-    await writeFile(join5(staging, name), Buffer.concat(filesWithContents.map(({ contents }) => contents)));
-    archiveAsset = portableRelative(join5(config.nativeProjectDirectory, "src", "generated"), join5(destination, name));
+    await writeFile2(join6(staging, name), Buffer.concat(filesWithContents.map(({ contents }) => contents)));
+    archiveAsset = portableRelative2(join6(config.nativeProjectDirectory, "src", "generated"), join6(destination, name));
     await installStagedDirectory(staging, destination);
   } catch (error) {
-    await rm(staging, { force: true, recursive: true });
+    await rm2(staging, { force: true, recursive: true });
     throw error;
   }
-  const generated = join5(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
+  const generated = join6(config.nativeProjectDirectory, "src", "generated", "webAssets.ts");
   await writeManagedFile(generated, assetModuleSource(assets, archiveAsset, bundleId, nativeDataManifest), true);
   return { appBuild, assets: assets.length, bundleId, path: destination };
 };
 
-export { discoverAbsoluteSyncSchema, absoluteDeviceNativeRequirements, assertAbsoluteDeviceCapabilityPackages, resolveAbsoluteDeviceCapabilityPlan, ABSOLUTE_MOBILE_UPDATE_FORMAT, absoluteMobileUpdateSigningPayload, canonicalizeAbsoluteMobileUpdate, parseAbsoluteMobileUpdateManifest, unsignedAbsoluteMobileUpdate, resolveAbsoluteMobileUpdateRuntime, writeAbsoluteExpoProject, syncAbsoluteExpoWebAssets };
+export { discoverAbsoluteSyncSchema, absoluteDeviceNativeRequirements, assertAbsoluteDeviceCapabilityPackages, resolveAbsoluteDeviceCapabilityPlan, ABSOLUTE_MOBILE_UPDATE_FORMAT, absoluteMobileUpdateSigningPayload, canonicalizeAbsoluteMobileUpdate, parseAbsoluteMobileUpdateManifest, unsignedAbsoluteMobileUpdate, resolveAbsoluteMobileUpdateRuntime, ABSOLUTE_CAPACITOR_ASSETS_SPEC, generateAbsoluteCapacitorBranding, inspectAbsoluteMobileBranding, renderAbsoluteMobileBrandingPreview, writeAbsoluteExpoProject, syncAbsoluteExpoWebAssets };