@toolpath/dfm 0.5.0 → 1.0.0

package/dist/model/index.d.ts

@@ -1,11 +1,634 @@
-import { h as DfmHit, U as Units, i as FeaturePinch, j as FeatureSheet, g as RuleProcess, D as DfmRule, R as RuleVocabulary, b as DfmFeature, a as DfmCheck } from '../feature-record-CfjgDCJU.js';
-export { B as BrokenRule, C as CRITICAL_COLOR, k as ClearanceFit, l as DfmMetric, m as DfmOp, n as DfmQuantity, o as DfmSources, p as DfmSubject, q as FactsKind, r as FeatureAcross, d as FeatureProfile, e as FeatureRecord, F as FeatureSheets, s as FeatureThreading, t as FeatureUndercut, f as MILLING_RULES, M as Measurement, P as PINCH_TOOL_MM, u as PinchDisc, v as RULE_COLORS, w as RangeHigh, x as RangeLow, c as ReachCurve, y as ReportFeature, z as RuleResult, S as SurfaceToolKind, T as TURNING_RULES, A as TurnedFactsKind, W as WARNING_COLOR, E as brokenRules, G as checkPart, H as compareColors, I as describeRule, J as dfmFeatures, K as featureColor, L as featureMeasurements, N as featureProfile, O as featureSheet, Q as featureTypeLabel, V as isNoReading, X as isSurfaceType, Y as makeRule, Z as maxBallDiameter, _ as parseRules, $ as peakHeight, a0 as readPinch, a1 as readReachCurve, a2 as runStart, a3 as trimmedCurve, a4 as turnedTypeLabel, a5 as withSurroundedFaces } from '../feature-record-CfjgDCJU.js';
+/**
+ * Where a feature is at its tightest (the datasheet's `pinchPoints`, API
+ * 1.12.1): one disc per stretch of the feature that reaches its minimum
+ * clearance, tightest first and never more than ten.
+ *
+ * As the API defines it, a disc fits in the space the clearance was measured
+ * in and touches the feature's boundary, so a cylinder of its diameter
+ * standing at its centre and spanning the datasheet's `zMin`..`zMax` is
+ * exactly the widest tool that reaches the boundary there. That is what makes
+ * them drawable: each is the tool the feature allows, standing where the
+ * feature stops a larger one.
+ *
+ * The Engine measures each disc to a tolerance (`toleranceBand.atolIgnore`),
+ * which lets it read a little wider than the gap it sits in. The discs here
+ * have that slack taken out (see {@link clearanceFit}), so each is the
+ * clearance itself: in a 2.5 mm corner, a 5 mm disc.
+ *
+ * Empty for the kinds whose clearance is not measured off a single medial
+ * axis (a hole, a facing pass, the undercut and layered kinds), so empty is
+ * "nowhere to point at", never "nowhere is tight".
+ *
+ * Millimetres, in the datasheet's tool frame: x and y across the tool, z up
+ * it.
+ */
+/** One disc: its centre across the tool, and its diameter. */
+interface PinchDisc {
+    x: number;
+    y: number;
+    diameter: number;
+}
+/** A feature's pinch discs, and the band along the tool they stand through. */
+interface FeaturePinch {
+    discs: readonly PinchDisc[];
+    zMin: number;
+    zMax: number;
+    /**
+     * The Engine measured the clearance at one tolerance only, so the slack
+     * could not be taken out: each disc is as measured, the most the clearance
+     * can be.
+     */
+    unresolved?: true;
+}
+/**
+ * The figures a feature's clearance is run back from, as the datasheet has
+ * them: the widest tool that reaches every point (`min` of the cutter band,
+ * which is also its tightest pinch disc) at the strict tolerance, and at the
+ * looser one where the Engine reports it.
+ */
+interface ClearanceFit {
+    /** `facts.cd`, or `facts.three.cd` for a chamfer. */
+    bandPath: string;
+    strict: number;
+    loose?: number;
+    atStrict?: number;
+    atLoose?: number;
+    /**
+     * How much wider, mm, the tolerance lets the widest tool read than the
+     * clearance it fits: what to take off a measured disc. Zero where the
+     * Engine measured at one tolerance only (`resolved` false), or where the
+     * tool does not grow with tolerance (a gap between walls, not a corner).
+     */
+    slack: number;
+    resolved: boolean;
+}
+/** A datasheet's pinch discs, the tolerance taken out of each, or null where it has none to draw. */
+declare const readPinch: (datasheet: unknown) => FeaturePinch | null;
+
+/**
+ * The few numbers of a feature's datasheet that the DFM rules and the
+ * feature details read. All millimetres, as the Engine reports them. Each is
+ * left out where this kind of feature does not report it, rather than sent as
+ * a zero that reads as measured.
+ *
+ * From the quoting app (quoting-ui `server/lib/engine.ts`). A datasheet is
+ * large, so the worker cuts each one down to this before it sends it.
+ */
+interface FeatureSheet {
+    /** The Engine's family for it: `Hole`, `Pocket`, … */
+    kind?: string;
+    /** Along the machining direction, the feature's own bottom and top. */
+    zMin?: number;
+    zMax?: number;
+    /** Its top extended to the stock, which the highest of stands in for the part's top. */
+    extendedZMax?: number;
+    /** The widest cutter that still reaches the tightest corner. */
+    maxTool?: number;
+    diameter?: number;
+    /** For a hole: the full angle of the cone at its bottom, degrees; 180 for a flat bottom. */
+    tipAngle?: number;
+    filletRadius?: number;
+    chamferAngle?: number;
+    /**
+     * For a milled feature with walls: the radius of its tightest inside corner
+     * between walls, as the geometry has it rather than as a tool reaches it —
+     * zero for a sharp one. Half its minimum clearance: see {@link insideCornerRadius}.
+     */
+    cornerRadius?: number;
+    /**
+     * The Engine measured the clearance at one tolerance only, so neither
+     * `cornerRadius` nor `pinchDiameter` could be run back to none: each is as
+     * a tool reads it at that tolerance, the most the clearance can be.
+     */
+    cornerRadiusUnresolved?: true;
+    /** What the clearance was worked out from, so a reader can follow it. See {@link ClearanceFit}. */
+    clearance?: ClearanceFit;
+    /**
+     * A vertical inside corner between its walls with no radius, which no end
+     * mill makes; and where, in the datasheet's tool frame (x, y across the
+     * tool; its `zMin`..`zMax` along it).
+     */
+    sharpCorners?: readonly {
+        x: number;
+        y: number;
+    }[];
+    /**
+     * For a contour surface: the largest tool its shape admits (`facts.toolFit`)
+     * — its diameter, and the radius on its corner, no larger than the
+     * surface's tightest concave curve; half the diameter for a ball.
+     */
+    fitToolDiameter?: number;
+    fitCornerRadius?: number;
+    /** Where the tool fit was read: `facts.toolFit` or `facts.three.toolFit`. */
+    toolFitPath?: string;
+    /** For a contour surface: only a ball end mill can finish it, not a bull nose. */
+    ballOnly?: true;
+    /**
+     * The feature's minimum clearance: the smallest of its pinch discs
+     * (`pinchPoints`), the tolerance taken out, leaving out the zero-wide ones
+     * a sharp corner reports. The widest tool that fits where it is tightest,
+     * and what a milled feature's L/D is taken over.
+     */
+    pinchDiameter?: number;
+    /** How many places are that tight: the pinch discs counted in `pinchDiameter`. */
+    pinchPlaces?: number;
+    /** No cutter fits anywhere in the feature. */
+    noToolFits?: true;
+    /** For a hole the model threads: its thread. */
+    threading?: FeatureThreading;
+    /** For an undercut — a T-slot or a dovetail: what its cutter is held to. */
+    undercut?: FeatureUndercut;
+}
+/**
+ * An undercut's own figures, from its `facts`: a T-slot's or a dovetail's.
+ * Millimetres and degrees. Each is left out where the Engine did not measure
+ * it, or where nothing limits it.
+ */
+interface FeatureUndercut {
+    /** T-slot: how far the groove runs back from its opening, radially (`facts.undercutDepth`). */
+    undercutDepth?: number;
+    /**
+     * T-slot: the widest tool that comes down through the opening above it
+     * (`facts.maxEntryCd`), which holds the cutter's shaft. Left out where
+     * nothing above limits it; zero where nothing fits.
+     */
+    maxEntry?: number;
+    /** Dovetail: between the overhanging wall and the tool axis, degrees (`facts.taperDeg`). */
+    taperDeg?: number;
+    /** Dovetail: the widest clearance over the floor, the width the groove cuts at. */
+    floorWidth?: number;
+    /** Dovetail: the clearance through the opening at the top of the groove. */
+    topOpeningWidth?: number;
+    /** Dovetail: the groove's widths vary from place to place — it runs out somewhere. */
+    isExternal?: true;
+    /** T-slot: its walls close on themselves in plan view, so a cutter's head comes down through its opening. */
+    isClosed?: true;
+    /**
+     * The Engine could not measure it (`facts.isInvalidGeometry` or
+     * `facts.cd.measurementFailed`), so its figures offer no cutter.
+     */
+    unmeasured?: true;
+}
+/** A modelled thread, from a hole's `facts.threading`. Millimetres. */
+interface FeatureThreading {
+    basicDiameter: number;
+    threadPitch: number;
+}
+/** Feature tag, lower-cased → its sheet. */
+type FeatureSheets = Record<string, FeatureSheet>;
+/** Narrower than this, mm, a pinch disc is a sharp corner, which no tool fits: not a pinch tool. */
+declare const PINCH_TOOL_MM = 0.01;
+/** A feature that is no reading of its faces at all, which the analysis leaves out. */
+declare const isNoReading: (featureType: unknown, datasheet: unknown) => boolean;
+/** One datasheet, cut down to what the rules read. Read loosely: kinds report different fields. */
+declare const featureSheet: (datasheet: unknown) => FeatureSheet;
+
+type Direction = {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+};
+/**
+ * A feature as the Engine's report gives it, cut down to the fields the rules
+ * read. `@toolpath/api`'s `PartFeature` is one, so the package takes no
+ * dependency on the SDK for a type.
+ */
+interface ReportFeature {
+    readonly featureTag: string;
+    readonly featureType: string;
+    readonly machiningDirection: Direction;
+    readonly regionIdxs: readonly number[];
+}
+/** A feature as the DFM rules read it: which it is, what kind, the way it is machined, and its faces. */
+interface DfmFeature {
+    readonly tag: string;
+    readonly featureType: string;
+    readonly machiningDirection: Direction;
+    readonly regionIdxs: readonly number[];
+    /**
+     * What the panels call it, after its type: 1, 2, 3… across the part,
+     * numbered a machining direction at a time, so the features cut one way
+     * run together. Arbitrary otherwise, but steady for one analysis.
+     */
+    readonly number: number;
+}
+/** The report's features, cut down to what the rules read, and numbered by direction. */
+declare const dfmFeatures: (features: readonly ReportFeature[]) => DfmFeature[];
+/** `through_hole` as `Through hole`. The Engine's feature types are open-ended snake case. */
+declare const featureTypeLabel: (featureType: string) => string;
+
+/** A turning datasheet's `facts.kind`, and `Unknown` for a stretch the Engine could not name. */
+type TurnedFactsKind = 'AxialHole' | 'Face' | 'FaceGroove' | 'FaceProfile' | 'IdGroove' | 'IdProfile' | 'IdThread' | 'OdGroove' | 'OdProfile' | 'OdThread' | 'Unknown';
+/**
+ * `od_groove` as `OD groove`, `axial_hole` as `Axial hole`. The Engine's
+ * turned feature types are open-ended snake case, so a type it adds later
+ * reads as its words.
+ */
+declare const turnedTypeLabel: (featureType: string) => string;
+/** Turning rules: the measures and subjects of the Engine's turned features. */
+declare const TURNING_RULES: RuleVocabulary;
+
+/** The unit a length is shown in. The Engine's meshes are always millimetres. */
+type Units = 'mm' | 'inch';
+/** The number alone, for a line of several lengths that names the unit once. */
+declare const lengthValue: (mm: number, units: Units) => string;
+declare const unitLabel: (units: Units) => string;
+
+/**
+ * At or above, above, at or below, below, equal, not equal, or between —
+ * equal meaning within half a percent, since figures are measured, and not
+ * equal anything further off; between from a low end up to, not including, a
+ * high one.
+ */
+type DfmOp = 'gte' | 'gt' | 'lte' | 'lt' | 'eq' | 'ne' | 'between';
+/**
+ * How a figure is read and typed: a length (mm), an area (mm²), an angle
+ * (degrees), a plain ratio, a count, a percentage, yes/no, or — for "any
+ * size" — nothing at all.
+ */
+type DfmQuantity = 'length' | 'area' | 'angle' | 'ratio' | 'count' | 'percent' | 'flag' | 'presence';
+/** A datasheet's `facts.kind`: which family of measurements the Engine took. */
+type FactsKind = 'Hole' | 'Pocket' | 'Boss' | 'Wall' | 'Face' | 'Three' | 'Chamfer' | 'Profile' | 'Dovetail' | 'Tslot';
+/** A datasheet's `facts.kind`, milled or turned. */
+type AnyFactsKind = FactsKind | TurnedFactsKind;
+interface DfmMetric {
+    key: string;
+    /** As the rule sentence reads it: "L/D", "depth below top". */
+    label: string;
+    /** The heading it is listed under when choosing. */
+    group: string;
+    quantity: DfmQuantity;
+    /** Which way is worse, for a new rule: deep is bad (≥), a tiny corner is bad (≤). */
+    op: DfmOp;
+    /** What a new rule starts at: millimetres and inches kept apart, so both read as round numbers. */
+    start: Record<Units, number>;
+    /** What it means, in a few plain words. */
+    hint: string;
+    /** The kinds of datasheet that report it; every kind when left out. */
+    kinds?: readonly AnyFactsKind[];
+    /**
+     * Where it sits in the datasheet, first found wins: a chamfer keeps its
+     * cutter band under its surface reading (`facts.three.cd`). Left out for a
+     * measure worked out rather than read (see `dfm-flags.ts`).
+     */
+    path?: readonly string[];
+    /** Whether a rule may name a value below zero: a height, or a signed radius. */
+    signed?: true;
+}
+declare const PRESENCE_METRIC: DfmMetric;
+interface DfmSubject {
+    value: string;
+    /** Plural, as the rule sentence starts: "Holes", "Undercut T-slots". */
+    label: string;
+    /** "Groups" or "Feature types", for choosing. */
+    group: string;
+    /** The datasheet kinds its features report; every kind when left out. */
+    kinds?: readonly AnyFactsKind[];
+}
+/** The common subjects, one list — broad groups and the few types worth naming alone. */
+declare const QUICK_SUBJECTS: readonly string[];
+/** Which kind of machining a set of rules is about: a milled part's features, or a turned part's. */
+type RuleProcess = 'milling' | 'turning';
+/**
+ * Everything a set of rules can say, for one process: its measures, its
+ * subjects, the short lists offered first, and how a feature that breaks a
+ * rule is named in a list. Pure data, so the editor, the checker and the
+ * rule-set file read milling and turning rules the same way.
+ */
+interface RuleVocabulary {
+    process: RuleProcess;
+    metrics: readonly DfmMetric[];
+    subjects: readonly DfmSubject[];
+    quickSubjects: readonly string[];
+    quickMetrics: readonly string[];
+    /** What a new or moved rule falls back on when its own measure is unknown: L/D for milling, "any size" for turning. */
+    fallbackMetric: DfmMetric;
+    /**
+     * A feature as a list or the feature panel names it: `{ name: 'Blind hole',
+     * detail: 'from +Z' }`, or for a turned one `{ name: 'OD groove', detail:
+     * 'from both ends' }`. The detail follows "Machined" in the feature panel.
+     */
+    featureLabel: (feature: Pick<DfmFeature, 'featureType' | 'machiningDirection'>) => {
+        name: string;
+        detail: string;
+    };
+    /** The feature panel's heading over what a feature asks of the machining: `Milling considerations`. */
+    considerationsTitle: string;
+    /** What an exported set is saved as. */
+    fileName: string;
+}
+/** Milling rules: the measures and subjects above, which the Engine's milled features report. */
+declare const MILLING_RULES: RuleVocabulary;
+declare const metricInfo: (key: string, vocabulary?: RuleVocabulary) => DfmMetric | undefined;
+/**
+ * The measures a subject's features can have: those every kind reports, and
+ * those its kinds do. Any feature, of whatever kind, can have any of them.
+ */
+declare const metricsForSubject: (subject: string, vocabulary?: RuleVocabulary) => readonly DfmMetric[];
+
+declare const OPS: readonly DfmOp[];
+/** How a range holds its low end: at or above it, or above it. */
+type RangeLow = 'gte' | 'gt';
+/** How a range holds its high end: below it, or at or below it. */
+type RangeHigh = 'lt' | 'lte';
+declare const RANGE_LOWS: readonly RangeLow[];
+declare const RANGE_HIGHS: readonly RangeHigh[];
+declare const opSymbol: (op: DfmOp) => string;
+interface DfmRule {
+    /** Stable, so a list can key its rows and a feature can name the rule it broke. */
+    id: string;
+    /** Which features: a value from its vocabulary's subjects — `FEATURE_SUBJECTS` for milling. */
+    subject: string;
+    /** What is measured: a key from its vocabulary's metrics — `FEATURE_METRICS` for milling. */
+    metric: string;
+    op: DfmOp;
+    /** Canonical — mm or a ratio. Ignored by a yes/no metric. The low end of a range. */
+    value: number;
+    /** A range's high end. Only a `between` rule has one. */
+    max?: number;
+    /** How a range holds its low end; ≥ where unsaid. Only a `between` rule has one. */
+    lowOp?: RangeLow;
+    /** How a range holds its high end; < where unsaid. Only a `between` rule has one. */
+    highOp?: RangeHigh;
+    /** `#rrggbb`: what the features that break it are painted. */
+    color: string;
+}
+/**
+ * The colours a rule can wear: vivid, and far enough apart in hue and
+ * lightness to tell apart on the part at a glance (no two closer than ΔE 37,
+ * and none within 50 of the selection's blue). Warm first, since most
+ * rules call out trouble; then cool ones for a rule that marks something
+ * good.
+ */
+declare const RULE_COLORS: readonly {
+    name: string;
+    value: string;
+}[];
+/**
+ * Which colour shows where a feature breaks rules of two: the one earliest in
+ * the palette, so red over yellow. Colours from outside it come after, in an
+ * order of their own, so a tie never falls back on the list.
+ */
+declare const compareColors: (a: string, b: string) => number;
+/** The quoting app's two severities, as the colours a rule starts in. */
+declare const CRITICAL_COLOR = "#e5484d";
+declare const WARNING_COLOR = "#ffd60a";
+declare const subjectLabel: (value: string, vocabulary?: RuleVocabulary) => string;
+/** The unit a value is typed in, beside its field. */
+declare const quantityUnit: (quantity: DfmQuantity, units: Units) => string;
+/** A canonical value as its field shows it. */
+declare const toField: (quantity: DfmQuantity, value: number, units: Units) => string;
+/**
+ * What a field says, back to canonical — or null when it is not a number,
+ * is below zero where the measure cannot be, or is a fraction of a count.
+ */
+declare const fromField: (metric: DfmMetric, text: string, units: Units) => number | null;
+/** A measured value, as a row says it: `7.5`, `1.25"`, `3.2 mm`, `1,200 mm²`. */
+declare const formatMeasured: (quantity: DfmQuantity, value: number, units: Units) => string;
+/**
+ * A rule as one plain line: "Holes with L/D ≥ 8", "Holes with 4 ≤ L/D < 8",
+ * "Any feature with a sharp inside corner", "Undercut T-slots, any size".
+ */
+declare const describeRule: (rule: DfmRule, units: Units, vocabulary?: RuleVocabulary) => string;
+/**
+ * A new rule for a subject and metric, at the metric's own starting value in
+ * the reader's units. A metric the vocabulary does not know is its fallback.
+ */
+declare const makeRule: (subject: string, metricKey: string, units: Units, color?: string, vocabulary?: RuleVocabulary) => DfmRule;
+/** A range's high end: its own, or as far again above its low one (at least 1) where it has none yet. */
+declare const upperOf: (rule: DfmRule) => number;
+/** How a range holds its low end. */
+declare const lowOf: (rule: DfmRule) => RangeLow;
+/** How a range holds its high end. */
+declare const highOf: (rule: DfmRule) => RangeHigh;
+/** A rule with its metric moved: the metric's own way and starting value, since the old ones meant something else. */
+declare const withMetric: (rule: DfmRule, metricKey: string, units: Units, vocabulary?: RuleVocabulary) => DfmRule;
+/** A rule with its comparison changed: a range gets a high end, and anything else loses it. */
+declare const withOp: (rule: DfmRule, op: DfmOp) => DfmRule;
+/** A rule with its subject moved, and its metric too when the new subject has no such measure. */
+declare const withSubject: (rule: DfmRule, subject: string, units: Units, vocabulary?: RuleVocabulary) => DfmRule;
+/**
+ * Stored rules, the ones that read in this vocabulary — a turning rule is
+ * dropped as milling reads it, and the other way round; null when what is
+ * stored is not a list at all.
+ */
+declare const parseRules: (raw: unknown, vocabulary?: RuleVocabulary) => DfmRule[] | null;
+
+/** What the checks read of the part, beyond its features. */
+interface DfmSources {
+    /** Each feature's measurements, cut down (`feature-sheet.ts`), by lower-cased tag. */
+    sheets: FeatureSheets;
+    /** Each feature's datasheet as the API sent it, by lower-cased tag. */
+    datasheets: Readonly<Record<string, unknown>>;
+    /** Each face's area, mm², by region index. */
+    regionAreas: ReadonlyMap<number, number>;
+}
+/** One rule a feature broke, with the figure that broke it. */
+interface DfmHit {
+    rule: DfmRule;
+    metric: DfmMetric;
+    /** What was measured, canonical. */
+    value: number;
+    /** For an L/D: against a drill's bore rather than the widest cutter. */
+    drilling?: boolean;
+}
+/** One rule and the features that break it. */
+interface RuleResult {
+    rule: DfmRule;
+    /** The required features' tags, as the report spells them: the worst first, the furthest past the rule. */
+    tags: string[];
+    /**
+     * The other readings that break it, worst first: features some other
+     * reading could stand in for, so they are not counted or painted, but a
+     * reader opening the rule should see everything it caught.
+     */
+    otherTags: string[];
+}
+/** The part checked against the rules. */
+interface DfmCheck {
+    /** Lower-cased tag → the rules the feature breaks, in the rules' order. Every feature, required or not. */
+    hitsByTag: ReadonlyMap<string, DfmHit[]>;
+    /** Lower-cased tags of the features a plan cannot do without. */
+    required: ReadonlySet<string>;
+    /** Each rule in order, with the required features that break it. */
+    byRule: RuleResult[];
+    /**
+     * Region → the colour a face is painted alone, and the reading it is painted for. See
+     * {@link unavoidableFaces}, and {@link withSurroundedFaces} for the faces painted with their surroundings.
+     */
+    paintedFaces: ReadonlyMap<number, {
+        tag: string;
+        color: string;
+    }>;
+    /** Lower-cased tag → a contour surface painted whole in its own worst colour. See {@link unavoidableFaces}. */
+    paintedWhole: ReadonlyMap<string, {
+        tag: string;
+        color: string;
+    }>;
+}
+/**
+ * The check with the faces its paint surrounds painted too. A face some
+ * reading cuts clean is left unpainted, but where that face is one of the
+ * feature that paints most of its painted neighbours, it is part of that
+ * feature, cut with it: a through hole in a flagged pocket's wall, say, read
+ * clean as a hole drilled from a floor far below that no plan would drill it
+ * from. Leaving it bare punches a hole in the feature's paint, so it takes
+ * the feature's colour. Where two features paint as many neighbours, the
+ * face takes the worse colour of those it is one of.
+ *
+ * One pass, over the paint as the check left it, so paint never spreads
+ * from a face that was itself only surrounded.
+ */
+declare const withSurroundedFaces: (check: DfmCheck, features: readonly DfmFeature[], adjacency: ReadonlyMap<number, ReadonlySet<number>>) => DfmCheck;
+/**
+ * Checks every feature against every rule. Only the required features count
+ * against a rule: a feature some other reading could stand in for may never
+ * be cut, so flagging it would bury the ones that will be.
+ */
+declare const checkPart: (features: readonly DfmFeature[], sources: DfmSources, rules: readonly DfmRule[]) => DfmCheck;
+
+/**
+ * A rule a feature breaks, as a row of its details says it: a coloured dot,
+ * the rule, and the figure that broke it. Neutral, so an app with rules of its
+ * own — the quoting app's, by severity — fills it from those, and an app on
+ * this package's checker fills it with {@link brokenRules}.
+ */
+interface BrokenRule {
+    /** Unique among one feature's rows: the rule's id. */
+    readonly key: string;
+    /** The dot: the rule's colour, or the app's colour for its severity. */
+    readonly color: string;
+    /** The rule: `Holes with L/D to top of part ≥ 8`, or a short label where `limit` says the rest. */
+    readonly text: string;
+    /** What the feature measured: `9.8`. Absent for a yes/no. */
+    readonly figure?: string;
+    /** The line it crossed, where `text` does not already say it: `≥ 8`. */
+    readonly limit?: string;
+    /** On hover: the rule written out, and why it matters. */
+    readonly note?: string;
+}
+/**
+ * The rules a feature breaks, as its details list them: one a measure, the
+ * worst, palette first, each written in the vocabulary its rules are in.
+ */
+declare const brokenRules: (check: DfmCheck, tag: string, units: Units, vocabulary?: RuleVocabulary) => BrokenRule[];
+/**
+ * The colour a feature is painted on the part: the one earliest in the
+ * palette of the rules it breaks, for a required feature. Read from a face
+ * painted alone (`region`), that face's colour where it is painted for this
+ * feature; a feature painted whole, its colour. Undefined otherwise.
+ */
+declare const featureColor: (check: DfmCheck, tag: string, region?: number | null) => string | undefined;
 
 /** The figure that broke a rule, bare: `7.5`, `0.05"`. Empty for a yes/no or "any size". */
 declare const hitFigure: (hit: DfmHit, units: Units) => string;
 
