astro 5.0.9 → 5.1.1

package/dist/core/session.js

@@ -0,0 +1,385 @@
+import { stringify, unflatten } from "devalue";
+import {
+  builtinDrivers,
+  createStorage
+} from "unstorage";
+import { SessionStorageInitError, SessionStorageSaveError } from "./errors/errors-data.js";
+import { AstroError } from "./errors/index.js";
+const PERSIST_SYMBOL = Symbol();
+const DEFAULT_COOKIE_NAME = "astro-session";
+const VALID_COOKIE_REGEX = /^[\w-]+$/;
+class AstroSession {
+  // The cookies object.
+  #cookies;
+  // The session configuration.
+  #config;
+  // The cookie config
+  #cookieConfig;
+  // The cookie name
+  #cookieName;
+  // The unstorage object for the session driver.
+  #storage;
+  #data;
+  // The session ID. A v4 UUID.
+  #sessionID;
+  // Sessions to destroy. Needed because we won't have the old session ID after it's destroyed locally.
+  #toDestroy = /* @__PURE__ */ new Set();
+  // Session keys to delete. Used for partial data sets to avoid overwriting the deleted value.
+  #toDelete = /* @__PURE__ */ new Set();
+  // Whether the session is dirty and needs to be saved.
+  #dirty = false;
+  // Whether the session cookie has been set.
+  #cookieSet = false;
+  // The local data is "partial" if it has not been loaded from storage yet and only
+  // contains values that have been set or deleted in-memory locally.
+  // We do this to avoid the need to block on loading data when it is only being set.
+  // When we load the data from storage, we need to merge it with the local partial data,
+  // preserving in-memory changes and deletions.
+  #partial = true;
+  constructor(cookies, {
+    cookie: cookieConfig = DEFAULT_COOKIE_NAME,
+    ...config
+  }) {
+    this.#cookies = cookies;
+    if (typeof cookieConfig === "object") {
+      this.#cookieConfig = cookieConfig;
+      this.#cookieName = cookieConfig.name || DEFAULT_COOKIE_NAME;
+    } else {
+      this.#cookieName = cookieConfig || DEFAULT_COOKIE_NAME;
+    }
+    this.#config = config;
+  }
+  /**
+   * Gets a session value. Returns `undefined` if the session or value does not exist.
+   */
+  async get(key) {
+    return (await this.#ensureData()).get(key)?.data;
+  }
+  /**
+   * Checks if a session value exists.
+   */
+  async has(key) {
+    return (await this.#ensureData()).has(key);
+  }
+  /**
+   * Gets all session values.
+   */
+  async keys() {
+    return (await this.#ensureData()).keys();
+  }
+  /**
+   * Gets all session values.
+   */
+  async values() {
+    return [...(await this.#ensureData()).values()].map((entry) => entry.data);
+  }
+  /**
+   * Gets all session entries.
+   */
+  async entries() {
+    return [...(await this.#ensureData()).entries()].map(([key, entry]) => [key, entry.data]);
+  }
+  /**
+   * Deletes a session value.
+   */
+  delete(key) {
+    this.#data?.delete(key);
+    if (this.#partial) {
+      this.#toDelete.add(key);
+    }
+    this.#dirty = true;
+  }
+  /**
+   * Sets a session value. The session is created if it does not exist.
+   */
+  set(key, value, { ttl } = {}) {
+    if (!key) {
+      throw new AstroError({
+        ...SessionStorageSaveError,
+        message: "The session key was not provided."
+      });
+    }
+    try {
+      stringify(value);
+    } catch (err) {
+      throw new AstroError(
+        {
+          ...SessionStorageSaveError,
+          message: `The session data for ${key} could not be serialized.`,
+          hint: "See the devalue library for all supported types: https://github.com/rich-harris/devalue"
+        },
+        { cause: err }
+      );
+    }
+    if (!this.#cookieSet) {
+      this.#setCookie();
+      this.#cookieSet = true;
+    }
+    this.#data ??= /* @__PURE__ */ new Map();
+    const lifetime = ttl ?? this.#config.ttl;
+    const expires = typeof lifetime === "number" ? Date.now() + lifetime * 1e3 : lifetime;
+    this.#data.set(key, {
+      data: value,
+      expires
+    });
+    this.#dirty = true;
+  }
+  /**
+   * Destroys the session, clearing the cookie and storage if it exists.
+   */
+  destroy() {
+    this.#destroySafe();
+  }
+  /**
+   * Regenerates the session, creating a new session ID. The existing session data is preserved.
+   */
+  async regenerate() {
+    let data = /* @__PURE__ */ new Map();
+    try {
+      data = await this.#ensureData();
+    } catch (err) {
+      console.error("Failed to load session data during regeneration:", err);
+    }
+    const oldSessionId = this.#sessionID;
+    this.#sessionID = void 0;
+    this.#data = data;
+    this.#ensureSessionID();
+    await this.#setCookie();
+    if (oldSessionId && this.#storage) {
+      this.#storage.removeItem(oldSessionId).catch((err) => {
+        console.error("Failed to remove old session data:", err);
+      });
+    }
+  }
+  // Persists the session data to storage.
+  // This is called automatically at the end of the request.
+  // Uses a symbol to prevent users from calling it directly.
+  async [PERSIST_SYMBOL]() {
+    if (!this.#dirty && !this.#toDestroy.size) {
+      return;
+    }
+    const storage = await this.#ensureStorage();
+    if (this.#dirty && this.#data) {
+      const data = await this.#ensureData();
+      this.#toDelete.forEach((key2) => data.delete(key2));
+      const key = this.#ensureSessionID();
+      let serialized;
+      try {
+        serialized = stringify(data, {
+          // Support URL objects
+          URL: (val) => val instanceof URL && val.href
+        });
+      } catch (err) {
+        throw new AstroError(
+          {
+            ...SessionStorageSaveError,
+            message: SessionStorageSaveError.message(
+              "The session data could not be serialized.",
+              this.#config.driver
+            )
+          },
+          { cause: err }
+        );
+      }
+      await storage.setItem(key, serialized);
+      this.#dirty = false;
+    }
+    if (this.#toDestroy.size > 0) {
+      const cleanupPromises = [...this.#toDestroy].map(
+        (sessionId) => storage.removeItem(sessionId).catch((err) => {
+          console.error(`Failed to clean up session ${sessionId}:`, err);
+        })
+      );
+      await Promise.all(cleanupPromises);
+      this.#toDestroy.clear();
+    }
+  }
+  get sessionID() {
+    return this.#sessionID;
+  }
+  /**
+   * Sets the session cookie.
+   */
+  async #setCookie() {
+    if (!VALID_COOKIE_REGEX.test(this.#cookieName)) {
+      throw new AstroError({
+        ...SessionStorageSaveError,
+        message: "Invalid cookie name. Cookie names can only contain letters, numbers, and dashes."
+      });
+    }
+    const cookieOptions = {
+      sameSite: "lax",
+      secure: true,
+      path: "/",
+      ...this.#cookieConfig,
+      httpOnly: true
+    };
+    const value = this.#ensureSessionID();
+    this.#cookies.set(this.#cookieName, value, cookieOptions);
+  }
+  /**
+   * Attempts to load the session data from storage, or creates a new data object if none exists.
+   * 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();
+    const raw = await storage.get(this.#ensureSessionID());
+    if (!raw) {
+      return this.#data;
+    }
+    try {
+      const storedMap = unflatten(raw, {
+        // Revive URL objects
+        URL: (href) => new URL(href)
+      });
+      if (!(storedMap instanceof Map)) {
+        await this.#destroySafe();
+        throw new AstroError({
+          ...SessionStorageInitError,
+          message: SessionStorageInitError.message(
+            "The session data was an invalid type.",
+            this.#config.driver
+          )
+        });
+      }
+      const now = Date.now();
+      for (const [key, value] of storedMap) {
+        const expired = typeof value.expires === "number" && value.expires < now;
+        if (!this.#data.has(key) && !this.#toDelete.has(key) && !expired) {
+          this.#data.set(key, value);
+        }
+      }
+      this.#partial = false;
+      return this.#data;
+    } catch (err) {
+      await this.#destroySafe();
+      if (err instanceof AstroError) {
+        throw err;
+      }
+      throw new AstroError(
+        {
+          ...SessionStorageInitError,
+          message: SessionStorageInitError.message(
+            "The session data could not be parsed.",
+            this.#config.driver
+          )
+        },
+        { cause: err }
+      );
+    }
+  }
+  /**
+   * Safely destroys the session, clearing the cookie and storage if it exists.
+   */
+  #destroySafe() {
+    if (this.#sessionID) {
+      this.#toDestroy.add(this.#sessionID);
+    }
+    if (this.#cookieName) {
+      this.#cookies.delete(this.#cookieName);
+    }
+    this.#sessionID = void 0;
+    this.#data = void 0;
+    this.#dirty = true;
+  }
+  /**
+   * Returns the session ID, generating a new one if it does not exist.
+   */
+  #ensureSessionID() {
+    this.#sessionID ??= this.#cookies.get(this.#cookieName)?.value ?? crypto.randomUUID();
+    return this.#sessionID;
+  }
+  /**
+   * Ensures the storage is initialized.
+   * This is called automatically when a storage operation is needed.
+   */
+  async #ensureStorage() {
+    if (this.#storage) {
+      return this.#storage;
+    }
+    if (this.#config.driver === "test") {
+      this.#storage = this.#config.options.mockStorage;
+      return this.#storage;
+    }
+    if (this.#config.driver === "fs" || this.#config.driver === "fsLite" || this.#config.driver === "fs-lite") {
+      this.#config.options ??= {};
+      this.#config.driver = "fs-lite";
+      this.#config.options.base ??= ".astro/session";
+    }
+    if (!this.#config?.driver) {
+      throw new AstroError({
+        ...SessionStorageInitError,
+        message: SessionStorageInitError.message(
+          "No driver was defined in the session configuration and the adapter did not provide a default driver."
+        )
+      });
+    }
+    let driver = null;
+    const driverPackage = await resolveSessionDriver(this.#config.driver);
+    try {
+      if (this.#config.driverModule) {
+        driver = (await this.#config.driverModule()).default;
+      } else if (driverPackage) {
+        driver = (await import(driverPackage)).default;
+      }
+    } catch (err) {
+      if (err.code === "ERR_MODULE_NOT_FOUND") {
+        throw new AstroError(
+          {
+            ...SessionStorageInitError,
+            message: SessionStorageInitError.message(
+              err.message.includes(`Cannot find package '${driverPackage}'`) ? "The driver module could not be found." : err.message,
+              this.#config.driver
+            )
+          },
+          { cause: err }
+        );
+      }
+      throw err;
+    }
+    if (!driver) {
+      throw new AstroError({
+        ...SessionStorageInitError,
+        message: SessionStorageInitError.message(
+          "The module did not export a driver.",
+          this.#config.driver
+        )
+      });
+    }
+    try {
+      this.#storage = createStorage({
+        driver: driver(this.#config.options)
+      });
+      return this.#storage;
+    } catch (err) {
+      throw new AstroError(
+        {
+          ...SessionStorageInitError,
+          message: SessionStorageInitError.message("Unknown error", this.#config.driver)
+        },
+        { cause: err }
+      );
+    }
+  }
+}
+function resolveSessionDriver(driver) {
+  if (!driver) {
+    return null;
+  }
+  if (driver === "fs") {
+    return import.meta.resolve(builtinDrivers.fsLite);
+  }
+  if (driver in builtinDrivers) {
+    return import.meta.resolve(builtinDrivers[driver]);
+  }
+  return driver;
+}
+export {
+  AstroSession,
+  PERSIST_SYMBOL,
+  resolveSessionDriver
+};

package/dist/i18n/middleware.js

@@ -20,12 +20,12 @@ function createI18nMiddleware(i18n, base, trailingSlash, format) {
   const _noFoundForNonLocaleRoute = notFound(payload);
   const _requestHasLocale = requestHasLocale(payload.locales);
   const _redirectToFallback = redirectToFallback(payload);
-  const prefixAlways = (context) => {
+  const prefixAlways = (context, response) => {
     const url = context.url;
     if (url.pathname === base + "/" || url.pathname === base) {
       return _redirectToDefaultLocale(context);
     } else if (!_requestHasLocale(context)) {
-      return _noFoundForNonLocaleRoute(context);
+      return _noFoundForNonLocaleRoute(context, response);
     }
     return void 0;
   };
@@ -96,7 +96,7 @@ function createI18nMiddleware(i18n, base, trailingSlash, format) {
         break;
       }
       case "pathname-prefix-always": {
-        const result = prefixAlways(context);
+        const result = prefixAlways(context, response);
         if (result) {
           return result;
         }
@@ -104,7 +104,7 @@ function createI18nMiddleware(i18n, base, trailingSlash, format) {
       }
       case "domains-prefix-always": {
         if (localeHasntDomain(i18n, currentLocale)) {
-          const result = prefixAlways(context);
+          const result = prefixAlways(context, response);
           if (result) {
             return result;
           }

package/dist/types/public/common.d.ts

@@ -67,7 +67,7 @@ export interface Page<T = any> {
         next: string | undefined;
         /** url of the first page (if the current page is not the first page) */
         first: string | undefined;
-        /** url of the next page (if the current page in not the last page) */
+        /** url of the last page (if the current page is not the last page) */
         last: string | undefined;
     };
 }

package/dist/types/public/config.d.ts

@@ -1,5 +1,6 @@
 import type { OutgoingHttpHeaders } from 'node:http';
 import type { RehypePlugins, RemarkPlugins, RemarkRehype, ShikiConfig } from '@astrojs/markdown-remark';
+import type { BuiltinDriverName, BuiltinDriverOptions, Driver, Storage } from 'unstorage';
 import type { UserConfig as OriginalViteUserConfig, SSROptions as ViteSSROptions } from 'vite';
 import type { ImageFit, ImageLayout } from '../../assets/types.js';
 import type { RemotePattern } from '../../assets/utils/remotePattern.js';
@@ -7,6 +8,7 @@ import type { SvgRenderMode } from '../../assets/utils/svg.js';
 import type { AssetsPrefix } from '../../core/app/types.js';
 import type { AstroConfigType } from '../../core/config/schema.js';
 import type { REDIRECT_STATUS_CODES } from '../../core/constants.js';
+import type { AstroCookieSetOptions } from '../../core/cookies/cookies.js';
 import type { LoggerLevel } from '../../core/logger/core.js';
 import type { EnvSchema } from '../../env/schema.js';
 import type { AstroIntegration } from './integrations.js';
@@ -79,6 +81,41 @@ export type ServerConfig = {
      */
     open?: string | boolean;
 };
+export type SessionDriverName = BuiltinDriverName | 'custom' | 'test';
+interface CommonSessionConfig {
+    /**
+     * Configures the session cookie. If set to a string, it will be used as the cookie name.
+     * Alternatively, you can pass an object with additional options.
+     */
+    cookie?: string | (Omit<AstroCookieSetOptions, 'httpOnly' | 'expires' | 'encode'> & {
+        name?: string;
+    });
+    /**
+     * Default session duration in seconds. If not set, the session will be stored until deleted, or until the cookie expires.
+     */
+    ttl?: number;
+}
+interface BuiltinSessionConfig<TDriver extends keyof BuiltinDriverOptions> extends CommonSessionConfig {
+    driver: TDriver;
+    options?: BuiltinDriverOptions[TDriver];
+}
+interface CustomSessionConfig extends CommonSessionConfig {
+    /** Entrypoint for a custom session driver */
+    driver: string;
+    options?: Record<string, unknown>;
+}
+interface TestSessionConfig extends CommonSessionConfig {
+    driver: 'test';
+    options: {
+        mockStorage: Storage;
+    };
+}
+export type SessionConfig<TDriver extends SessionDriverName> = TDriver extends keyof BuiltinDriverOptions ? BuiltinSessionConfig<TDriver> : TDriver extends 'test' ? TestSessionConfig : CustomSessionConfig;
+export type ResolvedSessionConfig<TDriver extends SessionDriverName> = SessionConfig<TDriver> & {
+    driverModule?: () => Promise<{
+        default: () => Driver;
+    }>;
+};
 export interface ViteUserConfig extends OriginalViteUserConfig {
     ssr?: ViteSSROptions;
 }
@@ -87,7 +124,7 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
  * Docs: https://docs.astro.build/reference/configuration-reference/
  *
  * Generics do not follow semver and may change at any time.
- */ export interface AstroUserConfig<TLocales extends Locales = never> {
+ */ export interface AstroUserConfig<TLocales extends Locales = never, TSession extends SessionDriverName = never> {
     /**
      * @docs
      * @kind heading
@@ -515,8 +552,8 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
          *
          * #### Effect on Astro.url
          * Setting `build.format` controls what `Astro.url` is set to during the build. When it is:
-         * - `directory` - The `Astro.url.pathname` will include a trailing slash to mimic folder behavior; ie `/foo/`.
-         * - `file` - The `Astro.url.pathname` will include `.html`; ie `/foo.html`.
+         * - `directory` - The `Astro.url.pathname` will include a trailing slash to mimic folder behavior. (e.g. `/foo/`)
+         * - `file` - The `Astro.url.pathname` will include `.html`. (e.g. `/foo.html`)
          *
          * This means that when you create relative URLs using `new URL('./relative', Astro.url)`, you will get consistent behavior between dev and build.
          *
@@ -1818,6 +1855,49 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
          * The `densities` attribute is not compatible with responsive images and will be ignored if set.
          */
         responsiveImages?: boolean;
+        /**
+         *
+         * @name experimental.session
+         * @type {SessionConfig}
+         * @version 5.0.0
+         * @description
+         *
+         * Enables support for sessions in Astro. Sessions are used to store user data across requests, such as user authentication state.
+         *
+         * When enabled you can access the `Astro.session` object to read and write data that persists across requests. You can configure the session driver using the [`session` option](#session), or use the default provided by your adapter.
+         *
+         * ```astro title=src/components/CartButton.astro
+         * ---
+         * export const prerender = false; // Not needed in 'server' mode
+         * const cart = await Astro.session.get('cart');
+         * ---
+         *
+         * <a href="/checkout">🛒 {cart?.length ?? 0} items</a>
+         *
+         * ```
+         * The object configures session management for your Astro site by specifying a `driver` as well as any `options` for your data storage.
+         *
+         * You can specify [any driver from Unstorage](https://unstorage.unjs.io/drivers) or provide a custom config which will override your adapter's default.
+         *
+         * ```js title="astro.config.mjs"
+         * 	{
+         * 		experimental: {
+         *  		session: {
+         *    		// Required: the name of the Unstorage driver
+         *    		driver: "redis",
+         *   			// The required options depend on the driver
+         *   			options: {
+         *     			url: process.env.REDIS_URL,
+         * 				}
+         * 			}
+         *   	},
+         * 	}
+         * ```
+         *
+         * For more details, see [the Sessions RFC](https://github.com/withastro/roadmap/blob/sessions/proposals/0054-sessions.md).
+         *
+         */
+        session?: SessionConfig<TSession>;
         /**
          *
          * @name experimental.svg

package/dist/types/public/context.d.ts

@@ -2,6 +2,7 @@ import type { z } from 'zod';
 import type { ActionAccept, ActionClient, ActionReturnType } from '../../actions/runtime/virtual/server.js';
 import type { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from '../../core/constants.js';
 import type { AstroCookies } from '../../core/cookies/cookies.js';
+import type { AstroSession } from '../../core/session.js';
 import type { AstroComponentFactory } from '../../runtime/server/index.js';
 import type { Params, RewritePayload } from './common.js';
 import type { ValidRedirectStatus } from './config.js';
@@ -239,6 +240,10 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
      * Utility for getting and setting the values of cookies.
      */
     cookies: AstroCookies;
+    /**
+     * Utility for handling sessions.
+     */
+    session?: AstroSession;
     /**
      * Information about the current request. This is a standard [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request) object
      */

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

@@ -150,7 +150,8 @@ function createDevelopmentManifest(settings) {
       return {
         onRequest: NOOP_MIDDLEWARE_FN
       };
-    }
+    },
+    sessionConfig: settings.config.experimental.session
   };
 }
 export {

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

@@ -14,6 +14,7 @@ import { getProps } from "../core/render/index.js";
 import { createRequest } from "../core/request.js";
 import { redirectTemplate } from "../core/routing/3xx.js";
 import { matchAllRoutes } from "../core/routing/index.js";
+import { PERSIST_SYMBOL } from "../core/session.js";
 import { getSortedPreloadedMatches } from "../prerender/routing.js";
 import { writeSSRResult, writeWebResponse } from "./response.js";
 function isLoggedRequest(url) {
@@ -158,6 +159,8 @@ async function handleRoute({
     renderContext.props.error = err;
     response = await renderContext.render(preloaded500Component);
     statusCode = 500;
+  } finally {
+    renderContext.session?.[PERSIST_SYMBOL]();
   }
   if (isLoggedRequest(pathname)) {
     const timeEnd = performance.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "5.0.9",
+  "version": "5.1.1",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -148,8 +148,9 @@
     "tsconfck": "^3.1.4",
     "ultrahtml": "^1.5.3",
     "unist-util-visit": "^5.0.0",
+    "unstorage": "^1.14.0",
     "vfile": "^6.0.3",
-    "vite": "^6.0.1",
+    "vite": "^6.0.5",
     "vitefu": "^1.0.4",
     "which-pm": "^3.0.0",
     "xxhash-wasm": "^1.1.0",
@@ -159,8 +160,8 @@
     "zod-to-json-schema": "^3.23.5",
     "zod-to-ts": "^1.2.0",
     "@astrojs/internal-helpers": "0.4.2",
-    "@astrojs/telemetry": "3.2.0",
-    "@astrojs/markdown-remark": "6.0.1"
+    "@astrojs/markdown-remark": "6.0.1",
+    "@astrojs/telemetry": "3.2.0"
   },
   "optionalDependencies": {
     "sharp": "^0.33.3"

package/templates/actions.mjs

@@ -1,4 +1,5 @@
 import {
+	ACTION_QUERY_PARAMS,
 	ActionError,
 	appendForwardSlash,
 	deserializeActionResult,
@@ -52,6 +53,17 @@ function toActionProxy(actionCallback = {}, aggregatedPath = '') {
 	});
 }
 
+const SHOULD_APPEND_TRAILING_SLASH = '/** @TRAILING_SLASH@ **/';
+
+/** @param {import('astro:actions').ActionClient<any, any, any>} */
+export function getActionPath(action) {
+	let path = `${import.meta.env.BASE_URL.replace(/\/$/, '')}/_actions/${new URLSearchParams(action.toString()).get(ACTION_QUERY_PARAMS.actionName)}`;
+	if (SHOULD_APPEND_TRAILING_SLASH) {
+		path = appendForwardSlash(path);
+	}
+	return path;
+}
+
 /**
  * @param {*} param argument passed to the action when called server or client-side.
  * @param {string} path Built path to call action by path name.
@@ -88,19 +100,19 @@ async function handleAction(param, path, context) {
 			headers.set('Content-Length', '0');
 		}
 	}
+	const rawResult = await fetch(
+		getActionPath({
+			toString() {
+				return getActionQueryString(path);
+			},
+		}),
+		{
+			method: 'POST',
+			body,
+			headers,
+		},
+	);
 
-	const shouldAppendTrailingSlash = '/** @TRAILING_SLASH@ **/';
-	let actionPath = import.meta.env.BASE_URL.replace(/\/$/, '') + '/_actions/' + path;
-
-	if (shouldAppendTrailingSlash) {
-		actionPath = appendForwardSlash(actionPath);
-	}
-
-	const rawResult = await fetch(actionPath, {
-		method: 'POST',
-		body,
-		headers,
-	});
 	if (rawResult.status === 204) {
 		return deserializeActionResult({ type: 'empty', status: 204 });
 	}

package/types/actions.d.ts

@@ -1,3 +1,7 @@
 declare module 'astro:actions' {
 	export * from 'astro/actions/runtime/virtual/server.js';
+
+	export function getActionPath(
+		action: import('astro/actions/runtime/virtual/server.js').ActionClient<any, any, any>,
+	): string;
 }