@instruments/materialgraph 0.16.0 → 0.18.0

package/association-types.d.ts

@@ -90,3 +90,64 @@ export interface AssociatedOptions {
      */
     cursor?: Cursor;
 }
+export type ApplicabilitySubject = {
+    kind: "product";
+    id: string;
+} | {
+    kind: "variant";
+    id: VariantId;
+};
+export type ApplicabilityCoverageState = "available" | "partial" | "none_declared" | "not_ingested" | "source_not_applicable" | "unavailable";
+export interface ApplicabilityCoverage {
+    state: ApplicabilityCoverageState;
+    countKind: "exact" | "partial";
+    declaredCount: number | null;
+    sourceAuthority: string;
+    sourceLocator: string;
+    sourceRevision: string;
+}
+export interface ApplicabilityFact {
+    id: string;
+    subject: ApplicabilitySubject;
+    finish: {
+        kind: "variant";
+        id: VariantId;
+    };
+    relation: "applicable_finish";
+    evidenceScope: "manufacturer_declared";
+    declaringBrandId: string;
+    source: {
+        authority: string;
+        locator: string;
+        revision: string;
+    };
+    lifecycle: "active";
+}
+export interface ApplicabilitySourceEntry {
+    scope: {
+        sourceAuthority: string;
+        sourceLocator: string;
+    };
+    /** Null when facts exist but this direction has no coverage census. */
+    coverage: ApplicabilityCoverage | null;
+    /** Revisions carried by active facts, independent from the coverage revision. */
+    factRevisions: string[];
+    /** Active facts from this source only. */
+    facts: ApplicabilityFact[];
+}
+/** Source-grained response; sources are never merged or given hidden precedence. */
+export interface ApplicabilityResponse {
+    kind: "manufacturer_declared_applicability";
+    requestedSubject: ApplicabilitySubject;
+    direction: "forward" | "reverse";
+    sources: ApplicabilitySourceEntry[];
+}
+export type ApplicabilityOptions = {
+    subjectKind: "product";
+    subjectId: string;
+    direction: "forward";
+} | {
+    subjectKind: "variant";
+    subjectId: VariantId;
+    direction: "forward" | "reverse";
+};

package/associations-client.d.ts

@@ -12,7 +12,7 @@
  * sections, never concatenate them, and never describe a pairing as
  * "available on".
  */
-import type { AssociatedOptions, DeclaredAssociationsResponse } from "./association-types.js";
+import type { ApplicabilityOptions, ApplicabilityResponse, AssociatedOptions, DeclaredAssociationsResponse } from "./association-types.js";
 import { HttpTransport } from "./http-transport.js";
 import type { VariantId } from "./identifiers.js";
 /**
@@ -49,3 +49,5 @@ export declare function declaredFinishes(transport: HttpTransport, variantId: Va
  * @param variantId The FINISH variant. Opaque — pass back exactly what you were given.
  */
 export declare function declaredProducts(transport: HttpTransport, variantId: VariantId, options?: AssociatedOptions, signal?: AbortSignal): Promise<DeclaredAssociationsResponse>;
+/** Read manufacturer-declared applicability without collapsing Product/Variant grain. */
+export declare function applicability(transport: HttpTransport, options: ApplicabilityOptions, signal?: AbortSignal): Promise<ApplicabilityResponse>;

package/associations-client.js

