astro 4.13.3 → 4.14.0

package/components/Code.astro

@@ -23,6 +23,13 @@ interface Props extends Omit<HTMLAttributes<'pre'>, 'lang'> {
 	 * @default "plaintext"
 	 */
 	lang?: BuiltinLanguage | SpecialLanguage | LanguageRegistration;
+	/**
+	 * A metastring to pass to the highlighter.
+	 * Allows passing information to transformers: https://shiki.style/guide/transformers#meta
+	 *
+	 * @default undefined
+	 */
+	meta?: string;
 	/**
 	 * The styling theme.
 	 * Supports all themes listed here: https://shiki.style/themes
@@ -72,6 +79,7 @@ interface Props extends Omit<HTMLAttributes<'pre'>, 'lang'> {
 const {
 	code,
 	lang = 'plaintext',
+	meta,
 	theme = 'github-dark',
 	themes = {},
 	defaultColor = 'light',
@@ -110,6 +118,7 @@ const highlighter = await getCachedHighlighter({
 
 const html = await highlighter.highlight(code, typeof lang === 'string' ? lang : lang.name, {
 	inline,
+	meta,
 	attributes: rest as any,
 });
 ---

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

@@ -6,6 +6,7 @@ import type * as rollup from 'rollup';
 import type * as vite from 'vite';
 import type { ActionAccept, ActionClient, ActionInputSchema, ActionReturnType } from '../actions/runtime/virtual/server.js';
 import type { RemotePattern } from '../assets/utils/remotePattern.js';
+import type { DataEntry, RenderedContent } from '../content/data-store.js';
 import type { AssetsPrefix, SSRManifest, SerializedSSRManifest } from '../core/app/types.js';
 import type { PageBuildData } from '../core/build/types.js';
 import type { AstroConfigType } from '../core/config/index.js';
@@ -29,7 +30,7 @@ export type { MarkdownHeading, RehypePlugins, RemarkPlugins, ShikiConfig, } from
 export type { ExternalImageService, ImageService, LocalImageService, } from '../assets/services/service.js';
 export type { GetImageResult, ImageInputFormat, ImageMetadata, ImageOutputFormat, ImageQuality, ImageQualityPreset, ImageTransform, UnresolvedImageTransform, } from '../assets/types.js';
 export type { RemotePattern } from '../assets/utils/remotePattern.js';
-export type { SSRManifest, AssetsPrefix } from '../core/app/types.js';
+export type { AssetsPrefix, SSRManifest } from '../core/app/types.js';
 export type { AstroCookieGetOptions, AstroCookieSetOptions, AstroCookies, } from '../core/cookies/index.js';
 export interface AstroBuiltinProps {
     'client:load'?: boolean;
@@ -2038,6 +2039,223 @@ export interface AstroUserConfig {
          * For a complete overview, and to give feedback on this experimental API, see the [Server Islands RFC](https://github.com/withastro/roadmap/pull/963).
          */
         serverIslands?: boolean;
+        /**
+         * @docs
+         * @name experimental.contentIntellisense
+         * @type {boolean}
+         * @default `false`
+         * @version 4.14.0
+         * @description
+         *
+         * Enables Intellisense features (e.g. code completion, quick hints) for your content collection entries in compatible editors.
+         *
+         * When enabled, this feature will generate and add JSON schemas to the `.astro` directory in your project. These files can be used by the Astro language server to provide Intellisense inside content files (`.md`, `.mdx`, `.mdoc`).
+         *
+         * ```js
+         * {
+         *   experimental: {
+         *     contentIntellisense: true,
+         *   },
+         * }
+         * ```
+         *
+         * To use this feature with the Astro VS Code extension, you must also enable the `astro.content-intellisense` option in your VS Code settings. For editors using the Astro language server directly, pass the `contentIntellisense: true` initialization parameter to enable this feature.
+         */
+        contentIntellisense?: boolean;
+        /**
+         * @docs
+         * @name experimental.contentLayer
+         * @type {boolean}
+         * @default `false`
+         * @version 4.14.0
+         * @description
+         *
+         * The Content Layer API is a new way to handle content and data in Astro. It is similar to and builds upon [content collections](/en/guides/content-collections/), taking them beyond local files in `src/content/` and allowing you to fetch content from anywhere, including remote APIs, by adding a `loader` to your collection.
+         *
+         * Your existing content collections can be [migrated to the Content Layer API](#migrating-an-existing-content-collection-to-use-the-content-layer-api) with a few small changes. However, it is not necessary to update all your collections at once to add a new collection powered by the Content Layer API. You may have collections using both the existing and new APIs defined in `src/content/config.ts` at the same time.
+         *
+         * The Content Layer API is designed to be more powerful and more performant, helping sites scale to thousands of pages. Data is cached between builds and updated incrementally. Markdown parsing is also 5-10 times faster, with similar scale reductions in memory, and MDX is 2-3 times faster.
+         *
+         * To enable, add the `contentLayer` flag to the `experimental` object in your Astro config:
+         *
+         * ```js
+         * // astro.config.mjs
+         * {
+         * 	experimental: {
+         * 		contentLayer: true,
+         * 	}
+         * }
+         * ```
+         *
+         * #### Fetching data with a `loader`
+         *
+         * The Content Layer API allows you to fetch your content from outside of the `src/content/` folder (whether stored locally in your project or remotely) and uses a `loader` property to retrieve your data.
+         *
+         * The `loader` is defined in the collection's schema and returns an array of entries. Astro provides two built-in loader functions (`glob()` and `file()`) for fetching your local content, as well as access to the API to [construct your own loader and fetch remote data](#creating-a-loader).
+         *
+         * The `glob()` loader creates entries from directories of Markdown, MDX, Markdoc, or JSON files from anywhere on the filesystem. It accepts a `pattern` of entry files to match, and a `base` file path of where your files are located. Use this when you have one file per entry.
+         *
+         * The `file()` loader creates multiple entries from a single local file. Use this when all your entries are stored in an array of objects.
+         *
+         * ```ts  {3,8,19}
+         * // src/content/config.ts
+         * import { defineCollection, z } from 'astro:content';
+         * import { glob, file } from 'astro/loaders';
+         *
+         * const blog = defineCollection({
+         *   // By default the ID is a slug generated from
+         *   // the path of the file relative to `base`
+         *   loader: glob({ pattern: "**\/*.md", base: "./src/data/blog" }),
+         *   schema: z.object({
+         *     title: z.string(),
+         *     description: z.string(),
+         *     pubDate: z.coerce.date(),
+         *     updatedDate: z.coerce.date().optional(),
+         *   })
+         * });
+         *
+         * const dogs = defineCollection({
+         *   // The path is relative to the project root, or an absolute path.
+         *   loader: file("src/data/dogs.json"),
+         *   schema: z.object({
+         *     id: z.string(),
+         *     breed: z.string(),
+         *     temperament: z.array(z.string()),
+         *   }),
+         * });
+         *
+         * export const collections = { blog, dogs };
+         * ```
+         *
+         * #### Querying and rendering with the Content Layer API
+         *
+         * The collection can be [queried in the same way as content collections](/en/guides/content-collections/#querying-collections):
+         *
+         * ```ts
+         * // src/pages/index.astro
+         * import { getCollection, getEntry } from 'astro:content';
+         *
+         * // Get all entries from a collection.
+         * // Requires the name of the collection as an argument.
+         * const allBlogPosts = await getCollection('blog');
+         *
+         * // Get a single entry from a collection.
+         * // Requires the name of the collection and ID
+         * const labradorData = await getEntry('dogs', 'labrador-retriever');
+         * ```
+         *
+         * Entries generated from Markdown, MDX, or Markdoc can be rendered directly to a page using the `render()` function.
+         *
+         * :::note
+         * The syntax for rendering collection entries is different from the current content collections syntax.
+         * :::
+         *
+         * ```astro title="src/pages/[slug].astro"
+         * ---
+         * import { getEntry, render } from 'astro:content';
+         *
+         * const post = await getEntry('blog', Astro.params.slug);
+         *
+         * const { Content, headings } = await render(entry);
+         * ---
+         *
+         * <Content />
+         * ```
+         *
+         * #### Creating a loader
+         *
+         * With the Content Layer API, you can build loaders to load or generate content from anywhere.
+         *
+         * For example, you can create a loader that fetches collection entries from a remote API.
+         *
+         * ```ts
+         * // src/content/config.ts
+         * const countries = defineCollection({
+         *   loader: async () => {
+         *     const response = await fetch("https://restcountries.com/v3.1/all");
+         *     const data = await response.json();
+         *     // Must return an array of entries with an id property,
+         *     // or an object with IDs as keys and entries as values
+         *     return data.map((country) => ({
+         *       id: country.cca3,
+         *       ...country,
+         *     }));
+         *   },
+         *   // optionally add a schema
+         *   // schema: z.object...
+         * });
+         *
+         * export const collections = { countries };
+         * ```
+         *
+         * For more advanced loading logic, you can define an object loader. This allows incremental updates and conditional loading while also giving full access to the data store. See the API in [the Content Layer API RFC](https://github.com/withastro/roadmap/blob/content-layer/proposals/0047-content-layer.md#loaders).
+         *
+         * #### Migrating an existing content collection to use the Content Layer API
+         *
+         * You can convert an existing content collection with Markdown, MDX, Markdoc, or JSON entries to use the Content Layer API.
+         *
+         * 1. **Move the collection folder out of `src/content/`** (e.g. to `src/data/`). All collections located in the `src/content/` folder will use the existing Content Collections API.
+         *
+         *     **Do not move the existing `src/content/config.ts` file**. This file will define all collections, using either API.
+         *
+         * 2. **Edit the collection definition**. Your updated collection requires a `loader`, and the option to select a collection `type` is no longer available.
+         *
+         *     ```diff
+         *     // src/content/config.ts
+         *     import { defineCollection, z } from 'astro:content';
+         *     + import { glob } from 'astro/loaders';
+         *
+         *     const blog = defineCollection({
+         *       // For content layer you no longer define a `type`
+         *     - type: 'content',
+         *     + loader: glob({ pattern: "**\/*.md", base: "./src/data/blog" }),
+         *       schema: z.object({
+         *         title: z.string(),
+         *         description: z.string(),
+         *         pubDate: z.coerce.date(),
+         *         updatedDate: z.coerce.date().optional(),
+         *       }),
+         *     });
+         *     ```
+         *
+         * 3. **Change references from `slug` to `id`**. Content layer collections do not have a `slug` field. Instead, all updated collections will have an `id`.
+         *
+         *     ```diff
+         *     // src/pages/index.astro
+         *     ---
+         *     export async function getStaticPaths() {
+         *       const posts = await getCollection('blog');
+         *       return posts.map((post) => ({
+         *     -   params: { slug: post.slug },
+         *     +   params: { slug: post.id },
+         *         props: post,
+         *       }));
+         *     }
+         *     ---
+         *     ```
+         *
+         * 4. **Switch to the new `render()` function**. Entries no longer have a `render()` method, as they are now serializable plain objects. Instead, import the `render()` function from `astro:content`.
+         *
+         *     ```diff
+         *     // src/pages/index.astro
+         *     ---
+         *     - import { getEntry } from 'astro:content';
+         *     + import { getEntry, render } from 'astro:content';
+         *
+         *       const post = await getEntry('blog', params.slug);
+         *
+         *     - const { Content, headings } = await post.render();
+         *     + const { Content, headings } = await render(post);
+         *     ---
+         *
+         *     <Content />
+         *     ```
+         *
+         * #### Learn more
+         *
+         * For a complete overview and the full API reference, see [the Content Layer API RFC](https://github.com/withastro/roadmap/blob/content-layer/proposals/0047-content-layer.md) and [share your feedback](https://github.com/withastro/roadmap/pull/982).
+         */
+        contentLayer?: boolean;
     };
 }
 /**
@@ -2064,6 +2282,20 @@ export interface InjectedRoute {
 export interface ResolvedInjectedRoute extends InjectedRoute {
     resolvedEntryPoint?: URL;
 }
+export interface RouteOptions {
+    /**
+     * The path to this route relative to the project root. The slash is normalized as forward slash
+     * across all OS.
+     * @example "src/pages/blog/[...slug].astro"
+     */
+    readonly component: string;
+    /**
+     * Whether this route should be prerendered. If the route has an explicit `prerender` export,
+     * the value will be passed here. Otherwise, it's undefined and will fallback to a prerender
+     * default depending on the `output` option.
+     */
+    prerender?: boolean;
+}
 /**
  * Resolved Astro Config
  * Config with user settings along with all defaults filled in.
@@ -2103,6 +2335,10 @@ export interface AstroInlineOnlyConfig {
      * @default "info"
      */
     logLevel?: LoggerLevel;
