@lde/search-typesense 0.37.0 → 0.38.0

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

@@ -20,6 +20,9 @@ export type BlueGreenRebuildOptions = RebuildOptions;
  *   derived from the {@link SearchType}.
  * - `write` streams documents into the fresh collection, batched across write
  *   calls, each recording the dataset it came from ({@link openDocuments}).
+ * - `write` leaves out a document Typesense refuses or that lacks a required
+ *   field; `flush` reports those through {@link RunContext.itemsRejected} and
+ *   fails the dataset when they exceed `maxRejectedShare`.
  * - `flush` on a **failed** dataset, and `reset` (the pipeline’s dump-fallback
  *   discard), roll that dataset back out of the not-yet-live collection, so a
  *   swap never ships a half-processed dataset; a successful flush leaves the

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;AASvB,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAE9B;;yDAEyD;AACzD,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,gBAAgB,CAC3B,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAa1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAb7B;;;;;;;OAOG;IACH,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;gBAG/B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACvC,OAAO,GAAE,uBAA4B;IAUjC,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IAsGjE,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;AASvB,OAAO,EAGL,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAE9B;;yDAEyD;AACzD,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,gBAAgB,CAC3B,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAa1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAb7B;;;;;;;OAOG;IACH,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;gBAG/B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACvC,OAAO,GAAE,uBAA4B;IAUjC,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IA2HjE,4EAA4E;YAC9D,WAAW;CAW1B"}

package/dist/blue-green-rebuild.js

@@ -1,7 +1,7 @@
 import { buildCollectionDefinition } from './collection-definition.js';
 import { httpStatus, openLockedRun, releaseLock } from './lock.js';
 import { assertWritableType, openDocuments, withBookkeeping, } from './documents.js';
-import { resolveRebuildOptions, } from './rebuild-support.js';
+import { resolveRebuildOptions, settleDataset, } from './rebuild-support.js';
 /**
  * Blue/green Rebuild (build a fresh index alongside the live one, then swap to
  * it atomically) as a transactional `Writer`: each run builds the search
@@ -16,6 +16,9 @@ import { resolveRebuildOptions, } from './rebuild-support.js';
  *   derived from the {@link SearchType}.
  * - `write` streams documents into the fresh collection, batched across write
  *   calls, each recording the dataset it came from ({@link openDocuments}).
+ * - `write` leaves out a document Typesense refuses or that lacks a required
+ *   field; `flush` reports those through {@link RunContext.itemsRejected} and
+ *   fails the dataset when they exceed `maxRejectedShare`.
  * - `flush` on a **failed** dataset, and `reset` (the pipeline’s dump-fallback
  *   discard), roll that dataset back out of the not-yet-live collection, so a
  *   swap never ships a half-processed dataset; a successful flush leaves the
@@ -58,7 +61,7 @@ export class BlueGreenRebuild {
             this.resolved.definitionOptions.collectionNameFor(searchType);
     }
     async openRun(context) {
-        const { batchSize, lockTtlMs, definitionOptions } = this.resolved;
+        const { batchSize, lockTtlMs, maxRejectedShare, definitionOptions } = this.resolved;
         const name = this.collectionName;
         return openLockedRun(this.client, name, lockTtlMs, async () => {
             // Create the fresh (blue) collection up front, so a failure surfaces
@@ -89,6 +92,7 @@ export class BlueGreenRebuild {
                 runId: context.runId,
                 startedAt: context.startedAt,
                 batchSize,
+                schema: definitionOptions.schema,
             });
             // Roll a dataset back out of the not-yet-live collection (a failed
             // dataset, or a reset before the dump re-run). On a keyed collection
@@ -99,12 +103,25 @@ export class BlueGreenRebuild {
                 write: async (dataset, items) => documents.add(dataset, items),
                 flush: async (dataset, outcome) => {
                     // A successful dataset keeps its streamed documents (they go live at
-                    // the swap); a failed one is rolled back so the swap never ships it.
+                    // the swap); a failed one – or one that left too much out – is
+                    // rolled back so the swap never ships it.
+                    try {
+                        await settleDataset(documents, dataset, outcome, context, this.searchType, maxRejectedShare);
+                    }
+                    catch (error) {
+                        await rollback(dataset);
+                        throw error;
+                    }
                     if (outcome !== 'success') {
                         await rollback(dataset);
                     }
                 },
-                reset: async (dataset) => rollback(dataset),
+                reset: async (dataset) => {
+                    // The re-run writes the dataset afresh, so what this attempt left
+                    // out is no longer the dataset’s to answer for.
+                    await documents.settle(dataset);
+                    await rollback(dataset);
+                },
                 commit: async () => {
                     await documents.flush();
                     // The alias swap is the commit point: once it lands the new

package/dist/documents.d.ts

@@ -1,6 +1,7 @@
 import type { Client, CollectionCreateSchema } from 'typesense';
 import type { CollectionFieldSchema } from 'typesense/lib/Typesense/Collection.js';
 import type { Dataset } from '@lde/dataset';
+import type { ItemsRejected } from '@lde/pipeline';
 import type { SearchSchema, SearchType } from '@lde/search';
 /**
  * Default ceiling on the distinct datasets a collection may hold before the
@@ -19,6 +20,9 @@ export interface RunDocumentsOptions {
     readonly startedAt: string;
     /** Documents per Typesense import request. */
     readonly batchSize: number;
