@lde/search 0.5.0 → 0.7.0

package/README.md

@@ -3,7 +3,7 @@
 The core of the LDE search family: packages that together act as a **generator
 for search engines**. You write one declarative `SearchSchema`, and everything
 a running search engine needs is derived from it: the document projection, the
-engine collection schema, the query semantics, and the API surface. All these
+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
@@ -21,26 +21,26 @@ The library never names your domain: the same core drives a `Dataset`,
 
 It provides four things:
 
-- **unified field model** — `SearchField` / `SearchType` / `SearchSchema`:
+- **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
+- **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
+- **engine port** – `SearchEngine` and the logical result types
   (`SearchResult` / `SearchHit` / `ResultDocument` / `Reference` / …);
-- **streaming projection** — `projectGraph`, RDF `CONSTRUCT` quads → flat
+- **streaming projection** – `projectGraph`, RDF `CONSTRUCT` quads → flat
   search documents.
 
 ```
 SearchSchema ─┬─► projection      (projectGraph → flat documents)        [here]
-              ├─► engine adapter  (collection schema + query compiler)   e.g. @lde/search-typesense
+              ├─► 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
+data shapes**, each one parameterised by the schema – three chains, meeting at
 the engine:
 
 ```
@@ -50,20 +50,20 @@ results:   engine response ──parse──► SearchResult ──shape──
 ```
 
 Validation happens before the first arrow (SHACL over the RDF) and inside the
-last (the engine enforces its collection schema); between them every stage is
-a typed, deterministic function — easy to test, and swappable per deployment.
+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`,
+- **`@lde/search`** – the authoring surface: `defineSearchType`,
   `searchSchema`, `projectGraph` (+ the IR readers `derive` functions use),
   validation, and every model/query/result type.
-- **`@lde/search/adapter`** — plumbing for engine adapters and API surfaces:
+- **`@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
+- **`@lde/search/testing`** – `describeSearchEngineContract`, the executable
   port contract every engine adapter runs against a live instance of itself
   (vitest; optional peer).
 
@@ -72,11 +72,11 @@ Exports are stratified by audience:
 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 root type’s complete declaration: its logical API `name`, its `type` IRI and its fields (incl. derived)     | NodeShape      | object type |
-| `SearchSchema` | The whole search declaration: every `SearchType`, keyed by `type` IRI — build one with `searchSchema(...types)` | shapes graph   | schema      |
+| 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 root type’s complete declaration: its logical API `name`, its `class` IRI and its fields (incl. derived)     | NodeShape      | object type |
+| `SearchSchema` | The whole search declaration: every `SearchType`, keyed by `class` IRI – build one with `searchSchema(...types)` | shapes graph   | schema      |
 
 `projectGraph` and the GraphQL surface consume a `SearchSchema` (projecting
 every type in one pass); the engine port executes one `SearchType` at a time.
@@ -85,14 +85,14 @@ every type in one pass); the engine port executes one `SearchType` at a time.
 
 Two conventions hold across the whole family:
 
-- **Parameter order** — a function takes the value it operates on first and
+- **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.
+- **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 (`buildCollectionSchema`,
+  `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.
@@ -101,10 +101,10 @@ Two conventions hold across the whole family:
 
 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 framed
-node in declaration order — so it may read fields declared before it), and the
+node in declaration order – so it may read fields declared before it), and the
 capabilities it opts into. The physical field names a declaration fans out to
 (per-locale search/sort keys) come from
-`physicalFields`, the single convention projection, the collection schema and the
+`physicalFields`, the single convention projection, the collection definition and the
 query compiler all share.
 
 ```ts
@@ -117,9 +117,9 @@ import {
 
 const DATASET = defineSearchType({
   name: 'Dataset', // logical API name: names the GraphQL type, a REST path, …
-  type: 'http://www.w3.org/ns/dcat#Dataset',
+  class: 'http://www.w3.org/ns/dcat#Dataset',
   fields: [
-    // → title_nl, title_en, title_search_nl/_en, title_sort_nl/_en
+    // → title_<lang> (display, every present language), title_search_nl/_en, title_sort_nl/_en
     {
       name: 'title',
       path: 'http://purl.org/dc/terms/title',
@@ -163,33 +163,35 @@ for await (const { searchType, document } of projectGraph(
 
 `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
+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.
+_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
+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 fan out, 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']`. 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.
+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()`
+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 `type` IRI or `name`) — the declaration-time counterpart of the
+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
@@ -228,7 +230,7 @@ Each yielded value is a `{ searchType, document }` pair: the whole schema
 projects into **one** mixed stream, and every document is tagged with the
 `SearchType` it was framed from. That tag is what lets the write side fan the
 stream out to per-type collections without re-deriving the type from the
-document — see `@lde/search-pipeline`’s multi-collection writer.
+document – see `@lde/search-pipeline`’s multi-collection writer.
 
 `projectGraph` **consumes the quads once** – a single scan builds the subject
 index every type frames off – and so accepts any `Iterable<Quad>`, not just a
@@ -247,30 +249,39 @@ projectGraph(
 
 ## Locales
 
-`locales` is the **single** list of locales a `text` field projects (`und` =
-untagged literals);
-`output`, `searchable` and `sortable` are independent opt-ins that each fan out
-over it (so a field emits exactly what it opts into):
-
-- `output` → `title_nl`/`title_en` (accents preserved);
-- `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);
+`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
+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**; a literal whose language tag is not in
-`locales` is not projected (declare `und` to catch untagged literals). Per-locale fields are
-**omitted, never empty**, when a document lacks that language, so declare them
-optional in the engine schema and sort with `missing_values: last`.
+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
+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
@@ -281,21 +292,21 @@ fields and keep proper-noun facets on a separate, unstemmed field.
 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
+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`) —
+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
+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
+An engine is **bound to the whole `SearchSchema` at construction** – like
 every other schema consumer (`projectGraph(quads, schema)`,
 `buildGraphQLSchema(schema)`): the adapter factory takes the deployment’s
 declaration together with each type’s physical location, so a query can never
