@instruments/materialgraph 0.25.0 → 0.26.0

package/match-stream-types.d.ts

@@ -42,14 +42,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 +61,7 @@ export interface MatchDetectedSurface {
     boundingBox: MatchBoundingBox;
     /** JPEG data-URI crop used for Match retrieval — the thumbnail to show. */
     cropDataUri?: 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 +86,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 +98,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 +150,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 +162,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 +179,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 +214,10 @@ export interface MatchWorkflowResult {
      */
     paletteMatches?: {
         results: SearchResultItem[];
-        palette: Array<{
+        palette: {
             hex: string;
             proportion: number;
-        }>;
+        }[];
         note: string;
     };
     /**
@@ -225,23 +225,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 +252,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 +261,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 +276,18 @@ 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;
-}
+};
 /** One frame of the Match progress stream, discriminated by `type`. */
 export type MatchStreamEvent = MatchStreamStepEvent | MatchStreamClassifiedEvent | MatchStreamSurfacesEvent | MatchStreamSurfaceEvent | MatchStreamHeartbeatEvent | MatchStreamCompleteEvent | MatchStreamErrorEvent;

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

@@ -57,7 +57,7 @@
 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 { 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 +70,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 +113,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 +127,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 +138,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 +152,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 +167,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 +200,41 @@ 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);
             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 +246,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 +260,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

@@ -12,11 +12,11 @@ import type { CorpusScope } from "./corpus-scope-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 +31,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 +73,9 @@ export interface MatchResponse {
     /** The query crop's own extracted palette — what the colour stage compared against. */
     segmentPalette?: PaletteSwatch[] | null;
     note?: string;
-}
+};
 /** 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 +111,4 @@ export interface MatchInput {
     preferences?: SearchFilter[];
     /** Opt in to seed-relative verdict cells; inert unless the inner search carries a variant seed. */
     verdicts?: boolean;
-}
+};

package/material-asset-types.d.ts

@@ -18,7 +18,7 @@ export type MaterialAssetVisualRole = OpenEnum<"grid" | "detail" | "scene" | "sw
  *  - `retired_placeholder` — a stand-in for a withdrawn asset.
  */
 export type MaterialAssetStatus = OpenEnum<"downloaded" | "linked_not_downloaded" | "failed" | "retired_placeholder">;
