content-query 0.3.0 → 0.5.0

package/dist/internal.d.mts

@@ -1,12 +1,16 @@
-import { n as createLiveRuntime, o as ContentError, r as PreparedRevision, t as Content } from "./content-lwPxE9Yu.mjs";
+import { n as Collection, r as CollectionHandles, s as ContentError } from "./collection-types-CsQtGw7_.mjs";
 import { n as ContentRenderResult } from "./types-Dh-Sydyw.mjs";
-import { i as CollectionRegistry } from "./types-BC8gVJ6u.mjs";
-import { v as QueryRegistry } from "./relational-types-B45zM34W.mjs";
+import { i as CollectionRegistry } from "./types-Dz1vTXa2.mjs";
+import { O as QueryRegistry } from "./relational-types-CTcalUNW.mjs";
+import { n as QueryStyle } from "./query-style-C2FcT1f9.mjs";
+import { n as PreparedRevision, t as ContentState } from "./revision-DBwU-aC9.mjs";
 //#region src/artifacts/types.d.ts
 type ArtifactManifest = {
   version: number;
   codec: string;
   collections: QueryRegistry;
+  /** Optional and additive, so it needs no version bump; absent allows both query styles. */
+  queryStyle?: QueryStyle;
 };
 type EncodedCollection = {
   records: readonly string[];
@@ -14,13 +18,43 @@ type EncodedCollection = {
   builtins: Record<string, () => Promise<{
     default: string;
   }>>;
+  /** Lazy encoded custom payloads by payload name, entry ID, and canonical variant key. */
+  payloads?: Record<string, Record<string, Record<string, () => Promise<{
+    default: string;
+  }>>>>;
 };
 //#endregion
 //#region src/artifacts/runtime.d.ts
-/** Initializes generated/embedded prepared content. This versioned wiring is internal. */
+/**
+ * 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.
+ */
 export declare function createArtifactRevision(manifest: ArtifactManifest, collections: Record<string, EncodedCollection>, renderMarkdown?: (body: string) => Promise<ContentRenderResult>): PreparedRevision;
-/** Initializes the public generated server export from a complete immutable artifact revision. */
-export declare function createArtifactRuntime<Registry extends CollectionRegistry>(manifest: ArtifactManifest, collections: Record<string, EncodedCollection>, renderMarkdown?: (body: string) => Promise<ContentRenderResult>): Content<Registry>;
+/**
+ * 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.
+ */
+export declare function createArtifactCollection<Registry extends CollectionRegistry, Name extends keyof Registry & string, Style extends QueryStyle = QueryStyle>(manifest: ArtifactManifest, name: Name, collection: EncodedCollection, renderMarkdown?: (body: string) => Promise<ContentRenderResult>): Collection<Registry, Name, Style>;
+/**
+ * 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.
+ */
+export declare function createArtifactCollections<Registry extends CollectionRegistry, Style extends QueryStyle = QueryStyle>(manifest: ArtifactManifest, collections: Record<string, EncodedCollection>, renderMarkdown?: (body: string) => Promise<ContentRenderResult>): CollectionHandles<Registry, Style>;
 //#endregion
 //#region src/artifacts/payloads.d.ts
 /**
@@ -47,8 +81,21 @@ type PayloadChunk = {
  */
 export declare function createPayloadLoaders(chunks: readonly PayloadChunk[]): EncodedCollection["builtins"];
 //#endregion
+//#region src/runtime/collection.d.ts
+/**
+ * Keeps one collection handle live across host-delivered development revisions.
+ *
+ * @param initial - The first prepared state.
+ * @param name - The collection the handle queries.
+ * @returns The handle and an `update()` that switches its state to a newer revision or error.
+ */
+export declare function createLiveCollection(initial: ContentState, name: string): {
+  collection: object;
+  update(next: ContentState): void;
+};
+//#endregion
 //#region src/runtime/diagnostics.d.ts
 /** Restores the library error and its causes in a generated or isolated development runtime. */
 export declare function restoreContentError(encoded: string): ContentError;
 //#endregion
-export { createLiveRuntime };
+export {};

package/dist/internal.mjs

@@ -1,13 +1,62 @@
-import { t as ContentError } from "./errors-C2iuBM0G.mjs";
+import { t as ContentError } from "./errors-Bfd0R4_P.mjs";
 import { r as decode } from "./values-BbTV4QT-.mjs";
-import { i as prepareRelationships, n as createRuntime, t as createLiveRuntime } from "./content-N1gYshjg.mjs";
-import { t as restoreContentError } from "./diagnostics-Cu94mZhl.mjs";
-import { gunzipSync } from "fflate/browser";
+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";
 //#region src/artifacts/runtime.ts
-/** Initializes generated/embedded prepared content. This versioned wiring is internal. */
+/** Checks that a value is a plain record before reading generated payload tables from it. */
+function isTable(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Restores lazy custom payload loaders from a generated payload table.
+*
+* @param collection - The collection name, for error messages.
+* @param payloads - Encoded loaders by payload name, entry ID, and canonical variant key.
+* @returns Decoding loaders with the same keys.
+*/
+function customPayloadTable(collection, payloads) {
+	if (!isTable(payloads)) throw new Error(`Invalid payload table for collection "${collection}".`);
+	return new Map(Object.entries(payloads).map(([payload, entries]) => {
+		if (!isTable(entries)) throw new Error(`Invalid payload table for collection "${collection}".`);
+		return [payload, new Map(Object.entries(entries).map(([id, variants]) => {
+			if (!isTable(variants) || Object.values(variants).some((load) => typeof load !== "function")) throw new Error(`Invalid payload table for collection "${collection}".`);
+			return [id, new Map(Object.entries(variants).map(([variant, load]) => [variant, async () => decode((await load()).default)]))];
+		}))];
+	}));
+}
+/**
+* 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,
 			collections: Object.create(null),
@@ -15,21 +64,17 @@ function createArtifactRevision(manifest, collections, renderMarkdown) {
 			active: 0,
 			payloadCache: /* @__PURE__ */ new Map(),
 			renderCache: /* @__PURE__ */ new Map(),
-			renderMarkdown
+			renderMarkdown,
+			...manifest.queryStyle ? { queryStyle: manifest.queryStyle } : {}
 		};
 		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)]))
