content-query 0.0.2 → 0.2.0

package/dist/build-Dxz7P1ur.mjs

@@ -0,0 +1,1439 @@
+import { a as builtinLoader, i as validate, n as normalizeSnapshot, o as builtinPath, r as renderedPayload, t as isRecord } from "./validation-D_XdE1pF.mjs";
+import { i as groupDiagnostics, n as contentError, o as withContext, t as ContentError } from "./errors-C2iuBM0G.mjs";
+import { i as detach, l as valuePath, o as encode } from "./values-BbTV4QT-.mjs";
+import { t as assertServerOnly } from "./server-only-CIJUlyL-.mjs";
+import { a as CODEC_VERSION, i as prepareRelationships, n as createRuntime, r as isRelationship } from "./content-N1gYshjg.mjs";
+import { t as renderMarkdown } from "./markdown-CHvBBJNa.mjs";
+import { access, link, mkdir, readFile, readdir, realpath, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
+import { realpathSync, renameSync, unwatchFile, watchFile } from "node:fs";
+import { gzipSync } from "node:zlib";
+import { createJiti } from "jiti";
+import { watch } from "chokidar";
+import picomatch from "picomatch";
+//#region src/artifacts/modules.ts
+/** Creates an opaque content-addressed key with an unambiguous serialization boundary. */
+function digest(value) {
+	return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+/** Maps collection names to distinct safe directory names without changing public identities. */
+function directoryName(name) {
+	return /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name) && !/^(?:con|prn|aux|nul|com[0-9]|lpt[0-9])$/i.test(name) ? name : `~${Buffer.from(name).toString("base64url")}`;
+}
+/** Returns a gzip/base64 JavaScript literal only when it saves at least ten percent. */
+function compactJson(source) {
+	const bytes = Buffer.byteLength(source);
+	if (bytes < 4096) return;
+	const compressed = JSON.stringify(gzipSync(source, { level: 1 }).toString("base64"));
+	return compressed.length < bytes * .9 ? compressed : void 0;
+}
+/** Creates portable ESM; build integrations can batch payload sources before a strict bundler runs. */
+async function revisionModules(revision, { payloadChunkBytes = 0 } = {}) {
+	const modules = /* @__PURE__ */ new Map();
+	const manifest = {
+		version: 2,
+		codec: CODEC_VERSION,
+		collections: revision.registry
+	};
+	const imports = [];
+	const names = [];
+	let needsRenderer = false;
+	for (const [name, collection] of Object.entries(revision.collections)) {
+		const directory = `collections/${directoryName(name)}`;
+		const payloads = [];
+		const chunks = [];
+		let batch = [];
+		let batchBytes = 0;
+		/** Retains collision checks for both individual payloads and batched source modules. */
+		function publishPayload(filename, code) {
+			if (modules.has(filename) && modules.get(filename) !== code) throw new Error("Payload hash collision.");
+			modules.set(filename, code);
+		}
+		/** Emits one lazy source module without creating a dynamic-import entry per item. */
+		function flushBatch() {
+			if (!batch.length) return;
+			const source = JSON.stringify(Object.fromEntries(batch));
+			const code = `export default ${compactJson(source) ?? `JSON.parse(${JSON.stringify(source)})`};\n`;
+			const key = digest([name, code]);
+			publishPayload(`${directory}/entries/${key}.js`, code);
+			chunks.push(`{ ids: ${JSON.stringify(batch.map(([id]) => id))}, load: () => import(${JSON.stringify(`./entries/${key}.js`)}) }`);
+			batch = [];
+			batchBytes = 0;
+		}
+		for (const [id, load] of collection.builtins) {
+			const payload = await load();
+			const encoded = encode(payload);
+			needsRenderer ||= payload.markdown !== void 0;
+			if (payloadChunkBytes) {
+				const bytes = Buffer.byteLength(`[${JSON.stringify(id)}]: ${JSON.stringify(encoded)},\n`);
+				if (batchBytes && batchBytes + bytes > payloadChunkBytes) flushBatch();
+				batch.push([id, encoded]);
+				batchBytes += bytes;
+				continue;
+			}
+			const key = digest([
+				name,
+				id,
+				encoded
+			]);
+			publishPayload(`${directory}/entries/${key}.js`, `export default ${JSON.stringify(encoded)};\n`);
+			payloads.push(`[${JSON.stringify(id)}]: () => import(${JSON.stringify(`./entries/${key}.js`)})`);
+		}
+		flushBatch();
+		const recordSource = JSON.stringify(collection.records.map(encode));
+		const compressedRecords = compactJson(recordSource);
+		const helpers = [...chunks.length ? ["createPayloadLoaders"] : [], ...compressedRecords ? ["decodeCompressed"] : []];
+		const loaders = helpers.length ? `import { ${helpers.join(", ")} } from "content-query/internal";\n` : "";
+		const loading = chunks.length ? `createPayloadLoaders([${chunks.join(",\n")}])` : `{ ${payloads.join(",\n")} }`;
+		const code = `${loaders}export default { records: ${compressedRecords ? `decodeCompressed(${compressedRecords})` : recordSource}, builtins: ${loading} };\n`;
+		const index = `index-${digest(code)}.js`;
+		modules.set(`${directory}/${index}`, code);
+		modules.set(`${directory}/index.js`, `export { default } from ${JSON.stringify(`./${index}`)};\n`);
+		const binding = `collection${imports.length}`;
+		imports.push(`import ${binding} from ${JSON.stringify(`./${directory}/${index}`)};`);
+		names.push(`[${JSON.stringify(name)}]: ${binding}`);
+	}
+	modules.set("manifest.js", `export default JSON.parse(${JSON.stringify(JSON.stringify(manifest))});\n`);
+	const renderer = needsRenderer ? `, body => import("content-query/internal/markdown").then(module => module.renderMarkdown(body))` : "";
+	modules.set("server.js", `import { createArtifactRuntime } from "content-query/internal";\n${imports.join("\n")}\nexport const content = createArtifactRuntime(JSON.parse(${JSON.stringify(JSON.stringify(manifest))}), { ${names.join(", ")} }${renderer});\n`);
+	return modules;
+}
+//#endregion
+//#region src/artifacts/declarations.ts
+/** Generates type-only consumer bindings without loading schemas or adding runtime imports. */
+function contentDeclarations(directory, config) {
+	let relative = path.relative(directory, config).replace(/\\/g, "/");
+	if (!relative.startsWith(".")) relative = `./${relative}`;
+	return `type Registry = typeof import(${JSON.stringify(relative)}).collections;\nexport type CollectionKey = keyof Registry & string;\nexport type CollectionData<Name extends CollectionKey> = import("content-query").QueryData<Registry[Name]>;\nexport type Collections = { [Name in CollectionKey]: CollectionData<Name> };\nexport declare const content: import("content-query/runtime").Content<Registry>;\n`;
+}
+/** Declares project-bound virtual server types and the framework-neutral development bridge. */
+function virtualDeclarations(directory, config) {
+	return `declare module "content-query:server" {\n${contentDeclarations(directory, config).replace("export declare const", "export const")}\n}\ndeclare module "content-query:client" {\n  export function onContentUpdate(callback: () => void | Promise<void>): () => void;\n}\n`;
+}
+//#endregion
+//#region src/artifacts/write.ts
+/** Writes changed bytes only, keeping unchanged importer targets stable. */
+async function writeChanged(filename, source, signal) {
+	try {
+		if (await readFile(filename, "utf8") === source) return;
+	} catch {}
+	await mkdir(path.dirname(filename), { recursive: true });
+	const temporary = `${filename}.tmp-${process.pid}-${randomUUID()}`;
+	await writeFile(temporary, source);
+	try {
+		signal?.throwIfAborted();
+		renameSync(temporary, filename);
+	} finally {
+		await rm(temporary, { force: true });
+	}
+}
+/** Checks reusable immutable bytes, retaining corruption diagnostics instead of overwriting them. */
+async function existingImmutable(filename, source) {
+	let existing;
+	try {
+		existing = await readFile(filename, "utf8");
+	} catch (cause) {
+		if (cause && typeof cause === "object" && "code" in cause && cause.code === "ENOENT") return false;
+		throw cause;
+	}
+	if (existing !== source) throw new ContentError({
+		code: "artifact-error",
+		operation: "build",
+		source: filename,
+		message: "An immutable artifact key has conflicting bytes. Regenerate the output directory."
+	});
+	return true;
+}
+/** Publishes into an existing directory without rewriting an earlier revision's immutable bytes. */
+async function writeImmutable(filename, source) {
+	if (await existingImmutable(filename, source)) return;
+	const temporary = `${filename}.tmp-${process.pid}-${randomUUID()}`;
+	await writeFile(temporary, source);
+	try {
+		try {
+			await link(temporary, filename);
+		} catch (cause) {
+			if (!cause || typeof cause !== "object" || !("code" in cause) || cause.code !== "EEXIST") throw cause;
+			if (!await existingImmutable(filename, source)) throw cause;
+		}
+	} finally {
+		await rm(temporary, { force: true });
+	}
+}
+const immutableModule = /\/(?:entries\/[a-f0-9]{64}|index-[a-f0-9]{64})\.js$/;
+/** Lists one directory's entries, treating a missing directory or a file as empty. */
+async function entriesOf(directory) {
+	try {
+		return await readdir(directory);
+	} catch (cause) {
+		const code = cause && typeof cause === "object" && "code" in cause ? cause.code : void 0;
+		if (code === "ENOENT" || code === "ENOTDIR") return [];
+		throw cause;
+	}
+}
+/** Removes a directory only when nothing else remains in it. */
+async function removeIfEmpty(directory) {
+	try {
+		await rmdir(directory);
+	} catch (cause) {
+		const code = cause && typeof cause === "object" && "code" in cause ? cause.code : void 0;
+		if (![
+			"ENOTEMPTY",
+			"EEXIST",
+			"ENOENT",
+			"ENOTDIR"
+		].includes(String(code))) throw cause;
+	}
+}
+/**
+* Deletes generated collection modules the published revision no longer references. Only
+* library-named files are removed, so unrelated files in the output directory survive.
+*/
+async function pruneArtifacts(outDir, modules) {
+	const collections = path.join(outDir, "collections");
+	for (const directory of await entriesOf(collections)) {
+		const owned = path.join(collections, directory);
+		const entries = path.join(owned, "entries");
+		const candidates = [...(await entriesOf(owned)).map((name) => `collections/${directory}/${name}`), ...(await entriesOf(entries)).map((name) => `collections/${directory}/entries/${name}`)];
+		for (const filename of candidates) if ((immutableModule.test(`/${filename}`) || filename.endsWith(`/${directory}/index.js`)) && !modules.has(filename)) await rm(path.join(outDir, filename), { force: true });
+		await removeIfEmpty(entries);
+		await removeIfEmpty(owned);
+	}
+}
+/** Stages modules with bounded I/O before atomically switching the public server entry. */
+async function writeArtifacts(revision, outDir, config, { signal, prune = false } = {}) {
+	const modules = await revisionModules(revision);
+	await writeChanged(path.join(outDir, "package.json"), "{\"type\":\"module\",\"private\":true}\n");
+	await writeChanged(path.join(outDir, "server.d.ts"), contentDeclarations(outDir, config));
+	await writeChanged(path.join(outDir, "types.d.ts"), virtualDeclarations(outDir, config));
+	const staged = [...modules].filter(([filename]) => filename !== "server.js");
+	const directories = new Set(staged.map(([filename]) => path.dirname(path.join(outDir, filename))));
+	await Promise.all([...directories].map(async (directory) => mkdir(directory, { recursive: true })));
+	const pending = staged.values();
+	const failure = (await Promise.allSettled(Array.from({ length: Math.min(16, staged.length) }, async () => {
+		for (const [filename, code] of pending) {
+			signal?.throwIfAborted();
+			if (immutableModule.test(`/${filename}`)) await writeImmutable(path.join(outDir, filename), code);
+			else await writeChanged(path.join(outDir, filename), code);
+		}
+	}))).find((outcome) => outcome.status === "rejected");
+	if (failure?.status === "rejected") throw failure.reason;
+	await writeChanged(path.join(outDir, "server.js"), modules.get("server.js"), signal);
+	if (prune) await pruneArtifacts(outDir, modules);
+}
+//#endregion
+//#region src/collection/registry.ts
+/** Built-in payload names start with an underscore, which custom payload names cannot use. */
+const builtinPayloads = {
+	_body: { variants: [] },
+	_rendered: { variants: [] }
+};
+/**
+* Reports whether a collection can carry built-in `_body` and `_rendered` payloads.
+* This depends only on the declaration, never on the entries a source currently contains.
+*
+* @param definition - A collection definition, including the `source` shorthand when used.
+* @returns False for JSON, YAML, and TOML sources and `file()` loaders; true otherwise.
+*/
+function hasBuiltinPayloads(definition) {
+	const source = definition.source;
+	if (source !== void 0) return typeof source === "string" || source.type === "markdown";
+	return builtinLoader(definition.loader)?.kind !== "file";
+}
+/**
+* Builds the query registry that runtimes validate queries against, without resolvers or schemas.
+*
+* @param registry - The configured collection definitions.
+* @returns Relationship and payload descriptors for each collection.
+*/
+function queryRegistry(registry) {
+	return Object.fromEntries(Object.entries(registry).map(([name, definition]) => [name, {
+		relationships: definition.relationships ?? {},
+		payloads: hasBuiltinPayloads(definition) ? { ...builtinPayloads } : {}
+	}]));
+}
+//#endregion
+//#region src/preparation/prepare.ts
+/** Prepares one immutable revision with loader-defined source metadata, aggregating failures. */
+async function prepareRevision(registry, sources, cache, signal, development, sourceDiagnostics = [], parsedData) {
+	const diagnostics = [...sourceDiagnostics];
+	const collections = Object.create(null);
+	for (const [collectionName, definition] of Object.entries(registry)) {
+		const records = [];
+		const builtins = /* @__PURE__ */ new Map();
+		const computed = definition.computed ?? {};
+		const relationships = definition.relationships ?? {};
+		const declarationNames = [...Object.keys(computed), ...Object.keys(relationships)];
+		if (declarationNames.some((name) => [
+			"id",
+			"_adjacent",
+			"_payloads"
+		].includes(name)) || new Set(declarationNames).size !== declarationNames.length || Object.values(relationships).some((relation) => !isRelationship(relation))) {
+			diagnostics.push({
+				code: "validation-error",
+				operation: "build",
+				collection: collectionName,
+				message: "Invalid or overlapping computed/relationship declarations."
+			});
+			continue;
+		}
+		const descriptor = builtinLoader(definition.loader);
+		for (const entry of sources.get(collectionName)?.values() ?? []) {
+			signal.throwIfAborted();
+			const context = {
+				operation: "build",
+				collection: collectionName,
+				id: entry.id,
+				source: entry.source
+			};
+			const key = JSON.stringify([collectionName, entry.id]);
+			let signature;
+			try {
+				signature = encode(entry);
+			} catch {}
+			const previous = cache.get(key);
+			if (signature !== void 0 && previous?.signature === signature && previous.definition === definition) {
+				records.push(previous.record);
+				if (Object.keys(previous.payload).length) builtins.set(entry.id, async () => previous.payload);
+				continue;
+			}
+			try {
+				const parsed = parsedData?.get(collectionName);
+				const validated = parsed?.has(entry.data) && parsed.get(entry.data) === definition.schema ? entry.data : await validate(definition.schema, entry.data, context);
+				signal.throwIfAborted();
+				if (!isRecord(validated)) throw new Error("Validated metadata must be a record of named fields.");
+				if (Object.hasOwn(validated, "id") || Object.hasOwn(validated, "_adjacent") || Object.hasOwn(validated, "_payloads") || declarationNames.some((name) => Object.hasOwn(validated, name))) throw new Error("Metadata, computed fields, relationships, and reserved id/_adjacent/_payloads must have distinct names.");
+				const metadata = detach(validated);
+				const values = Object.create(null);
+				const before = diagnostics.length;
+				for (const [field, computedField] of Object.entries(computed)) try {
+					const result = await computedField.resolve({
+						collection: collectionName,
+						id: entry.id,
+						source: detach(entry.sourceData),
+						data: detach(metadata),
+						readBody: async () => entry.body,
+						signal
+					});
+					values[field] = await validate(computedField.schema, result, {
+						...context,
+						path: [field]
+					});
+				} catch (cause) {
+					diagnostics.push(...contentError(cause, {
+						...context,
+						path: [field],
+						code: "validation-error",
+						message: `Computed field "${field}" failed.`
+					}).diagnostics);
+				}
+				signal.throwIfAborted();
+				if (before !== diagnostics.length) continue;
+				const record = detach({
+					...metadata,
+					...values,
+					id: entry.id
+				});
+				const payload = {};
+				const markdown = descriptor?.kind === "glob" && entry.source?.toLowerCase().endsWith(".md");
+				if (entry.body !== void 0 && (!markdown || descriptor?.kind !== "glob" || descriptor.options.retainBody !== false)) payload.body = entry.body;
+				const supplied = renderedPayload(entry);
+				if (supplied) payload.rendered = supplied;
+				else if (markdown && entry.body !== void 0) {
+					if (development || descriptor.options.deferRender === true) payload.markdown = entry.body;
+					else try {
+						payload.rendered = await renderMarkdown(entry.body);
+					} catch (cause) {
+						throw new ContentError({
+							...context,
+							code: "render-error",
+							message: "Eager Markdown compilation failed.",
+							cause
+						});
+					}
+				}
+				encode(payload);
+				cache.set(key, {
+					definition,
+					signature,
+					record,
+					payload
+				});
+				records.push(record);
+				if (Object.keys(payload).length) builtins.set(entry.id, async () => payload);
+			} catch (cause) {
+				const formatted = cause && typeof cause === "object" && "path" in cause && typeof cause.path === "string" ? cause.path : "";
+				const message = cause instanceof Error ? cause.message : "Entry preparation failed.";
+				diagnostics.push(...contentError(cause, {
+					...context,
+					path: formatted ? valuePath(formatted) : void 0,
+					code: "validation-error",
+					message: formatted ? `${message} (at ${formatted})` : message
+				}).diagnostics);
+			}
+		}
+		collections[collectionName] = {
+			records,
+			relationships,
+			builtins,
+			sources: new Map([...sources.get(collectionName)?.values() ?? []].map((entry) => [entry.id, entry.source]))
+		};
+	}
+	signal.throwIfAborted();
+	const revision = {
+		collections,
+		registry: queryRegistry(Object.fromEntries(Object.keys(collections).map((name) => [name, registry[name]]))),
+		relations: /* @__PURE__ */ new Map(),
+		active: 0,
+		payloadCache: /* @__PURE__ */ new Map(),
+		renderCache: /* @__PURE__ */ new Map(),
+		renderMarkdown
+	};
+	const failed = diagnostics.map((diagnostic) => diagnostic.collection);
+	if (!failed.includes(void 0)) diagnostics.push(...prepareRelationships(revision, new Set(failed)).flatMap((error) => error.diagnostics));
+	if (diagnostics.length) throw groupDiagnostics(diagnostics);
+	return revision;
+}
+//#endregion
+//#region src/preparation/config.ts
+/** Loads build-only configuration without retaining a previous config module value. */
+async function loadRegistry(config) {
+	const filename = await realpath(config);
+	const dependencies = /* @__PURE__ */ new Set([filename]);
+	const transpiler = createJiti(filename, {
+		moduleCache: false,
+		fsCache: false
+	});
+	const imported = await createJiti(filename, {
+		moduleCache: false,
+		fsCache: false,
+		transform: (options) => {
+			if (options.filename) dependencies.add(path.resolve(options.filename));
+			return { code: transpiler.transform(options) };
+		}
+	}).evalModule(await readFile(filename, "utf8"), {
+		filename,
+		async: true,
+		forceTranspile: true
+	});
+	if (imported.loaderConfig !== void 0 && (!imported.loaderConfig || typeof imported.loaderConfig !== "object" || Array.isArray(imported.loaderConfig))) throw new Error("content-query.config loaderConfig must be an object.");
+	const registry = imported.collections;
+	if (!registry || typeof registry !== "object" || Array.isArray(registry)) throw new Error("content-query.config must export a collections registry.");
+	for (const [name, definition] of Object.entries(registry)) if (!name || !definition || typeof definition !== "object" || !("loader" in definition) || !definition.loader || typeof definition.loader !== "object" || !("name" in definition.loader) || typeof definition.loader.name !== "string" || !definition.loader.name || !("load" in definition.loader) || typeof definition.loader.load !== "function") throw new Error(`Collection "${name}" requires a named loader object with load(context).`);
+	return {
+		registry,
+		dependencies,
+		loaderConfig: imported.loaderConfig
+	};
+}
+//#endregion
+//#region src/shared/paths.ts
+/** Checks containment without confusing sibling prefixes, drive roots, or trailing separators. */
+function withinDirectory(directory, filename) {
+	const relative = path.relative(directory, filename);
+	return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+/** Resolves existing symlink ancestors even when the output directory does not exist yet. */
+async function canonicalPath(filename) {
+	try {
+		return await realpath(filename);
+	} catch (cause) {
+		if (!cause || typeof cause !== "object" || !("code" in cause) || cause.code !== "ENOENT") throw cause;
+		const parent = path.dirname(filename);
+		if (parent === filename) throw cause;
+		return path.join(await canonicalPath(parent), path.basename(filename));
+	}
+}
+//#endregion
+//#region src/loaders/match.ts
+const matchers = /* @__PURE__ */ new WeakMap();
+/**
+* Builds a watch-time superset of tinyglobby discovery: every file discovery could return
+* matches, so an edit is never missed, while unrelated files are ignored.
+*/
+function globMatcher(options) {
+	const cached = matchers.get(options);
+	if (cached) return cached;
+	const patterns = typeof options.pattern === "string" ? [options.pattern] : options.pattern;
+	const negated = (pattern) => pattern.startsWith("!") && !pattern.startsWith("!(");
+	const included = patterns.filter((pattern) => pattern && !negated(pattern));
+	const excluded = patterns.filter((pattern) => pattern && negated(pattern));
+	const matchOptions = {
+		dot: false,
+		posix: true
+	};
+	let matcher;
+	if (included.some((pattern) => pattern.startsWith("..") || path.posix.isAbsolute(pattern))) matcher = () => true;
+	else {
+		const match = picomatch(included.flatMap((pattern) => {
+			const normalized = path.posix.normalize(pattern).replace(/\/$/, "");
+			return [normalized, `${normalized}/**`];
+		}), matchOptions);
+		const ignore = excluded.length ? picomatch(excluded.map((pattern) => path.posix.normalize(pattern.slice(1))), matchOptions) : () => false;
+		matcher = (relative) => match(relative) && !ignore(relative);
+	}
+	matchers.set(options, matcher);
+	return matcher;
+}
+/** Reports whether a filesystem event can change a built-in loader's next snapshot. */
+function affectsSnapshot(descriptor, base, event, filename) {
+	if (event === "addDir") return false;
+	if (filename === base) return true;
+	if (event === "unlinkDir" && (withinDirectory(filename, base) || descriptor.kind === "glob" && withinDirectory(base, filename))) return true;
+	if (descriptor.kind !== "glob" || !withinDirectory(base, filename)) return false;
+	return globMatcher(descriptor.options)(path.relative(base, filename).split(path.sep).join("/"));
+}
+//#endregion
+//#region src/preparation/watch.ts
+const awaitWriteFinish = {
+	stabilityThreshold: 50,
+	pollInterval: 10
+};
+/** Finds an existing ancestor so watching also detects a missing base directory's creation. */
+async function watchAncestor(filename) {
+	let ancestor = filename;
+	while (true) try {
+		await access(ancestor);
+		return ancestor;
+	} catch {
+		const parent = path.dirname(ancestor);
+		if (parent === ancestor) return parent;
+		ancestor = parent;
+	}
+}
+/** Resolves symlinked ancestors so watcher paths compare with Jiti's physical module paths. */
+function physicalPath(filename) {
+	try {
+		return realpathSync(filename);
+	} catch {
+		try {
+			return path.join(realpathSync(path.dirname(filename)), path.basename(filename));
+		} catch {
+			return filename;
+		}
+	}
+}
+/** Matches edits a config reload can observe, conservatively while the module graph is unknown. */
+function configDependency(options, filename) {
+	const resolved = path.resolve(filename);
+	if (resolved === options.config) return true;
+	const dependencies = options.dependencies();
+	if (!dependencies) return /\.(?:[cm]?[jt]sx?)$/.test(resolved);
+	return dependencies.has(resolved) || dependencies.has(physicalPath(resolved));
+}
+/** Resolves once a watcher has subscribed to its initial paths. */
+function ready(watcher) {
+	return new Promise((resolve, reject) => {
+		watcher.once("ready", resolve);
+		watcher.once("error", reject);
+	});
+}
+/** Shares the project ignore policy with declared-input subscription coverage checks. */
+function projectIgnored(options) {
+	const ignoredRoots = [...options.output ? [options.output] : [], path.join(options.root, ".content-query")];
+	return (filename) => filename.split(path.sep).some((segment) => [
+		"node_modules",
+		".git",
+		".next",
+		".void",
+		".wrangler",
+		"dist",
+		"coverage"
+	].includes(segment)) || ignoredRoots.some((ignored) => withinDirectory(ignored, filename));
+}
+/** Registers ownership before awaiting readiness so initialization failures retain cleanup. */
+async function watchProject(options, register) {
+	const watcher = watch([options.root, await watchAncestor(path.dirname(options.config))], {
+		ignoreInitial: true,
+		awaitWriteFinish,
+		ignored: projectIgnored(options)
+	});
+	register(watcher);
+	watcher.on("all", (event, filename) => {
+		if (event === "addDir") return;
+		if (configDependency(options, filename)) {
+			options.configChanged();
+			return;
+		}
+	});
+	watcher.on("error", (cause) => options.failed(cause));
+	await ready(watcher);
+}
+/** Owns scoped source listeners and external subscriptions for one configuration. */
+async function watchSources(options, register) {
+	const ignoredByProject = projectIgnored(options);
+	const modules = [...options.dependencies() ?? []].filter((filename) => !withinDirectory(options.root, filename) && !withinDirectory(path.dirname(options.config), filename) && !filename.split(path.sep).includes("node_modules"));
+	if (modules.length) {
+		const external = watch(modules, {
+			ignoreInitial: true,
+			awaitWriteFinish
+		});
+		register(() => external.close());
+		external.on("all", () => options.configChanged());
+		external.on("error", (cause) => options.failed(cause));
+		await ready(external);
+	}
+	for (const [name, definition] of Object.entries(options.registry())) {
+		const builtin = builtinLoader(definition.loader);
+		if (builtin) {
+			const target = builtinPath(builtin, options.root);
+			const outputRoots = [path.join(options.root, ".content-query"), ...options.output ? [options.output] : []];
+			const ancestor = await watchAncestor(target);
+			const shared = !ignoredByProject(target) && (withinDirectory(options.root, target) || withinDirectory(path.dirname(options.config), target)) ? options.projectWatcher : void 0;
+			const dedicated = !shared || builtin.kind === "glob";
+			const external = dedicated ? watch(ancestor, {
+				ignoreInitial: true,
+				awaitWriteFinish,
+				ignored: (filename, stats) => !(withinDirectory(target, filename) || withinDirectory(filename, target)) || outputRoots.some((output) => withinDirectory(output, filename)) || !!(shared && stats?.isFile() && !ignoredByProject(filename))
+			}) : shared;
+			/** Invalidates only the collection whose declared input can match this event. */
+			function changed(event, filename) {
+				if (affectsSnapshot(builtin, target, event, filename)) options.invalidated(name);
+			}
+			if (shared) {
+				shared.on("all", changed);
+				register(() => {
+					shared.off("all", changed);
+				});
+			}
+			if (dedicated) register(() => external.close());
+			if (ancestor !== target && !outputRoots.some((output) => withinDirectory(output, target))) {
+				/** Recovers a missing declared path even if the ancestor's creation event is lost. */
+				function recheck(current, previous) {
+					if (current.nlink === 0 && previous.nlink === 0) return;
+					external.add(target);
+					if (shared && shared !== external) shared.add(target);
+					options.invalidated(name);
+				}
+				watchFile(target, {
+					interval: 100,
+					persistent: false
+				}, recheck);
+				register(() => unwatchFile(target, recheck));
+			}
+			if (dedicated) {
+				external.on("all", changed);
+				external.on("error", (cause) => options.failed(cause));
+				await ready(external);
+			}
+		}
+	}
+}
+//#endregion
+//#region src/preparation/loaders/context.ts
+/** Supplies portable filesystem defaults and fails explicitly for unavailable Astro settings. */
+function loaderConfig(root, overrides = {}) {
+	const defaults = {
+		root: pathToFileURL(`${path.resolve(root)}${path.sep}`),
+		srcDir: pathToFileURL(`${path.resolve(root, "src")}${path.sep}`),
+		publicDir: pathToFileURL(`${path.resolve(root, "public")}${path.sep}`),
+		outDir: pathToFileURL(`${path.resolve(root, "dist")}${path.sep}`),
+		cacheDir: pathToFileURL(`${path.resolve(root, "node_modules/.astro")}${path.sep}`),
+		base: "/",
+		site: void 0,
+		output: "static",
+		...overrides
+	};
+	return new Proxy(defaults, { get(target, property, receiver) {
+		if (typeof property === "string" && !(property in target)) throw new Error(`Content loader requires config.${property}; provide loaderConfig.${property} in content-query.config.ts.`);
+		return Reflect.get(target, property, receiver);
+	} });
+}
+/** Creates the public Astro logger shape without importing Astro's framework runtime. */
+function loaderLogger(label, options = {
+	level: "info",
+	destination: { write: ({ label: name, level, message }) => {
+		if (level !== "silent") console[level](`[${name}] ${message}`);
+	} }
+}) {
+	/** Routes messages through the shared logger options and configured level. */
+	function emit(level, message) {
+		const ranks = {
+			debug: 0,
+			info: 1,
+			warn: 2,
+			error: 3,
+			silent: 4
+		};
+		if (ranks[level] >= ranks[options.level]) options.destination.write({
+			label,
+			level,
+			message,
+			newLine: true
+		});
+	}
+	return {
+		label,
+		options,
+		fork: (name) => loaderLogger(name, options),
+		info: (message) => emit("info", message),
+		warn: (message) => emit("warn", message),
+		error: (message) => emit("error", message),
+		debug: (message) => emit("debug", message),
+		flush: () => {
+			options.destination.flush?.();
+		},
+		close: () => {
+			options.destination.close?.();
+		}
+	};
+}
+//#endregion
+//#region src/preparation/loaders/store.ts
+/** Creates an isolated native loader store, retaining validation identity across defensive copies. */
+function createStores(current, parsed, changed) {
+	/** Copies entries without exposing mutable preparation state to loader code. */
+	function copy(entry) {
+		const copied = detach(entry);
+		if (parsed.has(entry.data)) parsed.set(copied.data, parsed.get(entry.data));
+		return copied;
+	}
+	return {
+		store: {
+			get(key) {
+				const entry = current().entries.get(String(key));
+				return entry ? copy(entry) : void 0;
+			},
+			entries: () => [...current().entries].map(([key, entry]) => [key, copy(entry)]),
+			values: () => [...current().entries.values()].map(copy),
+			keys: () => [...current().entries.keys()],
+			has: (key) => current().entries.has(String(key)),
+			set(entry) {
+				if (entry.deferredRender || entry.assetImports?.length || entry.imageImports?.length || entry.rendered?.metadata?.imagePaths?.length) throw new Error("Astro loader module and image imports require Astro's rendering pipeline; supply portable HTML or use a ContentQuery loader.");
+				const id = entry.id;
+				if (typeof id !== "string" || !id || !entry.data || typeof entry.data !== "object" || Array.isArray(entry.data)) throw new Error("Astro store entries require a nonempty id and record data.");
+				const previous = current().entries.get(id);
+				if (entry.digest !== void 0 && previous?.digest === entry.digest) return false;
+				current().entries.set(id, copy({
+					...entry,
+					id
+				}));
+				changed();
+				return true;
+			},
+			delete(key) {
+				if (current().entries.delete(String(key))) changed();
+			},
+			clear() {
+				if (current().entries.size) {
+					current().entries.clear();
+					changed();
+				}
+			},
+			addModuleImport() {
+				throw new Error("Astro loader module imports require Astro's rendering pipeline.");
+			}
+		},
+		meta: {
+			get: (key) => current().metadata.get(key),
+			has: (key) => current().metadata.has(key),
+			set: (key, value) => {
+				current().metadata.set(key, value);
+			},
+			delete: (key) => {
+				current().metadata.delete(key);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/preparation/loaders/watcher.ts
+/** Guards loader-owned watcher callbacks and exposes cleanup for abandoned load attempts. */
+function guardedWatcher(watcher, run, failed) {
+	const listeners = [];
+	let running = Promise.resolve();
+	const registration = /* @__PURE__ */ new Set([
+		"on",
+		"once",
+		"addListener",
+		"prependListener",
+		"prependOnceListener"
+	]);
+	const facade = new Proxy(watcher, { get(target, property, receiver) {
+		if (typeof property === "string" && registration.has(property)) return (event, original) => {
+			const wrapped = (...arguments_) => {
+				running = running.then(() => run(() => Reflect.apply(original, facade, arguments_))).catch(failed);
+			};
+			listeners.push({
+				event,
+				original,
+				wrapped
+			});
+			target[property](event, wrapped);
+			return facade;
+		};
+		if (property === "off" || property === "removeListener" || property === "removeAllListeners") return (event, original) => {
+			for (let index = listeners.length - 1; index >= 0; index--) {
+				const listener = listeners[index];
+				if ((event === void 0 || listener.event === event) && (original === void 0 || listener.original === original)) {
+					target.off(listener.event, listener.wrapped);
+					listeners.splice(index, 1);
+				}
+			}
+			return facade;
+		};
+		const value = Reflect.get(target, property, receiver);
+		return typeof value === "function" ? (...arguments_) => {
+			const result = Reflect.apply(value, target, arguments_);
+			return result === target ? facade : result;
+		} : value;
+	} });
+	return {
+		watcher: facade,
+		cleanup() {
+			for (const { event, wrapped } of listeners) watcher.off(event, wrapped);
+			listeners.length = 0;
+		}
+	};
+}
+//#endregion
+//#region src/preparation/loaders/session.ts
+/** Narrows schema providers without coupling native ContentQuery definitions to Zod. */
+function standardSchema(value) {
+	return !!value && typeof value === "object" && "~standard" in value && isRecord(value["~standard"]) && typeof value["~standard"].validate === "function";
+}
+/** Owns a collection's mutable loader store and converts completed loads into immutable sources. */
+function createLoaderSession(source, options) {
+	const parsed = /* @__PURE__ */ new WeakMap();
+	const state = {
+		root: path.resolve(options.root),
+		lifetime: options.signal,
+		watcher: options.watcher,
+		entries: /* @__PURE__ */ new Map(),
+		metadata: /* @__PURE__ */ new Map(),
+		changed: false,
+		queued: false,
+		initialized: false,
+		failedInitialLoad: false,
+		guards: /* @__PURE__ */ new Set()
+	};
+	let declaredSchema;
+	const schema = options.schema ?? { "~standard": {
+		version: 1,
+		vendor: "content-query",
+		async validate(value) {
+			declaredSchema ??= Promise.resolve().then(async () => {
+				const authored = "schema" in source ? source.schema : void 0;
+				if (authored) return typeof authored === "function" ? authored() : authored;
+				return "createSchema" in source ? (await source.createSchema?.())?.schema : void 0;
+			}).catch((cause) => {
+				declaredSchema = void 0;
+				throw cause;
+			});
+			const provider = await declaredSchema;
+			if (!provider) return { value };
+			if (standardSchema(provider)) {
+				const result = await provider["~standard"].validate(value);
+				return result.issues ? { issues: result.issues } : isRecord(result.value) ? { value: result.value } : { issues: [{ message: "Astro loader schemas must produce a record of named fields." }] };
+			}
+			const legacy = provider && typeof provider === "object" && "safeParseAsync" in provider ? provider.safeParseAsync : void 0;
+			const result = typeof legacy === "function" ? await legacy.call(provider, value) : await (async () => {
+				return (await import("zod/v4/core")).safeParseAsync(provider, value);
+			})();
+			return result.success ? { value: result.data } : { issues: result.error.issues };
+		}
+	} };
+	/** Converts the private store into source-independent ContentQuery entries. */
+	function snapshot(state) {
+		return [...state.entries.values()].map((entry) => ({
+			id: entry.id,
+			data: entry.data,
+			...entry.body === void 0 ? {} : { body: entry.body },
+			...entry.rendered === void 0 ? {} : { rendered: entry.rendered },
+			...entry.filePath === void 0 ? {} : { source: path.resolve(state.root, entry.filePath) },
+			...entry.source === void 0 ? {} : { sourceData: entry.source }
+		}));
+	}
+	/** Coalesces synchronous store batches into a complete validated publication. */
+	function changed(state) {
+		state.changed = true;
+		if (!state.queued) {
+			state.queued = true;
+			queueMicrotask(() => {
+				state.queued = false;
+				if (!state.lifetime.aborted) state.subscription?.invalidate();
+			});
+		}
+	}
+	return {
+		schema,
+		parsed,
+		async load(context) {
+			context.signal.throwIfAborted();
+			if (state.changed) {
+				state.changed = false;
+				return snapshot(state);
+			}
+			const candidate = {
+				entries: new Map(state.entries),
+				metadata: new Map(state.metadata)
+			};
+			let committed = false;
+			let retired = false;
+			let batch;
+			let batchChanged = false;
+			const pending = /* @__PURE__ */ new Set();
+			let parseFailure;
+			const effectiveSchema = schema;
+			const stores = createStores(() => batch ?? (committed ? state : candidate), parsed, () => {
+				if (batch) batchChanged = true;
+				else if (committed && !retired && !state.lifetime.aborted) changed(state);
+			});
+			/** Awaits parsing work even when a source uses unawaited stream callbacks. */
+			async function settled() {
+				while (pending.size) await Promise.all(pending);
+				if (parseFailure) {
+					const { cause } = parseFailure;
+					parseFailure = void 0;
+					throw cause;
+				}
+			}
+			const guarded = state.watcher ? guardedWatcher(state.watcher, async (callback) => {
+				if (retired || state.lifetime.aborted) return;
+				const current = committed ? state : candidate;
+				batch = {
+					entries: new Map(current.entries),
+					metadata: new Map(current.metadata)
+				};
+				batchChanged = false;
+				parseFailure = void 0;
+				try {
+					await callback();
+					await settled();
+					state.lifetime.throwIfAborted();
+					current.entries = batch.entries;
+					current.metadata = batch.metadata;
+					if (committed && batchChanged) changed(state);
+				} catch (cause) {
+					await Promise.allSettled(pending);
+					parseFailure = void 0;
+					throw cause;
+				} finally {
+					batch = void 0;
+				}
+			}, (cause) => {
+				if (!state.lifetime.aborted) state.subscription?.error(cause);
+			}) : void 0;
+			const loaderContext = {
+				...stores,
+				collection: options.collection,
+				config: loaderConfig(state.root, options.config),
+				logger: loaderLogger(source.name),
+				signal: context.signal,
+				watcher: guarded?.watcher,
+				generateDigest: (data) => createHash("sha256").update(encode(data)).digest("hex"),
+				async renderMarkdown(body) {
+					const { html, headings } = await renderMarkdown(body);
+					return {
+						html,
+						metadata: { headings }
+					};
+				},
+				parseData({ id, data, filePath }) {
+					const operation = (async () => {
+						state.lifetime.throwIfAborted();
+						const result = await validate(effectiveSchema, data, {
+							operation: "build",
+							collection: options.collection,
+							id,
+							source: filePath === void 0 ? void 0 : path.resolve(state.root, filePath)
+						});
+						if (!isRecord(result)) throw new Error("Validated Astro loader metadata must be a record of named fields.");
+						let copied;
+						try {
+							copied = detach(result);
+						} catch (cause) {
+							const formatted = cause && typeof cause === "object" && "path" in cause && typeof cause.path === "string" ? cause.path : "";
+							throw contentError(cause, {
+								code: "validation-error",
+								operation: "build",
+								collection: options.collection,
+								id,
+								source: filePath === void 0 ? void 0 : path.resolve(state.root, filePath),
+								path: formatted ? valuePath(formatted) : void 0,
+								message: formatted ? `${cause instanceof Error ? cause.message : "Unsupported parsed metadata."} (at ${formatted})` : cause instanceof Error ? cause.message : "Unsupported parsed metadata."
+							});
+						}
+						parsed.set(copied, effectiveSchema);
+						return copied;
+					})();
+					pending.add(operation);
+					operation.then(() => pending.delete(operation), (cause) => {
+						pending.delete(operation);
+						parseFailure = { cause };
+						if (committed && !batch && !retired) state.subscription?.error(cause);
+					});
+					return operation;
+				}
+			};
+			try {
+				state.failedInitialLoad = false;
+				await source.load(loaderContext);
+				await settled();
+				context.signal.throwIfAborted();
+				state.entries = candidate.entries;
+				state.metadata = candidate.metadata;
+				committed = true;
+				state.initialized = true;
+				if (guarded) state.guards.add(() => guarded.cleanup());
+				return snapshot(state);
+			} catch (cause) {
+				retired = true;
+				if (!state.initialized && !context.signal.aborted) state.failedInitialLoad = true;
+				guarded?.cleanup();
+				throw cause;
+			}
+		},
+		async watch(context) {
+			state.subscription = context;
+			/** Retries failed startup loads whose source code could not install its own listener yet. */
+			function retryInitialLoad() {
+				if (state.failedInitialLoad && !state.lifetime.aborted) context.invalidate();
+			}
+			state.watcher?.on("all", retryInitialLoad);
+			return () => {
+				state.subscription = void 0;
+				state.watcher?.off("all", retryInitialLoad);
+				for (const cleanup of state.guards) cleanup();
+				state.guards.clear();
+			};
+		}
+	};
+}
+//#endregion
+//#region src/preparation/session.ts
+const internals = /* @__PURE__ */ new WeakMap();
+/** Gives integrations private lifecycle access without expanding the application session API. */
+function sessionInternals(session) {
+	const internal = internals.get(session);
+	if (!internal) throw new Error("Unknown ContentQuery session.");
+	return internal;
+}
+/** Creates a preparation session with ordered source commands and atomic revision publication. */
+async function createSession(options) {
+	options = {
+		...options,
+		root: path.resolve(options.root),
+		config: path.resolve(options.root, options.config),
+		outDir: path.resolve(options.root, options.outDir)
+	};
+	const state = {};
+	let registry = {};
+	let loaders = /* @__PURE__ */ new Map();
+	let configDependencies;
+	let configurationError;
+	const candidates = /* @__PURE__ */ new Map();
+	const cache = /* @__PURE__ */ new Map();
+	let cleanups = [];
+	let subscriptions = new AbortController();
+	let attempt;
+	let watcher;
+	let disposed = false;
+	let initializing = true;
+	let running;
+	let commands = [];
+	const stale = /* @__PURE__ */ new Set();
+	let loading = /* @__PURE__ */ new Set();
+	let generation = 0;
+	const loadFailures = /* @__PURE__ */ new Map();
+	const watchOptions = {
+		root: options.root,
+		config: options.config,
+		output: options.publish ? options.outDir : void 0,
+		registry: () => registry,
+		dependencies: () => configDependencies,
+		configChanged: () => enqueue({ kind: "config" }),
+		invalidated: (collection) => enqueue({
+			kind: "invalidate",
+			collection
+		}),
+		failed: (cause) => enqueue({
+			kind: "error",
+			cause
+		})
+	};
+	/** Queues ordered notifications and makes any in-flight preparation obsolete. */
+	function enqueue(command) {
+		if (disposed) return;
+		for (const name of loading) if (!commands.some((queued) => queued.kind === "invalidate" && queued.collection === name)) commands.push({
+			kind: "invalidate",
+			collection: name
+		});
+		commands.push(command);
+		generation++;
+		attempt?.abort();
+		if (!running && !initializing) running = Promise.resolve().then(drain).finally(() => {
+			running = void 0;
+			if (commands.length && !disposed) enqueueDrain();
+		});
+	}
+	/** Restarts draining without inventing another source notification. */
+	function enqueueDrain() {
+		if (!running && !disposed) running = Promise.resolve().then(drain).finally(() => {
+			running = void 0;
+			if (commands.length && !disposed) enqueueDrain();
+		});
+	}
+	/** Reports current preparation failures while keeping recovery subscriptions alive. */
+	function fail(cause) {
+		state.error = contentError(cause, {
+			code: "source-error",
+			operation: "build",
+			message: cause instanceof Error ? cause.message : "Content preparation failed."
+		});
+		options.change?.(state);
+	}
+	/** Aborts an owned subscription group and attempts every cleanup even when one fails. */
+	async function releaseResources(controller, handlers) {
+		controller.abort();
+		const failure = (await Promise.allSettled(handlers.map(async (cleanup) => cleanup()))).find((result) => result.status === "rejected");
+		if (failure?.status === "rejected") throw failure.reason;
+	}
+	/** Releases the active configuration independently from load-attempt cancellation. */
+	async function releaseSubscriptions() {
+		const previous = cleanups;
+		cleanups = [];
+		await releaseResources(subscriptions, previous);
+	}
+	/** Stages all replacement subscriptions before adopting a valid configuration. */
+	async function configure(initial) {
+		configDependencies = void 0;
+		const loaded = options.registry ? {
+			registry: options.registry,
+			dependencies: /* @__PURE__ */ new Set(),
+			loaderConfig: void 0
+		} : await loadRegistry(options.config);
+		const nextSubscriptions = new AbortController();
+		const nextCleanups = [];
+		const nextLoaders = /* @__PURE__ */ new Map();
+		const nextRegistry = Object.create(null);
+		const notifications = [];
+		let installed = false;
+		/** Retains setup notifications and ignores callbacks from aborted configurations. */
+		function receive(command) {
+			if (nextSubscriptions.signal.aborted) return;
+			if (installed) enqueue(command);
+			else notifications.push(command);
+		}
+		try {
+			for (const [name, definition] of Object.entries(loaded.registry)) {
+				const loader = createLoaderSession(definition.loader, {
+					root: options.root,
+					config: loaded.loaderConfig,
+					collection: name,
+					schema: definition.schema,
+					signal: nextSubscriptions.signal,
+					watcher
+				});
+				nextLoaders.set(name, loader);
+				nextRegistry[name] = {
+					...definition,
+					schema: loader.schema
+				};
+				if (options.watch) {
+					const cleanup = await loader.watch({
+						signal: nextSubscriptions.signal,
+						invalidate: () => receive({
+							kind: "invalidate",
+							collection: name
+						}),
+						error: (cause) => receive({
+							kind: "error",
+							cause
+						})
+					});
+					if (typeof cleanup !== "function") throw new Error(`Loader watch() for "${name}" must return a cleanup function.`);
+					nextCleanups.push(cleanup);
+				}
+			}
+			if (watcher) await watchSources({
+				...watchOptions,
+				projectWatcher: watcher,
+				registry: () => loaded.registry,
+				dependencies: () => loaded.dependencies,
+				configChanged: () => receive({ kind: "config" }),
+				invalidated: (collection) => receive({
+					kind: "invalidate",
+					collection
+				}),
+				failed: (cause) => receive({
+					kind: "error",
+					cause
+				})
+			}, (cleanup) => nextCleanups.push(cleanup));
+			if (disposed) throw new Error("Content session was disposed during configuration setup.");
+			if (!initial) await releaseSubscriptions();
+		} catch (cause) {
+			const failure = contentError(cause, {
+				code: "source-error",
+				operation: "build",
+				source: options.config,
+				message: cause instanceof Error ? cause.message : "Configuration setup failed."
+			});
+			try {
+				await releaseResources(nextSubscriptions, nextCleanups);
+			} catch (cleanup) {
+				throw groupDiagnostics([...failure.diagnostics, ...contentError(cleanup, {
+					code: "source-error",
+					operation: "dispose",
+					message: "Subscription cleanup failed."
+				}).diagnostics]);
+			}
+			throw failure;
+		}
+		subscriptions = nextSubscriptions;
+		cleanups = nextCleanups;
+		registry = nextRegistry;
+		loaders = nextLoaders;
+		configDependencies = loaded.dependencies;
+		state.registry = queryRegistry(registry);
+		candidates.clear();
+		cache.clear();
+		loadFailures.clear();
+		configurationError = void 0;
+		installed = true;
+		for (const notification of notifications) enqueue(notification);
+	}
+	/** Acquires invalidated snapshots and publishes only the complete current attempt. */
+	async function prepare(names) {
+		const currentGeneration = generation;
+		attempt = new AbortController();
+		const signal = attempt.signal;
+		loading = names;
+		const acquired = await Promise.allSettled([...names].map(async (name) => {
+			const entries = await loaders.get(name).load({ signal });
+			return [name, normalizeSnapshot(entries, name)];
+		}));
+		if (disposed || currentGeneration !== generation) return;
+		loading = /* @__PURE__ */ new Set();
+		acquired.forEach((result, index) => {
+			const name = [...names][index];
+			if (result.status === "fulfilled") {
+				candidates.set(...result.value);
+				loadFailures.delete(name);
+			} else loadFailures.set(name, withContext(result.reason, {
+				code: "source-error",
+				operation: "build",
+				collection: name,
+				message: `Could not load collection "${name}"`
+			}));
+		});
+		try {
+			const failures = [...loadFailures.values()];
+			const revision = await prepareRevision(registry, candidates, cache, signal, options.watch, failures.flatMap((error) => error.diagnostics), new Map([...loaders].map(([name, loader]) => [name, loader.parsed])));
+			if (disposed || currentGeneration !== generation) return;
+			await options.publish?.(revision, registry, signal);
+			if (disposed || currentGeneration !== generation) return;
+			state.revision = revision;
+			state.error = void 0;
+			options.change?.(state);
+		} catch (cause) {
+			if (!disposed && currentGeneration === generation) fail(cause);
+		}
+	}
+	/** Lets a newer attempt progress even when obsolete user code ignores its signal. */
+	async function runAttempt(names) {
+		const work = prepare(names);
+		const signal = attempt.signal;
+		if (signal.aborted) return;
+		let finish;
+		const aborted = new Promise((resolve) => {
+			finish = () => resolve();
+			signal.addEventListener("abort", finish, { once: true });
+		});
+		try {
+			await Promise.race([work, aborted]);
+		} finally {
+			if (finish) signal.removeEventListener("abort", finish);
+		}
+	}
+	/** Applies queued source state separately from publishing validated content. */
+	async function drain() {
+		while (commands.length && !disposed) {
+			const pending = commands;
+			commands = [];
+			let failedCommand = false;
+			for (const command of pending) try {
+				if (command.kind === "error") throw command.cause;
+				if (command.kind === "config") {
+					await configure(false);
+					for (const name of Object.keys(registry)) stale.add(name);
+				} else if (command.kind === "invalidate") stale.add(command.collection);
+			} catch (cause) {
+				if (command.kind === "config") configurationError = contentError(cause, {
+					code: "source-error",
+					operation: "build",
+					source: options.config,
+					message: cause instanceof Error ? cause.message : "Configuration reload failed."
+				});
+				fail(configurationError ?? cause);
+				failedCommand = true;
+			}
+			if (!failedCommand && !configurationError) {
+				const names = new Set([...stale].filter((name) => Object.hasOwn(registry, name)));
+				stale.clear();
+				await runAttempt(names);
+			}
+		}
+	}
+	/** Idempotently stops watchers and prevents obsolete attempts from publishing. */
+	async function dispose() {
+		if (disposed) return;
+		disposed = true;
+		generation++;
+		attempt?.abort();
+		const failed = (await Promise.allSettled([watcher?.close() ?? Promise.resolve(), releaseSubscriptions()])).find((result) => result.status === "rejected");
+		if (failed?.status === "rejected") throw contentError(failed.reason, {
+			code: "source-error",
+			operation: "dispose",
+			message: "A content subscription could not be cleaned up."
+		});
+	}
+	const session = {
+		content: createRuntime(state),
+		dispose
+	};
+	internals.set(session, {
+		state,
+		async idle() {
+			await Promise.resolve();
+			while (running) await running;
+		},
+		invalidate() {
+			enqueue({ kind: "config" });
+		}
+	});
+	try {
+		if (options.watch) await watchProject(watchOptions, (created) => {
+			watcher = created;
+		});
+		await configure(true);
+		await runAttempt(new Set(Object.keys(registry)));
+		initializing = false;
+		if (commands.length) {
+			enqueueDrain();
+			while (running) await running;
+		}
+		if (state.error && !options.watch) throw state.error;
+		return session;
+	} catch (cause) {
+		const failure = contentError(cause, {
+			code: "source-error",
+			operation: "build",
+			message: "Content configuration or subscription initialization failed."
+		});
+		try {
+			await dispose();
+		} catch (cleanup) {
+			throw new ContentError({
+				...failure.diagnostics[0],
+				message: failure.message,
+				diagnostics: [...failure.diagnostics, ...contentError(cleanup, {
+					code: "source-error",
+					operation: "dispose",
+					message: "Subscription cleanup failed."
+				}).diagnostics]
+			});
+		}
+		throw failure;
+	}
+}
+//#endregion
+//#region src/preparation/config-path.ts
+const extensions = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs"
+];
+/** Lists default config paths, or the exact explicitly selected file, from the host root. */
+function configCandidates(root, config) {
+	return config === void 0 ? extensions.map((extension) => path.resolve(root, `content-query.config.${extension}`)) : [path.resolve(root, config)];
+}
+/** Discovers exactly one config file without evaluating candidates or guessing explicit paths. */
+async function resolveConfigPath(root, config) {
+	const candidates = configCandidates(root, config);
+	if (config !== void 0) return candidates[0];
+	const files = await Promise.all(candidates.map(async (filename) => {
+		try {
+			return (await stat(filename)).isFile();
+		} catch (cause) {
+			if (cause && typeof cause === "object" && "code" in cause && (cause.code === "ENOENT" || cause.code === "ENOTDIR")) return false;
+			throw contentError(cause, {
+				code: "source-error",
+				operation: "build",
+				source: filename,
+				message: `Could not inspect ContentQuery configuration "${filename}".`
+			});
+		}
+	}));
+	const matches = candidates.filter((_filename, index) => files[index]);
+	if (matches.length === 1) return matches[0];
+	throw new ContentError({
+		code: "source-error",
+		operation: "build",
+		source: path.resolve(root),
+		message: matches.length ? `Multiple ContentQuery configuration files found: ${matches.map((filename) => path.basename(filename)).join(", ")}. Set the config option to choose one.` : `No ContentQuery configuration found in "${path.resolve(root)}". Expected content-query.config.{${extensions.join(",")}}, or set the config option to an exact path.`
+	});
+}
+//#endregion
+//#region src/preparation/build.ts
+assertServerOnly();
+/**
+* Builds content independently of a bundler; bind the registry through an erased type import.
+* Generated watch sessions prune previous-run artifacts after their first successful publication.
+*/
+async function buildContent(...arguments_) {
+	return buildAtRoot(process.cwd(), arguments_[0] ?? {});
+}
+/** Resolves host paths and prunes previous-run artifacts on the first successful publication. */
+async function buildAtRoot(root, options, change) {
+	const { backend = "generated", watch = false } = options;
+	if (!["generated", "in-memory"].includes(backend) || typeof watch !== "boolean" || options.config !== void 0 && typeof options.config !== "string" || options.outDir !== void 0 && typeof options.outDir !== "string") throw new ContentError({
+		code: "source-error",
+		message: "Invalid build options."
+	});
+	const config = await resolveConfigPath(root, options.config);
+	const outDir = path.resolve(root, options.outDir ?? "./.content-query");
+	if (backend === "generated") {
+		const [physicalRoot, physicalOutput, physicalConfig] = await Promise.all([
+			canonicalPath(path.resolve(root)),
+			canonicalPath(outDir),
+			canonicalPath(config)
+		]);
+		if (withinDirectory(physicalOutput, physicalRoot) || withinDirectory(physicalOutput, physicalConfig)) throw new ContentError({
+			code: "source-error",
+			operation: "build",
+			message: "Generated output must be a dedicated directory outside collection configuration and cannot contain the application root."
+		});
+	}
+	let firstPublication = true;
+	let publication = Promise.resolve();
+	/** Keeps startup pruning from racing an artifact write from a newer content attempt. */
+	function publish(revision, _registry, signal) {
+		const pending = publication.catch(() => {}).then(async () => {
+			signal.throwIfAborted();
+			await writeArtifacts(revision, outDir, config, {
+				signal,
+				prune: !watch || firstPublication
+			});
+			firstPublication = false;
+		});
+		publication = pending;
+		return pending;
+	}
+	return createSession({
+		root,
+		config,
+		outDir,
+		watch,
+		change,
+		publish: backend === "generated" ? publish : void 0
+	});
+}
+//#endregion
+export { sessionInternals as a, contentDeclarations as c, resolveConfigPath as i, virtualDeclarations as l, buildContent as n, withinDirectory as o, configCandidates as r, writeChanged as s, buildAtRoot as t, revisionModules as u };