@@ -38,3 +38,7 @@ export function declaredFinishes(transport, variantId, options, signal) {
 export function declaredProducts(transport, variantId, options, signal) {
     return transport.requestJson(resolveOperation("list_associated_products"), { query: { variantId, ...options }, signal });
 }
+/** Read manufacturer-declared applicability without collapsing Product/Variant grain. */
+export function applicability(transport, options, signal) {
+    return transport.requestJson(resolveOperation("get_applicability"), { query: options, signal });
+}

package/catalogue-client.d.ts

@@ -1,4 +1,4 @@
-import type { CatalogueDocumentAccessResult, CatalogueReferenceBatchResponse } from "./catalogue-types.js";
+import type { CatalogDocumentList, CatalogPageListResult, CatalogProductReferenceReadResult, CatalogueChannelCollectionsResponse, CatalogueCollectionsOptions, CatalogueDocumentAccessResult, CataloguePageRepresentationReadResult, CatalogueReferenceBatchResponse } from "./catalogue-types.js";
 import type { HttpTransport } from "./http-transport.js";
 import type { VariantId } from "./identifiers.js";
 /** Catalogue publication operations inherited by the public SDK client. */
@@ -13,6 +13,19 @@ export declare class CatalogueClient {
     catalogueReferences(input: {
         variantIds: VariantId[];
     }, signal?: AbortSignal): Promise<CatalogueReferenceBatchResponse>;
+    /** List product collections with governed catalogue-channel membership. */
+    catalogueCollections(options?: CatalogueCollectionsOptions, signal?: AbortSignal): Promise<CatalogueChannelCollectionsResponse>;
+    /** List immutable catalog documents retained from verified source material. */
+    catalogs(signal?: AbortSignal): Promise<CatalogDocumentList>;
+    /** List stable one-based page identities and their representation status. */
+    catalogPages(catalogId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }, signal?: AbortSignal): Promise<CatalogPageListResult>;
+    /** Read a retained page representation or its exact missing-artifact receipt. */
+    catalogPageRepresentation(pageId: string, signal?: AbortSignal): Promise<CataloguePageRepresentationReadResult>;
+    /** Read every verified product/page reference for one retained catalog. */
+    catalogReferences(catalogId: string, signal?: AbortSignal): Promise<CatalogProductReferenceReadResult>;
     /** Resolve browser-safe access to one immutable catalogue document. */
     catalogueDocumentAccess(documentId: string, signal?: AbortSignal): Promise<CatalogueDocumentAccessResult>;
 }

package/catalogue-client.js

