@toolpath/plan 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,2951 @@
+// src/coverage.ts
+var COVERAGE_KINDS = [
+  "pinned",
+  "ignored",
+  "open",
+  "machined",
+  "notMachined"
+];
+var COVERAGE_LABELS = {
+  pinned: "Pinned",
+  ignored: "Ignored",
+  open: "Open",
+  machined: "Machined",
+  notMachined: "Not machined"
+};
+var facesByRegion = (coverage) => new Map(
+  COVERAGE_KINDS.flatMap(
+    (kind) => (coverage?.faces[kind] ?? []).map((face) => [face.region, { face, kind }])
+  )
+);
+var tagKey = (tag) => tag.toLowerCase();
+var tagSet = (tags) => new Set([...tags].map(tagKey));
+var planTags = (setups) => tagSet(setups.flatMap((setup) => setup.actions.flatMap((action) => action.featureTags ?? [])));
+var areaOf = (faces) => faces.reduce((sum, face) => sum + face.area, 0);
+var classifyFaces = (input) => {
+  const { regions, features, ignored = [] } = input;
+  const owners = ownersByRegion(features);
+  const ignoredSet = new Set(ignored);
+  const faces = {
+    pinned: [],
+    ignored: [],
+    open: [],
+    machined: [],
+    notMachined: []
+  };
+  for (const region of regions) {
+    const face = { region: region.idx, area: region.area, owners: owners.get(region.idx) ?? [] };
+    faces[kindOf(face, ignoredSet, input)].push(face);
+  }
+  for (const kind of COVERAGE_KINDS) {
+    faces[kind].sort((a, b) => b.area - a.area);
+  }
+  return { total: areaOf(regions), faces };
+};
+var ownersByRegion = (features) => {
+  const owners = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    for (const region of feature.regionIdxs ?? []) {
+      owners.set(region, [...owners.get(region) ?? [], feature.tag]);
+    }
+  }
+  return owners;
+};
+var kindOf = (face, ignored, input) => {
+  if (ignored.has(face.region)) {
+    return "ignored";
+  }
+  const ownedBy = (tags) => face.owners.some((tag) => tags.has(tag.toLowerCase()));
+  if (input.pinned !== void 0) {
+    return ownedBy(input.pinned) ? "pinned" : "open";
+  }
+  return ownedBy(input.machined) ? "machined" : "notMachined";
+};
+var RANKS = [
+  ["blind_hole", "through_hole", "filleted_blind_hole"],
+  ["pocket", "open_pocket", "boss", "filleted_boss", "undercut_tslot", "undercut_dovetail", "sink"],
+  ["chamfer", "inner_fillet", "outer_fillet", "contour_surface", "slanted_face"],
+  ["wall", "face"],
+  ["profile"]
+];
+var RANK_OF = new Map(RANKS.flatMap((types, rank) => types.map((type) => [type, rank])));
+var rankOf = (type) => RANK_OF.get(type) ?? 2.5;
+var isFallback = (type) => type === "profile";
+var groupFaces = (faces, features) => {
+  const byTag = new Map(features.map((feature) => [feature.tag.toLowerCase(), feature]));
+  const { groups, taken } = gatherUnderFeatures(facesOfFeatures(faces, byTag), byTag);
+  const alone = faces.filter((face) => !taken.has(face.region)).map((face) => ({ tag: null, faces: [face], area: face.area }));
+  return [...groups, ...alone].sort(
+    (a, b) => Number(a.tag === null) - Number(b.tag === null) || b.area - a.area
+  );
+};
+var facesOfFeatures = (faces, byTag) => {
+  const includes = /* @__PURE__ */ new Map();
+  for (const face of faces) {
+    const known = [...new Set(face.owners)].filter((tag) => byTag.has(tag.toLowerCase()));
+    for (const tag of known) {
+      includes.set(tag, [...includes.get(tag) ?? [], face]);
+    }
+  }
+  return includes;
+};
+var gatherUnderFeatures = (includes, byTag) => {
+  const left = new Map([...includes].map(([tag, all]) => [tag, all.length]));
+  const before = gathersBefore(byTag, left);
+  const taken = /* @__PURE__ */ new Set();
+  const groups = [];
+  let best = nextToGather(left, before);
+  while (best !== null) {
+    const gathered = includes.get(best).filter((face) => !taken.has(face.region));
+    markGathered(gathered, taken, left);
+    groups.push({ tag: best, faces: gathered, area: areaOf(gathered) });
+    best = nextToGather(left, before);
+  }
+  return { groups, taken };
+};
+var gathersBefore = (byTag, left) => (a, b) => {
+  const [fa, fb] = [byTag.get(a.toLowerCase()), byTag.get(b.toLowerCase())];
+  return (Number(isFallback(fa.featureType)) - Number(isFallback(fb.featureType)) || left.get(b) - left.get(a) || rankOf(fa.featureType) - rankOf(fb.featureType) || (fa.regionIdxs?.length ?? 0) - (fb.regionIdxs?.length ?? 0) || a.localeCompare(b)) < 0;
+};
+var nextToGather = (left, before) => {
+  let best = null;
+  for (const [tag, count] of left) {
+    if (count > 0 && (best === null || before(tag, best))) {
+      best = tag;
+    }
+  }
+  return best;
+};
+var markGathered = (gathered, taken, left) => {
+  for (const face of gathered) {
+    taken.add(face.region);
+    for (const tag of new Set(face.owners)) {
+      countDown(left, tag);
+    }
+  }
+};
+var countDown = (left, tag) => {
+  const count = left.get(tag);
+  if (count !== void 0) {
+    left.set(tag, count - 1);
+  }
+};
+
+// src/refusals.ts
+var MAX_DEPTH = 6;
+var GONE = "That folder is gone.";
+var TOO_DEEP = `Folders sit at most ${MAX_DEPTH} below their setup.`;
+
+// src/plan-draft.ts
+var MAX_SETUPS = 64;
+var MAX_NAME = 100;
+var MAX_FEATURES = 5e3;
+var alreadyCut = (frame) => ({
+  refused: `${frame.name} is cut from that direction already.`
+});
+var sameDirection = (a, b) => a.x === b.x && a.y === b.y && a.z === b.z;
+var isIndexed = (setup) => setup.process === "3+1" || setup.process === "3+2";
+var placedFolders = (setups) => {
+  const placed = [];
+  const walk = (folder, setup, parent, depth) => {
+    const here = placedAt(folder, setup, parent, depth);
+    placed.push(here);
+    for (const child of folder.folders ?? []) {
+      walk(child, setup, here, depth + 1);
+    }
+  };
+  for (const setup of setups) {
+    walk(setup, setup, null, 0);
+  }
+  return placed;
+};
+var placedAt = (folder, setup, parent, depth) => {
+  const toolOrientation = parent !== null && isIndexed(setup) && folder.direction !== void 0;
+  return {
+    folder,
+    setup,
+    parent: parent?.folder ?? null,
+    depth,
+    direction: parent === null ? setup.direction : toolOrientation ? folder.direction : parent.direction,
+    frameId: parent === null || toolOrientation ? folder.id : parent.frameId,
+    toolOrientation
+  };
+};
+var findPlaced = (setups, id) => placedFolders(setups).find((placed) => placed.folder.id === id);
+var framesOf = (setups) => {
+  const placed = placedFolders(setups);
+  return placed.filter((each) => each.frameId === each.folder.id).map((frame) => ({
+    id: frame.folder.id,
+    name: frame.folder.name,
+    holdId: frame.setup.id,
+    direction: frame.direction,
+    features: [
+      ...new Set(
+        placed.filter((each) => each.frameId === frame.folder.id).flatMap((each) => each.folder.features)
+      )
+    ]
+  }));
+};
+var heightOf = (folder) => 1 + Math.max(0, ...(folder.folders ?? []).map(heightOf));
+var idsIn = (folder) => [
+  folder.id,
+  ...(folder.folders ?? []).flatMap(idsIn)
+];
+var updateFolder = (setups, id, change) => {
+  const visit = (folder) => {
+    const next = folder.id === id ? change(folder) : folder;
+    const children = (next.folders ?? []).map(visit);
+    return children.some((child, index) => child !== next.folders[index]) ? { ...next, folders: children } : next;
+  };
+  return setups.map((setup) => visit(setup));
+};
+var pruneFolder = (setups, id) => {
+  const prune = (folder) => folder.folders.some((child) => child.id === id) ? { ...folder, folders: folder.folders.filter((child) => child.id !== id).map(prune) } : { ...folder, folders: folder.folders.map(prune) };
+  return setups.filter((setup) => setup.id !== id).map((setup) => prune(setup));
+};
+var removeFolder = (setups, id) => removeFolders(setups, [id]);
+var removeFolders = (setups, ids) => {
+  const parents = [...new Set(ids.flatMap((id) => findPlaced(setups, id)?.parent?.id ?? []))];
+  const pruned = ids.reduce((all, id) => pruneFolder(all, id), [...setups]);
+  return parents.reduce((all, parentId) => liftLoneFolder(all, parentId), pruned);
+};
+var following = (folder) => {
+  const { direction: _d, process: _p, ...rest } = folder;
+  return rest;
+};
+var tiltsBelow = (folder) => folder.folders.flatMap((child) => [
+  ...child.direction ? [child.direction] : [],
+  ...tiltsBelow(child)
+]);
+var liftedFrom = (here, top) => {
+  if (here.folders.length !== 1 || here.features.length > 0) {
+    return null;
+  }
+  const [only] = here.folders;
+  const { direction: ownTilt, ...kept } = only;
+  if (top) {
+    return liftedToTop(here, kept, ownTilt);
+  }
+  const tilt = ownTilt ?? here.direction;
+  return { ...kept, ...tilt ? { direction: tilt } : {} };
+};
+var liftedToTop = (setup, kept, ownTilt) => {
+  if (ownTilt) {
+    const tilts = tiltsBelow(kept);
+    return {
+      ...kept,
+      direction: ownTilt,
+      ...tilts.length > 0 ? { process: indexedFor(ownTilt, tilts) } : {}
+    };
+  }
+  return {
+    ...kept,
+    direction: setup.direction,
+    ...setup.process && tiltsBelow(kept).length > 0 ? { process: setup.process } : {}
+  };
+};
+var liftLoneFolder = (setups, id) => {
+  const placed = findPlaced(setups, id);
+  const next = placed ? liftedFrom(placed.folder, placed.depth === 0) : null;
+  if (!placed || !next) {
+    return [...setups];
+  }
+  if (!placed.parent) {
+    return setups.map((setup) => setup.id === id ? next : setup);
+  }
+  return replaceChild(setups, placed.parent.id, id, next);
+};
+var replaceChild = (setups, parentId, childId, next) => updateFolder(setups, parentId, (folder) => ({
+  ...folder,
+  folders: folder.folders.map((child) => child.id === childId ? next : child)
+}));
+var namesIn = (setups) => placedFolders(setups).map((placed) => placed.folder.name);
+var FOLDER_NUMBER = /^Folder (\d+)$/;
+var nextFolderName = (names) => `Folder ${Math.max(
+  0,
+  ...names.map(
+    (each) => Number(FOLDER_NUMBER.exec(typeof each === "string" ? each : each.name)?.[1] ?? 0)
+  )
+) + 1}`;
+var addFolder = (setups, parentId, id, workId = `${id}:work`) => {
+  const parent = findPlaced(setups, parentId);
+  if (!parent || parent.depth >= MAX_DEPTH) {
+    return [...setups];
+  }
+  const name = nextFolderName(namesIn(setups));
+  const added = { id, name, features: [], folders: [] };
+  const split = parent.folder.folders.length === 0;
+  return updateFolder(
+    setups,
+    parentId,
+    (folder) => split ? {
+      ...folder,
+      features: [],
+      folders: [
+        { id: workId, name: folder.name, features: folder.features, folders: [] },
+        added
+      ]
+    } : { ...folder, folders: [...folder.folders, added] }
+  );
+};
+var renameFolder = (setups, id, name) => updateFolder(setups, id, (folder) => ({
+  ...folder,
+  name: name.trim().slice(0, MAX_NAME) || folder.name
+}));
+var setSetupProcess = (setups, setupId, process) => {
+  if (process === void 0 && placedFolders(setups).some((placed) => placed.setup.id === setupId && placed.toolOrientation)) {
+    return { refused: "Move or delete its tool orientations first." };
+  }
+  return setups.map((setup) => {
+    if (setup.id !== setupId) {
+      return setup;
+    }
+    const { process: _was, ...rest } = setup;
+    return process ? { ...rest, process } : rest;
+  });
+};
+var setToolOrientation = (setups, folderId, direction) => {
+  const placed = findPlaced(setups, folderId);
+  if (!placed || placed.depth === 0) {
+    return { refused: "Only a folder inside a setup can be a tool orientation." };
+  }
+  if (direction && !isIndexed(placed.setup)) {
+    return { refused: "Only a 3+1 or 3+2 setup has tool orientations." };
+  }
+  const taken = direction ? framesOf(setups).find(
+    (frame) => frame.id !== folderId && sameDirection(frame.direction, direction)
+  ) : void 0;
+  if (taken) {
+    return alreadyCut(taken);
+  }
+  return updateFolder(
+    setups,
+    folderId,
+    (folder) => direction ? { ...following(folder), direction } : following(folder)
+  );
+};
+var withFolders = (setups) => {
+  const fill = (folder) => ({
+    ...folder,
+    features: folder.features ?? [],
+    folders: (folder.folders ?? []).map(fill)
+  });
+  return setups.map((setup) => fill(setup));
+};
+var isDirection = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const { x, y, z } = value;
+  return [x, y, z].every((n) => typeof n === "number" && Number.isFinite(n));
+};
+var copyDirection = ({ x, y, z }) => ({ x, y, z });
+var parseDraftSetups = (value) => {
+  if (!Array.isArray(value)) {
+    return "The plan has no list of setups.";
+  }
+  if (value.length > MAX_SETUPS) {
+    return `A plan can state at most ${MAX_SETUPS} setups.`;
+  }
+  const seen = { ids: /* @__PURE__ */ new Set(), tags: /* @__PURE__ */ new Set(), names: [] };
+  const setups = parseEach(value, (entry) => parseSetup(entry, seen));
+  if (typeof setups === "string") {
+    return setups;
+  }
+  if (anyDirectionTwice(setups)) {
+    return "Each direction can be a setup only once.";
+  }
+  return setups;
+};
+var parseEach = (entries, parse) => {
+  const parsed = [];
+  for (const entry of entries) {
+    const each = parse(entry);
+    if (typeof each === "string") {
+      return each;
+    }
+    parsed.push(each);
+  }
+  return parsed;
+};
+var parseSetup = (entry, seen) => {
+  const { direction, process } = entry ?? {};
+  if (!isDirection(direction)) {
+    return "A setup needs a direction.";
+  }
+  if (process !== void 0 && process !== "3+1" && process !== "3+2") {
+    return "A setup is held 3 axis, 3+1 or 3+2.";
+  }
+  const parsed = parseFolder(entry, 0, seen);
+  if (typeof parsed === "string") {
+    return parsed;
+  }
+  return {
+    ...parsed,
+    direction: copyDirection(direction),
+    ...process ? { process } : {}
+  };
+};
+var parseFolder = (entry, depth, seen) => {
+  const { id, name, direction, features, folders } = entry ?? {};
+  if (typeof id !== "string" || !id || seen.ids.has(id) || typeof name !== "string") {
+    return "A folder needs an id of its own and a name.";
+  }
+  if (depth > MAX_DEPTH) {
+    return `A folder can sit at most ${MAX_DEPTH} below its setup.`;
+  }
+  if (direction !== void 0 && !isDirection(direction)) {
+    return "A folder\u2019s direction is three numbers.";
+  }
+  const own = claimFeatures(features, folders, seen);
+  if (typeof own === "string") {
+    return own;
+  }
+  seen.ids.add(id);
+  const children = parseEach(
+    Array.isArray(folders) ? folders : [],
+    (child) => parseFolder(child, depth + 1, seen)
+  );
+  if (typeof children === "string") {
+    return children;
+  }
+  const folder = {
+    id,
+    name: name.trim().slice(0, MAX_NAME) || nextFolderName(seen.names),
+    features: own,
+    folders: children,
+    ...direction ? { direction: copyDirection(direction) } : {}
+  };
+  seen.names.push(folder.name);
+  return folder;
+};
+var FEATURE_TAG = /^[0-9a-f]{1,16}$/;
+var claimFeatures = (features, folders, seen) => {
+  const pinned2 = features ?? [];
+  if (!isTagList(pinned2)) {
+    return "A folder\u2019s features are feature tags.";
+  }
+  const own = [...new Set(pinned2)];
+  if (own.length > 0 && Array.isArray(folders) && folders.length > 0) {
+    return "A folder holds features or folders, never both.";
+  }
+  if (own.some((tag) => seen.tags.has(tag))) {
+    return "A feature can be pinned in one folder only.";
+  }
+  own.forEach((tag) => seen.tags.add(tag));
+  return own;
+};
+var isTagList = (value) => Array.isArray(value) && value.length <= MAX_FEATURES && value.every((tag) => typeof tag === "string" && FEATURE_TAG.test(tag));
+var anyDirectionTwice = (setups) => {
+  const frames = framesOf(setups);
+  return frames.some(
+    (frame, index) => frames.findIndex((other) => sameDirection(other.direction, frame.direction)) !== index
+  );
+};
+var addSetup = (setups, direction, id) => framesOf(setups).some((frame) => sameDirection(frame.direction, direction)) || setups.length >= MAX_SETUPS ? [...setups] : [
+  ...setups,
+  {
+    id,
+    name: nextFolderName(namesIn(setups)),
+    direction,
+    features: [],
+    folders: []
+  }
+];
+var statedFrom = (planned, newId, pins) => {
+  const stating = { setups: [], newId, pins, pinned: /* @__PURE__ */ new Set() };
+  for (const setup of planned) {
+    const stated = stateSetup(stating, setup);
+    if (stated) {
+      stating.setups.push(stated);
+    }
+  }
+  return stating.setups;
+};
+var stateSetup = (stating, setup) => {
+  const [first, ...rest] = setup.orientations.map((orientation) => orientation.direction);
+  if (!first || frameFacing(stating.setups, first) || stating.setups.length >= MAX_SETUPS) {
+    return null;
+  }
+  const tilts = tiltsToState(stating.setups, first, rest);
+  const passedOver = rest.filter((tilt) => !tilts.some((each) => sameDirection(each, tilt)));
+  const claimed = claimsOf(setup);
+  const notMachined = notMachinedIn(setup);
+  const take = (tags) => takePins(stating, notMachined, tags);
+  const tilted = tilts.map((tilt) => [tilt, take(claimedFrom(claimed, tilt))]);
+  const own = take([
+    ...[first, ...passedOver].flatMap((direction) => claimedFrom(claimed, direction)),
+    ...unlistedRows(setup, claimed)
+  ]);
+  return statedFrame(stating, first, own, tilted);
+};
+var tiltsToState = (setups, first, rest) => rest.filter(
+  (tilt, index) => !frameFacing(setups, tilt) && !sameDirection(tilt, first) && rest.findIndex((each) => sameDirection(each, tilt)) === index
+);
+var notMachinedIn = (setup) => new Set(
+  (setup.rows ?? []).filter((row) => row.mark === "notMachined").map((row) => row.tag.toLowerCase())
+);
+var takePins = (stating, notMachined, tags) => {
+  if (!stating.pins) {
+    return [];
+  }
+  const taken = [];
+  for (const tag of tags) {
+    const key = tag.toLowerCase();
+    if (!notMachined.has(key) && !stating.pinned.has(key)) {
+      stating.pinned.add(key);
+      taken.push(tag);
+    }
+  }
+  return taken;
+};
+var claimsOf = (setup) => {
+  const claimed = /* @__PURE__ */ new Map();
+  const listed = setup.orientations.flatMap(
+    (orientation) => (orientation.features ?? []).map(({ tag }) => ({ tag, direction: orientation.direction }))
+  );
+  for (const claim of listed) {
+    if (!claimed.has(claim.tag.toLowerCase())) {
+      claimed.set(claim.tag.toLowerCase(), claim);
+    }
+  }
+  return claimed;
+};
+var claimedFrom = (claimed, direction) => [...claimed.values()].filter((claim) => sameDirection(claim.direction, direction)).map((claim) => claim.tag);
+var unlistedRows = (setup, claimed) => (setup.rows ?? []).filter((row) => !claimed.has(row.tag.toLowerCase())).map((row) => row.tag);
+var statedFrame = (stating, direction, own, tilted) => {
+  const newFolder = folderMaker(stating);
+  if (tilted.length === 0) {
+    return { ...newFolder(own), direction };
+  }
+  const frame = newFolder([]);
+  const followers = tilted.length === 1 || own.length > 0 ? [newFolder(own)] : [];
+  const tiltFolders = tilted.map(([tilt, features]) => ({
+    ...newFolder(features),
+    direction: tilt
+  }));
+  return {
+    ...frame,
+    direction,
+    process: indexedFor(
+      direction,
+      tilted.map(([tilt]) => tilt)
+    ),
+    folders: [...followers, ...tiltFolders]
+  };
+};
+var folderMaker = (stating) => {
+  const names = namesIn(stating.setups);
+  return (features) => {
+    const folder = {
+      id: stating.newId(),
+      name: nextFolderName(names),
+      features,
+      folders: []
+    };
+    names.push(folder.name);
+    return folder;
+  };
+};
+var foldersFromPlan = (planned, newId) => statedFrom(planned, newId, false);
+var planFromResults = (planned, newId) => statedFrom(planned, newId, true);
+var moveSetup = (setups, id, by) => {
+  const from = setups.findIndex((setup) => setup.id === id);
+  if (from < 0) {
+    return [...setups];
+  }
+  const to = Math.max(0, Math.min(setups.length - 1, from + by));
+  const next = [...setups];
+  const [moved] = next.splice(from, 1);
+  next.splice(to, 0, moved);
+  return next;
+};
+var moveWithin = (setups, id, by) => {
+  const parent = findPlaced(setups, id)?.parent;
+  if (!parent) {
+    return moveSetup(setups, id, by);
+  }
+  const reorder = (folder) => {
+    if (folder.id !== parent.id) {
+      return { ...folder, folders: folder.folders.map(reorder) };
+    }
+    const from = folder.folders.findIndex((child) => child.id === id);
+    const to = Math.max(0, Math.min(folder.folders.length - 1, from + by));
+    const folders = [...folder.folders];
+    const [moved] = folders.splice(from, 1);
+    folders.splice(to, 0, moved);
+    return { ...folder, folders };
+  };
+  return setups.map((setup) => reorder(setup));
+};
+var indexedFor = (setupDirection, tilts) => {
+  const z = setupDirection;
+  const axes = tilts.map((t) => ({ x: z.y * t.z - z.z * t.y, y: z.z * t.x - z.x * t.z, z: z.x * t.y - z.y * t.x })).map((a) => ({ a, length: Math.hypot(a.x, a.y, a.z) })).filter(({ length }) => length > 1e-9).map(({ a, length }) => ({ x: a.x / length, y: a.y / length, z: a.z / length }));
+  const [first] = axes;
+  return !first || axes.every((a) => Math.abs(a.x * first.x + a.y * first.y + a.z * first.z) > 1 - 1e-6) ? "3+1" : "3+2";
+};
+var pinnedIn = (setups, tag) => {
+  const key = tagKey(tag);
+  return placedFolders(setups).find(
+    (placed) => placed.folder.features.some((each) => tagKey(each) === key)
+  )?.folder.id ?? null;
+};
+var pinHomes = (setups) => {
+  const homes = /* @__PURE__ */ new Map();
+  for (const { folder } of placedFolders(setups)) {
+    for (const tag of folder.features) {
+      if (!homes.has(tagKey(tag))) {
+        homes.set(tagKey(tag), folder.id);
+      }
+    }
+  }
+  return homes;
+};
+var pinOf = (setups, tag) => {
+  const key = tag.toLowerCase();
+  for (const { folder } of placedFolders(setups)) {
+    const pin = folder.features.find((each) => each.toLowerCase() === key);
+    if (pin) {
+      return { folderId: folder.id, tag: pin };
+    }
+  }
+  return null;
+};
+var pinInto = (setups, folderId, tag, newId = `${folderId}:${tag}`) => {
+  const was = pinnedIn(setups, tag);
+  const unpinned = was ? unpinFeature(setups, was, tag) : [...setups];
+  if (was === folderId) {
+    return { setups: unpinned, setupId: folderId, added: false, unpinned: true };
+  }
+  const holdsFolders = (findPlaced(setups, folderId)?.folder.folders.length ?? 0) > 0;
+  const name = nextFolderName(namesIn(setups));
+  return {
+    setups: updateFolder(
+      unpinned,
+      folderId,
+      (folder) => holdsFolders ? {
+        ...folder,
+        folders: [...folder.folders, { id: newId, name, features: [tag], folders: [] }]
+      } : { ...folder, features: [...folder.features, tag] }
+    ),
+    setupId: holdsFolders ? newId : folderId,
+    added: false,
+    unpinned: false
+  };
+};
+var pinTargetOf = (setups, direction) => {
+  const frame = frameFacing(setups, direction);
+  if (!frame) {
+    return null;
+  }
+  const placed = placedFolders(setups);
+  const leaf = placed.find((each) => each.frameId === frame.id && each.folder.folders.length === 0);
+  return leaf?.folder.id ?? frame.id;
+};
+var frameFacing = (setups, direction) => framesOf(setups).find((each) => sameDirection(each.direction, direction));
+var pinFrom = (setups, direction, tag, newId) => {
+  const frame = frameFacing(setups, direction);
+  if (frame) {
+    const was = pinnedIn(setups, tag);
+    const inFrame = was !== null && placedFolders(setups).some((p) => p.folder.id === was && p.frameId === frame.id);
+    return pinInto(setups, inFrame ? was : pinTargetOf(setups, direction), tag, newId);
+  }
+  const next = addSetup(setups, direction, newId);
+  if (next.length === setups.length) {
+    return { refused: `A plan holds at most ${MAX_SETUPS} setups.` };
+  }
+  return {
+    setups: next.map((setup) => setup.id === newId ? { ...setup, features: [tag] } : setup),
+    setupId: newId,
+    added: true,
+    unpinned: false
+  };
+};
+var unpinFeature = (setups, folderId, tag) => updateFolder(setups, folderId, (folder) => ({
+  ...folder,
+  features: folder.features.filter((feature) => tagKey(feature) !== tagKey(tag))
+}));
+var placedAsBefore = (list, before, tag) => {
+  const without = list.filter((each) => each !== tag);
+  const at = before?.indexOf(tag) ?? -1;
+  if (at >= 0) {
+    without.splice(Math.min(at, without.length), 0, tag);
+  }
+  return without;
+};
+var restoreFeature = (setups, saved, tag) => {
+  const was = new Map(placedFolders(saved).map(({ folder }) => [folder.id, folder]));
+  const visit = (folder) => ({
+    ...folder,
+    features: placedAsBefore(folder.features, was.get(folder.id)?.features, tag),
+    folders: folder.folders.map(visit)
+  });
+  return setups.map((setup) => visit(setup));
+};
+var currentFor = (list, stamp, now) => stamp && stamp !== now ? [] : [...list ?? []];
+var ignoredAs = (done, kernel) => ({
+  done: [...done].sort((a, b) => a - b),
+  doneKernel: done.length > 0 ? kernel : null
+});
+var withIgnored = (plan, faces, kernel) => ignoredAs([.../* @__PURE__ */ new Set([...currentFor(plan.done, plan.doneKernel, kernel), ...faces])], kernel);
+var withoutIgnored = (plan, faces, kernel) => {
+  const these = new Set(faces);
+  return ignoredAs(
+    currentFor(plan.done, plan.doneKernel, kernel).filter((r) => !these.has(r)),
+    kernel
+  );
+};
+var ignoredAsSaved = (plan, saved, faces, kernel) => {
+  const these = new Set(faces);
+  return withIgnored(
+    withoutIgnored(plan, faces, kernel),
+    currentFor(saved.done, saved.doneKernel, kernel).filter((r) => these.has(r)),
+    kernel
+  );
+};
+var pinsWhere = (setups, test) => placedFolders(setups).flatMap(
+  ({ folder }) => folder.features.filter(test).map((tag) => ({ setupId: folder.id, tag }))
+);
+var statementOf = (setups) => {
+  const frames = framesOf(setups);
+  if (frames.length === 0) {
+    return null;
+  }
+  return {
+    setups: frames.map((frame) => ({
+      orientations: [{ direction: frame.direction, features: frame.features }]
+    }))
+  };
+};
+var holdsFor = (setups, planned) => {
+  const frames = framesOf(setups);
+  const holds2 = /* @__PURE__ */ new Map();
+  for (const setup of planned) {
+    const direction = setup.direction;
+    const frame = direction ? frames.find((each) => sameDirection(each.direction, direction)) : void 0;
+    const hold = frame ? setups.find((each) => each.id === frame.holdId) : void 0;
+    const key = hold?.id ?? `setup:${setup.idx}`;
+    const found = holds2.get(key);
+    if (found) {
+      found.setupIdxs.push(setup.idx);
+    } else {
+      holds2.set(key, { key, name: hold?.name ?? `Setup ${setup.idx + 1}`, setupIdxs: [setup.idx] });
+    }
+  }
+  return [...holds2.values()];
+};
+var tiltsIn = (setups, setupId) => placedFolders(setups).filter((placed) => placed.setup.id === setupId && placed.toolOrientation).map((placed) => placed.direction);
+var moveFolder = (setups, id, to, newId = `${id}:parent`) => {
+  const left = findPlaced(setups, id)?.parent?.id ?? null;
+  const moved = placeFolder(setups, id, to, newId);
+  return Array.isArray(moved) && left ? liftLoneFolder(moved, left) : moved;
+};
+var placeFolder = (setups, id, to, newId) => {
+  const moved = findPlaced(setups, id);
+  if (!moved) {
+    return { refused: GONE };
+  }
+  const move = { setups, moved, to, newId };
+  if (to.parentId === parentIdOf(moved)) {
+    return withLanded(move, moved.folder);
+  }
+  if (to.parentId === null) {
+    return placeAtTop(move);
+  }
+  const target = findPlaced(setups, to.parentId);
+  if (!target) {
+    return { refused: GONE };
+  }
+  return placeInside(move, target);
+};
+var parentIdOf = (placed) => placed.parent?.id ?? null;
+var withLanded = ({ setups, moved, to }, folder) => putAt(takenOut(setups, moved), folder, to);
+var takenOut = (setups, placed) => parentIdOf(placed) === null ? setups.filter((setup) => setup.id !== placed.folder.id) : pruneFolder(setups, placed.folder.id);
+var putAt = (setups, folder, to) => {
+  if (to.parentId === null) {
+    const next = [...setups];
+    next.splice(to.index, 0, folder);
+    return next;
+  }
+  return updateFolder(setups, to.parentId, (parent) => {
+    const children = [...parent.folders];
+    children.splice(to.index, 0, folder);
+    return { ...parent, folders: children };
+  });
+};
+var placeAtTop = (move) => {
+  const { moved } = move;
+  if (!moved.toolOrientation) {
+    return { refused: `It is cut from ${moved.setup.name}\u2019s direction, a setup already.` };
+  }
+  const { direction: tilt, ...rest } = moved.folder;
+  const setup = { ...rest, direction: tilt };
+  return indexedForTiltsIn(withLanded(move, setup), setup.id);
+};
+var indexedForTiltsIn = (setups, setupId) => {
+  const tilts = tiltsIn(
+    setups.map((each) => each.id === setupId ? { ...each, process: "3+2" } : each),
+    setupId
+  );
+  if (tilts.length === 0) {
+    return setups;
+  }
+  return setups.map(
+    (each) => each.id === setupId ? { ...each, process: indexedFor(each.direction, tilts) } : each
+  );
+};
+var placeInside = (move, target) => {
+  const { moved } = move;
+  if (idsIn(moved.folder).includes(target.folder.id)) {
+    return { refused: "A folder can\u2019t go inside itself." };
+  }
+  if (target.depth + heightOf(moved.folder) > MAX_DEPTH) {
+    return { refused: TOO_DEEP };
+  }
+  if (target.folder.folders.length === 0) {
+    return wrapBoth(move, target);
+  }
+  if (sameDirection(moved.direction, target.direction)) {
+    return withLanded(move, following(moved.folder));
+  }
+  return placeAsTilt(move, target);
+};
+var placeAsTilt = (move, target) => {
+  const { setups, moved } = move;
+  const taken = frameFacing(takenOut(setups, moved), moved.direction);
+  if (taken) {
+    return alreadyCut(taken);
+  }
+  const tilt = { ...following(moved.folder), direction: moved.direction };
+  return indexedToReach(withLanded(move, tilt), target.setup.id);
+};
+var indexedToReach = (setups, setupId) => {
+  const indexed = setups.map(
+    (each) => each.id === setupId ? { ...each, process: each.process ?? "3+1" } : each
+  );
+  const tilts = tiltsIn(indexed, setupId);
+  return indexed.map(
+    (each) => each.id === setupId ? { ...each, process: each.process === "3+2" ? "3+2" : indexedFor(each.direction, tilts) } : each
+  );
+};
+var wrapBoth = (move, target) => {
+  const { setups, moved, newId } = move;
+  if (tooDeepWrapped(moved, target)) {
+    return { refused: TOO_DEEP };
+  }
+  const base = takenOut(setups, moved);
+  const sameWay = sameDirection(moved.direction, target.direction);
+  const taken = sameWay ? void 0 : frameFacing(base, moved.direction);
+  if (taken) {
+    return alreadyCut(taken);
+  }
+  const placed = inPlaceOf(base, target, parentOfBoth(move, target));
+  if (sameWay) {
+    return placed;
+  }
+  return indexedToReach(placed, target.depth === 0 ? newId : target.setup.id);
+};
+var tooDeepWrapped = (moved, target) => target.depth + 1 + heightOf(moved.folder) > MAX_DEPTH || target.depth + 1 + heightOf(target.folder) - 1 > MAX_DEPTH;
+var parentOfBoth = ({ setups, moved, newId }, target) => ({
+  id: newId,
+  name: nextFolderName(namesIn(setups)),
+  features: [],
+  folders: [following(target.folder), besideTarget(moved, target)],
+  ...target.toolOrientation ? { direction: target.direction } : {}
+});
+var besideTarget = (moved, target) => sameDirection(moved.direction, target.direction) ? following(moved.folder) : { ...following(moved.folder), direction: moved.direction };
+var inPlaceOf = (setups, target, parent) => {
+  if (target.depth !== 0) {
+    return replaceChild(setups, target.parent.id, target.folder.id, parent);
+  }
+  return setups.map(
+    (each) => each.id === target.folder.id ? {
+      ...parent,
+      direction: target.setup.direction,
+      ...target.setup.process ? { process: target.setup.process } : {}
+    } : each
+  );
+};
+var moveFeature = (setups, tag, featureDirection, folderId, newId) => {
+  const dropped = findPlaced(setups, folderId);
+  if (!dropped) {
+    return { refused: GONE };
+  }
+  const target = rowTarget(setups, dropped, featureDirection);
+  if (!target) {
+    return { refused: `No folder in ${dropped.folder.name} is cut from that direction.` };
+  }
+  if (!sameDirection(target.direction, featureDirection)) {
+    return { refused: "Rows stay in folders cut from their own direction." };
+  }
+  if (target.folder.features.includes(tag)) {
+    return [...setups];
+  }
+  const result = pinInto(setups, target.folder.id, tag, newId);
+  return "setups" in result ? result.setups : { refused: result.refused };
+};
+var rowTarget = (setups, dropped, featureDirection) => {
+  if (dropped.folder.folders.length === 0) {
+    return dropped;
+  }
+  const inside = new Set(idsIn(dropped.folder));
+  const leaf = placedFolders(setups).find(
+    (each) => inside.has(each.folder.id) && each.folder.folders.length === 0 && sameDirection(each.direction, featureDirection)
+  );
+  return leaf ?? (sameDirection(dropped.direction, featureDirection) ? dropped : void 0);
+};
+
+// src/direction-analysis.ts
+var directionAnalysis = (direction, { analyzed, discovered, pending }) => (
+  // Nothing is known before the report is read: nothing to say about it either.
+  !analyzed || analyzed.some((each) => sameDirection(each, direction)) ? "analyzed" : !discovered?.some((each) => sameDirection(each, direction)) ? "undetected" : pending ? "analyzing" : "unanalyzed"
+);
+
+// src/readings.ts
+var faceRegions = (regions, region) => {
+  const origin = regions.find((candidate) => candidate.idx === region)?.splitOrigin;
+  return origin === void 0 ? [region] : regions.filter((candidate) => candidate.splitOrigin === origin).map(({ idx }) => idx);
+};
+var regionsOf = (feature) => feature.regionIdxs ?? [];
+var readingsFor = (at, scope, context) => {
+  const wanted = new Set(at.regions);
+  const owners = context.features.filter(
+    (feature) => regionsOf(feature).some((region) => wanted.has(region))
+  );
+  const read = scope.kind === "ignore" ? ignoreOrder(owners) : sizeOrder(owners, scope, at.ranked, context);
+  const tags = read.map((feature) => feature.tag);
+  return { tags, default: defaultOf(read, at.prefer ?? null, scope, context) };
+};
+var rankOf2 = (ranked, tag) => {
+  const at = ranked?.indexOf(tag) ?? -1;
+  return at < 0 ? ranked?.length ?? 0 : at;
+};
+var sizeOrder = (owners, scope, ranked, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  return owners.filter((feature) => {
+    const key = tagKey(feature.tag);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    if (scope.kind === "all") {
+      return true;
+    }
+    const direction = context.featureOf(feature.tag)?.direction;
+    return direction !== void 0 && sameDirection(direction, scope.direction);
+  }).sort(
+    (a, b) => regionsOf(b).length - regionsOf(a).length || rankOf2(ranked, a.tag) - rankOf2(ranked, b.tag)
+  );
+};
+var ignoreOrder = (owners) => {
+  const sorted = [...owners].sort(
+    (a, b) => Number(isFallback(a.featureType)) - Number(isFallback(b.featureType)) || regionsOf(a).length - regionsOf(b).length || a.tag.localeCompare(b.tag)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return sorted.filter((feature) => {
+    const key = [...new Set(regionsOf(feature))].sort((a, b) => a - b).join(",");
+    return seen.has(key) ? false : (seen.add(key), true);
+  });
+};
+var defaultOf = (read, prefer, scope, context) => {
+  const preferred = prefer ? read.find((feature) => tagKey(feature.tag) === tagKey(prefer)) : null;
+  if (preferred) {
+    return preferred.tag;
+  }
+  if (scope.kind === "ignore") {
+    return read.find((feature) => !isFallback(feature.featureType))?.tag ?? null;
+  }
+  const pinned2 = read.find((feature) => {
+    const home = context.pinnedIn?.(feature.tag) ?? null;
+    return scope.kind === "folder" ? home === scope.id : home !== null;
+  });
+  return pinned2?.tag ?? read[0]?.tag ?? null;
+};
+
+// src/ignore.ts
+var ignoreEdit = (plan, regions, context) => {
+  const ignored = withIgnored(plan, regions, context.kernel);
+  const done = new Set(ignored.done);
+  const these = new Set(regions);
+  const unpinned = pinsWhere(plan.setups, (tag) => {
+    const faces = context.regionsOf(tag);
+    return faces.some((face) => these.has(face)) && faces.every((face) => done.has(face));
+  });
+  return {
+    intent: {
+      setups: unpinned.reduce(
+        (all, pin) => unpinFeature(all, pin.setupId, pin.tag),
+        [...plan.setups]
+      ),
+      ...ignored
+    },
+    unpinned
+  };
+};
+var unpinnedNote = (unpinned, setups) => {
+  const folders = [
+    ...new Set(unpinned.map((pin) => findPlaced(setups, pin.setupId)?.folder.name ?? "its folder"))
+  ];
+  return folders.length > 0 ? ` Unpinned from ${folders.join(", ")}.` : "";
+};
+var unignoredNote = (regions) => regions.length > 0 ? ` ${regionLabel(regions)} no longer ignored.` : "";
+var unignoreEdit = (plan, regions, context) => ({ setups: [...plan.setups], ...withoutIgnored(plan, regions, context.kernel) });
+var featureAt = (region, features) => featuresAt(region, features).find((feature) => !isFallback(feature.featureType)) ?? null;
+var featuresAt = (region, features) => {
+  const owners = features.filter((feature) => (feature.regionIdxs ?? []).includes(region)).sort(
+    (a, b) => Number(isFallback(a.featureType)) - Number(isFallback(b.featureType)) || (a.regionIdxs?.length ?? 0) - (b.regionIdxs?.length ?? 0) || a.tag.localeCompare(b.tag)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return owners.filter((feature) => {
+    const key = [...new Set(feature.regionIdxs ?? [])].sort((a, b) => a - b).join(",");
+    return seen.has(key) ? false : (seen.add(key), true);
+  });
+};
+var ignoreSelection = ({
+  region,
+  mode,
+  features,
+  regions
+}) => {
+  if (mode === "face") {
+    return { tag: null, regions: faceRegions(regions, region) };
+  }
+  if (mode === "region") {
+    return { tag: null, regions: [region] };
+  }
+  const feature = featureAt(region, features);
+  return {
+    tag: feature?.tag ?? null,
+    regions: feature ? [...new Set(feature.regionIdxs ?? [])] : [region]
+  };
+};
+var regionLabel = (regions) => {
+  const ids = [...regions].sort((a, b) => a - b);
+  return `${ids.length === 1 ? "Region" : "Regions"} ${ids.join(", ")}`;
+};
+var takeBackIgnore = (plan, saved, regions, context) => ({
+  setups: [...plan.setups],
+  ...ignoredAsSaved(plan, saved, regions, context.kernel)
+});
+var ignoreClick = ({
+  region,
+  ignored,
+  regions
+}) => {
+  if (ignored.has(region)) {
+    return { kind: "unignore", regions: regions.filter((each) => ignored.has(each)) };
+  }
+  return { kind: "ignore", regions: [...regions] };
+};
+
+// src/engine-plan.ts
+var featureTypeLabel = (type) => {
+  const words = type.replaceAll("_", " ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+};
+var notMachinedOf = (setup) => setup.unmachined;
+var planRunOf = (plan) => plan.jobId ? `${plan.planId}/${plan.jobId}` : plan.planId;
+
+// src/not-machined.ts
+var REASON_SHORT = {
+  library: "no tool in your libraries",
+  sharpCorner: "corner too sharp",
+  planned: "planned, not cut",
+  leftOut: "not planned",
+  noFeature: "not a feature",
+  notFinished: "not finished"
+};
+var reasonLine = (reason, detail) => `${REASON_SHORT[reason].charAt(0).toUpperCase()}${REASON_SHORT[reason].slice(1)}: ${detail}`;
+var indexOf = (setups, at) => setups[at].idx ?? at;
+var alike = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z > 0.9999;
+var isFromBelow = (direction) => (direction?.z ?? 0) < -0.5;
+var whyOf = (tag, setups, direction) => {
+  if (tag === null) {
+    return { kind: "noFeature" };
+  }
+  const key = tag.toLowerCase();
+  const planned = setups.findIndex(
+    (setup) => (setup.unmachined ?? []).some((each) => each.toLowerCase() === key)
+  );
+  if (planned >= 0) {
+    return { kind: "planned", setup: indexOf(setups, planned) };
+  }
+  const facing = direction ? setups.findIndex((setup) => setup.direction && alike(setup.direction, direction)) : -1;
+  return { kind: "leftOut", setup: facing >= 0 ? indexOf(setups, facing) : null };
+};
+var notFinishedIn = (setup) => {
+  const cut = new Set(
+    setup.actions.flatMap((action) => action.featureTags ?? []).map((tag) => tag.toLowerCase())
+  );
+  return [...new Set(setup.unmachined ?? [])].filter((tag) => cut.has(tag.toLowerCase()));
+};
+var notFinishedOf = (setups) => {
+  const seen = /* @__PURE__ */ new Set();
+  return setups.flatMap(
+    (setup, at) => notFinishedIn(setup).flatMap((tag) => {
+      if (seen.has(tag.toLowerCase())) {
+        return [];
+      }
+      seen.add(tag.toLowerCase());
+      return [{ tag, setup: indexOf(setups, at) }];
+    })
+  );
+};
+var whyText = (why, setupName) => {
+  if (why.kind === "noFeature") {
+    return reasonLine(why.kind, "nothing can be told to cut this face");
+  }
+  const name = why.setup === null ? null : setupName?.(why.setup) ?? null;
+  if (why.kind === "notFinished") {
+    return reasonLine(
+      why.kind,
+      name ? `roughed in ${name}, but no pass finishes it` : "roughed, but no pass finishes it"
+    );
+  }
+  if (why.kind === "planned") {
+    return reasonLine(why.kind, name ? `in ${name}, but no pass cuts it` : "no pass cuts it");
+  }
+  return reasonLine(why.kind, name ? `in no setup, though ${name} faces its way` : "in no setup");
+};
+
+// src/plan-view.ts
+var PART_ROW = "part";
+var IGNORE = "ignore";
+var featureTypePlural = (type) => {
+  if (!type) {
+    return "Other";
+  }
+  const label = featureTypeLabel(type);
+  return /(s|x|ch|sh)$/.test(label) ? `${label}es` : `${label}s`;
+};
+var isHoleType = (type) => type?.endsWith("_hole") ?? false;
+var boreKey = (bore) => bore.diameter.toFixed(4);
+var featureGroups = (rows) => [...rowsByType(rows)].map(([key, members]) => typeGroup(key, members));
+var rowsByType = (rows) => {
+  const byType = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = row.type ?? "";
+    byType.set(key, [...byType.get(key) ?? [], row]);
+  }
+  return byType;
+};
+var tagsOf = (rows) => rows.map((r) => r.tag);
+var typeGroup = (key, members) => {
+  const type = key || void 0;
+  const label = featureTypePlural(type);
+  if (!isHoleType(type)) {
+    return {
+      key: `t:${key}`,
+      level: "type",
+      type,
+      label,
+      rows: members,
+      groups: [],
+      tags: tagsOf(members)
+    };
+  }
+  const unread = members.filter((row) => !hasBore(row));
+  const groups = boreGroups(key, members);
+  return {
+    key: `t:${key}`,
+    level: "type",
+    type,
+    label,
+    rows: unread,
+    groups,
+    tags: [...groups.flatMap((group) => group.tags), ...tagsOf(unread)]
+  };
+};
+var boreGroups = (type, members) => [...rowsByBore(members)].sort(([, a], [, b]) => a.bore.diameter - b.bore.diameter).map(
+  ([bore, at]) => ({
+    key: `t:${type}:${bore}`,
+    level: "bore",
+    type,
+    label: at.bore.label,
+    rows: at.rows,
+    groups: [],
+    tags: tagsOf(at.rows)
+  })
+);
+var hasBore = (row) => Boolean(row.bore);
+var rowsByBore = (rows) => {
+  const byBore = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!hasBore(row)) {
+      continue;
+    }
+    const at = byBore.get(boreKey(row.bore));
+    if (at) {
+      at.rows.push(row);
+    } else {
+      byBore.set(boreKey(row.bore), { bore: row.bore, rows: [row] });
+    }
+  }
+  return byBore;
+};
+var allFolders = (views) => views.flatMap((view) => [view, ...allFolders(view.folders)]);
+var rowsOf = (folder) => folder.orientations.flatMap((orientation) => orientation.features);
+var listsTag = (folder, tag) => {
+  const key = tagKey(tag);
+  return rowsOf(folder).some((row) => tagKey(row.tag) === key);
+};
+var folderPath = (setups, folderId) => {
+  const folders = allFolders(setups);
+  const names = [];
+  let at = folders.find((folder) => folder.id === folderId);
+  while (at) {
+    names.unshift(at.name);
+    const parentId = at.parentId;
+    at = parentId ? folders.find((folder) => folder.id === parentId) : void 0;
+  }
+  return names.join(" \u203A ");
+};
+var flatView = (view) => ({
+  ...view,
+  depth: 0,
+  setupId: view.id,
+  parentId: null,
+  toolOrientation: false,
+  isFrame: true,
+  folders: []
+});
+var featureRow = (part, tag) => {
+  const bore = part.featureBore?.(tag);
+  return {
+    tag,
+    label: part.featureLabel(tag),
+    type: part.featureType?.(tag),
+    ...bore ? { bore } : {}
+  };
+};
+var unique = (tags) => [...new Set(tags)];
+var planView = (plan, part) => plan.setups.map(
+  (setup, index) => plannedSetupView(setup, index, plannedDirections(plan, setup, index), part)
+);
+var plannedDirections = (plan, setup, index) => {
+  const stated = plan.setupPlan?.setups[index]?.orientations;
+  if (stated) {
+    return stated.map((orientation) => ({
+      direction: orientation.direction,
+      tags: unique(orientation.features)
+    }));
+  }
+  if (!setup.direction) {
+    return [];
+  }
+  return [
+    {
+      direction: setup.direction,
+      tags: unique(setup.actions.flatMap((action) => action.featureTags))
+    }
+  ];
+};
+var plannedSetupView = (setup, index, directions, part) => {
+  const row = (tag) => featureRow(part, tag);
+  return flatView({
+    id: `setup-${setup.idx}`,
+    name: `Setup ${index + 1}`,
+    process: directions.length > 1 ? "3+2" : "3axis",
+    orientations: directions.map(({ direction, tags }, at) => ({
+      id: `setup-${setup.idx}-${at}`,
+      direction,
+      directionIndex: part.directionIndex(direction),
+      features: tags.map(row)
+    })),
+    notMachined: unique(notMachinedOf(setup)).map(row),
+    notFinished: notFinishedIn(setup),
+    operations: setup.actions.length
+  });
+};
+var planCounts = (setups) => ({
+  setups: setups.length,
+  orientations: allFolders(setups).filter((view) => view.isFrame).reduce((sum, frame) => sum + frame.orientations.length, 0)
+});
+var DONE_COLOR = 6583435;
+var UNMACHINED_FACE_COLOR = 14427686;
+var IGNORED_WEIGHT = 0.6;
+var NOT_MACHINED_WEIGHT = 0.6;
+var PART_WEIGHT = 0.85;
+var OPEN_WEIGHT = 0.8;
+var OTHER_FOLDER_COLOR = 5395026;
+var OTHER_FOLDER_WEIGHT = 0.75;
+var folderRows = ({ setups, openId, colorOf }) => {
+  const folders = allFolders(setups);
+  const open = folders.find((folder) => folder.id === openId);
+  const rows = ownerRowsByTag(folders, colorOf, selectedIn(open));
+  return {
+    open,
+    rowsOf: (face) => face.owners.flatMap((tag) => rows.get(tagKey(tag)) ?? [])
+  };
+};
+var selectedIn = (open) => {
+  const inOpen = new Set(open ? allFolders([open]) : []);
+  const way = open?.orientations[0]?.direction;
+  return (folder, orientation) => inOpen.has(folder) && way !== void 0 && sameDirection(orientation.direction, way);
+};
+var ownerRowsByTag = (folders, colorOf, isSelected) => {
+  const rows = /* @__PURE__ */ new Map();
+  const orientations = folders.flatMap(
+    (folder) => folder.orientations.map((orientation) => ({ folder, orientation }))
+  );
+  for (const { folder, orientation } of orientations) {
+    const selected = isSelected(folder, orientation);
+    for (const feature of orientation.features) {
+      const key = tagKey(feature.tag);
+      rows.set(key, [...rows.get(key) ?? [], { color: colorOf(orientation), selected }]);
+    }
+  }
+  return rows;
+};
+var planPaint = ({
+  uncovered = true,
+  ...input
+}) => {
+  const { faces, everyFolder = true } = input;
+  const { open, rowsOf: rowsOf2 } = folderRows(input);
+  const showing = { folderOpen: open !== void 0, everyFolder };
+  const fromFolder = (face) => folderPaint(face, rowsOf2(face), showing);
+  return [
+    ...faces.pinned.flatMap(fromFolder),
+    ...faces.machined.flatMap(fromFolder),
+    ...faces.ignored.map((face) => facePaint(face, DONE_COLOR, IGNORED_WEIGHT)),
+    ...uncovered ? faces.notMachined.map((face) => facePaint(face, UNMACHINED_FACE_COLOR, NOT_MACHINED_WEIGHT)) : []
+  ];
+};
+var facePaint = (face, color, weight) => ({
+  region: face.region,
+  color,
+  weight
+});
+var folderPaint = (face, own, { folderOpen, everyFolder }) => {
+  const row = own.find((each) => each.selected) ?? own[0];
+  if (!row) {
+    return [];
+  }
+  if (!folderOpen) {
+    return everyFolder ? [facePaint(face, row.color, PART_WEIGHT)] : [];
+  }
+  if (row.selected) {
+    return [facePaint(face, row.color, OPEN_WEIGHT)];
+  }
+  return everyFolder ? [facePaint(face, OTHER_FOLDER_COLOR, OTHER_FOLDER_WEIGHT)] : [];
+};
+var planHatch = (input) => {
+  const { faces, everyFolder = true } = input;
+  const { open, rowsOf: rowsOf2 } = folderRows(input);
+  if (!everyFolder) {
+    return [];
+  }
+  const hatchOf = (face) => {
+    const own = rowsOf2(face);
+    const secondary = open ? own.filter((row) => !row.selected) : own.filter((row) => row.color !== own[0]?.color);
+    const colors = new Set(secondary.map((row) => row.color));
+    return [...colors].map((color) => ({ region: face.region, color }));
+  };
+  return [...faces.pinned.flatMap(hatchOf), ...faces.machined.flatMap(hatchOf)];
+};
+var draftView = (draft, part) => {
+  const placed = placedFolders(draft.setups);
+  const view = (here) => ({
+    id: here.folder.id,
+    name: here.folder.name,
+    process: here.depth === 0 ? here.setup.process ?? "3axis" : "3axis",
+    orientations: [
+      {
+        id: `${here.folder.id}-0`,
+        direction: here.direction,
+        directionIndex: part.directionIndex(here.direction),
+        features: unique(here.folder.features).map((tag) => featureRow(part, tag))
+      }
+    ],
+    depth: here.depth,
+    setupId: here.setup.id,
+    parentId: here.parent?.id ?? null,
+    toolOrientation: here.toolOrientation,
+    isFrame: here.frameId === here.folder.id,
+    folders: placed.filter((child) => child.parent?.id === here.folder.id).map(view)
+  });
+  return placed.filter((each) => each.depth === 0).map(view);
+};
+var refusalClauses = (error) => {
+  if (error?.startsWith("stale_regions:")) {
+    return [
+      "Ignored faces are from an older analysis of this part. Clear them, then ignore them again."
+    ];
+  }
+  if (error?.startsWith("unknown_regions:")) {
+    return [
+      "Some ignored faces are not on this part\u2019s current analysis. Clear them, then ignore them again."
+    ];
+  }
+  if (!error?.startsWith("refused_user_plan:")) {
+    return null;
+  }
+  const listed = error.slice(error.indexOf("refused:") + "refused:".length);
+  return listed.split(";").map((clause) => clause.trim()).filter(Boolean);
+};
+
+// src/pin.ts
+var coversAll = (outer, inner) => {
+  const has = new Set(outer);
+  return inner.length > 0 && inner.every((region) => has.has(region));
+};
+var replacedBy = (setups, tag, regionsOf2) => {
+  const regions = regionsOf2(tag);
+  return pinsWhere(setups, (other) => other !== tag && coversAll(regions, regionsOf2(other)));
+};
+var unignorePinned = (plan, tags, context) => {
+  const ignored = new Set(currentFor(plan.done, plan.doneKernel, context.kernel));
+  const unignored = [...new Set(tags.flatMap((tag) => context.regionsOf(tag)))].filter((region) => ignored.has(region)).sort((a, b) => a - b);
+  return {
+    intent: unignored.length > 0 ? unignoreEdit(plan, unignored, context) : plan,
+    unignored
+  };
+};
+var pinEdit = (plan, tag, at, context) => {
+  const result = "folderId" in at ? pinInto(plan.setups, at.folderId, tag, at.newId) : pinFrom(plan.setups, at.direction, tag, at.newId);
+  if ("refused" in result) {
+    return result;
+  }
+  const { setupId, added, unpinned } = result;
+  if (unpinned) {
+    return {
+      intent: { ...plan, setups: result.setups },
+      setupId,
+      added,
+      unpinned,
+      replaced: [],
+      unignored: []
+    };
+  }
+  return { ...withPin(plan, tag, result.setups, context), setupId, added, unpinned };
+};
+var withPin = (plan, tag, pinned2, context) => {
+  const replaced = replacedBy(plan.setups, tag, context.regionsOf);
+  const setups = replaced.reduce(
+    (all, each) => unpinFeature(all, each.setupId, each.tag),
+    [...pinned2]
+  );
+  return {
+    ...unignorePinned({ ...plan, setups }, [tag], context),
+    replaced: replaced.map((each) => each.tag)
+  };
+};
+var letGo = (plan, tag) => {
+  const was = pinnedIn(plan.setups, tag);
+  return was ? { ...plan, setups: unpinFeature(plan.setups, was, tag) } : plan;
+};
+var takeBack = (plan, saved, tag, context) => {
+  const home = pinnedIn(plan.setups, tag);
+  const pinnedSince = home !== null && home !== pinnedIn(saved.setups, tag);
+  const replaced = pinnedSince ? replacedBy(saved.setups, tag, context.regionsOf) : [];
+  const tags = [.../* @__PURE__ */ new Set([tag, ...replaced.map((each) => each.tag)])];
+  return {
+    ...plan,
+    setups: tags.reduce((all, each) => restoreFeature(all, saved.setups, each), [...plan.setups]),
+    ...pinnedSince ? ignoredAsSaved(plan, saved, context.regionsOf(tag), context.kernel) : {}
+  };
+};
+var folderClick = (plan, feature, folder, context) => {
+  if (feature.inFolder) {
+    return {
+      intent: { ...plan, setups: unpinFeature(plan.setups, folder.id, feature.tag) },
+      note: `${feature.label} taken out of ${folder.name}.`
+    };
+  }
+  const pinned2 = pinHere(plan, feature.tag, folder.id, context);
+  return {
+    intent: pinned2.intent,
+    note: `${feature.label} pinned to ${folder.name}.${unignoredNote(pinned2.unignored)}`
+  };
+};
+var pinHere = (plan, tag, folderId, context) => {
+  if (pinnedIn(plan.setups, tag) === folderId) {
+    return { intent: plan, unignored: [] };
+  }
+  const pinned2 = pinEdit(plan, tag, { folderId }, context);
+  return "refused" in pinned2 ? { intent: plan, unignored: [] } : pinned2;
+};
+var chooseReading = (plan, saved, line, reading, read, folder, context) => {
+  const choice = { plan, saved, line, reading, read, folder, context };
+  return line.target === "pin" ? chosenForPin(choice) : chosenForTakeOut(choice);
+};
+var chosenForPin = ({
+  plan,
+  saved,
+  line,
+  reading,
+  folder,
+  context
+}) => {
+  if (reading === line.tag) {
+    return { intent: plan, chosen: [reading] };
+  }
+  const left = leaving(plan, saved, line.tag, context);
+  return { intent: pinHere(left, reading, folder.id, context).intent, chosen: [reading] };
+};
+var chosenForTakeOut = (choice) => {
+  const { plan, saved, line, reading, folder, context } = choice;
+  const cleared = chosenBefore(choice).reduce((all, tag) => leaving(all, saved, tag, context), plan);
+  const out = pinnedIn(cleared.setups, line.tag) === pinnedIn(plan.setups, line.tag) ? cleared : letGo(cleared, line.tag);
+  return {
+    intent: reading === line.tag ? out : pinHere(out, reading, folder.id, context).intent,
+    chosen: reading === line.tag ? [line.tag] : [reading, line.tag]
+  };
+};
+var leaving = (plan, saved, tag, context) => letGo(takeBack(plan, saved, tag, context), tag);
+var chosenBefore = ({
+  plan,
+  saved,
+  line,
+  reading,
+  read,
+  folder
+}) => read.filter(
+  (each) => each !== line.tag && each !== reading && pinnedIn(plan.setups, each) === folder.id && pinnedIn(saved.setups, each) !== folder.id
+);
+var readingOf = (folders, coverage) => {
+  const faces = facesByRegion(coverage);
+  return { folders, kindOf: (region) => faces.get(region)?.kind ?? "open" };
+};
+var readingDetail = (faces, state, way) => [`${faces} face${faces === 1 ? "" : "s"}`, ...way ? [way] : [], state].join(" \xB7 ");
+var stateOf = (tag, plan, folderId, regionsOf2) => {
+  const faces = regionsOf2(tag);
+  const kind = kindAmong(faces.map(plan.kindOf));
+  const said = (text, folders = []) => stateSaid(text, folders, folderId);
+  if (kind === "ignored") {
+    return said(COVERAGE_LABELS.ignored);
+  }
+  const own = plan.folders.filter((folder) => listsTag(folder, tag));
+  if (own.length > 0) {
+    return said(COVERAGE_LABELS.pinned, own);
+  }
+  const around = pinCovering(plan.folders, faces, regionsOf2);
+  if (around) {
+    return regionsOf2(around.row.tag).length === faces.length ? said(COVERAGE_LABELS.pinned, around.folders) : said(`Part of ${around.row.label}`, around.folders);
+  }
+  const shared = foldersSharing(plan.folders, faces, regionsOf2);
+  if (shared.length > 0 && kind === "pinned") {
+    return said(COVERAGE_LABELS.pinned, shared);
+  }
+  return said(COVERAGE_LABELS[kind]);
+};
+var kindAmong = (kinds) => COVERAGE_KINDS.find((each) => kinds.includes(each)) ?? "open";
+var stateSaid = (text, folders, folderId) => {
+  const first = folders[0];
+  const where = !first || first.id === folderId ? "" : ` in ${first.name}`;
+  const more = folders.length > 1 ? ` +${folders.length - 1}` : "";
+  return { text: `${text}${where}${more}`, folders: folders.map((folder) => folder.id) };
+};
+var pinCovering = (folders, faces, regionsOf2) => {
+  const around = folders.flatMap(
+    (folder) => rowsOf(folder).filter((row) => coversAll(regionsOf2(row.tag), faces)).map((row) => ({ folder, row }))
+  );
+  const first = around[0];
+  if (!first) {
+    return void 0;
+  }
+  return { row: first.row, folders: [...new Set(around.map((each) => each.folder))] };
+};
+var foldersSharing = (folders, faces, regionsOf2) => folders.filter(
+  (folder) => rowsOf(folder).some((row) => regionsOf2(row.tag).some((region) => faces.includes(region)))
+);
+
+// src/draft-action.ts
+var DRAFT_ACTION_KINDS = [
+  "addFolder",
+  "renameFolder",
+  "remove",
+  "moveFolder",
+  "moveWithin",
+  "addSetup",
+  "setProcess",
+  "setToolOrientation",
+  "pinInto",
+  "pinFrom",
+  "moveFeature",
+  "unpin",
+  "ignore",
+  "unignore",
+  "choosePinReading",
+  "chooseIgnoreReading",
+  "fromPlan"
+];
+var NO_FACTS = Object.freeze({
+  replaced: Object.freeze([]),
+  unignored: Object.freeze([]),
+  unpinned: Object.freeze([]),
+  added: false,
+  letGo: false,
+  home: null
+});
+var TOO_MANY = `A plan holds at most ${MAX_SETUPS} setups.`;
+var OTHER_WAY = "Rows stay in folders cut from their own direction.";
+var TAKEN = "That id is taken: each folder needs an id of its own.";
+var NOT_AN_ACTION = "That is not a plan action.";
+var NEEDS_SAVED = "This needs the plan as applied.";
+var NOT_EMPTY = "Start from Toolpath\u2019s plan while the plan holds no folders.";
+var applyDraftAction = (draft, action, rules, saved) => {
+  if (typeof action !== "object" || action === null) {
+    return { refused: NOT_AN_ACTION };
+  }
+  const result = carryOut({ draft, rules, saved }, action);
+  if ("refused" in result) {
+    return result;
+  }
+  const unignored = action.kind === "chooseIgnoreReading" ? [] : ignoredNoLonger(draft, result.draft, rules);
+  return { ...result, facts: { ...NO_FACTS, ...result.facts, unignored } };
+};
+var ignoredNoLonger = (before, after, rules) => {
+  const still = new Set(ignoredIn(after, rules));
+  return ignoredIn(before, rules).filter((region) => !still.has(region)).sort((a, b) => a - b);
+};
+var ignoredIn = (plan, rules) => currentFor(plan.done, plan.doneKernel, rules.kernel);
+var withConstraints = (draft, intent, more = {}) => ({ ...more, draft: { ...draft, ...intent } });
+var withSetups = (draft, setups, folderId) => withConstraints(draft, { ...draft, setups }, folderId ? { folderId } : {});
+var withEdited = (draft, edited, folderId) => Array.isArray(edited) ? withSetups(draft, edited, folderId) : { refused: edited.refused };
+var holds = (draft, id) => findPlaced(draft.setups, id) !== void 0;
+var anyTaken = (draft, ...ids) => ids.some((id) => holds(draft, id)) || new Set(ids).size < ids.length;
+var pinned = ({ draft, rules }, at, tag) => {
+  const pin = pinEdit(draft, tag, at, rules);
+  if ("refused" in pin) {
+    return pin;
+  }
+  return withConstraints(draft, pin.intent, {
+    facts: { replaced: pin.replaced, added: pin.added, letGo: pin.unpinned, home: pin.setupId }
+  });
+};
+var applyAddFolder = ({ draft }, action) => {
+  const parent = findPlaced(draft.setups, action.parentId);
+  if (!parent) {
+    return { refused: GONE };
+  }
+  if (parent.depth >= MAX_DEPTH) {
+    return { refused: TOO_DEEP };
+  }
+  if (anyTaken(draft, action.id, action.workId)) {
+    return { refused: TAKEN };
+  }
+  const setups = addFolder(draft.setups, action.parentId, action.id, action.workId);
+  return withSetups(draft, setups, action.id);
+};
+var applyRenameFolder = ({ draft }, action) => {
+  if (!holds(draft, action.id)) {
+    return { refused: GONE };
+  }
+  return withSetups(draft, renameFolder(draft.setups, action.id, action.name));
+};
+var applyRemove = ({ draft }, action) => {
+  if (!Array.isArray(action.folders)) {
+    return { refused: NOT_AN_ACTION };
+  }
+  const unpinned = (action.features ?? []).reduce(
+    (setups, pin) => unpinFeature(setups, pin.setupId, pin.tag),
+    [...draft.setups]
+  );
+  const folders = action.folders.filter((id) => holds(draft, id));
+  return withSetups(draft, removeFolders(unpinned, folders));
+};
+var applyMoveFolder = ({ draft }, action) => {
+  if (!holds(draft, action.id)) {
+    return { refused: GONE };
+  }
+  if (anyTaken(draft, action.newId)) {
+    return { refused: TAKEN };
+  }
+  const moved = moveFolder(draft.setups, action.id, action.to, action.newId);
+  return withEdited(draft, moved, action.id);
+};
+var applyMoveWithin = ({ draft }, action) => {
+  if (!holds(draft, action.id)) {
+    return { refused: GONE };
+  }
+  if (!Number.isInteger(action.by)) {
+    return { refused: "A folder moves a whole number of places." };
+  }
+  return withSetups(draft, moveWithin(draft.setups, action.id, action.by));
+};
+var applyAddSetup = ({ draft }, action) => {
+  const facing = frameFacing(draft.setups, action.direction);
+  if (facing) {
+    return { refused: `${facing.name} is cut from that direction already.` };
+  }
+  if (draft.setups.length >= MAX_SETUPS) {
+    return { refused: TOO_MANY };
+  }
+  if (anyTaken(draft, action.id)) {
+    return { refused: TAKEN };
+  }
+  return withSetups(draft, addSetup(draft.setups, action.direction, action.id), action.id);
+};
+var applySetProcess = ({ draft }, action) => {
+  if (!draft.setups.some((setup) => setup.id === action.setupId)) {
+    return { refused: holds(draft, action.setupId) ? "Only a setup has a hold." : GONE };
+  }
+  const process = action.process ?? void 0;
+  return withEdited(draft, setSetupProcess(draft.setups, action.setupId, process));
+};
+var applySetToolOrientation = ({ draft }, action) => {
+  if (!holds(draft, action.folderId)) {
+    return { refused: GONE };
+  }
+  return withEdited(draft, setToolOrientation(draft.setups, action.folderId, action.direction));
+};
+var applyPinInto = (editing, action) => {
+  const { setups } = editing.draft;
+  const target = findPlaced(setups, action.folderId);
+  if (!target) {
+    return { refused: GONE };
+  }
+  if (anyTaken(editing.draft, action.newId)) {
+    return { refused: TAKEN };
+  }
+  if (pinnedIn(setups, action.tag) === action.folderId) {
+    return pinned(editing, { folderId: action.folderId }, action.tag);
+  }
+  if (!sameDirection(target.direction, action.direction)) {
+    return { refused: OTHER_WAY };
+  }
+  return pinned(editing, { folderId: action.folderId, newId: action.newId }, action.tag);
+};
+var applyPinFrom = (editing, action) => {
+  if (anyTaken(editing.draft, action.newId)) {
+    return { refused: TAKEN };
+  }
+  return pinned(editing, { direction: action.direction, newId: action.newId }, action.tag);
+};
+var applyMoveFeature = ({ draft, rules }, action) => {
+  if (anyTaken(draft, action.newId)) {
+    return { refused: TAKEN };
+  }
+  const { tag, direction, folderId, newId } = action;
+  const moved = moveFeature(draft.setups, tag, direction, folderId, newId);
+  if (!Array.isArray(moved)) {
+    return { refused: moved.refused };
+  }
+  const pin = withPin(draft, tag, moved, rules);
+  return withConstraints(draft, pin.intent, {
+    folderId: pinnedIn(moved, tag) ?? folderId,
+    facts: { replaced: pin.replaced }
+  });
+};
+var applyUnpin = ({ draft }, action) => {
+  const home = pinnedIn(draft.setups, action.tag);
+  if (!home) {
+    return { draft };
+  }
+  return withSetups(draft, unpinFeature(draft.setups, home, action.tag));
+};
+var applyIgnore = ({ draft, rules }, action) => {
+  if (!Array.isArray(action.regions)) {
+    return { refused: NOT_AN_ACTION };
+  }
+  const ignored = ignoreEdit(draft, action.regions, rules);
+  return withConstraints(draft, ignored.intent, { facts: { unpinned: ignored.unpinned } });
+};
+var applyUnignore = ({ draft, rules }, action) => {
+  if (!Array.isArray(action.regions)) {
+    return { refused: NOT_AN_ACTION };
+  }
+  return withConstraints(draft, unignoreEdit(draft, action.regions, rules));
+};
+var applyChoosePinReading = ({ draft, rules, saved }, action) => {
+  const placed = findPlaced(draft.setups, action.folderId);
+  if (!placed) {
+    return { draft };
+  }
+  if (!saved) {
+    return { refused: NEEDS_SAVED };
+  }
+  const clicked = withClickStanding(draft, action, placed, rules);
+  const chosen = chooseReading(
+    clicked,
+    saved,
+    { tag: action.tag, target: action.target },
+    action.reading,
+    action.readings,
+    { id: action.folderId, direction: placed.direction },
+    rules
+  );
+  return withConstraints(draft, chosen.intent);
+};
+var withClickStanding = (draft, action, placed, rules) => {
+  const inFolder = pinnedIn(draft.setups, action.tag) === action.folderId;
+  const standing = inFolder !== (action.target === "takeOut");
+  if (standing) {
+    return draft;
+  }
+  const feature = { tag: action.tag, label: action.tag, direction: placed.direction, inFolder };
+  const folder = { id: action.folderId, name: placed.folder.name };
+  return folderClick(draft, feature, folder, rules).intent;
+};
+var applyChooseIgnoreReading = ({ draft, rules, saved }, action) => {
+  if (!saved) {
+    return { refused: NEEDS_SAVED };
+  }
+  const clicked = action.click.regions;
+  const ignored = new Set(ignoredIn(draft, rules));
+  const stands = clicked.every((region) => ignored.has(region));
+  if (stands && action.tag === action.click.tag) {
+    return { draft };
+  }
+  const back = stands ? takeBackIgnore(draft, saved, clicked, rules) : draft;
+  const chosen = ignoreEdit(back, rules.regionsOf(action.tag), rules);
+  return withConstraints(draft, chosen.intent, { facts: { unpinned: chosen.unpinned } });
+};
+var applyFromPlan = ({ draft, rules }, action) => {
+  if (draft.setups.length > 0) {
+    return { refused: NOT_EMPTY };
+  }
+  let count = 0;
+  const newId = () => `${action.idSeed}-${count++}`;
+  if (!action.pins) {
+    return withSetups(draft, foldersFromPlan(action.planned, newId));
+  }
+  const stated = planFromResults(action.planned, newId);
+  const tags = pinsWhere(stated, () => true).map((pin) => pin.tag);
+  return withConstraints(draft, unignorePinned({ ...draft, setups: stated }, tags, rules).intent);
+};
+var CARRY_OUT = {
+  addFolder: applyAddFolder,
+  renameFolder: applyRenameFolder,
+  remove: applyRemove,
+  moveFolder: applyMoveFolder,
+  moveWithin: applyMoveWithin,
+  addSetup: applyAddSetup,
+  setProcess: applySetProcess,
+  setToolOrientation: applySetToolOrientation,
+  pinInto: applyPinInto,
+  pinFrom: applyPinFrom,
+  moveFeature: applyMoveFeature,
+  unpin: applyUnpin,
+  ignore: applyIgnore,
+  unignore: applyUnignore,
+  choosePinReading: applyChoosePinReading,
+  chooseIgnoreReading: applyChooseIgnoreReading,
+  fromPlan: applyFromPlan
+};
+var carryOut = (editing, action) => {
+  if (!Object.hasOwn(CARRY_OUT, action.kind)) {
+    return { refused: NOT_AN_ACTION };
+  }
+  const carry = CARRY_OUT[action.kind];
+  return carry(editing, action);
+};
+var actionsFor = (draft, target, rules) => {
+  const allowed = new Set(actionsOn(draft, target, rules.kernel));
+  return DRAFT_ACTION_KINDS.filter((kind) => allowed.has(kind));
+};
+var actionsOn = (draft, target, kernel) => {
+  if ("folder" in target) {
+    return folderActions(draft.setups, target.folder);
+  }
+  if ("feature" in target) {
+    return featureActions(draft.setups, target.feature, target.direction);
+  }
+  if ("faces" in target) {
+    return faceActions(draft, target.faces, kernel);
+  }
+  return partActions(draft.setups);
+};
+var when = (yes, ...kinds) => yes ? kinds : [];
+var partActions = (setups) => [
+  ...when(setups.length < MAX_SETUPS, "addSetup"),
+  ...when(setups.length > 0, "remove")
+];
+var folderActions = (setups, id) => {
+  const placed = findPlaced(setups, id);
+  if (!placed) {
+    return [];
+  }
+  const top = placed.depth === 0;
+  const beside = top ? setups : placed.parent?.folders ?? [];
+  const toolOriented = isIndexed(placed.setup) || placed.toolOrientation;
+  return [
+    "renameFolder",
+    "remove",
+    ...when(placed.depth < MAX_DEPTH, "addFolder"),
+    ...when(beside.length > 1, "moveWithin", "moveFolder"),
+    ...when(canMoveAway(setups, placed.folder.id, placed.parent?.id ?? null), "moveFolder"),
+    ...when(top, "setProcess"),
+    ...when(!top && toolOriented, "setToolOrientation")
+  ];
+};
+var canMoveAway = (setups, id, parentId) => {
+  const landings = [null, ...placedFolders(setups).map((placed) => placed.folder.id)].filter(
+    (landing) => landing !== parentId && landing !== id
+  );
+  return landings.some(
+    (landing) => Array.isArray(moveFolder(setups, id, { parentId: landing, index: 0 }))
+  );
+};
+var PROBE_ID = "\0probe";
+var featureActions = (setups, tag, direction) => {
+  const home = pinnedIn(setups, tag);
+  const facingIds = placedFolders(setups).filter((each) => each.folder.id !== home && sameDirection(each.direction, direction)).map((each) => each.folder.id);
+  return [
+    ...when(facingIds.length > 0, "pinInto"),
+    ...when(canPinFromItsWay(setups, home, direction), "pinFrom"),
+    ...when(canMoveFeature(setups, tag, direction, facingIds), "moveFeature"),
+    ...when(home !== null, "unpin")
+  ];
+};
+var canPinFromItsWay = (setups, home, direction) => {
+  const frame = frameFacing(setups, direction);
+  if (!frame) {
+    return setups.length < MAX_SETUPS;
+  }
+  const inFrame = home !== null && placedFolders(setups).some((each) => each.folder.id === home && each.frameId === frame.id);
+  return !inFrame;
+};
+var canMoveFeature = (setups, tag, direction, facingIds) => {
+  const home = pinnedIn(setups, tag);
+  return facingIds.some((folderId) => {
+    const moved = moveFeature(setups, tag, direction, folderId, PROBE_ID);
+    return Array.isArray(moved) && pinnedIn(moved, tag) !== home;
+  });
+};
+var faceActions = (draft, regions, kernel) => {
+  const ignored = new Set(currentFor(draft.done, draft.doneKernel, kernel));
+  const anyOpen = regions.some((region) => !ignored.has(region));
+  const anyIgnored = regions.some((region) => ignored.has(region));
+  return [...when(anyOpen, "ignore"), ...when(anyIgnored, "unignore")];
+};
+
+// src/folder-sort.ts
+var heightOf2 = (folder) => folder.folders.length === 0 ? 0 : 1 + Math.max(...folder.folders.map(heightOf2));
+var flattenFolders = (setups, isOpen, carriedId = null) => {
+  const walk = (folder) => [
+    { id: folder.id, parentId: folder.parentId, depth: folder.depth, height: heightOf2(folder) },
+    ...folder.id !== carriedId && isOpen(folder.id) ? folder.folders.flatMap(walk) : []
+  ];
+  return setups.flatMap(walk);
+};
+var projectFolder = (items, activeId, gap, offsetX, indent, maxDepth) => {
+  const active = items.find((item) => item.id === activeId);
+  if (!active) {
+    return null;
+  }
+  const rest = items.filter((item) => item.id !== activeId);
+  const index = Math.max(0, Math.min(gap, rest.length));
+  const moved = [...rest.slice(0, index), active, ...rest.slice(index)];
+  const wanted = active.depth + Math.round(offsetX / indent);
+  const depth = depthAllowed(moved, index, wanted, maxDepth);
+  const parentId = parentAt(moved, index, depth);
+  const unmoved = moved.every((item, at) => item.id === items[at]?.id);
+  if (unmoved && depth === active.depth) {
+    return { depth, parentId, at: null };
+  }
+  return { depth, parentId, at: dropAtFor(moved, index, depth, parentId) };
+};
+var depthAllowed = (moved, index, wanted, maxDepth) => {
+  const active = moved[index];
+  const previous = moved[index - 1];
+  const next = moved[index + 1];
+  const deepest = Math.min(previous ? previous.depth + 1 : 0, maxDepth - active.height);
+  const shallowest = Math.min(next ? next.depth : 0, deepest);
+  return Math.max(shallowest, Math.min(wanted, deepest));
+};
+var parentAt = (moved, index, depth) => {
+  const previous = moved[index - 1];
+  if (depth === 0 || !previous) {
+    return null;
+  }
+  if (depth > previous.depth) {
+    return previous.id;
+  }
+  const above = moved.slice(0, index).reverse().find((item) => item.depth === depth);
+  return above?.parentId ?? null;
+};
+var gapAt = (centres, activeId, y) => centres.filter((row) => row.id !== activeId && row.centreY < y).length;
+var dropAtFor = (moved, index, depth, parentId) => {
+  for (const item of moved.slice(0, index).reverse()) {
+    if (item.depth < depth) {
+      break;
+    }
+    if (item.depth === depth) {
+      return { id: item.id, zone: "after" };
+    }
+  }
+  for (const item of moved.slice(index + 1)) {
+    if (item.depth < depth) {
+      break;
+    }
+    if (item.depth === depth) {
+      return { id: item.id, zone: "before" };
+    }
+  }
+  return parentId ? { id: parentId, zone: "inside" } : { id: PART_ROW, zone: "first" };
+};
+
+// src/plan-checks.ts
+var planChecks = (draft, context) => {
+  if (!statementOf(draft.setups)) {
+    return [];
+  }
+  const stated = framesOf(draft.setups);
+  return [
+    ...stated.flatMap((frame) => frameChecks(frame, context)),
+    ...otherWayChecks(draft.setups, context),
+    ...kernelChecks(draft, stated, context)
+  ];
+};
+var frameChecks = (frame, context) => [
+  ...analysisChecks(frame.name, directionAnalysis(frame.direction, context.directions)),
+  // One check for each pin of a feature the part does not have.
+  ...Array.from(
+    { length: frame.features.filter((tag) => isUnknownFeature(tag, context)).length },
+    () => ({
+      tone: "blocking",
+      text: `A feature pinned in ${frame.name} is not one of this part\u2019s. Unpin it.`
+    })
+  )
+];
+var NOT_ANALYZED = {
+  undetected: (name) => `${name} faces a direction the part was not analyzed from. Delete it and add it again.`,
+  analyzing: (name) => `Toolpath is analyzing ${name}\u2019s direction. Its features arrive when it is done.`,
+  unanalyzed: (name) => `Toolpath has not analyzed ${name}\u2019s direction. Open ${name} and analyze it.`
+};
+var analysisChecks = (name, analysis) => {
+  if (analysis === "analyzed") {
+    return [];
+  }
+  return [
+    {
+      tone: analysis === "analyzing" ? "warning" : "blocking",
+      text: NOT_ANALYZED[analysis](name)
+    }
+  ];
+};
+var isUnknownFeature = (tag, context) => {
+  const feature = context.feature(tag);
+  return Boolean(context.directions.analyzed) && !feature;
+};
+var otherWayChecks = (setups, context) => placedFolders(setups).flatMap(
+  (placed) => placed.folder.features.flatMap((tag) => {
+    const feature = context.feature(tag);
+    if (!feature?.direction || sameDirection(feature.direction, placed.direction)) {
+      return [];
+    }
+    return [
+      {
+        tone: "blocking",
+        text: `${feature.label} is cut from another direction than ${placed.folder.name}. Move it to a folder facing its way, or unpin it.`
+      }
+    ];
+  })
+);
+var kernelChecks = (draft, stated, context) => {
+  const pinned2 = stated.some((frame) => frame.features.length > 0);
+  const kernelMoved = draft.kernelVersion && context.kernelVersion && draft.kernelVersion !== context.kernelVersion;
+  if (!pinned2 || !kernelMoved) {
+    return [];
+  }
+  return [
+    {
+      tone: "warning",
+      text: "Toolpath has been updated since these features were pinned. If they are refused, pin them again."
+    }
+  ];
+};
+var sameTag = (a, b) => a.replace(/^0+/, "").toLowerCase() === b.replace(/^0+/, "").toLowerCase();
+var describeClause = (clause, draft, label, tags) => clause.replace(/\bsetup (\d+)(, orientation \d+)?/, (whole, index) => {
+  const setup = framesOf(draft.setups)[Number(index)];
+  return setup ? setup.name : whole;
+}).replace(/FeatureTag\(([0-9a-fA-F]+)\)/g, (whole, hex) => {
+  const tag = tags.find((candidate) => sameTag(candidate, hex));
+  return (tag && label(tag)) ?? whole;
+}).replace(
+  / is not among the features offered$/,
+  " could not be measured, so Toolpath cannot plan it \u2014 unpin it, or pin its faces as another feature"
+);
+var changedSinceResults = (changed, setups) => changed && setups > 0;
+var confirmChecks = (own, context) => [
+  ...own.filter((check) => check.tone !== "info"),
+  ...changedChecks(context.changed),
+  ...notMachinedChecks(context.notMachined),
+  ...setupChecks(context.setups),
+  ...emptyFolderChecks(context.folders)
+];
+var featuresCounted = (count) => `${count} feature${count === 1 ? "" : "s"}`;
+var changedChecks = (changed) => changed ? [{ tone: "info", text: "Constraints changed since these results." }] : [];
+var notMachinedChecks = (notMachined) => {
+  if (notMachined === null) {
+    return [];
+  }
+  if (notMachined > 0) {
+    return [
+      {
+        tone: "warning",
+        text: `${featuresCounted(notMachined)} nothing machines.`,
+        show: { kind: "notMachined" }
+      }
+    ];
+  }
+  return [{ tone: "ok", text: "Every face that needs machining is machined." }];
+};
+var setupChecks = (setups) => {
+  const count = countOf(setups, cutByNoneOf);
+  const roughCount = countOf(setups, notFinishedOf2);
+  const checks = [];
+  if (roughCount > 0) {
+    checks.push(notFinishedCheck(roughCount, firstWith(setups, notFinishedOf2)));
+  }
+  if (count > 0) {
+    checks.push({
+      tone: "warning",
+      text: `${featuresCounted(count)} can\u2019t be cut as planned.`,
+      show: { kind: "setup", idx: firstWith(setups, cutByNoneOf).idx }
+    });
+  } else if (roughCount === 0 && setups.length > 0) {
+    checks.push({ tone: "ok", text: "Every setup can cut what is in it." });
+  }
+  return checks;
+};
+var notFinishedOf2 = (setup) => setup.notMachined.filter((tag) => setup.notFinished.includes(tag));
+var cutByNoneOf = (setup) => setup.notMachined.filter((tag) => !setup.notFinished.includes(tag));
+var countOf = (setups, left) => setups.reduce((sum, setup) => sum + left(setup).length, 0);
+var firstWith = (setups, left) => setups.find((setup) => left(setup).length > 0);
+var notFinishedCheck = (count, first) => {
+  const them = count === 1 ? "it" : "them";
+  return {
+    tone: "warning",
+    text: `${featuresCounted(count)} not finished: Toolpath roughs ${them}, but no pass finishes ${them}.`,
+    show: { kind: "setup", idx: first.idx }
+  };
+};
+var emptyFolderChecks = (folders) => {
+  const empty = folders.filter((folder) => !folder.machined);
+  if (!empty[0]) {
+    return [];
+  }
+  return [
+    {
+      tone: "warning",
+      text: `${empty.length} folder${empty.length === 1 ? " has nothing in it" : "s have nothing in them"}.`,
+      show: { kind: "folder", setupId: empty[0].id }
+    }
+  ];
+};
+var allClear = (checks) => checks.every((check) => check.tone === "ok");
+
+// src/same-json.ts
+var sortedKeys = (value) => Array.isArray(value) ? value.map(sortedKeys) : typeof value === "object" && value !== null ? Object.fromEntries(
+  Object.keys(value).sort().map((key) => [key, sortedKeys(value[key])])
+) : value;
+var sameJson = (a, b) => JSON.stringify(sortedKeys(a)) === JSON.stringify(sortedKeys(b));
+
+// src/plan-session.ts
+var HISTORY = 100;
+var CONSTRAINT_KEYS = {
+  setups: true,
+  done: true,
+  doneKernel: true
+};
+var isConstraint = (key) => Object.hasOwn(CONSTRAINT_KEYS, key);
+var fieldsOnly = (change) => Object.fromEntries(Object.entries(change).filter(([key]) => !isConstraint(key)));
+var EDITS = ["act", "edit", "undo", "redo", "discard"];
+var sameOf = (rules) => rules.same ?? ((a, b) => a === b || sameJson(a, b));
+var followSaved = (held, was, now) => {
+  const next = { ...held };
+  for (const key of Object.keys(now)) {
+    if (!isConstraint(key) && sameJson(held[key], was[key])) {
+      next[key] = now[key];
+    }
+  }
+  return next;
+};
+var startSession = (saved, { held, version } = {}) => ({
+  saved,
+  draft: held ?? saved,
+  past: [],
+  future: [],
+  run: null,
+  refused: null,
+  folderId: null,
+  facts: null,
+  version: version ?? null
+});
+var isHeld = (session, rules = {}) => !sameOf(rules)(session.draft, session.saved);
+var canUndo = (session, rules = {}) => !rules.locked && session.past.length > 0;
+var canRedo = (session, rules = {}) => !rules.locked && session.future.length > 0;
+var planSession = (session, event, rules) => {
+  const same = sameOf(rules);
+  if (rules.locked && EDITS.includes(event.type)) {
+    return session;
+  }
+  const settled = settle(session);
+  if (!Object.hasOwn(TAKE, event.type)) {
+    return settled;
+  }
+  const take = TAKE[event.type];
+  return take({ session, settled, rules, same }, event);
+};
+var settle = (session) => session.refused === null && session.folderId === null && session.facts === null ? session : { ...session, refused: null, folderId: null, facts: null };
+var takeAct = ({ session, settled, rules, same }, event) => {
+  const result = applyDraftAction(session.draft, event.action, rules, session.saved);
+  if ("refused" in result) {
+    return { ...settled, refused: result.refused };
+  }
+  const next = step(settled, result.draft, event.coalesce, same);
+  return { ...next, folderId: result.folderId ?? null, facts: result.facts };
+};
+var takeEdit = ({ session, settled, same }, event) => {
+  const fields = fieldsOnly(event.change(session.draft));
+  return step(settled, { ...session.draft, ...fields }, event.coalesce, same);
+};
+var takeDiscard = ({
+  session,
+  settled,
+  same
+}) => step(settled, session.saved, void 0, same);
+var takeUndo = ({ session, settled }) => {
+  const back = session.past.at(-1);
+  if (back === void 0) {
+    return settled;
+  }
+  return {
+    ...settled,
+    draft: back,
+    past: session.past.slice(0, -1),
+    future: [session.draft, ...session.future],
+    run: null
+  };
+};
+var takeRedo = ({ session, settled }) => {
+  const [forward, ...rest] = session.future;
+  if (forward === void 0) {
+    return settled;
+  }
+  return {
+    ...settled,
+    draft: forward,
+    past: [...session.past, session.draft],
+    future: rest,
+    run: null
+  };
+};
+var takeApplied = ({ session, settled }, event) => {
+  if (older(session, event.version)) {
+    return settled;
+  }
+  return { ...settled, saved: event.sent, run: null, version: event.version ?? session.version };
+};
+var takeRead = ({ session, settled, rules, same }, event) => {
+  if (older(session, event.version)) {
+    return settled;
+  }
+  const held = !same(session.draft, session.saved);
+  const rebase = rules.rebase ?? followSaved;
+  return {
+    ...settled,
+    saved: event.saved,
+    draft: held ? rebase(session.draft, session.saved, event.saved) : event.saved,
+    run: null,
+    version: event.version ?? session.version
+  };
+};
+var older = (session, version) => version !== void 0 && session.version !== null && version < session.version;
+var step = (session, next, coalesce, same) => {
+  if (same(next, session.draft)) {
+    return session;
+  }
+  const joined = coalesce !== void 0 && session.run?.key === coalesce ? session.run : null;
+  const moved = { ...session, draft: next, future: [] };
+  if (joined && same(next, joined.before)) {
+    return { ...moved, past: session.past.slice(0, -1), run: null };
+  }
+  if (joined) {
+    return moved;
+  }
+  return {
+    ...moved,
+    past: [...session.past.slice(-(HISTORY - 1)), session.draft],
+    run: coalesce === void 0 ? null : { key: coalesce, before: session.draft }
+  };
+};
+var TAKE = {
+  act: takeAct,
+  edit: takeEdit,
+  undo: takeUndo,
+  redo: takeRedo,
+  discard: takeDiscard,
+  applied: takeApplied,
+  read: takeRead
+};
+
+// src/results-view.ts
+var EMPTY = { setups: [], leftOut: [] };
+var resultsView = ({
+  plan,
+  constraints,
+  part
+}) => {
+  if (!plan) {
+    return EMPTY;
+  }
+  const frames = framesOf(constraints?.setups ?? []);
+  const planned = planView(plan, part).map((view, idx) => ({
+    view,
+    idx,
+    facing: framesFacing(view, frames)
+  }));
+  const matched = new Set(planned.flatMap(({ facing }) => facing.map((frame) => frame.id)));
+  return {
+    setups: planned.map((each) => resultsSetup(each, plan.setups[each.idx], frames)),
+    leftOut: frames.filter((frame) => !matched.has(frame.id)).map((frame) => ({ folderId: frame.id, name: frameName(frame, frames) }))
+  };
+};
+var frameName = (frame, frames) => {
+  const hold = frame.id === frame.holdId ? null : frames.find((each) => each.id === frame.holdId);
+  return hold ? `${hold.name} \u203A ${frame.name}` : frame.name;
+};
+var framesFacing = (view, frames) => view.orientations.flatMap((orientation) => {
+  const frame = frames.find((each) => sameDirection(each.direction, orientation.direction));
+  return frame ? [frame] : [];
+});
+var resultsSetup = ({ view, idx, facing }, setup, frames) => {
+  const frame = facing[0];
+  return {
+    ...view,
+    idx,
+    name: frame ? frameName(frame, frames) : view.name,
+    rows: setupRows(view, setup),
+    fromFolder: frame?.id ?? null
+  };
+};
+var setupRows = (view, setup) => {
+  const listed = listedOnce(view);
+  const listedKeys = new Set(listed.map((feature) => feature.tag.toLowerCase()));
+  const unlisted = view.notMachined.filter((each) => !listedKeys.has(each.tag.toLowerCase()));
+  const notFinished = new Set(view.notFinished.map((tag) => tag.toLowerCase()));
+  const notMachined = new Set(view.notMachined.map((row) => row.tag.toLowerCase()));
+  return [...listed, ...unlisted].map((feature) => {
+    const key = feature.tag.toLowerCase();
+    return {
+      ...feature,
+      tool: toolsCutting(setup, key),
+      mark: markOf(key, notFinished, notMachined)
+    };
+  });
+};
+var listedOnce = (view) => {
+  const keys = /* @__PURE__ */ new Set();
+  return view.orientations.flatMap((orientation) => orientation.features).filter((feature) => {
+    const key = feature.tag.toLowerCase();
+    if (keys.has(key)) {
+      return false;
+    }
+    keys.add(key);
+    return true;
+  });
+};
+var toolsCutting = (setup, key) => {
+  const cuts = (action) => (action.featureTags ?? []).some((tag) => tag.toLowerCase() === key);
+  const tools = [...new Set(setup.actions.filter(cuts).map((action) => action.toolName))];
+  return tools.length > 0 ? tools.join(", ") : null;
+};
+var markOf = (key, notFinished, notMachined) => {
+  if (notFinished.has(key)) {
+    return "notFinished";
+  }
+  return notMachined.has(key) ? "notMachined" : false;
+};
+var setupOf = (setups, tag) => {
+  const key = tag.toLowerCase();
+  return setups.find(
+    (setup) => setup.rows.some((row) => row.tag.toLowerCase() === key && row.mark !== "notMachined")
+  ) ?? null;
+};
+
+// src/units.ts
+import { MM_PER_INCH } from "@toolpath/tool-support";
+var isUnits = (value) => value === "in" || value === "mm";
+var KG_M3_PER_LB_IN3 = 27679.9047;
+var LB_PER_KG = 2.2046226;
+var FT_PER_M = 3.2808399;
+var trim = (value, places) => String(Number(value.toFixed(places)));
+var formatLength = (mm2, units) => units === "mm" ? `${trim(mm2, 3)} mm` : `${trim(mm2 / MM_PER_INCH, 4)}"`;
+var formatDimensions = (sizeMm, units, shape = "box") => {
+  const axes = shape === "cylinder" ? [sizeMm.length, sizeMm.height] : [sizeMm.length, sizeMm.width, sizeMm.height];
+  const prefix = shape === "cylinder" ? "\xD8 " : "";
+  return units === "mm" ? `${prefix}${axes.map((value) => trim(value, 2)).join(" x ")} mm` : `${prefix}${axes.map((value) => trim(value / MM_PER_INCH, 3)).join(" x ")} in`;
+};
+var formatArea = (mm2, units) => units === "mm" ? `${trim(mm2, 1)} mm\xB2` : `${trim(mm2 / MM_PER_INCH ** 2, 3)} in\xB2`;
+var formatFeed = (mmPerMin, units) => units === "mm" ? `${Math.round(mmPerMin)} mm/min` : `${trim(mmPerMin / MM_PER_INCH, 1)} in/min`;
+var formatSurfaceSpeed = (mPerMin, units) => units === "mm" ? `${trim(mPerMin, 1)} m/min` : `${Math.round(mPerMin * FT_PER_M)} SFM`;
+var formatWeight = (kg, units) => units === "mm" ? `${trim(kg, 3)} kg` : `${trim(kg * LB_PER_KG, 3)} lb`;
+var PRECISION = {
+  // A tenth of a kg/m³ is under 0.000004 lb/in³, well inside the fourth place a datasheet prints.
+  density: { mm: 1, in: 4 },
+  // A thousandth of a millimetre is 0.00004", inside half a ten-thousandth of an inch.
+  length: { mm: 3, in: 4 },
+  // Unitless: the same in either system.
+  ratio: { mm: 2, in: 2 },
+  angle: { mm: 1, in: 1 },
+  // Whole things — flutes — in either system.
+  count: { mm: 0, in: 0 }
+};
+var IMPERIAL_PER_METRIC = {
+  density: 1 / KG_M3_PER_LB_IN3,
+  length: 1 / MM_PER_INCH,
+  ratio: 1,
+  angle: 1,
+  count: 1
+};
+var roundTo = (value, places) => Number(value.toFixed(places));
+var toStored = (quantity, value) => roundTo(value, PRECISION[quantity].mm);
+var toInput = (quantity, canonical, units) => roundTo(
+  units === "mm" ? canonical : canonical * IMPERIAL_PER_METRIC[quantity],
+  PRECISION[quantity][units]
+);
+var fromInput = (quantity, shown, units) => toStored(quantity, units === "mm" ? shown : shown / IMPERIAL_PER_METRIC[quantity]);
+var stepFor = (quantity, units) => {
+  const places = PRECISION[quantity][units];
+  return places === 0 ? "1" : `0.${"0".repeat(places - 1)}1`;
+};
+var densityUnit = (units) => units === "in" ? "lb/in\xB3" : "kg/m\xB3";
+var parseToolLength = (text, units) => {
+  const cleaned = text.trim().replace(/\s*("|in|mm)$/i, "").trim();
+  const mixed = /^(?:(\d+)[\s-]+)?(\d+)\/(\d+)$/.exec(cleaned);
+  const shown = mixed ? Number(mixed[1] ?? 0) + Number(mixed[2]) / Number(mixed[3]) : /^(\d+\.?\d*|\.\d+)$/.test(cleaned) ? Number(cleaned) : Number.NaN;
+  return Number.isFinite(shown) && shown >= 0 ? fromInput("length", shown, units) : void 0;
+};
+
+// src/stock.ts
+var STOCK_LABELS = {
+  automaticFlatBar: "Flat Bar",
+  automaticRoundStock: "Round Stock",
+  fixedBox: "Fixed Box",
+  fixedCylinder: "Fixed Cylinder"
+};
+var FLAT_BAR_FIELDS = [
+  ["oversizeX", "Width (X)"],
+  ["oversizeY", "Depth (Y)"],
+  ["oversizeZTop", "Thickness (Z)"],
+  ["snapX", "Width (X)"],
+  ["snapY", "Depth (Y)"],
+  ["snapZ", "Thickness (Z)"],
+  ["oversizeZBottom", "Stock Grip Amt."]
+];
+var ROUND_STOCK_FIELDS = [
+  ["radialOversize", "Radial"],
+  ["axialOversize", "Front"],
+  ["diaRoundToNearest", "Diameter"],
+  ["lengthRoundToNearest", "Length"],
+  ["gripStock", "Stock Grip Amt."]
+];
+var defaultStock = (mode = "automaticFlatBar", units = "in") => {
+  const oversize = units === "in" ? 0.762 : 0.5;
+  const increment = units === "in" ? 6.35 : 5;
+  return mode === "automaticFlatBar" ? {
+    mode,
+    oversizeX: oversize,
+    oversizeY: oversize,
+    oversizeZTop: oversize,
+    oversizeZBottom: increment,
+    snapX: increment,
+    snapY: increment,
+    snapZ: increment
+  } : {
+    mode,
+    radialOversize: oversize,
+    axialOversize: oversize,
+    gripStock: increment,
+    diaRoundToNearest: increment,
+    lengthRoundToNearest: increment,
+    // Milling flow: stand the round along the first cutting direction, explicitly.
+    verticalAxis: true
+  };
+};
+var ENVELOPE_MM = [2032, 1270, 762];
+var CHOOSE_STOCK = "Choose automatic stock, a fixed box or a fixed cylinder.";
+var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var mm = (value, min, max) => typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+var parseStock = (value) => {
+  if (!record(value)) {
+    return CHOOSE_STOCK;
+  }
+  const { mode } = value;
+  if (mode === "automaticFlatBar" || mode === "automaticRoundStock") {
+    return parseAutomaticStock(value, mode);
+  }
+  if (mode !== "fixedBox" && mode !== "fixedCylinder") {
+    return CHOOSE_STOCK;
+  }
+  return parseFixedStock(value, mode);
+};
+var hasUnknownKey = (value, allowed) => Object.keys(value).some((key) => !allowed.includes(key));
+var parseAutomaticStock = (value, mode) => {
+  const fields = mode === "automaticFlatBar" ? FLAT_BAR_FIELDS : ROUND_STOCK_FIELDS;
+  const keys = fields.map(([key]) => key);
+  const allowed = ["mode", ...keys, ...mode === "automaticRoundStock" ? ["verticalAxis"] : []];
+  if (hasUnknownKey(value, allowed)) {
+    return "The automatic stock contains an unknown setting.";
+  }
+  if (keys.some((key) => value[key] !== void 0 && !mm(value[key], 0, 762))) {
+    return "Stock oversize, grip and rounding must be between 0 and 30 in (762 mm).";
+  }
+  if (mode === "automaticRoundStock" && value.verticalAxis !== void 0 && typeof value.verticalAxis !== "boolean") {
+    return "Choose whether Round Stock stands along the cutting direction.";
+  }
+  return value;
+};
+var parseFixedStock = (value, mode) => {
+  const allowed = [
+    "mode",
+    "position",
+    "positionOffset",
+    ...mode === "fixedBox" ? ["dimensions"] : ["diameter", "length"]
+  ];
+  if (hasUnknownKey(value, allowed)) {
+    return "The fixed stock contains an unknown setting.";
+  }
+  if (!["modelCentered", "offsetFromTop", "offsetFromBottom"].includes(String(value.position))) {
+    return "Choose the stock position.";
+  }
+  if (value.positionOffset !== void 0 && !mm(value.positionOffset, -2032, 2032)) {
+    return "The stock position offset must be between -80 and 80 in (-2032 and 2032 mm).";
+  }
+  const sizeProblem = mode === "fixedBox" ? fixedBoxSizeProblem(value.dimensions) : fixedCylinderSizeProblem(value);
+  return sizeProblem ?? value;
+};
+var positiveSide = (n) => mm(n, 0, 2032) && n > 0;
+var outsideEnvelope = (sides) => [...sides].sort((a, b) => b - a).some((n, i) => n > ENVELOPE_MM[i]);
+var fixedBoxSizeProblem = (dims) => {
+  if (!record(dims) || hasUnknownKey(dims, ["x", "y", "z"]) || ![dims.x, dims.y, dims.z].every(positiveSide)) {
+    return "Give the fixed box positive X, Y and Z dimensions.";
+  }
+  if (outsideEnvelope([dims.x, dims.y, dims.z])) {
+    return "The box must fit within 80 \xD7 50 \xD7 30 in in some order.";
+  }
+  return null;
+};
+var fixedCylinderSizeProblem = (value) => {
+  if (![value.diameter, value.length].every(positiveSide)) {
+    return "Give the fixed cylinder a positive diameter and length.";
+  }
+  const { diameter, length } = value;
+  if (outsideEnvelope([diameter, diameter, length])) {
+    return "The cylinder\u2019s diameter \xD7 diameter \xD7 length must fit within 80 \xD7 50 \xD7 30 in in some order.";
+  }
+  return null;
+};
+var sameStock = (a, b) => sameJson(a ?? null, b ?? null);
+var stockEdited = (policy, baseline) => policy ? !echoesStock(policy, baseline?.stock) : false;
+var AXES = ["x", "y", "z"];
+var AXIS_TOLERANCE = 1e-6;
+var FIT_TOLERANCE_MM = 1e-6;
+var NO_FIRST_FOLDER = "Add a folder first: a fixed box is measured from the first setup.";
+var TILTED_FIRST_FOLDER = "A fixed box needs a first folder facing along X, Y or Z.";
+var BOX_ENVELOPE = "The box must fit 80 \xD7 50 in across the first folder\u2019s direction and 30 in along it.";
+var FIX_STOCK_FIRST = "Fix the stock first";
+var axisAlong = (direction) => {
+  const along = AXES.filter((axis2) => Math.abs(direction[axis2]) > AXIS_TOLERANCE);
+  const axis = along.length === 1 ? along[0] : null;
+  return axis ? { axis, sign: direction[axis] > 0 ? 1 : -1 } : null;
+};
+var boxFrameOf = (first) => first === null ? NO_FIRST_FOLDER : axisAlong(first) ?? TILTED_FIRST_FOLDER;
+var across = (axis) => AXES.filter((each) => each !== axis);
+var stockRequest = (stock, first) => {
+  if (stock.mode !== "fixedBox") {
+    return stock;
+  }
+  const frame = boxFrameOf(first);
+  if (typeof frame === "string") {
+    return frame;
+  }
+  const [a, b] = across(frame.axis);
+  const { dimensions } = stock;
+  const sent = { x: dimensions[a], y: dimensions[b], z: dimensions[frame.axis] };
+  const [length, width, depth] = ENVELOPE_MM;
+  return Math.max(sent.x, sent.y) > length + FIT_TOLERANCE_MM || Math.min(sent.x, sent.y) > width + FIT_TOLERANCE_MM || sent.z > depth + FIT_TOLERANCE_MM ? BOX_ENVELOPE : { ...stock, dimensions: sent };
+};
+var vectorOf = (value) => record(value) && [value.x, value.y, value.z].every((n) => typeof n === "number") ? { x: value.x, y: value.y, z: value.z } : null;
+var placedAlong = (envelope) => {
+  const resolved = record(envelope) ? envelope.resolved : null;
+  const input = record(envelope) ? envelope.input : null;
+  if (record(resolved) && resolved.shape === "cylinder") {
+    const stood = record(input) && (input.mode === "fixedCylinder" || input.mode === "automaticRoundStock" && input.verticalAxis === true);
+    const along = stood ? vectorOf(resolved.axis) : null;
+    const axis = along && axisAlong(along);
+    return axis ? { x: 0, y: 0, z: 0, [axis.axis]: axis.sign } : null;
+  }
+  return vectorOf(record(resolved) && record(resolved.frame) ? resolved.frame.axis : null);
+};
+var echoesStock = (policy, envelope) => {
+  const sent = parseStock(record(envelope) ? envelope.input : void 0);
+  if (typeof sent === "string") {
+    return false;
+  }
+  if (policy.mode !== "fixedBox") {
+    return sameStock(policy, sent);
+  }
+  const placed = placedAlong(envelope);
+  const firsts = placed ? [placed] : AXES.map((axis) => ({ x: 0, y: 0, z: 0, [axis]: 1 }));
+  return firsts.some((first) => {
+    const request = stockRequest(policy, first);
+    return typeof request !== "string" && sameStock(request, sent);
+  });
+};
+var cross = (a, b) => ({
+  x: a.y * b.z - a.z * b.y,
+  y: a.z * b.x - a.x * b.z,
+  z: a.x * b.y - a.y * b.x
+});
+var unit = ({ axis, sign }) => ({
+  x: 0,
+  y: 0,
+  z: 0,
+  [axis]: sign
+});
+var stockFrame = (first, part) => {
+  const z = first && axisAlong(first);
+  if (!z) {
+    return null;
+  }
+  const along = unit(z);
+  const level = cross(along, { x: 0, y: 0, z: 1 });
+  const flip = along.y < 0 ? -1 : 1;
+  const toolX = axisAlong(level) ? { x: level.x * flip, y: level.y * flip, z: level.z * flip } : { x: along.z < 0 ? -1 : 1, y: 0, z: 0 };
+  const toolY = cross(along, toolX);
+  const extent = (v) => Math.abs(AXES.reduce((sum, k) => sum + v[k] * (part.max[k] - part.min[k]), 0));
+  const x = extent(toolY) > extent(toolX) ? toolY : toolX;
+  return { x: axisAlong(x), y: axisAlong(cross(along, x)), z };
+};
+var spanAlong = (sign, [low, high]) => sign > 0 ? [low, high] : [-high, -low];
+var partSpan = (part, { axis, sign }) => spanAlong(sign, [part.min[axis], part.max[axis]]);
+var extentAlong = (part, frameAxis) => {
+  const [low, high] = partSpan(part, frameAxis);
+  return high - low;
+};
+var stockStart = (position, offset, [low, high], length) => position === "offsetFromTop" ? high + offset - length : position === "offsetFromBottom" ? low - offset : (low + high - length) / 2;
+var snapUp = (size, increment) => increment === 0 ? size : Math.ceil(Math.round(size / increment * 1e6) / 1e6) * increment;
+var placeBlock = (frame, part, size, position, offset) => {
+  const min = { ...part.min };
+  const max = { ...part.max };
+  for (const k of AXES) {
+    const span = partSpan(part, frame[k]);
+    const start = k === "z" ? stockStart(position, offset, span, size.z) : stockStart("modelCentered", 0, span, size[k]);
+    const { axis, sign } = frame[k];
+    [min[axis], max[axis]] = spanAlong(sign, [start, start + size[k]]);
+  }
+  return { min, max };
+};
+var placeCylinder = (frame, part, along, diameter, length, start) => {
+  const { axis, sign } = frame[along];
+  const middle = (k) => (part.min[k] + part.max[k]) / 2;
+  return {
+    origin: {
+      x: middle("x"),
+      y: middle("y"),
+      z: middle("z"),
+      [axis]: sign * start(partSpan(part, frame[along]))
+    },
+    axis: unit(frame[along]),
+    diameter,
+    length
+  };
+};
+var fixedBoxPlacement = (stock, first, part) => {
+  const frame = stockFrame(first, part);
+  if (!frame) {
+    return null;
+  }
+  const { dimensions } = stock;
+  const [x, y] = [dimensions[frame.x.axis], dimensions[frame.y.axis]];
+  const size = { x: Math.max(x, y), y: Math.min(x, y), z: dimensions[frame.z.axis] };
+  return {
+    ...placeBlock(frame, part, size, stock.position, stock.positionOffset ?? 0),
+    turned: x < y
+  };
+};
+var stockPlacement = (stock, first, part) => {
+  if (stock.mode === "fixedBox") {
+    const box = fixedBoxPlacement(stock, first, part);
+    return box && { box };
+  }
+  const frame = stockFrame(first, part);
+  if (!frame) {
+    return null;
+  }
+  if (stock.mode === "fixedCylinder") {
+    return { cylinder: placeFixedCylinder(stock, frame, part) };
+  }
+  if (stock.mode === "automaticFlatBar") {
+    return { box: placeFlatBar(stock, frame, part) };
+  }
+  return { cylinder: placeRoundStock(stock, frame, part) };
+};
+var placeFixedCylinder = (stock, frame, part) => {
+  const { diameter, length, position, positionOffset = 0 } = stock;
+  return placeCylinder(
+    frame,
+    part,
+    "z",
+    diameter,
+    length,
+    (span) => stockStart(position, positionOffset, span, length)
+  );
+};
+var placeFlatBar = (stock, frame, part) => {
+  const extent = (k) => extentAlong(part, frame[k]);
+  const { oversizeX, oversizeY, oversizeZTop, oversizeZBottom, snapX, snapY, snapZ } = {
+    ...defaultStock(stock.mode),
+    ...stock
+  };
+  const size = {
+    x: snapUp(extent("x") + 2 * oversizeX, snapX),
+    y: snapUp(extent("y") + 2 * oversizeY, snapY),
+    z: snapUp(extent("z") + oversizeZTop + oversizeZBottom, snapZ)
+  };
+  return placeBlock(frame, part, size, "offsetFromBottom", oversizeZBottom);
+};
+var placeRoundStock = (stock, frame, part) => {
+  const extent = (k) => extentAlong(part, frame[k]);
+  const { radialOversize, axialOversize, gripStock, diaRoundToNearest, lengthRoundToNearest } = {
+    ...defaultStock(stock.mode),
+    ...stock
+  };
+  const along = stock.verticalAxis ? "z" : "x";
+  const [a, b] = across(along);
+  const diameter = snapUp(Math.hypot(extent(a), extent(b)) + 2 * radialOversize, diaRoundToNearest);
+  const length = snapUp(gripStock + extent(along) + axialOversize, lengthRoundToNearest);
+  return placeCylinder(frame, part, along, diameter, length, ([low]) => low - gripStock);
+};
+var fixedBoxCheck = (stock, first, size, units) => {
+  if (stock?.mode !== "fixedBox") {
+    return null;
+  }
+  const request = stockRequest(stock, first);
+  if (typeof request === "string") {
+    return unsendableBox(request);
+  }
+  if (!size) {
+    return null;
+  }
+  const part = { min: { x: 0, y: 0, z: 0 }, max: { x: size.length, y: size.width, z: size.height } };
+  const box = fixedBoxPlacement(stock, first, part);
+  if (!box) {
+    return null;
+  }
+  return partOutsideBox(box, part, units) ?? turnedBox(box);
+};
+var unsendableBox = (request) => ({
+  problem: request,
+  applyReason: request === BOX_ENVELOPE ? FIX_STOCK_FIRST : request
+});
+var partOutsideBox = (box, part, units) => {
+  const worst = furthestOutside(box, part);
+  if (worst && worst.by > FIT_TOLERANCE_MM) {
+    return {
+      problem: `The part stands ${formatLength(worst.by, units)} outside the box along ${worst.axis.toUpperCase()}.`,
+      applyReason: FIX_STOCK_FIRST
+    };
+  }
+  return null;
+};
+var furthestOutside = (box, part) => {
+  const [worst] = AXES.map((axis) => ({
+    axis,
+    by: Math.max(box.min[axis] - part.min[axis], part.max[axis] - box.max[axis])
+  })).sort((p, q) => q.by - p.by);
+  return worst;
+};
+var turnedBox = (box) => box.turned ? {
+  note: "Toolpath turns the box a quarter turn about the first folder\u2019s direction, to lay its longer side along the part\u2019s."
+} : null;
+
+// src/tool-crib.ts
+var implicitLibraryIds = (crib) => crib.filter((entry) => entry.kind === "implicit").map((entry) => entry.id);
+var suitsMaterial = (materialFamilies, family) => family === null || materialFamilies.length === 0 || materialFamilies.includes(family);
+var startingLibrary = (libraries, family) => {
+  const suiting = libraries.filter((library) => suitsMaterial(library.materialFamilies, family));
+  return (family === null ? void 0 : suiting.find((library) => library.materialFamilies.includes(family))) ?? suiting.find((library) => library.isDefault) ?? suiting[0] ?? libraries.find((library) => library.isDefault) ?? libraries[0];
+};
+var offeredLibraries = (libraries, inCrib, family) => {
+  const left = libraries.filter((library) => !inCrib.includes(library.id));
+  const suits = (library) => suitsMaterial(library.materialFamilies, family);
+  return [...left.filter(suits), ...left.filter((library) => !suits(library))];
+};
+var cribOf = (library) => [{ kind: "implicit", id: library.id }];
+var cribUntouched = (crib, libraries, family) => {
+  const start = startingLibrary(libraries, family);
+  return crib.length === 0 || start !== void 0 && crib.length === 1 && crib[0]?.id === start.id;
+};
+var addLibrary = (crib, id) => crib.some((entry) => entry.id === id) ? crib : [...crib, { kind: "implicit", id }];
+var removeLibrary = (crib, id) => crib.filter((entry) => entry.id !== id);
+var swapLibraries = (crib, a, b) => crib.map(
+  (entry) => entry.id === a ? { ...entry, id: b } : entry.id === b ? { ...entry, id: a } : entry
+);
+export {
+  BOX_ENVELOPE,
+  COVERAGE_KINDS,
+  COVERAGE_LABELS,
+  DONE_COLOR,
+  DRAFT_ACTION_KINDS,
+  FLAT_BAR_FIELDS,
+  HISTORY,
+  IGNORE,
+  MAX_DEPTH,
+  MAX_NAME,
+  MAX_SETUPS,
+  MM_PER_INCH,
+  NO_FIRST_FOLDER,
+  OTHER_FOLDER_COLOR,
+  PART_ROW,
+  PRECISION,
+  REASON_SHORT,
+  ROUND_STOCK_FIELDS,
+  STOCK_LABELS,
+  TILTED_FIRST_FOLDER,
+  UNMACHINED_FACE_COLOR,
+  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
+};