@instruments/materialgraph 0.25.0 → 0.26.0

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

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;