@instruments/materialgraph 0.26.0 → 0.27.1

package/brand-most-sampled-types.d.ts

@@ -1,33 +0,0 @@
-import type { CandidateReadCard } from "./exploration-types.js";
-export type BrandMostSampledResponse = {
-    data: {
-        brand: {
-            id: string;
-            name: string;
-        };
-        status: "ready" | "unavailable";
-        metric: "sample_order_lines";
-        provenance: {
-            source: "material_bank_order_history";
-            signal: "sampled";
-            sessionId: string;
-            window: "trailing_36mo";
-            windowStart: string;
-            windowEnd: string;
-        } | null;
-        products: {
-            rank: number;
-            sampleOrderLines: number;
-            representativeVariantSampleOrderLines: number;
-            card: CandidateReadCard & {
-                category: string | null;
-            };
-        }[];
-    };
-    meta: {
-        operationId: "brands.most_sampled";
-        requestId: string;
-    };
-    links: Record<string, never>;
-    warnings: never[];
-};

package/browse-types.d.ts

@@ -1,236 +0,0 @@
-import type { ByColourSwatch } from "./by-colour-types.js";
-/**
- * Wire types for the browse lane — GET `/api/v1/search/browse`.
- *
- * The SDK's one genuinely cursor-paginated surface, and the only lane with no
- * query, no relevance and no ranking: the corpus in a stated order. That is what
- * a category listing or a brand fan deck actually needs, and it is why `count`
- * matters here more than anywhere else — a listing that cannot state its own
- * size has to either walk every page or report a page size as a total.
- *
- * Lifted out of `types.ts` for the repository's source-file size budget when the
- * lane gained its non-colour sorts and its feed count (MG-1483 / MG-1542).
- * Nothing about the client's surface changed: `index.ts` re-exports these
- * exactly as before.
- */
-import type { CorpusScope, CorpusScopeReceipt } from "./corpus-scope-types.js";
-import type { Cursor, ProductId, VariantId } from "./identifiers.js";
-import type { CountedTotal, OpenEnum, SearchFacets } from "./types.js";
-/** One item from the pure colour-scalar browse. */
-export type BrowseResultItem = {
-    /** Opaque — round-trip verbatim. */
-    variantId: VariantId;
-    brand: string;
-    product: string;
-    brandSlug: string | null;
-    productId: ProductId | null;
-    color: string | null;
-    variantName: string | null;
-    /** MaterialGraph record creation time, not a manufacturer release date. */
-    recordCreatedAt: string | null;
-    imageUrl: string | null;
-    scalars: {
-        l: number | null;
-        chroma: number | null;
-        vibrancy: number | null;
-    };
-    retired?: boolean;
-    /**
-     * The row's own image palette — the FULL stored palette of the SAME image
-     * `imageUrl` serves, uncapped and in stored order, each swatch with `oklab`
-     * (see {@link ByColourSwatch}), so a card can render, sort or group colours
-     * without a second call. A one-swatch palette means the extractor found one
-     * colour (solid-colour materials are genuinely monochrome), not that the list
-     * was trimmed. ABSENT when no palette is on record for that image: absent
-     * means unknown, NOT that the material has no colours. These swatches come
-     * from product imagery, not from the manufacturer.
-     */
-    palette?: ByColourSwatch[];
-    /**
-     * Resolved values for the attribute ids sent in `returnAttributes`, keyed by
-     * attribute id. ABSENT entirely when `returnAttributes` was not sent; a key
-     * whose value is `null` means this material carries no accepted value for that
-     * attribute. Three states, all different.
-     */
-    attributes?: Record<string, string | string[] | null>;
-};
-/**
- * The browse orders. `name` (A→Z) is the default, `name_desc` the same index
- * read Z→A, `recent` newest first; the rest are the colour ramps. `/search`
- * takes all eight too — one word, one order, on both lanes.
- */
-export type BrowseSort = OpenEnum<"name" | "name_desc" | "recent" | "light" | "dark" | "vivid" | "muted" | "colourful">;
-/**
- * The browse feed's total — how many materials the browse DESCRIBES, which is
- * never `results.length`.
- *
- * Uncapped, unlike {@link SearchCounts}: `basis:"exact"` is the true figure
- * whatever its size, and `basis:"lowerBound"` means the count query timed out
- * and the value is a floor. Counted over the SAME filters the page was drawn
- * from, so a `types=`, `brands=` or `corpusScope=` narrowed browse reports the
- * narrowed total — you will never get a whole-graph number beside a filtered
- * page.
- */
-export type BrowseCounts = {
-    variants: CountedTotal;
-};
-/**
- * A single page of the browse — the SDK's one genuinely cursor-paginated
- * surface. `results.length` is this page. Ask for `count: true` and `counts`
- * states the total; without it the browse states no total at all, and a corpus
- * claim can only come from walking every page (`client.browse.pages(...)` does
- * the loop).
- */
-export type BrowseResponse = {
-    /** THIS PAGE. */
-    results: BrowseResultItem[];
-    /** Opaque keyset for the next page. Absent = the walk is finished. */
-    cursor?: Cursor;
-    /**
-     * The order this page was built in — echoed, because `sort` is optional and
-     * defaulted, so a caller that omitted it need not know the server's default
-     * to label its own listing.
-     */
-    sort: BrowseSort;
-    /**
-     * The attribute ladder this page was ordered by — present ONLY when `orderBy`
-     * was sent, in which case it SUPERSEDED `sort` (still echoed above, and still
-     * describing nothing this page was ordered by).
-     */
-    orderBy?: {
-        attributeId: string;
-        direction: OpenEnum<"asc" | "desc">;
-    };
-    /**
-     * Reader prose about how the request was interpreted — today, only that
-     * `orderBy` superseded a STATED `sort`. Absent means nothing needed saying.
-     */
-    note?: string;
-    /**
-     * The total, present ONLY when `count: true` was passed. Absent means it was
-     * not asked for — never that the set is empty.
-     */
-    counts?: BrowseCounts;
-    /**
-     * Per-facet value counts, present ONLY when `facetCounts` was asked for.
-     *
-     * Counted over this browse's OWN match set — the same predicate the page and
-     * `counts` ran under — so every value is `basis:"exact"` and `poolSize` is
-     * ABSENT. That differs from {@link SearchResponse}'s facets, which are
-     * normally counted over a ranked candidate pool and are therefore floors:
-     * browse retrieves no pool, so there is nothing for a figure to be a floor
-     * of. A facet the server could not count in time appears in `absent` with
-     * `reason:"timeout"` and the results are unaffected.
-     */
-    facets?: SearchFacets;
-    /**
-     * The corpus this page was drawn from — present ONLY when the request
-     * narrowed it. ABSENT means the whole graph: every material MaterialGraph
-     * knows, orderable or not.
-     */
-    corpusScope?: CorpusScopeReceipt;
-};
-/** Params for the pure colour `search/browse` surface. */
-export type BrowseParams = {
-    /**
-     * OPTIONAL. Defaults to `name` (A→Z); `recent` is newest first.
-     *
-     * The five colour ramps (`light`/`dark`/`vivid`/`muted`/`colourful`) order by
-     * an EXTRACTED colour scalar and therefore see only colour-extracted
-     * materials — a genuinely smaller set than `name` and `recent` walk. That is
-     * not a bug to route around; ask for `count` and each sort reports the size of
-     * the set it actually describes.
-     */
-    sort?: BrowseSort;
-    /**
-     * The previous page's `cursor`, verbatim. Opaque keyset state — not an offset.
-     * Changing `sort`, `limit`, `types`, `brands` or `corpusScope` invalidates it.
-     */
-    cursor?: Cursor;
-    /** Page size. */
-    limit?: number;
-    /**
-     * Return `counts.variants` — the total size of the set this browse walks,
-     * counted over the same filters the page came from.
-     *
-     * Opt-in, because it is a second query. A category listing that cannot state
-     * how many things it is listing has to either walk every page or report the
-     * page size as a total; this is the third option.
-     */
-    count?: boolean;
-    /**
-     * Comma-separated taxonomy keys to restrict the browse to, at EITHER tier of
-     * `/api/v1/taxonomy/categories`. A GROUP key (`tile_surfaces`) expands to
-     * every product type under it, a TYPE key (`ceramic_porcelain_tile`) stands
-     * for itself, and a mixed list is their deduplicated union. A key in neither
-     * tier is a 400 listing the valid keys — never an empty page.
-     */
-    types?: string;
-    /**
-     * Comma-separated canonical brand ids, exact slugs (`farrow-ball`), or exact
-     * display names (`Farrow & Ball`). Canonical ids and slugs are case-sensitive
-     * and opaque; display names are case-insensitive. One brand plus a colour `sort` is that brand's
-     * fan deck. An unknown brand is a typed 400 naming it, and an exact display
-     * name shared by multiple brands is a typed 400 with the candidates; neither
-     * becomes an empty page.
-     */
-    brands?: string;
-    /**
-     * Positive manufacturer declarations. accepts_finishes includes variants of
-     * product-level declarations; it does not assert variant-specific applicability.
-     * Absence means no role filter.
-     */
-    role?: "finish" | "accepts_finishes";
-    /**
-     * Typed attribute filters, in the SAME grammar `search` takes — a term, a
-     * term SET (OR within the entry), a presence check or a numeric range, each
-     * optionally carrying a `trust` bar. Entries AND together.
-     *
-     * Each entry is sent as ITS OWN `filters=` parameter, JSON-encoded, which is
-     * what the route reads. Pass the objects; the client does the encoding.
-     *
-     * Applied INSIDE the keyset scan and counted under the same predicate, so a
-     * filtered page still fills to `limit`, `cursor` still means another MATCHING
-     * row exists, and `counts.variants` describes the FILTERED set. An attribute
-     * id outside the registry is a 400 carrying ranked candidates, never an empty
-     * page.
-     */
-    filters?: readonly Record<string, unknown>[];
-    /**
-     * Facet ids to count over this browse's match set — `brand`, `category`, or a
-     * spec attribute id. Sent as one comma-separated `facetCounts=` parameter.
-     *
-     * The response's `facets` block comes back `basis:"exact"` with no
-     * `poolSize`, because browse counts the whole predicate rather than a ranked
-     * pool. Omit it for no `facets` block and no counting cost.
-     */
-    facetCounts?: readonly string[];
-    /**
-     * Which corpus to walk. ABSENT means the whole graph — every material
-     * MaterialGraph knows, orderable or not. `materialBankOrderable` restricts to
-     * materials carrying a Material Bank identity, applied inside the scan, so a
-     * scoped page is still a full page and `cursor` still means another eligible
-     * row exists.
-     */
-    corpusScope?: CorpusScope;
-    /**
-     * Sort along ONE attribute's declared value ladder instead of a `sort` word —
-     * the same field, ladder and refusals `search` takes. Sent as one JSON-encoded
-     * `orderBy=` parameter; pass the object, the client encodes it.
-     *
-     * SUPERSEDES `sort` when both are given, and the response `note` says so.
-     * Ordering is DECLARED, never inferred from a value's spelling: an attribute
-     * with no stated ladder is a 400 carrying `orderable_attributes`. Materials
-     * off the ladder, or carrying no value, sort LAST in both directions.
-     */
-    orderBy?: {
-        attributeId: string;
-        direction?: OpenEnum<"asc" | "desc">;
-    };
-    /**
-     * Attribute ids whose resolved value rides each result under `attributes`, so
-     * a filtered listing can display what it filtered on. Sent as one
-     * comma-separated `returnAttributes=` parameter.
-     */
-    returnAttributes?: readonly string[];
-};

