@instruments/materialgraph 0.25.0 → 0.27.0

package/palette-search-types.d.ts

@@ -1,3 +1,4 @@
+import type { ColourCategoryGate } from "./by-colour-types.js";
 import type { CorpusScope, CorpusScopeReceipt } from "./corpus-scope-types.js";
 /**
  * Wire types for MULTI-COLOUR search — `POST /api/v1/search/palettes` and
@@ -17,67 +18,91 @@ import type { OklabTriple, OpenEnum } from "./types.js";
 /** How the per-colour scores are combined across a palette. */
 export type PaletteLogic = OpenEnum<"all" | "any">;
 /** One queried palette colour — exactly one of `hex` or `oklab`. */
-export interface PaletteQueryColour {
+export type PaletteQueryColour = {
     hex?: string;
     oklab?: OklabTriple;
     /**
-     * Share of the surface this colour should occupy, in (0,1]. Stating it
-     * CHANGES the ranking: a colour asked for at 0.6 rewards candidates whose own
-     * swatch sits near 0.6, not merely candidates that contain the colour.
+     * Share of the surface this colour should occupy, in (0,1]. A colour stated
+     * below 5% is dropped; otherwise not applied, since a palette is ordered by
+     * its first colour alone.
      */
     proportion?: number;
-    /** Relative importance; defaults to 1 and is normalised across the query. */
+    /** Relative importance. Not applied: a palette is ordered by its first colour. */
     weight?: number;
-}
+};
 /** One gradient stop — exactly one of `hex` or `oklab`. Order is meaningful. */
-export interface GradientStop {
+export type GradientStop = {
     hex?: string;
     oklab?: OklabTriple;
-}
-export interface SearchPaletteInput {
+};
+export type SearchPaletteInput = {
+    /**
+     * HARD category filter: category-group or product-type names or keys.
+     * Absent, the page holds surface materials only, so lights, taps and
+     * furniture are left out.
+     */
+    category?: string[];
     corpusScope?: CorpusScope;
-    /** The palette to match, 1–8 colours. */
+    /**
+     * The palette to match, 1–8 colours. The page is ordered by the FIRST colour;
+     * the rest come back in `query.droppedColours`.
+     */
     colours: PaletteQueryColour[];
     /**
-     * `all` (the default) requires every queried colour to clear a per-colour
-     * eligibility floor and scores the weighted geometric mean; `any` is a
-     * noisy-OR and never rejects a candidate for missing one colour.
+     * Kept so existing callers still parse: the one search orders the page by
+     * the first colour with no eligibility floor, so `all` and `any` return the
+     * same page.
      */
     logic?: PaletteLogic;
     /** Results to return; defaults to 24, capped at 48. */
     limit?: number;
-}
-export interface SearchGradientInput {
+};
+export type SearchGradientInput = {
+    /**
+     * HARD category filter: category-group or product-type names or keys.
+     * Absent, the page holds surface materials only, so lights, taps and
+     * furniture are left out.
+     */
+    category?: string[];
     corpusScope?: CorpusScope;
     /** The ordered colour transition, 2–6 stops. */
     stops: GradientStop[];
     /** Results to return; defaults to 24, capped at 48. */
     limit?: number;
-}
+};
 /**
  * One swatch used for scoring. Samplize paint uses its selected published hex;
  * other materials use colorscope palettes extracted from imagery. `name` is null when no human
  * name was resolved — unnamed, not colourless.
  */
-export interface CandidateSwatch {
+export type CandidateSwatch = {
     hex: string;
     proportion: number;
     name: string | null;
-}
+};
 /** Why a queried colour (or gradient sample) scored what it scored. */
