content-query 0.3.0 → 0.5.0

package/dist/types-Dz1vTXa2.d.mts

@@ -0,0 +1,214 @@
+import { c as Loader, n as GlobOptions, t as FileOptions } from "./descriptor-bcPa6XLk.mjs";
+import { n as ContentRenderResult, r as RenderedContent } from "./types-Dh-Sydyw.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/collection/types.d.ts
+declare const builtinPayloadsType: unique symbol;
+declare const customPayloadsType: unique symbol;
+declare const loadedCollectionsType: unique symbol;
+type Schema = StandardSchemaV1;
+type SchemaOutput<Value> = Value extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<Value> : Record<string, unknown>;
+/** One file or record that a `files` helper read, shaped like a loader entry. */
+type FileEntry<Data = Record<string, unknown>> = {
+  id: string;
+  data: Data;
+  /** The Markdown body, when the file is Markdown and `retainBody` is not `false`. */
+  body?: string;
+  /** The file's path relative to the project root. */
+  filePath: string;
+};
+/**
+ * Tracked file access for computed and payload resolvers. Paths are relative to the entry's
+ * folder and must stay inside it or one of the collection's `sharedFiles` directories. Every read
+ * is recorded, so editing, adding, or removing a file re-resolves only what read it.
+ */
+type EntryFiles = {
+  /** Lists and parses files like `glob()`, with `base` relative to the entry's folder. */
+  glob<FileSchema extends Schema | undefined = undefined>(options: Omit<GlobOptions, "base" | "deferRender"> & {
+    base?: string;
+    schema?: FileSchema;
+  }): Promise<FileEntry<SchemaOutput<FileSchema>>[]>;
+  /** Parses one data file's records like `file()`, returning one entry per record. */
+  file<FileSchema extends Schema | undefined = undefined>(filePath: string, options?: FileOptions & {
+    schema?: FileSchema;
+  }): Promise<FileEntry<SchemaOutput<FileSchema>>[]>;
+  /** Reads a file as UTF-8 text. */
+  text(filePath: string): Promise<string>;
+  /** Reads a file's bytes. */
+  bytes(filePath: string): Promise<Uint8Array>;
+  /** Renders Markdown with the built-in renderer, like a loader's `renderMarkdown()`. */
+  renderMarkdown(body: string): Promise<RenderedContent>;
+};
+type ComputedContext<Data, Source = unknown> = {
+  /** The collection's key in the configured registry. */
+  collection: string;
+  id: string;
+  /** Loader-provided source metadata, detached from stored entries for this resolver. */
+  source?: Source extends object ? Readonly<Source> : Source;
+  data: Readonly<Data>;
+  readBody(this: void): Promise<string | undefined>;
+  /** Tracked reads of files beside the entry; edits re-prepare the entry. */
+  files: EntryFiles;
+  signal: AbortSignal;
+};
+type ComputedDefinition<Data = Record<string, unknown>, Source = unknown> = {
+  schema: Schema;
+  resolve(context: ComputedContext<Data, Source>): unknown;
+};
+/** Context for a payload's `combinations()` override, with the entry's prepared data. */
+type VariantContext<Data, Source = unknown> = {
+  /** The collection's key in the configured registry. */
+  collection: string;
+  id: string;
+  /** Loader-provided source metadata, detached from stored entries for this resolver. */
+  source?: Source extends object ? Readonly<Source> : Source;
+  /** Validated metadata plus computed fields. */
+  data: Readonly<Data>;
+  signal: AbortSignal;
+};
+/** Context for a custom payload resolver, called once per entry and variant combination. */
+type PayloadContext<Data, Source = unknown, Variant = {}> = VariantContext<Data, Source> & {
+  /** The variant combination being resolved; empty for payloads without variants. */
+  variant: Readonly<Variant>;
+  readBody(this: void): Promise<string | undefined>;
+  /** Tracked reads of files beside the entry; edits re-resolve only this variant. */
+  files: EntryFiles;
+};
+/** Data fields, including computed fields, whose values are string arrays. */
+type VariantField<Data> = { [Field in keyof Data]-?: NonNullable<Data[Field]> extends readonly string[] ? Field : never; }[keyof Data] & string;
+/**
+ * Enumerates one variant key's values: the name of a string-array data field, read per entry, or
+ * a fixed list. Derive values in a computed field when they need logic.
+ */
+type VariantValues<Data> = VariantField<Data> | readonly string[];
+/**
+ * A custom payload: schema-validated data resolved during preparation and loaded only when a
+ * query requests it. Names cannot start with `_`, which built-in payloads such as `_body` use.
+ */
+type PayloadDefinition<Data = Record<string, unknown>, Source = unknown, Variant = {}> = {
+  schema: Schema;
+  /** Variant keys and their values for an entry. Omit for a single payload value. */
+  variants?: Record<string, VariantValues<Data>>;
+  /**
+   * Overrides the default cross product of enumerated values. Each combination must name every
+   * variant key with one of that key's enumerated values.
+   */
+  combinations?(context: VariantContext<Data, Source> & {
+    variants: Readonly<Record<string, readonly string[]>>;
+  }): Iterable<Variant> | PromiseLike<Iterable<Variant>>;
+  resolve(context: PayloadContext<Data, Source, Variant>): unknown;
+  /**
+   * Set to `false` to resolve again in every revision, for resolvers that read data `files` cannot
+   * track, such as a remote API. Defaults to `true`.
+   */
+  cache?: boolean;
+};
+/**
+ * Any payload declaration once its inferred types are erased, as registries and preparation see
+ * it. Typed declarations from `defineCollection` are always assignable.
+ */
+type PayloadDeclaration = {
+  schema: Schema;
+  variants?: Record<string, string | readonly string[]>;
+  combinations?(context: never): unknown;
+  resolve(context: never): unknown;
+  cache?: boolean;
+};
+type Relationship = {
+  collection: string;
+  type: "one" | "many";
+  from: string;
+  to: string;
+  referenceSide: "from" | "to" | "none";
+};
+type CollectionDefinition<SourceSchema extends Schema | undefined = Schema | undefined, Computed extends Record<string, ComputedDefinition<never, never>> = Record<string, ComputedDefinition<never, never>>, Relationships extends Record<string, Relationship> = Record<string, Relationship>> = {
+  loader: Loader;
+  schema?: SourceSchema;
+  computed?: Computed;
+  relationships?: Relationships;
+  payloads?: Record<string, PayloadDeclaration>;
+  /** Directories, relative to the project root, that every entry's `files` helpers may read. */
+  sharedFiles?: readonly string[];
+  /**
+   * The singular name in generated types, such as `"Category"` for `ContentCategory`. Defaults to
+   * the export name without one trailing `s`.
+   */
+  typeName?: string;
+};
+type CollectionRegistry = Record<string, CollectionDefinition>;
+type EntryData<Definition> = Definition extends {
+  schema: infer SourceSchema;
+} ? SchemaOutput<SourceSchema> : Record<string, unknown>;
+type ComputedData<Definition> = Definition extends {
+  computed: infer Computed;
+} ? { [Name in keyof Computed]: Computed[Name] extends {
+  schema: infer ResultSchema;
+} ? SchemaOutput<ResultSchema> : never; } : {};
+type QueryData<Definition> = {
+  id: string;
+} & EntryData<Definition> & ComputedData<Definition>;
+/**
+ * Type-only marker recording which collections a query scope loaded. A marked definition offers
+ * only the relationships whose target is loaded; an unmarked one offers every relationship.
+ */
+type LoadedMarker<Loaded> = {
+  readonly [loadedCollectionsType]?: Loaded;
+};
+/** The collections a marked definition's query scope loaded, or `unknown` when unmarked. */
+type LoadedOf<Definition> = Definition extends {
+  readonly [loadedCollectionsType]?: infer Loaded;
+} ? Loaded : unknown;
+/** The declared relationships, keeping only those into `Loaded` when it is not `unknown`. */
+type RelationshipsInto<Relationships, Loaded, Keep extends boolean> = unknown extends Loaded ? Keep extends true ? Relationships : {} : { [Name in keyof Relationships as (Relationships[Name] extends {
+  collection: Loaded;
+} ? Keep : Keep extends true ? false : true) extends true ? Name : never]: Relationships[Name]; };
+/** Relationships a query can follow: every declared one, or only those into loaded collections. */
+type RelationshipsOf<Definition> = Definition extends {
+  relationships: infer Relationships;
+} ? RelationshipsInto<Relationships, LoadedOf<Definition>, true> : {};
+/**
+ * The type error for a declared relationship whose target collection the query has not loaded,
+ * or `never` for a name that is not such a relationship.
+ */
+type UnavailableRelationship<Definition, Name> = Name extends keyof UnavailableRelationshipsOf<Definition> ? UnavailableRelationshipsOf<Definition>[Name] extends {
+  collection: infer Target extends string;
+} ? `Relationship "${Name & string}" targets the ${Target} collection, which this query has not loaded. Pass it to using().` : never : never;
+/** Declared relationships into collections the query scope has not loaded. */
+type UnavailableRelationshipsOf<Definition> = Definition extends {
+  relationships: infer Relationships;
+} ? RelationshipsInto<Relationships, LoadedOf<Definition>, false> : {};
+/**
+ * Payloads that Markdown sources, `glob()`, and custom loaders provide for every entry.
+ * Built-in names start with an underscore, so they never collide with custom payloads.
+ */
+type BuiltinPayloads = {
+  /** The retained raw body, or undefined when the entry has none or retention is disabled. */
+  _body: string | undefined;
+  /** HTML and headings; entries without a rendering path reject with `not-renderable`. */
+  _rendered: ContentRenderResult;
+};
+/** Type-only marker recording which built-in payloads a defined collection carries. */
+type BuiltinPayloadMarker<Available extends keyof BuiltinPayloads> = {
+  readonly [builtinPayloadsType]?: Available;
+};
+/** One custom payload's validated value type and variant record, as recorded by a definition. */
+type CustomPayload<Value = unknown, Variant = {}> = {
+  value: Value;
+  variant: Variant;
+};
+/** Type-only marker recording a defined collection's custom payload values and variant keys. */
+type CustomPayloadMarker<Payloads extends Record<string, CustomPayload>> = {
+  readonly [customPayloadsType]?: Payloads;
+};
+type CustomPayloadsOf<Definition> = Definition extends {
+  readonly [customPayloadsType]?: infer Payloads;
+} ? Payloads extends Record<string, CustomPayload> ? Payloads : {} : {};
+/** Payload names and value types that queries can request for a collection definition. */
+type PayloadsOf<Definition> = (Definition extends {
+  readonly [builtinPayloadsType]?: infer Available;
+} ? Pick<BuiltinPayloads, Available & keyof BuiltinPayloads> : BuiltinPayloads) & { [Name in keyof CustomPayloadsOf<Definition>]: CustomPayloadsOf<Definition>[Name] extends CustomPayload<infer Value> ? Value : never; };
+/** The value type of one payload that queries return under `_payloads`. */
+type PayloadData<Definition, Name extends keyof PayloadsOf<Definition>> = PayloadsOf<Definition>[Name];
+/** The variant keys a payload request must supply; empty for built-in and single-value payloads. */
+type VariantOf<Definition, Name> = Name extends keyof CustomPayloadsOf<Definition> ? CustomPayloadsOf<Definition>[Name] extends CustomPayload<unknown, infer Variant> ? Variant : {} : {};
+//#endregion
+export { VariantContext as C, VariantValues as E, UnavailableRelationshipsOf as S, VariantOf as T, Relationship as _, ComputedContext as a, SchemaOutput as b, EntryFiles as c, PayloadContext as d, PayloadData as f, QueryData as g, PayloadsOf as h, CollectionRegistry as i, FileEntry as l, PayloadDefinition as m, BuiltinPayloads as n, CustomPayload as o, PayloadDeclaration as p, CollectionDefinition as r, CustomPayloadMarker as s, BuiltinPayloadMarker as t, LoadedMarker as u, RelationshipsOf as v, VariantField as w, UnavailableRelationship as x, Schema as y };

