@lde/search 0.6.0 → 0.7.1

package/README.md

@@ -21,15 +21,15 @@ 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.
 
 ```
@@ -40,7 +40,7 @@ SearchSchema ─┬─► projection      (projectGraph → flat documents)
 ```
 
 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:
 
 ```
@@ -51,19 +51,19 @@ 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 definition); between them every stage is
-a typed, deterministic function — easy to test, and swappable per deployment.
+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).
 
@@ -76,7 +76,7 @@ and GraphQL (one of the surfaces):
 | -------------- | ---------------------------------------------------------------------------------------------------------------- | -------------- | ----------- |
 | `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      |
+| `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,12 +85,12 @@ 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 (`buildCollectionDefinition`,
   `buildSearchParams`, `buildGraphQLSchema`); `create*` makes a stateful
@@ -101,7 +101,7 @@ 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 definition and the
@@ -119,7 +119,7 @@ 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_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 `class` 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,35 +292,37 @@ 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
-meet the wrong index, and deployment-level concerns (the label cache,
-cross-type search, facet batching) have one home. A search names its type per
+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:
+– no caller-side generics:
 
 ```ts
-const engine = createTypesenseSearchEngine(client, schema, {
-  collections: { Dataset: 'datasets', Person: 'people' }, // omitting one = type error
-});
+// 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
@@ -337,5 +350,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,13 +1,14 @@
 /**
  * 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 { physicalNameTokens } from './physical-name.js';
 export { filterOperatorFor, filterOperator, validateQuery, assertValidQuery, pageForOffset, } from './query.js';
 export type { FilterOperator, QueryIssue } from './query.js';
 //# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,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,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/adapter.js

@@ -1,10 +1,11 @@
 /**
  * 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 { physicalNameTokens } from './physical-name.js';
 export { filterOperatorFor, filterOperator, validateQuery, assertValidQuery, pageForOffset, } from './query.js';

package/dist/physical-name.d.ts

@@ -0,0 +1,31 @@
+import type { SearchType } from './schema.js';
+/**
+ * The engine-neutral word tokens an adapter formats into the physical name of a
+ * {@link SearchType}’s container – a Typesense collection, an Elasticsearch or
+ * OpenSearch index: the type’s `name` split into words, lowercased, with the
+ * last word pluralized (`CreativeWork` → `['creative', 'works']`).
+ *
+ * Both engines document the same convention – name a container after the plural
+ * of what it holds – and differ only in how they join the words: Typesense
+ * snake_case (`blog_articles`), Elasticsearch/OpenSearch kebab-case
+ * (`blog-articles`). So the split and the inflection are shared here, and only
+ * the join and the engine’s own legality rules live in the adapter – which is
+ * why this returns tokens rather than a formatted name, and why it is spelled
+ * neutrally (‘container’, not ‘collection’ or ‘index’).
+ *
+ * Acronyms stay whole (`DCATDataset` → `['dcat', 'datasets']`, `TVSeries` →
+ * `['tv', 'series']`), which is why the split is hand-rolled rather than
+ * delegated to an inflector’s `underscore`/`tableize` – those split on every
+ * capital (`t_v_series`).
+ *
+ * Pluralization is a real inflector, so irregular and invariant nouns land the
+ * way the engines’ own docs write them (`Person` → `people`, `TVSeries` →
+ * `tv_series`, `Analysis` → `analyses`) rather than as the non-words regular
+ * rules produce (`serieses`, `analysises`). An already-plural name is
+ * idempotent (`People` → `people`).
+ *
+ * Returns an empty array when `name` carries no alphanumerics at all; the
+ * adapter decides what that means, since only it knows its engine’s rules.
+ */
+export declare function physicalNameTokens(searchType: SearchType): readonly string[];
+//# sourceMappingURL=physical-name.d.ts.map

package/dist/physical-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physical-name.d.ts","sourceRoot":"","sources":["../src/physical-name.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,CAK5E"}

package/dist/physical-name.js

