@mohasinac/appkit 4.58.0 → 4.60.0

package/dist/features/price-index/market-stats.js

@@ -0,0 +1,230 @@
+/*
+ * WHY: The price tool showed a MEDIAN of a competitor crawl, taken once, at
+ *      GENERATION level — so Dragoon MS and Strata Dragoon MS reported the
+ *      same ₹3,999 (they are different beys), Dragoon G reported nothing at
+ *      all (Engine Gear was never crawled), and a figure measured in October
+ *      would still read as current a year later. The owner's ask was precise:
+ *      the headline should be the price most sightings actually cluster on,
+ *      the low and high should describe the LAST SIX MONTHS, and anything
+ *      older should be used only when there is nothing recent.
+ * WHAT: The pure statistics behind that — mode over price buckets, a recency
+ *       window with an explicit historic fallback, and the provenance flags a
+ *       renderer needs to avoid overclaiming.
+ *
+ * EXPORTS:
+ *   RECENT_WINDOW_DAYS      — the six-month window, as days
+ *   MIN_BAND_OBSERVATIONS   — below this there is no band at all
+ *   MIN_MODE_OBSERVATIONS   — below this there is no mode, only a median
+ *   PriceObservationSample  — the minimum a sighting must carry
+ *   MarketStats             — one computed band
+ *   priceBucketWidth        — the bucket a price falls in, by magnitude
+ *   computeMarketStats      — samples -> a band, or null
+ *
+ * ## 🛑 Why MODE, and why it is bucketed
+ *
+ * A median answers "what is the middle of this list" and a mode answers "what
+ * do people actually charge", and for a collectible those differ. Six sightings
+ * at ₹6,500 and three clearance ones at ₹3,000 have a median of ₹6,500 only by
+ * luck of the ordering; add two more cheap ones and the median drops to ₹3,000
+ * while the going rate has not moved at all. The mode does not do that.
+ *
+ * 🛑 But an EXACT-VALUE mode is a trap on this data. Retail listings cluster on
+ * round price points (₹999, ₹1,399, ₹2,999) where exact mode works perfectly —
+ * and private resale does not (₹6,400, ₹6,500, ₹6,600 are one market and three
+ * distinct values). An exact mode would report "no mode" for precisely the
+ * second-hand market this tool exists to describe. So values are bucketed by
+ * magnitude first.
+ *
+ * 🛑 The reported figure is the MEDIAN OF THE WINNING BUCKET, never the bucket
+ * edge. A bucket boundary is an artefact of our arithmetic; quoting ₹6,500 when
+ * the bucket is 6,250–6,750 and the sightings were 6,400/6,500/6,600 reports a
+ * price somebody actually asked. Quoting the edge would invent one.
+ *
+ * ## 🛑 Recency is a MEASUREMENT, not a label
+ *
+ * `basedOnRecent` is false whenever the six-month window could not carry the
+ * band on its own, and the renderer must say "all time" in that case. Printing
+ * "last 6 months" over figures drawn from a three-year-old crawl is the exact
+ * dishonesty this module was written to remove — and it is invisible, because a
+ * stale number looks identical to a current one.
+ *
+ * ## 🛑 Why this is in `features/`, not `_internal/shared/`
+ *
+ * It needs THREE consumers — the scheduled rollup, the `price-observations`
+ * CLI, and anything that later wants to restate a band — and `_internal/` is
+ * not reachable from a standalone script through the package's export map. A
+ * CLI that could not import it would have to re-derive "the mode, bucketed,
+ * with a six-month window", which is Root Cause #75's exact shape: a rule
+ * reachable only by copy-paste gets copied, and the copy never learns about the
+ * branch added later. `lookup-target.ts` sits here for the same reason — pure,
+ * shared, no React, no Firestore.
+ *
+ * @tag domain:price-index
+ * @tag layer:feature
+ * @tag pattern:pure-function
+ * @tag access:isomorphic
+ * @tag consumers:marketPriceRollup,price-observations CLI,PriceIndexToolView
+ * @tag sideEffects:none
+ */
+/**
+ * Six months, the window the owner specified for "recent".
+ *
+ * 182 rather than 180: it is half of 365, so a year's data splits into exactly
+ * two windows and "the last six months" cannot quietly mean a different span
+ * depending on which months they were.
+ */
+export const RECENT_WINDOW_DAYS = 182;
+/**
+ * Below this, NO band is published for a leaf.
+ *
+ * Three, matching `PRICE_INDEX_MIN_CONFIDENT_SAMPLES` on the sold half — the
+ * two halves of this page must not disagree about what counts as evidence, and
+ * the sold half's reasoning ("a median of two sales is a coin flip presented as
+ * data") is about sample size, not about which side of the page it is on.
+ */
+export const MIN_BAND_OBSERVATIONS = 3;
+/**
+ * Below this, the band publishes a MEDIAN and no mode.
+ *
+ * A "most common price" derived from a bucket containing one sighting is not a
+ * most-common anything — it is that one sighting, relabelled. Two is the
+ * smallest number for which the word means what it says.
+ */
+export const MIN_MODE_OBSERVATIONS = 2;
+/**
+ * Bucket width by magnitude.
+ *
+ * Proportional rather than fixed, because a ₹50 bucket is three separate
+ * buckets across ₹99–₹249 part pricing and a rounding error on a ₹9,999 grail.
+ * The widths are ~2–5% of the value throughout, so "the same price" means the
+ * same thing at every price point.
+ */
+export function priceBucketWidth(amount) {
+    if (amount < 500)
+        return 25;
+    if (amount < 1000)
+        return 50;
+    if (amount < 5000)
+        return 100;
+    if (amount < 20000)
+        return 250;
+    return 1000;
+}
+/** The inclusive-lower bucket key a price falls in. */
+function bucketOf(amount) {
+    const width = priceBucketWidth(amount);
+    return Math.floor(amount / width) * width;
+}
+function medianOf(sorted) {
+    const n = sorted.length;
+    if (n === 0)
+        return 0;
+    const mid = n >> 1;
+    // Even n averages the two middles, which can land between two real prices.
+    // That is correct for a median and is why it is never the headline figure.
+    return n % 2 === 1 ? sorted[mid] : ((sorted[mid - 1] + sorted[mid]) / 2);
+}
+/** Whole rupees. Every price in this system is a decimal rupee amount. */
+function round(n) {
+    return Math.round(n);
+}
+/**
+ * The band for one leaf, or `null` when there is not enough to say anything.
+ *
+ * 🛑 `null`, never a zeroed band. A band of ₹0 renders as a real figure meaning
+ * "this sells for nothing", which is strictly worse than silence — the same
+ * rule `CategoryPriceGuidance.sold` is held to ("absent until there are some —
+ * never zeroed").
+ *
+ * The recency decision happens ONCE here and is reported in `basedOnRecent`, so
+ * the job, the CLI and the renderer cannot each arrive at a different answer
+ * about which window a figure came from.
+ */
+export function computeMarketStats(samples, now = new Date()) {
+    const usable = samples.filter((s) => Number.isFinite(s.amount) && s.amount > 0 && s.seenAt instanceof Date && !Number.isNaN(s.seenAt.getTime()));
+    if (usable.length < MIN_BAND_OBSERVATIONS)
+        return null;
+    const cutoff = now.getTime() - RECENT_WINDOW_DAYS * 86400000;
+    const recent = usable.filter((s) => s.seenAt.getTime() >= cutoff);
+    /*
+     * 🛑 The whole fallback, in one decision. The six-month window is used when
+     * it can carry a band ALONE; otherwise the full history is, and the caller is
+     * told. A blend of the two would be neither — and would be undetectable,
+     * since the result is a number either way.
+     */
+    const basedOnRecent = recent.length >= MIN_BAND_OBSERVATIONS;
+    const set = basedOnRecent ? recent : usable;
+    const amounts = set.map((s) => s.amount).sort((a, b) => a - b);
+    const lastSeenAt = set.reduce((max, s) => (s.seenAt.getTime() > max.getTime() ? s.seenAt : max), set[0].seenAt);
+    /*
+     * Buckets, with their members kept — the reported mode is the median of the
+     * winning bucket's real prices, so the members cannot be discarded for a
+     * count alone.
+     */
+    const buckets = new Map();
+    for (const amount of amounts) {
+        const key = bucketOf(amount);
+        const existing = buckets.get(key);
+        if (existing)
+            existing.push(amount);
+        else
+            buckets.set(key, [amount]);
+    }
+    let bestMembers;
+    for (const members of buckets.values()) {
+        if (members.length < MIN_MODE_OBSERVATIONS)
+            continue;
+        if (!bestMembers || members.length > bestMembers.length) {
+            bestMembers = members;
+            continue;
+        }
+        /*
+         * 🛑 A tie breaks toward the DEARER bucket, deliberately. The two failure
+         * directions are not symmetric: a seller shown too low a figure leaves
+         * money on the table on a sale that still happens, while a buyer shown too
+         * low a figure arrives at the listing expecting a price that does not
+         * exist. Breaking toward the cheaper bucket optimises for the second.
+         */
+        if (members.length === bestMembers.length && members[0] > bestMembers[0]) {
+            bestMembers = members;
+        }
+    }
+    const median = round(medianOf(amounts));
+    return {
+        ...(bestMembers
+            ? {
+                // The median of the winning bucket's members — a price somebody
+                // actually asked, not the arithmetic edge of our own bucket.
+                mode: round(medianOf(bestMembers)),
+                modeCount: bestMembers.length,
+            }
+            : {}),
+        median,
+        low: round(amounts[0]),
+        high: round(amounts[amounts.length - 1]),
+        sampleSize: set.length,
+        basedOnRecent,
+        windowDays: basedOnRecent ? RECENT_WINDOW_DAYS : spanDays(set),
+        lastSeenAt,
+    };
+}
+/**
+ * The real span of a sample set, for the historic-fallback case.
+ *
+ * Reported rather than left as `RECENT_WINDOW_DAYS`, because "all time" has to
+ * mean a measurable number of days for the renderer to say anything honest
+ * about it — "over the 14 months we have data for" is a statement; "all time"
+ * alone is not.
+ */
+function spanDays(set) {
+    let min = set[0].seenAt.getTime();
+    let max = min;
+    for (const s of set) {
+        const t = s.seenAt.getTime();
+        if (t < min)
+            min = t;
+        if (t > max)
+            max = t;
+    }
+    return Math.max(1, Math.round((max - min) / 86400000));
+}

