@instruments/materialgraph 0.25.0 → 0.27.0

package/specifications.d.ts

@@ -1,22 +1,12 @@
+import type { CertificationProgrammeFilter, SpecExclusionFilter, SpecPresenceFilter, SpecTermFilter } from "./spec-types.js";
 /**
- * Zero-dependency builders for the specification surface. Turn a plain-language
- * spec intent into a typed criterion the SDK's two spec operations accept:
+ * A hard criterion excluding one canonical value.
  *
- * - `search({ filters })` takes {@link SpecFilter} objects — a spec gate layered
- *   onto a ranked (colour / visual / lexical) search. Build them with
- *   {@link specTerm}, {@link hasSpec}, and {@link certificationProgramme}.
- * - `bySpec(specs)` takes `attribute:value` strings — the value-anchored,
- *   spec-only primitive. Build them with {@link specCriterion} and
- *   {@link certificationProgrammeCriterion}.
- *
- * The point of these helpers: Desk (and any spec-driven caller) never has to
- * remember that a certification programme lives under a VIRTUAL attribute, nor
- * hand-format the `attribute:value` string the `bySpec` route splits on its
- * first `:`.
+ * By default retains only variants with a KNOWN value (unstated does not
+ * pass). Pass `whenUnstated: "pass"` to admit unstated variants too — only a
+ * variant that STATES the excluded term is dropped.
  */
-import { type CertificationProgrammeFilter, type SpecExclusionFilter, type SpecPresenceFilter, type SpecTermFilter } from "./spec-types.js";
-/** A hard criterion excluding one known canonical value while retaining only variants with known values. */
-export declare function excludeSpec(attributeId: string, excludesTerm: string): SpecExclusionFilter;
+export declare const excludeSpec: (attributeId: string, excludesTerm: string, whenUnstated?: "drop" | "pass") => SpecExclusionFilter;
 /**
  * A term-equality criterion for `search({ filters })` — the attribute must
  * carry this canonical value.
@@ -25,7 +15,7 @@ export declare function excludeSpec(attributeId: string, excludesTerm: string):
  * // "same fire class as the seed"
  * client.search({ similarTo: { variantId }, filters: [specTerm("fire_classifications", "astm_e84_class_a")] });
  */
-export declare function specTerm(attributeId: string, term: string): SpecTermFilter;
+export declare const specTerm: (attributeId: string, term: string) => SpecTermFilter;
 /**
  * A presence criterion for `search({ filters })` — the attribute must have ANY
  * accepted value.
@@ -34,67 +24,19 @@ export declare function specTerm(attributeId: string, term: string): SpecTermFil
  * // "…and it must have an EPD on record"
  * client.search({ similarTo: { variantId }, filters: [hasSpec("environmental_product_declaration")] });
  */