@@ -0,0 +1,44 @@
+import { pluralize } from 'inflection';
+/**
+ * The engine-neutral word tokens an adapter formats into the physical name of a
+ * {@link SearchType}’s container – a Typesense collection, an Elasticsearch or
+ * OpenSearch index: the type’s `name` split into words, lowercased, with the
+ * last word pluralized (`CreativeWork` → `['creative', 'works']`).
+ *
+ * Both engines document the same convention – name a container after the plural
+ * of what it holds – and differ only in how they join the words: Typesense
+ * snake_case (`blog_articles`), Elasticsearch/OpenSearch kebab-case
+ * (`blog-articles`). So the split and the inflection are shared here, and only
+ * the join and the engine’s own legality rules live in the adapter – which is
+ * why this returns tokens rather than a formatted name, and why it is spelled
+ * neutrally (‘container’, not ‘collection’ or ‘index’).
+ *
+ * Acronyms stay whole (`DCATDataset` → `['dcat', 'datasets']`, `TVSeries` →
+ * `['tv', 'series']`), which is why the split is hand-rolled rather than
+ * delegated to an inflector’s `underscore`/`tableize` – those split on every
+ * capital (`t_v_series`).
+ *
+ * Pluralization is a real inflector, so irregular and invariant nouns land the
+ * way the engines’ own docs write them (`Person` → `people`, `TVSeries` →
+ * `tv_series`, `Analysis` → `analyses`) rather than as the non-words regular
+ * rules produce (`serieses`, `analysises`). An already-plural name is
+ * idempotent (`People` → `people`).
+ *
+ * Returns an empty array when `name` carries no alphanumerics at all; the
+ * adapter decides what that means, since only it knows its engine’s rules.
+ */
+export function physicalNameTokens(searchType) {
+    const words = searchType.name.match(NAME_WORD_PATTERN) ?? [];
+    const tokens = words.map((word) => word.toLowerCase());
+    const last = tokens.at(-1);
+    return last === undefined ? [] : [...tokens.slice(0, -1), pluralize(last)];
+}
+/**
+ * One word of a PascalCase/camelCase name, in precedence order: a run of
+ * capitals not followed by a lowercase letter (an acronym – `DCAT` in
+ * `DCATDataset`, `TV` in `TVSeries`); a capital starting an ordinary word; or a
+ * lowercase run. Anything else (a separator, punctuation) matches nothing and
+ * is dropped, so a name already written as `creative_work` or `creative-work`
+ * tokenizes the same way.
+ */
+const NAME_WORD_PATTERN = /[A-Z]+(?![a-z])|[A-Z][a-z0-9]*|[a-z0-9]+/g;

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.
  */
