@lde/search 0.23.0 → 0.23.2

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, nestedReferenceType, nestedFieldName, referenceFields, referenceTypeNamed, inlineFramingDepth, fieldNamed, datasetField, ID_FIELD, AND_KEY, OR_KEY, labelFieldOf, labelFieldNameOf, labelSourceNameOf, DEFAULT_LABEL_FIELD, isRangeFacet, isAbsoluteIri, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
+export { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, nestedReferenceType, nestedFieldName, referenceFields, referenceTypeNamed, rootTypeNamed, inlineFramingDepth, fieldNamed, datasetField, ID_FIELD, AND_KEY, OR_KEY, labelFieldOf, labelFieldNameOf, labelSourceNameOf, documentKeyOf, DEFAULT_LABEL_FIELD, isRangeFacet, isAbsoluteIri, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
 export type { PhysicalFields } from './schema.js';
 export { physicalNameTokens } from './physical-name.js';
 export { joinGraph, MAX_JOIN_DEPTH } from './join-graph.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,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,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,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC5D,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,QAAQ,EACR,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,aAAa,EACb,kBAAkB,EAClB,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,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,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC5D,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,QAAQ,EACR,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,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, nestedReferenceType, nestedFieldName, referenceFields, referenceTypeNamed, inlineFramingDepth, fieldNamed, datasetField, ID_FIELD, AND_KEY, OR_KEY, labelFieldOf, labelFieldNameOf, labelSourceNameOf, DEFAULT_LABEL_FIELD, isRangeFacet, isAbsoluteIri, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
+export { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, nestedReferenceType, nestedFieldName, referenceFields, referenceTypeNamed, rootTypeNamed, inlineFramingDepth, fieldNamed, datasetField, ID_FIELD, AND_KEY, OR_KEY, labelFieldOf, labelFieldNameOf, labelSourceNameOf, documentKeyOf, DEFAULT_LABEL_FIELD, isRangeFacet, isAbsoluteIri, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
 export { physicalNameTokens } from './physical-name.js';
 export { joinGraph, MAX_JOIN_DEPTH } from './join-graph.js';
 export { filterOperatorFor, filterOperator, filterOn, isUnsatisfiable, validateQuery, assertValidQuery, pageForOffset, } from './query.js';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { projectRoots } from './project.js';
 export type { ProjectedNode, ProjectionContext, SearchDocument, } from './project.js';
 export { defineSearchType, searchSchema, validateSearchType, assertValidSearchType, ID_FIELD, AND_KEY, OR_KEY, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
-export type { FieldKind, SearchField, SearchFieldBase, TextField, KeywordField, ReferenceField, ReferenceStrategy, NumericField, BooleanField, SearchType, SearchTypeBase, RootType, ReferenceType, RootTypeOf, SearchTypeIssue, SearchSchema, FacetRange, ProjectionValue, } from './schema.js';
+export type { FieldKind, SearchField, SearchFieldBase, TextField, KeywordField, ReferenceField, ReferenceStrategy, NumericField, BooleanField, SearchType, SearchTypeBase, RootType, ReferenceType, RootTypeOf, SearchTypeIssue, KeyField, FacetKeys, SearchSchema, FacetRange, ProjectionValue, } from './schema.js';
 export { joinGraph, MAX_JOIN_DEPTH } from './join-graph.js';
 export type { JoinGraph } from './join-graph.js';
 export { filterOn } from './query.js';

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,EACV,aAAa,EACb,iBAAiB,EACjB,cAAc,GACf,MAAM,cAAc,CAAC;AAKtB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,EACR,OAAO,EACP,MAAM,EAMN,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,SAAS,EACT,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,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;AAKrB,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC5D,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAOjD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,MAAM,EACN,SAAS,EACT,aAAa,EACb,IAAI,GACL,MAAM,YAAY,CAAC;AAIpB,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"}
+{"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,EACR,OAAO,EACP,MAAM,EAMN,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,SAAS,EACT,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACb,UAAU,EACV,eAAe,EACf,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,UAAU,EACV,eAAe,GAChB,MAAM,aAAa,CAAC;AAKrB,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC5D,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAOjD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,MAAM,EACN,SAAS,EACT,aAAa,EACb,IAAI,GACL,MAAM,YAAY,CAAC;AAIpB,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.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,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;AA2ED;;;;;;;;;;;;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"}
+{"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,EAiBL,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;AAmHD;;;;;;;;;;;;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,CAc/B"}

package/dist/project.js

@@ -1,6 +1,6 @@
 import { fold } from '@lde/text-normalization';
 import { buildSubjectIndex, frameSubjects, } from './frame-by-type.js';
-import { assertTypeInSchema, displayFieldName, inlineFramingDepth, irAlias, isAbsoluteIri, isInternalField, isInlineReference, isoToUnixSeconds, physicalFields, referenceTypeNamed, } from './schema.js';
+import { assertTypeInSchema, displayFieldName, documentKeyOf, fieldNamed, inheritedFacetKeys, inlineFramingDepth, irAlias, isAbsoluteIri, isInternalField, isInlineReference, isoToUnixSeconds, labelSourceNameOf, physicalFields, referenceTypeNamed, rootTypeNamed, } from './schema.js';
 /** The context a projection runs with when its caller supplied none. */
 const NO_PROJECTION_CONTEXT = {};
 /**
@@ -68,7 +68,7 @@ function pruneInternalFields(document, searchType, schema) {
  *  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, context) {
-    const id = documentKey(node);
+    const id = documentIdOf(node, searchType);
     const document = id === undefined ? {} : { id };
     for (const field of searchType.fields) {
         applyField(document, node, field, searchType, schema, context);
@@ -88,6 +88,33 @@ function documentKey(node) {
     const id = node['@id'];
     return typeof id === 'string' && isAbsoluteIri(id) ? id : undefined;
 }
+/**
+ * The `id` a node is projected under: its own IRI, unless its type declares a
+ * {@link RootType.key} – then the key its key field carries
+ * ({@link documentKeyOf}). The candidates are read off the frame like any other
+ * field value, under the key field’s own {@link irAlias IR Alias}, because the
+ * key field *is* an ordinary declared field: the extraction already emits it,
+ * and a reader transform that repairs reference values has already run on it.
+ *
+ * The key is assigned before any `derive` runs, so a derive sees the key and
+ * never the node IRI; a deployment that wants the node IRI declares a plain
+ * `idOnly` reference over the same path.
+ */
+function documentIdOf(node, searchType) {
+    const nodeIri = documentKey(node);
+    if (nodeIri === undefined || searchType.key === undefined) {
+        return nodeIri;
+    }
+    return documentKeyOf(searchType, nodeIri, keyCandidatesOf(node, searchType, searchType.key.field));
+}
+/** The raw values a node carries under a type’s key field – untransformed, as
+ *  {@link documentKeyOf} expects them. Empty for a node the key field matched
+ *  nothing on. The field itself is guaranteed declared by `searchSchema`, which
+ *  is what validates a `key` at all. */
+function keyCandidatesOf(node, searchType, name) {
+    const keyField = fieldNamed(searchType, name);
+    return irisOf(node, irAlias(searchType, keyField));
+}
 /**
  * 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)
@@ -106,8 +133,11 @@ export async function* projectRoots(quads, roots, schema, searchType, context =
     const index = buildSubjectIndex(quads);
     // Distinct roots only. A selector may return an IRI more than once – a
     // non-`DISTINCT` `SELECT` over a one-to-many join yields the same subject per
-    // matched row – and a repeated root would otherwise frame and emit a
-    // duplicate document under the same `id`.
+    // matched row – and framing a root twice would do the same work twice for one
+    // node. Distinct roots may still legitimately share an `id`, where the type
+    // declares a `key` two of them carry: that is what a document key means, and
+    // it is the writer’s upsert – not the projection – that folds them into one
+    // document.
     const depth = inlineFramingDepth(schema, searchType);
     for await (const node of frameSubjects(index, [...new Set(roots)], depth)) {
         yield projectDocument(node, searchType, schema, context);
@@ -118,7 +148,7 @@ function applyField(document, node, field, searchType, schema, context) {
     // (`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);
+        return applyProjectionValue(document, field, field.from, context, schema);
     }
     if (field.derive !== undefined) {
         const derived = field.derive(document, context);
@@ -177,9 +207,9 @@ function applyField(document, node, field, searchType, schema, context) {
         case 'text':
             return applyText(document, langValuesOf(node, alias), field);
         case 'keyword':
-            return applyFacet(document, literalsOf(node, alias), field);
+            return applyFacet(document, literalsOf(node, alias), field, schema);
         case 'reference':
-            return applyFacet(document, irisOf(node, alias), field);
+            return applyFacet(document, referenceValues(node, alias, field, schema), field, schema);
         case 'integer':
             return setNumber(document, field.name, toInteger(firstLiteralOf(node, alias)));
         case 'number':
@@ -198,6 +228,53 @@ function applyField(document, node, field, searchType, schema, context) {
         }
     }
 }
+/**
+ * The values a non-inline reference stores: the referents’ IRIs, **or their
+ * document keys** when the type the reference names declares a
+ * {@link RootType.key}. A `lookup`’s `target` and an `idOnly`’s `labelSource`
+ * both mean *this field holds ids of documents in that collection* (ADR 20) –
+ * the fact a label lookup and a join rely on – so storing the node IRI where
+ * the target keys on something else would break an invariant the schema already
+ * has. Rewriting a reference is LDE keeping it, not a new rule.
+ *
+ * That is also why the boundary is *naming the target*: a reference that names
+ * none ({@link labelSourceNameOf} → `undefined`) never claimed to hold a
+ * collection’s ids, and a `derive`d one produces its own values rather than
+ * reading a referent, so neither is re-keyed.
+ *
+ * The referent’s candidates are in the frame because framing already embeds a
+ * referenced node’s own triples at one hop, and the extraction adds the key
+ * field to that hop. A projection run without a `schema` cannot resolve the
+ * target, so it leaves the values as they are – exactly as it leaves an inline
+ * reference unprojected.
+ *
+ * The referring field’s own {@link ReferenceField.transform} still runs after
+ * this, in {@link applyFacet}: a `transform` transforms what the field stores,
+ * and for a keyed target that is the key. A `transform` written to repair the
+ * referent’s node IRIs therefore sees a key instead, which is why the two are
+ * worth declaring together only deliberately.
+ */
+function referenceValues(node, alias, field, schema) {
+    const targetName = labelSourceNameOf(field);
+    if (schema === undefined || targetName === undefined) {
+        return irisOf(node, alias);
+    }
+    // Guaranteed declared: `searchSchema` validates that every named target
+    // resolves, and the projection only ever runs against a type of its schema.
+    const target = rootTypeNamed(schema, targetName);
+    if (target.key === undefined) {
+        return irisOf(node, alias);
+    }
+    const keyFieldName = target.key.field;
+    return valuesOf(node, alias)
+        .map((value) => {
+        const iri = iriString(value);
+        return iri === undefined
+            ? undefined
+            : documentKeyOf(target, iri, isObject(value) ? keyCandidatesOf(value, target, keyFieldName) : []);
+    })
+        .filter((value) => value !== undefined);
+}
 /**
  * Project a text field. **Display** (when `output`) preserves *every* language
  * present – one label per language (accents preserved, untagged under `und`),
@@ -250,6 +327,16 @@ function foldedSearchValue(values) {
  * `keyword` reads literals; `reference` reads IRIs (the caller passes the
  * already-read raw values).
  *
+ * A reference inheriting a {@link FacetKeys facet policy} from the type it
+ * names ({@link inheritedFacetKeys}) also writes the `${name}_facet` companion
+ * the engine facets instead of the field: the subset of **what the field
+ * stores** that the policy admits. So it is written after the field’s own
+ * `transform` and the IRI filter, from the same `values` – for a keyed target
+ * those are already keys ({@link referenceValues}), which is what makes a
+ * predicate over document keys the right shape. The field itself keeps every
+ * value; only the facet narrows. An empty subset writes nothing, exactly as a
+ * path that matched nothing does.
+ *
  * **`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
@@ -260,7 +347,7 @@ function foldedSearchValue(values) {
  * 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) {
+function applyFacet(document, raw, field, schema) {
     // A `reference` stores identity, so what it stores must be an IRI whatever
     // route the value arrived by. {@link iriString} guards the graph path, but a
     // `transform` runs after it and a `from` projection value never passes it at
@@ -270,18 +357,34 @@ function applyFacet(document, raw, field) {
     const transformed = field.transform ? raw.map(field.transform) : raw;
     const values = dedupe(referenced ? transformed.filter(isAbsoluteIri) : transformed);
     const folded = dedupe(values.map((value) => fold(value)));
-    const searchField = physicalFields(field).search[0];
+    const names = physicalFields(field, schema);
+    const searchField = names.search[0];
+    const policy = inheritedFacetKeys(field, schema);
+    // `names.facet` is the companion exactly when a policy is inherited –
+    // physicalFields reads the same `inheritedFacetKeys`.
+    const facetField = names.facet;
+    // The companion is a subset of what the field STORES – for a single-valued
+    // field its first value, not the first admitted of all of them, or the facet
+    // would count a value no filter on the field can reproduce.
+    const stored = field.array === true ? values : values.slice(0, 1);
+    const admitted = policy === undefined ? [] : stored.filter(policy.only);
     if (field.array === true) {
-        setArray(document, field.name, values);
+        setArray(document, field.name, stored);
         if (field.searchable) {
             setArray(document, searchField, folded);
         }
+        if (policy !== undefined) {
+            setArray(document, facetField, admitted);
+        }
         return;
     }
-    setString(document, field.name, values[0]);
+    setString(document, field.name, stored[0]);
     if (field.searchable) {
         setString(document, searchField, folded[0]);
     }
+    if (policy !== undefined) {
+        setString(document, facetField, admitted[0]);
+    }
 }
 /**
  * Project a field declared over a {@link ProjectionContext} value: read the
@@ -294,13 +397,13 @@ function applyFacet(document, raw, field) {
  * 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) {
+function applyProjectionValue(document, field, from, context, schema) {
     // `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);
+    applyFacet(document, value === undefined ? [] : [value], field, schema);
 }
 /**
  * Project an inline reference: the referent node(s) embedded under the field’s

package/dist/schema.d.ts

@@ -321,6 +321,90 @@ export interface SearchTypeBase {
     readonly labelField?: string;
     readonly fields: readonly SearchField[];
 }
+/**
+ * Which declared field of a {@link RootType} holds its **document key**, when
+ * that key is not the node’s own IRI. It has the shape of
+ * {@link SearchTypeBase.labelField} – *which field is the label* – and says
+ * *which field holds the key*: a statement about the search document, never
+ * about the world, so the words a deployment reaches for (identity, alignment,
+ * canonical, authority) stay in the deployment’s own schema comments.
+ *
+ * Two things that already hold of keys then hold here too, without a new rule:
+ * several nodes sharing a key are **one document** (the writer upserts by `id`,
+ * so a deployment that wants particular content on the merged document attaches
+ * a transform, and one that does not gets last-writer-wins), and a reference
+ * into a keyed type stores the **target’s key** – a `lookup`/`labelSource`
+ * already means *this field holds ids of documents in that collection*
+ * (ADR 20), which storing the node IRI would break.
+ *
+ * See [ADR 22](../../docs/decisions/0022-key-a-root-type-on-a-declared-field.md).
+ */
+export interface KeyField {
+    /**
+     * The `name` of a declared field of this type whose values are the key
+     * candidates: a path-bearing, `array` {@link ReferenceField} that is not
+     * `inline` ({@link searchSchema} validates all four). Being an ordinary field
+     * is the point – its extraction branch already exists, a reader transform
+     * that repairs reference values covers it the day it is declared, and its own
+     * {@link ReferenceField.transform} is where IRI normalisation lives, so two
+     * spellings of one IRI become one candidate before anything chooses among
+     * them.
+     *
+     * A transform that **replaces** a root’s quads must re-emit this field, the
+     * existing rule that *a field the document needs must be in the stream*
+     * applied to one more field; a transform that only adds never meets it.
+     */
+    readonly field: string;
+    /**
+     * Choose the key among the candidates – the key field’s values after its
+     * `transform`, IRI-filtered, deduplicated and sorted, so the default is
+     * deterministic whatever order the CONSTRUCT returned them in. Return one of
+     * them, or `undefined` to keep the node’s own IRI; anything else throws at
+     * projection. Not consulted for a node whose key field is empty.
+     *
+     * Must be **pure**: the same function keys the document and every reference
+     * to it, so a `pick` that consulted the network or the clock could key the
+     * two differently and leave a reference dangling. LDE never inspects an
+     * IRI’s shape – it asks.
+     *
+     * @default the first candidate
+     */
+    readonly pick?: (candidates: readonly string[]) => string | undefined;
+}
+/**
+ * A {@link RootType}’s **facet policy**: which of its documents get a facet
+ * bucket, as a predicate over the document key. Declared once, on the type,
+ * and inherited by every facetable reference that *names* the type – a
+ * `lookup`’s `target`, an `idOnly`’s `labelSource` ({@link labelSourceNameOf})
+ * – because *which of a type’s ids deserve a bucket* is a fact about the type,
+ * not about each field that points at it. A per-field policy would be one rule
+ * declared N times, and forgetting one would silently reintroduce the buckets
+ * on that facet alone.
+ *
+ * Only the facet narrows. The referring field keeps **every** value: a
+ * document still displays the excluded referent, and a `where` filter on its
+ * IRI still matches exactly. *Facets are discovery, filters are exact.*
+ *
+ * The mechanism is a second physical field per inheriting facet –
+ * `${name}_facet`, holding the admitted subset ({@link physicalFields}) – which
+ * the engine facets instead of the field itself, so the facet is exact under
+ * any bucket cap: the engine never sees an excluded value. Declaring a policy
+ * therefore changes the collection definition of every type that references
+ * this one; an engine adapter that reuses a live collection must notice.
+ *
+ * **The failure mode is silence.** A predicate that admits none of a type’s
+ * keys – a type whose alignments are not what it tests for, or stored values
+ * that are still node IRIs because the type was keyed after its references
+ * were indexed – empties every facet referencing the type without an error.
+ * Give each type its own predicate rather than reuse another’s, and key a type
+ * ({@link RootType.key}) before declaring a policy over its keys.
+ */
+export interface FacetKeys {
+    /** Whether a document key gets a bucket. Must be **pure**: it is applied per
+     *  document at projection time, so an impure one would bucket one document
+     *  and not its twin. */
+    readonly only: (id: string) => boolean;
+}
 /**
  * A **Root Type**: a {@link SearchType} that is indexed. It declares a `class`,
  * roots are selected for it, a Writer owns a collection for it, and the
@@ -333,6 +417,13 @@ export interface RootType extends SearchTypeBase {
      *  key a {@link SearchSchema} maps this type under. Its presence is what makes
      *  a type a Root Type – and so what gives it a collection. */
     readonly class: string;
+    /** Which declared field holds this type’s document key, when it is not the
+     *  node’s own IRI ({@link KeyField}, {@link documentKeyOf}). */
+    readonly key?: KeyField;
+    /** Which of this type’s documents get a facet bucket, on every facetable
+     *  reference that names this type ({@link FacetKeys}). Unset, every
+     *  document does. */
+    readonly facetKeys?: FacetKeys;
 }
 /**
  * A **Reference Type**: a {@link SearchType} reached only through an
@@ -350,6 +441,13 @@ export interface ReferenceType extends SearchTypeBase {
      *  {@link SearchField} discriminates by `kind`: an indexed Reference Type
      *  fails to compile, not at run time. */
     readonly class?: never;
+    /** A Reference Type has no document key to declare: it is nested inside its
+     *  referrer rather than keyed in a collection of its own. `never` for the
+     *  same reason `class` is. */
+    readonly key?: never;
+    /** Nothing references a Reference Type by id, so there is no facet for a
+     *  policy to narrow. `never` for the same reason `key` is. */
+    readonly facetKeys?: never;
 }
 /**
  * One type’s complete search declaration: its logical API `name`, the queryable
@@ -420,6 +518,19 @@ export declare function searchSchema<const Types extends readonly SearchType[]>(
  * resolves an inline reference’s referent shape through it.
  */
 export declare function referenceTypeNamed(schema: SearchSchema, name: string): ReferenceType | undefined;
+/**
+ * The {@link RootType} a declaration names – a `lookup`’s `target`, an
+ * `idOnly`’s {@link ReferenceField.labelSource} ({@link labelSourceNameOf}), a
+ * join edge – or `undefined` when the schema declares no Root Type by that
+ * name. The one reading of *which type does this point at*, so the projection
+ * (which re-keys a reference through its target’s {@link KeyField}), the
+ * label-source validation and an adapter’s lookup cannot resolve a target
+ * differently.
+ *
+ * Complements {@link referenceTypeNamed}: the two name indexes are disjoint,
+ * because {@link searchSchema} rejects a name declared twice.
+ */
+export declare function rootTypeNamed(schema: SearchSchema, name: string): RootType | undefined;
 /** Whether a field is an inline reference – a {@link ReferenceField} whose
  *  `ref` carries its referent’s projected fields ({@link ReferenceType}). */
 export declare function isInlineReference(field: SearchField): field is ReferenceField & {
@@ -495,7 +606,7 @@ export declare function labelSourceNameOf(field: ReferenceField): string | undef
  */
 export interface SearchTypeIssue {
     readonly field: string;
-    readonly reason: 'duplicate-field-name' | 'invalid-field-name' | 'unknown-kind' | 'invalid-locale' | 'missing-ref' | 'missing-ref-type-name' | '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' | 'joinable-not-allowed' | 'joinable-without-label-source' | 'joinable-with-inline-ref' | 'reserved-field-name';
+    readonly reason: 'duplicate-field-name' | 'invalid-field-name' | 'unknown-kind' | 'invalid-locale' | 'missing-ref' | 'missing-ref-type-name' | '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' | 'joinable-not-allowed' | 'joinable-without-label-source' | 'joinable-with-inline-ref' | 'reserved-field-name' | 'key-field-unknown' | 'key-field-not-reference' | 'key-field-without-path' | 'key-field-not-array' | 'key-field-inline' | 'key-pick-not-a-function' | 'key-not-allowed' | 'facet-keys-only-not-a-function' | 'facet-keys-not-allowed';
 }
 /**
  * The reserved logical name of a document’s IRI – the one field every indexed
@@ -565,7 +676,13 @@ export declare const OR_KEY = "or";
  *   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.
+ *   the dataset off a declaration no rule picks between;
+ * - a {@link RootType.key} names a declared, `path`-bearing, `array`,
+ *   non-`inline` `reference` field of this type, and its `pick` is a function
+ *   ({@link keyIssues}); a {@link ReferenceType} declares no key at all;
+ * - a {@link RootType.facetKeys} policy’s `only` is a function
+ *   ({@link facetKeysIssues}); a {@link ReferenceType} declares no policy at
+ *   all.
  *
  * Pure and total: returns every issue rather than throwing;
  * {@link assertValidSearchType} is the throwing entry point.
@@ -594,6 +711,11 @@ export interface PhysicalFields {
     /** Per-locale folded sort keys `${name}_sort_${locale}` (localized text,
      *  `sortable`); a non-localized field sorts on its own `name` field. */
     readonly sort: readonly string[];
+    /** The field a facet on this field reads, when `facetable`: the field’s own
+     *  `name`, or the `${name}_facet` companion holding the subset its target’s
+     *  {@link FacetKeys facet policy} admits. `undefined` for a field that is
+     *  not facetable. */
+    readonly facet: string | undefined;
 }
 /**
  * The display fields of a localized `text` field are pattern-based, not
@@ -688,6 +810,38 @@ export declare function referenceFields(searchType: SearchType): readonly Refere
 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;
+/**
+ * The **document key** of one node of `searchType`: what the projection writes
+ * as the document’s `id`, and what a reference into this type stores.
+ *
+ * The whole rule, in one place, so the projection and any transform that needs
+ * to know a node’s key read the same answer:
+ *
+ * 1. a type declaring no {@link RootType.key} keys on `nodeIri` – the node’s own
+ *    IRI, as every type does today;
+ * 2. otherwise the key field’s `rawValues` become **candidates**: its
+ *    {@link ReferenceField.transform} (where IRI normalisation lives, so two
+ *    spellings of one IRI become one candidate), then the
+ *    {@link isAbsoluteIri} filter, then dedupe and sort – so the default is
+ *    deterministic whatever order the CONSTRUCT returned them in;
+ * 3. no candidate keys on `nodeIri`, without consulting {@link KeyField.pick};
+ * 4. otherwise {@link KeyField.pick} chooses (defaulting to the first
+ *    candidate), and `undefined` keeps `nodeIri`.
+ *
+ * So a key is always either the node’s own IRI or an IRI the graph offered for
+ * that node – never one invented in between. A `pick` returning anything else
+ * throws, naming the node and the candidates: it is a bug in a pure function
+ * that keys both the document and every reference to it, and letting it through
+ * would key those two differently.
+ *
+ * @param nodeIri the node’s own IRI – the key it falls back to
+ * @param rawValues the key field’s values **as a reference field reads them** –
+ *   a node’s `@id` or a bare-string value, before the field’s `transform`. A
+ *   caller that reads them itself (a transform working on quads) must apply the
+ *   same rule and skip a literal-valued object, or it will compute a key for a
+ *   value the projection never saw and key the two differently.
+ */
+export declare function documentKeyOf(searchType: RootType, nodeIri: string, rawValues: readonly string[]): string;
 /**
  * The **IR Alias** predicate for a field: `urn:lde:‹SearchType.name›/‹field.name›`.
  * The extraction CONSTRUCT emits a field’s value under this minted predicate, and
@@ -746,9 +900,28 @@ export declare function isoToUnixSeconds(iso: string): number | undefined;
 export declare function unixSecondsToIso(seconds: number): string;
 /**
  * Derive the **indexed** physical engine field names a declaration produces:
- * the per-locale `search`/`sort` fanout. A localized `text` field’s display
- * fields are pattern-based and not enumerated here – see {@link displayFieldName}
- * and its siblings.
- */
-export declare function physicalFields(field: SearchField): PhysicalFields;
+ * the per-locale `search`/`sort` fanout, and the field a `facet` reads. A
+ * localized `text` field’s display fields are pattern-based and not enumerated
+ * here – see {@link displayFieldName} and its siblings.
+ *
+ * The facet is the one member that depends on more than the declaration: a
+ * facetable reference whose target declares a {@link FacetKeys facet policy}
+ * facets a `${name}_facet` companion rather than itself, and only the `schema`
+ * can resolve that target ({@link inheritedFacetKeys}). Without one the field
+ * facets on its own name – the same reading the projection makes without a
+ * schema, where it cannot re-key a reference either.
+ */
+export declare function physicalFields(field: SearchField, schema?: SearchSchema): PhysicalFields;
+/**
+ * The {@link FacetKeys facet policy} a field inherits: the `facetKeys` of the
+ * Root Type it names ({@link labelSourceNameOf}), when the field is a facetable
+ * reference and the schema resolves that type. The boundary is *naming the
+ * target* – the same line along which a reference is re-keyed and a join is
+ * drawn – so a reference that names no type inherits nothing, whatever type
+ * its values happen to point at; and a `derive`d reference, which produces its
+ * own values rather than reading a referent, is re-keyed by nothing and so
+ * narrowed by nothing either. The one reading the projection (which writes the
+ * companion) and {@link physicalFields} (which names it) share.
+ */
+export declare function inheritedFacetKeys(field: SearchField, schema: SearchSchema | undefined): FacetKeys | undefined;
 //# sourceMappingURL=schema.d.ts.map

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

@@ -36,6 +36,17 @@ export function defineSearchType(searchType) {
  * through {@link referenceTypeNamed}.
  */
 const referenceTypesBySchema = new WeakMap();
+/**
+ * The Root Type name index each {@link SearchSchema} carries alongside its
+ * class-keyed map. A schema is keyed by `class` because that is what a selector
+ * and a Writer address it by, while every declaration that points at another
+ * type – a `lookup`’s `target`, an `idOnly`’s `labelSource`, a join edge –
+ * names it. Kept beside the map rather than rebuilt per consumer, so the
+ * projection, the label-source validation and an adapter’s lookup resolve a
+ * target the same way ({@link rootTypeNamed}) instead of each maintaining a
+ * by-name map of its own.
+ */
+const rootTypesBySchema = new WeakMap();
 /** Whether a declared type is a {@link RootType} (declares a `class`) rather
  *  than a {@link ReferenceType}. */
 function isRootType(searchType) {
@@ -80,12 +91,16 @@ export function searchSchema(...types) {
         .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
-        .filter(isRootType)
-        .map((searchType) => [searchType.class, searchType]));
+    // The one blessed cast: only this validated constructor mints the brand. Built
+    // BEFORE the schema-wide assertions that resolve a type by name, so they can
+    // use `rootTypeNamed` – the same reading the projection and an adapter's
+    // lookup use – rather than a by-name map of their own. The schema stays local
+    // until every assertion has passed, so an invalid one is never observable.
+    const rootTypes = types.filter(isRootType);
+    const schema = new Map(rootTypes.map((searchType) => [searchType.class, searchType]));
     referenceTypesBySchema.set(schema, referenceTypes);
+    rootTypesBySchema.set(schema, new Map(rootTypes.map((searchType) => [searchType.name, searchType])));
+    assertResolvableLabelSources(types, schema);
     // Build the join graph eagerly and discard it: it is cached per schema, and
     // building it is what enforces the schema-wide join rules (one joinable
     // reference per target, every target an indexed Root Type, no cycles). A
@@ -103,6 +118,21 @@ export function searchSchema(...types) {
 export function referenceTypeNamed(schema, name) {
     return referenceTypesBySchema.get(schema)?.get(name);
 }
+/**
+ * The {@link RootType} a declaration names – a `lookup`’s `target`, an
+ * `idOnly`’s {@link ReferenceField.labelSource} ({@link labelSourceNameOf}), a
+ * join edge – or `undefined` when the schema declares no Root Type by that
+ * name. The one reading of *which type does this point at*, so the projection
+ * (which re-keys a reference through its target’s {@link KeyField}), the
+ * label-source validation and an adapter’s lookup cannot resolve a target
+ * differently.
+ *
+ * Complements {@link referenceTypeNamed}: the two name indexes are disjoint,
+ * because {@link searchSchema} rejects a name declared twice.
+ */
+export function rootTypeNamed(schema, name) {
+    return rootTypesBySchema.get(schema)?.get(name);
+}
 /** Whether a field is an inline reference – a {@link ReferenceField} whose
  *  `ref` carries its referent’s projected fields ({@link ReferenceType}). */
 export function isInlineReference(field) {
@@ -311,13 +341,13 @@ export function labelSourceNameOf(field) {
  * can actually serve labels ({@link labelFieldOf}). Checked schema-wide,
  * because a single declaration cannot see its siblings.
  *
- * That leaves only a {@link RootType}, without naming one: a label field is
- * `searchable`, and {@link assertServiceableNestedFields} already rejects a
- * `searchable` field on a Reference Type – so a Reference Type can never serve
- * labels, and a resolved label always has a collection to come from.
+ * Resolved through {@link rootTypeNamed}, which is exactly the set that can
+ * serve labels: a label field is `searchable`, and
+ * {@link assertServiceableNestedFields} – which runs first – already rejects a
+ * `searchable` field on a Reference Type, so a resolved label always has a
+ * collection to come from.
  */
-function assertResolvableLabelSources(types) {
-    const byName = new Map(types.map((searchType) => [searchType.name, searchType]));
+function assertResolvableLabelSources(types, schema) {
     for (const searchType of types) {
         for (const field of searchType.fields) {
             const labelSource = field
@@ -339,9 +369,15 @@ function assertResolvableLabelSources(types) {
             if (sourceName === undefined) {
                 continue;
             }
-            const source = byName.get(sourceName);
+            const source = rootTypeNamed(schema, sourceName);
             if (source === undefined) {
-                throw new Error(`Reference “${searchType.name}.${field.name}” names unknown label source “${sourceName}”; declare a SearchType with that name.`);
+                // A name that IS declared, just not as a Root Type, is the confusing
+                // case: telling the author to declare a type they already declared
+                // would send them looking in the wrong place. Only a Root Type has a
+                // collection to resolve against, so name that instead.
+                throw new Error(referenceTypeNamed(schema, sourceName) === undefined
+                    ? `Reference “${searchType.name}.${field.name}” names unknown label source “${sourceName}”; declare a SearchType with that name.`
+                    : `Reference “${searchType.name}.${field.name}” names label source “${sourceName}”, which is a Reference Type; a label source must be a Root Type, since a resolved label is read from that type’s own collection.`);
             }
             if (labelFieldOf(source) === undefined) {
                 throw new Error(`Reference “${searchType.name}.${field.name}” uses label source “${sourceName}”, which must declare an output, searchable text field “${labelFieldNameOf(source)}”.`);
@@ -449,7 +485,13 @@ const LOCALE_PATTERN = /^[A-Za-z0-9]+(-[A-Za-z0-9]+)*$/;
  *   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.
+ *   the dataset off a declaration no rule picks between;
+ * - a {@link RootType.key} names a declared, `path`-bearing, `array`,
+ *   non-`inline` `reference` field of this type, and its `pick` is a function
+ *   ({@link keyIssues}); a {@link ReferenceType} declares no key at all;
+ * - a {@link RootType.facetKeys} policy’s `only` is a function
+ *   ({@link facetKeysIssues}); a {@link ReferenceType} declares no policy at
+ *   all.
  *
  * Pure and total: returns every issue rather than throwing;
  * {@link assertValidSearchType} is the throwing entry point.
@@ -596,8 +638,84 @@ export function validateSearchType(searchType) {
             }
         }
     }
+    issues.push(...keyIssues(searchType), ...facetKeysIssues(searchType));
+    return issues;
+}
+/**
+ * The issues a type’s {@link RootType.key} declaration carries, each filed
+ * under the field name the declaration names – so a message reads like every
+ * other one, naming the field the rule is about rather than a member.
+ *
+ * The key field must be an ordinary declared field the extraction already
+ * reads and the projection already applies a `transform` to: a `reference`
+ * (candidates are IRIs), with a `path` (a key read from the graph, not one
+ * derived from a document that is keyed already), `array` (a node may offer
+ * several candidates, and a single-valued field would drop all but the first
+ * before `pick` ever saw them), and not `inline` (which carries the referent’s
+ * fields rather than its IRI, so it offers no candidate at all).
+ */
+function keyIssues(searchType) {
+    const key = searchType.key;
+    if (key === undefined) {
+        return [];
+    }
+    const issue = (reason) => ({
+        field: key.field,
+        reason,
+    });
+    // A Reference Type is nested inside its referrer, never keyed in a collection
+    // of its own – so a key on one states a rule nothing could apply.
+    if (searchType.class === undefined) {
+        return [issue('key-not-allowed')];
+    }
+    const issues = [];
+    if (key.pick !== undefined && typeof key.pick !== 'function') {
+        issues.push(issue('key-pick-not-a-function'));
+    }
+    const field = fieldNamed(searchType, key.field);
+    if (field === undefined) {
+        issues.push(issue('key-field-unknown'));
+        return issues;
+    }
+    if (field.kind !== 'reference') {
+        issues.push(issue('key-field-not-reference'));
+        return issues;
+    }
+    if (field.path === undefined) {
+        issues.push(issue('key-field-without-path'));
+    }
+    if (field.array !== true) {
+        issues.push(issue('key-field-not-array'));
+    }
+    if (field.ref?.strategy === 'inline') {
+        issues.push(issue('key-field-inline'));
+    }
     return issues;
 }
+/**
+ * The issues a type’s {@link RootType.facetKeys} declaration carries, filed
+ * under the member’s name: the policy names no field – it is a rule about the
+ * type’s own keys, applied through other types’ fields – so there is no field
+ * name to file it under.
+ */
+function facetKeysIssues(searchType) {
+    const facetKeys = searchType.facetKeys;
+    if (facetKeys === undefined) {
+        return [];
+    }
+    const issue = (reason) => ({
+        field: 'facetKeys',
+        reason,
+    });
+    // Nothing references a Reference Type by id, so a policy on one narrows no
+    // facet – it states a rule nothing could apply.
+    if (searchType.class === undefined) {
+        return [issue('facet-keys-not-allowed')];
+    }
+    return typeof facetKeys.only === 'function'
+        ? []
+        : [issue('facet-keys-only-not-a-function')];
+}
 /**
  * Throw when `searchType` is not a member of `schema` – the port membership
  * guard every engine adapter applies before searching, so a query can never
@@ -750,6 +868,66 @@ export function datasetField(searchType) {
 export function fieldNamed(searchType, name) {
     return searchType.fields.find((field) => field.name === name);
 }
+/**
+ * The **document key** of one node of `searchType`: what the projection writes
+ * as the document’s `id`, and what a reference into this type stores.
+ *
+ * The whole rule, in one place, so the projection and any transform that needs
+ * to know a node’s key read the same answer:
+ *
+ * 1. a type declaring no {@link RootType.key} keys on `nodeIri` – the node’s own
+ *    IRI, as every type does today;
+ * 2. otherwise the key field’s `rawValues` become **candidates**: its
+ *    {@link ReferenceField.transform} (where IRI normalisation lives, so two
+ *    spellings of one IRI become one candidate), then the
+ *    {@link isAbsoluteIri} filter, then dedupe and sort – so the default is
+ *    deterministic whatever order the CONSTRUCT returned them in;
+ * 3. no candidate keys on `nodeIri`, without consulting {@link KeyField.pick};
+ * 4. otherwise {@link KeyField.pick} chooses (defaulting to the first
+ *    candidate), and `undefined` keeps `nodeIri`.
+ *
+ * So a key is always either the node’s own IRI or an IRI the graph offered for
+ * that node – never one invented in between. A `pick` returning anything else
+ * throws, naming the node and the candidates: it is a bug in a pure function
+ * that keys both the document and every reference to it, and letting it through
+ * would key those two differently.
+ *
+ * @param nodeIri the node’s own IRI – the key it falls back to
+ * @param rawValues the key field’s values **as a reference field reads them** –
+ *   a node’s `@id` or a bare-string value, before the field’s `transform`. A
+ *   caller that reads them itself (a transform working on quads) must apply the
+ *   same rule and skip a literal-valued object, or it will compute a key for a
+ *   value the projection never saw and key the two differently.
+ */
+export function documentKeyOf(searchType, nodeIri, rawValues) {
+    const key = searchType.key;
+    if (key === undefined) {
+        return nodeIri;
+    }
+    // Guaranteed a declared reference field by `searchSchema`, which is what
+    // validates a `key` at all.
+    const { transform } = fieldNamed(searchType, key.field);
+    const candidates = [
+        ...new Set((transform === undefined ? rawValues : rawValues.map(transform)).filter(isAbsoluteIri)),
+    ].sort();
+    if (candidates.length === 0) {
+        return nodeIri;
+    }
+    const picked = (key.pick ?? firstCandidate)(candidates);
+    if (picked === undefined) {
+        return nodeIri;
+    }
+    if (!candidates.includes(picked)) {
+        throw new Error(`The “pick” of “${searchType.name}.key” returned “${picked}” for <${nodeIri}>, which is not among its candidates (${candidates
+            .map((candidate) => `<${candidate}>`)
+            .join(', ')}); a key must be one of them, or “undefined” to keep the node’s own IRI.`);
+    }
+    return picked;
+}
+/** The {@link KeyField.pick} a type that declares none falls back to. */
+function firstCandidate(candidates) {
+    return candidates[0];
+}
 /**
  * The **IR Alias** predicate for a field: `urn:lde:‹SearchType.name›/‹field.name›`.
  * The extraction CONSTRUCT emits a field’s value under this minted predicate, and
@@ -848,11 +1026,18 @@ export function unixSecondsToIso(seconds) {
 }
 /**
  * Derive the **indexed** physical engine field names a declaration produces:
- * the per-locale `search`/`sort` fanout. A localized `text` field’s display
- * fields are pattern-based and not enumerated here – see {@link displayFieldName}
- * and its siblings.
+ * the per-locale `search`/`sort` fanout, and the field a `facet` reads. A
+ * localized `text` field’s display fields are pattern-based and not enumerated
+ * here – see {@link displayFieldName} and its siblings.
+ *
+ * The facet is the one member that depends on more than the declaration: a
+ * facetable reference whose target declares a {@link FacetKeys facet policy}
+ * facets a `${name}_facet` companion rather than itself, and only the `schema`
+ * can resolve that target ({@link inheritedFacetKeys}). Without one the field
+ * facets on its own name – the same reading the projection makes without a
+ * schema, where it cannot re-key a reference either.
  */
-export function physicalFields(field) {
+export function physicalFields(field, schema) {
     if (field.kind === 'text') {
         const locales = field.locales;
         return {
@@ -862,10 +1047,40 @@ export function physicalFields(field) {
             sort: field.sortable
                 ? locales.map((locale) => `${field.name}_sort_${locale}`)
                 : [],
+            // Text is never facetable (`validateSearchType`).
+            facet: undefined,
         };
     }
     return {
         search: field.searchable !== undefined ? [`${field.name}_search`] : [],
         sort: [],
+        facet: field.facetable !== true
+            ? undefined
+            : inheritedFacetKeys(field, schema) === undefined
+                ? field.name
+                : `${field.name}_facet`,
     };
 }
+/**
+ * The {@link FacetKeys facet policy} a field inherits: the `facetKeys` of the
+ * Root Type it names ({@link labelSourceNameOf}), when the field is a facetable
+ * reference and the schema resolves that type. The boundary is *naming the
+ * target* – the same line along which a reference is re-keyed and a join is
+ * drawn – so a reference that names no type inherits nothing, whatever type
+ * its values happen to point at; and a `derive`d reference, which produces its
+ * own values rather than reading a referent, is re-keyed by nothing and so
+ * narrowed by nothing either. The one reading the projection (which writes the
+ * companion) and {@link physicalFields} (which names it) share.
+ */
+export function inheritedFacetKeys(field, schema) {
+    if (schema === undefined ||
+        field.kind !== 'reference' ||
+        field.facetable !== true ||
+        field.derive !== undefined) {
+        return undefined;
+    }
+    const targetName = labelSourceNameOf(field);
+    return targetName === undefined
+        ? undefined
+        : rootTypeNamed(schema, targetName)?.facetKeys;
+}

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;AAmBhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,YAAY,GACzB,IAAI,CAuON"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAoBhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,YAAY,GACzB,IAAI,CAuRN"}

package/dist/testing.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { filterOn, filterOperatorFor, } from './query.js';
-import { facetableFields, filterableFields, ID_FIELD, nestedReferenceType, outputFields, } from './schema.js';
+import { facetableFields, filterableFields, ID_FIELD, inheritedFacetKeys, 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
@@ -200,6 +200,53 @@ export function describeSearchEngineContract(name, engine) {
                 }
             }
         });
+        it('buckets a facet inheriting a policy on admitted keys only, labelled, while filtering stays exact', async () => {
+            // A facet policy (`RootType.facetKeys`) narrows the FACET and nothing
+            // else. Two things an adapter can get wrong, each silently: facet the
+            // companion field but report its buckets under the engine’s name, which
+            // loses every label and files the counts under a key no consumer asked
+            // for; and pick the filter operator off the declaration, so a `where`
+            // on an excluded value – still `facetable` in the schema, no longer a
+            // facet in the engine – partial-matches on a shared path prefix. The
+            // adapter’s fixture should carry two IRIs sharing a prefix so the
+            // second assertion bites.
+            for (const searchType of types()) {
+                for (const field of facetableFields(searchType)) {
+                    const policy = inheritedFacetKeys(field, engine().schema);
+                    if (policy === undefined) {
+                        continue;
+                    }
+                    const result = await engine().search(searchType, {
+                        ...browse(searchType),
+                        limit: 20,
+                        facets: [field.name],
+                    });
+                    const buckets = result.facets[field.name] ?? [];
+                    for (const bucket of buckets) {
+                        expect(policy.only(bucket.value)).toBe(true);
+                        expect(bucket.label).toBeDefined();
+                    }
+                    if (field.output !== true || field.filterable !== true) {
+                        continue; // Nothing to read the stored values back from.
+                    }
+                    const excluded = result.hits
+                        .flatMap((hit) => referenceIds(hit.document[field.name]))
+                        .find((id) => !policy.only(id));
+                    if (excluded === undefined) {
+                        continue;
+                    }
+                    const filtered = await engine().search(searchType, {
+                        ...browse(searchType),
+                        limit: 20,
+                        where: [filterOn({ field: field.name, in: [excluded] })],
+                    });
+                    expect(filtered.total).toBeGreaterThan(0);
+                    for (const hit of filtered.hits) {
+                        expect(referenceIds(hit.document[field.name])).toContain(excluded);
+                    }
+                }
+            }
+        });
         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));
@@ -220,6 +267,16 @@ function mismatchedFilter(field, operator) {
         ? filterOn({ field, range: { min: 0 } })
         : filterOn({ field, in: ['x'] });
 }
+/** The ids a reconstructed reference value carries – one labelled reference
+ *  or a list of them – read the way a consumer reads them. */
+function referenceIds(value) {
+    const references = Array.isArray(value) ? value : [value];
+    return references
+        .map((reference) => typeof reference === 'object' && reference !== null && 'id' in reference
+        ? String(reference.id)
+        : undefined)
+        .filter((id) => id !== undefined);
+}
 /** The locale a query against this type may select (any is contract-valid). */
 function firstLocale(searchType) {
     for (const field of searchType.fields) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "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",