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

package/dist/cli/index.js

@@ -3458,7 +3458,7 @@ import {
   resolve as resolvePath,
   sep as sep4
 } from "path";
-var PROFILE_FORMAT = 1, PROFILE_NAME, SSH_DESTINATION, defaultProfilePath = () => join11(homedir4(), ".absolutejs", "mobile", "remote-macs.json"), emptyStore = () => ({
+var PROFILE_FORMAT = 1, REMOTE_STDIN_FLUSH_ATTEMPTS = 3, PROFILE_NAME, SSH_DESTINATION, defaultProfilePath = () => join11(homedir4(), ".absolutejs", "mobile", "remote-macs.json"), emptyStore = () => ({
   format: PROFILE_FORMAT,
   profiles: {}
 }), loadStore = async (path = defaultProfilePath()) => {
@@ -3913,8 +3913,17 @@ var PROFILE_FORMAT = 1, PROFILE_NAME, SSH_DESTINATION, defaultProfilePath = () =
     const response = new Promise((resolve8, reject) => pending.set(id, { reject, resolve: resolve8 }));
     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 () => {
@@ -6107,7 +6116,12 @@ ${authImport}${syncImport}void startAbsoluteMobileShell(${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 }
+            ]
+          }
         }
       } : {}
     };
@@ -6289,9 +6303,392 @@ var init_materializedBundle = __esm(() => {
   BUNDLE_ID_PATTERN = /^amb_[a-f0-9]{64}$/;
 });
 