+/** One row of a feature's details. */
+interface Measurement {
+    /** Stable, so a list can key its rows. */
+    readonly key: string;
+    readonly label: string;
+    readonly value: string;
+    /** The same number in the other unit. Absent on a ratio or a count. */
+    readonly alt?: string;
+    /**
+     * How it was worked out from the datasheet, a line at a time: the fields it
+     * reads, by their path in the raw record, and the arithmetic, in the
+     * Engine's millimetres.
+     */
+    readonly derivation: readonly string[];
+    /**
+     * A machining consideration rather than a measurement of the feature's own
+     * shape: the tool that cuts it, and how far it has to reach. The panel lists
+     * these under their own heading, for every kind of feature.
+     */
+    readonly milling?: true;
+    /** A row that stands for a tool the viewer can draw on the part, by its kind. */
+    readonly tool?: SurfaceToolKind;
+}
+/** Which of a surface's finishing tools: a ball nose, or a bull nose with a flat between its corners. */
+type SurfaceToolKind = 'ball' | 'bull';
+/** Whether a feature type is read as a surface: see `SURFACE_TYPES`. */
+declare const isSurfaceType: (featureType: string) => boolean;
+/**
+ * The biggest ball nose a surface admits, mm: a ball's corner radius is half
+ * its diameter, so it is held under the tool fit's diameter and corner radius
+ * at once. None where the surface reports no fit, or admits no corner at all.
+ */
+declare const maxBallDiameter: (sheet: Pick<FeatureSheet, "fitToolDiameter" | "fitCornerRadius">) => number | undefined;
+/**
+ * The rows a feature gets, in {@link ROW_ORDER}: its own geometry first, then
+ * where it sits in the part and the reach that makes, then the tools a
+ * surface admits. A row is left out rather than shown empty: "—" against a
+ * field this kind never reports reads as a measurement that failed.
+ */
+declare const featureMeasurements: ({ features, feature, sheets, units, inchMark, }: {
+    features: readonly DfmFeature[];
+    feature: DfmFeature;
+    sheets: FeatureSheets;
+    units: Units;
+    /** Writes inches as `0.46"` rather than `0.46 in`. */
+    inchMark?: boolean;
+}) => Measurement[];
+
+/**
+ * Everything the API said about one feature: its entry in the part report and
+ * its datasheet, both as sent, so fields newer than any SDK are still there.
+ */
+interface FeatureRecord {
+    readonly feature: unknown;
+    /** Null where the API sent no datasheet for the feature. */
+    readonly datasheet: unknown;
+}
+/** One leaf of a datasheet: where it sits — `facts.bevel.angleDeg` — and what it says. */
+interface DatasheetField {
+    readonly path: string;
+    readonly value: string;
+}
+/** More rows than this and the list stops, rather than read a long curve out point by point. */
+declare const MAX_DATASHEET_FIELDS = 500;
+/**
+ * Every leaf of a datasheet by its path, as sent: millimetres and degrees,
+ * numbers to four places. A list of plain values is one row; a list of records
+ * is walked by index; an empty list or record is a row of its own. Stops at
+ * {@link MAX_DATASHEET_FIELDS}, and says so with `more`.
+ */
+declare const datasheetFields: (datasheet: unknown) => {
+    fields: DatasheetField[];
+    more: boolean;
+};
+
+/**
+ * A machining direction as a reader names it: `+Z` along an axis, the vector
+ * otherwise. The same words `@toolpath/viewer` uses, kept here so the rule
+ * list does not pull in three.js for one label.
+ */
+declare const directionLabel: (direction: {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}) => string;
+
 /** Whether two depths are one depth, as the quoting app counts them: within a twentieth, or a hundredth of a mm. */
 declare const sameDepth: (a: number, b: number) => boolean;
