astro 4.13.4 → 4.14.1

package/dist/core/dev/restart.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from "node:url";
 import * as vite from "vite";
+import { globalContentLayer } from "../../content/content-layer.js";
 import { eventCliSession, telemetry } from "../../events/index.js";
 import { createNodeLogger, createSettings, resolveConfig } from "../config/index.js";
 import { collectErrorMetadata } from "../errors/dev/utils.js";
@@ -20,16 +21,18 @@ async function createRestartedContainer(container, settings) {
   return newContainer;
 }
 const configRE = /.*astro.config.(?:mjs|cjs|js|ts)$/;
-const preferencesRE = /.*\.astro\/settings.json$/;
 function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, changedFile) {
   if (restartInFlight) return false;
   let shouldRestart = false;
+  const normalizedChangedFile = vite.normalizePath(changedFile);
   if (inlineConfig.configFile) {
-    shouldRestart = vite.normalizePath(inlineConfig.configFile) === vite.normalizePath(changedFile);
+    shouldRestart = vite.normalizePath(inlineConfig.configFile) === normalizedChangedFile;
   } else {
-    const normalizedChangedFile = vite.normalizePath(changedFile);
     shouldRestart = configRE.test(normalizedChangedFile);
-    if (preferencesRE.test(normalizedChangedFile)) {
+    const settingsPath = vite.normalizePath(
+      fileURLToPath(new URL("settings.json", settings.dotAstroDir))
+    );
+    if (settingsPath.endsWith(normalizedChangedFile)) {
       shouldRestart = settings.preferences.ignoreNextPreferenceReload ? false : true;
       settings.preferences.ignoreNextPreferenceReload = false;
     }
@@ -116,13 +119,25 @@ async function createContainerWithAutomaticRestart({
     watcher.on("unlink", handleChangeRestart("Configuration file removed."));
     watcher.on("add", handleChangeRestart("Configuration file added."));
     restart.container.viteServer.restart = () => handleServerRestart();
+    const customShortcuts = [
+      // Disable default Vite shortcuts that don't work well with Astro
+      { key: "r", description: "" },
+      { key: "u", description: "" },
+      { key: "c", description: "" }
+    ];
+    if (restart.container.settings.config.experimental.contentLayer) {
+      customShortcuts.push({
+        key: "s",
+        description: "sync content layer",
+        action: () => {
+          if (globalContentLayer.initialized()) {
+            globalContentLayer.get().sync();
+          }
+        }
+      });
+    }
     restart.container.viteServer.bindCLIShortcuts({
-      customShortcuts: [
-        // Disable Vite's builtin "r" (restart server), "u" (print server urls) and "c" (clear console) shortcuts
-        { key: "r", description: "" },
-        { key: "u", description: "" },
-        { key: "c", description: "" }
-      ]
+      customShortcuts
     });
   }
   setupContainer();

package/dist/core/errors/errors-data.d.ts

@@ -1151,6 +1151,16 @@ export declare const RewriteWithBodyUsed: {
     title: string;
     message: string;
 };
+/**
+ * @docs
+ * @description
+ * An unknown error occurred while reading or writing files to disk. It can be caused by many things, eg. missing permissions or a file not existing we attempt to read.
+ */
+export declare const UnknownFilesystemError: {
+    name: string;
+    title: string;
+    hint: string;
+};
 /**
  * @docs
  * @kind heading
@@ -1320,6 +1330,17 @@ export declare const UnknownContentCollectionError: {
     name: string;
     title: string;
 };
+/**
+ * @docs
+ * @description
+ * The `getDataEntryById` and `getEntryBySlug` functions are deprecated and cannot be used with content layer collections. Use the `getEntry` function instead.
+ */
+export declare const GetEntryDeprecationError: {
+    name: string;
+    title: string;
+    message: (collection: string, method: string) => string;
+    hint: string;
+};
 /**
  * @docs
  * @message

package/dist/core/errors/errors-data.js

@@ -419,6 +419,11 @@ const RewriteWithBodyUsed = {
   title: "Cannot use Astro.rewrite after the request body has been read",
   message: "Astro.rewrite() cannot be used if the request body has already been read. If you need to read the body, first clone the request."
 };
+const UnknownFilesystemError = {
+  name: "UnknownFilesystemError",
+  title: "An unknown error occurred while reading or writing files to disk.",
+  hint: "It can be caused by many things, eg. missing permissions or a file not existing we attempt to read. Check the error cause for more details."
+};
 const UnknownCSSError = {
   name: "UnknownCSSError",
   title: "Unknown CSS Error."
@@ -476,6 +481,12 @@ const UnknownContentCollectionError = {
   name: "UnknownContentCollectionError",
   title: "Unknown Content Collection Error."
 };
+const GetEntryDeprecationError = {
+  name: "GetEntryDeprecationError",
+  title: "Invalid use of `getDataEntryById` or `getEntryBySlug` function.",
+  message: (collection, method) => `The \`${method}\` function is deprecated and cannot be used to query the "${collection}" collection. Use \`getEntry\` instead.`,
+  hint: "Use the `getEntry` or `getCollection` functions to query content layer collections."
+};
 const InvalidContentEntryFrontmatterError = {
   name: "InvalidContentEntryFrontmatterError",
   title: "Content entry frontmatter does not match schema.",
@@ -602,6 +613,7 @@ export {
   FailedToFindPageMapSSR,
   FailedToLoadModuleSSR,
   GenerateContentTypesError,
+  GetEntryDeprecationError,
   GetStaticPathsExpectedParams,
   GetStaticPathsInvalidRouteParam,
   GetStaticPathsRemovedRSSHelper,
@@ -664,6 +676,7 @@ export {
   UnknownConfigError,
   UnknownContentCollectionError,
   UnknownError,
+  UnknownFilesystemError,
   UnknownMarkdownError,
   UnknownViteError,
   UnsupportedConfigTransformError,

package/dist/core/index.js

@@ -3,7 +3,7 @@ import { default as _sync } from "./sync/index.js";
 import { default as default2 } from "./dev/index.js";
 import { default as default3 } from "./preview/index.js";
 const build = (inlineConfig) => _build(inlineConfig);
-const sync = (inlineConfig) => _sync({ inlineConfig });
+const sync = (inlineConfig) => _sync(inlineConfig);
 export {
   build,
   default2 as dev,

package/dist/core/logger/vite.js

@@ -1,4 +1,4 @@
-import { fileURLToPath } from "url";
+import { fileURLToPath } from "node:url";
 import stripAnsi from "strip-ansi";
 import { isAstroError } from "../errors/errors.js";
 import { serverShortcuts as formatServerShortcuts } from "../messages.js";

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "4.13.4";
+  const version = "4.14.1";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -270,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"4.13.4"}`
+        `v${"4.14.1"}`
       )} ${headline}`
     );
   }

package/dist/core/preview/static-preview-server.js

@@ -1,5 +1,5 @@
+import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
-import { performance } from "perf_hooks";
 import { preview } from "vite";
 import * as msg from "../messages.js";
 import { getResolvedHostForHttpServer } from "./util.js";

package/dist/core/routing/manifest/create.js

@@ -1,5 +1,5 @@
-import { createRequire } from "module";
 import nodeFs from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { bold } from "kleur/colors";

package/dist/core/sync/constants.d.ts

@@ -0,0 +1 @@
+export declare const REFERENCE_FILE = "./types.d.ts";

package/dist/core/sync/constants.js

@@ -0,0 +1,4 @@
+const REFERENCE_FILE = "./types.d.ts";
+export {
+  REFERENCE_FILE
+};

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

@@ -1,22 +1,30 @@
 import fsMod from 'node:fs';
-import type { AstroInlineConfig, AstroSettings } from '../../@types/astro.js';
+import type { AstroConfig, AstroInlineConfig, AstroSettings } from '../../@types/astro.js';
 import type { Logger } from '../logger/core.js';
 export type SyncOptions = {
     logger: Logger;
     settings: AstroSettings;
+    force?: boolean;
     skip?: {
         content?: boolean;
     };
 };
-export default function sync({ inlineConfig, fs, telemetry: _telemetry, }: {
-    inlineConfig: AstroInlineConfig;
+export default function sync(inlineConfig: AstroInlineConfig, { fs, telemetry: _telemetry }?: {
     fs?: typeof fsMod;
     telemetry?: boolean;
 }): Promise<void>;
+/**
+ * Clears the content layer and content collection cache, forcing a full rebuild.
+ */
+export declare function clearContentLayerCache({ astroConfig, logger, fs, }: {
+    astroConfig: AstroConfig;
+    logger: Logger;
+    fs?: typeof fsMod;
+}): Promise<void>;
 /**
  * Generates TypeScript types for all Astro modules. This sets up a `src/env.d.ts` file for type inferencing,
  * and defines the `astro:content` module for the Content Collections API.
  *
  * @experimental The JavaScript API is experimental
  */
-export declare function syncInternal({ logger, fs, settings, skip, }: SyncOptions): Promise<void>;
+export declare function syncInternal({ logger, fs, settings, skip, force, }: SyncOptions): Promise<void>;

package/dist/core/sync/index.js

@@ -1,15 +1,17 @@
-import fsMod from "node:fs";
+import fsMod, { existsSync } from "node:fs";
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
 import { dim } from "kleur/colors";
 import { createServer } from "vite";
-import { getPackage } from "../../cli/install-package.js";
+import { CONTENT_TYPES_FILE, DATA_STORE_FILE } from "../../content/consts.js";
+import { globalContentLayer } from "../../content/content-layer.js";
 import { createContentTypesGenerator } from "../../content/index.js";
-import { globalContentConfigObserver } from "../../content/utils.js";
+import { MutableDataStore } from "../../content/mutable-data-store.js";
+import { getContentPaths, globalContentConfigObserver } from "../../content/utils.js";
 import { syncAstroEnv } from "../../env/sync.js";
 import { telemetry } from "../../events/index.js";
 import { eventCliSession } from "../../events/session.js";
-import { runHookConfigSetup } from "../../integrations/hooks.js";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
 import { getTimeStat } from "../build/util.js";
 import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
@@ -25,12 +27,8 @@ import {
 } from "../errors/index.js";
 import { formatErrorMessage } from "../messages.js";
 import { ensureProcessNodeEnv } from "../util.js";
-import { setUpEnvTs } from "./setup-env-ts.js";
-async function sync({
-  inlineConfig,
-  fs,
-  telemetry: _telemetry = false
-}) {
+import { writeFiles } from "./write-files.js";
+async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
   ensureProcessNodeEnv("production");
   const logger = createNodeLogger(inlineConfig);
   const { astroConfig, userConfig } = await resolveConfig(inlineConfig ?? {}, "sync");
@@ -43,32 +41,63 @@ async function sync({
     settings,
     logger
   });
-  return await syncInternal({ settings, logger, fs });
+  await runHookConfigDone({ settings, logger });
+  return await syncInternal({ settings, logger, fs, force: inlineConfig.force });
+}
+async function clearContentLayerCache({
+  astroConfig,
+  logger,
+  fs = fsMod
+}) {
+  const dataStore = new URL(DATA_STORE_FILE, astroConfig.cacheDir);
+  if (fs.existsSync(dataStore)) {
+    logger.debug("content", "clearing data store");
+    await fs.promises.rm(dataStore, { force: true });
+    logger.warn("content", "data store cleared (force)");
+  }
 }
 async function syncInternal({
   logger,
   fs = fsMod,
   settings,
-  skip
+  skip,
+  force
 }) {
-  const cwd = fileURLToPath(settings.config.root);
+  if (force) {
+    await clearContentLayerCache({ astroConfig: settings.config, logger, fs });
+  }
   const timerStart = performance.now();
-  const dbPackage = await getPackage(
-    "@astrojs/db",
-    logger,
-    {
-      optional: true,
-      cwd
-    },
-    []
-  );
   try {
-    await dbPackage?.typegen?.(settings.config);
     if (!skip?.content) {
       await syncContentCollections(settings, { fs, logger });
+      settings.timer.start("Sync content layer");
+      let store;
+      try {
+        const dataStoreFile = new URL(DATA_STORE_FILE, settings.config.cacheDir);
+        if (existsSync(dataStoreFile)) {
+          store = await MutableDataStore.fromFile(dataStoreFile);
+        }
+      } catch (err) {
+        logger.error("content", err.message);
+      }
+      if (!store) {
+        store = new MutableDataStore();
+      }
+      const contentLayer = globalContentLayer.init({
+        settings,
+        logger,
+        store
+      });
+      await contentLayer.sync();
+      settings.timer.end("Sync content layer");
+    } else if (fs.existsSync(fileURLToPath(getContentPaths(settings.config, fs).contentDir))) {
+      settings.injectedTypes.push({
+        filename: CONTENT_TYPES_FILE,
+        content: ""
+      });
     }
     syncAstroEnv(settings, fs);
-    await setUpEnvTs({ settings, logger, fs });
+    await writeFiles(settings, fs, logger);
     logger.info("types", `Generated ${dim(getTimeStat(timerStart, performance.now()))}`);
   } catch (err) {
     const error = createSafeError(err);
@@ -137,6 +166,7 @@ async function syncContentCollections(settings, { logger, fs }) {
   }
 }
 export {
+  clearContentLayerCache,
   sync as default,
   syncInternal
 };

package/dist/core/sync/write-files.d.ts

@@ -0,0 +1,4 @@
+import type fsMod from 'node:fs';
+import type { AstroSettings } from '../../@types/astro.js';
+import type { Logger } from '../logger/core.js';
+export declare function writeFiles(settings: AstroSettings, fs: typeof fsMod, logger: Logger): Promise<void>;

package/dist/core/sync/write-files.js

@@ -0,0 +1,69 @@
+import { dirname, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { bold } from "kleur/colors";
+import { normalizePath } from "vite";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { REFERENCE_FILE } from "./constants.js";
+async function writeFiles(settings, fs, logger) {
+  try {
+    writeInjectedTypes(settings, fs);
+    await setUpEnvTs(settings, fs, logger);
+  } catch (e) {
+    throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: e });
+  }
+}
+function getTsReference(type, value) {
+  return `/// <reference ${type}=${JSON.stringify(value)} />`;
+}
+const CLIENT_TYPES_REFERENCE = getTsReference("types", "astro/client");
+function writeInjectedTypes(settings, fs) {
+  const references = [];
+  for (const { filename, content } of settings.injectedTypes) {
+    const filepath = normalizePath(fileURLToPath(new URL(filename, settings.dotAstroDir)));
+    fs.mkdirSync(dirname(filepath), { recursive: true });
+    fs.writeFileSync(filepath, content, "utf-8");
+    references.push(normalizePath(relative(fileURLToPath(settings.dotAstroDir), filepath)));
+  }
+  const astroDtsContent = `${CLIENT_TYPES_REFERENCE}
+${references.map((reference) => getTsReference("path", reference)).join("\n")}`;
+  if (references.length === 0) {
+    fs.mkdirSync(settings.dotAstroDir, { recursive: true });
+  }
+  fs.writeFileSync(
+    normalizePath(fileURLToPath(new URL(REFERENCE_FILE, settings.dotAstroDir))),
+    astroDtsContent,
+    "utf-8"
+  );
+}
+async function setUpEnvTs(settings, fs, logger) {
+  const envTsPath = normalizePath(fileURLToPath(new URL("env.d.ts", settings.config.srcDir)));
+  const envTsPathRelativetoRoot = normalizePath(
+    relative(fileURLToPath(settings.config.root), envTsPath)
+  );
+  const relativePath = normalizePath(
+    relative(
+      fileURLToPath(settings.config.srcDir),
+      fileURLToPath(new URL(REFERENCE_FILE, settings.dotAstroDir))
+    )
+  );
+  const expectedTypeReference = getTsReference("path", relativePath);
+  if (fs.existsSync(envTsPath)) {
+    const initialEnvContents = await fs.promises.readFile(envTsPath, "utf-8");
+    let typesEnvContents = initialEnvContents;
+    if (!typesEnvContents.includes(expectedTypeReference)) {
+      typesEnvContents = `${expectedTypeReference}
+${typesEnvContents}`;
+    }
+    if (initialEnvContents !== typesEnvContents) {
+      logger.info("types", `Updated ${bold(envTsPathRelativetoRoot)} type declarations.`);
+      await fs.promises.writeFile(envTsPath, typesEnvContents, "utf-8");
+    }
+  } else {
+    await fs.promises.mkdir(settings.config.srcDir, { recursive: true });
+    await fs.promises.writeFile(envTsPath, expectedTypeReference, "utf-8");
+    logger.info("types", `Added ${bold(envTsPathRelativetoRoot)} type declarations`);
+  }
+}
+export {
+  writeFiles
+};

package/dist/core/util.js

@@ -101,7 +101,7 @@ function isPage(file, settings) {
 function isEndpoint(file, settings) {
   if (!isInPagesDir(file, settings.config)) return false;
   if (!isPublicRoute(file, settings.config)) return false;
-  return !endsWithPageExt(file, settings);
+  return !endsWithPageExt(file, settings) && !file.toString().includes("?astro");
 }
 function isServerLikeOutput(config) {
   return config.output === "server" || config.output === "hybrid";

package/dist/env/sync.js

@@ -1,5 +1,5 @@
 import fsMod from "node:fs";
-import { ENV_TYPES_FILE, TYPES_TEMPLATE_URL } from "./constants.js";
+import { TYPES_TEMPLATE_URL } from "./constants.js";
 import { getEnvFieldType } from "./validators.js";
 function syncAstroEnv(settings, fs = fsMod) {
   if (!settings.config.experimental.env) {
@@ -18,9 +18,11 @@ function syncAstroEnv(settings, fs = fsMod) {
     }
   }
   const template = fs.readFileSync(TYPES_TEMPLATE_URL, "utf-8");
-  const dts = template.replace("// @@CLIENT@@", client).replace("// @@SERVER@@", server);
-  fs.mkdirSync(settings.dotAstroDir, { recursive: true });
-  fs.writeFileSync(new URL(ENV_TYPES_FILE, settings.dotAstroDir), dts, "utf-8");
+  const content = template.replace("// @@CLIENT@@", client).replace("// @@SERVER@@", server);
+  settings.injectedTypes.push({
+    filename: "astro/env.d.ts",
+    content
+  });
 }
 export {
   syncAstroEnv

package/dist/integrations/hooks.d.ts

@@ -1,7 +1,7 @@
 import fsMod from 'node:fs';
 import type { AddressInfo } from 'node:net';
 import type { InlineConfig, ViteDevServer } from 'vite';
-import type { AstroAdapter, AstroConfig, AstroSettings, RouteData } from '../@types/astro.js';
+import type { AstroAdapter, AstroConfig, AstroSettings, RouteData, RouteOptions } from '../@types/astro.js';
 import type { SerializedSSRManifest } from '../core/app/types.js';
 import type { PageBuildData } from '../core/build/types.js';
 import type { Logger } from '../core/logger/core.js';
@@ -33,6 +33,7 @@ export declare function getToolbarServerCommunicationHelpers(server: ViteDevServ
         state: boolean;
     }) => void) => void;
 };
+export declare function normalizeInjectedTypeFilename(filename: string, integrationName: string): string;
 export declare function runHookConfigSetup({ settings, command, logger, isRestart, fs, }: {
     settings: AstroSettings;
     command: 'dev' | 'build' | 'preview';
@@ -89,5 +90,10 @@ type RunHookBuildDone = {
     cacheManifest: boolean;
 };
 export declare function runHookBuildDone({ config, pages, routes, logging, cacheManifest, }: RunHookBuildDone): Promise<void>;
+export declare function runHookRouteSetup({ route, settings, logger, }: {
+    route: RouteOptions;
+    settings: AstroSettings;
+    logger: Logger;
+}): Promise<void>;
 export declare function isFunctionPerRouteEnabled(adapter: AstroAdapter | undefined): boolean;
 export {};

package/dist/integrations/hooks.js

@@ -70,6 +70,15 @@ function getToolbarServerCommunicationHelpers(server) {
     }
   };
 }
+const SAFE_CHARS_RE = /[^\w.-]/g;
+function normalizeInjectedTypeFilename(filename, integrationName) {
+  if (!filename.endsWith(".d.ts")) {
+    throw new Error(
+      `Integration ${bold(integrationName)} is injecting a type that does not end with "${bold(".d.ts")}"`
+    );
+  }
+  return `./integrations/${integrationName.replace(SAFE_CHARS_RE, "_")}/${filename.replace(SAFE_CHARS_RE, "_")}`;
+}
 async function runHookConfigSetup({
   settings,
   command,
@@ -242,6 +251,17 @@ async function runHookConfigDone({
             }
             settings.adapter = adapter;
           },
+          injectTypes(injectedType) {
+            const normalizedFilename = normalizeInjectedTypeFilename(
+              injectedType.filename,
+              integration.name
+            );
+            settings.injectedTypes.push({
+              filename: normalizedFilename,
+              content: injectedType.content
+            });
+            return new URL(normalizedFilename, settings.config.root);
+          },
           logger: getLogger(integration, logger)
         }),
         logger
@@ -419,6 +439,38 @@ async function runHookBuildDone({
     }
   }
 }
+async function runHookRouteSetup({
+  route,
+  settings,
+  logger
+}) {
+  const prerenderChangeLogs = [];
+  for (const integration of settings.config.integrations) {
+    if (integration?.hooks?.["astro:route:setup"]) {
+      const originalRoute = { ...route };
+      const integrationLogger = getLogger(integration, logger);
+      await withTakingALongTimeMsg({
+        name: integration.name,
+        hookName: "astro:route:setup",
+        hookResult: integration.hooks["astro:route:setup"]({
+          route,
+          logger: integrationLogger
+        }),
+        logger
+      });
+      if (route.prerender !== originalRoute.prerender) {
+        prerenderChangeLogs.push({ integrationName: integration.name, value: route.prerender });
+      }
+    }
+  }
+  if (prerenderChangeLogs.length > 1) {
+    logger.debug(
+      "router",
+      `The ${route.component} route's prerender option has been changed multiple times by integrations:
+` + prerenderChangeLogs.map((log) => `- ${log.integrationName}: ${log.value}`).join("\n")
+    );
+  }
+}
 function isFunctionPerRouteEnabled(adapter) {
   if (adapter?.adapterFeatures?.functionPerRoute === true) {
     return true;
@@ -429,6 +481,7 @@ function isFunctionPerRouteEnabled(adapter) {
 export {
   getToolbarServerCommunicationHelpers,
   isFunctionPerRouteEnabled,
+  normalizeInjectedTypeFilename,
   runHookBuildDone,
   runHookBuildGenerated,
   runHookBuildSetup,
@@ -436,6 +489,7 @@ export {
   runHookBuildStart,
   runHookConfigDone,
   runHookConfigSetup,
+  runHookRouteSetup,
   runHookServerDone,
   runHookServerSetup,
   runHookServerStart

package/dist/preferences/index.d.ts

@@ -32,5 +32,5 @@ export interface AstroPreferences {
 }
 export declare function isValidKey(key: string): key is PreferenceKey;
 export declare function coerce(key: string, value: unknown): any;
-export default function createPreferences(config: AstroConfig): AstroPreferences;
+export default function createPreferences(config: AstroConfig, dotAstroDir: URL): AstroPreferences;
 export {};

package/dist/preferences/index.js

@@ -25,9 +25,9 @@ function coerce(key, value) {
   }
   return value;
 }
-function createPreferences(config) {
+function createPreferences(config, dotAstroDir) {
   const global = new PreferenceStore(getGlobalPreferenceDir());
-  const project = new PreferenceStore(fileURLToPath(new URL("./.astro/", config.root)));
+  const project = new PreferenceStore(fileURLToPath(dotAstroDir));
   const stores = { global, project };
   return {
     async get(key, { location } = {}) {

package/dist/runtime/server/render/server-islands.js

@@ -40,7 +40,8 @@ function renderServerIsland(result, _displayName, props, slots) {
       const key = await result.key;
       const propsEncrypted = await encryptString(key, JSON.stringify(props));
       const hostId = crypto.randomUUID();
-      const serverIslandUrl = `${result.base}_server-islands/${componentId}${result.trailingSlash === "always" ? "/" : ""}`;
+      const slash = result.base.endsWith("/") ? "" : "/";
+      const serverIslandUrl = `${result.base}${slash}_server-islands/${componentId}${result.trailingSlash === "always" ? "/" : ""}`;
       destination.write(`<script async type="module" data-island-id="${hostId}">
 let componentId = ${safeJsonStringify(componentId)};
 let componentExport = ${safeJsonStringify(componentExport)};
@@ -60,9 +61,10 @@ if(response.status === 200 && response.headers.get('content-type') === 'text/htm
 	let html = await response.text();
 
 	// Swap!
-	while(script.previousSibling?.nodeType !== 8 &&
-		script.previousSibling?.data !== 'server-island-start') {
-		script.previousSibling?.remove();
+	while(script.previousSibling &&
+		script.previousSibling.nodeType !== 8 &&
+		script.previousSibling.data !== 'server-island-start') {
+		script.previousSibling.remove();
 	}
 	script.previousSibling?.remove();
 

package/dist/vite-plugin-astro-server/response.js

@@ -1,4 +1,4 @@
-import { Readable } from "stream";
+import { Readable } from "node:stream";
 import { getSetCookiesFromResponse } from "../core/cookies/index.js";
 import { getViteErrorPayload } from "../core/errors/dev/index.js";
 import notFoundTemplate from "../template/4xx.js";

package/dist/vite-plugin-env/index.d.ts

@@ -1,7 +1,9 @@
 import type * as vite from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
 interface EnvPluginOptions {
     settings: AstroSettings;
+    logger: Logger;
 }
-export default function envVitePlugin({ settings }: EnvPluginOptions): vite.Plugin;
+export default function envVitePlugin({ settings, logger }: EnvPluginOptions): vite.Plugin;
 export {};