@mohasinac/appkit 4.52.5 → 4.53.0

package/dist/_internal/shared/features/sticker-trace/types.d.ts

@@ -0,0 +1,197 @@
+/** Decoded pixels. Always RGBA8, row-major, tightly packed. */
+export interface DecodedRaster {
+    readonly width: number;
+    readonly height: number;
+    /** length === width * height * 4 */
+    readonly data: Uint8Array;
+    /**
+     * Scan resolution, when the source declared one AND an operator confirmed it.
+     *
+     * Absent is a real answer and must stay representable: five of the nine
+     * reference scans declare 72 or 96 dpi, which is a default the encoder wrote
+     * rather than a measurement. Millimetre output is WITHHELD when this is
+     * undefined — a fabricated mm figure on a cut file is a physical production
+     * error, which is a different class of wrong from a missing number.
+     */
+    readonly dpi?: number;
+}
+export interface EncodedImage {
+    readonly bytes: Uint8Array;
+    readonly contentType: string;
+}
+export interface Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+/** One cubic Bézier segment; the start point is the previous segment's end. */
+export interface CubicSegment {
+    readonly c1: Point;
+    readonly c2: Point;
+    readonly to: Point;
+}
+/**
+ * One closed outline. Kiss-cut sheets cut the outer boundary only — interior
+ * holes are never cut, or the sticker falls apart on the backing — so a part
+ * carries exactly one path and `segments` always closes back to `start`.
+ */
+export interface CutPath {
+    readonly start: Point;
+    readonly segments: readonly CubicSegment[];
+}
+/**
+ * The pipeline, in order. A failure reports the stage it died in, which is the
+ * difference between "it broke" and "the ridge detector found nothing on a
+ * halftone scan" — so the union is shared by the runner, the progress channel
+ * and the retry panel rather than restated in each.
+ */
+export declare const TRACE_STAGES: readonly ["decode", "prefilter", "ridge", "quantise", "fuse", "flood", "segment", "cluster", "geometry", "parts", "exports"];
+export type TraceStage = (typeof TRACE_STAGES)[number];
+/**
+ * `paper` — stickers sit on bare backing; the sheet border is background.
+ * `art`   — the whole sheet is printed and the only signal is the cut line.
+ * `auto`  — decide from the border band's colour spread (see trace/paper).
+ *
+ * Several real sheets are BOTH (black-dranzer is paper on the left, solid red
+ * and blue panels on the right), which is why this selects an emphasis rather
+ * than switching algorithms: the ridge pass runs regardless, and this only
+ * weights how much the paper-flood is trusted.
+ */
+export type ScanType = "auto" | "paper" | "art";
+export type PrecisionTier = "draft" | "standard" | "precise" | "max";
+export type PrefilterKind = "none" | "median" | "bilateral";
+/**
+ * Grouped BY STAGE, and that grouping is load-bearing rather than cosmetic: a
+ * resumed run may only skip stages whose parameters did not change. Without the
+ * grouping, "resume from `parts` with a different ridge threshold" yields a run
+ * whose stored artifacts were produced under different parameters than the run
+ * records, and nothing anywhere contradicts it.
+ */
+export interface TraceParams {
+    readonly tier: PrecisionTier;
+    readonly scanType: ScanType;
+    /** decode */
+    readonly workingLongEdge: number;
+    readonly dpi?: number;
+    /** prefilter */
+    readonly prefilter: PrefilterKind;
+    readonly prefilterRadius: number;
+    /** ridge */
+    readonly ridgeHysteresisLow: number;
+    readonly ridgeHysteresisHigh: number;
+    readonly ridgeKernelScale: number;
+    /** quantise — the second detector channel; see trace/quantise */
+    readonly quantiseEnabled: boolean;
+    readonly quantiseColours: number;
+    readonly quantiseWeight: number;
+    /** flood */
+    readonly paperTolerance: number;
+    readonly seedBandPx: number;
+    /** segment */
+    readonly minPartAreaMm2: number;
+    readonly maxParts: number;
+    readonly bridgeMm: number;
+    /**
+     * Art sheets only. A region boundary below this multiple of the sheet's
+     * MEDIAN boundary strength is treated as printing rather than a cut, and the
+     * two regions merge. See trace/merge for why this exists at all.
+     */
+    readonly mergeStrengthFactor: number;
+    /** geometry */
+    readonly smoothMm: number;
+    readonly borderMm: number;
+    readonly bleedMm: number;
+    readonly simplifyMm: number;
+    readonly cleanMm: number;
+    /** cluster */
+    readonly clusterGapMm: number;
+}
+export interface PartGeometry {
+    /** 1-based, stable within a run; what the admin renames and references. */
+    readonly ordinal: number;
+    /** Which physical sheet this part belongs to, when one scan holds several. */
+    readonly groupIndex: number;
+    readonly bboxPx: Rect;
+    readonly areaPx: number;
+    /** Null whenever DPI is unknown — never a guess. */
+    readonly bboxMm: Rect | null;
+    readonly areaMm2: number | null;
+    /**
+     * Narrowest internal width, in mm when DPI is known. Cricut's minimum
+     * reliable detail is 0.25in (6mm); a part with a neck below that tears rather
+     * than cuts, so the exporter needs this to warn before a sheet is wasted.
+     */
+    readonly minFeatureMm: number | null;
+    readonly path: CutPath;
+}
+/**
+ * One physical sheet within a scan. A 4948x6955 scan can hold several, and
+ * grouping them by large border gaps is what makes the part list navigable
+ * rather than one run of sixty.
+ */
+export interface SheetCluster {
+    readonly index: number;
+    readonly bboxPx: Rect;
+    readonly partOrdinals: readonly number[];
+}
+/**
+ * Reported whether or not the trace succeeded, because the numbers that explain
+ * a BAD result are the same ones that explain a good one. `ridgeCoverage` near
+ * zero on an `art` scan means the detector found nothing — which is a different
+ * remedy from `droppedBelowMinArea` in the hundreds, which means it found noise.
+ */
+export interface TraceDiagnostics {
+    readonly workingSize: Rect;
+    readonly paperColour: readonly [number, number, number] | null;
+    readonly ridgeCoverage: number;
+    readonly quantiseCoverage: number;
+    readonly fusedCoverage: number;
+    readonly componentsFound: number;
+    readonly droppedBelowMinArea: number;
+    /**
+     * Components covering more than MAX_PART_FRACTION of the raster.
+     *
+     * 🛑 Named for what it counts. It was `droppedTouchingBorder`, which told a
+     * reader diagnosing a zero-part scan that a sticker had run off the edge —
+     * a different and wrong story. A sheet-sized component means the flood never
+     * got IN, and that is the one thing worth knowing at that moment.
+     */
+    readonly droppedSheetSized: number;
+    /**
+     * Fraction of the raster the paper path could flood through.
+     *
+     * The paper model needs real background; `isAvailable`-style negation has
+     * nothing to work with when there is none. Measured across this corpus at
+     * `standard`, the three paper scans that segment correctly sit at 27.7%,
+     * 51.3% and 74.2%, and the one that returns zero parts sits at **7.8%** — so
+     * this is the statistic that separates "this sheet has no stickers" from
+     * "this model cannot read this scan", which otherwise look identical.
+     *
+     * 1 on an art scan, where the question does not arise.
+     */
+    readonly backgroundCoverage: number;
+    readonly bridgedComponents: number;
+    /**
+     * Reserved. Art-background sheets WERE unsupported — see the git history for
+     * the four approaches that failed and why — and are now handled by the
+     * Hessian line filter plus the region merge. Kept as a field rather than
+     * deleted because the art path is the one whose accuracy depends on a tuned
+     * constant (mergeStrengthFactor), so a future sheet that defeats it needs a
+     * way to say so without a schema change.
+     */
+    readonly artBackgroundUnsupported: boolean;
+}
+export interface TraceResult {
+    readonly parts: readonly PartGeometry[];
+    readonly clusters: readonly SheetCluster[];
+    readonly diagnostics: TraceDiagnostics;
+    /** Pixels per millimetre, or null when DPI is unknown. */
+    readonly pxPerMm: number | null;
+    /** Scale from working-raster pixels back to the source image. */
+    readonly sourceScale: number;
+}