+				...decodeCollection(name, encoded),
+				relationships: descriptor.relationships
 			};
 		}
-		const errors = prepareRelationships(revision);
-		if (errors.length) throw errors[0];
 		return revision;
 	} catch (cause) {
 		throw new ContentError({
@@ -39,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
 /**
@@ -86,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/loaders.d.mts

@@ -1,5 +1,4 @@
-import { a as FileSource, c as LoaderContext, d as LoaderWatcher, f as MetaStore, i as FileEntrySource, l as LoaderLogger, n as DataEntry, o as Loader, p as RecordLoader, r as DataStore, s as LoaderConfig, t as BodyLoader, u as LoaderSource } from "./types-FmUJ3cH1.mjs";
-import { n as GlobOptions, t as FileOptions } from "./descriptor-BUPT2J7X.mjs";
+import { a as DataStore, c as Loader, d as LoaderLogger, f as LoaderSource, h as RecordLoader, i as DataEntry, l as LoaderConfig, m as MetaStore, n as GlobOptions, o as FileEntrySource, p as LoaderWatcher, r as BodyLoader, s as FileSource, t as FileOptions, u as LoaderContext } from "./descriptor-bcPa6XLk.mjs";
 //#region src/loaders/file.d.ts
 /** Declares a multi-entry data file with typed source paths and record keys, plus an optional parser. */
 export declare function file(filename: string, options?: FileOptions): RecordLoader<FileEntrySource>;

package/dist/loaders.mjs

@@ -1,85 +1,6 @@
-import { o as builtinPath, s as builtinSymbol } from "./validation-D_XdE1pF.mjs";
-import { i as groupDiagnostics, n as contentError, r as describeCause, t as ContentError } from "./errors-C2iuBM0G.mjs";
-import { a as populateStore, i as recordData, n as coerceIdentity, r as parseData, t as glob } from "./glob-Bv0dpvCQ.mjs";
+import { t as glob } from "./glob-BXJuwy_p.mjs";
 import { t as assertServerOnly } from "./server-only-CIJUlyL-.mjs";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-//#region src/loaders/file.ts
-/** Declares a multi-entry data file with typed source paths and record keys, plus an optional parser. */
-function file(filename, options = {}) {
-	if (typeof filename !== "string" || !filename) throw new TypeError("file() requires a filename.");
-	const descriptor = {
-		kind: "file",
-		filename,
-		options
-	};
-	return {
-		[builtinSymbol]: descriptor,
-		name: "content-query/file",
-		async load(context) {
-			const entries = await loadFile(descriptor, fileURLToPath(context.config.root), context.signal ?? new AbortController().signal);
-			await populateStore(context, entries);
-		}
-	};
-}
-/** Captures a complete multi-entry data source without applying collection validation. */
-async function loadFile(descriptor, root, signal) {
-	const resolved = builtinPath(descriptor, root);
-	let parsed;
-	try {
-		const text = await readFile(resolved, {
-			encoding: "utf8",
-			signal
-		});
-		parsed = descriptor.options.parser ? await descriptor.options.parser(text) : parseData(text, resolved);
-	} catch (cause) {
-		signal.throwIfAborted();
-		throw contentError(cause, {
-			code: "source-error",
-			source: resolved,
-			message: `Could not load "${descriptor.filename}": ${describeCause(cause)}`,
-			cause
-		});
-	}
-	const array = Array.isArray(parsed);
-	if (!array && (!parsed || typeof parsed !== "object")) throw new ContentError({
-		code: "source-error",
-		source: resolved,
-		message: `"${descriptor.filename}" must parse to an array or keyed record.`
-	});
-	const diagnostics = [];
-	const entries = Object.entries(parsed).flatMap(([key, value]) => {
-		if (!array && key === "$schema" && typeof value === "string") return [];
-		const source = `${resolved}#${key}`;
-		try {
-			const data = recordData(value);
-			const identity = array ? data.id ?? data.slug : key;
-			if (identity == null || coerceIdentity(identity) === "") throw new Error("Array entries require a nonempty id or slug.");
-			const { id: _transportId, ...metadata } = data;
-			return [{
-				id: coerceIdentity(identity),
-				data: metadata,
-				source: array ? source : `${resolved}#${coerceIdentity(identity)}`,
-				sourceData: {
-					filePath: path.relative(root, resolved).split(path.sep).join("/"),
-					key
-				}
-			}];
-		} catch (cause) {
-			diagnostics.push({
-				code: "source-error",
-				source,
-				message: `Invalid entry "${key}" in "${descriptor.filename}": ${describeCause(cause)}`,
-				cause
-			});
-			return [];
-		}
-	});
-	if (diagnostics.length) throw groupDiagnostics(diagnostics);
-	return entries;
-}
-//#endregion
+import { t as file } from "./file-DSOcdFj0.mjs";
 //#region src/loaders.ts
 assertServerOnly();
 //#endregion

package/dist/next.d.mts

@@ -1,4 +1,4 @@
-import { t as BuildContentOptions } from "./build-jKnjDjQE.mjs";
+import { t as BuildContentOptions } from "./build-DfoncKL8.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.