@lde/search-typesense 0.7.1 → 0.9.0

package/README.md

@@ -4,32 +4,35 @@
 domain-agnostic [`@lde/search`](../search) core. **Engine-specific (Typesense) but
 domain-agnostic** – you supply a `SearchType`; this package never names your
 domain. It is the Typesense implementation of the `SearchEngine` port: it derives
-a collection schema from the field model, compiles the neutral `SearchQuery` into
+a collection definition from the field model, compiles the neutral `SearchQuery` into
 Typesense search params, runs it, reconstructs the engine-neutral `SearchResult`,
 and manages the search index lifecycle as transactional `@lde/pipeline`
 writers (Blue/green Rebuild and In-place Rebuild).
 
 ## Collection schema and engine
 
-`buildCollectionSchema(searchType, { name, defaultSortingField, … })` derives a
-Typesense collection from the unified `SearchField` model — the Typesense field
+`buildCollectionDefinition(searchType, { name, defaultSortingField, … })` derives a
+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.
-`buildCollectionSchema` 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`,
@@ -67,9 +70,9 @@ Indexing runs through two transactional writers, one per update mode – the
 Both implement `@lde/pipeline`’s `Writer` – each run is
 `openRun(context)` → `write` per dataset → `commit()` or `abort(error)` – so
 an `@lde/pipeline` `Pipeline` drives them without branching on the mode. Both
-derive the collection schema from your `SearchType` (via
-`buildCollectionSchema`), and their options accept everything
-`buildCollectionSchema` does (`defaultLocale`, `defaultSortingField`,
+derive the collection definition from your `SearchType` (via
+`buildCollectionDefinition`), and their options accept everything
+`buildCollectionDefinition` does (`defaultLocale`, `defaultSortingField`,
 `synonymSets`) plus the tuning knobs (`batchSize`, `lockTtlMs`).
 
 ### Blue/green Rebuild

package/dist/blue-green-rebuild.d.ts

@@ -2,7 +2,7 @@ import type { Client } from 'typesense';
 import type { SearchType } from '@lde/search';
 import type { RunContext, RunWriter, Writer } from '@lde/pipeline';
 import { type RebuildOptions } from './rebuild-support.js';
-/** {@link BlueGreenRebuild} options: the collection-schema options (`name` is
+/** {@link BlueGreenRebuild} options: the collection-definition options (`name` is
  *  the logical index name the alias is kept on) plus the rebuild tuning knobs. */
 export type BlueGreenRebuildOptions = RebuildOptions;
 /**

package/dist/blue-green-rebuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blue-green-rebuild.d.ts","sourceRoot":"","sources":["../src/blue-green-rebuild.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACT,MAAM,EACP,MAAM,eAAe,CAAC;AAMvB,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AAE9B;kFACkF;AAClF,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,gBAAgB,CAC3B,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAE1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFP,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,uBAAuB;IAM7C,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IA2FjE,4EAA4E;YAC9D,WAAW;CAW1B"}
+{"version":3,"file":"blue-green-rebuild.d.ts","sourceRoot":"","sources":["../src/blue-green-rebuild.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACT,MAAM,EACP,MAAM,eAAe,CAAC;AAMvB,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AAE9B;kFACkF;AAClF,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,gBAAgB,CAC3B,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAE1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFP,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,uBAAuB;IAM7C,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IA6FjE,4EAA4E;YAC9D,WAAW;CAW1B"}

package/dist/blue-green-rebuild.js

@@ -1,4 +1,4 @@
-import { buildCollectionSchema } from './collection-schema.js';
+import { buildCollectionDefinition } from './collection-definition.js';
 import { BatchImporter } from './import.js';
 import { httpStatus, openLockedRun, releaseLock } from './lock.js';
 import { SOURCE_FIELD, sourceDocumentsFilter } from './sweep.js';
@@ -42,19 +42,19 @@ export class BlueGreenRebuild {
         assertNoReservedFields(searchType, [SOURCE_FIELD]);
     }
     async openRun(context) {
-        const { name, batchSize, lockTtlMs, schemaOptions } = resolveRebuildOptions(this.options);
+        const { name, batchSize, lockTtlMs, definitionOptions } = resolveRebuildOptions(this.options);
         return openLockedRun(this.client, name, lockTtlMs, async () => {
             // Create the fresh (blue) collection up front, so a failure surfaces
             // before any dataset is processed. startedAt orders the versioned names;
             // concurrent same-name runs are excluded by the lock.
             const collection = `${name}_${Date.parse(context.startedAt)}`;
             const previous = await this.aliasTarget(name);
-            const schema = buildCollectionSchema(this.searchType, schemaOptions);
+            const definition = buildCollectionDefinition(this.searchType, definitionOptions);
             await this.client.collections().create({
-                ...schema,
+                ...definition,
                 name: collection,
                 fields: [
-                    ...(schema.fields ?? []),
+                    ...(definition.fields ?? []),
                     { name: SOURCE_FIELD, type: 'string' },
                 ],
             });

package/dist/{collection-schema.d.ts → collection-definition.d.ts}

@@ -1,11 +1,11 @@
 import type { CollectionCreateSchema } from 'typesense';
 import { type SearchType } from '@lde/search';
 /** Deployment-specific options the generic field model does not carry. */
-export interface CollectionSchemaOptions {
+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;
@@ -15,7 +15,7 @@ export interface CollectionSchemaOptions {
     readonly synonymSets?: readonly string[];
 }
 /**
- * Build a Typesense collection schema from the unified {@link SearchType}, so
+ * Build a Typesense collection definition from the unified {@link SearchType}, so
  * the index and the projection are driven by one declarative source and cannot
  * drift. Each field fans out into the same physical fields the projection writes
  * ({@link physicalFields}); the Typesense field type is derived from the field
@@ -29,11 +29,12 @@ export interface CollectionSchemaOptions {
  * 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 buildCollectionSchema(searchType: SearchType, options: CollectionSchemaOptions): CollectionCreateSchema;
-//# sourceMappingURL=collection-schema.d.ts.map
+export declare function buildCollectionDefinition(searchType: SearchType, options: CollectionDefinitionOptions): CollectionCreateSchema;
+//# sourceMappingURL=collection-definition.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,2BAA2B,GACnC,sBAAsB,CAexB"}

package/dist/{collection-schema.js → collection-definition.js}

@@ -1,6 +1,6 @@
-import { physicalFields } from '@lde/search/adapter';
+import { displayFieldPattern, physicalFields } from '@lde/search/adapter';
 /**
- * Build a Typesense collection schema from the unified {@link SearchType}, so
+ * Build a Typesense collection definition from the unified {@link SearchType}, so
  * the index and the projection are driven by one declarative source and cannot
  * drift. Each field fans out into the same physical fields the projection writes
  * ({@link physicalFields}); the Typesense field type is derived from the field
@@ -14,13 +14,14 @@ 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 buildCollectionSchema(searchType, options) {
+export function buildCollectionDefinition(searchType, options) {
     const { defaultLocale } = options;
     const collection = {
         name: options.name,
@@ -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/in-place-rebuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-place-rebuild.d.ts","sourceRoot":"","sources":["../src/in-place-rebuild.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACT,MAAM,EACP,MAAM,eAAe,CAAC;AAYvB,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AAa9B;gCACgC;AAChC,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC3D;sEACkE;IAClE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,cAAc,CACzB,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAE1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFP,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,qBAAqB;IAK3C,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IAuFjE;;;;;;OAMG;YACW,cAAc;CAsB7B"}
+{"version":3,"file":"in-place-rebuild.d.ts","sourceRoot":"","sources":["../src/in-place-rebuild.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACT,MAAM,EACP,MAAM,eAAe,CAAC;AAYvB,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AAa9B;gCACgC;AAChC,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC3D;sEACkE;IAClE,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,cAAc,CACzB,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAE1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFP,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,qBAAqB;IAK3C,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IA0FjE;;;;;;OAMG;YACW,cAAc;CAsB7B"}

package/dist/in-place-rebuild.js

@@ -1,4 +1,4 @@
-import { buildCollectionSchema } from './collection-schema.js';
+import { buildCollectionDefinition } from './collection-definition.js';
 import { BatchImporter } from './import.js';
 import { ensureCollectionExists, openLockedRun, releaseLock } from './lock.js';
 import { LAST_SEEN_FIELD, SOURCE_FIELD, departedSources, membershipSweepFilters, staleDocumentsFilter, thisRunDocumentsFilter, } from './sweep.js';
@@ -58,20 +58,20 @@ export class InPlaceRebuild {
     }
     async openRun(context) {
         const { maxSweepableSources = DEFAULT_MAX_SWEEPABLE_SOURCES, ...rebuildOptions } = this.options;
-        const { name, batchSize, lockTtlMs, schemaOptions } = resolveRebuildOptions(rebuildOptions);
+        const { name, batchSize, lockTtlMs, definitionOptions } = resolveRebuildOptions(rebuildOptions);
         return openLockedRun(this.client, name, lockTtlMs, async () => {
             // Create the collection on demand: SearchType schema + the bookkeeping
             // fields, `source` faceted so the membership sweep can enumerate the
             // distinct sources.
             await ensureCollectionExists(this.client, name, () => {
-                const schema = buildCollectionSchema(this.searchType, schemaOptions);
+                const definition = buildCollectionDefinition(this.searchType, definitionOptions);
                 const bookkeeping = [
                     { name: SOURCE_FIELD, type: 'string', facet: true },
                     { name: LAST_SEEN_FIELD, type: 'string' },
                 ];
                 return {
-                    ...schema,
-                    fields: [...(schema.fields ?? []), ...bookkeeping],
+                    ...definition,
+                    fields: [...(definition.fields ?? []), ...bookkeeping],
                 };
             });
             const importer = new BatchImporter(this.client, name, batchSize);

package/dist/index.d.ts

@@ -4,8 +4,8 @@ export { InPlaceRebuild } from './in-place-rebuild.js';
 export type { InPlaceRebuildOptions } from './in-place-rebuild.js';
 export { RebuildAlreadyRunning } from './lock.js';
 export { departedSources, membershipSweepFilters, sourceDocumentsFilter, staleDocumentsFilter, } from './sweep.js';
-export { buildCollectionSchema } from './collection-schema.js';
-export type { CollectionSchemaOptions } from './collection-schema.js';
+export { buildCollectionDefinition } from './collection-definition.js';
+export type { CollectionDefinitionOptions } from './collection-definition.js';
 export { buildSearchParams } from './query-compiler.js';
 export type { BuildSearchParamsOptions } from './query-compiler.js';
 export { createTypesenseSearchEngine, parseSearchResponse } from './search.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,YAAY,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC/E,YAAY,EACV,4BAA4B,EAC5B,uBAAuB,GACxB,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,YAAY,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,YAAY,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC/E,YAAY,EACV,4BAA4B,EAC5B,uBAAuB,GACxB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -2,6 +2,6 @@ export { BlueGreenRebuild } from './blue-green-rebuild.js';
 export { InPlaceRebuild } from './in-place-rebuild.js';
 export { RebuildAlreadyRunning } from './lock.js';
 export { departedSources, membershipSweepFilters, sourceDocumentsFilter, staleDocumentsFilter, } from './sweep.js';
-export { buildCollectionSchema } from './collection-schema.js';
+export { buildCollectionDefinition } from './collection-definition.js';
 export { buildSearchParams } from './query-compiler.js';
 export { createTypesenseSearchEngine, parseSearchResponse } from './search.js';

package/dist/rebuild-support.d.ts

@@ -1,23 +1,23 @@
 import type { Client } from 'typesense';
 import type { SearchType } from '@lde/search';
-import type { CollectionSchemaOptions } from './collection-schema.js';
+import type { CollectionDefinitionOptions } from './collection-definition.js';
 /**
- * The tuning knobs both rebuild writers share, on top of the collection-schema
+ * The tuning knobs both rebuild writers share, on top of the collection-definition
  * options. Each writer may add its own (In-place adds `maxSweepableSources`).
  */
-export interface RebuildOptions extends CollectionSchemaOptions {
+export interface RebuildOptions extends CollectionDefinitionOptions {
     /** Documents imported per Typesense request (default 1000). */
     readonly batchSize?: number;
     /** A held lock older than this (ms) is reclaimed (default 10 minutes). */
     readonly lockTtlMs?: number;
 }
 /** The shared options resolved to concrete values plus the residual
- *  collection-schema options a writer passes to {@link buildCollectionSchema}. */
+ *  collection-definition options a writer passes to {@link buildCollectionDefinition}. */
 export interface ResolvedRebuildOptions {
     readonly name: string;
     readonly batchSize: number;
     readonly lockTtlMs: number;
-    readonly schemaOptions: CollectionSchemaOptions;
+    readonly definitionOptions: CollectionDefinitionOptions;
 }
 /** Apply the shared defaults, once, so neither writer restates them. */
 export declare function resolveRebuildOptions(options: RebuildOptions): ResolvedRebuildOptions;

package/dist/rebuild-support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rebuild-support.d.ts","sourceRoot":"","sources":["../src/rebuild-support.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAItE;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,uBAAuB;IAC7D,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;kFACkF;AAClF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,uBAAuB,CAAC;CACjD;AAED,wEAAwE;AACxE,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,cAAc,GACtB,sBAAsB,CAOxB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,IAAI,CAWN;AAED,4EAA4E;AAC5E,wBAAuB,cAAc,CAAC,SAAS,EAC7C,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,EACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACtC,aAAa,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAInD;AAED,mEAAmE;AACnE,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAKf"}
+{"version":3,"file":"rebuild-support.d.ts","sourceRoot":"","sources":["../src/rebuild-support.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAI9E;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,2BAA2B;IACjE,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;0FAC0F;AAC1F,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,iBAAiB,EAAE,2BAA2B,CAAC;CACzD;AAED,wEAAwE;AACxE,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,cAAc,GACtB,sBAAsB,CAYxB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,IAAI,CAWN;AAED,4EAA4E;AAC5E,wBAAuB,cAAc,CAAC,SAAS,EAC7C,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,EACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACtC,aAAa,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAInD;AAED,mEAAmE;AACnE,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAKf"}

package/dist/rebuild-support.js

@@ -2,8 +2,13 @@ import { DEFAULT_LOCK_TTL_MS } from './lock.js';
 import { DEFAULT_BATCH_SIZE } from './import.js';
 /** Apply the shared defaults, once, so neither writer restates them. */
 export function resolveRebuildOptions(options) {
-    const { batchSize = DEFAULT_BATCH_SIZE, lockTtlMs = DEFAULT_LOCK_TTL_MS, ...schemaOptions } = options;
-    return { name: schemaOptions.name, batchSize, lockTtlMs, schemaOptions };
+    const { batchSize = DEFAULT_BATCH_SIZE, lockTtlMs = DEFAULT_LOCK_TTL_MS, ...definitionOptions } = options;
+    return {
+        name: definitionOptions.name,
+        batchSize,
+        lockTtlMs,
+        definitionOptions,
+    };
 }
 /**
  * Reject a {@link SearchType} that declares any of the bookkeeping field names

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,25 +17,25 @@ 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];
         if (collection === undefined) {
             throw new Error(`No collection configured for search type “${searchType.name}”; set options.collections.${searchType.name}.`);
         }
-        return [searchType.type, collection];
+        return [searchType.class, collection];
     }));
     // Resolve every reference field's label source ONCE at construction. The
     // schema already guarantees the named type exists and serves labels
     // (`searchSchema`/`labelFieldOf`), and `collections` is exhaustive per type.
     const typesByName = new Map([...schema.values()].map((searchType) => [searchType.name, searchType]));
     const labelSources = new Map([...schema.values()].map((searchType) => [
-        searchType.type,
+        searchType.class,
         new Map(referenceFields(searchType)
             .filter((field) => field.labelSource !== undefined)
             .map((field) => {
@@ -44,7 +44,7 @@ export function createTypesenseSearchEngine(client, schema, options) {
             return [
                 field.name,
                 {
-                    collection: collections.get(source.type),
+                    collection: collections.get(source.class),
                     labelField,
                     queryBy: physicalFields(labelField).search.join(','),
                 },
@@ -63,9 +63,9 @@ export function createTypesenseSearchEngine(client, schema, options) {
     // resolved label source – fixed at construction, so labelLookupGroups need
     // not re-derive or re-resolve them on every search.
     const outputReferenceSources = new Map([...schema.values()].map((searchType) => {
-        const sources = labelSources.get(searchType.type);
+        const sources = labelSources.get(searchType.class);
         return [
-            searchType.type,
+            searchType.class,
             referenceFields(searchType)
                 .filter((field) => field.output === true && sources?.has(field.name))
                 .map((field) => ({
@@ -129,14 +129,14 @@ export function createTypesenseSearchEngine(client, schema, options) {
     // cannot leave an unhandled rejection behind if the search itself fails.
     // `undefined` when the cache is off or the type has no label sources.
     function startCachedLabels(searchType) {
-        const sources = distinctLabelSources.get(searchType.type);
+        const sources = distinctLabelSources.get(searchType.class);
         if (options.labelCacheTtlMs === undefined ||
             sources === undefined ||
             sources.length === 0) {
             return undefined;
         }
         const ttlMs = options.labelCacheTtlMs;
-        return Promise.all(sources.map((source) => cachedAllLabels(source, ttlMs))).then((maps) => mergeCachedLabels(searchType.type, maps));
+        return Promise.all(sources.map((source) => cachedAllLabels(source, ttlMs))).then((maps) => mergeCachedLabels(searchType.class, maps));
     }
     // Labels are supplementary: a failed lookup (e.g. a label-source collection
     // mid-rebuild) degrades to id-only references rather than failing the whole
@@ -165,10 +165,10 @@ export function createTypesenseSearchEngine(client, schema, options) {
             const params = buildSearchParams(query, searchType, options);
             const cachedLabelsPromise = startCachedLabels(searchType);
             const response = (await client
-                .collections(collections.get(searchType.type))
+                .collections(collections.get(searchType.class))
                 .documents()
                 .search(params));
-            const labels = await resolveLabels(cachedLabelsPromise, () => labelLookupGroups([response], labelSources.get(searchType.type), outputReferenceSources.get(searchType.type) ?? []));
+            const labels = await resolveLabels(cachedLabelsPromise, () => labelLookupGroups([response], labelSources.get(searchType.class), outputReferenceSources.get(searchType.class) ?? []));
             return parseSearchResponse(response, searchType, labels);
         },
         async searchFacets(searchType, queries) {
@@ -179,7 +179,7 @@ export function createTypesenseSearchEngine(client, schema, options) {
             if (queries.length === 0) {
                 return [];
             }
-            const collection = collections.get(searchType.type);
+            const collection = collections.get(searchType.class);
             const cachedLabelsPromise = startCachedLabels(searchType);
             // The whole batch travels as ONE multi_search round-trip. Each query
             // compiles as facet-only regardless of what it carries: no hits
@@ -193,7 +193,7 @@ export function createTypesenseSearchEngine(client, schema, options) {
             }));
             // One label lookup serves every successful facet result in the batch.
             const responses = results.filter((result) => !('error' in result));
-            const labels = await resolveLabels(cachedLabelsPromise, () => labelLookupGroups(responses, labelSources.get(searchType.type), outputReferenceSources.get(searchType.type) ?? []));
+            const labels = await resolveLabels(cachedLabelsPromise, () => labelLookupGroups(responses, labelSources.get(searchType.class), outputReferenceSources.get(searchType.class) ?? []));
             // multi_search reports a failed entry inline instead of rejecting the
             // call; pass that through as a per-query outcome – naming the facets,
             // not the position, since the batch order is the caller's internal –
@@ -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.7.1",
+  "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.5.0",
+    "@lde/search": "^0.7.0",
     "@lde/text-normalization": "^0.1.1",
     "tslib": "^2.3.0",
     "typesense": "^3.0.6"

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

@@ -1 +0,0 @@
-{"version":3,"file":"collection-schema.d.ts","sourceRoot":"","sources":["../src/collection-schema.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,uBAAuB;IACtC,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,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,uBAAuB,GAC/B,sBAAsB,CAexB"}