@lde/search-typesense 0.8.0 → 0.9.0

package/README.md

@@ -12,24 +12,27 @@ writers (Blue/green Rebuild and In-place Rebuild).
 ## Collection schema and engine
 
 `buildCollectionDefinition(searchType, { name, defaultSortingField, … })` derives a
-Typesense collection from the unified `SearchField` model — the Typesense field
+Typesense collection from the unified `SearchField` model – the Typesense field
 type comes from each field’s `kind`, and the physical fanout (per-locale
-search/sort keys) matches what the projection writes, via
-`@lde/search`’s `physicalFields`, so the index and the documents cannot drift.
+search/sort keys, plus one regex display field per output text field) matches
+what the projection writes, via `@lde/search`’s `physicalFields` and its display
+helpers, so the index and the documents cannot drift.
 
 **Memory lever.** Typesense keeps the index in RAM (with a raw copy of each
 document on disk), so RAM tracks the _indexed_ surface – roughly 2–3× the size
 of the fields you search, facet or sort on – not the full document.
-`buildCollectionDefinition` keeps that surface minimal: the `output` display labels
-fan out to `index: false` fields, stored on disk and fetched only for a hit, so
-they cost no RAM; only the folded `*_search_${locale}`, facet/reference and
-`*_sort_${locale}` companions are indexed. Keeping retrieval-only fields
-un-indexed is the lever for holding a large index’s RAM down.
+`buildCollectionDefinition` keeps that surface minimal: the `output` display
+labels land in one `index: false` regex field (`${name}_<lang>`, one value per
+present language), stored on disk and fetched only for a hit, so they cost no RAM
+and preserve every language; only the folded `*_search_${locale}`,
+facet/reference and `*_sort_${locale}` companions are indexed. Keeping
+retrieval-only fields un-indexed is the lever for holding a large index’s RAM
+down.
 
 `createTypesenseSearchEngine(client, schema, { collections })` is the
 `SearchEngine` implementation. Each search:
 