-export interface MaterialAssetProjectionImage {
+export type MaterialAssetProjectionImage = {
     key: string;
     ordinal: number;
     proxyPath: string;
@@ -28,8 +28,8 @@ export interface MaterialAssetProjectionImage {
     fileExtension: string | null;
     filename: string | null;
     byteSize: number | null;
-}
-export interface MaterialAssetProjectionDownload {
+};
+export type MaterialAssetProjectionDownload = {
     ordinal: number;
     url: string;
     label: string | null;
@@ -38,20 +38,20 @@ export interface MaterialAssetProjectionDownload {
     contentType: string | null;
     fileExtension: string | null;
     filename: string | null;
-}
+};
 export type MaterialDocumentStatus = OpenEnum<"downloaded" | "linked_not_downloaded" | "unavailable_source" | "dead_link" | "failed_ingest">;
 export type MaterialDocumentCoverageState = OpenEnum<"available" | "none_declared" | "not_ingested" | "unavailable_source" | "dead_link" | "failed_ingest">;
-export interface MaterialDocumentScope {
+export type MaterialDocumentScope = {
     kind: "product" | "variant";
     id: string;
-}
-export interface MaterialDocumentSource {
+};
+export type MaterialDocumentSource = {
     /** Opaque, public identifier for one source collection; never a PIM/DAM path. */
     id: string;
     authority: string;
     revision: string;
-}
-export interface MaterialDocumentProjectionItem {
+};
+export type MaterialDocumentProjectionItem = {
     id: string;
     scope: MaterialDocumentScope & {
         inherited: boolean;
@@ -61,12 +61,12 @@ export interface MaterialDocumentProjectionItem {
     /** True only for a Product declaration or this exact requested Variant. */
     appliesToRequestedVariant: boolean;
     /** Every exact source-grain declaration collapsed into this URL identity. */
-    declarations: Array<{
+    declarations: {
         scope: MaterialDocumentScope;
         source: MaterialDocumentSource;
         status: MaterialDocumentStatus;
         readable: boolean;
-    }>;
+    }[];
     documentType: string | null;
     originalName: string;
     status: MaterialDocumentStatus;
@@ -75,46 +75,46 @@ export interface MaterialDocumentProjectionItem {
     contentType: string | null;
     fileExtension: string | null;
     source: MaterialDocumentSource;
-}
-export interface MaterialDocumentCoverageSource {
+};
+export type MaterialDocumentCoverageSource = {
     scope: MaterialDocumentScope;
     state: MaterialDocumentCoverageState;
     exact: boolean;
     declaredCount: number | null;
     readableCount: number;
     source: MaterialDocumentSource;
-}
-export interface MaterialDocumentCoverage {
+};
+export type MaterialDocumentCoverage = {
     productUnion: MaterialDocumentCoverageSummary;
     requestedVariant: MaterialDocumentCoverageSummary;
     sources: MaterialDocumentCoverageSource[];
-}
-export interface MaterialDocumentCoverageSummary {
+};
+export type MaterialDocumentCoverageSummary = {
     state: MaterialDocumentCoverageState;
     exact: boolean;
     declaredCount: number | null;
     readableCount: number;
-}
-export interface MaterialDocumentPageOptions {
+};
+export type MaterialDocumentPageOptions = {
     cursor?: string;
     limit?: number;
-}
-export interface MaterialDocumentPage {
+};
+export type MaterialDocumentPage = {
     variantId: VariantId;
     documents: MaterialDocumentProjectionItem[];
     coverage: MaterialDocumentCoverage;
     totalDocuments: number;
     nextCursor: string | null;
-}
+};
 /** Tallies over what this projection returned — never a claim about the brand's own library. */
-export interface MaterialAssetProjectionSummary {
+export type MaterialAssetProjectionSummary = {
     imageCount: number;
     downloadCount: number;
     documentCount: number;
     readableDocumentCount: number;
     downloadedImageCount: number;
-}
-export interface MaterialAssetProjection {
+};
+export type MaterialAssetProjection = {
     /** Opaque — echoed from the request. */
     variantId: VariantId;
     images: MaterialAssetProjectionImage[];
@@ -122,4 +122,4 @@ export interface MaterialAssetProjection {
     documents: MaterialDocumentProjectionItem[];
     documentCoverage: MaterialDocumentCoverage;
     summary: MaterialAssetProjectionSummary;
-}
+};

package/material-block-types.d.ts

@@ -45,7 +45,7 @@ export type MaterialBlockFieldValue = string | number | boolean | unknown[] | Re
  * `status: "verified"` is a real negative you may publish; the same `false`
  * under `missing` is a placeholder for an unanswered question.
  */
-export interface MaterialBlockProjectionField {
+export type MaterialBlockProjectionField = {
     /** Canonical vocabulary, not an opaque id — the same token `bySpec` accepts. */
     attributeId: string;
     label: string;
@@ -56,21 +56,21 @@ export interface MaterialBlockProjectionField {
     sourceBasis?: string;
     /** Claim confidence supplied by the graph; absence means no confidence was emitted. */
     confidence?: number;
-}
-export interface MaterialBlockProjectionItem {
+};
+export type MaterialBlockProjectionItem = {
     canonicalBlockId: string;
     canonicalBlockName: string;
     status: MaterialBlockStatus;
     fields: MaterialBlockProjectionField[];
     /** The work queue: attributes with `status: "missing"`. UNKNOWN, never "none". */
     missingAttributeIds: string[];
-}
+};
 /**
  * Every canonical block for one material, each field carrying whether it is
  * determined. The whole surface, not a page — there is no cursor here.
  */
-export interface MaterialBlockProjection {
+export type MaterialBlockProjection = {
     /** Opaque — echoed from the request. */
     variantId: VariantId;
     blocks: MaterialBlockProjectionItem[];
-}
+};