@absolutejs/absolute 0.20.0-beta.13 → 0.20.0-beta.14

package/dist/mobile/index.js

@@ -167,6 +167,257 @@ var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-
   return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
 };
 
+// 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, SyncLocalStoreSchemaError, positiveVersion = (value, label) => {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new SyncLocalStoreSchemaError("INVALID_PLAN", `${label} must be a positive safe integer`);
+  return value;
+}, isSchemaBundle = (schema) => ("components" in schema), normalizeSyncLocalSchemaComponents = (schema = { version: 1 }) => {
+  const components = isSchemaBundle(schema) ? [...schema.components] : [{ ...schema, id: "@absolutejs/app" }];
+  const ids = new Set;
+  for (const component of components) {
+    if (typeof component.id !== "string" || component.id.trim() !== component.id || component.id.length === 0)
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", "Sync schema component id must be non-empty and trimmed");
+    if (ids.has(component.id))
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", `Sync schema component "${component.id}" is declared more than once`);
+    ids.add(component.id);
+  }
+  return components.sort((a, b) => a.id.localeCompare(b.id));
+}, resolveSyncLocalSchemaComponents = (storedVersions, schema = { version: 1 }) => {
+  const components = normalizeSyncLocalSchemaComponents(schema).map((component) => {
+    const current = resolveSyncLocalMigrations(component.version, component);
+    return {
+      id: component.id,
+      ...resolveSyncLocalMigrations(storedVersions[component.id] ?? current.minimumCompatibleVersion, component)
+    };
+  });
+  const active = new Set(components.map((component) => component.id));
+  const orphanedComponents = Object.keys(storedVersions).filter((id) => !active.has(id)).sort();
+  return { components, orphanedComponents };
+}, resolveSyncLocalMigrations = (storedVersion, schema = { version: 1 }) => {
+  positiveVersion(storedVersion, "Stored Sync schema version");
+  const targetVersion = positiveVersion(schema.version, "Target Sync schema version");
+  const migrations = [...schema.migrations ?? []].sort((a, b) => a.toVersion - b.toVersion);
+  const versions = new Set;
+  for (const migration of migrations) {
+    positiveVersion(migration.toVersion, "Sync migration toVersion");
+    if (versions.has(migration.toVersion))
+      throw new SyncLocalStoreSchemaError("INVALID_PLAN", `Sync migration ${migration.toVersion} is declared more than once`);
+    versions.add(migration.toVersion);
+  }
+  const inferredMinimum = migrations[0] ? migrations[0].toVersion - 1 : targetVersion;
+  const minimumCompatibleVersion = positiveVersion(schema.minimumCompatibleVersion ?? inferredMinimum, "Minimum compatible Sync schema version");
+  if (minimumCompatibleVersion > targetVersion)
+    throw new SyncLocalStoreSchemaError("INVALID_PLAN", "Minimum compatible Sync schema version cannot exceed its target");
+  if (storedVersion > targetVersion)
+    throw new SyncLocalStoreSchemaError("SCHEMA_TOO_NEW", `Stored Sync schema ${storedVersion} is newer than this runtime's schema ${targetVersion}`, { storedVersion, targetVersion });
+  if (storedVersion < minimumCompatibleVersion)
+    throw new SyncLocalStoreSchemaError("SCHEMA_TOO_OLD", `Stored Sync schema ${storedVersion} is older than the minimum compatible schema ${minimumCompatibleVersion}`, { storedVersion, targetVersion });
+  const steps = [];
+  for (let version = storedVersion + 1;version <= targetVersion; version++) {
+    const migration = migrations.find((candidate) => candidate.toVersion === version);
+    if (migration === undefined)
+      throw new SyncLocalStoreSchemaError("MIGRATION_MISSING", `Sync migration ${version - 1} -> ${version} is missing`, { storedVersion, targetVersion });
+    steps.push(migration);
+  }
+  return { minimumCompatibleVersion, steps, targetVersion };
+};
+var init_client = __esm(() => {
+  RUNTIME_TRANSPORT = Symbol.for("@absolutejs/sync/client-runtime-transport");
+  host = globalThis;
+  registry = (() => {
+    const existing = host[RUNTIME_TRANSPORT];
+    if (isRegistry(existing))
+      return existing;
+    const created = { installations: [] };
+    Object.defineProperty(host, RUNTIME_TRANSPORT, {
+      configurable: false,
+      enumerable: false,
+      value: created,
+      writable: false
+    });
+    return created;
+  })();
+  SyncLocalStoreSchemaError = class SyncLocalStoreSchemaError extends Error {
+    code;
+    storedVersion;
+    targetVersion;
+    constructor(code, message, versions = {}) {
+      super(message);
+      this.name = "SyncLocalStoreSchemaError";
+      this.code = code;
+      this.storedVersion = versions.storedVersion;
+      this.targetVersion = versions.targetVersion;
+    }
+  };
+});
+
+// src/mobile/syncSchema.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname9, join as join12, resolve as resolve10 } from "path";
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value), manifestAt = (path) => {
+  try {
+    const value = JSON.parse(readFileSync3(path, "utf8"));
+    return object(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}, localSchemaMetadata = (manifest) => {
+  const absolutejs = Reflect.get(manifest, "absolutejs");
+  if (!object(absolutejs))
+    return;
+  const sync = Reflect.get(absolutejs, "sync");
+  if (!object(sync))
+    return;
+  return Reflect.get(sync, "localSchema");
+}, packageManifestPath = (projectRoot, packageName) => {
+  let directory = resolve10(projectRoot);
+  while (true) {
+    const candidate = join12(directory, "node_modules", packageName, "package.json");
+    const manifest = manifestAt(candidate);
+    if (manifest && Reflect.get(manifest, "name") === packageName)
+      return candidate;
+    const parent = dirname9(directory);
+    if (parent === directory)
+      return;
+    directory = parent;
+  }
+}, metadataError = (id, detail) => new TypeError(`Invalid AbsoluteJS Sync schema metadata for ${id}: ${detail}`), positiveVersion2 = (value, id, field) => {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+    throw metadataError(id, `${field} must be a positive safe integer.`);
+  return value;
+}, nonEmpty = (value, id, field) => {
+  if (typeof value !== "string" || value.trim() !== value || value.length === 0)
+    throw metadataError(id, `${field} must be a non-empty trimmed string.`);
+  return value;
+}, requireObject = (value, id, detail) => {
+  if (!object(value))
+    throw metadataError(id, detail);
+  return value;
+}, normalizeJsonValue2 = (value, id, field) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return value;
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (Array.isArray(value))
+    return value.map((entry) => normalizeJsonValue2(entry, id, field));
+  if (object(value))
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      normalizeJsonValue2(entry, id, field)
+    ]));
+  throw metadataError(id, `${field} must be JSON-safe.`);
+}, operation = (value, id, index) => {
+  const record = requireObject(value, id, `migration operation ${index} must be an object.`);
+  const type = Reflect.get(record, "type");
+  const collection = nonEmpty(Reflect.get(record, "collection"), id, `operation ${index}.collection`);
+  if (type === "delete-collection")
+    return { collection, type };
+  if (type === "rename-field")
+    return {
+      collection,
+      from: nonEmpty(Reflect.get(record, "from"), id, `operation ${index}.from`),
+      to: nonEmpty(Reflect.get(record, "to"), id, `operation ${index}.to`),
+      type
+    };
+  const field = nonEmpty(Reflect.get(record, "field"), id, `operation ${index}.field`);
+  if (type === "remove-field")
+    return { collection, field, type };
+  if (type === "set-default")
+    return {
+      collection,
+      field,
+      type,
+      value: normalizeJsonValue2(Reflect.get(record, "value"), id, `operation ${index}.value`)
+    };
+  throw metadataError(id, `operation ${index}.type is not supported.`);
+}, migration = (value, id, index) => {
+  const record = requireObject(value, id, `migration ${index} must be an object.`);
+  const allowed = new Set(["operations", "toVersion"]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `migration ${index}.${unsupported} is not declarative metadata.`);
+  const declaredOperations = Reflect.get(record, "operations");
+  if (declaredOperations !== undefined && !Array.isArray(declaredOperations))
+    throw metadataError(id, `migration ${index}.operations must be an array.`);
+  const operations = Array.isArray(declaredOperations) ? declaredOperations : [];
+  return {
+    operations: operations.map((entry, operationIndex) => operation(entry, id, operationIndex)),
+    toVersion: positiveVersion2(Reflect.get(record, "toVersion"), id, `migration ${index}.toVersion`)
+  };
+}, component = (id, value) => {
+  const record = requireObject(value, id, "localSchema must be an object.");
+  const allowed = new Set([
+    "migrations",
+    "minimumCompatibleVersion",
+    "version"
+  ]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `${unsupported} is not supported.`);
+  const version = positiveVersion2(Reflect.get(record, "version"), id, "version");
+  const declaredMinimum = Reflect.get(record, "minimumCompatibleVersion");
+  const minimumCompatibleVersion = declaredMinimum === undefined ? Math.max(1, version - 2) : positiveVersion2(declaredMinimum, id, "minimumCompatibleVersion");
+  const declaredMigrations = Reflect.get(record, "migrations");
+  if (declaredMigrations !== undefined && !Array.isArray(declaredMigrations))
+    throw metadataError(id, "migrations must be an array.");
+  const migrations = Array.isArray(declaredMigrations) ? declaredMigrations : undefined;
+  return {
+    id,
+    minimumCompatibleVersion,
+    ...Array.isArray(migrations) ? {
+      migrations: migrations.map((entry, index) => migration(entry, id, index))
+    } : {},
+    version
+  };
+}, dependencyNames = (manifest) => [
+  Reflect.get(manifest, "dependencies"),
+  Reflect.get(manifest, "optionalDependencies"),
+  Reflect.get(manifest, "devDependencies"),
+  Reflect.get(manifest, "peerDependencies")
+].flatMap((dependencies) => object(dependencies) ? Object.keys(dependencies) : []).filter((name, index, names) => names.indexOf(name) === index).sort(), discoverAbsoluteSyncSchema = (projectRoot) => {
+  const appManifestPath = join12(resolve10(projectRoot), "package.json");
+  const appManifest = manifestAt(appManifestPath);
+  if (!appManifest)
+    return {
+      components: [
+        {
+          id: "@absolutejs/app",
+          minimumCompatibleVersion: 1,
+          version: 1
+        }
+      ],
+      sources: []
+    };
+  const appMetadata = localSchemaMetadata(appManifest);
+  const components = [
+    appMetadata === undefined ? { id: "@absolutejs/app", minimumCompatibleVersion: 1, version: 1 } : component("@absolutejs/app", appMetadata)
+  ];
+  const sources = [
+    { id: "@absolutejs/app", manifestPath: appManifestPath }
+  ];
+  for (const name of dependencyNames(appManifest)) {
+    const manifestPath = packageManifestPath(projectRoot, name);
+    if (!manifestPath)
+      continue;
+    const manifest = manifestAt(manifestPath);
+    if (!manifest)
+      continue;
+    const metadata = localSchemaMetadata(manifest);
+    if (metadata === undefined)
+      continue;
+    components.push(component(name, metadata));
+    sources.push({ id: name, manifestPath });
+  }
+  components.sort((left, right) => left.id.localeCompare(right.id));
+  sources.sort((left, right) => left.id.localeCompare(right.id));
+  resolveSyncLocalSchemaComponents({}, { components });
+  return { components, sources };
+};
+var init_syncSchema = __esm(() => {
+  init_client();
+});
+
 // src/mobile/artifactStore.ts
 import { createHash as createHash2 } from "crypto";
 import {
@@ -2576,6 +2827,7 @@ var ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION = 1;
 
 // src/mobile/remoteMacProtocol.ts
 var PROFILE_FORMAT = 1;
+var REMOTE_STDIN_FLUSH_ATTEMPTS = 3;
 var PROFILE_NAME = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/u;
 var SSH_DESTINATION = /^(?:[A-Za-z0-9._-]+@)?[A-Za-z0-9._:-]+$/u;
 var defaultProfilePath = () => join7(homedir2(), ".absolutejs", "mobile", "remote-macs.json");
@@ -3067,8 +3319,17 @@ var startAbsoluteRemoteIosDevSession = async (options) => {
     const response = new Promise((resolve6, reject) => pending.set(id, { reject, resolve: resolve6 }));
     process2.stdin.write(`${JSON.stringify({ command: commandName, id, v: 1 })}
 `);
-    process2.stdin.flush();
-    return response;
+    const flush = async () => {
+      for (let attempt = 0;attempt < REMOTE_STDIN_FLUSH_ATTEMPTS; attempt++) {
+        try {
+          await process2.stdin.flush();
+          return;
+        } catch {
+          await Promise.resolve();
+        }
+      }
+    };
+    return flush().then(() => response);
   };
   let closed = false;
   const close = async () => {
@@ -3495,7 +3756,7 @@ var parseAbsoluteMobileBuildPageMetadata = (value) => {
 };
 // src/mobile/buildPipeline.ts
 import { readFile as readFile13 } from "fs/promises";
-import { join as join12, resolve as resolve10 } from "path";
+import { join as join13, resolve as resolve11 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/mobile/buildRelease.ts
@@ -4325,7 +4586,12 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
             endpoint: new URL("/__absolute/sync/background", options.config.productionOrigin).href,
             intervalMinutes: 15
           },
-          socketTickets: true
+          socketTickets: true,
+          storageSchema: options.syncSchema ?? {
+            components: [
+              { id: "@absolutejs/app", version: 1 }
+            ]
+          }
         }
       } : {}
     };