-export declare function hasSpec(attributeId: string): SpecPresenceFilter;
+export declare const hasSpec: (attributeId: string) => SpecPresenceFilter;
 /**
  * A certification-programme criterion for `search({ filters })`, pinned to the
  * virtual attribute so a programme matches wherever it landed at ingest
  * (compliance / sustainability / material-health / VOC buckets).
  *
- * The value may be a display name or alias ("GREENGUARD Gold", "LEED") — the
- * server resolves it to its canonical programme token before matching — or a
- * canonical token directly (e.g. `greenguard_certificate`,
- * `has_greenguard_gold_certification`).
+ * The value is a canonical programme token (e.g. `greenguard_certificate`,
+ * `has_greenguard_gold_certification`). The one search matches tokens on its
+ * index and does not resolve display names, so a name such as
+ * "GREENGUARD Gold" is a 400 naming the term.
  *
  * @example
  * // "find a GREENGUARD-certified alternative"
- * client.search({ similarTo: { variantId: seed }, filters: [certificationProgramme("GREENGUARD Gold")] });
- */
-export declare function certificationProgramme(programme: string): CertificationProgrammeFilter;
-/**
- * An `attribute:value` criterion string for `bySpec`. The `bySpec` route splits
- * on the FIRST `:`, so a value may itself contain colons; the attribute id may
- * not.
- *
- * @example
- * client.bySpec([specCriterion("primary_material", "textile"), specCriterion("fire_classifications", "astm_e84_class_a")]);
- */
-export declare function specCriterion(attributeId: string, value: string): string;
-/**
- * An `attribute:min..max` RANGE criterion string for `bySpec`, for a
- * NUMBER-valued spec (`light_reflectance_value`, `nrc_rating`,
- * `slip_resistance_dcof`, …). Pass the result in `bySpec`'s `ranges` option.
- *
- * BOTH BOUNDS ARE INCLUSIVE — `{ min: 60 }` matches a value of exactly 60 —
- * because spec language is written that way ("LRV of 60 or more", "DCOF ≥ 0.42")
- * and because inclusive-both-ends means adjacent ranges overlap at the join
- * rather than leaving a gap that hides products.
- *
- * At least one bound is REQUIRED: a range with neither is a presence check, and
- * this throws rather than sending a criterion the server would have to refuse.
- * Discover which attributes take a range — and the span they actually occupy —
- * from `specificationFacets()`: those are the facets with `kind: "numeric"`.
- *
- * @example
- * // light paints, every brand at once
- * client.bySpec([], { ranges: [specRangeCriterion("light_reflectance_value", { min: 60 })] });
- * @example
- * // a mid-tone band
- * specRangeCriterion("light_reflectance_value", { min: 30, max: 45 }); // "light_reflectance_value:30..45"
- */
-export declare function specRangeCriterion(attributeId: string, bounds: {
-    min?: number;
-    max?: number;
-}): string;
-/**
- * An `attribute:value` criterion string for `bySpec` that filters by
- * certification PROGRAMME across all four certification buckets.
- *
- * The value may be a display name or alias ("GREENGUARD Gold", "LEED"), resolved
- * server-side to its canonical programme token, or a canonical token directly
- * (e.g. `greenguard_certificate`, `has_greenguard_gold_certification`).
- *
- * @example
- * // every brand's GREENGUARD-Gold materials
- * client.bySpec([certificationProgrammeCriterion("GREENGUARD Gold")]);
+ * client.search({ similarTo: { variantId: seed }, filters: [certificationProgramme("has_greenguard_gold_certification")] });
  */
-export declare function certificationProgrammeCriterion(programme: string): string;
+export declare const certificationProgramme: (programme: string) => CertificationProgrammeFilter;

package/specifications.js

@@ -1,24 +1,32 @@
 /**
- * Zero-dependency builders for the specification surface. Turn a plain-language
- * spec intent into a typed criterion the SDK's two spec operations accept:
- *
- * - `search({ filters })` takes {@link SpecFilter} objects — a spec gate layered
- *   onto a ranked (colour / visual / lexical) search. Build them with
- *   {@link specTerm}, {@link hasSpec}, and {@link certificationProgramme}.
- * - `bySpec(specs)` takes `attribute:value` strings — the value-anchored,
- *   spec-only primitive. Build them with {@link specCriterion} and
- *   {@link certificationProgrammeCriterion}.
+ * Zero-dependency builders for the specification surface. Turn a
+ * plain-language spec intent into a typed {@link SpecFilter} `search({
+ * filters })` accepts: hard token sets on the one search's index, run in the
+ * same query. Build them with {@link specTerm}, {@link hasSpec}, and
+ * {@link certificationProgramme}.
  *
  * The point of these helpers: Desk (and any spec-driven caller) never has to
- * remember that a certification programme lives under a VIRTUAL attribute, nor
- * hand-format the `attribute:value` string the `bySpec` route splits on its
- * first `:`.
+ * remember that a certification programme lives under a VIRTUAL attribute.
+ *
+ * A hard specification across every brand (formerly `bySpec`, built with
+ * `specCriterion`/`specRangeCriterion`) is now `list_variants`'s `filters`:
+ * `{field: attributeId, op: "in", values: [...]}` for a term,
+ * `{field: attributeId, op: "gte"/"lte"/etc, value}` for a number — a plain
+ * object literal needs no encoder (MG-2222).
+ */
+import { CERTIFICATION_PROGRAMME_ATTRIBUTE_ID } from "./spec-types.js";
+/**
+ * A hard criterion excluding one canonical value.
+ *
+ * By default retains only variants with a KNOWN value (unstated does not
+ * pass). Pass `whenUnstated: "pass"` to admit unstated variants too — only a
+ * variant that STATES the excluded term is dropped.
  */
