@farm.js/core 0.1.0-beta.5 → 0.1.0-beta.7

package/dist/{chunk-A2LUXHD2.mjs → chunk-5VYHFKWE.mjs}

@@ -13,8 +13,9 @@ import {
   createFarmImageHandler
 } from "./chunk-3XNTL3FQ.mjs";
 import {
+  createEnvTypeDeclarations,
   generateEnvTypes
-} from "./chunk-BHG3LVHH.mjs";
+} from "./chunk-CGIXMLSY.mjs";
 import {
   writeFileIfChanged
 } from "./chunk-USWZZUEH.mjs";
@@ -23,6 +24,9 @@ import {
   isFarmNotFoundError,
   isFarmRedirectError
 } from "./chunk-7HO6AEOP.mjs";
+import {
+  resolveFarmAuthConfig
+} from "./chunk-I4CUBGVF.mjs";
 import {
   getFarmAppDirectories,
   getFarmLayerAliases,
@@ -43,17 +47,18 @@ import {
 import {
   resolveServerActionsConfig
 } from "./chunk-UB5UOSHB.mjs";
-import {
-  createMarkdownMirrorResponse,
-  resolveMarkdownConfig
-} from "./chunk-LLC7BNXW.mjs";
 import {
   createFarmMarkdownRouteModuleFromFile,
   createFarmMarkdownSourceResponse,
   isFarmMarkdownPageFile,
   loadFarmMdxComponents,
   resolveMdxConfig
-} from "./chunk-QGQX7SFC.mjs";
+} from "./chunk-ZVWA4ZQ3.mjs";
+import {
+  createMarkdownMirrorResponse,
+  resolveMarkdownConfig,
+  resolveMarkdownMirrorTarget
+} from "./chunk-7FBJLMQH.mjs";
 import {
   resolveWorkflowsConfig
 } from "./chunk-XIVV5IWN.mjs";
@@ -142,7 +147,7 @@ import {
 } from "./chunk-RHIFZZUI.mjs";
 import {
   FARM_VERSION
-} from "./chunk-EEABSBKK.mjs";
+} from "./chunk-6F5OI5GA.mjs";
 import {
   FARM_DEPLOYMENT_ID_HEADER,
   createFarmDeploymentCookie,
@@ -1206,8 +1211,56 @@ var _RouteManager = class _RouteManager {
       "**/{opengraph-image,twitter-image}.{ts,tsx,js,jsx,png,jpg,jpeg,gif,webp}",
       appDir
     );
+    const canonicalPageGroups = /* @__PURE__ */ new Map();
+    for (const file of pageFiles.filter((candidate) => parseRouteSlotFile(candidate) === null)) {
+      const route = parseRoutePath(file);
+      const pattern = this.createRoutePattern(route);
+      const group = canonicalPageGroups.get(pattern);
+      if (group) {
+        group.files.push(file);
+      } else {
+        canonicalPageGroups.set(pattern, {
+          route,
+          files: [file]
+        });
+      }
+    }
+    for (const [pattern, group] of canonicalPageGroups) {
+      const componentFiles = group.files.filter((file) => !isFarmMarkdownPageFile(file));
+      const markdownFiles = group.files.filter(isFarmMarkdownPageFile);
+      if (componentFiles.length > 1) {
+        throw new Error(
+          `Duplicate page route "${pattern}". Found ${componentFiles.map((file) => path3.join(appDir, file)).join(" and ")}.`
+        );
+      }
+      if (markdownFiles.length > 1) {
+        throw new Error(
+          `Duplicate markdown representation for page route "${pattern}". Found ${markdownFiles.map((file) => path3.join(appDir, file)).join(" and ")}.`
+        );
+      }
+      const componentFile = componentFiles[0];
+      const markdownFile = markdownFiles[0];
+      const primaryFile = componentFile || markdownFile;
+      if (!primaryFile) continue;
+      const modulePath = path3.join(appDir, primaryFile);
+      const existing = this.routes.get(pattern);
+      if (existing?.sourceRoot === source.root) {
+        throw new Error(
+          `Duplicate page route "${pattern}". Found both ${existing.modulePath} and ${modulePath}.`
+        );
+      }
+      this.routes.set(pattern, {
+        route: group.route,
+        modulePath,
+        ...markdownFile ? {
+          markdownSourcePath: path3.join(appDir, markdownFile)
+        } : {},
+        pattern,
+        source: "file",
+        sourceRoot: source.root
+      });
+    }
     for (const [kind, files, target] of [
-      ["page", pageFiles.filter((file) => parseRouteSlotFile(file) === null), this.routes],
       ["layout", layoutFiles, this.layouts],
       ["loading", loadingFiles, this.loadings],
       ["error", errorFiles, this.errors]
@@ -2490,6 +2543,15 @@ var _ServerRenderer = class _ServerRenderer {
         });
       });
     } catch (error) {
+      if (isWebResponse(error)) {
+        if (!res.headersSent && !res.writableEnded) {
+          await sendWebResponse(res, error);
+        } else if (!res.writableEnded) {
+          res.end();
+        }
+        completeRender(error.status, pathname);
+        return;
+      }
       if (isFarmRedirectError(error)) {
         const redirect = getFarmRedirectError(error);
         const snapshot = getFarmI18nClientSnapshot();
@@ -2790,7 +2852,7 @@ var _ServerRenderer = class _ServerRenderer {
     }
   }
   async renderWithSSR(element, req, res, clearMiddlewareData, options = {}) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const streamStartTime = Date.now();
       const observabilityRoute = options.observabilityRoute || req.__FARM_ROUTE__ || req.url || "/";
       const deploymentId = this.getDeploymentId();
@@ -2970,7 +3032,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
                 route: observabilityRoute,
                 durationMs: Date.now() - streamStartTime
               });
