@bicharts/chart-host 0.6.83 → 0.6.85

package/dist/types/legendFit/legendReconcile.d.ts

@@ -0,0 +1,295 @@
+/**
+ * D3 legend / plot reconciliation — pure geometry.
+ *
+ * The measured sibling of the label-contrast pass. A generated D3 chart
+ * can draw its legend ON TOP of plot content, or with its text running off the
+ * right edge, because legend WIDTH is data-dependent — the generator can't reserve
+ * the right gutter at author time without measuring rendered text, which only
+ * exists after render. So we measure post-render and fix it.
+ *
+ * Coordinates: EVERYTHING here is in the SVG's USER space (== viewBox units).
+ * The caller maps the measured client-px bounding boxes into user space via
+ * svg.getScreenCTM().inverse() before calling — that one matrix captures the
+ * viewBox, preserveAspectRatio and any container scaling/letterboxing exactly,
+ * so this module needs no px↔unit scale factor.
+ *
+ * The fix is TWO independent quantities (the bug in v1 was conflating them):
+ *   - SLIDE (legendDx): move the legend right just enough that its LEFT edge
+ *     clears the rightmost plot content it overlaps, + pad.
+ *   - EXTEND (ext): widen the viewBox just enough that the slid legend's RIGHT
+ *     edge sits inside it, + pad. Widening the viewBox makes the SVG scale to
+ *     fit its container, so nothing is clipped and the plot isn't reflowed.
+ * The first version set EXTEND = SLIDE, which left the legend's right edge exactly
+ * as clipped as before and made the gutter overlap-sized rather than need-sized
+ * (a Sankey's legend text stayed cut off at the viewport edge, with more gutter
+ * than necessary).
+ *
+ * DOM-free: the caller gathers user-space boxes + the viewBox and applies the
+ * plan (set newViewBox, translate the legend group by legendDx). Tests feed
+ * plain numbers and assert the plan.
+ */
+export interface Rect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface ViewBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export type ReconcileSide = "right" | "bottom";
+export interface ReconcilePlan {
+    action: "none" | "reserve";
+    legendDx: number;
+    legendDy: number;
+    ext: number;
+    newViewBox: ViewBox;
+    reason: string;
+}
+export declare const MIN_OVERLAP = 2;
+export declare const MAX_GUTTER_FRACTION = 0.6;
+export interface ReconcileOptions {
+    /** Ignore overlaps at or below this many user units (default MIN_OVERLAP). */
+    minOverlap?: number;
+    /** Defer if the viewBox extension would exceed this fraction of its width
+     *  (default MAX_GUTTER_FRACTION). */
+    maxGutterFraction?: number;
+    /** Gap (user units) left between the legend's LEFT and the plot (default 8). */
+    pad?: number;
+    /** Gap (user units) left between the legend's RIGHT and the viewBox edge
+     *  (default 4). Smaller than `pad` so the legend hugs the right edge — this
+     *  is the lever for "too much gutter to the right of the legend". */
+    edgePad?: number;
+}
+/**
+ * The rightmost right-edge among plot elements that vertically overlap the
+ * legend and do NOT horizontally span it. Per-element (not a union) so a title
+ * or axis label that isn't actually beside the legend doesn't count, and a
+ * full-width plot background (which spans the legend) is ignored — that's not a
+ * collision a right gutter fixes. Returns -Infinity when nothing sits beside it.
+ */
+export declare function rightmostOverlappingPlotEdge(legendBox: Rect, plotRects: Rect[]): number;
+/**
+ * The bottom-most bottom-edge among plot elements whose box INTERSECTS the legend
+ * (horizontal AND vertical overlap) without fully spanning it. The 90°-rotated
+ * analogue of rightmostOverlappingPlotEdge — for a horizontal bottom
+ * legend/colorbar overprinted by the x-axis ticks/title. Box-intersection (not a
+ * "starts above" test) so a colorbar whose own TITLE sits above its gradient —
+ * making the union box taller than the colliders — still detects the x-axis
+ * labels that overlap the gradient. Content that clears the legend entirely
+ * (a cell row above, a footer below) doesn't intersect and is ignored. Returns
+ * -Infinity when nothing intersects.
+ */
+export declare function bottommostOverlappingPlotEdge(legendBox: Rect, plotRects: Rect[]): number;
+/**
+ * Decide whether/how to reconcile an overlapping/clipped D3 legend.
+ *
+ * @param legendBox  legend group bbox in USER space
+ * @param plotRects  per-element plot-content bboxes (marks + non-legend text) in USER space
+ * @param viewBox    the SVG's current viewBox
+ * @param opts       strictness thresholds (mode-dependent)
+ */
+export declare function planLegendReconcile(legendBox: Rect | null, plotRects: Rect[] | null, viewBox: ViewBox | null, opts?: ReconcileOptions, side?: ReconcileSide): ReconcilePlan;
+/**
+ * WHICH MARGIN A STRUCTURALLY-FOUND COLORBAR BELONGS IN.
+ *
+ * The colorbar pass was first written for ONE case — a horizontal bar in the bottom margin
+ * overprinting the x-axis — so it asked `planLegendReconcile` for side "bottom" and nothing
+ * else. A VERTICAL colorbar inset into the plot was therefore detected, measured, refused
+ * ("not-horizontal-legend") and shipped covering the marks. A treemap with `margin.right = 4`,
+ * a colorbar at `plotW - barW - 52` and a `rgba(255,255,255,0.88)` plate under it is that case
+ * exactly — the generated code's own comment reads *"Background plate so legend is readable
+ * over treemap tiles"*, so the occlusion was deliberate, and two cells and their labels went
+ * behind it.
+ *
+ * The right-side remedy already existed for a legend that carries `.d3-legend-mark`; a colorbar
+ * carries no contract class, which is the only reason it was out of reach. So this picks the
+ * side from the bar's own geometry and the rest of the machinery is unchanged.
+ *
+ * THE TESTS HERE MIRROR THE PLANNER'S OWN GATES, deliberately — a strip wider than 2× its
+ * height can only go down, anything else can only go right, and each must already be anchored
+ * in the margin it is being pushed into. Returning null where the planner would refuse keeps
+ * the two from disagreeing: a caller that guesses gets a "not-…" reason instead of a move, and
+ * a decorative gradient panel in the middle of the canvas is nobody's furniture.
+ */
+/**
+ * IS THE COLORBAR DRAWN ON TOP OF THE CHART? Measured against the GRADIENT BAR itself,
+ * not the group box - and by plain intersection, not by the edge test the right slide uses.
+ *
+ * BOTH of those choices were forced by a corpus of rendered charts, and each was wrong the
+ * first time:
+ *
+ *  - THE GROUP BOX IS AMBIGUOUS. It also holds the ticks, the title and a backing plate, so
+ *    "marks reach past the group's left edge" reads the same for a colorbar sitting on the
+ *    plot and for one parked correctly in the gutter with a label hanging left of its bar.
+ *    Over 401 rendered charts that ambiguity was the whole problem: gating on the group box
+ *    moved 89 charts, only 37 of which had a mark near the bar at all. The BAR's own box has
+ *    no such ambiguity - a mark under it means the colorbar was drawn over the chart, full
+ *    stop. That reading finds 15.
+ *  - `rightmostOverlappingPlotEdge` SKIPS A MARK THAT SPANS THE BOX, which is right for a
+ *    full-width backdrop and exactly wrong here: a treemap tile drawn behind the colorbar
+ *    spans it, and that is the case where the occlusion is TOTAL. It answered "nothing
+ *    overlaps" on a bar sitting entirely on a tile.
+ *
+ * A MAJORITY, because a colorbar beside the marks still gets its edge touched. The measured
+ * spread of `cover` over the 15 is
+ * 1.00 1.00 1.00 0.97 | 0.57 0.49 0.41 | 0.25 0.25 0.13 0.06 0.05 0.03 0.01 0.01
+ * - the top four are bars drawn wholly on a mark, and the tail from 0.25 down is the last
+ * bar of a chart grazing a bar parked in the gutter, which is the content-fit pass's business
+ * and not a reason to re-lay-out a cached chart. 0.5 is the default, not a discovery: it is
+ * the one number here that a reader should feel free to move.
+ */
+export declare const COLORBAR_ON_PLOT_COVER = 0.5;
+/**
+ * WHERE TO ASK "IS ANYTHING PAINTED HERE?" - an evenly spaced grid strictly inside the
+ * bar, inset half a cell so no probe lands on its own edge.
+ *
+ * A BOX IS NOT INK, and this pass learned it the expensive way. Gating on box
+ * intersection alone fired on a density-contour plot whose OUTERMOST contour
+ * is a thin diagonal band from the top-left to the bottom-right: its bounding box is
+ * 705x664 of a 776x779 canvas and therefore covers the colorbar completely, while its
+ * ink comes nowhere near it. A box-only test shipped at 50% precision on the corpus.
+ * The remedy is the browser's own answer - isPointInFill / isPointInStroke at these
+ * points.
+ */
+export declare function colorbarProbePoints(bar: Rect | null, cols?: number, rows?: number): {
+    x: number;
+    y: number;
+}[];
+/** A majority of the bar's own area has a mark painted under it. */
+export declare function colorbarOnPlot(inkHits: number, probes: number, minCover?: number): boolean;
+export declare function colorbarSitsOnMarks(bar: Rect | null, marks: Rect[] | null, minCover?: number): boolean;
+export declare function colorbarReconcileSide(bar: Rect | null, viewBox: ViewBox | null): ReconcileSide | null;
+/**
+ * CONTENT FIT — the universal "nothing gets cut off" pass (a Sankey used
+ * margin.left=20 with text-anchor:end node labels at x0-6, so left labels hung ~80
+ * units into NEGATIVE x and were clipped — while the legend mechanism, which only
+ * ever measures the legend column and extends the RIGHT edge, applied cleanly.
+ * Whack-a-mole by design: every targeted fix watches one edge).
+ *
+ * This is edge- and chart-agnostic: take the union bbox of ALL rendered
+ * content and EXTEND the viewBox on whichever sides content hangs past, + pad.
+ * Extend-only — never shrink (intentional margins/whitespace are not ours to
+ * reclaim). Runs after any legend slide (it re-measures, so it covers the slid
+ * legend's final position too) and also when there is NO legend at all.
+ *
+ * Outlier defense: a generation may park junk far off-canvas (work elements at
+ * x=-9999). A rect is considered only if it intersects the viewBox expanded by
+ * maxFitFraction per side; the final extension is also clamped to that
+ * fraction. A real hanging label sits just past the edge and is unaffected;
+ * parked junk is ignored rather than blowing the canvas up.
+ */
+export interface ContentFitPlan {
+    action: "none" | "fit";
+    newViewBox: ViewBox;
+    reason: string;
+    /** user units added per side (0 when that side didn't move) */
+    cut: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+}
+export declare const MAX_FIT_FRACTION = 0.35;
+export declare const FIT_PAD = 4;
+export declare const LEGIBILITY_GRACE_PX = 1;
+export interface ContentFitOptions {
+    /** Ignore per-side overhangs at or below this many user units (default MIN_OVERLAP). */
+    minOverhang?: number;
+    /** Per-side extension cap as a fraction of the viewBox dimension (default MAX_FIT_FRACTION). */
+    maxFitFraction?: number;
+    /** Padding (user units) between content and the new viewBox edge (default FIT_PAD). */
+    pad?: number;
+    /**
+     * The smallest text the chart currently paints, in SCREEN px — declared user units
+     * already multiplied by the live CTM scale, because that is the number a reader's eye
+     * meets. Omitted (or non-finite) disables the legibility test entirely, which is the
+     * honest degrade: a chart whose text could not be measured must keep today's behaviour
+     * rather than be refused on a guess.
+     */
+    smallestTextPx?: number;
+    /** The readable floor in px (default MIN_LEGIBLE_PX). */
+    minLegiblePx?: number;
+    /** How much of the smallest text the fit may spend (default LEGIBILITY_GRACE_PX). */
+    legibilityGracePx?: number;
+}
+export declare const MIN_LEGIBLE_PX = 10;
+export declare function planContentFit(contentRects: Rect[] | null, viewBox: ViewBox | null, opts?: ContentFitOptions): ContentFitPlan;
+export declare const BOTTOM_TEXT_MIN_TICK_HITS = 2;
+export declare function planBottomTextPush(candidate: Rect, tickBoxes: Rect[], gap?: number, transform?: string): {
+    move: boolean;
+    dy: number;
+};
+export declare const SWATCH_MAX_PX = 28;
+export declare const SWATCH_LABEL_GAP_PX = 30;
+export declare const SIGNATURE_MIN_PAIRS = 2;
+export interface SwatchPairs {
+    pairs: number;
+    sameSize: boolean;
+}
+export declare function swatchPairs(shapes: Rect[], texts: Rect[]): SwatchPairs;
+export declare function isLegendSignature(p: SwatchPairs): boolean;
+export declare const AXIS_THIN_MIN_TICKS = 4;
+export declare const AXIS_THIN_GAP = 2;
+export interface AxisThinPlan {
+    stride: number;
+    hide: number[];
+    reason: string;
+}
+/**
+ * Boxes are the tick labels of ONE axis, in any order (they are sorted here by
+ * left edge, and `hide` comes back indexed against the INPUT). Returns the
+ * smallest stride that clears every adjacent collision.
+ *
+ * Fail-open in both directions: too few ticks to be worth thinning, and an axis
+ * still colliding when only its two ends survive, both hide NOTHING. An ugly
+ * axis is recoverable by resizing the tile; an axis stripped to one label is not.
+ */
+export declare function planAxisTickThin(boxes: Rect[], gap?: number, minTicks?: number): AxisThinPlan;
+export declare const LABEL_ROW_MIN_TEXTS = 3;
+export declare const LABEL_ROW_Y_TOLERANCE = 2;
+/**
+ * A tick-like label: at least one digit, and nothing but digits and the furniture a number
+ * format adds - separators, sign, decimal point, currency, percent, a K/M/B suffix, a
+ * time colon. "Jan 2026" and "1 region unmatched" are not numeric; "$1.2M" and "-3.5%" are.
+ */
+export declare function isNumericLabelText(s: string): boolean;
+/**
+ * A date-like axis caption: a year (2026, FY2026, "Jan 2026"), a month or weekday name, a quarter,
+ * half or week ("Q3", "H1", "W12"), a slashed date ("1/15", "15.01.2026") or a clock time ("6 PM").
+ * Deliberately generous: a label read as ordered is thinned as before, so the cost of a wrong
+ * "date" is today's behaviour, never worse.
+ */
+export declare function isDateLikeLabelText(s: string): boolean;
+/** Ordered = a number (isNumericLabelText) or a date-like caption (isDateLikeLabelText). */
+export declare function isOrderedAxisLabelText(s: string): boolean;
+/** A NOMINAL axis: at least one non-empty label that is neither a number nor date-like. One name
+ *  among dates counts - that name has no neighbour to imply it. Empty labels say nothing. */
+export declare function axisLabelsAreNominal(labels: string[]): boolean;
+/**
+ * The room each label of a nominal axis may take, in input order: the step to its NARROWER
+ * neighbour less `gap`. `anchors` are the labels' anchor x positions (centre for middle, left
+ * edge for start, right edge for end - one anchor kind per axis), so the step is the band pitch
+ * whatever the labels' widths. Two labels each within that room cannot collide, whichever anchor
+ * they share. A lone anchor has no band and no limit.
+ */
+export declare function nominalLabelRooms(anchors: number[], gap?: number): number[];
+/**
+ * Group label boxes into horizontal ROWS - same vertical centre within `tol` px. Returns
+ * index lists into the input, each sorted by left edge; rows of one are dropped because a
+ * lone label has nothing to collide with.
+ */
+export declare function groupLabelRows(boxes: Rect[], tol?: number): number[][];
+export declare const LABEL_ROW_TRACK_COVER = 0.8;
+export declare const LABEL_ROW_TRACK_REACH = 3;
+/**
+ * Does a horizontal track run under (or over) this row of labels? `row` is the row's label
+ * boxes; `candidates` are the non-mark rect / line / path boxes of the row's own group. The
+ * candidates within reach are unioned - a five-swatch bar is five rects - and the union has
+ * to cover `cover` of the row's span. Pure, so the geometry is testable without a DOM.
+ */
+export declare function labelRowHasTrack(row: Rect[], candidates: Rect[], cover?: number, reach?: number): boolean;

