astro 7.0.0-alpha.0 → 7.0.0-alpha.2

package/dist/core/routing/handler.js

@@ -0,0 +1,171 @@
+import { ActionHandler } from "../../actions/handler.js";
+import {
+  REROUTABLE_STATUS_CODES,
+  REROUTE_DIRECTIVE_HEADER,
+  REWRITE_DIRECTIVE_HEADER_KEY
+} from "../constants.js";
+import { TrailingSlashHandler } from "./trailing-slash-handler.js";
+import { CacheHandler, provideCache } from "../cache/handler.js";
+import { I18n } from "../i18n/handler.js";
+import { AstroMiddleware } from "../middleware/astro-middleware.js";
+import { PagesHandler } from "../pages/handler.js";
+import { renderRedirect } from "../redirects/render.js";
+import { provideSession } from "../session/handler.js";
+import { prepareResponse } from "../app/prepare-response.js";
+import { ALL_PIPELINE_FEATURES, PipelineFeatures } from "../base-pipeline.js";
+class AstroHandler {
+  #app;
+  #trailingSlashHandler;
+  #actionHandler;
+  #astroMiddleware;
+  #pagesHandler;
+  #cacheHandler;
+  /** Bound callback for the middleware chain — created once, reused per request. */
+  #renderRouteCallback;
+  /**
+   * i18n post-processor. Only set when the app has i18n configured and
+   * the strategy is not `manual` — for the manual strategy users wire
+   * `astro:i18n.middleware(...)` into their own `onRequest`.
+   */
+  #i18n;
+  /** Whether sessions are configured on the manifest. */
+  #hasSession;
+  constructor(app) {
+    this.#app = app;
+    this.#trailingSlashHandler = new TrailingSlashHandler(app);
+    this.#actionHandler = new ActionHandler();
+    this.#astroMiddleware = new AstroMiddleware(app.pipeline);
+    this.#pagesHandler = new PagesHandler(app.pipeline);
+    this.#cacheHandler = new CacheHandler(app);
+    this.#renderRouteCallback = this.#actionsAndPages.bind(this);
+    this.#hasSession = !!app.manifest.sessionConfig;
+    const i18n = app.manifest.i18n;
+    if (i18n && i18n.strategy !== "manual") {
+      this.#i18n = new I18n(
+        i18n,
+        app.manifest.base,
+        app.manifest.trailingSlash,
+        app.manifest.buildFormat
+      );
+    }
+  }
+  /**
+   * Runs actions then pages — the callback at the bottom of the
+   * middleware chain. Bound once in the constructor to avoid
+   * per-request closure allocation.
+   */
+  #actionsAndPages(state, ctx) {
+    if (!state.skipMiddleware) {
+      const actionResult = this.#actionHandler.handle(ctx, state);
+      if (actionResult) {
+        return actionResult.then((response) => response ?? this.#pagesHandler.handle(state, ctx));
+      }
+    }
+    return this.#pagesHandler.handle(state, ctx);
+  }
+  async handle(state) {
+    state.pipeline.usedFeatures |= ALL_PIPELINE_FEATURES;
+    const trailingSlashRedirect = this.#trailingSlashHandler.handle(state);
+    if (trailingSlashRedirect) {
+      return trailingSlashRedirect;
+    }
+    if (!state.routeData) {
+      return this.#app.renderError(state.request, {
+        ...state.renderOptions,
+        status: 404,
+        pathname: state.pathname
+      });
+    }
+    return this.render(state);
+  }
+  /**
+   * Renders a response for the given `FetchState`. Assumes
+   * trailing-slash redirects and routeData resolution have already run.
+   *
+   * User-triggered rewrites (`Astro.rewrite` / `ctx.rewrite`) go through
+   * `Rewrites.execute` on the current `FetchState` — they mutate the
+   * existing state in place and re-run middleware + page dispatch.
+   */
+  async render(state) {
+    const routeData = state.routeData;
+    const pathname = state.pathname;
+    const request = state.request;
+    const { addCookieHeader } = state.renderOptions;
+    const defaultStatus = this.#app.getDefaultStatusCode(routeData, pathname);
+    state.status = defaultStatus;
+    let response;
+    try {
+      const sessionP = this.#hasSession ? provideSession(state) : void 0;
+      const cacheP = provideCache(state);
+      if (sessionP || cacheP) await Promise.all([sessionP, cacheP]);
+      state.pipeline.usedFeatures |= PipelineFeatures.sessions;
+      if (routeData.type === "redirect") {
+        const redirectResponse = await renderRedirect(state);
+        this.#app.logThisRequest({
+          pathname,
+          method: request.method,
+          statusCode: redirectResponse.status,
+          isRewrite: false,
+          timeStart: state.timeStart
+        });
+        prepareResponse(redirectResponse, { addCookieHeader });
+        this.#app.pipeline.logger.flush();
+        return redirectResponse;
+      }
+      if (!this.#app.pipeline.cacheProvider) {
+        this.#app.pipeline.usedFeatures |= PipelineFeatures.cache;
+        response = await this.#astroMiddleware.handle(state, this.#renderRouteCallback);
+        if (this.#i18n) {
+          response = await this.#i18n.finalize(state, response);
+        }
+      } else {
+        const runPipeline = async () => {
+          let res = await this.#astroMiddleware.handle(state, this.#renderRouteCallback);
+          if (this.#i18n) {
+            res = await this.#i18n.finalize(state, res);
+          }
+          return res;
+        };
+        response = await this.#cacheHandler.handle(state, runPipeline);
+      }
+      const isRewrite = response.headers.has(REWRITE_DIRECTIVE_HEADER_KEY);
+      this.#app.logThisRequest({
+        pathname,
+        method: request.method,
+        statusCode: response.status,
+        isRewrite,
+        timeStart: state.timeStart
+      });
+    } catch (err) {
+      this.#app.logger.error(null, err.stack || err.message || String(err));
+      return this.#app.renderError(request, {
+        ...state.renderOptions,
+        status: 500,
+        error: err,
+        pathname: state.pathname
+      });
+    } finally {
+      const finalize = state.finalizeAll();
+      if (finalize) await finalize;
+    }
+    if (REROUTABLE_STATUS_CODES.includes(response.status) && // If the body isn't null, that means the user sets the 404 status
+    // but uses the current route to handle the 404
+    response.body === null && response.headers.get(REROUTE_DIRECTIVE_HEADER) !== "no") {
+      return this.#app.renderError(request, {
+        ...state.renderOptions,
+        response,
+        status: response.status,
+        // We don't have an error to report here. Passing null means we pass nothing intentionally
+        // while undefined means there's no error
+        error: response.status === 500 ? null : void 0,
+        pathname: state.pathname
+      });
+    }
+    prepareResponse(response, { addCookieHeader });
+    this.#app.pipeline.logger.flush();
+    return response;
+  }
+}
+export {
+  AstroHandler
+};