-- validates the query against the search type (the port contract — a
+- validates the query against the search type (the port contract – a
   structurally invalid query is rejected, never sent);
 - compiles it into Typesense search params (`buildSearchParams`);
 - runs the search;
@@ -38,7 +41,7 @@ un-indexed is the lever for holding a large index’s RAM down.
   sources bundled into a single lookup. A reference without a `labelSource`
   stays id-only. With `labelCacheTtlMs` set, each label-source collection is
   instead loaded once into an in-memory cache;
-- reconstructs the logical `SearchResult` (`parseSearchResponse`) — language
+- reconstructs the logical `SearchResult` (`parseSearchResponse`) – language
   maps, labelled references, labelled facet buckets.
 
 A label source is just another `SearchType` in the schema (with an `output`,

package/dist/collection-definition.d.ts

@@ -5,7 +5,7 @@ export interface CollectionDefinitionOptions {
     /** The Typesense collection (or alias) name. */
     readonly name: string;
     /** Snowball stemming locale for non-localized searchable fields (e.g. `en`).
-     *  Unset, those fields are not stemmed — folding still applies — so no
+     *  Unset, those fields are not stemmed – folding still applies – so no
      *  language is ever assumed. Localized text search fields always stem in
      *  their own locale. */
     readonly defaultLocale?: string;
@@ -29,11 +29,12 @@ export interface CollectionDefinitionOptions {
  * Memory lever: Typesense holds the index in RAM (with a raw copy of each
  * document on disk), so RAM tracks the *indexed* surface – roughly 2–3× the
  * size of the fields you search, facet or sort on – not the whole document.
- * This builder keeps that surface minimal: the `output` display labels fan out
- * to `index: false` fields, kept on disk and read back only for a hit, so they
- * cost no RAM; only the folded `*_search_${locale}`, facet/reference and
- * `*_sort_${locale}` companions are indexed. Keeping retrieval-only fields
- * un-indexed is the lever for holding a large index’s RAM down.
+ * This builder keeps that surface minimal: the `output` display labels land in
+ * a single `index: false` regex field (`${name}_<lang>`, one value per present
+ * language), kept on disk and read back only for a hit, so they cost no RAM;
+ * only the folded `*_search_${locale}`, facet/reference and `*_sort_${locale}`
+ * companions are indexed. Keeping retrieval-only fields un-indexed is the lever
+ * for holding a large index’s RAM down.
  */
 export declare function buildCollectionDefinition(searchType: SearchType, options: CollectionDefinitionOptions): CollectionCreateSchema;
 //# sourceMappingURL=collection-definition.d.ts.map

package/dist/collection-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection-definition.d.ts","sourceRoot":"","sources":["../src/collection-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAExD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAGhE,0EAA0E;AAC1E,MAAM,WAAW,2BAA2B;IAC1C,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;4BAGwB;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,2BAA2B,GACnC,sBAAsB,CAexB"}
+{"version":3,"file":"collection-definition.d.ts","sourceRoot":"","sources":["../src/collection-definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAExD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAGhE,0EAA0E;AAC1E,MAAM,WAAW,2BAA2B;IAC1C,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;4BAGwB;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IACtC,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,2BAA2B,GACnC,sBAAsB,CAexB"}

package/dist/collection-definition.js

@@ -1,4 +1,4 @@
-import { physicalFields } from '@lde/search/adapter';
+import { displayFieldPattern, physicalFields } from '@lde/search/adapter';
 /**
  * Build a Typesense collection definition from the unified {@link SearchType}, so
  * the index and the projection are driven by one declarative source and cannot
@@ -14,11 +14,12 @@ import { physicalFields } from '@lde/search/adapter';
  * Memory lever: Typesense holds the index in RAM (with a raw copy of each
  * document on disk), so RAM tracks the *indexed* surface – roughly 2–3× the
  * size of the fields you search, facet or sort on – not the whole document.
- * This builder keeps that surface minimal: the `output` display labels fan out
- * to `index: false` fields, kept on disk and read back only for a hit, so they
- * cost no RAM; only the folded `*_search_${locale}`, facet/reference and
- * `*_sort_${locale}` companions are indexed. Keeping retrieval-only fields
- * un-indexed is the lever for holding a large index’s RAM down.
+ * This builder keeps that surface minimal: the `output` display labels land in
+ * a single `index: false` regex field (`${name}_<lang>`, one value per present
+ * language), kept on disk and read back only for a hit, so they cost no RAM;
+ * only the folded `*_search_${locale}`, facet/reference and `*_sort_${locale}`
+ * companions are indexed. Keeping retrieval-only fields un-indexed is the lever
+ * for holding a large index’s RAM down.
  */
 export function buildCollectionDefinition(searchType, options) {
     const { defaultLocale } = options;
@@ -39,17 +40,24 @@ function typesenseFields(field, defaultLocale, defaultSortingField) {
     const names = physicalFields(field);
     if (field.kind === 'text') {
         const locales = field.locales;
+        const displayPattern = displayFieldPattern(field);
         return [
-            // Display labels: stored but NOT indexed (`index: false`) – search hits
-            // the folded `*_search` companions, so the display copy stays on disk and
-            // off RAM (fetched only for a hit), accents preserved. This is the memory
-            // lever: RAM tracks the search surface, not the display text.
-            ...names.display.map((name) => ({
-                name,
-                type: 'string',
-                index: false,
-                optional: true,
-            })),
+            // Display labels: ONE regex field (`${name}_<lang>`) storing every
+            // present language’s value, NOT indexed (`index: false`) – search hits
+            // the folded `*_search` companions, so the display copies stay on disk and
+            // off RAM (fetched only for a hit), accents preserved, and a language
+            // outside `locales` still renders. This is the memory lever: RAM tracks
+            // the search surface, not the display text. Absent for a non-output field.
+            ...(displayPattern !== undefined
+                ? [
+                    {
+                        name: displayPattern,
+                        type: 'string',
+                        index: false,
+                        optional: true,
+                    },
+                ]
+                : []),
             // One folded search field per locale, each stemmed in its own
             // language; the untagged `und` locale is folded but unstemmed unless
             // the deployment opts in via `defaultLocale`.
@@ -83,7 +91,7 @@ function typesenseFields(field, defaultLocale, defaultSortingField) {
         },
     ];
     // `names.search` is non-empty exactly when the field projects a folded
-    // search companion — physicalFields owns that rule.
+    // search companion – physicalFields owns that rule.
     for (const name of names.search) {
         fields.push({
             name,

package/dist/search.d.ts

@@ -1,20 +1,20 @@
 import type { Client } from 'typesense';
 import { type LocalizedValue, type SearchEngine, type SearchResult, type SearchSchema, type SearchType, type TextField } from '@lde/search';
 import { type BuildSearchParamsOptions } from './query-compiler.js';
-/** Where the engine reads documents — plus every query-compiler knob
+/** Where the engine reads documents – plus every query-compiler knob
  *  ({@link BuildSearchParamsOptions}), declared once there and forwarded
  *  wholesale into each search. `TypeName` is the union of the schema’s type
  *  names, so a literal schema makes the `collections` map exhaustive at
  *  compile time. Reference labels resolve per field from the collection of
- *  the SearchType its `labelSource` names — a label source is just another
+ *  the SearchType its `labelSource` names – a label source is just another
  *  entry in `collections`. */
 export interface TypesenseSearchEngineOptions<TypeName extends string = string> extends BuildSearchParamsOptions {
-    /** The collection (or alias) per search type, keyed by the type’s `name` —
+    /** The collection (or alias) per search type, keyed by the type’s `name` –
      *  with a literal schema, omitting a type is a compile error. */
     readonly collections: Readonly<Record<TypeName, string>>;
     /**
      * Called when reference-label resolution fails; the search then degrades to
-     * id-only references rather than failing. Optional — omit to swallow silently.
+     * id-only references rather than failing. Optional – omit to swallow silently.
      */
     readonly onLabelError?: (error: unknown) => void;
     /**
@@ -40,12 +40,12 @@ export interface LabelSource {
 }
 /**
  * A Typesense-backed {@link SearchEngine}, bound to the whole
- * {@link SearchSchema} at construction — like every other schema consumer.
+ * {@link SearchSchema} at construction – like every other schema consumer.
  * Each type’s collection comes from `options.collections`. `search` compiles
  * the query ({@link buildSearchParams}), runs it against the type’s
- * collection, resolves the reference labels for the page of hits — each
+ * collection, resolves the reference labels for the page of hits – each
  * reference field from its own label source’s collection, all sources bundled
- * into one lookup — and reconstructs the engine-neutral
+ * into one lookup – and reconstructs the engine-neutral
  * {@link SearchResult} ({@link parseSearchResponse}). `searchFacets` answers
  * a whole facet batch (e.g. a faceted listing’s skip-own-filter query variants) as a
  * single `multi_search` round-trip with one shared label lookup; a failed
@@ -55,7 +55,7 @@ export interface LabelSource {
  *
  * With a schema built by `searchSchema` over `defineSearchType` literals,
  * `search()` accepts only the deployment’s own types and returns typo-safe
- * facet/document keys per call — no caller-side generics.
+ * facet/document keys per call – no caller-side generics.
  */
 export declare function createTypesenseSearchEngine<const Types extends readonly SearchType[]>(client: Client, schema: SearchSchema<Types>, options: TypesenseSearchEngineOptions<Types[number]['name']>): SearchEngine<Types>;
 /** One label lookup: a source and the distinct IRIs to resolve against it. */
@@ -64,13 +64,14 @@ export interface LabelLookupGroup {
     readonly iris: readonly string[];
 }
 /**
- * Resolve labels from each group’s label-source collection. Localized labels
- * are reconstructed from the source type’s `label` declaration; a bare
- * untagged `label` value is the `und` fallback when no locale variant exists.
+ * Resolve labels from each group’s label-source collection. Labels are
+ * reconstructed from the source type’s `label` declaration ({@link
+ * localizedValue}), carrying every present language – including ones outside
+ * the declared `locales` and untagged (`und`) values.
  *
  * All groups travel as ONE `multi_search` (POST) call, each group’s id-list
  * split over per-search batches: the id-list of a page or facet carrying many
- * references — e.g. a dataset with dozens of classes — would overflow
+ * references – e.g. a dataset with dozens of classes – would overflow
  * Typesense’s GET query-string limit (4000 chars, and IRIs URL-encode to
  * several times their length) if it travelled in the URL. POST puts it in the
  * body; each batch stays under Typesense’s `per_page` cap, and bundling the

package/dist/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAGL,KAAK,cAAc,EAMnB,KAAK,YAAY,EAEjB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,UAAU,EAEf,KAAK,SAAS,EACf,MAAM,aAAa,CAAC;AAWrB,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,qBAAqB,CAAC;AAE7B;;;;;;8BAM8B;AAC9B,MAAM,WAAW,4BAA4B,CAC3C,QAAQ,SAAS,MAAM,GAAG,MAAM,CAChC,SAAQ,wBAAwB;IAChC;qEACiE;IACjE,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;IACzD;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACjD;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,CAAC,KAAK,SAAS,SAAS,UAAU,EAAE,EAEzC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,CAAC,KAAK,CAAC,EAC3B,OAAO,EAAE,4BAA4B,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,GAC3D,YAAY,CAAC,KAAK,CAAC,CAsRrB;AAED,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AA0FD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,aAAa,CAAC,EACnC,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAC/B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAgDtC;AAgDD,oEAAoE;AACpE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EAAE,CAAC;IAC1E,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS;QAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS;YACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;YACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;SACxB,EAAE,CAAC;KACL,EAAE,CAAC;CACL;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,uBAAuB,EACjC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,GAC1C,YAAY,CAsCd"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAGL,KAAK,cAAc,EAMnB,KAAK,YAAY,EAEjB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,UAAU,EAEf,KAAK,SAAS,EACf,MAAM,aAAa,CAAC;AAYrB,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,qBAAqB,CAAC;AAE7B;;;;;;8BAM8B;AAC9B,MAAM,WAAW,4BAA4B,CAC3C,QAAQ,SAAS,MAAM,GAAG,MAAM,CAChC,SAAQ,wBAAwB;IAChC;qEACiE;IACjE,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;IACzD;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACjD;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,CAAC,KAAK,SAAS,SAAS,UAAU,EAAE,EAEzC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,CAAC,KAAK,CAAC,EAC3B,OAAO,EAAE,4BAA4B,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,GAC3D,YAAY,CAAC,KAAK,CAAC,CAsRrB;AAED,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AA0FD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,aAAa,CAAC,EACnC,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAC/B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAgDtC;AA6BD,oEAAoE;AACpE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EAAE,CAAC;IAC1E,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS;QAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS;YACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;YACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;SACxB,EAAE,CAAC;KACL,EAAE,CAAC;CACL;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,uBAAuB,EACjC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,GAC1C,YAAY,CAsCd"}

package/dist/search.js

@@ -1,13 +1,13 @@
-import { assertTypeInSchema, assertValidQuery, fieldNamed, isRangeFacet, labelFieldOf, outputFields, physicalFields, referenceFields, } from '@lde/search/adapter';
+import { assertTypeInSchema, assertValidQuery, displayLangOf, fieldNamed, isRangeFacet, labelFieldOf, outputFields, physicalFields, referenceFields, } from '@lde/search/adapter';
 import { buildSearchParams, escapeFilterValue, } from './query-compiler.js';
 /**
  * A Typesense-backed {@link SearchEngine}, bound to the whole
- * {@link SearchSchema} at construction — like every other schema consumer.
+ * {@link SearchSchema} at construction – like every other schema consumer.
  * Each type’s collection comes from `options.collections`. `search` compiles
  * the query ({@link buildSearchParams}), runs it against the type’s
- * collection, resolves the reference labels for the page of hits — each
+ * collection, resolves the reference labels for the page of hits – each
  * reference field from its own label source’s collection, all sources bundled
- * into one lookup — and reconstructs the engine-neutral
+ * into one lookup – and reconstructs the engine-neutral
  * {@link SearchResult} ({@link parseSearchResponse}). `searchFacets` answers
  * a whole facet batch (e.g. a faceted listing’s skip-own-filter query variants) as a
  * single `multi_search` round-trip with one shared label lookup; a failed
@@ -17,11 +17,11 @@ import { buildSearchParams, escapeFilterValue, } from './query-compiler.js';
  *
  * With a schema built by `searchSchema` over `defineSearchType` literals,
  * `search()` accepts only the deployment’s own types and returns typo-safe
- * facet/document keys per call — no caller-side generics.
+ * facet/document keys per call – no caller-side generics.
  */
 export function createTypesenseSearchEngine(client, schema, options) {
     // Resolve every type's collection ONCE at construction, so a
-    // misconfiguration fails at startup — never on the first search that
+    // misconfiguration fails at startup – never on the first search that
     // happens to hit the unwired type.
     const collections = new Map([...schema.values()].map((searchType) => {
         const collection = options.collections[searchType.name];
@@ -211,7 +211,7 @@ export function createTypesenseSearchEngine(client, schema, options) {
 /**
  * Load a FULL label-source collection into a label map via the documents
  * export endpoint, which streams every document as JSONL (one JSON object per
- * line). Each line is reconstructed by {@link labelValue}, exactly as the
+ * line). Each line is reconstructed by {@link localizedValue}, exactly as the
  * per-search {@link fetchLabels} path does for its `multi_search` hits.
  */
 async function loadAllLabels(client, source) {
@@ -225,7 +225,7 @@ async function loadAllLabels(client, source) {
             continue;
         }
         const document = JSON.parse(line);
-        const label = labelValue(document, source.labelField);
+        const label = localizedValue(document, source.labelField);
         if (label !== undefined) {
             labels.set(String(document.id), label);
         }
@@ -286,13 +286,14 @@ function labelLookupGroups(responses, sources, outputSources) {
     }));
 }
 /**
- * Resolve labels from each group’s label-source collection. Localized labels
- * are reconstructed from the source type’s `label` declaration; a bare
- * untagged `label` value is the `und` fallback when no locale variant exists.
+ * Resolve labels from each group’s label-source collection. Labels are
+ * reconstructed from the source type’s `label` declaration ({@link
+ * localizedValue}), carrying every present language – including ones outside
+ * the declared `locales` and untagged (`und`) values.
  *
  * All groups travel as ONE `multi_search` (POST) call, each group’s id-list
  * split over per-search batches: the id-list of a page or facet carrying many
- * references — e.g. a dataset with dozens of classes — would overflow
+ * references – e.g. a dataset with dozens of classes – would overflow
  * Typesense’s GET query-string limit (4000 chars, and IRIs URL-encode to
  * several times their length) if it travelled in the URL. POST puts it in the
  * body; each batch stays under Typesense’s `per_page` cap, and bundling the
@@ -331,7 +332,7 @@ export async function fetchLabels(client, groups, onError) {
             return;
         }
         for (const hit of result.hits ?? []) {
-            const label = labelValue(hit.document, groupPerSearch[index].source.labelField);
+            const label = localizedValue(hit.document, groupPerSearch[index].source.labelField);
             if (label !== undefined) {
                 labels.set(String(hit.document.id), label);
             }
@@ -342,21 +343,6 @@ export async function fetchLabels(client, groups, onError) {
 /** Typesense caps `per_page` at 250; the multi_search POST body holds the
  *  id-list comfortably, so resolve references in batches of this size. */
 const LABEL_BATCH_SIZE = 200;
-/**
- * Reconstruct a label document into a language map via the source type’s
- * `label` declaration (its per-locale display fields), with a bare untagged
- * `label` value as the `und` fallback when no locale variant exists, or
- * `undefined` when the document carries no usable label – so the reference
- * stays id-only rather than gaining an empty label.
- */
-function labelValue(document, labelField) {
-    const localized = localizedValue(document, labelField);
-    if (localized !== undefined) {
-        return localized;
-    }
-    const untagged = document[labelField.name];
-    return typeof untagged === 'string' ? { und: [untagged] } : undefined;
-}
 /** Merge per-collection label maps into one IRI-keyed map (URI identity). */
 function mergeLabels(maps) {
     if (maps.length === 1) {
@@ -383,7 +369,7 @@ export function parseSearchResponse(response, searchType, labels) {
         document: reconstructDocument(hit.document, searchType, labels),
     }));
     // Reference facets are IRI-keyed; their buckets carry a resolved data label.
-    // Plain facets (tokens, free strings) carry no label — the consumer owns display.
+    // Plain facets (tokens, free strings) carry no label – the consumer owns display.
     // Only reference facets with a label source get bucket labels; an id-only
     // reference facet stays id-only even when a cached full-collection map holds
     // its IRIs.
@@ -447,16 +433,24 @@ function logicalValue(flat, field, labels) {
             return flat[field.name] === true;
     }
 }
-/** Gather the per-locale display fields back into a language map. */
+/**
+ * Gather every present-language display field back into a language map. Display
+ * fields are pattern-based (`${name}_<lang>`, {@link displayLangOf}), so this
+ * recovers languages outside the declared `locales` too – a value tagged in an
+ * undeclared language, or untagged (`und`), still reconstructs rather than being
+ * dropped.
+ */
 function localizedValue(flat, field) {
     const map = {};
-    const display = physicalFields(field).display;
-    field.locales.forEach((locale, index) => {
-        const value = flat[display[index]];
-        if (typeof value === 'string') {
-            map[locale] = [value];
+    for (const [key, value] of Object.entries(flat)) {
+        if (typeof value !== 'string') {
+            continue;
         }
-    });
+        const lang = displayLangOf(field, key);
+        if (lang !== undefined) {
+            map[lang] = [value];
+        }
+    }
     return Object.keys(map).length > 0 ? map : undefined;
 }
 /** Map stored reference IRIs to labelled references; id-only when no label. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Typesense implementation of the @lde/search SearchEngine port: collection-schema builder, query compiler, label-resolving result reconstruction, and blue/green index lifecycle. Engine-specific (Typesense) but domain-agnostic.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
@@ -25,7 +25,7 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/search": "^0.6.0",
+    "@lde/search": "^0.7.0",
     "@lde/text-normalization": "^0.1.1",
     "tslib": "^2.3.0",
     "typesense": "^3.0.6"