@absolutejs/absolute 0.20.0-beta.16 → 0.20.0-beta.18

package/dist/mobile/index.js

@@ -168,7 +168,7 @@ var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-
 };
 
 // node_modules/@absolutejs/sync/dist/client/index.js
-var RUNTIME_TRANSPORT, host, isRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations")), registry, SyncLocalDataPolicyError, SyncLocalStoreSchemaError, positiveVersion = (value, label) => {
+var RUNTIME_TRANSPORT, host, isRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations")) && Array.isArray(Reflect.get(value, "clients")), registry, SyncLocalDataPolicyError, SyncLocalStoreSchemaError, positiveVersion = (value, label) => {
   if (!Number.isSafeInteger(value) || value < 1)
     throw new SyncLocalStoreSchemaError("INVALID_PLAN", `${label} must be a positive safe integer`);
   return value;
@@ -189,6 +189,12 @@ var RUNTIME_TRANSPORT, host, isRegistry = (value) => typeof value === "object" &
   }
   for (const [index, rule] of (policy.mutations ?? []).entries()) {
     validatePolicyMatch(rule.match, `${label}.mutations[${index}]`);
+    if (rule.conflict !== undefined && rule.conflict.strategy !== "client-wins" && rule.conflict.strategy !== "manual" && rule.conflict.strategy !== "server-wins")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.strategy is invalid.`);
+    if (rule.conflict?.maxAttempts !== undefined && (!Number.isSafeInteger(rule.conflict.maxAttempts) || rule.conflict.maxAttempts < 1))
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.maxAttempts must be a positive safe integer.`);
+    if (rule.conflict?.maxAttempts !== undefined && rule.conflict.strategy !== "client-wins")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}].conflict.maxAttempts is only valid for client-wins.`);
     if (rule.persistence === "memory-only" && rule.protection === "required")
       throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}] cannot require at-rest protection when it is memory-only.`);
     if (rule.sensitivity !== undefined && rule.sensitivity !== "public" && rule.protection !== "required" && rule.persistence !== "memory-only")