package/dist/features/print/components/BoxLabelPrintView.d.ts

@@ -0,0 +1,25 @@
+import { type BoxContentsRow } from "./labels";
+export interface PrintableBox {
+    id: string;
+    code: string;
+    boxType: string;
+    location?: string | null;
+    distinctProducts?: number | null;
+    totalUnits?: number | null;
+    countedAt?: string | null;
+    /** Present only when the caller loaded placements for this box. */
+    contents?: BoxContentsRow[];
+}
+export interface BoxLabelPrintViewProps {
+    boxes: PrintableBox[];
+    /**
+     * 🛑 Passed in rather than read from `Date.now()` here. A render-time clock
+     * makes the printed date differ between the server render and the client
+     * hydration, which React reports as a hydration mismatch — and more
+     * practically it means the date on the paper is "whenever this component
+     * last rendered", which is not a fact about anything.
+     */
+    printedAt: string;
+    boxesFailed?: boolean;
+}
+export declare function BoxLabelPrintView({ boxes, printedAt, boxesFailed, }: BoxLabelPrintViewProps): import("react").JSX.Element;

package/dist/features/print/components/BoxLabelPrintView.js

@@ -0,0 +1,66 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Prints box labels and box contents sheets.
+ *
+ * Two outputs with deliberately different shapes, because they answer
+ * different questions at different distances:
+ *
+ *   LABEL     stuck to the box. `BOX-AC60-03` as a scannable symbol, the code
+ *             large enough to read across a room, and a total with a date.
+ *   CONTENTS  A4, goes inside the box or on the shelf beside it. Lists every
+ *             product. A 50 x 25 mm label cannot hold eight product names, so
+ *             the label carries a total and this carries the detail.
+ *
+ * 🛑 BOTH ARE DATED SNAPSHOTS, AND BOTH SAY SO. A printed count is wrong the
+ * moment something is picked. Printing "8 items" bare invites the operator to
+ * trust it over the screen; printing "8 items as of 21 Oct" says what it is.
+ */
+import { useMemo, useState } from "react";
+import { Alert, Button, Div, Heading, Row, Stack, Text, } from "../../../ui/index.js";
+import { FieldCheckbox } from "../../../ui/forms/FieldCheckbox.js";
+import { BoxContentsSheet, BoxLabel, LabelPageStyle, LabelSheet, PrintScaleWarning, } from "./labels.js";
+import { LabelProfilePicker } from "./LabelProfilePicker.js";
+import { LABEL_PROFILES, documentPageCss, labelPageCss, } from "../../../_internal/shared/features/print/label-profiles.js";
+export function BoxLabelPrintView({ boxes, printedAt, boxesFailed = false, }) {
+    const [mode, setMode] = useState("labels");
+    /*
+     * 100 x 50 mm by default, not the 50 x 25 used for products. A box label is
+     * read from across a room and carries a code, a type, a location and a
+     * count — four lines plus a symbol does not fit on a product label, and the
+     * fit check would (correctly) refuse the barcode on 38 mm stock.
+     */
+    const [profileId, setProfileId] = useState("thermal-100x50");
+    const profile = LABEL_PROFILES[profileId];
+    const [selected, setSelected] = useState(new Set());
+    const chosen = useMemo(() => boxes.filter((b) => selected.has(b.id)), [boxes, selected]);
+    const toggle = (id) => setSelected((prev) => {
+        const next = new Set(prev);
+        if (next.has(id))
+            next.delete(id);
+        else
+            next.add(id);
+        return next;
+    });
+    /*
+     * `BOX-` + the code. The longest one in the selection drives the fit report,
+     * so the warning is about the worst label in the batch rather than the first.
+     */
+    const longestCodeLength = useMemo(() => chosen.reduce((n, b) => Math.max(n, b.code.length + 4), 0), [chosen]);
+    return (_jsxs(Stack, { gap: "md", padding: "md", children: [_jsx(LabelPageStyle, { css: mode === "labels" ? labelPageCss(profile) : documentPageCss() }), _jsxs(Stack, { className: "no-print", gap: "sm", children: [_jsx(Heading, { level: 1, size: "2xl", children: "Print box labels" }), boxesFailed && (_jsx(Alert, { variant: "warning", children: "Could not load the box list. It is unknown, not empty \u2014 reload before printing, or you will print a subset without knowing it." })), _jsxs(Row, { gap: "xs", children: [_jsx(Button, { variant: mode === "labels" ? "primary" : "secondary", size: "sm", onClick: () => setMode("labels"), children: "Box labels" }), _jsx(Button, { variant: mode === "contents" ? "primary" : "secondary", size: "sm", onClick: () => setMode("contents"), children: "Contents sheets (A4)" })] }), mode === "labels" && (_jsxs(_Fragment, { children: [_jsx(LabelProfilePicker, { value: profileId, onChange: setProfileId, longestCodeLength: longestCodeLength }), _jsx(PrintScaleWarning, {})] })), boxes.length === 0 ? (_jsx(Text, { color: "muted", children: "No boxes registered yet. A box exists here because someone labelled a real one, so an empty list on a fresh install is correct." })) : (_jsx(Stack, { gap: "xs", children: boxes.map((b) => (_jsx(FieldCheckbox, { name: `box-${b.id}`, label: `${b.code}${b.location ? ` — ${b.location}` : ""}`, checked: selected.has(b.id), onChange: () => toggle(b.id) }, b.id))) })), _jsxs(Row, { gap: "sm", align: "center", wrap: true, children: [_jsxs(Button, { disabled: chosen.length === 0, onClick: () => window.print(), children: ["Print ", chosen.length > 0 ? `${chosen.length} selected` : "selected"] }), boxes.length > 0 && (_jsx(Button, { variant: "ghost", onClick: () => setSelected(selected.size === boxes.length
+                                    ? new Set()
+                                    : new Set(boxes.map((b) => b.id))), children: selected.size === boxes.length ? "Clear all" : "Select all" }))] }), mode === "contents" && chosen.some((b) => !b.contents) && (
+                    /*
+                     * 🛑 Says WHICH sheets will be blank rather than printing a blank
+                     * one. A contents sheet for a box whose placements were never loaded
+                     * prints "This box is empty" — about a box that may hold eight
+                     * things. That is the worst claim this feature can make, and it is
+                     * indistinguishable from a genuinely empty box on paper.
+                     */
+                    _jsxs(Alert, { variant: "warning", children: ["Contents were not loaded for", " ", chosen
+                                .filter((b) => !b.contents)
+                                .map((b) => b.code)
+                                .join(", "), ". Those sheets would print as empty, which is not the same as the box being empty \u2014 open each box's page to load its contents first."] }))] }), mode === "labels" ? (_jsx(LabelSheet, { profile: profile, children: chosen.map((b) => (_jsx(BoxLabel, { profile: profile, box: b }, b.id))) })) : (_jsx(Div, { children: chosen
+                    .filter((b) => b.contents)
+                    .map((b) => (_jsx(BoxContentsSheet, { boxCode: b.code, boxType: b.boxType, location: b.location, rows: b.contents ?? [], printedAt: printedAt }, b.id))) }))] }));
+}