@@ -304,7 +315,7 @@ cross-type search, facet batching) have one home. 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:
+– no caller-side generics:
 
 ```ts
 const engine = createTypesenseSearchEngine(client, schema, {
@@ -337,5 +348,5 @@ signatures, and `engine.schema` exposes the bound declaration for routing.
 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
+today will run a **SHACL-generated** one tomorrow – the model, the ports and the
 IR stay; only schema-authoring gets automated.

package/dist/adapter.d.ts

@@ -1,12 +1,12 @@
 /**
  * The adapter-author surface of `@lde/search` (import from
  * `@lde/search/adapter`): the plumbing an engine adapter or API surface needs
- * to compile queries and reconstruct results — field selectors, the physical
+ * to compile queries and reconstruct results – field selectors, the physical
  * field-name convention, query validation and the storage codecs. A
  * deployment author declaring a schema and running searches needs none of
  * this; the main entry point carries that (small) authoring surface.
  */
-export { assertTypeInSchema, physicalFields, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, referenceFields, fieldNamed, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
+export { assertTypeInSchema, physicalFields, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, referenceFields, fieldNamed, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
 export type { PhysicalFields } from './schema.js';
 export { filterOperatorFor, filterOperator, validateQuery, assertValidQuery, pageForOffset, } from './query.js';
 export type { FilterOperator, QueryIssue } from './query.js';

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,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,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,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"}

package/dist/adapter.js

@@ -1,10 +1,10 @@
 /**
  * The adapter-author surface of `@lde/search` (import from
  * `@lde/search/adapter`): the plumbing an engine adapter or API surface needs
- * to compile queries and reconstruct results — field selectors, the physical
+ * to compile queries and reconstruct results – field selectors, the physical
  * field-name convention, query validation and the storage codecs. A
  * deployment author declaring a schema and running searches needs none of
  * this; the main entry point carries that (small) authoring surface.
  */
-export { assertTypeInSchema, physicalFields, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, referenceFields, fieldNamed, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
+export { assertTypeInSchema, physicalFields, displayFieldName, displayFieldPattern, displayLangOf, searchableFields, facetableFields, filterableFields, sortableFields, outputFields, referenceFields, fieldNamed, labelFieldOf, isRangeFacet, isoToUnixSeconds, unixSecondsToIso, } from './schema.js';
 export { filterOperatorFor, filterOperator, validateQuery, assertValidQuery, pageForOffset, } from './query.js';

package/dist/project.d.ts

@@ -7,7 +7,7 @@ export type SearchDocument = {
 } & Record<string, unknown>;
 /**
  * A projected document tagged with the {@link SearchType} it was projected
- * from — one element of {@link projectGraph}’s mixed, whole-schema stream. The
+ * from – one element of {@link projectGraph}’s mixed, whole-schema stream. The
  * tag is what lets a multi-collection writer route each document to the
  * collection for its type without re-deriving the type from the document.
  */
@@ -21,12 +21,12 @@ export interface TypedSearchDocument {
  * its value from the node and the document as populated so far (so a derived
  * field may read fields declared before it). The physical field names a field
  * fans out to come from {@link physicalFields}, the single source shared with
- * the engine collection schema and the query compiler.
+ * the engine collection definition and the query compiler.
  */
 export declare function projectDocument(node: FramedNode, searchType: SearchType): SearchDocument;
 /**
  * Frame `quads` for every root type in the schema and project each node with its
- * type’s declaration — the multi-shape pipeline. Yields each document tagged
+ * type’s declaration – the multi-shape pipeline. Yields each document tagged
  * with its {@link SearchType} ({@link TypedSearchDocument}), so a downstream
  * multi-collection writer can route it to that type’s collection; a
  * single-collection consumer just reads `.document`. Streams one document at a

package/dist/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAML,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAErB,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,GACrB,cAAc,CAYhB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,MAAM,EAAE,YAAY,GACnB,aAAa,CAAC,mBAAmB,CAAC,CAWpC;AAsID,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAInE;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAI/D"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAOL,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAErB,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,GACrB,cAAc,CAYhB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,MAAM,EAAE,YAAY,GACnB,aAAa,CAAC,mBAAmB,CAAC,CAWpC;AAqJD,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAInE;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAI/D"}

package/dist/project.js

@@ -1,18 +1,18 @@
 import { fold } from '@lde/text-normalization';
 import { buildSubjectIndex, frameSubjects, } from './frame-by-type.js';
-import { isoToUnixSeconds, physicalFields, } from './schema.js';
+import { displayFieldName, isoToUnixSeconds, physicalFields, } from './schema.js';
 /**
  * Project one framed JSON-LD node into a flat search document: apply each field
  * of the type in declaration order. A field with a `derive` function computes
  * its value from the node and the document as populated so far (so a derived
  * field may read fields declared before it). The physical field names a field
  * fans out to come from {@link physicalFields}, the single source shared with
- * the engine collection schema and the query compiler.
+ * the engine collection definition and the query compiler.
  */
 export function projectDocument(node, searchType) {
     const id = node['@id'];
     if (typeof id !== 'string') {
-        throw new Error(`Cannot project a ${searchType.type} node without an @id: every search document needs a stable key, and an empty one would collide with other keyless nodes.`);
+        throw new Error(`Cannot project a ${searchType.class} node without an @id: every search document needs a stable key, and an empty one would collide with other keyless nodes.`);
     }
     const document = { id };
     for (const field of searchType.fields) {
@@ -22,7 +22,7 @@ export function projectDocument(node, searchType) {
 }
 /**
  * Frame `quads` for every root type in the schema and project each node with its
- * type’s declaration — the multi-shape pipeline. Yields each document tagged
+ * type’s declaration – the multi-shape pipeline. Yields each document tagged
  * with its {@link SearchType} ({@link TypedSearchDocument}), so a downstream
  * multi-collection writer can route it to that type’s collection; a
  * single-collection consumer just reads `.document`. Streams one document at a
@@ -36,9 +36,9 @@ export function projectDocument(node, searchType) {
  */
 export async function* projectGraph(quads, schema) {
     const types = [...schema.values()];
-    const index = buildSubjectIndex(quads, types.map((searchType) => searchType.type));
+    const index = buildSubjectIndex(quads, types.map((searchType) => searchType.class));
     for (const searchType of types) {
-        for await (const node of frameSubjects(index, searchType.type)) {
+        for await (const node of frameSubjects(index, searchType.class)) {
             yield { searchType, document: projectDocument(node, searchType) };
         }
     }
@@ -82,35 +82,46 @@ function applyField(document, node, field) {
     }
 }
 /**
- * Project a text field per locale (untagged literals land in the `und`
- * locale). Display shows one label (accents preserved) when the field is
- * `output`; sort keys off that same primary value (folded) when `sortable`;
- * search folds every value of the locale when `searchable`, so all are
- * matchable. Absent locales emit nothing.
+ * Project a text field. **Display** (when `output`) preserves *every* language
+ * present – one label per language (accents preserved, untagged under `und`),
+ * stored `index: false` so extra languages cost nothing – so a value in an
+ * undeclared language still renders rather than collapsing to a bare IRI.
+ * **Search** (folded, when `searchable`) and **sort** (folded primary, when
+ * `sortable`) stay on the declared `locales`, which drive the indexed, stemmed,
+ * weighted fanout; a value in an undeclared language is not indexed. Absent
+ * languages emit nothing.
  */
 function applyText(document, values, field) {
-    // Empty `locales` is rejected at declaration time (`validateSearchType`);
-    // here it simply projects nothing.
-    const locales = field.locales;
-    const names = physicalFields(field);
-    locales.forEach((locale, index) => {
-        const localeValues = values
-            .filter((value) => value.lang === locale)
-            .map((value) => value.value);
-        if (localeValues.length === 0) {
-            return;
-        }
-        const [primary] = localeValues;
-        if (field.output) {
-            setString(document, names.display[index], primary);
-        }
-        if (field.searchable) {
-            setString(document, names.search[index], foldedSearchValue(localeValues));
-        }
-        if (field.sortable) {
-            setString(document, names.sort[index], fold(primary));
+    if (field.output) {
+        // First value of each present language wins; a language absent from
+        // `locales` still lands as a display field (kept off the search index).
+        const seenLangs = new Set();
+        for (const { lang, value } of values) {
+            if (!seenLangs.has(lang)) {
+                seenLangs.add(lang);
+                setString(document, displayFieldName(field, lang), value);
+            }
         }
-    });
+    }
+    // Empty `locales` is rejected at declaration time (`validateSearchType`);
+    // here it simply indexes nothing.
+    if (field.searchable !== undefined || field.sortable === true) {
+        const names = physicalFields(field);
+        field.locales.forEach((locale, index) => {
+            const localeValues = values
+                .filter((value) => value.lang === locale)
+                .map((value) => value.value);
+            if (localeValues.length === 0) {
+                return;
+            }
+            if (field.searchable) {
+                setString(document, names.search[index], foldedSearchValue(localeValues));
+            }
+            if (field.sortable) {
+                setString(document, names.sort[index], fold(localeValues[0]));
+            }
+        });
+    }
 }
 /** The projection’s definition of a folded free-text search value. */
 function foldedSearchValue(values) {
@@ -118,7 +129,7 @@ function foldedSearchValue(values) {
 }
 /**
  * Project a faceted multi-value field: dedupe (after the optional transform),
- * write the value field, and — when `searchable` — a folded `${name}_search`
+ * write the value field, and – when `searchable` – a folded `${name}_search`
  * array. `keyword` reads literals; `reference` reads IRIs (the caller passes the
  * already-read raw values).
  */
@@ -160,10 +171,14 @@ function toLangValue(value) {
         return undefined;
     }
     // Untagged literals (JSON-LD @none) land in the reserved `und` locale.
-    const lang = isObject(value) && typeof value['@language'] === 'string'
+    // Normalise the tag to its BCP-47 shape: `_` is the reserved separator in the
+    // physical/display field naming, so a non-conformant `pt_BR` tag becomes
+    // `pt-BR`, which round-trips through display and matches a declared locale
+    // instead of being silently dropped.
+    const rawLang = isObject(value) && typeof value['@language'] === 'string'
         ? value['@language']
         : 'und';
-    return { value: literal, lang };
+    return { value: literal, lang: rawLang.replace(/_/g, '-') };
 }
 function literalString(value) {
     if (typeof value === 'string') {

package/dist/schema.d.ts

@@ -3,7 +3,7 @@ import type { SearchDocument } from './project.js';
 /**
  * The engine-neutral kind of a queryable field. It drives every downstream
  * behavior: which physical fields the projection emits, the engine
- * collection-schema type, the `where`/facet/sort semantics, and the GraphQL
+ * collection-definition type, the `where`/facet/sort semantics, and the GraphQL
  * output/input type. The Typesense-vocabulary types (`string`, `int32`, …) are
  * *derived* from this by the engine adapter, never declared here.
  */
@@ -13,14 +13,14 @@ export type FieldKind = 'text' | 'keyword' | 'integer' | 'number' | 'boolean' |
 export type FilterOperator = 'in' | 'range' | 'is';
 /**
  * The `where` operator a field of this kind accepts (per the ADR filter-semantics
- * table), or `undefined` for `text` — which feeds the free-text `query` rather
+ * table), or `undefined` for `text` – which feeds the free-text `query` rather
  * than `where`. The ONE source for the surface’s `where` input type, the
  * adapter’s filter compiler and declaration validation, so they cannot drift.
  */
 export declare function filterOperatorFor(kind: FieldKind): FilterOperator | undefined;
 /**
- * One queryable field — the single declarative source that drives all four
- * consumers (projection, engine collection schema, query semantics, and the
+ * One queryable field – the single declarative source that drives all four
+ * consumers (projection, engine collection definition, query semantics, and the
  * GraphQL surface).
  *
  * A **discriminated union by `kind`**: each kind declares exactly the
@@ -32,13 +32,13 @@ export declare function filterOperatorFor(kind: FieldKind): FilterOperator | und
  * Capability flags (`searchable`/`filterable`/`facetable`/`sortable`/`output`)
  * are independent opt-ins: a field exposes exactly the roles it declares. A
  * field with a {@link SearchFieldBase.derive `derive`} function instead of a
- * `path` is a **derived field** — computed from the framed node rather than
- * projected from the IR — yet it still carries full query/schema/output
+ * `path` is a **derived field** – computed from the framed node rather than
+ * projected from the IR – yet it still carries full query/schema/output
  * behavior (e.g. `status`, the compatibility booleans).
  *
  * The physical field names a declaration fans out to (per-locale search/sort
  * keys) follow one convention, owned by
- * {@link physicalFields} so projection, collection-schema and query compiler
+ * {@link physicalFields} so projection, collection-definition and query compiler
  * cannot disagree.
  *
  * SHACL is one possible *source*, not a dependency: a generator can emit a
@@ -72,7 +72,7 @@ export interface SearchFieldBase {
     /** Publicly selectable in `orderBy`; localized text also emits a folded sort key. */
     readonly sortable?: boolean;
     /**
-     * Compute this field’s value instead of projecting it from a `path` — a
+     * Compute this field’s value instead of projecting it from a `path` – a
      * status token, a compatibility boolean, a count over the framed node.
      * Mutually exclusive with `path`. Runs in declaration order during
      * projection, receiving the framed node and the document as populated so
@@ -95,7 +95,7 @@ export interface Searchable {
  * locale into display/search/sort companions. `locales` lists the language
  * tags to emit; the reserved locale **`und`** (JSON-LD `@none`, RDF `und`)
  * buckets untagged literals, so a monolingual or untagged corpus declares
- * `locales: ['und']` and mixed data `['nl', 'und']` — one mechanism, and
+ * `locales: ['und']` and mixed data `['nl', 'und']` – one mechanism, and
  * adding a language later is additive (the API output shape never changes).
  * Declaring a real language is RECOMMENDED where the data has one: it drives
  * the engine’s per-locale stemming; `und` is folded but unstemmed (unless the
@@ -139,7 +139,7 @@ export interface ReferenceField extends SearchFieldBase, Searchable {
      *  optional for a facet- or filter-only reference. */
     readonly ref?: {
         /** Logical API type name of the referenced entity (PascalCase, e.g.
-         *  `Organization`) — names the reference’s type in the API surfaces, the
+         *  `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
@@ -156,7 +156,7 @@ export interface ReferenceField extends SearchFieldBase, Searchable {
 /**
  * Range-facet bins for a numeric (`integer`/`number`/`date`) facetable field.
  * When set, the field facets into these fixed half-open `[min, max)` ranges (a
- * histogram) rather than one bucket per distinct value — the per-bucket counts
+ * histogram) rather than one bucket per distinct value – the per-bucket counts
  * a UI slider needs. Bins are query-time only (no index impact) and
  * engine-neutral: the Typesense adapter emits a `facet_by` range, an
  * OpenSearch adapter a `range` aggregation. See {@link FacetRange}.
@@ -167,7 +167,7 @@ export interface RangeFacetable {
 /**
  * A numeric value: range-filtered, range- or value-faceted, sortable.
  * `integer` is a whole number, `number` a float, `date` a point in time
- * (ISO 8601 at the edges, Unix seconds in the index) — identical capabilities,
+ * (ISO 8601 at the edges, Unix seconds in the index) – identical capabilities,
  * so one interface serves all three kinds; `field.kind` still narrows.
  */
 export interface NumericField extends SearchFieldBase, RangeFacetable {
@@ -193,25 +193,28 @@ export interface FacetRange {
 }
 /**
  * One root type’s complete search declaration: its logical API `name`, the
- * `type` IRI its documents are instances of, and the queryable `fields`
- * (including {@link SearchField.derive derived} ones). A SHACL generator can
- * emit one per NodeShape (`name`←`sh:name`/local name, `type`←`sh:targetClass`,
- * `fields`←its property shapes), but that is a source, not a requirement.
+ * `class` IRI its documents are instances of (the RDF class), and the queryable
+ * `fields` (including {@link SearchField.derive derived} ones). A SHACL
+ * generator can emit one per NodeShape (`name`←`sh:name`/local name,
+ * `class`←`sh:targetClass`, `fields`←its property shapes), but that is a source,
+ * not a requirement.
  */
 export interface SearchType {
-    /** Logical API name (PascalCase, e.g. `Dataset`) — names the type in the API
+    /** Logical API name (PascalCase, e.g. `Dataset`) – names the type in the API
      *  surfaces (GraphQL type names, a REST path), the way each field’s
      *  {@link SearchField.name} names that field. Deliberately declared rather
-     *  than derived from the `type` IRI, so re-modelling the vocabulary cannot
+     *  than derived from the `class` IRI, so re-modelling the vocabulary cannot
      *  silently rename the public contract. */
     readonly name: string;
-    readonly type: string;
+    /** The RDF class IRI its documents are instances of (`sh:targetClass`); the
+     *  key a {@link SearchSchema} maps this type under. */
+    readonly class: string;
     readonly fields: readonly SearchField[];
 }
 /**
  * Declare a {@link SearchType}, capturing it as a literal: the `const` type
  * parameter preserves the field names and capability flags that the type-level
- * helpers (`FacetFieldsOf`, `OutputFieldsOf`) read off the type —
+ * helpers (`FacetFieldsOf`, `OutputFieldsOf`) read off the type –
  * with none of the widening a plain `: SearchType` annotation causes and
  * without having to remember `as const satisfies SearchType`. Identity at
  * runtime.
@@ -219,13 +222,13 @@ export interface SearchType {
 export declare function defineSearchType<const Type extends SearchType>(searchType: Type): Type;
 /**
  * The complete search declaration of a deployment: every root {@link SearchType},
- * keyed by its `type` IRI. Build one with {@link searchSchema}, which captures
+ * keyed by its `class` IRI. Build one with {@link searchSchema}, which captures
  * the declared types as a literal tuple (`Types`), so schema-bound consumers
  * (the engine port) can type their per-type behaviour off it. A plain
  * `: SearchSchema` annotation widens gracefully to `SearchType`.
  */
 /** Brand for {@link SearchSchema}: type-only, no runtime existence. Makes the
- *  schema NOMINAL — a hand-built `Map` is not assignable, so `searchSchema()`
+ *  schema NOMINAL – a hand-built `Map` is not assignable, so `searchSchema()`
  *  (which validates) is the only way to obtain one and downstream consumers
  *  need no defensive re-validation. */
 export declare const validSearchSchema: unique symbol;
@@ -233,11 +236,11 @@ export interface SearchSchema<Types extends readonly SearchType[] = readonly Sea
     readonly [validSearchSchema]: true;
 }
 /**
- * Build a {@link SearchSchema} from root-type declarations, keyed by `type`.
+ * Build a {@link SearchSchema} from root-type declarations, keyed by `class`.
  *
- * Every declaration is validated ({@link assertValidSearchType}) — the
- * declaration-time counterpart of the port’s `assertValidQuery` — and the
- * schema-wide invariants are enforced: no two types may share a `type` IRI
+ * Every declaration is validated ({@link assertValidSearchType}) – the
+ * declaration-time counterpart of the port’s `assertValidQuery` – and the
+ * schema-wide invariants are enforced: no two types may share a `class` IRI
  * (they would silently overwrite each other in the map) or a `name` (names
  * key the API surfaces). Throws on the first invalid declaration, so a bad
  * schema fails at startup, not per document at index time or per query.
@@ -260,21 +263,25 @@ export declare function labelFieldOf(searchType: SearchType): TextField | undefi
  */
 export interface SearchTypeIssue {
     readonly field: string;
-    readonly reason: 'duplicate-field-name' | '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' | '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
+ * Structurally validate one {@link SearchType} declaration – the
  * declaration-time counterpart of `validateQuery`. Rules:
  *
  * - field names are unique (a duplicate would silently shadow in every
- *   consumer, each picking a different winner);
+ *   consumer, each picking a different winner) and a metacharacter-free
+ *   identifier (the name is interpolated into physical field names and the
+ *   display RE2 pattern);
+ * - 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
  *   need the reference type name); `ref` on any other kind is meaningless;
  * - a `text` field declares at least one locale (`und` = untagged; projection and
- *   result reconstruction have no representation for unlocalized text — use
+ *   result reconstruction have no representation for unlocalized text – use
  *   `keyword` for untagged strings); `locales` on any other kind is
  *   meaningless;
