@instruments/materialgraph 0.24.0 → 0.26.0

package/slot-pool-types.d.ts

@@ -61,11 +61,11 @@ export type SlotPoolCriterion = {
     coverageNote?: string;
 };
 /** A colour cue for a slot. Colours rerank within the retrieved set; they never admit. */
-export interface SlotPoolColourCue {
+export type SlotPoolColourCue = {
     /** `#rrggbb`. */
     hex: string;
     name?: string;
-}
+};
 /**
  * What to do with a candidate the catalogue no longer lists. Neither value ever
  * marks such a candidate eligible — the policy decides only whether it is
@@ -73,7 +73,7 @@ export interface SlotPoolColourCue {
  */
 export type SlotPoolAvailabilityPolicy = "flag-unavailable" | "exclude-unavailable";
 /** One slot of work. Self-contained: nothing in it identifies a project. */
-export interface SlotPoolTask {
+export type SlotPoolTask = {
     /**
      * YOUR key for this task, opaque to MaterialGraph and returned verbatim on the
      * matching pool. This is how you correlate 24 results; it is never parsed,
@@ -102,9 +102,9 @@ export interface SlotPoolTask {
     availability?: SlotPoolAvailabilityPolicy;
     /** Candidates returned for this task. Max 48, default 12. */
     limit?: number;
-}
+};
 /** Body for `POST /api/v1/schemes/pools` ({@link MaterialGraphClient.slotPools}). */
-export interface SlotPoolsRequest {
+export type SlotPoolsRequest = {
     /** Up to 24 tasks. Each is independent: one failing costs that one. */
     tasks: SlotPoolTask[];
     /**
@@ -112,11 +112,11 @@ export interface SlotPoolsRequest {
      * (default true). One bounded read — never one request per candidate.
      */
     coSpecification?: boolean;
-}
+};
 /** The six live verdict states, plus the two legacy tokens older rows carry. */
 export type SlotPoolVerdictState = OpenEnum<"matched" | "deviated" | "failed" | "unverified" | "missing" | "not_evaluated">;
 /** One cell of a candidate's report card against one criterion. */