+/** A row in a list of features: one feature, or a group of the same hole. */
+type FeatureRow = {
+    kind: 'feature';
+    tag: string;
+} | {
+    kind: 'holes';
+    /** Stable: the first hole's tag. */
+    key: string;
+    /** In list order, the first standing for them all. */
+    tags: [string, ...string[]];
+    diameter: number;
+};
+/**
+ * These features as a list's rows, identical holes gathered into one where
+ * the first of them was. Holes the Engine did not measure, and anything not
+ * a hole, stay a row each.
+ */
+declare const featureRows: (tags: readonly string[], features: readonly DfmFeature[], sheets: FeatureSheets) => FeatureRow[];
 
 /**
  * A feature's pinch discs as the widest tool that fits stands in them: the
@@ -72,6 +695,64 @@ interface PlacedTool {
  */
 declare const placePinchTool: (mark: PinchMark, triangles: FaceTriangles, direction: Vec3, origin?: Vec3) => PlacedTool | null;
 
+/**
+ * A feature's reach curve (the datasheet's `reachCurve`, API 1.12.1): how
+ * high the material around a feature stands, by how far out from it.
+ *
+ * As the API defines it: material within `horizontalOffset[i]` of the
+ * feature rises to `verticalOffset[i]` above it. Both lists ascend, the
+ * curve is a step that never falls, and past its last knot it holds. So the
+ * rise comes at the *start* of each run, not at its knot: between two knots
+ * the material could stand anywhere out to the next one, and the next one's
+ * height is the bound — as the tool catalog's sweep reads it
+ * (`@toolpath/tool-support` `heightAt`), so a stack clears here where it
+ * clears there. Offsets
+ * are measured from the feature — zero is the wall of the cut — so material
+ * at offset `d` meets a tool at radius `d` plus the cutter's radius. Each
+ * reading is the worst case over the whole feature, with no direction to it.
+ *
+ * Millimetres throughout.
+ */
+
+interface ReachCurve {
+    /** Outward from the feature's wall, ascending. */
+    offsets: readonly number[];
+    /** How high the material within each offset rises above the feature, ascending. */
+    heights: readonly number[];
+}
+/** A datasheet's reach curve, or null where it has none worth drawing. */
+declare const readReachCurve: (datasheet: unknown) => ReachCurve | null;
+/** Where a knot's run starts, and so the nearest its material may stand: just past the knot before. */
+declare const runStart: ({ offsets }: ReachCurve, index: number) => number;
+/** The tallest the material stands anywhere the curve reaches. */
+declare const peakHeight: ({ heights }: ReachCurve) => number;
+/**
+ * The curve as the drawings show it: whole, where it keeps rising nearly to
+ * its end, and otherwise cut off {@link TAIL_MM} past where it reaches its
+ * full height, the height there held to the cut. `cut` says which, so the
+ * drawing can mark the break.
+ */
+declare const trimmedCurve: (curve: ReachCurve) => {
+    curve: ReachCurve;
+    cut: boolean;
+};
+/** How wide the feature itself is, across the tool, and what that width is. */
+interface FeatureAcross {
+    width: number;
+    /** A hole's bore, or a milled feature's tightest clearance (its smallest pinch disc). */
+    kind: 'diameter' | 'clearance';
+}
+/** The feature as the reach section draws it, left of its wall. */
+interface FeatureProfile {
+    /** Its width, to draw it to scale; null draws it at a set share. */
+    across: FeatureAcross | null;
+    /** Its own depth, top to bottom (`zMax − zMin`), over the same floor the curve stands on. */
+    depth: number | null;
+    /** It runs out through the part, so there is no floor under it. */
+    through: boolean;
+}
+declare const featureProfile: (sheet: FeatureSheet | undefined, featureType: string) => FeatureProfile;
+
 /**
  * A set of DFM rules as a file: what Export writes, Import reads, and what
  * an LLM is asked to produce. One JSON object, so a shop can keep a set per
@@ -171,4 +852,4 @@ declare const turnedStretches: (features: readonly TurnedReportFeature[]) => Tur
  */
 declare const checkTurnedPart: (stretches: readonly TurnedStretch[], rules: readonly DfmRule[]) => DfmCheck;
 
