astro 7.0.4 → 7.0.6

package/components/Picture.astro

@@ -1,7 +1,13 @@
 ---
-import { getImage, imageConfig, type LocalImageProps, type RemoteImageProps } from 'astro:assets';
+import {
+	getImage,
+	imageConfig,
+	inferRemoteSize,
+	type LocalImageProps,
+	type RemoteImageProps,
+} from 'astro:assets';
 import * as mime from 'mrmime';
-import { isESMImportedImage, resolveSrc } from '../dist/assets/utils/imageKind.js';
+import { isESMImportedImage, isRemoteImage, resolveSrc } from '../dist/assets/utils/imageKind.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 import type {
 	GetImageResult,
@@ -62,6 +68,17 @@ for (const key in props) {
 }
 
 const originalSrc = await resolveSrc(props.src);
+
+// When inferSize is set for a remote image, resolve dimensions once and thread them through
+// to all getImage() calls. This avoids multiple redundant HTTP requests to the same URL,
+// which can trigger rate-limiting (HTTP 429) on servers like Wikimedia.
+if (props.inferSize && isRemoteImage(originalSrc)) {
+	const remoteSize = await inferRemoteSize(originalSrc);
+	delete props.inferSize;
+	props.width ??= remoteSize.width;
+	props.height ??= remoteSize.height;
+}
+
 const optimizedImages: GetImageResult[] = await Promise.all(
 	formats.map(
 		async (format) =>

package/dist/actions/handler.js

@@ -1,3 +1,7 @@
+import {
+  createCrossOriginForbiddenResponse,
+  isForbiddenCrossOriginRequest
+} from "../core/app/origin-check.js";
 import { PipelineFeatures } from "../core/base-pipeline.js";
 import { getActionContext, serializeActionResult } from "./runtime/server.js";
 class ActionHandler {
@@ -18,6 +22,9 @@ class ActionHandler {
     if (!action) {
       return void 0;
     }
+    if (state.pipeline.manifest.checkOrigin && isForbiddenCrossOriginRequest(apiContext.request, apiContext.url, apiContext.isPrerendered)) {
+      return Promise.resolve(createCrossOriginForbiddenResponse(apiContext.request));
+    }
     return this.#executeAction(action, setActionResult);
   }
   async #executeAction(action, setActionResult) {

package/dist/cli/dev/background.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, openSync } from "node:fs";
-import { resolve } from "node:path";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   checkExistingServer,
@@ -11,6 +12,7 @@ import {
   GRACEFUL_SHUTDOWN_TIMEOUT
 } from "../../core/dev/lockfile.js";
 import { resolveRoot } from "../../core/config/config.js";
+const require2 = createRequire(import.meta.url);
 function formatBackgroundOutput(result) {
   return JSON.stringify(result);
 }
@@ -76,7 +78,7 @@ async function background({
   }
   const logFd = openSync(logFilePath, "w");
   const rootPath = fileURLToPath(root);
-  const astroBin = resolve(rootPath, "node_modules", "astro", "bin", "astro.mjs");
+  const astroBin = resolve(dirname(require2.resolve("astro/package.json")), "bin", "astro.mjs");
   const child = spawn(process.execPath, [astroBin, ...args], {
     detached: true,
     stdio: ["ignore", logFd, logFd],

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "7.0.4";
+  version = "7.0.6";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/cli/install-package.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
 import * as clack from "@clack/prompts";
 import ci from "ci-info";
 import { detect, resolveCommand } from "package-manager-detector";
@@ -8,8 +9,8 @@ const require2 = createRequire(import.meta.url);
 const { bold, cyan, dim, magenta } = colors;
 async function getPackage(packageName, logger, options, otherDeps = []) {
   try {
-    require2.resolve(packageName, { paths: [options.cwd ?? process.cwd()] });
-    const packageImport = await import(packageName);
+    const resolved = require2.resolve(packageName, { paths: [options.cwd ?? process.cwd()] });
+    const packageImport = await import(pathToFileURL(resolved).href);
     return packageImport;
   } catch {
     if (options.optional) return void 0;
@@ -25,7 +26,8 @@ async function getPackage(packageName, logger, options, otherDeps = []) {
     }
     const result = await installPackage([packageName, ...otherDeps], options, logger);
     if (result) {
-      const packageImport = await import(packageName);
+      const resolved = require2.resolve(packageName, { paths: [options.cwd ?? process.cwd()] });
+      const packageImport = await import(pathToFileURL(resolved).href);
       return packageImport;
     } else {
       return void 0;

package/dist/container/index.js

@@ -14,6 +14,8 @@ import { validateSegment } from "../core/routing/segment.js";
 import { SlotString } from "../runtime/server/render/slot.js";
 import { ContainerPipeline } from "./pipeline.js";
 import { createConsoleLogger } from "../core/logger/impls/console.js";
+const { gfm: _, smartypants: __, ...containerMarkdownDefaults } = ASTRO_CONFIG_DEFAULTS.markdown;
+const CONTAINER_CONFIG_DEFAULTS = { ...ASTRO_CONFIG_DEFAULTS, markdown: containerMarkdownDefaults };
 function createManifest(manifest, renderers, middleware) {
   function middlewareInstance() {
     return {
@@ -113,7 +115,7 @@ class experimental_AstroContainer {
    */
   static async create(containerOptions = {}) {
     const { streaming = false, manifest, renderers = [], resolve } = containerOptions;
-    const astroConfig = await validateConfig(ASTRO_CONFIG_DEFAULTS, process.cwd(), "container");
+    const astroConfig = await validateConfig(CONTAINER_CONFIG_DEFAULTS, process.cwd(), "container");
     return new experimental_AstroContainer({
       streaming,
       manifest,
@@ -206,7 +208,7 @@ class experimental_AstroContainer {
   // NOTE: we keep this private via TS instead via `#` so it's still available on the surface, so we can play with it.
   // @ts-expect-error @ematipico: I plan to use it for a possible integration that could help people
   static async createFromManifest(manifest) {
-    const astroConfig = await validateConfig(ASTRO_CONFIG_DEFAULTS, process.cwd(), "container");
+    const astroConfig = await validateConfig(CONTAINER_CONFIG_DEFAULTS, process.cwd(), "container");
     const container = new experimental_AstroContainer({
       manifest,
       astroConfig

package/dist/content/content-layer.js

@@ -197,7 +197,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.0.4") {
+    if (previousAstroVersion && previousAstroVersion !== "7.0.6") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -205,8 +205,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.0.4") {
-      this.#store.metaStore().set("astro-version", "7.0.4");
+    if ("7.0.6") {
+      this.#store.metaStore().set("astro-version", "7.0.6");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/core/app/origin-check.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Home of the `security.checkOrigin` logic. Exposes the shared predicate and
+ * response used to reject cross-site submissions, plus the middleware factory
+ * that installs the check in the request pipeline. Consumers (the pipeline
+ * middleware and the Astro Actions dispatch) import from here so the check
+ * stays consistent regardless of where it runs.
+ */
+import type { MiddlewareHandler } from '../../types/public/common.js';
+/**
+ * Determines whether a request should be rejected because it is a cross-site
+ * submission for a route rendered on demand.
+ *
+ * This encapsulates the shared logic used by both the origin-check middleware
+ * and the Astro Actions dispatch, so the check is applied consistently
+ * regardless of where the request is handled.
+ *
+ * @private
+ */
+export declare function isForbiddenCrossOriginRequest(request: Request, url: URL, isPrerendered: boolean): boolean;
+/**
+ * Builds the 403 response returned when a cross-site submission is rejected.
+ *
+ * @private
+ */
+export declare function createCrossOriginForbiddenResponse(request: Request): Response;
+/**
+ * Returns a middleware function in charge to check the `origin` header.
+ *
+ * @private
+ */
+export declare function createOriginCheckMiddleware(): MiddlewareHandler;
+export declare function hasFormLikeHeader(contentType: string | null): boolean;

package/dist/core/app/origin-check.js

@@ -0,0 +1,52 @@
+import { defineMiddleware } from "../middleware/defineMiddleware.js";
+const FORM_CONTENT_TYPES = [
+  "application/x-www-form-urlencoded",
+  "multipart/form-data",
+  "text/plain"
+];
+const SAFE_METHODS = ["GET", "HEAD", "OPTIONS"];
+function isForbiddenCrossOriginRequest(request, url, isPrerendered) {
+  if (isPrerendered) {
+    return false;
+  }
+  if (SAFE_METHODS.includes(request.method)) {
+    return false;
+  }
+  const isSameOrigin = request.headers.get("origin") === url.origin;
+  const hasContentType = request.headers.has("content-type");
+  if (hasContentType) {
+    const formLikeHeader = hasFormLikeHeader(request.headers.get("content-type"));
+    return formLikeHeader && !isSameOrigin;
+  }
+  return !isSameOrigin;
+}
+function createCrossOriginForbiddenResponse(request) {
+  return new Response(`Cross-site ${request.method} form submissions are forbidden`, {
+    status: 403
+  });
+}
+function createOriginCheckMiddleware() {
+  return defineMiddleware((context, next) => {
+    const { request, url, isPrerendered } = context;
+    if (isForbiddenCrossOriginRequest(request, url, isPrerendered)) {
+      return createCrossOriginForbiddenResponse(request);
+    }
+    return next();
+  });
+}
+function hasFormLikeHeader(contentType) {
+  if (contentType) {
+    for (const FORM_CONTENT_TYPE of FORM_CONTENT_TYPES) {
+      if (contentType.toLowerCase().includes(FORM_CONTENT_TYPE)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+export {
+  createCrossOriginForbiddenResponse,
+  createOriginCheckMiddleware,
+  hasFormLikeHeader,
+  isForbiddenCrossOriginRequest
+};

package/dist/core/base-pipeline.js

@@ -1,5 +1,5 @@
 import { NOOP_ACTIONS_MOD } from "../actions/noop-actions.js";
-import { createOriginCheckMiddleware } from "./app/middlewares.js";
+import { createOriginCheckMiddleware } from "./app/origin-check.js";
 import { ActionNotFoundError } from "./errors/errors-data.js";
 import { AstroError } from "./errors/index.js";
 import { NOOP_MIDDLEWARE_FN } from "./middleware/noop-middleware.js";

package/dist/core/build/plugins/index.js

@@ -3,6 +3,7 @@ import { astroHeadBuildPlugin } from "../../../vite-plugin-head/index.js";
 import { pluginAnalyzer } from "./plugin-analyzer.js";
 import { pluginComponentEntry } from "./plugin-component-entry.js";
 import { pluginCSS } from "./plugin-css.js";
+import { pluginCssTargetLowering } from "./plugin-css-target-lowering.js";
 import { pluginInternals } from "./plugin-internals.js";
 import { pluginMiddleware } from "./plugin-middleware.js";
 import { pluginPrerender } from "./plugin-prerender.js";
@@ -18,6 +19,7 @@ function getAllBuildPlugins(internals, options) {
     pluginInternals(options, internals),
     pluginMiddleware(options, internals),
     vitePluginActionsBuild(options, internals),
+    pluginCssTargetLowering(),
     ...pluginCSS(options, internals),
     astroHeadBuildPlugin(internals),
     pluginPrerender(options, internals),

package/dist/core/build/plugins/plugin-css-target-lowering.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin as VitePlugin } from 'vite';
+/**
+ * Vite plugin that applies CSS target lowering without minification.
+ *
+ * Vite's `finalizeCss` only applies CSS target lowering (via lightningcss) when
+ * `config.build.cssMinify` is truthy, because target lowering and minification
+ * are coupled in `minifyCSS`. When users set `minify: false`, Astro forces
+ * `cssMinify: false`, which disables target lowering for all CSS.
+ *
+ * This plugin fills that gap: when `cssMinify` is falsy and a CSS target is
+ * configured, it runs lightningcss with `minify: false` on all CSS assets in
+ * `generateBundle`, applying target lowering without minification.
+ */
+export declare function pluginCssTargetLowering(): VitePlugin;

package/dist/core/build/plugins/plugin-css-target-lowering.js

@@ -0,0 +1,82 @@
+import { createRequire } from "node:module";
+const BROWSER_MAP = {
+  chrome: "chrome",
+  edge: "edge",
+  firefox: "firefox",
+  hermes: false,
+  ie: "ie",
+  ios: "ios_saf",
+  node: false,
+  opera: "opera",
+  rhino: false,
+  safari: "safari"
+};
+const VERSION_RE = /\d/;
+function convertTargets(esbuildTarget) {
+  if (!esbuildTarget) return {};
+  const targets = {};
+  const entries = Array.isArray(esbuildTarget) ? esbuildTarget : [esbuildTarget];
+  for (const entry of entries) {
+    if (entry === "esnext") continue;
+    const index = entry.search(VERSION_RE);
+    if (index >= 0) {
+      const browserName = entry.slice(0, index);
+      const browser = BROWSER_MAP[browserName];
+      if (browser === false) continue;
+      if (browser) {
+        const [major, minor = 0] = entry.slice(index).split(".").map((v) => Number.parseInt(v, 10));
+        if (!isNaN(major) && !isNaN(minor)) {
+          const version = major << 16 | minor << 8;
+          if (!targets[browser] || version < targets[browser]) {
+            targets[browser] = version;
+          }
+        }
+      }
+    }
+  }
+  return targets;
+}
+function pluginCssTargetLowering() {
+  let resolvedConfig;
+  return {
+    name: "astro:css-target-lowering",
+    enforce: "post",
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    async generateBundle(_outputOptions, bundle) {
+      if (resolvedConfig.build.cssMinify) return;
+      const cssTarget = resolvedConfig.build.cssTarget;
+      if (!cssTarget) return;
+      const targets = convertTargets(cssTarget);
+      if (Object.keys(targets).length === 0) return;
+      let lcssTransform;
+      try {
+        const requireFromVite = createRequire(import.meta.resolve("vite"));
+        lcssTransform = requireFromVite("lightningcss").transform;
+      } catch {
+        return;
+      }
+      for (const [, asset] of Object.entries(bundle)) {
+        if (asset.type !== "asset") continue;
+        if (!asset.fileName.endsWith(".css")) continue;
+        if (typeof asset.source !== "string") continue;
+        try {
+          const result = lcssTransform({
+            ...resolvedConfig.css?.lightningcss,
+            targets,
+            cssModules: void 0,
+            filename: asset.fileName,
+            code: Buffer.from(asset.source),
+            minify: false
+          });
+          asset.source = new TextDecoder().decode(result.code);
+        } catch {
+        }
+      }
+    }
+  };
+}
+export {
+  pluginCssTargetLowering
+};

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "7.0.4";
+const ASTRO_VERSION = "7.0.6";
 const ASTRO_GENERATOR = `Astro v${ASTRO_VERSION}`;
 const ASTRO_ERROR_HEADER = "X-Astro-Error";
 const DEFAULT_404_COMPONENT = "astro-default-404.astro";

package/dist/core/create-vite.js

@@ -201,6 +201,8 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       }
     },
     resolve: {
+      // Vite's native tsconfig path resolution; see configAliasVitePlugin for the deprecated fallback.
+      tsconfigPaths: true,
       alias: [
         {
           // This is needed for Deno compatibility, as the non-browser version

package/dist/core/dev/dev.js

@@ -26,7 +26,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "7.0.4";
+  const currentVersion = "7.0.6";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/fetch/fetch-state.js

@@ -297,6 +297,8 @@ class FetchState {
         extraStyleHashes,
         extraScriptHashes,
         propagators: /* @__PURE__ */ new Set(),
+        routeHasPropagation: false,
+        pendingSlotEvaluations: [],
         templateDepth: 0
       },
       cspDestination: manifest.csp?.cspDestination ?? (routeData.prerender ? "meta" : "header"),

package/dist/core/head-propagation/buffer.d.ts

@@ -3,10 +3,21 @@ export interface HeadPropagator {
     init(result: SSRResult): unknown | Promise<unknown>;
 }
 /**
- * Runs all registered propagators and collects emitted head HTML strings.
+ * Runs all registered propagators and collects the head HTML they emit.
  *
- * This iterates the live `Set`, so propagators discovered during iteration
- * are also processed in the same pass.
+ * Components with head content are discovered as we go. Initializing one
+ * propagator can register more of them: a component marked `in-tree` renders
+ * its children, and one of those children may be a `self` component that emits
+ * styles. Slots add a second way to find them — a slot whose markup contains an
+ * `await` only reaches the components after that `await` once it resolves, so
+ * we also wait for those pending slot pre-renders. We keep initializing
+ * propagators and waiting on slots until no new ones appear.
+ *
+ * Propagators are tracked in a `seen` set rather than read through a single
+ * live `Set` iterator. A propagator can be registered after we have already
+ * iterated to the end of the set (e.g. once a slot's `await` resolves), and a
+ * `Set` iterator that has reported `done` would never report those late
+ * additions.
  *
  * @example
  * If a layout initializes and discovers a nested component that also emits

package/dist/core/head-propagation/buffer.js

@@ -1,15 +1,25 @@
 async function collectPropagatedHeadParts(input) {
   const collectedHeadParts = [];
-  const iterator = input.propagators.values();
+  const seen = /* @__PURE__ */ new Set();
+  const pendingSlotEvaluations = input.result._metadata?.pendingSlotEvaluations ?? [];
   while (true) {
-    const { value, done } = iterator.next();
-    if (done) {
-      break;
+    if (pendingSlotEvaluations.length > 0) {
+      const batch = pendingSlotEvaluations.splice(0, pendingSlotEvaluations.length);
+      await Promise.all(batch);
+      continue;
     }
-    const returnValue = await value.init(input.result);
-    if (input.isHeadAndContent(returnValue) && returnValue.head) {
-      collectedHeadParts.push(returnValue.head);
+    let progressed = false;
+    for (const propagator of input.propagators) {
+      if (seen.has(propagator)) continue;
+      seen.add(propagator);
+      progressed = true;
+      const returnValue = await propagator.init(input.result);
+      if (input.isHeadAndContent(returnValue) && returnValue.head) {
+        collectedHeadParts.push(returnValue.head);
+      }
+      break;
     }
+    if (!progressed) break;
   }
   return collectedHeadParts;
 }

package/dist/core/messages/runtime.js

@@ -269,7 +269,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.0.4"}`
+        `v${"7.0.6"}`
       )} ${headline}`
     );
   }

package/dist/core/pages/handler.js

@@ -1,6 +1,10 @@
 import { renderEndpoint } from "../../runtime/server/endpoint.js";
 import { renderPage } from "../../runtime/server/index.js";
 import { ASTRO_ERROR_HEADER } from "../constants.js";
+import {
+  createCrossOriginForbiddenResponse,
+  isForbiddenCrossOriginRequest
+} from "../app/origin-check.js";
 import { getCookiesFromResponse } from "../cookies/response.js";
 const EMPTY_SLOTS = Object.freeze({});
 class PagesHandler {
@@ -78,8 +82,12 @@ class PagesHandler {
     if (!state.routeData) {
       return new Response(null, { status: 404, headers: { [ASTRO_ERROR_HEADER]: "true" } });
     }
+    const ctx = state.getAPIContext();
+    if (this.#pipeline.manifest.checkOrigin && isForbiddenCrossOriginRequest(ctx.request, ctx.url, ctx.isPrerendered)) {
+      return createCrossOriginForbiddenResponse(ctx.request);
+    }
     try {
-      return await this.handle(state, state.getAPIContext());
+      return await this.handle(state, ctx);
     } catch (err) {
       app.logger.error(null, err.stack || err.message || String(err));
       return app.renderError(state.request, {

package/dist/core/routing/generator.js

@@ -11,10 +11,10 @@ function sanitizeParams(params) {
 }
 function getParameter(part, params) {
   if (part.spread) {
-    return params[part.content.slice(3)] || "";
+    return params[part.content.slice(3)] ?? "";
   }
   if (part.dynamic) {
-    if (!params[part.content]) {
+    if (params[part.content] === void 0) {
       throw new TypeError(`Missing parameter: ${part.content}`);
     }
     return params[part.content];

package/dist/core/util.d.ts

@@ -24,6 +24,14 @@ export declare function resolvePages(config: AstroConfig): URL;
 export declare function isPage(file: URL, settings: AstroSettings): boolean;
 export declare function isEndpoint(file: URL, settings: AstroSettings): boolean;
 export declare function resolveJsToTs(filePath: string): string;
+/**
+ * Resolve a path that doesn't name a file on disk (e.g. produced by an
+ * extensionless import like `import { Counter } from './Counter'`) to the file
+ * Vite would load, by probing Vite's default extension order and directory
+ * `index` files. Returns the path unchanged when it already exists as a file
+ * or when no candidate is found.
+ */
+export declare function resolveExtensionlessPath(filePath: string): string;
 /**
  * Set a default NODE_ENV so Vite doesn't set an incorrect default when loading the Astro config
  */

package/dist/core/util.js

@@ -94,6 +94,28 @@ function resolveJsToTs(filePath) {
   }
   return filePath;
 }
+const VITE_DEFAULT_RESOLVE_EXTENSIONS = [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"];
+function resolveExtensionlessPath(filePath) {
+  const stat = fs.statSync(filePath, { throwIfNoEntry: false });
+  if (stat?.isFile()) {
+    return filePath;
+  }
+  for (const ext of VITE_DEFAULT_RESOLVE_EXTENSIONS) {
+    const tryPath = filePath + ext;
+    if (fs.existsSync(tryPath)) {
+      return tryPath;
+    }
+  }
+  if (stat?.isDirectory()) {
+    for (const ext of VITE_DEFAULT_RESOLVE_EXTENSIONS) {
+      const tryPath = `${filePath}/index${ext}`;
+      if (fs.existsSync(tryPath)) {
+        return tryPath;
+      }
+    }
+  }
+  return filePath;
+}
 function ensureProcessNodeEnv(defaultNodeEnv) {
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = defaultNodeEnv;
@@ -106,6 +128,7 @@ export {
   isMarkdownFile,
   isPage,
   parseNpmName,
+  resolveExtensionlessPath,
   resolveJsToTs,
   resolvePages,
   unwrapId,

package/dist/core/viteUtils.d.ts

@@ -9,6 +9,9 @@ export declare function normalizePath(id: string): string;
  * Examples:
  * - `./components/Button.jsx` from `/app/src/pages/index.astro`
  *   -> `/app/src/pages/components/Button.tsx` (when `.tsx` exists)
+ * - `../components/Counter` from `/app/src/pages/index.astro`
+ *   -> `/app/src/components/Counter.tsx` (extensionless imports probe Vite's
+ *   default extension order, then directory `index` files)
  * - `#components/react/Counter.tsx`
  *   -> `/app/src/components/react/Counter.tsx` via package `imports`
  */

package/dist/core/viteUtils.js

@@ -2,7 +2,13 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { prependForwardSlash, slash } from "../core/path.js";
-import { resolveJsToTs, unwrapId, VALID_ID_PREFIX, viteID } from "./util.js";
+import {
+  resolveExtensionlessPath,
+  resolveJsToTs,
+  unwrapId,
+  VALID_ID_PREFIX,
+  viteID
+} from "./util.js";
 const isWindows = typeof process !== "undefined" && process.platform === "win32";
 function normalizePath(id) {
   return path.posix.normalize(isWindows ? slash(id) : id);
@@ -10,7 +16,7 @@ function normalizePath(id) {
 function resolvePath(specifier, importer) {
   if (specifier.startsWith(".")) {
     const absoluteSpecifier = path.resolve(path.dirname(importer), specifier);
-    return resolveJsToTs(normalizePath(absoluteSpecifier));
+    return resolveExtensionlessPath(resolveJsToTs(normalizePath(absoluteSpecifier)));
   } else if (specifier.startsWith("#")) {
     try {
       const resolved = createRequire(pathToFileURL(importer)).resolve(specifier);

package/dist/prefetch/index.js

@@ -191,6 +191,16 @@ function onPageLoad(cb) {
     }
     cb();
   });
+  new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      for (const node of mutation.addedNodes) {
+        if (node instanceof Element && (node.tagName === "A" || node.querySelector?.("a"))) {
+          cb();
+          return;
+        }
+      }
+    }
+  }).observe(document.body, { childList: true, subtree: true });
 }
 function appendSpeculationRules(url, eagerness) {
   const script = document.createElement("script");

package/dist/runtime/server/render/astro/instance.js

@@ -18,6 +18,9 @@ class AstroComponentInstance {
     for (const name in slots) {
       let didRender = false;
       let value = slots[name](result);
+      if (result._metadata.routeHasPropagation && isPromise(value)) {
+        result._metadata.pendingSlotEvaluations.push(value);
+      }
       this.slotValues[name] = () => {
         if (!didRender) {
           didRender = true;

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

@@ -103,7 +103,13 @@ function stringifyChunk(result, chunk) {
         out += stringifyChunk(result, instr);
       }
     }
-    out += chunk.toString();
+    if (c.chunks.length) {
+      for (const part of c.chunks) {
+        out += typeof part === "string" ? part : stringifyChunk(result, part);
+      }
+    } else {
+      out += chunk.toString();
+    }
     return out;
   }
   return chunk.toString();