astro 5.1.3 → 5.1.5

package/astro-jsx.d.ts

@@ -837,10 +837,12 @@ declare namespace astroHTML.JSX {
 
 	interface LinkHTMLAttributes extends HTMLAttributes {
 		as?: string | undefined | null;
+		blocking?: 'render' | undefined | null;
 		crossorigin?: boolean | string | undefined | null;
+		disabled?: boolean | undefined | null;
+		fetchpriority?: 'auto' | 'high' | 'low' | undefined | null;
 		href?: string | URL | undefined | null;
 		hreflang?: string | undefined | null;
-		fetchpriority?: 'auto' | 'high' | 'low' | undefined | null;
 		integrity?: string | undefined | null;
 		media?: string | undefined | null;
 		imagesrcset?: string | undefined | null;

package/components/Image.astro

@@ -4,7 +4,6 @@ import type { UnresolvedImageTransform } from '../dist/assets/types';
 import { applyResponsiveAttributes } from '../dist/assets/utils/imageAttributes.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 import type { HTMLAttributes } from '../types';
-import './image.css';
 
 // The TypeScript diagnostic for JSX props uses the last member of the union to suggest props, so it would be better for
 // LocalImageProps to be last. Unfortunately, when we do this the error messages that remote images get are complete nonsense

package/components/Picture.astro

@@ -10,9 +10,8 @@ import type {
 	UnresolvedImageTransform,
 } from '../dist/types/public/index.js';
 import type { HTMLAttributes } from '../types';
-import './image.css';
 
-type Props = (LocalImageProps | RemoteImageProps) & {
+export type Props = (LocalImageProps | RemoteImageProps) & {
 	formats?: ImageOutputFormat[];
 	fallbackFormat?: ImageOutputFormat;
 	pictureAttributes?: HTMLAttributes<'picture'>;

package/components/ResponsiveImage.astro

@@ -0,0 +1,13 @@
+---
+import type { LocalImageProps, RemoteImageProps } from 'astro:assets';
+import Image from './Image.astro';
+
+type Props = LocalImageProps | RemoteImageProps;
+
+const { class: className, ...props } = Astro.props;
+
+import './image.css';
+---
+
+{/* Applying class outside of the spread prevents it from applying unnecessary astro-* classes */}
+<Image {...props} class={className} />

package/components/ResponsivePicture.astro

@@ -0,0 +1,11 @@
+---
+import { default as Picture, type Props as PictureProps } from './Picture.astro';
+
+type Props = PictureProps;
+
+const { class: className, ...props } = Astro.props;
+---
+
+{/* Applying class outside of the spread prevents it from applying unnecessary astro-* classes */}
+
+<Picture {...props} class={className} />

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

@@ -1,4 +1,3 @@
-import type PQueue from 'p-queue';
 import type { BuildPipeline } from '../../core/build/pipeline.js';
 import type { Logger } from '../../core/logger/core.js';
 import type { MapValue } from '../../type-utils.js';
@@ -19,6 +18,6 @@ type AssetEnv = {
     assetsFolder: AstroConfig['build']['assets'];
 };
 export declare function prepareAssetsGenerationEnv(pipeline: BuildPipeline, totalCount: number): Promise<AssetEnv>;
-export declare function generateImagesForPath(originalFilePath: string, transformsAndPath: MapValue<AssetsGlobalStaticImagesList>, env: AssetEnv, queue: PQueue): Promise<void>;
+export declare function generateImagesForPath(originalFilePath: string, transformsAndPath: MapValue<AssetsGlobalStaticImagesList>, env: AssetEnv): Promise<void>;
 export declare function getStaticImageList(): AssetsGlobalStaticImagesList;
 export {};

package/dist/assets/build/generate.js

@@ -47,12 +47,10 @@ async function prepareAssetsGenerationEnv(pipeline, totalCount) {
 function getFullImagePath(originalFilePath, env) {
   return new URL(removeLeadingForwardSlash(originalFilePath), env.serverRoot);
 }
-async function generateImagesForPath(originalFilePath, transformsAndPath, env, queue) {
+async function generateImagesForPath(originalFilePath, transformsAndPath, env) {
   let originalImage;
   for (const [_, transform] of transformsAndPath.transforms) {
-    await queue.add(async () => generateImage(transform.finalPath, transform.transform)).catch((e) => {
-      throw e;
-    });
+    await generateImage(transform.finalPath, transform.transform);
   }
   if (!env.isSSR && transformsAndPath.originalSrcPath && !globalThis.astroAsset.referencedImages?.has(transformsAndPath.originalSrcPath)) {
     try {
@@ -85,8 +83,10 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     const finalFileURL = new URL("." + filepath, env.clientRoot);
     const finalFolderURL = new URL("./", finalFileURL);
     await fs.promises.mkdir(finalFolderURL, { recursive: true });
-    const cacheFile = basename(filepath) + (isLocalImage ? "" : ".json");
+    const cacheFile = basename(filepath);
     const cachedFileURL = new URL(cacheFile, env.assetsCacheDir);
+    const cacheMetaFile = cacheFile + ".json";
+    const cachedMetaFileURL = new URL(cacheMetaFile, env.assetsCacheDir);
     try {
       if (isLocalImage) {
         await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
@@ -94,15 +94,26 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
           cached: "hit"
         };
       } else {
-        const JSONData = JSON.parse(readFileSync(cachedFileURL, "utf-8"));
-        if (!JSONData.data || !JSONData.expires) {
-          await fs.promises.unlink(cachedFileURL);
+        const JSONData = JSON.parse(readFileSync(cachedMetaFileURL, "utf-8"));
+        if (!JSONData.expires) {
+          try {
+            await fs.promises.unlink(cachedFileURL);
+          } catch {
+          }
+          await fs.promises.unlink(cachedMetaFileURL);
           throw new Error(
             `Malformed cache entry for ${filepath}, cache will be regenerated for this file.`
           );
         }
+        if (JSONData.data) {
+          const { data, ...meta } = JSONData;
+          await Promise.all([
+            fs.promises.writeFile(cachedFileURL, Buffer.from(data, "base64")),
+            writeCacheMetaFile(cachedMetaFileURL, meta, env)
+          ]);
+        }
         if (JSONData.expires > Date.now()) {
-          await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
+          await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
           return {
             cached: "hit"
           };
@@ -116,9 +127,12 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
             if (revalidatedData.data.length) {
               originalImage = revalidatedData;
             } else {
-              revalidatedData.data = Buffer.from(JSONData.data, "base64");
-              await writeRemoteCacheFile(cachedFileURL, revalidatedData, env);
-              await fs.promises.writeFile(finalFileURL, revalidatedData.data);
+              await writeCacheMetaFile(cachedMetaFileURL, revalidatedData, env);
+              await fs.promises.copyFile(
+                cachedFileURL,
+                finalFileURL,
+                fs.constants.COPYFILE_FICLONE
+              );
               return { cached: "revalidated" };
             }
           } catch (e) {
@@ -126,11 +140,12 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
               null,
               `An error was encountered while revalidating a cached remote asset. Proceeding with stale cache. ${e}`
             );
-            await fs.promises.writeFile(finalFileURL, Buffer.from(JSONData.data, "base64"));
+            await fs.promises.copyFile(cachedFileURL, finalFileURL, fs.constants.COPYFILE_FICLONE);
             return { cached: "hit" };
           }
         }
         await fs.promises.unlink(cachedFileURL);
+        await fs.promises.unlink(cachedMetaFileURL);
       }
     } catch (e) {
       if (e.code !== "ENOENT") {
@@ -169,7 +184,10 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
         if (isLocalImage) {
           await fs.promises.writeFile(cachedFileURL, resultData.data);
         } else {
-          await writeRemoteCacheFile(cachedFileURL, resultData, env);
+          await Promise.all([
+            fs.promises.writeFile(cachedFileURL, resultData.data),
+            writeCacheMetaFile(cachedMetaFileURL, resultData, env)
+          ]);
         }
       }
     } catch (e) {
@@ -190,12 +208,11 @@ async function generateImagesForPath(originalFilePath, transformsAndPath, env, q
     };
   }
 }
-async function writeRemoteCacheFile(cachedFileURL, resultData, env) {
+async function writeCacheMetaFile(cachedMetaFileURL, resultData, env) {
   try {
     return await fs.promises.writeFile(
-      cachedFileURL,
+      cachedMetaFileURL,
       JSON.stringify({
-        data: Buffer.from(resultData.data).toString("base64"),
         expires: resultData.expires,
         etag: resultData.etag,
         lastModified: resultData.lastModified

package/dist/assets/build/remote.d.ts

@@ -1,5 +1,5 @@
 export type RemoteCacheEntry = {
-    data: string;
+    data?: string;
     expires: number;
     etag?: string;
     lastModified?: string;

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

@@ -1,6 +1,5 @@
 import { extname } from "node:path";
 import MagicString from "magic-string";
-import { normalizePath } from "vite";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import {
   appendForwardSlash,
@@ -9,6 +8,7 @@ import {
   removeBase,
   removeQueryString
 } from "../core/path.js";
+import { normalizePath } from "../core/viteUtils.js";
 import { VALID_INPUT_FORMATS, VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
 import { getAssetsPrefix } from "./utils/getAssetsPrefix.js";
 import { isESMImportedImage } from "./utils/imageKind.js";
@@ -70,6 +70,7 @@ function assets({ settings }) {
   globalThis.astroAsset = {
     referencedImages: /* @__PURE__ */ new Set()
   };
+  const imageComponentPrefix = settings.config.experimental.responsiveImages ? "Responsive" : "";
   return [
     // Expose the components and different utilities from `astro:assets`
     {
@@ -92,8 +93,8 @@ function assets({ settings }) {
             `
 					export { getConfiguredImageService, isLocalService } from "astro/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 { default as Image } from "astro/components/${imageComponentPrefix}Image.astro";
+					export { default as Picture } from "astro/components/${imageComponentPrefix}Picture.astro";
 					export { inferRemoteSize } from "astro/assets/utils/inferRemoteSize.js";
 
 					export const imageConfig = ${JSON.stringify({ ...settings.config.image, experimentalResponsiveImages: settings.config.experimental.responsiveImages })};

package/dist/container/index.js

@@ -9,8 +9,9 @@ import { nodeLogDestination } from "../core/logger/node.js";
 import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
 import { removeLeadingForwardSlash } from "../core/path.js";
 import { RenderContext } from "../core/render-context.js";
-import { getParts, validateSegment } from "../core/routing/manifest/create.js";
+import { getParts } from "../core/routing/manifest/parts.js";
 import { getPattern } from "../core/routing/manifest/pattern.js";
+import { validateSegment } from "../core/routing/manifest/segment.js";
 import { ContainerPipeline } from "./pipeline.js";
 function createManifest(manifest, renderers, middleware) {
   function middlewareInstance() {

package/dist/content/content-layer.d.ts

@@ -40,7 +40,7 @@ export declare function simpleLoader<TData extends {
  * During development, this is in the `.astro` directory so that the Vite watcher can see it.
  * In production, it's in the cache directory so that it's preserved between builds.
  */
-export declare function getDataStoreFile(settings: AstroSettings, isDev?: boolean): URL;
+export declare function getDataStoreFile(settings: AstroSettings, isDev: boolean): URL;
 export declare const globalContentLayer: {
     init: (options: ContentLayerOptions) => ContentLayer;
     get: () => ContentLayer | null;

package/dist/content/content-layer.js

@@ -148,7 +148,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.1.3") {
+    if (previousAstroVersion && previousAstroVersion !== "5.1.5") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -156,8 +156,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.1.3") {
-      await this.#store.metaStore().set("astro-version", "5.1.3");
+    if ("5.1.5") {
+      await this.#store.metaStore().set("astro-version", "5.1.5");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);
@@ -215,8 +215,7 @@ ${contentConfig.error.message}`);
     );
     await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
     await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
-    const cacheFile = getDataStoreFile(this.#settings);
-    await this.#store.writeToDisk(cacheFile);
+    await this.#store.writeToDisk();
     const assetImportsFile = new URL(ASSET_IMPORTS_FILE, this.#settings.dotAstroDir);
     await this.#store.writeAssetImports(assetImportsFile);
     const modulesImportsFile = new URL(MODULES_IMPORTS_FILE, this.#settings.dotAstroDir);
@@ -303,7 +302,6 @@ ${JSON.stringify({ ...raw, id: void 0 }, null, 2)}`
   });
 }
 function getDataStoreFile(settings, isDev) {
-  isDev ??= process?.env.NODE_ENV === "development";
   return new URL(DATA_STORE_FILE, isDev ? settings.dotAstroDir : settings.config.cacheDir);
 }
 function contentLayerSingleton() {

package/dist/content/mutable-data-store.d.ts

@@ -21,7 +21,7 @@ export declare class MutableDataStore extends ImmutableDataStore {
      */
     metaStore(collectionName?: string): MetaStore;
     toString(): string;
-    writeToDisk(filePath: PathLike): Promise<void>;
+    writeToDisk(): Promise<void>;
     /**
      * Attempts to load a MutableDataStore from the virtual module.
      * This only works in Vite.

package/dist/content/mutable-data-store.js

@@ -144,15 +144,15 @@ ${lines.join(",\n")}]);
   }
   #saveToDiskDebounced() {
     this.#dirty = true;
-    if (this.#file) {
-      if (this.#saveTimeout) {
-        clearTimeout(this.#saveTimeout);
-      }
-      this.#saveTimeout = setTimeout(() => {
-        this.#saveTimeout = void 0;
-        this.writeToDisk(this.#file);
-      }, SAVE_DEBOUNCE_MS);
+    if (this.#saveTimeout) {
+      clearTimeout(this.#saveTimeout);
     }
+    this.#saveTimeout = setTimeout(() => {
+      this.#saveTimeout = void 0;
+      if (this.#file) {
+        this.writeToDisk();
+      }
+    }, SAVE_DEBOUNCE_MS);
   }
   #writing = /* @__PURE__ */ new Set();
   #pending = /* @__PURE__ */ new Set();
@@ -270,13 +270,15 @@ ${lines.join(",\n")}]);
   toString() {
     return devalue.stringify(this._collections);
   }
-  async writeToDisk(filePath) {
+  async writeToDisk() {
     if (!this.#dirty) {
       return;
     }
+    if (!this.#file) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError);
+    }
     try {
-      await this.#writeFileAtomic(filePath, this.toString());
-      this.#file = filePath;
+      await this.#writeFileAtomic(this.#file, this.toString());
       this.#dirty = false;
     } catch (err) {
       throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
@@ -308,11 +310,17 @@ ${lines.join(",\n")}]);
     try {
       if (existsSync(filePath)) {
         const data = await fs.readFile(filePath, "utf-8");
-        return MutableDataStore.fromString(data);
+        const store2 = await MutableDataStore.fromString(data);
+        store2.#file = filePath;
+        return store2;
+      } else {
+        await fs.mkdir(new URL("./", filePath), { recursive: true });
       }
     } catch {
     }
-    return new MutableDataStore();
+    const store = new MutableDataStore();
+    store.#file = filePath;
+    return store;
   }
 }
 export {

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

@@ -36,6 +36,16 @@ import {
   globWithUnderscoresIgnored,
   isDeferredModule
 } from "./utils.js";
+function invalidateDataStore(server) {
+  const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
+  if (module) {
+    server.moduleGraph.invalidateModule(module);
+  }
+  server.ws.send({
+    type: "full-reload",
+    path: "*"
+  });
+}
 function astroContentVirtualModPlugin({
   settings,
   fs
@@ -49,7 +59,10 @@ function astroContentVirtualModPlugin({
       dataStoreFile = getDataStoreFile(settings, env.command === "serve");
     },
     buildStart() {
-      devServer?.watcher.add(fileURLToPath(dataStoreFile));
+      if (devServer) {
+        devServer.watcher.add(fileURLToPath(dataStoreFile));
+        invalidateDataStore(devServer);
+      }
     },
     async resolveId(id) {
       if (id === VIRTUAL_MODULE_ID) {
@@ -143,24 +156,14 @@ function astroContentVirtualModPlugin({
     configureServer(server) {
       devServer = server;
       const dataStorePath = fileURLToPath(dataStoreFile);
-      function invalidateDataStore() {
-        const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
-        if (module) {
-          server.moduleGraph.invalidateModule(module);
-        }
-        server.ws.send({
-          type: "full-reload",
-          path: "*"
-        });
-      }
       server.watcher.on("add", (addedPath) => {
         if (addedPath === dataStorePath) {
-          invalidateDataStore();
+          invalidateDataStore(server);
         }
       });
       server.watcher.on("change", (changedPath) => {
         if (changedPath === dataStorePath) {
-          invalidateDataStore();
+          invalidateDataStore(server);
         }
       });
     }

package/dist/core/app/index.js

@@ -89,10 +89,22 @@ class App {
     }
     return pathname;
   }
+  /**
+   * It removes the base from the request URL, prepends it with a forward slash and attempts to decoded it.
+   *
+   * If the decoding fails, it logs the error and return the pathname as is.
+   * @param request
+   * @private
+   */
   #getPathnameFromRequest(request) {
     const url = new URL(request.url);
     const pathname = prependForwardSlash(this.removeBase(url.pathname));
-    return pathname;
+    try {
+      return decodeURI(pathname);
+    } catch (e) {
+      this.getAdapterLogger().error(e.toString());
+      return pathname;
+    }
   }
   match(request) {
     const url = new URL(request.url);

package/dist/core/build/css-asset-name.js

@@ -1,8 +1,8 @@
 import crypto from "node:crypto";
 import npath from "node:path";
 import { fileURLToPath } from "node:url";
-import { normalizePath } from "vite";
 import { viteID } from "../util.js";
+import { normalizePath } from "../viteUtils.js";
 import { getTopLevelPageModuleInfos } from "./graph.js";
 const confusingBaseNames = ["404", "500"];
 function shortHashedName(settings) {

package/dist/core/build/generate.js

@@ -96,7 +96,9 @@ ${bgGreen(black(` ${verb} static routes `))}`);
     const queue = new PQueue({ concurrency: Math.max(cpuCount, 1) });
     const assetsTimer = performance.now();
     for (const [originalPath, transforms] of staticImageList) {
-      await generateImagesForPath(originalPath, transforms, assetsCreationPipeline, queue);
+      queue.add(() => generateImagesForPath(originalPath, transforms, assetsCreationPipeline)).catch((e) => {
+        throw e;
+      });
     }
     await queue.onIdle();
     const assetsTimeEnd = performance.now();
@@ -128,7 +130,7 @@ async function generatePage(pageData, ssrEntry, builtPaths, pipeline) {
   async function generatePathWithLogs(path, route, index, paths, isConcurrent) {
     const timeStart = performance.now();
     pipeline.logger.debug("build", `Generating: ${path}`);
-    const filePath = getOutputFilename(config, path, pageData.route.type);
+    const filePath = getOutputFilename(config, path, pageData.route);
     const lineIcon = index === paths.length - 1 && !isConcurrent || paths.length === 1 ? "\u2514\u2500" : "\u251C\u2500";
     if (!isConcurrent) {
       logger.info(null, `  ${blue(lineIcon)} ${dim(filePath)}`, false);

package/dist/core/build/index.js

@@ -33,7 +33,7 @@ async function build(inlineConfig, options = {}) {
   telemetry.record(eventCliSession("build", userConfig));
   const settings = await createSettings(astroConfig, fileURLToPath(astroConfig.root));
   if (inlineConfig.force) {
-    await clearContentLayerCache({ settings, logger, fs });
+    await clearContentLayerCache({ settings, logger, fs, isDev: false });
   }
   const builder = new AstroBuilder(settings, {
     ...options,
@@ -99,7 +99,8 @@ class AstroBuilder {
       settings: this.settings,
       logger,
       fs,
-      manifest: this.manifest
+      manifest: this.manifest,
+      command: "build"
     });
     return { viteConfig };
   }

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

@@ -272,7 +272,7 @@ async function cleanServerOutput(opts, ssrOutputChunkNames, internals) {
       files.map(async (filename) => {
         const url = new URL(filename, out);
         const map = new URL(url + ".map");
-        await Promise.all([fs.promises.rm(url), fs.promises.rm(new URL(map)).catch((e) => {
+        await Promise.all([fs.promises.rm(url), fs.promises.rm(map).catch(() => {
         })]);
       })
     );

package/dist/core/compile/compile.js

@@ -1,9 +1,8 @@
 import { fileURLToPath } from "node:url";
 import { transform } from "@astrojs/compiler";
-import { normalizePath } from "vite";
 import { AggregateError, CompilerError } from "../errors/errors.js";
 import { AstroErrorData } from "../errors/index.js";
-import { resolvePath } from "../viteUtils.js";
+import { normalizePath, resolvePath } from "../viteUtils.js";
 import { createStylePreprocessor } from "./style.js";
 async function compile({
   astroConfig,

package/dist/core/compile/style.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
-import { normalizePath, preprocessCSS } from "vite";
+import { preprocessCSS } from "vite";
 import { AstroErrorData, CSSError, positionAt } from "../errors/index.js";
+import { normalizePath } from "../viteUtils.js";
 function createStylePreprocessor({
   filename,
   viteConfig,

package/dist/core/config/schema.d.ts

@@ -1,5 +1,5 @@
-import type { ShikiConfig, RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype } from '@astrojs/markdown-remark';
 import type { OutgoingHttpHeaders } from 'node:http';
+import type { ShikiConfig, RehypePlugin as _RehypePlugin, RemarkPlugin as _RemarkPlugin, RemarkRehype as _RemarkRehype } from '@astrojs/markdown-remark';
 import { z } from 'zod';
 import type { ViteUserConfig } from '../../types/public/config.js';
 interface ComplexifyUnionObj {
@@ -449,34 +449,43 @@ export declare const AstroConfigSchema: z.ZodObject<{
         checkOrigin?: boolean | undefined;
     }>>>;
     env: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
-            context: z.ZodLiteral<"client">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodEffects<z.ZodType<{
             context: "client";
             access: "public";
-        }, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
+            context: "server";
+            access: "secret";
+        }, z.ZodTypeDef, {
             context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
             context: "server";
             access: "public";
-        }, {
+        } | {
             context: "server";
+            access: "secret";
+        }>, {
+            context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"secret">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
         }, {
+            context: "client";
+            access: "public";
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
-        }>]>, z.ZodUnion<[z.ZodObject<{
+        }>, z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"string">;
             optional: z.ZodOptional<z.ZodBoolean>;
             default: z.ZodOptional<z.ZodString>;
@@ -1507,34 +1516,43 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: stri
         checkOrigin?: boolean | undefined;
     }>>>;
     env: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodUnion<[z.ZodObject<{
-            context: z.ZodLiteral<"client">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, z.ZodIntersection<z.ZodEffects<z.ZodType<{
             context: "client";
             access: "public";
-        }, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
+            context: "server";
+            access: "secret";
+        }, z.ZodTypeDef, {
             context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"public">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
             context: "server";
             access: "public";
-        }, {
+        } | {
             context: "server";
+            access: "secret";
+        }>, {
+            context: "client";
             access: "public";
-        }>, z.ZodObject<{
-            context: z.ZodLiteral<"server">;
-            access: z.ZodLiteral<"secret">;
-        }, "strip", z.ZodTypeAny, {
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
         }, {
+            context: "client";
+            access: "public";
+        } | {
+            context: "server";
+            access: "public";
+        } | {
             context: "server";
             access: "secret";
-        }>]>, z.ZodUnion<[z.ZodObject<{
+        }>, z.ZodUnion<[z.ZodObject<{
             type: z.ZodLiteral<"string">;
             optional: z.ZodOptional<z.ZodBoolean>;
             default: z.ZodOptional<z.ZodString>;