-import { CERTIFICATION_PROGRAMME_ATTRIBUTE_ID, } from "./spec-types.js";
-/** A hard criterion excluding one known canonical value while retaining only variants with known values. */
-export function excludeSpec(attributeId, excludesTerm) {
-    return { attributeId, excludesTerm };
-}
+export const excludeSpec = (attributeId, excludesTerm, whenUnstated) => ({
+    attributeId,
+    excludesTerm,
+    ...(whenUnstated === undefined ? {} : { whenUnstated }),
+});
 /**
  * A term-equality criterion for `search({ filters })` — the attribute must
  * carry this canonical value.
@@ -27,9 +35,7 @@ export function excludeSpec(attributeId, excludesTerm) {
  * // "same fire class as the seed"
  * client.search({ similarTo: { variantId }, filters: [specTerm("fire_classifications", "astm_e84_class_a")] });
  */
-export function specTerm(attributeId, term) {
-    return { attributeId, term };
-}
+export const specTerm = (attributeId, term) => ({ attributeId, term });
 /**
  * A presence criterion for `search({ filters })` — the attribute must have ANY
  * accepted value.
@@ -38,81 +44,25 @@ export function specTerm(attributeId, term) {
  * // "…and it must have an EPD on record"
  * client.search({ similarTo: { variantId }, filters: [hasSpec("environmental_product_declaration")] });
  */
