@lde/search 0.14.0 → 0.16.0

package/dist/adapter.d.ts

@@ -6,7 +6,7 @@
  * deployment author declaring a schema and running searches needs none of
  * this; the main entry point carries that (small) authoring surface.
  */
-export { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, referenceFields, referenceTypeNamed, inlineFramingDepth, fieldNamed, ID_FIELD, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
+export { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, nestedReferenceType, nestedFieldName, referenceFields, referenceTypeNamed, inlineFramingDepth, fieldNamed, datasetField, ID_FIELD, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
 export type { PhysicalFields } from './schema.js';
 export { physicalNameTokens } from './physical-name.js';
 export { filterOperatorFor, filterOperator, isUnsatisfiable, validateQuery, assertValidQuery, pageForOffset, } from './query.js';

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,OAAO,EACP,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,OAAO,EACP,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/adapter.js

@@ -6,6 +6,6 @@
  * deployment author declaring a schema and running searches needs none of
  * this; the main entry point carries that (small) authoring surface.
  */
-export { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, referenceFields, referenceTypeNamed, inlineFramingDepth, fieldNamed, ID_FIELD, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
+export { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, nestedReferenceType, nestedFieldName, referenceFields, referenceTypeNamed, inlineFramingDepth, fieldNamed, datasetField, ID_FIELD, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
 export { physicalNameTokens } from './physical-name.js';
 export { filterOperatorFor, filterOperator, isUnsatisfiable, validateQuery, assertValidQuery, pageForOffset, } from './query.js';

package/dist/engine.d.ts

@@ -116,7 +116,21 @@ export interface SearchHit<OutputField extends string = string> {
  */
 export type ResultDocument<OutputField extends string = string> = Readonly<Partial<Record<OutputField, SearchValue>>>;
 /** A logical field value. */
-export type SearchValue = string | number | boolean | readonly string[] | LocalizedValue | Reference | readonly Reference[];
+export type SearchValue = string | number | boolean | readonly string[] | LocalizedValue | Reference | readonly Reference[] | NestedDocument | readonly NestedDocument[];
+/**
+ * A **nested Search Document**: the referent of a surfaced (`output`) inline
+ * reference, carrying its Reference Type’s own output fields – each referent’s
+ * values grouped together, so a multi-valued reference never degrades into
+ * parallel arrays a consumer has to pair by index.
+ *
+ * `id` is present only when the referent is a named node: nesting carries the
+ * referent’s fields, not a document key, so a blank-node referent nests exactly
+ * like a named one, minus the `id`. Distinct from {@link Reference}, which is
+ * what an `idOnly`/`labelOnly` reference carries – there the IRI *is* the value.
+ */
+export interface NestedDocument {
+    readonly [field: string]: SearchValue | undefined;
+}
 /**
  * A JSON-LD-style language map (`@container: @language`, `@set` arrays); the key
  * `und` carries untagged (`@none`) values. The surface flattens it to a

package/dist/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { projectRoots } from './project.js';
-export type { ProjectedNode, SearchDocument } from './project.js';
+export type { ProjectedNode, ProjectionContext, SearchDocument, } from './project.js';
 export { defineSearchType, searchSchema, validateSearchType, assertValidSearchType, ID_FIELD, } from './schema.js';
-export type { FieldKind, SearchField, SearchFieldBase, TextField, KeywordField, ReferenceField, NumericField, BooleanField, SearchType, SearchTypeBase, RootType, ReferenceType, RootTypeOf, SearchTypeIssue, SearchSchema, FacetRange, } from './schema.js';
+export type { FieldKind, SearchField, SearchFieldBase, TextField, KeywordField, ReferenceField, NumericField, BooleanField, SearchType, SearchTypeBase, RootType, ReferenceType, RootTypeOf, SearchTypeIssue, SearchSchema, FacetRange, ProjectionValue, } from './schema.js';
 export type { SearchQuery, Filter, Sort } from './query.js';
-export type { SearchEngine, SearchResult, SearchHit, ResultDocument, SearchValue, LocalizedValue, Reference, FacetBucket, FacetMap, FacetsOutcome, FacetFieldsOf, OutputFieldsOf, } from './engine.js';
+export type { SearchEngine, SearchResult, SearchHit, ResultDocument, SearchValue, LocalizedValue, Reference, NestedDocument, FacetBucket, FacetMap, FacetsOutcome, FacetFieldsOf, OutputFieldsOf, } from './engine.js';
 export type { FramedNode } from './frame-by-type.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAKlE,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,GACT,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACb,UAAU,EACV,eAAe,EACf,YAAY,EACZ,UAAU,GACX,MAAM,aAAa,CAAC;AAIrB,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAI5D,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,WAAW,EACX,cAAc,EACd,SAAS,EACT,WAAW,EACX,QAAQ,EACR,aAAa,EACb,aAAa,EACb,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,cAAc,GACf,MAAM,cAAc,CAAC;AAKtB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,GACT,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACb,UAAU,EACV,eAAe,EACf,YAAY,EACZ,UAAU,EACV,eAAe,GAChB,MAAM,aAAa,CAAC;AAIrB,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAI5D,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,WAAW,EACX,cAAc,EACd,SAAS,EACT,cAAc,EACd,WAAW,EACX,QAAQ,EACR,aAAa,EACb,aAAa,EACb,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/project.d.ts

@@ -1,6 +1,6 @@
 import type { Quad } from '@rdfjs/types';
 import { type FramedNode } from './frame-by-type.js';
-import { type RootType, type SearchSchema, type SearchType } from './schema.js';
+import { type ProjectionValue, type RootType, type SearchSchema, type SearchType } from './schema.js';
 /**
  * A projected node: the fields of one {@link SearchType}, flat. A root always
  * carries the `id` that keys it – it is a {@link SearchDocument} – but an inline
@@ -13,6 +13,21 @@ export type ProjectedNode = Record<string, unknown>;
 export type SearchDocument = {
     id: string;
 } & ProjectedNode;
+/**
+ * What the projection knows that the graph does not say: the values a run
+ * carries about the *indexing* rather than about the data. They reach a
+ * declaration two ways – a field declaring {@link KeywordField.from `from`} is
+ * populated from one, and every `derive` receives the whole context as its
+ * second argument, so a derive can relate a projected value to it.
+ *
+ * Empty when the caller supplies nothing: projecting a graph in isolation (a
+ * test, a one-off) is legitimate, and a field over an absent value is simply
+ * left unpopulated, exactly as a `path` that matched nothing is.
+ */
+export interface ProjectionContext extends Partial<Readonly<Record<ProjectionValue, string>>> {
+    /** The IRI of the dataset being indexed. */
+    readonly dataset?: string;
+}
 /**
  * Project one framed JSON-LD node into a flat search document: apply each field
  * of the type in declaration order. A field with a `derive` function computes
@@ -27,7 +42,7 @@ export type SearchDocument = {
  * fans out to come from {@link physicalFields}, the single source shared with
  * the engine collection definition and the query compiler.
  */
-export declare function projectDocument(node: FramedNode, searchType: SearchType, schema?: SearchSchema): SearchDocument;
+export declare function projectDocument(node: FramedNode, searchType: SearchType, schema?: SearchSchema, context?: ProjectionContext): SearchDocument;
 /**
  * Project a single type over a known set of `roots` – the per-type, roots-given
  * projection. The roots are supplied by the caller (the pipeline selector)
@@ -41,5 +56,5 @@ export declare function projectDocument(node: FramedNode, searchType: SearchType
  * Consumes `quads` once, so it accepts any `Iterable` – a batch’s materialized
  * array or a chained generator merging several readers.
  */
-export declare function projectRoots(quads: Iterable<Quad>, roots: readonly string[], schema: SearchSchema, searchType: RootType): AsyncIterable<SearchDocument>;
+export declare function projectRoots(quads: Iterable<Quad>, roots: readonly string[], schema: SearchSchema, searchType: RootType, context?: ProjectionContext): AsyncIterable<SearchDocument>;
 //# sourceMappingURL=project.d.ts.map

package/dist/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAYL,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,GACpB,cAAc,CAWhB;AAwED;;;;;;;;;;;;GAYG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,QAAQ,GACnB,aAAa,CAAC,cAAc,CAAC,CAW/B"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAWL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAErB;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAChD,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAC1C;IACC,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,EACrB,OAAO,GAAE,iBAAyC,GACjD,cAAc,CAgBhB;AAyED;;;;;;;;;;;;GAYG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,QAAQ,EACpB,OAAO,GAAE,iBAAyC,GACjD,aAAa,CAAC,cAAc,CAAC,CAW/B"}

package/dist/project.js

@@ -1,6 +1,8 @@
 import { fold } from '@lde/text-normalization';
 import { buildSubjectIndex, frameSubjects, } from './frame-by-type.js';
 import { assertTypeInSchema, displayFieldName, inlineFramingDepth, irAlias, isInternalField, isInlineReference, isoToUnixSeconds, physicalFields, referenceTypeNamed, } from './schema.js';
+/** The context a projection runs with when its caller supplied none. */
+const NO_PROJECTION_CONTEXT = {};
 /**
  * Project one framed JSON-LD node into a flat search document: apply each field
  * of the type in declaration order. A field with a `derive` function computes
@@ -15,13 +17,13 @@ import { assertTypeInSchema, displayFieldName, inlineFramingDepth, irAlias, isIn
  * fans out to come from {@link physicalFields}, the single source shared with
  * the engine collection definition and the query compiler.
  */
-export function projectDocument(node, searchType, schema) {
+export function projectDocument(node, searchType, schema, context = NO_PROJECTION_CONTEXT) {
     if (documentKey(node) === undefined) {
         throw new Error(`Cannot project a “${searchType.name}” node without an @id (a blank node label is not one): every search document needs a stable key, and an empty one would collide with other keyless nodes.`);
     }
     // The guard above is what makes this a SearchDocument: projectFields sets `id`
     // for exactly the nodes documentKey resolves.
-    const document = projectFields(node, searchType, schema);
+    const document = projectFields(node, searchType, schema, context);
     pruneInternalFields(document, searchType, schema);
     return document;
 }
@@ -65,11 +67,11 @@ function pruneInternalFields(document, searchType, schema) {
  *  Pruning is deferred to a single recursive pass ({@link pruneInternalFields})
  *  once the whole nested structure is projected, so a derive at any depth can
  *  still read an internal field before it is removed. */
-function projectFields(node, searchType, schema) {
+function projectFields(node, searchType, schema, context) {
     const id = documentKey(node);
     const document = id === undefined ? {} : { id };
     for (const field of searchType.fields) {
-        applyField(document, node, field, searchType, schema);
+        applyField(document, node, field, searchType, schema, context);
     }
     return document;
 }
@@ -97,7 +99,7 @@ function documentKey(node) {
  * Consumes `quads` once, so it accepts any `Iterable` – a batch’s materialized
  * array or a chained generator merging several readers.
  */
-export async function* projectRoots(quads, roots, schema, searchType) {
+export async function* projectRoots(quads, roots, schema, searchType, context = NO_PROJECTION_CONTEXT) {
     assertTypeInSchema(schema, searchType);
     const index = buildSubjectIndex(quads);
     // Distinct roots only. A selector may return an IRI more than once – a
@@ -106,12 +108,18 @@ export async function* projectRoots(quads, roots, schema, searchType) {
     // duplicate document under the same `id`.
     const depth = inlineFramingDepth(schema, searchType);
     for await (const node of frameSubjects(index, [...new Set(roots)], depth)) {
-        yield projectDocument(node, searchType, schema);
+        yield projectDocument(node, searchType, schema, context);
     }
 }
-function applyField(document, node, field, searchType, schema) {
+function applyField(document, node, field, searchType, schema, context) {
+    // The three value sources, mutually exclusive by declaration
+    // (`validateSearchType`): a projection value, a computed value, a graph path.
+    if ((field.kind === 'keyword' || field.kind === 'reference') &&
+        field.from !== undefined) {
+        return applyProjectionValue(document, field, field.from, context);
+    }
     if (field.derive !== undefined) {
-        const value = field.derive(document);
+        const value = field.derive(document, context);
         if (value !== undefined) {
             document[field.name] = value;
         }
@@ -134,7 +142,7 @@ function applyField(document, node, field, searchType, schema) {
         // project nothing rather than fall through and emit the referent IRIs under
         // the field name (the wrong shape).
         if (schema !== undefined) {
-            applyInlineReference(document, node, alias, field, schema);
+            applyInlineReference(document, node, alias, field, schema, context);
         }
         return;
     }
@@ -210,18 +218,56 @@ function foldedSearchValue(values) {
     return fold(values.join(' ')).trim();
 }
 /**
- * Project a faceted multi-value field: dedupe (after the optional transform),
- * write the value field, and – when `searchable` – a folded `${name}_search`
- * array. `keyword` reads literals; `reference` reads IRIs (the caller passes the
+ * Project a faceted field: dedupe (after the optional transform), write the
+ * value field, and – when `searchable` – its folded `${name}_search` companion.
+ * `keyword` reads literals; `reference` reads IRIs (the caller passes the
  * already-read raw values).
+ *
+ * **`array` decides the shape**, as it does for every other kind: a declared
+ * `array` field stores a list, and a single-valued one stores the first value –
+ * the graph may still carry several, exactly as it may carry several literals
+ * for a single-valued `integer` or `date` (which take the first too). Honouring
+ * it here is what keeps the projection, the engine collection definition
+ * (`string` vs `string[]`) and the API output type saying the same thing about
+ * one declaration; a list written into a single-valued field is a document the
+ * engine rejects, or – where it does not type-check, as inside a nested
+ * document – a value the API cannot serialize.
  */
 function applyFacet(document, raw, field) {
     const values = dedupe(field.transform ? raw.map(field.transform) : raw);
-    setArray(document, field.name, values);
+    const folded = dedupe(values.map((value) => fold(value)));
+    const searchField = physicalFields(field).search[0];
+    if (field.array === true) {
+        setArray(document, field.name, values);
+        if (field.searchable) {
+            setArray(document, searchField, folded);
+        }
+        return;
+    }
+    setString(document, field.name, values[0]);
     if (field.searchable) {
-        setArray(document, physicalFields(field).search[0], dedupe(values.map((value) => fold(value))));
+        setString(document, searchField, folded[0]);
     }
 }
+/**
+ * Project a field declared over a {@link ProjectionContext} value: read the
+ * value the run carries and write it exactly as a graph-read one, through
+ * {@link applyFacet} – so `array`, `transform` and the folded `searchable`
+ * companion mean the same thing for a declaration over the dataset as for one
+ * over a path, and the collection definition needs no special case.
+ *
+ * A value the context does not carry writes nothing: a projection run outside a
+ * pipeline (a test, a one-off) leaves the field absent rather than inventing a
+ * placeholder, the same as a `path` that matched nothing.
+ */
+function applyProjectionValue(document, field, from, context) {
+    // `ProjectionContext` is keyed by `ProjectionValue`, so the declaration reads
+    // the context directly: a projection value that has no context key, or a
+    // context key no declaration can name, is a compile error rather than a
+    // silently unpopulated field.
+    const value = context[from];
+    applyFacet(document, value === undefined ? [] : [value], field);
+}
 /**
  * Project an inline reference: the referent node(s) embedded under the field’s
  * {@link irAlias IR Alias} are each projected through the reference’s
@@ -239,7 +285,7 @@ function applyFacet(document, raw, field) {
  * the schema’s declared depth. The referent type is guaranteed declared by
  * {@link searchSchema}.
  */
-function applyInlineReference(document, node, alias, field, schema) {
+function applyInlineReference(document, node, alias, field, schema, context) {
     // Resolves for a schema that declares the referent (always so for the schema a
     // type is projected through); a type framed against a foreign schema that
     // omits it simply contributes no nesting.
@@ -249,7 +295,7 @@ function applyInlineReference(document, node, alias, field, schema) {
     }
     const referents = valuesOf(node, alias)
         .filter(isObject)
-        .map((referent) => projectFields(referent, referenceType, schema))
+        .map((referent) => projectFields(referent, referenceType, schema, context))
         // Fields, not identity, are what makes something a referent: a literal
         // value object under the alias (dirty source data), or a node this
         // reference type reads nothing from, projects nothing and is no referent.

package/dist/schema.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectedNode } from './project.js';
+import type { ProjectedNode, ProjectionContext } from './project.js';
 /**
  * The engine-neutral kind of a queryable field. It drives every downstream
  * behavior: which physical fields the projection emits, the engine
@@ -33,9 +33,13 @@ export declare function filterOperatorFor(kind: FieldKind): FilterOperator | und
  * field with a {@link SearchFieldBase.derive `derive`} function instead of a
  * `path` is a **derived field** – computed from the document projected so far
  * rather than read from the graph – yet it still carries full query/schema/output
- * behavior (e.g. `status`, the compatibility booleans). A field declaring **no**
- * role at all is an {@link isInternalField **internal field**}: projected so a
- * later derive can read it, then pruned before the writer.
+ * behavior (e.g. `status`, the compatibility booleans). A `keyword`/`reference`
+ * field may instead declare {@link KeywordField.from `from`}, populating it from
+ * a {@link ProjectionValue} – something the run knows and the graph does not.
+ * `path`, `derive` and `from` are the three mutually exclusive value sources. A
+ * field declaring **no** role at all is an {@link isInternalField **internal
+ * field**}: projected so a later derive can read it, then pruned before the
+ * writer.
  *
  * The physical field names a declaration fans out to (per-locale search/sort
  * keys) follow one convention, owned by
@@ -58,7 +62,10 @@ export interface SearchFieldBase {
     /** Framed-IR predicate IRI to project from. Omit for a field populated by
      *  {@link SearchFieldBase.derive} (or outside the projection entirely). */
     readonly path?: string;
-    /** Multi-valued. */
+    /** Multi-valued: the field stores a list. Single-valued (the default) stores
+     *  the FIRST value the graph carries, whatever their number – for every kind
+     *  alike – so one declaration cannot mean a list to the projection and a
+     *  scalar to the collection definition and the API. */
     readonly array?: boolean;
     /** Always present: a non-null scalar in the API output and
      *  a non-optional field in the engine index. Moot for arrays/booleans/`id`,
@@ -86,9 +93,30 @@ export interface SearchFieldBase {
      * is the search document for a root type, and the referent’s own
      * projected fields for a Reference Type – which carry an `id` only when the
      * referent is a named node, never for a blank-node one.
+     *
+     * The second argument is the {@link ProjectionContext} – the run’s
+     * projection-time values, which are about the *indexing*, not the graph (the
+     * dataset being indexed). It is what lets a derive relate a projected value
+     * to its provenance: dropping a polymorphic `isPartOf` value that merely
+     * points back at the containing dataset, say.
      */
-    readonly derive?: (document: ProjectedNode) => unknown;
+    readonly derive?: (document: ProjectedNode, context: ProjectionContext) => unknown;
 }
+/**
+ * A projection-time value a field can be declared **over** – something the run
+ * knows that the graph does not say. `dataset` is the IRI of the dataset being
+ * indexed: every indexed document comes from exactly one, and for the many
+ * entity types that carry no containing-collection property (`Person`,
+ * `Organization`, `Place`, …) it is the only available answer to *which dataset
+ * does this come from*.
+ *
+ * A field declaring one is populated by the projection, like a `path`-bearing
+ * or `derive`d field, and carries the full range of behaviour: `output`,
+ * `filterable`, `facetable`, and – for a `reference` – a
+ * {@link ReferenceField.labelSource `labelSource`} that resolves the IRI to a
+ * readable label at query time.
+ */
+export type ProjectionValue = 'dataset';
 /** Full-text inclusion with a `query_by` weight (folded; per-locale for
  *  localized text). Presence is what makes a field searchable. */
 export interface Searchable {
@@ -124,6 +152,9 @@ export interface KeywordField extends SearchFieldBase, Searchable {
     /** Projection-time value transform (e.g. strip a media-type prefix). */
     readonly transform?: (value: string) => string;
     readonly facetRanges?: never;
+    /** Populate from a {@link ProjectionValue} instead of the graph. Mutually
+     *  exclusive with `path` and `derive`. */
+    readonly from?: ProjectionValue;
 }
 /** An IRI-valued reference to another entity, label-resolved at the surface. */
 export interface ReferenceField extends SearchFieldBase, Searchable {
@@ -131,6 +162,11 @@ export interface ReferenceField extends SearchFieldBase, Searchable {
     /** Projection-time value transform. */
     readonly transform?: (value: string) => string;
     readonly facetRanges?: never;
+    /** Populate from a {@link ProjectionValue} instead of the graph – a
+     *  `dataset` reference is how a type declares the dataset it was indexed
+     *  from, resolvable to a label like any other reference. Mutually exclusive
+     *  with `path` and `derive`. */
+    readonly from?: ProjectionValue;
     /**
      * The `name` of the {@link SearchType} whose collection resolves this
      * reference’s labels – its ‘label source’. The named type must declare an
@@ -318,6 +354,34 @@ export declare function isInlineReference(field: SearchField): field is Referenc
         readonly strategy: 'inline';
     };
 };
+/**
+ * The {@link ReferenceType} a **surfaced** inline reference nests – an
+ * `output` inline reference’s referent shape – or `undefined` for every other
+ * field. The one predicate the collection definition, result reconstruction and
+ * the API surfaces share, so they cannot disagree about which fields carry a
+ * nested Search Document and which carry a bare IRI: an inline reference
+ * declaring no Role is a reading device, pruned before the writer
+ * ({@link isInternalField}), and a `labelOnly`/`idOnly` reference stays an id
+ * (plus a resolved label).
+ *
+ * A schema built by {@link searchSchema} always resolves the reference type of
+ * its own types; `undefined` for a type declared against another schema.
+ */
+export declare function nestedReferenceType(schema: SearchSchema, field: SearchField): ReferenceType | undefined;
+/**
+ * The Physical Field name a nested field carries in the engine: the surfaced
+ * inline reference’s own name, then the referent’s physical name –
+ * `media.contentUrl`, `media.label_nl`, and `media.thumbnail.contentUrl` one
+ * hop deeper. The nested counterpart of {@link physicalFields}, and equally the
+ * single home of its convention: the collection definition declares these
+ * names, so a second consumer (a nested filter compiler) reads them from here
+ * rather than restating the separator.
+ *
+ * The nested Search Document itself is keyed by the referent’s own field names
+ * ({@link ProjectedNode}) – the qualification is how an engine that stores
+ * nested documents flat addresses them, never what the projection writes.
+ */
+export declare function nestedFieldName(parent: string, name: string): string;
 /**
  * The framing depth a Root Type needs: how many hops the inline reference graph
  * reaches from it (`Dataset → Subset → Measurement` is two), floored at one so
@@ -344,7 +408,7 @@ export declare function labelFieldOf(searchType: SearchType): TextField | undefi
  */
 export interface SearchTypeIssue {
     readonly field: string;
-    readonly reason: 'duplicate-field-name' | 'invalid-field-name' | 'unknown-kind' | 'invalid-locale' | 'missing-ref' | 'ref-not-allowed' | 'text-requires-locales' | 'locales-not-allowed' | 'facet-ranges-not-allowed' | 'searchable-not-allowed' | 'transform-not-allowed' | 'derive-with-path' | 'text-not-filterable' | 'text-not-facetable' | 'reserved-field-name';
+    readonly reason: 'duplicate-field-name' | 'invalid-field-name' | 'unknown-kind' | 'invalid-locale' | 'missing-ref' | 'ref-not-allowed' | 'text-requires-locales' | 'locales-not-allowed' | 'facet-ranges-not-allowed' | 'searchable-not-allowed' | 'transform-not-allowed' | 'derive-with-path' | 'from-not-allowed' | 'from-with-path' | 'from-with-derive' | 'from-with-inline-ref' | 'unknown-projection-value' | 'duplicate-projection-value' | 'text-not-filterable' | 'text-not-facetable' | 'reserved-field-name';
 }
 /**
  * The reserved logical name of a document’s IRI – the one field every indexed
@@ -383,7 +447,13 @@ export declare const ID_FIELD = "id";
  * - `transform` only on `keyword`/`reference` (the only kinds whose
  *   projection applies it);
  * - `derive` and `path` are mutually exclusive (a field is projected or
- *   computed, never both).
+ *   computed, never both);
+ * - `from` names a known {@link ProjectionValue}, sits on a `keyword`/`reference`
+ *   field, excludes `path` and `derive` (the three are the value sources, and a
+ *   field has exactly one), is not an `inline` reference (a projection value is
+ *   a bare IRI, with no referent to carry fields from), and no two fields
+ *   declare the same projection value – which would leave a consumer reading
+ *   the dataset off a declaration no rule picks between.
  *
  * Pure and total: returns every issue rather than throwing;
  * {@link assertValidSearchType} is the throwing entry point.
@@ -483,6 +553,18 @@ export declare function outputFields(searchType: SearchType): readonly SearchFie
 export declare function isInternalField(field: SearchField): boolean;
 /** Fields of kind `reference` (IRI-valued, label-resolved), in declaration order. */
 export declare function referenceFields(searchType: SearchType): readonly ReferenceField[];
+/**
+ * The field a type declares over the dataset being indexed
+ * ({@link ProjectionValue `from: 'dataset'`}), if it declares one.
+ * {@link validateSearchType} rejects a second field over the same projection
+ * value, so for any type that reached a {@link SearchSchema} this is the only
+ * such field rather than the first of several.
+ *
+ * The single lookup every consumer of the declaration shares – the projection
+ * that populates it, and the engine writer that keeps its provenance
+ * bookkeeping on it rather than on a private field of its own.
+ */
+export declare function datasetField(searchType: SearchType): (KeywordField | ReferenceField) | undefined;
 /** Look up a field by its logical name. */
 export declare function fieldNamed(searchType: SearchType, name: string): SearchField | undefined;
 /**

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"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"}

package/dist/schema.js

@@ -77,6 +77,7 @@ export function searchSchema(...types) {
         .filter((searchType) => !isRootType(searchType))
         .map((searchType) => [searchType.name, searchType]));
     assertResolvableInlineReferences(types, referenceTypes);
+    assertServiceableNestedFields(referenceTypes);
     assertResolvableLabelSources(types);
     // The one blessed cast: only this validated constructor mints the brand.
     const schema = new Map(types
@@ -99,6 +100,40 @@ export function referenceTypeNamed(schema, name) {
 export function isInlineReference(field) {
     return field.kind === 'reference' && field.ref?.strategy === 'inline';
 }
+/**
+ * The {@link ReferenceType} a **surfaced** inline reference nests – an
+ * `output` inline reference’s referent shape – or `undefined` for every other
+ * field. The one predicate the collection definition, result reconstruction and
+ * the API surfaces share, so they cannot disagree about which fields carry a
+ * nested Search Document and which carry a bare IRI: an inline reference
+ * declaring no Role is a reading device, pruned before the writer
+ * ({@link isInternalField}), and a `labelOnly`/`idOnly` reference stays an id
+ * (plus a resolved label).
+ *
+ * A schema built by {@link searchSchema} always resolves the reference type of
+ * its own types; `undefined` for a type declared against another schema.
+ */
+export function nestedReferenceType(schema, field) {
+    return isInlineReference(field) && field.output === true
+        ? referenceTypeNamed(schema, field.ref.typeName)
+        : undefined;
+}
+/**
+ * The Physical Field name a nested field carries in the engine: the surfaced
+ * inline reference’s own name, then the referent’s physical name –
+ * `media.contentUrl`, `media.label_nl`, and `media.thumbnail.contentUrl` one
+ * hop deeper. The nested counterpart of {@link physicalFields}, and equally the
+ * single home of its convention: the collection definition declares these
+ * names, so a second consumer (a nested filter compiler) reads them from here
+ * rather than restating the separator.
+ *
+ * The nested Search Document itself is keyed by the referent’s own field names
+ * ({@link ProjectedNode}) – the qualification is how an engine that stores
+ * nested documents flat addresses them, never what the projection writes.
+ */
+export function nestedFieldName(parent, name) {
+    return `${parent}.${name}`;
+}
 /**
  * The framing depth a Root Type needs: how many hops the inline reference graph
  * reaches from it (`Dataset → Subset → Measurement` is two), floored at one so
@@ -145,6 +180,17 @@ function assertResolvableInlineReferences(types, referenceTypes) {
             if (!referenceTypes.has(field.ref.typeName)) {
                 throw new Error(`Inline reference “${searchType.name}.${field.name}” names “${field.ref.typeName}”, which is not a declared reference type; declare a reference type (a SearchType with no class) with that name.`);
             }
+            // The two jobs of an inline reference, told apart only by Roles: a
+            // reading device (no Role, pruned before the writer) or a surfaced nested
+            // object (`output`). Anything else asks an engine to search, filter,
+            // facet or sort on a value that is stored as a nested document – which no
+            // query compiler serves, so it would be ignored per query.
+            const extraRoles = unserviceableNestedRoles(field);
+            if (extraRoles.length > 0) {
+                throw new Error(`Inline reference “${searchType.name}.${field.name}” declares ${extraRoles
+                    .map((role) => `“${role}”`)
+                    .join(', ')}, which it cannot serve: an inline reference is either a reading device (no Role) or surfaced (“output”).`);
+            }
         }
     }
     for (const referenceType of referenceTypes.values()) {
@@ -166,6 +212,49 @@ function assertNoInlineCycle(referenceType, referenceTypes, onPath) {
         assertNoInlineCycle(referent, referenceTypes, extended);
     }
 }
+/**
+ * Every field of a {@link ReferenceType} must be one the nesting can actually
+ * serve. A nested field carries **`output` only**: it is stored as part of its
+ * referent and read back with it, so it never becomes an indexed, addressable
+ * field of its own. `searchable`, `filterable`, `facetable` and `sortable` on a
+ * nested field would need query-compiler and engine support that no engine port
+ * declares, and a `labelSource` would need a label lookup no reconstruction
+ * runs – each would be silently ignored per query. A Role-less field stays an
+ * {@link isInternalField Internal Field}, the reading device that is the other
+ * half of an inline reference’s job.
+ *
+ * Checked schema-wide, like the label sources and for the same reason: a single
+ * declaration cannot see whether it is a Reference Type at all.
+ */
+function assertServiceableNestedFields(referenceTypes) {
+    for (const referenceType of referenceTypes.values()) {
+        for (const field of referenceType.fields) {
+            const unserviceable = unserviceableNestedRoles(field);
+            if (unserviceable.length > 0) {
+                throw new Error(`Nested field “${referenceType.name}.${field.name}” declares ${unserviceable
+                    .map((role) => `“${role}”`)
+                    .join(', ')}, which an inline reference cannot serve; a nested field carries “output” only.`);
+            }
+            if (field.labelSource !== undefined) {
+                throw new Error(`Nested field “${referenceType.name}.${field.name}” declares a label source, which an inline reference cannot serve; nest the referent through an inline reference instead of resolving a label for it.`);
+            }
+        }
+    }
+}
+/** The Roles a field declares that nesting cannot serve – every Role but
+ *  `output`, in declaration order, so a message names them all at once. */
+function unserviceableNestedRoles(field) {
+    return UNSERVICEABLE_NESTED_ROLES.filter((role) => role === 'searchable'
+        ? field.searchable !== undefined
+        : field[role] === true);
+}
+/** The Roles a nested field cannot carry – everything but `output`. */
+const UNSERVICEABLE_NESTED_ROLES = [
+    'searchable',
+    'filterable',
+    'facetable',
+    'sortable',
+];
 /**
  * The text field a label source serves labels from – the ‘label’ convention
  * in one place: an `output` (something to reconstruct a label from),
@@ -227,6 +316,15 @@ export const ID_FIELD = 'id';
 const SEARCHABLE_KINDS = ['text', 'keyword', 'reference'];
 /** Kinds whose projection applies the {@link KeywordField.transform}. */
 const TRANSFORMABLE_KINDS = ['keyword', 'reference'];
+/**
+ * Kinds a {@link ProjectionValue} can populate: every projection value is an
+ * IRI or a token, so only the two string-shaped kinds can hold one. `reference`
+ * is what carries a {@link ReferenceField.labelSource}, and so the kind a
+ * facet over the dataset wants.
+ */
+const FROM_KINDS = ['keyword', 'reference'];
+/** The {@link ProjectionValue}s a declaration may name. */
+const PROJECTION_VALUES = ['dataset'];
 /**
  * A safe logical field name: a GraphQL-style identifier. The name is
  * interpolated raw into physical field names AND, for a display text field,
@@ -267,7 +365,13 @@ const LOCALE_PATTERN = /^[A-Za-z0-9]+(-[A-Za-z0-9]+)*$/;
  * - `transform` only on `keyword`/`reference` (the only kinds whose
  *   projection applies it);
  * - `derive` and `path` are mutually exclusive (a field is projected or
- *   computed, never both).
+ *   computed, never both);
+ * - `from` names a known {@link ProjectionValue}, sits on a `keyword`/`reference`
+ *   field, excludes `path` and `derive` (the three are the value sources, and a
+ *   field has exactly one), is not an `inline` reference (a projection value is
+ *   a bare IRI, with no referent to carry fields from), and no two fields
+ *   declare the same projection value – which would leave a consumer reading
+ *   the dataset off a declaration no rule picks between.
  *
  * Pure and total: returns every issue rather than throwing;
  * {@link assertValidSearchType} is the throwing entry point.
@@ -275,6 +379,7 @@ const LOCALE_PATTERN = /^[A-Za-z0-9]+(-[A-Za-z0-9]+)*$/;
 export function validateSearchType(searchType) {
     const issues = [];
     const seen = new Set();
+    const seenProjectionValues = new Set();
     for (const declared of searchType.fields) {
         // Validation guards declarations built OUTSIDE TypeScript (a SHACL
         // generator, plain JS), so it inspects the uniform flat shape rather
@@ -350,6 +455,35 @@ export function validateSearchType(searchType) {
         if (field.derive !== undefined && field.path !== undefined) {
             issue('derive-with-path');
         }
+        if (field.from !== undefined) {
+            if (!PROJECTION_VALUES.includes(field.from)) {
+                issue('unknown-projection-value');
+            }
+            else if (seenProjectionValues.has(field.from)) {
+                // Two fields over one projection value leaves every consumer that
+                // resolves the value back to a declaration – the writer’s provenance
+                // field, above all – with no rule to pick between them.
+                issue('duplicate-projection-value');
+            }
+            seenProjectionValues.add(field.from);
+            if (!FROM_KINDS.includes(field.kind)) {
+                issue('from-not-allowed');
+            }
+            if (field.path !== undefined) {
+                issue('from-with-path');
+            }
+            if (field.derive !== undefined) {
+                issue('from-with-derive');
+            }
+            // An inline reference carries a referent’s projected fields, and the
+            // collection definition declares it as a nested object. A projection
+            // value has no referent – it is a bare IRI – so the two together would
+            // declare an object field the projection fills with a string, and every
+            // document import would fail.
+            if (field.ref?.strategy === 'inline') {
+                issue('from-with-inline-ref');
+            }
+        }
     }
     return issues;
 }
@@ -476,6 +610,21 @@ export function isInternalField(field) {
 export function referenceFields(searchType) {
     return searchType.fields.filter((field) => field.kind === 'reference');
 }
+/**
+ * The field a type declares over the dataset being indexed
+ * ({@link ProjectionValue `from: 'dataset'`}), if it declares one.
+ * {@link validateSearchType} rejects a second field over the same projection
+ * value, so for any type that reached a {@link SearchSchema} this is the only
+ * such field rather than the first of several.
+ *
+ * The single lookup every consumer of the declaration shares – the projection
+ * that populates it, and the engine writer that keeps its provenance
+ * bookkeeping on it rather than on a private field of its own.
+ */
+export function datasetField(searchType) {
+    return searchType.fields.find((field) => (field.kind === 'keyword' || field.kind === 'reference') &&
+        field.from === 'dataset');
+}
 /** Look up a field by its logical name. */
 export function fieldNamed(searchType, name) {
     return searchType.fields.find((field) => field.name === name);

package/dist/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAchD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,YAAY,GACzB,IAAI,CAuKN"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAkBhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,YAAY,GACzB,IAAI,CA0NN"}

package/dist/testing.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { filterOperatorFor, } from './query.js';
-import { facetableFields, filterableFields, ID_FIELD, } from './schema.js';
+import { facetableFields, filterableFields, ID_FIELD, nestedReferenceType, outputFields, } from './schema.js';
 /**
  * The executable {@link SearchEngine} port contract (import from
  * `@lde/search/testing`): a vitest suite every engine adapter runs against a
@@ -145,6 +145,50 @@ export function describeSearchEngineContract(name, engine) {
                 await expect(engine().searchFacets(searchType, [])).resolves.toEqual([]);
             }
         });
+        it('serves a surfaced inline reference as nested documents, never a bare IRI', async () => {
+            // The API device of an Inline Reference (ADR 11): a reference declared
+            // `inline` with `output` reaches the caller as its referent’s own fields,
+            // grouped per referent. Every engine owes that shape – reconstruction
+            // lives below the surfaces, so a surface never has to rebuild it – and an
+            // adapter that stores the reference as an IRI fails here rather than in
+            // one deployment’s UI.
+            for (const searchType of types()) {
+                const nested = [];
+                for (const field of searchType.fields) {
+                    const referenceType = nestedReferenceType(engine().schema, field);
+                    if (referenceType !== undefined) {
+                        nested.push({ field, referenceType });
+                    }
+                }
+                if (nested.length === 0) {
+                    continue;
+                }
+                const result = await engine().search(searchType, {
+                    ...browse(searchType),
+                    limit: 20,
+                });
+                for (const hit of result.hits) {
+                    for (const { field, referenceType } of nested) {
+                        const value = hit.document[field.name];
+                        if (value === undefined) {
+                            continue; // A referent-less document nests nothing.
+                        }
+                        // A multi-valued reference keeps one document per referent, so a
+                        // consumer never pairs parallel arrays by index.
+                        expect(Array.isArray(value)).toBe(field.array === true);
+                        const referents = (Array.isArray(value) ? value : [value]);
+                        const declared = new Set([
+                            ID_FIELD,
+                            ...outputFields(referenceType).map((nestedField) => nestedField.name),
+                        ]);
+                        for (const referent of referents) {
+                            expect(referent).toBeTypeOf('object');
+                            expect(Object.keys(referent).every((key) => declared.has(key))).toBe(true);
+                        }
+                    }
+                }
+            }
+        });
         it('answers a browse query with hits, a total and facets', async () => {
             for (const searchType of types()) {
                 const result = await engine().search(searchType, browse(searchType));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Engine- and domain-agnostic core for RDF-backed search: a unified declarative field model (SearchField/SearchType/SearchSchema), a neutral query IR, the SearchEngine port with logical result types, and a streaming CONSTRUCT-to-document projection. Bakes in no engine, protocol, or domain.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -52,7 +52,7 @@
   "devDependencies": {
     "@tpluscode/rdf-ns-builders": "^5.0.0",
     "@types/jsonld": "^1.5.15",
-    "n3": "^2.1.1"
+    "n3": "^2.1.2"
   },
   "peerDependencies": {
     "vitest": "^4.0.0"