astro 7.2.2 → 7.2.3

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<{

package/dist/content/runtime.js

@@ -1,5 +1,4 @@
 import { escape } from "html-escaper";
-import { forEach } from "neotraverse";
 import * as z from "zod/v4";
 import { createSvgComponent } from "../assets/runtime.js";
 import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
@@ -17,7 +16,6 @@ import {
   unescapeHTML
 } from "../runtime/server/index.js";
 import { defineCollection as defineCollectionOrig } from "./config.js";
-import { IMAGE_IMPORT_PREFIX } from "./consts.js";
 import { globalDataStore } from "./data-store.js";
 import {
   LiveCollectionCacheHintError,
@@ -357,33 +355,52 @@ async function updateImageReferencesInBody(html, fileName) {
     }).filter(([, value]) => value != null).map(([key, value]) => value === "" ? `${key}=""` : `${key}="${escape(String(value))}"`).join(" ");
   });
 }
-function updateImageReferencesInData(data, fileName, imageAssetMap) {
-  const copy = structuredClone(data);
-  forEach(copy, function(ctx, val) {
-    if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
-      const src = val.replace(IMAGE_IMPORT_PREFIX, "");
-      const id = imageSrcToImportId(src, fileName);
-      if (!id) {
-        ctx.update(src);
-        return;
-      }
-      const imported = imageAssetMap?.get(id);
-      if (imported) {
-        if (imported.__svgData) {
-          const { __svgData: svgData, ...meta } = imported;
-          ctx.update(createSvgComponent({ meta, ...svgData }));
-        } else {
-          ctx.update(imported);
-        }
-      } else {
-        ctx.update(src);
-      }
-    }
-  });
+function resolveImageAtPath(src, fileName, imageAssetMap) {
+  const id = imageSrcToImportId(src, fileName);
+  if (!id) {
+    return void 0;
+  }
+  const imported = imageAssetMap?.get(id);
+  if (!imported) {
+    return void 0;
+  }
+  if (imported.__svgData) {
+    const { __svgData: svgData, ...meta } = imported;
+    return createSvgComponent({ meta, ...svgData });
+  }
+  return imported;
+}
+function setAtPathCopying(target, path, value) {
+  if (path.length === 0) {
+    return target;
+  }
+  const [key, ...rest] = path;
+  const copy = Array.isArray(target) ? target.slice() : { ...target };
+  copy[key] = rest.length === 0 ? value : setAtPathCopying(copy[key], rest, value);
   return copy;
 }
