astro 4.13.3 → 4.14.0

package/dist/cli/db/index.js

@@ -2,10 +2,13 @@ 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({ flags }) {
+async function db({ positionals, flags }) {
   applyPolyfill();
   const logger = createLoggerFromFlags(flags);
-  const getPackageOpts = { skipAsk: flags.yes || flags.y, cwd: flags.root };
+  const getPackageOpts = {
+    skipAsk: !!flags.yes || !!flags.y,
+    cwd: typeof flags.root == "string" ? flags.root : void 0
+  };
   const dbPackage = await getPackage("@astrojs/db", logger, getPackageOpts, []);
   if (!dbPackage) {
     logger.error(
@@ -17,7 +20,11 @@ async function db({ flags }) {
   const { cli } = dbPackage;
   const inlineConfig = flagsToAstroInlineConfig(flags);
   const { astroConfig } = await resolveConfig(inlineConfig, "build");
-  await cli({ flags, config: astroConfig });
+  const yargsArgs = {
+    _: positionals,
+    ...flags
+  };
+  await cli({ flags: yargsArgs, config: astroConfig });
 }
 export {
   db

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

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface DevOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function dev({ flags }: DevOptions): Promise<import("../../core/dev/dev.js").DevServer | undefined>;
 export {};

package/dist/cli/dev/index.js

@@ -13,6 +13,7 @@ async function dev({ flags }) {
           ["--host", `Listen on all addresses, including LAN and public addresses.`],
           ["--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."],
           ["--help (-h)", "See all available flags."]
         ]
       },

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

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import type { Flags } from '../flags.js';
 interface DocsOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function docs({ flags }: DocsOptions): Promise<import("execa").ExecaReturnValue<string> | undefined>;
 export {};

package/dist/cli/flags.d.ts

@@ -1,6 +1,8 @@
-import type { Arguments as Flags } from 'yargs-parser';
+import type { parseArgs } from 'node:util';
 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 declare function flagsToAstroInlineConfig(flags: Flags): AstroInlineConfig;
 /**
  * The `logging` is usually created from an `AstroInlineConfig`, but some flows like `add`

package/dist/cli/flags.js

@@ -6,13 +6,14 @@ function flagsToAstroInlineConfig(flags) {
     configFile: typeof flags.config === "string" ? flags.config : void 0,
     mode: typeof flags.mode === "string" ? flags.mode : void 0,
     logLevel: flags.verbose ? "debug" : flags.silent ? "silent" : void 0,
+    force: flags.force ? true : void 0,
     // Astro user configs
     root: typeof flags.root === "string" ? flags.root : void 0,
     site: typeof flags.site === "string" ? flags.site : void 0,
     base: typeof flags.base === "string" ? flags.base : void 0,
     outDir: typeof flags.outDir === "string" ? flags.outDir : void 0,
     server: {
-      port: typeof flags.port === "number" ? flags.port : void 0,
+      port: typeof flags.port === "string" ? 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.d.ts

@@ -1,2 +1,2 @@
 /** The primary CLI action */
-export declare function cli(args: string[]): Promise<void>;
+export declare function cli(argv: string[]): Promise<void>;

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(flags) {
-  const cmd = flags._[2];
-  if (flags.version) return "version";
+function resolveCommand(args) {
+  const cmd = args.positionals[2];
+  if (args.values.version) return "version";
   const supportedCommands = /* @__PURE__ */ new Set([
     "add",
     "sync",
@@ -68,7 +68,8 @@ function resolveCommand(flags) {
   }
   return "help";
 }
-async function runCommand(cmd, flags) {
+async function runCommand(cmd, args) {
+  const flags = args.values;
   switch (cmd) {
     case "help":
       await printAstroHelp();
@@ -88,7 +89,7 @@ async function runCommand(cmd, flags) {
     }
     case "telemetry": {
       const { update } = await import("./telemetry/index.js");
-      const subcommand = flags._[3]?.toString();
+      const subcommand = args.positionals[3];
       await update(subcommand, { flags });
       return;
     }
@@ -99,7 +100,7 @@ async function runCommand(cmd, flags) {
     }
     case "preferences": {
       const { preferences } = await import("./preferences/index.js");
-      const [subcommand, key, value] = flags._.slice(3).map((v) => v.toString());
+      const [subcommand, key, value] = args.positionals.slice(3);
       const exitCode = await preferences(subcommand, key, value, { flags });
       return process.exit(exitCode);
     }
@@ -113,7 +114,7 @@ async function runCommand(cmd, flags) {
   switch (cmd) {
     case "add": {
       const { add } = await import("./add/index.js");
-      const packages = flags._.slice(3);
+      const packages = args.positionals.slice(3);
       await add(packages, { flags });
       return;
     }
@@ -123,7 +124,7 @@ async function runCommand(cmd, flags) {
     case "link":
     case "init": {
       const { db } = await import("./db/index.js");
-      await db({ flags });
+      await db({ positionals: args.positionals, flags });
       return;
     }
     case "dev": {
@@ -161,11 +162,23 @@ async function runCommand(cmd, flags) {
   }
   throw new Error(`Error running ${cmd} -- no command found.`);
 }
-async function cli(args) {
-  const flags = yargs(args, { boolean: ["global"], alias: { g: "global" } });
-  const cmd = resolveCommand(flags);
+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);
   try {
-    await runCommand(cmd, flags);
+    await runCommand(cmd, args);
   } catch (err) {
     const { throwAndExit } = await import("./throw-and-exit.js");
     await throwAndExit(cmd, err);

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

@@ -1,7 +1,7 @@
-import type yargs from 'yargs-parser';
 import type { AstroConfig, AstroUserConfig } from '../../@types/astro.js';
+import { type Flags } from '../flags.js';
 interface InfoOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function getInfoOutput({ userConfig, print, }: {
     userConfig: AstroUserConfig | AstroConfig;

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

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface PreferencesOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 declare const PREFERENCES_SUBCOMMANDS: readonly ["get", "set", "enable", "disable", "delete", "reset", "list"];
 export type Subcommand = (typeof PREFERENCES_SUBCOMMANDS)[number];

package/dist/cli/preferences/index.js

@@ -55,7 +55,7 @@ async function preferences(subcommand, key, value, { flags }) {
   const settings = await createSettings(astroConfig, fileURLToPath(astroConfig.root));
   const opts = {
     location: flags.global ? "global" : void 0,
-    json: flags.json
+    json: !!flags.json
   };
   if (subcommand === "list") {
     return listPreferences(settings, opts);

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

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface PreviewOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function preview({ flags }: PreviewOptions): Promise<import("../../@types/astro.js").PreviewServer | undefined>;
 export {};

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

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface SyncOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function sync({ flags }: SyncOptions): Promise<0 | 1>;
 export {};

package/dist/cli/sync/index.js

@@ -7,14 +7,17 @@ async function sync({ flags }) {
       commandName: "astro sync",
       usage: "[...flags]",
       tables: {
-        Flags: [["--help (-h)", "See all available flags."]]
+        Flags: [
+          ["--force", "Clear the content layer cache, forcing a full rebuild."],
+          ["--help (-h)", "See all available flags."]
+        ]
       },
       description: `Generates TypeScript types for all Astro modules.`
     });
     return 0;
   }
   try {
-    await _sync({ inlineConfig: flagsToAstroInlineConfig(flags), telemetry: true });
+    await _sync(flagsToAstroInlineConfig(flags), { telemetry: true });
     return 0;
   } catch (_) {
     return 1;

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

@@ -1,6 +1,6 @@
-import type yargs from 'yargs-parser';
+import { type Flags } from '../flags.js';
 interface TelemetryOptions {
-    flags: yargs.Arguments;
+    flags: Flags;
 }
 export declare function notify(): Promise<void>;
 export declare function update(subcommand: string, { flags }: TelemetryOptions): Promise<void>;

package/dist/container/index.js

@@ -2,6 +2,7 @@ import { posix } from "node:path";
 import { getDefaultClientDirectives } from "../core/client-directive/index.js";
 import { ASTRO_CONFIG_DEFAULTS } from "../core/config/schema.js";
 import { validateConfig } from "../core/config/validate.js";
+import { createKey } from "../core/encryption.js";
 import { Logger } from "../core/logger/core.js";
 import { nodeLogDestination } from "../core/logger/node.js";
 import { removeLeadingForwardSlash } from "../core/path.js";
@@ -31,7 +32,8 @@ function createManifest(manifest, renderers, middleware) {
     i18n: manifest?.i18n,
     checkOrigin: false,
     middleware: manifest?.middleware ?? middleware ?? defaultMiddleware,
-    experimentalEnvGetSecretEnabled: false
+    experimentalEnvGetSecretEnabled: false,
+    key: createKey()
   };
 }
 class experimental_AstroContainer {

package/dist/content/consts.d.ts

@@ -2,10 +2,24 @@ export declare const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
 export declare const CONTENT_RENDER_FLAG = "astroRenderContent";
 export declare const CONTENT_FLAG = "astroContentCollectionEntry";
 export declare const DATA_FLAG = "astroDataCollectionEntry";
+export declare const CONTENT_IMAGE_FLAG = "astroContentImageFlag";
+export declare const CONTENT_MODULE_FLAG = "astroContentModuleFlag";
 export declare const VIRTUAL_MODULE_ID = "astro:content";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
+export declare const DATA_STORE_VIRTUAL_ID = "astro:data-layer-content";
+export declare const RESOLVED_DATA_STORE_VIRTUAL_ID: string;
+export declare const MODULES_MJS_ID = "astro:content-module-imports";
+export declare const MODULES_MJS_VIRTUAL_ID: string;
+export declare const DEFERRED_MODULE = "astro:content-layer-deferred-module";
+export declare const ASSET_IMPORTS_VIRTUAL_ID = "astro:asset-imports";
+export declare const ASSET_IMPORTS_RESOLVED_STUB_ID: string;
 export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 export declare const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
-export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroRenderContent", "astroDataCollectionEntry", "astroPropagatedAssets"];
-export declare const CONTENT_TYPES_FILE = "types.d.ts";
+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 = "astro/content.d.ts";
+export declare const DATA_STORE_FILE = "data-store.json";
+export declare const ASSET_IMPORTS_FILE = "assets.mjs";
+export declare const MODULES_IMPORTS_FILE = "modules.mjs";
+export declare const CONTENT_LAYER_TYPE = "content_layer";

package/dist/content/consts.js

@@ -2,26 +2,56 @@ const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
 const CONTENT_RENDER_FLAG = "astroRenderContent";
 const CONTENT_FLAG = "astroContentCollectionEntry";
 const DATA_FLAG = "astroDataCollectionEntry";
+const CONTENT_IMAGE_FLAG = "astroContentImageFlag";
+const CONTENT_MODULE_FLAG = "astroContentModuleFlag";
 const VIRTUAL_MODULE_ID = "astro:content";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const DATA_STORE_VIRTUAL_ID = "astro:data-layer-content";
+const RESOLVED_DATA_STORE_VIRTUAL_ID = "\0" + DATA_STORE_VIRTUAL_ID;
+const MODULES_MJS_ID = "astro:content-module-imports";
+const MODULES_MJS_VIRTUAL_ID = "\0" + MODULES_MJS_ID;
+const DEFERRED_MODULE = "astro:content-layer-deferred-module";
+const ASSET_IMPORTS_VIRTUAL_ID = "astro:asset-imports";
+const ASSET_IMPORTS_RESOLVED_STUB_ID = "\0" + ASSET_IMPORTS_VIRTUAL_ID;
 const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
 const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
 const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
+const IMAGE_IMPORT_PREFIX = "__ASTRO_IMAGE_";
 const CONTENT_FLAGS = [
   CONTENT_FLAG,
   CONTENT_RENDER_FLAG,
   DATA_FLAG,
-  PROPAGATED_ASSET_FLAG
+  PROPAGATED_ASSET_FLAG,
+  CONTENT_IMAGE_FLAG,
+  CONTENT_MODULE_FLAG
 ];
-const CONTENT_TYPES_FILE = "types.d.ts";
+const CONTENT_TYPES_FILE = "astro/content.d.ts";
+const DATA_STORE_FILE = "data-store.json";
+const ASSET_IMPORTS_FILE = "assets.mjs";
+const MODULES_IMPORTS_FILE = "modules.mjs";
+const CONTENT_LAYER_TYPE = "content_layer";
 export {
+  ASSET_IMPORTS_FILE,
+  ASSET_IMPORTS_RESOLVED_STUB_ID,
+  ASSET_IMPORTS_VIRTUAL_ID,
   CONTENT_FLAG,
   CONTENT_FLAGS,
+  CONTENT_IMAGE_FLAG,
+  CONTENT_LAYER_TYPE,
+  CONTENT_MODULE_FLAG,
   CONTENT_RENDER_FLAG,
   CONTENT_TYPES_FILE,
   DATA_FLAG,
+  DATA_STORE_FILE,
+  DATA_STORE_VIRTUAL_ID,
+  DEFERRED_MODULE,
+  IMAGE_IMPORT_PREFIX,
   LINKS_PLACEHOLDER,
+  MODULES_IMPORTS_FILE,
+  MODULES_MJS_ID,
+  MODULES_MJS_VIRTUAL_ID,
   PROPAGATED_ASSET_FLAG,
+  RESOLVED_DATA_STORE_VIRTUAL_ID,
   RESOLVED_VIRTUAL_MODULE_ID,
   SCRIPTS_PLACEHOLDER,
   STYLES_PLACEHOLDER,

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

@@ -0,0 +1,40 @@
+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';
+export interface ContentLayerOptions {
+    store: DataStore;
+    settings: AstroSettings;
+    logger: Logger;
+    watcher?: FSWatcher;
+}
+export declare class ContentLayer {
+    #private;
+    constructor({ settings, logger, store, watcher }: ContentLayerOptions);
+    /**
+     * Whether the content layer is currently loading content
+     */
+    get loading(): boolean;
+    /**
+     * Watch for changes to the content config and trigger a sync when it changes.
+     */
+    watchContentConfig(): void;
+    unwatchContentConfig(): void;
+    /**
+     * Run the `load()` method of each collection's loader, which will load the data and save it in the data store.
+     * The loader itself is responsible for deciding whether this will clear and reload the full collection, or
+     * perform an incremental update. After the data is loaded, the data store is written to disk.
+     */
+    sync(): Promise<void>;
+    regenerateCollectionFileManifest(): Promise<void>;
+}
+export declare function simpleLoader<TData extends {
+    id: string;
+}>(handler: () => Array<TData> | Promise<Array<TData>>, context: LoaderContext): Promise<void>;
+export declare const globalContentLayer: {
+    initialized: () => boolean;
+    init: (options: ContentLayerOptions) => ContentLayer;
+    get: () => ContentLayer;
+    dispose: () => void;
+};

package/dist/content/content-layer.js

@@ -0,0 +1,253 @@
+import { promises as fs, existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import xxhash from "xxhash-wasm";
+import { AstroUserError } from "../core/errors/errors.js";
+import {
+  ASSET_IMPORTS_FILE,
+  CONTENT_LAYER_TYPE,
+  DATA_STORE_FILE,
+  MODULES_IMPORTS_FILE
+} from "./consts.js";
+import { getEntryDataAndImages, globalContentConfigObserver, posixRelative } from "./utils.js";
+class ContentLayer {
+  #logger;
+  #store;
+  #settings;
+  #watcher;
+  #lastConfigDigest;
+  #unsubscribe;
+  #generateDigest;
+  #loading = false;
+  constructor({ settings, logger, store, watcher }) {
+    watcher?.setMaxListeners(50);
+    this.#logger = logger;
+    this.#store = store;
+    this.#settings = settings;
+    this.#watcher = watcher;
+  }
+  /**
+   * Whether the content layer is currently loading content
+   */
+  get loading() {
+    return this.#loading;
+  }
+  /**
+   * Watch for changes to the content config and trigger a sync when it changes.
+   */
+  watchContentConfig() {
+    this.#unsubscribe?.();
+    this.#unsubscribe = globalContentConfigObserver.subscribe(async (ctx) => {
+      if (!this.#loading && ctx.status === "loaded" && ctx.config.digest !== this.#lastConfigDigest) {
+        this.sync();
+      }
+    });
+  }
+  unwatchContentConfig() {
+    this.#unsubscribe?.();
+  }
+  /**
+   * Run the `load()` method of each collection's loader, which will load the data and save it in the data store.
+   * The loader itself is responsible for deciding whether this will clear and reload the full collection, or
+   * perform an incremental update. After the data is loaded, the data store is written to disk.
+   */
+  async sync() {
+    if (this.#loading) {
+      return;
+    }
+    this.#loading = true;
+    try {
+      await this.#doSync();
+    } finally {
+      this.#loading = false;
+    }
+  }
+  async #getGenerateDigest() {
+    if (this.#generateDigest) {
+      return this.#generateDigest;
+    }
+    const { h64ToString } = await xxhash();
+    this.#generateDigest = (data) => {
+      const dataString = typeof data === "string" ? data : JSON.stringify(data);
+      return h64ToString(dataString);
+    };
+    return this.#generateDigest;
+  }
+  async #getLoaderContext({
+    collectionName,
+    loaderName = "content",
+    parseData
+  }) {
+    return {
+      collection: collectionName,
+      store: this.#store.scopedStore(collectionName),
+      meta: this.#store.metaStore(collectionName),
+      logger: this.#logger.forkIntegrationLogger(loaderName),
+      settings: this.#settings,
+      parseData,
+      generateDigest: await this.#getGenerateDigest(),
+      watcher: this.#watcher
+    };
+  }
+  async #doSync() {
+    const contentConfig = globalContentConfigObserver.get();
+    const logger = this.#logger.forkIntegrationLogger("content");
+    if (contentConfig?.status !== "loaded") {
+      logger.debug("Content config not loaded, skipping sync");
+      return;
+    }
+    if (!this.#settings.config.experimental.contentLayer) {
+      const contentLayerCollections = Object.entries(contentConfig.config.collections).filter(
+        ([_, collection]) => collection.type === CONTENT_LAYER_TYPE
+      );
+      if (contentLayerCollections.length > 0) {
+        throw new AstroUserError(
+          `The following collections have a loader defined, but the content layer is not enabled: ${contentLayerCollections.map(([title]) => title).join(", ")}.`,
+          "To enable the Content Layer API, set `experimental: { contentLayer: true }` in your Astro config file."
+        );
+      }
+      return;
+    }
+    logger.info("Syncing content");
+    const { digest: currentConfigDigest } = contentConfig.config;
+    this.#lastConfigDigest = currentConfigDigest;
+    const previousConfigDigest = await this.#store.metaStore().get("config-digest");
+    if (currentConfigDigest && previousConfigDigest !== currentConfigDigest) {
+      logger.info("Content config changed, clearing cache");
+      this.#store.clearAll();
+      await this.#store.metaStore().set("config-digest", currentConfigDigest);
+    }
+    await Promise.all(
+      Object.entries(contentConfig.config.collections).map(async ([name, collection]) => {
+        if (collection.type !== CONTENT_LAYER_TYPE) {
+          return;
+        }
+        let { schema } = collection;
+        if (!schema && typeof collection.loader === "object") {
+          schema = collection.loader.schema;
+          if (typeof schema === "function") {
+            schema = await schema();
+          }
+        }
+        const collectionWithResolvedSchema = { ...collection, schema };
+        const parseData = async ({ id, data, filePath = "" }) => {
+          const { imageImports, data: parsedData } = await getEntryDataAndImages(
+            {
+              id,
+              collection: name,
+              unvalidatedData: data,
+              _internal: {
+                rawData: void 0,
+                filePath
+              }
+            },
+            collectionWithResolvedSchema,
+            false
+          );
+          if (imageImports?.length) {
+            this.#store.addAssetImports(
+              imageImports,
+              // This path may already be relative, if we're re-parsing an existing entry
+              isAbsolute(filePath) ? posixRelative(fileURLToPath(this.#settings.config.root), filePath) : filePath
+            );
+          }
+          return parsedData;
+        };
+        const context = await this.#getLoaderContext({
+          collectionName: name,
+          parseData,
+          loaderName: collection.loader.name
+        });
+        if (typeof collection.loader === "function") {
+          return simpleLoader(collection.loader, context);
+        }
+        if (!collection.loader.load) {
+          throw new Error(`Collection loader for ${name} does not have a load method`);
+        }
+        return collection.loader.load(context);
+      })
+    );
+    if (!existsSync(this.#settings.config.cacheDir)) {
+      await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
+    }
+    const cacheFile = new URL(DATA_STORE_FILE, this.#settings.config.cacheDir);
+    await this.#store.writeToDisk(cacheFile);
+    if (!existsSync(this.#settings.dotAstroDir)) {
+      await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
+    }
+    const assetImportsFile = new URL(ASSET_IMPORTS_FILE, this.#settings.dotAstroDir);
+    await this.#store.writeAssetImports(assetImportsFile);
+    const modulesImportsFile = new URL(MODULES_IMPORTS_FILE, this.#settings.dotAstroDir);
+    await this.#store.writeModuleImports(modulesImportsFile);
+    logger.info("Synced content");
+    if (this.#settings.config.experimental.contentIntellisense) {
+      await this.regenerateCollectionFileManifest();
+    }
+  }
+  async regenerateCollectionFileManifest() {
+    const collectionsManifest = new URL("collections/collections.json", this.#settings.dotAstroDir);
+    this.#logger.debug("content", "Regenerating collection file manifest");
+    if (existsSync(collectionsManifest)) {
+      try {
+        const collections = await fs.readFile(collectionsManifest, "utf-8");
+        const collectionsJson = JSON.parse(collections);
+        collectionsJson.entries ??= {};
+        for (const { hasSchema, name } of collectionsJson.collections) {
+          if (!hasSchema) {
+            continue;
+          }
+          const entries = this.#store.values(name);
+          if (!entries?.[0]?.filePath) {
+            continue;
+          }
+          for (const { filePath } of entries) {
+            if (!filePath) {
+              continue;
+            }
+            const key = new URL(filePath, this.#settings.config.root).href.toLowerCase();
+            collectionsJson.entries[key] = name;
+          }
+        }
+        await fs.writeFile(collectionsManifest, JSON.stringify(collectionsJson, null, 2));
+      } catch {
+        this.#logger.error("content", "Failed to regenerate collection file manifest");
+      }
+    }
+    this.#logger.debug("content", "Regenerated collection file manifest");
+  }
+}
+async function simpleLoader(handler, context) {
+  const data = await handler();
+  context.store.clear();
+  for (const raw of data) {
+    const item = await context.parseData({ id: raw.id, data: raw });
+    context.store.set({ id: raw.id, data: item });
+  }
+}
+function contentLayerSingleton() {
+  let instance = null;
+  return {
+    initialized: () => Boolean(instance),
+    init: (options) => {
+      instance?.unwatchContentConfig();
+      instance = new ContentLayer(options);
+      return instance;
+    },
+    get: () => {
+      if (!instance) {
+        throw new Error("Content layer not initialized");
+      }
+      return instance;
+    },
+    dispose: () => {
+      instance?.unwatchContentConfig();
+      instance = null;
+    }
+  };
+}
+const globalContentLayer = contentLayerSingleton();
+export {
+  ContentLayer,
+  globalContentLayer,
+  simpleLoader
+};