package/dist/vite.d.mts

@@ -1,4 +1,4 @@
-import { a as ContentSourceEvent, o as ContentSourceSnapshot, t as BuildContentOptions } from "./build-jKnjDjQE.mjs";
+import { a as ContentSourceEvent, o as ContentSourceSnapshot, t as BuildContentOptions } from "./build-DfoncKL8.mjs";
 import { Plugin } from "vite";
 //#region src/integrations/vite/plugin.d.ts
 /** Public, format-neutral hooks for integrations sharing this plugin's preparation session. */

package/dist/vite.mjs

@@ -1,9 +1,13 @@
-import { a as sessionInternals, i as resolveConfigPath, l as virtualDeclarations, o as withinDirectory, r as configCandidates, s as writeChanged, t as buildAtRoot, u as revisionModules } from "./build-CI4s0oFP.mjs";
-import { n as serializeContentError } from "./diagnostics-Cu94mZhl.mjs";
+import { I as collectionNames } from "./operators-D-w1-gDg.mjs";
+import { a as sessionInternals, i as resolveConfigPath, l as virtualDeclarations, o as withinDirectory, r as configCandidates, s as writeChanged, t as buildAtRoot, u as revisionModules } from "./build-DWpB69_c.mjs";
+import { n as serializeContentError } from "./diagnostics-DmUZtrJ6.mjs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
+//#region src/integrations/vite/modules.ts
+/** Collection facades are `content-query:collections/<export name>`. */
+const collectionPrefix = "content-query:collections/";
 const preparedFacade = "content-query:prepared-server";
 const clientModule = "\0content-query:client.js";
 const virtualPrefix = "\0content-query:";