+function updateImageReferencesInData(data, fileName, imageAssetMap, imageImports) {
+  if (!imageImports?.length) {
+    return data;
+  }
+  let result = data;
+  for (const path of imageImports) {
+    let src = result;
+    for (const key of path) {
+      src = src?.[key];
+    }
+    if (typeof src !== "string") {
+      continue;
+    }
+    const resolved = resolveImageAtPath(src, fileName, imageAssetMap);
+    if (resolved !== void 0) {
+      result = setAtPathCopying(result, path, resolved);
+    }
+  }
+  return result;
+}
 function resolveEntryData(entry, imageAssetMap) {
-  return entry.assetImports?.length ? updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap) : structuredClone(entry.data);
+  return updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap, entry.imageImports);
 }
 async function renderEntry(entry) {
   if (!entry) {

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

@@ -1,7 +1,5 @@
 import { BaseApp, type LogRequestPayload } from './base.js';
-import { AppPipeline } from './pipeline.js';
 export declare class App extends BaseApp {
-    createPipeline(streaming: boolean): AppPipeline;
     isDev(): boolean;
     logRequest(_options: LogRequestPayload): void;
 }

package/dist/core/app/app.js

@@ -1,12 +1,5 @@
 import { BaseApp } from "./base.js";
-import { AppPipeline } from "./pipeline.js";
 class App extends BaseApp {
-  createPipeline(streaming) {
-    return AppPipeline.create({
-      manifest: this.manifest,
-      streaming
-    });
-  }
   isDev() {
     return false;
   }

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

@@ -1,12 +1,10 @@
 import type { RoutesList } from '../../types/astro.js';
 import type { RemotePattern, RouteData } from '../../types/public/index.js';
-import { type Pipeline } from '../base-pipeline.js';
 import { getSetCookiesFromResponse } from '../cookies/index.js';
 import { AstroIntegrationLogger, type AstroLogger } from '../logger/core.js';
 import type { FetchHandler } from '../fetch/types.js';
-import type { ErrorHandler } from '../errors/handler.js';
+import { type ErrorHandler } from '../errors/handler.js';
 import type { WaitUntilHook } from '../wait-until.js';
-import type { AppPipeline } from './pipeline.js';
 import type { SSRManifest } from './types.js';
 export interface DevMatch {
     routeData: RouteData;
@@ -87,17 +85,38 @@ export interface RenderErrorOptions extends ResolvedRenderOptions {
     pathname?: string;
 }
 type ErrorPagePath = `${string}/404` | `${string}/500` | `${string}/404/` | `${string}/500/` | `${string}/404/index.html` | `${string}/500/index.html` | `${string}404.html` | `${string}500.html`;
-export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
+export declare abstract class BaseApp {
     #private;
     manifest: SSRManifest;
-    manifestData: {
-        routes: RouteData[];
-    };
-    pipeline: P;
     baseWithoutTrailingSlash: string;
     get logger(): AstroLogger;
+    /**
+     * Route data derived from the manifest, used for route matching. Reads and
+     * writes go through the single per-manifest route table, so HMR updates are
+     * visible to every consumer at once.
+     */
+    get manifestData(): {
+        routes: RouteData[];
+    };
+    set manifestData(routesList: {
+        routes: RouteData[];
+    });
     get adapterLogger(): AstroIntegrationLogger;
-    constructor(manifest: SSRManifest, streaming?: boolean, ...args: any[]);
+    constructor(manifest: SSRManifest, streaming?: boolean);
+    /**
+     * Resolves the user-configured logger destination from the manifest and
+     * returns the logger. Lazy and only resolves once; safe to call before
+     * the first render (adapters use this to log startup messages through
+     * the configured destination).
+     */
+    getLogger(): Promise<AstroLogger>;
+    /**
+     * The streaming flag fed into the internal `FetchState` facade hooks on
+     * the fast path. Returns the constructor flag by
+     * default; `BuildApp` overrides this to return `undefined` so streaming
+     * falls through to the environment default (`manifest.serverLike`).
+     */
+    protected resolveStreaming(): boolean | undefined;
     /**
      * Override the fetch handler used to dispatch requests. Entrypoints
      * call this with the default export of `virtual:astro:fetchable` to
@@ -107,8 +126,10 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
         fetch: FetchHandler;
     }): void;
     /**
-     * Returns the error handler strategy used by this app. Override to
-     * provide environment-specific behavior (dev overlay, build-time throws, etc.).
+     * Returns the error handler used by this app. The default is a thin
+     * bridge over the functional error API — strategy selection (production
+     * default / dev / build) is environment-driven inside `renderErrorPage`.
+     * External subclasses can override this to customize error rendering.
      */
     protected createErrorHandler(): ErrorHandler;
     abstract isDev(): boolean;
@@ -120,15 +141,6 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     getAllowedDomains(): Partial<RemotePattern>[] | undefined;
     protected matchesAllowedDomains(forwardedHost: string, protocol?: string): boolean;
     static validateForwardedHost(forwardedHost: string, allowedDomains?: Partial<RemotePattern>[], protocol?: string): boolean;
-    /**
-     * Creates a pipeline by reading the stored manifest
-     *
-     * @param streaming
-     * @param manifest
-     * @param args
-     * @private
-     */
-    abstract createPipeline(streaming: boolean, manifest: SSRManifest, ...args: any[]): P;
     set setManifestData(newManifestData: RoutesList);
     removeBase(pathname: string): string;
     /**