package/dist/types/legendFit/legendReconcileDom.d.ts

@@ -0,0 +1,109 @@
+/**
+ * D3 legend reconcile — DOM adapter.
+ *
+ * The PURE geometry lives in legendReconcile.ts (unit-tested). This is the
+ * browser-side glue that the geometry can't be: find the legend group in a
+ * rendered SVG, measure it + the plot content in the SVG's USER space (via
+ * getScreenCTM, which captures viewBox + scaling exactly), run the plan, and
+ * apply it (widen the viewBox, slide the legend). It needs browser layout
+ * (getScreenCTM / DOMPoint), so its tests run on a jsdom layout stand-in — same
+ * split as the label-contrast pass's applier and its pure decision. Idempotent within
+ * a render via a data attribute; the caller wraps it in try/catch and owns logging.
+ */
+import { ReconcileOptions } from "./legendReconcile";
+export interface LegendReconcileResult {
+    applied: boolean;
+    reason: string;
+    dx?: number;
+    ext?: number;
+    newW?: number;
+    furniture?: number;
+    fit?: string;
+    cb?: string;
+    bt?: string;
+    fitDeclined?: string;
+    smallestTextPx?: number;
+    at?: string;
+    axisThin?: AxisThinReport;
+    lt?: string;
+    labelThin?: {
+        rows: number;
+        hidden: number;
+        stride: number;
+    };
+    dy?: number;
+    source?: "class" | "signature";
+}
+export declare function smallestRenderedTextPx(svg: SVGSVGElement, ctmScale: number): number | null;
+/**
+ * SELF-MANAGED SCROLL LAYOUT. A chart that renders its
+ * content as HTML inside a <foreignObject> with its OWN inner scroll body — a
+ * table-with-embedded scorecard (30 users × 32px rows scrolling inside a ~525px body) —
+ * manages its own frame. Its below-the-fold rows are SCROLLED, not clipped. The
+ * content-fit pass, which exists to rescue clipped SVG content, reads those off-canvas
+ * row <text>/marks as clipped and grows the viewBox (+239 on the bottom in that case);
+ * preserveAspectRatio then draws the taller viewBox to fit, letterboxing the chart into
+ * huge left/right gutters with everything shrunk (~72%) and the text illegibly small.
+ * NONE of the reconcile passes (legend slide / colorbar push / bottom-text / content-fit)
+ * apply to a self-scrolling HTML table, so skip the whole thing. Detected STRUCTURALLY (a
+ * <foreignObject> containing an element that scrolls its own content), never by chart-type
+ * name — any future self-managed layout is covered automatically.
+ */
+export declare function styleDeclaresScroll(inlineStyle: string | null | undefined, overflow?: string, overflowY?: string): boolean;
+/**
+ * AXIS TICK THINNING. A horizontal axis whose own tick labels overlap each
+ * other - eleven "Jan 2026" into a 312px plot, or "50K | 60K | 70K" along a
+ * numeric axis. The decision (which stride clears it) is planAxisTickThin; this
+ * is the DOM half: find each axis, establish it IS horizontal, measure the real
+ * text, and hide the labels the plan drops.
+ *
+ * MEASURED, NOT ESTIMATED, and that is the whole reason this lives client-side.
+ * The server exec-gate breadcrumb has to approximate text width as
+ * chars * fontSize * 0.6 because jsdom has no getComputedTextLength - good
+ * enough to triage on and not good enough to spend a regeneration on. Here the
+ * box is the browser's own.
+ *
+ * Hides the text only. The tick LINE and the gridline stay, so the reader keeps
+ * every position they align against and loses only a redundant caption.
+ * Conservative and fail-open throughout: fewer than four ticks, any rotated
+ * label (rotation is the generation's own answer to density and pairs badly
+ * with thinning), a vertical axis, or an axis still colliding when only its two
+ * ends survive all leave the axis exactly as it was drawn.
+ */
+/** What the axis pass did, for the caller's log line. cut / shrunk / nominal appear only when a
+ *  NOMINAL axis was fitted instead of thinned; colliding counts labels still touching a
+ *  neighbour after the cut kept their first character (a band too narrow for even that). */
+export interface AxisThinReport {
+    axes: number;
+    hidden: number;
+    stride: number;
+    cut?: number;
+    shrunk?: number;
+    nominal?: boolean;
+    colliding?: number;
+}
+export declare function reconcileLegendInSvg(svg: SVGSVGElement, opts?: ReconcileOptions): LegendReconcileResult;
+/**
+ * LEGENDS THAT NEVER ANNOUNCED THEMSELVES. The
+ * maximal mark-free <g> subtrees of the chart, judged by the legend signature in
+ * legendReconcile.ts. Walk top-down and stop descending once a group qualifies as
+ * mark-free, so an axis is one block and a legend nested inside the plot group is
+ * found on the way down. Axes are skipped STRUCTURALLY - d3's axis generator always
+ * emits g.tick / path.domain - which is the one exclusion a signature is allowed.
+ */
+export declare function findSignatureLegendGroups(svg: SVGSVGElement): Element[];
+/**
+ * THE COLORBAR'S OWN FURNITURE, FOUND STRUCTURALLY. The class-based legend finder
+ * above can't see a colorbar — the generator leaves the gradient rect UNCLASSED (and
+ * reuses .d3-legend-mark for the clickable AXIS labels, which are COLLIDERS here,
+ * not furniture). So: a <rect> filled url(#<gradient>) that isn't a plot mark; its
+ * parent <g> is the colorbar group, which is what carries the tick labels, the
+ * title and — the case that made this matter — a backing plate.
+ *
+ * Exported so the corpus replay measures with the SHIPPED detector instead of a
+ * copy of it; a replay that re-implements the predicate tests the translation.
+ */
+export declare function findColorbarFurniture(svg: SVGSVGElement): {
+    groups: Element[];
+    bars: SVGGraphicsElement[];
+};

