astro 5.16.5 → 6.0.0-alpha.1

package/{astro.js → bin/astro.mjs}

@@ -1,9 +1,6 @@
 #!/usr/bin/env node
 'use strict';
 
-// ISOMORPHIC FILE: NO TOP-LEVEL IMPORT/REQUIRE() ALLOWED
-// This file has to run as both ESM and CJS on older Node.js versions
-
 const CI_INSTRUCTIONS = {
 	NETLIFY: 'https://docs.netlify.com/configure-builds/manage-dependencies/#node-js-and-javascript',
 	GITHUB_ACTIONS:
@@ -11,9 +8,12 @@ const CI_INSTRUCTIONS = {
 	VERCEL: 'https://vercel.com/docs/runtimes#official-runtimes/node-js/node-js-version',
 };
 
+// TODO: remove once Stackblitz supports Node 22
+const IS_STACKBLITZ = !!process.versions.webcontainer;
+
 // Hardcode supported Node.js version so we don't have to read differently in CJS & ESM.
-const engines = '>=18.20.8';
-const skipSemverCheckIfAbove = 19;
+const engines = IS_STACKBLITZ ? '>=20.19.5' : '>=22.12.0';
+const skipSemverCheckIfAbove = IS_STACKBLITZ ? 21 : 23;
 
 /** `astro *` */
 async function main() {
@@ -39,7 +39,7 @@ async function main() {
 		if (correctedCwd !== cwd) process.chdir(correctedCwd);
 	}
 
-	return import('./dist/cli/index.js')
+	return import('../dist/cli/index.js')
 		.then(({ cli }) => cli(process.argv))
 		.catch((error) => {
 			console.error(error);
@@ -52,8 +52,7 @@ async function errorNodeUnsupported() {
 Node.js v${process.versions.node} is not supported by Astro!
 Please upgrade Node.js to a supported version: "${engines}"\n`);
 
-	// eslint-disable-next-line @typescript-eslint/no-require-imports
-	const ci = typeof require !== 'undefined' ? require('ci-info') : await import('ci-info');
+	const ci = await import('ci-info');
 
 	// Special instructions for CI environments, which may have special steps needed.
 	// This is a common issue that we can help users with proactively.

package/client.d.ts

@@ -1,12 +1,16 @@
 /// <reference types="vite/types/import-meta.d.ts" />
-/// <reference path="./types/content.d.ts" />
+
 /// <reference path="./types/actions.d.ts" />
+/// <reference path="./types/content.d.ts" />
 /// <reference path="./types/env.d.ts" />
 /// <reference path="./types/fonts.d.ts" />
+/// <reference path="./types/transitions.d.ts" />
 
 interface ImportMetaEnv {
+	// TODO: remove in Astro 7
 	/**
 	 * The prefix for Astro-generated asset links if the build.assetsPrefix config option is set. This can be used to create asset links not handled by Astro.
+	 * @deprecated This will be removed in a future major version of Astro. Use `build.assetsPrefix` from `astro:config/server` instead.
 	 */
 	readonly ASSETS_PREFIX: string | Record<string, string>;
 	/**
@@ -117,50 +121,6 @@ declare module '*.svg' {
 	export default Component;
 }
 
-declare module 'astro:transitions' {
-	type TransitionModule = typeof import('./dist/virtual-modules/transitions.js');
-	export const slide: TransitionModule['slide'];
-	export const fade: TransitionModule['fade'];
-	export const createAnimationScope: TransitionModule['createAnimationScope'];
-
-	type ClientRouterModule = typeof import('./components/ClientRouter.astro');
-	/**
-	 * @deprecated The ViewTransitions component has been renamed to ClientRouter
-	 */
-	export const ViewTransitions: ClientRouterModule['default'];
-	export const ClientRouter: ClientRouterModule['default'];
-}
-
-declare module 'astro:transitions/client' {
-	type TransitionRouterModule = typeof import('./dist/virtual-modules/transitions-router.js');
-	export const navigate: TransitionRouterModule['navigate'];
-	export const supportsViewTransitions: TransitionRouterModule['supportsViewTransitions'];
-	export const getFallback: TransitionRouterModule['getFallback'];
-	export const transitionEnabledOnThisPage: TransitionRouterModule['transitionEnabledOnThisPage'];
-
-	export type Fallback = import('./dist/virtual-modules/transitions-types.js').Fallback;
-	export type Direction = import('./dist/virtual-modules/transitions-types.ts').Direction;
-	// biome-ignore format: bug
-	export type NavigationTypeString = import('./dist/virtual-modules/transitions-types.js').NavigationTypeString;
-	export type Options = import('./dist/virtual-modules/transitions-types.js').Options;
-
-	type EventModule = typeof import('./dist/virtual-modules/transitions-events.js');
-	export const TRANSITION_BEFORE_PREPARATION: EventModule['TRANSITION_BEFORE_PREPARATION'];
-	export const TRANSITION_AFTER_PREPARATION: EventModule['TRANSITION_AFTER_PREPARATION'];
-	export const TRANSITION_BEFORE_SWAP: EventModule['TRANSITION_BEFORE_SWAP'];
-	export const TRANSITION_AFTER_SWAP: EventModule['TRANSITION_AFTER_SWAP'];
-	export const TRANSITION_PAGE_LOAD: EventModule['TRANSITION_PAGE_LOAD'];
-	// biome-ignore format: bug
-	export type TransitionBeforePreparationEvent = import('./dist/virtual-modules/transitions-events.js').TransitionBeforePreparationEvent;
-	// biome-ignore format: bug
-	export type TransitionBeforeSwapEvent = import('./dist/virtual-modules/transitions-events.js').TransitionBeforeSwapEvent;
-	export const isTransitionBeforePreparationEvent: EventModule['isTransitionBeforePreparationEvent'];
-	export const isTransitionBeforeSwapEvent: EventModule['isTransitionBeforeSwapEvent'];
-	// biome-ignore format: bug
-	type TransitionSwapFunctionModule = typeof import('./dist/virtual-modules/transitions-swap-functions.js');
-	export const swapFunctions: TransitionSwapFunctionModule['swapFunctions'];
-}
-
 declare module 'astro:prefetch' {
 	export { prefetch, PrefetchOptions } from 'astro/virtual-modules/prefetch.js';
 }
@@ -195,8 +155,22 @@ declare module 'astro:components' {
 	export * from 'astro/components';
 }
 
+// TODO: remove in Astro 7
+/**
+ * @deprecated
+ * `import { z } from 'astro:schema'` is deprecated and will be removed
+ * in Astro 7. Use `import { z } from 'astro/zod'` instead.
+ */
 declare module 'astro:schema' {
 	export * from 'astro/zod';
+	import zod from 'astro/zod';
+
+	/**
+	 * @deprecated
+	 * `import { z } from 'astro:schema'` is deprecated and will be removed
+	 * in Astro 7. Use `import { z } from 'astro/zod'` instead.
+	 */
+	export const z = zod.z;
 }
 
 type MD = import('./dist/types/public/content.js').MarkdownInstance<Record<string, any>>;

package/components/ClientRouter.astro

@@ -3,11 +3,6 @@ type Fallback = 'none' | 'animate' | 'swap';
 
 export interface Props {
 	fallback?: Fallback;
-	/** @deprecated handleForms is enabled by default in Astro 4.0
-	 *
-	 * Set `data-astro-reload` on your form to opt-out of the default behavior.
-	 */
-	handleForms?: boolean;
 }
 
 const { fallback = 'animate' } = Astro.props;

package/components/Code.astro

@@ -3,8 +3,8 @@ import type { ThemePresets } from '@astrojs/markdown-remark';
 import type { ShikiTransformer, ThemeRegistration, ThemeRegistrationRaw } from 'shiki';
 import { bundledLanguages } from 'shiki/langs';
 import { getCachedHighlighter } from '../dist/core/shiki.js';
-import type { CodeLanguage } from '../dist/types/public';
-import type { HTMLAttributes } from '../types';
+import type { CodeLanguage } from '../dist/types/public/common.js';
+import type { HTMLAttributes } from '../types.js';
 
 interface Props extends Omit<HTMLAttributes<'pre'>, 'lang'> {
 	/** The code to highlight. Required. */

package/components/Image.astro

@@ -1,8 +1,8 @@
 ---
 import { getImage, imageConfig, type LocalImageProps, type RemoteImageProps } from 'astro:assets';
-import type { UnresolvedImageTransform } from '../dist/assets/types';
+import type { UnresolvedImageTransform } from '../dist/assets/types.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
-import type { HTMLAttributes } from '../types';
+import type { HTMLAttributes } from '../types.js';
 
 // The TypeScript diagnostic for JSX props uses the last member of the union to suggest props, so it would be better for
 // LocalImageProps to be last. Unfortunately, when we do this the error messages that remote images get are complete nonsense

package/components/Picture.astro

@@ -8,7 +8,7 @@ import type {
 	ImageOutputFormat,
 	UnresolvedImageTransform,
 } from '../dist/types/public/index.js';
-import type { HTMLAttributes } from '../types';
+import type { HTMLAttributes } from '../types.js';
 
 export type Props = (LocalImageProps | RemoteImageProps) & {
 	formats?: ImageOutputFormat[];

package/dist/actions/consts.d.ts

@@ -1,11 +1,8 @@
 export declare const ACTIONS_TYPES_FILE = "actions.d.ts";
 export declare const VIRTUAL_MODULE_ID = "astro:actions";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
-/** Used to expose shared utilities, with server or client specific implementations */
-export declare const RUNTIME_VIRTUAL_MODULE_ID = "virtual:astro:actions/runtime";
-export declare const RESOLVED_RUNTIME_VIRTUAL_MODULE_ID: string;
-export declare const ENTRYPOINT_VIRTUAL_MODULE_ID = "virtual:astro:actions/entrypoint";
-export declare const RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID: string;
+export declare const ACTIONS_ENTRYPOINT_VIRTUAL_MODULE_ID = "virtual:astro:actions/entrypoint";
+export declare const ACTIONS_RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID: string;
 /** Used to pass data from the config to the main virtual module */
 export declare const OPTIONS_VIRTUAL_MODULE_ID = "virtual:astro:actions/options";
 export declare const RESOLVED_OPTIONS_VIRTUAL_MODULE_ID: string;

package/dist/actions/consts.js

@@ -1,10 +1,8 @@
 const ACTIONS_TYPES_FILE = "actions.d.ts";
 const VIRTUAL_MODULE_ID = "astro:actions";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-const RUNTIME_VIRTUAL_MODULE_ID = "virtual:astro:actions/runtime";
-const RESOLVED_RUNTIME_VIRTUAL_MODULE_ID = "\0" + RUNTIME_VIRTUAL_MODULE_ID;
-const ENTRYPOINT_VIRTUAL_MODULE_ID = "virtual:astro:actions/entrypoint";
-const RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID = "\0" + ENTRYPOINT_VIRTUAL_MODULE_ID;
+const ACTIONS_ENTRYPOINT_VIRTUAL_MODULE_ID = "virtual:astro:actions/entrypoint";
+const ACTIONS_RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID = "\0" + ACTIONS_ENTRYPOINT_VIRTUAL_MODULE_ID;
 const OPTIONS_VIRTUAL_MODULE_ID = "virtual:astro:actions/options";
 const RESOLVED_OPTIONS_VIRTUAL_MODULE_ID = "\0" + OPTIONS_VIRTUAL_MODULE_ID;
 const RESOLVED_NOOP_ENTRYPOINT_VIRTUAL_MODULE_ID = "\0virtual:astro:actions/noop-entrypoint";
@@ -14,16 +12,14 @@ const ACTION_QUERY_PARAMS = {
 };
 const ACTION_RPC_ROUTE_PATTERN = "/_actions/[...path]";
 export {
+  ACTIONS_ENTRYPOINT_VIRTUAL_MODULE_ID,
+  ACTIONS_RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID,
   ACTIONS_TYPES_FILE,
   ACTION_QUERY_PARAMS,
   ACTION_RPC_ROUTE_PATTERN,
-  ENTRYPOINT_VIRTUAL_MODULE_ID,
   OPTIONS_VIRTUAL_MODULE_ID,
-  RESOLVED_ENTRYPOINT_VIRTUAL_MODULE_ID,
   RESOLVED_NOOP_ENTRYPOINT_VIRTUAL_MODULE_ID,
   RESOLVED_OPTIONS_VIRTUAL_MODULE_ID,
-  RESOLVED_RUNTIME_VIRTUAL_MODULE_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
-  RUNTIME_VIRTUAL_MODULE_ID,
   VIRTUAL_MODULE_ID
 };

package/dist/actions/integration.js

@@ -12,7 +12,7 @@ function astroIntegrationActionsRouteHandler({
       async "astro:config:setup"() {
         settings.injectedRoutes.push({
           pattern: ACTION_RPC_ROUTE_PATTERN,
-          entrypoint: "astro/actions/runtime/route.js",
+          entrypoint: "astro/actions/runtime/entrypoints/route.js",
           prerender: false,
           origin: "internal"
         });
@@ -29,9 +29,7 @@ function astroIntegrationActionsRouteHandler({
         settings.injectedTypes.push({
           filename: ACTIONS_TYPES_FILE,
           content: `declare module "astro:actions" {
-	type Actions = typeof import(${stringifiedActionsImport})["server"];
-
-	export const actions: Actions;
+	export const actions: typeof import(${stringifiedActionsImport})["server"];
 }`
         });
       }

package/dist/actions/runtime/client.d.ts

@@ -1,3 +1,84 @@
-export * from './shared.js';
-export declare function defineAction(): void;
-export declare function getActionContext(): void;
+import type * as z from 'zod/v4/core';
+import type { ActionClient, ActionErrorCode, ErrorInferenceObject, SafeResult, SerializedActionResult } from './types.js';
+import type { APIContext } from '../../types/public/context.js';
+export declare const codeToStatusMap: {
+    BAD_REQUEST: number;
+    UNAUTHORIZED: number;
+    PAYMENT_REQUIRED: number;
+    FORBIDDEN: number;
+    NOT_FOUND: number;
+    METHOD_NOT_ALLOWED: number;
+    NOT_ACCEPTABLE: number;
+    PROXY_AUTHENTICATION_REQUIRED: number;
+    REQUEST_TIMEOUT: number;
+    CONFLICT: number;
+    GONE: number;
+    LENGTH_REQUIRED: number;
+    PRECONDITION_FAILED: number;
+    CONTENT_TOO_LARGE: number;
+    URI_TOO_LONG: number;
+    UNSUPPORTED_MEDIA_TYPE: number;
+    RANGE_NOT_SATISFIABLE: number;
+    EXPECTATION_FAILED: number;
+    MISDIRECTED_REQUEST: number;
+    UNPROCESSABLE_CONTENT: number;
+    LOCKED: number;
+    FAILED_DEPENDENCY: number;
+    TOO_EARLY: number;
+    UPGRADE_REQUIRED: number;
+    PRECONDITION_REQUIRED: number;
+    TOO_MANY_REQUESTS: number;
+    REQUEST_HEADER_FIELDS_TOO_LARGE: number;
+    UNAVAILABLE_FOR_LEGAL_REASONS: number;
+    INTERNAL_SERVER_ERROR: number;
+    NOT_IMPLEMENTED: number;
+    BAD_GATEWAY: number;
+    SERVICE_UNAVAILABLE: number;
+    GATEWAY_TIMEOUT: number;
+    HTTP_VERSION_NOT_SUPPORTED: number;
+    VARIANT_ALSO_NEGOTIATES: number;
+    INSUFFICIENT_STORAGE: number;
+    LOOP_DETECTED: number;
+    NETWORK_AUTHENTICATION_REQUIRED: number;
+};
+export declare class ActionError<_T extends ErrorInferenceObject = ErrorInferenceObject> extends Error {
+    type: string;
+    code: ActionErrorCode;
+    status: number;
+    constructor(params: {
+        message?: string;
+        code: ActionErrorCode;
+        stack?: string;
+    });
+    static codeToStatus(code: ActionErrorCode): number;
+    static statusToCode(status: number): ActionErrorCode;
+    static fromJson(body: any): ActionError<ErrorInferenceObject>;
+}
+export declare function isActionError(error?: unknown): error is ActionError;
+export declare function isInputError<T extends ErrorInferenceObject>(error?: ActionError<T>): error is ActionInputError<T>;
+export declare function isInputError(error?: unknown): error is ActionInputError<ErrorInferenceObject>;
+export declare class ActionInputError<T extends ErrorInferenceObject> extends ActionError {
+    type: string;
+    issues: z.$ZodIssue[];
+    fields: {
+        [P in keyof T]?: string[] | undefined;
+    };
+    constructor(issues: z.$ZodIssue[]);
+}
+export declare function deserializeActionResult(res: SerializedActionResult): SafeResult<any, any>;
+export declare const actionResultErrorStack: {
+    set(stack: string | undefined): void;
+    get(): string | undefined;
+};
+export declare function getActionQueryString(name: string): string;
+export declare function getActionPathFromString({ baseUrl, shouldAppendTrailingSlash, path: input, }: {
+    baseUrl: string;
+    shouldAppendTrailingSlash: boolean;
+    path: string;
+}): string;
+export declare function createGetActionPath(options: Pick<Parameters<typeof getActionPathFromString>[0], 'baseUrl' | 'shouldAppendTrailingSlash'>): (action: ActionClient<any, any, any>) => string;
+export declare function createActionsProxy({ actionCallback, aggregatedPath, handleAction, }: {
+    actionCallback?: Record<string | symbol, any>;
+    aggregatedPath?: string;
+    handleAction: (param: any, path: string, context: APIContext | undefined) => Promise<SafeResult<any, any>>;
+}): Record<string | symbol, any>;

package/dist/actions/runtime/client.js

@@ -1,11 +1,242 @@
-export * from "./shared.js";
-function defineAction() {
-  throw new Error("[astro:action] `defineAction()` unexpectedly used on the client.");
+import { parse as devalueParse } from "devalue";
+import { ACTION_QUERY_PARAMS } from "../consts.js";
+import { appendForwardSlash } from "../../core/path.js";
+const codeToStatusMap = {
+  // Implemented from IANA HTTP Status Code Registry
+  // https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  CONTENT_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_CONTENT: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+const statusToCodeMap = Object.entries(codeToStatusMap).reduce(
+  // reverse the key-value pairs
+  (acc, [key, value]) => ({ ...acc, [value]: key }),
+  {}
+);
+class ActionError extends Error {
+  type = "AstroActionError";
+  code = "INTERNAL_SERVER_ERROR";
+  status = 500;
+  constructor(params) {
+    super(params.message);
+    this.code = params.code;
+    this.status = ActionError.codeToStatus(params.code);
+    if (params.stack) {
+      this.stack = params.stack;
+    }
+  }
+  static codeToStatus(code) {
+    return codeToStatusMap[code];
+  }
+  static statusToCode(status) {
+    return statusToCodeMap[status] ?? "INTERNAL_SERVER_ERROR";
+  }
+  static fromJson(body) {
+    if (isInputError(body)) {
+      return new ActionInputError(body.issues);
+    }
+    if (isActionError(body)) {
+      return new ActionError(body);
+    }
+    return new ActionError({
+      code: "INTERNAL_SERVER_ERROR"
+    });
+  }
+}
+function isActionError(error) {
+  return typeof error === "object" && error != null && "type" in error && error.type === "AstroActionError";
+}
+function isInputError(error) {
+  return typeof error === "object" && error != null && "type" in error && error.type === "AstroActionInputError" && "issues" in error && Array.isArray(error.issues);
+}
+class ActionInputError extends ActionError {
+  type = "AstroActionInputError";
+  // We don't expose all ZodError properties.
+  // Not all properties will serialize from server to client,
+  // and we don't want to import the full ZodError object into the client.
+  issues;
+  fields;
+  constructor(issues) {
+    super({
+      message: `Failed to validate: ${JSON.stringify(issues, null, 2)}`,
+      code: "BAD_REQUEST"
+    });
+    this.issues = issues;
+    this.fields = {};
+    for (const issue of issues) {
+      if (issue.path.length > 0) {
+        const key = issue.path[0].toString();
+        this.fields[key] ??= [];
+        this.fields[key]?.push(issue.message);
+      }
+    }
+  }
+}
+function deserializeActionResult(res) {
+  if (res.type === "error") {
+    let json;
+    try {
+      json = JSON.parse(res.body);
+    } catch {
+      return {
+        data: void 0,
+        error: new ActionError({
+          message: res.body,
+          code: "INTERNAL_SERVER_ERROR"
+        })
+      };
+    }
+    if (import.meta.env?.PROD) {
+      return { error: ActionError.fromJson(json), data: void 0 };
+    } else {
+      const error = ActionError.fromJson(json);
+      error.stack = actionResultErrorStack.get();
+      return {
+        error,
+        data: void 0
+      };
+    }
+  }
+  if (res.type === "empty") {
+    return { data: void 0, error: void 0 };
+  }
+  return {
+    data: devalueParse(res.body, {
+      URL: (href) => new URL(href)
+    }),
+    error: void 0
+  };
+}
+const actionResultErrorStack = /* @__PURE__ */ function actionResultErrorStackFn() {
+  let errorStack;
+  return {
+    set(stack) {
+      errorStack = stack;
+    },
+    get() {
+      return errorStack;
+    }
+  };
+}();
+function getActionQueryString(name) {
+  const searchParams = new URLSearchParams({ [ACTION_QUERY_PARAMS.actionName]: name });
+  return `?${searchParams.toString()}`;
+}
+function getActionPathFromString({
+  baseUrl,
+  shouldAppendTrailingSlash,
+  path: input
+}) {
+  let path = `${baseUrl.replace(/\/$/, "")}/_actions/${new URLSearchParams(input).get(ACTION_QUERY_PARAMS.actionName)}`;
+  if (shouldAppendTrailingSlash) {
+    path = appendForwardSlash(path);
+  }
+  return path;
+}
+function createGetActionPath(options) {
+  return function getActionPath(action) {
+    return getActionPathFromString({
+      baseUrl: options.baseUrl,
+      shouldAppendTrailingSlash: options.shouldAppendTrailingSlash,
+      path: action.toString()
+    });
+  };
 }
-function getActionContext() {
-  throw new Error("[astro:action] `getActionContext()` unexpectedly used on the client.");
+const ENCODED_DOT = "%2E";
+function createActionsProxy({
+  actionCallback = {},
+  aggregatedPath = "",
+  handleAction
+}) {
+  return new Proxy(actionCallback, {
+    get(target, objKey) {
+      if (target.hasOwnProperty(objKey) || typeof objKey === "symbol") {
+        return target[objKey];
+      }
+      const path = aggregatedPath + encodeURIComponent(objKey.toString()).replaceAll(".", ENCODED_DOT);
+      function action(param) {
+        return handleAction(param, path, this);
+      }
+      Object.assign(action, {
+        queryString: getActionQueryString(path),
+        toString: () => action.queryString,
+        // redefine prototype methods as the object's own property, not the prototype's
+        bind: action.bind,
+        valueOf: () => action.valueOf,
+        // Progressive enhancement info for React.
+        $$FORM_ACTION: function() {
+          const searchParams = new URLSearchParams(action.toString());
+          return {
+            method: "POST",
+            // `name` creates a hidden input.
+            // It's unused by Astro, but we can't turn this off.
+            // At least use a name that won't conflict with a user's formData.
+            name: "_astroAction",
+            action: "?" + searchParams.toString()
+          };
+        },
+        // Note: `orThrow` does not have progressive enhancement info.
+        // If you want to throw exceptions,
+        //  you must handle those exceptions with client JS.
+        async orThrow(param) {
+          const { data, error } = await handleAction(param, path, this);
+          if (error) throw error;
+          return data;
+        }
+      });
+      return createActionsProxy({
+        actionCallback: action,
+        aggregatedPath: path + ".",
+        handleAction
+      });
+    }
+  });
 }
 export {
-  defineAction,
-  getActionContext
+  ActionError,
+  ActionInputError,
+  actionResultErrorStack,
+  codeToStatusMap,
+  createActionsProxy,
+  createGetActionPath,
+  deserializeActionResult,
+  getActionPathFromString,
+  getActionQueryString,
+  isActionError,
+  isInputError
 };

package/dist/actions/runtime/entrypoints/client.d.ts

@@ -0,0 +1,7 @@
+export { ACTION_QUERY_PARAMS } from '../../consts.js';
+export { ActionError, isActionError, isInputError, } from '../client.js';
+export type { ActionAPIContext, ActionClient, ActionErrorCode, ActionInputSchema, ActionReturnType, SafeResult, } from '../types.js';
+export declare function defineAction(): void;
+export declare function getActionContext(): void;
+export declare const getActionPath: (action: import("../types.js").ActionClient<any, any, any>) => string;
+export declare const actions: Record<string | symbol, any>;