@absolutejs/absolute 0.20.0-beta.179 → 0.20.0-beta.180

package/dist/cli/index-evsnq0n2.js

@@ -0,0 +1,17 @@
+// @bun
+// src/utils/vueCompiler.ts
+var createVueCompiler = async () => {
+  const [compiler, typescript] = await Promise.all([
+    import("@vue/compiler-sfc"),
+    import("typescript")
+  ]);
+  compiler.registerTS?.(() => typescript);
+  return compiler;
+};
+var compilerPromise;
+var loadVueCompiler2 = () => {
+  compilerPromise ??= createVueCompiler();
+  return compilerPromise;
+};
+
+export { loadVueCompiler2 };

package/dist/cli/index-fxwf3n2v.js

@@ -0,0 +1,224 @@
+// @bun
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
+
+// src/react/staticAnalyzeSpaRoutes.ts
+import { existsSync, promises as fs } from "fs";
+import { join } from "path";
+var DYNAMIC_SEGMENT_PATTERN = /^[:*]/;
+var pathHasDynamic = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN.test(seg) || seg === "**");
+var readStringLiteral = (expression) => {
+  if (lazyTypescript.isStringLiteral(expression) || lazyTypescript.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  return null;
+};
+var readPropertyKey = (property) => {
+  if (lazyTypescript.isPropertyAssignment(property)) {
+    const { name } = property;
+    if (lazyTypescript.isIdentifier(name) || lazyTypescript.isStringLiteral(name))
+      return name.text;
+  }
+  if (lazyTypescript.isShorthandPropertyAssignment(property)) {
+    return property.name.text;
+  }
+  return null;
+};
+var importsSymbolFromAny = (sourceFile, localName, moduleSpecifiers) => {
+  for (const statement of sourceFile.statements) {
+    if (!lazyTypescript.isImportDeclaration(statement))
+      continue;
+    if (!lazyTypescript.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (!moduleSpecifiers.includes(statement.moduleSpecifier.text))
+      continue;
+    const named = statement.importClause?.namedBindings;
+    if (!named || !lazyTypescript.isNamedImports(named))
+      continue;
+    for (const element of named.elements) {
+      if (element.name.text === localName)
+        return true;
+    }
+  }
+  return false;
+};
+var findVariableArrayDeclaration = (sourceFile, identifierName) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (lazyTypescript.isVariableDeclaration(node) && lazyTypescript.isIdentifier(node.name) && node.name.text === identifierName && node.initializer && lazyTypescript.isArrayLiteralExpression(node.initializer)) {
+      found = node.initializer;
+      return;
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  lazyTypescript.forEachChild(sourceFile, visit);
+  return found;
+};
+var joinSegments = (parent, child) => {
+  if (!child)
+    return parent;
+  if (!parent)
+    return child;
+  return `${parent.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+};
+var extractRouteEntries = (routeArray, parentPath, routes) => {
+  for (const element of routeArray.elements) {
+    if (!lazyTypescript.isObjectLiteralExpression(element))
+      continue;
+    let pathSegment = null;
+    let redirected = false;
+    let sitemapExcluded = false;
+    let childrenLiteral = null;
+    let isIndex = false;
+    for (const property of element.properties) {
+      const key = readPropertyKey(property);
+      if (!key)
+        continue;
+      if (!lazyTypescript.isPropertyAssignment(property))
+        continue;
+      if (key === "path") {
+        pathSegment = readStringLiteral(property.initializer);
+      } else if (key === "index") {
+        isIndex = true;
+      } else if (key === "loader" || key === "lazy") {} else if (key === "children" && lazyTypescript.isArrayLiteralExpression(property.initializer)) {
+        childrenLiteral = property.initializer;
+      } else if (key === "redirectTo") {
+        redirected = true;
+      } else if (key === "handle" && lazyTypescript.isObjectLiteralExpression(property.initializer)) {
+        for (const handleProp of property.initializer.properties) {
+          const handleKey = readPropertyKey(handleProp);
+          if (handleKey !== "sitemap")
+            continue;
+          if (!lazyTypescript.isPropertyAssignment(handleProp))
+            continue;
+          const value = readStringLiteral(handleProp.initializer);
+          if (value === "exclude")
+            sitemapExcluded = true;
+        }
+      }
+    }
+    const segment = pathSegment ?? "";
+    const joined = joinSegments(parentPath, segment);
+    if (childrenLiteral) {
+      extractRouteEntries(childrenLiteral, joined, routes);
+      continue;
+    }
+    if (!isIndex && pathSegment === null)
+      continue;
+    if (joined === "")
+      continue;
+    routes.push({
+      dynamic: pathHasDynamic(joined),
+      path: joined,
+      redirected,
+      sitemapExcluded
+    });
+  }
+};
+var findCreateBrowserRouterCall = (sourceFile) => {
+  const result = { found: null };
+  const visit = (node) => {
+    if (result.found)
+      return;
+    if (lazyTypescript.isCallExpression(node) && lazyTypescript.isIdentifier(node.expression) && node.expression.text === "createBrowserRouter") {
+      result.found = node;
+      return;
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  lazyTypescript.forEachChild(sourceFile, visit);
+  return result.found;
+};
+var readBasenameFromOptions = (expression) => {
+  if (!expression || !lazyTypescript.isObjectLiteralExpression(expression))
+    return null;
+  for (const property of expression.properties) {
+    const key = readPropertyKey(property);
+    if (key !== "basename")
+      continue;
+    if (!lazyTypescript.isPropertyAssignment(property))
+      continue;
+    const value = readStringLiteral(property.initializer);
+    if (value !== null)
+      return value;
+  }
+  return null;
+};
+var analyzeReactSpaRouteFile = async (filePath) => {
+  let source;
+  try {
+    source = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  if (!source.includes("createBrowserRouter"))
+    return null;
+  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? lazyTypescript.ScriptKind.TSX : lazyTypescript.ScriptKind.TS);
+  if (!importsSymbolFromAny(sourceFile, "createBrowserRouter", [
+    "react-router-dom",
+    "react-router"
+  ])) {
+    return null;
+  }
+  const call = findCreateBrowserRouterCall(sourceFile);
+  if (!call)
+    return null;
+  const [routesArg] = call.arguments;
+  if (!routesArg)
+    return null;
+  let routesArray = null;
+  if (lazyTypescript.isArrayLiteralExpression(routesArg)) {
+    routesArray = routesArg;
+  } else if (lazyTypescript.isIdentifier(routesArg)) {
+    routesArray = findVariableArrayDeclaration(sourceFile, routesArg.text);
+  }
+  if (!routesArray)
+    return null;
+  const basename = readBasenameFromOptions(call.arguments[1]);
+  const baseHref = basename ? `${basename.replace(/\/+$/, "")}/` : "/";
+  const routes = [];
+  extractRouteEntries(routesArray, "", routes);
+  return { baseHref, routes, sourceFile: filePath };
+};
+var walkSourceFiles = async (dir, files) => {
+  let items;
+  try {
+    items = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const directories = [];
+  for (const item of items) {
+    if (item.name === "node_modules" || item.name.startsWith("."))
+      continue;
+    const full = join(dir, item.name);
+    if (item.isDirectory()) {
+      directories.push(full);
+    } else if (item.isFile() && (item.name.endsWith(".tsx") || item.name.endsWith(".ts") || item.name.endsWith(".jsx") || item.name.endsWith(".js")) && !item.name.endsWith(".d.ts")) {
+      files.push(full);
+    }
+  }
+  await Promise.all(directories.map((directory) => walkSourceFiles(directory, files)));
+};
+var analyzeReactSpaRoutes2 = async (reactDirectory) => {
+  if (!existsSync(reactDirectory))
+    return [];
+  const files = [];
+  await walkSourceFiles(reactDirectory, files);
+  const hosts = [];
+  await Promise.all(files.map(async (file) => {
+    try {
+      const host = await analyzeReactSpaRouteFile(file);
+      if (host)
+        hosts.push(host);
+    } catch (err) {
+      console.warn(`[sitemap] React SPA analysis failed for ${file}:`, err);
+    }
+  }));
+  return hosts;
+};
+
+export { analyzeReactSpaRoutes2 };

package/dist/cli/{index-zyd80s3h.js → index-js2hksgv.js}

@@ -1,295 +1,21 @@
 // @bun
+import {
+  normalizeAbsoluteMobileConfig2
+} from "./index-t7yf3vxs.js";
 import {
   lazyTypescript
 } from "./index-4j1twret.js";
 import {
-  normalizeAbsoluteMobileConfig2
-} from "./index-t7yf3vxs.js";
+  assertAbsoluteDeviceCapabilityPackages
+} from "./index-ycqdxy55.js";
 import {
-  assertAbsoluteDeviceCapabilityPackages,
   resolveAbsoluteMobileUpdateRuntime,
   writeAbsoluteExpoProject2,
   syncAbsoluteExpoWebAssets2
-} from "./index-cksezef8.js";
+} from "./index-0gd30trc.js";
 import {
   toPascal
-} from "./index-92g14j47.js";
-
-// src/build/islandRegistryTransform.ts
-import { basename } from "path";
-var VALID_FRAMEWORKS = [
-  "react",
-  "svelte",
-  "vue",
-  "angular"
-];
-var getObjectPropertyName = (name) => lazyTypescript.isIdentifier(name) || lazyTypescript.isStringLiteral(name) ? name.text : null;
-var isIslandRegistryHelperImport = (source) => source === "@absolutejs/absolute/islands" || source.endsWith("/islands") || source.endsWith("/core/islands");
-var collectRegistryFactory = (sourceFile) => {
-  const factoryNames = new Set;
-  const namespaceNames = new Set;
-  for (const statement of sourceFile.statements) {
-    if (!lazyTypescript.isImportDeclaration(statement))
-      continue;
-    if (!lazyTypescript.isStringLiteral(statement.moduleSpecifier))
-      continue;
-    if (!isIslandRegistryHelperImport(statement.moduleSpecifier.text))
-      continue;
-    const bindings = statement.importClause?.namedBindings;
-    if (!bindings)
-      continue;
-    if (lazyTypescript.isNamespaceImport(bindings)) {
-      namespaceNames.add(bindings.name.text);
-      continue;
-    }
-    if (!lazyTypescript.isNamedImports(bindings))
-      continue;
-    for (const element of bindings.elements) {
-      const imported = element.propertyName?.text ?? element.name.text;
-      if (imported === "defineIslandRegistry") {
-        factoryNames.add(element.name.text);
-      }
-    }
-  }
-  return { factoryNames, namespaceNames };
-};
-var isDefineIslandRegistryCall = (expression, factoryNames, namespaceNames) => {
-  if (lazyTypescript.isIdentifier(expression))
-    return factoryNames.has(expression.text);
-  return lazyTypescript.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && lazyTypescript.isIdentifier(expression.expression) && namespaceNames.has(expression.expression.text);
-};
-var findDefineIslandRegistryCall = (sourceFile, factoryNames, namespaceNames) => {
-  let found = null;
-  const visit = (node) => {
-    if (found)
-      return;
-    const [firstArg] = lazyTypescript.isCallExpression(node) ? node.arguments : [];
-    if (lazyTypescript.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, factoryNames, namespaceNames) && firstArg && lazyTypescript.isObjectLiteralExpression(firstArg)) {
-      found = node;
-      return;
-    }
-    lazyTypescript.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return found;
-};
-var quoteKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
-var definitionLiteral = (reference) => {
-  const exportPart = reference.export ? `, export: ${JSON.stringify(reference.export)}` : "";
-  return `{ component: null, source: ${JSON.stringify(reference.source)}${exportPart} }`;
-};
-var transformIslandRegistrySource = (source, filePath, info) => {
-  if (!source.includes("defineIslandRegistry"))
-    return null;
-  const scriptKind = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? lazyTypescript.ScriptKind.TSX : lazyTypescript.ScriptKind.TS;
-  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, scriptKind);
-  const { factoryNames, namespaceNames } = collectRegistryFactory(sourceFile);
-  if (factoryNames.size === 0 && namespaceNames.size === 0)
-    return null;
-  const call = findDefineIslandRegistryCall(sourceFile, factoryNames, namespaceNames);
-  if (!call)
-    return null;
-  const [objectLiteral] = call.arguments;
-  if (!objectLiteral || !lazyTypescript.isObjectLiteralExpression(objectLiteral)) {
-    return null;
-  }
-  const definitionLookup = new Map;
-  for (const definition of info.definitions) {
-    if (!definition.buildReference)
-      continue;
-    definitionLookup.set(`${definition.framework}:${definition.component}`, {
-      export: definition.buildReference.export,
-      source: definition.buildReference.source
-    });
-  }
-  const edits = [];
-  const replacedLocals = new Set;
-  for (const frameworkProperty of objectLiteral.properties) {
-    if (!lazyTypescript.isPropertyAssignment(frameworkProperty))
-      continue;
-    const frameworkName = getObjectPropertyName(frameworkProperty.name);
-    const framework = VALID_FRAMEWORKS.find((f) => f === frameworkName);
-    if (!framework)
-      continue;
-    if (!lazyTypescript.isObjectLiteralExpression(frameworkProperty.initializer))
-      continue;
-    for (const componentProperty of frameworkProperty.initializer.properties) {
-      let componentKey = null;
-      let localName = null;
-      let replaceNode = null;
-      let replacementText = "";
-      if (lazyTypescript.isShorthandPropertyAssignment(componentProperty)) {
-        componentKey = componentProperty.name.text;
-        localName = componentProperty.name.text;
-        const reference = definitionLookup.get(`${framework}:${componentKey}`);
-        if (!reference)
-          continue;
-        replaceNode = componentProperty;
-        replacementText = `${quoteKey(componentKey)}: ${definitionLiteral(reference)}`;
-      } else if (lazyTypescript.isPropertyAssignment(componentProperty) && lazyTypescript.isIdentifier(componentProperty.initializer)) {
-        componentKey = getObjectPropertyName(componentProperty.name);
-        localName = componentProperty.initializer.text;
-        if (!componentKey)
-          continue;
-        const reference = definitionLookup.get(`${framework}:${componentKey}`);
-        if (!reference)
-          continue;
-        replaceNode = componentProperty.initializer;
-        replacementText = definitionLiteral(reference);
-      } else {
-        continue;
-      }
-      edits.push({
-        end: replaceNode.getEnd(),
-        start: replaceNode.getStart(sourceFile),
-        text: replacementText
-      });
-      replacedLocals.add(localName);
-    }
-  }
-  if (edits.length === 0)
-    return null;
-  for (const statement of sourceFile.statements) {
-    if (!lazyTypescript.isImportDeclaration(statement))
-      continue;
-    const clause = statement.importClause;
-    if (!clause)
-      continue;
-    const localNames = [];
-    if (clause.name)
-      localNames.push(clause.name.text);
-    const bindings = clause.namedBindings;
-    if (bindings && lazyTypescript.isNamedImports(bindings)) {
-      for (const element of bindings.elements) {
-        localNames.push(element.name.text);
-      }
-    } else if (bindings && lazyTypescript.isNamespaceImport(bindings)) {
-      localNames.push(bindings.name.text);
-    }
-    if (localNames.length === 0)
-      continue;
-    if (localNames.every((name) => replacedLocals.has(name))) {
-      edits.push({
-        end: statement.getEnd(),
-        start: statement.getStart(sourceFile),
-        text: ""
-      });
-    }
-  }
-  edits.sort((a, b) => b.start - a.start);
-  let output = source;
-  for (const edit of edits) {
-    output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
-  }
-  return output;
-};
-var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var loaderForPath = (filePath) => {
-  if (filePath.endsWith(".tsx"))
-    return "tsx";
-  if (filePath.endsWith(".jsx"))
-    return "jsx";
-  if (filePath.endsWith(".js") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs")) {
-    return "js";
-  }
-  return "ts";
-};
-var createIslandRegistryDefinitionPlugin = (info) => {
-  const registryBase = basename(info.resolvedRegistryPath).replace(/\.[mc]?[jt]sx?$/, "");
-  const filter = new RegExp(`(^|[/\\\\])${escapeRegExp(registryBase)}\\.[mc]?[jt]sx?$`);
-  return {
-    name: "absolute-island-registry-definitions",
-    setup(build) {
-      build.onLoad({ filter }, async (args) => {
-        const source = await Bun.file(args.path).text();
-        const transformed = transformIslandRegistrySource(source, args.path, info);
-        if (transformed === null)
-          return;
-        return {
-          contents: transformed,
-          loader: loaderForPath(args.path)
-        };
-      });
-    }
-  };
-};
-
-// src/build/bunStringRawUnicodePlugin.ts
-import { extname } from "path";
-var NON_ASCII = /[^\x00-\x7f]/;
-var getScriptKind = (filePath) => {
-  if (/\.[cm]?tsx$/.test(filePath))
-    return lazyTypescript.ScriptKind.TSX;
-  if (/\.[cm]?jsx$/.test(filePath))
-    return lazyTypescript.ScriptKind.JSX;
-  if (/\.[cm]?ts$/.test(filePath))
-    return lazyTypescript.ScriptKind.TS;
-  return lazyTypescript.ScriptKind.JS;
-};
-var getLoader = (filePath) => {
-  const extension = extname(filePath);
-  if (extension === ".tsx")
-    return "tsx";
-  if (extension === ".jsx")
-    return "jsx";
-  if (extension === ".ts" || extension === ".mts" || extension === ".cts") {
-    return "ts";
-  }
-  return "js";
-};
-var isStringRawTag = (node) => lazyTypescript.isPropertyAccessExpression(node.tag) && lazyTypescript.isIdentifier(node.tag.expression) && node.tag.expression.text === "String" && node.tag.name.text === "raw";
-var getRawText = (node) => node.rawText ?? node.text;
-var rewriteBunStringRawUnicode = (source, filePath = "input.ts") => {
-  if (!source.includes("String.raw") || !NON_ASCII.test(source))
-    return source;
-  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, getScriptKind(filePath));
-  const replacements = [];
-  const visit = (node) => {
-    if (lazyTypescript.isTaggedTemplateExpression(node) && isStringRawTag(node)) {
-      const rawSegments = lazyTypescript.isNoSubstitutionTemplateLiteral(node.template) ? [getRawText(node.template)] : [
-        getRawText(node.template.head),
-        ...node.template.templateSpans.map((span) => getRawText(span.literal))
-      ];
-      if (rawSegments.some((segment) => NON_ASCII.test(segment))) {
-        const expressions = lazyTypescript.isTemplateExpression(node.template) ? node.template.templateSpans.map((span) => {
-          const expression = source.slice(span.expression.getStart(sourceFile), span.expression.end);
-          return rewriteBunStringRawUnicode(expression, filePath);
-        }) : [];
-        const args = [
-          `{ raw: [${rawSegments.map((text) => JSON.stringify(text)).join(", ")}] }`,
-          ...expressions
-        ];
-        replacements.push({
-          end: node.end,
-          start: node.getStart(sourceFile),
-          value: `String.raw(${args.join(", ")})`
-        });
-        return;
-      }
-    }
-    lazyTypescript.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  let result = source;
-  for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
-    result = result.slice(0, replacement.start) + replacement.value + result.slice(replacement.end);
-  }
-  return result;
-};
-var createBunStringRawUnicodePlugin = () => ({
-  name: "absolute-bun-string-raw-unicode",
-  setup(build) {
-    build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async (args) => {
-      if (args.path.includes("/node_modules/"))
-        return;
-      const source = await Bun.file(args.path).text();
-      const contents = rewriteBunStringRawUnicode(source, args.path);
-      if (contents === source)
-        return;
-      return { contents, loader: getLoader(args.path) };
-    });
-  }
-});
+} from "./index-dw44xa4x.js";
 
 // src/mobile/buildPipeline.ts
 import { readFile as readFile4 } from "fs/promises";
@@ -669,7 +395,7 @@ var verifyAbsoluteMobileCompatibilityProducer = async (release, maxProducerBytes
 // src/mobile/buildRelease.ts
 import { createHash as createHash3 } from "crypto";
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { basename as basename2, dirname, extname as extname2, join, relative, resolve } from "path";
+import { basename, dirname, extname, join, relative, resolve } from "path";
 
 // src/mobile/buildMetadata.ts
 var ABSOLUTE_MOBILE_ROUTE_DETAIL = "x-absolute-mobile";
@@ -705,7 +431,7 @@ var STATIC_SCRIPT_PATTERN = /(<script\b[^>]*?\bsrc\s*=\s*["'])(\/[^"']+\.(?:js|t
 var rewriteStaticScriptPaths = (source, manifest) => source.replace(STATIC_SCRIPT_PATTERN, (match, prefix, path, suffix) => {
   if (path.endsWith("/htmx.min.js"))
     return match;
-  const key = toPascal(basename2(path, extname2(path)));
+  const key = toPascal(basename(path, extname(path)));
   const builtPath = manifest[key];
   return builtPath ? `${prefix}${builtPath}${suffix}` : match;
 });
@@ -859,7 +585,7 @@ import {
   writeFile as writeFile2
 } from "fs/promises";
 import { existsSync } from "fs";
-import { basename as basename3, dirname as dirname2, extname as extname3, join as join2, relative as relative2, resolve as resolve2 } from "path";
+import { basename as basename2, dirname as dirname2, extname as extname2, join as join2, relative as relative2, resolve as resolve2 } from "path";
 
 // src/mobile/routeMatcher.ts
 var REGEXP_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
@@ -1127,14 +853,14 @@ var copyClientPage = async (page, buildDirectory, staging, copiedDependencies) =
   if (!CAPACITOR_CLIENT_FRAMEWORKS.has(page.framework)) {
     throw new TypeError(`Capacitor client rendering does not yet support ${page.framework} page ${page.pageId}.`);
   }
-  const extension = extname3(page.bundlePath) || ".js";
+  const extension = extname2(page.bundlePath) || ".js";
   const localBundlePath = `./pages/${page.bundleHash}${extension}`;
   const source = sourceAssetPath(buildDirectory, page.bundlePath);
   await copyFile(source, join2(staging, localBundlePath));
   await copyAbsoluteClientDependencies(source, buildDirectory, staging, copiedDependencies);
   let localStylePath;
   if (page.styleBundlePath && page.styleBundleHash) {
-    const styleExtension = extname3(page.styleBundlePath) || ".css";
+    const styleExtension = extname2(page.styleBundlePath) || ".css";
     localStylePath = `./styles/${page.styleBundleHash}${styleExtension}`;
     const styleSource = sourceAssetPath(buildDirectory, page.styleBundlePath);
     await mkdir2(dirname2(join2(staging, localStylePath)), {
@@ -1160,13 +886,13 @@ var materializeAbsoluteMobileSourcemaps = async (pages, appBuild, projectRoot) =
   const releaseRoot = join2(privateRoot, "mobile", release);
   const copied = [];
   const available = pages.flatMap((page) => {
-    const source = join2(privateRoot, `${basename3(page.bundlePath)}.map`);
+    const source = join2(privateRoot, `${basename2(page.bundlePath)}.map`);
     return existsSync(source) ? [{ page, source }] : [];
   });
   if (available.length > 0)
     await mkdir2(releaseRoot, { recursive: true });
   await Promise.all(available.map(async ({ page, source }) => {
-    const extension = extname3(page.bundlePath) || ".js";
+    const extension = extname2(page.bundlePath) || ".js";
     if (!/^\.[a-z0-9]+$/iu.test(extension))
       throw new TypeError("Mobile page extension is not a safe source-map key.");
     const bundleHash = safeLeaf(page.bundleHash, "Mobile page bundle hash");
@@ -1186,7 +912,7 @@ var materializeAbsoluteMobileSourcemaps = async (pages, appBuild, projectRoot) =
 };
 var absoluteClientImports = async (sourcePath, buildDirectory) => {
   const source = await readFile2(sourcePath, "utf8");
-  const extension = extname3(sourcePath).toLowerCase();
+  const extension = extname2(sourcePath).toLowerCase();
   let scriptLoader;
   if (extension === ".tsx")
     scriptLoader = "tsx";
@@ -1237,7 +963,7 @@ var materializeAbsoluteCapacitorWebBundle = async (options) => {
   }
   const destination = options.config.bundleDirectory;
   await mkdir2(dirname2(destination), { recursive: true });
-  const staging = await mkdtemp(join2(dirname2(destination), `.${basename3(destination)}.stage-`));
+  const staging = await mkdtemp(join2(dirname2(destination), `.${basename2(destination)}.stage-`));
   try {
     const pageDirectory = join2(staging, "pages");
     await mkdir2(pageDirectory, { recursive: true });
@@ -1567,7 +1293,7 @@ var finalizeAbsoluteMobileCompatibilityBuild = async (options) => {
 
 // src/mobile/routeMetadataTransform.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
-import { dirname as dirname4, extname as extname4, relative as relative3, resolve as resolve4 } from "path";
+import { dirname as dirname4, extname as extname3, relative as relative3, resolve as resolve4 } from "path";
 var ROUTE_METHODS = new Set(["get", "head"]);
 var SOURCE_FILTER = /\.[cm]?[jt]sx?$/;
 var PAGE_HANDLERS = new Map([
@@ -2079,7 +1805,7 @@ var createAbsoluteMobileRouteMetadataPlugin = (options) => {
         const source = await Bun.file(path).text();
         return {
           contents: transformFile(source, path, analysis),
-          loader: extname4(path).endsWith("x") ? "tsx" : "ts"
+          loader: extname3(path).endsWith("x") ? "tsx" : "ts"
         };
       });
     }
@@ -2154,14 +1880,14 @@ var collectOptionalPeers = (projectRoot) => {
     ...new Set(Object.keys(app?.dependencies ?? {}).flatMap((dependency) => Object.entries(readManifest(join5(projectRoot, "node_modules", dependency, "package.json"))?.peerDependenciesMeta ?? {}).filter(([, meta]) => meta.optional === true).map(([peer]) => peer)))
   ];
 };
-var escapeRegExp2 = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var createOptionalPeerPlugin = (projectRoot = process.cwd()) => ({
   name: "absolute-optional-peers",
   setup(build) {
     const peers = collectOptionalPeers(projectRoot);
     if (peers.length === 0)
       return;
-    const filter = new RegExp(`^(?:${peers.map(escapeRegExp2).join("|")})(?:/.*)?$`);
+    const filter = new RegExp(`^(?:${peers.map(escapeRegExp).join("|")})(?:/.*)?$`);
     build.onResolve({ filter }, (args) => {
       const from = args.importer ? dirname6(args.importer) : projectRoot;
       try {
@@ -2186,4 +1912,4 @@ var resolveServerBundleExternals = (buildConfig) => [
   ...collectUserServerExternals(buildConfig)
 ];
 
-export { createIslandRegistryDefinitionPlugin, createBunStringRawUnicodePlugin, resolveAbsoluteMobileRoute, ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION, ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT, finalizeAbsoluteMobileCompatibilityBuild, createAbsoluteMobileRouteMetadataPlugin, createElysiaOpenApiTypeboxPlugin, createOptionalPeerPlugin, resolveServerBundleExternals };
+export { resolveAbsoluteMobileRoute, ABSOLUTE_MOBILE_PAGE_PROTOCOL_VERSION, ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT, finalizeAbsoluteMobileCompatibilityBuild, createAbsoluteMobileRouteMetadataPlugin, createElysiaOpenApiTypeboxPlugin, createOptionalPeerPlugin, resolveServerBundleExternals };

package/dist/cli/{index-bp60baze.js → index-jyap0bhv.js}

@@ -345,4 +345,4 @@ var rewriteContentSpecifiers = (content, rewriter, options) => {
 };
 var rewriteSpecifiers = (masked, rewriter, options) => masked.replace(options.sweep ? rewriter.unionRegex : rewriter.mainRegex, replaceSpecifier(rewriter.lookup));
 
-export { maskLiterals, compileSpecifierRewriter, rewriteContentSpecifiers };
+export { SENTINEL, maskLiterals, compileSpecifierRewriter, rewriteContentSpecifiers };