@lde/search 0.23.1 → 0.24.0

package/dist/query.js

@@ -1,5 +1,9 @@
-import { fieldNamed, filterOperatorFor, ID_FIELD, isoToUnixSeconds, } from './schema.js';
+import { fieldNamed, filterOperatorFor, ID_FIELD, isoToUnixSeconds, nestedReferenceType, } from './schema.js';
 import { MAX_JOIN_DEPTH } from './join-graph.js';
+/** Whether a criterion welds conditions to one entry ({@link WeldedCriterion}). */
+export function isWelded(criterion) {
+    return 'entry' in criterion;
+}
 // The kind→operator table lives with the field model in schema.ts (one source
 // for the query IR, the surfaces, the adapters AND declaration validation);
 // re-exported here so the query-IR module stays the natural import site.
@@ -50,6 +54,96 @@ export function isUnsatisfiable(query) {
             criterion.in.length === 0);
     });
 }
+/**
+ * The checks every leaf criterion answers to, wherever it sits: the field is
+ * declared and `filterable` on the type it constrains, its operator matches
+ * that field's kind, and a `date` range's bounds are readable.
+ *
+ * Shared by an ordinary criterion and by each condition welded to an entry, so
+ * a welded condition is held to exactly the same rules – there is no second,
+ * weaker validator for the inside of an edge. `field` is the path to report
+ * under, which differs between the two.
+ */
+function collectLeafIssues(criterion, constrained, field, issues) {
+    const declared = fieldNamed(constrained, criterion.field);
+    if (declared === undefined) {
+        issues.push({ part: 'where', field, reason: 'unknown-field' });
+        return;
+    }
+    if (declared.filterable !== true) {
+        issues.push({ part: 'where', field, reason: 'not-filterable' });
+        return;
+    }
+    if (filterOperatorFor(declared.kind) !== filterOperator(criterion)) {
+        issues.push({ part: 'where', field, reason: 'operator-mismatch' });
+        return;
+    }
+    if (declared.kind === 'date' && 'range' in criterion) {
+        // A `date` bound is ISO 8601 at the edge and Unix seconds in storage, so a
+        // bound the codec cannot read has nothing to compare against. Both bounds
+        // are checked, so a caller who wrote two bad ones is told about both
+        // instead of fixing one to be told about the other.
+        for (const bound of [criterion.range.min, criterion.range.max]) {
+            if (typeof bound === 'string' && isoToUnixSeconds(bound) === undefined) {
+                issues.push({
+                    part: 'where',
+                    field,
+                    value: bound,
+                    reason: 'unparseable-bound',
+                });
+            }
+        }
+    }
+}
+/**
+ * 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 function resolvePath(searchType, path, schema, joins) {
+    const joinPath = [];
+    const nestedPath = [];
+    let current = searchType;
+    for (const name of path) {
+        const field = fieldNamed(current, name);
+        const nested = field === undefined ? undefined : nestedReferenceType(schema, field);
+        if (nested !== undefined) {
+            nestedPath.push(name);
+            current = nested;
+            continue;
+        }
+        if (nestedPath.length > 0) {
+            // Already inside a document, where the only hop that means anything is
+            // another nesting. A join addresses a collection and there is none to
+            // address from inside an array element, so a joinable name here is as
+            // unwalkable as an unknown one – one reason covers both.
+            return 'unknown-nesting';
+        }
+        // Checked as the budget is spent, not after the walk: a path over the cap
+        // is too deep whether or not its last hop would have resolved, and saying
+        // so is more use than reporting the hop that happened to fail first.
+        if (joinPath.length === MAX_JOIN_DEPTH) {
+            return 'join-too-deep';
+        }
+        const target = joins?.resolve(current, [name]);
+        if (target === undefined) {
+            return 'unknown-join';
+        }
+        joinPath.push(name);
+        current = target;
+    }
+    return { leafType: current, joinPath, nestedPath };
+}
 /** The `field` a joined issue is reported under: the path and the leaf name
  *  together, so a message says which hop and which field, not just which
  *  field. `dataset.publisher.id` reads the way the criterion was written. */