@@ -4573,6 +4839,7 @@ var serializeAbsoluteMobileAuthEnvironment = (config, auth) => auth === undefine
 ]);
 
 // src/mobile/buildPipeline.ts
+init_syncSchema();
 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) => {
@@ -4606,11 +4873,11 @@ var loadServerApp = async (producerPath) => {
   return { app, exportName };
 };
 var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve10(options.buildDirectory);
+  const buildDirectory = resolve11(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join12(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join13(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile13(join12(buildDirectory, "manifest.json"), "utf8"),
+    readFile13(join13(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -4623,11 +4890,11 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
   process.env.ABSOLUTE_COMPILED_RUNTIME = "1";
   if (options.configPath) {
-    process.env.ABSOLUTE_CONFIG = resolve10(options.projectRoot, options.configPath);
+    process.env.ABSOLUTE_CONFIG = resolve11(options.projectRoot, options.configPath);
   }
   let loaded;
   try {
-    loaded = await loadServerApp(resolve10(options.producerPath));
+    loaded = await loadServerApp(resolve11(options.producerPath));
   } finally {
     restoreEnvironmentVariable("ABSOLUTE_BUILD_DIR", previousBuildDirectory);
     restoreEnvironmentVariable("ABSOLUTE_COMPILED_RUNTIME", previousCompiledRuntime);
@@ -4640,11 +4907,12 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve10(options.producerPath),
+    producerPath: resolve11(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;
   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.");
   }
@@ -4663,10 +4931,15 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
     ...auth ? { auth } : {},
     buildDirectory,
     config: mobile,
-    ...sync ? { sync: true } : {}
+    ...sync ? { sync: true } : {},
+    ...syncSchema ? { syncSchema: { components: syncSchema.components } } : {}
   });
   return current.artifact;
 };
+
+// src/mobile/index.ts
+init_syncSchema();
+
 // src/mobile/compatibilityDispatcher.ts
 import { Elysia as Elysia2 } from "elysia";
 
@@ -4808,7 +5081,7 @@ var createAbsoluteMobileCompatibilityDispatcher = (options) => {
 };
 // src/mobile/nativeDeepLinks.ts
 import { readFile as readFile14, rename as rename11, writeFile as writeFile12 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->";
 var END_MARKER = "<!-- absolutejs:deep-links:end -->";
 var IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements";
@@ -4844,7 +5117,7 @@ var replaceManagedRegion = (source, region, insertAt) => {
   return `${source.slice(0, index)}${region}${source.slice(index)}`;
 };
 var androidRegion = (config) => {
-  const hosts = config.deepLinkHosts.map((host) => `                <data android:scheme="https" android:host="${escapeXml(host)}" />`).join(`
+  const hosts = config.deepLinkHosts.map((host2) => `                <data android:scheme="https" android:host="${escapeXml(host2)}" />`).join(`
 `);
   const customScheme = config.deepLinkScheme ? `
 
@@ -4865,7 +5138,7 @@ ${hosts}
 `;
 };
 var configureAndroid = async (config) => {
-  const path = join13(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const path = join14(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) {
@@ -4891,7 +5164,7 @@ var iosSchemeRegion = (scheme) => `	${START_MARKER}
 	${END_MARKER}
 `;
 var configureIosInfo = async (config) => {
-  const path = join13(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const path = join14(config.nativeProjectDirectory, "ios/App/App/Info.plist");
   const source = await readFile14(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
@@ -4900,7 +5173,7 @@ var configureIosInfo = async (config) => {
   return writeChangedFile(path, updated);
 };
 var iosEntitlementsSource = (config) => {
-  const domains = config.deepLinkHosts.map((host) => `		<string>applinks:${escapeXml(host)}</string>`).join(`
+  const domains = config.deepLinkHosts.map((host2) => `		<string>applinks:${escapeXml(host2)}</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">
@@ -4915,7 +5188,7 @@ ${domains}
 `;
 };
 var configureIosEntitlements = async (config) => {
-  const path = join13(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join14(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
     current = await readFile14(path, "utf8");
@@ -4933,7 +5206,7 @@ var configureIosEntitlements = async (config) => {
   return true;
 };
 var configureIosProject = async (config) => {
-  const path = join13(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const path = join14(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
   const source = await readFile14(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
@@ -4973,7 +5246,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 resolve11, sep as sep6 } from "path";
+import { isAbsolute as isAbsolute6, relative as relative9, resolve as resolve12, sep as sep6 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -4999,8 +5272,8 @@ 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 = resolve11(projectRoot);
-  const path = resolve11(root, requested);
+  const root = resolve12(projectRoot);
+  const path = resolve12(root, requested);
   const projectRelative = relative9(root, path);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute6(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
@@ -5070,8 +5343,8 @@ var publishAbsoluteIosRelease = async (options) => {
   return publication;
 };
 // src/mobile/routeMetadataTransform.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname9, extname as extname3, relative as relative10, resolve as resolve12 } from "path";
+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";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
@@ -5122,7 +5395,7 @@ var PAGE_HANDLERS = new Map([
   ]
 ]);
 var posixPath = (value) => value.replace(/\\/g, "/");
-var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname9(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
+var findTsconfig = (entry, projectRoot) => ts.findConfigFile(dirname10(entry), existsSync3, "tsconfig.json") ?? ts.findConfigFile(projectRoot, existsSync3, "tsconfig.json");
 var createProgram = (entry, projectRoot) => {
   const configPath = findTsconfig(entry, projectRoot);
   if (!configPath) {
@@ -5134,7 +5407,7 @@ var createProgram = (entry, projectRoot) => {
       target: ts.ScriptTarget.ESNext
     });
   }
-  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync3(path, "utf8")).config, ts.sys, dirname9(configPath));
+  const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, (path) => readFileSync4(path, "utf8")).config, ts.sys, dirname10(configPath));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts.createProgram(parsed.fileNames, parsed.options);
@@ -5148,8 +5421,8 @@ var propertyName = (property) => {
     return property.name.text;
   return;
 };
-var objectPropertyExpression = (object, name) => {
-  const property = object.properties.find((candidate) => propertyName(candidate) === name);
+var objectPropertyExpression = (object2, name) => {
+  const property = object2.properties.find((candidate) => propertyName(candidate) === name);
   if (property && ts.isPropertyAssignment(property)) {
     return property.initializer;
   }
@@ -5345,8 +5618,8 @@ var spreadObject = (expression, checker, bindings) => {
     return;
   return callableObject(expression, checker);
 };
-var objectAssetKey = (object, name, checker, bindings = new Map) => {
-  for (const property of [...object.properties].reverse()) {
+var objectAssetKey = (object2, name, checker, bindings = new Map) => {
+  for (const property of [...object2.properties].reverse()) {
     if (propertyName(property) === name && ts.isShorthandPropertyAssignment(property)) {
       return assetKeyWithBindings(property.name, checker, bindings);
     }
@@ -5479,7 +5752,7 @@ var analyzeProgram = (program, projectRoot) => {
   const checker = program.getTypeChecker();
   const analyzed = new Map;
   for (const sourceFile of program.getSourceFiles()) {
-    const resolvedFile = resolve12(sourceFile.fileName);
+    const resolvedFile = resolve13(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -5572,14 +5845,14 @@ var transformFile = (source, fileName, analysis) => {
 };
 var ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL = ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION;
 var createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve12(options.projectRoot ?? process.cwd());
-  const entry = resolve12(options.entry);
+  const projectRoot = resolve13(options.projectRoot ?? process.cwd());
+  const entry = resolve13(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(resolve12(path));
+        const analysis = analyzed.get(resolve13(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
@@ -5592,8 +5865,8 @@ var createAbsoluteMobileRouteMetadataPlugin = (options) => {
   };
 };
 var inspectAbsoluteMobileRouteMetadata = (options) => {
-  const projectRoot = resolve12(options.projectRoot ?? process.cwd());
-  const entry = resolve12(options.entry);
+  const projectRoot = resolve13(options.projectRoot ?? process.cwd());
+  const entry = resolve13(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)),
@@ -5663,6 +5936,7 @@ export {
   finalizeAbsoluteMobileCompatibilityBuild,
   fetchAbsoluteMobilePage,
   disposeAbsoluteMobilePage,
+  discoverAbsoluteSyncSchema,
   createAbsoluteRemoteIosDevProject,
   createAbsoluteMobileUpgradeResponse,
   createAbsoluteMobileRouteMetadataPlugin,
@@ -5710,5 +5984,5 @@ export {
   ABSOLUTE_ANDROID_RELEASE_FORMAT
 };
 
-//# debugId=712D22B2B8D89AC264756E2164756E21
+//# debugId=3502D864F8FBB90464756E2164756E21
 //# sourceMappingURL=index.js.map