astro 7.2.2 → 7.2.3

package/dist/actions/handler.d.ts

@@ -17,16 +17,10 @@ import type { FetchState } from '../core/fetch/fetch-state.js';
  * page dispatch. That placement preserves the existing behavior where
  * user middleware sees action requests and response finalization (cookies,
  * sessions, etc.) runs around the action response.
+ *
+ * Expects the APIContext that is already being used by the render pipeline.
+ * Returns a `Response` when the action fully handles the request (RPC),
+ * or `undefined` when the caller should continue processing the request
+ * (form actions or non-action requests).
  */
-export declare class ActionHandler {
-    #private;
-    /**
-     * Run action handling for the current request. Expects the APIContext
-     * that is already being used by the render pipeline.
-     *
-     * Returns a `Response` when the action fully handles the request (RPC),
-     * or `undefined` when the caller should continue processing the
-     * request (form actions or non-action requests).
-     */
-    handle(apiContext: APIContext, state: FetchState): Promise<Response | undefined> | undefined;
-}
+export declare function handleAction(apiContext: APIContext, state: FetchState): Promise<Response | undefined> | undefined;

package/dist/actions/handler.js

@@ -2,51 +2,41 @@ import {
   createCrossOriginForbiddenResponse,
   isForbiddenCrossOriginRequest
 } from "../core/app/origin-check.js";
-import { PipelineFeatures } from "../core/base-pipeline.js";
+import { markFeatureUsed, FetchFeatures } from "../core/fetch/features.js";
 import { getActionContext, serializeActionResult } from "./runtime/server.js";