-export { DfmCheck, DfmFeature, DfmHit, DfmRule, FILE_KIND, type FaceTriangles, FeaturePinch, FeatureSheet, type PinchMark, type PlacedTool, RuleProcess, type RuleSetFile, RuleVocabulary, type TurnedReportFeature, type TurnedStretch, Units, type Vec3, checkTurnedPart, hitFigure, llmRulePrompt, parseRuleSetFile, pinchLabel, pinchMark, placePinchTool, sameDepth, serializeRuleSet, turnedStretches };
+export { type BrokenRule, CRITICAL_COLOR, type ClearanceFit, type DfmCheck, type DfmFeature, type DfmHit, type DfmMetric, type DfmOp, type DfmQuantity, type DfmRule, type DfmSources, type DfmSubject, FILE_KIND, type FaceTriangles, type FactsKind, type FeatureAcross, type FeaturePinch, type FeatureProfile, type FeatureRecord, type FeatureRow, type FeatureSheet, type FeatureSheets, type FeatureThreading, type FeatureUndercut, MAX_DATASHEET_FIELDS, MILLING_RULES, type Measurement, OPS, PINCH_TOOL_MM, PRESENCE_METRIC, type PinchDisc, type PinchMark, type PlacedTool, QUICK_SUBJECTS, RANGE_HIGHS, RANGE_LOWS, RULE_COLORS, type RangeHigh, type RangeLow, type ReachCurve, type ReportFeature, type RuleProcess, type RuleResult, type RuleSetFile, type RuleVocabulary, type SurfaceToolKind, TURNING_RULES, type TurnedFactsKind, type TurnedReportFeature, type TurnedStretch, type Units, type Vec3, WARNING_COLOR, brokenRules, checkPart, checkTurnedPart, compareColors, datasheetFields, describeRule, dfmFeatures, directionLabel, featureColor, featureMeasurements, featureProfile, featureRows, featureSheet, featureTypeLabel, formatMeasured, fromField, highOf, hitFigure, isNoReading, isSurfaceType, lengthValue, llmRulePrompt, lowOf, makeRule, maxBallDiameter, metricInfo, metricsForSubject, opSymbol, parseRuleSetFile, parseRules, peakHeight, pinchLabel, pinchMark, placePinchTool, quantityUnit, readPinch, readReachCurve, runStart, sameDepth, serializeRuleSet, subjectLabel, toField, trimmedCurve, turnedStretches, turnedTypeLabel, unitLabel, upperOf, withMetric, withOp, withSubject, withSurroundedFaces };