@content-collections/core 0.13.1 → 0.14.1

package/README.md

@@ -52,7 +52,7 @@ If your framework is not listed, you can still use Content Collections by using
    });
 
    export default defineConfig({
-     collections: [posts],
+     content: [posts],
    });
    ```
 

package/dist/index.d.ts

@@ -1,5 +1,45 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
+//#region src/parser.d.ts
+type ParseFn = (content: string) => Record<string, unknown> | Promise<Record<string, unknown>>;
+type Parser = {
+  hasContent: boolean;
+  parse: ParseFn;
+};
+type PredefinedParsers = typeof parsers;
+type PredefinedParser = keyof typeof parsers;
+type ConfiguredParser = PredefinedParser | Parser;
+declare function parseYaml(content: string): any;
+declare function frontmatterParser(fileContent: string): {
+  content: string;
+};
+declare function frontmatterOnlyParser(fileContent: string): {
+  [key: string]: any;
+};
+declare const parsers: {
+  frontmatter: {
+    hasContent: true;
+    parse: typeof frontmatterParser;
+  };
+  "frontmatter-only": {
+    hasContent: false;
+    parse: typeof frontmatterOnlyParser;
+  };
+  json: {
+    hasContent: false;
+    parse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
+  };
+  yaml: {
+    hasContent: false;
+    parse: typeof parseYaml;
+  };
+};
+type DefineParserResult<TArgument extends Parser | ParseFn> = TArgument extends Function ? {
+  hasContent: false;
+  parse: ParseFn;
+} : TArgument extends infer Parser ? Parser : never;
+declare function defineParser<TArgument extends Parser | ParseFn>(parser: TArgument): DefineParserResult<TArgument>;
+//#endregion
 //#region src/cache.d.ts
 type Options$2 = {
   key: string;
@@ -673,46 +713,6 @@ type GetTypeOfImport<T$1> = T$1 extends Import<infer U> ? U : never;
 declare function createDefaultImport<T$1>(path: string): Import<T$1>;
 declare function createNamedImport<T$1>(name: string, path: string): Import<T$1>;
 //#endregion
-//#region src/parser.d.ts
-type ParseFn = (content: string) => Record<string, unknown> | Promise<Record<string, unknown>>;
-type Parser = {
-  hasContent: boolean;
-  parse: ParseFn;
-};
-type PredefinedParsers = typeof parsers;
-type PredefinedParser = keyof typeof parsers;
-type ConfiguredParser = PredefinedParser | Parser;
-declare function parseYaml(content: string): any;
-declare function frontmatterParser(fileContent: string): {
-  content: string;
-};
-declare function frontmatterOnlyParser(fileContent: string): {
-  [key: string]: any;
-};
-declare const parsers: {
-  frontmatter: {
-    hasContent: true;
-    parse: typeof frontmatterParser;
-  };
-  "frontmatter-only": {
-    hasContent: false;
-    parse: typeof frontmatterOnlyParser;
-  };
-  json: {
-    hasContent: false;
-    parse: (text: string, reviver?: (this: any, key: string, value: any) => any) => any;
-  };
-  yaml: {
-    hasContent: false;
-    parse: typeof parseYaml;
-  };
-};
-type DefineParserResult<TArgument extends Parser | ParseFn> = TArgument extends Function ? {
-  hasContent: false;
-  parse: ParseFn;
-} : TArgument extends infer Parser ? Parser : never;
-declare function defineParser<TArgument extends Parser | ParseFn>(parser: TArgument): DefineParserResult<TArgument>;
-//#endregion
 //#region src/serializer.d.ts
 declare const literalSchema: ZodMiniUnion<readonly [ZodMiniString<string>, ZodMiniNumber<number>, ZodMiniBoolean<boolean>, ZodMiniNull, ZodMiniUndefined, ZodMiniDate<Date>, ZodMiniMap<ZodMiniUnknown, ZodMiniUnknown>, ZodMiniSet<ZodMiniUnknown>, ZodMiniBigInt<bigint>, ZodMiniObject<{
   __cc_import: ZodMiniLiteral<true>;
@@ -753,15 +753,18 @@ type Schema<TParser extends ConfiguredParser, TShape extends TSchemaProp> = GetO
   _meta: Meta;
 };
 type Prettify<T$1> = { [K in keyof T$1]: T$1[K] } & {};
-type GetSchema<TCollection$1 extends AnyCollection> = TCollection$1 extends Collection<any, any, any, infer TSchema, any, any> ? Prettify<TSchema> : never;
+type GetSchema<TSource extends AnyContent> = TSource extends Collection<any, any, any, infer TSchema, any, any> ? Prettify<TSchema> : TSource extends Singleton<any, any, any, infer TSchema, any, any> ? Prettify<TSchema> : never;
 declare const skippedSymbol: unique symbol;
 type SkippedSignal = {
   [skippedSymbol]: true;
   reason?: string;
 };
 type Context<TSchema$1 = unknown> = {
-  documents<TCollection$1 extends AnyCollection>(collection: TCollection$1): Array<GetSchema<TCollection$1>>;
+  documents<TSource extends AnyContent>(source: TSource): Array<GetSchema<TSource>>;
   cache: CacheFn;
+  /**
+   * @deprecated Use `CollectionContext["collection"]` in collection transforms.
+   */
   collection: {
     name: string;
     directory: string;
@@ -769,23 +772,59 @@ type Context<TSchema$1 = unknown> = {
   };
   skip: (reason?: string) => SkippedSignal;
 };
+type CollectionContext<TSchema$1 = unknown> = Context<TSchema$1> & {
+  collection: {
+    name: string;
+    directory: string;
+    documents: () => Promise<Array<TSchema$1>>;
+  };
+};
+type SingletonContext<TSchema$1 = unknown> = Context<TSchema$1> & {
+  singleton: {
+    name: string;
+    filePath: string;
+    directory: string;
+    document: () => Promise<TSchema$1 | undefined>;
+  };
+};
+type ContentType = "collection" | "singleton";
 type CollectionRequest<TName extends string, TShape extends TSchemaProp, TParser, TSchema$1, TTransformResult, TDocument$1> = {
   name: TName;
   parser?: TParser;
   typeName?: string;
   schema: TShape;
-  transform?: (data: TSchema$1, context: Context<TSchema$1>) => TTransformResult;
+  transform?: (data: TSchema$1, context: CollectionContext<TSchema$1>) => TTransformResult;
   directory: string;
   include: string | string[];
   exclude?: string | string[];
   onSuccess?: (documents: Array<TDocument$1>) => void | Promise<void>;
 };
 type Collection<TName extends string, TShape extends TSchemaProp, TParser extends ConfiguredParser, TSchema$1, TTransformResult, TDocument$1> = Omit<CollectionRequest<TName, TShape, TParser, TSchema$1, TTransformResult, TDocument$1>, "schema"> & {
+  type: "collection";
   typeName: string;
   schema: StandardSchemaV1;
   parser: TParser;
 };
 type AnyCollection = Collection<any, TSchemaProp, ConfiguredParser, any, any, any>;
+type SingletonRequest<TName extends string, TShape extends TSchemaProp, TParser, TSchema$1, TTransformResult, TDocument$1> = {
+  name: TName;
+  filePath: string;
+  parser?: TParser;
+  typeName?: string;
+  schema: TShape;
+  optional?: boolean;
+  transform?: (data: TSchema$1, context: SingletonContext<TSchema$1>) => TTransformResult;
+  onSuccess?: (document: TDocument$1 | undefined) => void | Promise<void>;
+};
+type Singleton<TName extends string, TShape extends TSchemaProp, TParser extends ConfiguredParser, TSchema$1, TTransformResult, TDocument$1> = Omit<SingletonRequest<TName, TShape, TParser, TSchema$1, TTransformResult, TDocument$1>, "schema"> & {
+  type: "singleton";
+  typeName: string;
+  schema: StandardSchemaV1;
+  parser: TParser;
+};
+type AnySingleton = Singleton<any, TSchemaProp, ConfiguredParser, any, any, any>;
+type AnyContent = AnyCollection | AnySingleton;
+declare function isSingleton(source: AnyContent): source is AnySingleton;
 declare const InvalidReturnTypeSymbol: unique symbol;
 type InvalidReturnType<TMessage extends string, TObject> = {
   [InvalidReturnTypeSymbol]: TMessage;
@@ -793,13 +832,37 @@ type InvalidReturnType<TMessage extends string, TObject> = {
 };
 type ResolveImports<TTransformResult> = TTransformResult extends Import<any> ? GetTypeOfImport<TTransformResult> : TTransformResult extends Array<infer U> ? Array<ResolveImports<U>> : TTransformResult extends ((...args: any[]) => any) ? TTransformResult : TTransformResult extends object ? { [K in keyof TTransformResult]: ResolveImports<TTransformResult[K]> } : TTransformResult;
 declare function defineCollection<TName extends string, TShape extends TSchemaProp, TParser extends ConfiguredParser = "frontmatter", TSchema$1 = Schema<TParser, TShape>, TTransformResult = never, TDocument$1 = ([TTransformResult] extends [never] ? Schema<TParser, TShape> : Exclude<Awaited<TTransformResult>, SkippedSignal>), TResult = (TDocument$1 extends Serializable ? Collection<TName, TShape, TParser, TSchema$1, TTransformResult, ResolveImports<TDocument$1>> : InvalidReturnType<NotSerializableError, TDocument$1>)>(collection: CollectionRequest<TName, TShape, TParser, TSchema$1, TTransformResult, TDocument$1>): TResult;
+declare function defineSingleton<TName extends string, TShape extends TSchemaProp, TParser extends ConfiguredParser = "frontmatter", TSchema$1 = Schema<TParser, TShape>, TTransformResult = never, TDocument$1 = ([TTransformResult] extends [never] ? Schema<TParser, TShape> : Exclude<Awaited<TTransformResult>, SkippedSignal>), TResult = (TDocument$1 extends Serializable ? Singleton<TName, TShape, TParser, TSchema$1, TTransformResult, ResolveImports<TDocument$1>> : InvalidReturnType<NotSerializableError, TDocument$1>)>(singleton: SingletonRequest<TName, TShape, TParser, TSchema$1, TTransformResult, TDocument$1>): TResult;
 type Cache = "memory" | "file" | "none";
-type Configuration<TCollections extends Array<AnyCollection>> = {
+type ConfigurationWithContent<TCollections extends Array<AnyContent>> = {
+  content: TCollections;
+  /**
+   * @deprecated Use `content` instead.
+   */
+  collections?: TCollections;
+  cache?: Cache;
+};
+type ConfigurationWithCollections<TCollections extends Array<AnyContent>> = {
+  /**
+   * @deprecated Use `content` instead.
+   */
   collections: TCollections;
+  content?: TCollections;
   cache?: Cache;
 };
-type AnyConfiguration = Configuration<Array<AnyCollection>>;
-declare function defineConfig<TConfig extends AnyConfiguration>(config: TConfig): TConfig;
+type Configuration<TCollections extends Array<AnyContent>> = ConfigurationWithContent<TCollections> | ConfigurationWithCollections<TCollections>;
+type AnyConfiguration = Configuration<Array<AnyContent>>;
+declare function defineConfig<TCollections extends Array<AnyContent>>(config: {
+  content: TCollections;
+  cache?: Cache;
+}): ConfigurationWithContent<TCollections>;
+declare function defineConfig<TCollections extends Array<AnyContent>>(config: {
+  /**
+   * @deprecated Use `content` instead.
+   */
+  collections: TCollections;
+  cache?: Cache;
+}): ConfigurationWithCollections<TCollections>;
 //#endregion
 //#region src/types.d.ts
 type Modification = "create" | "update" | "delete";
@@ -813,9 +876,14 @@ type CollectionFile = {
   };
   path: string;
 };
-type CollectionByName<TConfiguration extends AnyConfiguration> = { [TCollection in TConfiguration["collections"][number] as TCollection["name"]]: TCollection };
-type GetDocument<TCollection$1 extends AnyCollection> = TCollection$1 extends Collection<any, any, any, any, any, infer TDocument> ? TDocument : never;
-type GetTypeByName<TConfiguration extends AnyConfiguration, TName extends keyof CollectionByName<TConfiguration>, TCollection$1 = CollectionByName<TConfiguration>[TName]> = TCollection$1 extends AnyCollection ? GetDocument<TCollection$1> : never;
+type ConfigurationSources<TConfiguration extends AnyConfiguration> = TConfiguration extends {
+  content: infer TSources extends Array<AnyContent>;
+} ? TSources : TConfiguration extends {
+  collections: infer TSources extends Array<AnyContent>;
+} ? TSources : never;
+type CollectionByName<TConfiguration extends AnyConfiguration> = { [TCollection in ConfigurationSources<TConfiguration>[number] as TCollection["name"]]: TCollection };
+type GetDocument<TSource extends AnyContent> = TSource extends Collection<any, any, any, any, any, infer TDocument> ? TDocument : TSource extends Singleton<any, any, any, any, any, infer TDocument> ? TDocument : never;
+type GetTypeByName<TConfiguration extends AnyConfiguration, TName extends keyof CollectionByName<TConfiguration>, TCollection$1 = CollectionByName<TConfiguration>[TName]> = TCollection$1 extends AnyContent ? GetDocument<TCollection$1> : never;
 //#endregion
 //#region src/collector.d.ts
 type CollectorEvents = {
@@ -837,21 +905,24 @@ declare class CollectError extends Error {
 //#region src/transformer.d.ts
 type TransformerEvents = {
   "transformer:validation-error": {
-    collection: AnyCollection;
+    collection: AnyContent;
     file: CollectionFile;
     error: TransformError;
   };
+  "transformer:singleton-warning": {
+    collection: AnyContent;
+  };
   "transformer:result-error": {
-    collection: AnyCollection;
+    collection: AnyContent;
     document: any;
     error: TransformError;
   };
   "transformer:error": {
-    collection: AnyCollection;
+    collection: AnyContent;
     error: TransformError;
   };
   "transformer:document-skipped": {
-    collection: AnyCollection;
+    collection: AnyContent;
     filePath: string;
     reason?: string;
   };
@@ -881,7 +952,9 @@ type WatchableCollection = {
 };
 type WatcherConfiguration = {
   inputPaths: Array<string>;
-  collections: Array<WatchableCollection>;
+  collections: Array<WatchableCollection | {
+    filePath: string;
+  }>;
 };
 declare function createWatcher(emitter: Emitter, baseDirectory: string, configuration: WatcherConfiguration, sync: SyncFn): Promise<{
   unsubscribe: () => Promise<void>;
@@ -920,7 +993,7 @@ declare class ConfigurationError extends Error {
   constructor(type: ErrorType, message: string);
 }
 type InternalConfiguration = {
-  collections: Array<AnyCollection>;
+  collections: Array<AnyContent>;
   path: string;
   inputPaths: Array<string>;
   checksum: string;
@@ -979,7 +1052,7 @@ declare function createBuilder(configurationPath: string, options?: Options$1, e
     unsubscribe: () => Promise<void>;
   }>;
   on: {
-    <TKey extends "builder:start" | "builder:end" | "builder:created" | "watcher:file-changed" | "watcher:config-changed" | "watcher:config-reload-error" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "transformer:document-skipped" | "watcher:subscribe-error" | "watcher:subscribed" | "watcher:unsubscribed">(key: TKey, listener: (event: Events[TKey]) => void): void;
+    <TKey extends "builder:start" | "builder:end" | "builder:created" | "watcher:file-changed" | "watcher:config-changed" | "watcher:config-reload-error" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:singleton-warning" | "transformer:result-error" | "transformer:error" | "transformer:document-skipped" | "watcher:subscribe-error" | "watcher:subscribed" | "watcher:unsubscribed">(key: TKey, listener: (event: Events[TKey]) => void): void;
     <TKey extends "_error" | "_all">(key: TKey, listener: (event: SystemEvents[TKey]) => void): void;
   };
 }>;
@@ -990,7 +1063,7 @@ declare function createInternalBuilder(initialConfiguration: InternalConfigurati
     unsubscribe: () => Promise<void>;
   }>;
   on: {
-    <TKey extends "builder:start" | "builder:end" | "builder:created" | "watcher:file-changed" | "watcher:config-changed" | "watcher:config-reload-error" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:result-error" | "transformer:error" | "transformer:document-skipped" | "watcher:subscribe-error" | "watcher:subscribed" | "watcher:unsubscribed">(key: TKey, listener: (event: Events[TKey]) => void): void;
+    <TKey extends "builder:start" | "builder:end" | "builder:created" | "watcher:file-changed" | "watcher:config-changed" | "watcher:config-reload-error" | "collector:read-error" | "collector:parse-error" | "transformer:validation-error" | "transformer:singleton-warning" | "transformer:result-error" | "transformer:error" | "transformer:document-skipped" | "watcher:subscribe-error" | "watcher:subscribed" | "watcher:unsubscribed">(key: TKey, listener: (event: Events[TKey]) => void): void;
     <TKey extends "_error" | "_all">(key: TKey, listener: (event: SystemEvents[TKey]) => void): void;
   };
 }>;
@@ -999,8 +1072,9 @@ type Builder = Awaited<ReturnType<typeof createBuilder>>;
 //#region src/features.d.ts
 declare const deprecations: {
   implicitContentProperty: string;
+  collectionsConfigProperty: string;
 };
 type Deprecation = keyof typeof deprecations;
 declare function suppressDeprecatedWarnings(...suppresses: Array<Deprecation | "all">): void;
 //#endregion
-export { AnyCollection, AnyConfiguration, Builder, BuilderEvents, CollectError, Collection, CollectionRequest, Configuration, ConfigurationError, ConfigurationReloadError, Context, type Document, type GetTypeByName, Meta, type Modification, Schema, SkippedSignal, TransformError, type Watcher, createBuilder, createDefaultImport, createInternalBuilder, createNamedImport, defineCollection, defineConfig, defineParser, skippedSymbol, suppressDeprecatedWarnings };
+export { AnyCollection, AnyConfiguration, AnyContent, AnySingleton, Builder, BuilderEvents, CollectError, Collection, CollectionContext, CollectionRequest, Configuration, ConfigurationError, ConfigurationReloadError, ConfigurationWithCollections, ConfigurationWithContent, ContentType, Context, type Document, type GetTypeByName, Meta, type Modification, Schema, Singleton, SingletonContext, SingletonRequest, SkippedSignal, TransformError, type Watcher, createBuilder, createDefaultImport, createInternalBuilder, createNamedImport, defineCollection, defineConfig, defineParser, defineSingleton, isSingleton, skippedSymbol, suppressDeprecatedWarnings };

package/dist/index.js

@@ -4,6 +4,10 @@ import { existsSync } from "node:fs";
 import fs, { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { readFile as readFile$1 } from "fs/promises";
 import { glob } from "tinyglobby";
+import fs2 from "fs";
+import path2 from "path";
+import { build } from "esbuild";
+import { createRequire } from "module";
 import matter from "gray-matter";
 import { parse, stringify } from "yaml";
 import camelcase from "camelcase";
@@ -11,10 +15,6 @@ import pluralize from "pluralize";
 import picomatch from "picomatch";
 import os from "node:os";
 import pLimit from "p-limit";
-import fs2 from "fs";
-import path2 from "path";
-import { build } from "esbuild";
-import { createRequire } from "module";
 import serializeJs from "serialize-javascript";
 import { EventEmitter } from "node:events";
 import chokidar from "chokidar";
@@ -23,10 +23,8 @@ import chokidar from "chokidar";
 function createKey(config$1, input, key) {
 	return createHash("sha256").update(config$1).update(JSON.stringify(input)).update(key).digest("hex");
 }
-async function createCacheDirectory(directory) {
-	const cacheDirectory = path.join(directory, ".content-collections", "cache");
+async function createCacheDirectory(cacheDirectory) {
 	if (!existsSync(cacheDirectory)) await mkdir(cacheDirectory, { recursive: true });
-	return cacheDirectory;
 }
 function fileName(input) {
 	return input.replace(/[^a-z0-9]/gi, "_").toLowerCase();
@@ -39,8 +37,8 @@ async function readMapping(mappingPath) {
 	}
 	return {};
 }
-async function createCacheManager(baseDirectory, configChecksum) {
-	const cacheDirectory = await createCacheDirectory(baseDirectory);
+async function createCacheManager(cacheDirectory, configChecksum) {
+	await createCacheDirectory(cacheDirectory);
 	const mappingPath = join(cacheDirectory, "mapping.json");
 	const mapping = await readMapping(mappingPath);
 	async function flush() {
@@ -94,215 +92,6 @@ async function createCacheManager(baseDirectory, configChecksum) {
 	};
 }
 
-//#endregion
-//#region src/parser.ts
-function parseYaml(content) {
-	return parse(content.trim());
-}
-function frontmatter(fileContent) {
-	return matter(fileContent, { engines: { yaml: {
-		parse: parseYaml,
-		stringify
-	} } });
-}
-function frontmatterParser(fileContent) {
-	const { data, content } = frontmatter(fileContent);
-	return {
-		...data,
-		content: content.trim()
-	};
-}
-function frontmatterOnlyParser(fileContent) {
-	const { data } = frontmatter(fileContent);
-	return data;
-}
-const parsers = {
-	frontmatter: {
-		hasContent: true,
-		parse: frontmatterParser
-	},
-	["frontmatter-only"]: {
-		hasContent: false,
-		parse: frontmatterOnlyParser
-	},
-	json: {
-		hasContent: false,
-		parse: JSON.parse
-	},
-	yaml: {
-		hasContent: false,
-		parse: parseYaml
-	}
-};
-function getParser(configuredParser) {
-	if (typeof configuredParser === "string") return parsers[configuredParser];
-	return configuredParser;
-}
-function defineParser(parser) {
-	if (typeof parser === "function") return {
-		hasContent: false,
-		parse: parser
-	};
-	return parser;
-}
-function isValidParser(parser) {
-	if (typeof parser === "string") return parser in parsers;
-	return "hasContent" in parser && typeof parser.parse === "function";
-}
-
-//#endregion
-//#region src/utils.ts
-function generateTypeName(name) {
-	return camelcase(pluralize.singular(name), { pascalCase: true });
-}
-function isDefined(value) {
-	return value !== void 0 && value !== null;
-}
-function orderByPath(a, b) {
-	return a.path.localeCompare(b.path);
-}
-function removeChildPaths(paths) {
-	return Array.from(new Set(paths.filter((path$1) => {
-		return !paths.some((otherPath) => {
-			if (path$1 === otherPath) return false;
-			return path$1.startsWith(otherPath);
-		});
-	})));
-}
-function posixToNativePath(pathName) {
-	if (path.sep !== path.posix.sep) return pathName.replaceAll(path.posix.sep, path.sep);
-	return pathName;
-}
-function toError(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-
-//#endregion
-//#region src/collector.ts
-var CollectError = class extends Error {
-	type;
-	constructor(type, message) {
-		super(message);
-		this.type = type;
-	}
-};
-function createCollector(emitter, baseDirectory = ".") {
-	async function read(filePath) {
-		try {
-			return await readFile$1(filePath, "utf-8");
-		} catch (error) {
-			emitter.emit("collector:read-error", {
-				filePath,
-				error: new CollectError("Read", String(error))
-			});
-			return null;
-		}
-	}
-	async function collectFile(collection, filePath) {
-		const file = await read(path.join(baseDirectory, collection.directory, filePath));
-		if (!file) return null;
-		try {
-			return {
-				data: await getParser(collection.parser).parse(file),
-				path: filePath
-			};
-		} catch (error) {
-			emitter.emit("collector:parse-error", {
-				filePath: path.join(collection.directory, filePath),
-				error: new CollectError("Parse", String(error))
-			});
-			return null;
-		}
-	}
-	function createIgnorePattern(collection) {
-		if (collection.exclude) if (Array.isArray(collection.exclude)) return collection.exclude;
-		else return [collection.exclude];
-	}
-	async function resolveCollection(collection) {
-		const collectionDirectory = path.join(baseDirectory, collection.directory);
-		const promises = (await glob(Array.isArray(collection.include) ? collection.include : [collection.include], {
-			cwd: collectionDirectory,
-			onlyFiles: true,
-			absolute: false,
-			ignore: createIgnorePattern(collection)
-		})).map((filePath) => collectFile(collection, posixToNativePath(filePath)));
-		const files = await Promise.all(promises);
-		return {
-			...collection,
-			files: files.filter(isDefined).sort(orderByPath)
-		};
-	}
-	async function collect(unresolvedCollections) {
-		const promises = unresolvedCollections.map((collection) => resolveCollection(collection));
-		return await Promise.all(promises);
-	}
-	return {
-		collect,
-		collectFile
-	};
-}
-
-//#endregion
-//#region src/synchronizer.ts
-function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
-	function findCollections(filePath) {
-		const resolvedFilePath = path.resolve(filePath);
-		return collections.filter((collection) => {
-			return resolvedFilePath.startsWith(path.resolve(baseDirectory, collection.directory));
-		});
-	}
-	function createRelativePath(collectionPath, filePath) {
-		const resolvedCollectionPath = path.resolve(baseDirectory, collectionPath);
-		let relativePath = path.resolve(filePath).slice(resolvedCollectionPath.length);
-		if (relativePath.startsWith(path.sep)) relativePath = relativePath.slice(path.sep.length);
-		return relativePath;
-	}
-	function resolve$1(filePath) {
-		return findCollections(filePath).map((collection) => {
-			return {
-				collection,
-				relativePath: createRelativePath(collection.directory, filePath)
-			};
-		}).filter(({ collection, relativePath }) => {
-			return picomatch.isMatch(relativePath, collection.include, {
-				windows: process.platform === "win32",
-				ignore: collection.exclude
-			});
-		});
-	}
-	function deleted(filePath) {
-		const resolvedCollections = resolve$1(filePath);
-		if (resolvedCollections.length === 0) return false;
-		let changed$1 = false;
-		for (const { collection, relativePath } of resolvedCollections) {
-			const index = collection.files.findIndex((file) => file.path === relativePath);
-			if (collection.files.splice(index, 1).length > 0) changed$1 = true;
-		}
-		return changed$1;
-	}
-	async function changed(filePath) {
-		const resolvedCollections = resolve$1(filePath);
-		if (resolvedCollections.length === 0) return false;
-		let changed$1 = false;
-		for (const { collection, relativePath } of resolvedCollections) {
-			const index = collection.files.findIndex((file$1) => file$1.path === relativePath);
-			const file = await readCollectionFile(collection, relativePath);
-			if (file) {
-				changed$1 = true;
-				if (index === -1) {
-					collection.files.push(file);
-					collection.files.sort(orderByPath);
-				} else collection.files[index] = file;
-			}
-		}
-		return changed$1;
-	}
-	return {
-		deleted,
-		changed
-	};
-}
-
 //#endregion
 //#region ../../node_modules/.pnpm/load-tsconfig@0.2.5/node_modules/load-tsconfig/dist/index.js
 var singleComment = Symbol("singleComment");
@@ -522,6 +311,46 @@ async function compile(configurationPath, outfile) {
 	return Object.keys(result.metafile.inputs);
 }
 
+//#endregion
+//#region src/features.ts
+const deprecations = {
+	implicitContentProperty: `The implicit addition of a content property to schemas is deprecated.
+Please add an explicit content property to your schema.
+For more information, see:
+https://content-collections.dev/docs/deprecations/implicit-content-property`,
+	collectionsConfigProperty: `The configuration property "collections" is deprecated.
+Please use "content" instead.
+For more information, see:
+https://content-collections.dev/docs/deprecations/config-collections-property`
+};
+const _suppressDeprecatedWarnings = [];
+function suppressDeprecatedWarnings(...suppresses) {
+	for (const deprecation of suppresses) if (deprecation === "all") {
+		_suppressDeprecatedWarnings.push(...Object.keys(deprecations));
+		return;
+	} else _suppressDeprecatedWarnings.push(deprecation);
+}
+function deprecated(deprecation, logger = console.warn) {
+	if (_suppressDeprecatedWarnings.includes(deprecation)) return;
+	logger(`[CC DEPRECATED]: ${deprecations[deprecation]}`);
+}
+const retiredFeatures = { legacySchema: `The use of a function as a schema is retired.
+Please use a StandardSchema compliant library directly.
+For more information, see:
+https://content-collections.dev/docs/deprecations/schema-as-function` };
+var RetiredFeatureError = class RetiredFeatureError extends Error {
+	feature;
+	constructor(feature) {
+		super(`This feature has been removed:\n${retiredFeatures[feature]}`);
+		this.feature = feature;
+		this.name = "RetiredFeatureError";
+		Object.setPrototypeOf(this, RetiredFeatureError.prototype);
+	}
+};
+function retired(feature) {
+	throw new RetiredFeatureError(feature);
+}
+
 //#endregion
 //#region src/configurationReader.ts
 var ConfigurationError = class extends Error {
@@ -531,83 +360,160 @@ var ConfigurationError = class extends Error {
 		this.type = type;
 	}
 };