-class ActionHandler {
-  /**
-   * Run action handling for the current request. Expects the APIContext
-   * that is already being used by the render pipeline.
-   *
-   * Returns a `Response` when the action fully handles the request (RPC),
-   * or `undefined` when the caller should continue processing the
-   * request (form actions or non-action requests).
-   */
-  handle(apiContext, state) {
-    state.pipeline.usedFeatures |= PipelineFeatures.actions;
-    if (apiContext.isPrerendered) {
-      return void 0;
-    }
-    const { action, setActionResult } = getActionContext(apiContext);
-    if (!action) {
-      return void 0;
-    }
-    if (state.pipeline.manifest.checkOrigin && isForbiddenCrossOriginRequest(apiContext.request, apiContext.url, apiContext.isPrerendered)) {
-      return Promise.resolve(createCrossOriginForbiddenResponse(apiContext.request));
-    }
-    return this.#executeAction(action, setActionResult);
+function handleAction(apiContext, state) {
+  markFeatureUsed(state.manifest, FetchFeatures.actions);
+  if (apiContext.isPrerendered) {
+    return void 0;
   }
-  async #executeAction(action, setActionResult) {
-    const actionResult = await action.handler();
-    const serialized = serializeActionResult(actionResult);
-    if (action.calledFrom === "rpc") {
-      if (serialized.type === "empty") {
-        return new Response(null, {
-          status: serialized.status
-        });
-      }
-      return new Response(serialized.body, {
-        status: serialized.status,
-        headers: {
-          "Content-Type": serialized.contentType
-        }
+  const { action, setActionResult } = getActionContext(apiContext);
+  if (!action) {
+    return void 0;
+  }
+  if (state.manifest.checkOrigin && isForbiddenCrossOriginRequest(apiContext.request, apiContext.url, apiContext.isPrerendered)) {
+    return Promise.resolve(createCrossOriginForbiddenResponse(apiContext.request));
+  }
+  return executeAction(action, setActionResult);
+}
+async function executeAction(action, setActionResult) {
+  const actionResult = await action.handler();
+  const serialized = serializeActionResult(actionResult);
+  if (action.calledFrom === "rpc") {
+    if (serialized.type === "empty") {
+      return new Response(null, {
+        status: serialized.status
       });
     }
-    setActionResult(action.name, serialized);
-    return void 0;
+    return new Response(serialized.body, {
+      status: serialized.status,
+      headers: {
+        "Content-Type": serialized.contentType
+      }
+    });
   }
+  setActionResult(action.name, serialized);
+  return void 0;
 }
 export {
-  ActionHandler
+  handleAction
 };

package/dist/actions/load.d.ts

@@ -0,0 +1,12 @@
+import type { $ZodType } from 'zod/v4/core';
+import type { SSRActions, SSRManifest } from '../types/public/internal.js';
+import type { ActionAccept, ActionClient } from './runtime/types.js';
+/** Resolves the actions module from the manifest (a no-op module when none). */
+export declare function getActions(manifest: SSRManifest): Promise<SSRActions>;
+/**
+ * Clears the cached actions so they are re-resolved on the next request.
+ * Called via HMR when action files change during development.
+ */
+export declare function clearActions(manifest: SSRManifest): void;
+/** Looks up a single action handler by its dot-separated path. */
+export declare function getAction(manifest: SSRManifest, path: string): Promise<ActionClient<unknown, ActionAccept, $ZodType>>;

package/dist/actions/load.js

@@ -0,0 +1,55 @@
+import { FORBIDDEN_PATH_KEYS } from "@astrojs/internal-helpers/object";
+import { ActionNotFoundError } from "../core/errors/errors-data.js";
+import { AstroError } from "../core/errors/index.js";
+import { createAsyncManifestMemo } from "../core/manifest/memo.js";
+import { NOOP_ACTIONS_MOD } from "./noop-actions.js";
+const actionsMemo = createAsyncManifestMemo(
+  async (manifest) => manifest.actions ? await manifest.actions() : NOOP_ACTIONS_MOD
+);
+function getActions(manifest) {
+  return actionsMemo.get(manifest);
+}
+function clearActions(manifest) {
+  actionsMemo.invalidate(manifest);
+}
+async function getAction(manifest, path) {
+  const pathKeys = path.split(".").map((key) => decodeURIComponent(key));
+  let { server } = await getActions(manifest);
+  if (!server || !(typeof server === "object")) {
+    throw new TypeError(
+      `Expected \`server\` export in actions file to be an object. Received ${typeof server}.`
+    );
+  }
+  for (const key of pathKeys) {
+    if (typeof server === "function") {
+      throw new AstroError({
+        ...ActionNotFoundError,
+        message: ActionNotFoundError.message(pathKeys.join("."))
+      });
+    }
+    if (FORBIDDEN_PATH_KEYS.has(key)) {
+      throw new AstroError({
+        ...ActionNotFoundError,
+        message: ActionNotFoundError.message(pathKeys.join("."))
+      });
+    }
+    if (!Object.hasOwn(server, key)) {
+      throw new AstroError({
+        ...ActionNotFoundError,
+        message: ActionNotFoundError.message(pathKeys.join("."))
+      });
+    }
+    server = server[key];
+  }
+  if (typeof server !== "function") {
+    throw new TypeError(
+      `Expected handler for action ${pathKeys.join(".")} to be a function. Received ${typeof server}.`
+    );
+  }
+  return server;
+}
+export {
+  clearActions,
+  getAction,
+  getActions
+};

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

@@ -1,6 +1,7 @@
-import { pipelineSymbol } from "../../../core/constants.js";
+import { fetchStateSymbol } from "../../../core/constants.js";
 import { ActionCalledFromServerError } from "../../../core/errors/errors-data.js";
 import { AstroError } from "../../../core/errors/errors.js";
+import { getAction } from "../../load.js";
 import { createGetActionPath, createActionsProxy } from "../client.js";
 import { shouldAppendTrailingSlash } from "virtual:astro:actions/options";
 import { ACTION_QUERY_PARAMS } from "../../consts.js";
@@ -12,11 +13,11 @@ const getActionPath = createGetActionPath({
 });
 const actions = createActionsProxy({
   handleAction: async (param, path, context) => {
-    const pipeline = context ? Reflect.get(context, pipelineSymbol) : void 0;
-    if (!pipeline) {
+    const state = context ? Reflect.get(context, fetchStateSymbol) : void 0;
+    if (!state) {
       throw new AstroError(ActionCalledFromServerError);
     }
-    const action = await pipeline.getAction(path);
+    const action = await getAction(state.manifest, path);
     if (!action) throw new Error(`Action not found: ${path}`);
     return action.bind(context)(param);
   }

package/dist/actions/runtime/server.js

@@ -1,7 +1,9 @@
 import { stringify as devalueStringify } from "devalue";
 import * as z from "zod/v4/core";
 import { shouldAppendForwardSlash } from "../../core/build/util.js";
-import { pipelineSymbol, REDIRECT_STATUS_CODES } from "../../core/constants.js";
+import { REDIRECT_STATUS_CODES } from "../../core/constants.js";
+import { getFetchStateFromAPIContext } from "../../core/fetch/fetch-state.js";
+import { getAction } from "../load.js";
 import {
   ActionCalledFromServerError,
   ActionNotFoundError,
@@ -86,21 +88,21 @@ function getActionContext(context) {
       calledFrom: callerInfo.from,
       name: callerInfo.name,
       handler: async () => {
-        const pipeline = Reflect.get(context, pipelineSymbol);
+        const { manifest } = getFetchStateFromAPIContext(context);
         const callerInfoName = shouldAppendForwardSlash(
-          pipeline.manifest.trailingSlash,
-          pipeline.manifest.buildFormat
+          manifest.trailingSlash,
+          manifest.buildFormat
         ) ? removeTrailingForwardSlash(callerInfo.name) : callerInfo.name;
         let baseAction;
         try {
-          baseAction = await pipeline.getAction(callerInfoName);
+          baseAction = await getAction(manifest, callerInfoName);
         } catch (error) {
           if (error instanceof Error && "name" in error && typeof error.name === "string" && error.name === ActionNotFoundError.name) {
             return { data: void 0, error: new ActionError({ code: "NOT_FOUND" }) };
           }
           throw error;
         }
-        const bodySizeLimit = pipeline.manifest.actionBodySizeLimit;
+        const bodySizeLimit = manifest.actionBodySizeLimit;
         let input;
         try {
           input = await parseRequestBody(context.request, bodySizeLimit);

package/dist/assets/fonts/providers/index.d.ts

@@ -26,7 +26,7 @@ declare function npm(options?: Omit<NpmProviderOptions, 'root' | 'readFile'>): F
  * - [Google](https://docs.astro.build/en/reference/font-provider-reference/#google)
  * - [Google Icons](https://docs.astro.build/en/reference/font-provider-reference/#google-icons)
  * - [Local](https://docs.astro.build/en/reference/font-provider-reference/#local)
- * - [NPM](TODO:)
+ * - [NPM](https://docs.astro.build/en/reference/font-provider-reference/#npm)
  */
 export declare const fontProviders: {
     adobe: typeof adobe;

package/dist/assets/fonts/providers/index.js

@@ -94,18 +94,8 @@ function googleicons() {
     async init(context) {
       initializedProvider = await provider(context);
     },
-    async resolveFont({ familyName, options, ...rest }) {
-      const patchedOptions = options?.experimental?.glyphs && options.experimental.glyphs.length > 1 ? {
-        ...options,
-        experimental: {
-          ...options.experimental,
-          glyphs: [options.experimental.glyphs.join(",")]
-        }
-      } : options;
-      return await initializedProvider?.resolveFont(familyName, {
-        options: patchedOptions,
-        ...rest
-      });
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
     },
     async listFonts() {
       return await initializedProvider?.listFonts?.();

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "7.2.2";
+  version = "7.2.3";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/container/environment.d.ts

@@ -0,0 +1,20 @@
+import type { RouteData, SSRLoadedRenderer, SSRResult } from '../types/public/internal.js';
+import type { SinglePageBuiltModule } from '../core/build/types.js';
+import type { RenderEnvironment } from '../core/environment/index.js';
+export interface ContainerEnvironmentOptions {
+    /**
+     * The route → module interner. Created by `experimental_AstroContainer`'s
+     * constructor and shared with its `insertRoute` writes; this record owns
+     * the lookups.
+     */
+    interner: WeakMap<RouteData, SinglePageBuiltModule>;
+    resolve: SSRResult['resolve'];
+    renderers: SSRLoadedRenderer[];
+    streaming: boolean;
+}
+/**
+ * The container environment. Registered by `experimental_AstroContainer`'s
+ * constructor on its fabricated manifest — the container never touches the
+ * ambient manifest, so multiple containers in one process stay isolated.
+ */
+export declare function createContainerEnvironment({ interner, resolve, renderers, streaming, }: ContainerEnvironmentOptions): RenderEnvironment;

package/dist/container/environment.js

@@ -0,0 +1,106 @@
+import { RedirectSinglePageBuiltModule } from "../core/redirects/index.js";
+import {
+  createModuleScriptElement,
+  createStylesheetElementSet
+} from "../core/render/ssr-element.js";
+import { getDefaultRoutes } from "../core/routing/default.js";
+import { findRouteToRewrite } from "../core/routing/rewrite.js";
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  if (route.type === "redirect") {
+    return RedirectSinglePageBuiltModule;
+  } else {
+    if (manifest.pageMap) {
+      const importComponentInstance = manifest.pageMap.get(route.component);
+      if (!importComponentInstance) {
+        throw new Error(
+          `Unexpectedly unable to find a component instance for route ${route.route}`
+        );
+      }
+      return await importComponentInstance();
+    } else if (manifest.pageModule) {
+      return manifest.pageModule;
+    }
+    throw new Error(
+      "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+    );
+  }
+}
+function createContainerEnvironment({
+  interner,
+  resolve,
+  renderers,
+  streaming
+}) {
+  async function getComponentByRoute(_manifest, routeData) {
+    const page = interner.get(routeData);
+    if (page) {
+      return page.page();
+    }
+    throw new Error("Couldn't find component for route " + routeData.pathname);
+  }
+  return {
+    name: "container",
+    runtimeMode: "development",
+    defaultStreaming: () => streaming,
+    async resolve(_manifest, specifier) {
+      return resolve(specifier);
+    },
+    headElements(manifest, routeData) {
+      const routeInfo = manifest.routes.find((route) => route.routeData === routeData);
+      const links = /* @__PURE__ */ new Set();
+      const scripts = /* @__PURE__ */ new Set();
+      const styles = createStylesheetElementSet(routeInfo?.styles ?? []);
+      for (const script of routeInfo?.scripts ?? []) {
+        if ("stage" in script) {
+          if (script.stage === "head-inline") {
+            scripts.add({
+              props: {},
+              children: script.children
+            });
+          }
+        } else {
+          scripts.add(createModuleScriptElement(script));
+        }
+      }
+      return { links, styles, scripts };
+    },
+    componentMetadata() {
+    },
+    getComponentByRoute,
+    getModuleForRoute,
+    async tryRewrite(manifest, payload, request) {
+      const { newUrl, pathname, routeData } = findRouteToRewrite({
+        payload,
+        request,
+        // PER-CALL scan of the live manifest routes: the container inserts
+        // routes at runtime (`insertRoute` pushes into `manifest.routes`),
+        // and an uncompiled scan sees them immediately. Reading the derived
+        // route table here would miss them.
+        routes: manifest.routes.map((r) => r.routeData),
+        trailingSlash: manifest.trailingSlash,
+        buildFormat: manifest.buildFormat,
+        base: manifest.base,
+        outDir: manifest.outDir
+      });
+      const componentInstance = await getComponentByRoute(manifest, routeData);
+      return { componentInstance, routeData, newUrl, pathname };
+    },
+    getRenderers() {
+      return renderers;
+    },
+    errorStrategy: "default",
+    injectCspMetaTagsOnErrorPages: false,
+    logRequest() {
+    }
+  };
+}
+export {
+  createContainerEnvironment
+};

package/dist/container/index.js

@@ -2,16 +2,20 @@ 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";
+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) {
   function middlewareInstance() {
     return {
@@ -69,9 +73,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
@@ -84,22 +96,29 @@ class experimental_AstroContainer {
     resolve
   }) {
     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 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];
@@ -153,12 +172,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 +212,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 +231,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 +253,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 +319,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 +333,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 +348,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 +356,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.3") {
       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.3") {
+      this.#store.metaStore().set("astro-version", "7.2.3");
     }
     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