astro 4.11.6 → 4.12.0

package/client.d.ts

@@ -54,6 +54,7 @@ declare module 'astro:assets' {
 		) => Promise<import('./dist/assets/types.js').GetImageResult>;
 		imageConfig: import('./dist/@types/astro.js').AstroConfig['image'];
 		getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;
+		inferRemoteSize: typeof import('./dist/assets/utils/index.js').inferRemoteSize;
 		Image: typeof import('./components/Image.astro').default;
 		Picture: typeof import('./components/Picture.astro').default;
 	};

package/components/Code.astro

@@ -36,6 +36,16 @@ interface Props extends Omit<HTMLAttributes<'pre'>, 'lang'> {
 	 * Supports all themes found above; see https://shiki.style/guide/dual-themes for more information.
 	 */
 	themes?: Record<string, ThemePresets | ThemeRegistration | ThemeRegistrationRaw>;
+	/**
+	 * Chooses a theme from the "themes" option that you've defined as the default styling theme.
+	 *  - <string>: one of the keys defined in the "themes" option. Will throw an error if the key is not defined.
+	 *  - false: disabled. You'll have to apply the styling theme yourself. No effect if the "themes" option is not set.
+	 *
+	 * See https://shiki.style/guide/dual-themes#without-default-color for more information.
+	 *
+	 * @default "light"
+	 */
+	defaultColor?: 'light' | 'dark' | string | false;
 	/**
 	 * Enable word wrapping.
 	 *  - true: enabled.
@@ -64,6 +74,7 @@ const {
 	lang = 'plaintext',
 	theme = 'github-dark',
 	themes = {},
+	defaultColor = 'light',
 	wrap = false,
 	inline = false,
 	transformers = [],
@@ -92,6 +103,7 @@ const highlighter = await getCachedHighlighter({
 	],
 	theme,
 	themes,
+	defaultColor,
 	wrap,
 	transformers,
 });

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

@@ -6,7 +6,7 @@ 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 { RemotePattern } from '../assets/utils/remotePattern.js';
-import type { AssetsPrefix, SerializedSSRManifest } from '../core/app/types.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';
 import type { AstroTimer } from '../core/config/timer.js';
@@ -37,6 +37,7 @@ export interface AstroBuiltinProps {
     'client:media'?: string;
     'client:visible'?: ClientVisibleOptions | boolean;
     'client:only'?: boolean | string;
+    'server:defer'?: boolean;
 }
 export type ClientVisibleOptions = Pick<IntersectionObserverInit, 'rootMargin'>;
 export interface TransitionAnimation {
@@ -2056,6 +2057,70 @@ export interface AstroUserConfig {
              */
             validateSecrets?: boolean;
         };
+        /**
+         * @docs
+         * @name experimental.serverIslands
+         * @type {boolean}
+         * @default `false`
+         * @version 4.12.0
+         * @description
+         *
+         * Enables experimental Server Island features.
+         * Server Islands offer the ability to defer a component to render asynchronously after the page has already rendered.
+         *
+         * To enable, configure an [on-demand server rendering `output` mode](https://docs.astro.build/en/basics/rendering-modes/#on-demand-rendered) with an adapter, and add the `serverIslands` flag to the `experimental` object:
+         *
+         * ```js
+         * {
+         *   output: 'hybrid', // or 'server'
+         *   adapter: nodejs({ mode: 'standalone' }),
+         *   experimental: {
+         *     serverIslands: true,
+         *   },
+         * }
+         * ```
+         *
+         * Use the `server:defer` directive on any Astro component to delay initial rendering:
+         *
+         * ```astro "server:defer"
+         * ---
+         * import Avatar from '~/components/Avatar.astro';
+         * ---
+         * <Avatar server:defer />
+         * ```
+         *
+         * The outer page will be rendered, either at build-time (`hybrid`) or at runtime (`server`) with the island content omitted and a `<script>` tag included in its place.
+         *
+         * After the page loads in the browser, the script tag will replace itself with the the contents of the island by making a request.
+         *
+         * Any Astro component can be given the `server: defer` attribute to delay its rendering. There is no special API and you can write `.astro` code as normal:
+         *
+         * ```astro
+         * ---
+         * import { getUser } from '../api';
+         *
+         * const user = await getUser(Astro.locals.userId);
+         * ---
+         * <img class="avatar" src={user.imageUrl}>
+         * ```
+         *
+         * #### Server island fallback content
+         *
+         * Since your component will not render with the rest of the page, you may want to add generic content (e.g. a loading message) to temporarily show in its place. This content will be displayed when the page first renders but before the island has loaded.
+         *
+         * Add placeholder content as a child of your Astro component with the `slot="fallback:` attribute. When your island content is available, the fallback content will be replaced.
+         *
+         * The example below displays a generic avatar as fallback content, then animates into a personalized avatar using view transitions:
+         *
+         * ```astro
+         * <Avatar server:defer>
+         *   <svg slot="fallback" class="generic-avatar" transition:name="avatar">...</svg>
+         * </Avatar>
+         * ```
+         *
+         * 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;
     };
 }
 /**
@@ -2229,6 +2294,8 @@ export interface AstroSettings {
      * - the user is on the latest version already
      */
     latestAstroVersion: string | undefined;