+    /**
+     * Clear the content layer cache, forcing a rebuild of all content entries.
+     */
+    force?: boolean;
 }
 export type ContentEntryModule = {
     id: string;
@@ -2124,6 +2360,7 @@ export type DataEntryModule = {
         filePath: string;
     };
 };
+export type ContentEntryRenderFuction = (entry: DataEntry) => Promise<RenderedContent>;
 export interface ContentEntryType {
     extensions: string[];
     getEntryInfo(params: {
@@ -2136,6 +2373,7 @@ export interface ContentEntryType {
         viteId: string;
     }): rollup.LoadResult | Promise<rollup.LoadResult>;
     contentModuleTypes?: string;
+    getRenderFunction?(settings: AstroSettings): Promise<ContentEntryRenderFuction>;
     /**
      * Handle asset propagation for rendered content to avoid bleed.
      * Ex. MDX content can import styles and scripts, so `handlePropagation` should be true.
@@ -2167,7 +2405,7 @@ export type GetDataEntryInfoReturnType = {
 };
 export interface AstroAdapterFeatures {
     /**
-     * Creates and edge function that will communiate with the Astro middleware
+     * Creates an edge function that will communiate with the Astro middleware
      */
     edgeMiddleware: boolean;
     /**
@@ -2175,6 +2413,10 @@ export interface AstroAdapterFeatures {
      */
     functionPerRoute: boolean;
 }
+export interface InjectedType {
+    filename: string;
+    content: string;
+}
 export interface AstroSettings {
     config: AstroConfig;
     adapter: AstroAdapter | undefined;
@@ -2213,6 +2455,7 @@ export interface AstroSettings {
     latestAstroVersion: string | undefined;
     serverIslandMap: NonNullable<SSRManifest['serverIslandMap']>;
     serverIslandNameMap: NonNullable<SSRManifest['serverIslandNameMap']>;
+    injectedTypes: Array<InjectedType>;
 }
 export type AsyncRendererComponentFn<U> = (Component: any, props: any, slots: Record<string, string>, metadata?: AstroComponentMetadata) => Promise<U>;
 /** Generic interface for a component (Astro, Svelte, React, etc.) */
@@ -2788,6 +3031,7 @@ declare global {
             'astro:config:done': (options: {
                 config: AstroConfig;
                 setAdapter: (adapter: AstroAdapter) => void;
+                injectTypes: (injectedType: InjectedType) => URL;
                 logger: AstroIntegrationLogger;
             }) => void | Promise<void>;
             'astro:server:setup': (options: {
@@ -2838,6 +3082,10 @@ declare global {
                 logger: AstroIntegrationLogger;
                 cacheManifest: boolean;
             }) => void | Promise<void>;
+            'astro:route:setup': (options: {
+                route: RouteOptions;
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
         }
     }
 }
@@ -2960,6 +3208,7 @@ export interface SSRResult {
     cookies: AstroCookies | undefined;
     serverIslandNameMap: Map<string, string>;
     trailingSlash: AstroConfig['trailingSlash'];
+    key: Promise<CryptoKey>;
     _metadata: SSRMetadata;
 }
 /**

package/dist/actions/consts.d.ts

@@ -1,6 +1,6 @@
 export declare const VIRTUAL_MODULE_ID = "astro:actions";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
-export declare const ACTIONS_TYPES_FILE = "actions.d.ts";
+export declare const ACTIONS_TYPES_FILE = "astro/actions.d.ts";
 export declare const VIRTUAL_INTERNAL_MODULE_ID = "astro:internal-actions";
 export declare const RESOLVED_VIRTUAL_INTERNAL_MODULE_ID = "\0astro:internal-actions";
 export declare const NOOP_ACTIONS = "\0noop-actions";

package/dist/actions/consts.js

@@ -1,6 +1,6 @@
 const VIRTUAL_MODULE_ID = "astro:actions";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-const ACTIONS_TYPES_FILE = "actions.d.ts";
+const ACTIONS_TYPES_FILE = "astro/actions.d.ts";
 const VIRTUAL_INTERNAL_MODULE_ID = "astro:internal-actions";
 const RESOLVED_VIRTUAL_INTERNAL_MODULE_ID = "\0astro:internal-actions";
 const NOOP_ACTIONS = "\0noop-actions";

package/dist/actions/index.js

@@ -23,9 +23,6 @@ function astroActions({
           error.stack = void 0;
           throw error;
         }
-        const stringifiedActionsImport = JSON.stringify(
-          viteID(new URL("./actions", params.config.srcDir))
-        );
         params.updateConfig({
           vite: {
             plugins: [vitePluginUserActions({ settings }), vitePluginActions(fs)]
@@ -40,10 +37,18 @@ function astroActions({
           entrypoint: "astro/actions/runtime/middleware.js",
           order: "post"
         });
-        await typegen({
-          stringifiedActionsImport,
-          root: params.config.root,
-          fs
+      },
+      "astro:config:done": (params) => {
+        const stringifiedActionsImport = JSON.stringify(
+          viteID(new URL("./actions", params.config.srcDir))
+        );
+        settings.injectedTypes.push({
+          filename: ACTIONS_TYPES_FILE,
+          content: `declare module "astro:actions" {
+	type Actions = typeof import(${stringifiedActionsImport})["server"];
+
+	export const actions: Actions;
+}`
         });
       }
     }
@@ -101,20 +106,6 @@ export * from 'astro/actions/runtime/virtual/client.js';`;
     return code;
   }
 });
-async function typegen({
-  stringifiedActionsImport,
-  root,
-  fs
-}) {
-  const content = `declare module "astro:actions" {
-	type Actions = typeof import(${stringifiedActionsImport})["server"];
-
-	export const actions: Actions;
-}`;
-  const dotAstroDir = new URL(".astro/", root);
-  await fs.promises.mkdir(dotAstroDir, { recursive: true });
-  await fs.promises.writeFile(new URL(ACTIONS_TYPES_FILE, dotAstroDir), content);
-}
 export {
   astroActions as default,
   vitePluginUserActions

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

@@ -62,11 +62,17 @@ function formDataToObject(formData, schema) {
   const obj = {};
   for (const [key, baseValidator] of Object.entries(schema.shape)) {
     let validator = baseValidator;
-    while (validator instanceof z.ZodOptional || validator instanceof z.ZodNullable) {
+    while (validator instanceof z.ZodOptional || validator instanceof z.ZodNullable || validator instanceof z.ZodDefault) {
+      if (validator instanceof z.ZodDefault && !formData.has(key)) {
+        obj[key] = validator._def.defaultValue();
+      }
       validator = validator._def.innerType;
     }
-    if (validator instanceof z.ZodBoolean) {
-      obj[key] = formData.has(key);
+    if (!formData.has(key) && key in obj) {
+      continue;
+    } else if (validator instanceof z.ZodBoolean) {
+      const val = formData.get(key);
+      obj[key] = val === "true" ? true : val === "false" ? false : formData.has(key);
     } else if (validator instanceof z.ZodArray) {
       obj[key] = handleFormDataGetAll(key, formData, validator);
     } else {

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

@@ -132,14 +132,16 @@ function getActionProps(action) {
 }
 function serializeActionResult(res) {
   if (res.error) {
+    if (import.meta.env?.DEV) {
+      actionResultErrorStack.set(res.error.stack);
+    }
     return {
       type: "error",
       status: res.error.status,
       contentType: "application/json",
       body: JSON.stringify({
         ...res.error,
-        message: res.error.message,
-        stack: import.meta.env.PROD ? void 0 : res.error.stack
+        message: res.error.message
       })
     };
   }
@@ -161,7 +163,16 @@ function serializeActionResult(res) {
 }
 function deserializeActionResult(res) {
   if (res.type === "error") {
-    return { error: ActionError.fromJson(JSON.parse(res.body)), data: void 0 };
+    if (import.meta.env?.PROD) {
+      return { error: ActionError.fromJson(JSON.parse(res.body)), data: void 0 };
+    } else {
+      const error = ActionError.fromJson(JSON.parse(res.body));
+      error.stack = actionResultErrorStack.get();
+      return {
+        error,
+        data: void 0
+      };
+    }
   }
   if (res.type === "empty") {
     return { data: void 0, error: void 0 };
@@ -173,6 +184,17 @@ function deserializeActionResult(res) {
     error: void 0
   };
 }
+const actionResultErrorStack = /* @__PURE__ */ function actionResultErrorStackFn() {
+  let errorStack;
+  return {
+    set(stack) {
+      errorStack = stack;
+    },
+    get() {
+      return errorStack;
+    }
+  };
+}();
 export {
   ACTION_ERROR_CODES,
   ACTION_QUERY_PARAMS,

package/dist/assets/utils/resolveImports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves an image src from a content file (such as markdown) to a module ID or import that can be resolved by Vite.
+ *
+ * @param imageSrc The src attribute of an image tag
+ * @param filePath The path to the file that contains the imagem relative to the site root
+ * @returns A module id of the image that can be rsolved by Vite, or undefined if it is not a local image
+ */
+export declare function imageSrcToImportId(imageSrc: string, filePath: string): string | undefined;
+export declare const importIdToSymbolName: (importId: string) => string;

package/dist/assets/utils/resolveImports.js

@@ -0,0 +1,22 @@
+import { isRemotePath, removeBase } from "@astrojs/internal-helpers/path";
+import { CONTENT_IMAGE_FLAG, IMAGE_IMPORT_PREFIX } from "../../content/consts.js";
+import { shorthash } from "../../runtime/server/shorthash.js";
+import { VALID_INPUT_FORMATS } from "../consts.js";
+function imageSrcToImportId(imageSrc, filePath) {
+  imageSrc = removeBase(imageSrc, IMAGE_IMPORT_PREFIX);
+  if (isRemotePath(imageSrc) || imageSrc.startsWith("/")) {
+    return;
+  }
+  const ext = imageSrc.split(".").at(-1);
+  if (!ext || !VALID_INPUT_FORMATS.includes(ext)) {
+    return;
+  }
+  const params = new URLSearchParams(CONTENT_IMAGE_FLAG);
+  params.set("importer", filePath);
+  return `${imageSrc}?${params.toString()}`;
+}
+const importIdToSymbolName = (importId) => `__ASTRO_IMAGE_IMPORT_${shorthash(importId)}`;
+export {
+  imageSrcToImportId,
+  importIdToSymbolName
+};

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

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface AddOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function add(names: string[], { flags }: AddOptions): Promise<void>;
 export {};

package/dist/cli/add/index.js

@@ -123,7 +123,7 @@ async function add(names, { flags }) {
     });
     return;
   }
-  const cwd = flags.root;
+  const cwd = inlineConfig.root;
   const logger = createLoggerFromFlags(flags);
   const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
   const integrations = await validateIntegrations(integrationNames);
@@ -222,7 +222,7 @@ async function add(names, { flags }) {
   }
   const rawConfigPath = await resolveConfigPath({
     root: rootPath,
-    configFile: flags.config,
+    configFile: inlineConfig.configFile,
     fs: fsMod
   });
   let configURL = rawConfigPath ? pathToFileURL(rawConfigPath) : void 0;

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

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface BuildOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function build({ flags }: BuildOptions): Promise<void>;
 export {};

package/dist/cli/build/index.js

@@ -9,6 +9,10 @@ async function build({ flags }) {
       tables: {
         Flags: [
           ["--outDir <directory>", `Specify the output directory for the build.`],
+          [
+            "--force",
+            "Clear the content layer and content collection cache, forcing a full rebuild."
+          ],
           ["--help (-h)", "See all available flags."]
         ]
       },
@@ -17,7 +21,7 @@ async function build({ flags }) {
     return;
   }
   const inlineConfig = flagsToAstroInlineConfig(flags);
-  await _build(inlineConfig, { force: flags.force ?? false });
+  await _build(inlineConfig);
 }
 export {
   build

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

@@ -1,2 +1,2 @@
-import type { Arguments } from 'yargs-parser';
-export declare function check(flags: Arguments): Promise<boolean | void>;
+import { type Flags } from '../flags.js';
+export declare function check(flags: Flags): Promise<boolean | void>;

package/dist/cli/check/index.js

@@ -5,7 +5,10 @@ import { getPackage } from "../install-package.js";
 async function check(flags) {
   ensureProcessNodeEnv("production");
   const logger = createLoggerFromFlags(flags);
-  const getPackageOpts = { skipAsk: flags.yes || flags.y, cwd: flags.root };
+  const getPackageOpts = {
+    skipAsk: !!flags.yes || !!flags.y,
+    cwd: typeof flags.root == "string" ? flags.root : void 0
+  };
   const checkPackage = await getPackage(
     "@astrojs/check",
     logger,
@@ -23,7 +26,7 @@ async function check(flags) {
   if (!flags.noSync && !flags.help) {
     const { default: sync } = await import("../../core/sync/index.js");
     try {
-      await sync({ inlineConfig: flagsToAstroInlineConfig(flags) });
+      await sync(flagsToAstroInlineConfig(flags));
     } catch (_) {
       return process.exit(1);
     }

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

@@ -1,4 +1,5 @@
-import type { Arguments } from 'yargs-parser';
-export declare function db({ flags }: {
-    flags: Arguments;
+import { type Flags } from '../flags.js';
+export declare function db({ positionals, flags }: {
+    positionals: string[];
+    flags: Flags;
 }): Promise<void>;