@lde/search 0.23.1 → 0.24.0

package/dist/adapter.d.ts

@@ -6,11 +6,11 @@
  * 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, 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 { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, nestedReferenceType, nestedFieldName, localLookupTypeOf, identityFieldOf, identityFieldName, referenceFields, referenceTypeNamed, rootTypeNamed, inlineFramingDepth, fieldNamed, datasetField, ID_FIELD, AND_KEY, OR_KEY, labelFieldOf, labelFieldNameOf, labelSourceNameOf, labelTargetNameOf, 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';
 export type { JoinGraph } from './join-graph.js';
-export { filterOperatorFor, filterOperator, filterOn, isUnsatisfiable, validateQuery, assertValidQuery, pageForOffset, } from './query.js';
-export type { FilterOperator, QueryIssue } from './query.js';
+export { filterOperatorFor, filterOperator, filterOn, isWelded, isUnsatisfiable, validateQuery, assertValidQuery, resolvePath, pageForOffset, } from './query.js';
+export type { FilterOperator, QueryIssue, ResolvedPath, PathFailure, } from './query.js';
 //# sourceMappingURL=adapter.d.ts.map

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,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"}
+{"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,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,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,QAAQ,EACR,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,cAAc,EACd,UAAU,EACV,YAAY,EACZ,WAAW,GACZ,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, 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 { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, nestedReferenceType, nestedFieldName, localLookupTypeOf, identityFieldOf, identityFieldName, referenceFields, referenceTypeNamed, rootTypeNamed, inlineFramingDepth, fieldNamed, datasetField, ID_FIELD, AND_KEY, OR_KEY, labelFieldOf, labelFieldNameOf, labelSourceNameOf, labelTargetNameOf, 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';
+export { filterOperatorFor, filterOperator, filterOn, isWelded, isUnsatisfiable, validateQuery, assertValidQuery, resolvePath, pageForOffset, } from './query.js';

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 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, KeyField, 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';
-export type { SearchQuery, ReferenceProjection, Filter, Criterion, CriterionBase, Sort, } from './query.js';
+export type { SearchQuery, ReferenceProjection, Filter, Criterion, CriterionBase, WeldedCriterion, Sort, } from './query.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,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,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,eAAe,EACf,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,EAgBL,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"}
+{"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,EAkBL,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;AAsHD;;;;;;;;;;;;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, documentKeyOf, fieldNamed, inlineFramingDepth, irAlias, isAbsoluteIri, isInternalField, isInlineReference, isoToUnixSeconds, labelSourceNameOf, physicalFields, referenceTypeNamed, rootTypeNamed, } from './schema.js';
+import { assertTypeInSchema, displayFieldName, documentKeyOf, fieldNamed, inheritedFacetKeys, inlineFramingDepth, irAlias, isAbsoluteIri, isInternalField, isInlineReference, isoToUnixSeconds, labelSourceNameOf, localLookupTypeOf, physicalFields, referenceTypeNamed, rootTypeNamed, } from './schema.js';
 /** The context a projection runs with when its caller supplied none. */
 const NO_PROJECTION_CONTEXT = {};
 /**
@@ -32,10 +32,16 @@ export function projectDocument(node, searchType, schema, context = NO_PROJECTIO
  * only after all projection – so every derive that might read an internal
  * field, at any depth, has already run – which makes this single post-order
  * pass safe. A no-role inline reference is itself internal, so it is deleted
- * whole here; a surfaced (`output`) inline reference survives, but its own
- * internal helper fields are pruned from the nested document. That keeps the
- * *a field without a role reaches neither the engine nor the API* invariant
- * true at every depth of the reference graph, not just at the root.
+ * whole here; one that carries a Role survives, but its own internal helper
+ * fields are pruned from the nested document. That keeps the *a field without a
+ * role reaches neither the engine nor the API* invariant true at every depth of
+ * the reference graph, not just at the root.
+ *
+ * Both kinds of nesting are walked, because both store projected nodes: an
+ * inline reference’s Reference Type, and the Root Type a
+ * {@link ReferenceStrategy.local local} lookup projects its endpoint through.
+ * The second matters more than it looks – a Root Type’s reading-device fields
+ * exist for its OWN derives, and nothing in a referring document wants them.
  */
 function pruneInternalFields(document, searchType, schema) {
     for (const field of searchType.fields) {
@@ -43,22 +49,18 @@ function pruneInternalFields(document, searchType, schema) {
             delete document[field.name];
             continue;
         }
-        // A surfaced inline reference nests its referent(s) as projected node(s);
-        // prune those too, by their reference type.
         if (schema === undefined || field.kind !== 'reference') {
             continue;
         }
-        const ref = field.ref;
-        if (ref?.strategy !== 'inline') {
-            continue;
-        }
-        const referenceType = referenceTypeNamed(schema, ref.typeName);
+        const nestedType = field.ref?.strategy === 'inline'
+            ? referenceTypeNamed(schema, field.ref.typeName)
+            : localLookupTypeOf(field, schema);
         const nested = document[field.name];
-        if (referenceType === undefined || nested === undefined) {
+        if (nestedType === undefined || nested === undefined) {
             continue;
         }
         for (const referent of Array.isArray(nested) ? nested : [nested]) {
-            pruneInternalFields(referent, referenceType, schema);
+            pruneInternalFields(referent, nestedType, schema);
         }
     }
 }
@@ -148,7 +150,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);
@@ -203,13 +205,29 @@ function applyField(document, node, field, searchType, schema, context) {
         }
         return;
     }
+    // A `local` lookup stores nested documents too, shaped by the TARGET’s own
+    // declaration rather than by a reference type – so an unidentified referent
+    // is an entry like any other, minus its `id`. Same reason as above for
+    // needing a schema: without one there is no target to project through.
+    if (field.kind === 'reference' && schema !== undefined) {
+        const localType = localLookupTypeOf(field, schema);
+        if (localType !== undefined) {
+            const endpoints = applyNestedReferents(document, valuesOf(node, alias), field, localType, schema, context);
+            // A `local` lookup stores an object, so its own id is a level deeper than
+            // a filter can reach – an engine welds conditions on an entry's LEAF
+            // fields only. `filterable` therefore fans out the id beside the object,
+            // exactly as an inline reference's identity companion does.
+            applyLocalIdentity(document, endpoints, field, schema);
+            return;
+        }
+    }
     switch (field.kind) {
         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, referenceValues(node, alias, field, schema), field);
+            return applyFacet(document, referenceValues(node, alias, field, schema), field, schema);
         case 'integer':
             return setNumber(document, field.name, toInteger(firstLiteralOf(node, alias)));
         case 'number':
@@ -327,6 +345,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
@@ -337,7 +365,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
@@ -347,18 +375,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
@@ -371,13 +415,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
@@ -404,9 +448,103 @@ function applyInlineReference(document, node, alias, field, schema, context) {
     if (referenceType === undefined) {
         return;
     }
-    const referents = valuesOf(node, alias)
+    const referents = applyNestedReferents(document, valuesOf(node, alias), field, referenceType, schema, context);
+    applyIdentityCompanion(document, referents, field, schema);
+}
+/**
+ * Write the {@link ReferenceStrategy.identity identity companion} of an inline
+ * reference: the ids its entries reference, flattened out of the nested
+ * documents just projected, under the flat physical name an engine filters and
+ * facets ({@link physicalFields}).
+ *
+ * Harvested from the entries rather than read from a second path, so what the
+ * companion holds is exactly what the entries hold – including the re-keying
+ * the nested reference already applied, which a separately-read path would have
+ * to repeat and could get wrong.
+ *
+ * The identity field stores either bare ids or, when it is a
+ * {@link ReferenceStrategy.local local} lookup, nested documents carrying an
+ * `id`. Both are read here, because which one a deployment declares is about
+ * how much of the referent it wants to display – not about what identifies it.
+ */
+function applyIdentityCompanion(document, referents, field, schema) {
+    const names = physicalFields(field, schema);
+    if (names.identity === undefined) {
+        return;
+    }
+    const identity = field.ref.identity;
+    // Only the entries the document actually STORES: a single-valued reference
+    // keeps the first referent and drops the rest, and a companion holding an id
+    // from a dropped one would match a filter whose hit shows no such entry.
+    const stored = field.array === true ? referents : referents.slice(0, 1);
+    const ids = dedupe(stored.flatMap((referent) => (Array.isArray(referent[identity])
+        ? referent[identity]
+        : [referent[identity]])
+        .map(identityValue)
+        .filter((id) => id !== undefined)));
+    if (ids.length === 0) {
+        return;
+    }
+    setArray(document, names.identity, ids);
+    // Same rule as every other facetable reference: where the target declares a
+    // facet policy, the facet reads a narrowed companion of its own, so an
+    // excluded id is never seen by the engine rather than merely unlabelled.
+    const policy = inheritedFacetKeys(field, schema);
+    if (policy !== undefined) {
+        setArray(document, names.facet, ids.filter(policy.only));
+    }
+}
+/**
+ * Write the identity companion of a {@link ReferenceStrategy.local local}
+ * lookup: the ids of the endpoints just stored, under the flat physical name an
+ * engine filters on ({@link physicalFields}).
+ *
+ * Nothing to do where the field is not `filterable`: without that Role there is
+ * no companion, and the endpoint is display weight like every other nesting.
+ */
+function applyLocalIdentity(document, endpoints, field, schema) {
+    const names = physicalFields(field, schema);
+    if (names.identity === undefined) {
+        return;
+    }
+    // Only the endpoints the field actually STORES: a single-valued reference
+    // keeps the first and drops the rest, and a companion holding an id from a
+    // dropped one would match a filter whose hit shows a different endpoint.
+    const stored = field.array === true ? endpoints : endpoints.slice(0, 1);
+    const ids = dedupe(stored
+        .map((endpoint) => endpoint.id)
+        .filter((id) => typeof id === 'string'));
+    if (ids.length > 0) {
+        setArray(document, names.identity, ids);
+    }
+}
+/** The id a value under an identity field carries: the value itself when the
+ *  field stores bare ids, its `id` when it stores nested documents. */
+function identityValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    const id = isObject(value) ? value.id : undefined;
+    return typeof id === 'string' ? id : undefined;
+}
+/**
+ * Project raw framed values as nested document(s) of `nestedType` and attach
+ * them under the field’s name – the shared body of an inline reference and a
+ * {@link ReferenceStrategy.local local} lookup, which differ only in which type
+ * shapes the referent: a declared Reference Type for the one, the lookup’s own
+ * target Root Type for the other. Sharing it is what makes the two reconstruct
+ * through one path, so a consumer cannot tell a nested referent from a resolved
+ * one.
+ *
+ * Projecting through a Root Type also gives a `local` referent its `id` for
+ * free, re-keyed through that type’s {@link RootType.key} exactly as a
+ * top-level document of that type would be – so the stored id is the one the
+ * target’s collection files it under, and the lookup can find it.
+ */
+function applyNestedReferents(document, values, field, nestedType, schema, context) {
+    const referents = values
         .filter(isObject)
-        .map((referent) => projectFields(referent, referenceType, schema, context))
+        .map((referent) => projectFields(referent, nestedType, 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.
@@ -414,9 +552,10 @@ function applyInlineReference(document, node, alias, field, schema, context) {
         // single-valued reference, let it win the slot over a real referent.
         .filter((referent) => Object.keys(referent).length > 0);
     if (referents.length === 0) {
-        return;
+        return referents;
     }
     document[field.name] = field.array === true ? referents : referents[0];
+    return referents;
 }
 function langValuesOf(node, key) {
     return valuesOf(node, key)

package/dist/query.d.ts

@@ -95,7 +95,33 @@ export type Criterion = (CriterionBase & {
     };
 }) | (CriterionBase & {
     readonly is: boolean;
+}) | (CriterionBase & {
+    readonly entry: readonly Criterion[];
 });
+/**
+ * The conditions a criterion welds to **one entry** of the nested reference its
+ * {@link CriterionBase.field} names – *this endpoint in this role*, rather than
+ * this endpoint somewhere and that role somewhere.
+ *
+ * Welding is the whole reason an edge is worth indexing. Stated as two ordinary
+ * criteria, `role = etser` and `creator = rembrandt` are satisfied by
+ * *different* entries of the same document, which silently answers a wider
+ * question – the parallel-array defect nesting exists to remove.
+ *
+ * It stays an **atom**, so `where` remains the flat conjunction of disjunctions
+ * of [ADR 18](../../docs/decisions/0018-filter-across-several-fields-with-one-clause.md):
+ * the conjunction lives *inside* one criterion rather than nesting clause
+ * structure, and skip-own-filter still scans one level and finds one field.
+ *
+ * Each welded condition names a field of the reference type and carries no
+ * `on` of its own: they are all conditions on the same entry, which is what
+ * welding means.
+ */
+export type WeldedCriterion = CriterionBase & {
+    readonly entry: readonly Criterion[];
+};
+/** Whether a criterion welds conditions to one entry ({@link WeldedCriterion}). */
+export declare function isWelded(criterion: Criterion): criterion is WeldedCriterion;
 /**
  * One `where` clause: a disjunction, matching a document that satisfies **any**
  * of its criteria. An ordinary single-field filter is the one-criterion case,
@@ -169,13 +195,32 @@ export interface QueryIssue {
      *  the bound of an `unparseable-bound`. Absent on every other reason. */
     readonly value?: string;
     readonly reason: 'unknown-field' | 'not-filterable' | 'operator-mismatch' | 'not-facetable'
-    /** The criterion’s `on` path is longer than {@link MAX_JOIN_DEPTH}. */
+    /** The criterion’s `on` path crosses more than {@link MAX_JOIN_DEPTH}
+     *  *joins*. Nested hops cost no round trip and do not count. */
      | 'join-too-deep'
-    /** The `on` path does not resolve: a name that is not a field, a reference
+    /** A join hop does not resolve: a name that is not a field, a reference
      *  that is not `joinable`, or no join graph to resolve it against. */
      | 'unknown-join'
+    /**
+     * A hop *inside* an inline reference’s entries does not walk into a nested
+     * reference – an unknown name, or a field that is not one. Reported apart
+     * from `unknown-join` so “this field is not joinable” and “this field is
+     * not nested” are not one message.
+     *
+     * Joining out of a nesting lands here too, deliberately: a join addresses
+     * another collection and there is none to address from inside an array
+     * element, so from in here a joinable name is as unwalkable as an unknown
+     * one. A join may contain a nesting; never the reverse.
+     */
+     | 'unknown-nesting'
     /** A projected reference is not a `lookup`, so nothing resolves it. */
      | 'not-resolvable'
+    /**
+     * A criterion welds conditions to one entry of a field that has no entries
+     * – it is not an inline reference. Welding means *one entry satisfies all
+     * of these*, so there has to be something to weld them to.
+     */
+     | 'not-weldable'
     /**
      * A `date` range bound the storage codec ({@link isoToUnixSeconds}) cannot
      * read, so there is no stored value to compare against – reported per
@@ -188,6 +233,43 @@ export interface QueryIssue {
      */
      | 'unparseable-bound';
 }
+/**
+ * A resolved {@link CriterionBase.on} path: which type the leaf field belongs
+ * to, and how the criterion reaches it.
+ *
+ * The two hop kinds are genuinely different operations, so they are separated
+ * here once rather than re-derived by every adapter. A **join** hop crosses
+ * into another collection and costs a round trip; a **nested** hop stays inside
+ * the same document and costs nothing, walking into an inline reference’s
+ * entries.
+ */
+export interface ResolvedPath {
+    /** The type the criterion’s leaf field is declared by. */
+    readonly leafType: SearchType;
+    /** The joinable references to cross, in order. Counts against
+     *  {@link MAX_JOIN_DEPTH}; a nested hop deliberately does not. */
+    readonly joinPath: readonly string[];
+    /** The inline references to walk into, in order, after the joins. */
+    readonly nestedPath: readonly string[];
+}
+/** Why an {@link CriterionBase.on} path did not resolve. */
+export type PathFailure = 'join-too-deep' | 'unknown-join' | 'unknown-nesting';
+/**
+ * Resolve an {@link CriterionBase.on} path against the schema, classifying each
+ * hop by what the declaration says it is: a {@link ReferenceField.joinable}
+ * reference is a join, an inline reference is a nesting.
+ *
+ * **Nested hops must come last.** A join is a clause about another collection
+ * and a nesting is a clause about a field of this document, so a join can
+ * contain a nesting (`$people(…)` around `edge.role`) but a nesting cannot
+ * contain a join – there is no collection to address from inside an array
+ * element. Once inside a nesting, therefore, a joinable name is as unwalkable
+ * as an unknown one and both report `unknown-nesting`.
+ *
+ * Only join hops count against {@link MAX_JOIN_DEPTH}: the cap exists to bound
+ * round trips, and a nesting hop costs none.
+ */
+export declare function resolvePath(searchType: SearchType, path: readonly string[], schema: SearchSchema, joins?: JoinGraph): ResolvedPath | PathFailure;
 /**
  * Structurally validate a query against its search type: **every criterion of
  * every `where` clause** names a declared, `filterable` field whose kind accepts

package/dist/query.d.ts.map

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