astro 5.0.0-alpha.6 → 5.0.0-alpha.8

package/client.d.ts

@@ -116,8 +116,12 @@ declare module 'astro:transitions' {
 	export const fade: TransitionModule['fade'];
 	export const createAnimationScope: TransitionModule['createAnimationScope'];
 
-	type ViewTransitionsModule = typeof import('./components/ViewTransitions.astro');
-	export const ViewTransitions: ViewTransitionsModule['default'];
+	type ClientRouterModule = typeof import('./components/ClientRouter.astro');
+	/**
+	 * @deprecated The ViewTransitions component has been renamed to ClientRouter
+	 */
+	export const ViewTransitions: ClientRouterModule['default'];
+	export const ClientRouter: ClientRouterModule['default'];
 }
 
 declare module 'astro:transitions/client' {

package/config.d.ts

@@ -1,3 +1,4 @@
+/// <reference path='./client.d.ts' />
 type ViteUserConfig = import('vite').UserConfig;
 type ViteUserConfigFn = import('vite').UserConfigFn;
 type AstroUserConfig = import('./dist/types/public/config.js').AstroUserConfig;

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

@@ -34,7 +34,7 @@ function getFormServerHandler(handler, inputSchema) {
       });
     }
     if (!inputSchema) return await handler(unparsedInput, context);
-    const baseSchema = unwrapSchemaEffects(inputSchema);
+    const baseSchema = unwrapBaseObjectSchema(inputSchema, unparsedInput);
     const parsed = await inputSchema.safeParseAsync(
       baseSchema instanceof z.ZodObject ? formDataToObject(unparsedInput, baseSchema) : unparsedInput
     );
@@ -100,7 +100,7 @@ function handleFormDataGet(key, formData, validator, baseValidator) {
   }
   return validator instanceof z.ZodNumber ? Number(value) : value;
 }