@@ -107,23 +201,29 @@ export function validateQuery(query, searchType, schema, joins) {
             // supplied none cannot serve a joined criterion at all.
             const on = criterion.on ?? [];
             let constrained = searchType;
+            let nested = false;
             if (on.length > 0) {
-                if (on.length > MAX_JOIN_DEPTH) {
-                    issues.push({ part: 'where', field, reason: 'join-too-deep' });
+                const resolved = resolvePath(searchType, on, schema, joins);
+                if (typeof resolved === 'string') {
+                    issues.push({ part: 'where', field, reason: resolved });
                     continue;
                 }
-                const target = joins?.resolve(searchType, on);
-                if (target === undefined) {
-                    issues.push({ part: 'where', field, reason: 'unknown-join' });
-                    continue;
-                }
-                constrained = target;
+                constrained = resolved.leafType;
+                nested = resolved.nestedPath.length > 0;
             }
             // `id` is filterable on every type without being declared by any: it is
             // the document’s IRI, so the lookup exists wherever documents do.
             // Membership only – an IRI has no range and no truth value.
             if (name === ID_FIELD) {
-                if (filterOperator(criterion) !== 'in') {
+                // …but only where documents do. An entry inside a nested reference is
+                // read, not addressed: it has no document key, and the `id` a `local`
+                // lookup stores is the ENDPOINT’s, which the identity companion is
+                // what filters on. Accepting it here would compile to the ROOT
+                // document’s `id` and silently answer a different question.
+                if (nested) {
+                    issues.push({ part: 'where', field, reason: 'unknown-nesting' });
+                }
+                else if (filterOperator(criterion) !== 'in') {
                     issues.push({
                         part: 'where',
                         field,
@@ -133,36 +233,23 @@ export function validateQuery(query, searchType, schema, joins) {
                 continue;
             }
             const declared = fieldNamed(constrained, name);
-            if (declared === undefined) {
-                issues.push({ part: 'where', field, reason: 'unknown-field' });
-            }
-            else if (declared.filterable !== true) {
-                issues.push({ part: 'where', field, reason: 'not-filterable' });
-            }
-            else if (filterOperatorFor(declared.kind) !== filterOperator(criterion)) {
-                issues.push({
-                    part: 'where',
-                    field,
-                    reason: 'operator-mismatch',
-                });
-            }
-            else if (declared.kind === 'date' && 'range' in criterion) {
-                // A `date` bound is ISO 8601 at the edge and Unix seconds in storage,
-                // so a bound the codec cannot read has nothing to compare against.
-                // Both bounds are checked, so a caller who wrote two bad ones is told
-                // about both instead of fixing one to be told about the other.
-                for (const bound of [criterion.range.min, criterion.range.max]) {
-                    if (typeof bound === 'string' &&
-                        isoToUnixSeconds(bound) === undefined) {
-                        issues.push({
-                            part: 'where',
-                            field,
-                            value: bound,
-                            reason: 'unparseable-bound',
-                        });
-                    }
+            // A welded criterion names the NESTED REFERENCE and constrains fields of
+            // the type it nests, so each condition is checked one level in – against
+            // that reference type, and reported under the path a consumer wrote.
+            if (isWelded(criterion)) {
+                const entryType = declared === undefined
+                    ? undefined
+                    : nestedReferenceType(schema, declared);
+                if (entryType === undefined) {
+                    issues.push({ part: 'where', field, reason: 'not-weldable' });
+                    continue;
+                }
+                for (const welded of criterion.entry) {
+                    collectLeafIssues(welded, entryType, [...on, name, welded.field].join('.'), issues);
                 }
+                continue;
             }
+            collectLeafIssues(criterion, constrained, field, issues);
         }
     }
     for (const name of query.facets) {
@@ -188,12 +275,19 @@ export function validateQuery(query, searchType, schema, joins) {
     return issues;
 }
 /**
- * Walk a projection level by level: each key names a `lookup` reference on the
- * type that level belongs to, each `fields` entry an `output` field of the
- * target it resolves against, and each nested `resolve` repeats against that
- * target. A level whose reference is unresolvable stops there – its subtree
- * belongs to a target that does not exist, so reporting it too would bury the
- * one mistake under its consequences.
+ * Walk a projection level by level. A level is one of two things, and the
+ * difference is what it costs rather than how it is written:
+ *
+ * - a **lookup** level names a `lookup` reference, resolves against that
+ *   target’s collection, and costs one batched round trip;
+ * - a **nested** level names an inline reference and descends into its entries,
+ *   costing nothing – the entries are already in the hit. Its `fields` name
+ *   nothing to fetch, because the entries carry what they carry; only the
+ *   levels *below* it can ask for anything.
+ *
+ * A level whose reference is unresolvable stops there: its subtree belongs to a
+ * target that does not exist, so reporting it too would bury the one mistake
+ * under its consequences.
  */
 function collectProjectionIssues(projection, searchType, schema, issues) {
     for (const [name, level] of Object.entries(projection ?? {})) {
@@ -202,6 +296,13 @@ function collectProjectionIssues(projection, searchType, schema, issues) {
             issues.push({ part: 'resolve', field: name, reason: 'unknown-field' });
             continue;
         }
+        // Descending into an inline reference is free, so a nested level is valid
+        // wherever the entries exist – what it is *for* is the lookup below it.
+        const nested = nestedReferenceType(schema, field);
+        if (nested !== undefined) {
+            collectProjectionIssues(level.resolve, nested, schema, issues);
+            continue;
+        }
         if (field.kind !== 'reference' || field.ref?.strategy !== 'lookup') {
             issues.push({ part: 'resolve', field: name, reason: 'not-resolvable' });
             continue;

package/dist/schema.d.ts

@@ -186,7 +186,10 @@ export interface KeywordField extends SearchFieldBase, Searchable {
  *   `‹Target›Reference`, since type names must be unique).
  * - `inline` carries fields denormalised from the **parent’s** RDF framing at
  *   index time, shaped by the declared {@link ReferenceType} `typeName` names –
- *   so its typeName can never name a root type.
+ *   so its typeName can never name a root type. Pointed at a node the graph put
+ *   *between* subject and endpoint, the nested node is the **edge**, and
+ *   {@link ReferenceStrategy.identity `identity`} names the nested reference
+ *   that carries the endpoint.
  */
 export type ReferenceStrategy = {
     readonly strategy: 'idOnly';
@@ -198,12 +201,67 @@ export type ReferenceStrategy = {
      *  that belong to no such set. */
     readonly typeName?: string;
     readonly target?: never;
+    readonly identity?: never;
 } | {
     readonly strategy: 'lookup';
     readonly target: string;
+    /**
+     * Also project the target’s **own fields from this document’s frame**, so
+     * the reference stores what the referring document states about the
+     * referent alongside the id – and the resolved document overlays it at
+     * query time rather than being the only source of it.
+     *
+     * What it buys is one field where there were two. A referent the graph
+     * names inline – a literal, a blank node – has no id, so a plain
+     * reference stores nothing for it and a deployment needs a second, text
+     * field beside this one to show it at all; the two are then parallel
+     * arrays that cannot be paired. With `local`, an unidentified referent is
+     * an entry like any other, minus its `id`.
+     *
+     * Stored **unconditionally**, not only where there is no id, because the
+     * two failures differ: at index time the question is *is this referent
+     * identified*, at query time it is *is that document indexed*. A referent
+     * whose document is missing from the target’s collection therefore still
+     * carries what this document said about it, instead of degrading to a
+     * bare IRI.
+     *
+     * Opt-in, because it changes what the field stores – a nested object
+     * rather than an id – and because framing must reach one step further to
+     * read the target’s fields off the referent
+     * ({@link inlineFramingDepth}). A schema that declares none pays neither.
+     */
+    readonly local?: boolean;
+    readonly identity?: never;
 } | {
     readonly strategy: 'inline';
     readonly typeName: string;
+    /**
+     * The `name` of a **nested reference field** of this reference type whose
+     * ids identify each entry’s endpoint – required to declare `filterable`
+     * or `facetable` on the inline reference itself, and meaningless without
+     * one ({@link searchSchema} enforces both directions).
+     *
+     * A nested object is not something an engine can filter or facet, so an
+     * inline reference that opts into either fans out an **identity
+     * companion**: a flat physical field holding the ids its entries
+     * reference ({@link physicalFields}), which the engine filters and facets
+     * in the nested object’s place. The same mechanism `${name}_facet`
+     * already uses – one logical field, two physical fields, one holding a
+     * derived subset of the other.
+     *
+     * Declared rather than inferred, because a reference type may carry more
+     * than one nested reference and only the schema author knows which one
+     * identifies the edge. Naming it is also what gives the companion a
+     * **target**: the named field’s own `target` is the Root Type whose keys
+     * these ids are, which is what a facet policy is inherited through
+     * ({@link inheritedFacetKeys}) and what types the filter at the surface.
+     *
+     * The companion holds ids only, so a facet over it is exact and
+     * identity-keyed: an entry whose endpoint the graph named inline – a
+     * literal, a blank node – contributes no bucket rather than a bucket
+     * keyed on a label, so two endpoints that share a label are never merged.
+     */
+    readonly identity?: string;
 };
 /** An IRI-valued reference to another entity, resolved at the surface. */
 export interface ReferenceField extends SearchFieldBase, Searchable {
@@ -371,6 +429,40 @@ export interface KeyField {
      */
     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
@@ -386,6 +478,10 @@ export interface RootType extends SearchTypeBase {
     /** 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
@@ -407,6 +503,9 @@ export interface ReferenceType extends SearchTypeBase {
      *  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
@@ -499,14 +598,21 @@ export declare function isInlineReference(field: SearchField): field is Referenc
     };
 };
 /**
- * The {@link ReferenceType} a **surfaced** inline reference nests – an
- * `output` inline reference’s referent shape – or `undefined` for every other
- * field. The one predicate the collection definition, result reconstruction and
- * the API surfaces share, so they cannot disagree about which fields carry a
- * nested Search Document and which carry a bare IRI: an inline reference
- * declaring no Role is a reading device, pruned before the writer
- * ({@link isInternalField}), and a `labelOnly`/`idOnly` reference stays an id
- * (plus a resolved label).
+ * The {@link ReferenceType} an inline reference **stores entries of**, or
+ * `undefined` for every other field. The one predicate the collection
+ * definition, result reconstruction and the API surfaces share, so they cannot
+ * disagree about which fields carry nested Search Documents and which carry a
+ * bare IRI: a `labelOnly`/`idOnly` reference stays an id (plus a resolved
+ * label).
+ *
+ * The line is *any Role at all*, not `output`: an inline reference declaring no
+ * Role is a reading device, pruned before the writer
+ * ({@link isInternalField}), while one that is `filterable` or `facetable`
+ * without being `output` still has its entries stored – they are what a nested
+ * filter constrains and what the
+ * {@link ReferenceStrategy.identity identity companion} is harvested from. Only
+ * `output` decides whether they are *surfaced*, which is the surfaces’ own
+ * question ({@link outputFields}).
  *
  * A schema built by {@link searchSchema} always resolves the reference type of
  * its own types; `undefined` for a type declared against another schema.
@@ -527,12 +633,27 @@ export declare function nestedReferenceType(schema: SearchSchema, field: SearchF
  */
 export declare function nestedFieldName(parent: string, name: string): string;
 /**
- * The framing depth a Root Type needs: how many hops the inline reference graph
- * reaches from it (`Dataset → Subset → Measurement` is two), floored at one so
- * the existing single-hop embed for non-inline references is preserved. Depth is
- * a property of the declaration, bounded because {@link searchSchema} rejects
- * inline cycles – never a knob or a constant. Framing bounded per batch keeps
- * memory bounded by the unit of work (ADR 12), not the graph.
+ * The framing depth a Root Type needs: how far the **furthest value it declares**
+ * lies from it, in hops. Depth is a property of the declaration, bounded because
+ * {@link searchSchema} rejects inline cycles – never a knob or a constant.
+ * Framing bounded per batch keeps memory bounded by the unit of work (ADR 12),
+ * not the graph.
+ *
+ * Reach is measured in hops and depth in *intermediate* nodes, so depth is one
+ * less: reading `<a>/<b>` off a root needs the root’s own triples plus those of
+ * the node `<a>` reaches, which is depth 1. Floored at one, preserving the
+ * single-hop embed a non-inline reference has always had.
+ *
+ * Three things add hops, and counting only the first is what let a value fall
+ * outside the frame and be stored as absent, in silence:
+ *
+ * - **a property path**, which may traverse (`<a>/<b>` is two hops);
+ * - **an inline reference**, whose referent’s own fields reach on from wherever
+ *   its path landed;
+ * - **a reference naming a keyed target**, whose document key is read one hop
+ *   past the referent (ADR 22) – so a reference reached through an inline
+ *   chain needs its key hop inside the frame too, or it stores an un-keyed id
+ *   that matches nothing in the target’s collection.
  */
 export declare function inlineFramingDepth(schema: SearchSchema, searchType: SearchType): number;
 /** The label field name a type falls back to when it declares no
@@ -565,7 +686,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' | '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';
+    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
@@ -638,7 +759,10 @@ export declare const OR_KEY = "or";
  *   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.
+ *   ({@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.
@@ -667,7 +791,56 @@ 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 **identity companion** an inline reference filters and facets through:
+     * `${name}_id`, holding the ids its entries reference
+     * ({@link ReferenceStrategy.identity}). `undefined` for every other field –
+     * an ordinary field filters on its own `name`.
+     *
+     * A nested object is not a value an engine filters or facets, so this is the
+     * flat field it filters and facets in its place. The logical field keeps one
+     * name at the surface; only the physical fanout knows there are two.
+     */
+    readonly identity: string | undefined;
 }
+/** The physical name of an inline reference’s
+ *  {@link ReferenceStrategy.identity identity companion}. */
+export declare function identityFieldName(name: string): string;
+/**
+ * The Root Type whose labels a reference’s **facet buckets** read – its own
+ * label source, or, for an inline reference, the one its
+ * {@link ReferenceStrategy.identity identity companion} points at.
+ *
+ * The same one-level-in reading {@link inheritedFacetKeys} makes, and for the
+ * same reason: the companion holds that field’s ids, so the type that names
+ * those ids is the type that can label them. Kept together with it so a facet
+ * cannot inherit a policy from one type and its labels from another – or, as
+ * happened first, inherit the policy and no labels at all.
+ */
+export declare function labelTargetNameOf(field: SearchField, schema: SearchSchema | undefined): string | undefined;
+/**
+ * The Root Type a {@link ReferenceStrategy.local local} lookup projects its
+ * referents through, or `undefined` for every other field. Such a reference
+ * stores nested documents shaped by the **target’s own declaration** – so it
+ * needs no reference type of its own, and reconstructs through the same path a
+ * resolved referent does.
+ */
+export declare function localLookupTypeOf(field: SearchField, schema: SearchSchema | undefined): RootType | undefined;
+/**
+ * The nested reference an inline reference’s
+ * {@link ReferenceStrategy.identity identity companion} harvests, or
+ * `undefined` where the field declares none (or the schema cannot resolve its
+ * reference type). The one reading of *which nested field identifies the edge*,
+ * so the projection (which harvests it), {@link inheritedFacetKeys} (which
+ * reads its target’s facet policy) and an adapter’s filter compiler cannot
+ * resolve it differently.
+ */
+export declare function identityFieldOf(field: SearchField, schema: SearchSchema | undefined): ReferenceField | undefined;
 /**
  * The display fields of a localized `text` field are pattern-based, not
  * enumerated per declared locale: projection stores `${name}_${lang}` for
@@ -851,9 +1024,36 @@ 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.
+ * 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.
+ *
+ * An **inline** reference names its target one level in, through the nested
+ * reference its {@link ReferenceStrategy.identity identity companion} harvests
+ * ({@link identityFieldOf}). The boundary is the same one: the companion holds
+ * that field’s ids, so the policy that narrows a facet over those ids is the
+ * policy of the type that field names. Reading it through the nested field
+ * rather than declaring it twice is what keeps *which of a type’s ids deserve
+ * a bucket* a fact about the type.
  */
-export declare function physicalFields(field: SearchField): PhysicalFields;
+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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"}