@@ -254,7 +260,11 @@ var init_client = __esm(() => {
     const existing = host[RUNTIME_TRANSPORT];
     if (isRegistry(existing))
       return existing;
-    const created = { installations: [] };
+    if (typeof existing === "object" && existing !== null && Array.isArray(Reflect.get(existing, "installations"))) {
+      Reflect.set(existing, "clients", []);
+      return existing;
+    }
+    const created = { clients: [], installations: [] };
     Object.defineProperty(host, RUNTIME_TRANSPORT, {
       configurable: false,
       enumerable: false,
@@ -442,6 +452,7 @@ var object = (value) => typeof value === "object" && value !== null && !Array.is
   const mutations = Array.isArray(mutationRules) ? mutationRules.map((entry, index) => {
     const rule = requireObject(entry, id, `localData.mutations[${index}] must be an object.`);
     const allowedRuleKeys = new Set([
+      "conflict",
       "match",
       "onProtectionUnavailable",
       "persistence",
@@ -455,6 +466,26 @@ var object = (value) => typeof value === "object" && value !== null && !Array.is
     const sensitivity = unknownField(rule, "sensitivity");
     const persistence = unknownField(rule, "persistence");
     const onProtectionUnavailable = unknownField(rule, "onProtectionUnavailable");
+    const declaredConflict = unknownField(rule, "conflict");
+    let conflict;
+    if (declaredConflict !== undefined) {
+      const conflictRecord = requireObject(declaredConflict, id, `localData.mutations[${index}].conflict must be an object.`);
+      const unsupportedConflictKey = Object.keys(conflictRecord).find((key) => key !== "maxAttempts" && key !== "strategy");
+      if (unsupportedConflictKey)
+        throw metadataError(id, `localData.mutations[${index}].conflict.${unsupportedConflictKey} is not supported.`);
+      const strategy = unknownField(conflictRecord, "strategy");
+      if (strategy !== "client-wins" && strategy !== "manual" && strategy !== "server-wins")
+        throw metadataError(id, `localData.mutations[${index}].conflict.strategy is invalid.`);
+      const maxAttempts = unknownField(conflictRecord, "maxAttempts");
+      if (maxAttempts !== undefined && strategy !== "client-wins")
+        throw metadataError(id, `localData.mutations[${index}].conflict.maxAttempts requires client-wins.`);
+      conflict = {
+        strategy,
+        ...maxAttempts === undefined ? {} : {
+          maxAttempts: positiveVersion2(maxAttempts, id, `localData.mutations[${index}].conflict.maxAttempts`)
+        }
+      };
+    }
     if (protection !== undefined && protection !== "none" && protection !== "required")
       throw metadataError(id, `localData.mutations[${index}].protection is invalid.`);
     if (sensitivity !== undefined && sensitivity !== "public" && sensitivity !== "private" && sensitivity !== "secret")
@@ -465,6 +496,7 @@ var object = (value) => typeof value === "object" && value !== null && !Array.is
       throw metadataError(id, `localData.mutations[${index}].persistence is invalid.`);
     return {
       match: nonEmpty(Reflect.get(rule, "match"), id, `localData.mutations[${index}].match`),
+      ...conflict ? { conflict } : {},
       ...sensitivity ? { sensitivity } : {},
       ...onProtectionUnavailable ? { onProtectionUnavailable } : {},
       ...persistence ? {
@@ -3895,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
@@ -4566,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],
@@ -4713,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,
@@ -4738,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;
@@ -4979,6 +5047,164 @@ 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 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 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.`);
+  return { factory, module, packages: [...value.packages] };
+};
+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) => {
@@ -5012,11 +5238,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);
@@ -5029,11 +5255,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);
@@ -5046,12 +5272,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.");
   }
@@ -5070,6 +5298,8 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     ...auth ? { auth } : {},
     buildDirectory,
     config: mobile,
+    deviceCapabilities,
+    projectRoot: options.projectRoot,
     ...sync ? { sync: true } : {},
     ...syncSchema ? { syncSchema: { components: syncSchema.components } } : {}
   });
@@ -5079,6 +5309,113 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
 // src/mobile/index.ts
 init_syncSchema();
 
+// node_modules/@absolutejs/sync/dist/client/runtimeTransport.js
+var RUNTIME_TRANSPORT2 = Symbol.for("@absolutejs/sync/client-runtime-transport");
+var host2 = globalThis;
+var isRegistry2 = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations")) && Array.isArray(Reflect.get(value, "clients"));
+var registry2 = (() => {
+  const existing = host2[RUNTIME_TRANSPORT2];
+  if (isRegistry2(existing))
+    return existing;
+  if (typeof existing === "object" && existing !== null && Array.isArray(Reflect.get(existing, "installations"))) {
+    Reflect.set(existing, "clients", []);
+    return existing;
+  }
+  const created = { clients: [], installations: [] };
+  Object.defineProperty(host2, RUNTIME_TRANSPORT2, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+})();
+var maximum = (values) => {
+  const present = values.filter((value) => value !== undefined);
+  return present.length === 0 ? undefined : Math.max(...present);
+};
+var minimum = (values) => {
+  const present = values.filter((value) => value !== undefined);
+  return present.length === 0 ? undefined : Math.min(...present);
+};
+var inspectSyncRuntime = async () => {
+  const clients = [...registry2.clients];
+  const statuses = clients.map((client) => client.status());
+  const deadLetters = (await Promise.all(clients.map((client) => client.listDeadLetters()))).flat().map((record) => ({
+    attempts: record.attempts,
+    ...record.rejection?.code ? { code: record.rejection.code } : {},
+    createdAt: record.createdAt,
+    ...record.deadLetteredAt === undefined ? {} : { deadLetteredAt: record.deadLetteredAt },
+    ...record.rejection?.kind ? { kind: record.rejection.kind } : {},
+    ...record.rejection?.message ? { message: record.rejection.message } : {},
+    name: record.name,
+    operationId: record.operationId
+  })).sort((left, right) => (left.deadLetteredAt ?? left.createdAt) - (right.deadLetteredAt ?? right.createdAt) || left.operationId.localeCompare(right.operationId));
+  const lastError = statuses.findLast((status) => status.lastError)?.lastError;
+  return {
+    automaticResolutions: statuses.reduce((total, status) => total + status.automaticResolutions, 0),
+    clients: clients.length,
+    conflicts: deadLetters.filter((record) => record.kind === "conflict").length,
+    deadLetters,
+    ...lastError ? { lastError } : {},
+    ...maximum(statuses.map((status) => status.lastSuccessfulPullAt)) === undefined ? {} : {
+      lastSuccessfulPullAt: maximum(statuses.map((status) => status.lastSuccessfulPullAt))
+    },
+    ...maximum(statuses.map((status) => status.lastSuccessfulPushAt)) === undefined ? {} : {
+      lastSuccessfulPushAt: maximum(statuses.map((status) => status.lastSuccessfulPushAt))
+    },
+    ...minimum(statuses.map((status) => status.oldestDeadLetterAt)) === undefined ? {} : {
+      oldestDeadLetterAt: minimum(statuses.map((status) => status.oldestDeadLetterAt))
+    },
+    ...minimum(statuses.map((status) => status.oldestPendingAt)) === undefined ? {} : {
+      oldestPendingAt: minimum(statuses.map((status) => status.oldestPendingAt))
+    },
+    pending: statuses.reduce((total, status) => total + status.pending, 0)
+  };
+};
+var clientWithDeadLetter = async (operationId) => {
+  for (const client of registry2.clients)
+    if ((await client.listDeadLetters()).some((record) => record.operationId === operationId))
+      return client;
+  throw new Error(`Unknown Sync dead letter "${operationId}"`);
+};
+var retrySyncRuntimeDeadLetter = async (operationId) => (await clientWithDeadLetter(operationId)).retryDeadLetter(operationId);
+var discardSyncRuntimeDeadLetter = async (operationId) => (await clientWithDeadLetter(operationId)).discardDeadLetter(operationId);
+var rebaseSyncRuntimeDeadLetter = async (operationId, args) => (await clientWithDeadLetter(operationId)).rebaseDeadLetter(operationId, args);
+
+// src/mobile/syncRemediation.ts
+var REMEDIATION_REGISTRY = Symbol.for("@absolutejs/mobile-sync-remediation");
+var LAST_INSTALLATION_OFFSET = -1;
+var isRegistry3 = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations"));
+var resolveRegistry = () => {
+  const existing = Reflect.get(globalThis, REMEDIATION_REGISTRY);
+  if (isRegistry3(existing))
+    return existing;
+  const created = { installations: [] };
+  Object.defineProperty(globalThis, REMEDIATION_REGISTRY, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+};
+var registry3 = resolveRegistry();
+var getAbsoluteMobileSyncRemediation = () => registry3.installations.at(LAST_INSTALLATION_OFFSET)?.bridge;
+var installAbsoluteMobileSyncRemediation = (bridge = {
+  discard: discardSyncRuntimeDeadLetter,
+  inspect: inspectSyncRuntime,
+  rebase: rebaseSyncRuntimeDeadLetter,
+  retry: retrySyncRuntimeDeadLetter
+}) => {
+  const installation = { bridge };
+  registry3.installations.push(installation);
+  return () => {
+    const index = registry3.installations.indexOf(installation);
+    if (index >= 0)
+      registry3.installations.splice(index, 1);
+  };
+};
 // src/mobile/compatibilityDispatcher.ts
 import { Elysia as Elysia2 } from "elysia";
 
@@ -5220,7 +5557,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";
@@ -5256,7 +5593,7 @@ var replaceManagedRegion = (source, region, insertAt) => {
   return `${source.slice(0, index)}${region}${source.slice(index)}`;
 };
 var androidRegion = (config) => {
-  const hosts = config.deepLinkHosts.map((host2) => `                <data android:scheme="https" android:host="${escapeXml(host2)}" />`).join(`
+  const hosts = config.deepLinkHosts.map((host3) => `                <data android:scheme="https" android:host="${escapeXml(host3)}" />`).join(`
 `);
   const customScheme = config.deepLinkScheme ? `
 
@@ -5277,7 +5614,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) {
@@ -5303,7 +5640,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}
@@ -5312,7 +5649,7 @@ var configureIosInfo = async (config) => {
   return writeChangedFile(path, updated);
 };
 var iosEntitlementsSource = (config) => {
-  const domains = config.deepLinkHosts.map((host2) => `		<string>applinks:${escapeXml(host2)}</string>`).join(`
+  const domains = config.deepLinkHosts.map((host3) => `		<string>applinks:${escapeXml(host3)}</string>`).join(`
 `);
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -5327,7 +5664,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");
@@ -5345,7 +5682,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)
@@ -5385,7 +5722,7 @@ var applyAbsoluteNativeDeepLinks = async (config, platforms = config.platforms)
 };
 // 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") {
@@ -5411,9 +5748,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.");
   }
@@ -5482,9 +5819,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([
@@ -5534,60 +5871,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 {
@@ -5601,11 +5938,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")) {
@@ -5620,7 +5957,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)
         }
       ];
@@ -5628,7 +5965,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);
@@ -5646,25 +5983,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);
@@ -5672,26 +6009,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) {
@@ -5705,7 +6042,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;
   }
@@ -5716,16 +6053,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)
@@ -5737,35 +6074,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)
@@ -5781,14 +6118,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);
@@ -5797,12 +6134,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;
@@ -5835,7 +6172,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;
@@ -5877,21 +6214,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);
@@ -5900,21 +6237,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))
     ]))
   ]);
 };