@@ -51,24 +55,38 @@ export function onContentUpdate(callback) {
 async function preparedModules(state) {
 	const revision = state.revision;
 	const error = state.error;
-	let next;
 	if (error) {
 		const serialized = serializeContentError(error);
-		next = /* @__PURE__ */ new Map([["server.js", `import { restoreContentError } from "content-query/internal"; export const revision = undefined; export const registry = JSON.parse(${JSON.stringify(JSON.stringify(state.registry ?? {}))}); export const error = restoreContentError(${JSON.stringify(serialized)});`]]);
-	} else {
-		next = await revisionModules(revision, { payloadChunkBytes: 131072 });
-		next.set("server.js", next.get("server.js").replaceAll("createArtifactRuntime", "createArtifactRevision").replace("export const content =", "export const revision =") + "\nexport const registry = revision.registry; export const error = undefined;\n");
+		return /* @__PURE__ */ new Map([["prepared-server.js", `import { restoreContentError } from "content-query/internal"; export const revision = undefined; export const registry = JSON.parse(${JSON.stringify(JSON.stringify(state.registry ?? {}))}); export const error = restoreContentError(${JSON.stringify(serialized)});`]]);
 	}
-	return next;
+	return revisionModules(revision, {
+		payloadChunkBytes: 131072,
+		preparedEntry: true
+	});
 }
-/** Creates the stable facade that accepts revision updates in host and isolated dev runtimes. */
-function devFacade(bridgeKey) {
-	return `import { createLiveRuntime } from "content-query/internal";
-import * as prepared from ${JSON.stringify(preparedFacade)};
-const live = createLiveRuntime(prepared);
-export const content = globalThis[Symbol.for("content-query.dev-sessions")]?.get(${JSON.stringify(bridgeKey)})?.content ?? live.content;
+/** Picks a module-local binding that cannot shadow the facade's export name. */
+function binding(base, exportName) {
+	return base === exportName ? `${base}_` : base;
+}
+/**
+* Creates one collection's stable facade, which accepts revision updates in host and isolated
+* development runtimes.
+*
+* @param bridgeKey - Identifies the plugin's host session for runtimes in the same process.
+* @param name - The collection's name.
+* @param exportName - The facade's export name.
+* @returns The facade module source.
+*/
+function devFacade(bridgeKey, name, exportName) {
+	const runtime = binding("runtime", exportName);
+	const prepared = binding("prepared", exportName);
+	const live = binding("live", exportName);
+	return `import * as ${runtime} from "content-query/internal";
+import * as ${prepared} from ${JSON.stringify(preparedFacade)};
+const ${live} = ${runtime}.createLiveCollection(${prepared}, ${JSON.stringify(name)});
+export const ${exportName} = globalThis[Symbol.for("content-query.dev-sessions")]?.get(${JSON.stringify(bridgeKey)})?.collections[${JSON.stringify(name)}] ?? ${live}.collection;
 if (import.meta.hot) {
- const apply = next => { if (next) live.update(next); };
+ const apply = next => { if (next) ${live}.update(next); };
  import.meta.hot.accept(${JSON.stringify(preparedFacade)}, apply);
  // Module runners unwrap virtual IDs in update messages. Register that form too.
  const hot = import.meta.hot;
@@ -109,6 +127,8 @@ function forbidden(source, config, options, importer) {
 //#endregion
 //#region src/integrations/vite/plugin.ts
 const bridgeSymbol = Symbol.for("content-query.dev-sessions");
+/** Matches a collection facade's virtual ID and captures its export name. */
+const facadeModule = /^\0content-query:collections\/([^/]+)\/server\.js$/;
 /** Integrates in-memory content with Vite; opt into generated storage for standalone artifacts. */
 function contentQuery(options = {}) {
 	let config;
@@ -123,10 +143,18 @@ function contentQuery(options = {}) {
 	const bridgeKey = randomUUID();
 	const refreshClients = /* @__PURE__ */ new WeakSet();
 	const sourceListeners = /* @__PURE__ */ new Set();
-	/** Publishes type-only facade binding without importing configuration in executable code. */
-	async function writeTypes(configPath) {
+	let configFile;
+	/** Publishes type-only facade bindings without importing configuration in executable code. */
+	async function writeTypes(registry) {
+		if (!configFile || !registry) return;
 		const directory = path.join(config.root, ".content-query");
-		await writeChanged(path.join(directory, "types.d.ts"), virtualDeclarations(directory, configPath));
+		await writeChanged(path.join(directory, "types.d.ts"), virtualDeclarations(directory, configFile, collectionNames(registry)));
+	}
+	/** Maps a collection facade's export name back to its collection, or undefined when unknown. */
+	function collectionOf(exportName) {
+		const state = session && sessionInternals(session).state;
+		const registry = state?.revision?.registry ?? state?.registry ?? {};
+		for (const [name, generated] of collectionNames(registry)) if (generated.exportName === exportName) return name;
 	}
 	/** Notifies the host after atomic publication or a recoverable preparation failure. */
 	async function refreshModules(state) {
@@ -156,21 +184,24 @@ function contentQuery(options = {}) {
 	/** Notifies every host environment after portable state modules are ready. */
 	async function changed(state) {
 		await refreshModules(state);
+		await writeTypes(state.revision?.registry ?? state.registry).catch(deliveryFailed);
 		if (!server) return;
 		for (const environment of Object.values(server.environments)) {
-			const boundary = environment.moduleGraph.getModuleById(`${virtualPrefix}server.js`);
 			const prepared = environment.moduleGraph.getModuleById(`${virtualPrefix}prepared-server.js`);
-			for (const module of environment.moduleGraph.idToModuleMap.values()) if (module.id === `content-query:prepared-server.js`) environment.moduleGraph.invalidateModule(module);
-			if (boundary && prepared) environment.hot.send({
+			const boundaries = [...environment.moduleGraph.idToModuleMap.values()].filter((module) => facadeModule.test(module.id ?? ""));
+			if (prepared) environment.moduleGraph.invalidateModule(prepared);
+			const timestamp = Date.now();
+			const updates = prepared ? boundaries.map((boundary) => ({
+				type: "js-update",
+				timestamp,
+				path: boundary.url,
+				acceptedPath: prepared.url,
+				explicitImportRequired: false,
+				isWithinCircularImport: false
+			})) : [];
+			if (updates.length) environment.hot.send({
 				type: "update",
-				updates: [{
-					type: "js-update",
-					timestamp: Date.now(),
-					path: boundary.url,
-					acceptedPath: prepared.url,
-					explicitImportRequired: false,
-					isWithinCircularImport: false
-				}]
+				updates
 			});
 		}
 		if (state.error) server.ws.send({
@@ -232,7 +263,9 @@ function contentQuery(options = {}) {
 					global[bridgeSymbol].set(bridgeKey, prepared);
 					await refreshModules(sessionInternals(prepared).state);
 				}
-				await writeTypes(configPath);
+				configFile = configPath;
+				const state = sessionInternals(prepared).state;
+				await writeTypes(state.revision?.registry ?? state.registry);
 			} catch (cause) {
 				await prepared.dispose();
 				globalThis[bridgeSymbol]?.delete(bridgeKey);
@@ -283,25 +316,34 @@ function contentQuery(options = {}) {
 		},
 		resolveId(source, importer, resolveOptions) {
 			if (clientEnvironment(this, config, resolveOptions.ssr) && forbidden(source, config, options, importer)) this.error(`[content-query] Server-only import "${source}" is reachable from a client module${importer ? `: ${importer}` : "."}`);
-			if (source === "content-query:server") return `${virtualPrefix}server.js`;
+			if (source.startsWith("content-query:collections/")) return `${virtualPrefix}collections/${source.slice(26)}/server.js`;
 			if (source === "content-query:client") return clientModule;
 			if (source === "content-query:prepared-server") return `${virtualPrefix}prepared-server.js`;
 			if (source.startsWith("\0content-query:")) return source;
 			if (source.startsWith(".") && importer?.startsWith("\0content-query:")) return `${virtualPrefix}${path.posix.normalize(path.posix.join(path.posix.dirname(importer.slice(15)), source))}`;
-			if (physicalPath(source, config, importer) === path.resolve(config.root, options.outDir ?? "./.content-query", "server.js")) return `${virtualPrefix}server.js`;
+			const physical = physicalPath(source, config, importer);
+			const entries = path.resolve(config.root, options.outDir ?? "./.content-query", "collections");
+			const relative = physical ? path.relative(entries, physical).replace(/\\/g, "/") : "";
+			if (/^[^/.][^/]*\/server\.js$/.test(relative)) return `${virtualPrefix}collections/${relative}`;
 		},
 		async load(id, loadOptions) {
 			if (id === "\0content-query:client.js") return devClient(config.command === "serve");
 			if (!id.startsWith("\0content-query:")) return;
 			if (clientEnvironment(this, config, loadOptions?.ssr)) this.error("[content-query] Content runtime cannot be loaded by the client.");
 			await ensureSession();
+			const facade = facadeModule.exec(id)?.[1];
+			/** Reports an import of a collection that the configuration does not define. */
+			const unknown = (exportName) => this.error(`[content-query] "${collectionPrefix}${exportName}" does not match a collection in content-query.config.`);
 			if (config.command === "serve") {
 				await refreshModules(sessionInternals(session).state);
-				if (id === `content-query:server.js`) return devFacade(bridgeKey);
-				if (id === `content-query:prepared-server.js`) return modules.get("server.js");
+				if (facade !== void 0) {
+					const name = collectionOf(facade);
+					return name === void 0 ? unknown(facade) : devFacade(bridgeKey, name, facade);
+				}
 				return modules.get(id.slice(15));
 			}
-			return modules.get(id.slice(15));
+			const code = modules.get(id.slice(15));
+			return facade !== void 0 && code === void 0 ? unknown(facade) : code;
 		},
 		transform(_code, id, transformOptions) {
 			if (clientEnvironment(this, config, transformOptions?.ssr) && forbidden(id, config, options)) this.error(`[content-query] Server-only module is reachable from the client: ${id}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "content-query",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Typed, framework-independent content collections, queries, and rendering.",
   "homepage": "https://github.com/yangshun/content-query#readme",
   "bugs": {

package/dist/content-lwPxE9Yu.d.mts

@@ -1,109 +0,0 @@
-import { n as ContentRenderResult } from "./types-Dh-Sydyw.mjs";
-import { c as Relationship, i as CollectionRegistry, l as RelationshipsOf, s as QueryData } from "./types-BC8gVJ6u.mjs";
-import { _ as QueryPlan, n as RelationalQueries, t as RelationalCountOptions, u as Query, v as QueryRegistry } from "./relational-types-B45zM34W.mjs";
-//#region src/shared/errors.d.ts
-type ContentErrorCode = "variant-not-found" | "not-renderable" | "source-error" | "validation-error" | "duplicate-id" | "invalid-reference" | "invalid-query" | "artifact-error" | "render-error";
-type ContentDiagnostic = {
-  code: ContentErrorCode;
-  message: string;
-  operation?: string;
-  collection?: string;
-  id?: string;
-  source?: string;
-  path?: readonly PropertyKey[];
-  issues?: readonly unknown[];
-  cause?: unknown;
-};
-/** A contextual library failure; inspect code and diagnostics instead of message text. */
-declare class ContentError extends Error {
-  /** Recognizes contextual errors across preparation and separately bundled loader modules. */
-  static [Symbol.hasInstance](value: unknown): boolean;
-  readonly code: ContentErrorCode;
-  readonly operation?: string;
-  readonly collection?: string;
-  readonly id?: string;
-  readonly source?: string;
-  readonly path?: readonly PropertyKey[];
-  readonly issues?: readonly unknown[];
-  readonly diagnostics: readonly ContentDiagnostic[];
-  /** Creates one failure or a grouped report preserving individual causes and issues. */
-  constructor(options: ContentDiagnostic & {
-    diagnostics?: readonly ContentDiagnostic[];
-  });
-}
-//#endregion
-//#region src/collection/registry-types.d.ts
-type Scalar = string | number | bigint | boolean | Date;
-type Element<Value> = NonNullable<Value> extends readonly (infer Item)[] ? NonNullable<Item> : NonNullable<Value>;
-type Compatible<Left, Right> = NonNullable<Left> extends readonly unknown[] ? NonNullable<Right> extends readonly unknown[] ? false : ScalarCompatible<Left, Right> : ScalarCompatible<Left, Right>;
-type ScalarCompatible<Left, Right> = [Element<Left> | Element<Right>] extends [Scalar] ? [Element<Left>] extends [never] ? true : [Element<Right>] extends [never] ? true : [Extract<Element<Left>, Element<Right>> | Extract<Element<Right>, Element<Left>>] extends [never] ? false : true : false;
-type CheckRelation<Registry extends CollectionRegistry, Name extends keyof Registry, Link extends Relationship> = Link["collection"] extends keyof Registry ? Link["from"] extends keyof QueryData<Registry[Name]> ? Link["to"] extends keyof QueryData<Registry[Link["collection"]]> ? Compatible<QueryData<Registry[Name]>[Link["from"]], QueryData<Registry[Link["collection"]]>[Link["to"]]> extends true ? never : "incompatible-relationship-fields" : "unknown-target-field" : "unknown-source-field" : "unknown-target-collection";
-/** Registry-level relationship checks require the complete inferred collection map. */
-type InvalidRelationships<Registry extends CollectionRegistry> = { [Name in keyof Registry]: { [Link in keyof RelationshipsOf<Registry[Name]>]: RelationshipsOf<Registry[Name]>[Link] extends Relationship ? CheckRelation<Registry, Name, RelationshipsOf<Registry[Name]>[Link]> : "invalid-relationship"; }[keyof RelationshipsOf<Registry[Name]>]; }[keyof Registry];
-//#endregion
-//#region src/query/select.d.ts
-/** A selection whose collection and selected result are inferred when from() is supplied. */
-type SelectFrom<Registry extends CollectionRegistry, Keys extends readonly string[]> = {
-  /** Binds the collection and rejects selected keys that are absent from its prepared data type. */
-  from<Name extends keyof Registry & string>(collection: Name & (Exclude<Keys[number], keyof QueryData<Registry[NoInfer<Name>]>> extends never ? unknown : never)): Query<Registry, Name, Keys extends readonly [] ? QueryData<Registry[Name]> : { [Key in Keys[number]]-?: Key extends keyof QueryData<Registry[Name]> ? QueryData<Registry[Name]>[Key] : never; }, true>;
-};
-//#endregion
-//#region src/runtime/revision.d.ts
-type QueryRecord = Record<string, unknown> & {
-  id: string;
-};
-/** The built-in side payload shared by an entry's `_body` and `_rendered` payloads. */
-type BuiltinPayload = {
-  body?: string;
-  rendered?: ContentRenderResult;
-  markdown?: string;
-};
-type PreparedCollection = {
-  records: readonly QueryRecord[];
-  relationships: Record<string, Relationship>;
-  /** Lazy built-in payloads, present only for entries with a body or rendered output. */
-  builtins: ReadonlyMap<string, () => Promise<BuiltinPayload>>;
-  sources?: ReadonlyMap<string, string | undefined>;
-};
-type PreparedRevision = {
-  registry: QueryRegistry;
-  collections: Record<string, PreparedCollection>;
-  relations: Map<string, Map<string, readonly QueryRecord[]>>;
-  active: number;
-  payloadCache: Map<string, Promise<BuiltinPayload>>;
-  renderCache: Map<string, Promise<ContentRenderResult>>;
-  renderMarkdown?: (body: string) => Promise<ContentRenderResult>;
-  execute?: (plan: QueryPlan, terminal: "all" | "first" | "count", requests: PayloadRequest[]) => Promise<unknown>;
-};
-/** A projected row awaiting the payloads its query scope requested. */
-type PayloadRequest = {
-  target: Record<string, unknown>;
-  collection: string;
-  id: string;
-  payloads: NonNullable<QueryPlan["payloads"]>;
-};
-type ContentState = {
-  revision?: PreparedRevision;
-  registry?: QueryRegistry;
-  error?: ContentError;
-};
-//#endregion
-//#region src/runtime/content.d.ts
-type ContentMethods<Registry extends CollectionRegistry = {}> = {
-  /** Starts a SQL-ordered fluent query; field names are checked against the collection in from(). */
-  select<const Keys extends readonly string[]>(...fields: Keys): SelectFrom<Registry, Keys>;
-  /** Collection-scoped relational queries with typed columns, relationships, payloads, and filters. */
-  readonly query: RelationalQueries<Registry>;
-  /** Counts matching entries before pagination, like the fluent count terminal. */
-  count<Name extends keyof Registry & string>(collection: Name, options?: RelationalCountOptions<Registry, Name>): Promise<number>;
-};
-type Content<Registry extends CollectionRegistry = {}> = InvalidRelationships<Registry> extends never ? ContentMethods<Registry> : {
-  readonly invalidRelationships: InvalidRelationships<Registry>;
-};
-/** Keeps dev builders live across host-delivered revisions while pinning active operations. */
-declare function createLiveRuntime(initial: ContentState): {
-  content: ContentMethods<CollectionRegistry>;
-  update(next: ContentState): void;
-};
-//#endregion
-export { ContentDiagnostic as a, InvalidRelationships as i, createLiveRuntime as n, ContentError as o, PreparedRevision as r, ContentErrorCode as s, Content as t };

package/dist/descriptor-BUPT2J7X.d.mts

@@ -1,18 +0,0 @@
-import { m as MaybePromise } from "./types-FmUJ3cH1.mjs";
-//#region src/loaders/descriptor.d.ts
-type GlobOptions = {
-  pattern: string | string[];
-  base?: string | URL;
-  generateId?: (context: {
-    entry: string;
-    base: URL;
-    data: Record<string, unknown>;
-  }) => string;
-  retainBody?: boolean;
-  deferRender?: boolean;
-};
-type FileOptions = {
-  parser?: (text: string) => MaybePromise<unknown>;
-};
-//#endregion
-export { GlobOptions as n, FileOptions as t };