+// 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) => {
+  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), validatePolicyMatch = (match, label) => {
+  if (match.length === 0 || match.trim() !== match || /^\*+$/.test(match) || match.includes("**"))
+    throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.match must be an exact name or a non-empty glob without adjacent wildcards.`);
+}, validateSyncLocalDataPolicy = (policy, label = "localData") => {
+  if (policy.maxBytesPerNamespace !== undefined && (!Number.isSafeInteger(policy.maxBytesPerNamespace) || policy.maxBytesPerNamespace < 1))
+    throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.maxBytesPerNamespace must be a positive safe integer.`);
+  for (const [index, rule] of (policy.collections ?? []).entries()) {
+    validatePolicyMatch(rule.match, `${label}.collections[${index}]`);
+    if (rule.maxAgeMs !== undefined && (!Number.isSafeInteger(rule.maxAgeMs) || rule.maxAgeMs < 1))
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}].maxAgeMs must be a positive safe integer.`);
+    if (rule.persistence === "memory-only" && rule.protection === "required")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${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")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.collections[${index}] declares ${rule.sensitivity} data without required protection or memory-only persistence.`);
+  }
+  for (const [index, rule] of (policy.mutations ?? []).entries()) {
+    validatePolicyMatch(rule.match, `${label}.mutations[${index}]`);
+    if (rule.sensitivity !== undefined && rule.sensitivity !== "public" && rule.protection !== "required" && rule.persistence !== "memory-only")
+      throw new SyncLocalDataPolicyError("INVALID_POLICY", `${label}.mutations[${index}] declares ${rule.sensitivity} arguments without required protection.`);
+  }
+  return policy;
+}, 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);
+    if (component.localData)
+      validateSyncLocalDataPolicy(component.localData, `${component.id}.localData`);
+  }
+  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 version2 = storedVersion + 1;version2 <= targetVersion; version2++) {
+    const migration = migrations.find((candidate) => candidate.toVersion === version2);
+    if (migration === undefined)
+      throw new SyncLocalStoreSchemaError("MIGRATION_MISSING", `Sync migration ${version2 - 1} -> ${version2} is missing`, { storedVersion, targetVersion });
+    steps.push(migration);
+  }
+  return { minimumCompatibleVersion, steps, targetVersion };
+};
+var init_client2 = __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;
+  })();
+  SyncLocalDataPolicyError = class SyncLocalDataPolicyError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "SyncLocalDataPolicyError";
+      this.code = code;
+    }
+  };
+  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 readFileSync11 } from "fs";
+import { dirname as dirname12, join as join19, resolve as resolve15 } from "path";
+var object = (value) => typeof value === "object" && value !== null && !Array.isArray(value), manifestAt = (path) => {
+  try {
+    const value = JSON.parse(readFileSync11(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 = resolve15(projectRoot);
+  while (true) {
+    const candidate = join19(directory, "node_modules", packageName, "package.json");
+    const manifest = manifestAt(candidate);
+    if (manifest && Reflect.get(manifest, "name") === packageName)
+      return candidate;
+    const parent = dirname12(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;
+}, unknownField = (record, key) => record[key], normalizeJsonValue = (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) => normalizeJsonValue(entry, id, field));
+  if (object(value))
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      normalizeJsonValue(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: normalizeJsonValue(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`)
+  };
+}, localDataPolicy = (value, id) => {
+  const record = requireObject(value, id, "localData must be an object.");
+  const allowed = new Set([
+    "collections",
+    "maxBytesPerNamespace",
+    "mutations"
+  ]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `localData.${unsupported} is not supported.`);
+  const collectionRules = Reflect.get(record, "collections");
+  const mutationRules = Reflect.get(record, "mutations");
+  if (collectionRules !== undefined && !Array.isArray(collectionRules))
+    throw metadataError(id, "localData.collections must be an array.");
+  if (mutationRules !== undefined && !Array.isArray(mutationRules))
+    throw metadataError(id, "localData.mutations must be an array.");
+  const collections = Array.isArray(collectionRules) ? collectionRules.map((entry, index) => {
+    const rule = requireObject(entry, id, `localData.collections[${index}] must be an object.`);
+    const allowedRuleKeys = new Set([
+      "evictionPriority",
+      "match",
+      "maxAgeMs",
+      "onProtectionUnavailable",
+      "persistence",
+      "protection",
+      "sensitivity"
+    ]);
+    const unsupportedRuleKey = Object.keys(rule).find((key) => !allowedRuleKeys.has(key));
+    if (unsupportedRuleKey)
+      throw metadataError(id, `localData.collections[${index}].${unsupportedRuleKey} is not supported.`);
+    const match = nonEmpty(Reflect.get(rule, "match"), id, `localData.collections[${index}].match`);
+    const persistence = unknownField(rule, "persistence");
+    const sensitivity = unknownField(rule, "sensitivity");
+    const protection = unknownField(rule, "protection");
+    const onProtectionUnavailable = unknownField(rule, "onProtectionUnavailable");
+    const evictionPriority = unknownField(rule, "evictionPriority");
+    const maxAge = unknownField(rule, "maxAgeMs");
+    if (persistence !== undefined && persistence !== "durable" && persistence !== "memory-only")
+      throw metadataError(id, `localData.collections[${index}].persistence is invalid.`);
+    if (sensitivity !== undefined && sensitivity !== "public" && sensitivity !== "private" && sensitivity !== "secret")
+      throw metadataError(id, `localData.collections[${index}].sensitivity is invalid.`);
+    if (protection !== undefined && protection !== "none" && protection !== "required")
+      throw metadataError(id, `localData.collections[${index}].protection is invalid.`);
+    if (onProtectionUnavailable !== undefined && onProtectionUnavailable !== "error" && onProtectionUnavailable !== "memory-only")
+      throw metadataError(id, `localData.collections[${index}].onProtectionUnavailable is invalid.`);
+    if (evictionPriority !== undefined && evictionPriority !== "critical" && evictionPriority !== "normal" && evictionPriority !== "disposable")
+      throw metadataError(id, `localData.collections[${index}].evictionPriority is invalid.`);
+    return {
+      match,
+      ...sensitivity ? { sensitivity } : {},
+      ...persistence ? { persistence } : {},
+      ...protection ? { protection } : {},
+      ...onProtectionUnavailable ? {
+        onProtectionUnavailable
+      } : {},
+      ...evictionPriority ? { evictionPriority } : {},
+      ...maxAge === undefined ? {} : {
+        maxAgeMs: positiveVersion2(maxAge, id, `localData.collections[${index}].maxAgeMs`)
+      }
+    };
+  }) : undefined;
+  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([
+      "match",
+      "persistence",
+      "protection",
+      "sensitivity"
+    ]);
+    const unsupportedRuleKey = Object.keys(rule).find((key) => !allowedRuleKeys.has(key));
+    if (unsupportedRuleKey)
+      throw metadataError(id, `localData.mutations[${index}].${unsupportedRuleKey} is not supported.`);
+    const protection = unknownField(rule, "protection");
+    const sensitivity = unknownField(rule, "sensitivity");
+    const persistence = unknownField(rule, "persistence");
+    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")
+      throw metadataError(id, `localData.mutations[${index}].sensitivity is invalid.`);
+    if (persistence !== undefined && persistence !== "durable" && persistence !== "memory-only")
+      throw metadataError(id, `localData.mutations[${index}].persistence is invalid.`);
+    return {
+      match: nonEmpty(Reflect.get(rule, "match"), id, `localData.mutations[${index}].match`),
+      ...sensitivity ? { sensitivity } : {},
+      ...persistence ? {
+        persistence
+      } : {},
+      ...protection ? { protection } : {}
+    };
+  }) : undefined;
+  const quota = Reflect.get(record, "maxBytesPerNamespace");
+  return {
+    ...collections ? { collections } : {},
+    ...mutations ? { mutations } : {},
+    ...quota === undefined ? {} : {
+      maxBytesPerNamespace: positiveVersion2(quota, id, "localData.maxBytesPerNamespace")
+    }
+  };
+}, component = (id, value) => {
+  const record = requireObject(value, id, "localSchema must be an object.");
+  const allowed = new Set([
+    "localData",
+    "migrations",
+    "minimumCompatibleVersion",
+    "version"
+  ]);
+  const unsupported = Object.keys(record).find((key) => !allowed.has(key));
+  if (unsupported)
+    throw metadataError(id, `${unsupported} is not supported.`);
+  const version2 = positiveVersion2(Reflect.get(record, "version"), id, "version");
+  const declaredMinimum = Reflect.get(record, "minimumCompatibleVersion");
+  const minimumCompatibleVersion = declaredMinimum === undefined ? Math.max(1, version2 - 2) : positiveVersion2(declaredMinimum, id, "minimumCompatibleVersion");
+  const declaredMigrations = Reflect.get(record, "migrations");
+  const declaredLocalData = Reflect.get(record, "localData");
+  if (declaredMigrations !== undefined && !Array.isArray(declaredMigrations))
+    throw metadataError(id, "migrations must be an array.");
+  const migrations = Array.isArray(declaredMigrations) ? declaredMigrations : undefined;
+  return {
+    id,
+    ...declaredLocalData === undefined ? {} : { localData: localDataPolicy(declaredLocalData, id) },
+    minimumCompatibleVersion,
+    ...Array.isArray(migrations) ? {
+      migrations: migrations.map((entry, index) => migration(entry, id, index))
+    } : {},
+    version: version2
+  };
+}, 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 = join19(resolve15(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_client2();
+});
+
 // src/mobile/buildPipeline.ts
 import { readFile as readFile10 } from "fs/promises";
-import { join as join19, resolve as resolve15 } from "path";
+import { join as join20, resolve as resolve16 } from "path";
 import { pathToFileURL } from "url";
 var isElysiaApp = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "compile") === "function" && Array.isArray(Reflect.get(value, "routes")), isStringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string"), serverExportName = (loaded, app) => {
   if (loaded.server === app)
@@ -6320,11 +6717,11 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
   const exportName = serverExportName(loaded, app);
   return { app, exportName };
 }, finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
-  const buildDirectory = resolve15(options.buildDirectory);
+  const buildDirectory = resolve16(options.buildDirectory);
   const mobile = normalizeAbsoluteMobileConfig(options.mobile, options.projectRoot);
-  const root = join19(buildDirectory, ".absolutejs", "mobile-compatibility");
+  const root = join20(buildDirectory, ".absolutejs", "mobile-compatibility");
   const [manifestSource, previous] = await Promise.all([
-    readFile10(join19(buildDirectory, "manifest.json"), "utf8"),
+    readFile10(join20(buildDirectory, "manifest.json"), "utf8"),
     readAbsoluteMobileMaterializedReleases(root)
   ]);
   const manifest = JSON.parse(manifestSource);
@@ -6337,11 +6734,11 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
   process.env.ABSOLUTE_BUILD_DIR = buildDirectory;
   process.env.ABSOLUTE_COMPILED_RUNTIME = "1";
   if (options.configPath) {
-    process.env.ABSOLUTE_CONFIG = resolve15(options.projectRoot, options.configPath);
+    process.env.ABSOLUTE_CONFIG = resolve16(options.projectRoot, options.configPath);
   }
   let loaded;
   try {
-    loaded = await loadServerApp(resolve15(options.producerPath));
+    loaded = await loadServerApp(resolve16(options.producerPath));
   } finally {
     restoreEnvironmentVariable("ABSOLUTE_BUILD_DIR", previousBuildDirectory);
     restoreEnvironmentVariable("ABSOLUTE_COMPILED_RUNTIME", previousCompiledRuntime);
@@ -6354,11 +6751,12 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
     manifest,
     previousArtifacts: previous.map(({ artifact }) => artifact),
     producerExport: loaded.exportName,
-    producerPath: resolve15(options.producerPath),
+    producerPath: resolve16(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.");
   }
@@ -6377,7 +6775,8 @@ var isElysiaApp = (value) => typeof value === "object" && value !== null && type
     ...auth ? { auth } : {},
     buildDirectory,
     config: mobile,
-    ...sync ? { sync: true } : {}
+    ...sync ? { sync: true } : {},
+    ...syncSchema ? { syncSchema: { components: syncSchema.components } } : {}
   });
   return current.artifact;
 };
@@ -6389,13 +6788,14 @@ var init_buildPipeline = __esm(() => {
   init_pageProtocol();
   init_releaseArtifact();
   init_nativeAuth();
+  init_syncSchema();
 });
 
 // src/mobile/routeMetadataTransform.ts
-import { existsSync as existsSync10, readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname12, extname as extname5, relative as relative11, resolve as resolve16 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
+import { dirname as dirname13, extname as extname5, relative as relative11, resolve as resolve17 } from "path";
 import ts4 from "typescript";
-var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.replace(/\\/g, "/"), findTsconfig = (entry, projectRoot) => ts4.findConfigFile(dirname12(entry), existsSync10, "tsconfig.json") ?? ts4.findConfigFile(projectRoot, existsSync10, "tsconfig.json"), createProgram = (entry, projectRoot) => {
+var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.replace(/\\/g, "/"), findTsconfig = (entry, projectRoot) => ts4.findConfigFile(dirname13(entry), existsSync10, "tsconfig.json") ?? ts4.findConfigFile(projectRoot, existsSync10, "tsconfig.json"), createProgram = (entry, projectRoot) => {
   const configPath2 = findTsconfig(entry, projectRoot);
   if (!configPath2) {
     return ts4.createProgram([entry], {
@@ -6406,7 +6806,7 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
       target: ts4.ScriptTarget.ESNext
     });
   }
-  const parsed = ts4.parseJsonConfigFileContent(ts4.readConfigFile(configPath2, (path) => readFileSync11(path, "utf8")).config, ts4.sys, dirname12(configPath2));
+  const parsed = ts4.parseJsonConfigFileContent(ts4.readConfigFile(configPath2, (path) => readFileSync12(path, "utf8")).config, ts4.sys, dirname13(configPath2));
   if (!parsed.fileNames.includes(entry))
     parsed.fileNames.push(entry);
   return ts4.createProgram(parsed.fileNames, parsed.options);
@@ -6418,8 +6818,8 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
   if (ts4.isStringLiteralLike(property.name))
     return property.name.text;
   return;
-}, objectPropertyExpression = (object, name) => {
-  const property = object.properties.find((candidate) => propertyName(candidate) === name);
+}, objectPropertyExpression = (object2, name) => {
+  const property = object2.properties.find((candidate) => propertyName(candidate) === name);
   if (property && ts4.isPropertyAssignment(property)) {
     return property.initializer;
   }
@@ -6605,8 +7005,8 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
   if (!ts4.isCallExpression(expression))
     return;
   return callableObject(expression, checker);
-}, objectAssetKey = (object, name, checker, bindings = new Map) => {
-  for (const property of [...object.properties].reverse()) {
+}, objectAssetKey = (object2, name, checker, bindings = new Map) => {
+  for (const property of [...object2.properties].reverse()) {
     if (propertyName(property) === name && ts4.isShorthandPropertyAssignment(property)) {
       return assetKeyWithBindings(property.name, checker, bindings);
     }
@@ -6734,7 +7134,7 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
   const checker = program.getTypeChecker();
   const analyzed = new Map;
   for (const sourceFile of program.getSourceFiles()) {
-    const resolvedFile = resolve16(sourceFile.fileName);
+    const resolvedFile = resolve17(sourceFile.fileName);
     if (!isProjectSource(sourceFile, resolvedFile, projectRoot))
       continue;
     const analysis = analyzeSourceFile(sourceFile, checker, projectRoot);
@@ -6820,14 +7220,14 @@ var ROUTE_METHODS, SOURCE_FILTER, PAGE_HANDLERS, posixPath = (value) => value.re
     result.dispose();
   }
 }, createAbsoluteMobileRouteMetadataPlugin = (options) => {
-  const projectRoot = resolve16(options.projectRoot ?? process.cwd());
-  const entry = resolve16(options.entry);
+  const projectRoot = resolve17(options.projectRoot ?? process.cwd());
+  const entry = resolve17(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(resolve16(path));
+        const analysis = analyzed.get(resolve17(path));
         if (!analysis)
           return;
         const source = await Bun.file(path).text();
@@ -6894,7 +7294,7 @@ var init_routeMetadataTransform = __esm(() => {
 });
 
 // src/cli/elysiaOpenApiTypeboxPlugin.ts
-import { dirname as dirname13, resolve as resolve17 } from "path";
+import { dirname as dirname14, resolve as resolve18 } from "path";
 var OPENAPI_TYPEBOX_PREFIX = "../node_modules/typebox/", OPENAPI_DISTRIBUTION_SEGMENT = "/@elysia/openapi/dist/", createElysiaOpenApiTypeboxPlugin = () => ({
   name: "absolute-elysia-openapi-typebox",
   setup(build) {
@@ -6904,9 +7304,9 @@ var OPENAPI_TYPEBOX_PREFIX = "../node_modules/typebox/", OPENAPI_DISTRIBUTION_SE
         return;
       }
       const relativePath = args.path.slice(OPENAPI_TYPEBOX_PREFIX.length);
-      const typeboxEntry = Bun.resolveSync("typebox", dirname13(args.importer));
+      const typeboxEntry = Bun.resolveSync("typebox", dirname14(args.importer));
       return {
-        path: resolve17(dirname13(typeboxEntry), "..", relativePath)
+        path: resolve18(dirname14(typeboxEntry), "..", relativePath)
       };
     });
   }
@@ -6966,15 +7366,15 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync12 } from "fs";
-import { join as join20 } from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync13 } from "fs";
+import { join as join21 } from "path";
 var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_TIMEOUT_MS = 30000, DEFAULT_FETCH_TIMEOUT_MS = 1e4, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   await Bun.write(metaPath, String(Date.now()));
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync12(metaPath, "utf-8");
+    const content = readFileSync13(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -7037,7 +7437,7 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     if (!isCompleteHtml(html))
       return false;
     const fileName = routeToFilename(route);
-    const filePath = join20(prerenderDir, fileName);
+    const filePath = join21(prerenderDir, fileName);
     await Bun.write(filePath, html);
     await writeTimestamp(filePath);
     return true;
@@ -7067,13 +7467,13 @@ var SERVER_OUTPUT_LIMIT = 4000, STARTUP_POLL_INTERVAL_MS = 100, DEFAULT_STARTUP_
     return;
   }
   const fileName = routeToFilename(route);
-  const filePath = join20(prerenderDir, fileName);
+  const filePath = join21(prerenderDir, fileName);
   await Bun.write(filePath, html);
   await writeTimestamp(filePath);
   result.routes.set(route, filePath);
   log?.(`  Pre-rendered ${route} \u2192 ${fileName} (${html.length} bytes)`);
 }, prerender = async (port, outDir, staticConfig, log) => {
-  const prerenderDir = join20(outDir, "_prerendered");
+  const prerenderDir = join21(outDir, "_prerendered");
   mkdirSync6(prerenderDir, { recursive: true });
   const baseUrl = `http://localhost:${port}`;
   let routes;
@@ -7449,7 +7849,7 @@ var init_maskLiterals = __esm(() => {
 // src/build/nativeRewrite.ts
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import { platform as platform4, arch as arch3 } from "os";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 var ffiDefinition, nativeLib = null, loadNative = () => {
   if (nativeLib !== null)
     return nativeLib;
@@ -7467,7 +7867,7 @@ var ffiDefinition, nativeLib = null, loadNative = () => {
   if (!libPath)
     return null;
   try {
-    const fullPath = resolve18(import.meta.dir, "../../native/packages", libPath);
+    const fullPath = resolve19(import.meta.dir, "../../native/packages", libPath);
     const lib = dlopen(fullPath, ffiDefinition);
     nativeLib = lib.symbols;
     return nativeLib;
@@ -7509,7 +7909,7 @@ var init_nativeRewrite = __esm(() => {
 
 // src/build/rewriteImportsPlugin.ts
 import { readdir as readdir3 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
   let result = content;
   for (const [specifier, webPath] of replacements) {
@@ -7588,7 +7988,7 @@ ${content}`;
       const entries = await readdir3(dir);
       for (const entry of entries) {
         if (entry.endsWith(".js"))
-          allFiles.push(join21(dir, entry));
+          allFiles.push(join22(dir, entry));
       }
     } catch {}
   }
@@ -7663,8 +8063,8 @@ var init_rewriteImports = __esm(() => {
 
 // src/cli/scripts/start.ts
 var {env: env2 } = globalThis.Bun;
-import { existsSync as existsSync11, readFileSync as readFileSync13, rmSync as rmSync4 } from "fs";
-import { basename as basename8, join as join22, resolve as resolve19 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync14, rmSync as rmSync4 } from "fs";
+import { basename as basename8, join as join23, resolve as resolve20 } from "path";
 var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, resolvePackageVersion = (candidates) => {
   for (const candidate of candidates) {
     const version2 = readPackageVersion2(candidate);
@@ -7675,7 +8075,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return "";
 }, readPackageVersion2 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync13(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync14(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -7713,18 +8113,18 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   process.exit(1);
 }, resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve19(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve19(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve19(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
-    resolve19(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve19(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve19(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve20(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve20(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve20(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
+    resolve20(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve20(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve20(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync11(candidate))
       return candidate;
   }
-  return resolve19(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
+  return resolve20(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
 }, jsxDevRuntimeCompatPath, prerenderStaticPages = async (outputPath, prerenderPort, resolvedOutdir, staticConfig, absoluteVersion, configPath2) => {
   const prerenderStart = performance.now();
   process.stdout.write(cliTag2("\x1B[36m", "Pre-rendering static pages"));
@@ -7758,7 +8158,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   serverEntry,
   totalDuration
 }) => {
-  const usesDocker = existsSync11(resolve19(COMPOSE_PATH));
+  const usesDocker = existsSync11(resolve20(COMPOSE_PATH));
   const scripts = usesDocker ? await readDbScripts() : null;
   if (scripts)
     await startDatabase(scripts);
@@ -7849,10 +8249,10 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const port = Number(env2.PORT) || DEFAULT_PORT;
   killStaleProcesses(port);
   const entryName = basename8(serverEntry).replace(/\.[^.]+$/, "");
-  const resolvedOutdir = resolve19(outdir ?? "dist");
+  const resolvedOutdir = resolve20(outdir ?? "dist");
   const absoluteVersion = resolvePackageVersion([
-    resolve19(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve19(import.meta.dir, "..", "..", "package.json")
+    resolve20(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve20(import.meta.dir, "..", "..", "package.json")
   ]);
   const buildConfig = await loadConfig(configPath2);
   buildConfig.buildDirectory = resolvedOutdir;
@@ -7867,7 +8267,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     buildConfig.vueDirectory && "vue",
     buildConfig.angularDirectory && "angular"
   ].filter((val) => Boolean(val));
-  const outputPath = resolve19(resolvedOutdir, `${entryName}.js`);
+  const outputPath = resolve20(resolvedOutdir, `${entryName}.js`);
   if (options.prebuilt) {
     if (!existsSync11(outputPath)) {
       throw new Error(`Prepared production server not found: ${outputPath}`);
@@ -7890,13 +8290,13 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   process.stdout.write(cliTag2("\x1B[36m", `Building assets`));
   try {
     const build = await resolveBuildModule([
-      resolve19(import.meta.dir, "..", "..", "core", "build"),
-      resolve19(import.meta.dir, "..", "build")
+      resolve20(import.meta.dir, "..", "..", "core", "build"),
+      resolve20(import.meta.dir, "..", "build")
     ]);
     if (!build)
       throw new Error("Could not locate build module");
     await build(buildConfig);
-    rmSync4(join22(resolvedOutdir, "_prerendered"), {
+    rmSync4(join23(resolvedOutdir, "_prerendered"), {
       force: true,
       recursive: true
     });
@@ -7973,17 +8373,17 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     }
   };
   const islandRegistrySpec = buildConfig.islands?.registry;
-  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve19(islandRegistrySpec))) : undefined;
+  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve20(islandRegistrySpec))) : undefined;
   const serverBundle = await Bun.build({
     define: { "process.env.NODE_ENV": '"production"' },
-    entrypoints: [resolve19(serverEntry)],
+    entrypoints: [resolve20(serverEntry)],
     external: resolveServerBundleExternals(buildConfig),
     outdir: resolvedOutdir,
     plugins: [
       ...islandRegistryPlugin ? [islandRegistryPlugin] : [],
       ...buildConfig.mobile ? [
         createAbsoluteMobileRouteMetadataPlugin({
-          entry: resolve19(serverEntry)
+          entry: resolve20(serverEntry)
         })
       ] : [],
       createElysiaOpenApiTypeboxPlugin(),
@@ -8000,9 +8400,9 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     console.error(cliTag2("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync11(resolve19(resolvedOutdir, "angular", "vendor", "server"))) {
+  if (existsSync11(resolve20(resolvedOutdir, "angular", "vendor", "server"))) {
     const { readdirSync: readdirSync2 } = await import("fs");
-    const vendorDir = resolve19(resolvedOutdir, "angular", "vendor", "server");
+    const vendorDir = resolve20(resolvedOutdir, "angular", "vendor", "server");
     const vendorEntries = readdirSync2(vendorDir).filter((fileName) => fileName.endsWith(".js"));
     const angularServerVendorPaths = {};
     const { relative: pathRelative, dirname: pathDirname } = await import("path");
@@ -8012,7 +8412,7 @@ var cliTag2 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = pathRelative(pathDirname(outputPath), resolve19(vendorDir, file));
+      const relPath = pathRelative(pathDirname(outputPath), resolve20(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
@@ -8199,17 +8599,17 @@ var exports_build = {};
 __export(exports_build, {
   build: () => build
 });
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync15 } from "fs";
-import { join as join23, resolve as resolve21 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync16 } from "fs";
+import { join as join24, resolve as resolve22 } from "path";
 var PROFILE_TOP = 15, PROFILE_COL = 8, FRAMEWORK_KEYS, cliTag3 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, printProfile = (buildDir) => {
-  const traceDir = join23(buildDir, ".absolute-trace");
+  const traceDir = join24(buildDir, ".absolute-trace");
   if (!existsSync13(traceDir))
     return;
   const files = readdirSync3(traceDir).filter((file) => file.endsWith(".json")).sort();
   const latest = files[files.length - 1];
   if (latest === undefined)
     return;
-  const trace = JSON.parse(readFileSync15(join23(traceDir, latest), "utf-8"));
+  const trace = JSON.parse(readFileSync16(join24(traceDir, latest), "utf-8"));
   const events = Array.isArray(trace.events) ? trace.events : [];
   if (events.length === 0)
     return;
@@ -8246,7 +8646,7 @@ var PROFILE_TOP = 15, PROFILE_COL = 8, FRAMEWORK_KEYS, cliTag3 = (color, message
   }
   return resolveBuildModule2(remaining);
 }, build = async (outdir, configPath2, profile = false) => {
-  const resolvedOutdir = resolve21(outdir ?? "build");
+  const resolvedOutdir = resolve22(outdir ?? "build");
   const buildStart = performance.now();
   if (profile)
     process.env.ABSOLUTE_BUILD_TRACE = "1";
@@ -8256,8 +8656,8 @@ var PROFILE_TOP = 15, PROFILE_COL = 8, FRAMEWORK_KEYS, cliTag3 = (color, message
   buildConfig.mode = "production";
   try {
     const buildApp = await resolveBuildModule2([
-      resolve21(import.meta.dir, "..", "..", "core", "build"),
-      resolve21(import.meta.dir, "..", "build")
+      resolve22(import.meta.dir, "..", "..", "core", "build"),
+      resolve22(import.meta.dir, "..", "build")
     ]);
     if (!buildApp)
       throw new Error("Could not locate build module");
@@ -8306,14 +8706,14 @@ import {
   lstatSync,
   mkdirSync as mkdirSync8,
   mkdtempSync,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   realpathSync,
   renameSync as renameSync2,
   rmSync as rmSync5,
   writeFileSync as writeFileSync7
 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { delimiter, dirname as dirname14, relative as relative12, resolve as resolve22 } from "path";
+import { delimiter, dirname as dirname15, relative as relative12, resolve as resolve23 } from "path";
 var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSION = 2, FLAG_NOT_FOUND = -1, CHUNKED_FLAG = "--chunked", TSCONFIG_PATTERN, ABSOLUTE_BINARY, runGit = (args, options) => {
   const proc = Bun.spawnSync(["git", ...args], {
     cwd: options.cwd,
@@ -8326,7 +8726,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
     throw new Error(detail || `git ${args.join(" ")} failed`);
   }
   return proc.stdout.toString().trim();
-}, gitRoot = (cwd) => resolve22(runGit(["rev-parse", "--show-toplevel"], { cwd })), isInside3 = (parent, candidate) => {
+}, gitRoot = (cwd) => resolve23(runGit(["rev-parse", "--show-toplevel"], { cwd })), isInside3 = (parent, candidate) => {
   const path = relative12(parent, candidate);
   return path === "" || !path.startsWith("../") && path !== "..";
 }, attestationPayload = (proof) => Buffer.from([
@@ -8339,17 +8739,17 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
     sourceTree: proof.sourceTree
   })
 ].join("\x00")), publicKeyId = (key) => createHash11("sha256").update(key.export({ format: "der", type: "spki" })).digest("hex"), readEd25519PrivateKey = (cwd, location) => {
-  const path = resolve22(cwd, location);
+  const path = resolve23(cwd, location);
   if (isInside3(realpathSync(gitRoot(cwd)), realpathSync(path))) {
     throw new Error("lint proof signing key must live outside the Git working tree");
   }
-  const key = createPrivateKey(readFileSync16(path));
+  const key = createPrivateKey(readFileSync17(path));
   if (key.asymmetricKeyType !== "ed25519") {
     throw new Error("lint proof signing key must be an Ed25519 private key");
   }
   return key;
 }, readEd25519PublicKey = (cwd, location) => {
-  const key = createPublicKey(readFileSync16(resolve22(cwd, location)));
+  const key = createPublicKey(readFileSync17(resolve23(cwd, location)));
   if (key.asymmetricKeyType !== "ed25519") {
     throw new Error("trusted lint proof key must be an Ed25519 public key");
   }
@@ -8387,17 +8787,17 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
   ].sort();
 }, createLintSourceTree = (cwd = process.cwd(), proofLocation = DEFAULT_PROOF_LOCATION, command = []) => {
   const root = gitRoot(cwd);
-  const proofPath = resolve22(cwd, proofLocation);
+  const proofPath = resolve23(cwd, proofLocation);
   const proofRelative = relative12(root, proofPath).replaceAll("\\", "/");
   if (proofRelative === ".." || proofRelative.startsWith("../") || proofRelative === "") {
     throw new Error("lint proof must live inside the Git working tree");
   }
-  const temporaryDirectory = mkdtempSync(resolve22(tmpdir3(), "absolute-lint-proof-"));
-  const temporaryIndex = resolve22(temporaryDirectory, "index");
-  const temporaryObjects = resolve22(temporaryDirectory, "objects");
+  const temporaryDirectory = mkdtempSync(resolve23(tmpdir3(), "absolute-lint-proof-"));
+  const temporaryIndex = resolve23(temporaryDirectory, "index");
+  const temporaryObjects = resolve23(temporaryDirectory, "objects");
   mkdirSync8(temporaryObjects, { recursive: true });
   const repositoryObjectsPath = runGit(["rev-parse", "--git-path", "objects"], { cwd: root });
-  const repositoryObjects = resolve22(root, repositoryObjectsPath);
+  const repositoryObjects = resolve23(root, repositoryObjectsPath);
   const existingAlternates = process.env.GIT_ALTERNATE_OBJECT_DIRECTORIES?.trim();
   const env3 = {
     GIT_ALTERNATE_OBJECT_DIRECTORIES: [
@@ -8421,7 +8821,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
       if (!path || path === proofRelative)
         return false;
       try {
-        lstatSync(resolve22(root, path));
+        lstatSync(resolve23(root, path));
         return true;
       } catch {
         return false;
@@ -8445,7 +8845,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
 }, writeLintProof = (command, options = {}) => {
   const cwd = options.cwd ?? process.cwd();
   const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
-  const path = resolve22(cwd, proofLocation);
+  const path = resolve23(cwd, proofLocation);
   const temporary = `${path}.${process.pid}.tmp`;
   const proof = createLintProof(command, { cwd, proofLocation });
   if (options.signingKeyLocation) {
@@ -8457,7 +8857,7 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
       signature: sign(null, attestationPayload(proof), privateKey).toString("base64")
     };
   }
-  mkdirSync8(dirname14(path), { recursive: true });
+  mkdirSync8(dirname15(path), { recursive: true });
   writeFileSync7(temporary, `${JSON.stringify(proof, null, 2)}
 `);
   renameSync2(temporary, path);
@@ -8501,12 +8901,12 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
 }, verifyLintProof = (command, options = {}) => {
   const cwd = options.cwd ?? process.cwd();
   const proofLocation = options.proofLocation ?? DEFAULT_PROOF_LOCATION;
-  const path = resolve22(cwd, proofLocation);
+  const path = resolve23(cwd, proofLocation);
   if (!existsSync14(path))
     return { reason: `missing lint proof: ${proofLocation}`, valid: false };
   let proof;
   try {
-    proof = JSON.parse(readFileSync16(path, "utf-8"));
+    proof = JSON.parse(readFileSync17(path, "utf-8"));
   } catch {
     return { reason: `invalid lint proof: ${proofLocation}`, valid: false };
   }
@@ -8567,8 +8967,8 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
   console.log(`\x1B[32m\u2713\x1B[0m Lint proof matches the source tree, command, and lint toolchain${parsed.trustedKeyLocation ? ", with a trusted signature" : ""}`);
   return 0;
 }, runLintProof = async (args) => {
-  const [operation] = args;
-  if (operation !== "run" && operation !== "verify") {
+  const [operation2] = args;
+  if (operation2 !== "run" && operation2 !== "verify") {
     console.error("Usage: absolute lint-proof <run|verify> [--proof path] [--signing-key path | --trusted-key path] -- <lint command>");
     return 2;
   }
@@ -8583,15 +8983,15 @@ var DEFAULT_PROOF_LOCATION = ".absolutejs/lint-proof.json", PROOF_CONTRACT_VERSI
     console.error("A lint command is required after --");
     return 2;
   }
-  if (operation === "run" && parsed.trustedKeyLocation) {
+  if (operation2 === "run" && parsed.trustedKeyLocation) {
     console.error("--trusted-key is only valid with lint-proof verify");
     return 2;
   }
-  if (operation === "verify" && parsed.signingKeyLocation) {
+  if (operation2 === "verify" && parsed.signingKeyLocation) {
     console.error("--signing-key is only valid with lint-proof run");
     return 2;
   }
-  if (operation === "verify")
+  if (operation2 === "verify")
     return runVerification(parsed);
   const proc = Bun.spawn(parsed.command, {
     stderr: "inherit",
@@ -8671,8 +9071,8 @@ var exports_ls = {};
 __export(exports_ls, {
   runLs: () => runLs
 });
-import { existsSync as existsSync16, readFileSync as readFileSync17, statSync } from "fs";
-import { basename as basename10, extname as extname6, join as join24, relative as relative13 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync18, statSync } from "fs";
+import { basename as basename10, extname as extname6, join as join25, relative as relative13 } from "path";
 var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELDS, readStringField = (source, key) => {
   const value = Reflect.get(source, key);
   return typeof value === "string" ? value : undefined;
@@ -8694,13 +9094,13 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
   const dir = readStringField(source, framework.field);
   return dir === undefined ? [] : [
     {
-      dir: join24(baseDir, dir),
+      dir: join25(baseDir, dir),
       label: framework.label,
       pattern: framework.pattern
     }
   ];
 }), scanFramework = async (spec) => {
-  const { pageFiles } = await scanConventions(join24(spec.dir, "pages"), spec.pattern);
+  const { pageFiles } = await scanConventions(join25(spec.dir, "pages"), spec.pattern);
   if (pageFiles.length === 0)
     return null;
   const pages = pageFiles.map((file) => ({
@@ -8724,10 +9124,10 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
 }, resolveDiskPath = (buildDir, value) => {
   if (existsSync16(value))
     return value;
-  const underBuild = join24(buildDir, value);
+  const underBuild = join25(buildDir, value);
   if (existsSync16(underBuild))
     return underBuild;
-  return join24(process.cwd(), value);
+  return join25(process.cwd(), value);
 }, fileSize = (diskPath) => {
   try {
     return statSync(diskPath).size;
@@ -8735,7 +9135,7 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
     return 0;
   }
 }, readManifestSizes = (manifestDir) => {
-  const manifest = JSON.parse(readFileSync17(join24(manifestDir, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync18(join25(manifestDir, "manifest.json"), "utf-8"));
   const sizes = new Map;
   Object.entries(manifest).forEach(([key, value]) => {
     sizes.set(key, fileSize(resolveDiskPath(manifestDir, value)));
@@ -8754,7 +9154,7 @@ var DEFAULT_BUILD_DIR = "build", LABEL_ORDER, ARTIFACT_SUFFIXES, FRAMEWORK_FIELD
   }))
 })), manifestAge = (manifestPath) => getDurationString(Date.now() - statSync(manifestPath).mtimeMs), firstBuildDir = (candidates) => candidates.map((candidate) => {
   const dir = readStringField(candidate.source, "buildDirectory");
-  return dir === undefined ? undefined : join24(candidate.baseDir, dir);
+  return dir === undefined ? undefined : join25(candidate.baseDir, dir);
 }).find((dir) => dir !== undefined), resolveSizesDir = (args, candidates) => parseFlagValue(args, "--outdir") ?? firstBuildDir(candidates) ?? DEFAULT_BUILD_DIR, formatSize = (bytes) => {
   if (bytes === null || bytes === 0)
     return "-";
@@ -8852,7 +9252,7 @@ ${colors.dim}${frameworkCount} ${frameworkCount === 1 ? "framework" : "framework
     return;
   }
   const sizesDir = resolveSizesDir(args, candidates);
-  const manifestPath = join24(sizesDir, "manifest.json");
+  const manifestPath = join25(sizesDir, "manifest.json");
   if (!existsSync16(manifestPath)) {
     printDim(`No build at ${relativeOrSelf(manifestPath)}. Run \`absolute build\` first, or pass \`--outdir <dir>\`.`);
     return;
@@ -8976,22 +9376,22 @@ var init_discoverInstances = __esm(() => {
 // src/cli/instanceStatus.ts
 import { createConnection as createConnection2 } from "net";
 var {$: $4 } = globalThis.Bun;
-var displayHost = (host) => host === "0.0.0.0" || host === "::" ? "localhost" : host, probePort = (host, port) => {
-  const { promise, resolve: resolve23 } = Promise.withResolvers();
-  const socket = createConnection2({ host: displayHost(host), port });
+var displayHost = (host2) => host2 === "0.0.0.0" || host2 === "::" ? "localhost" : host2, probePort = (host2, port) => {
+  const { promise, resolve: resolve24 } = Promise.withResolvers();
+  const socket = createConnection2({ host: displayHost(host2), port });
   const timeout = setTimeout(() => {
     socket.destroy();
-    resolve23(false);
+    resolve24(false);
   }, INSTANCE_PROBE_TIMEOUT_MS);
   socket.once("connect", () => {
     clearTimeout(timeout);
     socket.end();
-    resolve23(true);
+    resolve24(true);
   });
   socket.once("error", () => {
     clearTimeout(timeout);
     socket.destroy();
-    resolve23(false);
+    resolve24(false);
   });
   return promise;
 }, probeStatus = async (record) => {
@@ -9703,9 +10103,9 @@ var exports_heapDiff = {};
 __export(exports_heapDiff, {
   runHeapDiff: () => runHeapDiff
 });
-import { existsSync as existsSync17, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync19 } from "fs";
 var TOP = 15, STRING_TYPES, aggregate = (path) => {
-  const data = JSON.parse(readFileSync18(path, "utf-8"));
+  const data = JSON.parse(readFileSync19(path, "utf-8"));
   const { nodes, strings } = data;
   const { node_fields: fields, node_types: nodeTypes } = data.snapshot.meta;
   const [typeNames] = nodeTypes;
@@ -9857,14 +10257,14 @@ import ts5 from "typescript";
 import {
   existsSync as existsSync18,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   statSync as statSync2,
   writeFileSync as writeFileSync8
 } from "fs";
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFrameworkRepo = (cwd) => {
   try {
-    const pkg = JSON.parse(readFileSync19(resolve23(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync20(resolve24(cwd, "package.json"), "utf-8"));
     return pkg?.name === "@absolutejs/absolute";
   } catch {
     return false;
@@ -9885,14 +10285,14 @@ var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFramework
   };
 }, SCHEMA_VERSION = 1, packageVersion = (cwd, specifier) => {
   const candidates = specifier === "@absolutejs/absolute" ? [
-    resolve23(cwd, "node_modules", "@absolutejs", "absolute", "package.json"),
-    resolve23(cwd, "package.json")
+    resolve24(cwd, "node_modules", "@absolutejs", "absolute", "package.json"),
+    resolve24(cwd, "package.json")
   ] : [
-    resolve23(cwd, "node_modules", ...specifier.split("/"), "package.json")
+    resolve24(cwd, "node_modules", ...specifier.split("/"), "package.json")
   ];
   for (const candidate of candidates) {
     try {
-      const { version: version2 } = JSON.parse(readFileSync19(candidate, "utf-8"));
+      const { version: version2 } = JSON.parse(readFileSync20(candidate, "utf-8"));
       if (typeof version2 === "string")
         return version2;
     } catch {}
@@ -9903,16 +10303,16 @@ var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFramework
   if (local) {
     const file = typeName === "PackageJson" ? "packageJson.ts" : "build.ts";
     try {
-      signature += `:${statSync2(resolve23(cwd, "types", file)).mtimeMs}`;
+      signature += `:${statSync2(resolve24(cwd, "types", file)).mtimeMs}`;
     } catch {}
   }
   return signature;
 }, cacheSlug = (specifier) => specifier.replace("@", "").split("/").join("-"), cacheFile = (cwd, typeName, specifier) => {
   const name = specifier === "@absolutejs/absolute" ? typeName : `${typeName}.${cacheSlug(specifier)}`;
-  return resolve23(cwd, ".absolutejs", "config-schema", `${name}.json`);
+  return resolve24(cwd, ".absolutejs", "config-schema", `${name}.json`);
 }, readDiskCache = (cwd, typeName, signature, specifier) => {
   try {
-    const cached = JSON.parse(readFileSync19(cacheFile(cwd, typeName, specifier), "utf-8"));
+    const cached = JSON.parse(readFileSync20(cacheFile(cwd, typeName, specifier), "utf-8"));
     if (isRecord9(cached) && cached.signature === signature && Array.isArray(cached.fields)) {
       return cached.fields;
     }
@@ -9920,7 +10320,7 @@ var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFramework
   return null;
 }, writeDiskCache = (cwd, typeName, signature, fields, specifier) => {
   try {
-    mkdirSync9(resolve23(cwd, ".absolutejs", "config-schema"), {
+    mkdirSync9(resolve24(cwd, ".absolutejs", "config-schema"), {
       recursive: true
     });
     writeFileSync8(cacheFile(cwd, typeName, specifier), JSON.stringify({ fields, signature }));
@@ -10007,19 +10407,19 @@ var VIRTUAL_NAME = "__absolute_type_introspect__.ts", MAX_DEPTH = 6, isFramework
   }
   return opaque();
 }, introspectFrom = (cwd, specifier, typeName, options, exclude) => {
-  const virtualPath = resolve23(cwd, VIRTUAL_NAME);
+  const virtualPath = resolve24(cwd, VIRTUAL_NAME);
   const source = `import type { ${typeName} } from '${specifier}';
 declare const value: ${typeName};
 export { value };
 `;
-  const host = ts5.createCompilerHost(options, true);
-  const getSourceFile = host.getSourceFile.bind(host);
-  host.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => fileName === virtualPath ? ts5.createSourceFile(fileName, source, languageVersion, true) : getSourceFile(fileName, languageVersion, onError, shouldCreate);
-  const fileExists = host.fileExists.bind(host);
-  host.fileExists = (fileName) => fileName === virtualPath ? true : fileExists(fileName);
-  const readFile11 = host.readFile.bind(host);
-  host.readFile = (fileName) => fileName === virtualPath ? source : readFile11(fileName);
-  const program = ts5.createProgram([virtualPath], options, host);
+  const host2 = ts5.createCompilerHost(options, true);
+  const getSourceFile = host2.getSourceFile.bind(host2);
+  host2.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => fileName === virtualPath ? ts5.createSourceFile(fileName, source, languageVersion, true) : getSourceFile(fileName, languageVersion, onError, shouldCreate);
+  const fileExists = host2.fileExists.bind(host2);
+  host2.fileExists = (fileName) => fileName === virtualPath ? true : fileExists(fileName);
+  const readFile11 = host2.readFile.bind(host2);
+  host2.readFile = (fileName) => fileName === virtualPath ? source : readFile11(fileName);
+  const program = ts5.createProgram([virtualPath], options, host2);
   const checker = program.getTypeChecker();
   const sourceFile = program.getSourceFile(virtualPath);
   if (!sourceFile)
@@ -10050,7 +10450,7 @@ export { value };
   const cached = cache.get(cacheKey);
   if (cached)
     return cached;
-  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync18(resolve23(cwd, "types/index.ts"));
+  const local = specifier === "@absolutejs/absolute" && isFrameworkRepo(cwd) && existsSync18(resolve24(cwd, "types/index.ts"));
   const signature = cacheSignature(cwd, typeName, local, specifier);
   const fromDisk = readDiskCache(cwd, typeName, signature, specifier);
   if (fromDisk) {
@@ -10078,15 +10478,15 @@ var init_fromType = __esm(() => {
 
 // src/cli/config/absolute/resolveAbsoluteConfig.ts
 import ts6 from "typescript";
-import { existsSync as existsSync19, readFileSync as readFileSync20 } from "fs";
-import { resolve as resolve24 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync21 } from "fs";
+import { resolve as resolve25 } from "path";
 var CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath = (cwd, override) => {
   if (override) {
-    const resolved = resolve24(cwd, override);
+    const resolved = resolve25(cwd, override);
     return existsSync19(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES2) {
-    const candidate = resolve24(cwd, name);
+    const candidate = resolve25(cwd, name);
     if (existsSync19(candidate))
       return candidate;
   }
@@ -10108,7 +10508,7 @@ var CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath = (cwd, override) => {
   }
   return null;
 }, parseConfigObject = (configPath2) => {
-  const text = readFileSync20(configPath2, "utf-8");
+  const text = readFileSync21(configPath2, "utf-8");
   return { object: findConfigObject(parseSource(configPath2, text)), text };
 }, evalLiteral = (node) => {
   if (ts6.isStringLiteralLike(node)) {
@@ -10140,7 +10540,7 @@ var CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath = (cwd, override) => {
     return { opaque: false, value: items };
   }
   if (ts6.isObjectLiteralExpression(node)) {
-    const object = {};
+    const object2 = {};
     for (const property of node.properties) {
       if (!ts6.isPropertyAssignment(property) || !(ts6.isIdentifier(property.name) || ts6.isStringLiteral(property.name))) {
         return { opaque: true, value: undefined };
@@ -10148,18 +10548,18 @@ var CONFIG_CANDIDATES2, RUNTIME_FIELDS, findConfigPath = (cwd, override) => {
       const result = evalLiteral(property.initializer);
       if (result.opaque)
         return { opaque: true, value: undefined };
-      object[property.name.text] = result.value;
+      object2[property.name.text] = result.value;
     }
-    return { opaque: false, value: object };
+    return { opaque: false, value: object2 };
   }
   return { opaque: true, value: undefined };
 }, readCurrent = (configPath2) => {
   const current = {};
   const opaqueKeys = [];
-  const { object } = parseConfigObject(configPath2);
-  if (!object)
+  const { object: object2 } = parseConfigObject(configPath2);
+  if (!object2)
     return { current, opaqueKeys };
-  for (const property of object.properties) {
+  for (const property of object2.properties) {
     if (!ts6.isPropertyAssignment(property) || !(ts6.isIdentifier(property.name) || ts6.isStringLiteral(property.name))) {
       continue;
     }
@@ -10319,8 +10719,8 @@ var init_frameworks = __esm(() => {
 });
 
 // src/cli/generate/context.ts
-import { dirname as dirname15, isAbsolute as isAbsolute5, join as join25, relative as relative14, resolve as resolve25 } from "path";
-var asString = (value) => typeof value === "string" ? value : undefined, isRecord10 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute5(value) ? value : resolve25(cwd, value), resolveStylesDir = (cwd, config) => {
+import { dirname as dirname16, isAbsolute as isAbsolute5, join as join26, relative as relative14, resolve as resolve26 } from "path";
+var asString = (value) => typeof value === "string" ? value : undefined, isRecord10 = (value) => typeof value === "object" && value !== null, resolveDir = (cwd, value) => isAbsolute5(value) ? value : resolve26(cwd, value), resolveStylesDir = (cwd, config) => {
   const styles = config.stylesConfig;
   if (typeof styles === "string")
     return resolveDir(cwd, styles);
@@ -10329,10 +10729,10 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
     if (indexes)
       return resolveDir(cwd, indexes);
   }
-  return resolve25(cwd, "src/frontend/styles/indexes");
+  return resolve26(cwd, "src/frontend/styles/indexes");
 }, configuredFrameworks = (project) => FRAMEWORK_KEYS2.filter((key) => project.frameworkDirs[key] !== undefined), frontendRootFor = (project, framework) => {
   const dir = project.frameworkDirs[framework];
-  return dir ? dirname15(dir) : resolve25(project.cwd, "src/frontend");
+  return dir ? dirname16(dir) : resolve26(project.cwd, "src/frontend");
 }, resolveProject = async (cwd, configOverride) => {
   const loaded = await loadConfig(configOverride);
   const config = isRecord10(loaded) ? loaded : {};
@@ -10382,7 +10782,7 @@ var asString = (value) => typeof value === "string" ? value : undefined, isRecor
     message: `Multiple frameworks configured (${configured.join(", ")}). Pass --framework <name>.`,
     ok: false
   };
-}, sharedDirFor = (project, framework) => join25(frontendRootFor(project, framework), "shared"), toModuleSpecifier = (fromDir, toFileNoExt) => {
+}, sharedDirFor = (project, framework) => join26(frontendRootFor(project, framework), "shared"), toModuleSpecifier = (fromDir, toFileNoExt) => {
   const rel = relative14(fromDir, toFileNoExt).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 };
@@ -10411,8 +10811,8 @@ var emptyOutcome = () => ({
 
 // src/cli/generate/routeWiring.ts
 import ts7 from "typescript";
-import { existsSync as existsSync20, readFileSync as readFileSync21, readdirSync as readdirSync4, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname16, join as join26 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync22, readdirSync as readdirSync4, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname17, join as join27 } from "path";
 var DEFAULT_SEPARATOR = `
 		`, BOUNDARY_USE, applyEdits = (text, edits) => {
   const ordered = [...edits].sort((first, second) => second.start - first.start);
@@ -10562,7 +10962,7 @@ ${newLines.join(`
 }, hasChain = (path) => {
   if (!existsSync20(path))
     return false;
-  const sourceFile = parse2(path, readFileSync21(path, "utf-8"));
+  const sourceFile = parse2(path, readFileSync22(path, "utf-8"));
   const found = findElysiaNew(sourceFile);
   return found !== null;
 }, firstChainFile = (pluginsDir) => {
@@ -10571,14 +10971,14 @@ ${newLines.join(`
   for (const name of readdirSync4(pluginsDir)) {
     if (!name.endsWith(".ts"))
       continue;
-    const candidate = join26(pluginsDir, name);
+    const candidate = join27(pluginsDir, name);
     if (hasChain(candidate))
       return candidate;
   }
   return null;
 }, findRoutingFile = (serverEntry) => {
-  const pluginsDir = join26(dirname16(serverEntry), "plugins");
-  const preferred = join26(pluginsDir, "pagesPlugin.ts");
+  const pluginsDir = join27(dirname17(serverEntry), "plugins");
+  const preferred = join27(pluginsDir, "pagesPlugin.ts");
   if (hasChain(preferred))
     return preferred;
   const scanned = firstChainFile(pluginsDir);
@@ -10588,7 +10988,7 @@ ${newLines.join(`
     return serverEntry;
   return null;
 }, buildRouteContext = (input, routingFile) => {
-  const specifier = `${toModuleSpecifier(dirname16(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
+  const specifier = `${toModuleSpecifier(dirname17(routingFile), stripExtension(input.pageFileAbs))}${input.def.pageImportExtension ?? ""}`;
   return {
     cssAssetKey: input.cssAssetKey,
     indexKey: input.indexKey,
@@ -10611,7 +11011,7 @@ ${newLines.join(`
   };
   if (!hasChain(serverEntry))
     return fallback;
-  const text = readFileSync21(serverEntry, "utf-8");
+  const text = readFileSync22(serverEntry, "utf-8");
   const sourceFile = parse2(serverEntry, text);
   const newExpr = findElysiaNew(sourceFile);
   if (!newExpr)
@@ -10640,7 +11040,7 @@ ${newLines.join(`
 ${routeExpr}`
     };
   }
-  const text = readFileSync21(routingFile, "utf-8");
+  const text = readFileSync22(routingFile, "utf-8");
   const sourceFile = parse2(routingFile, text);
   const newExpr = findElysiaNew(sourceFile);
   if (!newExpr) {
@@ -10670,7 +11070,7 @@ var init_routeWiring = __esm(() => {
 
 // src/cli/generate/generateApi.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname17, join as join27 } from "path";
+import { dirname as dirname18, join as join28 } from "path";
 var apiPluginTemplate = (pluginName, base) => `import { Elysia } from 'elysia';
 
 export const ${pluginName} = new Elysia()
@@ -10682,8 +11082,8 @@ export const ${pluginName} = new Elysia()
   const pluginName = `${camel}Plugin`;
   const base = `/api/${kebab}`;
   const outcome = { ...emptyOutcome(), route: base };
-  const pluginsDir = join27(dirname17(project.serverEntry), "plugins");
-  const fileAbs = join27(pluginsDir, `${pluginName}.ts`);
+  const pluginsDir = join28(dirname18(project.serverEntry), "plugins");
+  const fileAbs = join28(pluginsDir, `${pluginName}.ts`);
   if (existsSync21(fileAbs)) {
     outcome.notes.push(`${pluginName} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
@@ -10691,7 +11091,7 @@ export const ${pluginName} = new Elysia()
   mkdirSync10(pluginsDir, { recursive: true });
   writeFileSync10(fileAbs, apiPluginTemplate(pluginName, base), "utf-8");
   outcome.created.push(fileAbs);
-  const specifier = toModuleSpecifier(dirname17(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
+  const specifier = toModuleSpecifier(dirname18(project.serverEntry), fileAbs.replace(/\.ts$/, ""));
   const wired = wirePluginUse(project.serverEntry, pluginName, specifier);
   if (wired.kind === "edited")
     outcome.updated.push(wired.routingFile);
@@ -10758,7 +11158,7 @@ var init_componentTemplates = __esm(() => {
 
 // src/cli/generate/generateComponent.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname18, join as join28 } from "path";
+import { dirname as dirname19, join as join29 } from "path";
 var generateComponent = (project, framework, rawName) => {
   const def = frameworks6[framework];
   const pascal = toPascalCase(rawName);
@@ -10769,12 +11169,12 @@ var generateComponent = (project, framework, rawName) => {
     outcome.manual = { reason: "framework directory missing", snippet: "" };
     return outcome;
   }
-  const fileAbs = join28(frameworkDir, "components", def.componentFile({ kebab, pascal }));
+  const fileAbs = join29(frameworkDir, "components", def.componentFile({ kebab, pascal }));
   if (existsSync22(fileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${fileAbs} \u2014 skipped.`);
     return outcome;
   }
-  mkdirSync11(dirname18(fileAbs), { recursive: true });
+  mkdirSync11(dirname19(fileAbs), { recursive: true });
   writeFileSync11(fileAbs, componentTemplates[framework]({
     kebab,
     pascal,
@@ -10791,7 +11191,7 @@ var init_generateComponent = __esm(() => {
 // src/cli/generate/cssStrategy.ts
 import ts8 from "typescript";
 import { existsSync as existsSync23 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
 	margin: 0 auto;
 	max-width: 64rem;
@@ -10830,7 +11230,7 @@ var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
   return null;
 }, fileForKey = (stylesDir, assetKey2) => {
   const base = assetKey2.endsWith(CSS_SUFFIX) ? assetKey2.slice(0, -CSS_SUFFIX.length) : assetKey2;
-  return join29(stylesDir, `${toKebabCase(base)}.css`);
+  return join30(stylesDir, `${toKebabCase(base)}.css`);
 }, planCss = (routingText, stylesDir, pascal, kebab) => {
   const sharedKey = detectSharedKey(routingText);
   if (sharedKey) {
@@ -10843,7 +11243,7 @@ var CSS_SUFFIX = "CSS", SHARED_MIN_USES = 2, DEFAULT_CSS = `main {
       shared: true
     };
   }
-  const cssFileAbs = join29(stylesDir, `${kebab}.css`);
+  const cssFileAbs = join30(stylesDir, `${kebab}.css`);
   return {
     assetKey: `${pascal}${CSS_SUFFIX}`,
     contents: DEFAULT_CSS,
@@ -10856,8 +11256,8 @@ var init_cssStrategy = () => {};
 
 // src/cli/generate/navData.ts
 import ts9 from "typescript";
-import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync22, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname19 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync23, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname20 } from "path";
 var NAV_DATA_TEMPLATE = `type NavItem = {
 	href: string;
 	label: string;
@@ -10877,8 +11277,8 @@ export const navData: NavItem[] = [];
   };
   visit(sourceFile);
   return found;
-}, readStringProperty = (object, name) => {
-  const property = object.properties.find((candidate) => ts9.isPropertyAssignment(candidate) && ts9.isIdentifier(candidate.name) && candidate.name.text === name);
+}, readStringProperty = (object2, name) => {
+  const property = object2.properties.find((candidate) => ts9.isPropertyAssignment(candidate) && ts9.isIdentifier(candidate.name) && candidate.name.text === name);
   if (!property || !ts9.isStringLiteralLike(property.initializer)) {
     return null;
   }
@@ -10897,7 +11297,7 @@ export const navData: NavItem[] = [];
 }, readNavItems = (navDataPath) => {
   if (!existsSync24(navDataPath))
     return [];
-  const text = readFileSync22(navDataPath, "utf-8");
+  const text = readFileSync23(navDataPath, "utf-8");
   const sourceFile = ts9.createSourceFile(navDataPath, text, ts9.ScriptTarget.Latest, true);
   const array = findNavArray(sourceFile);
   return array ? parseNavItems(array) : [];
@@ -10934,14 +11334,14 @@ ${indent}${entry}`;
 }, upsertNavItem = (navDataPath, item) => {
   const created = !existsSync24(navDataPath);
   if (created) {
-    mkdirSync12(dirname19(navDataPath), { recursive: true });
+    mkdirSync12(dirname20(navDataPath), { recursive: true });
     writeFileSync12(navDataPath, NAV_DATA_TEMPLATE, "utf-8");
   }
   const existing = readNavItems(navDataPath);
   if (existing.some((candidate) => candidate.href === item.href)) {
     return { changed: created, created, items: existing };
   }
-  const text = readFileSync22(navDataPath, "utf-8");
+  const text = readFileSync23(navDataPath, "utf-8");
   const sourceFile = ts9.createSourceFile(navDataPath, text, ts9.ScriptTarget.Latest, true);
   const array = findNavArray(sourceFile);
   if (!array)
@@ -11100,19 +11500,19 @@ var init_pageTemplates = __esm(() => {
 import {
   existsSync as existsSync25,
   mkdirSync as mkdirSync13,
-  readFileSync as readFileSync23,
+  readFileSync as readFileSync24,
   readdirSync as readdirSync5,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname20, join as join30, relative as relative15 } from "path";
+import { dirname as dirname21, join as join31, relative as relative15 } from "path";
 var writeNew = (path, contents) => {
-  mkdirSync13(dirname20(path), { recursive: true });
+  mkdirSync13(dirname21(path), { recursive: true });
   writeFileSync13(path, contents, "utf-8");
 }, toHref = (fromDir, toFile) => {
   const rel = relative15(fromDir, toFile).split("\\").join("/");
   return rel.startsWith(".") ? rel : `./${rel}`;
-}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join30(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync25(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join30(pagesDir, name))), resyncPage = (file, items) => {
-  const html = readFileSync23(file, "utf-8");
+}, staticPageFiles = (project) => ["html", "htmx"].map((key) => project.frameworkDirs[key]).map((dir) => dir ? join31(dir, "pages") : null).filter((pagesDir) => pagesDir !== null && existsSync25(pagesDir)).flatMap((pagesDir) => readdirSync5(pagesDir).filter((name) => name.endsWith(".html")).map((name) => join31(pagesDir, name))), resyncPage = (file, items) => {
+  const html = readFileSync24(file, "utf-8");
   const synced = syncStaticNav(html, items);
   if (synced === null || synced === html)
     return false;
@@ -11139,19 +11539,19 @@ var writeNew = (path, contents) => {
     outcome.manual = { reason: "framework directory missing", snippet: "" };
     return outcome;
   }
-  const pageFileAbs = join30(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
+  const pageFileAbs = join31(frameworkDir, "pages", def.pageFile({ kebab, pascal }));
   if (existsSync25(pageFileAbs)) {
     outcome.notes.push(`${pascal} already exists at ${pageFileAbs} \u2014 skipped.`);
     return outcome;
   }
   const routingFile = findRoutingFile(project.serverEntry);
-  const routingText = routingFile ? readFileSync23(routingFile, "utf-8") : "";
+  const routingText = routingFile ? readFileSync24(routingFile, "utf-8") : "";
   const css = planCss(routingText, project.stylesDir, pascal, kebab);
-  const navDataPath = join30(sharedDirFor(project, framework), "navData.ts");
+  const navDataPath = join31(sharedDirFor(project, framework), "navData.ts");
   const nav = upsertNavItem(navDataPath, { href: route, label: title });
-  const navImportPath = toModuleSpecifier(dirname20(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
+  const navImportPath = toModuleSpecifier(dirname21(pageFileAbs), navDataPath.replace(/\.ts$/, ""));
   writeNew(pageFileAbs, pageTemplates[framework]({
-    cssHref: toHref(dirname20(pageFileAbs), css.cssFileAbs),
+    cssHref: toHref(dirname21(pageFileAbs), css.cssFileAbs),
     kebab,
     navImportPath,
     navItems: nav.items,
@@ -11334,25 +11734,25 @@ var init_serialize = () => {};
 
 // src/cli/config/absolute/editAbsoluteConfig.ts
 import ts10 from "typescript";
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync14 } from "fs";
 var lineStartOffset = (text, position) => {
   let index = position;
   while (index > 0 && text[index - 1] !== `
 `)
     index -= 1;
   return index;
-}, indentBefore2 = (text, position) => text.slice(lineStartOffset(text, position), position), findProperty = (object, name) => object.properties.find((property) => ts10.isPropertyAssignment(property) && (ts10.isIdentifier(property.name) || ts10.isStringLiteral(property.name)) && property.name.text === name), applyAbsoluteConfigEdit = (configPath2, request) => {
+}, indentBefore2 = (text, position) => text.slice(lineStartOffset(text, position), position), findProperty = (object2, name) => object2.properties.find((property) => ts10.isPropertyAssignment(property) && (ts10.isIdentifier(property.name) || ts10.isStringLiteral(property.name)) && property.name.text === name), applyAbsoluteConfigEdit = (configPath2, request) => {
   try {
-    const text = readFileSync24(configPath2, "utf-8");
+    const text = readFileSync25(configPath2, "utf-8");
     const sourceFile = ts10.createSourceFile(configPath2, text, ts10.ScriptTarget.Latest, true);
-    const object = findConfigObject(sourceFile);
-    if (!object) {
+    const object2 = findConfigObject(sourceFile);
+    if (!object2) {
       return {
         message: "Could not find defineConfig({ ... }) in the config file.",
         ok: false
       };
     }
-    const existing = findProperty(object, request.name);
+    const existing = findProperty(object2, request.name);
     if (request.remove) {
       if (!existing)
         return { message: `${request.name} is not set`, ok: true };
@@ -11373,7 +11773,7 @@ var lineStartOffset = (text, position) => {
       writeFileSync14(configPath2, text.slice(0, start2) + valueText + text.slice(end), "utf-8");
       return { message: `Updated ${request.name}`, ok: true };
     }
-    const { properties } = object;
+    const { properties } = object2;
     const entry = `${request.name}: ${valueText}`;
     if (properties.length > 0) {
       const last = properties[properties.length - 1];
@@ -11392,11 +11792,11 @@ var lineStartOffset = (text, position) => {
 ${indent}${entry}`;
       writeFileSync14(configPath2, text.slice(0, insertionIndex) + insertion + text.slice(insertionIndex), "utf-8");
     } else {
-      const insertionIndex = object.getStart(sourceFile) + 1;
-      const indent = `${indentBefore2(text, object.getStart(sourceFile))}	`;
+      const insertionIndex = object2.getStart(sourceFile) + 1;
+      const indent = `${indentBefore2(text, object2.getStart(sourceFile))}	`;
       const insertion = `
 ${indent}${entry}
-${indentBefore2(text, object.getStart(sourceFile))}`;
+${indentBefore2(text, object2.getStart(sourceFile))}`;
       writeFileSync14(configPath2, text.slice(0, insertionIndex) + insertion + text.slice(insertionIndex), "utf-8");
     }
     return { message: `Updated ${request.name}`, ok: true };
@@ -11526,14 +11926,14 @@ var init_catalog = __esm(() => {
 });
 
 // src/cli/integrations/addPlugin.ts
-import { existsSync as existsSync26, readFileSync as readFileSync25 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync26 } from "fs";
+import { join as join32 } from "path";
 var isRecord11 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readPackageJson = (cwd) => {
-  const path = join31(cwd, "package.json");
+  const path = join32(cwd, "package.json");
   if (!existsSync26(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync25(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync26(path, "utf-8"));
     return isRecord11(parsed) ? parsed : null;
   } catch {
     return null;
@@ -12025,15 +12425,15 @@ var init_authCatalog = __esm(() => {
 
 // src/cli/config/auth/resolveAuthSettings.ts
 import ts11 from "typescript";
-import { existsSync as existsSync27, readFileSync as readFileSync26 } from "fs";
-import { resolve as resolve26 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync27 } from "fs";
+import { resolve as resolve27 } from "path";
 var AUTH_PACKAGE = "@absolutejs/auth", CONFIG_CANDIDATES3, findAuthSettingsPath = (cwd, override) => {
   if (override) {
-    const resolved = resolve26(cwd, override);
+    const resolved = resolve27(cwd, override);
     return existsSync27(resolved) ? resolved : null;
   }
   for (const name of CONFIG_CANDIDATES3) {
-    const candidate = resolve26(cwd, name);
+    const candidate = resolve27(cwd, name);
     if (existsSync27(candidate))
       return candidate;
   }
@@ -12055,7 +12455,7 @@ var AUTH_PACKAGE = "@absolutejs/auth", CONFIG_CANDIDATES3, findAuthSettingsPath
   }
   return null;
 }, parseAuthSettingsObject = (configPath2) => {
-  const text = readFileSync26(configPath2, "utf-8");
+  const text = readFileSync27(configPath2, "utf-8");
   return {
     object: findAuthSettingsObject(parseSource2(configPath2, text)),
     text
@@ -12092,10 +12492,10 @@ var AUTH_PACKAGE = "@absolutejs/auth", CONFIG_CANDIDATES3, findAuthSettingsPath
 }, readCurrent2 = (configPath2) => {
   const current = {};
   const opaqueKeys = [];
-  const { object } = parseAuthSettingsObject(configPath2);
-  if (!object)
+  const { object: object2 } = parseAuthSettingsObject(configPath2);
+  if (!object2)
     return { current, opaqueKeys };
-  for (const property of object.properties) {
+  for (const property of object2.properties) {
     if (!ts11.isPropertyAssignment(property) || !(ts11.isIdentifier(property.name) || ts11.isStringLiteral(property.name))) {
       continue;
     }
@@ -12130,13 +12530,13 @@ var init_resolveAuthSettings = __esm(() => {
 
 // src/cli/config/auth/resolveAuthState.ts
 import ts12 from "typescript";
-import { existsSync as existsSync28, readdirSync as readdirSync6, readFileSync as readFileSync27 } from "fs";
-import { join as join32, relative as relative17, resolve as resolve27 } from "path";
+import { existsSync as existsSync28, readdirSync as readdirSync6, readFileSync as readFileSync28 } from "fs";
+import { join as join33, relative as relative17, resolve as resolve28 } from "path";
 var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutejs/absolute-auth", NPM_URL = "https://www.npmjs.com/package/@absolutejs/auth", SKIP_DIRS, MAX_FILES = 4000, SETUP_EXPORTS, isRecord12 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), readJson = (path) => {
   if (!existsSync28(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync27(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync28(path, "utf-8"));
     return isRecord12(parsed) ? parsed : null;
   } catch {
     return null;
@@ -12145,7 +12545,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
   const value = record?.[key];
   return typeof value === "string" ? value : null;
 }, declaredVersionFor = (cwd) => {
-  const pkg = readJson(join32(cwd, "package.json"));
+  const pkg = readJson(join33(cwd, "package.json"));
   if (!pkg)
     return null;
   for (const field of ["dependencies", "devDependencies"]) {
@@ -12157,14 +12557,14 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
       return version2;
   }
   return null;
-}, installedVersionFor = (cwd) => stringField(readJson(join32(cwd, "node_modules", AUTH_PACKAGE2, "package.json")), "version"), SOURCE_FILE, safeReaddir = (dir) => {
+}, installedVersionFor = (cwd) => stringField(readJson(join33(cwd, "node_modules", AUTH_PACKAGE2, "package.json")), "version"), SOURCE_FILE, safeReaddir = (dir) => {
   try {
     return readdirSync6(dir, { withFileTypes: true });
   } catch {
     return [];
   }
 }, sortEntry = (dir, entry, found, dirs) => {
-  const full = join32(dir, entry.name);
+  const full = join33(dir, entry.name);
   if (entry.isDirectory()) {
     if (SKIP_DIRS.has(entry.name) || entry.name.startsWith("."))
       return;
@@ -12208,11 +12608,11 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
     return null;
   }
   return property.initializer.properties.length;
-}, readConfigKeys = (object) => {
+}, readConfigKeys = (object2) => {
   const keys = new Set;
   let providerCount = null;
-  const usesSpread = object.properties.some((property) => ts12.isSpreadAssignment(property));
-  for (const property of object.properties) {
+  const usesSpread = object2.properties.some((property) => ts12.isSpreadAssignment(property));
+  for (const property of object2.properties) {
     const { name } = property;
     if (name === undefined || !ts12.isIdentifier(name))
       continue;
@@ -12229,7 +12629,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
   return { keys: new Set, providerCount: null, usesSpread: true };
 }, readFileOrNull = (path) => {
   try {
-    return readFileSync27(path, "utf-8");
+    return readFileSync28(path, "utf-8");
   } catch {
     return null;
   }
@@ -12262,7 +12662,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
   scaffoldable: isScaffoldableFeature(feature.id)
 })), resolveAuthState = (cwd) => {
   const installedVersion = installedVersionFor(cwd);
-  const root = existsSync28(join32(cwd, "src")) ? join32(cwd, "src") : cwd;
+  const root = existsSync28(join33(cwd, "src")) ? join33(cwd, "src") : cwd;
   let match = null;
   let setupPath = null;
   for (const file of candidateFiles(root)) {
@@ -12270,7 +12670,7 @@ var AUTH_PACKAGE2 = "@absolutejs/auth", REPO_URL = "https://github.com/absolutej
     if (found === null)
       continue;
     match = found;
-    setupPath = relative17(cwd, resolve27(file));
+    setupPath = relative17(cwd, resolve28(file));
     break;
   }
   const keys = match?.keys ?? new Set;
@@ -12308,7 +12708,7 @@ var init_resolveAuthState = __esm(() => {
 
 // src/cli/config/auth/scaffoldAuthFeature.ts
 import { existsSync as existsSync29, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname21, join as join33, relative as relative18, resolve as resolve28 } from "path";
+import { dirname as dirname22, join as join34, relative as relative18, resolve as resolve29 } from "path";
 var renderScaffold = (scaffold) => {
   const importNames = [...scaffold.imports, `type ${scaffold.typeName}`];
   const importLine = `import { ${importNames.join(", ")} } from '@absolutejs/auth';`;
@@ -12333,8 +12733,8 @@ ${body}
 }, targetDir = (cwd) => {
   const { setupPath } = resolveAuthState(cwd);
   if (setupPath)
-    return dirname21(resolve28(cwd, setupPath));
-  const src = join33(cwd, "src");
+    return dirname22(resolve29(cwd, setupPath));
+  const src = join34(cwd, "src");
   return existsSync29(src) ? src : cwd;
 }, spreadFor = (scaffold) => `import { ${scaffold.exportName} } from './${scaffold.exportName}';
 // add to your auth() call:
@@ -12348,7 +12748,7 @@ ${scaffold.configKey}: ${scaffold.exportName}`, failure2 = (message) => ({
   const scaffold = AUTH_SCAFFOLDS[id];
   if (!scaffold)
     return failure2(`Unknown auth feature "${id}".`);
-  const filePath = join33(targetDir(cwd), `${scaffold.exportName}.ts`);
+  const filePath = join34(targetDir(cwd), `${scaffold.exportName}.ts`);
   const relPath = relative18(cwd, filePath);
   if (existsSync29(filePath)) {
     return {
@@ -12377,12 +12777,12 @@ var init_scaffoldAuthFeature = __esm(() => {
 });
 
 // src/cli/htmx/install.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync14, readFileSync as readFileSync28, writeFileSync as writeFileSync16 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync14, readFileSync as readFileSync29, writeFileSync as writeFileSync16 } from "fs";
+import { join as join35 } from "path";
 var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
-  join34(import.meta.dir, "htmx.min.js"),
-  join34(import.meta.dir, "htmx", "htmx.min.js"),
-  join34(import.meta.dir, "..", "htmx", "htmx.min.js")
+  join35(import.meta.dir, "htmx.min.js"),
+  join35(import.meta.dir, "htmx", "htmx.min.js"),
+  join35(import.meta.dir, "..", "htmx", "htmx.min.js")
 ].find((path) => existsSync30(path)) ?? null, detectHtmxVersion = (content) => {
   const match = content.match(/version:"([0-9.]+)"/);
   return match ? match[1] : null;
@@ -12394,16 +12794,16 @@ var VENDORED_HTMX_VERSION = "2.0.6", vendoredHtmxFile = () => [
   }
   return response.text();
 }, installedHtmxVersion = (htmxDir) => {
-  const file = join34(htmxDir, "htmx.min.js");
+  const file = join35(htmxDir, "htmx.min.js");
   if (!existsSync30(file))
     return null;
-  return detectHtmxVersion(readFileSync28(file, "utf-8"));
+  return detectHtmxVersion(readFileSync29(file, "utf-8"));
 }, readVendoredHtmx = () => {
   const file = vendoredHtmxFile();
-  return file ? readFileSync28(file, "utf-8") : null;
+  return file ? readFileSync29(file, "utf-8") : null;
 }, writeHtmx = (htmxDir, content) => {
   mkdirSync14(htmxDir, { recursive: true });
-  const file = join34(htmxDir, "htmx.min.js");
+  const file = join35(htmxDir, "htmx.min.js");
   writeFileSync16(file, content, "utf-8");
   return file;
 };
@@ -12414,7 +12814,7 @@ var exports_add = {};
 __export(exports_add, {
   runAdd: () => runAdd
 });
-import { dirname as dirname22, join as join35, relative as relative19 } from "path";
+import { dirname as dirname23, join as join36, relative as relative19 } from "path";
 var write2 = (text) => process.stdout.write(`${text}
 `), fail2 = (message) => {
   process.stdout.write(`${colors.red}${message}${colors.reset}
@@ -12429,7 +12829,7 @@ var write2 = (text) => process.stdout.write(`${text}
 }, frontendRoot = (project, cwd) => {
   const [firstKey] = configuredFrameworks(project);
   const firstDir = firstKey ? project.frameworkDirs[firstKey] : undefined;
-  return firstDir ? dirname22(firstDir) : join35(cwd, "src", "frontend");
+  return firstDir ? dirname23(firstDir) : join36(cwd, "src", "frontend");
 }, addIntegrationCli = (id, install) => {
   const result = addIntegration(process.cwd(), id, { install });
   if (!result.ok) {
@@ -12493,7 +12893,7 @@ var write2 = (text) => process.stdout.write(`${text}
     write2(`${colors.yellow}!${colors.reset} ${frameworks6[framework].label} is already configured \u2014 nothing to do.`);
     return;
   }
-  const dirAbs = join35(frontendRoot(project, cwd), framework);
+  const dirAbs = join36(frontendRoot(project, cwd), framework);
   const dirRel = `./${relative19(cwd, dirAbs).split("\\").join("/")}`;
   let depNote = "Skipped dependency install (--no-install).";
   if (!noInstall) {
@@ -12563,8 +12963,8 @@ var exports_analyze = {};
 __export(exports_analyze, {
   runAnalyze: () => runAnalyze
 });
-import { existsSync as existsSync31, readFileSync as readFileSync29, statSync as statSync3, writeFileSync as writeFileSync17 } from "fs";
-import { join as join36, resolve as resolve29 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync30, statSync as statSync3, writeFileSync as writeFileSync17 } from "fs";
+import { join as join37, resolve as resolve30 } from "path";
 var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_WIDTH = 16, SIZE_WIDTH = 12, CHANGE_WIDTH = 10, CATEGORY_ORDER, categoryOf = (key) => {
   if (key.startsWith("Island"))
     return "Islands";
@@ -12584,21 +12984,21 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
     return 0;
   }
 }, readSizes = (manifestDir) => {
-  const manifestPath = join36(manifestDir, "manifest.json");
+  const manifestPath = join37(manifestDir, "manifest.json");
   if (!existsSync31(manifestPath))
     return null;
-  const manifest = JSON.parse(readFileSync29(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync30(manifestPath, "utf-8"));
   const sizes = {};
   for (const [key, value] of Object.entries(manifest)) {
-    sizes[key] = fileSize2(join36(manifestDir, value.replace(/^\//, "")));
+    sizes[key] = fileSize2(join37(manifestDir, value.replace(/^\//, "")));
   }
   return sizes;
 }, readBaseline = (cwd) => {
-  const path = join36(cwd, BASELINE_FILE);
+  const path = join37(cwd, BASELINE_FILE);
   if (!existsSync31(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync29(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync30(path, "utf-8"));
     return parsed;
   } catch {
     return null;
@@ -12676,14 +13076,14 @@ var BASELINE_FILE = ".absolute-size-baseline.json", TOP_CHANGES = 12, CATEGORY_W
   const config = await loadConfig(configIndex >= 0 ? args[configIndex + 1] : undefined);
   const outdirIndex = args.indexOf("--outdir");
   const outdir = outdirIndex >= 0 ? args[outdirIndex + 1] : config.buildDirectory;
-  const sizes = readSizes(resolve29(cwd, outdir ?? "build"));
+  const sizes = readSizes(resolve30(cwd, outdir ?? "build"));
   if (sizes === null) {
     process.stdout.write(`${colors.dim}No build found. Run \`absolute build\` first.${colors.reset}
 `);
     return;
   }
   if (args.includes("--save")) {
-    writeFileSync17(join36(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
+    writeFileSync17(join37(cwd, BASELINE_FILE), `${JSON.stringify(sizes, null, 2)}
 `);
     process.stdout.write(`${colors.green}\u2713${colors.reset} Saved size baseline (${Object.keys(sizes).length} entries) to ${BASELINE_FILE}
 `);
@@ -12845,10 +13245,10 @@ var METHOD_COLOR2, HTTP_METHODS, printDim2 = (message) => process.stdout.write(`
 }, getProp = (value, key) => typeof value === "object" && value !== null ? Reflect.get(value, key) : undefined, propertyNames = (schema) => {
   const properties = getProp(schema, "properties");
   return typeof properties === "object" && properties !== null ? Object.keys(properties) : [];
-}, summarize = (operation) => {
-  const parameters = getProp(operation, "parameters");
+}, summarize = (operation2) => {
+  const parameters = getProp(operation2, "parameters");
   const names = Array.isArray(parameters) ? parameters.map((param) => getProp(param, "name")).filter((name) => typeof name === "string") : [];
-  const json = getProp(getProp(operation, "requestBody"), "content");
+  const json = getProp(getProp(operation2, "requestBody"), "content");
   const body = propertyNames(getProp(getProp(json, "application/json"), "schema"));
   const parts = [];
   if (names.length > 0)
@@ -12860,10 +13260,10 @@ var METHOD_COLOR2, HTTP_METHODS, printDim2 = (message) => process.stdout.write(`
   const paths = Reflect.get(spec ?? {}, "paths");
   if (typeof paths !== "object" || paths === null)
     return [];
-  return Object.entries(paths).filter(([path]) => !isInternal(path)).flatMap(([path, methods]) => Object.entries(methods ?? {}).filter(([method]) => HTTP_METHODS.has(method)).map(([method, operation]) => ({
+  return Object.entries(paths).filter(([path]) => !isInternal(path)).flatMap(([path, methods]) => Object.entries(methods ?? {}).filter(([method]) => HTTP_METHODS.has(method)).map(([method, operation2]) => ({
     method: method.toUpperCase(),
     path,
-    summary: summarize(operation)
+    summary: summarize(operation2)
   })));
 }, runApi = async (args) => {
   const server = await findServer();
@@ -12929,7 +13329,7 @@ var exports_remove = {};
 __export(exports_remove, {
   runRemove: () => runRemove
 });
-import { existsSync as existsSync32, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync31 } from "fs";
 import { relative as relative20 } from "path";
 var write3 = (text) => process.stdout.write(`${text}
 `), fail3 = (message) => {
@@ -12943,7 +13343,7 @@ var write3 = (text) => process.stdout.write(`${text}
     if (file === null || seen.has(file) || !existsSync32(file))
       return false;
     seen.add(file);
-    return readFileSync30(file, "utf-8").includes(handler);
+    return readFileSync31(file, "utf-8").includes(handler);
   });
 }, runRemove = async (args) => {
   const [framework] = args.filter((arg) => !arg.startsWith("--"));
@@ -13070,15 +13470,15 @@ __export(exports_env, {
   runEnv: () => runEnv,
   collectEnvVars: () => collectEnvVars
 });
-import { existsSync as existsSync33, readFileSync as readFileSync31 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync32 } from "fs";
+import { join as join38 } from "path";
 var {env: env3, Glob: Glob3 } = globalThis.Bun;
-var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync33(join37(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
+var EXTENSIONS = "ts,tsx,js,jsx,mjs,cjs,svelte,vue", STATUS_WIDTH2, keysInFile = (text) => [...text.matchAll(/getEnv\(\s*['"]([^'"]+)['"]\s*\)/g)].map((match) => match[1]).filter((key) => key !== undefined), scanPatterns = () => existsSync33(join38(process.cwd(), "src")) ? [`src/**/*.{${EXTENSIONS}}`] : [`*.{${EXTENSIONS}}`], scanEnvUsage = async () => {
   const scans = scanPatterns().map((pattern) => Array.fromAsync(new Glob3(pattern).scan({ cwd: process.cwd() })));
   const files = (await Promise.all(scans)).flat();
   const usage = new Map;
   files.forEach((file) => {
-    keysInFile(readFileSync31(file, "utf-8")).forEach((key) => {
+    keysInFile(readFileSync32(file, "utf-8")).forEach((key) => {
       usage.set(key, [...usage.get(key) ?? [], file]);
     });
   });
@@ -13139,8 +13539,8 @@ __export(exports_db, {
   conflictClause: () => conflictClause,
   chunkRows: () => chunkRows
 });
-import { existsSync as existsSync34, mkdirSync as mkdirSync15, readFileSync as readFileSync32, writeFileSync as writeFileSync18 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync15, readFileSync as readFileSync33, writeFileSync as writeFileSync18 } from "fs";
+import { join as join39 } from "path";
 var {env: env4, spawn: spawn2, SQL } = globalThis.Bun;
 var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA_TYPES, SEED_CANDIDATES, VALUE_FLAGS, paint = (text, color) => `${color}${text}${colors.reset}`, chunkRows = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, idx) => items.slice(idx * size, idx * size + size)), quoteIdent = (name) => `"${name.replace(/"/g, '""')}"`, resolveUrl = (explicit) => {
   const found = explicit ?? URL_ENV_KEYS.map((key) => env4[key]).find((value) => typeof value === "string" && value !== "");
@@ -13250,19 +13650,19 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
     tables,
     v: BACKUP_FORMAT_VERSION
   };
-  const dir = options.out ?? join38(process.cwd(), "backups");
+  const dir = options.out ?? join39(process.cwd(), "backups");
   mkdirSync15(dir, { recursive: true });
   const json = JSON.stringify(payload, (_, value) => typeof value === "bigint" ? value.toString() : value);
-  const file = join38(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
+  const file = join39(dir, `backup-${payload.at.replace(/[:.]/g, "-")}.json`);
   writeFileSync18(file, json);
-  writeFileSync18(join38(dir, "latest.json"), json);
+  writeFileSync18(join39(dir, "latest.json"), json);
   const total = chosen.reduce((sum, name) => sum + (tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 backup \u2192 ${file}`, colors.green));
   console.log(paint(`  ${chosen.length} tables, ${total} rows`, colors.dim));
 }, runRestore = async (file, options) => {
   if (!existsSync34(file))
     throw new Error(`Backup not found: ${file}`);
-  const payload = JSON.parse(readFileSync32(file, "utf-8"));
+  const payload = JSON.parse(readFileSync33(file, "utf-8"));
   const names = Object.keys(payload.tables).filter((name) => keepTable(name, options));
   const sql = new SQL(options.url);
   const order = dependencyOrder(names, await foreignLinks(sql));
@@ -13284,7 +13684,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
   const total = order.reduce((sum, name) => sum + (payload.tables[name]?.length ?? 0), 0);
   console.log(paint(`\u2713 restored ${order.length} tables, ${total} rows (idempotent upsert by primary key)`, colors.green));
 }, runSeed = async (entry) => {
-  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync34(join38(process.cwd(), candidate)));
+  const target = entry ?? SEED_CANDIDATES.find((candidate) => existsSync34(join39(process.cwd(), candidate)));
   if (target === undefined)
     throw new Error(`No seed script found (looked for ${SEED_CANDIDATES.join(", ")}). Pass a path: absolute db seed <file>.`);
   console.log(paint(`seeding via ${target}\u2026`, colors.cyan));
@@ -13319,7 +13719,7 @@ var BACKUP_FORMAT_VERSION = 1, RESTORE_CHUNK_ROWS = 500, URL_ENV_KEYS, JSON_DATA
     return;
   }
   if (sub === "restore") {
-    const file = positionalArgs(rest)[0] ?? join38(process.cwd(), "backups", "latest.json");
+    const file = positionalArgs(rest)[0] ?? join39(process.cwd(), "backups", "latest.json");
     await runRestore(file, parseOptions(rest));
     return;
   }
@@ -13433,16 +13833,16 @@ var init_logs = __esm(() => {
 // src/cli/typeGraphCoherence.ts
 import {
   existsSync as existsSync36,
-  readFileSync as readFileSync33,
+  readFileSync as readFileSync34,
   realpathSync as realpathSync2,
   rmSync as rmSync6,
   writeFileSync as writeFileSync19
 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname23, join as join39, resolve as resolve30, sep as sep5 } from "path";
+import { dirname as dirname24, join as join40, resolve as resolve31, sep as sep5 } from "path";
 var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   try {
-    const parsed = JSON.parse(readFileSync33(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync34(path, "utf-8"));
     return isRecord9(parsed) ? parsed : null;
   } catch {
     return null;
@@ -13450,7 +13850,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
 }, dependencyRecord = (manifest, field) => {
   const value = Reflect.get(manifest, field);
   return isRecord9(value) ? value : {};
-}, dependencyNames = (manifest) => [
+}, dependencyNames2 = (manifest) => [
   ...new Set(DEPENDENCY_FIELDS.flatMap((field) => Object.keys(dependencyRecord(manifest, field))))
 ], declaresPackage = (manifest, name) => DEPENDENCY_FIELDS.some((field) => Object.hasOwn(dependencyRecord(manifest, field), name)), manifestName = (manifest, fallback) => {
   const name = Reflect.get(manifest, "name");
@@ -13459,13 +13859,13 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   const version2 = Reflect.get(manifest, "version");
   return typeof version2 === "string" ? version2 : "unknown";
 }, packageJsonFromEntry = (entry, expectedName) => {
-  let directory = dirname23(entry);
+  let directory = dirname24(entry);
   for (;; ) {
-    const candidate = join39(directory, "package.json");
+    const candidate = join40(directory, "package.json");
     const manifest = readManifest(candidate);
     if (manifest && manifestName(manifest, "") === expectedName)
       return candidate;
-    const parent = dirname23(directory);
+    const parent = dirname24(directory);
     if (parent === directory)
       return null;
     directory = parent;
@@ -13481,27 +13881,27 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
     }
   }
 }, findInstallRoot = (cwd) => {
-  let directory = resolve30(cwd);
+  let directory = resolve31(cwd);
   for (;; ) {
-    if (existsSync36(join39(directory, "bun.lock")) || existsSync36(join39(directory, "bun.lockb"))) {
+    if (existsSync36(join40(directory, "bun.lock")) || existsSync36(join40(directory, "bun.lockb"))) {
       return directory;
     }
-    const parent = dirname23(directory);
+    const parent = dirname24(directory);
     if (parent === directory)
-      return resolve30(cwd);
+      return resolve31(cwd);
     directory = parent;
   }
 }, findProjectManifest = (cwd, installRoot) => {
-  let directory = resolve30(cwd);
+  let directory = resolve31(cwd);
   for (;; ) {
-    const candidate = join39(directory, "package.json");
+    const candidate = join40(directory, "package.json");
     if (existsSync36(candidate))
       return candidate;
     if (directory === installRoot)
-      return join39(installRoot, "package.json");
-    const parent = dirname23(directory);
+      return join40(installRoot, "package.json");
+    const parent = dirname24(directory);
     if (parent === directory)
-      return join39(installRoot, "package.json");
+      return join40(installRoot, "package.json");
     directory = parent;
   }
 }, appendConsumer = (consumers, consumerPaths, path, manifest) => {
@@ -13539,7 +13939,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   appendConsumer(consumers, consumerPaths, inspection.consumer.path, inspection.consumer.manifest);
 }, inspectTypeGraph = (cwd) => {
   const installRoot = findInstallRoot(cwd);
-  const rootManifestPath = join39(installRoot, "package.json");
+  const rootManifestPath = join40(installRoot, "package.json");
   const rootManifest = readManifest(rootManifestPath) ?? {};
   const consumers = [
     { manifest: rootManifest, path: rootManifestPath }
@@ -13550,7 +13950,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   const projectConsumers = [...consumers];
   projectConsumers.forEach((consumer) => {
     const projectRequire = createRequire(consumer.path);
-    dependencyNames(consumer.manifest).forEach((dependency) => {
+    dependencyNames2(consumer.manifest).forEach((dependency) => {
       const path = resolvePackageJson(projectRequire, dependency);
       if (!path)
         return;
@@ -13575,7 +13975,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   const duplicates = duplicateTypeGraphPackages(report);
   if (duplicates.length === 0)
     return [];
-  const manifestPath = join39(report.installRoot, "package.json");
+  const manifestPath = join40(report.installRoot, "package.json");
   const manifest = readManifest(manifestPath);
   if (!manifest)
     return [];
@@ -13597,7 +13997,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   }
   return changes;
 }, removeDuplicateTypeGraphPackages = (report) => {
-  const manifest = readManifest(join39(report.installRoot, "package.json")) ?? {};
+  const manifest = readManifest(join40(report.installRoot, "package.json")) ?? {};
   const rootName = manifestName(manifest, "<workspace>");
   const installPrefix = `${realpathSync2(report.installRoot)}${sep5}`;
   const nodeModulesSegment = `${sep5}node_modules${sep5}`;
@@ -13609,7 +14009,7 @@ var DEPENDENCY_FIELDS, TYPE_GRAPH_PACKAGES, readManifest = (path) => {
   for (const stalePath of stalePaths) {
     if (!stalePath.startsWith(installPrefix) || !stalePath.includes(nodeModulesSegment))
       continue;
-    rmSync6(dirname23(stalePath), { force: true, recursive: true });
+    rmSync6(dirname24(stalePath), { force: true, recursive: true });
     removed.push(stalePath);
   }
   return removed;
@@ -13636,10 +14036,10 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync37, mkdirSync as mkdirSync16, readFileSync as readFileSync34, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync16, readFileSync as readFileSync35, writeFileSync as writeFileSync20 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { arch as arch4, platform as platform5 } from "os";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
   detail,
   label,
@@ -13674,7 +14074,7 @@ var FRAMEWORK_FIELDS2, projectRequire, check = (status2, label, detail) => ({
     return [];
   const label = `${field.replace("Directory", "")} pages`;
   return [
-    existsSync37(join40(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
+    existsSync37(join41(process.cwd(), dir)) ? check("ok", label, dir) : check("fail", label, `${dir} (missing)`)
   ];
 }), envCheck = async () => {
   const vars = await collectEnvVars();
@@ -13736,9 +14136,9 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const fixes = [];
   for (const field of FRAMEWORK_FIELDS2) {
     const dir = readString2(config, field);
-    if (dir === undefined || existsSync37(join40(cwd, dir)))
+    if (dir === undefined || existsSync37(join41(cwd, dir)))
       continue;
-    mkdirSync16(join40(cwd, dir, "pages"), { recursive: true });
+    mkdirSync16(join41(cwd, dir, "pages"), { recursive: true });
     fixes.push(`created ${dir}/pages`);
   }
   return fixes;
@@ -13746,8 +14146,8 @@ ${colors.dim}${checks.length} checks \xB7 ${colors.reset}${summary}${colors.dim}
   const missing = (await collectEnvVars()).filter((entry) => !entry.set);
   if (missing.length === 0)
     return null;
-  const envExample = join40(cwd, ".env.example");
-  const existing = existsSync37(envExample) ? readFileSync34(envExample, "utf-8") : "";
+  const envExample = join41(cwd, ".env.example");
+  const existing = existsSync37(envExample) ? readFileSync35(envExample, "utf-8") : "";
   const existingKeys = new Set(existing.split(`
 `).map((line) => line.split("=")[0]?.trim()));
   const toAdd = missing.filter((entry) => !existingKeys.has(entry.key));
@@ -13817,7 +14217,7 @@ var init_doctor = __esm(() => {
     "htmlDirectory",
     "htmxDirectory"
   ];
-  projectRequire = createRequire2(join40(process.cwd(), "package.json"));
+  projectRequire = createRequire2(join41(process.cwd(), "package.json"));
   STATUS_MARK = {
     fail: `${colors.red}\u2717${colors.reset}`,
     ok: `${colors.green}\u2713${colors.reset}`,
@@ -14141,8 +14541,8 @@ var islandFrameworks, islandHydrationModes, isIslandFramework = (value) => islan
   const componentMatch = attributeString.match(/\bcomponent\s*=\s*["']([^"']+)["']/);
   const hydrateMatch = attributeString.match(/\bhydrate\s*=\s*["']([^"']+)["']/);
   const framework = frameworkMatch?.[1];
-  const component = componentMatch?.[1];
-  if (!framework || !component) {
+  const component2 = componentMatch?.[1];
+  if (!framework || !component2) {
     return null;
   }
   if (!isIslandFramework(framework)) {
@@ -14150,7 +14550,7 @@ var islandFrameworks, islandHydrationModes, isIslandFramework = (value) => islan
   }
   const hydrateCandidate = hydrateMatch?.[1];
   return {
-    component,
+    component: component2,
     framework,
     hydrate: hydrateCandidate && isIslandHydrate(hydrateCandidate) ? hydrateCandidate : undefined
   };
@@ -14159,12 +14559,12 @@ var islandFrameworks, islandHydrationModes, isIslandFramework = (value) => islan
     return;
   usageMap.set(normalizeUsage(usage2), usage2);
 }, addRenderCallUsage = (usageMap, match) => {
-  const [, framework, component, hydrate] = match;
-  if (!framework || !component || !isIslandFramework(framework)) {
+  const [, framework, component2, hydrate] = match;
+  if (!framework || !component2 || !isIslandFramework(framework)) {
     return;
   }
   addUsage(usageMap, {
-    component,
+    component: component2,
     framework,
     hydrate: hydrate && isIslandHydrate(hydrate) ? hydrate : undefined
   });
@@ -14206,8 +14606,8 @@ var init_sourceMetadata = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync35 } from "fs";
-import { dirname as dirname24, resolve as resolve31 } from "path";
+import { readFileSync as readFileSync36 } from "fs";
+import { dirname as dirname25, resolve as resolve32 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.emberDirectory, framework: "ember" },
@@ -14227,8 +14627,8 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve31(dirname24(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve31(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve32(dirname25(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve32(resolvedSource));
   }
   return lookup;
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage2) => {
@@ -14241,13 +14641,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve31(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve32(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync35(filePath, "utf-8");
+    const source = readFileSync36(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve31(filePath), {
+    pageMetadata.set(resolve32(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve31(filePath)
+      pagePath: resolve32(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -14276,14 +14676,14 @@ var exports_islands = {};
 __export(exports_islands, {
   runIslands: () => runIslands
 });
-import { existsSync as existsSync39, readFileSync as readFileSync36, statSync as statSync5 } from "fs";
-import { join as join41, relative as relative21, resolve as resolve32 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync37, statSync as statSync5 } from "fs";
+import { join as join42, relative as relative21, resolve as resolve33 } from "path";
 var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.write(`${colors.dim}${message}${colors.reset}
 `), hostFrameworkOf = (pagePath, cwd, config) => {
-  const resolved = resolve32(cwd, pagePath);
+  const resolved = resolve33(cwd, pagePath);
   for (const [framework, key] of Object.entries(FRAMEWORK_DIR_KEY)) {
     const dir = config[key];
-    if (typeof dir === "string" && resolved.startsWith(resolve32(cwd, dir))) {
+    if (typeof dir === "string" && resolved.startsWith(resolve33(cwd, dir))) {
       return framework;
     }
   }
@@ -14295,20 +14695,20 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
     return 0;
   }
 }, readManifestSizes2 = (manifestDir) => {
-  const manifestPath = join41(manifestDir, "manifest.json");
+  const manifestPath = join42(manifestDir, "manifest.json");
   if (!existsSync39(manifestPath))
     return null;
-  const manifest = JSON.parse(readFileSync36(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync37(manifestPath, "utf-8"));
   const sizes = new Map;
   for (const [key, value] of Object.entries(manifest)) {
-    sizes.set(key, fileSize3(join41(manifestDir, value.replace(/^\//, ""))));
+    sizes.set(key, fileSize3(join42(manifestDir, value.replace(/^\//, ""))));
   }
   return sizes;
 }, collectIslands = async (cwd, config, sizes) => {
   const registryPath = config.islands?.registry;
   if (typeof registryPath !== "string")
     return null;
-  const buildInfo = await loadIslandRegistryBuildInfo(resolve32(cwd, registryPath));
+  const buildInfo = await loadIslandRegistryBuildInfo(resolve33(cwd, registryPath));
   const pageMetadata = await loadPageIslandMetadata(config);
   const usages = [...pageMetadata.values()].flatMap((meta) => meta.islands.map((island) => ({ ...island, page: meta.pagePath })));
   return buildInfo.definitions.map((definition) => {
@@ -14318,7 +14718,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
         crossFramework: hostFramework !== null && hostFramework !== definition.framework,
         hostFramework,
         hydrate: usage2.hydrate ?? "load",
-        page: relative21(cwd, resolve32(cwd, usage2.page))
+        page: relative21(cwd, resolve33(cwd, usage2.page))
       };
     });
     const key = getIslandManifestKey(definition.framework, definition.component);
@@ -14387,7 +14787,7 @@ var FRAMEWORK_DIR_KEY, FRAMEWORK_COLOR, printDim6 = (message) => process.stdout.
   }
   const outdirIndex = args.indexOf("--outdir");
   const outdir = outdirIndex >= 0 ? args[outdirIndex + 1] : config.buildDirectory;
-  const sizes = args.includes("--sizes") ? readManifestSizes2(resolve32(cwd, outdir ?? "build")) : null;
+  const sizes = args.includes("--sizes") ? readManifestSizes2(resolve33(cwd, outdir ?? "build")) : null;
   const islands = await collectIslands(cwd, config, sizes);
   if (islands === null) {
     printDim6('No island registry configured. Set `islands: { registry: "..." }` in absolute.config.ts.');
@@ -14437,12 +14837,12 @@ var init_islands2 = __esm(() => {
 
 // src/build/externalAssetPlugin.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync40, mkdirSync as mkdirSync17, statSync as statSync6 } from "fs";
-import { basename as basename11, dirname as dirname25, join as join42, resolve as resolve33 } from "path";
+import { basename as basename11, dirname as dirname26, join as join43, resolve as resolve34 } from "path";
 var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
   name: "absolute-external-asset",
   setup(bld) {
     const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
-    const skipRoots = userSourceRoots.map((root) => resolve33(root));
+    const skipRoots = userSourceRoots.map((root) => resolve34(root));
     const isUserSource = (path) => skipRoots.some((root) => path.startsWith(`${root}/`));
     bld.onLoad({ filter: /\.[mc]?[jt]sx?$/ }, async (args) => {
       if (isUserSource(args.path))
@@ -14452,20 +14852,20 @@ var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
         return;
       urlPattern.lastIndex = 0;
       let match;
-      const sourceDir = dirname25(args.path);
+      const sourceDir = dirname26(args.path);
       while ((match = urlPattern.exec(source)) !== null) {
         const relPath = match[1];
         if (!relPath)
           continue;
-        const assetPath = resolve33(sourceDir, relPath);
+        const assetPath = resolve34(sourceDir, relPath);
         if (!existsSync40(assetPath))
           continue;
         if (!statSync6(assetPath).isFile())
           continue;
-        const targetPath = join42(outDir, basename11(assetPath));
+        const targetPath = join43(outDir, basename11(assetPath));
         if (existsSync40(targetPath))
           continue;
-        mkdirSync17(dirname25(targetPath), { recursive: true });
+        mkdirSync17(dirname26(targetPath), { recursive: true });
         copyFileSync2(assetPath, targetPath);
       }
       return;
@@ -14486,7 +14886,7 @@ import {
   existsSync as existsSync41,
   mkdirSync as mkdirSync18,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync37,
+  readFileSync as readFileSync38,
   rmSync as rmSync7,
   statSync as statSync7,
   unlinkSync as unlinkSync4,
@@ -14495,11 +14895,11 @@ import {
 import { createRequire as createRequire3 } from "module";
 import {
   basename as basename12,
-  dirname as dirname26,
+  dirname as dirname27,
   isAbsolute as isAbsolute6,
-  join as join43,
+  join as join44,
   relative as relative22,
-  resolve as resolve34
+  resolve as resolve35
 } from "path";
 var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[cli]\x1B[0m ${color}${message}\x1B[0m`, compileBanner = (version2) => {
   const resolvedVersion = version2 || "unknown";
@@ -14513,7 +14913,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join43(entry.parentPath, entry.name);
+    const fullPath = join44(entry.parentPath, entry.name);
     if (entry.isDirectory())
       pending = pending.concat(readdirSync7(fullPath, { withFileTypes: true }));
     else
@@ -14521,7 +14921,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   return result;
 }, INLINE_SOURCE_MAP_RE, rebaseInlineSourceMap = (filePath) => {
-  const source = readFileSync37(filePath, "utf-8");
+  const source = readFileSync38(filePath, "utf-8");
   const match = source.match(INLINE_SOURCE_MAP_RE);
   const encoded = match?.[1];
   if (!encoded)
@@ -14532,7 +14932,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!Array.isArray(map.sources))
     return;
   const sourceRoot = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
-  const bundleDirectory = dirname26(filePath);
+  const bundleDirectory = dirname27(filePath);
   map.sources = map.sources.map((entry) => {
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(entry))
       return entry;
@@ -14541,7 +14941,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(sourceRoot)) {
       return new URL(entry, sourceRoot).href;
     }
-    return resolve34(bundleDirectory, sourceRoot, entry);
+    return resolve35(bundleDirectory, sourceRoot, entry);
   });
   delete map.sourceRoot;
   const rebased = Buffer.from(JSON.stringify(map)).toString("base64");
@@ -14559,7 +14959,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     const entry = pending.pop();
     if (!entry)
       continue;
-    const fullPath = join43(entry.parentPath, entry.name);
+    const fullPath = join44(entry.parentPath, entry.name);
     if (entry.isDirectory()) {
       if (SERVER_RUNTIME_SCAN_SKIP_DIRS.has(entry.name))
         continue;
@@ -14571,22 +14971,22 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return result;
 }, copyServerRuntimeAssetReferences = (outdir) => {
   const copied = new Set;
-  const normalizedOutdir = resolve34(outdir);
+  const normalizedOutdir = resolve35(outdir);
   const copyReference = (filePath, relPath) => {
-    const assetSource = resolve34(dirname26(filePath), relPath);
+    const assetSource = resolve35(dirname27(filePath), relPath);
     if (!existsSync41(assetSource) || !statSync7(assetSource).isFile())
       return;
-    const assetTarget = resolve34(normalizedOutdir, relPath.replace(/^\.\//, ""));
+    const assetTarget = resolve35(normalizedOutdir, relPath.replace(/^\.\//, ""));
     if (assetTarget !== normalizedOutdir && !assetTarget.startsWith(`${normalizedOutdir}/`))
       return;
     if (copied.has(assetTarget))
       return;
     copied.add(assetTarget);
-    mkdirSync18(dirname26(assetTarget), { recursive: true });
+    mkdirSync18(dirname27(assetTarget), { recursive: true });
     cpSync(assetSource, assetTarget, { force: true });
   };
   for (const filePath of collectProjectSourceFiles(process.cwd())) {
-    const source = readFileSync37(filePath, "utf-8");
+    const source = readFileSync38(filePath, "utf-8");
     SERVER_RUNTIME_ASSET_RE.lastIndex = 0;
     let match;
     while ((match = SERVER_RUNTIME_ASSET_RE.exec(source)) !== null) {
@@ -14615,7 +15015,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
 }, readPackageVersion4 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync37(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync38(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute")
       return null;
     const ver = pkg.version;
@@ -14650,18 +15050,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return resolveBuildModule3(remaining);
 }, resolveJsxDevRuntimeCompatPath2 = () => {
   const candidates = [
-    resolve34(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve34(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve34(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
-    resolve34(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve34(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve34(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve35(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve35(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve35(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.ts"),
+    resolve35(import.meta.dir, "..", "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve35(import.meta.dir, "..", "..", "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve35(import.meta.dir, "..", "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
     if (existsSync41(candidate))
       return candidate;
   }
-  return resolve34(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
+  return resolve35(import.meta.dir, "..", "..", "react", "jsxDevRuntimeCompat.js");
 }, jsxDevRuntimeCompatPath2, shouldEmbedCompiledAsset = (relativePath, skip = new Set) => {
   if (skip.has(relativePath))
     return false;
@@ -14686,7 +15086,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return true;
 }), requireForCompile, resolveNativeAssetForRuntime = (specifier) => {
   if (specifier.startsWith("."))
-    return resolve34(process.cwd(), specifier);
+    return resolve35(process.cwd(), specifier);
   if (specifier.startsWith("/"))
     return specifier;
   return requireForCompile.resolve(specifier, { paths: [process.cwd()] });
@@ -14698,11 +15098,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   return nativeAssetEnv;
 }, tryReadNodePackageJson = (packageDir) => {
   try {
-    return JSON.parse(readFileSync37(join43(packageDir, "package.json"), "utf-8"));
+    return JSON.parse(readFileSync38(join44(packageDir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
-}, resolveProjectPackageDir = (specifier) => resolve34(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
+}, resolveProjectPackageDir = (specifier) => resolve35(process.cwd(), "node_modules", ...specifier.split("/")), copyPackageToBuild = (specifier, outdir, seen) => {
   if (seen.has(specifier))
     return;
   const srcDir = resolveProjectPackageDir(specifier);
@@ -14710,7 +15110,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   if (!pkg)
     return;
   seen.add(specifier);
-  const destDir = join43(outdir, "node_modules", ...specifier.split("/"));
+  const destDir = join44(outdir, "node_modules", ...specifier.split("/"));
   rmSync7(destDir, { force: true, recursive: true });
   cpSync(srcDir, destDir, {
     force: true,
@@ -14732,7 +15132,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
 }, copyAngularRuntimePackages = (buildConfig, outdir) => {
   if (!buildConfig.angularDirectory)
     return;
-  const angularScopeDir = resolve34(process.cwd(), "node_modules", "@angular");
+  const angularScopeDir = resolve35(process.cwd(), "node_modules", "@angular");
   const angularPackages = existsSync41(angularScopeDir) ? readdirSync7(angularScopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => entry.name !== "compiler-cli").map((entry) => `@angular/${entry.name}`) : [];
   const roots = new Set([...angularPackages, "rxjs", "tslib", "typescript"]);
   const seen = new Set;
@@ -14751,7 +15151,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   copyAngularRuntimePackages(buildConfig, outdir);
   copyChunkReferencedPackages(outdir, seen);
 }, collectRuntimePackageSpecifiers = (distDir) => {
-  const nodeModulesDir = join43(distDir, "node_modules");
+  const nodeModulesDir = join44(distDir, "node_modules");
   if (!existsSync41(nodeModulesDir))
     return [];
   const specifiers = [];
@@ -14759,7 +15159,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!entry.isDirectory())
       continue;
     if (entry.name.startsWith("@")) {
-      const scopeDir = join43(nodeModulesDir, entry.name);
+      const scopeDir = join44(nodeModulesDir, entry.name);
       for (const scopedEntry of readdirSync7(scopeDir, {
         withFileTypes: true
       })) {
@@ -14773,7 +15173,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   }
   return specifiers.sort((firstSpecifier, secondSpecifier) => secondSpecifier.length - firstSpecifier.length);
 }, ensureRelativeModuleSpecifier = (fromFile, toFile) => {
-  const rel = relative22(dirname26(fromFile), toFile).replace(/\\/g, "/");
+  const rel = relative22(dirname27(fromFile), toFile).replace(/\\/g, "/");
   return rel.startsWith(".") ? rel : `./${rel}`;
 }, pickExportEntry = (value) => {
   if (typeof value === "string")
@@ -14790,18 +15190,18 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const packageSpecifier = packageSpecifiers.find((root) => specifier === root || specifier.startsWith(`${root}/`));
   if (!packageSpecifier)
     return null;
-  const packageDir = join43(distDir, "node_modules", ...packageSpecifier.split("/"));
+  const packageDir = join44(distDir, "node_modules", ...packageSpecifier.split("/"));
   const subpath = specifier.slice(packageSpecifier.length);
-  const subPackageDir = subpath ? join43(packageDir, ...subpath.slice(1).split("/")) : null;
-  const resolvedPackageDir = subPackageDir && existsSync41(join43(subPackageDir, "package.json")) ? subPackageDir : packageDir;
-  const packageJsonPath = join43(resolvedPackageDir, "package.json");
+  const subPackageDir = subpath ? join44(packageDir, ...subpath.slice(1).split("/")) : null;
+  const resolvedPackageDir = subPackageDir && existsSync41(join44(subPackageDir, "package.json")) ? subPackageDir : packageDir;
+  const packageJsonPath = join44(resolvedPackageDir, "package.json");
   if (!existsSync41(packageJsonPath))
     return null;
-  const pkg = JSON.parse(readFileSync37(packageJsonPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync38(packageJsonPath, "utf-8"));
   const exportKey = resolvedPackageDir !== subPackageDir && subpath ? `.${subpath}` : ".";
   const rootExport = pkg.exports?.[exportKey];
   const entry = pickExportEntry(rootExport) ?? (resolvedPackageDir === subPackageDir || !subpath ? pkg.module ?? pkg.main ?? "index.js" : `.${subpath}`);
-  return join43(resolvedPackageDir, entry);
+  return join44(resolvedPackageDir, entry);
 }, RUNTIME_JS_EXTENSIONS, MODULE_SPECIFIER_RE, isRuntimeJsFile = (filePath) => RUNTIME_JS_EXTENSIONS.some((extension) => filePath.endsWith(extension)), isNodeModulesPath = (filePath) => filePath.split(/[\\/]/).includes("node_modules"), isFile = (filePath) => {
   try {
     return statSync7(filePath).isFile();
@@ -14814,16 +15214,16 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const candidates = [
     candidate,
     ...RUNTIME_JS_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-    ...RUNTIME_JS_EXTENSIONS.map((extension) => join43(candidate, `index${extension}`))
+    ...RUNTIME_JS_EXTENSIONS.map((extension) => join44(candidate, `index${extension}`))
   ];
   return candidates.find((filePath) => isRuntimeJsFile(filePath) && isFile(filePath)) ?? null;
 }, findContainingRuntimePackageDir = (filePath) => {
-  let dir = dirname26(filePath);
-  while (dir !== dirname26(dir)) {
-    if (isNodeModulesPath(dir) && existsSync41(join43(dir, "package.json"))) {
+  let dir = dirname27(filePath);
+  while (dir !== dirname27(dir)) {
+    if (isNodeModulesPath(dir) && existsSync41(join44(dir, "package.json"))) {
       return dir;
     }
-    dir = dirname26(dir);
+    dir = dirname27(dir);
   }
   return null;
 }, resolvePackageImportEntryFile = (fromFile, specifier) => {
@@ -14836,13 +15236,13 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const entry = pickExportEntry(pkg?.imports?.[specifier]);
   if (!entry)
     return null;
-  return join43(packageDir, entry);
+  return join44(packageDir, entry);
 }, collectRuntimeRewriteRoots = (distDir) => collectFiles2(distDir).filter((filePath) => isRuntimeJsFile(filePath) && !isNodeModulesPath(filePath)), toTopLevelPackage = (specifier) => specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/"), FRAMEWORK_PACKAGE_NAME = "@absolutejs/absolute", copyChunkReferencedPackages = (distDir, seen) => {
-  const distRoot = resolve34(distDir);
+  const distRoot = resolve35(distDir);
   for (const filePath of collectRuntimeRewriteRoots(distDir)) {
-    if (resolve34(dirname26(filePath)) === distRoot)
+    if (resolve35(dirname27(filePath)) === distRoot)
       continue;
-    const source = readFileSync37(filePath, "utf-8");
+    const source = readFileSync38(filePath, "utf-8");
     for (const match of source.matchAll(MODULE_SPECIFIER_RE)) {
       const [, , , specifier] = match;
       if (!specifier || specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || specifier.startsWith("node:") || specifier.startsWith("bun:")) {
@@ -14872,11 +15272,11 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
     if (!filePath || seen.has(filePath))
       continue;
     seen.add(filePath);
-    const source = readFileSync37(filePath, "utf-8");
+    const source = readFileSync38(filePath, "utf-8");
     const { masked, restore } = maskLiterals(source);
     const rewrittenMasked = masked.replace(MODULE_SPECIFIER_RE, (match, prefix, quote, specifier) => {
       if (typeof specifier === "string" && specifier.startsWith(".")) {
-        enqueue(resolveRuntimeJsFile(resolve34(dirname26(filePath), specifier)));
+        enqueue(resolveRuntimeJsFile(resolve35(dirname27(filePath), specifier)));
         return match;
       }
       const packageImportTarget = resolveRuntimeJsFile(resolvePackageImportEntryFile(filePath, specifier) ?? "");
@@ -14920,7 +15320,7 @@ var cliTag4 = (color, message) => `\x1B[2m${formatTimestamp()}\x1B[0m ${color}[c
   const nativeAssets = resolveCompileNativeAssets(buildConfig);
   nativeAssets.forEach((asset, idx) => {
     const varName = `__native${idx}`;
-    const importSpecifier = asset.import.startsWith(".") ? resolve34(process.cwd(), asset.import) : asset.import;
+    const importSpecifier = asset.import.startsWith(".") ? resolve35(process.cwd(), asset.import) : asset.import;
     nativeImports.push(`import ${varName} from ${JSON.stringify(importSpecifier)} with { type: "file" };`);
     nativeMappings.push(`	[${JSON.stringify(asset.env)}, resolveNativeAssetPath(${varName})],`);
   });
@@ -14979,7 +15379,7 @@ import { buildGlobalWSHandler } from "elysia/ws";
 const SERVER_MODULE = (runtimeDir: string) => import(pathToFileURL(join(runtimeDir, ${JSON.stringify(serverBundleName)})).href);
 const RUNTIME_BUILD_ID = ${JSON.stringify(runtimeBuildId)};
 const RUNTIME_CONFIG_SOURCE = ${JSON.stringify(runtimeConfigSource)};
-const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve34(distDir))};
+const ORIGINAL_BUILD_DIR = ${JSON.stringify(resolve35(distDir))};
 const ORIGINAL_BUILD_DIR_NORMALIZED = ORIGINAL_BUILD_DIR.replace(/\\\\/g, "/");
 const EMBEDDED_NATIVE_AUTH_CLIENTS = ${JSON.stringify(process.env[ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV])};
 
@@ -15400,17 +15800,17 @@ console.log(\`
     });
   }
 }), compile = async (serverEntry, outdir, outfile, configPath2) => {
-  const resolvedOutdir = resolve34(outdir ?? "dist");
+  const resolvedOutdir = resolve35(outdir ?? "dist");
   await withBuildDirectoryLock(resolvedOutdir, () => compileUnlocked(serverEntry, resolvedOutdir, outfile, configPath2));
 }, compileUnlocked = async (serverEntry, resolvedOutdir, outfile, configPath2) => {
   const configuredPrerenderPort = env5.COMPILE_PORT === undefined ? Number(env5.PORT) : Number(env5.COMPILE_PORT);
   const prerenderPort = configuredPrerenderPort > 0 ? configuredPrerenderPort : await findFreePort();
   killStaleProcesses(prerenderPort);
   const entryName = basename12(serverEntry).replace(/\.[^.]+$/, "");
-  const resolvedOutfile = resolve34(outfile ?? "compiled-server");
+  const resolvedOutfile = resolve35(outfile ?? "compiled-server");
   const absoluteVersion = resolvePackageVersion3([
-    resolve34(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve34(import.meta.dir, "..", "..", "package.json")
+    resolve35(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve35(import.meta.dir, "..", "..", "package.json")
   ]);
   compileBanner(absoluteVersion);
   const totalStart = performance.now();
@@ -15423,8 +15823,8 @@ console.log(\`
     installAbsoluteMobileAuthEnvironment(process.cwd(), normalizeAbsoluteMobileConfig(buildConfig.mobile, process.cwd()));
   try {
     const build2 = await resolveBuildModule3([
-      resolve34(import.meta.dir, "..", "..", "core", "build"),
-      resolve34(import.meta.dir, "..", "build")
+      resolve35(import.meta.dir, "..", "..", "core", "build"),
+      resolve35(import.meta.dir, "..", "build")
     ]);
     if (!build2)
       throw new Error("Could not locate build module");
@@ -15446,11 +15846,11 @@ console.log(\`
     buildConfig.htmxDirectory
   ].filter((dir) => Boolean(dir));
   const islandRegistrySpec = buildConfig.islands?.registry;
-  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve34(islandRegistrySpec))) : undefined;
-  const serverBundleEntryDirectory = join43(resolvedOutdir, ".absolutejs-server-entry");
+  const islandRegistryPlugin = islandRegistrySpec ? createIslandRegistryDefinitionPlugin(await loadIslandRegistryBuildInfo(resolve35(islandRegistrySpec))) : undefined;
+  const serverBundleEntryDirectory = join44(resolvedOutdir, ".absolutejs-server-entry");
   mkdirSync18(serverBundleEntryDirectory, { recursive: true });
-  const typeboxSetupEntry = join43(serverBundleEntryDirectory, "_typebox_setup.ts");
-  const serverBundleEntry = join43(serverBundleEntryDirectory, basename12(serverEntry));
+  const typeboxSetupEntry = join44(serverBundleEntryDirectory, "_typebox_setup.ts");
+  const serverBundleEntry = join44(serverBundleEntryDirectory, basename12(serverEntry));
   writeFileSync21(typeboxSetupEntry, `import { setupTypebox } from 'elysia';
 import * as compile from 'typebox/compile';
 import * as schema from 'typebox/schema';
@@ -15461,7 +15861,7 @@ import * as value from 'typebox/value';
 setupTypebox({ typebox: { compile, schema, system, type, value } });
 `);
   writeFileSync21(serverBundleEntry, `import './_typebox_setup';
-import * as serverModule from ${JSON.stringify(resolve34(serverEntry))};
+import * as serverModule from ${JSON.stringify(resolve35(serverEntry))};
 
 export const server = serverModule.server ?? serverModule.app ?? serverModule.default;
 export default server;
@@ -15475,7 +15875,7 @@ export default server;
       ...islandRegistryPlugin ? [islandRegistryPlugin] : [],
       ...buildConfig.mobile ? [
         createAbsoluteMobileRouteMetadataPlugin({
-          entry: resolve34(serverEntry)
+          entry: resolve35(serverEntry)
         })
       ] : [],
       createElysiaOpenApiTypeboxPlugin(),
@@ -15499,13 +15899,13 @@ export default server;
     console.error(cliTag4("\x1B[31m", "Server bundle failed."));
     process.exit(1);
   }
-  const outputPath = resolve34(resolvedOutdir, `${entryName}.js`);
+  const outputPath = resolve35(resolvedOutdir, `${entryName}.js`);
   if (!existsSync41(outputPath)) {
     console.error(cliTag4("\x1B[31m", `Expected output not found: ${outputPath}`));
     process.exit(1);
   }
-  if (existsSync41(resolve34(resolvedOutdir, "angular", "vendor", "server"))) {
-    const vendorDir = resolve34(resolvedOutdir, "angular", "vendor", "server");
+  if (existsSync41(resolve35(resolvedOutdir, "angular", "vendor", "server"))) {
+    const vendorDir = resolve35(resolvedOutdir, "angular", "vendor", "server");
     const vendorEntries = readdirSync7(vendorDir).filter((fileName) => fileName.endsWith(".js"));
     const angularServerVendorPaths = {};
     for (const file of vendorEntries) {
@@ -15514,7 +15914,7 @@ export default server;
       if (scope !== "angular" || rest.length === 0)
         continue;
       const specifier = `@angular/${rest.join("/")}`;
-      const relPath = relative22(dirname26(outputPath), resolve34(vendorDir, file));
+      const relPath = relative22(dirname27(outputPath), resolve35(vendorDir, file));
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
@@ -15526,7 +15926,7 @@ export default server;
   copyServerRuntimeAssetReferences(resolvedOutdir);
   const prerenderStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Pre-rendering pages"));
-  rmSync7(join43(resolvedOutdir, "_prerendered"), {
+  rmSync7(join44(resolvedOutdir, "_prerendered"), {
     force: true,
     recursive: true
   });
@@ -15556,9 +15956,9 @@ export default server;
   const compileStart = performance.now();
   process.stdout.write(cliTag4("\x1B[36m", "Compiling standalone executable"));
   const entrypointCode = generateEntrypoint(resolvedOutdir, serverEntry, prerenderMap, absoluteVersion, buildConfig);
-  const entrypointPath = join43(resolvedOutdir, "_compile_entrypoint.ts");
+  const entrypointPath = join44(resolvedOutdir, "_compile_entrypoint.ts");
   await Bun.write(entrypointPath, entrypointCode);
-  mkdirSync18(dirname26(resolvedOutfile), { recursive: true });
+  mkdirSync18(dirname27(resolvedOutfile), { recursive: true });
   const result = await Bun.build({
     compile: { outfile: resolvedOutfile },
     define: { "process.env.NODE_ENV": '"production"' },
@@ -15642,7 +16042,7 @@ var init_compile = __esm(() => {
 
 // src/mobile/nativeDeepLinks.ts
 import { readFile as readFile11, rename as rename8, writeFile as writeFile9 } from "fs/promises";
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 var START_MARKER = "<!-- absolutejs:deep-links:start -->", END_MARKER = "<!-- absolutejs:deep-links:end -->", IOS_ENTITLEMENTS = "App/AbsoluteJS.entitlements", NOT_FOUND = -1, escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"), writeChangedFile = async (path, source) => {
   const current = await readFile11(path, "utf8");
   if (current === source)
@@ -15671,7 +16071,7 @@ var START_MARKER = "<!-- absolutejs:deep-links:start -->", END_MARKER = "<!-- ab
   }
   return `${source.slice(0, index)}${region}${source.slice(index)}`;
 }, 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 ? `
 
@@ -15691,7 +16091,7 @@ ${hosts}
             ${END_MARKER}
 `;
 }, configureAndroid = async (config) => {
-  const path = join44(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
+  const path = join45(config.nativeProjectDirectory, "android/app/src/main/AndroidManifest.xml");
   const source = await readFile11(path, "utf8");
   const mainActivity = source.indexOf('android:name=".MainActivity"');
   if (mainActivity === NOT_FOUND) {
@@ -15715,7 +16115,7 @@ ${hosts}
 	</array>
 	${END_MARKER}
 `, configureIosInfo = async (config) => {
-  const path = join44(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const path = join45(config.nativeProjectDirectory, "ios/App/App/Info.plist");
   const source = await readFile11(path, "utf8");
   const region = config.deepLinkScheme ? iosSchemeRegion(config.deepLinkScheme) : `	${START_MARKER}
 	${END_MARKER}
@@ -15723,7 +16123,7 @@ ${hosts}
   const updated = replaceManagedRegion(source, region, () => source.lastIndexOf("</dict>"));
   return writeChangedFile(path, updated);
 }, 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">
@@ -15737,7 +16137,7 @@ ${domains}
 </plist>
 `;
 }, configureIosEntitlements = async (config) => {
-  const path = join44(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
+  const path = join45(config.nativeProjectDirectory, "ios/App/AbsoluteJS.entitlements");
   let current = "";
   try {
     current = await readFile11(path, "utf8");
@@ -15754,7 +16154,7 @@ ${domains}
   await rename8(temporary, path);
   return true;
 }, configureIosProject = async (config) => {
-  const path = join44(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
+  const path = join45(config.nativeProjectDirectory, "ios/App/App.xcodeproj/project.pbxproj");
   const source = await readFile11(path, "utf8");
   const declarations = [
     ...source.matchAll(/CODE_SIGN_ENTITLEMENTS = ([^;]+);/g)
@@ -15794,7 +16194,7 @@ var init_nativeDeepLinks = () => {};
 
 // src/mobile/nativeBackgroundSync.ts
 import { readFile as readFile12, rename as rename9, writeFile as writeFile10 } from "fs/promises";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 var writeChanged = async (path, source) => {
   const current = await readFile12(path, "utf8");
   if (current === source)
@@ -15877,10 +16277,10 @@ ${makeRegion(values)}	</array>
   if (!platforms.includes("ios") || !projectUsesAbsoluteAuth(projectRoot) || !projectUsesAbsoluteSync(projectRoot))
     return { changed: false };
   const identifier = `${config.appId}.absolutejs.background-sync`;
-  const infoPath = join45(config.nativeProjectDirectory, "ios/App/App/Info.plist");
+  const infoPath = join46(config.nativeProjectDirectory, "ios/App/App/Info.plist");
   const info2 = await readFile12(infoPath, "utf8");
   const nextInfo = ensurePlistArrayValues(ensurePlistArrayValues(info2, "BGTaskSchedulerPermittedIdentifiers", [identifier], "background-sync-identifiers"), "UIBackgroundModes", ["fetch", "processing"], "background-sync-modes");
-  const delegatePath = join45(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
+  const delegatePath = join46(config.nativeProjectDirectory, "ios/App/App/AppDelegate.swift");
   let delegate = await readFile12(delegatePath, "utf8");
   if (!delegate.includes("import AbsoluteSyncCapacitor")) {
     const importIndex = delegate.lastIndexOf("import Capacitor");
@@ -15920,7 +16320,7 @@ import {
   rm as rm7,
   writeFile as writeFile11
 } from "fs/promises";
-import { resolve as resolve35 } from "path";
+import { resolve as resolve36 } from "path";
 import { Elysia } from "elysia";
 var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERIFY_TIMEOUT_MS = 1e4, ANDROID_ASSOCIATION_PATH = "/.well-known/assetlinks.json", APPLE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association", missingIdentity = (field, platform6) => new TypeError(`${field} is required to publish ${platform6} deep-link association files.`), createAppleDocument = (config, requireAll) => {
   if (!config.platforms.includes("ios"))
@@ -15993,7 +16393,7 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
     return false;
   }
 }, assertOwnedOutput = async (root) => {
-  const path = resolve35(root, OWNERSHIP_FILE);
+  const path = resolve36(root, OWNERSHIP_FILE);
   let ownership;
   try {
     ownership = JSON.parse(await readFile13(path, "utf8"));
@@ -16019,34 +16419,34 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
   }
   if (hasCurrent)
     await rm7(backup, { force: true, recursive: true });
-}, materializeHost = async (root, host, files) => {
-  const directory = resolve35(root, host, ".well-known");
+}, materializeHost = async (root, host2, files) => {
+  const directory = resolve36(root, host2, ".well-known");
   await mkdir10(directory, { recursive: true });
   return Promise.all(files.map(async ([name, document]) => {
-    const path = resolve35(directory, name);
+    const path = resolve36(directory, name);
     await writeAtomic(path, `${JSON.stringify(document, null, 2)}
 `);
     return path;
   }));
-}, associationEndpoints = (config, documents) => config.deepLinkHosts.flatMap((host) => {
+}, associationEndpoints = (config, documents) => config.deepLinkHosts.flatMap((host2) => {
   const endpoints = [];
   if (documents.android)
     endpoints.push({
       document: documents.android,
-      host,
+      host: host2,
       path: ANDROID_ASSOCIATION_PATH,
       platform: "Android"
     });
   if (documents.apple)
     endpoints.push({
       document: documents.apple,
-      host,
+      host: host2,
       path: APPLE_ASSOCIATION_PATH,
       platform: "Apple"
     });
   return endpoints;
 }), materializeAbsoluteMobileAssociationFiles = async (config, outputDirectory) => {
-  const root = resolve35(outputDirectory);
+  const root = resolve36(outputDirectory);
   const temporary = `${root}.${crypto.randomUUID()}.tmp`;
   const documents = createAbsoluteMobileAssociationDocuments(config, {
     requireAll: true
@@ -16059,11 +16459,11 @@ var OWNERSHIP_FILE = ".absolutejs-mobile-associations.json", HTTP_OK = 200, VERI
   }
   await mkdir10(temporary, { recursive: true });
   try {
-    const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host) => materializeHost(temporary, host, files)))).flat();
-    await writeAtomic(resolve35(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
+    const temporaryPaths = (await Promise.all(config.deepLinkHosts.map((host2) => materializeHost(temporary, host2, files)))).flat();
+    await writeAtomic(resolve36(temporary, OWNERSHIP_FILE), `${JSON.stringify({ format: 1, hosts: config.deepLinkHosts }, null, 2)}
 `);
     await publishGeneratedDirectory(temporary, root);
-    const written = temporaryPaths.map((path) => resolve35(root, path.slice(temporary.length + 1)));
+    const written = temporaryPaths.map((path) => resolve36(root, path.slice(temporary.length + 1)));
     return { root, written };
   } catch (error) {
     await rm7(temporary, { force: true, recursive: true });
@@ -16105,7 +16505,7 @@ var init_associationFiles = __esm(() => {
 
 // src/mobile/androidWebView.ts
 import { mkdir as mkdir11, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname27, resolve as resolve36 } from "path";
+import { dirname as dirname28, resolve as resolve37 } from "path";
 
 class CdpConnection {
   diagnostics = [];
@@ -16376,8 +16776,8 @@ var CDP_COMMAND_TIMEOUT_MS = 1e4, WEBVIEW_ATTACH_TIMEOUT_MS = 30000, WEBVIEW_POL
       if (typeof data !== "string") {
         throw new Error("Android WebView screenshot returned no image data.");
       }
-      const absolutePath = resolve36(path);
-      await mkdir11(dirname27(absolutePath), { recursive: true });
+      const absolutePath = resolve37(path);
+      await mkdir11(dirname28(absolutePath), { recursive: true });
       await writeFile12(absolutePath, Buffer.from(data, "base64"));
       return absolutePath;
     }
@@ -16497,7 +16897,7 @@ var DEFAULT_ROUTE_TIMEOUT_MS = 30000, DEFAULT_HMR_TIMEOUT_MS = 30000, routeExpre
 
 // src/mobile/releaseDoctor.ts
 import { access as access8, readFile as readFile14, readdir as readdir4 } from "fs/promises";
-import { extname as extname7, join as join46, relative as relative23 } from "path";
+import { extname as extname7, join as join47, relative as relative23 } from "path";
 var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
   try {
     await access8(path);
@@ -16516,7 +16916,7 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
   if (!await pathExists5(root))
     return;
   const entries = await readdir4(root, { withFileTypes: true });
-  const matches = await Promise.all(entries.map((entry) => inspectReleaseAsset(join46(root, entry.name), entry.isDirectory(), entry.isFile())));
+  const matches = await Promise.all(entries.map((entry) => inspectReleaseAsset(join47(root, entry.name), entry.isDirectory(), entry.isFile())));
   return matches.find((match) => match !== undefined);
 }, pass = (id, detail, path) => ({ detail, id, path, status: "pass" }), fail5 = (id, detail, path, remediation) => ({
   detail,
@@ -16560,12 +16960,29 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
 }, hmrAssetsReleaseCheck = async (publicRoot) => {
   const hmrAsset = await findHmrAsset(publicRoot);
   return hmrAsset ? fail5("android.hmr-assets", "A packaged Android asset contains the development HMR client.", hmrAsset, "Rebuild the production mobile bundle and run Capacitor sync again.") : pass("android.hmr-assets", "Packaged Android assets contain no development HMR markers.", publicRoot);
+}, syncSchemaReleaseCheck = (projectRoot) => {
+  if (!projectUsesAbsoluteSync(projectRoot))
+    return;
+  const manifestPath = join47(projectRoot, "package.json");
+  try {
+    const schema = discoverAbsoluteSyncSchema(projectRoot);
+    const versions = schema.components.map((component2) => `${component2.id}@${component2.version}`).join(", ");
+    const collectionRules = schema.components.flatMap((component2) => component2.localData?.collections ?? []);
+    const mutationRules = schema.components.flatMap((component2) => component2.localData?.mutations ?? []);
+    const protectedCount = [...collectionRules, ...mutationRules].filter((rule) => rule.protection === "required").length;
+    const memoryOnlyCount = collectionRules.filter((rule) => rule.persistence === "memory-only" || rule.onProtectionUnavailable === "memory-only").length;
+    const quotas = schema.components.map((component2) => component2.localData?.maxBytesPerNamespace).filter((value) => value !== undefined);
+    const policy = `${collectionRules.length} collection rule(s), ${mutationRules.length} mutation rule(s), ${protectedCount} encryption-required, ${memoryOnlyCount} memory-only fallback(s)${quotas.length > 0 ? `, ${Math.min(...quotas)}-byte effective quota` : ", no logical quota"}`;
+    return pass("sync.storage-schema", `Generated offline schema is compatible: ${versions}; ${policy}.`, manifestPath);
+  } catch (error) {
+    return fail5("sync.storage-schema", error instanceof Error ? error.message : "Generated offline schema metadata is invalid.", manifestPath, "Fix absolutejs.sync.localSchema metadata in the named app or package before releasing.");
+  }
 }, inspectAndroidRelease = async (config, projectRoot) => {
-  const androidRoot = join46(config.nativeProjectDirectory, "android");
-  const nativeConfigPath = join46(androidRoot, "app", "src", "main", "assets", "capacitor.config.json");
-  const manifestPath = join46(androidRoot, "app", "src", "main", "AndroidManifest.xml");
-  const publicRoot = join46(androidRoot, "app", "src", "main", "assets", "public");
-  const journalPath = join46(projectRoot, ".absolutejs", "mobile", "dev-session", "journal.json");
+  const androidRoot = join47(config.nativeProjectDirectory, "android");
+  const nativeConfigPath = join47(androidRoot, "app", "src", "main", "assets", "capacitor.config.json");
+  const manifestPath = join47(androidRoot, "app", "src", "main", "AndroidManifest.xml");
+  const publicRoot = join47(androidRoot, "app", "src", "main", "assets", "public");
+  const journalPath = join47(projectRoot, ".absolutejs", "mobile", "dev-session", "journal.json");
   const checks = await Promise.all([
     journalReleaseCheck(journalPath, "android"),
     capacitorConfigReleaseCheck(nativeConfigPath),
@@ -16577,11 +16994,11 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
     path: check2.path ? relative23(projectRoot, check2.path).replaceAll("\\", "/") || "." : undefined
   }));
 }, inspectIosRelease = async (config, projectRoot) => {
-  const iosAppRoot = join46(config.nativeProjectDirectory, "ios", "App", "App");
-  const nativeConfigPath = join46(iosAppRoot, "capacitor.config.json");
-  const infoPath = join46(iosAppRoot, "Info.plist");
-  const publicRoot = join46(iosAppRoot, "public");
-  const journalPath = join46(projectRoot, ".absolutejs", "mobile", "ios-dev-session", "journal.json");
+  const iosAppRoot = join47(config.nativeProjectDirectory, "ios", "App", "App");
+  const nativeConfigPath = join47(iosAppRoot, "capacitor.config.json");
+  const infoPath = join47(iosAppRoot, "Info.plist");
+  const publicRoot = join47(iosAppRoot, "public");
+  const journalPath = join47(projectRoot, ".absolutejs", "mobile", "ios-dev-session", "journal.json");
   const checks = [
     await journalReleaseCheck(journalPath, "ios")
   ];
@@ -16614,12 +17031,21 @@ var HMR_ASSET_PATTERN, RELEASE_ASSET_EXTENSIONS, pathExists5 = async (path) => {
   if (config.platforms.includes("ios")) {
     checks.push(...await inspectIosRelease(config, projectRoot));
   }
+  const syncSchema = syncSchemaReleaseCheck(projectRoot);
+  if (syncSchema) {
+    checks.push({
+      ...syncSchema,
+      path: syncSchema.path ? relative23(projectRoot, syncSchema.path).replaceAll("\\", "/") || "." : undefined
+    });
+  }
   return {
     checks,
     ready: checks.length > 0 && checks.every((check2) => check2.status === "pass")
   };
 };
 var init_releaseDoctor = __esm(() => {
+  init_nativeAuth();
+  init_syncSchema();
   HMR_ASSET_PATTERN = /(?:__HMR_WS__|hmr-timing|__absolute_target|absolutejs-error-overlay)/u;
   RELEASE_ASSET_EXTENSIONS = new Set([".html", ".js", ".mjs"]);
 });
@@ -16637,7 +17063,7 @@ import {
   stat as stat2,
   writeFile as writeFile13
 } from "fs/promises";
-import { dirname as dirname28, isAbsolute as isAbsolute7, join as join47, relative as relative24, resolve as resolve37, sep as sep6 } from "path";
+import { dirname as dirname29, isAbsolute as isAbsolute7, join as join48, relative as relative24, resolve as resolve38, sep as sep6 } from "path";
 var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), requireManifest2 = (value) => {
   if (!isRecord13(value) || typeof value.appBuild !== "string" || typeof value.appId !== "string" || typeof value.runtime !== "string") {
     throw new TypeError("Invalid embedded AbsoluteJS mobile manifest.");
@@ -16688,19 +17114,19 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
   ]);
   return result.exitCode === 0 && /jar verified/iu.test(result.stdout);
 }, sha256File2 = async (path) => createHash12("sha256").update(await readFile15(path)).digest("hex"), safeOutputDirectory2 = (projectRoot, requested) => {
-  const root = resolve37(projectRoot);
-  const output = resolve37(root, requested ?? ".absolutejs/mobile/releases/android");
+  const root = resolve38(projectRoot);
+  const output = resolve38(root, requested ?? ".absolutejs/mobile/releases/android");
   const projectRelative = relative24(root, output);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep6}`) || isAbsolute7(projectRelative)) {
     throw new TypeError("mobile build --outdir must remain inside the project.");
   }
   return output;
 }, installRelease2 = async (artifactPath, metadata, outputRoot) => {
-  const releaseRoot = join47(outputRoot, metadata.releaseId);
+  const releaseRoot = join48(outputRoot, metadata.releaseId);
   const artifactName = "app-release.aab";
-  const destination = join47(releaseRoot, artifactName);
+  const destination = join48(releaseRoot, artifactName);
   if (await pathExists6(releaseRoot)) {
-    const existing = requireManifestIdentity(JSON.parse(await readFile15(join47(releaseRoot, "release.json"), "utf8")), metadata);
+    const existing = requireManifestIdentity(JSON.parse(await readFile15(join48(releaseRoot, "release.json"), "utf8")), metadata);
     const [installedBytes, installedSha256] = await Promise.all([
       stat2(destination).then(({ size }) => size),
       sha256File2(destination)
@@ -16710,15 +17136,15 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
     }
     return { artifactPath: destination, metadata: existing, releaseRoot };
   }
-  await mkdir12(dirname28(releaseRoot), { recursive: true });
-  const staging = await mkdtemp5(join47(dirname28(releaseRoot), ".android-stage-"));
+  await mkdir12(dirname29(releaseRoot), { recursive: true });
+  const staging = await mkdtemp5(join48(dirname29(releaseRoot), ".android-stage-"));
   try {
-    await copyFile5(artifactPath, join47(staging, artifactName));
+    await copyFile5(artifactPath, join48(staging, artifactName));
     const complete = {
       ...metadata,
       artifact: artifactName
     };
-    await writeFile13(join47(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
+    await writeFile13(join48(staging, "release.json"), `${JSON.stringify(complete, null, "\t")}
 `, { flag: "wx" });
     await rename11(staging, releaseRoot);
     return { artifactPath: destination, metadata: complete, releaseRoot };
@@ -16743,11 +17169,11 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
   if (options.versionCode !== undefined && (!Number.isSafeInteger(options.versionCode) || options.versionCode < 1 || options.versionCode > 2100000000)) {
     throw new TypeError("Android versionCode must be an integer from 1 through 2100000000.");
   }
-  const projectRoot = resolve37(options.projectRoot);
-  const host = options.host ?? detectAbsoluteMobileHost();
-  const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host);
-  const nativeDirectory = join47(options.config.nativeProjectDirectory, "android");
-  const manifest = requireManifest2(JSON.parse(await readFile15(join47(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
+  const projectRoot = resolve38(options.projectRoot);
+  const host2 = options.host ?? detectAbsoluteMobileHost();
+  const androidRoot = options.androidRoot ?? process.env.ANDROID_HOME ?? process.env.ANDROID_SDK_ROOT ?? absoluteManagedAndroidSdkRoot(host2);
+  const nativeDirectory = join48(options.config.nativeProjectDirectory, "android");
+  const manifest = requireManifest2(JSON.parse(await readFile15(join48(options.config.bundleDirectory, "absolute-mobile-manifest.json"), "utf8")));
   if (manifest.appId !== options.config.appId) {
     throw new TypeError("Embedded mobile manifest appId does not match mobile.appId.");
   }
@@ -16766,7 +17192,7 @@ var ABSOLUTE_ANDROID_RELEASE_FORMAT = 1, isRecord13 = (value) => typeof value ==
     project: {
       androidRoot,
       config: options.config,
-      host,
+      host: host2,
       nativeDirectory,
       projectRoot
     },
@@ -16871,7 +17297,7 @@ var init_iosConformance = __esm(() => {
 
 // src/mobile/releasePublisher.ts
 import { access as access10 } from "fs/promises";
-import { isAbsolute as isAbsolute8, relative as relative25, resolve as resolve38, sep as sep7 } from "path";
+import { isAbsolute as isAbsolute8, relative as relative25, resolve as resolve39, sep as sep7 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var prepareAbsoluteIosRelease = async (publisher, options) => {
   if (typeof publisher.prepareIosRelease !== "function") {
@@ -16893,8 +17319,8 @@ var prepareAbsoluteIosRelease = async (publisher, options) => {
   }
   return versionCode;
 }, isRecord14 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), isPublisher = (value) => isRecord14(value) && typeof value.publish === "function", publisherModulePath = (projectRoot, requested) => {
-  const root = resolve38(projectRoot);
-  const path = resolve38(root, requested);
+  const root = resolve39(projectRoot);
+  const path = resolve39(root, requested);
   const projectRelative = relative25(root, path);
   if (projectRelative === ".." || projectRelative.startsWith(`..${sep7}`) || isAbsolute8(projectRelative)) {
     throw new TypeError("mobile publish --registry must remain inside the project.");
@@ -16968,10 +17394,10 @@ __export(exports_mobile, {
   runMobile: () => runMobile
 });
 import { access as access11, mkdir as mkdir13, readFile as readFile17, writeFile as writeFile14 } from "fs/promises";
-import { join as join48, resolve as resolve39 } from "path";
+import { join as join49, resolve as resolve40 } from "path";
 import { createInterface } from "readline/promises";
 var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), CAPACITOR_PACKAGES, CAPACITOR_PACKAGE_SPECS, CAPACITOR_SYNC_PACKAGE_SPECS, packageNameFromSpec = (spec) => spec.slice(0, spec.lastIndexOf("@")), directProjectPackages = async (projectRoot) => {
-  const manifest = JSON.parse(await readFile17(join48(projectRoot, "package.json"), "utf8"));
+  const manifest = JSON.parse(await readFile17(join49(projectRoot, "package.json"), "utf8"));
   if (!isRecord15(manifest))
     throw new TypeError("Application package.json must contain an object.");
   const names = new Set;
@@ -17008,7 +17434,7 @@ var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value
   }
   return value;
 }, capacitorExecutable = async (projectRoot) => {
-  const executable = join48(projectRoot, "node_modules", ".bin", "cap");
+  const executable = join49(projectRoot, "node_modules", ".bin", "cap");
   try {
     await access11(executable);
     return executable;
@@ -17094,7 +17520,7 @@ var NOT_FOUND2 = -1, isRecord15 = (value) => typeof value === "object" && value
   await applyAbsoluteNativeBackgroundSync(projectRoot, mobile, platforms);
 }, associations = async (args) => {
   const { mobile, projectRoot } = await loadMobile(valueAfter(args, "--config"));
-  const outputDirectory = resolve39(projectRoot, valueAfter(args, "--outdir") ?? ".absolutejs/mobile/associations");
+  const outputDirectory = resolve40(projectRoot, valueAfter(args, "--outdir") ?? ".absolutejs/mobile/associations");
   if (args.includes("--verify")) {
     const result2 = await verifyAbsoluteMobileAssociationFiles(mobile);
     console.log(`Verified ${result2.results.length} hosted association files`);
@@ -17324,7 +17750,7 @@ Mobile release transport checks failed.`);
     const durationMs = Math.round(performance.now() - startedAt);
     console.log(`Built ${release.metadata.signed ? "signed" : "unsigned"} Android App Bundle in ${getDurationString(durationMs)}.`);
     console.log(`Artifact: ${release.artifactPath}`);
-    console.log(`Metadata: ${join48(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join49(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:android-release-build", {
@@ -17424,7 +17850,7 @@ Mobile release transport checks failed.`);
     const durationMs = Math.round(performance.now() - startedAt);
     console.log(`Built ${release.metadata.signed ? "signed" : "unsigned"} iOS IPA ${release.metadata.marketingVersion}${release.metadata.buildNumber ? ` (${release.metadata.buildNumber})` : ""} in ${getDurationString(durationMs)}.`);
     console.log(`Artifact: ${release.artifactPath}`);
-    console.log(`Metadata: ${join48(release.releaseRoot, "release.json")}`);
+    console.log(`Metadata: ${join49(release.releaseRoot, "release.json")}`);
     return release;
   } finally {
     sendTelemetryEvent("mobile:ios-release-build", {
@@ -17523,6 +17949,28 @@ Mobile release transport checks failed.`);
       }
     ];
   }
+}, appendSyncSchemaDoctorCheck = (checks, projectRoot) => {
+  if (!projectUsesAbsoluteSync(projectRoot))
+    return;
+  try {
+    const schema = discoverAbsoluteSyncSchema(projectRoot);
+    checks.push({
+      id: "sync.storage-schema",
+      label: `Offline schema ${schema.components.map((component2) => `${component2.id}@${component2.version}`).join(", ")}`,
+      path: join49(projectRoot, "package.json"),
+      platform: "host",
+      status: "pass"
+    });
+  } catch (error) {
+    checks.push({
+      id: "sync.storage-schema",
+      label: "Offline schema metadata is invalid",
+      path: join49(projectRoot, "package.json"),
+      platform: "host",
+      remediation: error instanceof Error ? error.message : String(error),
+      status: "fail"
+    });
+  }
 }, doctor = async (args) => {
   if (args.includes("release")) {
     await runReleaseDoctor(args);
@@ -17542,6 +17990,7 @@ Mobile release transport checks failed.`);
     return;
   }
   const checks = await inspectAbsoluteMobileToolchain();
+  appendSyncSchemaDoctorCheck(checks, process.cwd());
   const selected = platform6 ? checks.filter((check2) => check2.platform === "host" || check2.platform === platform6) : checks;
   if (args.includes("--json")) {
     if (args.includes("--fix")) {
@@ -17601,7 +18050,7 @@ Emulator setup verification:`);
     }
     return { https: args.includes("--https"), port };
   }
-  const instances = listLiveInstances().filter((instance2) => resolve39(instance2.cwd) === resolve39(projectRoot) && instance2.source === "dev" && instance2.port !== null);
+  const instances = listLiveInstances().filter((instance2) => resolve40(instance2.cwd) === resolve40(projectRoot) && instance2.source === "dev" && instance2.port !== null);
   if (instances.length !== 1) {
     throw new TypeError(instances.length === 0 ? "No running AbsoluteJS dev server was found for this project. Start `bun dev`, wait for Android to report ready, then run `absolute mobile test android`." : "Multiple dev servers are running for this project. Select one with mobile test android --port <port>.");
   }
@@ -17644,8 +18093,8 @@ Emulator setup verification:`);
   }
   return selected;
 }, safeArtifactRoot = (projectRoot, value) => {
-  const root = resolve39(projectRoot, value ?? ".absolutejs/mobile/test-artifacts");
-  if (root !== projectRoot && !root.startsWith(`${resolve39(projectRoot)}/`)) {
+  const root = resolve40(projectRoot, value ?? ".absolutejs/mobile/test-artifacts");
+  if (root !== projectRoot && !root.startsWith(`${resolve40(projectRoot)}/`)) {
     throw new TypeError("mobile test --artifacts must remain inside the project.");
   }
   return root;
@@ -17670,10 +18119,10 @@ Emulator setup verification:`);
   });
 }, writeAndroidFailureArtifacts = async (options) => {
   await mkdir13(options.artifactRoot, { recursive: true });
-  const screenshot = options.session ? await options.session.screenshot(join48(options.artifactRoot, "android-failure.png")).catch(() => {
+  const screenshot = options.session ? await options.session.screenshot(join49(options.artifactRoot, "android-failure.png")).catch(() => {
     return;
   }) : undefined;
-  const diagnosticPath = join48(options.artifactRoot, "android-failure.json");
+  const diagnosticPath = join49(options.artifactRoot, "android-failure.json");
   await writeFile14(diagnosticPath, `${JSON.stringify({
     diagnostics: options.session?.diagnostics ?? [],
     error: options.error instanceof Error ? options.error.message : String(options.error),
@@ -17764,14 +18213,14 @@ Emulator setup verification:`);
     const port = Number(explicit);
     if (!Number.isInteger(port) || port < 1 || port > 65535)
       throw new TypeError("mobile test --port must be a valid TCP port.");
-    const instance2 = listLiveInstances().find((candidate) => resolve39(candidate.cwd) === resolve39(projectRoot) && candidate.source === "dev" && candidate.port === port);
+    const instance2 = listLiveInstances().find((candidate) => resolve40(candidate.cwd) === resolve40(projectRoot) && candidate.source === "dev" && candidate.port === port);
     return {
       https: instance2?.https ?? args.includes("--https"),
       instance: instance2,
       port
     };
   }
-  const instances = listLiveInstances().filter((instance2) => resolve39(instance2.cwd) === resolve39(projectRoot) && instance2.source === "dev" && instance2.port !== null);
+  const instances = listLiveInstances().filter((instance2) => resolve40(instance2.cwd) === resolve40(projectRoot) && instance2.source === "dev" && instance2.port !== null);
   if (instances.length !== 1)
     throw new TypeError(instances.length === 0 ? "No running AbsoluteJS dev server was found for this project. Start `bun dev`, wait for iOS to report ready, then run `absolute mobile test ios`." : "Multiple dev servers are running for this project. Select one with mobile test ios --port <port>.");
   const [instance] = instances;
@@ -17851,7 +18300,7 @@ Emulator setup verification:`);
   return result;
 }, writeIosFailureArtifacts = async (options) => {
   await mkdir13(options.artifactRoot, { recursive: true });
-  const screenshot = join48(options.artifactRoot, "ios-failure.png");
+  const screenshot = join49(options.artifactRoot, "ios-failure.png");
   const screenshotResult = captureCommand4([
     options.xcrun,
     "simctl",
@@ -17860,7 +18309,7 @@ Emulator setup verification:`);
     "screenshot",
     screenshot
   ]);
-  const diagnosticPath = join48(options.artifactRoot, "ios-failure.json");
+  const diagnosticPath = join49(options.artifactRoot, "ios-failure.json");
   await writeFile14(diagnosticPath, `${JSON.stringify({
     appId: options.appId,
     error: options.error instanceof Error ? options.error.message : String(options.error),
@@ -17906,7 +18355,7 @@ Emulator setup verification:`);
     ], "iOS app launch");
     await waitForIosHmrClient({ https, port, timeoutMs });
     await mkdir13(artifactRoot, { recursive: true });
-    const screenshot = join48(artifactRoot, "ios-simulator.png");
+    const screenshot = join49(artifactRoot, "ios-simulator.png");
     requireCapturedIosCommand([xcrun, "simctl", "io", simulator.udid, "screenshot", screenshot], "iOS simulator screenshot");
     const hmrApply = await waitForRequestedIosHmr(args, instance, timeoutMs);
     const report = {
@@ -18030,6 +18479,7 @@ var init_mobile = __esm(() => {
   init_getDurationString();
   init_remoteMacProtocol();
   init_nativeAuth();
+  init_syncSchema();
   CAPACITOR_PACKAGES = [
     "@capacitor/core",
     "@capacitor/app",
@@ -18055,7 +18505,7 @@ var init_mobile = __esm(() => {
     "@absolutejs/devices-capacitor@0.1.3"
   ];
   CAPACITOR_SYNC_PACKAGE_SPECS = [
-    "@absolutejs/sync-capacitor@0.5.0",
+    "@absolutejs/sync-capacitor@0.7.0",
     "@capacitor-community/sqlite@8.1.1"
   ];
 });
@@ -18065,10 +18515,10 @@ var exports_typecheck = {};
 __export(exports_typecheck, {
   typecheck: () => typecheck
 });
-import { resolve as resolve40, join as join49 } from "path";
-import { existsSync as existsSync42, readFileSync as readFileSync38 } from "fs";
+import { resolve as resolve41, join as join50 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync39 } from "fs";
 import { mkdir as mkdir14, writeFile as writeFile15 } from "fs/promises";
-var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve40(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
+var isCommandService3 = (service) => service.kind === "command" || Array.isArray(service.command), resolveConfigPath = (configPath2) => resolve41(configPath2 ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts"), getTypecheckTargets = async (configPath2) => {
   if (!existsSync42(resolveConfigPath(configPath2))) {
     const defaultService = {};
     return [defaultService];
@@ -18090,7 +18540,7 @@ var isCommandService3 = (service) => service.kind === "command" || Array.isArray
   const exitCode = await proc.exited;
   return { exitCode, name, output: (stdout + stderr).trim() };
 }, shellEscape = (value) => `'${value.replaceAll("'", "'\\''")}'`, runShell = async (name, command) => run(name, ["/bin/bash", "-lc", command]), findBin = (name) => {
-  const local = resolve40("node_modules", ".bin", name);
+  const local = resolve41("node_modules", ".bin", name);
   return existsSync42(local) ? local : null;
 }, ANSI_COLOR_REGEX, ANSI_PURPLE_REGEX, ANSI_CYAN_REGEX, ANSI_TOKEN_END_REGEX, stripAnsi4 = (str) => str.replace(ANSI_COLOR_REGEX, ""), formatSvelteOutput = (output) => {
   const cwd = `${process.cwd()}/`;
@@ -18138,15 +18588,15 @@ Found ${errorCount} error${suffix}.`;
   return formatted;
 }, ABSOLUTE_INTERNAL_EXCLUDES, resolveAbsoluteTypeFile = (fileName) => {
   const candidates = [
-    resolve40("node_modules/@absolutejs/absolute/dist/types", fileName),
-    resolve40(import.meta.dir, "../types", fileName),
-    resolve40(import.meta.dir, "../../types", fileName),
-    resolve40(import.meta.dir, "../../../types", fileName)
+    resolve41("node_modules/@absolutejs/absolute/dist/types", fileName),
+    resolve41(import.meta.dir, "../types", fileName),
+    resolve41(import.meta.dir, "../../types", fileName),
+    resolve41(import.meta.dir, "../../../types", fileName)
   ];
   return candidates.find((candidate) => existsSync42(candidate)) ?? candidates[0];
 }, ABSOLUTE_TYPECHECK_FILES, readProjectTsconfig = () => {
   try {
-    return JSON.parse(readFileSync38(resolve40("tsconfig.json"), "utf-8"));
+    return JSON.parse(readFileSync39(resolve41("tsconfig.json"), "utf-8"));
   } catch {
     return {};
   }
@@ -18168,37 +18618,44 @@ Found ${errorCount} error${suffix}.`;
       ...excludes.map(toGeneratedConfigPath)
     ])
   ];
-}, buildVueTscCheck = (cacheDir) => {
+}, buildVueTscCheck = async (cacheDir) => {
   const vueTscBin = findBin("vue-tsc");
   if (!vueTscBin) {
     console.error("\x1B[31m\u2717\x1B[0m vue-tsc is required for Vue type checking. Install it: bun add -d vue-tsc");
     process.exit(1);
   }
-  const vueTsconfigPath = join49(cacheDir, "tsconfig.vue-check.json");
-  return writeFile15(vueTsconfigPath, JSON.stringify({
+  const vueTsconfigPath = join50(cacheDir, "tsconfig.vue-check.json");
+  await writeFile15(vueTsconfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve40("tsconfig.json"),
+    extends: resolve41("tsconfig.json"),
     include: getProjectTypecheckIncludes()
-  }, null, "\t")).then(() => run("vue-tsc", [
+  }, null, "\t"));
+  const base = [
     vueTscBin,
     "--noEmit",
     "--project",
-    resolve40(vueTsconfigPath),
+    resolve41(vueTsconfigPath),
+    "--pretty"
+  ];
+  const cached = await run("vue-tsc", [
+    ...base,
     "--incremental",
     "--tsBuildInfoFile",
-    join49(cacheDir, "vue-tsc.tsbuildinfo"),
-    "--pretty"
-  ]));
+    join50(cacheDir, "vue-tsc.tsbuildinfo")
+  ]);
+  if (cached.exitCode === 0 || cached.output.length > 0)
+    return cached;
+  return run("vue-tsc", base);
 }, buildAngularCheck = async (cacheDir, angularDir) => {
   const ngcBin = findBin("ngc");
   if (!ngcBin) {
     console.error("\x1B[31m\u2717\x1B[0m @angular/compiler-cli is required for Angular type checking. Install it: bun add -d @angular/compiler-cli");
     process.exit(1);
   }
-  const angularTsconfigPath = join49(cacheDir, "tsconfig.angular-check.json");
+  const angularTsconfigPath = join50(cacheDir, "tsconfig.angular-check.json");
   await writeFile15(angularTsconfigPath, JSON.stringify({
     angularCompilerOptions: {
       strictTemplates: true
@@ -18208,32 +18665,32 @@ Found ${errorCount} error${suffix}.`;
       rootDir: ".."
     },
     exclude: ABSOLUTE_INTERNAL_EXCLUDES.map(toGeneratedConfigPath),
-    extends: resolve40("tsconfig.json"),
+    extends: resolve41("tsconfig.json"),
     include: [`../${angularDir}/**/*`]
   }, null, "\t"));
-  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve40(angularTsconfigPath))}`);
+  return runShell("ngc", `${shellEscape(ngcBin)} -p ${shellEscape(resolve41(angularTsconfigPath))}`);
 }, buildTscCheck = (cacheDir) => {
   const tscBin = findBin("tsc");
   if (!tscBin) {
     console.error("\x1B[31m\u2717\x1B[0m typescript is required for type checking. Install it: bun add -d typescript");
     process.exit(1);
   }
-  const tscConfigPath = join49(cacheDir, "tsconfig.typecheck.json");
+  const tscConfigPath = join50(cacheDir, "tsconfig.typecheck.json");
   return writeFile15(tscConfigPath, JSON.stringify({
     compilerOptions: {
       rootDir: ".."
     },
     exclude: getProjectTypecheckExcludes(),
-    extends: resolve40("tsconfig.json"),
+    extends: resolve41("tsconfig.json"),
     include: getProjectTypecheckIncludes()
   }, null, "\t")).then(() => run("tsc", [
     tscBin,
     "--noEmit",
     "--project",
-    resolve40(tscConfigPath),
+    resolve41(tscConfigPath),
     "--incremental",
     "--tsBuildInfoFile",
-    join49(cacheDir, "tsc.tsbuildinfo"),
+    join50(cacheDir, "tsc.tsbuildinfo"),
     "--pretty"
   ]));
 }, buildSvelteCheck = async (cacheDir, svelteDir) => {
@@ -18242,16 +18699,16 @@ Found ${errorCount} error${suffix}.`;
     console.error("\x1B[31m\u2717\x1B[0m svelte-check is required for Svelte type checking. Install it: bun add -d svelte-check");
     process.exit(1);
   }
-  const svelteTsconfigPath = join49(cacheDir, "tsconfig.svelte-check.json");
+  const svelteTsconfigPath = join50(cacheDir, "tsconfig.svelte-check.json");
   await writeFile15(svelteTsconfigPath, JSON.stringify({
-    extends: resolve40("tsconfig.json"),
+    extends: resolve41("tsconfig.json"),
     files: ABSOLUTE_TYPECHECK_FILES,
     include: [`../${svelteDir}/**/*`]
   }, null, "\t"));
   return run("svelte-check", [
     svelteBin,
     "--tsconfig",
-    resolve40(svelteTsconfigPath),
+    resolve41(svelteTsconfigPath),
     "--threshold",
     "error",
     "--compiler-warnings",
@@ -18331,9 +18788,9 @@ var DEFAULT_RELAY_PORT = 8787, DEFAULT_REQUEST_TIMEOUT_MS = 30000, headersToObje
     if (options.publicUrl)
       return options.publicUrl.replace(/\/$/, "");
     const url = new URL(request.url);
-    const host = request.headers.get("x-forwarded-host") ?? url.host;
+    const host2 = request.headers.get("x-forwarded-host") ?? url.host;
     const proto = request.headers.get("x-forwarded-proto") ?? url.protocol.replace(":", "");
-    return `${proto}://${host}`;
+    return `${proto}://${host2}`;
   };
   const isWebSocketUpgrade = (request) => request.headers.get("upgrade")?.toLowerCase() === "websocket";
   const server = Bun.serve({
@@ -18445,11 +18902,11 @@ var DEFAULT_RELAY_PORT = 8787, DEFAULT_REQUEST_TIMEOUT_MS = 30000, headersToObje
         url: url.pathname + url.search,
         ...bodyBytes && bodyBytes.length > 0 ? { bodyBase64: Buffer.from(bodyBytes).toString("base64") } : {}
       };
-      const responsePromise = new Promise((resolve41) => {
-        pending.set(id, resolve41);
+      const responsePromise = new Promise((resolve42) => {
+        pending.set(id, resolve42);
       });
       client.send(encodeTunnelMessage(message));
-      const timeout = new Promise((resolve41) => setTimeout(() => resolve41({ id, message: "timeout", type: "error" }), requestTimeoutMs));
+      const timeout = new Promise((resolve42) => setTimeout(() => resolve42({ id, message: "timeout", type: "error" }), requestTimeoutMs));
       const result = await Promise.race([responsePromise, timeout]);
       pending.delete(id);
       if (result.type === "error") {
@@ -20701,12 +21158,12 @@ import {
   existsSync as existsSync12,
   mkdirSync as mkdirSync7,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync6
 } from "fs";
 import { createConnection } from "net";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 
 // src/cli/workspaceTui.ts
 init_constants();
@@ -21268,18 +21725,18 @@ var createWorkspaceTui = ({
 
 // src/cli/scripts/workspace.ts
 init_utils();
-var sourceServerBootstrap2 = resolve20(import.meta.dir, "../../dev/serverBootstrap.ts");
-var serverBootstrap2 = existsSync12(sourceServerBootstrap2) ? sourceServerBootstrap2 : resolve20(import.meta.dir, "../dev/serverBootstrap.js");
+var sourceServerBootstrap2 = resolve21(import.meta.dir, "../../dev/serverBootstrap.ts");
+var serverBootstrap2 = existsSync12(sourceServerBootstrap2) ? sourceServerBootstrap2 : resolve21(import.meta.dir, "../dev/serverBootstrap.js");
 var ANSI_REGEX2 = new RegExp(`${String.fromCharCode(ANSI_ESCAPE_CODE)}\\[[0-?]*[ -/]*[@-~]`, "g");
 var sleep = (durationMs) => Bun.sleep(durationMs);
 var stripAnsi3 = (value) => value.replace(ANSI_REGEX2, "");
 var sanitizeLogFileName = (value) => value.replace(/[^a-zA-Z0-9._-]/g, "_") || "unknown";
 var createWorkspaceLogSink = (appendLog) => {
-  const logDirectory = resolve20(".absolutejs", "workspace", "logs");
+  const logDirectory = resolve21(".absolutejs", "workspace", "logs");
   mkdirSync7(logDirectory, { recursive: true });
-  readdirSync2(logDirectory).filter((file) => file.endsWith(".log")).forEach((file) => unlinkSync3(resolve20(logDirectory, file)));
-  writeFileSync6(resolve20(logDirectory, "all.log"), "");
-  writeFileSync6(resolve20(logDirectory, "workspace.log"), "");
+  readdirSync2(logDirectory).filter((file) => file.endsWith(".log")).forEach((file) => unlinkSync3(resolve21(logDirectory, file)));
+  writeFileSync6(resolve21(logDirectory, "all.log"), "");
+  writeFileSync6(resolve21(logDirectory, "workspace.log"), "");
   const initializedSources = new Set(["workspace"]);
   const writeLog = (source, message, level) => {
     const cleanMessage = stripAnsi3(message).trimEnd();
@@ -21289,13 +21746,13 @@ var createWorkspaceLogSink = (appendLog) => {
     const timestamp = new Date().toISOString();
     const line = `[${timestamp}] [${level}] [${source}] ${cleanMessage}
 `;
-    const sourceFile = resolve20(logDirectory, `${sanitizeLogFileName(source)}.log`);
+    const sourceFile = resolve21(logDirectory, `${sanitizeLogFileName(source)}.log`);
     if (!initializedSources.has(source)) {
       writeFileSync6(sourceFile, "");
       initializedSources.add(source);
     }
     appendFileSync(sourceFile, line);
-    appendFileSync(resolve20(logDirectory, "all.log"), line);
+    appendFileSync(resolve21(logDirectory, "all.log"), line);
   };
   return {
     appendLog: (source, message, level = "info") => {
@@ -21307,7 +21764,7 @@ var createWorkspaceLogSink = (appendLog) => {
 };
 var readPackageVersion3 = (candidate) => {
   try {
-    const pkg = JSON.parse(readFileSync14(candidate, "utf-8"));
+    const pkg = JSON.parse(readFileSync15(candidate, "utf-8"));
     if (pkg.name !== "@absolutejs/absolute") {
       return null;
     }
@@ -21319,9 +21776,9 @@ var readPackageVersion3 = (candidate) => {
 };
 var resolvePackageVersion2 = () => {
   const candidates = [
-    resolve20(import.meta.dir, "..", "..", "package.json"),
-    resolve20(import.meta.dir, "..", "..", "..", "package.json"),
-    resolve20(import.meta.dir, "..", "..", "..", "..", "package.json")
+    resolve21(import.meta.dir, "..", "..", "package.json"),
+    resolve21(import.meta.dir, "..", "..", "..", "package.json"),
+    resolve21(import.meta.dir, "..", "..", "..", "..", "package.json")
   ];
   for (const candidate of candidates) {
     const version2 = readPackageVersion3(candidate);
@@ -21657,11 +22114,11 @@ var appendRemainingLogBuffer = (buffer, name, level, appendLog) => {
   appendLog(name, buffer, level);
 };
 var getServicePublicHost = (service) => {
-  const host = service.env?.HOST ?? process.env.HOST ?? "localhost";
-  if (host === "0.0.0.0" || host === "::") {
+  const host2 = service.env?.HOST ?? process.env.HOST ?? "localhost";
+  if (host2 === "0.0.0.0" || host2 === "::") {
     return "localhost";
   }
-  return host;
+  return host2;
 };
 var getServiceProtocol = (service) => service.env?.ABSOLUTE_HTTPS === "true" || process.env.ABSOLUTE_HTTPS === "true" ? "https" : "http";
 var createWorkspaceServiceEnv = (services) => {
@@ -21675,15 +22132,15 @@ var createWorkspaceServiceEnv = (services) => {
 var getDefinedProcessEnv = () => Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string"));
 var resolveAbsoluteServiceConfigPath = (service, cwd, options) => {
   if (service.config)
-    return resolve20(cwd, service.config);
+    return resolve21(cwd, service.config);
   if (options.configPath)
-    return resolve20(options.configPath);
+    return resolve21(options.configPath);
   if (process.env.ABSOLUTE_CONFIG)
-    return resolve20(process.env.ABSOLUTE_CONFIG);
+    return resolve21(process.env.ABSOLUTE_CONFIG);
   return;
 };
 var resolveService = (name, service, workspaceEnv, options) => {
-  const cwd = resolve20(service.cwd ?? ".");
+  const cwd = resolve21(service.cwd ?? ".");
   const envVars = Object.assign(getDefinedProcessEnv(), workspaceEnv, service.port ? { PORT: String(service.port) } : {}, service.env, {
     ABSOLUTE_INSTANCE_MANAGED: "1",
     ABSOLUTE_WORKSPACE_MANAGED: "1",
@@ -21695,7 +22152,7 @@ var resolveService = (name, service, workspaceEnv, options) => {
   if (isAbsoluteService(service)) {
     const configPath2 = resolveAbsoluteServiceConfigPath(service, cwd, options);
     Object.assign(envVars, configPath2 ? { ABSOLUTE_CONFIG: configPath2 } : {}, {
-      ABSOLUTE_SERVER_ENTRY: resolve20(cwd, service.entry ?? DEFAULT_SERVER_ENTRY)
+      ABSOLUTE_SERVER_ENTRY: resolve21(cwd, service.entry ?? DEFAULT_SERVER_ENTRY)
     });
     const command = [
       process.execPath,
@@ -21725,8 +22182,8 @@ var resolveService = (name, service, workspaceEnv, options) => {
 var resolveServiceBuildDirectory = (service) => {
   if (!isAbsoluteService(service))
     return null;
-  const cwd = resolve20(service.cwd ?? ".");
-  return resolve20(cwd, service.buildDirectory ?? "build");
+  const cwd = resolve21(service.cwd ?? ".");
+  return resolve21(cwd, service.buildDirectory ?? "build");
 };
 var findSharedWorkspaceBuildDirectories = (services) => {
   const byBuildDirectory = new Map;
@@ -21944,7 +22401,7 @@ var workspace = async (subcommand, options) => {
       frameworks: [],
       host: getServicePublicHost(resolved.service),
       https: getServiceProtocol(resolved.service) === "https",
-      logFile: resolve20(workspaceLogs.logDirectory, `${sanitizeLogFileName(name)}.log`),
+      logFile: resolve21(workspaceLogs.logDirectory, `${sanitizeLogFileName(name)}.log`),
       name,
       pid: processHandle.pid,
       port: resolved.service.port ?? null,