astro 1.6.3 → 1.6.5

package/dist/@types/astro.d.ts

@@ -1289,6 +1289,7 @@ export interface PreviewServerParams {
     serverEntrypoint: URL;
     host: string | undefined;
     port: number;
+    base: string;
 }
 export declare type CreatePreviewServer = (params: PreviewServerParams) => PreviewServer | Promise<PreviewServer>;
 export interface PreviewModule {

package/dist/cli/index.js

@@ -2,8 +2,6 @@ import * as colors from "kleur/colors";
 import { pathToFileURL } from "url";
 import yargs from "yargs-parser";
 import { z } from "zod";
-import add from "../core/add/index.js";
-import build from "../core/build/index.js";
 import {
   createSettings,
   openConfig,
@@ -11,18 +9,15 @@ import {
   resolveFlags
 } from "../core/config/index.js";
 import { ASTRO_VERSION } from "../core/constants.js";
-import devServer from "../core/dev/index.js";
 import { collectErrorMetadata } from "../core/errors/dev/index.js";
 import { createSafeError } from "../core/errors/index.js";
 import { debug, error, info } from "../core/logger/core.js";
 import { enableVerboseLogging, nodeLogDestination } from "../core/logger/node.js";
 import { formatConfigErrorMessage, formatErrorMessage, printHelp } from "../core/messages.js";
-import preview from "../core/preview/index.js";
 import * as event from "../events/index.js";
 import { eventConfigError, eventError, telemetry } from "../events/index.js";
 import { check } from "./check/index.js";
 import { openInBrowser } from "./open.js";
-import * as telemetryHandler from "./telemetry.js";
 function printAstroHelp() {
   printHelp({
     commandName: "astro",
@@ -106,6 +101,7 @@ async function runCommand(cmd, flags) {
   }
   switch (cmd) {
     case "add": {
+      const { default: add } = await import("../core/add/index.js");
       telemetry.record(event.eventCliSession(cmd));
       const packages = flags._.slice(3);
       return await add(packages, { cwd: root, flags, logging, telemetry });
@@ -115,6 +111,7 @@ async function runCommand(cmd, flags) {
       return await openInBrowser("https://docs.astro.build/");
     }
     case "telemetry": {
+      const telemetryHandler = await import("./telemetry.js");
       const subcommand = (_a = flags._[3]) == null ? void 0 : _a.toString();
       return await telemetryHandler.update(subcommand, { flags, telemetry });
     }
@@ -134,6 +131,7 @@ async function runCommand(cmd, flags) {
   let settings = createSettings(initialAstroConfig, root);
   switch (cmd) {
     case "dev": {
+      const { default: devServer } = await import("../core/dev/index.js");
       const configFlag = resolveFlags(flags).config;
       const configFlagPath = configFlag ? await resolveConfigPath({ cwd: root, flags }) : void 0;
       await devServer(settings, {
@@ -150,6 +148,7 @@ async function runCommand(cmd, flags) {
       });
     }
     case "build": {
+      const { default: build } = await import("../core/build/index.js");
       return await build(settings, { ...flags, logging, telemetry });
     }
     case "check": {
@@ -157,6 +156,7 @@ async function runCommand(cmd, flags) {
       return process.exit(ret);
     }
     case "preview": {
+      const { default: preview } = await import("../core/preview/index.js");
       const server = await preview(settings, { logging, telemetry });
       return await server.closed();
     }

package/dist/core/add/babel.d.ts

@@ -9,4 +9,6 @@ export declare const visit: {
 };
 export { t };
 export declare function generate(ast: t.File): Promise<string>;
-export declare const parse: (code: string) => parser.ParseResult<t.File>;
+export declare const parse: (code: string) => t.File & {
+    errors: parser.ParseError[];
+};

package/dist/core/app/index.d.ts

@@ -9,6 +9,7 @@ export interface MatchOptions {
 export declare class App {
     #private;
     constructor(manifest: Manifest, streaming?: boolean);
+    removeBase(pathname: string): string;
     match(request: Request, { matchNotFound }?: MatchOptions): RouteData | undefined;
     render(request: Request, routeData?: RouteData): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, void, unknown>;

package/dist/core/app/index.js

@@ -20,13 +20,13 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-var _env, _manifest, _manifestData, _routeDataToRouteInfo, _encoder, _logging, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
+var _env, _manifest, _manifestData, _routeDataToRouteInfo, _encoder, _logging, _base, _baseWithoutTrailingSlash, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
 import mime from "mime";
 import { attachToResponse, getSetCookiesFromResponse } from "../cookies/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
 import { consoleLogDestination } from "../logger/console.js";
 import { error } from "../logger/core.js";
-import { joinPaths, prependForwardSlash } from "../path.js";
+import { joinPaths, prependForwardSlash, removeTrailingForwardSlash } from "../path.js";
 import {
   createEnvironment,
   createRenderContext,
@@ -54,6 +54,8 @@ class App {
       dest: consoleLogDestination,
       level: "info"
     });
+    __privateAdd(this, _base, void 0);
+    __privateAdd(this, _baseWithoutTrailingSlash, void 0);
     __privateSet(this, _manifest, manifest);
     __privateSet(this, _manifestData, {
       routes: manifest.routes.map((route) => route.routeData)
@@ -85,13 +87,22 @@ class App {
       ssr: true,
       streaming
     }));
+    __privateSet(this, _base, __privateGet(this, _manifest).base || "/");
+    __privateSet(this, _baseWithoutTrailingSlash, removeTrailingForwardSlash(__privateGet(this, _base)));
+  }
+  removeBase(pathname) {
+    if (pathname.startsWith(__privateGet(this, _base))) {
+      return pathname.slice(__privateGet(this, _baseWithoutTrailingSlash).length + 1);
+    }
+    return pathname;
   }
   match(request, { matchNotFound = false } = {}) {
     const url = new URL(request.url);
     if (__privateGet(this, _manifest).assets.has(url.pathname)) {
       return void 0;
     }
-    let routeData = matchRoute(url.pathname, __privateGet(this, _manifestData));
+    let pathname = "/" + this.removeBase(url.pathname);
+    let routeData = matchRoute(pathname, __privateGet(this, _manifestData));
     if (routeData) {
       return routeData;
     } else if (matchNotFound) {
@@ -149,11 +160,12 @@ _manifestData = new WeakMap();
 _routeDataToRouteInfo = new WeakMap();
 _encoder = new WeakMap();
 _logging = new WeakMap();
+_base = new WeakMap();
+_baseWithoutTrailingSlash = new WeakMap();
 _renderPage = new WeakSet();
 renderPage_fn = async function(request, routeData, mod, status = 200) {
   const url = new URL(request.url);
   const manifest = __privateGet(this, _manifest);
-  const renderers = manifest.renderers;
   const info = __privateGet(this, _routeDataToRouteInfo).get(routeData);
   const links = createLinkStylesheetElementSet(info.links, manifest.site);
   let scripts = /* @__PURE__ */ new Set();

package/dist/core/build/vite-plugin-ssr.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from "url";
 import { runHookBuildSsr } from "../../integrations/index.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../vite-plugin-scripts/index.js";
 import { pagesVirtualModuleId } from "../app/index.js";
+import { removeLeadingForwardSlash, removeTrailingForwardSlash } from "../path.js";
 import { serializeRouteData } from "../routing/index.js";
 import { addRollupInput } from "./add-rollup-input.js";
 import { eachPageData, sortedCSS } from "./internal.js";
@@ -112,9 +113,11 @@ function buildManifest(opts, internals, staticFiles) {
     if (settings.scripts.some((script) => script.stage === "page")) {
       scripts.push({ type: "external", value: entryModules[PAGE_SCRIPT_ID] });
     }
+    const bareBase = removeTrailingForwardSlash(removeLeadingForwardSlash(settings.config.base));
+    const links = sortedCSS(pageData).map((pth) => bareBase ? bareBase + "/" + pth : pth);
     routes.push({
       file: "",
-      links: sortedCSS(pageData),
+      links,
       scripts: [
         ...scripts,
         ...settings.scripts.filter((script) => script.stage === "head-inline").map(({ stage, content }) => ({ stage, children: content }))
@@ -137,7 +140,7 @@ function buildManifest(opts, internals, staticFiles) {
     pageMap: null,
     renderers: [],
     entryModules,
-    assets: staticFiles.map((s) => "/" + s)
+    assets: staticFiles.map((s) => settings.config.base + s)
   };
   return ssrManifest;
 }

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.6.3";
+const ASTRO_VERSION = "1.6.5";
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",

package/dist/core/create-vite.js

@@ -62,6 +62,7 @@ async function createVite(commandConfig, { settings, logging, mode, fs = nodeFs
     },
     plugins: [
       configAliasVitePlugin({ settings }),
+      astroLoadFallbackPlugin({ fs, settings }),
       astroVitePlugin({ settings, logging }),
       astroScriptsPlugin({ settings }),
       mode !== "build" && vitePluginAstroServer({ settings, logging, fs }),
@@ -71,8 +72,7 @@ async function createVite(commandConfig, { settings, logging, mode, fs = nodeFs
       jsxVitePlugin({ settings, logging }),
       astroPostprocessVitePlugin({ settings }),
       astroIntegrationsContainerPlugin({ settings, logging }),
-      astroScriptsPageSSRPlugin({ settings }),
-      astroLoadFallbackPlugin({ fs })
+      astroScriptsPageSSRPlugin({ settings })
     ],
     publicDir: fileURLToPath(settings.config.publicDir),
     root: fileURLToPath(settings.config.root),

package/dist/core/dev/dev.js

@@ -30,7 +30,7 @@ async function dev(settings, options) {
       isRestart: options.isRestart
     })
   );
-  const currentVersion = "1.6.3";
+  const currentVersion = "1.6.5";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/dev/index.d.ts

@@ -1,3 +1,3 @@
-export { createContainer, runInContainer, startContainer } from './container.js';
+export { createContainer, isStarted, runInContainer, startContainer } from './container.js';
 export { default } from './dev.js';
 export { createContainerWithAutomaticRestart } from './restart.js';

package/dist/core/dev/index.js

@@ -1,10 +1,11 @@
-import { createContainer, runInContainer, startContainer } from "./container.js";
+import { createContainer, isStarted, runInContainer, startContainer } from "./container.js";
 import { default as default2 } from "./dev.js";
 import { createContainerWithAutomaticRestart } from "./restart.js";
 export {
   createContainer,
   createContainerWithAutomaticRestart,
   default2 as default,
+  isStarted,
   runInContainer,
   startContainer
 };

package/dist/core/dev/restart.js

@@ -3,9 +3,8 @@ import { createSettings, openConfig } from "../config/index.js";
 import { createSafeError } from "../errors/index.js";
 import { info } from "../logger/core.js";
 import { createContainer, isStarted, startContainer } from "./container.js";
-async function createRestartedContainer(container, settings) {
+async function createRestartedContainer(container, settings, needsStart) {
   const { logging, fs, resolvedRoot, configFlag, configFlagPath } = container;
-  const needsStart = isStarted(container);
   const newContainer = await createContainer({
     isRestart: true,
     logging,
@@ -52,6 +51,7 @@ async function restartContainer({
   if (beforeRestart) {
     beforeRestart();
   }
+  const needsStart = isStarted(container);
   try {
     const newConfig = await openConfig({
       cwd: resolvedRoot,
@@ -66,7 +66,7 @@ async function restartContainer({
     const settings = createSettings(astroConfig, resolvedRoot);
     await close();
     return {
-      container: await createRestartedContainer(container, settings),
+      container: await createRestartedContainer(container, settings, needsStart),
       error: null
     };
   } catch (_err) {
@@ -75,7 +75,7 @@ async function restartContainer({
     await close();
     info(logging, "astro", "Continuing with previous valid configuration\n");
     return {
-      container: await createRestartedContainer(container, existingSettings),
+      container: await createRestartedContainer(container, existingSettings, needsStart),
       error
     };
   }

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   site,
   isRestart = false
 }) {
-  const version = "1.6.3";
+  const version = "1.6.5";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -255,7 +255,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.6.3"}`
+        `v${"1.6.5"}`
       )} ${headline}`
     );
   }

package/dist/core/preview/index.js

@@ -34,7 +34,8 @@ async function preview(_settings, { logging }) {
     client: settings.config.build.client,
     serverEntrypoint: new URL(settings.config.build.serverEntry, settings.config.build.server),
     host,
-    port
+    port,
+    base: settings.config.base
   });
   return server;
 }

package/dist/core/render/result.js

@@ -18,7 +18,7 @@ var __privateSet = (obj, member, value, setter) => {
 };
 var _cache, _result, _slots, _loggingOpts;
 import { bold } from "kleur/colors";
-import { renderSlot } from "../../runtime/server/index.js";
+import { renderSlot, stringifyChunk } from "../../runtime/server/index.js";
 import { renderJSX } from "../../runtime/server/jsx.js";
 import { AstroCookies } from "../cookies/index.js";
 import { warn } from "../logger/core.js";
@@ -102,12 +102,11 @@ Please update the name of this slot.`
         }
       }
     }
-    const content = await renderSlot(__privateGet(this, _result), __privateGet(this, _slots)[name]).then(
-      (res) => res != null ? String(res) : res
-    );
+    const content = await renderSlot(__privateGet(this, _result), __privateGet(this, _slots)[name]);
+    const outHTML = stringifyChunk(__privateGet(this, _result), content);
     if (cacheable)
-      __privateGet(this, _cache).set(name, content);
-    return content;
+      __privateGet(this, _cache).set(name, outHTML);
+    return outHTML;
   }
 }
 _cache = new WeakMap();

package/dist/runtime/server/render/common.d.ts

@@ -1,11 +1,12 @@
 import type { SSRResult } from '../../../@types/astro';
 import type { RenderInstruction } from './types.js';
 import { HTMLBytes } from '../escape.js';
+import { type SlotString } from './slot.js';
 export declare const Fragment: unique symbol;
 export declare const Renderer: unique symbol;
 export declare const encoder: TextEncoder;
 export declare const decoder: TextDecoder;
-export declare function stringifyChunk(result: SSRResult, chunk: string | RenderInstruction): any;
+export declare function stringifyChunk(result: SSRResult, chunk: string | SlotString | RenderInstruction): any;
 export declare class HTMLParts {
     parts: string;
     constructor();

package/dist/runtime/server/render/common.js

@@ -4,6 +4,7 @@ import {
   determinesIfNeedsDirectiveScript,
   getPrescripts
 } from "../scripts.js";
+import { isSlotString } from "./slot.js";
 const Fragment = Symbol.for("astro:fragment");
 const Renderer = Symbol.for("astro:renderer");
 const encoder = new TextEncoder();
@@ -23,6 +24,17 @@ function stringifyChunk(result, chunk) {
       }
     }
     default: {
+      if (isSlotString(chunk)) {
+        let out = "";
+        const c = chunk;
+        if (c.instructions) {
+          for (const instr of c.instructions) {
+            out += stringifyChunk(result, instr);
+          }
+        }
+        out += chunk.toString();
+        return out;
+      }
       return chunk.toString();
     }
   }

package/dist/runtime/server/render/slot.d.ts

@@ -1,10 +1,13 @@
 import type { SSRResult } from '../../../@types/astro.js';
 import type { RenderInstruction } from './types.js';
 import { HTMLString } from '../escape.js';
+declare const slotString: unique symbol;
 export declare class SlotString extends HTMLString {
     instructions: null | RenderInstruction[];
+    [slotString]: boolean;
     constructor(content: string, instructions: null | RenderInstruction[]);
 }
+export declare function isSlotString(str: string): str is any;
 export declare function renderSlot(_result: any, slotted: string, fallback?: any): Promise<string>;
 interface RenderSlotsResult {
     slotInstructions: null | RenderInstruction[];

package/dist/runtime/server/render/slot.js

@@ -1,11 +1,17 @@
 import { HTMLString, markHTMLString } from "../escape.js";
 import { renderChild } from "./any.js";
+const slotString = Symbol.for("astro:slot-string");
 class SlotString extends HTMLString {
   constructor(content, instructions) {
     super(content);
     this.instructions = instructions;
+    this[slotString] = true;
   }
 }
+slotString;
+function isSlotString(str) {
+  return !!str[slotString];
+}
 async function renderSlot(_result, slotted, fallback) {
   if (slotted) {
     let iterator = renderChild(slotted);
@@ -47,6 +53,7 @@ async function renderSlots(result, slots = {}) {
 }
 export {
   SlotString,
+  isSlotString,
   renderSlot,
   renderSlots
 };

package/dist/vite-plugin-astro/hmr.js

@@ -10,7 +10,7 @@ const isPkgFile = (id) => {
 };
 async function handleHotUpdate(ctx, { config, logging, compile }) {
   let isStyleOnlyChange = false;
-  if (ctx.file.endsWith(".astro")) {
+  if (ctx.file.endsWith(".astro") && isCached(config, ctx.file)) {
     const oldResult = await compile();
     invalidateCompilation(config, ctx.file);
     const newResult = await compile();

package/dist/vite-plugin-astro/index.js

@@ -26,7 +26,7 @@ function astro({ settings, logging }) {
   }
   let resolvedConfig;
   const srcRootWeb = config.srcDir.pathname.slice(config.root.pathname.length - 1);
-  const isBrowserPath = (path) => path.startsWith(srcRootWeb);
+  const isBrowserPath = (path) => path.startsWith(srcRootWeb) && srcRootWeb !== "/";
   const isFullFilePath = (path) => path.startsWith(prependForwardSlash(slash(fileURLToPath(config.root))));
   function resolveRelativeFromAstroParent(id, parsedFrom) {
     const filename = normalizeFilename(parsedFrom.filename);

package/dist/vite-plugin-env/index.js

@@ -11,27 +11,24 @@ function getPrivateEnv(viteConfig, astroConfig) {
     viteConfig.envDir ?? fileURLToPath(astroConfig.root),
     ""
   );
-  const privateKeys = Object.keys(fullEnv).filter((key) => {
-    for (const envPrefix of envPrefixes) {
-      if (key.startsWith(envPrefix))
-        return false;
+  const privateEnv = {};
+  for (const key in fullEnv) {
+    if (envPrefixes.every((prefix) => !key.startsWith(prefix))) {
+      if (typeof process.env[key] !== "undefined") {
+        privateEnv[key] = `process.env.${key}`;
+      } else {
+        privateEnv[key] = JSON.stringify(fullEnv[key]);
+      }
     }
-    return true;
-  });
-  if (privateKeys.length === 0) {
-    return null;
   }
-  return Object.fromEntries(
-    privateKeys.map((key) => {
-      if (typeof process.env[key] !== "undefined")
-        return [key, `process.env.${key}`];
-      return [key, JSON.stringify(fullEnv[key])];
-    })
-  );
+  privateEnv.SITE = astroConfig.site ? `'${astroConfig.site}'` : "undefined";
+  privateEnv.SSR = JSON.stringify(true);
+  privateEnv.BASE_URL = astroConfig.base ? `'${astroConfig.base}'` : "undefined";
+  return privateEnv;
 }
 function getReferencedPrivateKeys(source, privateEnv) {
   const references = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(privateEnv)) {
+  for (const key in privateEnv) {
     if (source.includes(key)) {
       references.add(key);
     }
@@ -40,73 +37,52 @@ function getReferencedPrivateKeys(source, privateEnv) {
 }
 function envVitePlugin({ settings }) {
   let privateEnv;
-  let config;
-  let replacements;
-  let pattern;
+  let viteConfig;
   const { config: astroConfig } = settings;
   return {
     name: "astro:vite-plugin-env",
     enforce: "pre",
     configResolved(resolvedConfig) {
-      config = resolvedConfig;
+      viteConfig = resolvedConfig;
     },
     async transform(source, id, options) {
-      const ssr = (options == null ? void 0 : options.ssr) === true;
-      if (!ssr) {
+      if (!(options == null ? void 0 : options.ssr) || !source.includes("import.meta.env")) {
         return;
       }
-      if (!source.includes("import.meta") || !/\benv\b/.test(source)) {
-        return;
-      }
-      if (typeof privateEnv === "undefined") {
-        privateEnv = getPrivateEnv(config, astroConfig);
-        if (privateEnv) {
-          privateEnv.SITE = astroConfig.site ? `'${astroConfig.site}'` : "undefined";
-          privateEnv.SSR = JSON.stringify(true);
-          privateEnv.BASE_URL = astroConfig.base ? `'${astroConfig.base}'` : void 0;
-          const entries = Object.entries(privateEnv).map(([key, value]) => [
-            `import.meta.env.${key}`,
-            value
-          ]);
-          replacements = Object.fromEntries(entries);
-          replacements = Object.assign(replacements, {
-            "import.meta.env.SITE": astroConfig.site ? `'${astroConfig.site}'` : "undefined",
-            "import.meta.env.SSR": JSON.stringify(true),
-            "import.meta.env.BASE_URL": astroConfig.base ? `'${astroConfig.base}'` : void 0,
-            "import.meta.env": `({})`
-          });
-          pattern = new RegExp(
-            "(?<!(?<!\\.\\.)\\.)\\b(" + Object.keys(replacements).map((str) => {
-              return str.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
-            }).join("|") + ")\\b(?!\\s*?=[^=])",
-            "g"
-          );
-        }
-      }
-      if (!privateEnv || !pattern)
-        return;
-      const references = getReferencedPrivateKeys(source, privateEnv);
-      if (references.size === 0)
-        return;
-      const s = new MagicString(source);
+      let s;
+      const pattern = new RegExp(
+        `(?<!(?<!\\.\\.)\\.)\\b(import\\.meta\\.env\\.(.+?)|import\\.meta\\.env)\\b(?!\\s*?=[^=])`,
+        "g"
+      );
+      let references;
       let match;
       while (match = pattern.exec(source)) {
-        const start = match.index;
-        const end = start + match[0].length;
-        let replacement = "" + replacements[match[1]];
+        let replacement;
         if (match[0] === "import.meta.env") {
+          privateEnv ?? (privateEnv = getPrivateEnv(viteConfig, astroConfig));
+          references ?? (references = getReferencedPrivateKeys(source, privateEnv));
           replacement = `(Object.assign(import.meta.env,{`;
           for (const key of references.values()) {
             replacement += `${key}:${privateEnv[key]},`;
           }
           replacement += "}))";
+        } else if (match[2]) {
+          privateEnv ?? (privateEnv = getPrivateEnv(viteConfig, astroConfig));
+          replacement = privateEnv[match[2]];
         }
-        s.overwrite(start, end, replacement);
+        if (replacement) {
+          const start = match.index;
+          const end = start + match[0].length;
+          s ?? (s = new MagicString(source));
+          s.overwrite(start, end, replacement);
+        }
+      }
+      if (s) {
+        return {
+          code: s.toString(),
+          map: s.generateMap()
+        };
       }
-      return {
-        code: s.toString(),
-        map: s.generateMap()
-      };
     }
   };
 }

package/dist/vite-plugin-load-fallback/index.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 import nodeFs from 'fs';
 import type * as vite from 'vite';
+import type { AstroSettings } from '../@types/astro';
 declare type NodeFileSystemModule = typeof nodeFs;
 export interface LoadFallbackPluginParams {
     fs?: NodeFileSystemModule;
+    settings: AstroSettings;
 }
-export default function loadFallbackPlugin({ fs }: LoadFallbackPluginParams): vite.Plugin | false;
+export default function loadFallbackPlugin({ fs, settings, }: LoadFallbackPluginParams): vite.Plugin[] | false;
 export {};

package/dist/vite-plugin-load-fallback/index.js

@@ -1,22 +1,55 @@
 import nodeFs from "fs";
-function loadFallbackPlugin({ fs }) {
+import npath from "path";
+function loadFallbackPlugin({
+  fs,
+  settings
+}) {
   if (!fs || fs === nodeFs) {
     return false;
   }
-  return {
-    name: "astro:load-fallback",
-    enforce: "post",
-    async load(id) {
+  const tryLoadModule = async (id) => {
+    try {
+      return await fs.promises.readFile(cleanUrl(id), "utf-8");
+    } catch (e) {
       try {
-        return await fs.promises.readFile(cleanUrl(id), "utf-8");
-      } catch (e) {
+        return await fs.promises.readFile(id, "utf-8");
+      } catch (e2) {
         try {
-          return await fs.promises.readFile(id, "utf-8");
-        } catch (e2) {
+          const fullpath = new URL("." + id, settings.config.root);
+          return await fs.promises.readFile(fullpath, "utf-8");
+        } catch (e3) {
         }
       }
     }
   };
+  return [
+    {
+      name: "astro:load-fallback",
+      enforce: "post",
+      resolveId(id, parent) {
+        if (id.startsWith(".") && parent && fs.existsSync(parent)) {
+          return npath.posix.join(npath.posix.dirname(parent), id);
+        }
+      },
+      async load(id) {
+        const source = await tryLoadModule(id);
+        return source;
+      }
+    },
+    {
+      name: "astro:load-fallback-hmr",
+      enforce: "pre",
+      handleHotUpdate(context) {
+        const read = context.read;
+        context.read = async () => {
+          const source = await tryLoadModule(context.file);
+          if (source)
+            return source;
+          return read.call(context);
+        };
+      }
+    }
+  ];
 }
 const queryRE = /\?.*$/s;
 const hashRE = /#.*$/s;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",