astro 4.12.3 → 4.13.1

package/dist/@types/astro.d.ts

@@ -4,7 +4,7 @@ import type { MarkdownHeading, MarkdownVFile, RehypePlugins, RemarkPlugins, Rema
 import type * as babel from '@babel/core';
 import type * as rollup from 'rollup';
 import type * as vite from 'vite';
-import type { ActionAccept, ActionClient, ActionInputSchema } from '../actions/runtime/virtual/server.js';
+import type { ActionAccept, ActionClient, ActionInputSchema, ActionReturnType } from '../actions/runtime/virtual/server.js';
 import type { RemotePattern } from '../assets/utils/remotePattern.js';
 import type { AssetsPrefix, SSRManifest, SerializedSSRManifest } from '../core/app/types.js';
 import type { PageBuildData } from '../core/build/types.js';
@@ -182,6 +182,21 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
      * ```
      */
     getActionResult: AstroSharedContext['getActionResult'];
+    /**
+     * Call an Action directly from an Astro page or API endpoint.
+     * Expects the action function as the first parameter,
+     * and the type-safe action input as the second parameter.
+     * Returns a Promise with the action result.
+     *
+     * Example usage:
+     *
+     * ```typescript
+     * import { actions } from 'astro:actions';
+     *
+     * const result = await Astro.callAction(actions.getPost, { postId: 'test' });
+     * ```
+     */
+    callAction: AstroSharedContext['callAction'];
     /** Redirect to another page
      *
      * Example usage:
@@ -1755,53 +1770,6 @@ export interface AstroUserConfig {
          * ```
          */
         contentCollectionCache?: boolean;
-        /**
-         * @docs
-         * @name experimental.contentCollectionJsonSchema
-         * @type {boolean}
-         * @default `false`
-         * @version 4.5.0
-         * @description
-         * This feature will auto-generate a JSON schema for content collections of `type: 'data'` which can be used as the `$schema` value for TypeScript-style autocompletion/hints in tools like VSCode.
-         *
-         * To enable this feature, add the experimental flag:
-         *
-         * ```diff
-         * import { defineConfig } from 'astro/config';
-
-         * export default defineConfig({
-         * 	experimental: {
-         * +		contentCollectionJsonSchema: true
-         * 	}
-         * });
-         * ```
-         *
-         * This experimental implementation requires you to manually reference the schema in each data entry file of the collection:
-         *
-         * ```diff
-         * // src/content/test/entry.json
-         * {
-         * +  "$schema": "../../../.astro/collections/test.schema.json",
-         * 	"test": "test"
-         * }
-         * ```
-         *
-         * Alternatively, you can set this in your [VSCode `json.schemas` settings](https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings):
-         *
-         * ```diff
-         * "json.schemas": [
-         * 	{
-         * 		"fileMatch": [
-         * 			"/src/content/test/**"
-         * 		],
-         * 		"url": "./.astro/collections/test.schema.json"
-         * 	}
-         * ]
-         * ```
-         *
-         * Note that this initial implementation uses a library with [known issues for advanced Zod schemas](https://github.com/StefanTerdell/zod-to-json-schema#known-issues), so you may wish to consult these limitations before enabling the experimental flag.
-         */
-        contentCollectionJsonSchema?: boolean;
         /**
          * @docs
          * @name experimental.clientPrerender
@@ -1866,61 +1834,6 @@ export interface AstroUserConfig {
          * In the event of route collisions, where two routes of equal route priority attempt to build the same URL, Astro will log a warning identifying the conflicting routes.
          */
         globalRoutePriority?: boolean;
-        /**
-         * @docs
-         * @name experimental.rewriting
-         * @type {boolean}
-         * @default `false`
-         * @version 4.8.0
-         * @description
-         *
-         * Enables a routing feature for rewriting requests in Astro pages, endpoints and Astro middleware, giving you programmatic control over your routes.
-         *
-         * ```js
-         * {
-         *   experimental: {
-         *     rewriting: true,
-         *   },
-         * }
-         * ```
-         *
-         * Use `Astro.rewrite` in your `.astro` files to reroute to a different page:
-         *
-         * ```astro "rewrite"
-         * ---
-         * // src/pages/dashboard.astro
-         * if (!Astro.props.allowed) {
-         * 	return Astro.rewrite("/")
-         * }
-         * ---
-         * ```
-         *
-         * Use `context.rewrite` in your endpoint files to reroute to a different page:
-         *
-         * ```js
-         * // src/pages/api.js
-         * export function GET(ctx) {
-         * 	if (!ctx.locals.allowed) {
-         * 		return ctx.rewrite("/")
-         * 	}
-         * }
-         * ```
-         *
-         * Use `next("/")` in your middleware file to reroute to a different page, and then call the next middleware function:
-         *
-         * ```js
-         * // src/middleware.js
-         * export function onRequest(ctx, next) {
-         * 	if (!ctx.cookies.get("allowed")) {
-         * 		return next("/") // new signature
-         * 	}
-         * 	return next();
-         * }
-         * ```
-         *
-         * For a complete overview, and to give feedback on this experimental API, see the [Rerouting RFC](https://github.com/withastro/roadmap/blob/feat/reroute/proposals/0047-rerouting.md).
-         */
-        rewriting?: boolean;
         /**
          * @docs
          * @name experimental.env
@@ -2593,7 +2506,11 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
     /**
      * Get action result on the server when using a form POST.
      */
-    getActionResult: <TAccept extends ActionAccept, TInputSchema extends ActionInputSchema<TAccept>, TAction extends ActionClient<unknown, TAccept, TInputSchema>>(action: TAction) => Awaited<ReturnType<TAction>> | undefined;
+    getActionResult: <TAccept extends ActionAccept, TInputSchema extends ActionInputSchema<TAccept>, TAction extends ActionClient<unknown, TAccept, TInputSchema>>(action: TAction) => ActionReturnType<TAction> | undefined;
+    /**
+     * Call action handler from the server.
+     */
+    callAction: <TAccept extends ActionAccept, TInputSchema extends ActionInputSchema<TAccept>, TOutput, TAction extends ActionClient<TOutput, TAccept, TInputSchema> | ActionClient<TOutput, TAccept, TInputSchema>['orThrow']>(action: TAction, input: Parameters<TAction>[0]) => Promise<ActionReturnType<TAction>>;
     /**
      * Route parameters for this request if this is a dynamic route.
      */

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

@@ -2,6 +2,7 @@ import type { APIContext } from '../../@types/astro.js';
 export type Locals = {
     _actionsInternal: {
         getActionResult: APIContext['getActionResult'];
+        callAction: APIContext['callAction'];
         actionResult?: ReturnType<APIContext['getActionResult']>;
     };
 };

package/dist/actions/runtime/middleware.js

@@ -5,13 +5,15 @@ import {
 } from "../../core/errors/errors-data.js";
 import { AstroError } from "../../core/errors/errors.js";
 import { defineMiddleware } from "../../core/middleware/index.js";
-import { ApiContextStorage } from "./store.js";
 import { formContentTypes, getAction, hasContentType } from "./utils.js";
 import { getActionQueryString } from "./virtual/shared.js";
 const onRequest = defineMiddleware(async (context, next) => {
   const locals = context.locals;
   const { request } = context;
-  if (locals._actionsInternal) return ApiContextStorage.run(context, () => next());
+  if (locals._actionsInternal) {
+    locals._actionsInternal.callAction = createCallAction(context);
+    return next();
+  }
   if (request.method === "POST" && request.body === null) {
     return nextWithStaticStub(next, context);
   }
@@ -36,8 +38,8 @@ async function handlePost({
   actionName
 }) {
   const { request } = context;
-  const action = await getAction(actionName);
-  if (!action) {
+  const baseAction = await getAction(actionName);
+  if (!baseAction) {
     throw new AstroError({
       ...ActionQueryStringInvalidError,
       message: ActionQueryStringInvalidError.message(actionName)
@@ -48,10 +50,11 @@ async function handlePost({
   if (contentType && hasContentType(contentType, formContentTypes)) {
     formData = await request.clone().formData();
   }
-  const actionResult = await ApiContextStorage.run(context, () => action(formData));
+  const action = baseAction.bind(context);
+  const actionResult = await action(formData);
   return handleResult({ context, next, actionName, actionResult });
 }
-function handleResult({
+async function handleResult({
   context,
   next,
   actionName,
@@ -64,21 +67,20 @@ function handleResult({
       }
       return actionResult;
     },
+    callAction: createCallAction(context),
     actionResult
   };
   const locals = context.locals;
   Object.defineProperty(locals, "_actionsInternal", { writable: false, value: actionsInternal });
-  return ApiContextStorage.run(context, async () => {
-    const response = await next();
-    if (actionResult.error) {
-      return new Response(response.body, {
-        status: actionResult.error.status,
-        statusText: actionResult.error.type,
-        headers: response.headers
-      });
-    }
-    return response;
-  });
+  const response = await next();
+  if (actionResult.error) {
+    return new Response(response.body, {
+      status: actionResult.error.status,
+      statusText: actionResult.error.type,
+      headers: response.headers
+    });
+  }
+  return response;
 }
 async function handlePostLegacy({ context, next }) {
   const { request } = context;
@@ -91,14 +93,15 @@ async function handlePostLegacy({ context, next }) {
   if (!formData) return nextWithLocalsStub(next, context);
   const actionName = formData.get("_astroAction");
   if (!actionName) return nextWithLocalsStub(next, context);
-  const action = await getAction(actionName);
-  if (!action) {
+  const baseAction = await getAction(actionName);
+  if (!baseAction) {
     throw new AstroError({
       ...ActionQueryStringInvalidError,
       message: ActionQueryStringInvalidError.message(actionName)
     });
   }
-  const actionResult = await ApiContextStorage.run(context, () => action(formData));
+  const action = baseAction.bind(context);
+  const actionResult = await action(formData);
   return handleResult({ context, next, actionName, actionResult });
 }
 function nextWithStaticStub(next, context) {
@@ -111,19 +114,27 @@ function nextWithStaticStub(next, context) {
           "`getActionResult()` should not be called on prerendered pages. Astro can only handle actions for pages rendered on-demand."
         );
         return void 0;
-      }
+      },
+      callAction: createCallAction(context)
     }
   });
-  return ApiContextStorage.run(context, () => next());
+  return next();
 }
 function nextWithLocalsStub(next, context) {
   Object.defineProperty(context.locals, "_actionsInternal", {
     writable: false,
     value: {
-      getActionResult: () => void 0
+      getActionResult: () => void 0,
+      callAction: createCallAction(context)
     }
   });
-  return ApiContextStorage.run(context, () => next());
+  return next();
+}
+function createCallAction(context) {
+  return (baseAction, input) => {
+    const action = baseAction.bind(context);
+    return action(input);
+  };
 }
 export {
   onRequest

package/dist/actions/runtime/route.js

@@ -1,9 +1,8 @@
-import { ApiContextStorage } from "./store.js";
 import { formContentTypes, getAction, hasContentType } from "./utils.js";
 const POST = async (context) => {
   const { request, url } = context;
-  const action = await getAction(url.pathname);
-  if (!action) {
+  const baseAction = await getAction(url.pathname);
+  if (!baseAction) {
     return new Response(null, { status: 404 });
   }
   const contentType = request.headers.get("Content-Type");
@@ -18,7 +17,8 @@ const POST = async (context) => {
   } else {
     return new Response(null, { status: 415 });
   }
-  const result = await ApiContextStorage.run(context, () => action(args));
+  const action = baseAction.bind(context);
+  const result = await action(args);
   if (result.error) {
     return new Response(
       JSON.stringify({

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

@@ -1,7 +1,9 @@
 import type { ZodType } from 'zod';
+import type { APIContext } from '../../@types/astro.js';
 import type { ActionAccept, ActionClient } from './virtual/server.js';
 export declare const formContentTypes: string[];
 export declare function hasContentType(contentType: string, expected: string[]): boolean;
+export type ActionAPIContext = Omit<APIContext, 'getActionResult' | 'callAction' | 'props'>;
 export type MaybePromise<T> = T | Promise<T>;
 /**
  * Get server-side action based on the route path.

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

@@ -1,4 +1,3 @@
 export * from './shared.js';
 export declare function defineAction(): void;
-export declare function getApiContext(): void;
 export declare const z: {};

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

@@ -2,9 +2,6 @@ export * from "./shared.js";
 function defineAction() {
   throw new Error("[astro:action] `defineAction()` unexpectedly used on the client.");
 }
-function getApiContext() {
-  throw new Error("[astro:action] `getApiContext()` unexpectedly used on the client.");
-}
 const z = new Proxy(
   {},
   {
@@ -15,6 +12,5 @@ const z = new Proxy(
 );
 export {
   defineAction,
-  getApiContext,
   z
 };

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

@@ -1,11 +1,8 @@
 import { z } from 'zod';
-import { type ActionAPIContext, getApiContext as _getApiContext } from '../store.js';
-import type { ErrorInferenceObject, MaybePromise } from '../utils.js';
+import type { ActionAPIContext, ErrorInferenceObject, MaybePromise } from '../utils.js';
 import { type SafeResult } from './shared.js';
 export * from './shared.js';
 export { z } from 'zod';
-/** @deprecated Access context from the second `handler()` parameter. */
-export declare const getApiContext: typeof _getApiContext;
 export type ActionAccept = 'form' | 'json';
 export type ActionInputSchema<T extends ActionAccept | undefined> = T extends 'form' ? z.AnyZodObject | z.ZodType<FormData> : z.ZodType;
 export type ActionHandler<TInputSchema, TOutput> = TInputSchema extends z.ZodType ? (input: z.infer<TInputSchema>, context: ActionAPIContext) => MaybePromise<TOutput> : (input: any, context: ActionAPIContext) => MaybePromise<TOutput>;

package/dist/actions/runtime/virtual/server.js

@@ -1,53 +1,61 @@
 import { z } from "zod";
-import { getApiContext as _getApiContext } from "../store.js";
+import { ActionCalledFromServerError } from "../../../core/errors/errors-data.js";
+import { AstroError } from "../../../core/errors/errors.js";
 import { ActionError, ActionInputError, callSafely } from "./shared.js";
 export * from "./shared.js";
 import { z as z2 } from "zod";
-const getApiContext = _getApiContext;
 function defineAction({
   accept,
   input: inputSchema,
   handler
 }) {
   const serverHandler = accept === "form" ? getFormServerHandler(handler, inputSchema) : getJsonServerHandler(handler, inputSchema);
-  const safeServerHandler = async (unparsedInput) => {
-    return callSafely(() => serverHandler(unparsedInput));
-  };
+  async function safeServerHandler(unparsedInput) {
+    if (typeof this === "function") {
+      throw new AstroError(ActionCalledFromServerError);
+    }
+    return callSafely(() => serverHandler(unparsedInput, this));
+  }
   Object.assign(safeServerHandler, {
-    orThrow: serverHandler
+    orThrow(unparsedInput) {
+      if (typeof this === "function") {
+        throw new AstroError(ActionCalledFromServerError);
+      }
+      return serverHandler(unparsedInput, this);
+    }
   });
   return safeServerHandler;
 }
 function getFormServerHandler(handler, inputSchema) {
-  return async (unparsedInput) => {
+  return async (unparsedInput, context) => {
     if (!(unparsedInput instanceof FormData)) {
       throw new ActionError({
         code: "UNSUPPORTED_MEDIA_TYPE",
         message: "This action only accepts FormData."
       });
     }
-    if (!(inputSchema instanceof z.ZodObject)) return await handler(unparsedInput, getApiContext());
+    if (!(inputSchema instanceof z.ZodObject)) return await handler(unparsedInput, context);
     const parsed = await inputSchema.safeParseAsync(formDataToObject(unparsedInput, inputSchema));
     if (!parsed.success) {
       throw new ActionInputError(parsed.error.issues);
     }
-    return await handler(parsed.data, getApiContext());
+    return await handler(parsed.data, context);
   };
 }
 function getJsonServerHandler(handler, inputSchema) {
-  return async (unparsedInput) => {
+  return async (unparsedInput, context) => {
     if (unparsedInput instanceof FormData) {
       throw new ActionError({
         code: "UNSUPPORTED_MEDIA_TYPE",
         message: "This action only accepts JSON."
       });
     }
-    if (!inputSchema) return await handler(unparsedInput, getApiContext());
+    if (!inputSchema) return await handler(unparsedInput, context);
     const parsed = await inputSchema.safeParseAsync(unparsedInput);
     if (!parsed.success) {
       throw new ActionInputError(parsed.error.issues);
     }
-    return await handler(parsed.data, getApiContext());
+    return await handler(parsed.data, context);
   };
 }
 function formDataToObject(formData, schema) {
@@ -87,6 +95,5 @@ function handleFormDataGet(key, formData, validator, baseValidator) {
 export {
   defineAction,
   formDataToObject,
-  getApiContext,
   z2 as z
 };

package/dist/actions/utils.d.ts

@@ -2,3 +2,4 @@ import type { APIContext } from '../@types/astro.js';
 import type { Locals } from './runtime/middleware.js';
 export declare function hasActionsInternal(locals: APIContext['locals']): locals is Locals;
 export declare function createGetActionResult(locals: APIContext['locals']): APIContext['getActionResult'];
+export declare function createCallAction(locals: APIContext['locals']): APIContext['callAction'];

package/dist/actions/utils.js

@@ -13,7 +13,19 @@ function createGetActionResult(locals) {
     return locals._actionsInternal.getActionResult(actionFn);
   };
 }
+function createCallAction(locals) {
+  return (actionFn, input) => {
+    if (!hasActionsInternal(locals))
+      throw new AstroError({
+        name: "AstroActionError",
+        message: "Experimental actions are not enabled in your project.",
+        hint: "See https://docs.astro.build/en/reference/configuration-reference/#experimental-flags"
+      });
+    return locals._actionsInternal.callAction(actionFn, input);
+  };
+}
 export {
+  createCallAction,
   createGetActionResult,
   hasActionsInternal
 };

package/dist/cli/add/index.d.ts

@@ -2,12 +2,5 @@ import type yargs from 'yargs-parser';
 interface AddOptions {
     flags: yargs.Arguments;
 }
-interface IntegrationInfo {
-    id: string;
-    packageName: string;
-    dependencies: [name: string, version: string][];
-    type: 'integration' | 'adapter';
-}
 export declare function add(names: string[], { flags }: AddOptions): Promise<void>;
-export declare function validateIntegrations(integrations: string[]): Promise<IntegrationInfo[]>;
 export {};

package/dist/cli/add/index.js

@@ -898,6 +898,5 @@ async function setupIntegrationConfig(opts) {
   }
 }
 export {
-  add,
-  validateIntegrations
+  add
 };

package/dist/cli/install-package.d.ts

@@ -13,5 +13,4 @@ export declare function getPackage<T>(packageName: string, logger: Logger, optio
 export declare function getExecCommand(packageManager?: string): Promise<string>;
 export declare function fetchPackageJson(scope: string | undefined, name: string, tag: string): Promise<Record<string, any> | Error>;
 export declare function fetchPackageVersions(packageName: string): Promise<string[] | Error>;
-export declare function getRegistry(): Promise<string>;
 export {};

package/dist/cli/install-package.js

@@ -165,6 +165,5 @@ export {
   fetchPackageJson,
   fetchPackageVersions,
   getExecCommand,
-  getPackage,
-  getRegistry
+  getPackage
 };

package/dist/container/index.js

@@ -15,7 +15,6 @@ function createManifest(manifest, renderers, middleware) {
   };
   return {
     hrefRoot: import.meta.url,
-    rewritingEnabled: false,
     trailingSlash: manifest?.trailingSlash ?? ASTRO_CONFIG_DEFAULTS.trailingSlash,
     buildFormat: manifest?.buildFormat ?? ASTRO_CONFIG_DEFAULTS.build.format,
     compressHTML: manifest?.compressHTML ?? ASTRO_CONFIG_DEFAULTS.compressHTML,

package/dist/content/runtime-assets.d.ts

@@ -2,10 +2,10 @@ import type { PluginContext } from 'rollup';
 import { z } from 'zod';
 export declare function createImage(pluginContext: PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodEffects<z.ZodString, z.ZodNever | {
     ASTRO_ASSET: string;
-    format: import("../assets/types.js").ImageInputFormat;
     width: number;
     height: number;
+    format: import("../assets/types.js").ImageInputFormat;
     src: string;
     fsPath: string;
-    orientation?: number;
+    orientation?: number | undefined;
 }, string>;

package/dist/content/types-generator.js

@@ -283,7 +283,7 @@ async function writeContentFiles({
   let contentTypesStr = "";
   let dataTypesStr = "";
   const collectionSchemasDir = new URL("./collections/", settings.dotAstroDir);
-  if (settings.config.experimental.contentCollectionJsonSchema && !fs.existsSync(collectionSchemasDir)) {
+  if (!fs.existsSync(collectionSchemasDir)) {
     fs.mkdirSync(collectionSchemasDir, { recursive: true });
   }
   for (const [collection, config] of Object.entries(contentConfig?.collections ?? {})) {
@@ -376,7 +376,7 @@ async function writeContentFiles({
           dataTypesStr += `};
 `;
         }
-        if (settings.config.experimental.contentCollectionJsonSchema && collectionConfig?.schema) {
+        if (collectionConfig?.schema) {
           let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
           if (zodSchemaForJson instanceof z.ZodObject) {
             zodSchemaForJson = zodSchemaForJson.extend({
@@ -390,7 +390,9 @@ async function writeContentFiles({
                 zodToJsonSchema(zodSchemaForJson, {
                   name: collectionKey.replace(/"/g, ""),
                   markdownDescription: true,
-                  errorMessages: true
+                  errorMessages: true,
+                  // Fix for https://github.com/StefanTerdell/zod-to-json-schema/issues/110
+                  dateStrategy: ["format:date-time", "format:date", "integer"]
                 }),
                 null,
                 2

package/dist/content/utils.d.ts

@@ -19,7 +19,7 @@ export type ContentLookupMap = {
         };
     };
 };
-export declare const collectionConfigParser: z.ZodUnion<[z.ZodObject<{
+declare const collectionConfigParser: z.ZodUnion<[z.ZodObject<{
     type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"content">>>;
     schema: z.ZodOptional<z.ZodAny>;
 }, "strip", z.ZodTypeAny, {
@@ -38,7 +38,7 @@ export declare const collectionConfigParser: z.ZodUnion<[z.ZodObject<{
     type: "data";
     schema?: any;
 }>]>;
-export declare const contentConfigParser: z.ZodObject<{
+declare const contentConfigParser: z.ZodObject<{
     collections: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
         type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"content">>>;
         schema: z.ZodOptional<z.ZodAny>;
@@ -81,9 +81,6 @@ type EntryInternal = {
     rawData: string | undefined;
     filePath: string;
 };
-export declare const msg: {
-    collectionConfigMissing: (collection: string) => string;
-};
 export declare function parseEntrySlug({ id, collection, generatedSlug, frontmatterSlug, }: {
     id: string;
     collection: string;
@@ -124,7 +121,6 @@ export declare function getContentEntryIdAndSlug({ entry, contentDir, collection
     slug: string;
 };
 export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
-export declare function hasUnderscoreBelowContentDirectoryPath(fileUrl: URL, contentDir: ContentPaths['contentDir']): boolean;
 export declare function safeParseFrontmatter(source: string, id?: string): matter.GrayMatterFile<string>;
 /**
  * The content config is loaded separately from other `src/` files.
@@ -134,11 +130,6 @@ export declare function safeParseFrontmatter(source: string, id?: string): matte
 export declare const globalContentConfigObserver: ContentObservable;
 export declare function hasAnyContentFlag(viteId: string): boolean;
 export declare function hasContentFlag(viteId: string, flag: (typeof CONTENT_FLAGS)[number]): boolean;
-export declare function loadContentConfig({ fs, settings, viteServer, }: {
-    fs: typeof fsMod;
-    settings: AstroSettings;
-    viteServer: ViteDevServer;
-}): Promise<ContentConfig | undefined>;
 export declare function reloadContentConfigObserver({ observer, ...loadContentConfigOpts }: {
     fs: typeof fsMod;
     settings: AstroSettings;

package/dist/content/utils.js

@@ -22,9 +22,6 @@ const collectionConfigParser = z.union([
 const contentConfigParser = z.object({
   collections: z.record(collectionConfigParser)
 });
-const msg = {
-  collectionConfigMissing: (collection) => `${collection} does not have a config. We suggest adding one for type safety!`
-};
 function parseEntrySlug({
   id,
   collection,
@@ -387,8 +384,6 @@ function hasAssetPropagationFlag(id) {
   }
 }
 export {
-  collectionConfigParser,
-  contentConfigParser,
   contentObservable,
   getContentEntryExts,
   getContentEntryIdAndSlug,
@@ -406,9 +401,6 @@ export {
   hasAnyContentFlag,
   hasAssetPropagationFlag,
   hasContentFlag,
-  hasUnderscoreBelowContentDirectoryPath,
-  loadContentConfig,
-  msg,
   parseEntrySlug,
   reloadContentConfigObserver,
   reverseSymlink,

package/dist/core/app/types.d.ts

@@ -55,7 +55,6 @@ export type SSRManifest = {
     i18n: SSRManifestI18n | undefined;
     middleware: MiddlewareHandler;
     checkOrigin: boolean;
-    rewritingEnabled: boolean;
     experimentalEnvGetSecretEnabled: boolean;
 };
 export type SSRManifestI18n = {

package/dist/core/build/generate.d.ts

@@ -1,7 +1,3 @@
-import type { OutputAsset, OutputChunk } from 'rollup';
-import type { AstroSettings } from '../../@types/astro.js';
 import { type BuildInternals } from '../../core/build/internal.js';
 import type { StaticBuildOptions } from './types.js';
-export declare function rootRelativeFacadeId(facadeId: string, settings: AstroSettings): string;
-export declare function chunkIsPage(settings: AstroSettings, output: OutputAsset | OutputChunk, internals: BuildInternals): boolean;
 export declare function generatePages(options: StaticBuildOptions, internals: BuildInternals): Promise<void>;