package/dist/_internal/shared/features/sticker-trace/types.js

@@ -0,0 +1,49 @@
+/*
+ * WHY: A scanned sticker sheet has to become cut-ready geometry, and the same
+ *      algorithm has to run in two places — a browser tuning it live, and a
+ *      Firebase Function rendering it at full resolution. Two implementations
+ *      would drift (CLAUDE.md Root Cause #59/#73), so there is exactly one, and
+ *      these are the shapes it speaks in.
+ * WHAT: Every type the tracing core exchanges with its callers. Deliberately
+ *       free of any image-codec, Firestore or DOM type: the core takes decoded
+ *       pixels and returns geometry, and knows nothing about where either came
+ *       from.
+ *
+ * Coordinates are a constant source of error here, so the rule is stated once:
+ * every geometric value in this module is in WORKING-RASTER PIXELS unless its
+ * name ends in `Mm`. The working raster is a downscale of the source (see
+ * config.WORKING_LONG_EDGE), so a caller rendering at full resolution scales by
+ * `source.width / raster.width`. Carrying vectors rather than masks is what
+ * makes that rescale exact.
+ *
+ * EXPORTS:
+ *   DecodedRaster, EncodedImage, Rect, Point, CubicSegment, CutPath,
+ *   TraceStage, TRACE_STAGES, ScanType, PrecisionTier, PrefilterKind,
+ *   TraceParams, PartGeometry, SheetCluster, TraceResult, TraceDiagnostics
+ *
+ * @tag domain:sticker-trace
+ * @tag layer:shared
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:trace/*,math/*,export/*,canvas-codec,sharp-codec,run
+ * @tag sideEffects:none
+ */
+/**
+ * The pipeline, in order. A failure reports the stage it died in, which is the
+ * difference between "it broke" and "the ridge detector found nothing on a
+ * halftone scan" — so the union is shared by the runner, the progress channel
+ * and the retry panel rather than restated in each.
+ */
+export const TRACE_STAGES = [
+    "decode",
+    "prefilter",
+    "ridge",
+    "quantise",
+    "fuse",
+    "flood",
+    "segment",
+    "cluster",
+    "geometry",
+    "parts",
+    "exports",
+];