-function unwrapSchemaEffects(schema) {
+function unwrapBaseObjectSchema(schema, unparsedInput) {
   while (schema instanceof z.ZodEffects || schema instanceof z.ZodPipeline) {
     if (schema instanceof z.ZodEffects) {
       schema = schema._def.schema;
@@ -109,6 +109,14 @@ function unwrapSchemaEffects(schema) {
       schema = schema._def.in;
     }
   }
+  if (schema instanceof z.ZodDiscriminatedUnion) {
+    const typeKey = schema._def.discriminator;
+    const typeValue = unparsedInput.get(typeKey);
+    if (typeof typeValue !== "string") return schema;
+    const objSchema = schema._def.optionsMap.get(typeValue);
+    if (!objSchema) return schema;
+    return objSchema;
+  }
   return schema;
 }
 export {

package/dist/assets/build/generate.js

@@ -48,9 +48,9 @@ function getFullImagePath(originalFilePath, env) {
   return new URL(removeLeadingForwardSlash(originalFilePath), env.serverRoot);
 }
 async function generateImagesForPath(originalFilePath, transformsAndPath, env, queue) {
-  const originalImageData = await loadImage(originalFilePath, env);
+  let originalImage;
   for (const [_, transform] of transformsAndPath.transforms) {
-    await queue.add(async () => generateImage(originalImageData, transform.finalPath, transform.transform)).catch((e) => {
+    await queue.add(async () => generateImage(transform.finalPath, transform.transform)).catch((e) => {
       throw e;
     });
   }
@@ -66,9 +66,9 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     } catch {
     }
   }
-  async function generateImage(originalImage, filepath, options) {
+  async function generateImage(filepath, options) {
     const timeStart = performance.now();
-    const generationData = await generateImageInternal(originalImage, filepath, options);
+    const generationData = await generateImageInternal(filepath, options);
     const timeEnd = performance.now();
     const timeChange = getTimeStat(timeStart, timeEnd);
     const timeIncrease = `(+${timeChange})`;
@@ -80,7 +80,7 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     );
     env.count.current++;
   }
-  async function generateImageInternal(originalImage, filepath, options) {
+  async function generateImageInternal(filepath, options) {
     const isLocalImage = isESMImportedImage(options.src);
     const finalFileURL = new URL("." + filepath, env.clientRoot);
     const cacheFile = basename(filepath) + (isLocalImage ? "" : ".json");
@@ -116,6 +116,9 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     const finalFolderURL = new URL("./", finalFileURL);
     await fs.promises.mkdir(finalFolderURL, { recursive: true });
     const originalImagePath = isLocalImage ? options.src.src : options.src;
+    if (!originalImage) {
+      originalImage = await loadImage(originalFilePath, env);
+    }
     let resultData = {
       data: void 0,
       expires: originalImage.expires

package/dist/assets/endpoint/config.js

@@ -1,4 +1,9 @@
+import {
+  removeLeadingForwardSlash,
+  removeTrailingForwardSlash
+} from "@astrojs/internal-helpers/path";
 import { resolveInjectedRoute } from "../../core/routing/manifest/create.js";
+import { getPattern } from "../../core/routing/manifest/pattern.js";
 function injectImageEndpoint(settings, manifest, mode, cwd) {
   manifest.routes.push(getImageEndpointData(settings, mode, cwd));
 }
@@ -8,17 +13,28 @@ function ensureImageEndpointRoute(settings, manifest, mode, cwd) {
   }
 }
 function getImageEndpointData(settings, mode, cwd) {
-  const endpointEntrypoint = settings.config.image.endpoint ?? (mode === "dev" ? "astro/assets/endpoint/node" : "astro/assets/endpoint/generic");
+  const endpointEntrypoint = settings.config.image.endpoint.entrypoint === void 0 ? mode === "dev" ? "astro/assets/endpoint/node" : "astro/assets/endpoint/generic" : settings.config.image.endpoint.entrypoint;
+  const segments = [
+    [
+      {
+        content: removeTrailingForwardSlash(
+          removeLeadingForwardSlash(settings.config.image.endpoint.route)
+        ),
+        dynamic: false,
+        spread: false
+      }
+    ]
+  ];
   return {
     type: "endpoint",
     isIndex: false,
-    route: "/_image",
-    pattern: /^\/_image$/,
-    segments: [[{ content: "_image", dynamic: false, spread: false }]],
+    route: settings.config.image.endpoint.route,
+    pattern: getPattern(segments, settings.config.base, settings.config.trailingSlash),
+    segments,
     params: [],
     component: resolveInjectedRoute(endpointEntrypoint, settings.config.root, cwd).component,
     generate: () => "",
-    pathname: "/_image",
+    pathname: settings.config.image.endpoint.route,
     prerender: false,
     fallbackRoutes: []
   };

package/dist/assets/services/service.d.ts

@@ -13,7 +13,7 @@ interface SharedServiceProps<T extends Record<string, any> = Record<string, any>
     /**
      * Return the URL to the endpoint or URL your images are generated from.
      *
-     * For a local service, your service should expose an endpoint handling the image requests, or use Astro's at `/_image`.
+     * For a local service, your service should expose an endpoint handling the image requests, or use Astro's which by default, is located at `/_image`.
      *
      * For external services, this should point to the URL your images are coming from, for instance, `/_vercel/image`
      *

package/dist/assets/services/service.js

@@ -167,7 +167,7 @@ const baseService = {
     Object.entries(params).forEach(([param, key]) => {
       options[key] && searchParams.append(param, options[key].toString());
     });
-    const imageEndpoint = joinPaths(import.meta.env.BASE_URL, "/_image");
+    const imageEndpoint = joinPaths(import.meta.env.BASE_URL, imageConfig.endpoint.route);
     return `${imageEndpoint}?${searchParams}`;
   },
   parseURL(url) {

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

@@ -72,7 +72,7 @@ function assets({
     referencedImages: /* @__PURE__ */ new Set()
   };
   return [
-    // Expose the components and different utilities from `astro:assets` and handle serving images from `/_image` in dev
+    // Expose the components and different utilities from `astro:assets`
     {
       name: "astro:assets",
       async resolveId(id) {

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

@@ -10,5 +10,5 @@ interface IntegrationInfo {
     type: 'integration' | 'adapter';
 }
 export declare function add(names: string[], { flags }: AddOptions): Promise<void>;
-export declare function setAdapter(mod: ProxifiedModule<any>, adapter: IntegrationInfo): void;
+export declare function setAdapter(mod: ProxifiedModule<any>, adapter: IntegrationInfo, exportName: string): void;
 export {};

package/dist/cli/add/index.js

@@ -247,7 +247,7 @@ async function add(names, { flags }) {
       if (isAdapter(integration)) {
         const officialExportName = OFFICIAL_ADAPTER_TO_IMPORT_MAP[integration.id];
         if (officialExportName) {
-          setAdapter(mod, integration);
+          setAdapter(mod, integration, officialExportName);
         } else {
           logger.info(
             "SKIP_FORMAT",
@@ -371,14 +371,14 @@ function addIntegration(mod, integration) {
     config.integrations.push(builders.functionCall(integrationId));
   }
 }
-function setAdapter(mod, adapter) {
+function setAdapter(mod, adapter, exportName) {
   const config = getDefaultExportOptions(mod);
   const adapterId = toIdent(adapter.id);
   if (!mod.imports.$items.some((imp) => imp.local === adapterId)) {
     mod.imports.$append({
       imported: "default",
       local: adapterId,
-      from: adapter.packageName
+      from: exportName
     });
   }
   if (!config.output) {

package/dist/cli/create-key/index.d.ts

@@ -0,0 +1,6 @@
+import { type Flags } from '../flags.js';
+interface CreateKeyOptions {
+    flags: Flags;
+}
+export declare function createKey({ flags }: CreateKeyOptions): Promise<0 | 1>;
+export {};

package/dist/cli/create-key/index.js

@@ -0,0 +1,27 @@
+import { createNodeLogger } from "../../core/config/logging.js";
+import { createKey as createCryptoKey, encodeKey } from "../../core/encryption.js";
+import { flagsToAstroInlineConfig } from "../flags.js";
+async function createKey({ flags }) {
+  try {
+    const inlineConfig = flagsToAstroInlineConfig(flags);
+    const logger = createNodeLogger(inlineConfig);
+    const keyPromise = createCryptoKey();
+    const key = await keyPromise;
+    const encoded = await encodeKey(key);
+    logger.info(
+      "crypto",
+      `Generated a key to encrypt props passed to Server islands. To reuse the same key across builds, set this value as ASTRO_KEY in an environment variable on your build server.
+
+ASTRO_KEY=${encoded}`
+    );
+  } catch (err) {
+    if (err != null) {
+      console.error(err.toString());
+    }
+    return 1;
+  }
+  return 0;
+}
+export {
+  createKey
+};

package/dist/cli/index.js

@@ -12,6 +12,7 @@ async function printAstroHelp() {
         ["add", "Add an integration."],
         ["build", "Build your project and write it to disk."],
         ["check", "Check your project for errors."],
+        ["create-key", "Create a cryptography key"],
         ["db", "Manage your Astro database."],
         ["dev", "Start the development server."],
         ["docs", "Open documentation in your web browser."],
@@ -55,6 +56,7 @@ function resolveCommand(flags) {
     "build",
     "preview",
     "check",
+    "create-key",
     "docs",
     "db",
     "info",
@@ -81,6 +83,11 @@ async function runCommand(cmd, flags) {
       await printInfo({ flags });
       return;
     }
+    case "create-key": {
+      const { createKey } = await import("./create-key/index.js");
+      const exitCode = await createKey({ flags });
+      return process.exit(exitCode);
+    }
     case "docs": {
       const { docs } = await import("./docs/index.js");
       await docs({ flags });

package/dist/cli/info/index.js

@@ -36,6 +36,7 @@ async function printInfo({ flags }) {
   await copyToClipboard(output);
 }
 async function copyToClipboard(text) {
+  text = text.trim();
   const system = platform();
   let command = "";
   if (system === "darwin") {
@@ -43,15 +44,22 @@ async function copyToClipboard(text) {
   } else if (system === "win32") {
     command = "clip";
   } else {
-    try {
-      const output = execSync("which xclip", { encoding: "utf8" });
-      if (output[0] !== "/") {
-        return;
+    const unixCommands = [
+      ["xclip", "-sel clipboard -l 1"],
+      ["wl-copy", '"$0"']
+    ];
+    for (const [unixCommand, args] of unixCommands) {
+      try {
+        const output = execSync(`which ${unixCommand}`, { encoding: "utf8", stdio: "pipe" });
+        if (output[0] !== "/") {
+          continue;
+        }
+        command = `${unixCommand} ${args}`;
+      } catch {
+        continue;
       }
-      command = "xclip -sel clipboard -l 1";
-    } catch {
-      return;
     }
+    if (!command) return;
   }
   console.log();
   const { shouldCopy } = await prompts({
@@ -62,8 +70,9 @@ async function copyToClipboard(text) {
   });
   if (!shouldCopy) return;
   try {
-    execSync(command, {
-      input: text.trim(),
+    execSync(command.replaceAll("$0", text), {
+      stdio: "ignore",
+      input: text,
       encoding: "utf8"
     });
   } catch {

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

@@ -52,12 +52,7 @@ export declare class App {
     set setManifestData(newManifestData: ManifestData);
     removeBase(pathname: string): string;
     match(request: Request): RouteData | undefined;
-    render(request: Request, options?: RenderOptions): Promise<Response>;
-    /**
-     * @deprecated Instead of passing `RouteData` and locals individually, pass an object with `routeData` and `locals` properties.
-     * See https://github.com/withastro/astro/pull/9199 for more information.
-     */
-    render(request: Request, routeData?: RouteData, locals?: object): Promise<Response>;
+    render(request: Request, renderOptions?: RenderOptions): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, string[], unknown>;
     /**
      * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.

package/dist/core/app/index.js

@@ -161,31 +161,15 @@ class App {
     }
     return pathname;
   }
-  async render(request, routeDataOrOptions, maybeLocals) {
+  async render(request, renderOptions) {
     let routeData;
     let locals;
     let clientAddress;
     let addCookieHeader;
-    if (routeDataOrOptions && ("addCookieHeader" in routeDataOrOptions || "clientAddress" in routeDataOrOptions || "locals" in routeDataOrOptions || "routeData" in routeDataOrOptions)) {
-      if ("addCookieHeader" in routeDataOrOptions) {
-        addCookieHeader = routeDataOrOptions.addCookieHeader;
-      }
-      if ("clientAddress" in routeDataOrOptions) {
-        clientAddress = routeDataOrOptions.clientAddress;
-      }
-      if ("routeData" in routeDataOrOptions) {
-        routeData = routeDataOrOptions.routeData;
-      }
-      if ("locals" in routeDataOrOptions) {
-        locals = routeDataOrOptions.locals;
-      }
-    } else {
-      routeData = routeDataOrOptions;
-      locals = maybeLocals;
-      if (routeDataOrOptions || locals) {
-        this.#logRenderOptionsDeprecationWarning();
-      }
-    }
+    addCookieHeader = renderOptions?.addCookieHeader;
+    clientAddress = renderOptions?.clientAddress;
+    routeData = renderOptions?.routeData;
+    locals = renderOptions?.locals;
     if (routeData) {
       this.#logger.debug(
         "router",
@@ -254,14 +238,6 @@ class App {
     Reflect.set(response, responseSentSymbol, true);
     return response;
   }
-  #logRenderOptionsDeprecationWarning() {
-    if (this.#renderOptionsDeprecationWarningShown) return;
-    this.#logger.warn(
-      "deprecated",
-      `The adapter ${this.#manifest.adapterName} is using a deprecated signature of the 'app.render()' method. From Astro 4.0, locals and routeData are provided as properties on an optional object to this method. Using the old signature will cause an error in Astro 5.0. See https://github.com/withastro/astro/pull/9199 for more information.`
-    );
-    this.#renderOptionsDeprecationWarningShown = true;
-  }
   setCookieHeaders(response) {
     return getSetCookiesFromResponse(response);
   }

package/dist/core/build/generate.js

@@ -283,7 +283,6 @@ async function generatePath(pathname, pipeline, gopts, route) {
     route.type
   );
   const request = createRequest({
-    base: config.base,
     url,
     headers: new Headers(),
     logger,
@@ -329,7 +328,11 @@ async function generatePath(pathname, pipeline, gopts, route) {
   }
   const outFolder = getOutFolder(pipeline.settings, pathname, route);
   const outFile = getOutFile(config, outFolder, pathname, route);
-  route.distURL = outFile;
+  if (route.distURL) {
+    route.distURL.push(outFile);
+  } else {
+    route.distURL = [outFile];
+  }
   await fs.promises.mkdir(outFolder, { recursive: true });
   await fs.promises.writeFile(outFile, body);
 }

package/dist/core/build/index.js

@@ -15,7 +15,7 @@ import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
 import { createSettings } from "../config/settings.js";
 import { createVite } from "../create-vite.js";
-import { createKey } from "../encryption.js";
+import { createKey, getEnvironmentKey, hasEnvironmentKey } from "../encryption.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { levels, timerMessage } from "../logger/core.js";
 import { apply as applyPolyfill } from "../polyfill.js";
@@ -137,6 +137,8 @@ class AstroBuilder {
       "build",
       green(`\u2713 Completed in ${getTimeStat(this.timer.init, performance.now())}.`)
     );
+    const hasKey = hasEnvironmentKey();
+    const keyPromise = hasKey ? getEnvironmentKey() : createKey();
     const opts = {
       allPages,
       settings: this.settings,
@@ -147,9 +149,13 @@ class AstroBuilder {
       pageNames,
       teardownCompiler: this.teardownCompiler,
       viteConfig,
-      key: createKey()
+      key: keyPromise
     };
     const { internals, ssrOutputChunkNames, contentFileNames } = await viteBuild(opts);
+    const hasServerIslands = this.settings.serverIslandNameMap.size > 0;
+    if (hasServerIslands && this.settings.buildOutput !== "server") {
+      throw new AstroError(AstroErrorData.NoAdapterInstalledServerIslands);
+    }
     await staticBuild(opts, internals, ssrOutputChunkNames, contentFileNames);
     this.timer.assetsStart = performance.now();
     Object.keys(assets).map((k) => {
@@ -163,9 +169,7 @@ class AstroBuilder {
     await runHookBuildDone({
       settings: this.settings,
       pages: pageNames,
-      routes: Object.values(allPages).flat().map((pageData) => pageData.route).concat(
-        this.settings.config.experimental.serverIslands ? [getServerIslandRouteData(this.settings.config)] : []
-      ),
+      routes: Object.values(allPages).flat().map((pageData) => pageData.route).concat(hasServerIslands ? getServerIslandRouteData(this.settings.config) : []),
       logging: this.logger,
       cacheManifest: internals.cacheManifestUsed
     });

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

@@ -99,16 +99,6 @@ export declare function getPageDatasByClientOnlyID(internals: BuildInternals, vi
  * @param component The component of the page, used to identify the page
  */
 export declare function getPageData(internals: BuildInternals, route: string, component: string): PageBuildData | undefined;
-/**
- * Map internals.pagesByKeys to a new map with the public key instead of the internal key.
- * This function is only used to avoid breaking changes in the Integrations API, after we changed the way
- * we identify pages, from the entrypoint component to an internal key.
- * If the page component is unique -> the public key is the component path. (old behavior)
- * If the page component is shared -> the public key is the internal key. (new behavior)
- * The new behavior on shared entrypoint it's not a breaking change, because it was not supported before.
- * @param pagesByKeys A map of all page data by their internal key
- */
-export declare function getPageDatasWithPublicKey(pagesByKeys: Map<string, PageBuildData>): Map<string, PageBuildData>;
 export declare function getPageDataByViteID(internals: BuildInternals, viteid: ViteID): PageBuildData | undefined;
 export declare function hasPrerenderedPages(internals: BuildInternals): boolean;
 interface OrderInfo {

package/dist/core/build/internal.js

@@ -77,25 +77,6 @@ function getPageData(internals, route, component) {
   }
   return void 0;
 }
-function getPageDatasWithPublicKey(pagesByKeys) {
-  const pagesWithPublicKey = /* @__PURE__ */ new Map();
-  const pagesByComponentsArray = Array.from(pagesByKeys.values()).map((pageData) => {
-    return { component: pageData.component, pageData };
-  });
-  const pagesWithUniqueComponent = pagesByComponentsArray.filter((page) => {
-    return pagesByComponentsArray.filter((p) => p.component === page.component).length === 1;
-  });
-  pagesWithUniqueComponent.forEach((page) => {
-    pagesWithPublicKey.set(page.component, page.pageData);
-  });
-  const pagesWithSharedComponent = pagesByComponentsArray.filter((page) => {
-    return pagesByComponentsArray.filter((p) => p.component === page.component).length > 1;
-  });
-  pagesWithSharedComponent.forEach((page) => {
-    pagesWithPublicKey.set(page.pageData.key, page.pageData);
-  });
-  return pagesWithPublicKey;
-}
 function getPageDataByViteID(internals, viteid) {
   if (internals.pagesByViteID.has(viteid)) {
     return internals.pagesByViteID.get(viteid);
@@ -148,7 +129,6 @@ export {
   getPageData,
   getPageDataByViteID,
   getPageDatasByClientOnlyID,
-  getPageDatasWithPublicKey,
   hasPrerenderedPages,
   mergeInlineCss,
   trackClientOnlyPageDatas,

package/dist/core/build/plugins/plugin-manifest.js

@@ -3,6 +3,7 @@ import glob from "fast-glob";
 import { getAssetsPrefix } from "../../../assets/utils/getAssetsPrefix.js";
 import { normalizeTheLocale } from "../../../i18n/index.js";
 import { toFallbackType, toRoutingStrategy } from "../../../i18n/utils.js";
+import { unwrapSupportKind } from "../../../integrations/features-validation.js";
 import { runHookBuildSsr } from "../../../integrations/hooks.js";
 import { BEFORE_HYDRATION_SCRIPT_ID, PAGE_SCRIPT_ID } from "../../../vite-plugin-scripts/index.js";
 import { encodeKey } from "../../encryption.js";
@@ -208,7 +209,7 @@ function buildManifest(opts, internals, staticFiles, encodedKey) {
     checkOrigin: settings.config.security?.checkOrigin ?? false,
     serverIslandNameMap: Array.from(settings.serverIslandNameMap),
     key: encodedKey,
-    envGetSecretEnabled: (settings.adapter?.supportedAstroFeatures.envGetSecret ?? "unsupported") !== "unsupported"
+    envGetSecretEnabled: (unwrapSupportKind(settings.adapter?.supportedAstroFeatures.envGetSecret) ?? "unsupported") !== "unsupported"
   };
 }
 export {

package/dist/core/build/plugins/plugin-ssr.js

@@ -141,10 +141,9 @@ function generateSSRCode(settings, adapter, middlewareId) {
     `import * as serverEntrypointModule from '${ADAPTER_VIRTUAL_MODULE_ID}';`,
     `import { manifest as defaultManifest } from '${SSR_MANIFEST_VIRTUAL_MODULE_ID}';`,
     edgeMiddleware ? `` : `import { onRequest as middleware } from '${middlewareId}';`,
-    settings.config.experimental.serverIslands ? `import { serverIslandMap } from '${VIRTUAL_ISLAND_MAP_ID}';` : ""
+    `import { serverIslandMap } from '${VIRTUAL_ISLAND_MAP_ID}';`
   ];
   const contents = [
-    settings.config.experimental.serverIslands ? "" : `const serverIslandMap = new Map()`,
     edgeMiddleware ? `const middleware = (_, next) => next()` : "",
     `const _manifest = Object.assign(defaultManifest, {`,
     `    pageMap,`,

package/dist/core/build/static-build.js

@@ -11,10 +11,7 @@ import {
   hasAnyContentFlag,
   reverseSymlink
 } from "../../content/utils.js";
-import {
-  createBuildInternals,
-  getPageDatasWithPublicKey
-} from "../../core/build/internal.js";
+import { createBuildInternals } from "../../core/build/internal.js";
 import { emptyDir, removeEmptyDirs } from "../../core/fs/index.js";
 import { appendForwardSlash, prependForwardSlash, removeFileExtension } from "../../core/path.js";
 import { runHookBuildSetup } from "../../integrations/hooks.js";
@@ -221,7 +218,7 @@ async function ssrBuild(opts, internals, input, container, logger) {
   };
   const updatedViteBuildConfig = await runHookBuildSetup({
     config: settings.config,
-    pages: getPageDatasWithPublicKey(internals.pagesByKeys),
+    pages: internals.pagesByKeys,
     vite: viteBuildConfig,
     target: "server",
     logger: opts.logger
@@ -269,7 +266,7 @@ ${bgGreen(black(" building client (vite) "))}`);
   };
   await runHookBuildSetup({
     config: settings.config,
-    pages: getPageDatasWithPublicKey(internals.pagesByKeys),
+    pages: internals.pagesByKeys,
     vite: viteBuildConfig,
     target: "client",
     logger: opts.logger