-export interface SlotPoolVerdictCell {
+export type SlotPoolVerdictCell = {
     attributeId: string;
     state: SlotPoolVerdictState;
     strength: OpenEnum<"required" | "preferred">;
@@ -149,12 +149,12 @@ export interface SlotPoolVerdictCell {
     sourceBasis: string | null;
     trustGap: OpenEnum<"below_confidence" | "basis_unmet" | "proposed"> | null;
     citation?: VerdictCitation;
-}
+};
 /** Why a candidate is labelled. An eligible candidate carries none of these. */
 export type SlotPoolFlag = OpenEnum<"below-floor" | "required-not-applied" | "discontinued" | "superseded" | "unverified-value">;
 export type SlotPoolAvailability = OpenEnum<"available" | "discontinued" | "superseded" | "unknown">;
 /** The declared successor of a withdrawn material, one hop only. */
-export interface SlotPoolSuccessor {
+export type SlotPoolSuccessor = {
     variantId: VariantId;
     brandSlug: string;
     productId: string;
@@ -163,13 +163,13 @@ export interface SlotPoolSuccessor {
     variant: string;
     color: string | null;
     availability: SlotPoolAvailability;
-}
+};
 /**
  * The features a composer scores on. Colours are EXTRACTED FROM PRODUCT IMAGERY
  * — visual likeness, never a declared colour specification. An empty `palette`
  * or `attributes` means nothing is on record, never that the material has none.
  */
-export interface SlotPoolCandidateFeatures {
+export type SlotPoolCandidateFeatures = {
     colour: {
         dominantHex: string | null;
         hsl: {
@@ -201,8 +201,8 @@ export interface SlotPoolCandidateFeatures {
         term: string;
     }[];
     dimensions: Record<string, unknown>[] | null;
-}
-export interface SlotPoolCandidate {
+};
+export type SlotPoolCandidate = {
     variantId: VariantId;
     productId: string;
     brandSlug: string;
@@ -241,7 +241,7 @@ export interface SlotPoolCandidate {
         minConfidence: number | null;
     };
     features: SlotPoolCandidateFeatures;
-}
+};
 /**
  * Why a pool is short. Four different facts, and none of them is "nothing in
  * the catalogue matches your brief".
@@ -268,7 +268,7 @@ export type SlotPoolShortfall = {
     tier: string;
     consideredCount: number;
 };
-export interface SlotPool {
+export type SlotPool = {
     /** Your own key, verbatim. */
     taskKey: string;
     category: string | null;
@@ -305,14 +305,14 @@ export interface SlotPool {
         variantId: VariantId;
     } | null;
     warnings: string[];
-}
+};
 /**
  * The sparse pairing graph among the returned candidates. Each unordered pair
  * appears ONCE and the relation is symmetric. An empty `edges` under a null
  * `datasetSessionId` means the dataset is absent, NOT that these materials are
  * never specified together.
  */
-export interface SlotPoolCoSpecification {
+export type SlotPoolCoSpecification = {
     edges: {
         from: VariantId;
         to: VariantId;
@@ -326,9 +326,9 @@ export interface SlotPoolCoSpecification {
         window: string;
         signal: string;
     };
-}
+};
 /** The `200` body from `POST /api/v1/schemes/pools`. */
-export interface SlotPoolsResponse {
+export type SlotPoolsResponse = {
     versions: {
         contract: string;
         retrieval: string;
@@ -369,4 +369,4 @@ export interface SlotPoolsResponse {
         coSpecificationQueries: number;
     };
     warnings: string[];
-}
+};

package/source-material-validation.d.ts

@@ -1,7 +1,7 @@
 import type { PostSourceMaterialCommentResult, SourceMaterialBatchDetail, SourceMaterialCommentThread } from "./run-types.js";
 /** Validate a batch-detail body, returning it typed, or throw explaining why. */
-export declare function checkSourceMaterialBatchDetail(value: unknown, batchId: string): SourceMaterialBatchDetail;
+export declare const checkSourceMaterialBatchDetail: (value: unknown, batchId: string) => SourceMaterialBatchDetail;
 /** Validate a comment-thread body, returning it typed, or throw explaining why. */
-export declare function checkSourceMaterialCommentThread(value: unknown, sourceId: string): SourceMaterialCommentThread;
+export declare const checkSourceMaterialCommentThread: (value: unknown, sourceId: string) => SourceMaterialCommentThread;
 /** Validate a posted-comment body, returning it typed, or throw explaining why. */
-export declare function checkPostSourceMaterialCommentResult(value: unknown, sourceId: string): PostSourceMaterialCommentResult;
+export declare const checkPostSourceMaterialCommentResult: (value: unknown, sourceId: string) => PostSourceMaterialCommentResult;

package/source-material-validation.js

@@ -48,23 +48,21 @@ const SOURCE_ROLES = [
     "inspiration_image",
     "unclassified",
 ];
-function detailFailure(batchId) {
-    return (reason) => MaterialGraphError.unexpected(`GET /api/v1/source-material/${batchId} returned a malformed body: ${reason}`);
-}
-function checkAnalysis(value, what, fail) {
+const detailFailure = (batchId) => (reason) => MaterialGraphError.unexpected(`GET /api/v1/source-material/${batchId} returned a malformed body: ${reason}`);
+const checkAnalysis = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     // `model` and `analysedAt` ARE `.min(1)` canonically — fields this endpoint
     // introduces, where an empty value is meaningless and `model` already cannot
     // be written empty. Parity here is achieved by the schema being strict, never
     // by this mirror freelancing past it.
     return {
+        analysedAt: requireNonEmptyString(record.analysedAt, `${what}.analysedAt`, fail),
         kind: requireEnum(record.kind, ANALYSIS_KINDS, `${what}.kind`, fail),
         model: requireNonEmptyString(record.model, `${what}.model`, fail),
-        status: requireEnum(record.status, ANALYSIS_STATUSES, `${what}.status`, fail),
         result: requireJsonRecord(record.result, `${what}.result`, fail),
-        analysedAt: requireNonEmptyString(record.analysedAt, `${what}.analysedAt`, fail),
+        status: requireEnum(record.status, ANALYSIS_STATUSES, `${what}.status`, fail),
     };
-}
+};
 /** `sourceMaterialCommentAuthorSchema`'s `attribution` members, verbatim. */
 const COMMENT_ATTRIBUTIONS = ["reported"];
 /** The canonical cap on both author fields: `.trim().min(1).max(160)`. */
@@ -84,27 +82,27 @@ const AUTHOR_FIELD_MAX = 160;
  * schema caps. A validator that is looser than the contract is a validator that
  * lets the two drift without anything failing.
  */
-function checkCommentBase(record, what, fail) {
+const checkCommentBase = (record, what, fail) => {
     const author = requireRecord(record.author, `${what}.author`, fail);
     const recordedBy = requireRecord(record.recordedBy, `${what}.recordedBy`, fail);
     return {
-        commentId: requireNonEmptyString(record.commentId, `${what}.commentId`, fail),
         author: {
-            name: requireTrimmedBoundedString(author.name, `${what}.author.name`, AUTHOR_FIELD_MAX, fail),
-            organisation: requireNullableTrimmedBoundedString(author.organisation, `${what}.author.organisation`, AUTHOR_FIELD_MAX, fail),
             // Closed here, matching the canonical `z.literal("reported")`, while the
             // published type is `OpenEnum` so a newer server value keeps
             // type-checking — the same split the analysis enums make.
             attribution: requireEnum(author.attribution, COMMENT_ATTRIBUTIONS, `${what}.author.attribution`, fail),
+            name: requireTrimmedBoundedString(author.name, `${what}.author.name`, AUTHOR_FIELD_MAX, fail),
+            organisation: requireNullableTrimmedBoundedString(author.organisation, `${what}.author.organisation`, AUTHOR_FIELD_MAX, fail),
         },
+        body: requireNonEmptyString(record.body, `${what}.body`, fail),
+        commentId: requireNonEmptyString(record.commentId, `${what}.commentId`, fail),
+        createdAt: requireNonEmptyString(record.createdAt, `${what}.createdAt`, fail),
         recordedBy: {
             principalId: requireNonEmptyString(recordedBy.principalId, `${what}.recordedBy.principalId`, fail),
         },
-        body: requireNonEmptyString(record.body, `${what}.body`, fail),
-        createdAt: requireNonEmptyString(record.createdAt, `${what}.createdAt`, fail),
     };
-}
-function checkComment(value, what, fail) {
+};
+const checkComment = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     // Same reasoning as `analyses`: no `.default([])` canonically, so an absent
     // `replies` is malformed rather than empty.
@@ -113,8 +111,8 @@ function checkComment(value, what, fail) {
         ...checkCommentBase(record, what, fail),
         replies: replies.map((reply, index) => checkCommentBase(requireRecord(reply, `${what}.replies[${index}]`, fail), `${what}.replies[${index}]`, fail)),
     };
-}
-function checkFile(value, what, fail) {
+};
+const checkFile = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     // NOT `requireDefaultedArray`: the schema has no `.default([])`, so an absent
     // `analyses` is a malformed body rather than an empty one. Keeping that
@@ -133,11 +131,7 @@ function checkFile(value, what, fail) {
     // refuse a response the server can legitimately produce, and tightening them
     // is a change to a contract this endpoint does not own.
     return {
-        sourceId: requireString(record.sourceId, `${what}.sourceId`, fail),
-        role: requireEnum(record.role, SOURCE_ROLES, `${what}.role`, fail),
-        filename: requireString(record.filename, `${what}.filename`, fail),
-        mediaType: requireString(record.mediaType, `${what}.mediaType`, fail),
-        sha256: requireString(record.sha256, `${what}.sha256`, fail),
+        analyses: analyses.map((analysis, index) => checkAnalysis(analysis, `${what}.analyses[${index}]`, fail)),
         // `requireSafeInteger`, NOT `requireIntegerAtLeast(…, 0)`. Canonically these
         // are a bare `z.number().int()` on the INHERITED
         // `sourceMaterialFileReceiptSchema`, which carries no lower bound — so a
@@ -150,17 +144,21 @@ function checkFile(value, what, fail) {
         // fields is a canonical change to a schema shared with the upload path, and
         // belongs in its own ticket with this mirror following after.
         bytes: requireSafeInteger(record.bytes, `${what}.bytes`, fail),
+        comments: comments.map((comment, index) => checkComment(comment, `${what}.comments[${index}]`, fail)),
+        commentsTruncated,
+        filename: requireString(record.filename, `${what}.filename`, fail),
+        mediaType: requireString(record.mediaType, `${what}.mediaType`, fail),
         pages: record.pages === null
             ? null
             : requireSafeInteger(record.pages, `${what}.pages`, fail),
+        role: requireEnum(record.role, SOURCE_ROLES, `${what}.role`, fail),
+        sha256: requireString(record.sha256, `${what}.sha256`, fail),
+        sourceId: requireString(record.sourceId, `${what}.sourceId`, fail),
         url: requireString(record.url, `${what}.url`, fail),
-        analyses: analyses.map((analysis, index) => checkAnalysis(analysis, `${what}.analyses[${index}]`, fail)),
-        comments: comments.map((comment, index) => checkComment(comment, `${what}.comments[${index}]`, fail)),
-        commentsTruncated,
     };
-}
+};
 /** Validate a batch-detail body, returning it typed, or throw explaining why. */
-export function checkSourceMaterialBatchDetail(value, batchId) {
+export const checkSourceMaterialBatchDetail = (value, batchId) => {
     const fail = detailFailure(batchId);
     const record = requireRecord(value, "body", fail);
     const sources = requireArray(record.sources, "body.sources", fail);
@@ -169,21 +167,19 @@ export function checkSourceMaterialBatchDetail(value, batchId) {
         createdAt: requireString(record.createdAt, "body.createdAt", fail),
         sources: sources.map((file, index) => checkFile(file, `body.sources[${index}]`, fail)),
     };
-}
-function commentsFailure(verb, sourceId) {
-    return (reason) => MaterialGraphError.unexpected(`${verb} .../sources/${sourceId}/comments returned a malformed body: ${reason}`);
-}
+};
+const commentsFailure = (verb, sourceId) => (reason) => MaterialGraphError.unexpected(`${verb} .../sources/${sourceId}/comments returned a malformed body: ${reason}`);
 /** Validate a comment-thread body, returning it typed, or throw explaining why. */
-export function checkSourceMaterialCommentThread(value, sourceId) {
+export const checkSourceMaterialCommentThread = (value, sourceId) => {
     const fail = commentsFailure("GET", sourceId);
     const record = requireRecord(value, "body", fail);
     const comments = requireArray(record.comments, "body.comments", fail);
     return {
-        sourceId: requireString(record.sourceId, "body.sourceId", fail),
         comments: comments.map((comment, index) => checkComment(comment, `body.comments[${index}]`, fail)),
+        sourceId: requireString(record.sourceId, "body.sourceId", fail),
         truncated: requireBoolean(record.truncated, "body.truncated", fail),
     };
-}
+};
 /** `storedSourceMaterialCommentSchema`'s discriminator members, verbatim. */
 const STORED_COMMENT_KINDS = ["root", "reply"];
 /**
@@ -195,7 +191,7 @@ const STORED_COMMENT_KINDS = ["root", "reply"];
  * defect this discriminated union was added to fix, and a mirror that did it
  * would put the lie back on the client side.
  */
-function checkStoredComment(value, what, fail) {
+const checkStoredComment = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     const kind = requireEnum(record.kind, STORED_COMMENT_KINDS, `${what}.kind`, fail);
     if (kind === "reply") {
@@ -206,13 +202,13 @@ function checkStoredComment(value, what, fail) {
         };
     }
     return { kind: "root", ...checkComment(record, what, fail) };
-}
+};
 /** Validate a posted-comment body, returning it typed, or throw explaining why. */
-export function checkPostSourceMaterialCommentResult(value, sourceId) {
+export const checkPostSourceMaterialCommentResult = (value, sourceId) => {
     const fail = commentsFailure("POST", sourceId);
     const record = requireRecord(value, "body", fail);
     return {
-        sourceId: requireString(record.sourceId, "body.sourceId", fail),
         comment: checkStoredComment(record.comment, "body.comment", fail),
+        sourceId: requireString(record.sourceId, "body.sourceId", fail),
     };
-}
+};

package/spec-facet-types.d.ts

@@ -1,9 +1,9 @@
-export interface SpecFacetValue {
+export type SpecFacetValue = {
     value: string;
     variants: number;
     brands: number;
     label?: string;
-}
+};
 /**
  * A NUMERIC facet's observed span and the coverage behind it.
  *
@@ -17,13 +17,13 @@ export interface SpecFacetValue {
  * `unparseableVariants` is the honesty companion: values recorded here that are
  * not numbers, which a range EXCLUDES rather than reading as zero.
  */
-export interface SpecFacetRange {
+export type SpecFacetRange = {
     min: number;
     max: number;
     variants: number;
     unparseableVariants: number;
-}
-export interface SpecFacet {
+};
+export type SpecFacet = {
     attributeId: string;
     name: string;
     isArray: boolean;
@@ -39,15 +39,15 @@ export interface SpecFacet {
     /** Present ONLY on a `numeric` facet. */
     range?: SpecFacetRange;
     description?: string;
-}
-export interface SpecFacetsListResponse {
+};
+export type SpecFacetsListResponse = {
     mode: "facets";
     count: number;
     facets: SpecFacet[];
-}
-export interface SpecFacetsDistributionResponse {
+};
+export type SpecFacetsDistributionResponse = {
     mode: "distribution";
     attributeId: string;
     count: number;
     values: SpecFacetValue[];
-}
+};

package/spec-types.d.ts

@@ -60,15 +60,15 @@ export type CertificationProgrammeAttributeId = typeof CERTIFICATION_PROGRAMME_A
  * and `client.attributeValues()`, or resolve free text with
  * `client.resolveAttribute()`.
  */
-export interface SpecTermFilter {
+export type SpecTermFilter = {
     attributeId: string;
     term: string;
-}
+};
 /** A negative spec criterion; absence of a value remains unproven. */
-export interface SpecExclusionFilter {
+export type SpecExclusionFilter = {
     attributeId: string;
     excludesTerm: string;
-}
+};
 /**
  * A presence spec criterion: the attribute must have ANY accepted value —
  * "has an EPD on record", "has a measured slip figure at all". Not supported for
@@ -90,10 +90,10 @@ export type SpecPresenceFilter = {
  * virtual {@link CERTIFICATION_PROGRAMME_ATTRIBUTE_ID}. Structurally assignable
  * to {@link SpecFilter}, so it drops straight into `search({ filters })`.
  */
-export interface CertificationProgrammeFilter {
+export type CertificationProgrammeFilter = {
     attributeId: CertificationProgrammeAttributeId;
     term: string;
-}
+};
 /**
  * A hard, canonical-attribute spec criterion — either a term match or a
  * presence check. The union the search engine applies as a restriction BEFORE

package/specifications.d.ts

@@ -1,22 +1,6 @@
-/**
- * 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}.
- *
- * 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 `:`.
- */
-import { type CertificationProgrammeFilter, type SpecExclusionFilter, type SpecPresenceFilter, type SpecTermFilter } from "./spec-types.js";
+import type { CertificationProgrammeFilter, SpecExclusionFilter, SpecPresenceFilter, 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) => SpecExclusionFilter;
 /**
  * A term-equality criterion for `search({ filters })` — the attribute must
  * carry this canonical value.
@@ -25,7 +9,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,7 +18,7 @@ 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
@@ -49,7 +33,7 @@ export declare function hasSpec(attributeId: string): SpecPresenceFilter;
  * // "find a GREENGUARD-certified alternative"
  * client.search({ similarTo: { variantId: seed }, filters: [certificationProgramme("GREENGUARD Gold")] });
  */
-export declare function certificationProgramme(programme: string): CertificationProgrammeFilter;
+export declare const 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
@@ -58,7 +42,7 @@ export declare function certificationProgramme(programme: string): Certification
  * @example
  * client.bySpec([specCriterion("primary_material", "textile"), specCriterion("fire_classifications", "astm_e84_class_a")]);
  */
-export declare function specCriterion(attributeId: string, value: string): string;
+export declare const 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`,
@@ -81,10 +65,10 @@ export declare function specCriterion(attributeId: string, value: string): strin
  * // a mid-tone band
  * specRangeCriterion("light_reflectance_value", { min: 30, max: 45 }); // "light_reflectance_value:30..45"
  */
-export declare function specRangeCriterion(attributeId: string, bounds: {
+export declare const specRangeCriterion: (attributeId: string, bounds: {
     min?: number;
     max?: number;
-}): string;
+}) => string;
 /**
  * An `attribute:value` criterion string for `bySpec` that filters by
  * certification PROGRAMME across all four certification buckets.
@@ -97,4 +81,4 @@ export declare function specRangeCriterion(attributeId: string, bounds: {
  * // every brand's GREENGUARD-Gold materials
  * client.bySpec([certificationProgrammeCriterion("GREENGUARD Gold")]);
  */
-export declare function certificationProgrammeCriterion(programme: string): string;
+export declare const certificationProgrammeCriterion: (programme: string) => string;

package/specifications.js

@@ -14,11 +14,9 @@
  * hand-format the `attribute:value` string the `bySpec` route splits on its
  * first `:`.
  */
-import { CERTIFICATION_PROGRAMME_ATTRIBUTE_ID, } from "./spec-types.js";
+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) => ({ attributeId, excludesTerm });
 /**
  * A term-equality criterion for `search({ filters })` — the attribute must
  * carry this canonical value.
@@ -27,9 +25,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,9 +34,10 @@ 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
@@ -55,9 +52,10 @@ export function hasSpec(attributeId) {
  * // "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 };
-}
+export const certificationProgramme = (programme) => ({
+    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
@@ -66,9 +64,7 @@ export function certificationProgramme(programme) {
  * @example
  * client.bySpec([specCriterion("primary_material", "textile"), specCriterion("fire_classifications", "astm_e84_class_a")]);
  */
-export function specCriterion(attributeId, value) {
-    return `${attributeId}:${value}`;
-}
+export const specCriterion = (attributeId, value) => `${attributeId}:${value}`;
 /**
  * An `attribute:min..max` RANGE criterion string for `bySpec`, for a
  * NUMBER-valued spec (`light_reflectance_value`, `nrc_rating`,
@@ -91,7 +87,7 @@ export function specCriterion(attributeId, value) {
  * // a mid-tone band
  * specRangeCriterion("light_reflectance_value", { min: 30, max: 45 }); // "light_reflectance_value:30..45"
  */
-export function specRangeCriterion(attributeId, bounds) {
+export const 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.`);
@@ -100,7 +96,7 @@ export function specRangeCriterion(attributeId, bounds) {
         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.
@@ -113,6 +109,4 @@ export function specRangeCriterion(attributeId, bounds) {
  * // every brand's GREENGUARD-Gold materials
  * client.bySpec([certificationProgrammeCriterion("GREENGUARD Gold")]);
  */
-export function certificationProgrammeCriterion(programme) {
-    return specCriterion(CERTIFICATION_PROGRAMME_ATTRIBUTE_ID, programme);
-}
+export const certificationProgrammeCriterion = (programme) => specCriterion(CERTIFICATION_PROGRAMME_ATTRIBUTE_ID, 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