@lde/search 0.7.1 → 0.8.1

package/dist/frame-by-type.d.ts

@@ -26,15 +26,20 @@ export interface SubjectIndex {
  */
 export declare function buildSubjectIndex(quads: Iterable<Quad>, rootTypes: Iterable<string>): SubjectIndex;
 /**
- * Frame every root subject of `rootType` from a prebuilt {@link SubjectIndex}
- * into one JSON-LD node – the reusable core behind {@link frameByType}. Each
- * root subject’s own triples plus the one-hop nodes it references (e.g. nested
- * publisher/distribution resources) are framed one subject at a time, so beyond
- * the shared subject index only a single subgraph is held (whole-graph
- * `jsonld.frame()` is ~O(N²)). The frame carries no `@context`, so framed keys
- * are full predicate IRIs.
+ * Frame each of the given `roots` from a prebuilt {@link SubjectIndex} into one
+ * JSON-LD node. Each root subject’s own triples plus the one-hop nodes it
+ * references (e.g. nested publisher/distribution resources) are framed one
+ * subject at a time, so beyond the shared subject index only a single subgraph
+ * is held (whole-graph `jsonld.frame()` is ~O(N²)). The frame carries no
+ * `@context`, so framed keys are full predicate IRIs.
+ *
+ * The roots are supplied explicitly rather than discovered from `rdf:type`: a
+ * caller with the roots already in hand ({@link projectRoots}, from the pipeline
+ * selector) passes them directly; a whole-graph caller ({@link frameByType},
+ * {@link projectGraph}) passes {@link SubjectIndex.rootsByType}. A root absent
+ * from the index simply frames nothing.
  */
-export declare function frameSubjects(index: SubjectIndex, rootType: string): AsyncIterable<FramedNode>;
+export declare function frameSubjects(index: SubjectIndex, roots: readonly string[]): AsyncIterable<FramedNode>;
 /**
  * Frame CONSTRUCT quads into one JSON-LD node per subject of `rootType`, for a
  * single root type. Consumes `quads` once (see {@link buildSubjectIndex}), so

package/dist/frame-by-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frame-by-type.d.ts","sourceRoot":"","sources":["../src/frame-by-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAMzC,4EAA4E;AAC5E,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAIjD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;IACzD,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;CAC9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC1B,YAAY,CA8Bd;AAED;;;;;;;;GAQG;AACH,wBAAuB,aAAa,CAClC,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,MAAM,GACf,aAAa,CAAC,UAAU,CAAC,CA+B3B;AAED;;;;;;GAMG;AACH,wBAAuB,WAAW,CAChC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,QAAQ,EAAE,MAAM,GACf,aAAa,CAAC,UAAU,CAAC,CAE3B"}
+{"version":3,"file":"frame-by-type.d.ts","sourceRoot":"","sources":["../src/frame-by-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAMzC,4EAA4E;AAC5E,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAIjD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;IACzD,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;CAC9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC1B,YAAY,CA8Bd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAuB,aAAa,CAClC,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,aAAa,CAAC,UAAU,CAAC,CA4B3B;AAED;;;;;;GAMG;AACH,wBAAuB,WAAW,CAChC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,QAAQ,EAAE,MAAM,GACf,aAAa,CAAC,UAAU,CAAC,CAG3B"}

package/dist/frame-by-type.js

@@ -44,19 +44,21 @@ export function buildSubjectIndex(quads, rootTypes) {
     return { bySubject, rootsByType };
 }
 /**
- * Frame every root subject of `rootType` from a prebuilt {@link SubjectIndex}
- * into one JSON-LD node – the reusable core behind {@link frameByType}. Each
- * root subject’s own triples plus the one-hop nodes it references (e.g. nested
- * publisher/distribution resources) are framed one subject at a time, so beyond
- * the shared subject index only a single subgraph is held (whole-graph
- * `jsonld.frame()` is ~O(N²)). The frame carries no `@context`, so framed keys
- * are full predicate IRIs.
+ * Frame each of the given `roots` from a prebuilt {@link SubjectIndex} into one
+ * JSON-LD node. Each root subject’s own triples plus the one-hop nodes it
+ * references (e.g. nested publisher/distribution resources) are framed one
+ * subject at a time, so beyond the shared subject index only a single subgraph
+ * is held (whole-graph `jsonld.frame()` is ~O(N²)). The frame carries no
+ * `@context`, so framed keys are full predicate IRIs.
+ *
+ * The roots are supplied explicitly rather than discovered from `rdf:type`: a
+ * caller with the roots already in hand ({@link projectRoots}, from the pipeline
+ * selector) passes them directly; a whole-graph caller ({@link frameByType},
+ * {@link projectGraph}) passes {@link SubjectIndex.rootsByType}. A root absent
+ * from the index simply frames nothing.
  */
-export async function* frameSubjects(index, rootType) {
+export async function* frameSubjects(index, roots) {
     const { bySubject } = index;
-    // A type the index was not built for has no roots, so it frames nothing; the
-    // `projectType`/`projectGraph` callers only pass types they registered.
-    const roots = index.rootsByType.get(rootType) ?? [];
     for (const rootIri of roots) {
         const owned = bySubject.get(rootIri) ?? [];
         const referenced = owned
@@ -68,7 +70,7 @@ export async function* frameSubjects(index, rootType) {
         // Frame for THIS specific root subject by `@id`, not just by root type. A
         // one-hop reference can itself be of `rootType` (e.g. a terminology source
         // that is also a separately registered dataset), so framing by type alone
-        // returns several root nodes and `[0]` could be the referenced one — which
+        // returns several root nodes and `[0]` could be the referenced one – which
         // would emit it twice and drop this subject entirely.
         const framed = await jsonld.frame(expanded, { '@id': rootIri }, FRAME_OPTIONS);
         const node = framed['@graph']?.[0];
@@ -85,5 +87,6 @@ export async function* frameSubjects(index, rootType) {
  * one index across types rather than re-scanning per type.
  */
 export async function* frameByType(quads, rootType) {
-    yield* frameSubjects(buildSubjectIndex(quads, [rootType]), rootType);
+    const index = buildSubjectIndex(quads, [rootType]);
+    yield* frameSubjects(index, index.rootsByType.get(rootType) ?? []);
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { projectGraph, irisOf, literalsOf, firstLiteralOf } from './project.js';
+export { projectGraph, projectRoots, irisOf, literalsOf, firstLiteralOf, } from './project.js';
 export type { SearchDocument, TypedSearchDocument } from './project.js';
 export { defineSearchType, searchSchema, validateSearchType, assertValidSearchType, } from './schema.js';
 export type { FieldKind, SearchField, SearchFieldBase, TextField, KeywordField, ReferenceField, NumericField, BooleanField, SearchType, SearchTypeIssue, SearchSchema, FacetRange, } from './schema.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAChF,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAKxE,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EACZ,UAAU,GACX,MAAM,aAAa,CAAC;AAIrB,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAI5D,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,WAAW,EACX,cAAc,EACd,SAAS,EACT,WAAW,EACX,QAAQ,EACR,aAAa,EACb,aAAa,EACb,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,MAAM,EACN,UAAU,EACV,cAAc,GACf,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAKxE,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EACZ,UAAU,GACX,MAAM,aAAa,CAAC;AAIrB,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAI5D,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,cAAc,EACd,WAAW,EACX,cAAc,EACd,SAAS,EACT,WAAW,EACX,QAAQ,EACR,aAAa,EACb,aAAa,EACb,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -6,8 +6,8 @@
 // Projection: RDF CONSTRUCT quads → flat search documents, driven by the
 // unified SearchField/SearchType model. The IR readers (irisOf, …) are here
 // because `derive` functions are written against them.
-export { projectGraph, irisOf, literalsOf, firstLiteralOf } from './project.js';
+export { projectGraph, projectRoots, irisOf, literalsOf, firstLiteralOf, } from './project.js';
 // Unified field model: one declaration drives projection, engine collection
-// schema, query semantics and the GraphQL surface — a discriminated union by
+// schema, query semantics and the GraphQL surface – a discriminated union by
 // `kind`, validated again at runtime when the schema is built.
 export { defineSearchType, searchSchema, validateSearchType, assertValidSearchType, } from './schema.js';

package/dist/physical-name.d.ts

@@ -24,8 +24,17 @@ import type { SearchType } from './schema.js';
  * rules produce (`serieses`, `analysises`). An already-plural name is
  * idempotent (`People` → `people`).
  *
- * Returns an empty array when `name` carries no alphanumerics at all; the
- * adapter decides what that means, since only it knows its engine’s rules.
+ * **Throws rather than name the wrong container.** Dropping what it cannot
+ * match is what lets `creative_work` tokenize like `CreativeWork`, but it would
+ * just as quietly turn `Café` into `['cafs']` and `Musée` into `['mus', 'es']`
+ * – a perfectly legal name for a container nobody meant. So a name is spellable
+ * only when it is ASCII words and word separators, and only when it leaves at
+ * least one word to name anything after; anything else throws here. This guard
+ * lives with the split it protects, not in each adapter: an adapter cannot
+ * derive a name without going through this function, so it cannot forget to
+ * check – and `SearchType.name` is otherwise unvalidated
+ * ({@link validateSearchType} rules on field names only). A deployment whose
+ * type name this cannot spell passes its adapter an explicit name instead.
  */
 export declare function physicalNameTokens(searchType: SearchType): readonly string[];
 //# sourceMappingURL=physical-name.d.ts.map

package/dist/physical-name.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"physical-name.d.ts","sourceRoot":"","sources":["../src/physical-name.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,CAK5E"}
+{"version":3,"file":"physical-name.d.ts","sourceRoot":"","sources":["../src/physical-name.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,CAiB5E"}

package/dist/physical-name.js

@@ -24,15 +24,43 @@ import { pluralize } from 'inflection';
  * rules produce (`serieses`, `analysises`). An already-plural name is
  * idempotent (`People` → `people`).
  *
- * Returns an empty array when `name` carries no alphanumerics at all; the
- * adapter decides what that means, since only it knows its engine’s rules.
+ * **Throws rather than name the wrong container.** Dropping what it cannot
+ * match is what lets `creative_work` tokenize like `CreativeWork`, but it would
+ * just as quietly turn `Café` into `['cafs']` and `Musée` into `['mus', 'es']`
+ * – a perfectly legal name for a container nobody meant. So a name is spellable
+ * only when it is ASCII words and word separators, and only when it leaves at
+ * least one word to name anything after; anything else throws here. This guard
+ * lives with the split it protects, not in each adapter: an adapter cannot
+ * derive a name without going through this function, so it cannot forget to
+ * check – and `SearchType.name` is otherwise unvalidated
+ * ({@link validateSearchType} rules on field names only). A deployment whose
+ * type name this cannot spell passes its adapter an explicit name instead.
  */
 export function physicalNameTokens(searchType) {
-    const words = searchType.name.match(NAME_WORD_PATTERN) ?? [];
-    const tokens = words.map((word) => word.toLowerCase());
+    const { name } = searchType;
+    if (!SPELLABLE_NAME.test(name)) {
+        throw new Error(`Cannot name search type “${name}”: a physical name is derived from the type’s name, and this one carries characters outside ASCII words and word separators – deriving would silently drop them and name the wrong container. Rename the type, or give the adapter an explicit name.`);
+    }
+    const tokens = (name.match(NAME_WORD_PATTERN) ?? []).map((word) => word.toLowerCase());
     const last = tokens.at(-1);
-    return last === undefined ? [] : [...tokens.slice(0, -1), pluralize(last)];
+    if (last === undefined) {
+        throw new Error(`Cannot name search type “${name}”: its name carries no word to name a container after. Rename the type, or give the adapter an explicit name.`);
+    }
+    return [...tokens.slice(0, -1), pluralize(last)];
 }
+/**
+ * A name the split can spell without losing part of it: ASCII letters and
+ * digits, plus the separators a name may already be written with (`creative
+ * work`, `creative_work`, `creative-work` all tokenize like `CreativeWork`).
+ * Deliberately narrower than what {@link NAME_WORD_PATTERN} would tolerate –
+ * that one skips anything it does not match, which is precisely the silent
+ * mangling this rejects.
+ *
+ * Matches the empty name too, on purpose: nothing about it is *unspellable*,
+ * there is simply nothing to spell, which the no-word check below reports far
+ * better than a complaint about characters it does not carry.
+ */
+const SPELLABLE_NAME = /^[A-Za-z0-9 _-]*$/;
 /**
  * One word of a PascalCase/camelCase name, in precedence order: a run of
  * capitals not followed by a lowercase letter (an acronym – `DCAT` in

package/dist/project.d.ts

@@ -39,6 +39,21 @@ export declare function projectDocument(node: FramedNode, searchType: SearchType
  * with no intermediate copy at the projection peak.
  */
 export declare function projectGraph(quads: Iterable<Quad>, schema: SearchSchema): AsyncIterable<TypedSearchDocument>;
+/**
+ * Project a single type over a known set of `roots` – the per-type, roots-given
+ * projection. Unlike {@link projectGraph}, the roots are supplied by the caller
+ * (the pipeline selector) rather than discovered from `rdf:type`, so `quads`
+ * need carry no type triples and the projection frames each distinct subject
+ * once. {@link assertTypeInSchema} guards that `searchType` belongs to `schema`
+ * – the port’s own membership check – so no schema is ever forged to scope a
+ * projection to one type. Yields a bare {@link SearchDocument}: tagging a
+ * document with its type is a routing concern, owned by the pipeline glue, not
+ * the projection.
+ *
+ * Consumes `quads` once, so it accepts any `Iterable` – a batch’s materialized
+ * array or a chained generator merging several readers.
+ */
+export declare function projectRoots(quads: Iterable<Quad>, roots: readonly string[], schema: SearchSchema, searchType: SearchType): AsyncIterable<SearchDocument>;
 export declare function literalsOf(node: FramedNode, path: string): string[];
 export declare function firstLiteralOf(node: FramedNode, path: string): string | undefined;
 export declare function irisOf(node: FramedNode, path: string): string[];

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;AAEzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAOL,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAErB,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,GACrB,cAAc,CAYhB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,MAAM,EAAE,YAAY,GACnB,aAAa,CAAC,mBAAmB,CAAC,CAWpC;AAqJD,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAInE;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAI/D"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../src/project.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAGL,KAAK,UAAU,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAQL,KAAK,YAAY,EACjB,KAAK,UAAU,EAEhB,MAAM,aAAa,CAAC;AAErB,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,UAAU,GACrB,cAAc,CAYhB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,MAAM,EAAE,YAAY,GACnB,aAAa,CAAC,mBAAmB,CAAC,CAYpC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAuB,YAAY,CACjC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,UAAU,GACrB,aAAa,CAAC,cAAc,CAAC,CAW/B;AAqJD,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAInE;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAI/D"}

package/dist/project.js

@@ -1,6 +1,6 @@
 import { fold } from '@lde/text-normalization';
 import { buildSubjectIndex, frameSubjects, } from './frame-by-type.js';
-import { displayFieldName, isoToUnixSeconds, physicalFields, } from './schema.js';
+import { assertTypeInSchema, displayFieldName, isoToUnixSeconds, physicalFields, } from './schema.js';
 /**
  * Project one framed JSON-LD node into a flat search document: apply each field
  * of the type in declaration order. A field with a `derive` function computes
@@ -38,11 +38,38 @@ export async function* projectGraph(quads, schema) {
     const types = [...schema.values()];
     const index = buildSubjectIndex(quads, types.map((searchType) => searchType.class));
     for (const searchType of types) {
-        for await (const node of frameSubjects(index, searchType.class)) {
+        const roots = index.rootsByType.get(searchType.class) ?? [];
+        for await (const node of frameSubjects(index, roots)) {
             yield { searchType, document: projectDocument(node, searchType) };
         }
     }
 }
+/**
+ * Project a single type over a known set of `roots` – the per-type, roots-given
+ * projection. Unlike {@link projectGraph}, the roots are supplied by the caller
+ * (the pipeline selector) rather than discovered from `rdf:type`, so `quads`
+ * need carry no type triples and the projection frames each distinct subject
+ * once. {@link assertTypeInSchema} guards that `searchType` belongs to `schema`
+ * – the port’s own membership check – so no schema is ever forged to scope a
+ * projection to one type. Yields a bare {@link SearchDocument}: tagging a
+ * document with its type is a routing concern, owned by the pipeline glue, not
+ * the projection.
+ *
+ * Consumes `quads` once, so it accepts any `Iterable` – a batch’s materialized
+ * array or a chained generator merging several readers.
+ */
+export async function* projectRoots(quads, roots, schema, searchType) {
+    assertTypeInSchema(schema, searchType);
+    const index = buildSubjectIndex(quads, []);
+    // Distinct roots only. A selector may return an IRI more than once – a
+    // non-`DISTINCT` `SELECT` over a one-to-many join yields the same subject per
+    // matched row – and a repeated root would otherwise frame and emit a
+    // duplicate document under the same `id`. (`projectGraph`’s roots come from
+    // `rootsByType`, which is inherently unique, so it never needs this.)
+    for await (const node of frameSubjects(index, [...new Set(roots)])) {
+        yield projectDocument(node, searchType);
+    }
+}
 function applyField(document, node, field) {
     if (field.derive !== undefined) {
         const value = field.derive(node, document);

package/package.json

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