package/client-browse.d.ts

@@ -1,78 +0,0 @@
-/**
- * The `browse` namespace's implementation — the paged colour-ordered walk of the
- * corpus behind `client.browse(...)` and `client.browse.pages(...)`.
- *
- * Lifted out of `client.ts` for the repository's source-file size budget. These
- * were already private implementations behind a public namespace, so nothing
- * about the client's surface changes: `client.browse` is still a callable with a
- * `.pages()` generator, and the class still owns the transport. What moved is
- * the pagination LOOP, which is the only real logic here and the only part worth
- * testing on its own.
- */
-import type { BrowseParams, BrowseResponse } from "./browse-types.js";
-/**
- * `client.browse(...)` — callable for ONE PAGE, `.pages()` for the whole walk.
- *
- * The distinction is the whole point: the single-call form hands you a page and
- * states no total, so a corpus claim can only come from `.pages()`. Never report
- * one page's length as "how many materials there are".
- */
-export type BrowseNamespace = {
-    (params: BrowseParams, signal?: AbortSignal): Promise<BrowseResponse>;
-    pages(params: BrowseParams, signal?: AbortSignal): AsyncGenerator<BrowseResponse, void, unknown>;
-};
-/** Fetch one page. The client supplies this, so the transport stays private. */
-export type BrowsePageFetcher = (params: BrowseParams, signal?: AbortSignal) => Promise<BrowseResponse>;
-/**
- * The query string for one browse page — EVERY param the route reads, named here
- * so the client method and the pagination loop cannot disagree about them.
- *
- * "Every" is load-bearing. This is an allow-list wrapper, and an allow-list
- * wrapper that rebuilds a query from named fields is precisely the shape that
- * silently drops a param the server already honours: `brands` shipped on the
- * route and never reached it from here, so the fan deck was unreachable through
- * the published client while the server had supported it all along. When the
- * route gains a param, it gains a line HERE too, or it is not shipped.
- *
- * It happened again, and twice: `filters` shipped with MG-1576 and `facetCounts`
- * with MG-1590, and neither had a line here. Attribute filtering — the thing
- * MG-1588 spent a materialized view making fast — was therefore unreachable
- * through the published client for as long as it existed on the route. Both are
- * enrolled below, along with MG-1593's `orderBy` and `returnAttributes`.
- *
- * `filters` is a REPEATED parameter and `facetCounts` a comma list, because that
- * is what the route reads: the transport appends an array once per element, so
- * the array shape and the comma-joined string are each doing exactly what the
- * server expects rather than being two spellings of one idea.
- */
-export declare const browseQuery: (params: BrowseParams) => {
-    sort: BrowseParams["sort"];
-    cursor: BrowseParams["cursor"];
-    limit: BrowseParams["limit"];
-    count: BrowseParams["count"];
-    types: BrowseParams["types"];
-    brands: BrowseParams["brands"];
-    role: BrowseParams["role"];
-    filters: string[] | undefined;
-    facetCounts: string | undefined;
-    corpusScope: BrowseParams["corpusScope"];
-    orderBy: string | undefined;
-    returnAttributes: string | undefined;
-};
-/**
- * Walk every page from `params.cursor` onward.
- *
- * Stops on the first page that reports no next cursor OR comes back empty. Both
- * conditions matter: a server that keeps handing out a cursor for an exhausted
- * scan would otherwise spin here forever, and an infinite generator is a hang,
- * not an error anyone can see.
- */
-export declare function browsePages(fetchPage: BrowsePageFetcher, params: BrowseParams, signal?: AbortSignal): AsyncGenerator<BrowseResponse, void, unknown>;
-/**
- * Build the callable-with-`.pages()` object the client exposes as `browse`.
- *
- * @example
- * const page = await client.browse({ sort: "lightest" });
- * for await (const page of client.browse.pages({ sort: "lightest" })) { … }
- */
-export declare const createBrowseNamespace: (fetchPage: BrowsePageFetcher) => BrowseNamespace;