package/dist/types/qualifyGroups.d.ts

@@ -44,15 +44,66 @@ export interface QualifyRefusalRow {
     reason?: string | null;
     /** True = a required channel is ABSENT. Absent/false = a threshold we are willing to waive. */
     isVeto?: boolean | null;
+    /**
+     * WHICH GATE wrote `reason`, as the server's stable code. Absent from a server that predates
+     * the code, which reads as "not known to be about the tile": the row keeps the grouping the
+     * list always had.
+     */
+    reasonCode?: string | null;
 }
 /** Which heading to write BEFORE a refused row, if any. */
-export type QualifyRefusalHeading = "poorFit" | "cannotDraw";
+export type QualifyRefusalHeading = "poorFit" | "tooSmall" | "cannotDraw";
 /** Carried across the refusal loop. One per render. */
 export interface QualifyRefusalGroupState {
     poorFit: boolean;
+    tooSmall: boolean;
     cannotDraw: boolean;
 }
 export declare function newQualifyRefusalGroupState(): QualifyRefusalGroupState;
+/**
+ * THE REFUSAL CODES THAT MEAN "THE TILE", NOT "THE FIELDS".
+ *
+ * Each refusal carries the code of the gate that wrote its sentence. These gates compare what a
+ * chart type needs with the size and shape of the tile and nothing else:
+ *  - TILE_TOO_NARROW, TILE_TOO_SHORT, TILE_NOT_SQUARE, TILE_NOT_TALL: too narrow, too short, not
+ *    square enough, not tall enough.
+ *  - TILE_TOO_SMALL: a type that does not hold up on a small tile, turned down because the tile is
+ *    under the size the full catalogue needs, whatever the data is.
+ *  - EMBED_NOTHING_FITS_TILE: a headline-plus-small-drawing type whose drawing has no form that
+ *    fits the tile; the headline alone is still drawable on a plain card.
+ *  - EMBED_BEESWARM_TILE_TOO_SMALL: a beeswarm turned down because the tile is under the size it
+ *    needs.
+ * The data can be exactly right and the type is still turned down, and the one thing that changes
+ * the answer is a bigger tile.
+ *
+ * Without this split those rows sat under "Can't be drawn from the fields as bound" or "Poor fit
+ * for these fields" - headings that send the reader to rebind data that is fine.
+ *
+ * ONLY GATES THAT LOOK AT THE TILE ALONE ARE LISTED. A gate that weighs the tile against the data
+ * (ROWS_CRAMPED, a row-per-category floor; TOO_MANY_PANELS, a panel budget; CATEGORIES_TOO_WIDE)
+ * can be answered by either, so naming it a tile problem would be the same false instruction
+ * turned around. A code is added here when the server starts sending one that is purely about the
+ * tile; an unknown code keeps the grouping it had.
+ */
+export declare const QUALIFY_TILE_REFUSAL_CODES: readonly string[];
+/**
+ * THE HEADING OVER THE TILE BLOCK, in the one place every host reads it from, so the wording
+ * cannot drift between them and a test pins it once.
+ *
+ * It says what the reader can do about it, not what category the row is in, and it says nothing
+ * about the fields: the rows under it are exactly the ones the fields are not the problem for.
+ * English source text - a host that localizes looks it up like its other headings.
+ */
+export declare const QUALIFY_TOO_SMALL_HEADING = "Needs a bigger tile";
+/**
+ * IS THIS REFUSAL ABOUT THE TILE'S SIZE OR SHAPE? Decided from the server's code, never from the
+ * sentence: a host that matched the English would go blind the day the sentences are translated,
+ * and would re-derive a verdict it was already handed.
+ *
+ * A row with no code (an older server) is NOT tile-bound. That is the safe direction: it keeps
+ * the two-heading grouping the list had before the code existed.
+ */
+export declare function refusalIsTileBound(row: QualifyRefusalRow | null | undefined): boolean;
 /**
  * MAY THE READER PICK THIS ONE? The single place that answers it, in either host.
  *
@@ -63,15 +114,22 @@ export declare function newQualifyRefusalGroupState(): QualifyRefusalGroupState;
  */
 export declare function refusalIsSelectable(row: QualifyRefusalRow | null | undefined): boolean;
 /**
- * The refused rows in RENDER ORDER: everything pickable first, then the vetoes.
+ * The refused rows in RENDER ORDER: the pickable ones first, then the ones the tile alone turned
+ * down, then the vetoes the fields cause.
  *
  * A STABLE PARTITION, not a sort — within each block the server's alphabetical order survives, so
  * two answers over the same shape stay diffable. Rows without a name are dropped: a control
  * labelled with nothing cannot be chosen and a reason with no subject cannot be read.
  *
- * The two blocks are ordered pickable-first because the reader opened this section to DO something.
+ * The blocks are ordered pickable-first because the reader opened this section to DO something.
  * Putting the inert half above the actionable half makes them scroll past every chart they cannot
  * have to reach the ones they can.
+ *
+ * THE TILE BLOCK SITS BETWEEN THE TWO, and its own rows are pickable-first too. A tile refusal is
+ * a veto or a waivable one like any other (the reader may still pick the waivable ones), but what
+ * it asks of the reader is different: resize, not rebind. Every row the code marks as about the
+ * tile goes there whichever way its veto flag points, so none is left under a heading that names
+ * the fields.
  */
 export declare function orderRefusalsForDisplay<T extends QualifyRefusalRow>(rows: readonly T[] | null | undefined): T[];
 /**

package/dist/types/selection.d.ts

@@ -3,6 +3,20 @@
  * numbers. A token that is not one names no row and is skipped; no attribute, no rows.
  */
 export declare function rowIdxsFromMark(el: Element | null): number[];
