@lde/search 0.12.1 → 0.12.3

package/README.md

@@ -6,395 +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/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/module.d.ts

@@ -0,0 +1,24 @@
+import { type SearchSchema } from './schema.js';
+/** What {@link loadSchemaModule} returns: the validated schema plus the raw
+ *  module exports, so each consumer validates its own optional exports (the
+ *  served API reads `schemaOptions`/`engineOptions`; the indexer reads none). */
+export interface LoadedSchemaModule {
+    /** The validated schema built from the module’s default export. */
+    readonly schema: SearchSchema;
+    /** Every export of the module, for consumer-specific optional exports. */
+    readonly moduleExports: Record<string, unknown>;
+}
+/**
+ * Load and validate a mounted schema-declaration module: an ES module whose
+ * default export is a non-empty array of {@link SearchType} declarations –
+ * **plain data with optional functions** (`derive`, `transform`), because a
+ * mounted file cannot resolve bare imports like `@lde/search`. The one schema
+ * source both the indexer image and the served-API image mount, so the write
+ * and the read side cannot disagree about the schema.
+ *
+ * Throws with the module path in the message for every failure mode – an
+ * unreadable file, a wrong export shape, an invalid declaration – so a bad
+ * mount fails the boot with a diagnosis, never the first query.
+ */
+export declare function loadSchemaModule(modulePath: string): Promise<LoadedSchemaModule>;
+//# sourceMappingURL=module.d.ts.map

package/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAIA,OAAO,EAAgB,KAAK,YAAY,EAAmB,MAAM,aAAa,CAAC;AAE/E;;iFAEiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,kBAAkB,CAAC,CA8B7B"}

package/dist/module.js

@@ -0,0 +1,42 @@
+// The `@lde/search/module` entry point: load a mounted schema-declaration
+// module. Node-only (it touches the filesystem), so it lives outside the main
+// entry point, which stays runtime-agnostic.
+import { pathToFileURL } from 'node:url';
+import { searchSchema } from './schema.js';
+/**
+ * Load and validate a mounted schema-declaration module: an ES module whose
+ * default export is a non-empty array of {@link SearchType} declarations –
+ * **plain data with optional functions** (`derive`, `transform`), because a
+ * mounted file cannot resolve bare imports like `@lde/search`. The one schema
+ * source both the indexer image and the served-API image mount, so the write
+ * and the read side cannot disagree about the schema.
+ *
+ * Throws with the module path in the message for every failure mode – an
+ * unreadable file, a wrong export shape, an invalid declaration – so a bad
+ * mount fails the boot with a diagnosis, never the first query.
+ */
+export async function loadSchemaModule(modulePath) {
+    let moduleExports;
+    try {
+        moduleExports = (await import(pathToFileURL(modulePath).href));
+    }
+    catch (cause) {
+        throw new Error(`Cannot load schema module “${modulePath}”: ${messageOf(cause)}`, { cause });
+    }
+    const declarations = moduleExports['default'];
+    if (!Array.isArray(declarations) || declarations.length === 0) {
+        throw new Error(`Schema module “${modulePath}” must default-export a non-empty array of search type declarations.`);
+    }
+    try {
+        return {
+            schema: searchSchema(...declarations),
+            moduleExports,
+        };
+    }
+    catch (cause) {
+        throw new Error(`Schema module “${modulePath}” declares an invalid schema: ${messageOf(cause)}`, { cause });
+    }
+}
+function messageOf(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}

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,7 +341,7 @@ export declare function labelFieldOf(searchType: SearchType): TextField | undefi
  */
 export interface SearchTypeIssue {
     readonly field: string;
-    readonly reason: 'duplicate-field-name' | 'invalid-field-name' | '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';
 }
 /**
  * Structurally validate one {@link SearchType} declaration – the

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

@@ -277,6 +277,12 @@ export function validateSearchType(searchType) {
         if (!FIELD_NAME_PATTERN.test(field.name)) {
             issue('invalid-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)) {
+            issue('unknown-kind');
+            continue;
+        }
         if (field.kind === 'reference') {
             if (field.output === true && field.ref === undefined) {
                 issue('missing-ref');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "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",
@@ -16,6 +16,12 @@
       "development": "./src/index.ts",
       "default": "./dist/index.js"
     },
+    "./module": {
+      "types": "./dist/module.d.ts",
+      "import": "./dist/module.js",
+      "development": "./src/module.ts",
+      "default": "./dist/module.js"
+    },
     "./adapter": {
       "types": "./dist/adapter.d.ts",
       "import": "./dist/adapter.js",
@@ -37,7 +43,7 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/text-normalization": "^0.1.1",
+    "@lde/text-normalization": "^0.1.2",
     "@rdfjs/types": "^2.0.1",
     "inflection": "^3.0.2",
     "jsonld": "^9.0.0",