-export interface ColourMatchReceipt {
+export type ColourMatchReceipt = {
     queryHex: string;
-    /** `colourScore × proportionScore` for the best-matching swatch. */
+    /** `colourScore × proportionScore`, so `colourScore` on the one search. */
     score: number;
-    /** OKLab closeness alone, in [0,1]. */
+    /**
+     * Closeness in [0,1] of the matched swatch to the queried colour, from plain
+     * OKLab distance with lightness counted in full. Not a confidence.
+     */
     colourScore: number;
-    /** Proportion agreement alone, in [0,1]. */
+    /** Proportion agreement; always 1, since no proportion is applied. */
     proportionScore: number;
     /** The swatch that produced the score, or null when nothing matched. */
     matched: CandidateSwatch | null;
-}
+    /**
+     * Whether `matched` has a hue compatible with the queried colour, at the
+     * response's `hueGate` thresholds. A flag, never a gate: an incompatible
+     * swatch still scores and ranks. Absent when there is no `matched` swatch.
+     */
+    hueCompatible?: boolean;
+};
 /** Identity and evidence shared by both multi-colour match shapes. */
-export interface MultiColourMatchBase {
+export type MultiColourMatchBase = {
     /** Opaque — round-trip verbatim. */
     variantId: VariantId;
     brand: string;
@@ -87,6 +112,11 @@ export interface MultiColourMatchBase {
     color: string | null;
     variantName: string | null;
     imageUrl: string | null;
+    /**
+     * SHA-256 of the displayed image `imageUrl` points at, as a hex digest.
+     * ABSENT means no hash is on record, never that there is no image.
+     */
+    imageSha256?: string;
     /** MB has retired or hidden this SKU. */
     retired: boolean;
     /**
@@ -103,80 +133,85 @@ export interface MultiColourMatchBase {
     category: string | null;
     /** The candidate's full extracted palette — the evidence scored against. */
     palette: CandidateSwatch[];
-    /** The aggregate match score in [0,1]; higher is closer. */
+    /**
+     * Closeness in [0,1] of the material's own colour to the searched colour,
+     * the page's order. Not a confidence or a percentage.
+     */
     score: number;
-}
-export interface PaletteMatch extends MultiColourMatchBase {
+};
+export type PaletteMatch = {
     /** One receipt per queried colour, in query order. */
     colours: ColourMatchReceipt[];
-}
-export interface GradientMatch extends MultiColourMatchBase {
+} & MultiColourMatchBase;
+export type GradientMatch = {
     /**
-     * Distinct matched thirds of the path over 3. A material owning only one end
-     * of the transition caps out around 0.33 — coverage is what separates a real
-     * gradient match from a good match on a single stop.
+     * Thirds of the path where the material holds a swatch near a sampled point,
+     * over 3. A receipt beside the order, which is by the first stop.
      */
     coverage: number;
     /** One receipt per sampled point along the path, in path order. */
     samples: ColourMatchReceipt[];
-}
+} & MultiColourMatchBase;
 /**
- * The hue-family ADMISSION gate the page was scored under: a candidate swatch
- * may satisfy a query colour only if colorscope's `isHueCompatible` admits it
- * at these exact thresholds. A refused swatch is absent from that colour's
- * matching entirely — it did not merely rank low. Admission, not ranking: it
- * decides which swatches count, never their order. Server-side and fixed (no
- * request knob); the receipt exists so a threshold change is visible on the
- * wire.
+ * The thresholds behind every receipt's `hueCompatible`: the exact values
+ * passed to colorscope's `isHueCompatible`, fixed server-side with no request
+ * knob. A FLAG, never admission or ranking: every swatch still scores, and the
+ * page and its order are the same with or without it.
  */
-export interface HueGateReceipt {
+export type HueGateReceipt = {
     /** Below this query chroma the colour is achromatic and any hue is admitted. */
     achromaticQueryChroma: number;
     /** A swatch must carry at least this share of the query colour's chroma. */
     minChromaRatio: number;
     /** Floor on the cosine agreement between the two hue vectors. */
     minHueCosine: number;
-}
+};
 /**
  * A PAGE, NOT A CORPUS. `count` is `matches.length` under `limit` (24 default,
  * 48 max) — this surface states no corpus total and has no cursor, so "N
  * materials match this palette" is not a claim you can make from it.
  */
-export interface SearchPaletteResponse {
+export type SearchPaletteResponse = {
     corpusScope?: CorpusScopeReceipt;
     /** The query as interpreted — check it before trusting a surprising order. */
     query: {
         /** Colours that actually ran after minor stated shares were omitted. */
-        colours: Array<{
+        colours: {
             hex: string;
             proportion?: number;
             weight?: number;
-        }>;
+        }[];
         /** Colours not searched because their stated share was below 5%. */
-        droppedColours: Array<{
+        droppedColours: {
             hex: string;
             proportion?: number;
             weight?: number;
-        }>;
+        }[];
         logic: PaletteLogic;
         /** `no_effective_colours` means no material query ran. */
         outcome: OpenEnum<"matches" | "no_effective_colours">;
     };
-    /** The hue-family admission gate this page was scored under. */
-    hueGate: HueGateReceipt;
+    /** The category gate the page ran under. */
+    categoryGate?: ColourCategoryGate;
+    /** The thresholds behind each receipt's `hueCompatible`. Absent only on responses stored before it existed. */
+    hueGate?: HueGateReceipt;
     /** `matches.length`, capped by `limit`. Never a corpus total. */
     count: number;
     matches: PaletteMatch[];
-}
+};
 /** A PAGE, NOT A CORPUS — see {@link SearchPaletteResponse}. */
-export interface SearchGradientResponse {
+export type SearchGradientResponse = {
+    /** The category gate the page ran under. */
+    categoryGate?: ColourCategoryGate;
     corpusScope?: CorpusScopeReceipt;
     query: {
         stops: string[];
         /** The sampled path points the search actually ran against. */
         samples: string[];
     };
+    /** The thresholds behind each sample receipt's `hueCompatible`. */
+    hueGate?: HueGateReceipt;
     /** `matches.length`, capped by `limit`. Never a corpus total. */
     count: number;
     matches: GradientMatch[];
-}
+};

package/query-understanding-types.d.ts

@@ -3,7 +3,7 @@ import type { ColorResolution } from "@instruments/colorscope/naming";
 import type { SearchFilter } from "./search-refinement-types.js";
 import type { OpenEnum } from "./types.js";
 export type QuerySenseKind = OpenEnum<"brand" | "product" | "paint_identity" | "category" | "material" | "colour" | "attribute" | "attribute_value" | "certification">;
-export interface QuerySense {
+export type QuerySense = {
     id: string;
     kind: QuerySenseKind;
     label: string;
@@ -28,14 +28,14 @@ export interface QuerySense {
         hex?: string;
     };
     reason?: string;
-}
-export interface CanonicalLexicalAuthorityReceipt {
+};
+export type CanonicalLexicalAuthorityReceipt = {
     authority: OpenEnum<"taxonomy" | "colorscope">;
     version: string;
     revision: string;
     digest?: string;
-}
-export interface CanonicalLexicalReading {
+};
+export type CanonicalLexicalReading = {
     matchTarget?: MatchTarget;
     colorResolution?: ColorResolution;
     authority: OpenEnum<"taxonomy" | "colorscope">;
@@ -63,8 +63,8 @@ export interface CanonicalLexicalReading {
         snapshot?: string;
         source: string;
     };
-}
-export interface CanonicalLexicalMatch {
+};
+export type CanonicalLexicalMatch = {
     original: string;
     canonical: string;
     rule: OpenEnum<"exact" | "plural-to-singular" | "typo-to-canonical">;
@@ -80,24 +80,24 @@ export interface CanonicalLexicalMatch {
         rule: OpenEnum<"exact" | "plural-to-singular" | "typo-to-canonical">;
         authorities: CanonicalLexicalAuthorityReceipt[];
     };
-}
-export interface CanonicalLexicalReceipt {
+};
+export type CanonicalLexicalReceipt = {
     original: string;
     outcome: OpenEnum<"resolved" | "ambiguous" | "declined" | "partial" | "unresolved">;
     matches: CanonicalLexicalMatch[];
     unresolved: CanonicalLexicalMatch[];
-}
-export interface QueryResidualReceipt {
+};
+export type QueryResidualReceipt = {
     kind: OpenEnum<"compound" | "descriptive" | "ambiguous" | "empty">;
     tokens: string[];
     resolvedTokens: string[];
     unresolvedTokens: string[];
     resolvedRatio: number;
     comparisonFrame: boolean;
-}
+};
 /** Deterministic criteria compiled from the query before retrieval. */
-export interface QueryCriteriaReceipt {
-    applied: Array<{
+export type QueryCriteriaReceipt = {
+    applied: {
         criterion: SearchFilter;
         lane: OpenEnum<"filter" | "preference">;
         lexicalSignal?: {
@@ -114,30 +114,30 @@ export interface QueryCriteriaReceipt {
         };
         source: OpenEnum<"compiled" | "taxonomy-adapter">;
         span: string;
-    }>;
-    conflicts: Array<{
+    }[];
+    conflicts: {
         attributeId: string;
         caller: SearchFilter;
         compiled: SearchFilter;
         reason: string;
-    }>;
-    exclusions: Array<{
+    }[];
+    exclusions: {
         criterion: SearchFilter;
         execution: OpenEnum<"blocked-positive-only-contract">;
         lane: OpenEnum<"hard" | "soft">;
         missingValuePolicy: OpenEnum<"retain-unknown">;
         span: string;
-    }>;
+    }[];
     preferences: SearchFilter[];
     residualText: string | null;
-    unresolved: Array<{
+    unresolved: {
         code: OpenEnum<"missing-searchable-attribute" | "missing-dimension-pair-contract" | "missing-explicit-comparator" | "negative-criterion-contract-blocked" | "registry-contract-drift" | "unsupported-numeric-format" | "unsupported-unit" | "unsupported-strict-comparator">;
         reason: string;
         span: string;
-    }>;
-}
+    }[];
+};
 /** How the query named or inferred a product type before retrieval. */
-export interface QueryProductTypeReceipt {
+export type QueryProductTypeReceipt = {
     kind: OpenEnum<"leaf" | "group" | "vector" | "ambiguous" | "none">;
     gate: OpenEnum<"hard" | "constrain" | "none">;
     pass: OpenEnum<"taxonomy" | "synonym" | "display-name" | "group" | "head-noun" | "vector" | "none">;
@@ -152,14 +152,14 @@ export interface QueryProductTypeReceipt {
     vectorPassRan: boolean;
     registryVersion: string;
     durationMs: number;
-    candidates: Array<{
+    candidates: {
         productTypeId: string;
         displayName: string;
         similarity: number;
-    }>;
-}
+    }[];
+};
 /** The selected retrieval arm; null when the path is browse or criteria-only. */
-export interface QueryArmReceipt {
+export type QueryArmReceipt = {
     arm: OpenEnum<"dense" | "lexical" | "colour"> | null;
     reason: string;
     reasonDetail?: OpenEnum<"derived-colour-veto" | "typo-recovery" | "literal-compound-without-type">;
@@ -169,8 +169,8 @@ export interface QueryArmReceipt {
     productTypeIds: string[];
     residual: QueryResidualReceipt;
     registryVersion: string;
-}
-export interface QueryAmbiguityReceipt {
+};
+export type QueryAmbiguityReceipt = {
     outcome: OpenEnum<"applied" | "abstained" | "refused" | "timeout">;
     modelId: string | null;
     providerRan: boolean;
@@ -182,24 +182,45 @@ export interface QueryAmbiguityReceipt {
     routing: OpenEnum<"compound" | "descriptive"> | null;
     productTypeIds: string[];
     changedArm: boolean;
-}
-export interface QueryCategoryScopeReceipt {
+};
+export type QueryCategoryScopeReceipt = {
     source: OpenEnum<"caller" | "anchor">;
     mechanism: OpenEnum<"sql-predicate" | "provider-filter" | "allowlist" | "prune">;
     variantCount: number | null;
     ceiling: number;
     specScanBounded?: boolean;
     [key: string]: unknown;
-}
-export interface QuerySpecAllowlistReceipt {
+};
+export type QuerySpecAllowlistReceipt = {
     limit: number;
     returned: number;
     retrieved?: number;
     truncated: boolean;
     emptyMeansScarcity: boolean;
     outcome?: OpenEnum<"corpus-scarcity" | "retrieval-miss" | "unknown">;
-}
-export interface QueryUnsatisfiableNarrowing {
+};
+/**
+ * Whether the phrase-reading step turned the query's descriptive words into
+ * filters and preferences. Present only on the workflow lane.
+ */
+export type QueryPhraseReadingReceipt = {
+    outcome: OpenEnum<"skipped">;
+    reason: string;
+} | {
+    outcome: OpenEnum<"read">;
+    /** Which model read the phrase: `jev`, or `second` behind it. */
+    reader: OpenEnum<"jev" | "second">;
+    elapsedMs: number;
+    leftAsText: string[];
+    rows: {
+        kind: OpenEnum<"want" | "avoid">;
+        attributeId: string;
+        values: string[];
+        confidence: number;
+        applied: boolean;
+    }[];
+};
+export type QueryUnsatisfiableNarrowing = {
     narrowing: OpenEnum<"product-type">;
     gate: OpenEnum<"hard">;
     productTypeId: string;
@@ -207,16 +228,19 @@ export interface QueryUnsatisfiableNarrowing {
     productTypeIds: string[];
     pass: string;
     evidence: OpenEnum<"zero-accepted-variants">;
-    relaxedTo: OpenEnum<"none">;
-}
+    relaxedDisplayName?: string;
+    relaxedProductTypeId?: string;
+    relaxedProductTypeIds?: string[];
+    relaxedTo: OpenEnum<"head-noun" | "none">;
+};
 /** Inspectable interpretation of the raw query by ordinary MaterialGraph search. */
-export interface QueryUnderstanding {
+export type QueryUnderstanding = {
     version: OpenEnum<"1">;
     rawQuery: string;
     normalisedQuery: string;
     residualText: string;
     status: OpenEnum<"resolved" | "ambiguous" | "partial" | "unresolved">;
-    mode: OpenEnum<"image" | "colour" | "text" | "lexical" | "entity-browse">;
+    mode: OpenEnum<"image" | "colour" | "text" | "lexical" | "entity-browse" | "attribute">;
     senses: QuerySense[];
     canonicalLexical?: CanonicalLexicalReceipt;
     criteria?: QueryCriteriaReceipt;
@@ -226,4 +250,5 @@ export interface QueryUnderstanding {
     categoryScope?: QueryCategoryScopeReceipt;
     specAllowlist?: QuerySpecAllowlistReceipt;
     unsatisfiableNarrowing?: QueryUnsatisfiableNarrowing;
-}
+    phraseReading?: QueryPhraseReadingReceipt;
+};

package/resolve-client.d.ts

@@ -17,9 +17,7 @@
  * silently the moment the registry moves.
  * - The whole phrase, any vocabulary → {@link resolvePhrasesRequest}. Batched,
  *   deterministic, and it says so out loud when a word means nothing here.
- * - You already know it is an attribute, or a value under a known attribute →
- *   `mg.resolveAttribute()` / `mg.resolveAttributeValue()`.
- * - You want to EXPLAIN a token you already hold → `mg.glossary(term)`.
+ * - You already know it is an attribute → `mg.listAttributes({ query })`.
  * - You want to complete a name as someone types → `mg.suggest()`.
  * - You want MATERIALS → `mg.search()`. This lens never returns one.
  */
@@ -56,9 +54,8 @@ import type { VocabularySearchOptions, VocabularySearchResponse } from "./types.
  *   could have caught comes back unresolved rather than slow.
  *
  * Deterministic — the same batch resolves to the same bytes every time. Instead
- * use `mg.search()` when you want materials rather than words, `mg.suggest()` to
- * complete a name as someone types, and `mg.glossary()` to EXPLAIN a token you
- * have already resolved.
+ * use `mg.search()` when you want materials rather than words, and
+ * `mg.suggest()` to complete a name as someone types.
  *
  * - **Every reading says what stands behind it.** `coverage.variants` is how
  *   many variants carry it corpus-wide, and `0` is a measured answer rather
@@ -76,15 +73,14 @@ import type { VocabularySearchOptions, VocabularySearchResponse } from "./types.
  * resolved independently, so one meaningless phrase never spoils the batch.
  * @param options `category` to scope the coverage answer, and an `AbortSignal`.
  */
-export declare function resolvePhrasesRequest(transport: HttpTransport, phrases: string[], scope?: ResolvePhrasesScope): Promise<ResolveResponse>;
+export declare const resolvePhrasesRequest: (transport: HttpTransport, phrases: string[], scope?: ResolvePhrasesScope) => Promise<ResolveResponse>;
 /**
  * THE QUESTION: "is 'FloorScore' an attribute or a value, and what is it called
  * here?" The catch-all for ONE phrase when you do not know which half of an
  * `attribute:value` pair it belongs to. Backs `mg.searchVocabulary()`.
  *
- * Instead use `mg.resolveAttribute()` / `mg.resolveAttributeValue()` once you do
- * know, {@link resolvePhrasesRequest} when you have SEVERAL phrases or the
- * phrase might name a brand, paint, colour or category rather than a spec, and
- * `mg.glossary()` to EXPLAIN a term rather than find it.
+ * Instead use `mg.listAttributes({ query })` once you do know the attribute,
+ * or {@link resolvePhrasesRequest} when you have SEVERAL phrases or the phrase
+ * might name a brand, paint, colour or category rather than a spec.
  */
-export declare function searchVocabularyRequest(transport: HttpTransport, query: string, options?: VocabularySearchOptions, signal?: AbortSignal): Promise<VocabularySearchResponse>;
+export declare const searchVocabularyRequest: (transport: HttpTransport, query: string, options?: VocabularySearchOptions, signal?: AbortSignal) => Promise<VocabularySearchResponse>;

package/resolve-client.js

@@ -29,9 +29,8 @@ import { resolveOperation } from "./operations.js";
  *   could have caught comes back unresolved rather than slow.
  *
  * Deterministic — the same batch resolves to the same bytes every time. Instead
- * use `mg.search()` when you want materials rather than words, `mg.suggest()` to
- * complete a name as someone types, and `mg.glossary()` to EXPLAIN a token you
- * have already resolved.
+ * use `mg.search()` when you want materials rather than words, and
+ * `mg.suggest()` to complete a name as someone types.
  *
  * - **Every reading says what stands behind it.** `coverage.variants` is how
  *   many variants carry it corpus-wide, and `0` is a measured answer rather
@@ -49,11 +48,11 @@ import { resolveOperation } from "./operations.js";
  * resolved independently, so one meaningless phrase never spoils the batch.
  * @param options `category` to scope the coverage answer, and an `AbortSignal`.
  */
-export function resolvePhrasesRequest(transport, phrases, scope) {
+export const resolvePhrasesRequest = async (transport, phrases, scope) => {
     // A bare signal is what this took before `category` existed; keep accepting it
     // so no published call site had to change to gain coverage.
     const options = scope instanceof AbortSignal ? { signal: scope } : (scope ?? {});
-    return transport.requestJson(resolveOperation("resolve_phrases"), {
+    return await transport.requestJson(resolveOperation("resolve_phrases"), {
         body: {
             phrases,
             ...(options.category === undefined
@@ -62,17 +61,14 @@ export function resolvePhrasesRequest(transport, phrases, scope) {
         },
         signal: options.signal,
     });
-}
+};
 /**
  * THE QUESTION: "is 'FloorScore' an attribute or a value, and what is it called
  * here?" The catch-all for ONE phrase when you do not know which half of an
  * `attribute:value` pair it belongs to. Backs `mg.searchVocabulary()`.
  *
- * Instead use `mg.resolveAttribute()` / `mg.resolveAttributeValue()` once you do
- * know, {@link resolvePhrasesRequest} when you have SEVERAL phrases or the
- * phrase might name a brand, paint, colour or category rather than a spec, and
- * `mg.glossary()` to EXPLAIN a term rather than find it.
+ * Instead use `mg.listAttributes({ query })` once you do know the attribute,
+ * or {@link resolvePhrasesRequest} when you have SEVERAL phrases or the phrase
+ * might name a brand, paint, colour or category rather than a spec.
  */
-export function searchVocabularyRequest(transport, query, options, signal) {
-    return transport.requestJson(resolveOperation("catalog_vocabulary_search"), { query: { q: query, limit: options?.limit, kind: options?.kind }, signal });
-}
+export const searchVocabularyRequest = async (transport, query, options, signal) => await transport.requestJson(resolveOperation("catalog_vocabulary_search"), { query: { kind: options?.kind, limit: options?.limit, q: query }, signal });

package/resolve-colour-types.d.ts

@@ -8,15 +8,15 @@ import type { CorpusScope } from "./corpus-scope-types.js";
 import type { VariantId } from "./identifiers.js";
 import type { OpenEnum } from "./types.js";
 /** Options for `resolveColour`. */
-export interface ResolveColourOptions {
+export type ResolveColourOptions = {
     /**
      * Sets `inScope` on each catalogue variant the lookup reports. It never
      * narrows the lookup. Absent leaves every `inScope` null.
      */
     corpusScope?: CorpusScope;
-}
+};
 /** One catalogue variant carrying the named paint. */
-export interface ResolveColourCatalogueVariant {
+export type ResolveColourCatalogueVariant = {
     variantId: VariantId;
     /** The brand exactly as stored, suspect or not. */
     brand: {
@@ -32,7 +32,7 @@ export interface ResolveColourCatalogueVariant {
      * made it. The variant is still the right one for the name.
      */
     parentageSuspect: boolean;
-}
+};
 /**
  * Whether the named paint is a variant in the catalogue. Exact, global, and
  * never narrowed by `corpusScope`, and run only for a `brand` library hit.
@@ -50,18 +50,18 @@ export type ResolveColourVariant = ({
     status: "not-looked-up";
     reason: OpenEnum<"reference-colour" | "descriptive-colour" | "no-paint-identity" | "generic-colour" | "several-paints">;
 };
-export interface ResolveColourResponse {
+export type ResolveColourResponse = {
     /** Examples within the governed range. They do not replace its representative or bounds. */
     rangeSamples?: string[];
     /** Explicit manufacturer choices for an ambiguous paint name. Never selected automatically. */
-    alternatives?: Array<{
+    alternatives?: {
         query: string;
         name: string;
         hex: string;
         libraryId: string;
         libraryName: string;
         code?: string;
-    }>;
+    }[];
     /** Generic meaning; maker-specific paint identity is carried by match. */
     genericResolution: ColorResolution;
     match: {
@@ -80,4 +80,4 @@ export interface ResolveColourResponse {
         /** The catalogue lookup for the name. Absent from servers that predate it. */
         variant?: ResolveColourVariant;
     } | null;
-}
+};