package/client-browse.js

@@ -1,71 +0,0 @@
-/**
- * The query string for one browse page — EVERY param the route reads, named here
- * so the client method and the pagination loop cannot disagree about them.
- *
- * "Every" is load-bearing. This is an allow-list wrapper, and an allow-list
- * wrapper that rebuilds a query from named fields is precisely the shape that
- * silently drops a param the server already honours: `brands` shipped on the
- * route and never reached it from here, so the fan deck was unreachable through
- * the published client while the server had supported it all along. When the
- * route gains a param, it gains a line HERE too, or it is not shipped.
- *
- * It happened again, and twice: `filters` shipped with MG-1576 and `facetCounts`
- * with MG-1590, and neither had a line here. Attribute filtering — the thing
- * MG-1588 spent a materialized view making fast — was therefore unreachable
- * through the published client for as long as it existed on the route. Both are
- * enrolled below, along with MG-1593's `orderBy` and `returnAttributes`.
- *
- * `filters` is a REPEATED parameter and `facetCounts` a comma list, because that
- * is what the route reads: the transport appends an array once per element, so
- * the array shape and the comma-joined string are each doing exactly what the
- * server expects rather than being two spellings of one idea.
- */
-export const browseQuery = (params) => ({
-    brands: params.brands,
-    corpusScope: params.corpusScope,
-    count: params.count,
-    cursor: params.cursor,
-    facetCounts: params.facetCounts?.join(","),
-    filters: params.filters?.map((entry) => JSON.stringify(entry)),
-    limit: params.limit,
-    // `orderBy` is JSON-encoded and `returnAttributes` comma-joined because that
-    // is what the route reads — the same two transports `filters` and
-    // `facetCounts` already use. Enrolled HERE at the same time they shipped on
-    // the route, which is the thing the three misses above did not do.
-    orderBy: params.orderBy ? JSON.stringify(params.orderBy) : undefined,
-    returnAttributes: params.returnAttributes?.join(","),
-    role: params.role,
-    sort: params.sort,
-    types: params.types,
-});
-/**
- * Walk every page from `params.cursor` onward.
- *
- * Stops on the first page that reports no next cursor OR comes back empty. Both
- * conditions matter: a server that keeps handing out a cursor for an exhausted
- * scan would otherwise spin here forever, and an infinite generator is a hang,
- * not an error anyone can see.
- */
-export async function* browsePages(fetchPage, params, signal) {
-    let { cursor } = params;
-    for (;;) {
-        const page = await fetchPage({ ...params, cursor }, signal);
-        yield page;
-        if (page.cursor === undefined || page.results.length === 0) {
-            return;
-        }
-        cursor = page.cursor;
-    }
-}
-/**
- * Build the callable-with-`.pages()` object the client exposes as `browse`.
- *
- * @example
- * const page = await client.browse({ sort: "lightest" });
- * for await (const page of client.browse.pages({ sort: "lightest" })) { … }
- */
-export const createBrowseNamespace = (fetchPage) => {
-    const browse = async (params, signal) => await fetchPage(params, signal);
-    browse.pages = (params, signal) => browsePages(fetchPage, params, signal);
-    return browse;
-};