package/dist/features/print/components/LabelProfilePicker.d.ts

@@ -0,0 +1,13 @@
+import { type LabelProfileId } from "../../../_internal/shared/features/print/label-profiles";
+export interface LabelProfilePickerProps {
+    value: LabelProfileId;
+    onChange: (id: LabelProfileId) => void;
+    /**
+     * The LONGEST code in the job. Checking the longest is the only check worth
+     * making: a report based on the average or the first row says "fits" about a
+     * batch in which some labels do not.
+     */
+    longestCodeLength?: number;
+    label?: string;
+}
+export declare function LabelProfilePicker({ value, onChange, longestCodeLength, label, }: LabelProfilePickerProps): import("react").JSX.Element;

package/dist/features/print/components/LabelProfilePicker.js

@@ -0,0 +1,38 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Picks the label stock, and says what that choice costs.
+ *
+ * 🛑 THE FIT REPORT IS SHOWN BESIDE THE PICKER, NOT AFTER PRINTING. The whole
+ * reason `labelFitsProfile` reports rather than scales is that a squeezed
+ * barcode looks perfect and does not scan, surfacing weeks later as "the
+ * scanner is broken" with every label already stuck to something. That
+ * guarantee is worth nothing if the report arrives after the stock is in the
+ * printer — so the picker tells the operator, in the moment they choose, what
+ * the longest code they are about to print will do on it.
+ *
+ * 🛑 `FieldSelect` WITH SIX OPTIONS, AGAINST RULE #9's ">5 USES
+ * PaginatedSelect" LINE — flagged rather than done quietly.
+ *
+ * That rule's own stated reason is that a long list cannot be scanned, and its
+ * mechanism is an async searchable drawer. This list is six physical stocks,
+ * closed and bounded by what the warehouse buys, with no server behind it; a
+ * search box over six static strings and a "Load more" is more chrome than
+ * choice. No audit enforces the threshold, so this is a judgement call and not
+ * a build failure — one line to reverse if the call is wrong.
+ */
+import { Alert, Row, Stack, Text } from "../../../ui/index.js";
+import { FieldSelect } from "../../../ui/forms/index.js";
+import { LABEL_PROFILES, LABEL_PROFILE_IDS, MIN_SCANNABLE_MODULE_MM, labelFitsProfile, } from "../../../_internal/shared/features/print/label-profiles.js";
+export function LabelProfilePicker({ value, onChange, longestCodeLength, label = "Label stock", }) {
+    const profile = LABEL_PROFILES[value];
+    const fit = longestCodeLength && longestCodeLength > 0
+        ? labelFitsProfile(profile, longestCodeLength)
+        : null;
+    return (_jsxs(Stack, { gap: "xs", className: "no-print", children: [_jsxs(Row, { gap: "sm", align: "end", wrap: true, children: [_jsx(FieldSelect, { name: "labelProfile", label: label, value: value, onChange: (v) => onChange(v), options: LABEL_PROFILE_IDS.map((id) => ({
+                            value: id,
+                            label: LABEL_PROFILES[id].label,
+                        })) }), _jsxs(Text, { size: "sm", color: "muted", children: [profile.widthMm, " \u00D7 ", profile.heightMm, " mm", profile.sheet
+                                ? ` · ${profile.sheet.columns * profile.sheet.rows} per A4 sheet`
+                                : " · one per page (roll)"] })] }), fit && !fit.fits && fit.impliedModuleMm < MIN_SCANNABLE_MODULE_MM && (_jsx(Alert, { variant: "error", children: fit.reason })), fit && !fit.fits && fit.impliedModuleMm >= MIN_SCANNABLE_MODULE_MM && (_jsx(Alert, { variant: "warning", children: fit.reason })), fit && fit.fits && (_jsx(Text, { size: "xs", color: "success", children: fit.reason }))] }));
+}

