astro 7.0.8 → 7.1.0

package/dist/assets/fonts/infra/fs-font-file-content-resolver.js

@@ -10,7 +10,7 @@ class FsFontFileContentResolver {
       return url;
     }
     try {
-      return url + this.#readFileSync(url);
+      return this.#readFileSync(url);
     } catch (cause) {
       throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
     }

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

@@ -2,5 +2,22 @@ import { type Flags } from '../flags.js';
 interface DevOptions {
     flags: Flags;
 }
+/**
+ * `yargs-parser` camel-cases `--ignore-lock` to `flags.ignoreLock`.
+ */
+export declare function isIgnoreLock(flags: Flags): boolean;
+/**
+ * `--ignore-lock` skips the lock file entirely, so a background dev server started with it
+ * could never be found by `astro dev stop`/`status`/`logs`. Returns an error message if
+ * background mode (explicit `--background`, or implied by AI agent detection) is combined
+ * with `--ignore-lock`, or `null` if there's no conflict.
+ */
+export declare function getBackgroundIgnoreLockConflict(flags: Flags, wantsBackground: boolean): string | null;
+/**
+ * `--force` (replace the existing server) and `--ignore-lock` (start alongside it,
+ * untracked) express contradictory intent. Returns an error message if both are set,
+ * or `null` otherwise.
+ */
+export declare function getForceIgnoreLockConflict(flags: Flags): string | null;
 export declare function dev({ flags }: DevOptions): Promise<import("../../core/dev/dev.js").DevServer | undefined>;
 export {};

package/dist/cli/dev/index.js

@@ -18,6 +18,31 @@ function isRunByAgent() {
     return false;
   }
 }
