@instruments/materialgraph 0.25.0 → 0.27.0

package/match-stream-types.d.ts

@@ -21,6 +21,9 @@ import type { SearchResultItem } from "./types.js";
 /** How the workflow classified the uploaded image. */
 export declare const MATCH_IMAGE_TYPES: readonly ["swatch", "installation", "flatplan"];
 export type MatchImageType = (typeof MATCH_IMAGE_TYPES)[number];
+/** Why a Match run ended on an `error` frame (MG-730). */
+export declare const MATCH_ERROR_REASONS: readonly ["upstream_unavailable", "failed"];
+export type MatchErrorReason = (typeof MATCH_ERROR_REASONS)[number];
 /** What a detected surface is FOR — the element the material would serve. */
 export declare const MATCH_MATERIAL_FUNCTIONS: readonly ["flooring", "wall_surface", "ceiling", "partition", "upholstery", "millwork", "countertop", "accent", "sample"];
 export type MatchMaterialFunction = (typeof MATCH_MATERIAL_FUNCTIONS)[number];
@@ -42,14 +45,14 @@ export type MatchSurfaceStatus = (typeof MATCH_SURFACE_STATUSES)[number];
 export declare const MATCH_STREAM_EVENT_TYPES: readonly ["step", "classified", "surfaces", "surface", "heartbeat", "complete", "error"];
 export type MatchStreamEventType = (typeof MATCH_STREAM_EVENT_TYPES)[number];
 /** Where a surface sits in the image, in Gemini-style 0–1000 image space. */
-export interface MatchBoundingBox {
+export type MatchBoundingBox = {
     x0: number;
     y0: number;
     x1: number;
     y1: number;
-}
+};
 /** One surface the decompose step found in the image. */