package/dist/features/print/components/labels.d.ts

@@ -0,0 +1,117 @@
+import { type LabelProfile } from "../../../_internal/shared/features/print/label-profiles";
+/** Millimetres of paper to CSS pixels. The only unit bridge in this file. */
+export declare function mmToCssPx(mm: number): number;
+/**
+ * A target module width in mm, as JsBarcode's `width` option.
+ *
+ * Not rounded to an integer: JsBarcode accepts a fractional module width and
+ * rounding to 1 px would quantise every density to 0.265 mm steps — which on a
+ * 50 x 25 mm label is the difference between fitting and not.
+ */
+export declare function moduleWidthPx(moduleMm?: number): number;
+/**
+ * The single `@page` owner for a printable view.
+ *
+ * 🛑 EXACTLY ONE OF THESE PER VIEW. `@page` is document-global and cannot be
+ * scoped — two of them does not give two geometries, the later one in document
+ * order silently wins and the label prints at the wrong size with nothing in
+ * the markup looking wrong. `audit-label-profiles` R3 enforces that only
+ * `label-profiles.ts` may author the rule at all.
+ */
+export declare function LabelPageStyle({ css }: {
+    css: string;
+}): import("react").JSX.Element;
+export interface ProductLabelData {
+    barcodeId?: string | null;
+    sku?: string | null;
+    name: string;
+    price?: number | null;
+    /** 🛑 Which box it lives in — see the component note. */
+    boxCode?: string | null;
+}
+/**
+ * A product label: symbol, name, price, and WHERE IT LIVES.
+ *
+ * 🛑 THE BOX CODE IS THE ADDITION THAT MAKES THE LABEL USEFUL FOR PUTTING
+ * THINGS AWAY. Without it a picker holding the item has to scan it and look at
+ * a screen to learn which shelf it came off; with it the label answers the
+ * question the person holding it is actually asking. It replaces the free-text
+ * `physicalLocation` that used to print here — that field was three
+ * inconsistent inputs with no registry behind it, so two people wrote "shelf
+ * 3", "Shelf-3" and "AC60 3" for one place and no list could group them.
+ */
+export declare function ProductLabel({ profile, product, }: {
+    profile: LabelProfile;
+    product: ProductLabelData;
+}): import("react").JSX.Element;
+export interface BoxLabelData {
+    code: string;
+    boxType: string;
+    location?: string | null;
+    distinctProducts?: number | null;
+    totalUnits?: number | null;
+    /** When the rollup was computed — see the staleness note. */
+    countedAt?: string | null;
+}
+/**
+ * A box label: the code, large, plus what it held WHEN PRINTED.
+ *
+ * 🛑 THE PRINT DATE IS NOT DECORATION — it is what makes the counts honest. A
+ * label is a frozen snapshot stuck to a moving object: the moment something is
+ * picked, the printed count is wrong. Printing "8 items" with no date invites
+ * the operator to trust it; printing "8 items as of 21 Oct" says plainly that
+ * it is a note from the past and the screen is authoritative.
+ *
+ * 🛑 The barcode encodes `BOX-{code}`, with the prefix, because the receive
+ * station discriminates on it: a `BOX-` scan arms a box and a `LIR-` scan adds
+ * an item, and that decision has to be makeable without a lookup. The stored
+ * `code` is the bare `AC60-03`.
+ */
+export declare function BoxLabel({ profile, box, }: {
+    profile: LabelProfile;
+    box: BoxLabelData;
+}): import("react").JSX.Element;
+/**
+ * Lays labels out on an A4 die-cut sheet, at the stock's real pitch.
+ *
+ * 🛑 ABSOLUTE POSITIONING FROM THE PITCH, not a flex grid. A grid distributes
+ * whatever space it is given; a die-cut sheet has fixed holes, and the only
+ * thing that lands ink inside them is placing each label at
+ * `margin + n x pitch`. One millimetre of accumulated flex rounding is
+ * invisible on label one and off the die-cut by label thirteen.
+ */
+export declare function LabelSheet({ profile, children, }: {
+    profile: LabelProfile;
+    children: React.ReactNode[];
+}): import("react").JSX.Element;
+export interface BoxContentsRow {
+    productTitle: string;
+    productSku?: string | null;
+    quantity: number;
+    slot?: string | null;
+}
+/**
+ * An A4 sheet listing what is in a box — the thing that goes INSIDE it, or on
+ * the shelf beside it.
+ *
+ * 🛑 A4, not a label, and that is the point of having it at all. A 50 x 25 mm
+ * label cannot list eight products, so the box label carries only a total; the
+ * contents have to live somewhere a person can read them without a screen, and
+ * that is a sheet of paper. It is explicitly a snapshot, dated in the header
+ * for the same reason the box label's counts are.
+ */
+export declare function BoxContentsSheet({ boxCode, boxType, location, rows, printedAt, }: {
+    boxCode: string;
+    boxType: string;
+    location?: string | null;
+    rows: BoxContentsRow[];
+    printedAt: string;
+}): import("react").JSX.Element;
+/**
+ * The on-screen warning that no code can replace.
+ *
+ * Every density calculation in this file assumes the browser prints at 100%.
+ * "Fit to page" rescales the symbol and takes the module width with it, and
+ * the result still looks like a correct label.
+ */
+export declare function PrintScaleWarning(): import("react").JSX.Element;