@lde/search 0.37.0 → 0.38.0

package/dist/period.d.ts

@@ -53,11 +53,11 @@ export declare const OPEN_END: number;
  */
 export declare function periodOf(value: string): StoredPeriod | undefined;
 /**
- * The period several values cover between them: the earliest start and the
- * latest end, or `undefined` when none states a period. One stored range per
- * document is what an engine can sort on and compare in a single clause, so a
- * work dated `1668`, `1676` and `1686` is stored as 1668 through 1686 – and a
- * range falling between its dates still matches it.
+ * The period several periods cover between them: the earliest start and the
+ * latest end. One stored range per document is what an engine can sort on and
+ * compare in a single clause, so a work dated `1668`, `1676` and `1686` is
+ * stored as 1668 through 1686 – and a range falling between its dates still
+ * matches it.
  */
-export declare function periodOfAll(values: readonly string[]): StoredPeriod | undefined;
+export declare function periodCovering(first: StoredPeriod, ...rest: readonly StoredPeriod[]): StoredPeriod;
 //# sourceMappingURL=period.d.ts.map

package/dist/period.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"period.d.ts","sourceRoot":"","sources":["../src/period.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,QAAa,CAAC;AAErC;oCACoC;AACpC,eAAO,MAAM,QAAQ,QAAU,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAehE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,YAAY,GAAG,SAAS,CAgB1B"}
+{"version":3,"file":"period.d.ts","sourceRoot":"","sources":["../src/period.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,QAAa,CAAC;AAErC;oCACoC;AACpC,eAAO,MAAM,QAAQ,QAAU,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAehE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,YAAY,EACnB,GAAG,IAAI,EAAE,SAAS,YAAY,EAAE,GAC/B,YAAY,CAQd"}

package/dist/period.js

@@ -59,28 +59,17 @@ export function periodOf(value) {
     return start <= end && !openAtBothEnds ? { start, end } : undefined;
 }
 /**
- * The period several values cover between them: the earliest start and the
- * latest end, or `undefined` when none states a period. One stored range per
- * document is what an engine can sort on and compare in a single clause, so a
- * work dated `1668`, `1676` and `1686` is stored as 1668 through 1686 – and a
- * range falling between its dates still matches it.
+ * The period several periods cover between them: the earliest start and the
+ * latest end. One stored range per document is what an engine can sort on and
+ * compare in a single clause, so a work dated `1668`, `1676` and `1686` is
+ * stored as 1668 through 1686 – and a range falling between its dates still
+ * matches it.
  */
-export function periodOfAll(values) {
-    let covered;
-    for (const value of values) {
-        const period = periodOf(value);
-        if (period === undefined) {
-            continue;
-        }
-        covered =
-            covered === undefined
-                ? period
-                : {
-                    start: Math.min(covered.start, period.start),
-                    end: Math.max(covered.end, period.end),
-                };
-    }
-    return covered;
+export function periodCovering(first, ...rest) {
+    return rest.reduce((covered, period) => ({
+        start: Math.min(covered.start, period.start),
+        end: Math.max(covered.end, period.end),
+    }), first);
 }
 /** One side of an interval, or a whole plain value. */
 function sideOf(text) {

package/dist/project.d.ts

@@ -27,6 +27,24 @@ export type SearchDocument = {
 export interface ProjectionContext extends Partial<Readonly<Record<ProjectionValue, string>>> {
     /** The IRI of the dataset being indexed. */
     readonly dataset?: string;
+    /**
+     * Called once for each value a typed field could not read and so left out:
+     * a `date` over `Z.j`, an `integer` over `onbekend`, a `period` over
+     * `1987/1897`, a `reference` over a literal, a `boolean` outside
+     * `true`/`false`/`1`/`0`. Values from a `derive` count too; one that is not
+     * a string is reported as `String(value)`.
+     */
+    readonly onUnreadable?: (unreadable: UnreadableValue) => void;
+}
+/** A value a typed field could not read ({@link ProjectionContext.onUnreadable}). */
+export interface UnreadableValue {
+    /** The field that could not read it; dotted for a field of a nested
+     *  referent (`creator.birthDate`). */
+    readonly field: string;
+    /** The value as the source – or the derive – stated it. */
+    readonly value: string;
+    /** The IRI of the node the document was projected from. */
+    readonly id: string;
 }
 /**
  * Project one framed JSON-LD node into a flat search document: apply each field

package/dist/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAwBL,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAGhB,MAAM,aAAa,CAAC;AAGrB;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAChD,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAC1C;IACC,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,EACrB,OAAO,GAAE,iBAAyC,GACjD,cAAc,CAgBhB;AAsLD;;;;;;;;;;;;GAYG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,QAAQ,EACpB,OAAO,GAAE,iBAAyC,GACjD,aAAa,CAAC,cAAc,CAAC,CAc/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,GACpB,SAAS,MAAM,EAAE,CAmCnB"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAwBL,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAGhB,MAAM,aAAa,CAAC;AAGrB;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAkB,SAAQ,OAAO,CAChD,QAAQ,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAC1C;IACC,4CAA4C;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/D;AAED,qFAAqF;AACrF,MAAM,WAAW,eAAe;IAC9B;0CACsC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,EACrB,OAAO,GAAE,iBAAyC,GACjD,cAAc,CAkBhB;AAgMD;;;;;;;;;;;;GAYG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,QAAQ,EACpB,OAAO,GAAE,iBAAyC,GACjD,aAAa,CAAC,cAAc,CAAC,CAc/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,UAAU,EACtB,MAAM,CAAC,EAAE,YAAY,GACpB,SAAS,MAAM,EAAE,CAmCnB"}

package/dist/project.js

@@ -2,7 +2,7 @@ import { fold } from '@lde/text-normalization';
 import { matchLanguage } from './language.js';
 import { buildSubjectIndex, frameSubjects, } from './frame-by-type.js';
 import { companionNames, assertTypeInSchema, displayFieldName, displayLangOf, documentKeyOf, endpointFieldOf, fieldNamed, identityFieldOf, inheritedFacetPolicies, inlineFramingDepth, irAlias, isAbsoluteIri, isInternalField, isInlineReference, isoToUnixSeconds, localLookupTargetsOf, physicalFields, referencedTargetsOf, referenceTypeNamed, storableUnixSeconds, storedTargetOf, TARGET_FIELD, } from './schema.js';
-import { periodOfAll } from './period.js';
+import { periodCovering, periodOf } from './period.js';
 /** The context a projection runs with when its caller supplied none. */
 const NO_PROJECTION_CONTEXT = {};
 /**
@@ -20,12 +20,13 @@ const NO_PROJECTION_CONTEXT = {};
  * the engine collection definition and the query compiler.
  */
 export function projectDocument(node, searchType, schema, context = NO_PROJECTION_CONTEXT) {
-    if (documentKey(node) === undefined) {
+    const key = documentKey(node);
+    if (key === undefined) {
         throw new Error(`Cannot project a “${searchType.name}” node whose @id is not an absolute IRI (got ${JSON.stringify(node['@id']) ?? 'none'}; a blank node label or a relative reference is not one): every search document needs a stable key, and an empty one would collide with other keyless nodes.`);
     }
     // The guard above is what makes this a SearchDocument: projectFields sets `id`
     // for exactly the nodes documentKey resolves.
-    const document = projectFields(node, searchType, schema, context);
+    const document = projectFields(node, searchType, schema, context, unreadableSink(context, key));
     pruneInternalFields(document, searchType, schema);
     return document;
 }
@@ -93,10 +94,10 @@ function pruneInternalFields(document, searchType, schema) {
  *  Pruning is deferred to a single recursive pass ({@link pruneInternalFields})
  *  once the whole nested structure is projected, so a derive at any depth can
  *  still read an internal field before it is removed. */
-function projectFields(node, searchType, schema, context, nested = false) {
+function projectFields(node, searchType, schema, context, sink, nested = false) {
     const document = emptyDocument(documentIdOf(node, searchType), searchType);
     for (const field of searchType.fields) {
-        applyField(document, node, field, searchType, schema, context, nested);
+        applyField(document, node, field, searchType, schema, context, sink, nested);
     }
     return document;
 }
@@ -255,7 +256,13 @@ function hasValue(document, field, searchType) {
             (displayLangOf(field, key) !== undefined &&
                 fieldNamed(searchType, key) === undefined)));
 }
-function applyField(document, node, field, searchType, schema, context, nested) {
+function applyField(document, node, field, searchType, schema, context, sink, nested) {
+    // A blank value states nothing, so there is nothing to correct at the source.
+    const unread = (value) => {
+        if (value.trim() !== '') {
+            sink(field.name, value);
+        }
+    };
     // The three value sources, mutually exclusive by declaration
     // (`validateSearchType`): a projection value, a computed value, a graph path.
     if ((field.kind === 'keyword' || field.kind === 'reference') &&
@@ -271,13 +278,13 @@ function applyField(document, node, field, searchType, schema, context, nested)
         // value that survives nothing leaves the field absent, exactly as a derive
         // returning `undefined` does.
         if (field.kind === 'date') {
-            return applyDerivedDate(document, field, derived);
+            return applyDerivedDate(document, field, derived, unread);
         }
         if (field.kind === 'period') {
-            return setPeriod(document, field, derivedStrings(derived));
+            return setPeriod(document, field, derivedStrings(derived, unread), unread);
         }
         const value = field.kind === 'reference' && derived !== undefined
-            ? derivedIris(derived)
+            ? derivedIris(derived, unread)
             : derived;
         // NaN is not a value any kind stores, and a derive is the only route that
         // can produce one (`setNumber` guards the read route). It serializes as
@@ -286,6 +293,9 @@ function applyField(document, node, field, searchType, schema, context, nested)
         if (value !== undefined && !Number.isNaN(value)) {
             document[field.name] = value;
         }
+        else if (value !== undefined) {
+            unread(String(value));
+        }
         return;
     }
     if (field.path === undefined && field.name !== searchType.literalField) {
@@ -307,7 +317,7 @@ function applyField(document, node, field, searchType, schema, context, nested)
         // project nothing rather than fall through and emit the referent IRIs under
         // the field name (the wrong shape).
         if (schema !== undefined) {
-            applyInlineReference(document, node, alias, field, schema, context, nested);
+            applyInlineReference(document, node, alias, field, schema, context, sink, nested);
         }
         return;
     }
@@ -318,7 +328,7 @@ function applyField(document, node, field, searchType, schema, context, nested)
     if (field.kind === 'reference' && schema !== undefined) {
         const localTargets = localLookupTargetsOf(field, schema);
         if (localTargets.length > 0) {
-            const endpoints = applyNestedReferents(document, valuesOf(node, alias), field, localTargets, schema, context);
+            const endpoints = applyNestedReferents(document, valuesOf(node, alias), field, localTargets, schema, context, sink);
             // A `local` lookup stores an object, so its own id is a level deeper than
             // a filter can reach – an engine welds conditions on an entry's LEAF
             // fields only, and facets flat values. `filterable` and `facetable`
@@ -335,26 +345,41 @@ function applyField(document, node, field, searchType, schema, context, nested)
             return applyFacet(document, literalsOf(node, alias), field, schema);
         case 'reference': {
             const targetsById = new Map();
-            const values = referenceValues(node, alias, field, schema, targetsById);
+            const values = referenceValues(node, alias, field, schema, targetsById, unread);
             rememberTargets(document, targetsById);
             return applyFacet(document, values, field, schema, targetsById);
         }
         case 'integer':
-            return setNumber(document, field.name, toInteger(firstLiteralOf(node, alias)));
-        case 'number':
-            return setNumber(document, field.name, toNumber(firstLiteralOf(node, alias)));
+        case 'number': {
+            const literal = firstLiteralOf(node, alias);
+            const value = field.kind === 'integer' ? toInteger(literal) : toNumber(literal);
+            if (literal !== undefined && Number.isNaN(value)) {
+                unread(literal);
+            }
+            return setNumber(document, field.name, value);
+        }
         case 'date': {
             const literal = firstLiteralOf(node, alias);
-            return setDate(document, field, literal === undefined ? undefined : isoToUnixSeconds(literal));
+            const stored = literal === undefined ? undefined : isoToUnixSeconds(literal);
+            if (literal !== undefined && stored === undefined) {
+                unread(literal);
+            }
+            return setDate(document, field, stored);
         }
         case 'period':
-            return setPeriod(document, field, literalsOf(node, alias));
+            return setPeriod(document, field, literalsOf(node, alias), unread);
         case 'boolean': {
-            // The xsd:boolean lexical space: true/false/1/0.
-            const literal = firstLiteralOf(node, alias);
-            if (literal !== undefined) {
-                document[field.name] = literal === 'true' || literal === '1';
+            // The xsd:boolean lexical space: true/false/1/0. Anything else – `ja`,
+            // `yes` – states neither, so it is left out rather than stored as false.
+            // Surrounding whitespace is collapsed, as xsd:boolean’s facet says.
+            const literal = firstLiteralOf(node, alias)?.trim();
+            if (literal === undefined) {
+                return;
+            }
+            if (!BOOLEAN_LEXICAL_SPACE.has(literal)) {
+                return unread(literal);
             }
+            document[field.name] = literal === 'true' || literal === '1';
             return;
         }
     }
@@ -385,7 +410,16 @@ function applyField(document, node, field, searchType, schema, context, nested)
  * referent’s node IRIs therefore sees a key instead, which is why the two are
  * worth declaring together only deliberately.
  */
-function referenceValues(node, alias, field, schema, targetsById) {
+function referenceValues(node, alias, field, schema, targetsById, unread) {
+    // A literal where a referent belongs states no IRI to store. A node without
+    // one – a blank node – carries no value a publisher could look up, so only
+    // literals are reported.
+    for (const value of valuesOf(node, alias)) {
+        const literal = iriString(value) === undefined ? literalString(value) : undefined;
+        if (literal !== undefined) {
+            unread(literal);
+        }
+    }
     // Guaranteed declared: `searchSchema` validates that every named target
     // resolves, and the projection only ever runs against a type of its schema.
     const targets = referencedTargetsOf(field, schema);
@@ -685,7 +719,7 @@ function applyProjectionValue(document, field, from, context, schema) {
  * the schema’s declared depth. The referent type is guaranteed declared by
  * {@link searchSchema}.
  */
-function applyInlineReference(document, node, alias, field, schema, context, nested) {
+function applyInlineReference(document, node, alias, field, schema, context, sink, nested) {
     // Resolves for a schema that declares the referent (always so for the schema a
     // type is projected through); a type framed against a foreign schema that
     // omits it simply contributes no nesting.
@@ -695,7 +729,7 @@ function applyInlineReference(document, node, alias, field, schema, context, nes
     }
     const asEdge = edgeReader(referenceType, field.ref.identity);
     const asLiteralEntry = literalReader(referenceType);
-    const referents = applyNestedReferents(document, valuesOf(node, alias).map((value) => asLiteralEntry(value) ?? asEdge(value)), field, [referenceType], schema, context);
+    const referents = applyNestedReferents(document, valuesOf(node, alias).map((value) => asLiteralEntry(value) ?? asEdge(value)), field, [referenceType], schema, context, sink);
     applyIdentityCompanion(document, referents, field, schema, nested);
 }
 /**
@@ -897,7 +931,7 @@ function identityValue(value) {
  * top-level document of that type would be – so the stored id is the one the
  * target’s collection files it under, and the lookup can find it.
  */
-function applyNestedReferents(document, values, field, nestedTypes, schema, context) {
+function applyNestedReferents(document, values, field, nestedTypes, schema, context, sink) {
     // One node may stand for several entries: a weldable leaf is single-valued,
     // so an edge the graph gave several roles or several endpoints fans out into
     // one entry per combination BEFORE it is projected (ADR 26).
@@ -910,8 +944,18 @@ function applyNestedReferents(document, values, field, nestedTypes, schema, cont
         const nestedType = nestedTypes.length === 1
             ? nestedTypes[0]
             : targetOfReferent(value, nestedTypes);
+        // Every tuple of a node carries the node’s other values, so each value
+        // is reported once per node, not once per tuple it was copied into.
+        let reported;
+        const nestedSink = (name, value) => {
+            const key = JSON.stringify([name, value]);
+            if (!(reported ??= new Set()).has(key)) {
+                reported.add(key);
+                sink(`${field.name}.${name}`, value);
+            }
+        };
         return tuplesOf(value, nestedType, field).map((tuple) => {
-            const projected = projectFields(tuple, nestedType, schema, context, true);
+            const projected = projectFields(tuple, nestedType, schema, context, nestedSink, true);
             if (nestedTypes.length > 1 && Object.keys(projected).length > 0) {
                 projected[TARGET_FIELD] = nestedType.name;
             }
@@ -1080,11 +1124,18 @@ function iriString(value) {
  *  promises (a list stays a list, a single value stays single) so `array` still
  *  decides the stored shape. A lone non-IRI becomes `undefined`, i.e. absent –
  *  the same outcome the graph path gives it. */
-function derivedIris(value) {
+function derivedIris(value, unread) {
+    const isIri = (entry) => {
+        const iri = typeof entry === 'string' && isAbsoluteIri(entry);
+        if (!iri && entry !== undefined) {
+            unread(String(entry));
+        }
+        return iri;
+    };
     if (Array.isArray(value)) {
-        return value.filter((entry) => typeof entry === 'string' && isAbsoluteIri(entry));
+        return value.filter(isIri);
     }
-    return typeof value === 'string' && isAbsoluteIri(value) ? value : undefined;
+    return isIri(value) ? value : undefined;
 }
 function toInteger(literal) {
     return literal === undefined ? undefined : Math.trunc(Number(literal));
@@ -1102,16 +1153,22 @@ function toNumber(literal) {
  * field is stored in would be refused by the engine where an unparseable
  * string merely leaves the field absent – so drop those too.
  */
-function applyDerivedDate(document, field, derived) {
+function applyDerivedDate(document, field, derived, unread) {
+    let stored;
     if (typeof derived === 'string') {
-        return setDate(document, field, isoToUnixSeconds(derived));
+        stored = isoToUnixSeconds(derived);
     }
-    if (typeof derived === 'number') {
+    else if (typeof derived === 'number') {
         // Truncated, as the codec truncates a string’s fractional seconds: the
         // field is an int64. `storableUnixSeconds` drops NaN.
         const seconds = storableUnixSeconds(Math.trunc(derived));
-        return setDate(document, field, seconds === undefined ? undefined : { seconds, precision: 'dateTime' });
+        stored =
+            seconds === undefined ? undefined : { seconds, precision: 'dateTime' };
+    }
+    if (derived !== undefined && stored === undefined) {
+        unread(String(derived));
     }
+    setDate(document, field, stored);
 }
 /** Store a `date` field’s seconds, and its precision in the companion beside
  *  them ({@link physicalFields}), so the surface can serve the value in the
@@ -1124,35 +1181,54 @@ function setDate(document, field, stored) {
     document[physicalFields(field).precision] = stored.precision;
 }
 /**
- * Store a `period` field: its values verbatim under the field’s own name, for
- * output, and the stretch they cover between them in the bound companions
- * ({@link physicalFields}). A value that states no period is still stored – it
- * is what the source said – but bounds nothing.
+ * Store a `period` field: the values that state a period, verbatim under the
+ * field’s own name, for output, and the stretch they cover between them in the
+ * bound companions ({@link physicalFields}). A value that states no period –
+ * `onbekend`, `1987/1897` – is reported and left out, so every value served is
+ * the EDTF its scalar promises; a deployment that wants to show such text
+ * declares a `keyword` field over the same path.
  *
- * Blank values are dropped before a single-valued field keeps its first, so
- * an empty literal cannot cost the field the value behind it; and the bounds
- * are taken from exactly the values stored, so what is served and what is
- * filtered cannot disagree.
+ * Blank and unreadable values are dropped before a single-valued field keeps
+ * its first, so neither can cost the field the period behind it; and the
+ * bounds are taken from exactly the values stored, so what is served and what
+ * is filtered cannot disagree.
  */
-function setPeriod(document, field, values) {
-    const nonBlank = dedupe(values.map((value) => value.trim())).filter((value) => value !== '');
-    const stated = field.array === true ? nonBlank : nonBlank.slice(0, 1);
+function setPeriod(document, field, values, unread) {
+    const readable = dedupe(values.map((value) => value.trim())).flatMap((value) => {
+        if (value === '') {
+            return [];
+        }
+        const period = periodOf(value);
+        if (period === undefined) {
+            unread(value);
+            return [];
+        }
+        return [{ value, period }];
+    });
+    const stated = field.array === true ? readable : readable.slice(0, 1);
     if (stated.length === 0) {
         return;
     }
-    document[field.name] = field.array === true ? stated : stated[0];
+    document[field.name] =
+        field.array === true ? stated.map(({ value }) => value) : stated[0].value;
     const companions = physicalFields(field).period;
-    const covered = periodOfAll(stated);
-    if (companions !== undefined && covered !== undefined) {
+    if (companions !== undefined) {
+        const [first, ...rest] = stated.map(({ period }) => period);
+        const covered = periodCovering(first, ...rest);
         document[companions.start] = covered.start;
         document[companions.end] = covered.end;
     }
 }
 /** A derive’s value as the strings a `period` stores: one string, or the
  *  strings in a list; anything else states no value. */
-function derivedStrings(derived) {
+function derivedStrings(derived, unread) {
     const values = Array.isArray(derived) ? derived : [derived];
-    return values.filter((value) => typeof value === 'string');
+    return values.filter((value) => {
+        if (typeof value !== 'string' && value !== undefined) {
+            unread(String(value));
+        }
+        return typeof value === 'string';
+    });
 }
 function setNumber(document, field, value) {
     if (value !== undefined && !Number.isNaN(value)) {
@@ -1187,3 +1263,22 @@ function setArray(document, field, values) {
 function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/** The sink a root document’s fields report to: the context’s
+ *  {@link ProjectionContext.onUnreadable}, told which node the value was
+ *  dropped from. */
+function unreadableSink(context, id) {
+    const { onUnreadable } = context;
+    return onUnreadable === undefined
+        ? ignoreUnreadable
+        : (field, value) => onUnreadable({ field, value, id });
+}
+function ignoreUnreadable() {
+    // Nobody asked for the report.
+}
+/** The xsd:boolean lexical space. */
+const BOOLEAN_LEXICAL_SPACE = new Set([
+    'true',
+    'false',
+    '1',
+    '0',
+]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "Engine- and domain-agnostic core for RDF-backed search: a unified declarative field model (SearchField/SearchType/SearchSchema), a neutral query IR, the SearchEngine port with logical result types, and a streaming CONSTRUCT-to-document projection. Bakes in no engine, protocol, or domain.",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",