@lde/search 0.37.0 → 0.39.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,EAsBL,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAEb,KAAK,YAAY,EACjB,KAAK,UAAU,EAGhB,MAAM,aAAa,CAAC;AAUrB;;;;;;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

@@ -1,8 +1,9 @@
 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 { companionNames, assertTypeInSchema, displayFieldName, displayLangOf, documentKeyOf, endpointFieldOf, fieldNamed, identityFieldOf, inheritedFacetPolicies, inlineFramingDepth, irAlias, isAbsoluteIri, isInternalField, isInlineReference, localLookupTargetsOf, physicalFields, referencedTargetsOf, referenceTypeNamed, storedTargetOf, TARGET_FIELD, } from './schema.js';
+import { periodCovering, periodOf } from './period.js';
+import { describeValue, isReadKind, readValue, UNREADABLE, } from './read-value.js';
 /** The context a projection runs with when its caller supplied none. */
 const NO_PROJECTION_CONTEXT = {};
 /**
@@ -20,12 +21,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 +95,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 +257,8 @@ 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) {
+    const unread = (value) => 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') &&
@@ -264,27 +267,24 @@ function applyField(document, node, field, searchType, schema, context, nested)
     }
     if (field.derive !== undefined) {
         const derived = field.derive(document, context);
-        // A derived `reference` is held to the same rule as a read one: what it
-        // stores is a selection key, and the surface types it `IRI`. ADR 21 sends
-        // an IRI-valued `keyword` derive here by converting it to `reference`, so
-        // this is the busiest way a non-IRI could otherwise reach the index. A
-        // value that survives nothing leaves the field absent, exactly as a derive
-        // returning `undefined` does.
-        if (field.kind === 'date') {
-            return applyDerivedDate(document, field, derived);
-        }
         if (field.kind === 'period') {
-            return setPeriod(document, field, derivedStrings(derived));
+            return setPeriod(document, field, derivedStrings(derived, unread), unread);
+        }
+        // A derived value is held to the same rule as a read one, through the same
+        // reader: a derived `reference` stores a selection key the surface types
+        // `IRI` – ADR 21 sends an IRI-valued `keyword` derive here by converting it
+        // to `reference`, so this is the busiest way a non-IRI could otherwise
+        // reach the index – and a derived `integer` an int64.
+        if (isReadKind(field.kind)) {
+            return applyRead(document, field, field.kind, Array.isArray(derived) ? derived : [derived], unread);
+        }
+        // A `keyword` or `text` field reads any value but NaN, which serializes as
+        // `null` – stored by an engine as no value, or refused with the document.
+        if (Number.isNaN(derived)) {
+            unread('NaN');
         }
-        const value = field.kind === 'reference' && derived !== undefined
-            ? derivedIris(derived)
-            : 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
-        // `null`, which an engine rejects for a numeric field – so drop it, leaving
-        // the field absent as an unparseable string already does.
-        if (value !== undefined && !Number.isNaN(value)) {
-            document[field.name] = value;
+        else if (derived !== undefined) {
+            document[field.name] = derived;
         }
         return;
     }
@@ -307,7 +307,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 +318,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,28 +335,42 @@ 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 'date': {
-            const literal = firstLiteralOf(node, alias);
-            return setDate(document, field, literal === undefined ? undefined : isoToUnixSeconds(literal));
-        }
+        case 'date':
+        case 'boolean':
+            return applyRead(document, field, field.kind, literalsOf(node, alias), unread);
         case 'period':
-            return setPeriod(document, field, literalsOf(node, alias));
-        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';
-            }
-            return;
+            return setPeriod(document, field, literalsOf(node, alias), unread);
+    }
+}
+/**
+ * Store what {@link readValue} reads of `values` as `kind`, reporting every
+ * value it cannot. An `array` reference stores the list; every other kind is a
+ * scalar in the engine, so it stores the first value read – and an unreadable
+ * or blank value cannot cost the field a readable one behind it.
+ */
+function applyRead(document, field, kind, values, unread) {
+    const read = values.flatMap((value) => {
+        const reading = readValue(kind, value);
+        if (reading === UNREADABLE) {
+            unread(describeValue(value));
+            return [];
         }
+        return reading === undefined ? [] : [reading];
+    });
+    if (kind === 'date') {
+        return setDate(document, field, read[0]);
+    }
+    if (kind === 'reference' && field.array === true) {
+        document[field.name] = read;
+    }
+    else if (read.length > 0) {
+        document[field.name] = read[0];
     }
 }
 /**
@@ -385,7 +399,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, and a blank one states nothing to correct.
+    for (const value of valuesOf(node, alias)) {
+        const literal = iriString(value) === undefined ? literalString(value) : undefined;
+        if (literal !== undefined && literal.trim() !== '') {
+            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 +708,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 +718,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 +920,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 +933,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;
             }
@@ -1010,9 +1043,6 @@ function literalsOf(node, key) {
         .map(literalString)
         .filter((value) => value !== undefined);
 }
-function firstLiteralOf(node, key) {
-    return literalsOf(node, key)[0];
-}
 function irisOf(node, key) {
     return valuesOf(node, key)
         .map(iriString)
@@ -1075,44 +1105,6 @@ function iriString(value) {
     const iri = isObject(value) ? value['@id'] : value;
     return typeof iri === 'string' && isAbsoluteIri(iri) ? iri : undefined;
 }
-/** What a `derive` on a `reference` field is allowed to have produced: the
- *  absolute IRIs among its return value, keeping the shape the declaration
- *  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) {
-    if (Array.isArray(value)) {
-        return value.filter((entry) => typeof entry === 'string' && isAbsoluteIri(entry));
-    }
-    return typeof value === 'string' && isAbsoluteIri(value) ? value : undefined;
-}
-function toInteger(literal) {
-    return literal === undefined ? undefined : Math.trunc(Number(literal));
-}
-function toNumber(literal) {
-    return literal === undefined ? undefined : Number(literal);
-}
-/**
- * A derived `date` goes through the same storage codec as a read one: the field
- * is stored as Unix seconds, so an ISO string returned here would otherwise
- * land as a string in an int64 field – and it is parsed like any literal, its
- * precision included. A derive that computed seconds itself returns a number,
- * which states no precision and so is stored as a date-time; the codec never
- * saw it and so never range-checked it, and seconds outside the int64 a `date`
- * 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) {
-    if (typeof derived === 'string') {
-        return setDate(document, field, isoToUnixSeconds(derived));
-    }
-    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' });
-    }
-}
 /** 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
  *  form its source gave. */