-export function hasSpec(attributeId) {
-    return { attributeId, hasValue: true };
-}
+export const hasSpec = (attributeId) => ({
+    attributeId,
+    hasValue: true,
+});
 /**
  * A certification-programme criterion for `search({ filters })`, pinned to the
  * virtual attribute so a programme matches wherever it landed at ingest
  * (compliance / sustainability / material-health / VOC buckets).
  *
- * The value may be a display name or alias ("GREENGUARD Gold", "LEED") — the
- * server resolves it to its canonical programme token before matching — or a
- * canonical token directly (e.g. `greenguard_certificate`,
- * `has_greenguard_gold_certification`).
+ * The value is a canonical programme token (e.g. `greenguard_certificate`,
+ * `has_greenguard_gold_certification`). The one search matches tokens on its
+ * index and does not resolve display names, so a name such as
+ * "GREENGUARD Gold" is a 400 naming the term.
  *
  * @example
  * // "find a GREENGUARD-certified alternative"
- * client.search({ similarTo: { variantId: seed }, filters: [certificationProgramme("GREENGUARD Gold")] });
- */
-export function certificationProgramme(programme) {
-    return { attributeId: CERTIFICATION_PROGRAMME_ATTRIBUTE_ID, term: programme };
-}
-/**
- * An `attribute:value` criterion string for `bySpec`. The `bySpec` route splits
- * on the FIRST `:`, so a value may itself contain colons; the attribute id may
- * not.
- *
- * @example
- * client.bySpec([specCriterion("primary_material", "textile"), specCriterion("fire_classifications", "astm_e84_class_a")]);
- */
-export function specCriterion(attributeId, value) {
-    return `${attributeId}:${value}`;
-}
-/**
- * An `attribute:min..max` RANGE criterion string for `bySpec`, for a
- * NUMBER-valued spec (`light_reflectance_value`, `nrc_rating`,
- * `slip_resistance_dcof`, …). Pass the result in `bySpec`'s `ranges` option.
- *
- * BOTH BOUNDS ARE INCLUSIVE — `{ min: 60 }` matches a value of exactly 60 —
- * because spec language is written that way ("LRV of 60 or more", "DCOF ≥ 0.42")
- * and because inclusive-both-ends means adjacent ranges overlap at the join
- * rather than leaving a gap that hides products.
- *
- * At least one bound is REQUIRED: a range with neither is a presence check, and
- * this throws rather than sending a criterion the server would have to refuse.
- * Discover which attributes take a range — and the span they actually occupy —
- * from `specificationFacets()`: those are the facets with `kind: "numeric"`.
- *
- * @example
- * // light paints, every brand at once
- * client.bySpec([], { ranges: [specRangeCriterion("light_reflectance_value", { min: 60 })] });
- * @example
- * // a mid-tone band
- * specRangeCriterion("light_reflectance_value", { min: 30, max: 45 }); // "light_reflectance_value:30..45"
- */
-export function specRangeCriterion(attributeId, bounds) {
-    const { min, max } = bounds;
-    if (min === undefined && max === undefined) {
-        throw new Error(`specRangeCriterion("${attributeId}") needs a min, a max, or both — a range with neither would match every recorded value. Use hasSpec() for a presence check.`);
-    }
-    if (min !== undefined && max !== undefined && min > max) {
-        throw new Error(`specRangeCriterion("${attributeId}") is inverted (min ${min} > max ${max}) and can only ever match nothing.`);
-    }
-    return `${attributeId}:${min ?? ""}..${max ?? ""}`;
-}
-/**
- * An `attribute:value` criterion string for `bySpec` that filters by
- * certification PROGRAMME across all four certification buckets.
- *
- * The value may be a display name or alias ("GREENGUARD Gold", "LEED"), resolved
- * server-side to its canonical programme token, or a canonical token directly
- * (e.g. `greenguard_certificate`, `has_greenguard_gold_certification`).
- *
- * @example
- * // every brand's GREENGUARD-Gold materials
- * client.bySpec([certificationProgrammeCriterion("GREENGUARD Gold")]);
+ * client.search({ similarTo: { variantId: seed }, filters: [certificationProgramme("has_greenguard_gold_certification")] });
  */
-export function certificationProgrammeCriterion(programme) {
-    return specCriterion(CERTIFICATION_PROGRAMME_ATTRIBUTE_ID, programme);
-}
+export const certificationProgramme = (programme) => ({
+    attributeId: CERTIFICATION_PROGRAMME_ATTRIBUTE_ID,
+    term: programme,
+});

package/sse.d.ts

@@ -11,11 +11,11 @@
  * chunks are held in an internal buffer until their terminating blank line.
  */
 /** One dispatched SSE frame. `data` is the joined data lines (no trailing newline). */