package/dist/core/routing/match.d.ts

@@ -18,10 +18,3 @@ export declare function isRoute404or500(route: RouteData): boolean;
  * @return {boolean} Returns true if the route's component is the server island component; otherwise, false.
  */
 export declare function isRouteServerIsland(route: RouteData): boolean;
-/**
- * Determines whether a given route is an external redirect.
- *
- * @param {RouteData} route - The route object to check.
- * @return {boolean} Returns true if the route is an external redirect; otherwise, false.
- */
-export declare function isRouteExternalRedirect(route: RouteData): boolean;

package/dist/core/routing/match.js

@@ -1,4 +1,3 @@
-import { redirectIsExternal } from "../redirects/render.js";
 import { SERVER_ISLAND_COMPONENT } from "../server-islands/endpoint.js";
 import { isRoute404, isRoute500 } from "./internal/route-errors.js";
 function matchRoute(pathname, manifest) {
@@ -23,12 +22,8 @@ function isRoute404or500(route) {
 function isRouteServerIsland(route) {
   return route.component === SERVER_ISLAND_COMPONENT;
 }
-function isRouteExternalRedirect(route) {
-  return !!(route.type === "redirect" && route.redirect && redirectIsExternal(route.redirect));
-}
 export {
   isRoute404or500,
-  isRouteExternalRedirect,
   isRouteServerIsland,
   matchAllRoutes,
   matchRoute

package/dist/core/routing/parse-route.js

@@ -58,7 +58,7 @@ function joinSegments(segments) {
   const arr = segments.map((segment) => {
     return segment.map((part) => part.dynamic ? `[${part.content}]` : part.content).join("");
   });
-  return `/${arr.join("/")}`.toLowerCase();
+  return `/${arr.join("/")}`;
 }
 export {
   parseRoute

package/dist/core/routing/pattern.js

@@ -16,7 +16,7 @@ function getPattern(segments, base, addTrailingSlash) {
   }).join("");
   const trailing = addTrailingSlash && segments.length ? getTrailingSlashPattern(addTrailingSlash) : "$";
   let initial = "\\/";
-  if (addTrailingSlash === "never" && base !== "/") {
+  if (addTrailingSlash === "never" && base !== "/" && pathname !== "") {
     initial = "";
   }
   return new RegExp(`^${pathname || initial}${trailing}`);

package/dist/core/routing/rewrite.js

@@ -101,7 +101,7 @@ function copyRequest(newUrl, oldRequest, isPrerendered, logger, routePattern) {
       signal: oldRequest.signal,
       keepalive: oldRequest.keepalive,
       // https://fetch.spec.whatwg.org/#dom-request-duplex
-      // @ts-expect-error It isn't part of the types, but undici accepts it and it allows to carry over the body to a new request
+      // @ts-expect-error It isn't part of the types, but undici accepts it and it allows carrying over the body to a new request
       duplex: "half"
     }
   });
@@ -134,7 +134,7 @@ function normalizeRewritePathname(urlPathname, base, trailingSlash, buildFormat)
   if (base !== "/") {
     const isBasePathRequest = urlPathname === base || urlPathname === removeTrailingForwardSlash(base);
     if (isBasePathRequest) {
-      pathname = shouldAppendSlash ? "/" : "";
+      pathname = "/";
     } else if (urlPathname.startsWith(base)) {
       pathname = shouldAppendSlash ? appendForwardSlash(urlPathname) : removeTrailingForwardSlash(urlPathname);
       pathname = pathname.slice(base.length);
@@ -143,9 +143,6 @@ function normalizeRewritePathname(urlPathname, base, trailingSlash, buildFormat)
   if (!pathname.startsWith("/") && shouldAppendSlash && urlPathname.endsWith("/")) {
     pathname = prependForwardSlash(pathname);
   }
-  if (pathname === "/" && base !== "/" && !shouldAppendSlash) {
-    pathname = "";
-  }
   if (buildFormat === "file") {
     pathname = pathname.replace(/\.html$/, "");
   }

package/dist/core/routing/router.d.ts

@@ -46,5 +46,13 @@ export declare class Router {
     match(inputPathname: string, { allowWithoutBase }?: {
         allowWithoutBase?: boolean;
     }): RouterMatch;
+    /**
+     * Returns all routes that match the given pathname, in priority order.
+     * Used when the first match (e.g. a prerendered route) cannot serve
+     * the request and subsequent matches need to be tried.
+     */
+    matchAll(inputPathname: string, { allowWithoutBase }?: {
+        allowWithoutBase?: boolean;
+    }): RouteData[];
 }
 export {};

package/dist/core/routing/router.js

@@ -57,6 +57,34 @@ class Router {
     const params = getParams(route, pathname);
     return { type: "match", route, params, pathname };
   }
+  /**
+   * Returns all routes that match the given pathname, in priority order.
+   * Used when the first match (e.g. a prerendered route) cannot serve
+   * the request and subsequent matches need to be tried.
+   */
+  matchAll(inputPathname, { allowWithoutBase = false } = {}) {
+    const normalized = getRedirectForPathname(inputPathname);
+    if (normalized.redirect) {
+      return [];
+    }
+    const baseResult = stripBase(
+      normalized.pathname,
+      this.#base,
+      this.#baseWithoutTrailingSlash,
+      this.#trailingSlash
+    );
+    if (!baseResult && !allowWithoutBase) {
+      return [];
+    }
+    let pathname = baseResult ?? normalized.pathname;
+    if (this.#buildFormat === "file") {
+      pathname = normalizeFileFormatPathname(pathname);
+    }
+    return this.#routes.filter((candidate) => {
+      if (candidate.pattern.test(pathname)) return true;
+      return candidate.fallbackRoutes.some((fallbackRoute) => fallbackRoute.pattern.test(pathname));
+    });
+  }
 }
 function normalizeBase(base) {
   if (!base) return "/";

package/dist/core/routing/trailing-slash-handler.d.ts

@@ -0,0 +1,18 @@
+import type { BaseApp } from '../app/base.js';
+import type { Pipeline } from '../base-pipeline.js';
+import type { FetchState } from '../fetch/fetch-state.js';
+/**
+ * Handles trailing-slash normalization for incoming requests. If the
+ * request's pathname does not match the app's configured `trailingSlash`
+ * policy, a redirect response is returned. Otherwise, returns `undefined`
+ * so the caller can continue processing the request.
+ */
+export declare class TrailingSlashHandler {
+    #private;
+    constructor(app: BaseApp<Pipeline>);
+    /**
+     * Returns a redirect `Response` if the request pathname needs
+     * normalization, or `undefined` if no redirect is required.
+     */
+    handle(state: FetchState): Response | undefined;
+}

package/dist/core/routing/trailing-slash-handler.js

@@ -0,0 +1,67 @@
+import {
+  appendForwardSlash,
+  collapseDuplicateTrailingSlashes,
+  hasFileExtension,
+  isInternalPath,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
+import { prepareResponse } from "../app/prepare-response.js";
+import { redirectTemplate } from "./3xx.js";
+class TrailingSlashHandler {
+  #app;
+  constructor(app) {
+    this.#app = app;
+  }
+  /**
+   * Returns a redirect `Response` if the request pathname needs
+   * normalization, or `undefined` if no redirect is required.
+   */
+  handle(state) {
+    const url = new URL(state.request.url);
+    const redirect = this.#redirectTrailingSlash(url.pathname);
+    if (redirect === url.pathname) {
+      return void 0;
+    }
+    const addCookieHeader = state.renderOptions.addCookieHeader;
+    const status = state.request.method === "GET" ? 301 : 308;
+    const response = new Response(
+      redirectTemplate({
+        status,
+        relativeLocation: url.pathname,
+        absoluteLocation: redirect,
+        from: state.request.url
+      }),
+      {
+        status,
+        headers: {
+          location: redirect + url.search
+        }
+      }
+    );
+    prepareResponse(response, { addCookieHeader });
+    return response;
+  }
+  #redirectTrailingSlash(pathname) {
+    const { trailingSlash } = this.#app.manifest;
+    if (pathname === "/" || isInternalPath(pathname)) {
+      return pathname;
+    }
+    const path = collapseDuplicateTrailingSlashes(pathname, trailingSlash !== "never");
+    if (path !== pathname) {
+      return path;
+    }
+    if (trailingSlash === "ignore") {
+      return pathname;
+    }
+    if (trailingSlash === "always" && !hasFileExtension(pathname)) {
+      return appendForwardSlash(pathname);
+    }
+    if (trailingSlash === "never") {
+      return removeTrailingForwardSlash(pathname);
+    }
+    return pathname;
+  }
+}
+export {
+  TrailingSlashHandler
+};

package/dist/core/routing/validation.js

@@ -3,7 +3,7 @@ function validateDynamicRouteModule(mod, {
   ssr,
   route
 }) {
-  if ((!ssr || route.prerender) && !mod.getStaticPaths) {
+  if ((!ssr || route.prerender) && route.origin !== "internal" && !mod.getStaticPaths) {
     throw new AstroError({
       ...AstroErrorData.GetStaticPathsRequired,
       location: { file: route.component }

package/dist/core/server-islands/vite-plugin-server-islands.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin as VitePlugin } from 'vite';
+import type { BuildEnvironment, Plugin as VitePlugin } from 'vite';
 import type { AstroPluginOptions } from '../../types/astro.js';
 import type { ServerIslandsState } from './shared-state.js';
 export declare const SERVER_ISLAND_MANIFEST = "virtual:astro:server-island-manifest";
@@ -6,3 +6,8 @@ export declare const SERVER_ISLAND_MAP_MARKER = "$$server-islands-map$$";
 export declare function vitePluginServerIslands({ settings, serverIslandsState, }: AstroPluginOptions & {
     serverIslandsState: ServerIslandsState;
 }): VitePlugin;
+/**
+ * Checks if the prerender environment discovered any server islands during the build.
+ * This encapsulates the logic of finding the server islands plugin and querying its state.
+ */
+export declare function hasServerIslands(environment: BuildEnvironment): boolean;

package/dist/core/server-islands/vite-plugin-server-islands.js

@@ -28,6 +28,11 @@ function vitePluginServerIslands({
   return {
     name: "astro:server-islands",
     enforce: "post",
+    api: {
+      hasServerIslands() {
+        return serverIslandsState.hasIslands();
+      }
+    },
     config(_config, { command: _command }) {
       command = _command;
     },
@@ -111,9 +116,8 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
           }
         }
         if (id === RESOLVED_SERVER_ISLAND_MANIFEST) {
-          if (command === "build" && settings.buildOutput) {
-            const hasServerIslands = serverIslandsState.hasIslands();
-            if (hasServerIslands && settings.buildOutput !== "server") {
+          if (command === "build") {
+            if (serverIslandsState.hasIslands() && !settings.adapter) {
               throw new AstroError(AstroErrorData.NoAdapterInstalledServerIslands);
             }
           }
@@ -163,8 +167,14 @@ export const serverIslandNameMap = ${serverIslandPlaceholderNameMap};`
     }
   };
 }
+function hasServerIslands(environment) {
+  const plugins = environment.config.plugins ?? [];
+  const serverIslandsPlugin = plugins.find((p) => p.name === "astro:server-islands");
+  return typeof serverIslandsPlugin?.api?.hasServerIslands === "function" && serverIslandsPlugin.api.hasServerIslands();
+}
 export {
   SERVER_ISLAND_MANIFEST,
   SERVER_ISLAND_MAP_MARKER,
+  hasServerIslands,
   vitePluginServerIslands
 };

package/dist/core/session/config.d.ts

@@ -15,9 +15,9 @@ export declare const SessionSchema: z.ZodObject<{
         path: z.ZodOptional<z.ZodString>;
         maxAge: z.ZodOptional<z.ZodNumber>;
         sameSite: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            none: "none";
             strict: "strict";
             lax: "lax";
-            none: "none";
         }>, z.ZodBoolean]>>;
         secure: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>, z.ZodPipe<z.ZodString, z.ZodTransform<{

package/dist/core/session/drivers.d.ts

@@ -1,6 +1,7 @@
 import type { SessionDriverConfig } from './types.js';
 export declare const sessionDrivers: {
     http: (config?: import("unstorage/drivers/http").HTTPOptions | undefined) => SessionDriverConfig;
+    fs: (config?: import("unstorage/drivers/fs").FSStorageOptions | undefined) => SessionDriverConfig;
     azureAppConfiguration: (config?: import("unstorage/drivers/azure-app-configuration").AzureAppConfigurationOptions | undefined) => SessionDriverConfig;
     azureCosmos: (config?: import("unstorage/drivers/azure-cosmos").AzureCosmosOptions | undefined) => SessionDriverConfig;
     azureKeyVault: (config?: import("unstorage/drivers/azure-key-vault").AzureKeyVaultOptions | undefined) => SessionDriverConfig;
@@ -14,7 +15,6 @@ export declare const sessionDrivers: {
     denoKVNode: (config?: import("unstorage/drivers/deno-kv-node").DenoKvNodeOptions | undefined) => SessionDriverConfig;
     denoKV: (config?: import("unstorage/drivers/deno-kv").DenoKvOptions | undefined) => SessionDriverConfig;
     fsLite: (config?: import("unstorage/drivers/fs-lite").FSStorageOptions | undefined) => SessionDriverConfig;
-    fs: (config?: import("unstorage/drivers/fs").FSStorageOptions | undefined) => SessionDriverConfig;
     github: (config?: import("unstorage/drivers/github").GithubOptions | undefined) => SessionDriverConfig;
     indexedb: (config?: import("unstorage/drivers/indexedb").IDBKeyvalOptions | undefined) => SessionDriverConfig;
     localstorage: (config?: import("unstorage/drivers/localstorage").LocalStorageOptions | undefined) => SessionDriverConfig;

package/dist/core/session/handler.d.ts

@@ -0,0 +1,11 @@
+import type { FetchState } from '../fetch/fetch-state.js';
+/**
+ * Registers a session provider on the given `FetchState`. When
+ * `state.resolve('session')` is first called, the `AstroSession` is
+ * created lazily. When `state.finalizeAll()` runs, any mutations are
+ * persisted.
+ *
+ * No-op (returns synchronously) if sessions are not configured on the
+ * pipeline, avoiding promise allocation on the hot path.
+ */
+export declare function provideSession(state: FetchState): Promise<void> | void;

package/dist/core/session/handler.js

@@ -0,0 +1,33 @@
+import { PipelineFeatures } from "../base-pipeline.js";
+import { AstroSession, PERSIST_SYMBOL } from "./runtime.js";
+const SESSION_KEY = "session";
+function provideSession(state) {
+  state.pipeline.usedFeatures |= PipelineFeatures.sessions;
+  const pipeline = state.pipeline;
+  const config = pipeline.manifest.sessionConfig;
+  if (!config) return;
+  return provideSessionAsync(state, config);
+}
+async function provideSessionAsync(state, config) {
+  const pipeline = state.pipeline;
+  const driverFactory = await pipeline.getSessionDriver();
+  if (!driverFactory) return;
+  state.provide(SESSION_KEY, {
+    create() {
+      const cookies = state.cookies;
+      return new AstroSession({
+        cookies,
+        config,
+        runtimeMode: pipeline.runtimeMode,
+        driverFactory,
+        mockStorage: null
+      });
+    },
+    finalize(session) {
+      return session[PERSIST_SYMBOL]();
+    }
+  });
+}
+export {
+  provideSession
+};

package/dist/core/session/runtime.js

@@ -121,7 +121,8 @@ class AstroSession {
    * Deletes a session value.
    */
   delete(key) {
-    this.#data?.delete(key);
+    this.#data ??= /* @__PURE__ */ new Map();
+    this.#data.delete(key);
     if (this.#partial) {
       this.#toDelete.add(key);
     }
@@ -272,11 +273,15 @@ class AstroSession {
    * If there is existing partial data, it will be merged into the new data object.
    */
   async #ensureData() {
-    const storage = await this.#ensureStorage();
     if (this.#data && !this.#partial) {
       return this.#data;
     }
     this.#data ??= /* @__PURE__ */ new Map();
+    if (!this.#sessionID && !this.#cookies.get(this.#cookieName)?.value) {
+      this.#partial = false;
+      return this.#data;
+    }
+    const storage = await this.#ensureStorage();
     const raw = await storage.get(this.#ensureSessionID());
     if (!raw) {
       if (this.#sessionIDFromCookie) {

package/dist/core/util/normalized-url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a normalized URL from a request URL string.
+ * Decodes and validates the pathname, collapses duplicate slashes.
+ */
+export declare function createNormalizedUrl(requestUrl: string): URL;
+/**
+ * Normalizes an already-parsed URL in place: decodes and validates the
+ * pathname, collapses duplicate slashes. Returns the same URL object.
+ */
+export declare function normalizeUrl(url: URL): URL;

package/dist/core/util/normalized-url.js

@@ -0,0 +1,24 @@
+import { collapseDuplicateSlashes } from "@astrojs/internal-helpers/path";
+import { MultiLevelEncodingError, validateAndDecodePathname } from "./pathname.js";
+function createNormalizedUrl(requestUrl) {
+  return normalizeUrl(new URL(requestUrl));
+}
+function normalizeUrl(url) {
+  try {
+    url.pathname = validateAndDecodePathname(url.pathname);
+  } catch (e) {
+    if (e instanceof MultiLevelEncodingError) {
+      throw e;
+    }
+    try {
+      url.pathname = decodeURI(url.pathname);
+    } catch {
+    }
+  }
+  url.pathname = collapseDuplicateSlashes(url.pathname);
+  return url;
+}
+export {
+  createNormalizedUrl,
+  normalizeUrl
+};

package/dist/core/util/pathname.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Error thrown when multi-level URL encoding is detected in a pathname.
+ * This is a distinct error type so callers can handle it specifically
+ * (e.g., returning a 400 response) rather than falling back to partial decoding.
+ */
+export declare class MultiLevelEncodingError extends Error {
+    constructor();
+}
 /**
  * Validates that a pathname is not multi-level encoded.
  * Detects if a pathname contains encoding that was encoded again (e.g., %2561dmin where %25 decodes to %).
@@ -5,6 +13,7 @@
  *
  * @param pathname - The pathname to validate
  * @returns The decoded pathname if valid
- * @throws Error if multi-level encoding is detected
+ * @throws MultiLevelEncodingError if multi-level encoding is detected
+ * @throws Error if the pathname contains invalid URL encoding
  */
 export declare function validateAndDecodePathname(pathname: string): string;

package/dist/core/util/pathname.js

@@ -1,17 +1,26 @@
+class MultiLevelEncodingError extends Error {
+  constructor() {
+    super("Multi-level URL encoding is not allowed");
+    this.name = "MultiLevelEncodingError";
+  }
+}
+const ENCODING_REGEX = /%25[0-9a-fA-F]{2}/;
 function validateAndDecodePathname(pathname) {
+  if (ENCODING_REGEX.test(pathname)) {
+    throw new MultiLevelEncodingError();
+  }
   let decoded;
   try {
     decoded = decodeURI(pathname);
   } catch (_e) {
     throw new Error("Invalid URL encoding");
   }
-  const hasDecoding = decoded !== pathname;
-  const decodedStillHasEncoding = /%[0-9a-fA-F]{2}/.test(decoded);
-  if (hasDecoding && decodedStillHasEncoding) {
-    throw new Error("Multi-level URL encoding is not allowed");
+  if (ENCODING_REGEX.test(decoded)) {
+    throw new MultiLevelEncodingError();
   }
   return decoded;
 }
 export {
+  MultiLevelEncodingError,
   validateAndDecodePathname
 };

package/dist/environments.js

@@ -1,6 +1,6 @@
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "./core/constants.js";
 function isAstroServerEnvironment(environment) {
-  return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender;
+  return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.ssr || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.prerender || environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.astro;
 }
 function isAstroClientEnvironment(environment) {
   return environment.name === ASTRO_VITE_ENVIRONMENT_NAMES.client;

package/dist/events/session.d.ts

@@ -5,6 +5,14 @@ interface EventPayload {
     configKeys?: string[];
     flags?: string[];
     optionalIntegrations?: number;
+    /** Whether the CLI session was run by an AI coding agent. */
+    isAgentic?: boolean;
+    /** ID of the detected agent, e.g. "cursor-agent", "claude-code". */
+    agentId?: string;
+    /** Display name of the detected agent, e.g. "Cursor Agent", "Claude Code". */
+    agentName?: string;
+    /** Type of agentic environment: "agent", "interactive", or "hybrid". */
+    agentType?: string;
 }
 type ConfigInfoValue = string | boolean | string[] | undefined;
 type ConfigInfoRecord = Record<string, ConfigInfoValue>;