@@ -26,7 +26,7 @@ export interface TypedSearchDocument {
 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,6 +1,6 @@
 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
@@ -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
@@ -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

@@ -13,13 +13,13 @@ 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
+ * One queryable field – the single declarative source that drives all four
  * consumers (projection, engine collection definition, query semantics, and the
  * GraphQL surface).
  *
@@ -32,8 +32,8 @@ 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
@@ -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 {
@@ -200,7 +200,7 @@ export interface FacetRange {
  * 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 `class` IRI, so re-modelling the vocabulary cannot
@@ -214,7 +214,7 @@ export interface SearchType {
 /**
  * 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.
@@ -228,7 +228,7 @@ export declare function defineSearchType<const Type extends SearchType>(searchTy
  * `: 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;
@@ -238,8 +238,8 @@ export interface SearchSchema<Types extends readonly SearchType[] = readonly Sea
 /**
  * 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
+ * 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
@@ -263,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
@@ -292,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.
@@ -308,8 +312,6 @@ export declare function assertValidSearchType(searchType: SearchType): void;
  * 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[];
@@ -318,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.
  */
@@ -359,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":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,SAAS,GACT,SAAS,GACT,QAAQ,GACR,SAAS,GACT,MAAM,GACN,WAAW,CAAC;AAEhB;oEACoE;AACpE,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAAC;AAcnD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,GAAG,SAAS,CAE7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,WAAW,GACnB,SAAS,GACT,YAAY,GACZ,cAAc,GACd,YAAY,GACZ,YAAY,CAAC;AAEjB,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B;wCACoC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;+EAC2E;IAC3E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,oBAAoB;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB;;yCAEqC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,yBAAyB;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,iCAAiC;IACjC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC;CAC3E;AAED;kEACkE;AAClE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACnD;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAU,SAAQ,eAAe,EAAE,UAAU;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;CAC9B;AAED;gCACgC;AAChC,MAAM,WAAW,YAAa,SAAQ,eAAe,EAAE,UAAU;IAC/D,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,wEAAwE;IACxE,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/C,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;CAC9B;AAED,gFAAgF;AAChF,MAAM,WAAW,cAAe,SAAQ,eAAe,EAAE,UAAU;IACjE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,uCAAuC;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/C,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IAC7B;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;0DAEsD;IACtD,QAAQ,CAAC,GAAG,CAAC,EAAE;QACb;;;;;qCAK6B;QAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B;;;;6EAIqE;QACrE,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;KACtD,CAAC;CACH;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CAC9C;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAa,SAAQ,eAAe,EAAE,cAAc;IACnE,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC7C,QAAQ,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC;CAC7B;AAED,0DAA0D;AAC1D,MAAM,WAAW,YAAa,SAAQ,eAAe;IACnD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB;;;;+CAI2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;2DACuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;CACzC;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,IAAI,SAAS,UAAU,EAC5D,UAAU,EAAE,IAAI,GACf,IAAI,CAEN;AAED;;;;;;GAMG;AACH;;;uCAGuC;AACvC,MAAM,CAAC,OAAO,CAAC,MAAM,iBAAiB,EAAE,OAAO,MAAM,CAAC;AAEtD,MAAM,WAAW,YAAY,CAC3B,KAAK,SAAS,SAAS,UAAU,EAAE,GAAG,SAAS,UAAU,EAAE,CAC3D,SAAQ,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,KAAK,SAAS,SAAS,UAAU,EAAE,EACpE,GAAG,KAAK,EAAE,KAAK,GACd,YAAY,CAAC,KAAK,CAAC,CAuBrB;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAQ1E;AAsCD;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EACX,sBAAsB,GACtB,aAAa,GACb,iBAAiB,GACjB,uBAAuB,GACvB,qBAAqB,GACrB,0BAA0B,GAC1B,wBAAwB,GACxB,uBAAuB,GACvB,kBAAkB,GAClB,qBAAqB,GACrB,oBAAoB,CAAC;CAC1B;AAQD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,GACrB,SAAS,eAAe,EAAE,CAkE5B;AAWD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,UAAU,GACrB,IAAI,CAUN;AAED;+EAC+E;AAC/E,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAQlE;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;sEACkE;IAClE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;4EACwE;IACxE,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,GACrB,SAAS,CAAC,WAAW,GAAG;IACzB,QAAQ,CAAC,UAAU,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAClD,CAAC,EAAE,CAOH;AAED,8DAA8D;AAC9D,wBAAgB,eAAe,CAC7B,UAAU,EAAE,UAAU,GACrB,SAAS,WAAW,EAAE,CAExB;AAED,sDAAsD;AACtD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,GACrB,SAAS,WAAW,EAAE,CAExB;AAED,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,WAAW,EAAE,CAE7E;AAED,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,WAAW,EAAE,CAE3E;AAED,qFAAqF;AACrF,wBAAgB,eAAe,CAC7B,UAAU,EAAE,UAAU,GACrB,SAAS,cAAc,EAAE,CAE3B;AAED,2CAA2C;AAC3C,wBAAgB,UAAU,CACxB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,GACX,WAAW,GAAG,SAAS,CAEzB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,WAAW,GACjB,KAAK,IAAI,YAAY,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAA;CAAE,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGhE;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,CAoBjE"}
+{"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.
@@ -30,8 +30,8 @@ export function defineSearchType(searchType) {
 /**
  * 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
+ * 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
@@ -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,7 +218,7 @@ 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.
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "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",
@@ -40,6 +40,7 @@
     "@lde/text-normalization": "^0.1.1",
     "@rdfjs/types": "^2.0.1",
     "@tpluscode/rdf-ns-builders": "^5.0.0",
+    "inflection": "^3.0.2",
     "jsonld": "^9.0.0",
     "tslib": "^2.3.0"
   },