-export interface MatchDetectedSurface {
+export type MatchDetectedSurface = {
     id: string;
     label: string;
     materialFunction: MatchMaterialFunction;
@@ -61,7 +64,9 @@ export interface MatchDetectedSurface {
     boundingBox: MatchBoundingBox;
     /** JPEG data-URI crop used for Match retrieval — the thumbnail to show. */
     cropDataUri?: string;
-}
+    /** The `construction_methods` dictionary term the detector's finish names. */
+    construction?: string;
+};
 /**
  * One surface's matching state and its ranked results. The same `surface.id`
  * arrives repeatedly as the run progresses (`matching` → `complete` / `error`);
@@ -86,7 +91,7 @@ export interface MatchDetectedSurface {
  * [0,1] — the same unit as each result's `confidence` — so they belong on one
  * axis. `poolSize` and `droppedBelowFloor` are counts and belong on neither.
  */
-export interface MatchComparison {
+export type MatchComparison = {
     /** Candidates retrieved before the quality floor and product dedup. */
     poolSize: number;
     /** How many of those the quality floor rejected. */
@@ -98,8 +103,8 @@ export interface MatchComparison {
      * nothing was rejected, or when the rejects carried no readable signal.
      */
     bestRejected?: number;
-}
-export interface MatchSurfaceResult {
+};
+export type MatchSurfaceResult = {
     surface: MatchDetectedSurface;
     status: MatchSurfaceStatus;
     results: SearchResultItem[];
@@ -150,10 +155,10 @@ export interface MatchSurfaceResult {
      */
     colour?: MatchColourReading[];
     /** The segment's own extracted palette — what the colour stage matched against. */
-    segmentPalette?: Array<{
+    segmentPalette?: {
         hex: string;
         proportion: number;
-    }>;
+    }[];
     /**
      * One sentence of provenance a consumer may render verbatim, when the server
      * sent one — e.g. the `colour_fallback` explanation carrying the refused
@@ -162,13 +167,13 @@ export interface MatchSurfaceResult {
     note?: string;
     /** Present only on `status: "error"` — why this one surface failed. */
     error?: string;
-}
+};
 /** The verifier's reading of one candidate, keyed back to its variant. */
-export interface MatchSenseCheckCell {
+export type MatchSenseCheckCell = {
     variantId: string;
     verdict: MatchSenseCheckVerdict;
     reason: string;
-}
+};
 export declare const MATCH_SENSE_CHECK_VERDICTS: readonly ["confirmed", "rejected", "abstained"];
 export type MatchSenseCheckVerdict = (typeof MATCH_SENSE_CHECK_VERDICTS)[number];
 /** The terminal Match workflow result — every surface in its final state. */
@@ -179,7 +184,7 @@ export type MatchSenseCheckVerdict = (typeof MATCH_SENSE_CHECK_VERDICTS)[number]
  */
 export declare const MATCH_OUTCOMES: readonly ["matched", "no_surfaces"];
 export type MatchOutcome = (typeof MATCH_OUTCOMES)[number];
-export interface MatchWorkflowResult {
+export type MatchWorkflowResult = {
     /**
      * Result attribution (MG-1131) — `responseId` (the same value as the run's
      * `X-Request-Id` header), `basis: "match"`, and `issuedAt`. Every item in
@@ -214,10 +219,10 @@ export interface MatchWorkflowResult {
      */
     paletteMatches?: {
         results: SearchResultItem[];
-        palette: Array<{
+        palette: {
             hex: string;
             proportion: number;
-        }>;
+        }[];
         note: string;
     };
     /**
@@ -225,23 +230,23 @@ export interface MatchWorkflowResult {
      * nowhere else to put this. A scene run reports per surface instead.
      */
     comparison?: MatchComparison;
-}
+};
 /** Progress narration for the phase the workflow just entered. */
-export interface MatchStreamStepEvent {
+export type MatchStreamStepEvent = {
     type: "step";
     step: MatchWorkflowStep;
     message: string;
-}
+};
 /** The image type the classify step settled on. */
-export interface MatchStreamClassifiedEvent {
+export type MatchStreamClassifiedEvent = {
     type: "classified";
     imageType: MatchImageType;
-}
+};
 /** Every surface the decompose step found, before any of them has matched. */
-export interface MatchStreamSurfacesEvent {
+export type MatchStreamSurfacesEvent = {
     type: "surfaces";
     surfaces: MatchDetectedSurface[];
-}
+};
 /**
  * The run's tally at the moment a `surface` event was emitted, so a consumer
  * reads the server's arithmetic rather than reimplementing it.
@@ -252,7 +257,7 @@ export interface MatchStreamSurfacesEvent {
  * `matchesSoFar`. `surfacesResolved === surfacesDetected` is therefore the
  * correct "the run is done" test, and never stalls at 3/4 on a failure.
  */
-export interface MatchRunTotals {
+export type MatchRunTotals = {
     /** Surfaces the decompose step found. The denominator; fixed for the run. */
     surfacesDetected: number;
     /** Surfaces that reached a terminal state — `complete` OR `error`. */
@@ -261,14 +266,14 @@ export interface MatchRunTotals {
     surfacesFailed: number;
     /** Result items accumulated across every surface resolved so far. */
     matchesSoFar: number;
-}
+};
 /** One surface's state changed — the frame that makes Match progressive. */
-export interface MatchStreamSurfaceEvent {
+export type MatchStreamSurfaceEvent = {
     type: "surface";
     surface: MatchSurfaceResult;
     /** The run's tally as of this frame. Always present on a `surface` event. */
     totals: MatchRunTotals;
-}
+};
 /**
  * CONNECTION LIVENESS ONLY — never progress. Proxies and load balancers kill
  * idle connections, so the server sends this when the stream has been quiet, and
@@ -276,18 +281,26 @@ export interface MatchStreamSurfaceEvent {
  * consumer should treat it as a state change: do not advance a step, reset a
  * no-progress watchdog, or count it towards anything.
  */
-export interface MatchStreamHeartbeatEvent {
+export type MatchStreamHeartbeatEvent = {
     type: "heartbeat";
-}
+};
 /** Terminal: the whole run finished and carries its assembled result. */
-export interface MatchStreamCompleteEvent {
+export type MatchStreamCompleteEvent = {
     type: "complete";
     result: MatchWorkflowResult;
-}
+};
 /** Terminal: the run failed as a whole (a single surface failing is not this). */
-export interface MatchStreamErrorEvent {
+export type MatchStreamErrorEvent = {
     type: "error";
     message: string;
-}
+    /**
+     * `upstream_unavailable`: a provider (vision, embedding, vector index) could
+     * not answer, so nothing was looked at and a retry may succeed. `failed`: the
+     * run broke on something else. Absent from servers older than MG-730.
+     */
+    reason?: MatchErrorReason;
+    /** True only for `upstream_unavailable`. Absent from servers older than MG-730. */
+    retriable?: boolean;
+};
 /** One frame of the Match progress stream, discriminated by `type`. */
 export type MatchStreamEvent = MatchStreamStepEvent | MatchStreamClassifiedEvent | MatchStreamSurfacesEvent | MatchStreamSurfaceEvent | MatchStreamHeartbeatEvent | MatchStreamCompleteEvent | MatchStreamErrorEvent;

package/match-stream-types.js

@@ -4,6 +4,8 @@ export const MATCH_IMAGE_TYPES = [
     "installation",
     "flatplan",
 ];
+/** Why a Match run ended on an `error` frame (MG-730). */
+export const MATCH_ERROR_REASONS = ["upstream_unavailable", "failed"];
 /** What a detected surface is FOR — the element the material would serve. */
 export const MATCH_MATERIAL_FUNCTIONS = [
     "flooring",

package/match-stream.d.ts

@@ -1,5 +1,5 @@
 import type { HttpTransport } from "./http-transport.js";
-import { type MatchStreamEvent } from "./match-stream-types.js";
+import type { MatchStreamEvent } from "./match-stream-types.js";
 import type { MatchInput } from "./match-types.js";
 /**
  * Decode one NDJSON line into a validated {@link MatchStreamEvent}, raising a
@@ -7,7 +7,7 @@ import type { MatchInput } from "./match-types.js";
  * for `contract-parity.test.ts`, which re-checks it against the real Zod schema;
  * it is not part of the published surface.
  */
-export declare function decodeMatchStreamEvent(line: string): MatchStreamEvent;
+export declare const decodeMatchStreamEvent: (line: string) => MatchStreamEvent;
 /**
  * Stream Match progress as an async iterator. Iterates until the run reaches a
  * `complete` or an `error` event, and raises if the connection ends before one

package/match-stream.js

@@ -35,10 +35,9 @@
  *     objects (`createMatchNdjsonStream`), so `parse` output is not what the wire
  *     carries; reshaping to match it would invent a normalisation that never
  *     happened.
- *  2. Stripping needs the COMPLETE key inventory of `searchResultItemSchema`,
- *     whose closure reaches `candidateVerdictSchema` in `@materialgraph/contracts`
- *     — a recursive hand-mirror that would have to stay in step forever, and a
- *     wider surface than the validation it would serve.
+ *  2. Stripping needs the COMPLETE key inventory of `searchResultItemSchema`
+ *     — a hand-mirror that would have to stay in step forever, and a wider
+ *     surface than the validation it would serve.
  *  3. An additive server field then reaches consumers without an SDK release,
  *     which matters while new EVENT types still require one (MG-658).
  * The ONE exception is `.default([])`: an omitted `results` / `inferredCategories`
@@ -50,14 +49,12 @@
  * optional string, `MatchCategoryInference` items, and every
  * `SearchResultItem` in `results[]` are checked exhaustively. Item validation is
  * the shared `checkSearchResultItem` (`search-result-validation.ts`), which
- * mirrors `searchResultItemSchema` and its whole closure down to
- * `candidateVerdictSchema` — including both of its `.superRefine()` cross-field
- * invariants.
+ * mirrors `searchResultItemSchema` and its whole closure.
  */
 import { MaterialGraphError } from "./errors.js";
-import { MATCH_IMAGE_TYPES, MATCH_MATERIAL_FUNCTIONS, MATCH_STREAM_EVENT_TYPES, MATCH_SURFACE_STATUSES, MATCH_WORKFLOW_STEPS, } from "./match-stream-types.js";
+import { MATCH_ERROR_REASONS, MATCH_IMAGE_TYPES, MATCH_MATERIAL_FUNCTIONS, MATCH_STREAM_EVENT_TYPES, MATCH_SURFACE_STATUSES, MATCH_WORKFLOW_STEPS, } from "./match-stream-types.js";
 import { readNdjsonLines } from "./ndjson.js";
-import { findSdkOperation, } from "./operations.js";
+import { findSdkOperation } from "./operations.js";
 import { checkSearchResultItems } from "./search-result-validation.js";
 import { requireArray, requireBoundedNumber, requireDefaultedArray, requireEnum, requireIntegerAtLeast, requireNumber, requireOptionalString, requireRecord, requireString, } from "./validation.js";
 /** The NDJSON media type the Match route negotiates the scene workflow on. */
@@ -70,34 +67,37 @@ const BOUNDING_BOX_CORNERS = Object.freeze([
     "x1",
     "y1",
 ]);
-function operation(operationId) {
+const operation = (operationId) => {
     const found = findSdkOperation(operationId);
-    if (!found)
+    if (!found) {
         throw MaterialGraphError.unexpected(`Unknown SDK operation: ${operationId}`);
+    }
     return found;
-}
+};
 /**
  * The failure shape every check in this module raises: one message naming the
  * offending path and quoting a bounded slice of the frame.
  */
-function frameFailure(line) {
+const frameFailure = (line) => {
     const preview = line.length > MAX_FRAME_PREVIEW
         ? `${line.slice(0, MAX_FRAME_PREVIEW)}…`
         : line;
     return (reason) => MaterialGraphError.unexpected(`MaterialGraph match stream sent a malformed NDJSON frame: ${reason}. Frame: ${preview}`);
-}
+};
 /** Check one `MatchCategoryInference` item. */
-function checkCategoryInference(value, what, fail) {
+const checkCategoryInference = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     requireString(record.productTypeId, `${what}.productTypeId`, fail);
     requireString(record.displayName, `${what}.displayName`, fail);
     requireNumber(record.boost, `${what}.boost`, fail);
-}
-function checkCategoryInferences(items, what, fail) {
-    items.forEach((item, index) => checkCategoryInference(item, `${what}[${index}]`, fail));
-}
+};
+const checkCategoryInferences = (items, what, fail) => {
+    items.forEach((item, index) => {
+        checkCategoryInference(item, `${what}[${index}]`, fail);
+    });
+};
 /** Check one detected surface — identity, function, confidence, and its box. */
-function checkDetectedSurface(value, what, fail) {
+const checkDetectedSurface = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     requireString(record.id, `${what}.id`, fail);
     requireString(record.label, `${what}.label`, fail);
@@ -110,12 +110,12 @@ function checkDetectedSurface(value, what, fail) {
     for (const corner of BOUNDING_BOX_CORNERS) {
         requireNumber(box[corner], `${what}.boundingBox.${corner}`, fail);
     }
-}
+};
 /**
  * Check one surface's matching state and fill the canonical `.default([])`
  * arrays, so a consumer never meets `undefined` where the type promises an array.
  */
-function readSurfaceResult(value, what, fail) {
+const readSurfaceResult = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     checkDetectedSurface(record.surface, `${what}.surface`, fail);
     requireEnum(record.status, MATCH_SURFACE_STATUSES, `${what}.status`, fail);
@@ -124,8 +124,8 @@ function readSurfaceResult(value, what, fail) {
     checkSearchResultItems(results, `${what}.results`, fail);
     const inferredCategories = requireDefaultedArray(record.inferredCategories, `${what}.inferredCategories`, fail);
     checkCategoryInferences(inferredCategories, `${what}.inferredCategories`, fail);
-    return { ...record, results, inferredCategories };
-}
+    return { ...record, inferredCategories, results };
+};
 /**
  * `matchRunTotalsSchema` — four non-negative integers plus the TWO cross-field
  * invariants its `.superRefine()` enforces. Relational rather than field-wise,
@@ -135,7 +135,7 @@ function readSurfaceResult(value, what, fail) {
  * `matchesSoFar` is deliberately unbounded against the surface counts — one
  * surface can carry many results and another none, so no ratio is principled.
  */
-function checkRunTotals(value, what, fail) {
+const checkRunTotals = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     const detected = requireIntegerAtLeast(record.surfacesDetected, `${what}.surfacesDetected`, fail, 0);
     const resolved = requireIntegerAtLeast(record.surfacesResolved, `${what}.surfacesResolved`, fail, 0);
@@ -149,9 +149,9 @@ function checkRunTotals(value, what, fail) {
     if (resolved > detected) {
         throw fail(`${what}.surfacesResolved (${resolved}) exceeds ${what}.surfacesDetected (${detected}) — a run cannot resolve more surfaces than it found`);
     }
-}
+};
 /** Check the terminal workflow result — image type, surfaces, optional roll-ups. */
-function readWorkflowResult(value, what, fail) {
+const readWorkflowResult = (value, what, fail) => {
     const record = requireRecord(value, what, fail);
     requireEnum(record.imageType, MATCH_IMAGE_TYPES, `${what}.imageType`, fail);
     const surfaces = requireArray(record.surfaces, `${what}.surfaces`, fail).map((surface, index) => readSurfaceResult(surface, `${what}.surfaces[${index}]`, fail));
@@ -164,26 +164,30 @@ function readWorkflowResult(value, what, fail) {
         checkCategoryInferences(requireArray(record.inferredCategories, `${what}.inferredCategories`, fail), `${what}.inferredCategories`, fail);
     }
     return { ...record, surfaces };
-}
+};
 /**
  * Validate one frame against the canonical contract and apply the schema's
  * `.default([])` fills, returning the event as a plain record. Unknown keys ride
  * through untouched — see the pass-through note in the module header.
  */
-function readFrame(value, fail) {
+const readFrame = (value, fail) => {
     const record = requireRecord(value, "the frame", fail);
     const type = requireString(record.type, "`type`", fail);
     switch (type) {
-        case "step":
+        case "step": {
             requireEnum(record.step, MATCH_WORKFLOW_STEPS, "`step`", fail);
             requireString(record.message, "`message`", fail);
             return record;
-        case "classified":
+        }
+        case "classified": {
             requireEnum(record.imageType, MATCH_IMAGE_TYPES, "`imageType`", fail);
             return record;
+        }
         case "surfaces": {
             const surfaces = requireArray(record.surfaces, "`surfaces`", fail);
-            surfaces.forEach((surface, index) => checkDetectedSurface(surface, `surfaces[${index}]`, fail));
+            surfaces.forEach((surface, index) => {
+                checkDetectedSurface(surface, `surfaces[${index}]`, fail);
+            });
             return record;
         }
         case "surface": {
@@ -193,37 +197,48 @@ function readFrame(value, fail) {
             checkRunTotals(record.totals, "`totals`", fail);
             return { ...record, surface };
         }
-        case "heartbeat":
+        case "heartbeat": {
             // Payload-free by contract — there is nothing else to check.
             return record;
-        case "complete":
+        }
+        case "complete": {
             return {
                 ...record,
                 result: readWorkflowResult(record.result, "`result`", fail),
             };
-        case "error":
+        }
+        case "error": {
             requireString(record.message, "`message`", fail);
+            if (record.reason !== undefined) {
+                requireEnum(record.reason, MATCH_ERROR_REASONS, "`reason`", fail);
+            }
+            if (record.retriable !== undefined &&
+                typeof record.retriable !== "boolean") {
+                throw fail("`retriable` must be a boolean");
+            }
             return record;
-        default:
+        }
+        default: {
             throw fail(`\`type\` is not a known Match stream event (${type})`);
+        }
     }
-}
+};
 /**
  * The single narrowing boundary of this module. {@link readFrame} has already
  * proven every field the union's shape depends on; re-checking the discriminant
  * here keeps the assertion from being vacuous.
  */
-function assertMatchStreamEvent(frame, fail) {
+const assertMatchStreamEvent = (frame, fail) => {
     const record = requireRecord(frame, "the frame", fail);
     requireEnum(record.type, MATCH_STREAM_EVENT_TYPES, "`type`", fail);
-}
+};
 /**
  * Decode one NDJSON line into a validated {@link MatchStreamEvent}, raising a
  * {@link MaterialGraphError} on anything the contract does not allow. Exported
  * for `contract-parity.test.ts`, which re-checks it against the real Zod schema;
  * it is not part of the published surface.
  */
-export function decodeMatchStreamEvent(line) {
+export const decodeMatchStreamEvent = (line) => {
     const fail = frameFailure(line);
     let parsed;
     try {
@@ -235,10 +250,8 @@ export function decodeMatchStreamEvent(line) {
     const frame = readFrame(parsed, fail);
     assertMatchStreamEvent(frame, fail);
     return frame;
-}
-function isTerminal(event) {
-    return event.type === "complete" || event.type === "error";
-}
+};
+const isTerminal = (event) => event.type === "complete" || event.type === "error";
 /**
  * Stream Match progress as an async iterator. Iterates until the run reaches a
  * `complete` or an `error` event, and raises if the connection ends before one
@@ -251,33 +264,38 @@ function isTerminal(event) {
  * it cancelled, so the truncated-stream error is not raised for it.
  */
 export async function* matchStream(transport, input, signal) {
-    if (signal?.aborted === true)
+    if (signal?.aborted === true) {
         return;
+    }
     // Our own controller, so abandoning the iterator cancels the request too.
     const controller = new AbortController();
-    const forwardAbort = () => controller.abort();
+    const forwardAbort = () => {
+        controller.abort();
+    };
     signal?.addEventListener("abort", forwardAbort, { once: true });
     try {
         let body;
         try {
             body = await transport.openStream(operation("match_material"), {
+                accept: MATCH_STREAM_ACCEPT,
                 body: input,
                 signal: controller.signal,
-                accept: MATCH_STREAM_ACCEPT,
                 subject: "match stream",
             });
         }
         catch (error) {
             // Cancelled before the response headers landed — the caller's own stop.
-            if (controller.signal.aborted)
+            if (controller.signal.aborted) {
                 return;
+            }
             throw error;
         }
         for await (const line of readNdjsonLines(body, controller.signal)) {
             const event = decodeMatchStreamEvent(line);
             yield event;
-            if (isTerminal(event))
+            if (isTerminal(event)) {
                 return;
+            }
         }
         if (!controller.signal.aborted) {
             throw MaterialGraphError.unexpected("MaterialGraph match stream ended without a `complete` or `error` event — the connection was truncated");

package/match-types.d.ts

@@ -9,14 +9,15 @@ import type { CorpusScope } from "./corpus-scope-types.js";
  * along its natural seam: everything a caller of `client.match()` needs, and
  * nothing else. The STREAMING contracts live in `match-stream-types.ts`.
  */
+import type { MatchWorkflowResult } from "./match-stream-types.js";
 import type { SearchFilter } from "./search-refinement-types.js";
 import type { OpenEnum, PaletteSwatch, SearchResultItem } from "./types.js";
 /** An inferred product-type category from the query image, with its boost. */
-export interface MatchCategoryInference {
+export type MatchCategoryInference = {
     productTypeId: string;
     displayName: string;
     boost: number;
-}
+};
 /**
  * The Material Match response (non-streaming form).
  *
@@ -31,13 +32,13 @@ export interface MatchCategoryInference {
  * means the material carries no palette on record — UNKNOWN, never "no colour"
  * and never "the wrong colour".
  */
-export interface MatchColourReading {
+export type MatchColourReading = {
     variantId: string;
     colourDistance: number | null;
     colourBand: string | null;
     measurable: boolean;
-}
-export interface MatchResponse {
+};
+export type MatchResponse = {
     /**
      * Result attribution (MG-1131). `basis` is always `"match"` here — this route
      * has no `mode`, so this is the field that lets a Match outcome be grouped
@@ -73,9 +74,32 @@ export interface MatchResponse {
     /** The query crop's own extracted palette — what the colour stage compared against. */
     segmentPalette?: PaletteSwatch[] | null;
     note?: string;
-}
+};
+/**
+ * What a BUFFERED `match()` actually answers with, either shape.
+ *
+ * An IMAGE input (`imageBase64` or `imageUrl`) runs the same workflow the
+ * stream lane runs — image kind first, then the swatch shortcut or the scene
+ * route — and answers in {@link MatchWorkflowResult}. A `vector` input has no
+ * bytes to read a kind from and keeps the thin {@link MatchResponse} leaf.
+ * The server declares exactly this as an `anyOf` of the two.
+ *
+ * TELL THEM APART BY A FIELD THAT ONLY ONE HAS, never by what you sent:
+ * `imageType` is required on the workflow shape and absent from the leaf, and
+ * `qualityFloor` is required on the leaf and absent from the workflow shape.
+ *
+ * ```ts
+ * const answer = await client.match({ imageBase64 });
+ * if ("imageType" in answer) {
+ *   for (const surface of answer.surfaces) render(surface);
+ * } else {
+ *   report(answer.qualityFloor, answer.droppedBelowFloor);
+ * }
+ * ```
+ */
+export type MatchAnswer = MatchResponse | MatchWorkflowResult;
 /** The Material Match request body — exactly one of `imageBase64`, `imageUrl`, `vector`. */
-export interface MatchInput {
+export type MatchInput = {
     imageBase64?: string;
     imageUrl?: string;
     vector?: string;
@@ -111,4 +135,4 @@ export interface MatchInput {
     preferences?: SearchFilter[];
     /** Opt in to seed-relative verdict cells; inert unless the inner search carries a variant seed. */
     verdicts?: boolean;
-}
+};