package/dist/_internal/shared/listing-types/_registry.d.ts

@@ -23,6 +23,7 @@
  */
 import { LISTING_TYPE_CAPABILITIES } from "./capabilities";
 import { type AvailabilityRow, type UnavailableClause } from "./availability";
+import type { IconKey } from "../../../ui/icons/icon-registry";
 import type { ListingType } from "../../../features/products/types/index";
 import type { SortOption } from "../../../features/products/constants/sieve";
 import { type AvailabilityFilter } from "../../../constants/field-names";
@@ -107,6 +108,16 @@ export interface ListingTypePlugin {
      * reachable only by typing the URL.
      */
     inGeneralCatalogue: boolean;
+    /**
+     * Leading glyph for this type's chip, tab and dropdown row.
+     *
+     * 🛑 REQUIRED, like `inGeneralCatalogue` and for the same reason: a tenth
+     * listing type must not compile until someone has answered what it looks
+     * like. An optional field would be silently omitted and that type would be
+     * the one unlabelled row in every picker — the gap being invisible is
+     * exactly the failure the required fields on this interface exist to stop.
+     */
+    iconKey: IconKey;
     /**
      * Which "Show X" default this type's browse surfaces apply. Since 2026-08-24
      * this drives the LABEL of the availability tab bar's middle tab

package/dist/_internal/shared/listing-types/art/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "art";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/art/config.js

@@ -22,6 +22,7 @@ export const config = {
     browseRoute: String(ROUTES.PUBLIC.ART),
     // /art ("Art & Stickers") is in MAIN_NAV_ITEMS and spans art + stickers.
     inGeneralCatalogue: false,
+    iconKey: "art",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared
     // stock-only rules are the whole story for this type.

package/dist/_internal/shared/listing-types/auction/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "bid";
     hideDefault: "ended";
     isAvailable: (row: AvailabilityRow, now: Date) => boolean;
     unavailableClauses: ({

package/dist/_internal/shared/listing-types/auction/config.js

@@ -22,6 +22,7 @@ export const config = {
     // /auctions is in MAIN_NAV_ITEMS. An auction card in the general grid renders
     // Buy-Now chrome rather than bid affordances, so it belongs on its own page.
     inGeneralCatalogue: false,
+    iconKey: "bid",
     // An auction is never "sold out" — it ends. Hiding by stock would hide
     // every live auction, since auctions don't carry meaningful stock.
     hideDefault: "ended",

package/dist/_internal/shared/listing-types/classified/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "deals";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/classified/config.js

@@ -21,6 +21,7 @@ export const config = {
     // Has a dedicated page but NO MAIN_NAV_ITEMS entry, so /products is its only
     // discovery path. Dropping it here would orphan the type (Root Cause #61).
     inGeneralCatalogue: true,
+    iconKey: "deals",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared
     // stock-only rules are the whole story for this type.

package/dist/_internal/shared/listing-types/digital-code/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "digitalCode";
     hideDefault: "sold";
     isAvailable: (row: AvailabilityRow) => boolean;
     unavailableClauses: ({

package/dist/_internal/shared/listing-types/digital-code/config.js

@@ -34,6 +34,7 @@ export const config = {
     // Has a dedicated page but NO MAIN_NAV_ITEMS entry, so /products is its only
     // discovery path. Dropping it here would orphan the type (Root Cause #61).
     inGeneralCatalogue: true,
+    iconKey: "digitalCode",
     // "Sold out" for a code pool means codesAvailable hit 0. That was ASSUMED to
     // be mirrored by stockQuantity, and it isn't — seed and production rows exist
     // with a drained pool and non-zero stock. The pool count is authoritative.

package/dist/_internal/shared/listing-types/feature-flags.d.ts

@@ -34,6 +34,13 @@ interface FeatureFlagSnapshot {
 export declare function isListingTypeEnabled(type: ListingType, settings: FeatureFlagSnapshot | null | undefined): boolean;
 export declare function isCategoryTypeEnabled(type: CategoryType, settings: FeatureFlagSnapshot | null | undefined): boolean;
 export declare const ALL_LISTING_TYPES: ListingType[];
+/**
+ * Narrow an untrusted string — a `?listingType=` param, a form value — to a
+ * real member of the union. Backed by the same `Record<ListingType, true>` as
+ * `ALL_LISTING_TYPES`, so it cannot fall behind the union the way a
+ * hand-written list would (Root Cause #61).
+ */
+export declare function isListingType(value: unknown): value is ListingType;
 /** Pull the full list of enabled listing types in canonical iteration order. */
 export declare function enabledListingTypes(settings: FeatureFlagSnapshot | null | undefined): ListingType[];
 export declare function enabledCategoryTypes(settings: FeatureFlagSnapshot | null | undefined): CategoryType[];

package/dist/_internal/shared/listing-types/feature-flags.js

@@ -54,6 +54,15 @@ const ALL_LISTING_TYPES_MAP = {
     stickers: true,
 };
 export const ALL_LISTING_TYPES = Object.keys(ALL_LISTING_TYPES_MAP);
+/**
+ * Narrow an untrusted string — a `?listingType=` param, a form value — to a
+ * real member of the union. Backed by the same `Record<ListingType, true>` as
+ * `ALL_LISTING_TYPES`, so it cannot fall behind the union the way a
+ * hand-written list would (Root Cause #61).
+ */
+export function isListingType(value) {
+    return typeof value === "string" && value in ALL_LISTING_TYPES_MAP;
+}
 /** Pull the full list of enabled listing types in canonical iteration order. */
 export function enabledListingTypes(settings) {
     return ALL_LISTING_TYPES.filter((t) => isListingTypeEnabled(t, settings));

package/dist/_internal/shared/listing-types/live/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "live";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/live/config.js

@@ -21,6 +21,7 @@ export const config = {
     // Has a dedicated page but NO MAIN_NAV_ITEMS entry, so /products is its only
     // discovery path. Dropping it here would orphan the type (Root Cause #61).
     inGeneralCatalogue: true,
+    iconKey: "live",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared
     // stock-only rules are the whole story for this type.

package/dist/_internal/shared/listing-types/pre-order/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "preOrder";
     hideDefault: "closed";
     isAvailable: (row: AvailabilityRow) => boolean;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/pre-order/config.js

@@ -21,6 +21,7 @@ export const config = {
     browseRoute: String(ROUTES.PUBLIC.PRE_ORDERS),
     // /pre-orders is in MAIN_NAV_ITEMS.
     inGeneralCatalogue: false,
+    iconKey: "preOrder",
     hideDefault: "closed",
     // A pre-order closes when its allocation fills, NOT when its delivery date
     // passes — a shipped-soon pre-order is still orderable. `preOrderClosed`

package/dist/_internal/shared/listing-types/prize-draw/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "prizeDraw";
     hideDefault: "closed";
     isAvailable: (row: AvailabilityRow) => boolean;
     unavailableClauses: ({

package/dist/_internal/shared/listing-types/prize-draw/config.js

@@ -21,6 +21,7 @@ export const config = {
     // /prize-draws is in MAIN_NAV_ITEMS. Entry-based pricing reads wrong beside
     // ordinary unit prices in the general grid.
     inGeneralCatalogue: false,
+    iconKey: "prizeDraw",
     hideDefault: "closed",
     // `prizeRevealStatus`, NOT remaining entries: a draw can close with slots
     // unsold (the seller ends it early, or the reveal window lapses), and it can

package/dist/_internal/shared/listing-types/standard/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "order";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/standard/config.js

@@ -19,6 +19,7 @@ export const config = {
     browseRoute: String(ROUTES.PUBLIC.PRODUCTS),
     // The general catalogue IS this type's page.
     inGeneralCatalogue: true,
+    iconKey: "order",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared
     // stock-only rules are the whole story for this type.

package/dist/_internal/shared/listing-types/stickers/config.d.ts

@@ -18,6 +18,7 @@ export declare const config: {
     chipLabel: string;
     browseRoute: string;
     inGeneralCatalogue: boolean;
+    iconKey: "stickers";
     hideDefault: "sold";
     isAvailable: typeof alwaysAvailable;
     unavailableClauses: readonly import("../availability").UnavailableClause[];

package/dist/_internal/shared/listing-types/stickers/config.js

@@ -22,6 +22,7 @@ export const config = {
     browseRoute: String(ROUTES.PUBLIC.ART),
     // /art ("Art & Stickers") is in MAIN_NAV_ITEMS and spans art + stickers.
     inGeneralCatalogue: false,
+    iconKey: "stickers",
     hideDefault: "sold",
     // Runs out rather than ending — no time dimension, so the shared
     // stock-only rules are the whole story for this type.

package/dist/_internal/shared/media/limits.d.ts

@@ -13,8 +13,18 @@ export declare const MAX_IMAGE_BYTES: number;
 export declare const MAX_PDF_BYTES: number;
 export declare const MAX_VIDEO_BYTES: number;
 export type MediaKind = "image" | "video" | "pdf";
-/** Gallery images per listing. */
-export declare const PRODUCT_MAX_IMAGES = 10;
+/**
+ * Gallery images per listing.
+ *
+ * 24, raised from 10 on 2026-10-19 against measured competitor data
+ * (docs/research/competitor-crawl-2026-10/images.md): sampled maxima are
+ * raikagesbeybladestore 21, hobsoncollectibles 20, toycollectorsindia 31.
+ * 24 covers a pre-owned lot with headroom; 31 is a single outlier and sizing
+ * for it would be sizing for one listing.
+ *
+ * The market MEDIAN is 1-4, so this is a ceiling, not a target.
+ */
+export declare const PRODUCT_MAX_IMAGES = 24;
 /** Videos per listing. Bounded by `ProductDocument.video` being singular. */
 export declare const PRODUCT_MAX_VIDEOS = 1;
 /**

package/dist/_internal/shared/media/limits.js

@@ -27,8 +27,18 @@ export const MAX_VIDEO_BYTES = 50 * MEGABYTE;
 // The video cap is 1 because `ProductDocument.video` is a single field, not an
 // array — raising it is a schema change, not a constant change.
 // ---------------------------------------------------------------------------
-/** Gallery images per listing. */
-export const PRODUCT_MAX_IMAGES = 10;
+/**
+ * Gallery images per listing.
+ *
+ * 24, raised from 10 on 2026-10-19 against measured competitor data
+ * (docs/research/competitor-crawl-2026-10/images.md): sampled maxima are
+ * raikagesbeybladestore 21, hobsoncollectibles 20, toycollectorsindia 31.
+ * 24 covers a pre-owned lot with headroom; 31 is a single outlier and sizing
+ * for it would be sizing for one listing.
+ *
+ * The market MEDIAN is 1-4, so this is a ceiling, not a target.
+ */
+export const PRODUCT_MAX_IMAGES = 24;
 /** Videos per listing. Bounded by `ProductDocument.video` being singular. */
 export const PRODUCT_MAX_VIDEOS = 1;
 /**

package/dist/_internal/shared/search/artifact-url.d.ts

@@ -0,0 +1,35 @@
+/** `search-index/v{n}.json` — the version IS the cache key. */
+export declare const SEARCH_INDEX_PREFIX = "search-index";
+/**
+ * The manifest mirror's object name.
+ *
+ * 🛑 A MIRROR of `searchIndex/manifest` in Firestore, never the source of
+ * truth. The build writes Firestore first and this second, because the
+ * Firestore document is what the next build reads to decide its mode — a
+ * mirror that disagrees costs a stale client for 60 seconds, whereas a
+ * manifest the builder cannot trust costs a full rebuild.
+ *
+ * It exists so the client bootstrap is two plain `fetch`es and no Firebase
+ * SDK: pulling in the client SDK to read one small document would cost more
+ * bytes than the index it is pointing at.
+ */
+export declare const SEARCH_MANIFEST_OBJECT = "search-index/manifest.json";
+export declare function searchIndexObjectPath(version: number): string;
+/** Public download URL for any object in the app's Storage bucket. */
+export declare function firebaseDownloadUrl(bucket: string, objectPath: string): string;
+export declare function searchManifestUrl(bucket: string): string;
+export declare function searchArtifactUrl(bucket: string, version: number): string;
+/**
+ * What the client needs out of the manifest, and nothing more.
+ *
+ * Deliberately NOT the server's `SearchIndexManifest`: that one carries
+ * `dirty`, `lastFullAt` and `perType`, which are build bookkeeping. A client
+ * type that structurally accepts them would invite someone to render build
+ * state in the UI, and then the mirror could never drop a field.
+ */
+export interface SearchIndexManifestPublic {
+    readonly schema: number;
+    readonly version: number;
+    readonly builtAt: string;
+    readonly recordCount: number;
+}