astro 4.14.0 → 4.14.2

package/dist/@types/astro.d.ts

@@ -2200,15 +2200,15 @@ export interface AstroUserConfig {
          *
          * 2. **Edit the collection definition**. Your updated collection requires a `loader`, and the option to select a collection `type` is no longer available.
          *
-         *     ```diff
+         *     ```ts ins={3,8} del={7}
          *     // src/content/config.ts
          *     import { defineCollection, z } from 'astro:content';
-         *     + import { glob } from 'astro/loaders';
+         *     import { glob } from 'astro/loaders';
          *
          *     const blog = defineCollection({
          *       // For content layer you no longer define a `type`
-         *     - type: 'content',
-         *     + loader: glob({ pattern: "**\/*.md", base: "./src/data/blog" }),
+         *      type: 'content',
+         *      loader: glob({ pattern: "**\/*.md", base: "./src/data/blog" }),
          *       schema: z.object({
          *         title: z.string(),
          *         description: z.string(),
@@ -2220,14 +2220,14 @@ export interface AstroUserConfig {
          *
          * 3. **Change references from `slug` to `id`**. Content layer collections do not have a `slug` field. Instead, all updated collections will have an `id`.
          *
-         *     ```diff
+         *     ```astro ins={7} del={6}
          *     // src/pages/index.astro
          *     ---
          *     export async function getStaticPaths() {
          *       const posts = await getCollection('blog');
          *       return posts.map((post) => ({
-         *     -   params: { slug: post.slug },
-         *     +   params: { slug: post.id },
+         *         params: { slug: post.slug },
+         *         params: { slug: post.id },
          *         props: post,
          *       }));
          *     }
@@ -2236,16 +2236,16 @@ export interface AstroUserConfig {
          *
          * 4. **Switch to the new `render()` function**. Entries no longer have a `render()` method, as they are now serializable plain objects. Instead, import the `render()` function from `astro:content`.
          *
-         *     ```diff
+         *     ```astro ins={4,9} del={3,8}
          *     // src/pages/index.astro
          *     ---
-         *     - import { getEntry } from 'astro:content';
-         *     + import { getEntry, render } from 'astro:content';
+         *      import { getEntry } from 'astro:content';
+         *      import { getEntry, render } from 'astro:content';
          *
          *       const post = await getEntry('blog', params.slug);
          *
-         *     - const { Content, headings } = await post.render();
-         *     + const { Content, headings } = await render(post);
+         *      const { Content, headings } = await post.render();
+         *      const { Content, headings } = await render(post);
          *     ---
          *
          *     <Content />

package/dist/assets/endpoint/node.js

@@ -1,9 +1,9 @@
+import { readFile } from "node:fs/promises";
 import os from "node:os";
 import { isAbsolute } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { assetsDir, imageConfig, outDir } from "astro:assets";
 import { isRemotePath, removeQueryString } from "@astrojs/internal-helpers/path";
-import { readFile } from "fs/promises";
 import * as mime from "mrmime";
 import { getConfiguredImageService } from "../internal.js";
 import { etag } from "../utils/etag.js";

package/dist/cli/check/index.js

@@ -7,7 +7,7 @@ async function check(flags) {
   const logger = createLoggerFromFlags(flags);
   const getPackageOpts = {
     skipAsk: !!flags.yes || !!flags.y,
-    cwd: typeof flags.root == "string" ? flags.root : void 0
+    cwd: flags.root
   };
   const checkPackage = await getPackage(
     "@astrojs/check",

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

@@ -1,5 +1,4 @@
-import { type Flags } from '../flags.js';
-export declare function db({ positionals, flags }: {
-    positionals: string[];
-    flags: Flags;
+import type { Arguments } from 'yargs-parser';
+export declare function db({ flags }: {
+    flags: Arguments;
 }): Promise<void>;

package/dist/cli/db/index.js

@@ -2,12 +2,12 @@ import { resolveConfig } from "../../core/config/config.js";
 import { apply as applyPolyfill } from "../../core/polyfill.js";
 import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
 import { getPackage } from "../install-package.js";
-async function db({ positionals, flags }) {
+async function db({ flags }) {
   applyPolyfill();
   const logger = createLoggerFromFlags(flags);
   const getPackageOpts = {
     skipAsk: !!flags.yes || !!flags.y,
-    cwd: typeof flags.root == "string" ? flags.root : void 0
+    cwd: flags.root
   };
   const dbPackage = await getPackage("@astrojs/db", logger, getPackageOpts, []);
   if (!dbPackage) {
@@ -20,11 +20,7 @@ async function db({ positionals, flags }) {
   const { cli } = dbPackage;
   const inlineConfig = flagsToAstroInlineConfig(flags);
   const { astroConfig } = await resolveConfig(inlineConfig, "build");
-  const yargsArgs = {
-    _: positionals,
-    ...flags
-  };
-  await cli({ flags: yargsArgs, config: astroConfig });
+  await cli({ flags, config: astroConfig });
 }
 export {
   db

package/dist/cli/flags.d.ts

@@ -1,8 +1,7 @@
-import type { parseArgs } from 'node:util';
+import type { Arguments } from 'yargs-parser';
 import type { AstroInlineConfig } from '../@types/astro.js';
 import { Logger } from '../core/logger/core.js';
-export type ParsedArgsResult = ReturnType<typeof parseArgs>;
-export type Flags = ParsedArgsResult['values'];
+export type Flags = Arguments;
 export declare function flagsToAstroInlineConfig(flags: Flags): AstroInlineConfig;
 /**
  * The `logging` is usually created from an `AstroInlineConfig`, but some flows like `add`

package/dist/cli/flags.js

@@ -13,7 +13,7 @@ function flagsToAstroInlineConfig(flags) {
     base: typeof flags.base === "string" ? flags.base : void 0,
     outDir: typeof flags.outDir === "string" ? flags.outDir : void 0,
     server: {
-      port: typeof flags.port === "string" ? Number(flags.port) : void 0,
+      port: typeof flags.port === "number" ? flags.port : void 0,
       host: typeof flags.host === "string" || typeof flags.host === "boolean" ? flags.host : void 0,
       open: typeof flags.open === "string" || typeof flags.open === "boolean" ? flags.open : void 0
     }

package/dist/cli/index.js

@@ -1,5 +1,5 @@
-import { parseArgs } from "node:util";
 import * as colors from "kleur/colors";
+import yargs from "yargs-parser";
 import { ASTRO_VERSION } from "../core/constants.js";
 async function printAstroHelp() {
   const { printHelp } = await import("../core/messages.js");
@@ -43,9 +43,9 @@ function printVersion() {
   console.log();
   console.log(`  ${colors.bgGreen(colors.black(` astro `))} ${colors.green(`v${ASTRO_VERSION}`)}`);
 }
-function resolveCommand(args) {
-  const cmd = args.positionals[2];
-  if (args.values.version) return "version";
+function resolveCommand(flags) {
+  const cmd = flags._[2];
+  if (flags.version) return "version";
   const supportedCommands = /* @__PURE__ */ new Set([
     "add",
     "sync",
@@ -68,8 +68,7 @@ function resolveCommand(args) {
   }
   return "help";
 }
-async function runCommand(cmd, args) {
-  const flags = args.values;
+async function runCommand(cmd, flags) {
   switch (cmd) {
     case "help":
       await printAstroHelp();
@@ -89,7 +88,7 @@ async function runCommand(cmd, args) {
     }
     case "telemetry": {
       const { update } = await import("./telemetry/index.js");
-      const subcommand = args.positionals[3];
+      const subcommand = flags._[3]?.toString();
       await update(subcommand, { flags });
       return;
     }
@@ -100,7 +99,7 @@ async function runCommand(cmd, args) {
     }
     case "preferences": {
       const { preferences } = await import("./preferences/index.js");
-      const [subcommand, key, value] = args.positionals.slice(3);
+      const [subcommand, key, value] = flags._.slice(3).map((v) => v.toString());
       const exitCode = await preferences(subcommand, key, value, { flags });
       return process.exit(exitCode);
     }
@@ -114,7 +113,7 @@ async function runCommand(cmd, args) {
   switch (cmd) {
     case "add": {
       const { add } = await import("./add/index.js");
-      const packages = args.positionals.slice(3);
+      const packages = flags._.slice(3);
       await add(packages, { flags });
       return;
     }
@@ -124,7 +123,7 @@ async function runCommand(cmd, args) {
     case "link":
     case "init": {
       const { db } = await import("./db/index.js");
-      await db({ positionals: args.positionals, flags });
+      await db({ flags });
       return;
     }
     case "dev": {
@@ -163,22 +162,10 @@ async function runCommand(cmd, args) {
   throw new Error(`Error running ${cmd} -- no command found.`);
 }
 async function cli(argv) {
-  const args = parseArgs({
-    args: argv,
-    allowPositionals: true,
-    strict: false,
-    options: {
-      global: { type: "boolean", short: "g" },
-      host: { type: "string" },
-      // Can be boolean too, which is covered by `strict: false`
-      open: { type: "string" }
-      // Can be boolean too, which is covered by `strict: false`
-      // TODO: Add more flags here
-    }
-  });
-  const cmd = resolveCommand(args);
+  const flags = yargs(argv, { boolean: ["global"], alias: { g: "global" } });
+  const cmd = resolveCommand(flags);
   try {
-    await runCommand(cmd, args);
+    await runCommand(cmd, flags);
   } catch (err) {
     const { throwAndExit } = await import("./throw-and-exit.js");
     await throwAndExit(cmd, err);

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

@@ -1,10 +1,10 @@
 import type { FSWatcher } from 'vite';
 import type { AstroSettings } from '../@types/astro.js';
 import type { Logger } from '../core/logger/core.js';
-import type { DataStore } from './data-store.js';
 import type { LoaderContext } from './loaders/types.js';
+import type { MutableDataStore } from './mutable-data-store.js';
 export interface ContentLayerOptions {
-    store: DataStore;
+    store: MutableDataStore;
     settings: AstroSettings;
     logger: Logger;
     watcher?: FSWatcher;

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

@@ -1,4 +1,3 @@
-import { type PathLike } from 'fs';
 import type { MarkdownHeading } from '@astrojs/markdown-remark';
 export interface RenderedContent {
     /** Rendered HTML string. If present then `render(entry)` will return a component that renders this HTML. */
@@ -32,83 +31,24 @@ export interface DataEntry<TData extends Record<string, unknown> = Record<string
      */
     deferredRender?: boolean;
 }
+/**
+ * A read-only data store for content collections. This is used to retrieve data from the content layer at runtime.
+ * To add or modify data, use {@link MutableDataStore} instead.
+ */
 export declare class DataStore {
-    #private;
+    protected _collections: Map<string, Map<string, any>>;
     constructor();
     get<T = DataEntry>(collectionName: string, key: string): T | undefined;
     entries<T = DataEntry>(collectionName: string): Array<[id: string, T]>;
     values<T = DataEntry>(collectionName: string): Array<T>;
     keys(collectionName: string): Array<string>;
-    set(collectionName: string, key: string, value: unknown): void;
-    delete(collectionName: string, key: string): void;
-    clear(collectionName: string): void;
-    clearAll(): void;
     has(collectionName: string, key: string): boolean;
     hasCollection(collectionName: string): boolean;
     collections(): Map<string, Map<string, any>>;
-    addAssetImport(assetImport: string, filePath: string): void;
-    addAssetImports(assets: Array<string>, filePath: string): void;
-    addModuleImport(fileName: string): void;
-    writeAssetImports(filePath: PathLike): Promise<void>;
-    writeModuleImports(filePath: PathLike): Promise<void>;
-    scopedStore(collectionName: string): ScopedDataStore;
-    /**
-     * Returns a MetaStore for a given collection, or if no collection is provided, the default meta collection.
-     */
-    metaStore(collectionName?: string): MetaStore;
-    toString(): string;
-    writeToDisk(filePath: PathLike): Promise<void>;
     /**
      * Attempts to load a DataStore from the virtual module.
      * This only works in Vite.
      */
     static fromModule(): Promise<DataStore>;
     static fromMap(data: Map<string, Map<string, any>>): Promise<DataStore>;
-    static fromString(data: string): Promise<DataStore>;
-    static fromFile(filePath: string | URL): Promise<DataStore>;
-}
-export interface ScopedDataStore {
-    get: <TData extends Record<string, unknown> = Record<string, unknown>>(key: string) => DataEntry<TData> | undefined;
-    entries: () => Array<[id: string, DataEntry]>;
-    set: <TData extends Record<string, unknown>>(opts: {
-        /** The ID of the entry. Must be unique per collection. */
-        id: string;
-        /** The data to store. */
-        data: TData;
-        /** The raw body of the content, if applicable. */
-        body?: string;
-        /** The file path of the content, if applicable. Relative to the site root. */
-        filePath?: string;
-        /** A content digest, to check if the content has changed. */
-        digest?: number | string;
-        /** The rendered content, if applicable. */
-        rendered?: RenderedContent;
-        /**
-         * If an entry is a deferred, its rendering phase is delegated to a virtual module during the runtime phase.
-         */
-        deferredRender?: boolean;
-    }) => boolean;
-    values: () => Array<DataEntry>;
-    keys: () => Array<string>;
-    delete: (key: string) => void;
-    clear: () => void;
-    has: (key: string) => boolean;
-    /**
-     * Adds a single asset to the store. This asset will be transformed
-     * by Vite, and the URL will be available in the final build.
-     * @param fileName
-     * @param specifier
-     * @returns
-     */
-    addModuleImport: (fileName: string) => void;
-}
-/**
- * A key-value store for metadata strings. Useful for storing things like sync tokens.
- */
-export interface MetaStore {
-    get: (key: string) => string | undefined;
-    set: (key: string, value: string) => void;
-    has: (key: string) => boolean;
-    delete: (key: string) => void;
 }
-export declare function contentModuleToId(fileName: string): string;

package/dist/content/data-store.js

@@ -1,266 +1,36 @@
-import { promises as fs, existsSync } from "fs";
 import * as devalue from "devalue";
-import { imageSrcToImportId, importIdToSymbolName } from "../assets/utils/resolveImports.js";
-import { AstroError, AstroErrorData } from "../core/errors/index.js";
-import { CONTENT_MODULE_FLAG, DEFERRED_MODULE } from "./consts.js";
-const SAVE_DEBOUNCE_MS = 500;
 class DataStore {
-  #collections = /* @__PURE__ */ new Map();
-  #file;
-  #assetsFile;
-  #modulesFile;
-  #saveTimeout;
-  #assetsSaveTimeout;
-  #modulesSaveTimeout;
-  #dirty = false;
-  #assetsDirty = false;
-  #modulesDirty = false;
-  #assetImports = /* @__PURE__ */ new Set();
-  #moduleImports = /* @__PURE__ */ new Map();
+  _collections = /* @__PURE__ */ new Map();
   constructor() {
-    this.#collections = /* @__PURE__ */ new Map();
+    this._collections = /* @__PURE__ */ new Map();
   }
   get(collectionName, key) {
-    return this.#collections.get(collectionName)?.get(String(key));
+    return this._collections.get(collectionName)?.get(String(key));
   }
   entries(collectionName) {
-    const collection = this.#collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
     return [...collection.entries()];
   }
   values(collectionName) {
-    const collection = this.#collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
     return [...collection.values()];
   }
   keys(collectionName) {
-    const collection = this.#collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
     return [...collection.keys()];
   }
-  set(collectionName, key, value) {
-    const collection = this.#collections.get(collectionName) ?? /* @__PURE__ */ new Map();
-    collection.set(String(key), value);
-    this.#collections.set(collectionName, collection);
-    this.#saveToDiskDebounced();
-  }
-  delete(collectionName, key) {
-    const collection = this.#collections.get(collectionName);
-    if (collection) {
-      collection.delete(String(key));
-      this.#saveToDiskDebounced();
-    }
-  }
-  clear(collectionName) {
-    this.#collections.delete(collectionName);
-    this.#saveToDiskDebounced();
-  }
-  clearAll() {
-    this.#collections.clear();
-    this.#saveToDiskDebounced();
-  }
   has(collectionName, key) {
-    const collection = this.#collections.get(collectionName);
+    const collection = this._collections.get(collectionName);
     if (collection) {
       return collection.has(String(key));
     }
     return false;
   }
   hasCollection(collectionName) {
-    return this.#collections.has(collectionName);
+    return this._collections.has(collectionName);
   }
   collections() {
-    return this.#collections;
-  }
-  addAssetImport(assetImport, filePath) {
-    const id = imageSrcToImportId(assetImport, filePath);
-    if (id) {
-      this.#assetImports.add(id);
-      this.#writeAssetsImportsDebounced();
-    }
-  }
-  addAssetImports(assets, filePath) {
-    assets.forEach((asset) => this.addAssetImport(asset, filePath));
-  }
-  addModuleImport(fileName) {
-    const id = contentModuleToId(fileName);
-    if (id) {
-      this.#moduleImports.set(fileName, id);
-      this.#writeModulesImportsDebounced();
-    }
-  }
-  async writeAssetImports(filePath) {
-    this.#assetsFile = filePath;
-    if (this.#assetImports.size === 0) {
-      try {
-        await fs.writeFile(filePath, "export default new Map();");
-      } catch (err) {
-        throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
-      }
-    }
-    if (!this.#assetsDirty && existsSync(filePath)) {
-      return;
-    }
-    const imports = [];
-    const exports = [];
-    this.#assetImports.forEach((id) => {
-      const symbol = importIdToSymbolName(id);
-      imports.push(`import ${symbol} from '${id}';`);
-      exports.push(`[${JSON.stringify(id)}, ${symbol}]`);
-    });
-    const code = (
-      /* js */
-      `
-${imports.join("\n")}
-export default new Map([${exports.join(", ")}]);
-		`
-    );
-    try {
-      await fs.writeFile(filePath, code);
-    } catch (err) {
-      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
-    }
-    this.#assetsDirty = false;
-  }
-  async writeModuleImports(filePath) {
-    this.#modulesFile = filePath;
-    if (this.#moduleImports.size === 0) {
-      try {
-        await fs.writeFile(filePath, "export default new Map();");
-      } catch (err) {
-        throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
-      }
-    }
-    if (!this.#modulesDirty && existsSync(filePath)) {
-      return;
-    }
-    const lines = [];
-    for (const [fileName, specifier] of this.#moduleImports) {
-      lines.push(`['${fileName}', () => import('${specifier}')]`);
-    }
-    const code = `
-export default new Map([
-${lines.join(",\n")}]);
-		`;
-    try {
-      await fs.writeFile(filePath, code);
-    } catch (err) {
-      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
-    }
-    this.#modulesDirty = false;
-  }
-  #writeAssetsImportsDebounced() {
-    this.#assetsDirty = true;
-    if (this.#assetsFile) {
-      if (this.#assetsSaveTimeout) {
-        clearTimeout(this.#assetsSaveTimeout);
-      }
-      this.#assetsSaveTimeout = setTimeout(() => {
-        this.#assetsSaveTimeout = void 0;
-        this.writeAssetImports(this.#assetsFile);
-      }, SAVE_DEBOUNCE_MS);
-    }
-  }
-  #writeModulesImportsDebounced() {
-    this.#modulesDirty = true;
-    if (this.#modulesFile) {
-      if (this.#modulesSaveTimeout) {
-        clearTimeout(this.#modulesSaveTimeout);
-      }
-      this.#modulesSaveTimeout = setTimeout(() => {
-        this.#modulesSaveTimeout = void 0;
-        this.writeModuleImports(this.#modulesFile);
-      }, SAVE_DEBOUNCE_MS);
-    }
-  }
-  #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);
-    }
-  }
-  scopedStore(collectionName) {
-    return {
-      get: (key) => this.get(collectionName, key),
-      entries: () => this.entries(collectionName),
-      values: () => this.values(collectionName),
-      keys: () => this.keys(collectionName),
-      set: ({ id: key, data, body, filePath, deferredRender, digest, rendered }) => {
-        if (!key) {
-          throw new Error(`ID must be a non-empty string`);
-        }
-        const id = String(key);
-        if (digest) {
-          const existing = this.get(collectionName, id);
-          if (existing && existing.digest === digest) {
-            return false;
-          }
-        }
-        const entry = {
-          id,
-          data
-        };
-        if (body) {
-          entry.body = body;
-        }
-        if (filePath) {
-          if (filePath.startsWith("/")) {
-            throw new Error(`File path must be relative to the site root. Got: ${filePath}`);
-          }
-          entry.filePath = filePath;
-        }
-        if (digest) {
-          entry.digest = digest;
-        }
-        if (rendered) {
-          entry.rendered = rendered;
-        }
-        if (deferredRender) {
-          entry.deferredRender = deferredRender;
-          if (filePath) {
-            this.addModuleImport(filePath);
-          }
-        }
-        this.set(collectionName, id, entry);
-        return true;
-      },
-      delete: (key) => this.delete(collectionName, key),
-      clear: () => this.clear(collectionName),
-      has: (key) => this.has(collectionName, key),
-      addAssetImport: (assetImport, fileName) => this.addAssetImport(assetImport, fileName),
-      addAssetImports: (assets, fileName) => this.addAssetImports(assets, fileName),
-      addModuleImport: (fileName) => this.addModuleImport(fileName)
-    };
-  }
-  /**
-   * Returns a MetaStore for a given collection, or if no collection is provided, the default meta collection.
-   */
-  metaStore(collectionName = ":meta") {
-    const collectionKey = `meta:${collectionName}`;
-    return {
-      get: (key) => this.get(collectionKey, key),
-      set: (key, data) => this.set(collectionKey, key, data),
-      delete: (key) => this.delete(collectionKey, key),
-      has: (key) => this.has(collectionKey, key)
-    };
-  }
-  toString() {
-    return devalue.stringify(this.#collections);
-  }
-  async writeToDisk(filePath) {
-    if (!this.#dirty) {
-      return;
-    }
-    try {
-      await fs.writeFile(filePath, this.toString());
-      this.#file = filePath;
-      this.#dirty = false;
-    } catch (err) {
-      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
-    }
+    return this._collections;
   }
   /**
    * Attempts to load a DataStore from the virtual module.
@@ -277,23 +47,9 @@ ${lines.join(",\n")}]);
   }
   static async fromMap(data) {
     const store = new DataStore();
-    store.#collections = data;
+    store._collections = data;
     return store;
   }
-  static async fromString(data) {
-    const map = devalue.parse(data);
-    return DataStore.fromMap(map);
-  }
-  static async fromFile(filePath) {
-    try {
-      if (existsSync(filePath)) {
-        const data = await fs.readFile(filePath, "utf-8");
-        return DataStore.fromString(data);
-      }
-    } catch {
-    }
-    return new DataStore();
-  }
 }
 function dataStoreSingleton() {
   let instance = void 0;
@@ -309,15 +65,8 @@ function dataStoreSingleton() {
     }
   };
 }
-function contentModuleToId(fileName) {
-  const params = new URLSearchParams(DEFERRED_MODULE);
-  params.set("fileName", fileName);
-  params.set(CONTENT_MODULE_FLAG, "true");
-  return `${DEFERRED_MODULE}?${params.toString()}`;
-}
 const globalDataStore = dataStoreSingleton();
 export {
   DataStore,
-  contentModuleToId,
   globalDataStore
 };

package/dist/content/loaders/types.d.ts

@@ -1,7 +1,7 @@
 import type { FSWatcher } from 'vite';
 import type { ZodSchema } from 'zod';
 import type { AstroIntegrationLogger, AstroSettings } from '../../@types/astro.js';
-import type { MetaStore, ScopedDataStore } from '../data-store.js';
+import type { MetaStore, ScopedDataStore } from '../mutable-data-store.js';
 export interface ParseDataOptions<TData extends Record<string, unknown>> {
     /** The ID of the entry. Unique per collection */
     id: string;

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

@@ -0,0 +1,77 @@
+import { type PathLike } from 'node:fs';
+import { type DataEntry, DataStore, type RenderedContent } from './data-store.js';
+/**
+ * Extends the DataStore with the ability to change entries and write them to disk.
+ * This is kept as a separate class to avoid needing node builtins at runtime, when read-only access is all that is needed.
+ */
+export declare class MutableDataStore extends DataStore {
+    #private;
+    set(collectionName: string, key: string, value: unknown): void;
+    delete(collectionName: string, key: string): void;
+    clear(collectionName: string): void;
+    clearAll(): void;
+    addAssetImport(assetImport: string, filePath: string): void;
+    addAssetImports(assets: Array<string>, filePath: string): void;
+    addModuleImport(fileName: string): void;
+    writeAssetImports(filePath: PathLike): Promise<void>;
+    writeModuleImports(filePath: PathLike): Promise<void>;
+    scopedStore(collectionName: string): ScopedDataStore;
+    /**
+     * Returns a MetaStore for a given collection, or if no collection is provided, the default meta collection.
+     */
+    metaStore(collectionName?: string): MetaStore;
+    toString(): string;
+    writeToDisk(filePath: PathLike): Promise<void>;
+    /**
+     * Attempts to load a MutableDataStore from the virtual module.
+     * This only works in Vite.
+     */
+    static fromModule(): Promise<MutableDataStore>;
+    static fromMap(data: Map<string, Map<string, any>>): Promise<MutableDataStore>;
+    static fromString(data: string): Promise<MutableDataStore>;
+    static fromFile(filePath: string | URL): Promise<MutableDataStore>;
+}
+export interface ScopedDataStore {
+    get: <TData extends Record<string, unknown> = Record<string, unknown>>(key: string) => DataEntry<TData> | undefined;
+    entries: () => Array<[id: string, DataEntry]>;
+    set: <TData extends Record<string, unknown>>(opts: {
+        /** The ID of the entry. Must be unique per collection. */
+        id: string;
+        /** The data to store. */
+        data: TData;
+        /** The raw body of the content, if applicable. */
+        body?: string;
+        /** The file path of the content, if applicable. Relative to the site root. */
+        filePath?: string;
+        /** A content digest, to check if the content has changed. */
+        digest?: number | string;
+        /** The rendered content, if applicable. */
+        rendered?: RenderedContent;
+        /**
+         * If an entry is a deferred, its rendering phase is delegated to a virtual module during the runtime phase.
+         */
+        deferredRender?: boolean;
+    }) => boolean;
+    values: () => Array<DataEntry>;
+    keys: () => Array<string>;
+    delete: (key: string) => void;
+    clear: () => void;
+    has: (key: string) => boolean;
+    /**
+     * Adds a single asset to the store. This asset will be transformed
+     * by Vite, and the URL will be available in the final build.
+     * @param fileName
+     * @param specifier
+     * @returns
+     */
+    addModuleImport: (fileName: string) => void;
+}
+/**
+ * A key-value store for metadata strings. Useful for storing things like sync tokens.
+ */
+export interface MetaStore {
+    get: (key: string) => string | undefined;
+    set: (key: string, value: string) => void;
+    has: (key: string) => boolean;
+    delete: (key: string) => void;
+}

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

@@ -0,0 +1,269 @@
+import { promises as fs, existsSync } from "node:fs";
+import * as devalue from "devalue";
+import { imageSrcToImportId, importIdToSymbolName } from "../assets/utils/resolveImports.js";
+import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { DataStore } from "./data-store.js";
+import { contentModuleToId } from "./utils.js";
+const SAVE_DEBOUNCE_MS = 500;
+class MutableDataStore extends DataStore {
+  #file;
+  #assetsFile;
+  #modulesFile;
+  #saveTimeout;
+  #assetsSaveTimeout;
+  #modulesSaveTimeout;
+  #dirty = false;
+  #assetsDirty = false;
+  #modulesDirty = false;
+  #assetImports = /* @__PURE__ */ new Set();
+  #moduleImports = /* @__PURE__ */ new Map();
+  set(collectionName, key, value) {
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    collection.set(String(key), value);
+    this._collections.set(collectionName, collection);
+    this.#saveToDiskDebounced();
+  }
+  delete(collectionName, key) {
+    const collection = this._collections.get(collectionName);
+    if (collection) {
+      collection.delete(String(key));
+      this.#saveToDiskDebounced();
+    }
+  }
+  clear(collectionName) {
+    this._collections.delete(collectionName);
+    this.#saveToDiskDebounced();
+  }
+  clearAll() {
+    this._collections.clear();
+    this.#saveToDiskDebounced();
+  }
+  addAssetImport(assetImport, filePath) {
+    const id = imageSrcToImportId(assetImport, filePath);
+    if (id) {
+      this.#assetImports.add(id);
+      this.#writeAssetsImportsDebounced();
+    }
+  }
+  addAssetImports(assets, filePath) {
+    assets.forEach((asset) => this.addAssetImport(asset, filePath));
+  }
+  addModuleImport(fileName) {
+    const id = contentModuleToId(fileName);
+    if (id) {
+      this.#moduleImports.set(fileName, id);
+      this.#writeModulesImportsDebounced();
+    }
+  }
+  async writeAssetImports(filePath) {
+    this.#assetsFile = filePath;
+    if (this.#assetImports.size === 0) {
+      try {
+        await fs.writeFile(filePath, "export default new Map();");
+      } catch (err) {
+        throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+      }
+    }
+    if (!this.#assetsDirty && existsSync(filePath)) {
+      return;
+    }
+    const imports = [];
+    const exports = [];
+    this.#assetImports.forEach((id) => {
+      const symbol = importIdToSymbolName(id);
+      imports.push(`import ${symbol} from '${id}';`);
+      exports.push(`[${JSON.stringify(id)}, ${symbol}]`);
+    });
+    const code = (
+      /* js */
+      `
+${imports.join("\n")}
+export default new Map([${exports.join(", ")}]);
+		`
+    );
+    try {
+      await fs.writeFile(filePath, code);
+    } catch (err) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+    }
+    this.#assetsDirty = false;
+  }
+  async writeModuleImports(filePath) {
+    this.#modulesFile = filePath;
+    if (this.#moduleImports.size === 0) {
+      try {
+        await fs.writeFile(filePath, "export default new Map();");
+      } catch (err) {
+        throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+      }
+    }
+    if (!this.#modulesDirty && existsSync(filePath)) {
+      return;
+    }
+    const lines = [];
+    for (const [fileName, specifier] of this.#moduleImports) {
+      lines.push(`['${fileName}', () => import('${specifier}')]`);
+    }
+    const code = `
+export default new Map([
+${lines.join(",\n")}]);
+		`;
+    try {
+      await fs.writeFile(filePath, code);
+    } catch (err) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+    }
+    this.#modulesDirty = false;
+  }
+  #writeAssetsImportsDebounced() {
+    this.#assetsDirty = true;
+    if (this.#assetsFile) {
+      if (this.#assetsSaveTimeout) {
+        clearTimeout(this.#assetsSaveTimeout);
+      }
+      this.#assetsSaveTimeout = setTimeout(() => {
+        this.#assetsSaveTimeout = void 0;
+        this.writeAssetImports(this.#assetsFile);
+      }, SAVE_DEBOUNCE_MS);
+    }
+  }
+  #writeModulesImportsDebounced() {
+    this.#modulesDirty = true;
+    if (this.#modulesFile) {
+      if (this.#modulesSaveTimeout) {
+        clearTimeout(this.#modulesSaveTimeout);
+      }
+      this.#modulesSaveTimeout = setTimeout(() => {
+        this.#modulesSaveTimeout = void 0;
+        this.writeModuleImports(this.#modulesFile);
+      }, SAVE_DEBOUNCE_MS);
+    }
+  }
+  #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);
+    }
+  }
+  scopedStore(collectionName) {
+    return {
+      get: (key) => this.get(collectionName, key),
+      entries: () => this.entries(collectionName),
+      values: () => this.values(collectionName),
+      keys: () => this.keys(collectionName),
+      set: ({ id: key, data, body, filePath, deferredRender, digest, rendered }) => {
+        if (!key) {
+          throw new Error(`ID must be a non-empty string`);
+        }
+        const id = String(key);
+        if (digest) {
+          const existing = this.get(collectionName, id);
+          if (existing && existing.digest === digest) {
+            return false;
+          }
+        }
+        const entry = {
+          id,
+          data
+        };
+        if (body) {
+          entry.body = body;
+        }
+        if (filePath) {
+          if (filePath.startsWith("/")) {
+            throw new Error(`File path must be relative to the site root. Got: ${filePath}`);
+          }
+          entry.filePath = filePath;
+        }
+        if (digest) {
+          entry.digest = digest;
+        }
+        if (rendered) {
+          entry.rendered = rendered;
+        }
+        if (deferredRender) {
+          entry.deferredRender = deferredRender;
+          if (filePath) {
+            this.addModuleImport(filePath);
+          }
+        }
+        this.set(collectionName, id, entry);
+        return true;
+      },
+      delete: (key) => this.delete(collectionName, key),
+      clear: () => this.clear(collectionName),
+      has: (key) => this.has(collectionName, key),
+      addAssetImport: (assetImport, fileName) => this.addAssetImport(assetImport, fileName),
+      addAssetImports: (assets, fileName) => this.addAssetImports(assets, fileName),
+      addModuleImport: (fileName) => this.addModuleImport(fileName)
+    };
+  }
+  /**
+   * Returns a MetaStore for a given collection, or if no collection is provided, the default meta collection.
+   */
+  metaStore(collectionName = ":meta") {
+    const collectionKey = `meta:${collectionName}`;
+    return {
+      get: (key) => this.get(collectionKey, key),
+      set: (key, data) => this.set(collectionKey, key, data),
+      delete: (key) => this.delete(collectionKey, key),
+      has: (key) => this.has(collectionKey, key)
+    };
+  }
+  toString() {
+    return devalue.stringify(this._collections);
+  }
+  async writeToDisk(filePath) {
+    if (!this.#dirty) {
+      return;
+    }
+    try {
+      await fs.writeFile(filePath, this.toString());
+      this.#file = filePath;
+      this.#dirty = false;
+    } catch (err) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+    }
+  }
+  /**
+   * Attempts to load a MutableDataStore from the virtual module.
+   * This only works in Vite.
+   */
+  static async fromModule() {
+    try {
+      const data = await import("astro:data-layer-content");
+      const map = devalue.unflatten(data.default);
+      return MutableDataStore.fromMap(map);
+    } catch {
+    }
+    return new MutableDataStore();
+  }
+  static async fromMap(data) {
+    const store = new MutableDataStore();
+    store._collections = data;
+    return store;
+  }
+  static async fromString(data) {
+    const map = devalue.parse(data);
+    return MutableDataStore.fromMap(map);
+  }
+  static async fromFile(filePath) {
+    try {
+      if (existsSync(filePath)) {
+        const data = await fs.readFile(filePath, "utf-8");
+        return MutableDataStore.fromString(data);
+      }
+    } catch {
+    }
+    return new MutableDataStore();
+  }
+}
+export {
+  MutableDataStore
+};

package/dist/content/types-generator.js

@@ -477,11 +477,9 @@ async function writeContentFiles({
     contentConfig ? `typeof import(${configPathRelativeToCacheDir})` : "never"
   );
   if (settings.injectedTypes.some((t) => t.filename === CONTENT_TYPES_FILE)) {
-    fs.promises.writeFile(
-      new URL(CONTENT_TYPES_FILE, settings.dotAstroDir),
-      typeTemplateContent,
-      "utf-8"
-    );
+    const filePath = fileURLToPath(new URL(CONTENT_TYPES_FILE, settings.dotAstroDir));
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(filePath, typeTemplateContent, "utf-8");
   } else {
     settings.injectedTypes.push({
       filename: CONTENT_TYPES_FILE,

package/dist/content/utils.d.ts

@@ -485,4 +485,5 @@ export declare function posixifyPath(filePath: string): string;
  * Unlike `path.posix.relative`, this function will accept a platform path and return a posix path.
  */
 export declare function posixRelative(from: string, to: string): string;
+export declare function contentModuleToId(fileName: string): string;
 export {};

package/dist/content/utils.js

@@ -12,6 +12,7 @@ import {
   CONTENT_FLAGS,
   CONTENT_LAYER_TYPE,
   CONTENT_MODULE_FLAG,
+  DEFERRED_MODULE,
   IMAGE_IMPORT_PREFIX,
   PROPAGATED_ASSET_FLAG
 } from "./consts.js";
@@ -465,7 +466,14 @@ function posixifyPath(filePath) {
 function posixRelative(from, to) {
   return posixifyPath(path.relative(from, to));
 }
+function contentModuleToId(fileName) {
+  const params = new URLSearchParams(DEFERRED_MODULE);
+  params.set("fileName", fileName);
+  params.set(CONTENT_MODULE_FLAG, "true");
+  return `${DEFERRED_MODULE}?${params.toString()}`;
+}
 export {
+  contentModuleToId,
   contentObservable,
   getContentEntryExts,
   getContentEntryIdAndSlug,

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "4.14.0";
+const ASTRO_VERSION = "4.14.2";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/dev.js

@@ -1,11 +1,11 @@
 import fs, { existsSync } from "node:fs";
+import { performance } from "node:perf_hooks";
 import { green } from "kleur/colors";
-import { performance } from "perf_hooks";
 import { gt, major, minor, patch } from "semver";
 import { DATA_STORE_FILE } from "../../content/consts.js";
 import { globalContentLayer } from "../../content/content-layer.js";
-import { DataStore, globalDataStore } from "../../content/data-store.js";
 import { attachContentServerListeners } from "../../content/index.js";
+import { MutableDataStore } from "../../content/mutable-data-store.js";
 import { globalContentConfigObserver } from "../../content/utils.js";
 import { telemetry } from "../../events/index.js";
 import * as msg from "../messages.js";
@@ -23,7 +23,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "4.14.0";
+  const currentVersion = "4.14.2";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -72,15 +72,13 @@ async function dev(inlineConfig) {
   try {
     const dataStoreFile = new URL(DATA_STORE_FILE, restart.container.settings.config.cacheDir);
     if (existsSync(dataStoreFile)) {
-      store = await DataStore.fromFile(dataStoreFile);
-      globalDataStore.set(store);
+      store = await MutableDataStore.fromFile(dataStoreFile);
     }
   } catch (err) {
     logger.error("content", err.message);
   }
   if (!store) {
-    store = new DataStore();
-    globalDataStore.set(store);
+    store = new MutableDataStore();
   }
   const config = globalContentConfigObserver.get();
   if (config.status === "error") {

package/dist/core/logger/vite.js

@@ -1,4 +1,4 @@
-import { fileURLToPath } from "url";
+import { fileURLToPath } from "node:url";
 import stripAnsi from "strip-ansi";
 import { isAstroError } from "../errors/errors.js";
 import { serverShortcuts as formatServerShortcuts } from "../messages.js";

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "4.14.0";
+  const version = "4.14.2";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -270,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"4.14.0"}`
+        `v${"4.14.2"}`
       )} ${headline}`
     );
   }

package/dist/core/preview/static-preview-server.js

@@ -1,5 +1,5 @@
+import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
-import { performance } from "perf_hooks";
 import { preview } from "vite";
 import * as msg from "../messages.js";
 import { getResolvedHostForHttpServer } from "./util.js";

package/dist/core/routing/manifest/create.js

@@ -1,5 +1,5 @@
-import { createRequire } from "module";
 import nodeFs from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { bold } from "kleur/colors";

package/dist/core/sync/index.js

@@ -1,11 +1,12 @@
 import fsMod, { existsSync } from "node:fs";
 import { performance } from "node:perf_hooks";
+import { fileURLToPath } from "node:url";
 import { dim } from "kleur/colors";
 import { createServer } from "vite";
 import { CONTENT_TYPES_FILE, DATA_STORE_FILE } from "../../content/consts.js";
 import { globalContentLayer } from "../../content/content-layer.js";
-import { DataStore, globalDataStore } from "../../content/data-store.js";
 import { createContentTypesGenerator } from "../../content/index.js";
+import { MutableDataStore } from "../../content/mutable-data-store.js";
 import { getContentPaths, globalContentConfigObserver } from "../../content/utils.js";
 import { syncAstroEnv } from "../../env/sync.js";
 import { telemetry } from "../../events/index.js";
@@ -74,15 +75,13 @@ async function syncInternal({
       try {
         const dataStoreFile = new URL(DATA_STORE_FILE, settings.config.cacheDir);
         if (existsSync(dataStoreFile)) {
-          store = await DataStore.fromFile(dataStoreFile);
-          globalDataStore.set(store);
+          store = await MutableDataStore.fromFile(dataStoreFile);
         }
       } catch (err) {
         logger.error("content", err.message);
       }
       if (!store) {
-        store = new DataStore();
-        globalDataStore.set(store);
+        store = new MutableDataStore();
       }
       const contentLayer = globalContentLayer.init({
         settings,
@@ -91,7 +90,7 @@ async function syncInternal({
       });
       await contentLayer.sync();
       settings.timer.end("Sync content layer");
-    } else if (fs.existsSync(getContentPaths(settings.config, fs).contentDir.href)) {
+    } else if (fs.existsSync(fileURLToPath(getContentPaths(settings.config, fs).contentDir))) {
       settings.injectedTypes.push({
         filename: CONTENT_TYPES_FILE,
         content: ""

package/dist/runtime/server/render/server-islands.js

@@ -61,9 +61,10 @@ if(response.status === 200 && response.headers.get('content-type') === 'text/htm
 	let html = await response.text();
 
 	// Swap!
-	while(script.previousSibling?.nodeType !== 8 &&
-		script.previousSibling?.data !== 'server-island-start') {
-		script.previousSibling?.remove();
+	while(script.previousSibling &&
+		script.previousSibling.nodeType !== 8 &&
+		script.previousSibling.data !== 'server-island-start') {
+		script.previousSibling.remove();
 	}
 	script.previousSibling?.remove();
 

package/dist/vite-plugin-astro-server/response.js

@@ -1,4 +1,4 @@
-import { Readable } from "stream";
+import { Readable } from "node:stream";
 import { getSetCookiesFromResponse } from "../core/cookies/index.js";
 import { getViteErrorPayload } from "../core/errors/dev/index.js";
 import notFoundTemplate from "../template/4xx.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "4.14.0",
+  "version": "4.14.2",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -115,8 +115,8 @@
     "@babel/plugin-transform-react-jsx": "^7.25.2",
     "@babel/traverse": "^7.25.3",
     "@babel/types": "^7.25.2",
-    "@rollup/pluginutils": "^5.1.0",
     "@oslojs/encoding": "^0.4.1",
+    "@rollup/pluginutils": "^5.1.0",
     "@types/babel__core": "^7.20.5",
     "@types/cookie": "^0.6.0",
     "acorn": "^8.12.1",
@@ -168,6 +168,7 @@
     "vitefu": "^0.2.5",
     "which-pm": "^3.0.0",
     "xxhash-wasm": "^1.0.2",
+    "yargs-parser": "^21.1.1",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.2",
     "zod-to-ts": "^1.2.0",
@@ -197,6 +198,7 @@
     "@types/micromatch": "^4.0.9",
     "@types/prompts": "^2.4.9",
     "@types/semver": "^7.5.8",
+    "@types/yargs-parser": "^21.0.3",
     "cheerio": "1.0.0",
     "eol": "^0.9.1",
     "expect-type": "^0.19.0",