@@ -5925,19 +6262,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)
   ]);
@@ -5950,16 +6287,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)
@@ -5970,45 +6307,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
   })));
 };
@@ -6030,6 +6367,7 @@ export {
   resolveAbsoluteMobileDeepLink,
   resolveAbsoluteMobileCompatibilityRelease,
   resolveAbsoluteMobileAuthManifest,
+  resolveAbsoluteDeviceCapabilityPlan,
   repairAbsoluteIosDevSession,
   removeAbsoluteRemoteMacProfile,
   redactAbsoluteIosLog,
@@ -6053,6 +6391,7 @@ export {
   pairAbsoluteRemoteMac,
   normalizeAbsoluteMobileConfig,
   navigateAbsoluteMobilePage,
+  missingAbsoluteDeviceCapabilityPackages,
   materializeAbsoluteRemoteMacAgent,
   materializeAbsoluteMobileCompatibilityBundle,
   materializeAbsoluteMobileAssociationFiles,
@@ -6060,15 +6399,18 @@ export {
   matchesAbsoluteMobileRoutePattern,
   loadAbsoluteNativeReleasePublisher,
   loadAbsoluteMobileMaterializedBundle,
+  loadAbsoluteDeviceCapabilityProviders,
   listAbsoluteRemoteMacProfiles,
   isAbsoluteIosNativeRootInput,
   installAbsoluteRemoteMacAgent,
+  installAbsoluteMobileSyncRemediation,
   installAbsoluteMobileAuthEnvironment,
   inspectAbsoluteRemoteMac,
   inspectAbsoluteMobileRouteMetadata,
   hashAbsoluteMobilePropsSchema,
   getCurrentAbsoluteMobileProducerContext,
   getAbsoluteRemoteMacProfile,
+  getAbsoluteMobileSyncRemediation,
   fingerprintAbsoluteIosNativeProject,
   fingerprintAbsoluteIosDevProject,
   finalizeAbsoluteMobilePage,
@@ -6076,6 +6418,8 @@ export {
   fetchAbsoluteMobilePage,
   disposeAbsoluteMobilePage,
   discoverAbsoluteSyncSchema,
+  discoverAbsoluteDeviceCapabilities,
+  directAbsoluteProjectPackages,
   createAbsoluteRemoteIosDevProject,
   createAbsoluteMobileUpgradeResponse,
   createAbsoluteMobileRouteMetadataPlugin,
@@ -6095,6 +6439,7 @@ export {
   buildAbsoluteMobileCompatibilityRelease,
   buildAbsoluteIosRelease,
   buildAbsoluteAndroidRelease,
+  assertAbsoluteDeviceCapabilityPackages,
   applyAbsoluteNativeDeepLinks,
   activateAbsoluteMobilePage,
   acceptsAbsoluteMobilePage,
@@ -6123,5 +6468,5 @@ export {
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=8A696911288E3CC364756E2164756E21
+//# debugId=09531F7676B08D9D64756E2164756E21
 //# sourceMappingURL=index.js.map