@@ -1124,40 +1116,55 @@ 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) {
+ *  strings in a list. `null` and `undefined` state no value; anything else
+ *  is reported. */
+function derivedStrings(derived, unread) {
     const values = Array.isArray(derived) ? derived : [derived];
-    return values.filter((value) => typeof value === 'string');
-}
-function setNumber(document, field, value) {
-    if (value !== undefined && !Number.isNaN(value)) {
-        document[field] = value;
-    }
+    return values.filter((value) => {
+        if (typeof value !== 'string' && value !== undefined && value !== null) {
+            unread(describeValue(value));
+        }
+        return typeof value === 'string';
+    });
 }
 function dedupe(values) {
     return [...new Set(values)];
@@ -1187,3 +1194,15 @@ 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.
+}

package/dist/read-value.d.ts

@@ -0,0 +1,44 @@
+import { type StoredDate } from './schema.js';
+/** What reading a value that is there, but not one its kind can store, gives:
+ *  `onbekend` for an integer, `ja` for a boolean. */
+export declare const UNREADABLE: unique symbol;
+/**
+ * One value read as a field’s kind: what the field stores, {@link UNREADABLE}
+ * for a value it cannot store, or `undefined` for no value at all – a missing
+ * or blank one, which states nothing to correct at the source.
+ */
+type Reading<T> = T | typeof UNREADABLE | undefined;
+/** The kinds that can refuse a value: the rest store any literal. */
+declare const READ_KINDS: readonly ["integer", "number", "boolean", "date", "reference"];
+/** One of {@link READ_KINDS}. */
+export type ReadKind = (typeof READ_KINDS)[number];
+/** Whether `kind` is one {@link readValue} reads. */
+export declare function isReadKind(kind: string): kind is ReadKind;
+/**
+ * Read one value – a literal from the graph, or whatever a `derive` returned –
+ * as `kind` stores it. Both value routes read through here, so a kind accepts
+ * and refuses the same values whichever route they came by.
+ *
+ * - `integer`: a finite number, or an `xsd:decimal` or `xsd:double` lexical
+ *   form, truncated, within ±2⁵³ – beyond that a double no longer holds every
+ *   integer, so the stored value would not be the stated one. `INF` and `NaN`
+ *   are refused: an engine cannot store them.
+ * - `number`: any finite one, untruncated.
+ * - `boolean`: `true` or `false`, or the `xsd:boolean` lexical space
+ *   (`true`/`false`/`1`/`0`).
+ * - `date`: anything the `date` codec reads ({@link isoToUnixSeconds}), or
+ *   Unix seconds as a number.
+ * - `reference`: an absolute IRI.
+ *
+ * A string is read with surrounding whitespace collapsed, as XSD does.
+ */
+export declare function readValue(kind: ReadKind, value: unknown): Reading<number | boolean | string | StoredDate>;
+/**
+ * A value as the report shows it: `String(value)`, or its `typeof` when it has
+ * no string form, as an object built without a prototype has not. Never
+ * throws, so a derive’s odd return is reported rather than crashing the
+ * projection.
+ */
+export declare function describeValue(value: unknown): string;
+export {};
+//# sourceMappingURL=read-value.d.ts.map

package/dist/read-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-value.d.ts","sourceRoot":"","sources":["../src/read-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAErB;qDACqD;AACrD,eAAO,MAAM,UAAU,eAAuB,CAAC;AAE/C;;;;GAIG;AACH,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,UAAU,GAAG,SAAS,CAAC;AAEpD,qEAAqE;AACrE,QAAA,MAAM,UAAU,gEAMN,CAAC;AAEX,iCAAiC;AACjC,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD,qDAAqD;AACrD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,QAAQ,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC,CA8CjD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMpD"}

package/dist/read-value.js

@@ -0,0 +1,96 @@
+import { isAbsoluteIri, isoToUnixSeconds, storableUnixSeconds, } from './schema.js';
+/** What reading a value that is there, but not one its kind can store, gives:
+ *  `onbekend` for an integer, `ja` for a boolean. */
+export const UNREADABLE = Symbol('unreadable');
+/** The kinds that can refuse a value: the rest store any literal. */
+const READ_KINDS = [
+    'integer',
+    'number',
+    'boolean',
+    'date',
+    'reference',
+];
+/** Whether `kind` is one {@link readValue} reads. */
+export function isReadKind(kind) {
+    return READ_KINDS.includes(kind);
+}
+/**
+ * Read one value – a literal from the graph, or whatever a `derive` returned –
+ * as `kind` stores it. Both value routes read through here, so a kind accepts
+ * and refuses the same values whichever route they came by.
+ *
+ * - `integer`: a finite number, or an `xsd:decimal` or `xsd:double` lexical
+ *   form, truncated, within ±2⁵³ – beyond that a double no longer holds every
+ *   integer, so the stored value would not be the stated one. `INF` and `NaN`
+ *   are refused: an engine cannot store them.
+ * - `number`: any finite one, untruncated.
+ * - `boolean`: `true` or `false`, or the `xsd:boolean` lexical space
+ *   (`true`/`false`/`1`/`0`).
+ * - `date`: anything the `date` codec reads ({@link isoToUnixSeconds}), or
+ *   Unix seconds as a number.
+ * - `reference`: an absolute IRI.
+ *
+ * A string is read with surrounding whitespace collapsed, as XSD does.
+ */
+export function readValue(kind, value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const text = typeof value === 'string' ? value.trim() : undefined;
+    if (text === '') {
+        return undefined;
+    }
+    switch (kind) {
+        case 'integer':
+        case 'number': {
+            const number = typeof value === 'number'
+                ? value
+                : text !== undefined && NUMERIC.test(text)
+                    ? Number(text)
+                    : Number.NaN;
+            if (kind === 'number') {
+                return Number.isFinite(number) ? number : UNREADABLE;
+            }
+            const integer = Math.trunc(number);
+            return Number.isSafeInteger(integer) ? integer : UNREADABLE;
+        }
+        case 'boolean':
+            if (typeof value === 'boolean') {
+                return value;
+            }
+            return text !== undefined && BOOLEAN.has(text)
+                ? text === 'true' || text === '1'
+                : UNREADABLE;
+        case 'date': {
+            if (typeof value === 'number') {
+                // Truncated, as the codec truncates a string’s fractional seconds: the
+                // field is an int64. `storableUnixSeconds` drops NaN.
+                const seconds = storableUnixSeconds(Math.trunc(value));
+                return seconds === undefined
+                    ? UNREADABLE
+                    : { seconds, precision: 'dateTime' };
+            }
+            return ((text === undefined ? undefined : isoToUnixSeconds(text)) ?? UNREADABLE);
+        }
+        case 'reference':
+            return text !== undefined && isAbsoluteIri(text) ? text : UNREADABLE;
+    }
+}
+/**
+ * A value as the report shows it: `String(value)`, or its `typeof` when it has
+ * no string form, as an object built without a prototype has not. Never
+ * throws, so a derive’s odd return is reported rather than crashing the
+ * projection.
+ */
+export function describeValue(value) {
+    try {
+        return String(value);
+    }
+    catch {
+        return typeof value;
+    }
+}
+/** The `xsd:decimal` and `xsd:double` lexical forms, `INF` and `NaN` aside. */
+const NUMERIC = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+/** The `xsd:boolean` lexical space. */
+const BOOLEAN = new Set(['true', 'false', '1', '0']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/search",
-  "version": "0.37.0",
+  "version": "0.39.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",