astro 5.9.3 → 5.10.0

package/client.d.ts

@@ -48,9 +48,7 @@ declare module 'astro:assets' {
 		getImage: (
 			options: import('./dist/assets/types.js').UnresolvedImageTransform,
 		) => Promise<import('./dist/assets/types.js').GetImageResult>;
-		imageConfig: import('./dist/types/public/config.js').AstroConfig['image'] & {
-			experimentalResponsiveImages: boolean;
-		};
+		imageConfig: import('./dist/types/public/config.js').AstroConfig['image'];
 		getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;
 		inferRemoteSize: typeof import('./dist/assets/utils/index.js').inferRemoteSize;
 		Image: typeof import('./components/Image.astro').default;

package/components/Image.astro

@@ -24,14 +24,13 @@ if (typeof props.height === 'string') {
 	props.height = parseInt(props.height);
 }
 
-const layout = props.layout ?? imageConfig.experimentalLayout ?? 'none';
-const useResponsive = imageConfig.experimentalResponsiveImages && layout !== 'none';
+const layout = props.layout ?? imageConfig.layout ?? 'none';
 
-if (useResponsive) {
+if (layout !== 'none') {
 	// Apply defaults from imageConfig if not provided
-	props.layout ??= imageConfig.experimentalLayout;
-	props.fit ??= imageConfig.experimentalObjectFit ?? 'cover';
-	props.position ??= imageConfig.experimentalObjectPosition ?? 'center';
+	props.layout ??= imageConfig.layout;
+	props.fit ??= imageConfig.objectFit ?? 'cover';
+	props.position ??= imageConfig.objectPosition ?? 'center';
 }
 
 const image = await getImage(props as UnresolvedImageTransform);

package/components/Picture.astro

@@ -42,14 +42,14 @@ if (scopedStyleClass) {
 	}
 }
 
-const layout = props.layout ?? imageConfig.experimentalLayout ?? 'none';
-const useResponsive = imageConfig.experimentalResponsiveImages && layout !== 'none';
+const layout = props.layout ?? imageConfig.layout ?? 'none';
+const useResponsive = layout !== 'none';
 
 if (useResponsive) {
 	// Apply defaults from imageConfig if not provided
-	props.layout ??= imageConfig.experimentalLayout;
-	props.fit ??= imageConfig.experimentalObjectFit ?? 'cover';
-	props.position ??= imageConfig.experimentalObjectPosition ?? 'center';
+	props.layout ??= imageConfig.layout;
+	props.fit ??= imageConfig.objectFit ?? 'cover';
+	props.position ??= imageConfig.objectPosition ?? 'center';
 }
 
 for (const key in props) {

package/components/ResponsivePicture.astro

@@ -4,6 +4,7 @@ import { default as Picture, type Props as PictureProps } from './Picture.astro'
 type Props = PictureProps;
 
 const { class: className, ...props } = Astro.props;
+import './image.css';
 ---
 
 {/* Applying class outside of the spread prevents it from applying unnecessary astro-* classes */}

package/dist/actions/integration.d.ts

@@ -4,6 +4,7 @@ import type { AstroIntegration } from '../types/public/integrations.js';
  * This integration is applied when the user is using Actions in their project.
  * It will inject the necessary routes and middlewares to handle actions.
  */
-export default function astroIntegrationActionsRouteHandler({ settings, }: {
+export default function astroIntegrationActionsRouteHandler({ settings, filename, }: {
     settings: AstroSettings;
+    filename: string;
 }): AstroIntegration;

package/dist/actions/integration.js

@@ -3,7 +3,8 @@ import { AstroError } from "../core/errors/errors.js";
 import { viteID } from "../core/util.js";
 import { ACTIONS_TYPES_FILE, ACTION_RPC_ROUTE_PATTERN, VIRTUAL_MODULE_ID } from "./consts.js";
 function astroIntegrationActionsRouteHandler({
-  settings
+  settings,
+  filename
 }) {
   return {
     name: VIRTUAL_MODULE_ID,
@@ -23,7 +24,7 @@ function astroIntegrationActionsRouteHandler({
           throw error;
         }
         const stringifiedActionsImport = JSON.stringify(
-          viteID(new URL("./actions", params.config.srcDir))
+          viteID(new URL(`./${filename}`, params.config.srcDir))
         );
         settings.injectedTypes.push({
           filename: ACTIONS_TYPES_FILE,

package/dist/actions/utils.d.ts

@@ -7,4 +7,4 @@ export declare function createCallAction(context: ActionAPIContext): APIContext[
 /**
  * Check whether the Actions config file is present.
  */
-export declare function isActionsFilePresent(fs: typeof fsMod, srcDir: URL): Promise<boolean>;
+export declare function isActionsFilePresent(fs: typeof fsMod, srcDir: URL): Promise<string | false>;

package/dist/actions/utils.js

@@ -26,20 +26,20 @@ async function isActionsFilePresent(fs, srcDir) {
   if (!actionsFile) return false;
   let contents;
   try {
-    contents = fs.readFileSync(actionsFile, "utf-8");
+    contents = fs.readFileSync(actionsFile.url, "utf-8");
   } catch {
     return false;
   }
-  const [, exports] = eslexer.parse(contents, actionsFile.pathname);
+  const [, exports] = eslexer.parse(contents, actionsFile.url.pathname);
   for (const exp of exports) {
     if (exp.n === "server") {
-      return true;
+      return actionsFile.filename;
     }
   }
   return false;
 }
 function search(fs, srcDir) {
-  const paths = [
+  const filenames = [
     "actions.mjs",
     "actions.js",
     "actions.mts",
@@ -48,10 +48,11 @@ function search(fs, srcDir) {
     "actions/index.js",
     "actions/index.mts",
     "actions/index.ts"
-  ].map((p) => new URL(p, srcDir));
-  for (const file of paths) {
-    if (fs.existsSync(file)) {
-      return file;
+  ];
+  for (const filename of filenames) {
+    const url = new URL(filename, srcDir);
+    if (fs.existsSync(url)) {
+      return { filename, url };
     }
   }
   return void 0;

package/dist/assets/internal.d.ts

@@ -2,8 +2,4 @@ import type { AstroConfig } from '../types/public/config.js';
 import { type ImageService } from './services/service.js';
 import { type GetImageResult, type UnresolvedImageTransform } from './types.js';
 export declare function getConfiguredImageService(): Promise<ImageService>;
-type ImageConfig = AstroConfig['image'] & {
-    experimentalResponsiveImages: boolean;
-};
-export declare function getImage(options: UnresolvedImageTransform, imageConfig: ImageConfig): Promise<GetImageResult>;
-export {};
+export declare function getImage(options: UnresolvedImageTransform, imageConfig: AstroConfig['image']): Promise<GetImageResult>;

package/dist/assets/internal.js

@@ -89,36 +89,34 @@ async function getImage(options, imageConfig) {
     }
   }
   resolvedOptions.src = clonedSrc;
-  const layout = options.layout ?? imageConfig.experimentalLayout;
-  if (imageConfig.experimentalResponsiveImages && layout) {
+  const layout = options.layout ?? imageConfig.layout ?? "none";
+  if (resolvedOptions.priority) {
+    resolvedOptions.loading ??= "eager";
+    resolvedOptions.decoding ??= "sync";
+    resolvedOptions.fetchpriority ??= "high";
+    delete resolvedOptions.priority;
+  } else {
+    resolvedOptions.loading ??= "lazy";
+    resolvedOptions.decoding ??= "async";
+    resolvedOptions.fetchpriority ??= "auto";
+  }
+  if (layout !== "none") {
     resolvedOptions.widths ||= getWidths({
       width: resolvedOptions.width,
       layout,
       originalWidth,
-      breakpoints: imageConfig.experimentalBreakpoints?.length ? imageConfig.experimentalBreakpoints : isLocalService(service) ? LIMITED_RESOLUTIONS : DEFAULT_RESOLUTIONS
+      breakpoints: imageConfig.breakpoints?.length ? imageConfig.breakpoints : isLocalService(service) ? LIMITED_RESOLUTIONS : DEFAULT_RESOLUTIONS
     });
     resolvedOptions.sizes ||= getSizesAttribute({ width: resolvedOptions.width, layout });
-    if (resolvedOptions.priority) {
-      resolvedOptions.loading ??= "eager";
-      resolvedOptions.decoding ??= "sync";
-      resolvedOptions.fetchpriority ??= "high";
-    } else {
-      resolvedOptions.loading ??= "lazy";
-      resolvedOptions.decoding ??= "async";
-      resolvedOptions.fetchpriority ??= "auto";
-    }
-    delete resolvedOptions.priority;
     delete resolvedOptions.densities;
-    if (layout !== "none") {
-      resolvedOptions.style = addCSSVarsToStyle(
-        {
-          fit: cssFitValues.includes(resolvedOptions.fit ?? "") && resolvedOptions.fit,
-          pos: resolvedOptions.position
-        },
-        resolvedOptions.style
-      );
-      resolvedOptions["data-astro-image"] = layout;
-    }
+    resolvedOptions.style = addCSSVarsToStyle(
+      {
+        fit: cssFitValues.includes(resolvedOptions.fit ?? "") && resolvedOptions.fit,
+        pos: resolvedOptions.position
+      },
+      resolvedOptions.style
+    );
+    resolvedOptions["data-astro-image"] = layout;
   }
   const validatedOptions = service.validateOptions ? await service.validateOptions(resolvedOptions, imageConfig) : resolvedOptions;
   const srcSetTransforms = service.getSrcSet ? await service.getSrcSet(validatedOptions, imageConfig) : [];

package/dist/assets/types.d.ts

@@ -138,9 +138,9 @@ type ImageSharedProps<T> = T & {
     quality?: ImageQuality;
 } & ({
     /**
-     * The layout type for responsive images. Requires the `experimental.responsiveImages` flag to be enabled in the Astro config.
+     * The layout type for responsive images.
      *
-     * Allowed values are `constrained`, `fixed`, `full-width` or `none`. Defaults to value of `image.experimentalLayout`.
+     * Allowed values are `constrained`, `fixed`, `full-width` or `none`. Defaults to value of `image.layout`.
      *
      * - `constrained` - The image will scale to fit the container, maintaining its aspect ratio, but will not exceed the specified dimensions.
      * - `fixed` - The image will maintain its original dimensions.
@@ -153,7 +153,7 @@ type ImageSharedProps<T> = T & {
      */
     layout?: ImageLayout;
     /**
-     * Defines how the image should be cropped if the aspect ratio is changed. Requires the `experimental.responsiveImages` flag to be enabled in the Astro config.
+     * Defines how the image should be cropped if the aspect ratio is changed. Requires `layout` to be set.
      *
      * Default is `cover`. Allowed values are `fill`, `contain`, `cover`, `none` or `scale-down`. These behave like the equivalent CSS `object-fit` values. Other values may be passed if supported by the image service.
      *
@@ -164,7 +164,7 @@ type ImageSharedProps<T> = T & {
      */
     fit?: ImageFit;
     /**
-     * Defines the position of the image when cropping. Requires the `experimental.responsiveImages` flag to be enabled in the Astro config.
+     * Defines the position of the image when cropping. Requires `layout` to be set.
      *
      * The value is a string that specifies the position of the image, which matches the CSS `object-position` property. Other values may be passed if supported by the image service.
      *

package/dist/assets/vite-plugin-assets.js

@@ -71,7 +71,7 @@ function assets({ fs, settings, sync, logger }) {
   globalThis.astroAsset = {
     referencedImages: /* @__PURE__ */ new Set()
   };
-  const imageComponentPrefix = settings.config.experimental.responsiveImages && settings.config.image.experimentalDefaultStyles ? "Responsive" : "";
+  const imageComponentPrefix = settings.config.image.responsiveStyles ? "Responsive" : "";
   return [
     // Expose the components and different utilities from `astro:assets`
     {
@@ -98,7 +98,7 @@ function assets({ fs, settings, sync, logger }) {
 							export { default as Font } from "astro/components/Font.astro";
 							export { inferRemoteSize } from "astro/assets/utils/inferRemoteSize.js";
 
-							export const imageConfig = ${JSON.stringify({ ...settings.config.image, experimentalResponsiveImages: settings.config.experimental.responsiveImages })};
+							export const imageConfig = ${JSON.stringify(settings.config.image)};
 							// This is used by the @astrojs/node integration to locate images.
 							// It's unused on other platforms, but on some platforms like Netlify (and presumably also Vercel)
 							// new URL("dist/...") is interpreted by the bundler as a signal to include that directory

package/dist/content/config.d.ts

@@ -0,0 +1,74 @@
+import type { ZodLiteral, ZodNumber, ZodObject, ZodString, ZodType, ZodUnion } from 'zod';
+import type { LiveLoader, Loader } from './loaders/types.js';
+export type ImageFunction = () => ZodObject<{
+    src: ZodString;
+    width: ZodNumber;
+    height: ZodNumber;
+    format: ZodUnion<[
+        ZodLiteral<'png'>,
+        ZodLiteral<'jpg'>,
+        ZodLiteral<'jpeg'>,
+        ZodLiteral<'tiff'>,
+        ZodLiteral<'webp'>,
+        ZodLiteral<'gif'>,
+        ZodLiteral<'svg'>,
+        ZodLiteral<'avif'>
+    ]>;
+}>;
+export interface DataEntry {
+    id: string;
+    data: Record<string, unknown>;
+    filePath?: string;
+    body?: string;
+}
+export interface DataStore {
+    get: (key: string) => DataEntry;
+    entries: () => Array<[id: string, DataEntry]>;
+    set: (key: string, data: Record<string, unknown>, body?: string, filePath?: string) => void;
+    values: () => Array<DataEntry>;
+    keys: () => Array<string>;
+    delete: (key: string) => void;
+    clear: () => void;
+    has: (key: string) => boolean;
+}
+export interface MetaStore {
+    get: (key: string) => string | undefined;
+    set: (key: string, value: string) => void;
+    delete: (key: string) => void;
+    has: (key: string) => boolean;
+}
+export type BaseSchema = ZodType;
+export type SchemaContext = {
+    image: ImageFunction;
+};
+type ContentLayerConfig<S extends BaseSchema, TData extends {
+    id: string;
+} = {
+    id: string;
+}> = {
+    type?: 'content_layer';
+    schema?: S | ((context: SchemaContext) => S);
+    loader: Loader | (() => Array<TData> | Promise<Array<TData>> | Record<string, Omit<TData, 'id'> & {
+        id?: string;
+    }> | Promise<Record<string, Omit<TData, 'id'> & {
+        id?: string;
+    }>>);
+};
+type DataCollectionConfig<S extends BaseSchema> = {
+    type: 'data';
+    schema?: S | ((context: SchemaContext) => S);
+};
+type ContentCollectionConfig<S extends BaseSchema> = {
+    type?: 'content';
+    schema?: S | ((context: SchemaContext) => S);
+    loader?: never;
+};
+export type LiveCollectionConfig<L extends LiveLoader, S extends BaseSchema | undefined = undefined> = {
+    type: 'live';
+    schema?: S;
+    loader: L;
+};
+export type CollectionConfig<S extends BaseSchema> = ContentCollectionConfig<S> | DataCollectionConfig<S> | ContentLayerConfig<S>;
+export declare function defineLiveCollection<L extends LiveLoader, S extends BaseSchema | undefined = undefined>(config: LiveCollectionConfig<L, S>): LiveCollectionConfig<L, S>;
+export declare function defineCollection<S extends BaseSchema>(config: CollectionConfig<S>): CollectionConfig<S>;
+export {};

package/dist/content/config.js

@@ -0,0 +1,78 @@
+import { AstroError, AstroErrorData, AstroUserError } from "../core/errors/index.js";
+import { CONTENT_LAYER_TYPE, LIVE_CONTENT_TYPE } from "./consts.js";
+function getImporterFilename() {
+  const stackLine = new Error().stack?.split("\n").find(
+    (line) => !line.includes("defineCollection") && !line.includes("defineLiveCollection") && !line.includes("getImporterFilename") && line !== "Error"
+  );
+  if (!stackLine) {
+    return void 0;
+  }
+  const match = /\/((?:src|chunks)\/.*?):\d+:\d+/.exec(stackLine);
+  return match?.[1] ?? void 0;
+}
+function defineLiveCollection(config) {
+  const importerFilename = getImporterFilename();
+  if (!importerFilename?.includes("live.config")) {
+    throw new AstroError({
+      ...AstroErrorData.LiveContentConfigError,
+      message: AstroErrorData.LiveContentConfigError.message(
+        "Live collections must be defined in a `src/live.config.ts` file.",
+        importerFilename ?? "your content config file"
+      )
+    });
+  }
+  if (config.type !== LIVE_CONTENT_TYPE) {
+    throw new AstroError({
+      ...AstroErrorData.LiveContentConfigError,
+      message: AstroErrorData.LiveContentConfigError.message(
+        "Collections in a live config file must have a type of `live`.",
+        importerFilename
+      )
+    });
+  }
+  if (!config.loader) {
+    throw new AstroError({
+      ...AstroErrorData.LiveContentConfigError,
+      message: AstroErrorData.LiveContentConfigError.message(
+        "Live collections must have a `loader` defined.",
+        importerFilename
+      )
+    });
+  }
+  if (typeof config.schema === "function") {
+    throw new AstroError({
+      ...AstroErrorData.LiveContentConfigError,
+      message: AstroErrorData.LiveContentConfigError.message(
+        "The schema cannot be a function for live collections. Please use a schema object instead.",
+        importerFilename
+      )
+    });
+  }
+  return config;
+}
+function defineCollection(config) {
+  const importerFilename = getImporterFilename();
+  if (importerFilename?.includes("live.config")) {
+    throw new AstroError({
+      ...AstroErrorData.LiveContentConfigError,
+      message: AstroErrorData.LiveContentConfigError.message(
+        "Collections in a live config file must use `defineLiveCollection`.",
+        importerFilename
+      )
+    });
+  }
+  if ("loader" in config) {
+    if (config.type && config.type !== CONTENT_LAYER_TYPE) {
+      throw new AstroUserError(
+        `Collections that use the Content Layer API must have a \`loader\` defined and no \`type\` set. Check your collection definitions in ${importerFilename ?? "your content config file"}.`
+      );
+    }
+    config.type = CONTENT_LAYER_TYPE;
+  }
+  if (!config.type) config.type = "content";
+  return config;
+}
+export {
+  defineCollection,
+  defineLiveCollection
+};

package/dist/content/consts.d.ts

@@ -24,3 +24,4 @@ export declare const MODULES_IMPORTS_FILE = "content-modules.mjs";
 export declare const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
 export declare const COLLECTIONS_DIR = "collections/";
 export declare const CONTENT_LAYER_TYPE = "content_layer";
+export declare const LIVE_CONTENT_TYPE = "live";

package/dist/content/consts.js

@@ -31,6 +31,7 @@ const MODULES_IMPORTS_FILE = "content-modules.mjs";
 const COLLECTIONS_MANIFEST_FILE = "collections/collections.json";
 const COLLECTIONS_DIR = "collections/";
 const CONTENT_LAYER_TYPE = "content_layer";
+const LIVE_CONTENT_TYPE = "live";
 export {
   ASSET_IMPORTS_FILE,
   ASSET_IMPORTS_RESOLVED_STUB_ID,
@@ -50,6 +51,7 @@ export {
   DEFERRED_MODULE,
   IMAGE_IMPORT_PREFIX,
   LINKS_PLACEHOLDER,
+  LIVE_CONTENT_TYPE,
   MODULES_IMPORTS_FILE,
   MODULES_MJS_ID,
   MODULES_MJS_VIRTUAL_ID,

package/dist/content/content-layer.js

@@ -164,7 +164,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.9.3") {
+    if (previousAstroVersion && previousAstroVersion !== "5.10.0") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -172,8 +172,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.9.3") {
-      await this.#store.metaStore().set("astro-version", "5.9.3");
+    if ("5.10.0") {
+      await this.#store.metaStore().set("astro-version", "5.10.0");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);

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

@@ -0,0 +1,20 @@
+import type { ZodError } from 'zod';
+export declare class LiveCollectionError extends Error {
+    readonly collection: string;
+    readonly message: string;
+    readonly cause?: Error | undefined;
+    constructor(collection: string, message: string, cause?: Error | undefined);
+    static is(error: unknown): error is LiveCollectionError;
+}
+export declare class LiveEntryNotFoundError extends LiveCollectionError {
+    constructor(collection: string, entryFilter: string | Record<string, unknown>);
+    static is(error: unknown): error is LiveEntryNotFoundError;
+}
+export declare class LiveCollectionValidationError extends LiveCollectionError {
+    constructor(collection: string, entryId: string, error: ZodError);
+    static is(error: unknown): error is LiveCollectionValidationError;
+}
+export declare class LiveCollectionCacheHintError extends LiveCollectionError {
+    constructor(collection: string, entryId: string | undefined, error: ZodError);
+    static is(error: unknown): error is LiveCollectionCacheHintError;
+}

package/dist/content/loaders/errors.js

@@ -0,0 +1,64 @@
+class LiveCollectionError extends Error {
+  constructor(collection, message, cause) {
+    super(message);
+    this.collection = collection;
+    this.message = message;
+    this.cause = cause;
+    this.name = "LiveCollectionError";
+  }
+  static is(error) {
+    return error instanceof LiveCollectionError;
+  }
+}
+class LiveEntryNotFoundError extends LiveCollectionError {
+  constructor(collection, entryFilter) {
+    super(
+      collection,
+      `Entry ${collection} \u2192 ${typeof entryFilter === "string" ? entryFilter : JSON.stringify(entryFilter)} was not found.`
+    );
+    this.name = "LiveEntryNotFoundError";
+  }
+  static is(error) {
+    return error?.name === "LiveEntryNotFoundError";
+  }
+}
+class LiveCollectionValidationError extends LiveCollectionError {
+  constructor(collection, entryId, error) {
+    super(
+      collection,
+      [
+        `**${collection} \u2192 ${entryId}** data does not match the collection schema.
+`,
+        ...error.errors.map((zodError) => `  **${zodError.path.join(".")}**: ${zodError.message}`),
+        ""
+      ].join("\n")
+    );
+    this.name = "LiveCollectionValidationError";
+  }
+  static is(error) {
+    return error?.name === "LiveCollectionValidationError";
+  }
+}
+class LiveCollectionCacheHintError extends LiveCollectionError {
+  constructor(collection, entryId, error) {
+    super(
+      collection,
+      [
+        `**${String(collection)}${entryId ? ` \u2192 ${String(entryId)}` : ""}** returned an invalid cache hint.
+`,
+        ...error.errors.map((zodError) => `  **${zodError.path.join(".")}**: ${zodError.message}`),
+        ""
+      ].join("\n")
+    );
+    this.name = "LiveCollectionCacheHintError";
+  }
+  static is(error) {
+    return error?.name === "LiveCollectionCacheHintError";
+  }
+}
+export {
+  LiveCollectionCacheHintError,
+  LiveCollectionError,
+  LiveCollectionValidationError,
+  LiveEntryNotFoundError
+};

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

@@ -2,6 +2,7 @@ import type { FSWatcher } from 'vite';
 import type { ZodSchema } from 'zod';
 import type { AstroIntegrationLogger } from '../../core/logger/core.js';
 import type { AstroConfig } from '../../types/public/config.js';
+import type { LiveDataCollection, LiveDataEntry } from '../../types/public/content.js';
 import type { RenderedContent } from '../data-store.js';
 import type { DataStore, MetaStore } from '../mutable-data-store.js';
 export type { DataStore, MetaStore };
@@ -42,3 +43,23 @@ export interface Loader {
     /** Optionally, define the schema of the data. Will be overridden by user-defined schema */
     schema?: ZodSchema | Promise<ZodSchema> | (() => ZodSchema | Promise<ZodSchema>);
 }
+export interface LoadEntryContext<TEntryFilter = never> {
+    filter: TEntryFilter extends never ? {
+        id: string;
+    } : TEntryFilter;
+}
+export interface LoadCollectionContext<TCollectionFilter = unknown> {
+    filter?: TCollectionFilter;
+}
+export interface LiveLoader<TData extends Record<string, any> = Record<string, unknown>, TEntryFilter extends Record<string, any> | never = never, TCollectionFilter extends Record<string, any> | never = never, TError extends Error = Error> {
+    /** Unique name of the loader, e.g. the npm package name */
+    name: string;
+    /** Load a single entry */
+    loadEntry: (context: LoadEntryContext<TEntryFilter>) => Promise<LiveDataEntry<TData> | undefined | {
+        error: TError;
+    }>;
+    /** Load a collection of entries */
+    loadCollection: (context: LoadCollectionContext<TCollectionFilter>) => Promise<LiveDataCollection<TData> | {
+        error: TError;
+    }>;
+}

package/dist/content/runtime.d.ts

@@ -1,24 +1,33 @@
 import type { MarkdownHeading } from '@astrojs/markdown-remark';
 import { z } from 'zod';
 import { type AstroComponentFactory } from '../runtime/server/index.js';
+import type { LiveDataCollectionResult, LiveDataEntryResult } from '../types/public/content.js';
+import { type LIVE_CONTENT_TYPE } from './consts.js';
 import { type DataEntry } from './data-store.js';
+import { LiveCollectionCacheHintError, LiveCollectionError, LiveCollectionValidationError, LiveEntryNotFoundError } from './loaders/errors.js';
+import type { LiveLoader } from './loaders/types.js';
 import type { ContentLookupMap } from './utils.js';
+export { LiveCollectionError, LiveCollectionCacheHintError, LiveEntryNotFoundError, LiveCollectionValidationError, };
 type LazyImport = () => Promise<any>;
 type GlobResult = Record<string, LazyImport>;
 type CollectionToEntryMap = Record<string, GlobResult>;
 type GetEntryImport = (collection: string, lookupId: string) => Promise<LazyImport>;
-export declare function getImporterFilename(): string | null;
-export declare function defineCollection(config: any): any;
+type LiveCollectionConfigMap = Record<string, {
+    loader: LiveLoader;
+    type: typeof LIVE_CONTENT_TYPE;
+    schema?: z.ZodType;
+}>;
 export declare function createCollectionToGlobResultMap({ globResult, contentDir, }: {
     globResult: GlobResult;
     contentDir: string;
 }): CollectionToEntryMap;
-export declare function createGetCollection({ contentCollectionToEntryMap, dataCollectionToEntryMap, getRenderEntryImport, cacheEntriesByCollection, }: {
+export declare function createGetCollection({ contentCollectionToEntryMap, dataCollectionToEntryMap, getRenderEntryImport, cacheEntriesByCollection, liveCollections, }: {
     contentCollectionToEntryMap: CollectionToEntryMap;
     dataCollectionToEntryMap: CollectionToEntryMap;
     getRenderEntryImport: GetEntryImport;
     cacheEntriesByCollection: Map<string, any[]>;
-}): (collection: string, filter?: (entry: any) => unknown) => Promise<any[]>;
+    liveCollections: LiveCollectionConfigMap;
+}): (collection: string, filter?: ((entry: any) => unknown) | Record<string, unknown>) => Promise<any[]>;
 export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImport, collectionNames, getEntry, }: {
     getEntryImport: GetEntryImport;
     getRenderEntryImport: GetEntryImport;
@@ -61,11 +70,12 @@ type EntryLookupObject = {
     collection: string;
     slug: string;
 };
-export declare function createGetEntry({ getEntryImport, getRenderEntryImport, collectionNames, }: {
+export declare function createGetEntry({ getEntryImport, getRenderEntryImport, collectionNames, liveCollections, }: {
     getEntryImport: GetEntryImport;
     getRenderEntryImport: GetEntryImport;
     collectionNames: Set<string>;
-}): (collectionOrLookupObject: string | EntryLookupObject, _lookupId?: string) => Promise<ContentEntryResult | DataEntryResult | undefined>;
+    liveCollections: LiveCollectionConfigMap;
+}): (collectionOrLookupObject: string | EntryLookupObject, lookup?: string | Record<string, unknown>) => Promise<ContentEntryResult | DataEntryResult | undefined>;
 export declare function createGetEntries(getEntry: ReturnType<typeof createGetEntry>): (entries: {
     collection: string;
     id: string;
@@ -73,6 +83,12 @@ export declare function createGetEntries(getEntry: ReturnType<typeof createGetEn
     collection: string;
     slug: string;
 }[]) => Promise<(ContentEntryResult | DataEntryResult | undefined)[]>;
+export declare function createGetLiveCollection({ liveCollections, }: {
+    liveCollections: LiveCollectionConfigMap;
+}): (collection: string, filter?: Record<string, unknown>) => Promise<LiveDataCollectionResult>;
+export declare function createGetLiveEntry({ liveCollections, }: {
+    liveCollections: LiveCollectionConfigMap;
+}): (collection: string, lookup: string | Record<string, unknown>) => Promise<LiveDataEntryResult>;
 type RenderResult = {
     Content: AstroComponentFactory;
     headings: MarkdownHeading[];
@@ -122,4 +138,4 @@ export declare function createReference({ lookupMap }: {
     slug: string;
     collection: string;
 }>;
-export {};
+export declare function defineCollection(config: any): import("./config.js").CollectionConfig<import("./config.js").BaseSchema>;