-export interface SseFrame {
+export type SseFrame = {
     id?: string;
     event?: string;
     data: string;
-}
+};
 /**
  * A push-based SSE line assembler. Feed it decoded text with {@link push}; it
  * returns any frames completed by that text. Call {@link flush} once the stream

package/sse.js

@@ -26,13 +26,15 @@ export class SseDecoder {
         const frames = [];
         for (;;) {
             const lineEnd = this.#nextLineEnd();
-            if (lineEnd === null)
+            if (lineEnd === null) {
                 break;
+            }
             const line = this.#buffer.slice(0, lineEnd.index);
             this.#buffer = this.#buffer.slice(lineEnd.nextIndex);
             const frame = this.#consumeLine(line);
-            if (frame)
+            if (frame) {
                 frames.push(frame);
+            }
         }
         return frames;
     }
@@ -45,8 +47,9 @@ export class SseDecoder {
                 : this.#buffer;
             this.#buffer = "";
             const frame = this.#consumeLine(line);
-            if (frame)
+            if (frame) {
                 return [frame];
+            }
         }
         const frame = this.#dispatch();
         return frame ? [frame] : [];
@@ -55,11 +58,13 @@ export class SseDecoder {
     #nextLineEnd() {
         for (let i = 0; i < this.#buffer.length; i += 1) {
             const char = this.#buffer[i];
-            if (char === "\n")
+            if (char === "\n") {
                 return { index: i, nextIndex: i + 1 };
+            }
             if (char === "\r") {
-                if (i === this.#buffer.length - 1)
+                if (i === this.#buffer.length - 1) {
                     return null;
+                }
                 return this.#buffer[i + 1] === "\n"
                     ? { index: i, nextIndex: i + 2 }
                     : { index: i, nextIndex: i + 1 };
@@ -68,15 +73,18 @@ export class SseDecoder {
         return null;
     }
     #consumeLine(line) {
-        if (line.length === 0)
+        if (line.length === 0) {
             return this.#dispatch();
-        if (line.startsWith(":"))
+        }
+        if (line.startsWith(":")) {
             return undefined;
+        }
         const colon = line.indexOf(":");
         const field = colon === -1 ? line : line.slice(0, colon);
         let value = colon === -1 ? "" : line.slice(colon + 1);
-        if (value.startsWith(" "))
+        if (value.startsWith(" ")) {
             value = value.slice(1);
+        }
         if (field === "data") {
             this.#dataLines.push(value);
             this.#hasFields = true;
@@ -92,13 +100,16 @@ export class SseDecoder {
         return undefined;
     }
     #dispatch() {
-        if (!this.#hasFields)
+        if (!this.#hasFields) {
             return undefined;
+        }
         const frame = { data: this.#dataLines.join("\n") };
-        if (this.#event !== undefined)
+        if (this.#event !== undefined) {
             frame.event = this.#event;
-        if (this.#id !== undefined)
+        }
+        if (this.#id !== undefined) {
             frame.id = this.#id;
+        }
         this.#dataLines = [];
         this.#event = undefined;
         this.#id = undefined;
@@ -117,28 +128,33 @@ export async function* readSseFrames(body, signal) {
     const sse = new SseDecoder();
     try {
         for (;;) {
-            if (signal?.aborted)
+            if (signal?.aborted) {
                 return;
+            }
             let result;
             try {
                 result = await reader.read();
             }
             catch (error) {
-                if (signal?.aborted)
+                if (signal?.aborted) {
                     return;
+                }
                 throw error;
             }
             if (result.done) {
-                for (const frame of sse.push(decoder.decode()))
+                for (const frame of sse.push(decoder.decode())) {
                     yield frame;
-                for (const frame of sse.flush())
+                }
+                for (const frame of sse.flush()) {
                     yield frame;
+                }
                 return;
             }
             const text = decoder.decode(result.value, { stream: true });
             for (const frame of sse.push(text)) {
-                if (signal?.aborted)
+                if (signal?.aborted) {
                     return;
+                }
                 yield frame;
             }
         }

package/substitute-types.d.ts

@@ -2,40 +2,40 @@ import type { BySpecVerdict } from "./by-spec-types.js";
 import type { VariantId } from "./identifiers.js";
 import type { MaterialSuccessor } from "./material-types.js";
 export type SubstituteSignatureFamily = "textile" | "tile" | "coating" | "lighting_electrical" | "acoustic" | "surface" | "furniture" | "sanitaryware" | "fittings" | "architectural_hardware";
-export interface SubstituteSignatureCriterion {
+export type SubstituteSignatureCriterion = {
     role: "primary_material" | "performance";
     attributeId: string;
     term: string;
-}
-export interface AvailableSubstituteSignature {
+};
+export type AvailableSubstituteSignature = {
     family: SubstituteSignatureFamily;
     form: string;
     criteria: [SubstituteSignatureCriterion, SubstituteSignatureCriterion];
-}
-export interface UnsupportedSubstituteSignature {
+};
+export type UnsupportedSubstituteSignature = {
     family: SubstituteSignatureFamily;
     form: string;
     reason: string;
-}
-export interface InsufficientSubstituteSignature {
+};
+export type InsufficientSubstituteSignature = {
     family: SubstituteSignatureFamily;
     form: string;
     missingRoles: ("primary_material" | "performance")[];
-}
-export interface FindSubstitutesOptions {
+};
+export type FindSubstitutesOptions = {
     excludeBrands?: string[];
     diversityBoost?: number;
     limit?: number;
     cursor?: string;
     includeSamplingArtifacts?: boolean;
     includeUnavailable?: boolean;
-}
-export interface SubstituteMatchedCriterion {
+};
+export type SubstituteMatchedCriterion = {
     attributeId: string;
     confidence: number | null;
     sourceBasis: string | null;
-}
-export interface SubstituteResultItem {
+};
+export type SubstituteResultItem = {
     variantId: VariantId;
     brandSlug: string;
     brand: string;
@@ -50,8 +50,8 @@ export interface SubstituteResultItem {
     diversityAdjustment: number;
     score: number;
     verdict: BySpecVerdict;
-}
-export interface AvailableSubstitutesResponse {
+};
+export type AvailableSubstitutesResponse = {
     status: "available";
     signatureUsed: AvailableSubstituteSignature;
     items: SubstituteResultItem[];
@@ -69,7 +69,7 @@ export interface AvailableSubstitutesResponse {
     poolTruncated: boolean;
     supersededBy: MaterialSuccessor | null;
     nextCursor?: string;
-}
+};
 /**
  * MG-1686. The search read a bounded window of the matches and nothing in it
  * reached the page, while more matches existed past the window. It is not an
@@ -77,7 +77,7 @@ export interface AvailableSubstitutesResponse {
  * empty `items`. `reason` names what happened and the next move; follow
  * `nextCursor` when it is present.
  */