+function isIgnoreLock(flags) {
+  return flags.ignoreLock === true;
+}
+function getBackgroundIgnoreLockConflict(flags, wantsBackground) {
+  if (!wantsBackground) {
+    return null;
+  }
+  const reason = flags.background ? "`--background`" : "an auto-detected AI agent environment, which runs the dev server in the background automatically";
+  return [
+    `\`--ignore-lock\` cannot be used together with ${reason}.`,
+    "",
+    "Background dev servers rely on the lock file so `astro dev stop`, `astro dev status`, and `astro dev logs` can find them.",
+    "Run the dev server in the foreground to use --ignore-lock."
+  ].join("\n");
+}
+function getForceIgnoreLockConflict(flags) {
+  if (!flags.force) {
+    return null;
+  }
+  return [
+    "`--force` and `--ignore-lock` cannot be used together.",
+    "",
+    "`--force` replaces the existing dev server; `--ignore-lock` starts a new one alongside it without touching the lock file. Choose one."
+  ].join("\n");
+}
 async function dev({ flags }) {
   if (flags.help || flags.h) {
     printHelp({
@@ -37,6 +62,10 @@ async function dev({ flags }) {
           ["--host <custom-address>", `Expose on a network IP address at <custom-address>`],
           ["--open", "Automatically open the app in the browser on server start"],
           ["--force", "Clear the content layer cache, forcing a full rebuild."],
+          [
+            "--ignore-lock",
+            "Start the dev server even if another one is already running, without checking or writing the lock file."
+          ],
           [
             "--allowed-hosts",
             "Specify a comma-separated list of allowed hosts or allow any hostname."
@@ -54,6 +83,8 @@ async function dev({ flags }) {
   if (agentDetected) {
     flags.json = true;
   }
+  const ignoreLock = isIgnoreLock(flags);
+  const wantsBackground = !!flags.background || agentDetected;
   const logger = createLoggerFromFlags(flags);
   const subcommand = flags._[3]?.toString();
   if (subcommand === "stop") {
@@ -71,7 +102,13 @@ async function dev({ flags }) {
     await logs({ flags, logger });
     return;
   }
-  if (flags.background || agentDetected) {
+  if (ignoreLock) {
+    const conflict = getBackgroundIgnoreLockConflict(flags, wantsBackground) ?? getForceIgnoreLockConflict(flags);
+    if (conflict) {
+      throw new Error(conflict);
+    }
+  }
+  if (wantsBackground) {
     const { background } = await import("./background.js");
     await background({ flags, logger });
     return;
@@ -86,6 +123,20 @@ Run \`astro dev --help\` to see available commands.`
     process.exit(1);
   }
   const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  if (ignoreLock) {
+    const existingServer2 = checkExistingServer(root);
+    if (existingServer2) {
+      logger.info(
+        "SKIP_FORMAT",
+        [
+          `Starting a new dev server alongside the one already running at ${existingServer2.url} (pid ${existingServer2.pid}).`,
+          "This instance is not tracked by `astro dev stop`, `astro dev status`, or `astro dev logs`."
+        ].join("\n")
+      );
+    }
+    const inlineConfig2 = flagsToAstroInlineConfig(flags);
+    return await devServer(inlineConfig2);
+  }
   const existingServer = checkExistingServer(root);
   if (existingServer) {
     if (flags.force) {
@@ -121,5 +172,8 @@ Run \`astro dev --help\` to see available commands.`
   return server;
 }
 export {
-  dev
+  dev,
+  getBackgroundIgnoreLockConflict,
+  getForceIgnoreLockConflict,
+  isIgnoreLock
 };

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.0.8";
+  version = "7.1.0";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/content/consts.d.ts

@@ -20,6 +20,8 @@ export declare const IMAGE_IMPORT_PREFIX = "__ASTRO_IMAGE_";
 export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroRenderContent", "astroDataCollectionEntry", "astroPropagatedAssets", "astroContentImageFlag", "astroContentModuleFlag"];
 export declare const CONTENT_TYPES_FILE = "content.d.ts";
 export declare const DATA_STORE_FILE = "data-store.json";
+export declare const DATA_STORE_DIR = "data-store/";
+export declare const DATA_STORE_MANIFEST_FILE = "manifest.json";
 export declare const ASSET_IMPORTS_FILE = "content-assets.mjs";
 export declare const MODULES_IMPORTS_FILE = "content-modules.mjs";
 export declare const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";

package/dist/content/consts.js

@@ -27,6 +27,8 @@ const CONTENT_FLAGS = [
 ];
 const CONTENT_TYPES_FILE = "content.d.ts";
 const DATA_STORE_FILE = "data-store.json";
+const DATA_STORE_DIR = "data-store/";
+const DATA_STORE_MANIFEST_FILE = "manifest.json";
 const ASSET_IMPORTS_FILE = "content-assets.mjs";
 const MODULES_IMPORTS_FILE = "content-modules.mjs";
 const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
@@ -47,7 +49,9 @@ export {
   CONTENT_RENDER_FLAG,
   CONTENT_TYPES_FILE,
   DATA_FLAG,
+  DATA_STORE_DIR,
   DATA_STORE_FILE,
+  DATA_STORE_MANIFEST_FILE,
   DATA_STORE_VIRTUAL_ID,
   DEFERRED_MODULE,
   IMAGE_IMPORT_PREFIX,

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

@@ -33,9 +33,3 @@ export declare class ContentLayer {
     sync(options?: RefreshContentOptions): Promise<void>;
     regenerateCollectionFileManifest(): Promise<void>;
 }
-/**
- * Get the path to the data store file.
- * During development, this is in the `.astro` directory so that the Vite watcher can see it.
- * In production, it's in the cache directory so that it's preserved between builds.
- */
-export declare function getDataStoreFile(settings: AstroSettings, isDev: boolean): URL;

package/dist/content/content-layer.js

@@ -7,7 +7,6 @@ import {
   ASSET_IMPORTS_FILE,
   COLLECTIONS_MANIFEST_FILE,
   CONTENT_LAYER_TYPE,
-  DATA_STORE_FILE,
   MODULES_IMPORTS_FILE
 } from "./consts.js";
 import {
@@ -197,7 +196,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.0.8") {
+    if (previousAstroVersion && previousAstroVersion !== "7.1.0") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -205,8 +204,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.0.8") {
-      this.#store.metaStore().set("astro-version", "7.0.8");
+    if ("7.1.0") {
+      this.#store.metaStore().set("astro-version", "7.1.0");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);
@@ -367,10 +366,6 @@ ${JSON.stringify({ ...raw, id: void 0 }, null, 2)}`
     )
   });
 }
-function getDataStoreFile(settings, isDev) {
-  return new URL(DATA_STORE_FILE, isDev ? settings.dotAstroDir : settings.config.cacheDir);
-}
 export {
-  ContentLayer,
-  getDataStoreFile
+  ContentLayer
 };

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

@@ -0,0 +1,36 @@
+import type { DataEntry, ImmutableDataStore } from './data-store.js';
+/**
+ * A read-only, async view over content collection data, used at runtime by
+ * `getCollection()` and `getEntry()`. It lets the runtime read from different
+ * data sources (an in-memory snapshot today, potentially a database or remote
+ * source in the future) through one interface, without depending on Node.js
+ * APIs.
+ *
+ * The query methods are async so a source can perform I/O when resolving data.
+ * The default {@link InMemorySource} resolves synchronously.
+ */
+export interface DataStoreSource {
+    hasCollection(collection: string): Promise<boolean> | boolean;
+    get<T = DataEntry>(collection: string, key: string): Promise<T | undefined> | T | undefined;
+    entries<T = DataEntry>(collection: string): Promise<Array<[id: string, T]>> | Array<[id: string, T]>;
+    values<T = DataEntry>(collection: string): Promise<Array<T>> | Array<T>;
+    keys(collection: string): Promise<Array<string>> | Array<string>;
+    has(collection: string, key: string): Promise<boolean> | boolean;
+    collections(): Promise<Map<string, Map<string, any>>> | Map<string, Map<string, any>>;
+}
+/**
+ * A {@link DataStoreSource} backed by an in-memory {@link ImmutableDataStore}.
+ * All queries resolve synchronously; the async signatures exist to satisfy the
+ * {@link DataStoreSource} contract.
+ */
+export declare class InMemorySource implements DataStoreSource {
+    #private;
+    constructor(store: ImmutableDataStore);
+    hasCollection(collection: string): boolean;
+    get<T = DataEntry>(collection: string, key: string): T | undefined;
+    entries<T = DataEntry>(collection: string): Array<[id: string, T]>;
+    values<T = DataEntry>(collection: string): Array<T>;
+    keys(collection: string): Array<string>;
+    has(collection: string, key: string): boolean;
+    collections(): Map<string, Map<string, any>>;
+}

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

@@ -0,0 +1,30 @@
+class InMemorySource {
+  #store;
+  constructor(store) {
+    this.#store = store;
+  }
+  hasCollection(collection) {
+    return this.#store.hasCollection(collection);
+  }
+  get(collection, key) {
+    return this.#store.get(collection, key);
+  }
+  entries(collection) {
+    return this.#store.entries(collection);
+  }
+  values(collection) {
+    return this.#store.values(collection);
+  }
+  keys(collection) {
+    return this.#store.keys(collection);
+  }
+  has(collection, key) {
+    return this.#store.has(collection, key);
+  }
+  collections() {
+    return this.#store.collections();
+  }
+}
+export {
+  InMemorySource
+};

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

@@ -0,0 +1,67 @@
+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.
+ */
+export type DataStoreManifest = Record<string, string[]>;
+/**
+ * Persists the content collection data produced by the content layer. This is
+ * the write side that saves the data; {@link import('./data-store-source.js').DataStoreSource}
+ * is the read side that loads it back. Implementations run in Node.js
+ * (build/dev) and are never imported at runtime.
+ */
+export interface DataStoreWriter {
+    /** Serialize and persist the given collections. */
+    write(collections: Map<string, Map<string, any>>): Promise<void>;
+}
+/**
+ * Serialize collections to a deterministic devalue string.
+ */
+export declare function serializeDataStore(collections: Map<string, Map<string, any>>): string;
+/**
+ * Split a string into parts each at most `maxBytes` UTF-8 bytes, never splitting
+ * a Unicode code point across parts.
+ *
+ * The store is serialized with devalue and written to disk as UTF-8. Splitting
+ * 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.
+ */
+export declare function chunkString(str: string, maxBytes: number): string[];
+/**
+ * Atomically write `data` to `file`.
+ *
+ * The data is written to a temporary file and then renamed into place to avoid
+ * partial reads. If the file already contains identical data, the write is
+ * skipped. Callers are responsible for serializing concurrent writes to the
+ * same file.
+ */
+export declare function writeFileAtomic(file: PathLike, data: string): Promise<void>;
+/**
+ * A {@link DataStoreWriter} that serializes the whole store to a single file.
+ */
+export declare class FileWriter implements DataStoreWriter {
+    #private;
+    constructor(file: PathLike);
+    write(collections: Map<string, Map<string, any>>): Promise<void>;
+}
+/**
+ * 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
+ * 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
+ * of {@link import('./data-store.js').ImmutableDataStore.manifestToMap}.
+ */
+export declare class ChunkedWriter implements DataStoreWriter {
+    #private;
+    constructor(dir: URL);
+    write(collections: Map<string, Map<string, any>>): Promise<void>;
+}

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

@@ -0,0 +1,94 @@
+import { promises as fs } from "node:fs";
+import * as devalue from "devalue";
+import xxhash, {} from "xxhash-wasm";
+import { emptyDir } from "../core/fs/index.js";
+import { DATA_STORE_MANIFEST_FILE } from "./consts.js";
+const CHUNK_SIZE_LIMIT = 20 * 1024 * 1024;
+function sortCollections(collections) {
+  return new Map(
+    [...collections.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, collection]) => [
+      key,
+      new Map([...collection.entries()].sort(([a], [b]) => a.localeCompare(b)))
+    ])
+  );
+}
+function serializeDataStore(collections) {
+  return devalue.stringify(sortCollections(collections));
+}
+const ENCODER = new TextEncoder();
+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));
+  }
+  return chunks;
+}
+async function writeFileAtomic(file, data) {
+  const tempFile = file instanceof URL ? new URL(`${file.href}.tmp`) : `${file}.tmp`;
+  const oldData = await fs.readFile(file, "utf-8").catch(() => "");
+  if (oldData === data) {
+    return;
+  }
+  await fs.writeFile(tempFile, data);
+  await fs.rename(tempFile, file);
+}
+class FileWriter {
+  #file;
+  constructor(file) {
+    this.#file = file;
+  }
+  async write(collections) {
+    await writeFileAtomic(this.#file, serializeDataStore(collections));
+  }
+}
+class ChunkedWriter {
+  #dir;
+  #manifestFile;
+  #hasher;
+  constructor(dir) {
+    this.#dir = dir;
+    this.#manifestFile = new URL(`./${DATA_STORE_MANIFEST_FILE}`, dir);
+  }
+  async write(collections) {
+    if (!this.#hasher) {
+      this.#hasher = await xxhash();
+    }
+    const { h64ToString } = this.#hasher;
+    const 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, CHUNK_SIZE_LIMIT)) {
+        const fileName = `${h64ToString(part)}.txt`;
+        await writeFileAtomic(new URL(`./${fileName}`, this.#dir), part);
+        parts.push(fileName);
+        writtenFiles.add(fileName);
+      }
+      manifest[collectionName] = parts;
+    }
+    await writeFileAtomic(this.#manifestFile, JSON.stringify(manifest));
+    writtenFiles.add(DATA_STORE_MANIFEST_FILE);
+    emptyDir(this.#dir, writtenFiles);
+  }
+}
+export {
+  ChunkedWriter,
+  FileWriter,
+  chunkString,
+  serializeDataStore,
+  writeFileAtomic
+};

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

@@ -46,6 +46,21 @@ export declare class ImmutableDataStore {
     has(collectionName: string, key: string): boolean;
     hasCollection(collectionName: string): boolean;
     collections(): Map<string, Map<string, any>>;
+    /**
+     * Rebuilds a collections map from a chunked-store manifest whose part file
+     * names have already been swapped for their contents.
+     *
+     * 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 `?raw`
+     * import (`{ default: string }`, when emitted into the virtual module at
+     * runtime). A collection's parts are concatenated back into the exact
+     * serialized string, then parsed with devalue. 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: Record<string, Array<string | {
+        default: string;
+    }>>): Map<string, Map<string, any>>;
     /**
      * Attempts to load a DataStore from the virtual module.
      * This only works in Vite.

package/dist/content/data-store.js

@@ -1,4 +1,5 @@
 import * as devalue from "devalue";
+import { InMemorySource } from "./data-store-source.js";
 class ImmutableDataStore {
   _collections = /* @__PURE__ */ new Map();
   constructor() {
@@ -32,6 +33,30 @@ class ImmutableDataStore {
   collections() {
     return this._collections;
   }
+  /**
+   * Rebuilds a collections map from a chunked-store manifest whose part file
+   * names have already been swapped for their contents.
+   *
+   * 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 `?raw`
+   * import (`{ default: string }`, when emitted into the virtual module at
+   * runtime). A collection's parts are concatenated back into the exact
+   * serialized string, then parsed with devalue. 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 = "";
+      for (const part of parts) {
+        stringified += typeof part === "string" ? part : part.default;
+      }
+      const entries = devalue.parse(stringified);
+      collections.set(collectionName, entries);
+    }
+    return collections;
+  }
   /**
    * Attempts to load a DataStore from the virtual module.
    * This only works in Vite.
@@ -42,7 +67,11 @@ class ImmutableDataStore {
       if (data.default instanceof Map) {
         return ImmutableDataStore.fromMap(data.default);
       }
-      const map = devalue.unflatten(data.default);
+      if (Array.isArray(data.default)) {
+        const map2 = devalue.unflatten(data.default);
+        return ImmutableDataStore.fromMap(map2);
+      }
+      const map = ImmutableDataStore.manifestToMap(data.default);
       return ImmutableDataStore.fromMap(map);
     } catch {
     }
@@ -59,12 +88,13 @@ function dataStoreSingleton() {
   return {
     get: async () => {
       if (!instance) {
-        instance = ImmutableDataStore.fromModule();
+        instance = ImmutableDataStore.fromModule().then((store) => new InMemorySource(store));
       }
       return instance;
     },
+    // Note: currently unused, but kept for API stability.
     set: (store) => {
-      instance = store;
+      instance = new InMemorySource(store);
     }
   };
 }

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

@@ -23,6 +23,13 @@ interface GlobOptions {
      * Defaults to `true`.
      */
     retainBody?: boolean;
+    /**
+     * When `true`, renderable content entries (e.g. Markdown) will not be eagerly rendered
+     * during content sync. Instead, rendering is deferred until the entry is actually rendered
+     * in a page. This reduces memory usage for large collections with heavy rendered output.
+     * Defaults to `false`.
+     */
+    deferRender?: boolean;
 }
 export declare const secretLegacyFlag: unique symbol;
 /**

package/dist/content/loaders/glob.js

@@ -111,7 +111,7 @@ function glob(globOptions) {
             );
           }
         }
-        if (entryType.getRenderFunction) {
+        if (entryType.getRenderFunction && !globOptions.deferRender) {
           let render = renderFunctionByContentType.get(entryType);
           if (!render) {
             render = await entryType.getRenderFunction(config);
@@ -138,7 +138,7 @@ function glob(globOptions) {
             rendered,
             assetImports: rendered?.metadata?.imagePaths
           });
-        } else if ("contentModuleTypes" in entryType) {
+        } else if (entryType.getRenderFunction && globOptions.deferRender || "contentModuleTypes" in entryType) {
           store.set({
             id,
             data: parsedData,

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

@@ -35,6 +35,14 @@ export declare class MutableDataStore extends ImmutableDataStore {
     static fromMap(data: Map<string, Map<string, any>>): Promise<MutableDataStore>;
     static fromString(data: string): Promise<MutableDataStore>;
     static fromFile(filePath: string | URL): Promise<MutableDataStore>;
+    /**
+     * Loads a MutableDataStore from a chunked store directory (experimental
+     * `collectionStorage: 'chunked'`), reading the manifest and its referenced parts.
+     * If the directory has no manifest yet (fresh build) it starts empty. If the
+     * manifest exists but can't be read (corrupt cache), it warns and starts
+     * empty so loaders rebuild it, rather than failing the sync.
+     */
+    static fromDir(dirPath: URL): Promise<MutableDataStore>;
 }
 export interface DataStore {
     get: <TData extends Record<string, unknown> = Record<string, unknown>>(key: string) => DataEntry<TData> | undefined;