-              resolve4();
+              resolve5();
             }
           });
           res.write(shell);
@@ -2981,7 +3043,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
         },
         onShellError(error) {
           didError = true;
-          if (!isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
+          if (!isWebResponse(error) && !isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
             logger.error(`SSR shell error: ${error}`);
             emitFarmEvent({
               type: "render.error",
@@ -2996,7 +3058,7 @@ ${getFarmI18nClientSnapshot() ? `window.__FARM_I18N__ = ${serializeInlineValue(g
         },
         onError(error) {
           didError = true;
-          if (!isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
+          if (!isWebResponse(error) && !isFarmRedirectError(error) && !isFarmNotFoundError(error)) {
             logger.error(`SSR streaming error: ${error}`);
             emitFarmEvent({
               type: "render.error",
@@ -3209,6 +3271,7 @@ var _FarmApp = class _FarmApp {
       deploy: config.deploy || {},
       storage: config.storage || {},
       cache: config.cache || {},
+      auth: isResolvedAuthConfig(config.auth) ? config.auth : resolveFarmAuthConfig(config.auth),
       integrations: config.integrations || {},
       plugins: config.plugins || [],
       migrations: config.migrations || { commands: [] },
@@ -3281,6 +3344,12 @@ function isResolvedI18nConfig(value) {
   return Boolean(value && typeof value === "object" && "enabled" in value);
 }
 __name(isResolvedI18nConfig, "isResolvedI18nConfig");
+function isResolvedAuthConfig(value) {
+  return Boolean(
+    value && typeof value === "object" && "enabled" in value && "emailAndPassword" in value && "database" in value
+  );
+}
+__name(isResolvedAuthConfig, "isResolvedAuthConfig");
 function createFarmApp(config, viteServer) {
   return new FarmApp(config, viteServer);
 }
@@ -3616,8 +3685,8 @@ __name(_HMRManager, "HMRManager");
 var HMRManager = _HMRManager;
 
 // src/type-artifacts.ts
-import { mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync2, unlinkSync } from "fs";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
 
 // src/routing/generate-route-types.ts
 import * as path6 from "path";
@@ -3662,15 +3731,19 @@ function createRoutePattern(route) {
 __name(createRoutePattern, "createRoutePattern");
 var DEFAULT_OUT_FILE = "farm-routes.d.ts";
 async function generateRouteTypes(options) {
-  const {
-    root,
-    srcDir = "src",
-    outFile = DEFAULT_OUT_FILE,
-    extraRoutes = [],
-    suppressLintOnLink = false
-  } = options;
+  const root = path6.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path6.isAbsolute(outFile) ? outFile : path6.join(root, srcDir, outFile);
+  const content = await createRouteTypeDeclarations(options, outPath);
+  fs3.mkdirSync(path6.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+__name(generateRouteTypes, "generateRouteTypes");
+async function createRouteTypeDeclarations(options, outPath) {
+  const { root, srcDir = "src", extraRoutes = [], suppressLintOnLink = false } = options;
   const sourceRoots = options.sourceRoots ?? [{ name: "project", root, srcDir, layer: false }];
-  const outPath = path6.join(root, srcDir, outFile);
   const patterns = /* @__PURE__ */ new Set();
   const glob = await import("fast-glob");
   for (const source of sourceRoots) {
@@ -3703,18 +3776,19 @@ async function generateRouteTypes(options) {
   const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
   const routePathType = suppressLintOnLink ? "string" : typeLiterals.length ? typeLiterals.join(" | ") : "never";
   const routePatternType = suppressLintOnLink ? "string" : patternLiterals.length ? patternLiterals.join(" | ") : "never";
+  const routeTypesImportPath = `./${path6.basename(outPath).replace(/\.d\.ts$/, "")}`;
   const augmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
 
 declare module "@farm.js/core" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
   // Ensure root import ("@farm.js/core") uses the same typed Link signature as client entry.
   const Link: typeof import("@farm.js/core/client").Link;
@@ -3723,8 +3797,8 @@ declare module "@farm.js/core" {
 // Internal declaration path used by @farm.js/core root type re-exports.
 declare module "@farm.js/core/dist/client.js" {
   interface LinkDefaultRoute {
-    _: import("./farm-routes").RoutePath;
-    pattern: import("./farm-routes").RoutePattern;
+    _: import(${JSON.stringify(routeTypesImportPath)}).RoutePath;
+    pattern: import(${JSON.stringify(routeTypesImportPath)}).RoutePattern;
   }
 }
 `;
@@ -3736,11 +3810,9 @@ declare module "@farm.js/core/dist/client.js" {
 export type RoutePath = ${routePathType};
 export type RoutePattern = ${routePatternType};${augmentationBlock}
 `;
-  fs3.mkdirSync(path6.dirname(outPath), { recursive: true });
-  writeFileIfChanged(outPath, content);
-  return outPath;
+  return content;
 }
-__name(generateRouteTypes, "generateRouteTypes");
+__name(createRouteTypeDeclarations, "createRouteTypeDeclarations");
 
 // src/image-types.ts
 import { mkdirSync as mkdirSync2 } from "fs";
@@ -3777,11 +3849,11 @@ __name(createFarmImageTypeDeclarations, "createFarmImageTypeDeclarations");
 
 // src/i18n/type-generator.ts
 import { mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, join as join3, resolve } from "path";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
 async function generateFarmI18nTypes(options) {
   if (!options.config.enabled) return void 0;
   const { signatures } = await readFarmI18nCatalogs(options.config);
-  const outFile = options.outFile ? resolve(options.root, options.outFile) : join3(resolve(options.root), options.srcDir || "src", "farm-i18n.d.ts");
+  const outFile = options.outFile ? resolve2(options.root, options.outFile) : join3(resolve2(options.root), options.srcDir || "src", "farm-i18n.d.ts");
   const content = renderFarmI18nTypes(options.config.locales, signatures);
   mkdirSync3(dirname2(outFile), { recursive: true });
   writeFileIfChanged(outFile, content);
@@ -3831,7 +3903,7 @@ __name(argumentType, "argumentType");
 
 // src/type-artifacts.ts
 async function generateFarmTypeArtifacts(options) {
-  const root = resolve2(options.root);
+  const root = resolve3(options.root);
   const srcDir = options.srcDir || "src";
   const shouldGenerateRoutes = options.routes !== false;
   const shouldGenerateApi = options.api !== false;
@@ -3843,7 +3915,10 @@ async function generateFarmTypeArtifacts(options) {
   const result = {
     apiRoutes: []
   };
-  if (shouldGenerateRoutes) {
+  const unifiedTypesPath = join4(root, srcDir, "farm.d.ts");
+  const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
+  const unifiedSections = [];
+  if (shouldRefreshUnifiedTypes && !options.routeTypesOutFile) {
     const routeOptions = {
       root,
       srcDir,
@@ -3851,37 +3926,62 @@ async function generateFarmTypeArtifacts(options) {
       suppressLintOnLink: options.suppressLintOnLink,
       sourceRoots
     };
-    if (options.routeTypesOutFile) {
-      routeOptions.outFile = options.routeTypesOutFile;
-    }
-    result.routeTypesPath = await generateRouteTypes(routeOptions);
+    unifiedSections.push(await createRouteTypeDeclarations(routeOptions, unifiedTypesPath));
+    result.routeTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateRoutes) {
+    result.routeTypesPath = await generateRouteTypes({
+      root,
+      srcDir,
+      outFile: options.routeTypesOutFile,
+      extraRoutes: options.extraRoutes || [],
+      suppressLintOnLink: options.suppressLintOnLink,
+      sourceRoots
+    });
   }
   if (shouldGenerateApi) {
     const generator = new APITypeGenerator(appDirs);
     const apiRoutes = generator.scanAPIRoutes();
-    const apiTypesPath = options.apiTypesOutFile ? resolve2(root, options.apiTypesOutFile) : join4(root, srcDir, "lib", "api.generated.ts");
+    const apiTypesPath = options.apiTypesOutFile ? resolve3(root, options.apiTypesOutFile) : join4(root, srcDir, "lib", "api.generated.ts");
     const content = generator.generateAPIRouter(apiRoutes, { outFile: apiTypesPath });
     mkdirSync4(dirname3(apiTypesPath), { recursive: true });
     writeFileIfChanged(apiTypesPath, content);
     result.apiTypesPath = apiTypesPath;
     result.apiRoutes = apiRoutes;
   }
-  if (shouldGenerateEnv) {
+  if (shouldRefreshUnifiedTypes && !options.envTypesOutFile) {
+    unifiedSections.push(
+      createEnvTypeDeclarations(
+        {
+          root,
+          srcDir,
+          configPath: options.configPath,
+          layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
+        },
+        unifiedTypesPath
+      )
+    );
+    result.envTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateEnv) {
     result.envTypesPath = await generateEnvTypes({
       root,
       srcDir,
       outFile: options.envTypesOutFile,
+      configPath: options.configPath,
       layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
     });
   }
-  if (shouldGenerateImages) {
+  if (shouldGenerateImages && options.imageTypesOutFile) {
     result.imageTypesPath = generateFarmImageTypes({
       root,
       srcDir,
       outFile: options.imageTypesOutFile
     });
   }
-  if (shouldGenerateI18n && options.i18nConfig) {
+  if (shouldRefreshUnifiedTypes && options.i18nConfig?.enabled && !options.i18nTypesOutFile) {
+    const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
+    unifiedSections.push(renderFarmI18nTypes(options.i18nConfig.locales, signatures));
+    result.i18nTypesPath = unifiedTypesPath;
+  } else if (shouldGenerateI18n && options.i18nConfig) {
     result.i18nTypesPath = await generateFarmI18nTypes({
       root,
       srcDir,
@@ -3889,9 +3989,42 @@ async function generateFarmTypeArtifacts(options) {
       outFile: options.i18nTypesOutFile
     });
   }
+  if (shouldRefreshUnifiedTypes) {
+    mkdirSync4(dirname3(unifiedTypesPath), { recursive: true });
+    writeFileIfChanged(
+      unifiedTypesPath,
+      `/**
+ * Generated by Farm.js. Do not edit.
+ * Contains project-specific route, environment, and internationalization types.
+ */
+
+import "@farm.js/core/image";
+
+${unifiedSections.join("\n")}`
+    );
+    result.typesPath = unifiedTypesPath;
+    removeLegacyTypeArtifacts(root, srcDir);
+  }
   return result;
 }
 __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+var LEGACY_TYPE_ARTIFACTS = [
+  ["farm-routes.d.ts", "Auto-generated route types"],
+  ["farm-env.d.ts", "Auto-generated env types"],
+  ["farm-images.d.ts", "Generated by Farm.js"],
+  ["farm-i18n.d.ts", "Generated by Farm.js"]
+];
+function removeLegacyTypeArtifacts(root, srcDir) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = join4(root, srcDir, fileName);
+    if (!existsSync3(filePath)) continue;
+    const source = readFileSync2(filePath, "utf8");
+    if (source.includes(marker)) {
+      unlinkSync(filePath);
+    }
+  }
+}
+__name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
 
 // src/vite.ts
 import * as fs4 from "fs";
@@ -3971,7 +4104,7 @@ var ALL_TYPE_ARTIFACTS = {
   routes: true,
   api: true,
   env: true,
-  images: true,
+  images: false,
   i18n: true
 };
 var createEmptyTypeArtifactSelection = /* @__PURE__ */ __name(() => ({
@@ -4008,7 +4141,7 @@ function loadFarmWorkflowsDevRuntime() {
 }
 __name(loadFarmWorkflowsDevRuntime, "loadFarmWorkflowsDevRuntime");
 function loadFarmDevtoolsSnapshotRuntime() {
-  return import("./devtools-LVC3VB5P.mjs");
+  return import("./devtools-REQTS3I7.mjs");
 }
 __name(loadFarmDevtoolsSnapshotRuntime, "loadFarmDevtoolsSnapshotRuntime");
 function loadFarmDevtoolsUIRuntime() {
@@ -4756,12 +4889,13 @@ function farmPlugin(options = {}, initialPluginManager) {
             config: farmApp.getConfig().mdx,
             resolveSource: /* @__PURE__ */ __name(async (pathname2) => {
               const match = farmApp.getRouteManager().matchRoute(pathname2);
-              if (!match.route || !isFarmMarkdownPageFile(match.route.modulePath)) {
+              const sourcePath = match.route?.markdownSourcePath || (match.route && isFarmMarkdownPageFile(match.route.modulePath) ? match.route.modulePath : null);
+              if (!sourcePath) {
                 return null;
               }
               return {
-                source: await fs4.promises.readFile(match.route.modulePath, "utf8"),
-                filePath: match.route.modulePath
+                source: await fs4.promises.readFile(sourcePath, "utf8"),
+                filePath: sourcePath
               };
             }, "resolveSource")
           });
@@ -4782,16 +4916,37 @@ function farmPlugin(options = {}, initialPluginManager) {
             await sendWebResponse(res, markdownResponse);
             return;
           }
+          const markdownPageTarget = resolveMarkdownMirrorTarget(
+            farmApp.getConfig().md,
+            requestPathname,
+            {
+              accept: "text/markdown"
+            }
+          );
+          if (markdownPageTarget && farmApp.getRouteManager().matchRoute(markdownPageTarget.pathname).route) {
+            const vary = res.getHeader("Vary");
+            const varyValues = String(vary || "").split(",").map((value) => value.trim()).filter(Boolean);
+            if (!varyValues.some((value) => value.toLowerCase() === "accept")) {
+              res.setHeader("Vary", [...varyValues, "Accept"].join(", "));
+            }
+            const alternatePath = markdownPageTarget.pathname === "/" ? "/index.md" : `${markdownPageTarget.pathname}.md`;
+            const alternateLink = `<${alternatePath}>; rel="alternate"; type="text/markdown"`;
+            const currentLink = res.getHeader("Link");
+            res.setHeader(
+              "Link",
+              currentLink ? `${String(currentLink)}, ${alternateLink}` : alternateLink
+            );
+          }
           if (workflowHandler && (requestPathname === workflowConfig.route || requestPathname.startsWith(`${workflowConfig.route}/`))) {
             let workflowBody;
             if (requestMethod !== "GET" && requestMethod !== "HEAD") {
-              workflowBody = await new Promise((resolve4) => {
+              workflowBody = await new Promise((resolve5) => {
                 let data = "";
                 req.on("data", (chunk) => {
                   data += chunk;
                 });
                 req.on("end", () => {
-                  resolve4(data);
+                  resolve5(data);
                 });
               });
             }
@@ -4834,13 +4989,13 @@ function farmPlugin(options = {}, initialPluginManager) {
               }
               let body;
               if (req.method !== "GET" && req.method !== "HEAD") {
-                body = await new Promise((resolve4) => {
+                body = await new Promise((resolve5) => {
                   let data = "";
                   req.on("data", (chunk) => {
                     data += chunk;
                   });
                   req.on("end", () => {
-                    resolve4(data);
+                    resolve5(data);
                   });
                 });
               }
@@ -4946,13 +5101,13 @@ function farmPlugin(options = {}, initialPluginManager) {
                 }
                 let body;
                 if (req.method !== "GET" && req.method !== "HEAD") {
-                  body = await new Promise((resolve4) => {
+                  body = await new Promise((resolve5) => {
                     let data = "";
                     req.on("data", (chunk) => {
                       data += chunk;
                     });
                     req.on("end", () => {
-                      resolve4(data);
+                      resolve5(data);
                     });
                   });
                 }
@@ -5009,13 +5164,13 @@ function farmPlugin(options = {}, initialPluginManager) {
                 }
                 let body;
                 if (req.method !== "GET" && req.method !== "HEAD") {
-                  body = await new Promise((resolve4) => {
+                  body = await new Promise((resolve5) => {
                     let data = "";
                     req.on("data", (chunk) => {
                       data += chunk;
                     });
                     req.on("end", () => {
-                      resolve4(data);
+                      resolve5(data);
                     });
                   });
                 }
@@ -6879,6 +7034,7 @@ async function buildRouteComponentProps(pageModule, params, searchParams, path,
   const parsedSearch = parseClientRouteSchema(schemas?.search, searchParams, 'search');
 
   return {
+    ...(existingProps || {}),
     params: parsedParams,
     search: parsedSearch,
     searchParams: schemas ? Promise.resolve(parsedSearch) : parsedSearch,
@@ -7628,4 +7784,4 @@ export {
   farmPlugin,
   defineConfig
 };
-//# sourceMappingURL=chunk-A2LUXHD2.mjs.map
+//# sourceMappingURL=chunk-5VYHFKWE.mjs.map