astro 7.2.2 → 7.2.4

package/dist/container/index.js

@@ -2,17 +2,21 @@ import { getDefaultClientDirectives } from "../core/client-directive/default.js"
 import { ASTRO_CONFIG_DEFAULTS } from "../core/config/schemas/defaults.js";
 import { createKey } from "../core/encryption.js";
 import { FetchState } from "../core/fetch/fetch-state.js";
-import { AstroMiddleware } from "../core/middleware/astro-middleware.js";
+import { handleMiddleware } from "../core/middleware/astro-middleware.js";
 import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
-import { PagesHandler } from "../core/pages/handler.js";
+import { handlePages } from "../core/pages/handler.js";
 import { removeLeadingForwardSlash } from "../core/path.js";
 import { getParts } from "../core/routing/parts.js";
 import { getPattern } from "../core/routing/pattern.js";
 import { validateSegment } from "../core/routing/segment.js";
 import { SlotString } from "../runtime/server/render/slot.js";
-import { ContainerPipeline } from "./pipeline.js";
+import { createContainerEnvironment } from "./environment.js";
+import { setEnvironment } from "../core/environment/index.js";
 import { createConsoleLogger } from "../core/logger/impls/console.js";
-function createManifest(manifest, renderers, middleware) {
+import { setLogger } from "../core/logger/manifest-logger.js";
+import { peekMiddleware } from "../core/middleware/load.js";
+import { getRouteTable } from "../core/routing/route-table.js";
+function createManifest(manifest, renderers, middleware, site) {
   function middlewareInstance() {
     return {
       onRequest: middleware ?? NOOP_MIDDLEWARE_FN
@@ -50,6 +54,7 @@ function createManifest(manifest, renderers, middleware) {
     componentMetadata: manifest?.componentMetadata ?? /* @__PURE__ */ new Map(),
     inlinedScripts: manifest?.inlinedScripts ?? /* @__PURE__ */ new Map(),
     i18n: manifest?.i18n,
+    site: site ?? manifest?.site,
     checkOrigin: false,
     allowedDomains: manifest?.allowedDomains ?? [],
     actionBodySizeLimit: 1024 * 1024,
@@ -69,9 +74,17 @@ function createManifest(manifest, renderers, middleware) {
   };
 }
 class experimental_AstroContainer {
-  #pipeline;
-  #astroMiddleware;
-  #pagesHandler;
+  /**
+   * The container's fabricated manifest — the source of truth all the
+   * functional-core accessors key off. The container never touches the
+   * ambient manifest, so multiple containers in one process stay isolated.
+   */
+  #manifest;
+  /**
+   * The route → module interner, shared between the environment record
+   * (lookups) and the `insertRoute` writes below.
+   */
+  #interner;
   /**
    * Internally used to check if the container was created with a manifest.
    * @private
@@ -81,25 +94,33 @@ class experimental_AstroContainer {
     streaming = false,
     manifest,
     renderers,
-    resolve
+    resolve,
+    site
   }) {
-    const ssrManifest = createManifest(manifest, renderers);
-    this.#pipeline = ContainerPipeline.create({
-      logger: createConsoleLogger({ level: "error" }),
-      manifest: ssrManifest,
-      streaming,
-      renderers: renderers ?? manifest?.renderers ?? [],
-      resolve: async (specifier) => {
-        if (this.#withManifest) {
-          return this.#containerResolve(specifier, ssrManifest);
-        } else if (resolve) {
-          return resolve(specifier);
-        }
-        return specifier;
+    const ssrManifest = createManifest(manifest, renderers, void 0, site);
+    const containerRenderers = renderers ?? manifest?.renderers ?? [];
+    const containerResolve = async (specifier) => {
+      if (this.#withManifest) {
+        return this.#containerResolve(specifier, ssrManifest);
+      } else if (resolve) {
+        return resolve(specifier);
       }
-    });
-    this.#astroMiddleware = new AstroMiddleware(this.#pipeline);
-    this.#pagesHandler = new PagesHandler(this.#pipeline);
+      return specifier;
+    };
+    const interner = /* @__PURE__ */ new WeakMap();
+    setLogger(ssrManifest, createConsoleLogger({ level: "error" }));
+    setEnvironment(
+      ssrManifest,
+      createContainerEnvironment({
+        interner,
+        resolve: containerResolve,
+        renderers: containerRenderers,
+        streaming
+      })
+    );
+    getRouteTable(ssrManifest);
+    this.#manifest = ssrManifest;
+    this.#interner = interner;
   }
   async #containerResolve(specifier, manifest) {
     const found = manifest.entryModules[specifier];
@@ -114,12 +135,13 @@ class experimental_AstroContainer {
    * @param {AstroContainerOptions=} containerOptions
    */
   static async create(containerOptions = {}) {
-    const { streaming = false, manifest, renderers = [], resolve } = containerOptions;
+    const { streaming = false, manifest, renderers = [], resolve, astroConfig } = containerOptions;
     return new experimental_AstroContainer({
       streaming,
       manifest,
       renderers,
-      resolve
+      resolve,
+      site: astroConfig?.site ?? manifest?.site
     });
   }
   /**
@@ -153,12 +175,12 @@ class experimental_AstroContainer {
       );
     }
     if (isNamedRenderer(renderer)) {
-      this.#pipeline.manifest.renderers.push({
+      this.#manifest.renderers.push({
         name: renderer.name,
         ssr: renderer
       });
     } else if ("name" in options) {
-      this.#pipeline.manifest.renderers.push({
+      this.#manifest.renderers.push({
         name: options.name,
         ssr: renderer
       });
@@ -193,15 +215,15 @@ class experimental_AstroContainer {
    */
   addClientRenderer(options) {
     const { entrypoint, name } = options;
-    const rendererIndex = this.#pipeline.manifest.renderers.findIndex((r) => r.name === name);
+    const rendererIndex = this.#manifest.renderers.findIndex((r) => r.name === name);
     if (rendererIndex === -1) {
       throw new Error(
         "You tried to add the " + name + " client renderer, but its server renderer wasn't added. You must add the server renderer first. Use the `addServerRenderer` function."
       );
     }
-    const renderer = this.#pipeline.manifest.renderers[rendererIndex];
+    const renderer = this.#manifest.renderers[rendererIndex];
     renderer.clientEntrypoint = entrypoint;
-    this.#pipeline.manifest.renderers[rendererIndex] = renderer;
+    this.#manifest.renderers[rendererIndex] = renderer;
   }
   // NOTE: we keep this private via TS instead via `#` so it's still available on the surface, so we can play with it.
   // @ts-expect-error @ematipico: I plan to use it for a possible integration that could help people
@@ -212,6 +234,20 @@ class experimental_AstroContainer {
     container.#withManifest = true;
     return container;
   }
+  /**
+   * Associates a runtime-inserted route with its component module in the
+   * interner shared with the container environment record. Snapshots the
+   * already-resolved middleware synchronously via `peekMiddleware` —
+   * `undefined` when `getMiddleware` has not settled yet.
+   */
+  #internRoute(routeData, componentInstance) {
+    this.#interner.set(routeData, {
+      page() {
+        return Promise.resolve(componentInstance);
+      },
+      onRequest: peekMiddleware(this.#manifest)
+    });
+  }
   #insertRoute({
     path,
     componentInstance,
@@ -220,14 +256,14 @@ class experimental_AstroContainer {
   }) {
     const pathUrl = new URL(path, "https://example.com");
     const routeData = this.#createRoute(pathUrl, params, type);
-    this.#pipeline.manifest.routes.push({
+    this.#manifest.routes.push({
       routeData,
       file: "",
       links: [],
       styles: [],
       scripts: []
     });
-    this.#pipeline.insertRoute(routeData, componentInstance);
+    this.#internRoute(routeData, componentInstance);
     return routeData;
   }
   /**
@@ -286,7 +322,7 @@ class experimental_AstroContainer {
       params: options.params,
       type: routeType
     });
-    const state = new FetchState(this.#pipeline, request);
+    const state = new FetchState(this.#manifest, request);
     state.routeData = routeData;
     state.pathname = url.pathname;
     state.clientAddress = "";
@@ -300,7 +336,7 @@ class experimental_AstroContainer {
     if (options.props) {
       state.initialProps = options.props;
     }
-    return this.#astroMiddleware.handle(state, this.#pagesHandler.handle.bind(this.#pagesHandler));
+    return handleMiddleware(state, handlePages);
   }
   /**
    * It stores an Astro **page** route. The first argument, `route`, gets associated to the `component`.
@@ -315,7 +351,7 @@ class experimental_AstroContainer {
   insertPageRoute(route, component, params) {
     const url = new URL(route, "https://example.com/");
     const routeData = this.#createRoute(url, params ?? {}, "page");
-    this.#pipeline.manifest.routes.push({
+    this.#manifest.routes.push({
       routeData,
       file: "",
       links: [],
@@ -323,7 +359,7 @@ class experimental_AstroContainer {
       scripts: []
     });
     const componentInstance = this.#wrapComponent(component, params);
-    this.#pipeline.insertRoute(routeData, componentInstance);
+    this.#internRoute(routeData, componentInstance);
   }
   #createRoute(url, params, type) {
     const segments = removeLeadingForwardSlash(url.pathname).split("/").filter(Boolean).map((s) => {

package/dist/content/content-layer.js

@@ -196,7 +196,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.2.2") {
+    if (previousAstroVersion && previousAstroVersion !== "7.2.4") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -204,8 +204,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.2.2") {
-      this.#store.metaStore().set("astro-version", "7.2.2");
+    if ("7.2.4") {
+      this.#store.metaStore().set("astro-version", "7.2.4");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

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

@@ -1,8 +1,5 @@
 import { type PathLike } from 'node:fs';
-/**
- * A chunked store manifest: each collection maps to the list of part file names
- * whose contents concatenate back into that collection's serialized string.
- */
+/** A chunked store manifest: each collection maps to its content-addressed part files. */
 export type DataStoreManifest = Record<string, string[]>;
 /**
  * Persists the content collection data produced by the content layer. This is
@@ -26,9 +23,9 @@ export declare function serializeDataStore(collections: Map<string, Map<string,
  * on UTF-16 code-unit boundaries (e.g. `String.prototype.slice`) can cut a
  * surrogate pair in half; encoding a lone surrogate to UTF-8 substitutes U+FFFD,
  * so concatenating the re-read parts would corrupt any astral-plane character
- * (emoji, some CJK, etc.). Iterating with `for...of` yields whole code points,
- * so `str.slice` is only ever called on code-point boundaries and the parts
- * always rejoin to the exact original string.
+ * (emoji, some CJK, etc.). `getChunkEnd()` advances by Unicode code point, so
+ * `str.slice` is only ever called on code-point boundaries and the parts always
+ * rejoin to the exact original string.
  */
 export declare function chunkString(str: string, maxBytes: number): string[];
 /**
@@ -52,9 +49,9 @@ export declare class FileWriter implements DataStoreWriter {
  * A {@link DataStoreWriter} that splits the store across many content-addressed
  * files inside a directory, described by a manifest.
  *
- * Each collection is serialized to a string and split into parts no larger than
- * a fixed byte size, so no single file grows unbounded (platform file-size
- * limits). Each part file is named by the xxhash of its contents, so unchanged
+ * Entries are serialized independently into parts no larger than a fixed byte
+ * size, so writing a collection does not require a collection-wide serialized
+ * string. Each part file is named by the xxhash of its contents, so unchanged
  * parts keep the same name across builds and their writes are skipped, and two
  * identical parts are naturally deduplicated. The manifest is written last as
  * the commit point, and stale files are pruned afterwards. This is the inverse

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

@@ -15,23 +15,31 @@ function serializeDataStore(collections) {
   return devalue.stringify(sortCollections(collections));
 }
 const ENCODER = new TextEncoder();
+function getChunkEnd(str, startIndex, maxBytes) {
+  let index = startIndex;
+  let bytes = 0;
+  while (index < str.length) {
+    const codePoint = str.codePointAt(index);
+    const charLength = codePoint > 65535 ? 2 : 1;
+    const charBytes = ENCODER.encode(str.slice(index, index + charLength)).length;
+    if (bytes + charBytes > maxBytes && index > startIndex) {
+      break;
+    }
+    index += charLength;
+    bytes += charBytes;
+    if (bytes >= maxBytes) {
+      break;
+    }
+  }
+  return { endIndex: index, bytes };
+}
 function chunkString(str, maxBytes) {
   const chunks = [];
   let startIndex = 0;
-  let index = 0;
-  let currentBytes = 0;
-  for (const char of str) {
-    const charBytes = ENCODER.encode(char).length;
-    if (currentBytes + charBytes > maxBytes && index > startIndex) {
-      chunks.push(str.slice(startIndex, index));
-      startIndex = index;
-      currentBytes = 0;
-    }
-    index += char.length;
-    currentBytes += charBytes;
-  }
-  if (startIndex < str.length) {
-    chunks.push(str.slice(startIndex));
+  while (startIndex < str.length) {
+    const { endIndex } = getChunkEnd(str, startIndex, maxBytes);
+    chunks.push(str.slice(startIndex, endIndex));
+    startIndex = endIndex;
   }
   return chunks;
 }
@@ -58,6 +66,7 @@ class ChunkedWriter {
   #manifestFile;
   #chunkSize;
   #hasher;
+  #writtenFiles = /* @__PURE__ */ new Set();
   constructor(dir, chunkSize) {
     this.#dir = dir;
     this.#manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dir);
@@ -67,23 +76,49 @@ class ChunkedWriter {
     if (!this.#hasher) {
       this.#hasher = await xxhash();
     }
-    const { h64ToString } = this.#hasher;
-    const writtenFiles = /* @__PURE__ */ new Set();
+    this.#writtenFiles = /* @__PURE__ */ new Set();
     const manifest = {};
     for (const [collectionName, entries] of sortCollections(collections)) {
-      const stringified = devalue.stringify(entries);
-      const parts = [];
-      for (const part of chunkString(stringified, this.#chunkSize)) {
-        const fileName = `${h64ToString(part)}.txt`;
-        await writeFileAtomic(new URL(`./${fileName}`, this.#dir), part);
-        parts.push(fileName);
-        writtenFiles.add(fileName);
-      }
-      manifest[collectionName] = parts;
+      manifest[collectionName] = await this.#writeCollection(entries);
     }
     await writeFileAtomic(this.#manifestFile, JSON.stringify(manifest));
-    writtenFiles.add(DATA_STORE_MANIFEST_FILE);
-    emptyDir(this.#dir, writtenFiles);
+    this.#writtenFiles.add(DATA_STORE_MANIFEST_FILE);
+    emptyDir(this.#dir, this.#writtenFiles);
+  }
+  async #writeCollection(entries) {
+    const parts = [];
+    let chunk = "";
+    let chunkBytes = 0;
+    const writeChunk = async () => {
+      const fileName = `${this.#hasher.h64ToString(chunk)}.txt`;
+      await writeFileAtomic(new URL(`./${fileName}`, this.#dir), chunk);
+      parts.push(fileName);
+      this.#writtenFiles.add(fileName);
+      chunk = "";
+      chunkBytes = 0;
+    };
+    for (const [id, entry] of entries) {
+      const serialized = `${devalue.stringify([id, entry])}
+`;
+      let startIndex = 0;
+      while (startIndex < serialized.length) {
+        const { endIndex, bytes } = getChunkEnd(
+          serialized,
+          startIndex,
+          this.#chunkSize - chunkBytes
+        );
+        chunk += serialized.slice(startIndex, endIndex);
+        chunkBytes += bytes;
+        startIndex = endIndex;
+        if (chunkBytes >= this.#chunkSize) {
+          await writeChunk();
+        }
+      }
+    }
+    if (chunk) {
+      await writeChunk();
+    }
+    return parts;
   }
 }
 export {

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

@@ -31,6 +31,24 @@ export interface DataEntry<TData extends Record<string, unknown> = Record<string
      */
     deferredRender?: boolean;
     assetImports?: Array<string>;
+    /**
+     * Locations of image fields within `data`, recorded when the entry is stored.
+     * Each path is the sequence of keys from `data` to a field that holds an image
+     * src string. At read time these fields are resolved to `ImageMetadata` without
+     * traversing or cloning the rest of `data`, so sibling values that devalue can
+     * serialize but `structuredClone` cannot (e.g. class instances) are left
+     * untouched.
+     */
+    imageImports?: (string | number)[][];
+}
+/**
+ * Rebuilds a collection from ordered parts containing newline-delimited
+ * `devalue.stringify([id, entry])` records.
+ */
+export declare class ChunkedCollectionParser {
+    #private;
+    add(part: string): void;
+    finish(): Map<string, any>;
 }
 /**
  * A read-only data store for content collections. This is used to retrieve data from the content layer at runtime.
@@ -52,9 +70,8 @@ export declare class ImmutableDataStore {
      *
      * Each collection maps to a list of parts. A part is either a raw string
      * (when the store is loaded from disk) or an ESM namespace from a virtual
-     * chunk import (`{ default: string }`, when emitted at runtime). A collection's
-     * parts are concatenated back into the exact
-     * serialized string, then parsed with devalue. This is the inverse of
+     * chunk import (`{ default: string }`, when emitted at runtime). Each part
+     * contains independently serialized entry records. This is the inverse of
      * {@link import('./data-store-writer.js').ChunkedWriter} and stays free of
      * Node built-ins so it can run at runtime.
      */

package/dist/content/data-store.js

@@ -1,5 +1,27 @@
 import * as devalue from "devalue";
 import { InMemorySource } from "./data-store-source.js";
+class ChunkedCollectionParser {
+  #entries = /* @__PURE__ */ new Map();
+  #remainder = "";
+  add(part) {
+    const content = this.#remainder + part;
+    const records = content.split("\n");
+    this.#remainder = records.pop();
+    for (const record of records) {
+      const parsed = devalue.parse(record);
+      if (!Array.isArray(parsed) || parsed.length !== 2 || typeof parsed[0] !== "string") {
+        throw new Error("Invalid chunked data store entry");
+      }
+      this.#entries.set(parsed[0], parsed[1]);
+    }
+  }
+  finish() {
+    if (this.#remainder) {
+      throw new Error("Invalid chunked data store entry");
+    }
+    return this.#entries;
+  }
+}
 class ImmutableDataStore {
   _collections = /* @__PURE__ */ new Map();
   constructor() {
@@ -39,21 +61,19 @@ class ImmutableDataStore {
    *
    * Each collection maps to a list of parts. A part is either a raw string
    * (when the store is loaded from disk) or an ESM namespace from a virtual
-   * chunk import (`{ default: string }`, when emitted at runtime). A collection's
-   * parts are concatenated back into the exact
-   * serialized string, then parsed with devalue. This is the inverse of
+   * chunk import (`{ default: string }`, when emitted at runtime). Each part
+   * contains independently serialized entry records. This is the inverse of
    * {@link import('./data-store-writer.js').ChunkedWriter} and stays free of
    * Node built-ins so it can run at runtime.
    */
   static manifestToMap(manifest) {
     const collections = /* @__PURE__ */ new Map();
     for (const [collectionName, parts] of Object.entries(manifest)) {
-      let stringified = "";
+      const parser = new ChunkedCollectionParser();
       for (const part of parts) {
-        stringified += typeof part === "string" ? part : part.default;
+        parser.add(typeof part === "string" ? part : part.default);
       }
-      const entries = devalue.parse(stringified);
-      collections.set(collectionName, entries);
+      collections.set(collectionName, parser.finish());
     }
     return collections;
   }
@@ -100,6 +120,7 @@ function dataStoreSingleton() {
 }
 const globalDataStore = dataStoreSingleton();
 export {
+  ChunkedCollectionParser,
   ImmutableDataStore,
   globalDataStore
 };

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

@@ -10,7 +10,7 @@ import {
   FileWriter,
   serializeDataStore
 } from "./data-store-writer.js";
-import { ImmutableDataStore } from "./data-store.js";
+import { ChunkedCollectionParser, ImmutableDataStore } from "./data-store.js";
 import { contentModuleToId } from "./utils.js";
 const SAVE_DEBOUNCE_MS = 500;
 const MAX_DEPTH = 10;
@@ -276,10 +276,13 @@ ${lines.join(",\n")}]);
           }
         }
         const foundAssets = new Set(assetImports);
-        forEach(data, (_, val) => {
+        const imageImports = [];
+        forEach(data, function(ctx, val) {
           if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
             const src = val.replace(IMAGE_IMPORT_PREFIX, "");
             foundAssets.add(src);
+            imageImports.push(ctx.path.map((segment) => segment));
+            ctx.update(src);
           }
         });
         const entry = {
@@ -299,6 +302,9 @@ ${lines.join(",\n")}]);
           entry.assetImports = Array.from(foundAssets);
           this.addAssetImports(entry.assetImports, filePath);
         }
+        if (imageImports.length) {
+          entry.imageImports = imageImports;
+        }
         if (digest) {
           entry.digest = digest;
         }
@@ -424,16 +430,15 @@ ${lines.join(",\n")}]);
       try {
         const manifestData = await fs.readFile(manifestFile, "utf-8");
         const manifest = JSON.parse(manifestData);
-        const expanded = {};
+        const collections = /* @__PURE__ */ new Map();
         for (const collectionName in manifest) {
-          expanded[collectionName] = await Promise.all(
-            manifest[collectionName].map(
-              (fileName) => fs.readFile(new URL(`./${fileName}`, dirPath), "utf-8")
-            )
-          );
+          const parser = new ChunkedCollectionParser();
+          for (const fileName of manifest[collectionName]) {
+            parser.add(await fs.readFile(new URL(`./${fileName}`, dirPath), "utf-8"));
+          }
+          collections.set(collectionName, parser.finish());
         }
-        const map = ImmutableDataStore.manifestToMap(expanded);
-        const store2 = await MutableDataStore.fromMap(map);
+        const store2 = await MutableDataStore.fromMap(collections);
         store2.#writer = new ChunkedWriter(dirPath, chunkSize);
         return store2;
       } catch (err) {

package/dist/content/runtime.d.ts

@@ -4,7 +4,7 @@ import type * as zCore from 'zod/v4/core';
 import type { ImageMetadata } from '../assets/types.js';
 import { type AstroComponentFactory } from '../runtime/server/index.js';
 import type { LiveDataCollectionResult, LiveDataEntryResult } from '../types/public/content.js';
-import { type LIVE_CONTENT_TYPE } from './consts.js';
+import type { LIVE_CONTENT_TYPE } from './consts.js';
 import { type DataEntry } from './data-store.js';
 import { LiveCollectionCacheHintError, LiveCollectionError, LiveCollectionValidationError, LiveEntryNotFoundError } from './loaders/errors.js';
 import type { LiveLoader } from './loaders/types.js';
@@ -26,6 +26,7 @@ export declare function createGetCollection({ liveCollections, }: {
     rendered?: import("./data-store.js").RenderedContent;
     deferredRender?: boolean;
     assetImports?: Array<string>;
+    imageImports?: (string | number)[][];
 }[]>;
 type ContentEntryResult = {
     id: string;
@@ -70,7 +71,7 @@ type RenderResult = {
     headings: MarkdownHeading[];
     remarkPluginFrontmatter: Record<string, any>;
 };
-export declare function updateImageReferencesInData<T extends Record<string, unknown>>(data: T, fileName?: string, imageAssetMap?: Map<string, ImageMetadata>): T;
+export declare function updateImageReferencesInData<T extends Record<string, unknown>>(data: T, fileName?: string, imageAssetMap?: Map<string, ImageMetadata>, imageImports?: (string | number)[][]): T;
 export declare function resolveEntryData<T extends Record<string, unknown>>(entry: DataEntry<T>, imageAssetMap?: Map<string, ImageMetadata>): T;
 export declare function renderEntry(entry: DataEntry): Promise<RenderResult>;
 export declare function createReference(): (collection: string) => z.ZodPipe<z.ZodUnion<readonly [z.ZodPipe<z.ZodNumber, z.ZodTransform<string, number>>, z.ZodString, z.ZodObject<{