package/client-exploration.d.ts

@@ -1,9 +0,0 @@
-import type { CandidateReadInput, CandidateReadResponse, GraphOperatorEvidence } from "./exploration-types.js";
-import type { HttpTransport } from "./http-transport.js";
-import type { VariantId } from "./identifiers.js";
-/** Discovery and traversal share one namespace so availability precedes use. */
-export type ExplorationNamespace = {
-    operators(variantId: VariantId, signal?: AbortSignal): Promise<GraphOperatorEvidence>;
-    candidates(variantId: VariantId, input: CandidateReadInput, signal?: AbortSignal): Promise<CandidateReadResponse>;
-};
-export declare const createExplorationNamespace: (transport: HttpTransport) => ExplorationNamespace;

package/client-exploration.js

@@ -1,5 +0,0 @@
-import { resolveOperation } from "./operations.js";
-export const createExplorationNamespace = (transport) => ({
-    candidates: async (variantId, input, signal) => await transport.requestJson(resolveOperation("read_material_candidates"), { body: input, pathParams: { variantId }, signal }),
-    operators: async (variantId, signal) => await transport.requestJson(resolveOperation("list_material_operators"), { pathParams: { variantId }, signal }),
-});

package/compare-types.d.ts

@@ -1,89 +0,0 @@
-export type CompareInput = {
-    variantIds: string[];
-    selection?: {
-        kind: "blocks";
-        blockIds: string[];
-    } | {
-        kind: "attributes";
-        attributeIds: string[];
-    };
-};
-type Availability = "available" | "discontinued" | "superseded" | "unknown";
-type ClaimScope = "variant" | "product" | "brand";
-export type CompareTarget = {
-    variantId: string;
-    version: string;
-    freshness: {
-        oldestAt: string | null;
-        newestAt: string | null;
-    };
-    identity: {
-        variantId: string;
-        variantName: string | null;
-        brand: string;
-        brandSlug: string;
-        product: string;
-        productId: string;
-        colourName: string | null;
-        category: string | null;
-        categoryPath: string[];
-        imageUrl: string | null;
-        installationImageUrl: string | null;
-        dominantHex: string | null;
-        siblingCount: number;
-    };
-    availability: {
-        state: Availability;
-        label: string | null;
-        supersededBy: {
-            variantId: string;
-            brandSlug: string;
-            productId: string;
-            brand: string;
-            product: string;
-            variant: string;
-            color: string | null;
-            availability: Availability;
-        } | null;
-    };
-    sampleability: boolean | null;
-};
-export type CompareCell = {
-    variantId: string;
-    state: "known" | "unknown" | "conflicting" | "inapplicable";
-    recordState: "stated" | "conflicting" | "stale" | "unknown" | "missing" | "not_applicable" | "not_evaluated";
-    value: unknown;
-    unit: string | null;
-    verification: "verified" | "unverified" | "unbacked";
-    confidence: number | null;
-    sourceBasis: string | null;
-    sourceRef: string | null;
-    freshnessAt: string | null;
-    claimScope: ClaimScope | null;
-    competingClaims: {
-        scope: ClaimScope;
-        value: unknown;
-        sourceRef: string | null;
-    }[];
-};
-export type CompareResult = {
-    targets: CompareTarget[];
-    rows: {
-        blockId: string;
-        blockName: string;
-        attributeId: string;
-        label: string;
-        outcome: "same" | "different" | "incomplete" | "indeterminate" | "not_applicable";
-        cells: CompareCell[];
-    }[];
-};
-export type CompareResponse = {
-    data: CompareResult;
-    meta: {
-        operationId: "retrieval.compare";
-        requestId: string;
-    };
-    links: Record<string, never>;
-    warnings: never[];
-};
-export {};

