content-query 0.4.0 → 0.5.1

package/dist/internal.mjs

@@ -1,8 +1,7 @@
 import { t as ContentError } from "./errors-Bfd0R4_P.mjs";
 import { r as decode } from "./values-BbTV4QT-.mjs";
-import { n as createRuntime, o as prepareRelationships, r as isQueryStyle, t as createLiveRuntime } from "./content-BXrgP7nL.mjs";
+import { i as isQueryStyle, n as createCollections, r as createLiveCollection, t as createCollection } from "./collection-Cb5eWGnv.mjs";
 import { t as restoreContentError } from "./diagnostics-DmUZtrJ6.mjs";
-import { gunzipSync } from "fflate/browser";
 //#region src/artifacts/runtime.ts
 /** Checks that a value is a plain record before reading generated payload tables from it. */
 function isTable(value) {
@@ -25,10 +24,38 @@ function customPayloadTable(collection, payloads) {
 		}))];
 	}));
 }
-/** Initializes generated/embedded prepared content. This versioned wiring is internal. */
+/**
+* Decoded collections by generated collection module. The main server entry and collection
+* entries import the same module, so a process that loads several entries decodes it once.
+* Prepared records are never mutated, since queries project copies.
+*/
+const decodedCollections = /* @__PURE__ */ new WeakMap();
+/** Decodes and checks one generated collection module, reusing an earlier decoding of it. */
+function decodeCollection(name, encoded) {
+	const cached = decodedCollections.get(encoded);
+	if (cached) return cached;
+	const records = encoded.records.map((record) => decode(record));
+	if (records.some((record) => !record || typeof record !== "object" || Array.isArray(record) || !Object.hasOwn(record, "id") || typeof record.id !== "string" || !record.id || Object.hasOwn(record, "_adjacent") || Object.hasOwn(record, "_payloads")) || new Set(records.map((record) => record.id)).size !== records.length) throw new Error(`Invalid query records for collection "${name}".`);
+	const decoded = {
+		records,
+		builtins: new Map(Object.entries(encoded.builtins ?? {}).map(([id, load]) => [id, async () => decode((await load()).default)])),
+		...encoded.payloads ? { payloads: customPayloadTable(name, encoded.payloads) } : {}
+	};
+	decodedCollections.set(encoded, decoded);
+	return decoded;
+}
+/**
+* Initializes generated/embedded prepared content. This versioned wiring is internal.
+* Relationships are related when a query scope combines the collections it loads.
+*
+* @param manifest - The entry's manifest; its registry lists exactly the collections it serves.
+* @param collections - Generated collection modules by name.
+* @param renderMarkdown - The packaged renderer, when a served collection captured Markdown.
+* @returns The prepared revision.
+*/
 function createArtifactRevision(manifest, collections, renderMarkdown) {
 	try {
-		if (manifest.version !== 2 || manifest.codec !== "devalue-6.0.2") throw new Error("Incompatible content artifact or codec version; regenerate content.");
+		if (manifest.version !== 3 || manifest.codec !== "devalue-6.0.2") throw new Error("Incompatible content artifact or codec version; regenerate content.");
 		if (manifest.queryStyle !== void 0 && !isQueryStyle(manifest.queryStyle)) throw new Error("Invalid query style in content artifact; regenerate content.");
 		const revision = {
 			registry: manifest.collections,
@@ -42,18 +69,12 @@ function createArtifactRevision(manifest, collections, renderMarkdown) {
 		};
 		for (const [name, descriptor] of Object.entries(manifest.collections)) {
 			const encoded = collections[name];
-			if (!encoded || !Array.isArray(encoded.records)) throw new Error(`Missing collection artifact "${name}".`);
-			const records = encoded.records.map((record) => decode(record));
-			if (records.some((record) => !record || typeof record !== "object" || Array.isArray(record) || !Object.hasOwn(record, "id") || typeof record.id !== "string" || !record.id || Object.hasOwn(record, "_adjacent") || Object.hasOwn(record, "_payloads")) || new Set(records.map((record) => record.id)).size !== records.length) throw new Error(`Invalid query records for collection "${name}".`);
+			if (!encoded || typeof encoded !== "object" || !Array.isArray(encoded.records)) throw new Error(`Missing collection artifact "${name}".`);
 			revision.collections[name] = {
-				records,
-				relationships: descriptor.relationships,
-				builtins: new Map(Object.entries(encoded.builtins ?? {}).map(([id, load]) => [id, async () => decode((await load()).default)])),
-				...encoded.payloads ? { payloads: customPayloadTable(name, encoded.payloads) } : {}
+				...decodeCollection(name, encoded),
+				relationships: descriptor.relationships
 			};
 		}
-		const errors = prepareRelationships(revision);
-		if (errors.length) throw errors[0];
 		return revision;
 	} catch (cause) {
 		throw new ContentError({
@@ -63,10 +84,370 @@ function createArtifactRevision(manifest, collections, renderMarkdown) {
 		});
 	}
 }
-/** Initializes the public generated server export from a complete immutable artifact revision. */
-function createArtifactRuntime(manifest, collections, renderMarkdown) {
-	return createRuntime({ revision: createArtifactRevision(manifest, collections, renderMarkdown) });
+/**
+* Initializes one generated collection entry's export.
+*
+* @param manifest - The entry's manifest, which lists only this collection.
+* @param name - The collection's name.
+* @param collection - The generated collection module.
+* @param renderMarkdown - The packaged renderer, when the collection captured Markdown.
+* @returns The collection handle the entry exports.
+*/
+function createArtifactCollection(manifest, name, collection, renderMarkdown) {
+	const revision = createArtifactRevision(manifest, { [name]: collection }, renderMarkdown);
+	if (!Object.hasOwn(revision.collections, name)) throw new ContentError({
+		code: "artifact-error",
+		message: `Missing collection artifact "${name}".`
+	});
+	return createCollection({
+		name,
+		state: { revision }
+	});
+}
+/**
+* Initializes handles for every collection of one artifact revision, sharing its caches. Tests
+* and integrations use it; applications import each collection's own entry instead.
+*
+* @param manifest - A manifest that lists every collection in `collections`.
+* @param collections - Generated collection modules by name.
+* @param renderMarkdown - The packaged renderer, when a collection captured Markdown.
+* @returns Collection handles keyed by collection name.
+*/
+function createArtifactCollections(manifest, collections, renderMarkdown) {
+	return createCollections({ revision: createArtifactRevision(manifest, collections, renderMarkdown) });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/browser.js
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	0,
+	0,
+	0,
+	0
+]);
+var fdeb = new u8([
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	6,
+	7,
+	7,
+	8,
+	8,
+	9,
+	9,
+	10,
+	10,
+	11,
+	11,
+	12,
+	12,
+	13,
+	13,
+	0,
+	0
+]);
+var clim = new u8([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]);
+var freb = function(eb, start) {
+	var b = new u16(31);
+	for (var i = 0; i < 31; ++i) b[i] = start += 1 << eb[i - 1];
+	var r = new i32(b[30]);
+	for (var i = 1; i < 30; ++i) for (var j = b[i]; j < b[i + 1]; ++j) r[j] = j - b[i] << 5 | i;
+	return {
+		b,
+		r
+	};
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+_b.r;
+var rev = new u16(32768);
+for (var i = 0; i < 32768; ++i) {
+	var x = (i & 43690) >> 1 | (i & 21845) << 1;
+	x = (x & 52428) >> 2 | (x & 13107) << 2;
+	x = (x & 61680) >> 4 | (x & 3855) << 4;
+	rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var hMap = (function(cd, mb, r) {
+	var s = cd.length;
+	var i = 0;
+	var l = new u16(mb);
+	for (; i < s; ++i) if (cd[i]) ++l[cd[i] - 1];
+	var le = new u16(mb);
+	for (i = 1; i < mb; ++i) le[i] = le[i - 1] + l[i - 1] << 1;
+	var co;
+	if (r) {
+		co = new u16(1 << mb);
+		var rvb = 15 - mb;
+		for (i = 0; i < s; ++i) if (cd[i]) {
+			var sv = i << 4 | cd[i];
+			var r_1 = mb - cd[i];
+			var v = le[cd[i] - 1]++ << r_1;
+			for (var m = v | (1 << r_1) - 1; v <= m; ++v) co[rev[v] >> rvb] = sv;
+		}
+	} else {
+		co = new u16(s);
+		for (i = 0; i < s; ++i) if (cd[i]) co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+	}
+	return co;
+});
+var flt = new u8(288);
+for (var i = 0; i < 144; ++i) flt[i] = 8;
+for (var i = 144; i < 256; ++i) flt[i] = 9;
+for (var i = 256; i < 280; ++i) flt[i] = 7;
+for (var i = 280; i < 288; ++i) flt[i] = 8;
+var fdt = new u8(32);
+for (var i = 0; i < 32; ++i) fdt[i] = 5;
+var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+var max = function(a) {
+	var m = a[0];
+	for (var i = 1; i < a.length; ++i) if (a[i] > m) m = a[i];
+	return m;
+};
+var bits = function(d, p, m) {
+	var o = p / 8 | 0;
+	return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+	var o = p / 8 | 0;
+	return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+	return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+	if (s == null || s < 0) s = 0;
+	if (e == null || e > v.length) e = v.length;
+	return new u8(v.subarray(s, e));
+};
+var ec = [
+	"unexpected EOF",
+	"invalid block type",
+	"invalid length/literal",
+	"invalid distance",
+	"stream finished",
+	"no stream handler",
+	,
+	"no callback",
+	"invalid UTF-8 data",
+	"extra field too long",
+	"date not in range 1980-2099",
+	"filename too long",
+	"stream finishing",
+	"invalid zip data"
+];
+var err = function(ind, msg, nt) {
+	var e = new Error(msg || ec[ind]);
+	e.code = ind;
+	if (Error.captureStackTrace) Error.captureStackTrace(e, err);
+	if (!nt) throw e;
+	return e;
+};
+var inflt = function(dat, st, buf, dict) {
+	var sl = dat.length, dl = dict ? dict.length : 0;
+	if (!sl || st.f && !st.l) return buf || new u8(0);
+	var noBuf = !buf;
+	var resize = noBuf || st.i != 2;
+	var noSt = st.i;
+	if (noBuf) buf = new u8(sl * 3);
+	var cbuf = function(l) {
+		var bl = buf.length;
+		if (l > bl) {
+			var nbuf = new u8(Math.max(bl * 2, l));
+			nbuf.set(buf);
+			buf = nbuf;
+		}
+	};
+	var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+	var tbts = sl * 8;
+	do {
+		if (!lm) {
+			final = bits(dat, pos, 1);
+			var type = bits(dat, pos + 1, 3);
+			pos += 3;
+			if (!type) {
+				var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+				if (t > sl) {
+					if (noSt) err(0);
+					break;
+				}
+				if (resize) cbuf(bt + l);
+				buf.set(dat.subarray(s, t), bt);
+				st.b = bt += l, st.p = pos = t * 8, st.f = final;
+				continue;
+			} else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+			else if (type == 2) {
+				var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+				var tl = hLit + bits(dat, pos + 5, 31) + 1;
+				pos += 14;
+				var ldt = new u8(tl);
+				var clt = new u8(19);
+				for (var i = 0; i < hcLen; ++i) clt[clim[i]] = bits(dat, pos + i * 3, 7);
+				pos += hcLen * 3;
+				var clb = max(clt), clbmsk = (1 << clb) - 1;
+				var clm = hMap(clt, clb, 1);
+				for (var i = 0; i < tl;) {
+					var r = clm[bits(dat, pos, clbmsk)];
+					pos += r & 15;
+					var s = r >> 4;
+					if (s < 16) ldt[i++] = s;
+					else {
+						var c = 0, n = 0;
+						if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+						else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
+						else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
+						while (n--) ldt[i++] = c;
+					}
+				}
+				var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+				lbt = max(lt);
+				dbt = max(dt);
+				lm = hMap(lt, lbt, 1);
+				dm = hMap(dt, dbt, 1);
+			} else err(1);
+			if (pos > tbts) {
+				if (noSt) err(0);
+				break;
+			}
+		}
+		if (resize) cbuf(bt + 131072);
+		var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+		var lpos = pos;
+		for (;; lpos = pos) {
+			var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+			pos += c & 15;
+			if (pos > tbts) {
+				if (noSt) err(0);
+				break;
+			}
+			if (!c) err(2);
+			if (sym < 256) buf[bt++] = sym;
+			else if (sym == 256) {
+				lpos = pos, lm = null;
+				break;
+			} else {
+				var add = sym - 254;
+				if (sym > 264) {
+					var i = sym - 257, b = fleb[i];
+					add = bits(dat, pos, (1 << b) - 1) + fl[i];
+					pos += b;
+				}
+				var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+				if (!d) err(3);
+				pos += d & 15;
+				var dt = fd[dsym];
+				if (dsym > 3) {
+					var b = fdeb[dsym];
+					dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+				}
+				if (pos > tbts) {
+					if (noSt) err(0);
+					break;
+				}
+				if (resize) cbuf(bt + 131072);
+				var end = bt + add;
+				if (bt < dt) {
+					var shift = dl - dt, dend = Math.min(dt, end);
+					if (shift + bt < 0) err(3);
+					for (; bt < dend; ++bt) buf[bt] = dict[shift + bt];
+				}
+				for (; bt < end; ++bt) buf[bt] = buf[bt - dt];
+			}
+		}
+		st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+		if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+	} while (!final);
+	return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /*#__PURE__*/ new u8(0);
+var gzs = function(d) {
+	if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
+	var flg = d[3];
+	var st = 10;
+	if (flg & 4) st += (d[10] | d[11] << 8) + 2;
+	for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]);
+	return st + (flg & 2);
+};
+var gzl = function(d) {
+	var l = d.length;
+	return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+};
+function gunzipSync(data, opts) {
+	var st = gzs(data);
+	if (st + 8 > data.length) err(6, "invalid gzip data");
+	return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
 }
+var td = typeof TextDecoder != "undefined" && /*#__PURE__*/ new TextDecoder();
+try {
+	td.decode(et, { stream: true });
+} catch (e) {}
 //#endregion
 //#region src/artifacts/payloads.ts
 /**
@@ -110,4 +491,4 @@ function createPayloadLoaders(chunks) {
 	return loaders;
 }
 //#endregion
-export { createArtifactRevision, createArtifactRuntime, createLiveRuntime, createPayloadLoaders, decodeCompressed, restoreContentError };
+export { createArtifactCollection, createArtifactCollections, createArtifactRevision, createLiveCollection, createPayloadLoaders, decodeCompressed, restoreContentError };

package/dist/next.d.mts

@@ -1,4 +1,4 @@
-import { t as BuildContentOptions } from "./build-DL1GzmRy.mjs";
+import { t as BuildContentOptions } from "./build-Aoi7Unm0.mjs";
 import { NextConfig } from "next";
 //#region src/integrations/next/plugin.d.ts
 /** Content locations for Next.js; the adapter chooses generated storage and the watch lifecycle. */
@@ -9,7 +9,8 @@ type ConfigContext = {
 type ConfigInput = NextConfig | Promise<NextConfig> | ((phase: string, context: ConfigContext) => NextConfig | Promise<NextConfig>);
 /**
  * Builds content before Next compiles, retaining one managed watcher during `next dev`.
- * Import the generated server entry from Server Components; Next's HMR observes its updates.
+ * Import each collection's generated entry, such as `#content-query/posts`, from Server
+ * Components; Next's HMR observes their updates, and each route traces only what it imports.
  * Next's detached telemetry helper evaluates configuration without starting content sessions.
  * @param nextConfig Existing object, promise, or phase-aware Next.js configuration.
  * @param options Optional content configuration file and generated output directory.

package/dist/next.mjs

@@ -1,10 +1,12 @@
-import { c as contentDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-CcqIpkes.mjs";
+import { I as collectionNames } from "./operators-D-w1-gDg.mjs";
+import { c as collectionDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-CIw4yWs9.mjs";
 import { n as serializeContentError } from "./diagnostics-DmUZtrJ6.mjs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
 import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "next/constants.js";
 //#region src/integrations/next/publication.ts
+const developmentEntry = /^next-dev-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}\.js$/;
 /** Switches a development entry synchronously so error delivery cannot race a later publication. */
 function writeEntry(filename, source) {
 	try {
@@ -19,25 +21,75 @@ function writeEntry(filename, source) {
 		rmSync(temporary, { force: true });
 	}
 }
-/** Publishes fresh runtime imports and optionally prunes previous runs after a successful build. */
+/** Lists one directory's entries, treating a missing directory as empty. */
+function entriesOf(directory) {
+	try {
+		return readdirSync(directory);
+	} catch (cause) {
+		const code = cause && typeof cause === "object" && "code" in cause ? cause.code : void 0;
+		if (code === "ENOENT" || code === "ENOTDIR") return [];
+		throw cause;
+	}
+}
+/** Lists the directories of collection entries that exist from an earlier publication. */
+function publishedCollections(outDir) {
+	const collections = path.join(outDir, "collections");
+	return entriesOf(collections).map((name) => path.join(collections, name)).filter((directory) => existsSync(path.join(directory, "server.js")));
+}
+/** Points one entry at a fresh copy of its runtime, so Next reloads it even for identical bytes. */
+function redirectEntry(directory, exportName, filename) {
+	const entry = path.join(directory, "server.js");
+	const runtime = path.join(directory, filename);
+	writeEntry(runtime, readFileSync(entry, "utf8"));
+	writeEntry(entry, `export { ${exportName} } from ${JSON.stringify(`./${filename}`)};\n`);
+	return runtime;
+}
+/**
+* Publishes fresh runtime imports and optionally prunes previous runs after a successful build.
+*
+* Each collection entry, `collections/<export name>/server.js`, is pointed at a fresh copy of its
+* runtime. A preparation error replaces every entry, so each route that imports one reports it.
+*
+* @param outDir - Generated output directory.
+* @param config - Absolute path of content-query.config.
+* @param state - The session's current revision or error.
+* @param options - `prune` removes development entries from previous runs.
+* @returns The new runtime modules, or `undefined` when nothing valid was published.
+*/
 function publishDevelopment(outDir, config, state, { prune = false } = {}) {
 	if (!state.error) {
 		if (!state.revision) return;
-		const entry = path.join(outDir, "server.js");
 		const filename = `next-dev-${randomUUID()}.js`;
-		const runtime = path.join(outDir, filename);
-		writeEntry(runtime, readFileSync(entry, "utf8"));
-		writeEntry(entry, `export { content } from ${JSON.stringify(`./${filename}`)};\n`);
+		const runtimes = [...collectionNames(state.revision.registry).values()].map(({ exportName }) => redirectEntry(path.join(outDir, "collections", exportName), exportName, filename));
 		if (prune) pruneDevelopmentEntries(outDir, filename);
-		return runtime;
+		return runtimes;
+	}
+	const failure = `import { restoreContentError } from "content-query/internal";\nthrow restoreContentError(${JSON.stringify(serializeContentError(state.error))});\n`;
+	const directories = new Map(publishedCollections(outDir).map((directory) => [directory, path.basename(directory)]));
+	for (const [name, generated] of collectionNames(state.registry ?? {})) {
+		const directory = path.join(outDir, "collections", generated.exportName);
+		directories.set(directory, generated.exportName);
+		writeEntry(path.join(directory, "server.d.ts"), collectionDeclarations(directory, config, name, generated));
 	}
 	writeEntry(path.join(outDir, "package.json"), "{\"type\":\"module\",\"private\":true}\n");
-	writeEntry(path.join(outDir, "server.d.ts"), contentDeclarations(outDir, config));
-	writeEntry(path.join(outDir, "server.js"), `import { restoreContentError } from "content-query/internal";\nthrow restoreContentError(${JSON.stringify(serializeContentError(state.error))});\nexport const content = undefined;\n`);
+	for (const [directory, exportName] of directories) writeEntry(path.join(directory, "server.js"), `${failure}export const ${exportName} = undefined;\n`);
 }
-/** Removes owned runtime entries from previous runs, preserving the current facade's target. */
+/**
+* Removes owned runtime entries from previous runs, preserving the current entries' target.
+*
+* @param outDir - Generated output directory.
+* @param keep - The current publication's runtime filename, shared by every entry.
+*/
 function pruneDevelopmentEntries(outDir, keep) {
-	for (const filename of readdirSync(outDir)) if (filename !== keep && /^next-dev-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}\.js$/.test(filename)) rmSync(path.join(outDir, filename), { force: true });
+	const collections = path.join(outDir, "collections");
+	const directories = [outDir, ...entriesOf(collections).map((name) => path.join(collections, name))];
+	for (const directory of directories) {
+		const entries = entriesOf(directory);
+		for (const filename of entries) if (filename !== keep && developmentEntry.test(filename)) rmSync(path.join(directory, filename), { force: true });
+		if (directory !== outDir && entries.every((filename) => developmentEntry.test(filename))) try {
+			rmdirSync(directory);
+		} catch {}
+	}
 }
 //#endregion
 //#region src/integrations/next/plugin.ts
@@ -114,7 +166,8 @@ async function startDevelopment(root, options) {
 }
 /**
 * Builds content before Next compiles, retaining one managed watcher during `next dev`.
-* Import the generated server entry from Server Components; Next's HMR observes its updates.
+* Import each collection's generated entry, such as `#content-query/posts`, from Server
+* Components; Next's HMR observes their updates, and each route traces only what it imports.
 * Next's detached telemetry helper evaluates configuration without starting content sessions.
 * @param nextConfig Existing object, promise, or phase-aware Next.js configuration.
 * @param options Optional content configuration file and generated output directory.