+    /** The schema the type belongs to, which a required field of an inline
+     *  reference’s referent is declared in. */
+    readonly schema?: SearchSchema;
     /** Most distinct datasets {@link RunDocuments.dropUnselected} may enumerate
      *  before it throws rather than risk missing one that left. */
     readonly maxSweepableSources?: number;
@@ -36,10 +40,21 @@ export interface RunDocumentsOptions {
 export interface RunDocuments<TDocument extends {
     id: string;
 }> {
-    /** Write a dataset’s documents, batched. */
+    /**
+     * Write a dataset’s documents, batched. A document Typesense refuses, or
+     * that lacks a required field Typesense cannot check
+     * ({@link missingRequiredFields}), is left out and counted against its
+     * dataset rather than failing the write – see {@link settle}.
+     */
     add(dataset: Dataset, documents: AsyncIterable<TDocument>): Promise<void>;
     /** Land whatever is still buffered. */
     flush(): Promise<void>;
+    /**
+     * Land whatever is still buffered and account for the dataset’s documents
+     * since it was last settled: how many it wrote, and which were left out and
+     * why. Starts the dataset’s count afresh.
+     */
+    settle(dataset: Dataset): Promise<DatasetWrites>;
     /**
      * Drop what this dataset had and this run did not rewrite – the sweep after
      * a dataset succeeds. A document another dataset still references survives,
@@ -63,6 +78,9 @@ export interface RunDocuments<TDocument extends {
      */
     dropUnselected(selectedDatasets: Iterable<string>): Promise<void>;
 }
+/** A dataset’s documents in one collection, as {@link RunDocuments.settle}
+ *  counts them. */
+export type DatasetWrites = Omit<ItemsRejected, 'target'>;
 /**
  * Open a run’s documents on a collection.
  *

package/dist/documents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../src/documents.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAY,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAmCtE;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAEpD,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;qCACiC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;mEAC+D;IAC/D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY,CAAC,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE;IAC5D,4CAA4C;IAC5C,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,uCAAuC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;;;OAGG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,yEAAyE;IACzE,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC;;;;;;;OAOG;IACH,cAAc,CAAC,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC5D,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC3B,YAAY,CAAC,SAAS,CAAC,CAIzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,sBAAsB,EAClC,UAAU,EAAE,UAAU,GACrB,sBAAsB,CA4BxB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE;IACP,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;CAChC,GACA,IAAI,CAoDN;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,SAAS,qBAAqB,EAAE,EAC1C,UAAU,EAAE,MAAM,GACjB,IAAI,CAWN"}
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../src/documents.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAAY,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA2CtE;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAEpD,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;qCACiC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;+CAC2C;IAC3C,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;IAC/B;mEAC+D;IAC/D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY,CAAC,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE;IAC5D;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,uCAAuC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACjD;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;;;OAGG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,yEAAyE;IACzE,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC;;;;;;;OAOG;IACH,cAAc,CAAC,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE;AAED;mBACmB;AACnB,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC5D,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC3B,YAAY,CAAC,SAAS,CAAC,CAIzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,sBAAsB,EAClC,UAAU,EAAE,UAAU,GACrB,sBAAsB,CA4BxB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE;IACP,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;CAChC,GACA,IAAI,CAoDN;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,SAAS,qBAAqB,EAAE,EAC1C,UAAU,EAAE,MAAM,GACjB,IAAI,CAWN"}

package/dist/documents.js

@@ -3,7 +3,7 @@
 // and the two regimes a collection can be in – a document belongs to one
 // dataset, or several reference it – so a writer states *what* should go and
 // never *how* it is stored.
-import { datasetField, isInternalField, physicalFields, } from '@lde/search/adapter';
+import { datasetField, isInternalField, missingRequiredFields, physicalFields, } from '@lde/search/adapter';
 import { escapeFilterValue } from './query-compiler.js';
 /** The private field carrying the dataset IRI a document came from, in a
  *  collection whose documents each belong to one dataset. */
@@ -25,6 +25,11 @@ const LOOKUP_BATCH = 200;
 const MAX_SEARCHES_PER_REQUEST = 50;
 /** Stay well under Typesense’s ~4000-char URL query-string limit per delete. */
 const MAX_FILTER_VALUES_LENGTH = 3000;
+/** Distinct rejection reasons kept per dataset; the rest are counted under
+ *  one, so a reason that varies per document cannot grow the tally unbounded. */
+const MAX_REJECTION_REASONS = 10;
+/** Ids kept per rejection reason, as examples to look up. */
+const MAX_REJECTION_EXAMPLES = 3;
 /**
  * Default ceiling on the distinct datasets a collection may hold before the
  * membership sweep refuses to guess. The sweep needs the complete set to spot
@@ -204,13 +209,21 @@ function ownedDocuments(client, collection, options) {
     const { searchType, runId, batchSize } = options;
     const field = provenanceFieldOf(searchType);
     const buffer = new Batch(batchSize);
+    const writes = new WriteTally();
     const run = escapeFilterValue(runId);
     const of = (dataset) => `${field}:=${escapeFilterValue(dataset.iri.toString())}`;
     const land = async () => {
         const batch = buffer.take();
-        if (batch.length > 0) {
-            await importDocuments(client, collection, batch, 'upsert');
+        if (batch.length === 0) {
+            return;
         }
+        const errors = await upsertDocuments(client, collection, batch);
+        errors.forEach((error, index) => {
+            if (error !== undefined) {
+                const document = batch[index];
+                writes.reject(String(document[field]), String(document.id), error);
+            }
+        });
     };
     const drop = async (filter) => {
         await land();
@@ -230,18 +243,25 @@ function ownedDocuments(client, collection, options) {
         // unprojected is sweepable but not full-text findable by dataset: absent,
         // never wrong.
         add: async (dataset, documents) => {
+            const iri = dataset.iri.toString();
             const stamp = {
-                [field]: dataset.iri.toString(),
+                [field]: iri,
                 [LAST_SEEN_FIELD]: runId,
             };
             for await (const document of documents) {
-                buffer.push({ ...document, ...stamp });
-                if (buffer.full()) {
-                    await land();
+                if (writes.admit(iri, document, searchType, options.schema)) {
+                    buffer.push({ ...document, ...stamp });
+                    if (buffer.full()) {
+                        await land();
+                    }
                 }
             }
         },
         flush: land,
+        settle: async (dataset) => {
+            await land();
+            return writes.take(dataset.iri.toString());
+        },
         dropUnwritten: async (dataset) => drop(`${of(dataset)} && ${LAST_SEEN_FIELD}:!=${run}`),
         dropWrittenThisRun: async (dataset) => drop(`${of(dataset)} && ${LAST_SEEN_FIELD}:=${run}`),
         dropAll: async (dataset) => drop(of(dataset)),
@@ -261,7 +281,8 @@ function ownedDocuments(client, collection, options) {
  * referencing.
  */
 function sharedDocuments(client, collection, options) {
-    const { batchSize } = options;
+    const { searchType, batchSize } = options;
+    const writes = new WriteTally();
     const run = Date.parse(options.startedAt);
     const facet = `${REFERENCED_BY_FIELD}.dataset`;
     const buffer = new Batch(batchSize);
@@ -280,6 +301,8 @@ function sharedDocuments(client, collection, options) {
         // Two nodes of one dataset, or two datasets, can key onto one document
         // within a single batch. Later content wins, as a merged document always
         // does – but membership is the union, or the second would erase the first.
+        // `writes` keeps every dataset a write came from, repeats included, so a
+        // refusal counts once per document the datasets wrote – as `admit` did.
         const merged = new Map();
         for (const { document, dataset } of batch) {
             const seen = merged.get(document.id);
@@ -290,18 +313,29 @@ function sharedDocuments(client, collection, options) {
                     : seen.datasets.includes(dataset)
                         ? seen.datasets
                         : [...seen.datasets, dataset],
+                writes: [...(seen?.writes ?? []), dataset],
             });
         }
         const stored = await storedMembership(client, collection, [
             ...merged.keys(),
         ]);
-        await importDocuments(client, collection, [...merged.values()].map(({ document, datasets }) => ({
+        const entries = [...merged.values()];
+        const errors = await upsertDocuments(client, collection, entries.map(({ document, datasets }) => ({
             ...document,
             [REFERENCED_BY_FIELD]: [
                 ...(stored.get(document.id) ?? []).filter((referrer) => !datasets.includes(referrer.dataset)),
                 ...datasets.map((dataset) => ({ dataset, run })),
             ],
-        })), 'upsert');
+        })));
+        // A refused document is refused for every write merged into it.
+        errors.forEach((error, index) => {
+            if (error !== undefined) {
+                const { document, writes: merges } = entries[index];
+                for (const dataset of merges) {
+                    writes.reject(dataset, document.id, error);
+                }
+            }
+        });
     };
     /**
      * Take the datasets out of every document the filter selects, deleting the
@@ -349,7 +383,7 @@ function sharedDocuments(client, collection, options) {
                 throw new Error(`Retracting ${datasets.join(', ')} from “${collection}” selected ${hits.length} document(s) carrying none of them, so the sweep cannot make progress.`);
             }
             if (keeping.length > 0) {
-                await importDocuments(client, collection, keeping, 'update');
+                await updateDocuments(client, collection, keeping);
             }
             for (const chunk of chunked(emptied.map(escapeFilterValue))) {
                 await deleteByFilter(client, collection, `id:=[${chunk.join(',')}]`);
@@ -360,13 +394,19 @@ function sharedDocuments(client, collection, options) {
         add: async (dataset, documents) => {
             const iri = dataset.iri.toString();
             for await (const document of documents) {
-                buffer.push({ document, dataset: iri });
-                if (buffer.full()) {
-                    await land();
+                if (writes.admit(iri, document, searchType, options.schema)) {
+                    buffer.push({ document, dataset: iri });
+                    if (buffer.full()) {
+                        await land();
+                    }
                 }
             }
         },
         flush: land,
+        settle: async (dataset) => {
+            await land();
+            return writes.take(dataset.iri.toString());
+        },
         dropUnwritten: async (dataset) => {
             const iri = dataset.iri.toString();
             await retract(`${REFERENCED_BY_FIELD}.{dataset:=${escapeFilterValue(iri)} && run:<${run}}`, [iri]);
@@ -494,24 +534,106 @@ class Batch {
     }
 }
 /**
- * Import one batch, throwing if any individual document fails – Typesense’s
- * bulk import otherwise reports per-document failures without rejecting, which
- * would turn a rejected write into silently missing data.
+ * Each dataset’s documents since it was last settled: how many it wrote, and
+ * which were left out and why. Bounded per dataset by
+ * {@link MAX_REJECTION_REASONS} and {@link MAX_REJECTION_EXAMPLES}, however
+ * many documents are rejected.
+ */
+class WriteTally {
+    datasets = new Map();
+    /**
+     * Count a document the dataset wrote, answering whether it may be imported:
+     * one lacking a required field is rejected here, before Typesense sees it.
+     */
+    admit(dataset, document, searchType, schema) {
+        this.of(dataset).written += 1;
+        const missing = missingRequiredFields(document, searchType, schema);
+        if (missing.length === 0) {
+            return true;
+        }
+        this.reject(dataset, document.id, `missing required ${missing.length === 1 ? 'field' : 'fields'} ${missing
+            .map((name) => `“${name}”`)
+            .join(', ')}`);
+        return false;
+    }
+    /** Count a document of the dataset as left out, for `reason`. */
+    reject(dataset, id, reason) {
+        const tally = this.of(dataset);
+        tally.rejected += 1;
+        const key = tally.reasons.has(reason) || tally.reasons.size < MAX_REJECTION_REASONS
+            ? reason
+            : 'other reasons';
+        const entry = tally.reasons.get(key) ?? { count: 0, examples: [] };
+        entry.count += 1;
+        if (entry.examples.length < MAX_REJECTION_EXAMPLES) {
+            entry.examples.push(id);
+        }
+        tally.reasons.set(key, entry);
+    }
+    /** The dataset’s count, most frequent reason first, starting it afresh. */
+    take(dataset) {
+        const tally = this.datasets.get(dataset);
+        this.datasets.delete(dataset);
+        const reasons = [...(tally?.reasons ?? [])]
+            .map(([reason, { count, examples }]) => ({ reason, count, examples }))
+            .sort((left, right) => right.count - left.count);
+        return {
+            written: tally?.written ?? 0,
+            rejected: tally?.rejected ?? 0,
+            reasons,
+        };
+    }
+    of(dataset) {
+        let tally = this.datasets.get(dataset);
+        if (tally === undefined) {
+            tally = { written: 0, rejected: 0, reasons: new Map() };
+            this.datasets.set(dataset, tally);
+        }
+        return tally;
+    }
+}
+/**
+ * Upsert one batch, answering each document Typesense refused with its error –
+ * `undefined` for one written – in batch order. Typesense writes the valid
+ * documents of a batch and reports the rest per document without rejecting,
+ * so a caller that ignored the answer would turn a refusal into silently
+ * missing data.
+ *
+ * Only a client error (4xx) refuses the document itself. Any other failure –
+ * the engine out of memory or disk, not ready – says nothing about the data,
+ * so it throws: counted as a rejection, it would let a dataset succeed short
+ * of documents, and an In-place sweep then delete their indexed versions.
  */
-async function importDocuments(client, collection, batch, action) {
-    const results = (await client
+async function upsertDocuments(client, collection, batch) {
+    const results = await importBatch(client, collection, batch, 'upsert');
+    const failed = results.find((result) => !result.success && !(result.code >= 400 && result.code < 500));
+    if (failed !== undefined && !failed.success) {
+        throw new Error(`Typesense upsert into “${collection}” failed: ${failed.error} (HTTP ${failed.code})`);
+    }
+    return results.map((result) => (result.success ? undefined : result.error));
+}
+/**
+ * Update one batch, throwing if any document fails. An update only rewrites
+ * bookkeeping on documents already stored, so a refusal means broken
+ * bookkeeping, not bad source data, and must not be skipped.
+ */
+async function updateDocuments(client, collection, batch) {
+    const results = await importBatch(client, collection, batch, 'update');
+    const failures = results.flatMap((result) => result.success ? [] : [result.error]);
+    if (failures.length > 0) {
+        throw new Error(`Typesense update into “${collection}” failed for ${failures.length}/${results.length} documents: ${failures.join('; ')}`);
+    }
+}
+/** Import one batch, answering Typesense’s result per document in batch
+ *  order. */
+async function importBatch(client, collection, batch, action) {
+    return (await client
         .collections(collection)
         .documents()
         .import(batch, {
         action,
         throwOnFail: false,
     }));
-    const failures = results.filter((result) => !result.success);
-    if (failures.length > 0) {
-        throw new Error(`Typesense ${action} into “${collection}” failed for ${failures.length}/${results.length} documents: ${failures
-            .map((failure) => failure.error)
-            .join('; ')}`);
-    }
 }
 /** A whole-collection search; `q: '*'` needs no field to query by. */
 async function search(client, collection, parameters) {

package/dist/in-place-rebuild.d.ts

@@ -25,6 +25,10 @@ export interface InPlaceRebuildOptions extends RebuildOptions {
  * document several datasets share, and the document itself only with the last
  * of them:
  *
+ * - a document Typesense refuses or that lacks a required field is left out
+ *   of the write; the dataset’s **flush** reports those through
+ *   {@link RunContext.itemsRejected} and fails the dataset, unswept, when they
+ *   exceed `maxRejectedShare`;
  * - a **successful dataset flush** drops what the dataset had and this run did
  *   not rewrite. A failed dataset is not swept – its output is incomplete, and
  *   the next successful run reconciles;

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,EAAgB,UAAU,EAAE,MAAM,aAAa,CAAC;AAG5D,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACT,MAAM,EACP,MAAM,eAAe,CAAC;AASvB,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAE9B;gCACgC;AAChC,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC3D;;;;;;;OAOG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,cAAc,CACzB,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAY1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAZ7B;;;;;OAKG;IACH,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;gBAG/B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACvC,OAAO,GAAE,qBAA0B;IAe/B,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;CAuElE"}
+{"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,EAAgB,UAAU,EAAE,MAAM,aAAa,CAAC;AAG5D,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACT,MAAM,EACP,MAAM,eAAe,CAAC;AASvB,OAAO,EAGL,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAE9B;gCACgC;AAChC,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC3D;;;;;;;OAOG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,qBAAa,cAAc,CACzB,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAY1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAZ7B;;;;;OAKG;IACH,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqB;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;gBAG/B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACvC,OAAO,GAAE,qBAA0B;IAe/B,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;CAqFlE"}

package/dist/in-place-rebuild.js

@@ -2,7 +2,7 @@ import { facetableFields, physicalFields } from '@lde/search/adapter';
 import { buildCollectionDefinition } from './collection-definition.js';
 import { ensureCollectionExists, openLockedRun, releaseLock } from './lock.js';
 import { assertBookkeepingPresent, assertWritableType, openDocuments, withBookkeeping, } from './documents.js';
-import { resolveRebuildOptions, } from './rebuild-support.js';
+import { resolveRebuildOptions, settleDataset, } from './rebuild-support.js';
 /**
  * In-place Rebuild (update the live index directly – upsert changed sources,
  * sweep the rest – rather than swap in a fresh one) as a transactional
@@ -13,6 +13,10 @@ import { resolveRebuildOptions, } from './rebuild-support.js';
  * document several datasets share, and the document itself only with the last
  * of them:
  *
+ * - a document Typesense refuses or that lacks a required field is left out
+ *   of the write; the dataset’s **flush** reports those through
+ *   {@link RunContext.itemsRejected} and fails the dataset, unswept, when they
+ *   exceed `maxRejectedShare`;
  * - a **successful dataset flush** drops what the dataset had and this run did
  *   not rewrite. A failed dataset is not swept – its output is incomplete, and
  *   the next successful run reconciles;
@@ -70,7 +74,7 @@ export class InPlaceRebuild {
             this.resolved.definitionOptions.collectionNameFor(searchType);
     }
     async openRun(context) {
-        const { batchSize, lockTtlMs, definitionOptions } = this.resolved;
+        const { batchSize, lockTtlMs, maxRejectedShare, definitionOptions } = this.resolved;
         const name = this.collectionName;
         return openLockedRun(this.client, name, lockTtlMs, async () => {
             // Create the collection on demand: the SearchType’s schema plus whatever
@@ -92,24 +96,31 @@ export class InPlaceRebuild {
                 runId: context.runId,
                 startedAt: context.startedAt,
                 batchSize,
+                schema: definitionOptions.schema,
                 maxSweepableSources: this.maxSweepableSources,
             });
             return {
                 write: async (dataset, items) => documents.add(dataset, items),
                 flush: async (dataset, outcome) => {
+                    // A dataset that left too much out fails here, unswept like any
+                    // other failed dataset.
+                    await settleDataset(documents, dataset, outcome, context, this.searchType, maxRejectedShare);
                     if (outcome !== 'success') {
                         // A failed dataset’s output is incomplete: sweeping against it
                         // would delete documents the run never got to rewrite. Leave the
-                        // stale ones for the next successful run to reconcile. The buffered
-                        // documents stay buffered; the next flush lands them.
+                        // stale ones for the next successful run to reconcile.
                         return;
                     }
                     await documents.dropUnwritten(dataset);
                 },
                 // Discard only this run’s partial writes for the dataset (the failed
                 // endpoint attempt) so the dump re-run rebuilds it cleanly; the
-                // dataset’s prior-run documents stay for the success sweep.
-                reset: async (dataset) => documents.dropWrittenThisRun(dataset),
+                // dataset’s prior-run documents stay for the success sweep. What the
+                // attempt left out is no longer the dataset’s to answer for.
+                reset: async (dataset) => {
+                    await documents.settle(dataset);
+                    await documents.dropWrittenThisRun(dataset);
+                },
                 commit: async () => {
                     await documents.flush();
                     await documents.dropUnselected(context.selectedSources());

package/dist/rebuild-support.d.ts

@@ -1,5 +1,8 @@
+import type { Dataset } from '@lde/dataset';
+import type { DatasetOutcome, RunContext } from '@lde/pipeline';
 import type { SearchType } from '@lde/search';
 import { type CollectionDefinitionOptions } from './collection-definition.js';
+import type { RunDocuments } from './documents.js';
 /**
  * The tuning knobs both rebuild writers share, on top of the collection-definition
  * options. Each writer may add its own (In-place adds `maxSweepableSources`).
@@ -9,12 +12,22 @@ export interface RebuildOptions extends CollectionDefinitionOptions {
     readonly batchSize?: number;
     /** A held lock older than this (ms) is reclaimed (default 10 minutes). */
     readonly lockTtlMs?: number;
+    /**
+     * The largest share of a dataset’s documents, from 0 to 1, this collection
+     * may leave out before the dataset fails (default 0.5). A document is left
+     * out when Typesense refuses it or it lacks a required field, and reported
+     * through {@link RunContext.itemsRejected} either way. A dataset whose every
+     * document was left out always fails, so it cannot go live empty; `0` fails
+     * a dataset on its first rejection.
+     */
+    readonly maxRejectedShare?: number;
 }
 /** The shared options resolved to concrete values plus the residual
  *  collection-definition options a writer passes to {@link buildCollectionDefinition}. */
 export interface ResolvedRebuildOptions {
     readonly batchSize: number;
     readonly lockTtlMs: number;
+    readonly maxRejectedShare: number;
     /** The collection-definition options with `collectionNameFor` resolved to a
      *  total function – the one place the naming convention lives, so the
      *  collection a writer talks to, the definition it creates and the peer
@@ -38,4 +51,19 @@ export interface ResolvedRebuildOptions {
  * been paid for.
  */
 export declare function resolveRebuildOptions(searchType: SearchType, options: RebuildOptions): ResolvedRebuildOptions;
+/**
+ * Finish a dataset’s writes to one collection: land them, report what was
+ * left out ({@link RunContext.itemsRejected}), and fail an otherwise
+ * successful dataset when more was left out than `maxRejectedShare` allows –
+ * or all of it. A dataset that already failed is only reported: its output is
+ * incomplete, so its share says nothing, and failing it twice would blame the
+ * data for what a stage did.
+ *
+ * Both writers settle at the dataset’s flush rather than leave its last
+ * partial batch for the next dataset’s writes to land, so a rejection is
+ * always counted, reported and judged against the dataset it belongs to.
+ */
+export declare function settleDataset(documents: RunDocuments<{
+    id: string;
+}>, dataset: Dataset, outcome: DatasetOutcome, context: RunContext, searchType: SearchType, maxRejectedShare: number): Promise<void>;
 //# sourceMappingURL=rebuild-support.d.ts.map

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,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,4BAA4B,CAAC;AAOpC;;;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,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;uEAGmE;IACnE,QAAQ,CAAC,iBAAiB,EAAE,2BAA2B,GAAG;QACxD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC;KAChE,CAAC;CACH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,cAAc,GACtB,sBAAsB,CAkBxB"}
+{"version":3,"file":"rebuild-support.d.ts","sourceRoot":"","sources":["../src/rebuild-support.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAUnD;;;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;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED;0FAC0F;AAC1F,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;;;uEAGmE;IACnE,QAAQ,CAAC,iBAAiB,EAAE,2BAA2B,GAAG;QACxD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC;KAChE,CAAC;CACH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,cAAc,GACtB,sBAAsB,CAyBxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CACjC,SAAS,EAAE,YAAY,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,EACvC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,IAAI,CAAC,CAsBf"}

package/dist/rebuild-support.js

@@ -4,6 +4,9 @@ import { deriveCollectionName } from './collection-name.js';
 import { DEFAULT_LOCK_TTL_MS } from './lock.js';
 /** Documents imported per Typesense request unless a writer is told otherwise. */
 const DEFAULT_BATCH_SIZE = 1000;
+/** The share of a dataset’s documents a collection may reject before the
+ *  dataset fails, unless a writer is told otherwise. */
+const DEFAULT_MAX_REJECTED_SHARE = 0.5;
 /**
  * Apply the shared defaults, once, so neither writer restates them – including
  * the collection naming, derived from each type ({@link deriveCollectionName})
@@ -19,10 +22,14 @@ const DEFAULT_BATCH_SIZE = 1000;
  * been paid for.
  */
 export function resolveRebuildOptions(searchType, options) {
-    const { batchSize = DEFAULT_BATCH_SIZE, lockTtlMs = DEFAULT_LOCK_TTL_MS, ...definitionOptions } = options;
+    const { batchSize = DEFAULT_BATCH_SIZE, lockTtlMs = DEFAULT_LOCK_TTL_MS, maxRejectedShare = DEFAULT_MAX_REJECTED_SHARE, ...definitionOptions } = options;
+    if (!(maxRejectedShare >= 0 && maxRejectedShare <= 1)) {
+        throw new Error(`maxRejectedShare must be a share from 0 to 1, got ${maxRejectedShare}.`);
+    }
     const resolved = {
         batchSize,
         lockTtlMs,
+        maxRejectedShare,
         definitionOptions: {
             ...definitionOptions,
             collectionNameFor: definitionOptions.collectionNameFor ?? deriveCollectionName,
@@ -32,6 +39,38 @@ export function resolveRebuildOptions(searchType, options) {
     buildCollectionDefinition(searchType, resolved.definitionOptions);
     return resolved;
 }
+/**
+ * Finish a dataset’s writes to one collection: land them, report what was
+ * left out ({@link RunContext.itemsRejected}), and fail an otherwise
+ * successful dataset when more was left out than `maxRejectedShare` allows –
+ * or all of it. A dataset that already failed is only reported: its output is
+ * incomplete, so its share says nothing, and failing it twice would blame the
+ * data for what a stage did.
+ *
+ * Both writers settle at the dataset’s flush rather than leave its last
+ * partial batch for the next dataset’s writes to land, so a rejection is
+ * always counted, reported and judged against the dataset it belongs to.
+ */
+export async function settleDataset(documents, dataset, outcome, context, searchType, maxRejectedShare) {
+    const writes = await documents.settle(dataset);
+    if (writes.rejected === 0) {
+        return;
+    }
+    context.itemsRejected?.(dataset, { target: searchType.name, ...writes });
+    if (outcome !== 'success') {
+        return;
+    }
+    const limit = writes.rejected === writes.written
+        ? 'every one of them'
+        : writes.rejected > writes.written * maxRejectedShare
+            ? `more than the ${Math.round(maxRejectedShare * 1000) / 10}% maxRejectedShare allows`
+            : undefined;
+    if (limit !== undefined) {
+        throw new Error(`“${searchType.name}” left out ${writes.rejected} of ${writes.written} documents of ${dataset.iri.toString()}, ${limit}: ${writes.reasons
+            .map(({ reason, count }) => `${count} × ${reason}`)
+            .join('; ')}`);
+    }
+}
 /**
  * Reject a `collectionNameFor` that gives a join target the same name as the
  * type doing the joining.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search-typesense",
-  "version": "0.37.0",
+  "version": "0.38.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.31.0",
+    "@lde/search": "^0.32.0",
     "@lde/text-normalization": "^0.2.0",
     "tslib": "^2.3.0",
     "typesense": "^3.1.1"
@@ -36,6 +36,6 @@
   },
   "peerDependencies": {
     "@lde/dataset": "^0.8.0",
-    "@lde/pipeline": "^0.38.1"
+    "@lde/pipeline": "^0.39.0"
   }
 }