package/composition-client.d.ts

@@ -1,33 +0,0 @@
-/**
- * The COMPOSITION lens: the two synchronous scheme surfaces, as thin wrappers
- * over the shared {@link HttpTransport}. `MaterialGraphClient.varyScheme` and
- * `.slotPools` delegate here; the contract lives in this file.
- *
- * They are two altitudes of the same capability. `varyScheme` re-derives a
- * scheme MaterialGraph itself composed; `slotPools` hands the ranked candidates
- * to a composer that is not MaterialGraph, and keeps none of the ownership.
- */
-import type { VarySchemesRequest, VarySchemesResponse } from "./composition-types.js";
-import type { HttpTransport } from "./http-transport.js";
-import type { SlotPoolsRequest, SlotPoolsResponse } from "./slot-pool-types.js";
-/**
- * THE QUESTION: "show me the same brief, decided differently." Re-derives an
- * option B from a succeeded compose Run along ONE constraint axis. Deterministic
- * and synchronous — the response IS the hydrated scheme (no Run envelope),
- * stamped with axis + source provenance whose `notes` are the receipts.
- * Requires the `mg:read` scope.
- */
-export declare const varyScheme: (transport: HttpTransport, body: VarySchemesRequest, signal?: AbortSignal) => Promise<VarySchemesResponse>;
-/**
- * THE QUESTION: "for each of these slots, what should I be choosing between?"
- * Up to 24 self-contained tasks in, one ranked and gated candidate pool each
- * out, correlated by YOUR `taskKey`. Synchronous, uncached and project-free —
- * no Run, no programme, no state kept on the MaterialGraph side.
- *
- * READ THE POOLS, NOT JUST THE CANDIDATES. A task whose search failed comes back
- * with a `search-failed` shortfall while the rest answer normally; a candidate
- * with `eligible: false` is LABELLED rather than dropped (read `flags`); and a
- * criterion that graded `missing` or `not_evaluated` was never a failure.
- * Requires the `mg:read` scope.
- */
-export declare const slotPools: (transport: HttpTransport, body: SlotPoolsRequest, signal?: AbortSignal) => Promise<SlotPoolsResponse>;