@@ -13,6 +13,33 @@ export class CatalogueClient {
     catalogueReferences(input, signal) {
         return this.#transport.requestJson(resolveOperation("get_catalogue_references_batch"), { body: input, signal });
     }
+    /** List product collections with governed catalogue-channel membership. */
+    catalogueCollections(options = {}, signal) {
+        return this.#transport.requestJson(resolveOperation("list_catalogue_channel_collections"), {
+            query: {
+                limit: options.limit,
+                offset: options.offset,
+                sampleLimit: options.sampleLimit,
+            },
+            signal,
+        });
+    }
+    /** List immutable catalog documents retained from verified source material. */
+    catalogs(signal) {
+        return this.#transport.requestJson(resolveOperation("list_catalog_documents"), { signal });
+    }
+    /** List stable one-based page identities and their representation status. */
+    catalogPages(catalogId, options = {}, signal) {
+        return this.#transport.requestJson(resolveOperation("list_catalog_pages"), { pathParams: { catalogId }, query: options, signal });
+    }
+    /** Read a retained page representation or its exact missing-artifact receipt. */
+    catalogPageRepresentation(pageId, signal) {
+        return this.#transport.requestJson(resolveOperation("get_catalog_page_representation"), { pathParams: { pageId }, signal });
+    }
+    /** Read every verified product/page reference for one retained catalog. */
+    catalogReferences(catalogId, signal) {
+        return this.#transport.requestJson(resolveOperation("list_catalog_product_references"), { pathParams: { catalogId }, signal });
+    }
     /** Resolve browser-safe access to one immutable catalogue document. */
     catalogueDocumentAccess(documentId, signal) {
         return this.#transport.requestJson(resolveOperation("get_catalogue_document_access"), { pathParams: { documentId }, signal });

package/catalogue-types.d.ts

@@ -1,5 +1,31 @@
 /** A verified product location in a specific immutable brand publication. */
 export interface CatalogueReference {
+    anchor: {
+        coordinateSpace: "normalized_0_1000";
+        height: number;
+        kind: "printed_code";
+        width: number;
+        x: number;
+        y: number;
+    };
+    productRegion?: {
+        coordinateSpace: "normalized_0_1000";
+        height: number;
+        kind: "product_region";
+        review: {
+            approvedBy: string;
+            confidence: {
+                evidenceBasis: "human_visual_review" | "model_assisted_visual_review";
+                level: "reviewed";
+            };
+            method: "human" | "model_assisted";
+            model?: string;
+            reviewedAt: string;
+        };
+        width: number;
+        x: number;
+        y: number;
+    };
     variantId: string;
     brand: {
         id: string;
@@ -35,7 +61,16 @@ export type CatalogueReferenceResult = {
     reference: CatalogueReference;
 } | {
     variantId: string;
-    status: "no_verified_reference" | "unresolved_variant" | "unavailable" | "upstream_failure";
+    status: "no_verified_reference";
+} | {
+    variantId: string;
+    status: "unresolved_variant";
+} | {
+    variantId: string;
+    status: "unavailable";
+} | {
+    variantId: string;
+    status: "upstream_failure";
 };
 export interface CatalogueReferenceBatchResponse {
     results: CatalogueReferenceResult[];
@@ -48,6 +83,50 @@ export interface CatalogueReferenceBatchResponse {
         upstreamFailure: number;
     };
 }
+/** Bounds for the flat catalogue-channel collection shelf. */
+export interface CatalogueCollectionsOptions {
+    limit?: number;
+    offset?: number;
+    sampleLimit?: number;
+}
+/** One representative product image carried by a catalogue collection. */
+export interface CatalogueCollectionSampleProduct {
+    assetId: string;
+    imageUrl: string;
+    sourceImageUrl: string;
+    productId: string;
+    productName: string;
+    variantId: string;
+    variantName: string | null;
+}
+/** A product collection whose variants have governed catalogue membership. */
+export interface CatalogueChannelCollection {
+    id: string;
+    slug: string;
+    name: string;
+    homepageUrl: string | null;
+    productCount: number;
+    variantCount: number;
+    sampleProducts: CatalogueCollectionSampleProduct[];
+}
+/** The flat, paginated catalogue-channel collection read model. */
+export interface CatalogueChannelCollectionsResponse {
+    collections: CatalogueChannelCollection[];
+    channel: {
+        token: "catalogue";
+        basis: "governed_variant_membership";
+    };
+    counts: {
+        basis: "exact_current_channel_membership";
+    };
+    pagination: {
+        count: number;
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+}
 export interface CatalogueDocumentAccess {
     documentId: string;
     contentType: "application/pdf";
@@ -61,5 +140,235 @@ export type CatalogueDocumentAccessResult = {
     access: CatalogueDocumentAccess;
 } | {
     documentId: string;
-    status: "unresolved_document" | "unavailable" | "forbidden" | "upstream_failure";
+    status: "unresolved_document";
+} | {
+    documentId: string;
+    status: "unavailable";
+} | {
+    documentId: string;
+    status: "forbidden";
+} | {
+    documentId: string;
+    status: "upstream_failure";
+};
+export interface CatalogDocument {
+    availability: "available";
+    brand: {
+        id: string;
+        name: string;
+    };
+    document: {
+        contentScope: "full_document" | "cover_only";
+        id: string;
+        mediaType: "application/pdf";
+        pageCount: number;
+    };
+    edition: CatalogEdition;
+    id: string;
+    kind: "document";
+    productStatus: "partial" | "not_processed";
+    receipt: CatalogAvailableReceipt;
+    title: string;
+}
+export interface CatalogEdition {
+    id: string;
+    label: string;
+    title: string;
+}
+export interface CatalogAvailableReceipt {
+    extraction: {
+        references: number;
+        status: "partial" | "not_processed";
+    };
+    failures: CatalogFailureReceipt[];
+    pages: {
+        documentPositionBase: 1;
+        pageCount: number;
+    };
+    render: {
+        failedPages: Array<{
+            documentPage: number;
+            reason: string;
+        }>;
+        renderedPages: number;
+        status: "complete" | "partial" | "not_recorded";
+    };
+    source: {
+        checksum: {
+            algorithm: "sha256";
+            value: string;
+        };
+        sourceBasis: "brand_supplied";
+        retainedUrl: string;
+        status: "retained";
+    };
+}
+export interface CatalogFailureReceipt {
+    count: number;
+    reason: string;
+    stage: "source" | "render" | "extraction";
+}
+export interface UnavailableCatalogDocument {
+    availability: "source_unavailable";
+    brand: {
+        id: string;
+        name: string;
+    };
+    document: null;
+    edition: CatalogEdition;
+    id: string;
+    kind: "document";
+    productStatus: "not_processed";
+    receipt: {
+        extraction: {
+            references: 0;
+            status: "blocked_source_unavailable";
+        };
+        failures: CatalogFailureReceipt[];
+        pages: {
+            documentPositionBase: 1;
+            pageCount: null;
+        };
+        render: {
+            failedPages: never[];
+            renderedPages: 0;
+            status: "blocked_source_unavailable";
+        };
+        source: {
+            reason: "retained_source_not_found";
+            status: "unavailable";
+        };
+    };
+    title: string;
+}
+export type CatalogPublication = CatalogDocument | UnavailableCatalogDocument;
+export interface CatalogDocumentList {
+    catalogs: CatalogPublication[];
+    source: "verified-source-material-registry";
+}
+export interface CatalogProductReferenceList {
+    catalog: CatalogDocument;
+    coverage: {
+        documentPages: {
+            total: number;
+            withVerifiedReferences: number;
+        };
+        pagesWithReferences: number;
+        precision: {
+            reason: "labelled_denominator_not_recorded";
+            status: "not_measured";
+        };
+        productCoverage: {
+            reason: "source_product_denominator_not_recorded";
+            status: "not_measured";
+        };
+        references: number;
+        unmatched: {
+            reasons: "unmatched_source_products_not_recorded"[];
+            status: "not_measured";
+        };
+    };
+    references: CatalogueReference[];
+    source: "verified-source-material-registry";
+    status: "available";
+}
+export interface CatalogProductReferenceUnavailable {
+    catalog: UnavailableCatalogDocument;
+    reason: "retained_source_not_found";
+    status: "source_unavailable";
+}
+export type CatalogProductReferenceReadResult = CatalogProductReferenceList | CatalogProductReferenceUnavailable;
+export interface CataloguePageRequiredArtifact {
+    mediaType: "image/webp";
+    version: "catalogue-page-webp-v1";
+}
+export interface CataloguePageAvailableArtifact extends Omit<CataloguePageRequiredArtifact, "version"> {
+    bucket: "materialgraph";
+    key: string;
+    url: string;
+}
+export type CataloguePage = {
+    catalogId: string;
+    documentId: string;
+    editionId: string;
+    id: string;
+    original: {
+        documentId: string;
+        documentPage: number;
+    };
+    page: {
+        documentPage: number;
+        printedPageLabel?: string;
+    };
+    representation: {
+        artifact: CataloguePageAvailableArtifact;
+        status: "available";
+    };
+} | {
+    catalogId: string;
+    documentId: string;
+    editionId: string;
+    id: string;
+    original: {
+        documentId: string;
+        documentPage: number;
+    };
+    page: {
+        documentPage: number;
+        printedPageLabel?: string;
+    };
+    representation: {
+        requiredArtifact: CataloguePageRequiredArtifact;
+        reason: "retained_representation_not_found";
+        status: "unavailable";
+    };
+};
+type CataloguePageAvailable = Extract<CataloguePage, {
+    representation: {
+        status: "available";
+    };
+}>;
+type CataloguePageUnavailable = Extract<CataloguePage, {
+    representation: {
+        status: "unavailable";
+    };
+}>;
+export type CatalogPageListResult = {
+    catalog: CatalogDocument;
+    pages: CataloguePage[];
+    pagination: {
+        count: number;
+        hasMore: boolean;
+        limit: number;
+        offset: number;
+        total: number;
+    };
+    representationCoverage: {
+        available: number;
+        failuresByReason: Array<{
+            count: number;
+            reason: "retained_representation_not_found";
+        }>;
+        total: number;
+        unavailable: number;
+    };
+    status: "available";
+} | {
+    catalog: UnavailableCatalogDocument;
+    reason: "retained_source_not_found";
+    status: "source_unavailable";
+};
+export type CataloguePageRepresentationReadResult = {
+    artifact: CataloguePageAvailableArtifact;
+    page: CataloguePageAvailable;
+    status: "available";
+} | {
+    requiredArtifact: CataloguePageRequiredArtifact;
+    page: CataloguePageUnavailable;
+    reason: "retained_representation_not_found";
+    status: "unavailable";
+} | {
+    pageId: string;
+    status: "unresolved_page";
 };
+export {};

package/client.d.ts

@@ -8,7 +8,7 @@ export type { BrowseNamespace } from "./client-browse.js";
 export type { ExplorationNamespace } from "./client-exploration.js";
 import { type SourceMaterialCommentsNamespace } from "./client-source-material-comments.js";
 export type { SourceMaterialCommentsNamespace } from "./client-source-material-comments.js";
-import type { AssociatedOptions } from "./association-types.js";
+import type { ApplicabilityOptions, AssociatedOptions } from "./association-types.js";
 import type { BrandsOptions } from "./brand-types.js";
 import type { ByColourParams, ByColourResponse } from "./by-colour-types.js";
 import { CodesClient } from "./codes-client.js";
@@ -18,8 +18,7 @@ import type { VarySchemesRequest, VarySchemesResponse } from "./composition-type
 import type { BatchId, ProjectId, RunId, VariantId } from "./identifiers.js";
 import type { MatchStreamEvent } from "./match-stream-types.js";
 import type { MatchInput, MatchResponse } from "./match-types.js";
-import type { MaterialAssetProjection } from "./material-asset-types.js";
-import type { MaterialBlockProjection } from "./material-block-types.js";
+import type { MaterialDocumentPageOptions } from "./material-asset-types.js";
 import type { MaterialQueryPlan } from "./material-query-plan-types.js";
 import type { AppendProjectEventRequest, CreateProjectRequest, ProjectEventReceipt, ProjectListResponse, ProjectState } from "./project-types.js";
 import { resolvePhrasesRequest as resolvePhrases } from "./resolve-client.js";
@@ -217,20 +216,9 @@ export declare class MaterialGraphClient extends CatalogueClient {
      * goes with this one, and `search({ similarTo })` for one that LOOKS like it.
      */
     siblings(variantId: VariantId, signal?: AbortSignal): Promise<SiblingsResponse>;
-    /**
-     * THE QUESTION: "what do we actually KNOW about this material, and what have we
-     * simply not checked?" The only read that distinguishes a determined absence
-     * from an unasked question — every field carries a `status`, so this is the one
-     * surface entitled to back a negative ("no fire rating").
-     * {@link MaterialGraphClient.material} cannot: there an absence is merely unknown.
-     */
-    materialBlocks(variantId: VariantId, signal?: AbortSignal): Promise<MaterialBlockProjection>;
-    /**
-     * THE QUESTION: "what images and documents may I SHOW for this material?" — the
-     * redistribution-safe set (GET `/api/v1/materials/{variantId}/assets`), not
-     * every file on record.
-     */
-    materialAssets(variantId: VariantId, signal?: AbortSignal): Promise<MaterialAssetProjection>;
+    materialBlocks(variantId: VariantId, signal?: AbortSignal): Promise<import("./material-block-types.js").MaterialBlockProjection>;
+    materialAssets(variantId: VariantId, signal?: AbortSignal): Promise<import("./material-asset-types.js").MaterialAssetProjection>;
+    materialDocuments(variantId: VariantId, options?: MaterialDocumentPageOptions, signal?: AbortSignal): Promise<import("./material-asset-types.js").MaterialDocumentPage>;
     /**
      * THE QUESTION: "what does the schema DEFINE?" — the governed static registry.
      *
@@ -258,6 +246,7 @@ export declare class MaterialGraphClient extends CatalogueClient {
     associatedFinishes(variantId: VariantId, options?: AssociatedOptions, signal?: AbortSignal): Promise<import("./association-types.js").DeclaredAssociationsResponse>;
     /** "What products does the manufacturer declare THIS finish for?" — {@link declaredProducts}. */
     associatedProducts(variantId: VariantId, options?: AssociatedOptions, signal?: AbortSignal): Promise<import("./association-types.js").DeclaredAssociationsResponse>;
+    applicability(options: ApplicabilityOptions, signal?: AbortSignal): Promise<import("./association-types.js").ApplicabilityResponse>;
     /**
      * THE QUESTION: "hydrate these ids I already hold" (POST
      * `/api/v1/materials/batch`, ≤ 100 ids) — never a discovery call. Throws

package/client.js

@@ -10,13 +10,14 @@ export * from "./client-config.js";
 import { browseQuery, createBrowseNamespace, } from "./client-browse.js";
 import { createExplorationNamespace, } from "./client-exploration.js";
 import { createSourceMaterialCommentsNamespace, } from "./client-source-material-comments.js";
-import { declaredFinishes, declaredProducts } from "./associations-client.js";
+import * as assoc from "./associations-client.js";
 import { brandColourDeck, brandProfile, listBrands } from "./brands-client.js";
 import { CodesClient } from "./codes-client.js";
 import { ColoursClient } from "./colours-client.js";
 import { slotPools as slotPoolsCall, varyScheme as varySchemeCall, } from "./composition-client.js";
 import { coordinate as coordinateCall } from "./coordinate-client.js";
 import { matchStream as matchStreamCall } from "./match-stream.js";
+import { materialAssets as materialAssetsCall, materialBlocks as materialBlocksCall, materialDocuments as materialDocumentsCall, } from "./material-resources-client.js";
 import { appendProjectEvent as appendProjectEventCall, createProject as createProjectCall, getProject as getProjectCall, listProjects as listProjectsCall, } from "./projects.js";
 import { resolvePhrasesRequest as resolvePhrases, searchVocabularyRequest, } from "./resolve-client.js";
 import { SCHEMA_RESOURCE_OPERATION_IDS } from "./schema-resource-types.js";
@@ -275,27 +276,14 @@ export class MaterialGraphClient extends CatalogueClient {
     siblings(variantId, signal) {
         return this.#get("get_material_siblings", undefined, signal, { variantId });
     }
-    /**
-     * THE QUESTION: "what do we actually KNOW about this material, and what have we
-     * simply not checked?" The only read that distinguishes a determined absence
-     * from an unasked question — every field carries a `status`, so this is the one
-     * surface entitled to back a negative ("no fire rating").
-     * {@link MaterialGraphClient.material} cannot: there an absence is merely unknown.
-     */
     materialBlocks(variantId, signal) {
-        return this.#get("list_material_blocks", undefined, signal, {
-            variantId,
-        });
+        return materialBlocksCall(this.#transport, variantId, signal);
     }
-    /**
-     * THE QUESTION: "what images and documents may I SHOW for this material?" — the
-     * redistribution-safe set (GET `/api/v1/materials/{variantId}/assets`), not
-     * every file on record.
-     */
     materialAssets(variantId, signal) {
-        return this.#get("list_material_assets", undefined, signal, {
-            variantId,
-        });
+        return materialAssetsCall(this.#transport, variantId, signal);
+    }
+    materialDocuments(variantId, options, signal) {
+        return materialDocumentsCall(this.#transport, variantId, options, signal);
     }
     /**
      * THE QUESTION: "what does the schema DEFINE?" — the governed static registry.
@@ -328,11 +316,14 @@ export class MaterialGraphClient extends CatalogueClient {
     }
     /** "What finishes does the manufacturer declare for THIS product?" — {@link declaredFinishes}. */
     associatedFinishes(variantId, options, signal) {
-        return declaredFinishes(this.#transport, variantId, options, signal);
+        return assoc.declaredFinishes(this.#transport, variantId, options, signal);
     }
     /** "What products does the manufacturer declare THIS finish for?" — {@link declaredProducts}. */
     associatedProducts(variantId, options, signal) {
-        return declaredProducts(this.#transport, variantId, options, signal);
+        return assoc.declaredProducts(this.#transport, variantId, options, signal);
+    }
+    applicability(options, signal) {
+        return assoc.applicability(this.#transport, options, signal);
     }
     materials(ids, options, signal) {
         if (ids.length > MAX_BATCH_IDS) {

package/corpus-scope-types.d.ts

@@ -29,19 +29,21 @@ import { type OpenEnum } from "./types.js";
  * `"all"` (and absence) is the WHOLE GRAPH — every material MaterialGraph
  * knows, orderable or not. Absence is never a narrower default.
  *
- * Three members gate on CHANNEL membership, which is what "can someone buy
- * this" means: `"materialBankNaOrderable"` (Material Bank North America),
+ * Four members gate on governed CHANNEL membership:
+ * `"materialBankNaOrderable"` (Material Bank North America),
  * `"materialBankEuOrderable"` (Material Bank Europe) and
  * `"designShopOrderable"` (DesignShop, with the products DesignShop hides from
  * browse excluded).
+ * `"materialBankNaAndCatalogue"` is a single producer-side union of Material
+ * Bank North America and governed Catalogue channel membership.
  *
  * `"materialBankOrderable"` is NOT one of them, despite the name. It selects
  * materials carrying a Material Bank identity — PROVENANCE, not a storefront —
  * and admits about 98% of the graph. Use it to exclude the crawl-sourced brands
  * that were never in the Material Bank feed; if you mean orderable, use one of
- * the three above.
+ * the channel-backed scopes above.
  */
-export type CorpusScope = OpenEnum<"all" | "designShopOrderable" | "materialBankEuOrderable" | "materialBankNaOrderable" | "materialBankOrderable">;
+export type CorpusScope = OpenEnum<"all" | "designShopOrderable" | "materialBankEuOrderable" | "materialBankNaAndCatalogue" | "materialBankNaOrderable" | "materialBankOrderable">;
 /**
  * The corpus a response AND its counts were drawn from. Present only when a
  * narrowing scope applied — absence means the whole graph. Read it alongside

package/index.d.ts

@@ -17,6 +17,7 @@ export type * from "./run-events.js";
 export { MATERIALGRAPH_PROBLEM_EXTENSIONS, MaterialGraphError, } from "./errors.js";
 export type { MaterialGraphErrorInit, MaterialGraphErrorKind, MaterialGraphRequestMetadata, ProblemDetail, RateLimit, SanitizedErrorValue, SanitizedIssue, SimpleErrorBody, } from "./errors.js";
 export type * from "./types.js";
+export type * from "./search-collapse-types.js";
 export type * from "./match-types.js";
 export type * from "./browse-types.js";
 export type * from "./catalogue-types.js";