@lde/search 0.12.2 → 0.13.0

package/README.md

@@ -6,400 +6,12 @@ a running search engine needs is derived from it: the document projection, the
 engine collection definition, the query semantics, and the API surface. All these
 are kept in sync automatically rather than handwritten per deployment.
 
-The core itself is **engine-, API- and domain-agnostic**: it bakes in no search
-engine, no API protocol, and no domain vocabulary. The engine- and API-specific
-halves are adapters that plug into the ports defined here:
+## Installation
 
-- **engine adapters** implement the `SearchEngine` port:
-  [`@lde/search-typesense`](../search-typesense), with OpenSearch to follow;
-- **API surfaces** drive it, parsing client input into `search(SearchQuery)`:
-  [`@lde/search-api-graphql`](../search-api-graphql), with a REST
-  surface to follow.
-
-The library never names your domain: the same core drives a `Dataset`,
-`Person`, or `CreativeWork` search.
-
-It provides four things:
-
-- **unified field model** – `SearchField` / `SearchType` / `SearchSchema`:
-  one declaration per field that drives all four consumers below, so they
-  cannot drift;
-- **neutral query IR** – `SearchQuery` / `Filter` / `Sort` + filter
-  semantics: every API surface compiles into it, every engine adapter compiles
-  out of it, so the two cannot drift;
-- **engine port** – `SearchEngine` and the logical result types
-  (`SearchResult` / `SearchHit` / `ResultDocument` / `Reference` / …);
-- **streaming projection** – `projectRoots`, RDF `CONSTRUCT` quads → flat
-  search documents, one root type at a time.
-
-```
-SearchSchema ─┬─► projection      (projectRoots → flat documents)        [here]
-              ├─► engine adapter  (collection definition + query compiler)   e.g. @lde/search-typesense
-              ├─► query semantics (SearchQuery, filter/sort/facet)       [here]
-              └─► API surface     (GraphQL / REST)                       e.g. @lde/search-api-graphql
-```
-
-At runtime, everything those consumers do is a **pure transformation between
-data shapes**, each one parameterised by the schema – three chains, meeting at
-the engine:
-
-```
-indexing:  RDF quads ──frame──► FramedNode ──project──► SearchDocument ──import──► engine
-querying:  client input ──parse──► SearchQuery ──compile──► engine query
-results:   engine response ──parse──► SearchResult ──shape──► API output
-```
-
-Validation happens before the first arrow (SHACL over the RDF) and inside the
-last (the engine enforces its collection definition); between them every stage is
-a typed, deterministic function – easy to test, and swappable per deployment.
-
-## Entry points
-
-Exports are stratified by audience:
-
-- **`@lde/search`** – the authoring surface: `defineSearchType`,
-  `searchSchema`, `projectRoots`, validation, and every model/query/result type.
-- **`@lde/search/adapter`** – plumbing for engine adapters and API surfaces:
-  `physicalFields`, the field selectors, `assertValidQuery`, the filter
-  operators and storage codecs.
-- **`@lde/search/module`** – `loadSchemaModule`, the Node-only loader for a
-  mounted schema-declaration module (an `.mjs` default-exporting declarations
-  as plain data). The one loader both the indexer image and the served-API
-  image boot from, so the write and the read side cannot disagree about the
-  schema.
-- **`@lde/search/testing`** – `describeSearchEngineContract`, the executable
-  port contract every engine adapter runs against a live instance of itself
-  (vitest; optional peer).
-
-## Terminology
-
-The model has three levels, with analogues in SHACL ([one possible source](#why-a-declarative-model))
-and GraphQL (one of the surfaces):
-
-| Term           | What it is                                                                                                                                                                                                                       | SHACL          | GraphQL     |
-| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- | ----------- |
-| `SearchField`  | One queryable field: a `kind`, the IR `path` it projects from, and the capability flags it opts into                                                                                                                             | property shape | field       |
-| `SearchType`   | One type’s complete declaration: its logical API `name` and fields (incl. derived). A **Root Type** declares a `class` (indexed, keys the schema); a **Reference Type** declares none (reached only through an inline reference) | NodeShape      | object type |
-| `SearchSchema` | The whole search declaration: every Root Type, keyed by `class` IRI, plus the Reference Types – build one with `searchSchema(...types)`                                                                                          | shapes graph   | schema      |
-
-A `SearchType` is a **Root Type** or a **Reference Type**, told apart by one
-absence: a Root Type declares a `class`, so roots are selected for it and a
-writer opens a collection for it; a Reference Type declares none, so it is
-never selected, framed by type or indexed – its identity is its name, and its
-type comes from the edge that points at it. `searchSchema` partitions its
-arguments accordingly: Root Types key the class map (`schema.values()` yields
-only them, so no writer ever opens a collection for a Reference Type), Reference
-Types go into a name index an inline `ref.typeName` resolves against. The
-absence is load-bearing, and enforced at the type level – an indexed Reference
-Type fails to compile ([ADR 11](../../docs/decisions/0011-decouple-rdf-depth-from-the-api-surface.md)).
-
-`projectRoots` and the engine port each execute one `SearchType` at a time –
-projection over the roots the pipeline selector supplied for that type; the
-GraphQL surface consumes the whole `SearchSchema`.
-
-### API conventions
-
-Two conventions hold across the whole family:
-
-- **Parameter order** – a function takes the value it operates on first and
-  the declaration right after it: `projectDocument(node, type)`,
-  `buildSearchParams(query, type)`,
-  `createTypesenseSearchEngine(client, schema, options)`,
-  `engine.search(type, query)`.
-- **Factory verbs** – the verb tells you what kind of thing comes back.
-  `define*` captures a declaration as a literal (`defineSearchType`);
-  `build*` is a pure data-to-data constructor (`buildCollectionDefinition`,
-  `buildSearchParams`, `buildGraphQLSchema`); `create*` makes a stateful
-  instance (`createTypesenseSearchEngine`). A bare noun (`searchSchema`)
-  constructs the trivial container it names.
-
-## Field model
-
-The mapping is data, not code. Each field declares its `kind`, the IR `path` to
-read (or a `derive` function for a **derived** field, computed from the document
-in declaration order – so it may read fields declared before it, never the
-graph), and the capabilities (**roles**) it opts into. `path` is therefore the
-complete statement of what the projection reads from the graph. A field that
-declares **no** role is an **internal field**: projected so a later `derive` can
-read it, then pruned before the writer and absent from the collection definition
-– not stored, not indexed, no RAM. The physical field names a declaration fans
-out to (per-locale search/sort keys) come from `physicalFields`, the single
-convention projection, the collection definition and the query compiler all
-share.
-
-```ts
-import { defineSearchType, projectRoots, searchSchema } from '@lde/search';
-
-const DATASET = defineSearchType({
-  name: 'Dataset', // logical API name: names the GraphQL type, a REST path, …
-  class: 'http://www.w3.org/ns/dcat#Dataset',
-  fields: [
-    // → title_<lang> (display, every present language), title_search_nl/_en, title_sort_nl/_en
-    {
-      name: 'title',
-      path: 'http://purl.org/dc/terms/title',
-      kind: 'text',
-      locales: ['nl', 'en'],
-      output: true,
-      searchable: { weight: 5 },
-      sortable: true,
-    },
-    // → publisher (IRI facet, resolved to a labelled reference at the surface)
-    {
-      name: 'publisher',
-      path: 'http://purl.org/dc/terms/publisher',
-      kind: 'reference',
-      facetable: true,
-      output: true,
-      ref: { typeName: 'Organization', strategy: 'labelOnly' },
-    },
-    // → size (int)
-    { name: 'size', path: 'urn:dr:size', kind: 'integer', sortable: true },
-    // internal field (no role): projected as a reading device for the derive
-    // below, then pruned before the writer – absent from the collection too
-    { name: 'classes', path: 'urn:dr:class', kind: 'reference' },
-    // derived field (no path): computed from the document in declaration order,
-    // never from the graph – so `path` stays the whole statement of what is read
-    {
-      name: 'classCount',
-      kind: 'integer',
-      sortable: true,
-      derive: (document) =>
-        (document.classes as string[] | undefined)?.length ?? 0,
-    },
-  ],
-});
-
-const schema = searchSchema(DATASET);
-for await (const document of projectRoots(quads, roots, schema, DATASET)) {
-  // one flat search document per given root subject, streamed. The caller (the
-  // pipeline selector) supplies `roots`; pairing a document with its type for a
-  // multi-collection writer is the pipeline glue’s job (see
-  // `@lde/search-pipeline`), not the projection’s.
-}
+```sh
+npm install @lde/search
 ```
 
-`defineSearchType` captures the declaration as a literal (what
-`as const satisfies SearchType` would do manually, with nothing to remember),
-so typed facet/output keys can be derived from it – see
-[Typed results](#typed-results) and `@lde/search-api-graphql`.
-
-**Kinds** (`FieldKind`): `text`, `keyword`, `integer`, `number`, `boolean`,
-`date`, `reference`. The Typesense/engine vocabulary and the GraphQL types are
-_derived_ from the kind by the adapter and the surface – never declared here.
-
-`SearchField` is a **discriminated union by `kind`** (`TextField`,
-`KeywordField`, `ReferenceField`, `NumericField`, `BooleanField`): each kind
-declares exactly the properties it can honour – `locales` on text, `ref` on
-references, `facetRanges` on numerics – so an illegal declaration fails to
-compile. Text is **always multilingual in shape**: `locales` lists the
-language tags to **index** (search/sort), and the reserved **`und`** locale
-(JSON-LD `@none`, RDF `und`) buckets untagged literals – a monolingual or
-untagged corpus declares `locales: ['und']`, mixed data `['nl', 'und']`.
-Display, by contrast, keeps every language present, not only the listed ones
-(see [Locales](#locales)). Declaring a real language is recommended (it drives
-per-locale stemming); `und` is folded but unstemmed unless `defaultLocale` opts
-in, is never demoted in search weighting, and adding a language later is
-additive – the API output shape never changes. Use `keyword` for exact-match
-tokens, never for prose.
-
-**Declarations are also validated at runtime** (for declarations built
-outside TypeScript – a SHACL generator, plain JS): `searchSchema()`
-rejects a structurally invalid declaration (duplicate field names, an `output`
-reference without `ref`, `text` without locales, `locales` on a non-text kind,
-`facetRanges` on a non-numeric kind, `searchable`/`transform` on a kind whose
-projection cannot honour it, `filterable`/`facetable` on `text`, two types
-sharing a `class` IRI or `name`) – the declaration-time counterpart of the
-port’s always-on query validation, so a bad schema fails at startup rather
-than per document at index time. `validateSearchType` /
-`assertValidSearchType` are exported for validating a single declaration
-directly.
-
-| kind                 | `where`              | facet | sort             | output                          |
-| -------------------- | -------------------- | ----- | ---------------- | ------------------------------- |
-| `text`               | – (feeds free text)  | –     | yes (per-locale) | best-first language list        |
-| `keyword`            | `in` (membership)    | yes   | –                | string / `string[]`             |
-| `reference`          | `in` (membership)    | yes   | –                | labelled reference (id + label) |
-| `integer` / `number` | `range { min, max }` | yes   | yes              | number                          |
-| `date`               | `range` (inclusive)  | yes   | yes              | ISO 8601 string (surface)       |
-| `boolean`            | `is`                 | yes   | –                | boolean (absent = false)        |
-
-A `reference` carries one of two strategies today: `labelOnly` (id + display
-label, resolved at query time from a label source) and `inline` (the referent’s
-own projected fields, carried inline). `idOnly` stays a forward declaration.
-
-An **inline reference** resolves `ref.typeName` to a declared **Reference Type**
-and projects the referent through it – a nested `SearchDocument`, or an array
-for an `array` reference. Roles decide whether the nesting surfaces, so the same
-construct serves two jobs (see
-[ADR 11](../../docs/decisions/0011-decouple-rdf-depth-from-the-api-surface.md)):
-
-- a **reading device** declares no role, so it is an internal field: projected
-  so a later `derive` can select and flatten a value a `path` cannot address (a
-  qualified hop), then pruned before the writer – nothing nested reaches the
-  engine or the API;
-- an **API device** declares `output`, deliberately surfacing the nested
-  Reference Type.
-
-So RDF depth and API shape stay independent: inline as deep as the source
-demands, expose exactly the flat fields you want. Framing follows the inline
-reference graph to the depth the schema declares (`Dataset → Subset →
-Measurement` is two hops), and `searchSchema` rejects inline cycles – the one
-way that depth could be unbounded – so it stays a bounded property of the
-declaration.
-
-A reference resolves its label from a **label source**: `labelSource` names
-the `SearchType` whose collection holds the referenced entities. The named
-type must declare an `output`, `searchable` text field called `label` –
-`searchSchema` validates this schema-wide, so a dangling or unsuitable label
-source fails at startup. A reference without a `labelSource` stays id-only.
-
-## Projection
-
-`projectRoots` projects **one root type** over the roots the caller supplies –
-the pipeline selector already holds them, so nothing is discovered from
-`rdf:type` and a `CONSTRUCT` need emit no type triple. It is fully streaming:
-each root’s subgraph is framed one at a time and its document yielded as
-produced, so beyond a subject index memory stays flat at scale (framing the
-whole graph at once is roughly O(N²)). Duplicate triples are collapsed first,
-because some SPARQL engines (e.g. QLever) do not deduplicate `CONSTRUCT` output.
-Every predicate a value comes from is read through a field’s `path`; a `derive`
-computes only from the document projected so far, so `path` is the whole
-statement of what the projection reads. `assertTypeInSchema` guards that
-the passed `SearchType` is a member of the schema – the port’s own membership
-check – so no schema is ever forged to scope a projection to one type.
-
-**Blank-node roots are not indexable**: a blank node has no stable document
-key, so framing skips a blank-node root (and any root absent from the index)
-rather than crash. Blank-node subjects still embed fine when _referenced_ from
-a root; they just cannot _be_ one – select roots accordingly
-(`selectByClass` in `@lde/search-pipeline` already excludes them).
-
-`projectRoots` yields a **bare** `SearchDocument`. Pairing each document with the
-`SearchType` it belongs to, so the write side can fan a mixed stream out to
-per-type collections, is a routing concern owned by the pipeline glue – see
-`@lde/search-pipeline`’s `searchStages` and multi-collection writer – not the
-projection. One stage per root type keeps `@lde/search` pipeline-free.
-
-`projectRoots` **consumes the quads once** – a single scan builds the subject
-index the roots frame off – and so accepts any `Iterable<Quad>`, not just a
-materialized array. A caller merging several readers can pass a chained
-generator instead of building a third full array at the projection peak:
-
-```ts
-projectRoots(
-  (function* () {
-    yield* registerQuads;
-    yield* dkgQuads;
-  })(),
-  roots,
-  schema,
-  DATASET,
-);
-```
-
-## Locales
-
-`locales` declares the languages a `text` field wants **indexed** (`und` =
-untagged literals). It drives the two per-locale, in-memory fanouts –
-`searchable` and `sortable` – but **not** display, which preserves every
-language present:
-
-- `output` → `title_<lang>` for **every** language the data carries (`title_nl`,
-  `title_en`, `title_fr`, `title_und`, …), accents preserved. Display is stored
-  `index: false` (on disk, off RAM), so extra languages cost nothing – a value
-  in a language outside `locales`, or an untagged one, still renders rather than
-  collapsing to a bare IRI. One un-indexed regex field (`${name}_<lang>`, see
-  `displayFieldPattern`) captures them all;
-- `searchable` → `title_search_nl`/`title_search_en` (folded; one field per
-  locale lets a query `query_by` them and rank the user’s language higher, and
-  lets a language that needs a dedicated tokenizer set its own stemming `locale`
-  in the engine schema);
-- `sortable` → `title_sort_nl`/`title_sort_en` (folded, so a locale-switching UI
-  sorts on the active language).
-
-A field with `searchable` but no `output` is **search-only** – folded and stemmed
-for retrieval but never rendered (e.g. a creator searched here but shown via a
-separate label). **Only listed locales are indexed** (searched and sorted); a
-literal whose language tag is not in `locales` is still **displayed** but not
-matched or sorted on. Display fields are **omitted, never empty**, when a document
-lacks that language, and the per-locale search/sort fields likewise, so declare
-them optional in the engine schema and sort with `missing_values: last`. A
-deployment that wants to bound the displayed languages narrows them upstream
-(e.g. selecting a language subset in its CONSTRUCT query), since preservation is
-the default.
-
-Folding the search fields is what lets diacritic-insensitive matching and
-stemming coexist. A search engine on its **default** locale typically folds case
-and diacritics for you; enabling a language’s **stemming** switches it to ICU
-tokenization, which **preserves** diacritics – at which point `fold()` (from
-[`@lde/text-normalization`](../text-normalization)) is what keeps matching
-diacritic-insensitive. Stemming is rules-based and can mangle proper nouns (the
-Dutch stemmer reduces the city `Bergen` to `berg`), so enable it on free-text
-fields and keep proper-noun facets on a separate, unstemmed field.
-
-## Querying
-
-The search fields are stored already case- and diacritic-folded, so **the query
-must be folded the same way** with the same `fold()` before it reaches the engine,
-or index and query normalize differently and matches silently miss. This contract
-holds for **any** consumer, including an API built on this package – which is why
-engine adapters and surfaces compile through the shared `SearchQuery` IR and the
-`physicalFields` convention rather than re-deriving field names.
-
-Queries are **always validated**: the port contract requires every engine
-adapter to reject a structurally invalid `SearchQuery` (`assertValidQuery`) –
-unknown or non-`filterable` fields in `where`, an operator not matching the
-field’s kind, non-`facetable` facet requests – no matter which surface or
-policy produced it. A typed surface like GraphQL makes most of these
-unrepresentable; the port enforces them for everyone else (deployment
-`queryDefaults`, in-process callers, weaker-typed surfaces).
-
-## Typed results
-
-An engine is **bound to the whole `SearchSchema` at construction** – like
-every other schema consumer (`projectRoots(quads, roots, schema, type)`,
-`buildGraphQLSchema(schema)`): the adapter factory takes the deployment’s
-declaration, so a query can never meet the wrong index, and deployment-level
-concerns (the label cache, cross-type search, facet batching) have one home.
-Where each type physically lives is the **adapter’s** to decide – it derives a
-collection/index name from the type, by its own engine’s naming conventions,
-and a deployment only overrides that where it must. A search names its type per
-call. Because `searchSchema()` captures the declared types as a literal
-tuple, `search()` accepts **only the deployment’s own types** (a foreign type
-is a compile error) and returns facet/document keys typed by the type passed
-– no caller-side generics:
-
-```ts
-// No `collections`: each type reads the collection the adapter names it,
-// which is the one its writer builds. Pass `collections` only to override.
-const engine = createTypesenseSearchEngine(client, schema);
-
-const result = await engine.search(DATASET, query);
-result.facets.publisher; // typed: only DATASET’s facetable fields are keys
-result.facets.publsher; // compile error (typo)
-result.hits[0].document.title; // typed: only DATASET’s output fields are keys
-await engine.search(OTHER_TYPE, query); // compile error: not in this schema
-```
-
-`searchFacets(type, queries)` is the port’s **batch entry point**: several
-facet-only queries – e.g. a faceted listing’s skip-own-filter variants –
-answered in one engine round-trip (Typesense: a single `multi_search`), one
-outcome per query, positionally aligned – its facet map, or an in-place error,
-so one failed query never discards its siblings’ facets. The same schema
-binding, per-query validation and typed facet keys apply to every query in
-the batch.
-
-This only works when the types were declared with `defineSearchType` (or
-captured `as const satisfies SearchType`) and composed with `searchSchema()`;
-a plain `: SearchSchema` annotation widens gracefully to string keys.
-`FacetFieldsOf`/`OutputFieldsOf` are exported for annotating your own
-signatures, and `engine.schema` exposes the bound declaration for routing.
-
-## Why a declarative model
+## Documentation
 
-The vocabulary mirrors SHACL on purpose: `path` is `sh:path`, `array` is
-`sh:maxCount`, `required` is `sh:minCount`, `locales` is `sh:languageIn`, `ref`
-is `sh:class`/`sh:node`. So the same core that runs a hand-written `SearchSchema`
-today will run a **SHACL-generated** one tomorrow – the model, the ports and the
-IR stay; only schema-authoring gets automated.
+See the [full documentation](https://ldelements.org/reference/search).

package/dist/adapter.d.ts

@@ -6,9 +6,9 @@
  * deployment author declaring a schema and running searches needs none of
  * this; the main entry point carries that (small) authoring surface.
  */
-export { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, referenceFields, referenceTypeNamed, inlineFramingDepth, fieldNamed, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
+export { assertTypeInSchema, physicalFields, irAlias, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, isInternalField, isInlineReference, referenceFields, referenceTypeNamed, inlineFramingDepth, fieldNamed, ID_FIELD, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
 export type { PhysicalFields } from './schema.js';
 export { physicalNameTokens } from './physical-name.js';
-export { filterOperatorFor, filterOperator, validateQuery, assertValidQuery, pageForOffset, } from './query.js';
+export { filterOperatorFor, filterOperator, isUnsatisfiable, validateQuery, assertValidQuery, pageForOffset, } from './query.js';
 export type { FilterOperator, QueryIssue } 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,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,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,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/adapter.js

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

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { projectRoots } from './project.js';
 export type { SearchDocument } from './project.js';
-export { defineSearchType, searchSchema, validateSearchType, assertValidSearchType, } from './schema.js';
+export { defineSearchType, searchSchema, validateSearchType, assertValidSearchType, ID_FIELD, } from './schema.js';
 export type { FieldKind, SearchField, SearchFieldBase, TextField, KeywordField, ReferenceField, NumericField, BooleanField, SearchType, SearchTypeBase, RootType, ReferenceType, RootTypeOf, SearchTypeIssue, SearchSchema, FacetRange, } from './schema.js';
 export type { SearchQuery, Filter, Sort } from './query.js';
 export type { SearchEngine, SearchResult, SearchHit, ResultDocument, SearchValue, LocalizedValue, Reference, FacetBucket, FacetMap, FacetsOutcome, FacetFieldsOf, OutputFieldsOf, } from './engine.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,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAKnD,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACb,UAAU,EACV,eAAe,EACf,YAAY,EACZ,UAAU,GACX,MAAM,aAAa,CAAC;AAIrB,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAI5D,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,WAAW,EACX,cAAc,EACd,SAAS,EACT,WAAW,EACX,QAAQ,EACR,aAAa,EACb,aAAa,EACb,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAKnD,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,GACT,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EACR,aAAa,EACb,UAAU,EACV,eAAe,EACf,YAAY,EACZ,UAAU,GACX,MAAM,aAAa,CAAC;AAIrB,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAI5D,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,WAAW,EACX,cAAc,EACd,SAAS,EACT,WAAW,EACX,QAAQ,EACR,aAAa,EACb,aAAa,EACb,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -10,4 +10,4 @@ export { projectRoots } from './project.js';
 // Unified field model: one declaration drives projection, engine collection
 // schema, query semantics and the GraphQL surface – a discriminated union by
 // `kind`, validated again at runtime when the schema is built.
-export { defineSearchType, searchSchema, validateSearchType, assertValidSearchType, } from './schema.js';
+export { defineSearchType, searchSchema, validateSearchType, assertValidSearchType, ID_FIELD, } from './schema.js';

package/dist/query.d.ts

@@ -24,7 +24,7 @@ export interface SearchQuery {
  * One `where` clause. The operator is fixed by the target field’s {@link FieldKind}
  * ({@link filterOperatorFor}): keyword/reference use `in` (OR within the field),
  * the numeric/date kinds use an inclusive `range`, boolean uses `is`. Bounds are
- * inclusive only — no `gt`/`gte`/`lt`/`lte`.
+ * inclusive only – no `gt`/`gte`/`lt`/`lte`.
  */
 export type Filter = {
     readonly field: string;
@@ -49,11 +49,28 @@ export type { FilterOperator } from './schema.js';
 import type { FilterOperator } from './schema.js';
 /** The operator a {@link Filter} value carries, from its discriminating key. */
 export declare function filterOperator(filter: Filter): FilterOperator;
+/**
+ * Whether the query asks for nothing, so no engine can answer it with a hit.
+ * True for an empty `in` on {@link ID_FIELD} – and only there, deliberately:
+ *
+ * An **identity** filter enumerates the documents wanted, so the empty set
+ * wants none. A **value** filter constrains a dimension, so an empty set
+ * constrains nothing – which is why every other vacuous clause is a no-op the
+ * compilers skip (a facet UI with nothing selected sends exactly that). The
+ * readings differ because the fields differ in kind, and only for `id` would
+ * “no constraint” hand back the whole collection to a caller who asked for
+ * specific things – the likely shape being a client mapping a possibly-empty
+ * reference array (`id: { in: doc.publisher }`) into a batch lookup.
+ *
+ * An adapter MUST answer an unsatisfiable query with an empty result rather
+ * than dispatching it.
+ */
+export declare function isUnsatisfiable(query: SearchQuery): boolean;
 /**
  * One structural problem {@link validateQuery} found: the query references a
  * field the search type does not declare, or uses it in a role it does not
  * opt into. Vacuous-but-valid clauses (an empty `in` list, a `range` with no
- * bound) are NOT issues — a compiler skips those as no-ops.
+ * bound) are NOT issues – a compiler skips those as no-ops.
  */
 export interface QueryIssue {
     readonly part: 'where' | 'facets' | 'orderBy';
@@ -63,14 +80,15 @@ export interface QueryIssue {
 /**
  * Structurally validate a query against its search type: every `where` clause
  * targets a declared, `filterable` field with the operator its kind accepts
- * ({@link filterOperatorFor}); every requested facet is a declared, `facetable`
+ * ({@link filterOperatorFor}) – or the undeclared, always-filterable
+ * {@link ID_FIELD}, which takes `in`; every requested facet is a declared, `facetable`
  * field; every sort is `relevance` or a declared field. Sorting deliberately
  * checks declaration only, not the `sortable` flag: that flag means *publicly
  * selectable*, and a deployment policy may sort on a private tie-break field.
  *
  * This is the port’s always-on guard: every {@link SearchEngine} adapter MUST
  * reject a query with issues ({@link assertValidQuery}) instead of passing
- * garbage to its engine, so validation holds for every caller — including
+ * garbage to its engine, so validation holds for every caller – including
  * `queryDefaults` policies and surfaces weaker than GraphQL.
  */
 export declare function validateQuery(query: SearchQuery, searchType: SearchType): readonly QueryIssue[];
@@ -78,7 +96,7 @@ export declare function validateQuery(query: SearchQuery, searchType: SearchType
  *  naming every issue. The always-on entry point for engine adapters. */
 export declare function assertValidQuery(query: SearchQuery, searchType: SearchType): void;
 /**
- * The 1-based page an `offset` falls on — the numbered-pagination presentation
+ * The 1-based page an `offset` falls on – the numbered-pagination presentation
  * of the IR, shared by the surfaces and the adapters. `limit: 0` (a facet-only
  * query) fetches no hits and has no meaningful page, so it pins to 1 rather
  * than dividing by zero.

package/dist/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE7E;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,yBAAyB;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,SAAS,IAAI,EAAE,CAAC;IAClC,2BAA2B;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GACd;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC1D;IACE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KAChC,CAAC;CACH,GACD;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;CAAE,CAAC;AAErD,+BAA+B;AAC/B,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,KAAK,GAAG,MAAM,CAAC;CACpC;AAKD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAE7D;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EACX,eAAe,GACf,gBAAgB,GAChB,mBAAmB,GACnB,eAAe,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,UAAU,GACrB,SAAS,UAAU,EAAE,CA6CvB;AAED;yEACyE;AACzE,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,UAAU,GACrB,IAAI,CAUN;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnE"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAErB;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,yBAAyB;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,EAAE,SAAS,IAAI,EAAE,CAAC;IAClC,2BAA2B;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GACd;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAC1D;IACE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC/B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KAChC,CAAC;CACH,GACD;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;CAAE,CAAC;AAErD,+BAA+B;AAC/B,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,KAAK,GAAG,MAAM,CAAC;CACpC;AAKD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAE7D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAK3D;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EACb,eAAe,GAAG,gBAAgB,GAAG,mBAAmB,GAAG,eAAe,CAAC;CAC9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,UAAU,GACrB,SAAS,UAAU,EAAE,CA0DvB;AAED;yEACyE;AACzE,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,UAAU,GACrB,IAAI,CAUN;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnE"}

package/dist/query.js

@@ -1,4 +1,4 @@
-import { fieldNamed, filterOperatorFor } from './schema.js';
+import { fieldNamed, filterOperatorFor, ID_FIELD, } from './schema.js';
 // 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.
@@ -7,22 +7,55 @@ export { filterOperatorFor } from './schema.js';
 export function filterOperator(filter) {
     return 'in' in filter ? 'in' : 'range' in filter ? 'range' : 'is';
 }
+/**
+ * Whether the query asks for nothing, so no engine can answer it with a hit.
+ * True for an empty `in` on {@link ID_FIELD} – and only there, deliberately:
+ *
+ * An **identity** filter enumerates the documents wanted, so the empty set
+ * wants none. A **value** filter constrains a dimension, so an empty set
+ * constrains nothing – which is why every other vacuous clause is a no-op the
+ * compilers skip (a facet UI with nothing selected sends exactly that). The
+ * readings differ because the fields differ in kind, and only for `id` would
+ * “no constraint” hand back the whole collection to a caller who asked for
+ * specific things – the likely shape being a client mapping a possibly-empty
+ * reference array (`id: { in: doc.publisher }`) into a batch lookup.
+ *
+ * An adapter MUST answer an unsatisfiable query with an empty result rather
+ * than dispatching it.
+ */
+export function isUnsatisfiable(query) {
+    return query.where.some((filter) => filter.field === ID_FIELD && 'in' in filter && filter.in.length === 0);
+}
 /**
  * Structurally validate a query against its search type: every `where` clause
  * targets a declared, `filterable` field with the operator its kind accepts
- * ({@link filterOperatorFor}); every requested facet is a declared, `facetable`
+ * ({@link filterOperatorFor}) – or the undeclared, always-filterable
+ * {@link ID_FIELD}, which takes `in`; every requested facet is a declared, `facetable`
  * field; every sort is `relevance` or a declared field. Sorting deliberately
  * checks declaration only, not the `sortable` flag: that flag means *publicly
  * selectable*, and a deployment policy may sort on a private tie-break field.
  *
  * This is the port’s always-on guard: every {@link SearchEngine} adapter MUST
  * reject a query with issues ({@link assertValidQuery}) instead of passing
- * garbage to its engine, so validation holds for every caller — including
+ * garbage to its engine, so validation holds for every caller – including
  * `queryDefaults` policies and surfaces weaker than GraphQL.
  */
 export function validateQuery(query, searchType) {
     const issues = [];
     for (const filter of query.where) {
+        // `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 (filter.field === ID_FIELD) {
+            if (filterOperator(filter) !== 'in') {
+                issues.push({
+                    part: 'where',
+                    field: filter.field,
+                    reason: 'operator-mismatch',
+                });
+            }
+            continue;
+        }
         const field = fieldNamed(searchType, filter.field);
         if (field === undefined) {
             issues.push({
@@ -79,7 +112,7 @@ export function assertValidQuery(query, searchType) {
     }
 }
 /**
- * The 1-based page an `offset` falls on — the numbered-pagination presentation
+ * The 1-based page an `offset` falls on – the numbered-pagination presentation
  * of the IR, shared by the surfaces and the adapters. `limit: 0` (a facet-only
  * query) fetches no hits and has no meaningful page, so it pins to 1 rather
  * than dividing by zero.

package/dist/schema.d.ts

@@ -144,9 +144,13 @@ export interface ReferenceField extends SearchFieldBase, Searchable {
         /** Logical API type name of the referenced entity (PascalCase, e.g.
          *  `Organization`) – names the reference’s type in the API surfaces, the
          *  way {@link SearchType.name} names a root type; fields sharing it share
-         *  one emitted type. A name, not a key: it need not correspond to any
-         *  indexed root type (and until cross-collection references exist, it must
-         *  not collide with one). */
+         *  one emitted type. For a `labelOnly`/`idOnly` reference it is a name,
+         *  not a key: it need not correspond to any indexed root type, and it may
+         *  name one (`creator` → `Person`, with the labels resolved from that
+         *  root’s collection via `labelSource`) – an API surface then serves the
+         *  reference under a derived name (GraphQL: `‹Name›Reference`) to keep
+         *  type names unique. An `inline` reference’s typeName instead resolves to
+         *  a declared {@link ReferenceType}, so it can never name a root type. */
         readonly typeName: string;
         /** How much of the referenced entity the reference carries. `labelOnly`
          *  (id + display label, resolved from a label source) and `inline` (the
@@ -337,8 +341,21 @@ export declare function labelFieldOf(searchType: SearchType): TextField | undefi
  */
 export interface SearchTypeIssue {
     readonly field: string;
-    readonly reason: 'duplicate-field-name' | 'invalid-field-name' | 'unknown-kind' | 'invalid-locale' | 'missing-ref' | 'ref-not-allowed' | 'text-requires-locales' | 'locales-not-allowed' | 'facet-ranges-not-allowed' | 'searchable-not-allowed' | 'transform-not-allowed' | 'derive-with-path' | 'text-not-filterable' | 'text-not-facetable';
+    readonly reason: 'duplicate-field-name' | 'invalid-field-name' | 'unknown-kind' | 'invalid-locale' | 'missing-ref' | 'ref-not-allowed' | 'text-requires-locales' | 'locales-not-allowed' | 'facet-ranges-not-allowed' | 'searchable-not-allowed' | 'transform-not-allowed' | 'derive-with-path' | 'text-not-filterable' | 'text-not-facetable' | 'reserved-field-name';
 }
+/**
+ * The reserved logical name of a document’s IRI – the one field every indexed
+ * thing carries, and the only one no {@link SearchType} declares. It is the
+ * hit’s identity ({@link SearchHit.id}), not a value in its
+ * {@link ResultDocument}, so it is surfaced and filtered by name alone.
+ *
+ * `id` answers *what the thing is*; a domain field like `schema:identifier`
+ * answers *what a source system calls it* (a catalogue or record number). Those
+ * are different questions, so a declaration may still carry an `identifier`
+ * field of its own – but never an `id` one, which
+ * {@link validateSearchType} rejects as `reserved-field-name`.
+ */
+export declare const ID_FIELD = "id";
 /**
  * Structurally validate one {@link SearchType} declaration – the
  * declaration-time counterpart of `validateQuery`. Rules:
@@ -346,7 +363,7 @@ export interface SearchTypeIssue {
  * - field names are unique (a duplicate would silently shadow in every
  *   consumer, each picking a different winner) and a metacharacter-free
  *   identifier (the name is interpolated into physical field names and the
- *   display RE2 pattern);
+ *   display RE2 pattern), and is not the reserved {@link ID_FIELD};
  * - a `text` field’s declared locales are BCP-47-shaped (no `_`, which is the
  *   reserved name↔locale separator);
  * - a `reference` field that is `output` declares `ref` (the API surfaces

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

@@ -210,6 +210,19 @@ function assertResolvableLabelSources(types) {
         }
     }
 }
+/**
+ * The reserved logical name of a document’s IRI – the one field every indexed
+ * thing carries, and the only one no {@link SearchType} declares. It is the
+ * hit’s identity ({@link SearchHit.id}), not a value in its
+ * {@link ResultDocument}, so it is surfaced and filtered by name alone.
+ *
+ * `id` answers *what the thing is*; a domain field like `schema:identifier`
+ * answers *what a source system calls it* (a catalogue or record number). Those
+ * are different questions, so a declaration may still carry an `identifier`
+ * field of its own – but never an `id` one, which
+ * {@link validateSearchType} rejects as `reserved-field-name`.
+ */
+export const ID_FIELD = 'id';
 /** Kinds that can feed full-text search (project a folded search field). */
 const SEARCHABLE_KINDS = ['text', 'keyword', 'reference'];
 /** Kinds whose projection applies the {@link KeywordField.transform}. */
@@ -237,7 +250,7 @@ const LOCALE_PATTERN = /^[A-Za-z0-9]+(-[A-Za-z0-9]+)*$/;
  * - field names are unique (a duplicate would silently shadow in every
  *   consumer, each picking a different winner) and a metacharacter-free
  *   identifier (the name is interpolated into physical field names and the
- *   display RE2 pattern);
+ *   display RE2 pattern), and is not the reserved {@link ID_FIELD};
  * - a `text` field’s declared locales are BCP-47-shaped (no `_`, which is the
  *   reserved name↔locale separator);
  * - a `reference` field that is `output` declares `ref` (the API surfaces
@@ -277,6 +290,12 @@ export function validateSearchType(searchType) {
         if (!FIELD_NAME_PATTERN.test(field.name)) {
             issue('invalid-field-name');
         }
+        // `id` is the document’s IRI, surfaced and filtered for every type; a
+        // declared field of that name would shadow it in the API output and in
+        // `where`, silently answering a different question.
+        if (field.name === ID_FIELD) {
+            issue('reserved-field-name');
+        }
         // Every kind-dependent rule below would silently pass for a kind outside
         // the union, so a typo’d kind in a plain-JS declaration must fail here.
         if (!Object.hasOwn(OPERATOR_BY_KIND, field.kind)) {

package/dist/testing.d.ts

@@ -5,8 +5,9 @@ import type { SearchEngine } from './engine.js';
  * live instance of itself, so the port rules hold by test rather than by
  * prose. Covers schema binding (a type outside the bound schema is rejected),
  * the always-on query validation (a structurally invalid query is rejected
- * before it reaches the engine) and the result shape of a browse query and a
- * `searchFacets` batch – for every type in the schema.
+ * before it reaches the engine), the undeclared `id` lookup, and the result
+ * shape of a browse query and a `searchFacets` batch – for every type in the
+ * schema.
  *
  * ```ts
  * describeSearchEngineContract('TypesenseSearchEngine', () => engine);

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

package/dist/testing.js

@@ -1,14 +1,15 @@
 import { describe, expect, it } from 'vitest';
 import { filterOperatorFor, } from './query.js';
-import { facetableFields, filterableFields } from './schema.js';
+import { facetableFields, filterableFields, ID_FIELD, } from './schema.js';
 /**
  * The executable {@link SearchEngine} port contract (import from
  * `@lde/search/testing`): a vitest suite every engine adapter runs against a
  * live instance of itself, so the port rules hold by test rather than by
  * prose. Covers schema binding (a type outside the bound schema is rejected),
  * the always-on query validation (a structurally invalid query is rejected
- * before it reaches the engine) and the result shape of a browse query and a
- * `searchFacets` batch – for every type in the schema.
+ * before it reaches the engine), the undeclared `id` lookup, and the result
+ * shape of a browse query and a `searchFacets` batch – for every type in the
+ * schema.
  *
  * ```ts
  * describeSearchEngineContract('TypesenseSearchEngine', () => engine);
@@ -52,6 +53,22 @@ export function describeSearchEngineContract(name, engine) {
                 await expect(engine().search(searchType, query)).rejects.toThrow(/unknown-field/);
             }
         });
+        it('applies an `id` lookup rather than ignoring the clause', async () => {
+            // `id` is filterable on every type without being declared by any, so an
+            // adapter that resolves `where` fields through its declaration alone
+            // takes the unknown-field path and drops the clause – returning EVERY
+            // document where the caller asked for one. Pinned here because that
+            // failure is silent: no error, just the wrong result set.
+            for (const searchType of types()) {
+                const query = {
+                    ...browse(searchType),
+                    where: [{ field: ID_FIELD, in: ['urn:test:no-such-document'] }],
+                };
+                const result = await engine().search(searchType, query);
+                expect(result.total).toBe(0);
+                expect(result.hits).toEqual([]);
+            }
+        });
         it('rejects a facet request for an unknown field', async () => {
             for (const searchType of types()) {
                 const query = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "Engine- and domain-agnostic core for RDF-backed search: a unified declarative field model (SearchField/SearchType/SearchSchema), a neutral query IR, the SearchEngine port with logical result types, and a streaming CONSTRUCT-to-document projection. Bakes in no engine, protocol, or domain.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",