@toolpath/plan 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1868 @@
+export { MM_PER_INCH } from '@toolpath/tool-support';
+
+type CoverageKind = 'pinned' | 'ignored' | 'open' | 'machined' | 'notMachined';
+/**
+ * In the order the coverage bar draws them, and a feature is said to be where its faces differ
+ * (`stateOf`). A face itself is weighed by `classifyFaces`, ignored first.
+ */
+declare const COVERAGE_KINDS: ReadonlyArray<CoverageKind>;
+/** Each kind in the glossary's words: what the bar, the lists and the Pin features notes say. */
+declare const COVERAGE_LABELS: Record<CoverageKind, string>;
+/** A face: its region, its area (mm²), and the features that include it. */
+interface Face {
+    region: number;
+    area: number;
+    owners: Array<string>;
+}
+/** A part's faces by kind, each largest first, and its whole surface (mm²). */
+interface Coverage {
+    total: number;
+    faces: Record<CoverageKind, Array<Face>>;
+}
+/** Each face of a coverage by region, and who machines it. */
+declare const facesByRegion: (coverage: Coverage | null) => Map<number, {
+    face: Face;
+    kind: CoverageKind;
+}>;
+/** A feature as the part's analysis reads it. */
+interface CoverageFeature {
+    tag: string;
+    featureType: string;
+    regionIdxs?: ReadonlyArray<number> | null;
+}
+/** A tag as compared: Toolpath and the analysis spell a tag differently, so in lower case. */
+declare const tagKey: (tag: string) => string;
+/** Tags in lower case: Toolpath and the analysis spell a tag differently. */
+declare const tagSet: (tags: Iterable<string>) => Set<string>;
+/** What every action of a plan cuts, by tag (lower case). */
+declare const planTags: (setups: ReadonlyArray<{
+    actions: ReadonlyArray<{
+        featureTags?: ReadonlyArray<string> | null;
+    }>;
+}>) => Set<string>;
+declare const areaOf: (faces: ReadonlyArray<Pick<Face, "area">>) => number;
+/** What `classifyFaces` reads of the part: its faces, its features, and the faces ignored. */
+interface ClassifiedPart {
+    regions: ReadonlyArray<{
+        idx: number;
+        area: number;
+    }>;
+    features: ReadonlyArray<CoverageFeature>;
+    ignored?: ReadonlyArray<number>;
+}
+/** The constraints view: the person's pins, by tag (lower case). The rest is open. */
+interface ConstraintsCoverage extends ClassifiedPart {
+    pinned: ReadonlySet<string>;
+    /** One view at a time: never Toolpath's plan beside the pins. */
+    machined?: never;
+}
+/** The results view: what Toolpath's plan cuts, by tag (lower case). The rest is not machined. */
+interface ResultsCoverage extends ClassifiedPart {
+    machined: ReadonlySet<string>;
+    /** One view at a time: never the pins beside Toolpath's plan. */
+    pinned?: never;
+}
+/**
+ * Each face in exactly one kind: ignored first, then — constraints — pinned or open, or — results —
+ * machined or not machined. Every tag set is lower case. The other view's kinds are empty.
+ */
+declare const classifyFaces: (input: ConstraintsCoverage | ResultsCoverage) => Coverage;
+/** Faces gathered under the one feature that would machine them all: a row of a Not machined list. */
+interface FaceGroup {
+    /** The feature, or null for a face no feature includes: listed alone. */
+    tag: string | null;
+    /** Its faces, largest first. */
+    faces: Array<Face>;
+    area: number;
+}
+/** A type that includes most of a direction's faces by its nature, so it never speaks for one. */
+declare const isFallback: (type: string) => boolean;
+/**
+ * Gather faces under features, so one choice settles several. Greedy: the feature including the
+ * most faces still ungathered goes first (the more specific, then the smaller, among equals) until
+ * every face is under one. A profile includes most of its direction's faces, so it is taken only for
+ * a face nothing else includes. A face no feature includes is a group of its own. Features come
+ * first, largest first, then the faces no feature includes.
+ */
+declare const groupFaces: (faces: ReadonlyArray<Face>, features: ReadonlyArray<CoverageFeature>) => Array<FaceGroup>;
+
+/** A feature type as a person says it: `open_pocket` → `Open pocket`. */
+declare const featureTypeLabel: (type: string) => string;
+/** A direction token, exactly as Toolpath served it: the kernel compares directions bit-exactly. */
+interface PlanDirection {
+    x: number;
+    y: number;
+    z: number;
+}
+/** One pass of a setup: its tool, and the features (tags, hex) it cuts. */
+interface EnginePlanAction {
+    idx: number;
+    toolName: string;
+    featureTags: Array<string>;
+}
+interface EnginePlanSetup {
+    idx: number;
+    /** The setup's first direction — a 3+2 setup has more, in {@link EnginePlan.setupPlan}. */
+    direction: PlanDirection | null;
+    /** Features this setup was meant to machine that no pass in it does. */
+    unmachined: Array<string>;
+    actions: Array<EnginePlanAction>;
+}
+/** What a setup was meant to machine and no pass in it does — Engine's `unmachined` — by tag. */
+declare const notMachinedOf: (setup: Pick<EnginePlanSetup, "unmachined">) => Array<string>;
+/** One direction of a setup, and the features planned from it. */
+interface StatedOrientation {
+    direction: PlanDirection;
+    features: Array<string>;
+}
+/**
+ * A plan's statement of itself — every setup in order, each with all of its directions and the
+ * features planned from each. What Toolpath takes back to plan from a statement.
+ */
+interface SetupPlan {
+    setups: Array<{
+        orientations: Array<StatedOrientation>;
+    }>;
+}
+/** What the plan leaves uncut: `Unseen`, `OutOfPlay` or `Incomplete`, with its area (mm²). */
+interface PlanIssue {
+    kind: string;
+    area: number;
+    regionCount: number;
+}
+interface EnginePlan {
+    planId: string;
+    /**
+     * The job that made this run of the plan. Every run is a new plan now, but plans recalculated in
+     * place before that share a plan id, so a run is told by plan and job together (`runKey`). Null
+     * from a plan copy stored before it was read.
+     */
+    jobId: string | null;
+    /**
+     * How far the plan has got: `planned`, its setups built but not timed yet, or `toolpathed`, with
+     * its toolpaths and times. Null from a copy stored before Toolpath said.
+     */
+    level: 'planned' | 'toolpathed' | null;
+    kernelVersion: string | null;
+    issues: Array<PlanIssue>;
+    setups: Array<EnginePlanSetup>;
+    /** Null from an Engine that does not serve it (before API 1.19), or for a plan with no setup. */
+    setupPlan: SetupPlan | null;
+}
+/**
+ * Which run of a plan this is: its id and the job that made it. What the Plan page stamps a taken-out
+ * list or an added folder with, so both are let go once Toolpath has planned again. A plan read
+ * without a job falls back to its id.
+ */
+declare const planRunOf: (plan: Pick<EnginePlan, "planId" | "jobId">) => string;
+
+/**
+ * Where Toolpath's analysis of a direction a folder faces stands: its features are in; they are on
+ * their way; it detected the direction and can be asked to analyze it; or it never detected it, and
+ * nothing can be planned from it.
+ */
+type DirectionAnalysis = 'analyzed' | 'analyzing' | 'unanalyzed' | 'undetected';
+/** What the part's report and its pending request say of its directions. */
+interface DirectionsKnown {
+    /** The directions analyzed — the report's candidates — or null before the report is read. */
+    analyzed: ReadonlyArray<PlanDirection> | null;
+    /** Every direction Toolpath detected, or null from a report that does not say. */
+    discovered: ReadonlyArray<PlanDirection> | null;
+    /** Toolpath is analyzing directions added to the part. */
+    pending: boolean;
+}
+declare const directionAnalysis: (direction: PlanDirection, { analyzed, discovered, pending }: DirectionsKnown) => DirectionAnalysis;
+
+/** How deep a folder may sit below its setup (FLD7). */
+declare const MAX_DEPTH = 6;
+
+/** A folder: a grouping of work, the features pinned in it, and the folders inside it. */
+interface DraftFolder {
+    id: string;
+    name: string;
+    /**
+     * Features pinned here — machined from this folder's direction, whatever else Toolpath decides.
+     * Tags (hex), each of that direction's reading of its surface. Only ever what someone pinned.
+     */
+    features: Array<string>;
+    folders: Array<DraftFolder>;
+    /** Set only on a tool orientation: the tilt it is cut from, inside an indexed setup. */
+    direction?: PlanDirection;
+}
+/** How a setup holds the part: indexed about one rotary axis, or two. Absent, it is 3 axis. */
+type SetupProcess = '3+1' | '3+2';
+/** A top-level folder: one way the part is held, facing its direction (Setup Z). */
+interface DraftSetup extends DraftFolder {
+    direction: PlanDirection;
+    process?: SetupProcess;
+}
+/** The person's constraints: the setups and the faces ignored — what the plan's own edits change. */
+interface Constraints {
+    setups: Array<DraftSetup>;
+    /**
+     * Faces already at their final surface, which no setup needs to reach: indices into the part
+     * report's regions, sorted. Sent to Toolpath with the plan as `doneRegions`.
+     */
+    done: Array<number>;
+    /**
+     * The kernel version of the part report the done faces were marked on: their indices are its
+     * numbering. Null with none marked.
+     */
+    doneKernel: string | null;
+}
+/** As many setups as the Engine takes in a stated plan, and the longest name worth keeping. */
+declare const MAX_SETUPS = 64;
+declare const MAX_NAME = 100;
+
+/** Two directions are the same only bit for bit: Toolpath compares its direction tokens exactly. */
+declare const sameDirection: (a: PlanDirection, b: PlanDirection) => boolean;
+declare const isIndexed: (setup: Pick<DraftSetup, "process">) => boolean;
+/** A folder where it sits: its setup, its parent, its depth, and the frame it is cut in. */
+interface PlacedFolder {
+    folder: DraftFolder;
+    setup: DraftSetup;
+    parent: DraftFolder | null;
+    /** 0 for a setup. */
+    depth: number;
+    /** The direction it is cut from: its own as a setup or tool orientation, else its parent's. */
+    direction: PlanDirection;
+    /** The folder whose direction that is — itself for a setup or tool orientation. */
+    frameId: string;
+    /** Whether it is a tool orientation: a tilt of its own, inside an indexed setup. */
+    toolOrientation: boolean;
+}
+/**
+ * Every folder in tree order — each setup, then what is inside it depth first — with where it sits.
+ * A tool orientation counts only inside an indexed setup; elsewhere a folder's own direction is
+ * inert and it follows its parent.
+ */
+declare const placedFolders: (setups: ReadonlyArray<DraftSetup>) => Array<PlacedFolder>;
+declare const findPlaced: (setups: ReadonlyArray<DraftSetup>, id: string) => PlacedFolder | undefined;
+/** A frame: one direction the plan is cut from, and every feature pinned in it or its followers. */
+interface Frame {
+    /** The folder that faces it: a setup, or a tool orientation. */
+    id: string;
+    name: string;
+    /** The setup it is held in — its hold. */
+    holdId: string;
+    direction: PlanDirection;
+    features: Array<string>;
+}
+/** The plan's frames, in tree order: each setup's direction, then its tool orientations'. */
+declare const framesOf: (setups: ReadonlyArray<DraftSetup>) => Array<Frame>;
+/** How deep the folders run below this one, counting itself: 1 for a folder with none in it. */
+declare const heightOf: (folder: DraftFolder) => number;
+/**
+ * The draft with a folder, and everything in it, taken out. A setup goes from the top; a folder it
+ * leaves holding only one folder gives way to it (`liftLoneFolder`).
+ */
+declare const removeFolder: (setups: ReadonlyArray<DraftSetup>, id: string) => Array<DraftSetup>;
+/**
+ * The draft with several folders, and everything in them, taken out together — then each folder
+ * they leave holding only one folder gives way to it. All go before any gives way, so a folder
+ * taken out with its pair's parent can't be left standing in that parent's place.
+ */
+declare const removeFolders: (setups: ReadonlyArray<DraftSetup>, ids: ReadonlyArray<string>) => Array<DraftSetup>;
+/**
+ * No edit leaves a folder holding a single folder: the folder an edit leaves that way — one taken
+ * out of a pair, say — gives way to the folder in it, which comes up into its place. That folder
+ * keeps its name, its pins and its folders. It is cut as it was: where it followed, from the way its place was cut — a setup's direction, and its
+ * hold while a tilt is left in it to reach, or a tilt — and where it was a tilt of its own, from
+ * that tilt; a tilt come up to the top is a setup facing it, indexed only to reach the tilts inside
+ * it, as a tilt moved to the top is (FLD23).
+ *
+ * Only the folder named: a draft saved holding one elsewhere is left as it is, rather than
+ * restructured by an edit to something else. Its place's own count is unchanged, so nothing above
+ * it needs another look.
+ */
+declare const liftLoneFolder: (setups: ReadonlyArray<DraftSetup>, id: string) => Array<DraftSetup>;
+/** A new folder's name: "Folder N", one past the highest N any folder is called (FLD1). */
+declare const nextFolderName: (names: ReadonlyArray<{
+    name: string;
+}> | ReadonlyArray<string>) => string;
+/**
+ * A folder inside another, at the end, following it in everything (FLD6) — or the draft unchanged
+ * where it would sit deeper than a folder may (FLD7). A folder holding no folders yet is split first:
+ * what it holds moves into a folder of its own, named as it is, and the new folder goes beside that —
+ * so no folder holds features and folders both, and none holds a single folder.
+ */
+declare const addFolder: (setups: ReadonlyArray<DraftSetup>, parentId: string, id: string, 
+/** The id for the folder the work moves into, where the parent is split. */
+workId?: string) => Array<DraftSetup>;
+declare const renameFolder: (setups: ReadonlyArray<DraftSetup>, id: string, name: string) => Array<DraftSetup>;
+/** What changing the plan did, or why it could not be done. */
+type Edited = Array<DraftSetup> | {
+    refused: string;
+};
+/**
+ * Hold a setup 3 axis, 3+1 or 3+2. Back to 3 axis is refused while it holds tool orientations: they
+ * are tilts only an indexed setup reaches.
+ */
+declare const setSetupProcess: (setups: ReadonlyArray<DraftSetup>, setupId: string, process: SetupProcess | undefined) => Edited;
+/**
+ * Make a folder a tool orientation facing a direction of its own, or — with none — follow its parent
+ * again. A direction another frame already faces is refused: Toolpath takes each direction once.
+ */
+declare const setToolOrientation: (setups: ReadonlyArray<DraftSetup>, folderId: string, direction: PlanDirection | null) => Edited;
+/**
+ * Setups as stored before folders nested, read as a tree: every folder with a list of folders.
+ * Everything that reads a stored draft goes through this.
+ */
+declare const withFolders: (setups: ReadonlyArray<DraftSetup>) => Array<DraftSetup>;
+declare const isDirection: (value: unknown) => value is PlanDirection;
+declare const copyDirection: ({ x, y, z }: PlanDirection) => PlanDirection;
+/**
+ * A draft's setups as sent to be saved, checked — or why not. Folders at most six below their
+ * setup, every tag pinned once, and each direction a frame once, as Toolpath requires. Anything
+ * else stored with a folder — the stamps drafts once carried — is dropped without a word.
+ */
+declare const parseDraftSetups: (value: unknown) => Array<DraftSetup> | string;
+/** A setup facing a direction no frame faces yet, added last — or the draft unchanged. */
+declare const addSetup: (setups: ReadonlyArray<DraftSetup>, direction: PlanDirection, id: string) => Array<DraftSetup>;
+/** A setup of Toolpath's plan, as `foldersFromPlan` and `planFromResults` read it. */
+interface PlannedSetup$1 {
+    orientations: ReadonlyArray<{
+        direction: PlanDirection;
+        /** The features planned from it, where the plan was served with its orientations. */
+        features?: ReadonlyArray<{
+            tag: string;
+        }>;
+    }>;
+    /** Every feature the setup takes, each once, marked where no pass cuts it. */
+    rows?: ReadonlyArray<{
+        tag: string;
+        mark?: string | false;
+    }>;
+}
+/** Folders facing each setup of Toolpath's plan, and nothing else: no pins (`statedFrom`). */
+declare const foldersFromPlan: (planned: ReadonlyArray<PlannedSetup$1>, newId: () => string) => Array<DraftSetup>;
+/** Toolpath's plan as constraints: its folders, and every feature pinned where it was planned (`statedFrom`). */
+declare const planFromResults: (planned: ReadonlyArray<PlannedSetup$1>, newId: () => string) => Array<DraftSetup>;
+/** A setup moved `by` places among the setups, clamped to the ends. */
+declare const moveSetup: (setups: ReadonlyArray<DraftSetup>, id: string, by: number) => Array<DraftSetup>;
+/**
+ * A folder moved `by` places among the folders beside it — the setups, or its parent's folders —
+ * clamped to the ends. Nothing about it changes but its place (FLD22).
+ */
+declare const moveWithin: (setups: ReadonlyArray<DraftSetup>, id: string, by: number) => Array<DraftSetup>;
+/**
+ * Indexed about one rotary axis or two: 3+1 when every tilt turns Setup Z about one axis square to
+ * it — every tilt in one plane through Setup Z — else 3+2. Straight up or down needs no particular
+ * axis.
+ */
+declare const indexedFor: (setupDirection: PlanDirection, tilts: ReadonlyArray<PlanDirection>) => SetupProcess;
+/** What pinning a feature did, or why it could not be done. */
+type Pinned = {
+    setups: Array<DraftSetup>;
+    /** The folder it is pinned in, or was let go from. */
+    setupId: string;
+    /** A setup was added for the feature's direction, which no folder faced. */
+    added: boolean;
+    /** It was pinned there already, and is now let go. */
+    unpinned: boolean;
+} | {
+    refused: string;
+};
+/** The folder a feature is pinned in, if any. */
+declare const pinnedIn: (setups: ReadonlyArray<DraftSetup>, tag: string) => string | null;
+/** The folder each feature is pinned in, by tag (`tagKey`): the first in tree order. */
+declare const pinHomes: (setups: ReadonlyArray<DraftSetup>) => Map<string, string>;
+/** A feature's pin, its tag in any case: the folder, and the tag as the pin spells it. */
+declare const pinOf: (setups: ReadonlyArray<DraftSetup>, tag: string) => {
+    folderId: string;
+    tag: string;
+} | null;
+/**
+ * Pin a feature in a folder — taking it from wherever else it was pinned — or let it go if it is
+ * pinned there already. The caller has checked the folder faces the feature's way. A folder holds
+ * features or folders, never both: into one holding folders, the pin goes in a folder added inside
+ * it, following it, which holds just the feature.
+ */
+declare const pinInto: (setups: ReadonlyArray<DraftSetup>, folderId: string, tag: string, 
+/** The id for the folder the pin goes in, where the folder named holds folders. */
+newId?: string) => Pinned;
+/**
+ * The folder a pin from this direction goes in: the frame facing that way — a setup or a tool
+ * orientation — or, where that holds folders, the first folder in it cut from its way that holds
+ * none (a folder holds features or folders, never both). Where the frame holds folders and none of
+ * them is cut from its way, the frame: `pinInto` adds a folder in it for the pin. Null where no
+ * frame faces it and pinning adds a setup.
+ */
+declare const pinTargetOf: (setups: ReadonlyArray<DraftSetup>, direction: PlanDirection) => string | null;
+/** The frame — a setup or a tool orientation — facing this direction: at most one does. */
+declare const frameFacing: (setups: ReadonlyArray<DraftSetup>, direction: PlanDirection) => Frame | undefined;
+/**
+ * Machine a feature from this direction: pin it in the folder facing that way — a setup or a tool
+ * orientation — or let it go if it is pinned there already. With no folder facing that way, a setup
+ * is added for it, last; `newId` is that setup's, or the folder's `pinInto` adds. Toolpath may refuse a pin — a profile outside the first setup, for now — and
+ * says so once Toolpath plans again.
+ */
+declare const pinFrom: (setups: ReadonlyArray<DraftSetup>, direction: PlanDirection, tag: string, newId: string) => Pinned;
+/** Let a pinned feature go: Toolpath decides again where it is machined. */
+declare const unpinFeature: (setups: ReadonlyArray<DraftSetup>, folderId: string, tag: string) => Array<DraftSetup>;
+/**
+ * A feature put back as `saved` had it: pinned, at its place, in the folders it was pinned in there,
+ * and in no other. Every other edit stands; a folder `saved` had that is gone since is passed over.
+ */
+declare const restoreFeature: (setups: ReadonlyArray<DraftSetup>, saved: ReadonlyArray<DraftSetup>, tag: string) => Array<DraftSetup>;
+/**
+ * A list stamped with what it was made against — faces marked done with a kernel's numbering — as
+ * it stands `now`: stamped with anything else, it no longer holds, and is let go.
+ */
+declare const currentFor: <T>(list: ReadonlyArray<T> | undefined, stamp: string | null | undefined, now: string | null | undefined) => Array<T>;
+/** Faces ignored, in order, numbered by `kernel` — none kept with no kernel to number them by. */
+declare const ignoredAs: (done: ReadonlyArray<number>, kernel: string | null) => Pick<Constraints, "done" | "doneKernel">;
+/** The faces ignored with `faces` among them, once each. */
+declare const withIgnored: (plan: Pick<Constraints, "done" | "doneKernel">, faces: ReadonlyArray<number>, kernel: string | null) => Pick<Constraints, "done" | "doneKernel">;
+/** The faces ignored with `faces` no longer among them, its kernel let go once none are left. */
+declare const withoutIgnored: (plan: Pick<Constraints, "done" | "doneKernel">, faces: ReadonlyArray<number>, kernel: string | null) => Pick<Constraints, "done" | "doneKernel">;
+/** The faces ignored with `faces` back as `saved` had them, and every other as `plan` has it. */
+declare const ignoredAsSaved: (plan: Pick<Constraints, "done" | "doneKernel">, saved: Pick<Constraints, "done" | "doneKernel">, faces: ReadonlyArray<number>, kernel: string | null) => Pick<Constraints, "done" | "doneKernel">;
+/** A pin of the person's: the feature, and the folder it is pinned in. */
+interface PinnedFeature {
+    tag: string;
+    setupId: string;
+}
+/** The person's pins that `test` keeps, in every folder each is pinned in. */
+declare const pinsWhere: (setups: ReadonlyArray<DraftSetup>, test: (tag: string) => boolean) => Array<PinnedFeature>;
+/** What pinning, and ignoring faces, need to know of the part. */
+interface PlanRules {
+    regionsOf: (tag: string) => ReadonlyArray<number>;
+    /** The kernel the part's faces are numbered by. */
+    kernel: string | null;
+}
+/** The plan as Toolpath's `setupPlan` takes it: setups in order, each one direction and its pins. */
+interface Statement {
+    setups: Array<{
+        orientations: Array<{
+            direction: PlanDirection;
+            features: Array<string>;
+        }>;
+    }>;
+}
+/**
+ * What the draft tells Toolpath: every frame, in tree order, each a 3-axis setup of its own with
+ * its pins — a floor Toolpath appends to. Null with no frames: Toolpath plans the part itself.
+ * Setup `i` of the statement is frame `i`.
+ */
+declare const statementOf: (setups: ReadonlyArray<DraftSetup>) => Statement | null;
+/** A hold: one of the draft's setups, and the Engine setups cut in it. */
+interface Hold {
+    key: string;
+    name: string;
+    setupIdxs: Array<number>;
+}
+/**
+ * Toolpath's setups grouped into the draft's holds: each setup cut from a direction one of the
+ * draft's frames faces belongs to that frame's setup's hold. Any other — one Toolpath added past
+ * the statement, or one with no direction — is a hold of its own, "Setup N". In the order Toolpath
+ * machines them.
+ */
+declare const holdsFor: (setups: ReadonlyArray<DraftSetup>, planned: ReadonlyArray<{
+    idx: number;
+    direction?: PlanDirection | null;
+}>) => Array<Hold>;
+/** Where a moved folder lands: among the setups, or inside a folder — at a place in its list. */
+interface Landing {
+    /** The folder it lands in, or null for the top: a setup. */
+    parentId: string | null;
+    /** Its place among what is there once it has left where it was. */
+    index: number;
+}
+/**
+ * Move a folder, with everything in it (FLD20–27), or say why not:
+ * - Reordered where it is, nothing about it changes.
+ * - To the top, a tool orientation becomes a setup facing its tilt — indexed, if it holds tilts of
+ *   its own. A folder that follows can't: its direction is a setup already.
+ * - Into a folder cut from the same way, it follows it, dropping a setup's hold or its own tilt.
+ * - Into a folder cut from another way, it becomes a tool orientation keeping its direction, and the
+ *   setup it lands in is indexed to turn the part to it: 3+1, or 3+2 where one axis won't reach.
+ * Never into itself, below a folder in it, deeper than six, or making a direction two frames.
+ */
+declare const moveFolder: (setups: ReadonlyArray<DraftSetup>, id: string, to: Landing, 
+/** The id for a parent made to hold both, where it is dropped on a folder holding work. */
+newId?: string) => Edited;
+/**
+ * Move a feature's row into a folder — pinning it there, taking it from wherever else it was pinned
+ * — where the folder is cut from the feature's own direction; or say why not. Onto a parent, it
+ * goes to the first folder in it cut from that direction that holds no folders; with none, onto a
+ * parent cut from that direction itself, into a folder added in it, as `pinInto` adds.
+ */
+declare const moveFeature: (setups: ReadonlyArray<DraftSetup>, tag: string, featureDirection: PlanDirection, folderId: string, 
+/** The id for a folder made to hold the row, where it is dropped on a parent. */
+newId?: string) => Edited;
+
+/** A region as the part's model has it: its index, and the CAD face it was split from. */
+type SplitRegion = {
+    idx: number;
+    splitOrigin: number;
+};
+/**
+ * The regions of the CAD face a region was split from: those sharing its `splitOrigin`. A region
+ * with none — unknown to the model — is a face of its own.
+ */
+declare const faceRegions: (regions: ReadonlyArray<SplitRegion>, region: number) => Array<number>;
+/** Where a click is read from: an open folder's way, Ignore, or the whole part. */
+type ReadingScope = 
+/** The folder's direction alone, largest first, the viewer's rank breaking ties. */
+{
+    kind: 'folder';
+    id: string;
+    direction: PlanDirection;
+}
+/** The most specific feature first; profiles offered but never the default. */
+ | {
+    kind: 'ignore';
+}
+/** Every direction, largest first, the viewer's rank breaking ties. */
+ | {
+    kind: 'all';
+};
+/** What a click gives: the faces it is on, the viewer's ranking of their owners, and a feature meant. */
+interface ReadingAt {
+    regions: ReadonlyArray<number>;
+    /** The viewer's ranking of the owners, best first — breaking ties in size. */
+    ranked?: ReadonlyArray<string>;
+    /** A feature to take as the default where it is among the readings: a list row's own, say. */
+    prefer?: string | null;
+}
+/** What the readings need of the part and the plan. */
+interface ReadingContext {
+    /** The part's features, in report order. */
+    features: ReadonlyArray<CoverageFeature>;
+    /** A feature by tag in any case: the way it is cut. */
+    featureOf: (tag: string) => {
+        direction: PlanDirection;
+    } | null;
+    /** The folder a feature is pinned in, or null: a reading already pinned is the default. */
+    pinnedIn?: (tag: string) => string | null;
+}
+/** The features a click reads, in the scope's order, and the one it means by default. */
+interface Readings {
+    tags: Array<string>;
+    default: string | null;
+}
+/**
+ * The features a click on `at.regions` reads in `scope`, and which it means by default: `prefer`
+ * where it is among them, else one already pinned — in the folder for `folder`, anywhere for
+ * `all` — else the first; for `ignore`, the first that is not a profile, else null.
+ */
+declare const readingsFor: (at: ReadingAt, scope: ReadingScope, context: ReadingContext) => Readings;
+
+/**
+ * Ignore faces. A pin — in any folder — whose every face is ignored with them is unpinned: the
+ * ignore wins. A plain unpin: the feature is open, its faces ignored.
+ */
+declare const ignoreEdit: (plan: Constraints, regions: ReadonlyArray<number>, context: Pick<PlanRules, "kernel" | "regionsOf">) => {
+    intent: Constraints;
+    unpinned: Array<PinnedFeature>;
+};
+/** What a status note adds of the pins ignoring took out, by folder: nothing, or " Unpinned from …". */
+declare const unpinnedNote: (unpinned: ReadonlyArray<PinnedFeature>, setups: ReadonlyArray<DraftSetup>) => string;
+/** What a status note says of regions no longer ignored: nothing, or " Region 4 no longer ignored.". */
+declare const unignoredNote: (regions: ReadonlyArray<number>) => string;
+/** Stop ignoring faces. */
+declare const unignoreEdit: (plan: Constraints, regions: ReadonlyArray<number>, context: Pick<PlanRules, "kernel">) => Constraints;
+/**
+ * What a click on the part takes while ignoring: the region clicked, every region of the CAD face
+ * it was split from, or a feature's regions.
+ */
+type IgnoreMode = 'region' | 'face' | 'feature';
+/**
+ * Every feature a click on `region` reads, in Feature mode, as a choice offers them: the most
+ * specific first — fewest regions, then by tag — and profiles (`isFallback`) last, offered but never
+ * the default. Owners of exactly the same regions are one.
+ */
+declare const featuresAt: (region: number, features: ReadonlyArray<CoverageFeature>) => Array<CoverageFeature>;
+/** What a click took: the feature it means, in Feature mode, and the regions. */
+interface IgnoredAs {
+    tag: string | null;
+    regions: ReadonlyArray<number>;
+}
+/**
+ * What a click on `region` takes, by mode: the region clicked; in Face mode every region of the CAD
+ * face it was split from (`faceRegions`, the kernel's `splitOrigin` lineage); in Feature mode the
+ * regions of the feature the click means (`featureAt`), the region alone where no feature does.
+ * What a click acts on and what the pointer lights, alike.
+ */
+declare const ignoreSelection: ({ region, mode, features, regions, }: {
+    region: number;
+    mode: IgnoreMode;
+    features: ReadonlyArray<CoverageFeature>;
+    /** The part's regions, with the CAD face each was split from. */
+    regions: ReadonlyArray<SplitRegion>;
+}) => IgnoredAs;
+/**
+ * What a group of regions is called — a tray row, a status note: its region ids, ascending.
+ * "Region 4", or "Regions 4, 6" for a feature's regions. Never a feature's name.
+ */
+declare const regionLabel: (regions: ReadonlyArray<number>) => string;
+/** The plan with a click's regions ignored as `saved` had them, and nothing else changed. */
+declare const takeBackIgnore: (plan: Constraints, saved: Constraints, regions: ReadonlyArray<number>, context: Pick<PlanRules, "kernel">) => Constraints;
+/** What a click on the part does while ignoring (`ignoreClick`). */
+type IgnoreClick = 
+/** The region was ignored: the ignored regions among those taken are let go. */
+{
+    kind: 'unignore';
+    regions: Array<number>;
+}
+/** What the click takes is ignored. */
+ | {
+    kind: 'ignore';
+    regions: Array<number>;
+};
+/**
+ * What a click on region `region`, taking `regions` (`ignoreSelection`), does while ignoring:
+ * ignored, the ignored regions among those taken are let go; otherwise they are ignored.
+ */
+declare const ignoreClick: ({ region, ignored, regions, }: {
+    region: number;
+    /** The regions ignored now. */
+    ignored: ReadonlySet<number>;
+    /** The regions the click takes: the CAD face clicked, or a feature's faces. */
+    regions: ReadonlyArray<number>;
+}) => IgnoreClick;
+
+/**
+ * One edit to a plan's constraints: its setups, folders, pins and ignored faces. Every id an action
+ * names for something it makes must be new to the draft, even where the edit ends up not needing it;
+ * ids from `crypto.randomUUID()` are.
+ * `direction` on a feature is the direction that reading of it was read from, as the part's
+ * features name it: the package can't check it.
+ */
+type DraftAction = 
+/**
+ * A folder inside another, at the end (`addFolder`). `id` is the new folder's; `workId` is for the
+ * folder the parent's own work moves into, where the parent held no folders yet.
+ */
+{
+    kind: 'addFolder';
+    parentId: string;
+    id: string;
+    workId: string;
+} | {
+    kind: 'renameFolder';
+    id: string;
+    name: string;
+}
+/**
+ * What Delete removes: folders — setups too — with all they hold, and pinned features, each taken
+ * out of the folder named (`setupId`). With every setup named, it is Remove all: Toolpath plans the
+ * part as it would. Folders gone already are passed over.
+ */
+ | {
+    kind: 'remove';
+    folders: ReadonlyArray<string>;
+    features?: ReadonlyArray<PinnedFeature>;
+}
+/**
+ * A folder dropped somewhere in the tree (`moveFolder`). `newId` is for the parent made to hold
+ * both, where it is dropped on a folder holding work.
+ */
+ | {
+    kind: 'moveFolder';
+    id: string;
+    to: Landing;
+    newId: string;
+}
+/** A folder moved `by` whole places up (negative) or down among the folders beside it. */
+ | {
+    kind: 'moveWithin';
+    id: string;
+    by: number;
+}
+/** A setup facing a direction no setup or tool orientation faces yet, last. */
+ | {
+    kind: 'addSetup';
+    direction: PlanDirection;
+    id: string;
+}
+/** Hold a setup 3+1 or 3+2, or 3 axis (`null`). */
+ | {
+    kind: 'setProcess';
+    setupId: string;
+    process: SetupProcess | null;
+}
+/** Make a folder a tool orientation facing `direction`, or follow its parent again (`null`). */
+ | {
+    kind: 'setToolOrientation';
+    folderId: string;
+    direction: PlanDirection | null;
+}
+/**
+ * A click on the part in an open folder (`folderClick`), or a pin into a folder named (`pinEdit`):
+ * the feature pinned there — or, pinned there already, taken out. `newId` is for the folder a pin
+ * goes in, where the folder named holds folders.
+ */
+ | {
+    kind: 'pinInto';
+    tag: string;
+    direction: PlanDirection;
+    folderId: string;
+    newId: string;
+}
+/**
+ * Machine a feature from its direction (`pinEdit`): pinned in the folder facing that way, or in a
+ * new setup facing it — or, pinned in that direction's folders already, let go. `newId` is that
+ * setup's, or the folder's a pin into a parent makes.
+ */
+ | {
+    kind: 'pinFrom';
+    tag: string;
+    direction: PlanDirection;
+    newId: string;
+}
+/**
+ * A feature's row dropped on a folder (`moveFeature`): pinned there, or in the first folder in it
+ * cut from its direction, as any pin is (`withPin`). `newId` is for a folder made to hold it, where
+ * it is dropped on a parent.
+ */
+ | {
+    kind: 'moveFeature';
+    tag: string;
+    direction: PlanDirection;
+    folderId: string;
+    newId: string;
+}
+/**
+ * A pick among the features a click in a folder read (`chooseReading`): `reading` meant instead of
+ * `tag`, which the click pinned (`target: 'pin'`) or took out (`'takeOut'`) in `folderId`. Where
+ * the click's edit no longer stands — Undo, Discard — it is made again first, in the same step.
+ * `readings` are every feature the click read. Needs the plan as applied. A folder gone since
+ * — Undo — changes nothing.
+ */
+ | {
+    kind: 'choosePinReading';
+    tag: string;
+    target: 'pin' | 'takeOut';
+    reading: string;
+    readings: ReadonlyArray<string>;
+    folderId: string;
+}
+/**
+ * A pick among the features an Ignore click read: `tag` ignored instead of what the click took
+ * (`click`, as `ignoreSelection` answers it), whose faces go back as applied where its edit still
+ * stands. The click's own feature, its edit standing, changes nothing. Needs the plan as applied.
+ */
+ | {
+    kind: 'chooseIgnoreReading';
+    tag: string;
+    click: IgnoredAs;
+}
+/**
+ * Start from Toolpath's plan, on a plan with no folders: folders facing each of its setups
+ * (`foldersFromPlan`), and with `pins` every feature pinned where it was planned
+ * (`planFromResults`), its faces no longer ignored. New folders' ids are `idSeed`, `-` and a count: no `:`, which
+ * an app may use to join an id with other keys.
+ */
+ | {
+    kind: 'fromPlan';
+    planned: ReadonlyArray<PlannedSetup$1>;
+    pins: boolean;
+    idSeed: string;
+}
+/** Let a pinned feature go: Toolpath decides again where it is machined. */
+ | {
+    kind: 'unpin';
+    tag: string;
+}
+/** Ignore faces: region indices, in the kernel `PlanRules` names. */
+ | {
+    kind: 'ignore';
+    regions: ReadonlyArray<number>;
+} | {
+    kind: 'unignore';
+    regions: ReadonlyArray<number>;
+};
+type DraftActionKind = DraftAction['kind'];
+/** Every kind of action, in the order `actionsFor` lists them. */
+declare const DRAFT_ACTION_KINDS: ReadonlyArray<DraftActionKind>;
+/**
+ * What an action did beyond the draft, for the page to say: what Toolpath's own app puts on its
+ * status line. Empty lists and `false` where there is nothing to say.
+ */
+interface DraftFacts {
+    /** A pin's: the person's pins it let go, because it covers every face of each. By tag. */
+    replaced: ReadonlyArray<string>;
+    /**
+     * Faces ignored before the action and not after, ascending: what a pin, `fromPlan` with pins and
+     * `unignore` give back. A pick among an Ignore click's readings says only what it ignores, so
+     * the faces it gives back are not here. Toolpath's own app says these after every kind but Clear
+     * (`unignore` of every ignored face), where it says nothing.
+     */
+    unignored: ReadonlyArray<number>;
+    /** An ignore's: the pins it let go, each with the folder it was in. */
+    unpinned: ReadonlyArray<PinnedFeature>;
+    /** A pin's: a setup was added for it, facing its way. */
+    added: boolean;
+    /** A pin's: it was pinned there already, and is now let go. */
+    letGo: boolean;
+    /** A pin's: the folder it is pinned in, or was let go from — what its note names. */
+    home: string | null;
+}
+/**
+ * What an action made of the draft, or why it can't be made. `folderId` is the folder Toolpath's own
+ * app opens after it: the one `addFolder`, `addSetup` or `moveFolder` made or moved, or the one a
+ * `moveFeature` row lands in. After any other action the open folder stays open. After `remove` the
+ * page chooses: Toolpath's own app opens the nearest folder the open one was in, or the part.
+ */
+type DraftResult<T extends Constraints> = {
+    draft: T;
+    folderId?: string;
+    facts: DraftFacts;
+} | {
+    refused: string;
+};
+/**
+ * Carry out one action on a draft: the draft after it, every other part of it as it was, or why it
+ * can't be made. `rules` reads the part: a feature's faces, and the kernel that numbers them.
+ *
+ * A pin is what pinning is in Toolpath's own app: the person's pins it covers are let go, and its
+ * faces are no longer ignored; pinning a feature where it is pinned already lets it go, as a click
+ * there does. Ignoring faces lets go of every pin they cover. An unpin of what is pinned nowhere, and
+ * a reorder past the end, change nothing. Where the functions in `plan-draft` would quietly change
+ * nothing — a folder too deep, a folder gone — this refuses, saying why. `saved`, the plan as
+ * applied, is what the two picks among a click's readings put back; `planSession` passes it.
+ */
+declare const applyDraftAction: <T extends Constraints>(draft: T, action: DraftAction, rules: PlanRules, saved?: Constraints) => DraftResult<T>;
+/** What a page asks `actionsFor` about: what the person clicked, or picked. */
+type ActionTarget = 
+/** The part itself: the tree's top row. */
+{
+    part: true;
+}
+/** A setup or a folder, by id. */
+ | {
+    folder: string;
+}
+/** One direction's reading of a feature: its tag, and the direction it is read from. */
+ | {
+    feature: string;
+    direction: PlanDirection;
+}
+/** Faces picked on the part: region indices, in the kernel `rules` names. */
+ | {
+    faces: ReadonlyArray<number>;
+};
+/**
+ * What can be done to this, as the draft stands: the kinds of action `applyDraftAction` would make
+ * here, in `DRAFT_ACTION_KINDS` order. A page offers these and no others. An action named here can
+ * still be refused for its details — a drop on one folder or another — and says why when it is.
+ * Three kinds follow other controls and are never named here: `choosePinReading` and
+ * `chooseIgnoreReading`, offered where a click read more than one feature, and `fromPlan`, offered
+ * while the plan holds no folders and Toolpath has planned the part.
+ */
+declare const actionsFor: (draft: Constraints, target: ActionTarget, rules: Pick<PlanRules, "kernel">) => Array<DraftActionKind>;
+
+/**
+ * The tree's part row: its key, its drop target's id, and as the page's open id the part active, its
+ * summary shown. No folder has it as an id.
+ */
+declare const PART_ROW = "part";
+/**
+ * What the page's `openId` holds while Ignore is open: not a folder, but held for its Save as one
+ * is, and left the same way. No folder has it as an id.
+ */
+declare const IGNORE = "ignore";
+/** One feature a direction takes: its tag, and its type and label from the part's analysis. */
+interface PlanFeatureRow {
+    tag: string;
+    label: string;
+    /** The Engine's feature type (`blind_hole`, `open_pocket`), which its icon is drawn from. */
+    type?: string;
+    /** A hole's bore, once its sheet is in: what holes of a type are grouped by. */
+    bore?: FeatureBore;
+}
+/** A hole's bore: its diameter in millimetres, and as the page says it (`⌀6.35 mm`). */
+interface FeatureBore {
+    diameter: number;
+    label: string;
+}
+/** A feature type as a group of them is headed: `blind_hole` → `Blind holes`, `boss` → `Bosses`. */
+declare const featureTypePlural: (type: string | undefined) => string;
+/** Whether a feature type is a hole, whose rows are grouped again by their bore. */
+declare const isHoleType: (type: string | undefined) => boolean;
+/**
+ * A group of a folder's rows under one header: the features of one type — and, inside a hole
+ * type's, those of one bore. Only a way of listing them: each row is still pinned, taken out and
+ * carried on its own, and nothing is dropped on a group.
+ */
+interface FeatureGroupView {
+    /** Unique within the folder: what its fold is remembered by. */
+    key: string;
+    /** A type's group, or a bore's inside a hole type's. */
+    level: 'type' | 'bore';
+    type: string | undefined;
+    label: string;
+    /** The rows listed straight under it: a hole type's with no bore read yet, after its bores. */
+    rows: Array<PlanFeatureRow>;
+    /** A hole type's bores, smallest first. */
+    groups: Array<FeatureGroupView>;
+    /** Every tag in it, in the order listed: what taking the group out takes. */
+    tags: Array<string>;
+}
+/**
+ * A folder's rows as the tree lists them: a group per feature type, in the order its first row was
+ * pinned, each row in its pinned order — and a hole type's rows grouped again by bore, smallest
+ * first, any with no bore read yet after them. A row of no type read yet is under Other.
+ */
+declare const featureGroups: (rows: ReadonlyArray<PlanFeatureRow>) => Array<FeatureGroupView>;
+/** One direction of a setup — the way the tool points — with the features cut from it. */
+interface PlanOrientationView {
+    id: string;
+    direction: PlanDirection;
+    /** Its place among the part's candidate directions, which is its colour; -1 when not one. */
+    directionIndex: number;
+    features: Array<PlanFeatureRow>;
+}
+/**
+ * A folder as the tree shows it — a setup at the top, the folders inside it below. Its one
+ * orientation is the direction it is cut from and the rows in it.
+ */
+interface PlanSetupView {
+    id: string;
+    name: string;
+    /** A setup's hold: `3 axis` from one direction, `3+1` / `3+2` turning the part to tilts. */
+    process: '3axis' | '3+1' | '3+2';
+    orientations: Array<PlanOrientationView>;
+    /** 0 for a setup. */
+    depth: number;
+    /** The setup it is in (itself for a setup), and the folder it is in, if any. */
+    setupId: string;
+    parentId: string | null;
+    /** A tilt of its own inside an indexed setup. */
+    toolOrientation: boolean;
+    /** Whether it faces its own direction — a setup or tool orientation — rather than following. */
+    isFrame: boolean;
+    folders: Array<PlanSetupView>;
+}
+/** A setup of Toolpath's plan, as `planView` lays it out: its rows, and what it left uncut. */
+interface PlannedSetupView extends PlanSetupView {
+    /** Features the setup was meant to machine that no pass in it does. */
+    notMachined: Array<PlanFeatureRow>;
+    /**
+     * Of those, the ones a pass in it does cut, but short: roughed, and owed a finish no pass gives
+     * (`notFinishedIn`). The rest are not machined at all.
+     */
+    notFinished: Array<string>;
+    operations: number;
+}
+/** Every folder of the tree, in tree order. */
+declare const allFolders: <T extends PlanSetupView>(views: ReadonlyArray<T>) => Array<T>;
+/** A folder's rows as the tree lists them. */
+declare const rowsOf: (folder: PlanSetupView) => Array<PlanFeatureRow>;
+/** Whether a folder lists a feature among its rows, its tag spelled in any case. */
+declare const listsTag: (folder: PlanSetupView, tag: string) => boolean;
+/** A folder's name with the folders it is in: `Folder 1 › Side`. */
+declare const folderPath: (setups: ReadonlyArray<PlanSetupView>, folderId: string) => string;
+/** What the view needs to know about the part: which candidate a direction is, and what a tag is. */
+interface PlanPart {
+    directionIndex: (direction: PlanDirection) => number;
+    featureLabel: (tag: string) => string;
+    /** The Engine's type for a tag, when the part's analysis has read it. */
+    featureType?: (tag: string) => string | undefined;
+    /** A hole's bore, once its sheet is in. */
+    featureBore?: (tag: string) => FeatureBore | undefined;
+}
+
+/**
+ * The plan's setups, each with every direction it is machined from.
+ *
+ * The plan's own statement (`setupPlan`) says both, and is what a plan is edited from. An Engine
+ * that does not serve one (before API 1.19) gives each setup only its first direction, so the
+ * features are read off its passes instead: every tag an action cuts, in machining order.
+ */
+declare const planView: (plan: Pick<EnginePlan, "setups" | "setupPlan">, part: PlanPart) => Array<PlannedSetupView>;
+/**
+ * A plan's count of holds and of the directions they are machined from (FLD60): a setup is one
+ * hold — an indexed one however many tilts it turns to, a 3 axis one however its work is grouped —
+ * and each direction a frame is cut from is one orientation.
+ */
+declare const planCounts: (setups: ReadonlyArray<PlanSetupView>) => {
+    setups: number;
+    orientations: number;
+};
+/** A colour on one feature, and how strongly — the viewer's `FeatureHighlight` (the DFM view's paint). */
+interface PlanHighlight {
+    tag: string;
+    color: number;
+    weight: number;
+}
+/** A colour on one face, and how strongly it covers the surface — the viewer's `RegionHighlight`. */
+interface FacePaint {
+    region: number;
+    color: number;
+    weight: number;
+}
+/** The colour ignored faces are painted, and Ignore's mark: slate — finished, so left alone. */
+declare const DONE_COLOR = 6583435;
+/** The red the faces nothing machines are painted, on every part viewer. */
+declare const UNMACHINED_FACE_COLOR = 14427686;
+/**
+ * With a folder open, what only the others take: a dark neutral gray under their hatching (Tailwind
+ * neutral-600), darker than ignored faces' slate, which is lighter and blue.
+ */
+declare const OTHER_FOLDER_COLOR = 5395026;
+/** What the paint and the hatches read of the plan: which folder is open, and who lists each feature. */
+interface PlanPaintInput {
+    faces: Coverage['faces'];
+    setups: ReadonlyArray<PlanSetupView>;
+    /** A folder's id; `PART_ROW` or `IGNORE`, no folder open. */
+    openId: string;
+    colorOf: (orientation: PlanOrientationView) => number;
+    /** Direction colours on: every folder paints. Off, only the open folder and its insides. */
+    everyFolder?: boolean;
+}
+/**
+ * The model's colouring, face by face, as `classifyFaces` reads the plan — the one rule for what
+ * machines each face, in either view. A pinned face takes its folder's colour in full, and so does
+ * a face Toolpath machines, its setup's; an ignored face is slate (`DONE_COLOR`); an open face —
+ * left to Toolpath — is left bare; a Not machined face red (`UNMACHINED_FACE_COLOR`). With no folder
+ * open every folder paints, with secondary colours hatched on shared faces; with one open, only
+ * its own direction does — it and the folders inside it facing the same way (FLD59). Every other
+ * direction, inside it or not, is a dark gray
+ * (`OTHER_FOLDER_COLOR`) with no tint of its own, hatched in its colour over the part
+ * (`planHatch`). With direction colours off (MAP73), only the open folder's direction paints.
+ */
+declare const planPaint: ({ uncovered, ...input }: PlanPaintInput & {
+    /** Paint what no folder covers — Not machined red. Off where the DFM flags paint. */
+    uncovered?: boolean;
+}) => Array<FacePaint>;
+/** Diagonal lines across one face, in one colour: the viewer canvas's `RegionHatch`. */
+interface FaceHatch {
+    region: number;
+    color: number;
+}
+/**
+ * With a folder open, what the other directions take, as lines across the part rather than paint:
+ * each face a feature of another direction includes — another folder's, or a tilt inside the open
+ * one — is hatched in that direction's colour, over the gray, or over the open folder's own colour
+ * where it takes the face too, so a face touched from more than one direction shows each. With no
+ * folder open, the first owner's colour paints the face (`planPaint`), and the remaining colours
+ * are hatched over it. A colour once per face. Nothing with direction colours off.
+ */
+declare const planHatch: (input: PlanPaintInput) => Array<FaceHatch>;
+/**
+ * The draft as the page lays it out: its folders, in its order and with its names, each listing
+ * what is pinned in it in the order it was pinned (MP-5). Nothing of Toolpath's: the constraints,
+ * and only those.
+ */
+declare const draftView: (draft: Pick<Constraints, "setups">, part: PlanPart) => Array<PlanSetupView>;
+/**
+ * The statements Toolpath refused of a stated plan, one per clause, from the error its job failed
+ * with — or null when the job failed for some other reason. Toolpath lists the first few and says
+ * how many more; that tail is kept as a clause of its own.
+ */
+declare const refusalClauses: (error: string | null) => Array<string> | null;
+
+/**
+ * Where it would land (MAP48): on a folder's row, before it, inside it or after it — the top, middle
+ * and bottom of the row — or on the part's row, first or last among the setups.
+ */
+type DropAt = {
+    id: string;
+    zone: 'before' | 'inside' | 'after';
+} | {
+    id: typeof PART_ROW;
+    zone: 'first' | 'last';
+};
+/** A folder as the list shows it: where it sits, and how many levels of folders it holds. */
+interface FlatFolder {
+    id: string;
+    parentId: string | null;
+    depth: number;
+    /** Levels of folders below it, which go where it goes: 0 for one with none inside. */
+    height: number;
+}
+interface FolderLike {
+    id: string;
+    parentId: string | null;
+    depth: number;
+    folders: ReadonlyArray<FolderLike>;
+}
+/**
+ * The folders shown, in tree order: a folder's own inside it only while it is open. The carried
+ * folder's are left out — they travel with it — so the list is what it can be dropped among.
+ */
+declare const flattenFolders: (setups: ReadonlyArray<FolderLike>, isOpen: (id: string) => boolean, carriedId?: string | null) => Array<FlatFolder>;
+/** Where the carried folder would land: its depth, the folder it would be in, and the drop. */
+interface Projection {
+    depth: number;
+    parentId: string | null;
+    /** The tree's drop for that place; null where it would land where it already is. */
+    at: DropAt | null;
+}
+/**
+ * Where a carried folder would land in the gap `gap` of the list without it — 0 before the first
+ * folder, 1 after it, and so on — dragged `offsetX` sideways. Its depth is its own plus a level for
+ * every `indent` dragged right, kept to what the place allows: no deeper than one below the folder
+ * before it, no shallower than the one after it — and no deeper than the plan allows with the
+ * folders it carries.
+ */
+declare const projectFolder: (items: ReadonlyArray<FlatFolder>, activeId: string, gap: number, offsetX: number, indent: number, maxDepth: number) => Projection | null;
+/** The gap a point is in: how many of the folders' rows, without the carried one, it is below. */
+declare const gapAt: (centres: ReadonlyArray<{
+    id: string;
+    centreY: number;
+}>, activeId: string, y: number) => number;
+
+/**
+ * Why a feature is left: Toolpath gave it to a setup whose passes leave it (`planned`); left it out of
+ * every setup (`leftOut`, with a setup facing its way, if one does); no feature includes the face; or
+ * a pass roughs it but none finishes it (`notFinished`). Setups by index.
+ */
+type NotMachinedWhy = {
+    kind: 'planned';
+    setup: number;
+} | {
+    kind: 'leftOut';
+    setup: number | null;
+} | {
+    kind: 'noFeature';
+} | {
+    kind: 'notFinished';
+    setup: number;
+};
+/**
+ * The one reason a list leads with: what the feature's own flag says of the tool or the corner,
+ * as the more telling, else what the plan did with it.
+ */
+type NotMachinedReason = NotMachinedWhy['kind'] | 'library' | 'sharpCorner';
+/**
+ * Each reason in a few words, for a chip or a count: `2 · not planned`. What happened, not a cause
+ * the plan never gave: Toolpath says which features it leaves, not why.
+ */
+declare const REASON_SHORT: Record<NotMachinedReason, string>;
+/** A reason said in full: its few words, then what it means here — `Not planned: in no setup`. */
+declare const reasonLine: (reason: NotMachinedReason, detail: string) => string;
+/** A feature (or a face no feature includes) the plan leaves, as the DFM check stores it. */
+interface NotMachinedFeature {
+    /** Null for a face no feature includes. */
+    tag: string | null;
+    /** The analysis's feature type, `blind_hole`; absent for a face no feature includes. */
+    type?: string;
+    /** The faces left, and their area (mm²). */
+    regions: Array<number>;
+    area: number;
+    why: NotMachinedWhy;
+    /** Its machining direction. */
+    direction?: PlanDirection;
+    /** For a hole: its bore and depth, mm. */
+    hole?: {
+        diameter: number;
+        depth: number;
+    };
+}
+/** A setup as Toolpath plans it: enough to say why a feature is left. */
+interface PlannedSetup {
+    idx?: number;
+    direction?: PlanDirection | null;
+    unmachined?: ReadonlyArray<string> | null;
+    actions: ReadonlyArray<{
+        featureTags?: ReadonlyArray<string> | null;
+    }>;
+}
+/** A direction looking up at the part: work cut from below. */
+declare const isFromBelow: (direction: PlanDirection | null | undefined) => boolean;
+/** Why a feature nothing machines is left. */
+declare const whyOf: (tag: string | null, setups: ReadonlyArray<PlannedSetup>, direction: PlanDirection | null) => NotMachinedWhy;
+/** What a setup roughs but no pass finishes: on its `unmachined` list, yet one of its passes cuts it. */
+declare const notFinishedIn: (setup: PlannedSetup) => Array<string>;
+/** Every feature a plan roughs but never finishes, each once, with the first setup that roughs it. */
+declare const notFinishedOf: (setups: ReadonlyArray<PlannedSetup>) => Array<{
+    tag: string;
+    setup: number;
+}>;
+/** The reason in words, given what names a setup — or none, where the list already says where. */
+declare const whyText: (why: NotMachinedWhy, setupName?: (setup: number) => string | null) => string;
+
+/** What a pin needs to know of the part. */
+type PinContext = PlanRules;
+/**
+ * The person's pins a new pin of `tag` replaces: each one, in any folder, whose every face it covers
+ * — another direction's reading of those faces, or a smaller feature inside it. One it only overlaps
+ * stays.
+ */
+declare const replacedBy: (setups: ReadonlyArray<DraftSetup>, tag: string, regionsOf: (tag: string) => ReadonlyArray<number>) => Array<PinnedFeature>;
+/**
+ * The plan with every face of `tags` no longer ignored, and those that were, ascending: what every
+ * way of pinning ends with, as a pinned feature is machined whole.
+ */
+declare const unignorePinned: (plan: Constraints, tags: ReadonlyArray<string>, context: PinContext) => {
+    intent: Constraints;
+    unignored: Array<number>;
+};
+/** What a pin did: the plan after it, where it went, the pins it replaced and the faces it un-ignored. */
+interface PinEdit {
+    intent: Constraints;
+    setupId: string;
+    /** A setup was added for it, facing its way. */
+    added: boolean;
+    /** It was pinned there already, and is now unpinned. */
+    unpinned: boolean;
+    replaced: Array<string>;
+    unignored: Array<number>;
+}
+/**
+ * Pin a feature into a folder, or into the one facing its direction (adding one where none does), or
+ * — pinned there already — unpin it. A new pin replaces the person's pins whose every face it
+ * covers. One edit.
+ */
+declare const pinEdit: (plan: Constraints, tag: string, 
+/** `newId` is for the folder a pin into a parent makes, or the setup a pin from a direction adds. */
+at: {
+    folderId: string;
+    newId?: string;
+} | {
+    direction: PlanDirection;
+    newId: string;
+}, context: PinContext) => PinEdit | {
+    refused: string;
+};
+/**
+ * The plan once `tag` is pinned where `pinned` (the setups with the pin made) has it: the person's
+ * pins it covers unpinned, and its faces no longer ignored (`unignorePinned`). What every way of
+ * pinning one feature ends with — `pinEdit`, and a row dropped in a folder.
+ */
+declare const withPin: (plan: Constraints, tag: string, pinned: ReadonlyArray<DraftSetup>, context: PinContext) => {
+    intent: Constraints;
+    replaced: Array<string>;
+    unignored: Array<number>;
+};
+/** What a click does to its feature: pin it in the folder, or take it out — unpinned. */
+type PinTarget = 'pin' | 'takeOut';
+/** What a click made of a feature since the plan was saved: pinned in the folder, or taken out. */
+interface PinChange {
+    tag: string;
+    target: PinTarget;
+}
+/**
+ * The plan with one line taken back: the feature as `saved` had it, and — where it is pinned since,
+ * or moved — the pins that pin replaced, and its faces ignored as `saved` had them. Every other
+ * edit stands.
+ */
+declare const takeBack: (plan: Constraints, saved: Constraints, tag: string, context: PinContext) => Constraints;
+/**
+ * What a click on the part in the open folder does, and what the status line says of it: a feature
+ * pinned in the folder is taken out — unpinned, left to Toolpath; any other is pinned there. (A
+ * click on the folder's tree row is the page's: it edits nothing, and only shows the feature.)
+ */
+declare const folderClick: (plan: Constraints, feature: {
+    tag: string;
+    label: string;
+    direction: PlanDirection;
+    /** Pinned in the folder. */
+    inFolder: boolean;
+}, folder: {
+    id: string;
+    name: string;
+}, context: PinContext) => {
+    intent: Constraints;
+    note: string;
+};
+/**
+ * A line's choice among the features its click read. On a pin: itself, or another pinned in its
+ * place. On a feature taken out: it stays out, and at most one other is pinned instead — choosing
+ * again, or choosing to take it out, lets the one before go. A feature that goes leaves the folder as
+ * a click takes it out: unpinned, never put back where it was before. Answers the plan, and the
+ * lines whose choice is made — a pin swapped away keeps its choice unmade, so undo brings it back
+ * to be made.
+ */
+declare const chooseReading: (plan: Constraints, saved: Constraints, line: PinChange, reading: string, 
+/** The features its click read, the line's among them. */
+read: ReadonlyArray<string>, folder: {
+    id: string;
+    direction: PlanDirection;
+}, context: PinContext) => {
+    intent: Constraints;
+    chosen: Array<string>;
+};
+/** A plan as a Pin features note reads it: every folder of the tree, and who machines each face. */
+interface PlanReading {
+    folders: ReadonlyArray<PlanSetupView>;
+    kindOf: (region: number) => CoverageKind;
+}
+/** A plan as a note reads it, from its folders and who machines each face (`classifyFaces`). */
+declare const readingOf: (folders: ReadonlyArray<PlanSetupView>, coverage: Coverage | null) => PlanReading;
+/**
+ * What a choice says of a feature beside its name: how many faces, the way it is cut where that is
+ * said, and where it is now (`stateOf`).
+ */
+declare const readingDetail: (faces: number, state: string, way?: string) => string;
+/** Where a feature is: in the glossary's words, and the folders that names. */
+interface FeatureState {
+    text: string;
+    folders: Array<string>;
+}
+/**
+ * Where a feature is in a plan, in the glossary's words, from the open folder (`folderId`): Pinned
+ * (in a folder, or part of a larger feature pinned there), Ignored, or Open. Read off its faces, so
+ * a feature inside another reads as that one's; faces in several folders name the first, and how
+ * many more.
+ */
+declare const stateOf: (tag: string, plan: PlanReading, folderId: string, regionsOf: (tag: string) => ReadonlyArray<number>) => FeatureState;
+/** A feature read from the open folder's direction, as its Pin features read it. */
+interface FolderFeature {
+    tag: string;
+    label: string;
+}
+
+/** One thing worth saying about the plan before it is sent. `blocking` stops it being sent. */
+interface PlanCheck {
+    tone: 'blocking' | 'warning' | 'info';
+    text: string;
+}
+/** What the checks know of the part: its analysis, and the kernel Toolpath last planned with. */
+interface CheckContext {
+    /** The part's directions: analyzed, detected, and being analyzed. `analyzed` is null before its model has been read. */
+    directions: DirectionsKnown;
+    /**
+     * A feature's type, label and the direction it is cut from, by tag — or null for a tag the part's
+     * model does not have.
+     */
+    feature: (tag: string) => {
+        type: string;
+        label: string;
+        direction?: PlanDirection;
+    } | null;
+    /** The kernel Toolpath's plan was made by, whose tags the pins have to be. */
+    kernelVersion: string | null;
+}
+/** What the checks read of a draft: its setups, and the kernel whose tags its pins name. */
+interface CheckedDraft extends Pick<Constraints, 'setups'> {
+    /** The kernel whose tags the pins name; null until something is pinned. */
+    kernelVersion: string | null;
+}
+/**
+ * What would stop Toolpath taking the plan as the person has stated it, and what is worth knowing
+ * before sending it: the rules its stated plan is held to (tp-kernel's `UserSetupPlan`), checked
+ * here where they can be, so the answer comes before the round trip rather than after it.
+ */
+declare const planChecks: (draft: CheckedDraft, context: CheckContext) => Array<PlanCheck>;
+/**
+ * One of Toolpath's refusal clauses in the person's own terms: its setup by the folder's name — setup
+ * `n` of the statement, counted from zero, is the draft's `n`th frame — and its features by their
+ * labels.
+ */
+declare const describeClause: (clause: string, draft: Pick<Constraints, "setups">, label: (tag: string) => string | null, tags: ReadonlyArray<string>) => string;
+/**
+ * Where a check's Show goes: the Not machined list, a folder and a feature in it, or one of
+ * Toolpath's setups in the Results view.
+ */
+type ShowTarget = {
+    kind: 'notMachined';
+} | {
+    kind: 'folder';
+    setupId: string;
+    tag?: string;
+} | {
+    kind: 'setup';
+    idx: number;
+};
+/** One line of the confirm checklist. `ok` says a check passed; the rest are as {@link PlanCheck}. */
+interface ConfirmCheck {
+    tone: PlanCheck['tone'] | 'ok';
+    text: string;
+    show?: ShowTarget;
+}
+/** What the confirm checklist looks at, beside the plan's own checks. */
+interface ConfirmContext {
+    /** The constraints as applied changed since Toolpath's results: the results are of an earlier version. */
+    changed: boolean;
+    /** How many features nothing in Toolpath's plan machines: null before known. */
+    notMachined: number | null;
+    /**
+     * Each of the person's folders that Toolpath plans a setup from, and whether the plan machines
+     * something in it, or in a folder inside it. Empty unless the results are of the current constraints.
+     */
+    folders: ReadonlyArray<{
+        id: string;
+        name: string;
+        machined: boolean;
+    }>;
+    /** Each setup of Toolpath's plan, with what it was meant to machine and no pass in it cuts. */
+    setups: ReadonlyArray<{
+        /** Its place in the plan: where Show goes. */
+        idx: number;
+        notMachined: Array<string>;
+        /** Of `notMachined`, what a pass roughs but none finishes. */
+        notFinished: Array<string>;
+    }>;
+}
+/**
+ * Whether the constraints changed since Toolpath's results: only with results to have changed
+ * from — a part never planned has none. The Results banner's rule and
+ * the checklist's, one place.
+ */
+declare const changedSinceResults: (changed: boolean, setups: number) => boolean;
+/**
+ * The checklist a move out of Plan shows: what stops the part moving on, what is worth a look
+ * first — each with where to look — and what is fine. The plan's own checks come first.
+ */
+declare const confirmChecks: (own: ReadonlyArray<PlanCheck>, context: ConfirmContext) => Array<ConfirmCheck>;
+/** Every line passed: the move goes straight on without asking. */
+declare const allClear: (checks: ReadonlyArray<ConfirmCheck>) => boolean;
+
+/** How many steps Undo reaches back through. */
+declare const HISTORY = 100;
+/**
+ * A page's edits to a plan. `D` is what an edit changes and Undo puts back: the constraints, and any
+ * fields of the app's own held with them (a material, a stock). Keep save stamps, such as a version
+ * or a time, out of it: Undo would put an old one back.
+ */
+interface PlanSession<D extends Constraints> {
+    /** The draft as applied: what the edits are measured from, and what Discard puts back. */
+    saved: D;
+    /** The draft as edited here. */
+    draft: D;
+    /** The drafts Undo goes back to, oldest first: what was done, in order. */
+    past: ReadonlyArray<D>;
+    /** The drafts Redo goes forward to, next first. */
+    future: ReadonlyArray<D>;
+    /** The run of edits joined as one step (`coalesce`): its key, and the draft before it. */
+    run: {
+        key: string;
+        before: D;
+    } | null;
+    /** Why the last action was refused, to show the person; null when it was not. */
+    refused: string | null;
+    /** The folder to open after the last action (`DraftResult`'s `folderId`); null for none. */
+    folderId: string | null;
+    /** What the last action did beyond the draft, for the page to say (`DraftFacts`); null for none. */
+    facts: DraftFacts | null;
+    /** The save version of `saved`, where the app has one: an older plan read is not taken. */
+    version: number | null;
+}
+/**
+ * A draft's own fields beside the constraints: what an `edit` changes (a material, a stock). The
+ * constraints change only through actions.
+ */
+type AppFields<D extends Constraints> = Partial<Omit<D, keyof Constraints>>;
+/**
+ * Everything a session can be told. Edits with the same `coalesce` key, one after another, are one
+ * step — the changes made while a stock editor is open, say. Any other edit, Undo or Redo ends the
+ * run.
+ */
+type SessionEvent<D extends Constraints> = 
+/**
+ * A plan action, carried out by `applyDraftAction` on the draft as it is now, with the plan as
+ * applied: every change to the setups, folders, pins and ignored faces.
+ */
+{
+    type: 'act';
+    action: DraftAction;
+    coalesce?: string;
+}
+/**
+ * The app's own fields (`AppFields`: a material, a stock), as one step. `change` is given the draft
+ * as it is now, so two edits in a row build on each other, and answers the fields it changes. It
+ * must be pure: React may call it twice. The constraints never change here: any it answers are
+ * passed over.
+ */
+ | {
+    type: 'edit';
+    change: (draft: D) => AppFields<D>;
+    coalesce?: string;
+} | {
+    type: 'undo';
+} | {
+    type: 'redo';
+}
+/** Put the draft back as applied: one step, which Undo takes back. */
+ | {
+    type: 'discard';
+}
+/**
+ * Apply saved `sent`, as `version` where the app counts saves. It is the draft as applied now; an
+ * edit made while it saved stays held.
+ */
+ | {
+    type: 'applied';
+    sent: D;
+    version?: number;
+}
+/**
+ * The draft as applied, read again: after another tab applied, or Toolpath made a new plan. With
+ * nothing held, the draft follows it; with edits held, they stay (`SessionRules.rebase`). A read
+ * whose `version` is older than the session's — answered after an Apply moved on — is not taken.
+ */
+ | {
+    type: 'read';
+    saved: D;
+    version?: number;
+};
+/** What a session needs to know of the part and the app. */
+interface SessionRules<D extends Constraints> extends PlanRules {
+    /** The plan can't be changed now: no edit, Undo, Redo or Discard changes the draft. */
+    locked?: boolean;
+    /**
+     * Whether two drafts are the same plan: an edit to the same plan is no step. Default: the same
+     * values, whatever the order of each object's keys.
+     */
+    same?: (a: D, b: D) => boolean;
+    /**
+     * The edits held, onto a draft applied since (`now`), from the one they were made on (`was`).
+     * Default: the constraints stay as held; each other field stays as held where it was edited here,
+     * and follows `now` where it was not.
+     */
+    rebase?: (held: D, was: D, now: D) => D;
+}
+/**
+ * A session on the draft as applied, at its save `version` if the app counts saves, with `held` —
+ * edits kept from before a reload — if any.
+ */
+declare const startSession: <D extends Constraints>(saved: D, { held, version }?: {
+    held?: D;
+    version?: number;
+}) => PlanSession<D>;
+/** Whether edits are held: the draft is not the plan as applied. What Apply and Discard need. */
+declare const isHeld: <D extends Constraints>(session: PlanSession<D>, rules?: Pick<SessionRules<D>, "same">) => boolean;
+/** Whether Undo would change the draft: a step to go back to, on a plan that can be changed. */
+declare const canUndo: (session: PlanSession<Constraints>, rules?: Pick<SessionRules<Constraints>, "locked">) => boolean;
+/** Whether Redo would change the draft: a step to go forward to, on a plan that can be changed. */
+declare const canRedo: (session: PlanSession<Constraints>, rules?: Pick<SessionRules<Constraints>, "locked">) => boolean;
+/**
+ * The session after `event`: the one function that moves it on. It answers the session as it was
+ * when the event changes nothing, so React draws nothing new. A refused action changes no draft and
+ * says why in `refused`.
+ *
+ * ```ts
+ * const [session, send] = useReducer(
+ *   (now: PlanSession<Draft>, event: SessionEvent<Draft>) => planSession(now, event, rules),
+ *   saved,
+ *   startSession,
+ * )
+ * ```
+ */
+declare const planSession: <D extends Constraints>(session: PlanSession<D>, event: SessionEvent<D>, rules: SessionRules<D>) => PlanSession<D>;
+
+/** A row's red mark: nothing cuts it, or a pass roughs it but none finishes it (MP-22). */
+type UnmachinedMark = false | 'notMachined' | 'notFinished';
+/** One feature a setup takes: what cuts it, and whether it is left short. */
+interface ResultsFeatureRow extends PlanFeatureRow {
+    /** The tools whose passes cut it, each once; null where none does. */
+    tool: string | null;
+    mark: UnmachinedMark;
+}
+/** A setup of Toolpath's plan, as the Results tree lists it. */
+interface ResultsSetupView extends PlannedSetupView {
+    /** Its place in the plan: `plan.setups[idx]`. */
+    idx: number;
+    /** Each feature it takes once, in the order its orientations list them. */
+    rows: Array<ResultsFeatureRow>;
+    /** The constraint frame it was planned from — one facing a way it is cut from — or null for one Toolpath added. */
+    fromFolder: string | null;
+}
+interface ResultsView {
+    setups: Array<ResultsSetupView>;
+    /** Constraint frames no setup was planned from: nothing to machine from there, so left out. */
+    leftOut: Array<{
+        folderId: string;
+        name: string;
+    }>;
+}
+/**
+ * Toolpath's plan laid out for the Results view. A setup takes the name of the first constraint
+ * frame facing a direction it is cut from — a tilt's, with its setup's (`Setup 1 › Tilt`) — else
+ * `Setup N`; the frames no setup faces are `leftOut`. The frames are the constraints the plan is
+ * of, as applied: with none (edits held, or the plan of an earlier version) nothing is named and
+ * nothing is left out.
+ */
+declare const resultsView: ({ plan, constraints, part, }: {
+    plan: EnginePlan | null;
+    /** The applied constraints the plan is of; null where it is not of the constraints as applied. */
+    constraints: Pick<Constraints, "setups"> | null;
+    part: PlanPart;
+}) => ResultsView;
+/** The setup a feature is machined in, by tag in any case: the first listing it, or null. */
+declare const setupOf: (setups: ReadonlyArray<ResultsSetupView>, tag: string) => ResultsSetupView | null;
+
+/**
+ * A JSON-shaped value with every object's keys sorted, at every depth: what makes two equal values
+ * stringify alike. (A replacer array would sort the top level, but also drop every nested key not in
+ * it — a rule's `time` would read `{}` and a changed factor would change nothing.)
+ */
+declare const sortedKeys: (value: unknown) => unknown;
+/** Whether two JSON-shaped values are the same, whatever the order of their properties. */
+declare const sameJson: (a: unknown, b: unknown) => boolean;
+
+/**
+ * The one place a physical value is turned from what we store into what a person reads.
+ *
+ * Units are a display preference, never a data one. Everything an app persists or sends is metric —
+ * lengths in millimetres, density in kg/m³, weight in kilograms — the same system the Engine
+ * speaks. These functions convert *for the screen only*, into whichever system the reader has
+ * chosen; nothing here is written back. Kept pure and free of React so the conversions can be
+ * tested as arithmetic.
+ *
+ * Metric is the identity, so a value passes through unchanged in `mm` and is converted only for a
+ * reader who has asked for `in`.
+ */
+
+type Units = 'in' | 'mm';
+declare const isUnits: (value: unknown) => value is Units;
+
+/**
+ * A length in millimetres — a tool diameter, a cut length, a step, a stock edge.
+ *
+ * Millimetres to three decimals, inches to four: an inch reading is a tenth the count of a millimetre
+ * one, so it needs the extra place to tell a chip load of 0.02" from 0.025".
+ */
+declare const formatLength: (mm: number, units: Units) => string;
+/** A part or stock size in millimetres, as `50.8 x 38.1 x 12.7 mm` / `2 x 1.5 x 0.5 in`. */
+declare const formatDimensions: (sizeMm: {
+    length: number;
+    width: number;
+    height: number;
+}, units: Units, shape?: "box" | "cylinder") => string;
+/** An area in mm², as `125.5 mm²` / `0.195 in²`. */
+declare const formatArea: (mm2: number, units: Units) => string;
+/** A feed rate in mm/min. */
+declare const formatFeed: (mmPerMin: number, units: Units) => string;
+/** A surface speed figured in m/min; imperial reads it as SFM (surface feet per minute). */
+declare const formatSurfaceSpeed: (mPerMin: number, units: Units) => string;
+/** A stock weight in kilograms, as `0.8 kg` / `1.76 lb`. */
+declare const formatWeight: (kg: number, units: Units) => string;
+/**
+ * A quantity a profile stores canonical and a person types in either system. Ratios, angles and
+ * counts have no unit to convert, but share the table so every field is shown and stored the same way.
+ */
+type Quantity = 'density' | 'length' | 'ratio' | 'angle' | 'count';
+/**
+ * Decimal places each quantity is shown, typed and stored at, per system.
+ *
+ * One table so the three can never disagree: a field's `step` is its places, the number shown is
+ * rounded to them, and the value saved is rounded to the metric places — which is also what the
+ * server stores. The imperial places are chosen so a figure typed in imperial, stored in metric and
+ * shown again reads back exactly as typed: one step of the stored metric value is always less than
+ * half a step of the imperial one.
+ */
+declare const PRECISION: Record<Quantity, Record<Units, number>>;
+/** A number to exactly `places` decimals, as a number. */
+declare const roundTo: (value: number, places: number) => number;
+/** A canonical value at the precision it is stored at — what the server keeps. */
+declare const toStored: (quantity: Quantity, value: number) => number;
+/** The stored canonical value as the number to show in the field for this system. */
+declare const toInput: (quantity: Quantity, canonical: number, units: Units) => number;
+/** A value typed in this system, back to canonical at the precision it is stored at. */
+declare const fromInput: (quantity: Quantity, shown: number, units: Units) => number;
+/** The field's `step`: one unit in its last shown place, so every value it shows is valid. */
+declare const stepFor: (quantity: Quantity, units: Units) => string;
+declare const densityUnit: (units: Units) => string;
+/**
+ * A tool length typed in `units`, back to canonical millimetres — undefined when it does not read
+ * as a length. Inches take what a machinist writes: `0.25`, `.25`, `1/4`, `1-1/4`, `1 1/4`, with or
+ * without a trailing `"` or `in`.
+ */
+declare const parseToolLength: (text: string, units: Units) => number | undefined;
+
+/** Engine 1.21 stock inputs. Every dimensional value is millimetres. */
+type StockPosition = 'modelCentered' | 'offsetFromTop' | 'offsetFromBottom';
+type AutomaticStock = {
+    mode: 'automaticFlatBar';
+    oversizeX?: number;
+    oversizeY?: number;
+    oversizeZTop?: number;
+    oversizeZBottom?: number;
+    snapX?: number;
+    snapY?: number;
+    snapZ?: number;
+} | {
+    mode: 'automaticRoundStock';
+    radialOversize?: number;
+    axialOversize?: number;
+    gripStock?: number;
+    diaRoundToNearest?: number;
+    lengthRoundToNearest?: number;
+    verticalAxis?: boolean;
+};
+type FixedStock = {
+    mode: 'fixedBox';
+    dimensions: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    position: StockPosition;
+    positionOffset?: number;
+} | {
+    mode: 'fixedCylinder';
+    diameter: number;
+    length: number;
+    position: StockPosition;
+    positionOffset?: number;
+};
+type StockOption = AutomaticStock | FixedStock;
+declare const STOCK_LABELS: {
+    readonly automaticFlatBar: "Flat Bar";
+    readonly automaticRoundStock: "Round Stock";
+    readonly fixedBox: "Fixed Box";
+    readonly fixedCylinder: "Fixed Cylinder";
+};
+declare const FLAT_BAR_FIELDS: readonly [readonly ["oversizeX", "Width (X)"], readonly ["oversizeY", "Depth (Y)"], readonly ["oversizeZTop", "Thickness (Z)"], readonly ["snapX", "Width (X)"], readonly ["snapY", "Depth (Y)"], readonly ["snapZ", "Thickness (Z)"], readonly ["oversizeZBottom", "Stock Grip Amt."]];
+declare const ROUND_STOCK_FIELDS: readonly [readonly ["radialOversize", "Radial"], readonly ["axialOversize", "Front"], readonly ["diaRoundToNearest", "Diameter"], readonly ["lengthRoundToNearest", "Length"], readonly ["gripStock", "Stock Grip Amt."]];
+/** Legacy-style defaults in the stock setting's entry system, stored canonical. */
+declare const defaultStock: (mode?: AutomaticStock["mode"], units?: Units) => AutomaticStock;
+/** Validate the service contract, including its stock envelope, before saving or forwarding. */
+declare const parseStock: (value: unknown) => StockOption | string;
+/** Stable comparison of policy values, independent of JSON property order. */
+declare const sameStock: (a: StockOption | null | undefined, b: StockOption | null | undefined) => boolean;
+/**
+ * Whether the saved policy is not the stock the part's times were calculated with. A calculation
+ * echoes the stock it was sent (`stock.input`, read by `echoesStock`), so edited stock — or none
+ * calculated yet — shows as a preview of the policy until a calculation of it lands. A part with
+ * no policy has nothing edited.
+ */
+declare const stockEdited: (policy: StockOption | null, baseline: Record<string, unknown> | null) => boolean;
+type ModelAxis = 'x' | 'y' | 'z';
+declare const NO_FIRST_FOLDER = "Add a folder first: a fixed box is measured from the first setup.";
+declare const TILTED_FIRST_FOLDER = "A fixed box needs a first folder facing along X, Y or Z.";
+declare const BOX_ENVELOPE = "The box must fit 80 \u00D7 50 in across the first folder\u2019s direction and 30 in along it.";
+/** The model axis a direction faces along, and which way; null for one off every axis. */
+declare const axisAlong: (direction: PlanDirection) => {
+    axis: ModelAxis;
+    sign: 1 | -1;
+} | null;
+/**
+ * The stock as Toolpath is sent it, for a plan whose first stated setup faces `first` (null with
+ * none stated): any stock but a fixed box as it is; a fixed box turned into that setup's frame, or
+ * why it can't be — no first folder, one facing off the axes, or a box too thick along it.
+ */
+declare const stockRequest: (stock: StockOption, first: PlanDirection | null) => StockOption | string;
+/**
+ * The direction Toolpath placed a calculation's stock along (its first setup's), or null where it
+ * can't be read: a box's frame `z`; a cylinder's axis where the stock asked for stood it along that
+ * direction — a fixed cylinder, or Round Stock with `verticalAxis` — taken only facing along X, Y or
+ * Z. A lying round bar's axis is the part's long side, not the direction, so it gives none.
+ */
+declare const placedAlong: (envelope: unknown) => PlanDirection | null;
+/**
+ * Whether a calculation's stock envelope echoes `policy` as it was sent (`stock.input`): the same
+ * stock — but a fixed box turned into the frame Toolpath placed it in (`placedAlong`) or, with no
+ * placement to read, into the frame of any one of the part's axes.
+ */
+declare const echoesStock: (policy: StockOption, envelope: unknown) => boolean;
+/** A box in the part's model coordinates, mm: its least and greatest corners. */
+interface ModelBox {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** A cylinder in the part's model coordinates, mm: its base centre, unit axis and size. */
+interface ModelCylinder {
+    origin: PlanDirection;
+    axis: PlanDirection;
+    diameter: number;
+    length: number;
+}
+/**
+ * Where Toolpath builds a fixed box around the part, in model coordinates, by the frame reading
+ * above — or null without a first folder facing along an axis. Its two sides across the direction
+ * are laid longer along the part's longer side (the worker sends them so, tp-kernel loads them so);
+ * `turned`: the other way round from how they were entered.
+ */
+declare const fixedBoxPlacement: (stock: Extract<StockOption, {
+    mode: "fixedBox";
+}>, first: PlanDirection | null, part: ModelBox) => (ModelBox & {
+    turned: boolean;
+}) | null;
+/**
+ * Where Toolpath builds any stock around the part, in model coordinates, standing it in the frame
+ * of a first setup facing `first` along an axis (null otherwise): a block (`box`) or a cylinder.
+ * Flat Bar: each side the part's extent plus its oversizes — `x` / `y` on either side across,
+ * `zTop` toward the direction and the exact grip `zBottom` away from it — rounded up, the grip
+ * kept exact (tp-rs `StockBox::relative`). Round Stock: lying along the part's longer side across
+ * the direction, or standing along it (`verticalAxis`, default lying), its diameter the enclosing
+ * circle and radial oversize rounded up, its length the grip, the part and the front oversize
+ * rounded up, the grip at its base (`StockCylinder::relative`). A fixed cylinder stands along the
+ * direction, placed along it by its position (`StockCylinder::fixed`).
+ */
+declare const stockPlacement: (stock: StockOption, first: PlanDirection | null, part: ModelBox) => {
+    box: ModelBox;
+} | {
+    cylinder: ModelCylinder;
+} | null;
+/** What a fixed box held for Apply comes to (`fixedBoxCheck`). */
+type FixedBoxCheck = 
+/** Apply waits on it: `problem` is said beside the stock, `applyReason` on Apply. */
+{
+    problem: string;
+    applyReason: string;
+}
+/** Said beside the stock; Apply does not wait on it. */
+ | {
+    note: string;
+};
+/**
+ * A fixed box against the first folder and the part, as Apply would send it: why it can't be sent
+ * (`stockRequest`), else how far the part stands outside it — the most along any one axis — else
+ * that Toolpath turns it. Null for any other stock, or a box with nothing to say. The part's size is
+ * its model box (`length`, `width` and `height` along X, Y and Z); unknown, the fit is not checked.
+ */
+declare const fixedBoxCheck: (stock: StockOption | null, first: PlanDirection | null, size: {
+    length: number;
+    width: number;
+    height: number;
+} | null, units: Units) => FixedBoxCheck | null;
+
+/**
+ * A tool crib: the tool libraries a part draws its tools from.
+ *
+ * A library is implicit when its tools are synthesized from settings, and explicit when they are a
+ * shop's catalogued tools. Only implicit libraries exist yet; entries are tagged by kind so explicit
+ * ones can join the same list.
+ */
+interface ToolCribEntry {
+    kind: 'implicit';
+    id: string;
+}
+type ToolCrib = Array<ToolCribEntry>;
+/** The implicit libraries a crib names, by id, in its order. */
+declare const implicitLibraryIds: (crib: ReadonlyArray<ToolCribEntry>) => Array<string>;
+/**
+ * Whether a library meant for these material families suits a part cut from `family`. A guide, not
+ * a limit: a library meant for no family in particular suits every part, and a part with no material
+ * is offered them all.
+ */
+declare const suitsMaterial: (materialFamilies: ReadonlyArray<string>, family: string | null) => boolean;
+/** What a crib picks a library by. */
+interface CribLibrary {
+    id: string;
+    isDefault: boolean;
+    materialFamilies: ReadonlyArray<string>;
+}
+/**
+ * The library a crib starts on for a part cut from `family`: the first meant for that family in
+ * particular, else the org's default if it suits, else the first that suits — and, when none does,
+ * the default anyway, since a part has to be planned with something.
+ */
+declare const startingLibrary: <Library extends CribLibrary>(libraries: ReadonlyArray<Library>, family: string | null) => Library | undefined;
+/**
+ * The libraries a crib offers to add for a part cut from `family`: every one not already in it, those
+ * that suit the material first. One meant for another material is still offered — the picker says
+ * whom it is meant for, and a shop may know better.
+ */
+declare const offeredLibraries: <Library extends CribLibrary>(libraries: ReadonlyArray<Library>, inCrib: ReadonlyArray<string>, family: string | null) => Array<Library>;
+/** A crib of one implicit library. */
+declare const cribOf: (library: CribLibrary) => ToolCrib;
+/**
+ * Whether a crib looks as the dialog would have started it for a part cut from `family`: empty, or
+ * just the library that material starts on. Only a saved part is judged this way, since nothing
+ * records whether its crib was picked by hand; a crib edited in the open dialog is known to be.
+ */
+declare const cribUntouched: (crib: ReadonlyArray<ToolCribEntry>, libraries: ReadonlyArray<CribLibrary>, family: string | null) => boolean;
+/** The crib with an implicit library added last — the lowest priority — unless it is already in. */
+declare const addLibrary: (crib: ToolCrib, id: string) => ToolCrib;
+/** The crib without a library. Its last one may go too: an empty crib is refused at upload or save. */
+declare const removeLibrary: (crib: ToolCrib, id: string) => ToolCrib;
+/** The crib with two libraries' places swapped, every other entry left where it is. */
+declare const swapLibraries: (crib: ToolCrib, a: string, b: string) => ToolCrib;
+
+export { type ActionTarget, type AppFields, type AutomaticStock, BOX_ENVELOPE, COVERAGE_KINDS, COVERAGE_LABELS, type CheckContext, type CheckedDraft, type ConfirmCheck, type ConfirmContext, type Constraints, type ConstraintsCoverage, type Coverage, type CoverageFeature, type CoverageKind, DONE_COLOR, DRAFT_ACTION_KINDS, type DirectionAnalysis, type DirectionsKnown, type DraftAction, type DraftActionKind, type DraftFacts, type DraftFolder, type DraftResult, type DraftSetup, type DropAt, type Edited, type EnginePlan, type EnginePlanAction, type EnginePlanSetup, FLAT_BAR_FIELDS, type Face, type FaceGroup, type FaceHatch, type FacePaint, type FeatureBore, type FeatureGroupView, type FixedBoxCheck, type FixedStock, type FlatFolder, type FolderFeature, type Frame, HISTORY, type Hold, IGNORE, type IgnoreMode, type IgnoredAs, type Landing, MAX_DEPTH, MAX_NAME, MAX_SETUPS, type ModelAxis, type ModelBox, type ModelCylinder, NO_FIRST_FOLDER, type NotMachinedFeature, type NotMachinedReason, type NotMachinedWhy, OTHER_FOLDER_COLOR, PART_ROW, PRECISION, type PinChange, type PinContext, type PinEdit, type Pinned, type PinnedFeature, type PlacedFolder, type PlanCheck, type PlanDirection, type PlanFeatureRow, type PlanHighlight, type PlanIssue, type PlanOrientationView, type PlanPart, type PlanReading, type PlanRules, type PlanSession, type PlanSetupView, type PlannedSetup$1 as PlannedSetup, type PlannedSetupView, type Projection, type Quantity, REASON_SHORT, ROUND_STOCK_FIELDS, type ReadingAt, type ReadingContext, type ReadingScope, type ResultsCoverage, type ResultsFeatureRow, type ResultsSetupView, type ResultsView, STOCK_LABELS, type SessionEvent, type SessionRules, type SetupPlan, type SetupProcess, type ShowTarget, type SplitRegion, type StatedOrientation, type Statement, type StockOption, type StockPosition, TILTED_FIRST_FOLDER, type ToolCrib, type ToolCribEntry, UNMACHINED_FACE_COLOR, type Units, type UnmachinedMark, actionsFor, addFolder, addLibrary, addSetup, allClear, allFolders, applyDraftAction, areaOf, axisAlong, canRedo, canUndo, changedSinceResults, chooseReading, classifyFaces, confirmChecks, copyDirection, cribOf, cribUntouched, currentFor, defaultStock, densityUnit, describeClause, directionAnalysis, draftView, echoesStock, faceRegions, facesByRegion, featureGroups, featureTypeLabel, featureTypePlural, featuresAt, findPlaced, fixedBoxCheck, fixedBoxPlacement, flattenFolders, folderClick, folderPath, foldersFromPlan, formatArea, formatDimensions, formatFeed, formatLength, formatSurfaceSpeed, formatWeight, frameFacing, framesOf, fromInput, gapAt, groupFaces, heightOf, holdsFor, ignoreClick, ignoreEdit, ignoreSelection, ignoredAs, ignoredAsSaved, implicitLibraryIds, indexedFor, isDirection, isFallback, isFromBelow, isHeld, isHoleType, isIndexed, isUnits, liftLoneFolder, listsTag, moveFeature, moveFolder, moveSetup, moveWithin, nextFolderName, notFinishedIn, notFinishedOf, notMachinedOf, offeredLibraries, parseDraftSetups, parseStock, parseToolLength, pinEdit, pinFrom, pinHomes, pinInto, pinOf, pinTargetOf, pinnedIn, pinsWhere, placedAlong, placedFolders, planChecks, planCounts, planFromResults, planHatch, planPaint, planRunOf, planSession, planTags, planView, projectFolder, readingDetail, readingOf, readingsFor, reasonLine, refusalClauses, regionLabel, removeFolder, removeFolders, removeLibrary, renameFolder, replacedBy, restoreFeature, resultsView, roundTo, rowsOf, sameDirection, sameJson, sameStock, setSetupProcess, setToolOrientation, setupOf, sortedKeys, startSession, startingLibrary, stateOf, statementOf, stepFor, stockEdited, stockPlacement, stockRequest, suitsMaterial, swapLibraries, tagKey, tagSet, takeBack, takeBackIgnore, toInput, toStored, unignoreEdit, unignorePinned, unignoredNote, unpinFeature, unpinnedNote, whyOf, whyText, withFolders, withIgnored, withPin, withoutIgnored };