- * - a kind without a `where` operator (`text` — it feeds the free-text query)
+ * - a kind without a `where` operator (`text` – it feeds the free-text query)
  *   is neither `filterable` nor `facetable`;
  * - `facetRanges` only on the `range`-operator kinds (`integer`/`number`/`date`);
  * - `searchable` only on `text`/`keyword`/`reference` (projection emits no
@@ -289,7 +296,7 @@ export interface SearchTypeIssue {
  */
 export declare function validateSearchType(searchType: SearchType): readonly SearchTypeIssue[];
 /**
- * Throw when `searchType` is not a member of `schema` — the port membership
+ * Throw when `searchType` is not a member of `schema` – the port membership
  * guard every engine adapter applies before searching, so a query can never
  * meet an index the deployment did not declare. Identity-based: the exact
  * declaration object must be in the schema, not a lookalike.
@@ -301,12 +308,10 @@ export declare function assertValidSearchType(searchType: SearchType): void;
 /**
  * The physical engine fields one {@link SearchField} fans out into, grouped by
  * the role each plays. The single source of truth for the naming convention, so
- * the projection (writes them), the collection schema (declares them) and the
+ * the projection (writes them), the collection definition (declares them) and the
  * query compiler (reads them) cannot disagree.
  */
 export interface PhysicalFields {
-    /** Per-locale output labels `${name}_${locale}` (localized text, `output`). */
-    readonly display: readonly string[];
     /** Folded match fields: `${name}_search_${locale}` per locale (localized) or a
      *  single `${name}_search` (non-localized), when `searchable`. */
     readonly search: readonly string[];
@@ -315,7 +320,44 @@ export interface PhysicalFields {
     readonly sort: readonly string[];
 }
 /**
- * Full-text searchable fields, highest `query_by` weight first — the order the
+ * The display fields of a localized `text` field are pattern-based, not
+ * enumerated per declared locale: projection stores `${name}_${lang}` for
+ * **every** language present in the data (not only those in `locales`), so a
+ * label in an undeclared language or an untagged one still renders rather than
+ * collapsing to a bare IRI. `locales` governs only the indexed search/sort
+ * fanout ({@link PhysicalFields}); display costs nothing per language (stored
+ * `index: false`), so it preserves them all. A deployment that wants fewer
+ * display languages restricts them upstream (e.g. in its CONSTRUCT).
+ *
+ * A language subtag never contains `_`, but the `search_`/`sort_` infixes do,
+ * so `${name}_${lang}` with `lang` matching `[^_]+` is unambiguously a display
+ * field: `label_nl`, `label_fr`, `label_zh-hant`, `label_und` are display;
+ * `label_search_nl` and `label_sort_nl` are not. This trio – the name a value
+ * is written under ({@link displayFieldName}), the collection pattern that
+ * accepts them all ({@link displayFieldPattern}), and the reader that recovers a
+ * key’s language ({@link displayLangOf}) – is the single home of that
+ * convention, so projection, collection-definition and result reconstruction
+ * cannot disagree.
+ */
+export declare function displayFieldName(field: TextField, lang: string): string;
+/**
+ * The RE2 pattern a collection declares to store every present language’s
+ * display value un-indexed, or `undefined` when the field is not `output` (no
+ * display at all). Matches `${name}_${lang}` for any underscore-free `lang`, so
+ * it never collides with the field’s `${name}_search_${locale}` /
+ * `${name}_sort_${locale}` companions.
+ */
+export declare function displayFieldPattern(field: TextField): string | undefined;
+/**
+ * The language a stored document key carries for `field`’s display, or
+ * `undefined` when the key is not one of `field`’s display fields – the inverse
+ * of {@link displayFieldName}. A key qualifies when it is `${name}_` followed by
+ * an underscore-free remainder, so the `${name}_search_…`/`${name}_sort_…`
+ * companions (and unrelated fields) are rejected.
+ */
+export declare function displayLangOf(field: TextField, key: string): string | undefined;
+/**
+ * Full-text searchable fields, highest `query_by` weight first – the order the
  * engine adapter weights `query_by` in. A field is searchable iff it carries a
  * `searchable` weight.
  */
@@ -356,6 +398,11 @@ export declare function isRangeFacet(field: SearchField): field is NumericField
 export declare function isoToUnixSeconds(iso: string): number | undefined;
 /** The inverse of {@link isoToUnixSeconds}: stored Unix seconds → ISO 8601. */
 export declare function unixSecondsToIso(seconds: number): string;
-/** Derive the physical engine field names a declaration produces. */
+/**
+ * Derive the **indexed** physical engine field names a declaration produces:
+ * the per-locale `search`/`sort` fanout. A localized `text` field’s display
+ * fields are pattern-based and not enumerated here – see {@link displayFieldName}
+ * and its siblings.
+ */
 export declare function physicalFields(field: SearchField): PhysicalFields;
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

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

package/dist/schema.js

@@ -9,7 +9,7 @@ const OPERATOR_BY_KIND = {
 };
 /**
  * The `where` operator a field of this kind accepts (per the ADR filter-semantics
- * table), or `undefined` for `text` — which feeds the free-text `query` rather
+ * table), or `undefined` for `text` – which feeds the free-text `query` rather
  * than `where`. The ONE source for the surface’s `where` input type, the
  * adapter’s filter compiler and declaration validation, so they cannot drift.
  */
@@ -19,7 +19,7 @@ export function filterOperatorFor(kind) {
 /**
  * Declare a {@link SearchType}, capturing it as a literal: the `const` type
  * parameter preserves the field names and capability flags that the type-level
- * helpers (`FacetFieldsOf`, `OutputFieldsOf`) read off the type —
+ * helpers (`FacetFieldsOf`, `OutputFieldsOf`) read off the type –
  * with none of the widening a plain `: SearchType` annotation causes and
  * without having to remember `as const satisfies SearchType`. Identity at
  * runtime.
@@ -28,11 +28,11 @@ export function defineSearchType(searchType) {
     return searchType;
 }
 /**
- * Build a {@link SearchSchema} from root-type declarations, keyed by `type`.
+ * Build a {@link SearchSchema} from root-type declarations, keyed by `class`.
  *
- * Every declaration is validated ({@link assertValidSearchType}) — the
- * declaration-time counterpart of the port’s `assertValidQuery` — and the
- * schema-wide invariants are enforced: no two types may share a `type` IRI
+ * Every declaration is validated ({@link assertValidSearchType}) – the
+ * declaration-time counterpart of the port’s `assertValidQuery` – and the
+ * schema-wide invariants are enforced: no two types may share a `class` IRI
  * (they would silently overwrite each other in the map) or a `name` (names
  * key the API surfaces). Throws on the first invalid declaration, so a bad
  * schema fails at startup, not per document at index time or per query.
@@ -42,18 +42,18 @@ export function searchSchema(...types) {
     const names = new Set();
     for (const searchType of types) {
         assertValidSearchType(searchType);
-        if (typeIris.has(searchType.type)) {
-            throw new Error(`Duplicate search type IRI “${searchType.type}”; each SearchType must declare a distinct type.`);
+        if (typeIris.has(searchType.class)) {
+            throw new Error(`Duplicate search type IRI “${searchType.class}”; each SearchType must declare a distinct class.`);
         }
         if (names.has(searchType.name)) {
             throw new Error(`Duplicate search type name “${searchType.name}”; each SearchType must declare a distinct name.`);
         }
-        typeIris.add(searchType.type);
+        typeIris.add(searchType.class);
         names.add(searchType.name);
     }
     assertResolvableLabelSources(types);
     // The one blessed cast: only this validated constructor mints the brand.
-    return new Map(types.map((searchType) => [searchType.type, searchType]));
+    return new Map(types.map((searchType) => [searchType.class, searchType]));
 }
 /**
  * The text field a label source serves labels from – the ‘label’ convention
@@ -104,18 +104,38 @@ const SEARCHABLE_KINDS = ['text', 'keyword', 'reference'];
 /** Kinds whose projection applies the {@link KeywordField.transform}. */
 const TRANSFORMABLE_KINDS = ['keyword', 'reference'];
 /**
- * Structurally validate one {@link SearchType} declaration — the
+ * A safe logical field name: a GraphQL-style identifier. The name is
+ * interpolated raw into physical field names AND, for a display text field,
+ * into the RE2 collection pattern `${name}_[^_]+` ({@link displayFieldPattern}),
+ * so it must contain no regex metacharacter – this charset (letters, digits,
+ * `_`) guarantees that, and is exactly what a GraphQL field name allows anyway.
+ */
+const FIELD_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+ * A safe declared locale: BCP-47-shaped (letters/digits, `-` between subtags),
+ * never containing `_`. The `_` is the reserved separator between a text field’s
+ * name and its language subtag, so a locale carrying one would collide with the
+ * `${name}_search_${locale}` / display naming; incoming data tags are normalised
+ * to this shape at projection time.
+ */
+const LOCALE_PATTERN = /^[A-Za-z0-9]+(-[A-Za-z0-9]+)*$/;
+/**
+ * Structurally validate one {@link SearchType} declaration – the
  * declaration-time counterpart of `validateQuery`. Rules:
  *
  * - field names are unique (a duplicate would silently shadow in every
- *   consumer, each picking a different winner);
+ *   consumer, each picking a different winner) and a metacharacter-free
+ *   identifier (the name is interpolated into physical field names and the
+ *   display RE2 pattern);
+ * - 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
  *   need the reference type name); `ref` on any other kind is meaningless;
  * - a `text` field declares at least one locale (`und` = untagged; projection and
- *   result reconstruction have no representation for unlocalized text — use
+ *   result reconstruction have no representation for unlocalized text – use
  *   `keyword` for untagged strings); `locales` on any other kind is
  *   meaningless;
- * - a kind without a `where` operator (`text` — it feeds the free-text query)
+ * - a kind without a `where` operator (`text` – it feeds the free-text query)
  *   is neither `filterable` nor `facetable`;
  * - `facetRanges` only on the `range`-operator kinds (`integer`/`number`/`date`);
  * - `searchable` only on `text`/`keyword`/`reference` (projection emits no
@@ -141,6 +161,11 @@ export function validateSearchType(searchType) {
             issue('duplicate-field-name');
         }
         seen.add(field.name);
+        // The name is interpolated into physical field names and the display RE2
+        // pattern, so it must be a metacharacter-free identifier.
+        if (!FIELD_NAME_PATTERN.test(field.name)) {
+            issue('invalid-field-name');
+        }
         if (field.kind === 'reference') {
             if (field.output === true && field.ref === undefined) {
                 issue('missing-ref');
@@ -153,6 +178,12 @@ export function validateSearchType(searchType) {
             if ((field.locales ?? []).length === 0) {
                 issue('text-requires-locales');
             }
+            // A locale carrying `_` would collide with the name/locale separator in
+            // the physical and display field naming, so declared locales are
+            // BCP-47-shaped (data tags are normalised to match at projection time).
+            if ((field.locales ?? []).some((locale) => !LOCALE_PATTERN.test(locale))) {
+                issue('invalid-locale');
+            }
         }
         else if (field.locales !== undefined) {
             issue('locales-not-allowed');
@@ -187,13 +218,13 @@ export function validateSearchType(searchType) {
     return issues;
 }
 /**
- * Throw when `searchType` is not a member of `schema` — the port membership
+ * Throw when `searchType` is not a member of `schema` – the port membership
  * guard every engine adapter applies before searching, so a query can never
  * meet an index the deployment did not declare. Identity-based: the exact
  * declaration object must be in the schema, not a lookalike.
  */
 export function assertTypeInSchema(schema, searchType) {
-    if (schema.get(searchType.type) !== searchType) {
+    if (schema.get(searchType.class) !== searchType) {
         throw new Error(`Search type “${searchType.name}” is not in this engine’s schema; it serves ${[
             ...schema.values(),
         ]
@@ -213,7 +244,55 @@ export function assertValidSearchType(searchType) {
     }
 }
 /**
- * Full-text searchable fields, highest `query_by` weight first — the order the
+ * The display fields of a localized `text` field are pattern-based, not
+ * enumerated per declared locale: projection stores `${name}_${lang}` for
+ * **every** language present in the data (not only those in `locales`), so a
+ * label in an undeclared language or an untagged one still renders rather than
+ * collapsing to a bare IRI. `locales` governs only the indexed search/sort
+ * fanout ({@link PhysicalFields}); display costs nothing per language (stored
+ * `index: false`), so it preserves them all. A deployment that wants fewer
+ * display languages restricts them upstream (e.g. in its CONSTRUCT).
+ *
+ * A language subtag never contains `_`, but the `search_`/`sort_` infixes do,
+ * so `${name}_${lang}` with `lang` matching `[^_]+` is unambiguously a display
+ * field: `label_nl`, `label_fr`, `label_zh-hant`, `label_und` are display;
+ * `label_search_nl` and `label_sort_nl` are not. This trio – the name a value
+ * is written under ({@link displayFieldName}), the collection pattern that
+ * accepts them all ({@link displayFieldPattern}), and the reader that recovers a
+ * key’s language ({@link displayLangOf}) – is the single home of that
+ * convention, so projection, collection-definition and result reconstruction
+ * cannot disagree.
+ */
+export function displayFieldName(field, lang) {
+    return `${field.name}_${lang}`;
+}
+/**
+ * The RE2 pattern a collection declares to store every present language’s
+ * display value un-indexed, or `undefined` when the field is not `output` (no
+ * display at all). Matches `${name}_${lang}` for any underscore-free `lang`, so
+ * it never collides with the field’s `${name}_search_${locale}` /
+ * `${name}_sort_${locale}` companions.
+ */
+export function displayFieldPattern(field) {
+    return field.output ? `${field.name}_[^_]+` : undefined;
+}
+/**
+ * The language a stored document key carries for `field`’s display, or
+ * `undefined` when the key is not one of `field`’s display fields – the inverse
+ * of {@link displayFieldName}. A key qualifies when it is `${name}_` followed by
+ * an underscore-free remainder, so the `${name}_search_…`/`${name}_sort_…`
+ * companions (and unrelated fields) are rejected.
+ */
+export function displayLangOf(field, key) {
+    const prefix = `${field.name}_`;
+    if (!key.startsWith(prefix)) {
+        return undefined;
+    }
+    const lang = key.slice(prefix.length);
+    return lang.length > 0 && !lang.includes('_') ? lang : undefined;
+}
+/**
+ * Full-text searchable fields, highest `query_by` weight first – the order the
  * engine adapter weights `query_by` in. A field is searchable iff it carries a
  * `searchable` weight.
  */
@@ -271,14 +350,16 @@ export function isoToUnixSeconds(iso) {
 export function unixSecondsToIso(seconds) {
     return new Date(seconds * 1000).toISOString();
 }
-/** Derive the physical engine field names a declaration produces. */
+/**
+ * Derive the **indexed** physical engine field names a declaration produces:
+ * the per-locale `search`/`sort` fanout. A localized `text` field’s display
+ * fields are pattern-based and not enumerated here – see {@link displayFieldName}
+ * and its siblings.
+ */
 export function physicalFields(field) {
     if (field.kind === 'text') {
         const locales = field.locales;
         return {
-            display: field.output
-                ? locales.map((locale) => `${field.name}_${locale}`)
-                : [],
             search: field.searchable
                 ? locales.map((locale) => `${field.name}_search_${locale}`)
                 : [],
@@ -288,7 +369,6 @@ export function physicalFields(field) {
         };
     }
     return {
-        display: [],
         search: field.searchable !== undefined ? [`${field.name}_search`] : [],
         sort: [],
     };

package/dist/testing.js

@@ -32,13 +32,13 @@ export function describeSearchEngineContract(name, engine) {
             expect(types().length).toBeGreaterThan(0);
             for (const searchType of types()) {
                 expect(typeof searchType.name).toBe('string');
-                expect(typeof searchType.type).toBe('string');
+                expect(typeof searchType.class).toBe('string');
             }
         });
         it('rejects a search type outside its schema', async () => {
             const foreign = {
                 name: 'NotInSchema',
-                type: 'urn:test:not-in-schema',
+                class: 'urn:test:not-in-schema',
                 fields: [],
             };
             await expect(engine().search(foreign, browse(foreign))).rejects.toThrow(/not in this engine/);
@@ -78,7 +78,7 @@ export function describeSearchEngineContract(name, engine) {
         it('rejects a searchFacets batch for a type outside its schema', async () => {
             const foreign = {
                 name: 'NotInSchema',
-                type: 'urn:test:not-in-schema',
+                class: 'urn:test:not-in-schema',
                 fields: [],
             };
             await expect(engine().searchFacets(foreign, [browse(foreign)])).rejects.toThrow(/not in this engine/);

package/package.json

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