@lde/search 0.8.0 → 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/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.8.0",
+  "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",