+/** The most rows one published set may name: the largest window any host hands a chart. A set past it
+ *  is cut there rather than refused, because the cap bounds the work an event can ask for and a table
+ *  never holds a row beyond it. */
+export declare const ROW_SET_MAX = 250000;
+/** The rows a published set names: whole non-negative numbers only, each once, in the order given, at
+ *  most ROW_SET_MAX. Anything else in the array is dropped, and a value that is not an array names none. */
+export declare function validRowSet(rows: unknown): number[];
+/**
+ * Publish a selection as a row set: fires the cross-filter event on `container`, carrying `rows` (valid
+ * ones only) and the `source` the host passes on to its subscribers. An empty set is a clear. For a
+ * chart that computes its own selection; a chart that selects by marks needs nothing, the host reads
+ * data-row-idx itself.
+ */
+export declare function dispatchRowSet(container: Element, rows: readonly number[], source?: string): void;
 /** The keys held during a click. Cmd counts as Ctrl. */
 export interface SelectionModifiers {
     ctrl?: boolean;
@@ -89,6 +103,43 @@ export declare function nextClickedMarks(prev: ClickedMarks | null | undefined,
  * its parent. A click inside a control is neither a selection nor a click on empty canvas.
  */
 export declare function isInsideControl(target: EventTarget | Node | null | undefined, container: Element): boolean;
+/** Movement between press and release, in px on either axis, at which a gesture is a drag. */
+export declare const DRAG_NOT_CLICK_PX = 5;
+/** A pointer position in client px. */
+export interface PressPoint {
+    x: number;
+    y: number;
+}
+/** True when the pointer travelled far enough between press and release to be a drag. */
+export declare function gestureWasDrag(down: PressPoint | null | undefined, up: PressPoint, thresholdPx?: number): boolean;
+/** Where the press is parked: on the CONTAINER, so every reader (the host's click handler, a renderer
+ *  adapter, the visual's bridge) reads the one record. */
+export declare const CONTAINER_SLOT_PRESS_AT = "__lchPressAt";
+/** The recorded press on `container`, or null when there is none. */
+export declare function pressOf(container: Element | null | undefined): PressPoint | null;
+/** Forget the recorded press: the click it led to has been read. */
+export declare function clearPress(container: Element | null | undefined): void;
+/**
+ * Record where the pointer goes down on `container`, in the CAPTURE phase so a renderer that stops
+ * propagation on its own handlers still leaves its origin, and whether it then travels 5px or more
+ * before it comes up. The travel is what makes a drag that ends where it began (a lasso closed on its
+ * own start, a brush returned to its origin) still a drag: the click it leaves has moved nowhere.
+ * Returns the function that stops all of it.
+ */
+export declare function trackPress(container: HTMLElement): () => void;
+/**
+ * True when `click` ended a press whose pointer travelled DRAG_NOT_CLICK_PX or more, on the way or by where
+ * the click landed. Reads the press, never writes it.
+ *
+ * A click a pointer made carries detail >= 1. A keyboard or scripted click carries detail 0 and no
+ * pointer position, so it is compared with nothing: the press on record may be one that never produced a
+ * click (released outside the chart), and a stale press must not turn a later keyboard click into a drag.
+ */
+export declare function clickWasDrag(container: Element | null | undefined, click: {
+    clientX?: number;
+    clientY?: number;
+    detail?: number;
+} | null | undefined): boolean;
 export interface MarkResolverEnv {
     root: HTMLElement;
     doc: Document;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bicharts/chart-host",
-  "version": "0.6.83",
+  "version": "0.6.85",
   "description": "Run a BIC-generated D3 chart in any web host: compiles the generated render() function, applies the shared option defaults, resolves mark clicks (through tooltip overlays), owns the selection affordance, and translates row indices between cross-filtered charts. The same contract the BIC Power BI visual implements, minus Power BI. React bindings at @bicharts/chart-host/react.",
   "license": "Apache-2.0",
   "type": "module",
@@ -59,6 +59,11 @@
       "import": "./dist/adapters.mjs",
       "default": "./dist/adapters.mjs"
     },
+    "./legend-fit": {
+      "types": "./dist/types/legendFit/index.d.ts",
+      "import": "./dist/legend-fit.mjs",
+      "default": "./dist/legend-fit.mjs"
+    },
     "./dax": {
       "types": "./dist/types/dax.d.ts",
       "import": "./dist/dax.mjs",