-const defaultConfigName = "content-collection-config.mjs";
-function resolveCacheDir(config$1, options) {
-	if (options.cacheDir) return options.cacheDir;
-	return path.join(path.dirname(config$1), ".content-collections", "cache");
+const defaultConfigName = "content-collection-config.mjs";
+function resolveCacheDir$1(config$1, options) {
+	if (options.cacheDir) return options.cacheDir;
+	return path.join(path.dirname(config$1), ".content-collections", "cache");
+}
+function createConfigurationReader() {
+	return async (configurationPath, options = { configName: defaultConfigName }) => {
+		if (!existsSync(configurationPath)) throw new ConfigurationError("Read", `configuration file ${configurationPath} does not exist`);
+		const cacheDir = resolveCacheDir$1(configurationPath, options);
+		await fs.mkdir(cacheDir, { recursive: true });
+		const outfile = path.join(cacheDir, options.configName);
+		try {
+			const configurationPaths = await compile(configurationPath, outfile);
+			const { content, collections,...rest } = (await import(`file://${path.resolve(outfile)}?x=${Date.now()}`)).default;
+			if (!content && collections) deprecated("collectionsConfigProperty");
+			const hash = createHash("sha256");
+			hash.update(await fs.readFile(outfile, "utf-8"));
+			const checksum = hash.digest("hex");
+			return {
+				...rest,
+				collections: content ?? collections ?? [],
+				path: configurationPath,
+				inputPaths: configurationPaths.map((p) => path.resolve(p)),
+				generateTypes: true,
+				checksum
+			};
+		} catch (error) {
+			throw new ConfigurationError("Compile", `configuration file ${configurationPath} is invalid: ${error}`);
+		}
+	};
+}
+
+//#endregion
+//#region src/parser.ts
+function parseYaml(content) {
+	return parse(content.trim());
+}
+function frontmatter(fileContent) {
+	return matter(fileContent, { engines: { yaml: {
+		parse: parseYaml,
+		stringify
+	} } });
+}
+function frontmatterParser(fileContent) {
+	const { data, content } = frontmatter(fileContent);
+	return {
+		...data,
+		content: content.trim()
+	};
+}
+function frontmatterOnlyParser(fileContent) {
+	const { data } = frontmatter(fileContent);
+	return data;
+}
+const parsers = {
+	frontmatter: {
+		hasContent: true,
+		parse: frontmatterParser
+	},
+	["frontmatter-only"]: {
+		hasContent: false,
+		parse: frontmatterOnlyParser
+	},
+	json: {
+		hasContent: false,
+		parse: JSON.parse
+	},
+	yaml: {
+		hasContent: false,
+		parse: parseYaml
+	}
+};
+function getParser(configuredParser) {
+	if (typeof configuredParser === "string") return parsers[configuredParser];
+	return configuredParser;
 }
-function createConfigurationReader() {
-	return async (configurationPath, options = { configName: defaultConfigName }) => {
-		if (!existsSync(configurationPath)) throw new ConfigurationError("Read", `configuration file ${configurationPath} does not exist`);
-		const cacheDir = resolveCacheDir(configurationPath, options);
-		await fs.mkdir(cacheDir, { recursive: true });
-		const outfile = path.join(cacheDir, options.configName);
-		try {
-			const configurationPaths = await compile(configurationPath, outfile);
-			const module = await import(`file://${path.resolve(outfile)}?x=${Date.now()}`);
-			const hash = createHash("sha256");
-			hash.update(await fs.readFile(outfile, "utf-8"));
-			const checksum = hash.digest("hex");
-			return {
-				...module.default,
-				path: configurationPath,
-				inputPaths: configurationPaths.map((p) => path.resolve(p)),
-				generateTypes: true,
-				checksum
-			};
-		} catch (error) {
-			throw new ConfigurationError("Compile", `configuration file ${configurationPath} is invalid: ${error}`);
-		}
+function defineParser(parser) {
+	if (typeof parser === "function") return {
+		hasContent: false,
+		parse: parser
 	};
+	return parser;
+}
+function isValidParser(parser) {
+	if (typeof parser === "string") return parser in parsers;
+	return "hasContent" in parser && typeof parser.parse === "function";
 }
 
 //#endregion
-//#region src/features.ts
-const deprecations = { implicitContentProperty: `The implicit addition of a content property to schemas is deprecated.
-Please add an explicit content property to your schema.
-For more information, see:
-https://content-collections.dev/docs/deprecations/implicit-content-property` };
-const _suppressDeprecatedWarnings = [];
-function suppressDeprecatedWarnings(...suppresses) {
-	for (const deprecation of suppresses) if (deprecation === "all") {
-		_suppressDeprecatedWarnings.push(...Object.keys(deprecations));
-		return;
-	} else _suppressDeprecatedWarnings.push(deprecation);
+//#region src/utils.ts
+function generateTypeName(name) {
+	return camelcase(pluralize.singular(name), { pascalCase: true });
 }
-function deprecated(deprecation, logger = console.warn) {
-	if (_suppressDeprecatedWarnings.includes(deprecation)) return;
-	logger(`[CC DEPRECATED]: ${deprecations[deprecation]}`);
+function generateArrayConstName(name) {
+	return "all" + pluralize(name.charAt(0).toUpperCase() + name.slice(1));
 }
-const retiredFeatures = { legacySchema: `The use of a function as a schema is retired.
-Please use a StandardSchema compliant library directly.
-For more information, see:
-https://content-collections.dev/docs/deprecations/schema-as-function` };
-var RetiredFeatureError = class RetiredFeatureError extends Error {
-	feature;
-	constructor(feature) {
-		super(`This feature has been removed:\n${retiredFeatures[feature]}`);
-		this.feature = feature;
-		this.name = "RetiredFeatureError";
-		Object.setPrototypeOf(this, RetiredFeatureError.prototype);
-	}
-};
-function retired(feature) {
-	throw new RetiredFeatureError(feature);
+function generateSingletonConstName(typeName) {
+	return camelcase(typeName, { pascalCase: false });
+}
+function isDefined(value) {
+	return value !== void 0 && value !== null;
+}
+function orderByPath(a, b) {
+	return a.path.localeCompare(b.path);
+}
+function removeChildPaths(paths) {
+	return Array.from(new Set(paths.filter((path$1) => {
+		return !paths.some((otherPath) => {
+			if (path$1 === otherPath) return false;
+			return path$1.startsWith(otherPath);
+		});
+	})));
+}
+function posixToNativePath(pathName) {
+	if (path.sep !== path.posix.sep) return pathName.replaceAll(path.posix.sep, path.sep);
+	return pathName;
+}
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
 }
 
 //#endregion
 //#region src/config.ts
 const skippedSymbol = Symbol("skipped");
+function isSingleton(source) {
+	return source.type === "singleton";
+}
 function defineCollection(collection) {
 	let typeName = collection.typeName;
 	if (!typeName) typeName = generateTypeName(collection.name);
 	let parser = collection.parser;
 	if (!parser) parser = "frontmatter";
-	else if (!isValidParser(parser)) throw new ConfigurationError("Read", `Parser ${parser} is not valid a parser`);
+	else if (!isValidParser(parser)) throw new ConfigurationError("Read", `Parser ${parser} is not a valid parser`);
 	let schema$1 = collection.schema;
 	if (!schema$1["~standard"]) retired("legacySchema");
 	return {
 		...collection,
+		type: "collection",
+		typeName,
+		parser,
+		schema: schema$1
+	};
+}
+function defineSingleton(singleton) {
+	let typeName = singleton.typeName;
+	if (!typeName) typeName = generateTypeName(singleton.name);
+	let parser = singleton.parser;
+	if (!parser) parser = "frontmatter";
+	else if (!isValidParser(parser)) throw new ConfigurationError("Read", `Parser ${parser} is not a valid parser`);
+	let schema$1 = singleton.schema;
+	if (!schema$1["~standard"]) retired("legacySchema");
+	return {
+		...singleton,
+		type: "singleton",
 		typeName,
 		parser,
 		schema: schema$1
@@ -617,6 +523,175 @@ function defineConfig(config$1) {
 	return config$1;
 }
 
+//#endregion
+//#region src/collector.ts
+var CollectError = class extends Error {
+	type;
+	constructor(type, message) {
+		super(message);
+		this.type = type;
+	}
+};
+function createCollector(emitter, baseDirectory = ".") {
+	async function read(filePath) {
+		try {
+			return await readFile$1(filePath, "utf-8");
+		} catch (error) {
+			emitter.emit("collector:read-error", {
+				filePath,
+				error: new CollectError("Read", String(error))
+			});
+			return null;
+		}
+	}
+	async function collectCollectionFile(collection, filePath) {
+		const file = await read(path.join(baseDirectory, collection.directory, filePath));
+		if (!file) return null;
+		try {
+			return {
+				data: await getParser(collection.parser).parse(file),
+				path: filePath
+			};
+		} catch (error) {
+			emitter.emit("collector:parse-error", {
+				filePath: path.join(collection.directory, filePath),
+				error: new CollectError("Parse", String(error))
+			});
+			return null;
+		}
+	}
+	async function collectSingletonFile(singleton) {
+		const file = await read(path.join(baseDirectory, singleton.filePath));
+		if (!file) {
+			if (singleton.optional) return null;
+			throw new CollectError("Read", `Singleton file not found at path: ${singleton.filePath}`);
+		}
+		try {
+			return {
+				data: await getParser(singleton.parser).parse(file),
+				path: path.basename(singleton.filePath)
+			};
+		} catch (error) {
+			emitter.emit("collector:parse-error", {
+				filePath: singleton.filePath,
+				error: new CollectError("Parse", String(error))
+			});
+			return null;
+		}
+	}
+	async function collectFile(source, filePath) {
+		if (isSingleton(source)) return collectSingletonFile(source);
+		return collectCollectionFile(source, filePath);
+	}
+	function createIgnorePattern(collection) {
+		if (collection.exclude) if (Array.isArray(collection.exclude)) return collection.exclude;
+		else return [collection.exclude];
+	}
+	async function resolveCollection(collection) {
+		const collectionDirectory = path.join(baseDirectory, collection.directory);
+		const promises = (await glob(Array.isArray(collection.include) ? collection.include : [collection.include], {
+			cwd: collectionDirectory,
+			onlyFiles: true,
+			absolute: false,
+			ignore: createIgnorePattern(collection)
+		})).map((filePath) => collectCollectionFile(collection, posixToNativePath(filePath)));
+		const files = await Promise.all(promises);
+		return {
+			...collection,
+			files: files.filter(isDefined).sort(orderByPath)
+		};
+	}
+	async function resolveSingleton(singleton) {
+		const file = await collectSingletonFile(singleton);
+		return {
+			...singleton,
+			files: file ? [file] : []
+		};
+	}
+	async function collect(unresolvedCollections) {
+		const promises = unresolvedCollections.map((collection) => {
+			if (isSingleton(collection)) return resolveSingleton(collection);
+			return resolveCollection(collection);
+		});
+		return await Promise.all(promises);
+	}
+	return {
+		collect,
+		collectFile
+	};
+}
+
+//#endregion
+//#region src/synchronizer.ts
+function createSynchronizer(readCollectionFile, collections, baseDirectory = ".") {
+	function findCollections(filePath) {
+		const resolvedFilePath = path.resolve(filePath);
+		return collections.filter((collection) => {
+			if (isSingleton(collection)) return resolvedFilePath === path.resolve(baseDirectory, collection.filePath);
+			return resolvedFilePath.startsWith(path.resolve(baseDirectory, collection.directory));
+		});
+	}
+	function createRelativePath(collectionPath, filePath) {
+		const resolvedCollectionPath = path.resolve(baseDirectory, collectionPath);
+		let relativePath = path.resolve(filePath).slice(resolvedCollectionPath.length);
+		if (relativePath.startsWith(path.sep)) relativePath = relativePath.slice(path.sep.length);
+		return relativePath;
+	}
+	function resolve$1(filePath) {
+		return findCollections(filePath).map((collection) => {
+			return {
+				collection,
+				relativePath: isSingleton(collection) ? path.basename(collection.filePath) : createRelativePath(collection.directory, filePath)
+			};
+		}).filter(({ collection, relativePath }) => {
+			if (isSingleton(collection)) return true;
+			return picomatch.isMatch(relativePath, collection.include, {
+				windows: process.platform === "win32",
+				ignore: collection.exclude
+			});
+		});
+	}
+	function deleted(filePath) {
+		const resolvedCollections = resolve$1(filePath);
+		if (resolvedCollections.length === 0) return false;
+		let changed$1 = false;
+		for (const { collection, relativePath } of resolvedCollections) {
+			if (isSingleton(collection)) {
+				if (collection.files.length > 0) {
+					collection.files = [];
+					changed$1 = true;
+				}
+				continue;
+			}
+			const index = collection.files.findIndex((file) => file.path === relativePath);
+			if (collection.files.splice(index, 1).length > 0) changed$1 = true;
+		}
+		return changed$1;
+	}
+	async function changed(filePath) {
+		const resolvedCollections = resolve$1(filePath);
+		if (resolvedCollections.length === 0) return false;
+		let changed$1 = false;
+		for (const { collection, relativePath } of resolvedCollections) {
+			const index = collection.files.findIndex((file$1) => file$1.path === relativePath);
+			const file = await readCollectionFile(collection, relativePath);
+			if (file) {
+				changed$1 = true;
+				if (isSingleton(collection)) collection.files = [file];
+				else if (index === -1) {
+					collection.files.push(file);
+					collection.files.sort(orderByPath);
+				} else collection.files[index] = file;
+			}
+		}
+		return changed$1;
+	}
+	return {
+		deleted,
+		changed
+	};
+}
+
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.1.11/node_modules/zod/v4/core/core.js
 /** A special constant with type `never` */
@@ -1856,17 +1931,24 @@ function createImport(imp, variableName) {
 function serialize(value) {
 	let serializedValue = "";
 	let counter = 0;
-	function handleImports(item) {
-		if (item instanceof Object) Object.entries(item).forEach(([key, value$1]) => {
-			if (isImport(value$1)) {
-				counter++;
-				const variableName = `__v_${counter}`;
-				serializedValue += createImport(value$1, variableName);
-				item[key] = variableName;
-			} else if (value$1 instanceof Object) handleImports(value$1);
+	function handleImports(item, parent, key) {
+		if (!item || typeof item !== "object") return;
+		if (isImport(item)) {
+			counter++;
+			const variableName = `__v_${counter}`;
+			serializedValue += createImport(item, variableName);
+			if (parent !== void 0 && key !== void 0) parent[key] = variableName;
+			return;
+		}
+		if (Array.isArray(item)) {
+			item.forEach((entry, index) => handleImports(entry, item, index));
+			return;
+		}
+		Object.entries(item).forEach(([entryKey, entryValue]) => {
+			handleImports(entryValue, item, entryKey);
 		});
 	}
-	value.forEach(handleImports);
+	handleImports(value);
 	serializedValue += "\n";
 	const js = serializeJs(value, {
 		space: 2,
@@ -1959,35 +2041,46 @@ function createTransformer(emitter, cacheManager) {
 		};
 	}
 	function createContext(collections, collection, cache) {
-		return {
-			documents: (collection$1) => {
-				const resolved = collections.find((c) => c.name === collection$1.name);
-				if (!resolved) throw new TransformError("Configuration", `Collection ${collection$1.name} not found, do you have registered it in your configuration?`);
+		const sourceDirectory = isSingleton(collection) ? dirname(collection.filePath) : collection.directory;
+		const base = {
+			documents: (source) => {
+				const resolved = collections.find((c) => c.name === source.name);
+				if (!resolved) throw new TransformError("Configuration", `Collection ${source.name} not found, do you have registered it in your configuration?`);
 				return resolved.documents.map((doc) => doc.document);
 			},
+			cache: cache.cacheFn,
 			collection: {
 				name: collection.name,
-				directory: collection.directory,
-				documents: async () => {
-					return collection.documents.map((doc) => doc.document);
-				}
+				directory: sourceDirectory,
+				documents: async () => collection.documents.map((doc) => doc.document)
 			},
-			cache: cache.cacheFn,
 			skip: (reason) => ({
 				[skippedSymbol]: true,
 				reason
 			})
 		};
+		if (isSingleton(collection)) return {
+			...base,
+			singleton: {
+				name: collection.name,
+				filePath: collection.filePath,
+				directory: sourceDirectory,
+				document: async () => {
+					return collection.documents[0]?.document;
+				}
+			}
+		};
+		return base;
 	}
 	async function transformDocument(collections, collection, transform, doc) {
 		const cache = cacheManager.cache(collection.name, doc.document._meta.path);
 		const context = createContext(collections, collection, cache);
 		try {
-			const document = await transform(doc.document, context);
+			const document = isSingleton(collection) ? await transform(doc.document, context) : await transform(doc.document, context);
 			await cache.tidyUp();
 			if (isSkippedSignal(document)) emitter.emit("transformer:document-skipped", {
 				collection,
-				filePath: join(collection.directory, doc.document._meta.filePath),
+				filePath: join(isSingleton(collection) ? dirname(collection.filePath) : collection.directory, doc.document._meta.filePath),
 				reason: document.reason
 			});
 			else return {
@@ -2009,7 +2102,8 @@ function createTransformer(emitter, cacheManager) {
 		const transform = collection.transform;
 		if (transform) {
 			const limit = pLimit(os.cpus().length);
-			const docs = collection.documents.map((doc) => limit(() => transformDocument(collections, collection, transform, doc)));
+			const typedTransform = transform;
+			const docs = collection.documents.map((doc) => limit(() => transformDocument(collections, collection, typedTransform, doc)));
 			const transformed = await Promise.all(docs);
 			await cacheManager.flush();
 			return transformed.filter(isDefined);
@@ -2032,29 +2126,33 @@ function createTransformer(emitter, cacheManager) {
 	return async (untransformedCollections) => {
 		const promises = untransformedCollections.map((collection) => parseCollection(collection));
 		const collections = await Promise.all(promises);
-		for (const collection of collections) collection.documents = await validateDocuments(collection, await transformCollection(collections, collection));
+		for (const collection of collections) {
+			collection.documents = await validateDocuments(collection, await transformCollection(collections, collection));
+			if (isSingleton(collection)) {
+				if (collection.documents.length === 0) emitter.emit("transformer:singleton-warning", { collection });
+			}
+		}
 		return collections;
 	};
 }
 
 //#endregion
 //#region src/writer.ts
-function createArrayConstName(name) {
-	return "all" + pluralize(name.charAt(0).toUpperCase() + name.slice(1));
-}
 async function createDataFile(directory, collection) {
-	const dataPath = path.join(directory, `${createArrayConstName(collection.name)}.${extension}`);
-	await fs.writeFile(dataPath, serialize(collection.documents.map((doc) => doc.document)));
+	const constName = isSingleton(collection) ? generateSingletonConstName(collection.typeName) : generateArrayConstName(collection.name);
+	const dataPath = path.join(directory, `${constName}.${extension}`);
+	const value = isSingleton(collection) ? collection.documents[0]?.document : collection.documents.map((doc) => doc.document);
+	await fs.writeFile(dataPath, serialize(value));
 }
 function createDataFiles(directory, collections) {
 	return Promise.all(collections.map((collection) => createDataFile(directory, collection)));
 }
 async function createJavaScriptFile(directory, configuration) {
-	const collections = configuration.collections.map(({ name }) => createArrayConstName(name));
+	const exports = configuration.collections.map((collection) => isSingleton(collection) ? generateSingletonConstName(collection.typeName) : generateArrayConstName(collection.name));
 	let content = `// generated by content-collections at ${/* @__PURE__ */ new Date()}\n\n`;
-	for (const name of collections) content += `import ${name} from "./${name}.${extension}";\n`;
+	for (const name of exports) content += `import ${name} from "./${name}.${extension}";\n`;
 	content += "\n";
-	content += "export { " + collections.join(", ") + " };\n";
+	content += "export { " + exports.join(", ") + " };\n";
 	await fs.writeFile(path.join(directory, "index.js"), content, "utf-8");
 }
 function createImportPath(directory, target) {
@@ -2071,7 +2169,8 @@ import { GetTypeByName } from "@content-collections/core";
 	for (const collection of collections) {
 		content += `\n`;
 		content += `export type ${collection.typeName} = GetTypeByName<typeof configuration, "${collection.name}">;\n`;
-		content += `export declare const ${createArrayConstName(collection.name)}: Array<${collection.typeName}>;\n`;
+		if (isSingleton(collection)) content += `export declare const ${generateSingletonConstName(collection.typeName)}: ${collection.typeName}${collection.optional ? " | undefined" : ""};\n`;
+		else content += `export declare const ${generateArrayConstName(collection.name)}: Array<${collection.typeName}>;\n`;
 	}
 	content += "\n";
 	content += "export {};\n";
@@ -2088,12 +2187,12 @@ async function createWriter(directory) {
 
 //#endregion
 //#region src/build.ts
-async function createBuildContext({ emitter, outputDirectory, baseDirectory, configuration }) {
+async function createBuildContext({ emitter, outputDirectory, cacheDirectory, baseDirectory, configuration }) {
 	const collector = createCollector(emitter, baseDirectory);
 	const [writer, resolved, cacheManager] = await Promise.all([
 		createWriter(outputDirectory),
 		collector.collect(configuration.collections),
-		createCacheManager(baseDirectory, configuration.checksum)
+		createCacheManager(cacheDirectory, configuration.checksum)
 	]);
 	return {
 		resolved,
@@ -2114,7 +2213,7 @@ async function build$1({ emitter, transform, resolved, writer, configuration })
 		writer.createTypeDefinitionFile(configuration),
 		writer.createJavaScriptFile(configuration)
 	]);
-	const pendingOnSuccess = collections.filter((collection) => Boolean(collection.onSuccess)).map((collection) => collection.onSuccess?.(collection.documents.map((doc) => doc.document)));
+	const pendingOnSuccess = collections.filter((collection) => Boolean(collection.onSuccess)).map((collection) => isSingleton(collection) ? collection.onSuccess?.(collection.documents[0]?.document) : collection.onSuccess?.(collection.documents.map((doc) => doc.document)));
 	await Promise.all(pendingOnSuccess.filter(isDefined));
 	const stats = collections.reduce((acc, collection) => {
 		acc.collections++;
@@ -2161,7 +2260,10 @@ function createEmitter() {
 //#endregion
 //#region src/watcher.ts
 async function createWatcher(emitter, baseDirectory, configuration, sync) {
-	const paths = removeChildPaths([...configuration.collections.map((collection) => path.join(baseDirectory, collection.directory)).map((p) => resolve(p)), ...configuration.inputPaths.map((p) => dirname(p))]);
+	const paths = removeChildPaths([...configuration.collections.map((collection) => {
+		const directory = isSingleton(collection) ? path.dirname(collection.filePath) : collection.directory;
+		return path.join(baseDirectory, directory);
+	}).map((p) => resolve(p)), ...configuration.inputPaths.map((p) => dirname(p))]);
 	const watcher = chokidar.watch(paths, {
 		ignored: [/(^|[\/\\])\../, /(^|[\/\\])node_modules([\/\\]|$)/],
 		persistent: true,
@@ -2205,6 +2307,10 @@ function resolveOutputDir(baseDirectory, options) {
 	if (options.outputDir) return options.outputDir;
 	return path.join(baseDirectory, ".content-collections", "generated");
 }
+function resolveCacheDir(baseDirectory, options) {
+	if (options.cacheDir) return options.cacheDir;
+	return path.join(baseDirectory, ".content-collections", "cache");
+}
 var ConfigurationReloadError = class extends Error {
 	constructor(message) {
 		super(message);
@@ -2219,6 +2325,7 @@ async function createInternalBuilder(initialConfiguration, baseDirectory, option
 	const readConfiguration = createConfigurationReader();
 	const configurationPath = initialConfiguration.path;
 	const outputDirectory = resolveOutputDir(baseDirectory, options);
+	const cacheDirectory = resolveCacheDir(baseDirectory, options);
 	emitter.emit("builder:created", {
 		createdAt: Date.now(),
 		configurationPath,
@@ -2230,6 +2337,7 @@ async function createInternalBuilder(initialConfiguration, baseDirectory, option
 		emitter,
 		baseDirectory,
 		outputDirectory,
+		cacheDirectory,
 		configuration
 	});
 	async function sync(modification, filePath) {
@@ -2267,6 +2375,7 @@ async function createInternalBuilder(initialConfiguration, baseDirectory, option
 			emitter,
 			baseDirectory,
 			outputDirectory,
+			cacheDirectory,
 			configuration
 		});
 		if (watcher) watcher = await createWatcher(emitter, baseDirectory, configuration, sync);
@@ -2292,4 +2401,4 @@ async function createInternalBuilder(initialConfiguration, baseDirectory, option
 }
 
 //#endregion
-export { CollectError, ConfigurationError, ConfigurationReloadError, TransformError, createBuilder, createDefaultImport, createInternalBuilder, createNamedImport, defineCollection, defineConfig, defineParser, skippedSymbol, suppressDeprecatedWarnings };
+export { CollectError, ConfigurationError, ConfigurationReloadError, TransformError, createBuilder, createDefaultImport, createInternalBuilder, createNamedImport, defineCollection, defineConfig, defineParser, defineSingleton, isSingleton, skippedSymbol, suppressDeprecatedWarnings };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@content-collections/core",
   "type": "module",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "description": "Core of Content Collections",
   "author": "Sebastian Sdorra <s.sdorra@gmail.com>",
   "license": "MIT",