astro 6.0.0-alpha.0 → 6.0.0-alpha.2

package/astro-jsx.d.ts

@@ -672,6 +672,17 @@ declare namespace astroHTML.JSX {
 		value?: string | string[] | number | undefined | null;
 		popovertarget?: string | undefined | null;
 		popovertargetaction?: 'hide' | 'show' | 'toggle' | undefined | null;
+		command?:
+			| 'show-modal'
+			| 'close'
+			| 'request-close'
+			| 'show-popover'
+			| 'hide-popover'
+			| 'toggle-popover'
+			| (string & {})
+			| undefined
+			| null;
+		commandfor?: string | undefined | null;
 	}
 
 	interface CanvasHTMLAttributes extends HTMLAttributes {

package/client.d.ts

@@ -1,8 +1,10 @@
 /// <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
@@ -119,46 +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');
-	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';
 }
@@ -193,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/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>;

package/dist/actions/runtime/entrypoints/client.js

@@ -0,0 +1,91 @@
+import { shouldAppendTrailingSlash } from "virtual:astro:actions/options";
+import { internalFetchHeaders } from "virtual:astro:adapter-config/client";
+import {
+  ActionError,
+  createActionsProxy,
+  createGetActionPath,
+  deserializeActionResult,
+  getActionPathFromString,
+  getActionQueryString
+} from "../client.js";
+import { ACTION_QUERY_PARAMS } from "../../consts.js";
+import {
+  ActionError as ActionError2,
+  isActionError,
+  isInputError
+} from "../client.js";
+function defineAction() {
+  throw new Error("[astro:actions] `defineAction()` unexpectedly used on the client.");
+}
+function getActionContext() {
+  throw new Error("[astro:actions] `getActionContext()` unexpectedly used on the client.");
+}
+const getActionPath = createGetActionPath({
+  baseUrl: import.meta.env.BASE_URL,
+  shouldAppendTrailingSlash
+});
+const actions = createActionsProxy({
+  handleAction: async (param, path) => {
+    const headers = new Headers();
+    headers.set("Accept", "application/json");
+    for (const [key, value] of Object.entries(internalFetchHeaders)) {
+      headers.set(key, value);
+    }
+    let body = param;
+    if (!(body instanceof FormData)) {
+      try {
+        body = JSON.stringify(param);
+      } catch (e) {
+        throw new ActionError({
+          code: "BAD_REQUEST",
+          message: `Failed to serialize request body to JSON. Full error: ${e.message}`
+        });
+      }
+      if (body) {
+        headers.set("Content-Type", "application/json");
+      } else {
+        headers.set("Content-Length", "0");
+      }
+    }
+    const rawResult = await fetch(
+      getActionPathFromString({
+        baseUrl: import.meta.env.BASE_URL,
+        shouldAppendTrailingSlash,
+        path: getActionQueryString(path)
+      }),
+      {
+        method: "POST",
+        body,
+        headers
+      }
+    );
+    if (rawResult.status === 204) {
+      return deserializeActionResult({ type: "empty", status: 204 });
+    }
+    const bodyText = await rawResult.text();
+    if (rawResult.ok) {
+      return deserializeActionResult({
+        type: "data",
+        body: bodyText,
+        status: 200,
+        contentType: "application/json+devalue"
+      });
+    }
+    return deserializeActionResult({
+      type: "error",
+      body: bodyText,
+      status: rawResult.status,
+      contentType: "application/json"
+    });
+  }
+});
+export {
+  ACTION_QUERY_PARAMS,
+  ActionError2 as ActionError,
+  actions,
+  defineAction,
+  getActionContext,
+  getActionPath,
+  isActionError,
+  isInputError
+};

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

@@ -0,0 +1,2 @@
+import type { APIRoute } from '../../../types/public/common.js';
+export declare const POST: APIRoute;

package/dist/actions/runtime/{route.js → entrypoints/route.js}

@@ -1,4 +1,4 @@
-import { getActionContext } from "./server.js";
+import { getActionContext } from "../server.js";
 const POST = async (context) => {
   const { action, serializeActionResult } = getActionContext(context);
   if (action?.calledFrom !== "rpc") {

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

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