-export interface InconclusiveSubstitutesResponse {
+export type InconclusiveSubstitutesResponse = {
     status: "inconclusive";
     signatureUsed: AvailableSubstituteSignature;
     items: [];
@@ -86,17 +86,17 @@ export interface InconclusiveSubstitutesResponse {
     reason: string;
     supersededBy: MaterialSuccessor | null;
     nextCursor?: string;
-}
-export interface UnsupportedSubstitutesResponse {
+};
+export type UnsupportedSubstitutesResponse = {
     status: "unsupported";
     signature: UnsupportedSubstituteSignature;
     items: [];
     supersededBy: MaterialSuccessor | null;
-}
-export interface InsufficientSubstitutesResponse {
+};
+export type InsufficientSubstitutesResponse = {
     status: "insufficient_signature";
     signature: InsufficientSubstituteSignature;
     items: [];
     supersededBy: MaterialSuccessor | null;
-}
+};
 export type FindSubstitutesResponse = AvailableSubstitutesResponse | InconclusiveSubstitutesResponse | UnsupportedSubstitutesResponse | InsufficientSubstitutesResponse;

package/suggest-types.d.ts

@@ -12,13 +12,12 @@
  * `mg.searchVocabulary()` covers attribute/value tokens. Suggestions are a page
  * of the best matches, never a census of matching entities.
  */
-import type { CorpusScope, CorpusScopeReceipt } from "./corpus-scope-types.js";
 /** Which kind of entity a suggestion is — and therefore what `refId` means. */
 export type SuggestKind = "product" | "brand" | "category";
 /** How the query met the suggestion's label. Strongest first. */
-export type SuggestMatch = "prefix" | "word" | "contains" | "fuzzy";
+export type SuggestMatch = "prefix" | "word" | "fuzzy";
 /** One ranked typeahead suggestion, carrying the identity it resolves to. */
-export interface Suggestion {
+export type Suggestion = {
     kind: SuggestKind;
     /** The entity's name as written, for display. */
     label: string;
@@ -36,27 +35,23 @@ export interface Suggestion {
      * Opaque, and null when none was picked — not a product without variants.
      */
     variantId: string | null;
-    /** Variants behind this entity IN MATERIALGRAPH — a coverage figure. */
+    /** How many of this entity's variants the search index holds: a coverage figure. */
     variantCount: number;
-}
+};
 /** The suggest response: the query as interpreted, plus the ranked suggestions. */
-export interface SuggestResponse {
-    /** The normalised query the corpus was matched against. */
+export type SuggestResponse = {
+    /** The typed words the search index was matched against. */
     query: string;
-    /** Ranked best-match-first. Empty when nothing came close — a miss, not an error. */
+    /** Ranked best-match-first. Empty when nothing came close: a miss, not an error. */
     suggestions: Suggestion[];
-    /** Present only when a narrowing governed corpus was applied. */
-    corpusScope?: CorpusScopeReceipt;
-}
+};
 /** Options for {@link MaterialGraphClient.suggest}. */
-export interface SuggestOptions {
+export type SuggestOptions = {
     /** How many suggestions to return (1–20, default 8). */
     limit?: number;
     /** Restrict to these kinds. Omit for all of them. */
     kind?: SuggestKind | SuggestKind[];
-    /** Governed corpus membership; absent means the whole graph. */
-    corpusScope?: CorpusScope;
-}
+};
 /**
  * Shape the query string for a suggest call.
  *
@@ -65,9 +60,8 @@ export interface SuggestOptions {
  * here rather than being sent as repeated `?kind=` pairs the route would ignore.
  * Undefined members are dropped by the transport.
  */
-export declare function suggestQuery(q: string, options?: SuggestOptions): {
+export declare const suggestQuery: (q: string, options?: SuggestOptions) => {
     q: string;
     limit?: number;
     kind?: string;
-    corpusScope?: CorpusScope;
 };

package/suggest-types.js

@@ -20,9 +20,9 @@
  * here rather than being sent as repeated `?kind=` pairs the route would ignore.
  * Undefined members are dropped by the transport.
  */
-export function suggestQuery(q, options) {
+export const suggestQuery = (q, options) => {
     const kind = Array.isArray(options?.kind)
         ? options.kind.join(",")
         : options?.kind;
-    return { q, limit: options?.limit, kind, corpusScope: options?.corpusScope };
-}
+    return { kind, limit: options?.limit, q };
+};

package/taxonomy-coverage-types.d.ts

@@ -1,5 +1,5 @@
 /** Exact, source-path-grained status coverage for primary product typing. */
-export interface ProductTypeStatusCoverageCounts {
+export type ProductTypeStatusCoverageCounts = {
     variants: number;
     accepted: number;
     proposed: number;
@@ -8,13 +8,13 @@ export interface ProductTypeStatusCoverageCounts {
     proposedUnknownConfidence: number;
     otherStatus: number;
     missingPrimary: number;
-}
-export interface ProductTypeStatusCoverageSourcePath extends ProductTypeStatusCoverageCounts {
+};
+export type ProductTypeStatusCoverageSourcePath = {
     /** Complete stored source path; null means the product retained no path. */
     sourcePath: string | null;
-}
+} & ProductTypeStatusCoverageCounts;
 /** Current primary-assignment coverage, never an inferred acceptance decision. */
-export interface ProductTypeStatusCoverage {
+export type ProductTypeStatusCoverage = {
     computedAt: string;
     basis: {
         count: "exact";
@@ -26,9 +26,9 @@ export interface ProductTypeStatusCoverage {
     };
     totals: ProductTypeStatusCoverageCounts;
     sourcePaths: ProductTypeStatusCoverageSourcePath[];
-}
-export interface ProductTypeCoverageOptions {
+};
+export type ProductTypeCoverageOptions = {
     [key: string]: number | undefined;
     /** Reporting cutoff in [0,1], default 0.85; it never accepts a proposal. */
     comparisonThreshold?: number;
-}
+};