package/composition-client.js

@@ -1,28 +0,0 @@
-import { resolveOperation } from "./operations.js";
-/**
- * THE QUESTION: "show me the same brief, decided differently." Re-derives an
- * option B from a succeeded compose Run along ONE constraint axis. Deterministic
- * and synchronous — the response IS the hydrated scheme (no Run envelope),
- * stamped with axis + source provenance whose `notes` are the receipts.
- * Requires the `mg:read` scope.
- */
-export const varyScheme = async (transport, body, signal) => await transport.requestJson(resolveOperation("vary_schemes"), {
-    body,
-    signal,
-});
-/**
- * THE QUESTION: "for each of these slots, what should I be choosing between?"
- * Up to 24 self-contained tasks in, one ranked and gated candidate pool each
- * out, correlated by YOUR `taskKey`. Synchronous, uncached and project-free —
- * no Run, no programme, no state kept on the MaterialGraph side.
- *
- * READ THE POOLS, NOT JUST THE CANDIDATES. A task whose search failed comes back
- * with a `search-failed` shortfall while the rest answer normally; a candidate
- * with `eligible: false` is LABELLED rather than dropped (read `flags`); and a
- * criterion that graded `missing` or `not_evaluated` was never a failure.
- * Requires the `mg:read` scope.
- */
-export const slotPools = async (transport, body, signal) => await transport.requestJson(resolveOperation("slot_pools"), {
-    body,
-    signal,
-});