+    serverIslandMap: NonNullable<SSRManifest['serverIslandMap']>;
+    serverIslandNameMap: NonNullable<SSRManifest['serverIslandNameMap']>;
 }
 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.) */
@@ -2426,6 +2493,10 @@ export interface Page<T = any> {
         prev: string | undefined;
         /** url of the next page (if there is one) */
         next: string | undefined;
+        /** url of the first page (if the current page is not the first page) */
+        first: string | undefined;
+        /** url of the next page (if the current page in not the last page) */
+        last: string | undefined;
     };
 }
 export type PaginateFunction = <PaginateData, AdditionalPaginateProps extends Props, AdditionalPaginateParams extends Params>(data: PaginateData[], args?: PaginateOptions<AdditionalPaginateProps, AdditionalPaginateParams>) => {
@@ -2771,84 +2842,91 @@ export interface SSRLoadedRenderer extends Pick<AstroRenderer, 'name' | 'clientE
     ssr: SSRLoadedRendererValue;
 }
 export type HookParameters<Hook extends keyof AstroIntegration['hooks'], Fn = AstroIntegration['hooks'][Hook]> = Fn extends (...args: any) => any ? Parameters<Fn>[0] : never;
+declare global {
+    namespace Astro {
+        interface IntegrationHooks {
+            'astro:config:setup': (options: {
+                config: AstroConfig;
+                command: 'dev' | 'build' | 'preview';
+                isRestart: boolean;
+                updateConfig: (newConfig: DeepPartial<AstroConfig>) => AstroConfig;
+                addRenderer: (renderer: AstroRenderer) => void;
+                addWatchFile: (path: URL | string) => void;
+                injectScript: (stage: InjectedScriptStage, content: string) => void;
+                injectRoute: (injectRoute: InjectedRoute) => void;
+                addClientDirective: (directive: ClientDirectiveConfig) => void;
+                /**
+                 * @deprecated Use `addDevToolbarApp` instead.
+                 * TODO: Fully remove in Astro 5.0
+                 */
+                addDevOverlayPlugin: (entrypoint: string) => void;
+                addDevToolbarApp: (entrypoint: DevToolbarAppEntry | string) => void;
+                addMiddleware: (mid: AstroIntegrationMiddleware) => void;
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
+            'astro:config:done': (options: {
+                config: AstroConfig;
+                setAdapter: (adapter: AstroAdapter) => void;
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
+            'astro:server:setup': (options: {
+                server: vite.ViteDevServer;
+                logger: AstroIntegrationLogger;
+                toolbar: ReturnType<typeof getToolbarServerCommunicationHelpers>;
+            }) => void | Promise<void>;
+            'astro:server:start': (options: {
+                address: AddressInfo;
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
+            'astro:server:done': (options: {
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
+            'astro:build:ssr': (options: {
+                manifest: SerializedSSRManifest;
+                /**
+                 * This maps a {@link RouteData} to an {@link URL}, this URL represents
+                 * the physical file you should import.
+                 */
+                entryPoints: Map<RouteData, URL>;
+                /**
+                 * File path of the emitted middleware
+                 */
+                middlewareEntryPoint: URL | undefined;
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
+            'astro:build:start': (options: {
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
+            'astro:build:setup': (options: {
+                vite: vite.InlineConfig;
+                pages: Map<string, PageBuildData>;
+                target: 'client' | 'server';
+                updateConfig: (newConfig: vite.InlineConfig) => void;
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
+            'astro:build:generated': (options: {
+                dir: URL;
+                logger: AstroIntegrationLogger;
+            }) => void | Promise<void>;
+            'astro:build:done': (options: {
+                pages: {
+                    pathname: string;
+                }[];
+                dir: URL;
+                routes: RouteData[];
+                logger: AstroIntegrationLogger;
+                cacheManifest: boolean;
+            }) => void | Promise<void>;
+        }
+    }
+}
 export interface AstroIntegration {
     /** The name of the integration. */
     name: string;
     /** The different hooks available to extend. */
     hooks: {
-        'astro:config:setup'?: (options: {
-            config: AstroConfig;
-            command: 'dev' | 'build' | 'preview';
-            isRestart: boolean;
-            updateConfig: (newConfig: DeepPartial<AstroConfig>) => AstroConfig;
-            addRenderer: (renderer: AstroRenderer) => void;
-            addWatchFile: (path: URL | string) => void;
-            injectScript: (stage: InjectedScriptStage, content: string) => void;
-            injectRoute: (injectRoute: InjectedRoute) => void;
-            addClientDirective: (directive: ClientDirectiveConfig) => void;
-            /**
-             * @deprecated Use `addDevToolbarApp` instead.
-             * TODO: Fully remove in Astro 5.0
-             */
-            addDevOverlayPlugin: (entrypoint: string) => void;
-            addDevToolbarApp: (entrypoint: DevToolbarAppEntry | string) => void;
-            addMiddleware: (mid: AstroIntegrationMiddleware) => void;
-            logger: AstroIntegrationLogger;
-        }) => void | Promise<void>;
-        'astro:config:done'?: (options: {
-            config: AstroConfig;
-            setAdapter: (adapter: AstroAdapter) => void;
-            logger: AstroIntegrationLogger;
-        }) => void | Promise<void>;
-        'astro:server:setup'?: (options: {
-            server: vite.ViteDevServer;
-            logger: AstroIntegrationLogger;
-            toolbar: ReturnType<typeof getToolbarServerCommunicationHelpers>;
-        }) => void | Promise<void>;
-        'astro:server:start'?: (options: {
-            address: AddressInfo;
-            logger: AstroIntegrationLogger;
-        }) => void | Promise<void>;
-        'astro:server:done'?: (options: {
-            logger: AstroIntegrationLogger;
-        }) => void | Promise<void>;
-        'astro:build:ssr'?: (options: {
-            manifest: SerializedSSRManifest;
-            /**
-             * This maps a {@link RouteData} to an {@link URL}, this URL represents
-             * the physical file you should import.
-             */
-            entryPoints: Map<RouteData, URL>;
-            /**
-             * File path of the emitted middleware
-             */
-            middlewareEntryPoint: URL | undefined;
-            logger: AstroIntegrationLogger;
-        }) => void | Promise<void>;
-        'astro:build:start'?: (options: {
-            logger: AstroIntegrationLogger;
-        }) => void | Promise<void>;
-        'astro:build:setup'?: (options: {
-            vite: vite.InlineConfig;
-            pages: Map<string, PageBuildData>;
-            target: 'client' | 'server';
-            updateConfig: (newConfig: vite.InlineConfig) => void;
-            logger: AstroIntegrationLogger;
-        }) => void | Promise<void>;
-        'astro:build:generated'?: (options: {
-            dir: URL;
-            logger: AstroIntegrationLogger;
-        }) => void | Promise<void>;
-        'astro:build:done'?: (options: {
-            pages: {
-                pathname: string;
-            }[];
-            dir: URL;
-            routes: RouteData[];
-            logger: AstroIntegrationLogger;
-            cacheManifest: boolean;
-        }) => void | Promise<void>;
-    };
+        [K in keyof Astro.IntegrationHooks]?: Astro.IntegrationHooks[K];
+    } & Partial<Record<string, unknown>>;
 }
 export type RewritePayload = string | URL | Request;
 export type MiddlewareNext = (rewritePayload?: RewritePayload) => Promise<Response>;
@@ -2941,6 +3019,7 @@ export interface SSRResult {
     componentMetadata: Map<string, SSRComponentMetadata>;
     inlinedScripts: Map<string, string>;
     createAstro(Astro: AstroGlobalPartial, props: Record<string, any>, slots: Record<string, any> | null): AstroGlobal;
+    params: Params;
     resolve: (s: string) => Promise<string>;
     response: AstroGlobal['response'];
     request: AstroGlobal['request'];
@@ -2957,6 +3036,7 @@ export interface SSRResult {
      */
     pathname: string;
     cookies: AstroCookies | undefined;
+    serverIslandNameMap: Map<string, string>;
     _metadata: SSRMetadata;
 }
 /**

package/dist/actions/index.d.ts

@@ -1,2 +1,5 @@
+import fsMod from 'node:fs';
 import type { AstroIntegration } from '../@types/astro.js';
-export default function astroActions(): AstroIntegration;
+export default function astroActions({ fs }: {
+    fs?: typeof fsMod;
+}): AstroIntegration;

package/dist/actions/index.js

@@ -1,9 +1,9 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import fsMod from "node:fs";
 import { ActionsWithoutServerOutputError } from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/errors.js";
 import { isServerLikeOutput, viteID } from "../core/util.js";
 import { ACTIONS_TYPES_FILE, RESOLVED_VIRTUAL_MODULE_ID, VIRTUAL_MODULE_ID } from "./consts.js";
-function astroActions() {
+function astroActions({ fs = fsMod }) {
   return {
     name: VIRTUAL_MODULE_ID,
     hooks: {
@@ -21,7 +21,7 @@ function astroActions() {
             define: {
               "import.meta.env.ACTIONS_PATH": stringifiedActionsImport
             },
-            plugins: [vitePluginActions]
+            plugins: [vitePluginActions(fs)]
           }
         });
         params.injectRoute({
@@ -35,13 +35,14 @@ function astroActions() {
         });
         await typegen({
           stringifiedActionsImport,
-          root: params.config.root
+          root: params.config.root,
+          fs
         });
       }
     }
   };
 }
-const vitePluginActions = {
+const vitePluginActions = (fs) => ({
   name: VIRTUAL_MODULE_ID,
   enforce: "pre",
   resolveId(id) {
@@ -51,7 +52,10 @@ const vitePluginActions = {
   },
   async load(id, opts) {
     if (id !== RESOLVED_VIRTUAL_MODULE_ID) return;
-    let code = await readFile(new URL("../../templates/actions.mjs", import.meta.url), "utf-8");
+    let code = await fs.promises.readFile(
+      new URL("../../templates/actions.mjs", import.meta.url),
+      "utf-8"
+    );
     if (opts?.ssr) {
       code += `
 export * from 'astro/actions/runtime/virtual/server.js';`;
@@ -61,10 +65,11 @@ export * from 'astro/actions/runtime/virtual/client.js';`;
     }
     return code;
   }
-};
+});
 async function typegen({
   stringifiedActionsImport,
-  root
+  root,
+  fs
 }) {
   const content = `declare module "astro:actions" {
 	type Actions = typeof import(${stringifiedActionsImport})["server"];
@@ -72,8 +77,8 @@ async function typegen({
 	export const actions: Actions;
 }`;
   const dotAstroDir = new URL(".astro/", root);
-  await mkdir(dotAstroDir, { recursive: true });
-  await writeFile(new URL(ACTIONS_TYPES_FILE, dotAstroDir), content);
+  await fs.promises.mkdir(dotAstroDir, { recursive: true });
+  await fs.promises.writeFile(new URL(ACTIONS_TYPES_FILE, dotAstroDir), content);
 }
 export {
   astroActions as default

package/dist/assets/internal.js

@@ -5,7 +5,7 @@ import {
   isImageMetadata
 } from "./types.js";
 import { isESMImportedImage, isRemoteImage, resolveSrc } from "./utils/imageKind.js";
-import { probe } from "./utils/remoteProbe.js";
+import { inferRemoteSize } from "./utils/remoteProbe.js";
 async function getConfiguredImageService() {
   if (!globalThis?.astroAsset?.imageService) {
     const { default: service } = await import(
@@ -48,17 +48,10 @@ async function getImage(options, imageConfig) {
     src: await resolveSrc(options.src)
   };
   if (options.inferSize && isRemoteImage(resolvedOptions.src)) {
-    try {
-      const result = await probe(resolvedOptions.src);
-      resolvedOptions.width ??= result.width;
-      resolvedOptions.height ??= result.height;
-      delete resolvedOptions.inferSize;
-    } catch {
-      throw new AstroError({
-        ...AstroErrorData.FailedToFetchRemoteImageDimensions,
-        message: AstroErrorData.FailedToFetchRemoteImageDimensions.message(resolvedOptions.src)
-      });
-    }
+    const result = await inferRemoteSize(resolvedOptions.src);
+    resolvedOptions.width ??= result.width;
+    resolvedOptions.height ??= result.height;
+    delete resolvedOptions.inferSize;
   }
   const originalFilePath = isESMImportedImage(resolvedOptions.src) ? resolvedOptions.src.fsPath : void 0;
   const clonedSrc = isESMImportedImage(resolvedOptions.src) ? (

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

@@ -1,6 +1,7 @@
-export { emitESMImage } from './emitAsset.js';
+export { emitESMImage } from './node/emitAsset.js';
 export { isESMImportedImage, isRemoteImage } from './imageKind.js';
 export { imageMetadata } from './metadata.js';
 export { getOrigQueryParams } from './queryParams.js';
 export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from './remotePattern.js';
 export { hashTransform, propsToFilename } from './transformToPath.js';
+export { inferRemoteSize } from './remoteProbe.js';

package/dist/assets/utils/index.js

@@ -1,4 +1,4 @@
-import { emitESMImage } from "./emitAsset.js";
+import { emitESMImage } from "./node/emitAsset.js";
 import { isESMImportedImage, isRemoteImage } from "./imageKind.js";
 import { imageMetadata } from "./metadata.js";
 import { getOrigQueryParams } from "./queryParams.js";
@@ -11,11 +11,13 @@ import {
   matchProtocol
 } from "./remotePattern.js";
 import { hashTransform, propsToFilename } from "./transformToPath.js";
+import { inferRemoteSize } from "./remoteProbe.js";
 export {
   emitESMImage,
   getOrigQueryParams,
   hashTransform,
   imageMetadata,
+  inferRemoteSize,
   isESMImportedImage,
   isRemoteAllowed,
   isRemoteImage,

package/dist/assets/utils/{emitAsset.d.ts → node/emitAsset.d.ts}

@@ -1,5 +1,5 @@
 import type * as vite from 'vite';
-import type { ImageMetadata } from '../types.js';
+import type { ImageMetadata } from '../../types.js';
 type FileEmitter = vite.Rollup.EmitFile;
 export declare function emitESMImage(id: string | undefined, 
 /** @deprecated */

package/dist/assets/utils/{emitAsset.js → node/emitAsset.js}

@@ -1,8 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { prependForwardSlash, slash } from "../../core/path.js";
-import { imageMetadata } from "./metadata.js";
+import { prependForwardSlash, slash } from "../../../core/path.js";
+import { imageMetadata } from "../metadata.js";
 async function emitESMImage(id, _watchMode, fileEmitter) {
   if (!id) {
     return void 0;

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

@@ -1,2 +1,2 @@
-import type { ISize } from './vendor/image-size/types/interface.ts';
-export declare function probe(url: string): Promise<ISize>;
+import type { ImageMetadata } from '../types.js';
+export declare function inferRemoteSize(url: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

package/dist/assets/utils/remoteProbe.js

@@ -1,8 +1,12 @@
-import { lookup } from "./vendor/image-size/lookup.js";
-async function probe(url) {
+import { AstroError, AstroErrorData } from "../../core/errors/index.js";
+import { imageMetadata } from "./metadata.js";
+async function inferRemoteSize(url) {
   const response = await fetch(url);
   if (!response.body || !response.ok) {
-    throw new Error("Failed to fetch image");
+    throw new AstroError({
+      ...AstroErrorData.FailedToFetchRemoteImageDimensions,
+      message: AstroErrorData.FailedToFetchRemoteImageDimensions.message(url)
+    });
   }
   const reader = response.body.getReader();
   let done, value;
@@ -18,7 +22,7 @@ async function probe(url) {
       tmp.set(value, accumulatedChunks.length);
       accumulatedChunks = tmp;
       try {
-        const dimensions = lookup(accumulatedChunks);
+        const dimensions = await imageMetadata(accumulatedChunks, url);
         if (dimensions) {
           await reader.cancel();
           return dimensions;
@@ -27,8 +31,11 @@ async function probe(url) {
       }
     }
   }
-  throw new Error("Failed to parse the size");
+  throw new AstroError({
+    ...AstroErrorData.NoImageMetadata,
+    message: AstroErrorData.NoImageMetadata.message(url)
+  });
 }
 export {
-  probe
+  inferRemoteSize
 };

package/dist/assets/vite-plugin-assets.js

@@ -12,9 +12,9 @@ import {
 } from "../core/path.js";
 import { isServerLikeOutput } from "../core/util.js";
 import { VALID_INPUT_FORMATS, VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
-import { emitESMImage } from "./utils/emitAsset.js";
 import { getAssetsPrefix } from "./utils/getAssetsPrefix.js";
 import { isESMImportedImage } from "./utils/imageKind.js";
+import { emitESMImage } from "./utils/node/emitAsset.js";
 import { getProxyCode } from "./utils/proxy.js";
 import { hashTransform, propsToFilename } from "./utils/transformToPath.js";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
@@ -101,6 +101,7 @@ function assets({
 					import { getImage as getImageInternal } from "astro/assets";
 					export { default as Image } from "astro/components/Image.astro";
 					export { default as Picture } from "astro/components/Picture.astro";
+					export { inferRemoteSize } from "astro/assets/utils/inferRemoteSize.js";
 
 					export const imageConfig = ${JSON.stringify(settings.config.image)};
 					// This is used by the @astrojs/node integration to locate images.

package/dist/cli/check/index.js

@@ -20,11 +20,13 @@ async function check(flags) {
     );
     return;
   }
-  const { default: sync } = await import("../../core/sync/index.js");
-  const inlineConfig = flagsToAstroInlineConfig(flags);
-  const exitCode = await sync(inlineConfig);
-  if (exitCode !== 0) {
-    process.exit(exitCode);
+  if (!flags.noSync && !flags.help) {
+    const { default: sync } = await import("../../core/sync/index.js");
+    try {
+      await sync({ inlineConfig: flagsToAstroInlineConfig(flags) });
+    } catch (_) {
+      return process.exit(1);
+    }
   }
   const { check: checker, parseArgsAsCheckConfig } = checkPackage;
   const config = parseArgsAsCheckConfig(process.argv);

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

@@ -2,5 +2,5 @@ import type yargs from 'yargs-parser';
 interface SyncOptions {
     flags: yargs.Arguments;
 }
-export declare function sync({ flags }: SyncOptions): Promise<import("../../core/sync/index.js").ProcessExit>;
+export declare function sync({ flags }: SyncOptions): Promise<0 | 1>;
 export {};

package/dist/cli/sync/index.js

@@ -13,9 +13,12 @@ async function sync({ flags }) {
     });
     return 0;
   }
-  const inlineConfig = flagsToAstroInlineConfig(flags);
-  const exitCode = await _sync(inlineConfig);
-  return exitCode;
+  try {
+    await _sync({ inlineConfig: flagsToAstroInlineConfig(flags), telemetry: true });
+    return 0;
+  } catch (_) {
+    return 1;
+  }
 }
 export {
   sync

package/dist/container/index.js

@@ -5,13 +5,15 @@ import { Logger } from "../core/logger/core.js";
 import { nodeLogDestination } from "../core/logger/node.js";
 import { removeLeadingForwardSlash } from "../core/path.js";
 import { RenderContext } from "../core/render-context.js";
-import { getParts, getPattern, validateSegment } from "../core/routing/manifest/create.js";
+import { getParts, validateSegment } from "../core/routing/manifest/create.js";
+import { getPattern } from "../core/routing/manifest/pattern.js";
 import { ContainerPipeline } from "./pipeline.js";
 function createManifest(manifest, renderers, middleware) {
   const defaultMiddleware = (_, next) => {
     return next();
   };
   return {
+    hrefRoot: import.meta.url,
     rewritingEnabled: false,
     trailingSlash: manifest?.trailingSlash ?? ASTRO_CONFIG_DEFAULTS.trailingSlash,
     buildFormat: manifest?.buildFormat ?? ASTRO_CONFIG_DEFAULTS.build.format,

package/dist/content/runtime-assets.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { emitESMImage } from "../assets/utils/emitAsset.js";
+import { emitESMImage } from "../assets/utils/node/emitAsset.js";
 function createImage(pluginContext, shouldEmitFile, entryFilePath) {
   return () => {
     return z.string().transform(async (imagePath, ctx) => {

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -8,6 +8,7 @@ import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { appendForwardSlash, removeFileExtension } from "../core/path.js";
 import { isServerLikeOutput } from "../core/util.js";
 import { rootRelativePath } from "../core/viteUtils.js";
+import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
 import {
   CONTENT_FLAG,
   CONTENT_RENDER_FLAG,
@@ -65,17 +66,12 @@ function astroContentVirtualModPlugin({
           IS_SERVER,
           isClient
         });
+        const astro = createDefaultAstroMetadata();
+        astro.propagation = "in-tree";
         return {
           code,
           meta: {
-            astro: {
-              hydratedComponents: [],
-              clientOnlyComponents: [],
-              scripts: [],
-              containsHead: false,
-              propagation: "in-tree",
-              pageOptions: {}
-            }
+            astro
           }
         };
       }