rig-c 2.32.2 → 2.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-c",
-  "version": "2.32.2",
+  "version": "2.34.0",
   "description": "AI-authored Spine 2D rigging and animation, verified before it is written. rigc compiles a rig spec into Spine 4.3 skeleton data, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Output imports into the Spine editor. Ships as an agent skill.",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
     "./mesh": "./src/mesh.ts",
     "./errors": "./src/errors.ts",
     "./meshcompare": "./src/meshcompare.ts",
+    "./core": "./src/core/entry.ts",
     "./cli": "./cli.ts",
     "./package.json": "./package.json",
     "./*.ts": "./*.ts",

package/src/core/entry.ts

@@ -0,0 +1,33 @@
+/**
+ * `rig-c/core` — the named entry a player with no Spine runtime poses the
+ * model document through (issue #1275).
+ *
+ * A dependant was observed importing these symbols from the core's own files
+ * through the pattern courtesy (`rig-c/src/core/raw`), which RELEASING.md
+ * *The import surface* says is not promised. This module re-exports exactly
+ * the observed list, so the core's files keep their names and may move: the
+ * entry moves with them, and a symbol leaves only as a breaking change.
+ *
+ * 🔒 It re-exports and does nothing else. What it reaches by value is the
+ * core and nothing outside `src/core/` — the core links no `node:` module and
+ * no runtime, and its imports of `../model.ts` are type imports — so a bundler
+ * targeting a browser takes this entry's closure without a node polyfill.
+ * `CUR123` holds the closure, by name; the install smoke bundles it for a
+ * browser and holds the bundle to zero `node:` strings.
+ *
+ * ⚠️ A symbol is listed here only because a dependant was seen using it.
+ * The list is `scripts/install_smoke.ts`'s `OBSERVED_SYMBOLS` row for
+ * `./core`, and a symbol added here and not there is not promised.
+ */
+export { readModel, underSkin, underNoSkin, CoreInputError, CORE_DOCUMENT_SPEC, CORE_DOCUMENT_SPECS, CORE_BLEND_MODES, activeBones } from './index.ts';
+export type { CompiledDocument, CoreSlotRow, CoreBlendMode } from './index.ts';
+export { poseRawSetup, poseRawAnimation, poseRawAnimationEach, loopedTime, setupBounds } from './raw.ts';
+export type { RawPose, RawBone, RawDrawn, RawClip, RawClipped, RawEvent, RawReset } from './raw.ts';
+export { poseWalkSetup, poseLoopingWalk } from './walk.ts';
+export type { WalkPose } from './walk.ts';
+export { documentPageLookup, drawnRegions, regionPageUvs, meshPageUvs, readUvSequences } from './uvs.ts';
+export type { DrawnRegion, UvPage, UvRegion, UvSource } from './uvs.ts';
+export { clipThrough, clipShapeOf, convexWhy, REGION_UVS, REGION_TRIANGLES } from './clipping.ts';
+export type { ClipShape, ClipResult } from './clipping.ts';
+export { eventsFired } from './events.ts';
+export type { ModelPage, ModelPageRegion } from '../model.ts';

package/src/meshquality.ts

@@ -71,7 +71,7 @@ import {
 } from './mesh.ts';
 import { areaBand, triangleAreas } from './areaband.ts';
 import { allocationContrast, boundaryNecessityOnce, deformLoad, gradeMax, minAngleP10, type AllocationArt, type AllocationPlant } from './meshallocation.ts';
-import { skinningEchoOf, skinningResidual, validateSkinning, type ReductionSkinning, type SkinningDetail, type SkinningEcho, type SkinningPlant, type SkinningResidualInput } from './meshskinning.ts';
+import { skinningEchoOf, skinningResidual, sourceMeshDigest, validateSkinning, type ReductionSkinning, type SkinningDetail, type SkinningEcho, type SkinningPlant, type SkinningResidualInput } from './meshskinning.ts';
 import { artRastersOf, type ArtRasters, type CoverageReading, type OutlineMemo, type RegionEdgeReading, type SilhouetteReading, type StepRasters } from './meshrasters.ts';
 import { cropToSpineY } from './transform.ts';
 
@@ -294,6 +294,45 @@ export interface MeshReductionInput {
    * mesh, `acceptedAt`, the termination and every other row are the call's without it (docs/MESH_REDUCTION.md §8).
    */
   motionAmplitude?: MotionAmplitude | null;
+  /**
+   * Named interior feature lines (issue #1326, docs/MESH_REDUCTION.md §11) — opt-in. Left out = no line is declared
+   * and the call is the one it was before the field existed, byte for byte. Set, each line's vertices may thin under
+   * its own `MQ_LINE_DEVIATION` bound: a line vertex is removed only by a step after which the line's row is within
+   * `maxDeviation` and its two kept neighbours are joined by an edge of the result; the triangulation post-pass flips
+   * no line edge; and, under `boundaryRuns`, a run of consecutive kept line vertices may be replaced by one chord as
+   * one step (`acceptedAt` kind `'line-run'`). An open line's two ends and a vertex two lines list are kept. The
+   * result's measurement carries one row per line, in declared order. Refused `REDUCE_INPUT_LINE`, before any work,
+   * when a line is not well formed against `source` (`validateLines`); `null` is refused like any value that is not
+   * a list. `protect.edges` keeps its meaning: a line held whole is listed there.
+   */
+  lines?: NamedLine[];
+}
+
+/**
+ * Issue #1326: an interior feature line of a source mesh — a chain of source vertices, each consecutive pair (and on a
+ * closed line the last–first pair) an edge of a source triangle. It lives on the reduction's and the measurement's
+ * input rather than on `SourceMesh`, so no field every measurement and comparison reads (and `sourceMeshDigest`
+ * hashes) changes.
+ */
+export interface NamedLine {
+  /** The caller's name, echoed in the row and in every refusal; rigc reads nothing into it. Unique among the input's lines. */
+  name: string;
+  /** Source vertex indices in order along the line, each once. */
+  vertices: number[];
+  /** Closed: the last joins the first, and at least 3 vertices. Open: two ends, at least 2 vertices. */
+  closed: boolean;
+  /** The bound `MQ_LINE_DEVIATION` is held to, drawing px, finite, 0 or more. Required: there is no default and no declared-absent form. */
+  maxDeviation: number;
+}
+
+/**
+ * Issue #1326: the source a measurement reads its lines against — the mesh their indices are into, by the caller's id.
+ * The line's kept chain on the measured mesh is read by position: a line vertex is kept when the measured mesh has a
+ * vertex at its exact position, as every vertex a reduction keeps does (P19: a survivor is never resampled).
+ */
+export interface LineSource {
+  id: string;
+  mesh: SourceMesh;
 }
 
 /**
@@ -328,11 +367,11 @@ export interface BoundaryRuns {
 export interface AcceptedOperation {
   /** The attempt number — `candidatesTried` as it stood when the operation was taken, 1-based. */
   step: number;
-  /** A refinement insertion, one source vertex removed, or a boundary run replaced by one chord. */
-  kind: 'insertion' | 'removal' | 'boundary-run';
-  /** Vertices the operation inserted (an insertion: 1) or removed (a removal: 1; a boundary run: 2 or more). */
+  /** A refinement insertion, one source vertex removed, a boundary run replaced by one chord, or (issue #1326) a run of a line's kept vertices replaced by one chord. */
+  kind: 'insertion' | 'removal' | 'boundary-run' | 'line-run';
+  /** Vertices the operation inserted (an insertion: 1) or removed (a removal: 1; a boundary run or a line run: 2 or more). */
   count: number;
-  /** The source indices it removed, in outline order for a run — each `null` in `indexMap`; empty for an insertion. */
+  /** The source indices it removed, in outline order for a boundary run and in the line's listed order for a line run — each `null` in `indexMap`; empty for an insertion. */
   sourceVertices: number[];
 }
 
@@ -390,6 +429,17 @@ export interface MeshMeasureInput {
    * full is refused `REDUCE_INPUT_MISSING` naming its path, before any work.
    */
   skinning?: SkinningResidualInput | null;
+  /**
+   * Issue #1326 (docs/MESH_REDUCTION.md §11): named lines over `lineSource`'s vertices — the same `NamedLine` list a
+   * reduction takes. Left out, no line row is written and the report is the one written without the field, byte for
+   * byte. Set, `lineSource` is required, and the report gains one required `MQ_LINE_DEVIATION` row per line, in
+   * declared order: the symmetric Hausdorff distance between the line's kept chain on this mesh and its polyline on
+   * `lineSource`. Refused `REDUCE_INPUT_LINE`, before any work, as a reduction refuses it; `null` is refused like any
+   * value that is not a list.
+   */
+  lines?: NamedLine[];
+  /** Issue #1326: the mesh `lines` index into, by the caller's id — required with `lines` and refused without it. Echoed by id and digest. */
+  lineSource?: LineSource;
 }
 
 /**
@@ -441,8 +491,8 @@ export type MeasureState = 'pass' | 'fail' | 'undeclared' | 'refused' | 'not-mea
 export interface MeasureRow {
   /** Stable code, e.g. `MQ_COVERAGE`. */
   code: string;
-  /** The object measured: attachment always; region when the row is a region's. */
-  object: { attachment: AttachmentRef; region: string | null };
+  /** The object measured: attachment always; region when the row is a region's; `line` on `MQ_LINE_DEVIATION` only (issue #1326), the line's name. */
+  object: { attachment: AttachmentRef; region: string | null; line?: string };
   state: MeasureState;
   /** The measured value: present on pass, fail and undeclared; null otherwise. */
   value: number | null;
@@ -696,6 +746,10 @@ export interface EffectiveSettings {
   skinning?: SkinningEcho | null;
   /** A comparison's `overBound`, echoed when the input set it (issue #1315); absent otherwise. */
   overBound?: OverBoundRequest;
+  /** A measurement's or a reduction's `lines`, echoed when the input set it (issue #1326); absent otherwise. */
+  lines?: NamedLine[];
+  /** A measurement's `lineSource`, by id and `sourceMeshDigest`, echoed when the input set it (issue #1326); absent otherwise. */
+  lineSource?: { id: string; digest: string };
 }
 
 export interface MeshCounts {
@@ -950,6 +1004,34 @@ function validateInput(input: MeshMeasureInput): void {
   }
   validateMotionAmplitude(who, input.motionAmplitude);
   validateSkinning(who, input.skinning);
+  validateMeasureLines(who, input);
+}
+
+/**
+ * Issue #1326: a measurement's `lines` and `lineSource`, refused `REDUCE_INPUT_LINE` before any work — the two together
+ * or neither, the source well formed enough to index, then the lines against it (`validateLines`).
+ */
+function validateMeasureLines(who: string, input: MeshMeasureInput): void {
+  const { lines, lineSource } = input;
+  if (lines === undefined) {
+    if (lineSource !== undefined) refuse('REDUCE_INPUT_LINE', `${who}: lineSource is set and lines is left out; required lines with it, or neither — a source no line reads is not an input`);
+    return;
+  }
+  const mesh: unknown = isObject(lineSource) ? lineSource.mesh : undefined;
+  const ok =
+    isObject(lineSource) &&
+    typeof lineSource.id === 'string' &&
+    lineSource.id !== '' &&
+    isObject(mesh) &&
+    Array.isArray(mesh.points) &&
+    mesh.points.every(isPoint) &&
+    Array.isArray(mesh.triangles) &&
+    mesh.triangles.every((v: unknown) => Number.isInteger(v)) &&
+    Number.isInteger(mesh.hull);
+  if (!ok) {
+    refuse('REDUCE_INPUT_LINE', `${who}: lineSource is ${lineSource === undefined ? 'missing (undefined)' : JSON.stringify(isObject(lineSource) ? { id: lineSource.id, mesh: isObject(mesh) ? '{…}' : mesh } : lineSource)}; required { id: a non-empty string, mesh: the SourceMesh the lines index into } whenever lines is set`);
+  }
+  validateLines(who, 'lines', lines, lineSource!.mesh);
 }
 
 /**
@@ -986,6 +1068,161 @@ export function validateMotionAmplitude(who: string, amplitude: unknown): void {
   });
 }
 
+/**
+ * Issue #1326 (docs/MESH_REDUCTION.md §11): `lines` refused `REDUCE_INPUT_LINE` before any work, against the mesh the
+ * indices are into — `MeshReductionInput.source`, or `MeshMeasureInput.lineSource.mesh`. `field` is the path the
+ * messages name. Each refusal names the line (its index and name), the index or pair, and the rule, in this order:
+ * the list and each line's shape (a non-empty name, `closed` a boolean, `maxDeviation` a finite number 0 or more —
+ * left out and `null` each named as itself, since neither is a bound), its vertex count (closed 3 or more, open 2 or
+ * more), each index a source vertex, no vertex twice, each consecutive pair (closed: and the last–first) an edge of a
+ * source triangle, no line vertex whose position another source vertex shares (the measurement reads a kept vertex by
+ * its position); then names unique across the lines; then each segment inside the source's outline (its hull
+ * polygon, the boundary counting as inside); then no two segments meeting other than at a vertex both list — two
+ * lines that cross list the crossing as one shared vertex, and two that run together list every vertex of the run.
+ * Nothing is resolved here or later: a crossing is the caller's to list. Shared by the reduction and the measurement,
+ * so both refuse one value in the same words; merely exported, as `validateMotionAmplitude` is.
+ */
+export function validateLines(who: string, field: string, lines: unknown, mesh: { points: ReadonlyArray<readonly [number, number]>; triangles: readonly number[]; hull: number }): void {
+  function no(message: string): never {
+    return refuse('REDUCE_INPUT_LINE', `${who}: ${message}`);
+  }
+  if (!Array.isArray(lines)) no(`${field} is ${JSON.stringify(lines)}; required a list of { name, vertices, closed, maxDeviation }, or the field left out (issue #1326: no line is declared)`);
+  const list = lines as unknown[];
+  const n = mesh.points.length;
+  const edges = new Set<number>();
+  for (let t = 0; t + 2 < mesh.triangles.length; t += 3) {
+    for (let k = 0; k < 3; k++) {
+      const a = mesh.triangles[t + k];
+      const b = mesh.triangles[t + ((k + 1) % 3)];
+      edges.add(a < b ? a * n + b : b * n + a);
+    }
+  }
+  const at = new Map<string, number[]>();
+  mesh.points.forEach((p, v) => {
+    const key = `${p[0]},${p[1]}`;
+    const here = at.get(key);
+    if (here === undefined) at.set(key, [v]);
+    else here.push(v);
+  });
+  const named: NamedLine[] = [];
+  list.forEach((line, i) => {
+    const it = `${field}[${i}]`;
+    if (!isObject(line)) no(`${it} is ${JSON.stringify(line)}; required { name, vertices, closed, maxDeviation }`);
+    if (typeof line.name !== 'string' || line.name === '') no(`${it}.name is ${JSON.stringify(line.name)}; required a non-empty string, unique among the lines — the row and every refusal name the line by it`);
+    const said = `${it} ("${line.name}")`;
+    if (typeof line.closed !== 'boolean') no(`${said}.closed is ${JSON.stringify(line.closed)}; required true (the last vertex joins the first) or false (two ends)`);
+    const bound = line.maxDeviation;
+    if (bound === undefined) no(`${said}.maxDeviation is missing (undefined); required a finite number of drawing px, 0 or more — the bound MQ_LINE_DEVIATION is held to, which has no default`);
+    if (bound === null) no(`${said}.maxDeviation is null; required a finite number of drawing px, 0 or more — a line declares its own bound and has no declared-absent form (a line held whole is protect.edges; a line with no bound is not declared)`);
+    if (!isFiniteNumber(bound) || bound < 0) no(`${said}.maxDeviation is ${typeof bound === 'number' ? String(bound) : JSON.stringify(bound)}; required a finite number of drawing px, 0 or more`);
+    const vs = line.vertices;
+    if (!Array.isArray(vs)) no(`${said}.vertices is ${JSON.stringify(vs)}; required a list of source vertex indices in order along the line`);
+    const vertices = vs as unknown[];
+    const least = line.closed ? 3 : 2;
+    if (vertices.length < least) no(`${said} is ${line.closed ? 'closed' : 'open'} with ${vertices.length} vertex(es); required at least ${least} — ${line.closed ? 'a closed line is a polygon' : 'an open line has two ends'}`);
+    vertices.forEach((v, k) => {
+      if (!Number.isInteger(v) || (v as number) < 0 || (v as number) >= n) no(`${said}.vertices[${k}] is ${JSON.stringify(v)}; required a source vertex index in 0..${n - 1}`);
+    });
+    const ids = vertices as number[];
+    const first = new Map<number, number>();
+    ids.forEach((v, k) => {
+      const was = first.get(v);
+      if (was !== undefined) no(`${said} lists vertex ${v} twice (vertices[${was}] and vertices[${k}]); required each vertex once — a line that touches itself is refused, never split`);
+      first.set(v, k);
+    });
+    const pairs = line.closed ? ids.length : ids.length - 1;
+    for (let k = 0; k < pairs; k++) {
+      const a = ids[k];
+      const b = ids[(k + 1) % ids.length];
+      if (!edges.has(a < b ? a * n + b : b * n + a)) {
+        no(`${said}: the pair ${a}–${b} (vertices[${k}], vertices[${(k + 1) % ids.length}]) is not an edge of a source triangle; required each consecutive pair${line.closed ? ', and the last–first pair,' : ''} to be one — the same test protect.edges applies`);
+      }
+    }
+    for (const v of ids) {
+      const p = mesh.points[v];
+      const all = at.get(`${p[0]},${p[1]}`)!;
+      if (all.length > 1) no(`${said}: vertex ${v} at (${p[0]}, ${p[1]}) shares its position with source vertex ${all.find((u) => u !== v)}; required a line vertex at a position no other source vertex has — a measurement reads a kept line vertex by its position`);
+    }
+    named.push({ name: line.name, vertices: ids, closed: line.closed, maxDeviation: bound as number });
+  });
+  const byName = new Map<string, number>();
+  named.forEach((line, i) => {
+    const was = byName.get(line.name);
+    if (was !== undefined) no(`${field}[${i}] is named "${line.name}", as ${field}[${was}] is; required one name per line — its row is keyed by it`);
+    byName.set(line.name, i);
+  });
+  const hull = mesh.points.slice(0, Math.max(0, mesh.hull));
+  type Segment = { line: number; a: number; b: number; lo: [number, number]; hi: [number, number] };
+  const segments: Segment[] = [];
+  named.forEach((line, i) => {
+    const pairs = line.closed ? line.vertices.length : line.vertices.length - 1;
+    for (let k = 0; k < pairs; k++) {
+      const a = line.vertices[k];
+      const b = line.vertices[(k + 1) % line.vertices.length];
+      if (hull.length >= 3) {
+        const off = segmentLeavesPolygon(mesh.points[a], mesh.points[b], hull);
+        if (off !== null) no(`${field}[${i}] ("${line.name}"): the segment ${a}–${b} leaves the source's outline at (${r6(off[0])}, ${r6(off[1])}); required every segment inside the hull polygon — a hull vertex on a line is allowed, a segment off the art is not`);
+      }
+      const p = mesh.points[a];
+      const q = mesh.points[b];
+      segments.push({ line: i, a, b, lo: [Math.min(p[0], q[0]), Math.min(p[1], q[1])], hi: [Math.max(p[0], q[0]), Math.max(p[1], q[1])] });
+    }
+  });
+  const slack = 1e-9;
+  for (let s = 0; s < segments.length; s++) {
+    const u = segments[s];
+    for (let t = s + 1; t < segments.length; t++) {
+      const w = segments[t];
+      // A shared endpoint is a vertex both lines list (each segment's ends are its own line's vertices): a meeting there is the crossing or the run, declared.
+      if (u.a === w.a || u.a === w.b || u.b === w.a || u.b === w.b) continue;
+      if (u.hi[0] < w.lo[0] - slack || w.hi[0] < u.lo[0] - slack || u.hi[1] < w.lo[1] - slack || w.hi[1] < u.lo[1] - slack) continue;
+      if (segmentsMeet(mesh.points[u.a], mesh.points[u.b], mesh.points[w.a], mesh.points[w.b])) {
+        const lu = named[u.line];
+        const lw = named[w.line];
+        no(
+          `${field}[${u.line}] ("${lu.name}")'s segment ${u.a}–${u.b} meets ${u.line === w.line ? 'its own' : `${field}[${w.line}] ("${lw.name}")'s`} segment ${w.a}–${w.b} other than at a vertex both list; required two lines that cross to list the crossing as one shared source vertex, and a line not to cross itself — rig-c resolves no crossing`,
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Issue #1326: where the segment p–q leaves the closed polygon `poly` (the boundary counting as inside), or null when
+ * it does not — the ends tested, then the midpoint of every piece between the parameters at which it meets an edge or
+ * passes a polygon vertex, so a segment that leaves through a notch and comes back is found whether or not it crosses
+ * an edge properly.
+ */
+function segmentLeavesPolygon(p: Pt, q: Pt, poly: readonly Pt[]): Pt | null {
+  if (!inClosedPolygon(p, poly)) return p;
+  if (!inClosedPolygon(q, poly)) return q;
+  const dx = q[0] - p[0];
+  const dy = q[1] - p[1];
+  const len2 = dx * dx + dy * dy;
+  if (len2 === 0) return null;
+  const ts = [0, 1];
+  const along = (r: Pt): number => ((r[0] - p[0]) * dx + (r[1] - p[1]) * dy) / len2;
+  const m = poly.length;
+  for (let i = 0; i < m; i++) {
+    const c = poly[i];
+    const d = poly[(i + 1) % m];
+    if (distanceToSegment(c, p, q) <= ON_BOUNDARY) ts.push(along(c));
+    if (!segmentsMeet(p, q, c, d)) continue;
+    const ex = d[0] - c[0];
+    const ey = d[1] - c[1];
+    const den = dx * ey - dy * ex;
+    if (den !== 0) ts.push(((c[0] - p[0]) * ey - (c[1] - p[1]) * ex) / den);
+  }
+  const cuts = ts.filter((t) => t >= 0 && t <= 1).sort((a, b) => a - b);
+  for (let k = 0; k + 1 < cuts.length; k++) {
+    if (cuts[k + 1] - cuts[k] <= 1e-12) continue;
+    const t = (cuts[k] + cuts[k + 1]) / 2;
+    const mid: Pt = [p[0] + dx * t, p[1] + dy * t];
+    if (!inClosedPolygon(mid, poly)) return mid;
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // plane geometry
 // ---------------------------------------------------------------------------
@@ -1269,12 +1506,16 @@ export function regionEdgeBound(a: readonly [number, number], b: readonly [numbe
   return bound;
 }
 
-/** Distance from a point to a closed polyline (the polygon's boundary), and the edge that realises it. */
-function pointToBoundary(p: Pt, poly: readonly Pt[]): { d: number; edge: number } {
+/**
+ * Distance from a point to a closed polyline (the polygon's boundary), and the edge that realises it. `closed: false`
+ * (issue #1326) reads an open polyline — no closing edge; one point is its own degenerate edge.
+ */
+function pointToBoundary(p: Pt, poly: readonly Pt[], closed = true): { d: number; edge: number } {
   let d = Infinity;
   let edge = 0;
   const n = poly.length;
-  for (let i = 0; i < n; i++) {
+  const edges = closed || n === 1 ? n : n - 1;
+  for (let i = 0; i < edges; i++) {
     const v = distanceToSegment(p, poly[i], poly[(i + 1) % n]);
     if (v < d) {
       d = v;
@@ -1295,26 +1536,32 @@ function pointToBoundary(p: Pt, poly: readonly Pt[]): { d: number; edge: number
  * of those maxima bounds it from above. A piece whose bound cannot beat the best
  * value already found is dropped; the rest are halved. No sampling density is
  * chosen, so nothing here can miss a maximum between two samples.
+ *
+ * `aClosed` / `bClosed` false (issue #1326, `MQ_LINE_DEVIATION`) read that side as an open polyline: its edges are
+ * the consecutive pairs and no closing one, and a single point is its own degenerate edge. Both true is the outline
+ * rows' reading, edge for edge as before the flags.
  */
-function directedHausdorff(a: readonly Pt[], b: readonly Pt[], carried: ((p: Pt) => Float64Array) | null = null): { d: number; edge: number; at: Pt } {
+function directedHausdorff(a: readonly Pt[], b: readonly Pt[], carried: ((p: Pt) => Float64Array) | null = null, aClosed = true, bClosed = true): { d: number; edge: number; at: Pt } {
   const m = b.length;
+  const mEdges = bClosed || m === 1 ? m : m - 1;
   const toEach =
     carried ??
     ((p: Pt): Float64Array => {
-      const out = new Float64Array(m);
-      for (let j = 0; j < m; j++) out[j] = distanceToSegment(p, b[j], b[(j + 1) % m]);
+      const out = new Float64Array(mEdges);
+      for (let j = 0; j < mEdges; j++) out[j] = distanceToSegment(p, b[j], b[(j + 1) % m]);
       return out;
     });
   const minOf = (g: Float64Array): number => {
     let v = Infinity;
-    for (let j = 0; j < m; j++) v = Math.min(v, g[j]);
+    for (let j = 0; j < mEdges; j++) v = Math.min(v, g[j]);
     return v;
   };
   let best = -1;
   let bestEdge = 0;
   let bestAt: Pt = a[0];
   const n = a.length;
-  for (let i = 0; i < n; i++) {
+  const nEdges = aClosed || n === 1 ? n : n - 1;
+  for (let i = 0; i < nEdges; i++) {
     const p0 = a[i];
     const p1 = a[(i + 1) % n];
     const at = (t: number): Pt => [p0[0] + (p1[0] - p0[0]) * t, p0[1] + (p1[1] - p0[1]) * t];
@@ -1333,7 +1580,7 @@ function directedHausdorff(a: readonly Pt[], b: readonly Pt[], carried: ((p: Pt)
     while (stack.length > 0) {
       const piece = stack.pop()!;
       let upper = Infinity;
-      for (let j = 0; j < m; j++) upper = Math.min(upper, Math.max(piece.g0[j], piece.g1[j]));
+      for (let j = 0; j < mEdges; j++) upper = Math.min(upper, Math.max(piece.g0[j], piece.g1[j]));
       if (upper <= best + HAUSDORFF_TOLERANCE || piece.depth >= 64) continue;
       const tm = (piece.t0 + piece.t1) / 2;
       const gm = toEach(at(tm));
@@ -1351,11 +1598,54 @@ function directedHausdorff(a: readonly Pt[], b: readonly Pt[], carried: ((p: Pt)
  * taken on when the worst point is the candidate's, else the candidate edge
  * nearest the reference's worst point.
  */
-function hausdorff(candidate: readonly Pt[], reference: readonly Pt[], carried: { forward: (p: Pt) => Float64Array; backward: (p: Pt) => Float64Array } | null = null): { d: number; candidateEdge: number } {
-  const forward = directedHausdorff(candidate, reference, carried?.forward ?? null);
-  const backward = directedHausdorff(reference, candidate, carried?.backward ?? null);
+function hausdorff(candidate: readonly Pt[], reference: readonly Pt[], carried: { forward: (p: Pt) => Float64Array; backward: (p: Pt) => Float64Array } | null = null, closed = true): { d: number; candidateEdge: number } {
+  const forward = directedHausdorff(candidate, reference, carried?.forward ?? null, closed, closed);
+  const backward = directedHausdorff(reference, candidate, carried?.backward ?? null, closed, closed);
   if (forward.d >= backward.d) return { d: forward.d, candidateEdge: forward.edge };
-  return { d: backward.d, candidateEdge: pointToBoundary(backward.at, candidate).edge };
+  return { d: backward.d, candidateEdge: pointToBoundary(backward.at, candidate, closed).edge };
+}
+
+/**
+ * Issue #1326: `MQ_LINE_DEVIATION`'s distance — the symmetric Hausdorff distance between a line's kept chain and its
+ * source polyline, by the outline rows' own function (`hausdorff`, exact to `HAUSDORFF_TOLERANCE`), a closed line as
+ * two polygons and an open one as two open polylines, with the chain edge the worst value belongs to. The reduction
+ * reads it on the chain an attempt would leave before it builds anything, and the row reads it on the measured mesh:
+ * one function of the same points in the same order, so the two are the same number.
+ */
+export function lineDeviation(kept: ReadonlyArray<readonly [number, number]>, reference: ReadonlyArray<readonly [number, number]>, closed: boolean): { d: number; chainEdge: number } {
+  const hd = hausdorff(kept, reference, null, closed);
+  return { d: hd.d, chainEdge: hd.candidateEdge };
+}
+
+/**
+ * Issue #1326: one `MQ_LINE_DEVIATION` row per line, in declared order. `reference` holds the points the lines' indices
+ * are into; `keptAt(v)` is the measured mesh's index of line vertex v, or null when the mesh does not keep it. The row:
+ * `object.line` the name and `object.region` null, drawing px, bound `<= maxDeviation`, required; the value the
+ * distance on the `r6` grid; the worst sample the chain edge it belongs to (as the measured mesh's indices; one kept
+ * vertex is its own `vertex`), nothing when the value is 0; `not-measurable` when the mesh keeps no vertex of the line.
+ * Merely exported — the reduction reads its steps' rows through it, so no row is written twice.
+ */
+export function lineDeviationRows(attachment: AttachmentRef, lines: readonly NamedLine[], reference: ReadonlyArray<readonly [number, number]>, keptAt: (v: number) => number | null): MeasureRow[] {
+  return lines.map((line): MeasureRow => {
+    const object = { attachment, region: null, line: line.name };
+    const chain = line.vertices.filter((v) => keptAt(v) !== null);
+    if (chain.length === 0) {
+      const reason = `attachment ${nameOf(attachment)}: line "${line.name}" has no vertex the measured mesh keeps (none of its ${line.vertices.length} source positions is a vertex of it), so there is no chain to measure`;
+      return { code: 'MQ_LINE_DEVIATION', object, state: 'not-measurable', value: null, bound: null, unit: 'px', worst: null, reason };
+    }
+    const hd = lineDeviation(
+      chain.map((v) => reference[v]),
+      line.vertices.map((v) => reference[v]),
+      line.closed,
+    );
+    const value = r6(hd.d);
+    const bound = { op: '<=' as const, value: line.maxDeviation };
+    let worst: WorstSample = NOTHING_WORSE;
+    if (hd.d !== 0) {
+      worst = chain.length === 1 ? { at: { vertex: keptAt(chain[0])! } } : { at: { edge: [keptAt(chain[hd.chainEdge])!, keptAt(chain[(hd.chainEdge + 1) % chain.length])!] } };
+    }
+    return { code: 'MQ_LINE_DEVIATION', object, state: judged(value, bound), value, bound, unit: 'px', worst, reason: null };
+  });
 }
 
 /** A point as a key: both coordinates' shortest round-trip decimals, a negative zero told from a positive one. */
@@ -1852,6 +2142,19 @@ function measureValidated(input: MeshMeasureInput, rasters: ArtRasters, steps: S
     rows.push(unmeasuredRow(traceSpec, 'not-measurable', `attachment ${nameOf(attachment)}: the tracer refused the art at alpha >= ${threshold}: ${traced.refused}`, false));
   }
 
+  // --- named lines (issue #1326): only when the input declared them, one row per line in declared order ---------
+  // `compareRows` ties them (one code, region null, no connectivity) and the sort is stable, so the order is the input's.
+  if (input.lines !== undefined) {
+    const lineSourceMesh = input.lineSource!.mesh;
+    const byPosition = new Map<string, number>();
+    points.forEach((p, v) => {
+      const key = `${p[0]},${p[1]}`;
+      if (!byPosition.has(key)) byPosition.set(key, v);
+    });
+    const keptAt = (v: number): number | null => byPosition.get(`${lineSourceMesh.points[v][0]},${lineSourceMesh.points[v][1]}`) ?? null;
+    for (const row of lineDeviationRows(attachment, input.lines, lineSourceMesh.points, keptAt)) rows.push({ row, required: true });
+  }
+
   // --- triangles: sign, degeneracy, angle --------------------------------------------------
   const world: number[] = [];
   for (const [x, y] of points) world.push(x, cropToSpineY(y, frame.height));
@@ -2398,6 +2701,8 @@ function effectiveOf(input: MeshMeasureInput, skinningPlant: SkinningPlant | nul
     budget: null,
     ...(input.motionAmplitude === undefined ? {} : { motionAmplitude: input.motionAmplitude }),
     ...(input.skinning === undefined ? (skinningPlant === 'echo-when-unset' ? { skinning: null } : {}) : { skinning: skinningEchoOf(input.skinning) }),
+    ...(input.lines === undefined ? {} : { lines: input.lines }),
+    ...(input.lineSource === undefined ? {} : { lineSource: { id: input.lineSource.id, digest: sourceMeshDigest(input.lineSource.mesh) } }),
   };
 }
 
@@ -2498,6 +2803,8 @@ function effectiveJson(e: EffectiveSettings): Json {
     ...(e.removalOrder === undefined ? {} : { removalOrder: e.removalOrder }),
     ...(e.skinning === undefined ? {} : { skinning: skinningEchoJson(e.skinning) }),
     ...(e.overBound === undefined ? {} : { overBound: { maxSamples: e.overBound.maxSamples, triangles: e.overBound.triangles } }),
+    ...(e.lines === undefined ? {} : { lines: e.lines.map((l): Json => ({ name: l.name, vertices: [...l.vertices], closed: l.closed, maxDeviation: l.maxDeviation })) }),
+    ...(e.lineSource === undefined ? {} : { lineSource: { id: e.lineSource.id, digest: e.lineSource.digest } }),
   };
 }
 
@@ -2521,7 +2828,7 @@ function worstJson(w: WorstSample | null): Json {
 function rowJson(r: MeasureRow): Json {
   const out: { [key: string]: Json } = {
     code: r.code,
-    object: { attachment: attachmentJson(r.object.attachment), region: r.object.region },
+    object: r.object.line === undefined ? { attachment: attachmentJson(r.object.attachment), region: r.object.region } : { attachment: attachmentJson(r.object.attachment), region: r.object.region, line: r.object.line },
     state: r.state,
     value: r.value,
     bound: r.bound === null ? null : { op: r.bound.op, value: r.bound.value },

package/src/meshreduce.ts

@@ -140,6 +140,8 @@ import {
   measureMeshQualityStep,
   measureMeshQualityWith,
   validateMotionAmplitude,
+  lineDeviationRows,
+  validateLines,
   type AcceptedOperation,
   type AttachmentRef,
   type ArtFitBounds,
@@ -152,6 +154,7 @@ import {
   type MeshQualityReport,
   type MeshReductionInput,
   type MotionAmplitude,
+  type NamedLine,
   type RefinementRegion,
   type ReductionChanges,
   type Retriangulation,
@@ -349,6 +352,12 @@ function validateReduction(input: MeshReductionInput, plant: ReductionPlant | nu
   const src = input.source;
   if (!isObject(src) || !Array.isArray(src.points)) refuse('REDUCE_INPUT_MISSING', `${who}: source is not { points, uvs, triangles, hull, weights }`);
   const n = src.points.length;
+  // Issue #1326: refused before any work, in the measurement's words. A source too malformed to index is left to the
+  // admission measurement, which refuses it by its own code before anything reads a line.
+  if ('lines' in input && input.lines !== undefined) {
+    const readable = src.points.every((q) => Array.isArray(q) && q.length === 2 && isFiniteNumber(q[0]) && isFiniteNumber(q[1])) && Array.isArray(src.triangles) && src.triangles.every((v) => Number.isInteger(v)) && Number.isInteger(src.hull);
+    if (readable || !Array.isArray(input.lines)) validateLines(who, 'lines', input.lines, src);
+  }
 
   const p = input.protect;
   if (p === undefined || p === null || !isObject(p)) refuse('REDUCE_INPUT_MISSING', `${who}: protect is ${JSON.stringify(p)}; required a ProtectedFeatures — a reduction has no default protection (P20)`);
@@ -950,6 +959,17 @@ interface Run {
   skinning: SkinningRun | null;
   /** Issue #1295: the controls' faults and inspector, or null. */
   hooks: SkinningHooks | null;
+  /** Issue #1326: the declared lines, or null when the input left `lines` out. */
+  lines: LineRun | null;
+}
+
+/** Issue #1326: the input's lines as the steps read them. */
+interface LineRun {
+  lines: NamedLine[];
+  /** Source vertex → the indices of the lines that list it, ascending. */
+  of: Map<number, number[]>;
+  /** Per line, source vertex → its position in the line's list. */
+  at: Array<Map<number, number>>;
 }
 
 /**
@@ -975,7 +995,7 @@ export type SkinningVetoPlant = CarryPlant | 'full-recompute' | 'post-pass-unche
 
 /** One decision the residual took part in, as a control reads it (issue #1295). */
 export interface SkinningInspection {
-  phase: 'insertion' | 'removal' | 'boundary-run' | 'delaunay';
+  phase: 'insertion' | 'removal' | 'boundary-run' | 'line-run' | 'delaunay';
   /** `candidatesTried` when it was decided. */
   step: number;
   /** Whether the working mesh now holds the trial (an insertion always does). */
@@ -1017,6 +1037,8 @@ function measureAgainstTargets(run: Run, mesh: SourceMesh, id: string, final = f
     preset: input.preset,
     ...amplitudeOf(run.input, run.plant, final),
     ...(final ? skinningOfResult(run) : {}),
+    // Issue #1326: the result's own measurement carries the line rows; every step reads them beside it (`lineRowsOf`).
+    ...(final && input.lines !== undefined ? { lines: input.lines, lineSource: { id: 'source', mesh: input.source } } : {}),
   };
   return run.stepRasters === null ? measureMeshQualityWith(measureInput, run.rasters) : measureMeshQualityStep(measureInput, run.stepRasters);
 }
@@ -1109,10 +1131,10 @@ function amplitudeOf(input: MeshReductionInput, plant: ReductionPlant | null, fi
 }
 
 /** The order constraints are named in when several fail on one step: structure, then shape, then art, then density. */
-const BLOCKING_ORDER = ['MQ_ORIENTATION', 'MQ_DEGENERATE', 'MQ_BOUNDARY_DEVIATION', 'MQ_COVERAGE', 'MQ_OVERSHOOT', 'MQ_UNDERCUT', 'MQ_MIN_ANGLE', 'MQ_MAX_EDGE', 'MQ_TRANSITION'];
+const BLOCKING_ORDER = ['MQ_ORIENTATION', 'MQ_DEGENERATE', 'MQ_BOUNDARY_DEVIATION', 'MQ_LINE_DEVIATION', 'MQ_COVERAGE', 'MQ_OVERSHOOT', 'MQ_UNDERCUT', 'MQ_MIN_ANGLE', 'MQ_MAX_EDGE', 'MQ_TRANSITION'];
 
 function rowName(row: MeasureRow): string {
-  const region = row.object.region === null ? '' : `[${row.object.region}]`;
+  const region = row.object.region !== null ? `[${row.object.region}]` : row.object.line === undefined ? '' : `[line ${row.object.line}]`;
   if (row.state === 'fail') return `${row.code}${region}: ${row.value} against ${row.bound!.op} ${row.bound!.value}`;
   return `${row.code}${region}: ${row.state} — ${row.reason ?? ''}`;
 }
@@ -1123,8 +1145,11 @@ function rowName(row: MeasureRow): string {
  * art bound declared `null` is not (`artBoundAbsent`, issue #1254); the
  * overshoot row gated is the 8-connected one (P12).
  */
-function firstBlockingRow(report: MeshQualityReport, artFit: ArtFitBounds): MeasureRow | null {
-  const rows = report.candidates[0]?.geometry?.rows ?? [];
+function firstBlockingRow(report: MeshQualityReport, artFit: ArtFitBounds, lineRows: readonly MeasureRow[] = []): MeasureRow | null {
+  // Issue #1326: a step's line rows are read beside the measurement's (`lineRowsOf`), never by it — the rows of the lines
+  // the step touches; every other line's row is unchanged and passed when its last step was taken.
+  const measured = report.candidates[0]?.geometry?.rows ?? [];
+  const rows = lineRows.length === 0 ? measured : [...measured, ...lineRows];
   const required = (r: MeasureRow): boolean => {
     if (artBoundAbsent(artFit, r)) return false;
     if (r.code === 'MQ_OVERSHOOT') return r.art?.connectivity === 8;
@@ -1426,7 +1451,7 @@ type PhaseEnd =
  * unreplayed run held after that step.
  */
 function accept(run: Run, kind: AcceptedOperation['kind'], sourceVertices: number[]): boolean {
-  if (kind === 'boundary-run' && run.plant === 'run-split-per-vertex') {
+  if ((kind === 'boundary-run' || kind === 'line-run') && run.plant === 'run-split-per-vertex') {
     for (const v of sourceVertices) run.acceptedAt.push({ step: run.steps, kind: 'removal', count: 1, sourceVertices: [v] });
   } else {
     run.acceptedAt.push({ step: run.steps, kind, count: kind === 'insertion' ? 1 : sourceVertices.length, sourceVertices: [...sourceVertices] });
@@ -1460,7 +1485,18 @@ export type ReductionPlant =
   | RetriangulationPlant
   | OrderPlant
   | AmplitudePlant
-  | RefinementPlant;
+  | RefinementPlant
+  | LinePlant;
+
+/**
+ * Issue #1326's faults in the line mechanism, for the `mesh-quality` suite's controls: the line rows read by no step
+ * (neither before the structure nor beside the measurement); the hole a line vertex leaves ear-clipped whole rather
+ * than along the line's chord, so only the edge check after it can refuse an unjoined chain; that check skipped as
+ * well; the post-pass flipping line edges; a vertex two lines list left removable; the line-run sweep counting a
+ * step at every start, whether or not it tries a run there; and the rows read before the structure half a pixel
+ * short of each line's bound, so they refuse steps the rows would take.
+ */
+export type LinePlant = 'line-rows-unread' | 'line-chord-unconstrained' | 'line-join-unchecked' | 'line-flips-unguarded' | 'line-crossings-unkept' | 'line-sweep-counts-steps' | 'line-early-short';
 
 /**
  * Issue #1311's faults in the refinement: the insertion its rule chose written without asking whether it writes a
@@ -1501,7 +1537,7 @@ export type AmplitudePlant =
 /** One removal-phase attempt as a control reads it (issue #1279): what was tried, and what refused it or null when taken. */
 export interface AttemptRecord {
   step: number;
-  kind: 'removal' | 'boundary-run';
+  kind: 'removal' | 'boundary-run' | 'line-run';
   sourceVertices: number[];
   /** Null when taken; else reads the name of what refused it — measuring the attempt in full when the floor decided it. Read it only inside the observer, while the working mesh is the one the attempt was tried on. */
   refusedBy: (() => string) | null;
@@ -1618,7 +1654,7 @@ type Removal = { triangles: Array<[number, number, number]>; added: () => Array<
  * One removal made on `work`'s triangles: the triangles after it — every triangle not touching `v` as it was, the
  * same tuple, then the hole's new ones, `fresh` — or the structural reason it cannot be made.
  */
-function removalStep(work: Work, v: number): { triangles: Array<[number, number, number]>; fresh: Array<[number, number, number]> } | { blocked: string } {
+function removalStep(work: Work, v: number, chords: readonly Chord[] = []): { triangles: Array<[number, number, number]>; fresh: Array<[number, number, number]> } | { blocked: string } {
   const star = work.triangles.filter((t) => t.includes(v));
   const next = new Map<number, number>();
   const incoming = new Set<number>();
@@ -1645,7 +1681,23 @@ function removalStep(work: Work, v: number): { triangles: Array<[number, number,
   if (ring.length !== (boundary ? next.size + 1 : next.size)) return { blocked: `retriangulation: vertex ${v}'s triangles do not form one fan` };
   const rest = work.triangles.filter((t) => !t.includes(v));
   const fresh: Array<[number, number, number]> = [];
-  if (ring.length >= 3) {
+  if (ring.length >= 3 && chords.length > 0) {
+    const poly = ring.map((id): [number, number] => [work.pos[id][0], work.pos[id][1]]);
+    if (findSelfIntersection(poly) !== null) return { blocked: `retriangulation: the hole vertex ${v} leaves is not a strictly simple polygon` };
+    const pieces = chordPieces(work, v, ring, poly, chords);
+    if ('blocked' in pieces) return pieces;
+    for (const piece of pieces.pieces) {
+      const pp = piece.map((id): [number, number] => [work.pos[id][0], work.pos[id][1]]);
+      let tris: number[];
+      try {
+        tris = earClip(pp);
+      } catch (err) {
+        if (!(err instanceof MeshError)) throw err;
+        return { blocked: `retriangulation: the hole vertex ${v} leaves does not ear-clip on the side of a line's chord (${err.message})` };
+      }
+      for (let i = 0; i < tris.length; i += 3) fresh.push([piece[tris[i]], piece[tris[i + 1]], piece[tris[i + 2]]]);
+    }
+  } else if (ring.length >= 3) {
     const poly = ring.map((id): [number, number] => [work.pos[id][0], work.pos[id][1]]);
     if (findSelfIntersection(poly) !== null) return { blocked: `retriangulation: the hole vertex ${v} leaves is not a strictly simple polygon` };
     let tris: number[];
@@ -1662,9 +1714,54 @@ function removalStep(work: Work, v: number): { triangles: Array<[number, number,
   return { triangles: [...rest, ...fresh], fresh };
 }
 
+/**
+ * Issue #1326: a line's chord through a removed vertex — its kept neighbours along the line, `a` before and `c` after
+ * in listed order, which the hole the vertex leaves has to join by an edge.
+ */
+interface Chord {
+  a: number;
+  c: number;
+  line: string;
+}
+
+/** Issue #1326: the chords a removal of `v` must keep, the vertices in `gone` already removed by the same operation; null when no line is declared. */
+type ChordsFor = ((v: number, gone: ReadonlySet<number>) => Chord[]) | null;
+
+/**
+ * Issue #1326: the hole `v` leaves cut along each chord in turn, so that each chord is a side of a piece and the pieces'
+ * ear-clipped triangles hold it as an edge — or the line refusal naming the chord when it is not a diagonal of the
+ * hole: its ends are not in one piece, or a piece it makes is not strictly simple or does not turn as the hole turns
+ * (the chord leaves the hole, or runs through a vertex of it). A chord that is already a side is left as it is.
+ */
+function chordPieces(work: Work, v: number, ring: readonly number[], poly: ReadonlyArray<readonly [number, number]>, chords: readonly Chord[]): { pieces: number[][] } | { blocked: string } {
+  const turn = Math.sign(signedArea(poly.map((q): [number, number] => [q[0], q[1]])));
+  const unjoinable = (ch: Chord): { blocked: string } => ({
+    blocked: `line "${ch.line}" (a): the kept line vertices ${ch.a}–${ch.c} on either side of vertex ${v} cannot be joined — the chord is not a diagonal of the hole ${v} leaves`,
+  });
+  const pieces: number[][] = [[...ring]];
+  for (const ch of chords) {
+    const k = pieces.findIndex((pc) => pc.includes(ch.a) && pc.includes(ch.c));
+    if (k === -1) return unjoinable(ch);
+    const pc = pieces[k];
+    const ia = pc.indexOf(ch.a);
+    const ic = pc.indexOf(ch.c);
+    const lo = Math.min(ia, ic);
+    const hi = Math.max(ia, ic);
+    if (hi - lo === 1 || (lo === 0 && hi === pc.length - 1)) continue;
+    const one = pc.slice(lo, hi + 1);
+    const two = [...pc.slice(hi), ...pc.slice(0, lo + 1)];
+    for (const piece of [one, two]) {
+      const pp = piece.map((id): [number, number] => [work.pos[id][0], work.pos[id][1]]);
+      if (Math.sign(signedArea(pp)) !== turn || findSelfIntersection(pp) !== null) return unjoinable(ch);
+    }
+    pieces.splice(k, 1, one, two);
+  }
+  return { pieces };
+}
+
 /** `removalStep` with the edges it adds: those of the hole's new triangles no triangle before it holds, in their order. */
-function removalOf(work: Work, v: number, audit: EdgeSetAudit | null = null): Removal {
-  const step = removalStep(work, v);
+function removalOf(work: Work, v: number, audit: EdgeSetAudit | null = null, chordsFor: ChordsFor = null): Removal {
+  const step = removalStep(work, v, chordsFor === null ? [] : chordsFor(v, new Set()));
   if ('blocked' in step) return step;
   const old = work.triangles;
   const n = work.alive.length;
@@ -1705,7 +1802,7 @@ function loadOrder(run: Run): { order: number[]; load: Map<number, number> } {
   const order: number[] = [];
   for (let v = 0; v < work.nSource; v++) {
     if (!work.alive[v] || run.protectedVertices.has(v)) continue;
-    const step = removalOf(work, v, run.edgeAudit);
+    const step = removalOf(work, v, run.edgeAudit, chordsForRun(run, [v]));
     let most = 0;
     if ('blocked' in step) most = Infinity;
     else for (const [a, b] of step.added()) most = Math.max(most, edgeLoad(work, a, b));
@@ -1728,16 +1825,18 @@ function loadOrder(run: Run): { order: number[]; load: Map<number, number> } {
  * structural reason one of the removals cannot be made. The outline loses the run and gains the chord from the
  * vertex before it to the vertex after it; nothing is measured in between.
  */
-function runRemovalOf(work: Work, vertices: readonly number[], audit: EdgeSetAudit | null = null): Removal {
+function runRemovalOf(work: Work, vertices: readonly number[], audit: EdgeSetAudit | null = null, chordsFor: ChordsFor = null): Removal {
   const was = work.triangles;
   // Issue #1307: each removal's own added edges are never read here, so none is built; what the run adds is read off
   // the triangles its removals made. A triangle of `after` that no removal made is the same tuple as one of `was`
   // (`removalStep` keeps every untouched triangle as it was), so every edge it holds is old and it adds nothing.
   const made = new Set<readonly number[]>();
   let after: Array<[number, number, number]>;
+  const gone = new Set<number>();
   try {
     for (const v of vertices) {
-      const step = removalStep(work, v);
+      const step = removalStep(work, v, chordsFor === null ? [] : chordsFor(v, gone));
+      gone.add(v);
       if ('blocked' in step) return step;
       for (const t of step.fresh) made.add(t);
       work.triangles = step.triangles;
@@ -1840,6 +1939,40 @@ function removeVertices(run: Run): PhaseEnd {
         }
       }
     }
+    // Issue #1326: line runs, under the same opt-in — each line in declared order, each start in its listed order, the
+    // runs of 2 to `maxVertices` consecutive kept line vertices from it, longest first, never an open line's end or a
+    // protected vertex, never leaving a closed line fewer than three. The first taken ends that start's sweep.
+    if (runs !== undefined && run.lines !== null) {
+      for (const line of run.lines.lines) {
+        for (const s of line.vertices) {
+          if (run.plant === 'line-sweep-counts-steps') run.steps++;
+          if (!work.alive[s] || run.protectedVertices.has(s)) continue;
+          const chain = line.vertices.filter((v) => work.alive[v]);
+          const at = chain.indexOf(s);
+          const most = line.closed ? Math.min(runs.maxVertices, chain.length - 3) : Math.min(runs.maxVertices, chain.length - 1 - at);
+          for (let r = most; r >= 2; r--) {
+            const members: number[] = [];
+            for (let i = 0; i < r; i++) {
+              const v = chain[(at + i) % chain.length];
+              if (run.protectedVertices.has(v)) break;
+              members.push(v);
+            }
+            if (members.length < r) continue;
+            if (run.steps >= input.budget.maxCandidates) return { kind: 'budget' };
+            run.steps++;
+            tried++;
+            const block = tryOperation(run, members, false, 'line-run');
+            if (run.observe !== null) run.observe({ step: run.steps, kind: 'line-run', sourceVertices: [...members], refusedBy: block === null ? null : () => refusalText(block), decidedByFloor: typeof block === 'function' && block.decidedByFloor, pass, predictedLoad: null });
+            if (block === null) {
+              taken++;
+              if (accept(run, 'line-run', members)) return { kind: 'replayed' };
+              break;
+            }
+            lastBlock = { refusal: block, what: `removing source vertices ${members.join(', ')} of line "${line.name}" as one line run` };
+          }
+        }
+      }
+    }
     // Issue #1283: with the load order the pass's singles are ranked once, here, over the mesh the runs left; without
     // it they are every source index ascending, exactly as before the field.
     const ranked = byLoad ? loadOrder(run) : null;
@@ -1863,7 +1996,8 @@ function removeVertices(run: Run): PhaseEnd {
     if (taken === 0) {
       // A pass that took nothing left the working mesh as it found it, so a refusal the floor decided is measured
       // now in the state it was decided in.
-      const constraint = tried === 0 ? 'protect: every surviving source vertex is protected (protect.hull, protect.vertices, protect.edges, protect.regionBoundaries or a weightJump edge)' : lastName();
+      const kept = run.lines === null ? '' : ", or an open line's end or a vertex two lines list";
+      const constraint = tried === 0 ? `protect: every surviving source vertex is protected (protect.hull, protect.vertices, protect.edges, protect.regionBoundaries or a weightJump edge${kept})` : lastName();
       return { kind: 'stuck', constraint };
     }
   }
@@ -1982,7 +2116,15 @@ export interface FloorAudit {
  */
 function structureOf(run: Run, vertices: readonly number[]): string | { canon: Canonical; undo: () => void } {
   const { work, input } = run;
-  const step = vertices.length === 1 ? removalOf(work, vertices[0], run.edgeAudit) : runRemovalOf(work, vertices, run.edgeAudit);
+  // Issue #1326: what a line asks of the structure — enough of it kept, its chord through each removed vertex an edge
+  // of the hole's triangulation, and every consecutive pair of its kept vertices an edge after the step.
+  const touched = run.lines === null ? [] : touchedLines(run, vertices);
+  if (touched.length > 0) {
+    const structural = lineStructure(run, vertices, touched);
+    if (structural !== null) return structural;
+  }
+  const chordsFor = touched.length === 0 ? null : chordsForRun(run, vertices);
+  const step = vertices.length === 1 ? removalOf(work, vertices[0], run.edgeAudit, chordsFor) : runRemovalOf(work, vertices, run.edgeAudit, chordsFor);
   if ('blocked' in step) return step.blocked;
   const jump = input.protect.weightJump;
   if (jump !== null) {
@@ -2012,6 +2154,24 @@ function structureOf(run: Run, vertices: readonly number[]): string | { canon: C
       }
     }
   }
+  if (touched.length > 0 && run.plant !== 'line-join-unchecked') {
+    const n = work.alive.length;
+    const edges = new Set<number>();
+    for (const t of work.triangles) for (let k = 0; k < 3; k++) edges.add(pairKey(t[k], t[(k + 1) % 3], n));
+    for (const li of touched) {
+      const line = run.lines!.lines[li];
+      const chain = line.vertices.filter((v) => work.alive[v]);
+      const pairs = line.closed ? chain.length : chain.length - 1;
+      for (let k = 0; k < pairs; k++) {
+        const a = chain[k];
+        const b = chain[(k + 1) % chain.length];
+        if (!edges.has(pairKey(a, b, n))) {
+          undo();
+          return `line "${line.name}" (a): the consecutive kept line vertices ${a}–${b} are no longer joined by an edge`;
+        }
+      }
+    }
+  }
   try {
     return { canon: canonicalise(work, run.sourceTurn, run.boneRank), undo };
   } catch (err) {
@@ -2074,7 +2234,7 @@ function auditFloors(audit: FloorAudit, run: Run, vertices: readonly number[], e
  * before the structure is built (`earlyFloor`); an attempt it refuses is not built at all unless an observer or the
  * floor audit asks what the path before would have decided.
  */
-function tryOperation(run: Run, vertices: readonly number[], full: boolean): Refusal | null {
+function tryOperation(run: Run, vertices: readonly number[], full: boolean, kind: AttemptRecord['kind'] = vertices.length > 1 ? 'boundary-run' : 'removal'): Refusal | null {
   const { input } = run;
   const floored = !full && run.plant !== 'measure-every-candidate' && !(vertices.length > 1 && run.plant === 'run-skips-rows');
   const audit = run.floorAudit;
@@ -2100,18 +2260,40 @@ function tryOperation(run: Run, vertices: readonly number[], full: boolean): Ref
       return refusal;
     }
   }
+  // Issue #1326: the rows of the lines the operation touches, read before any structure is built — they read nothing
+  // but the line vertices' positions, which the operation fixes, so this is the row itself and not a bound on it, and
+  // a refusal here is the one the measurement would make. Read, the refusal names what the full path names.
+  const touched = run.lines === null || run.plant === 'line-rows-unread' ? [] : touchedLines(run, vertices);
+  let lineRows: MeasureRow[] = [];
+  if (floored && touched.length > 0) {
+    const structural = lineStructure(run, vertices, touched);
+    if (structural !== null) return structural;
+    lineRows = lineRowsOf(run, vertices, touched);
+    const short = run.plant === 'line-early-short' ? 0.5 : 0;
+    if (lineRows.some((r) => r.state !== 'pass' || (short > 0 && r.value! > r.bound!.value - short))) {
+      const members = [...vertices];
+      const refusal = (() => {
+        const measured = tryOperation(run, members, true, kind);
+        if (measured === null) throw new Error(`a line row refused removing ${members.join(', ')}, which the full path accepts`);
+        return refusalText(measured);
+      }) as FloorRefusal;
+      refusal.decidedByFloor = true;
+      return refusal;
+    }
+  }
   const built = structureOf(run, vertices);
   if (typeof built === 'string') return built;
   const { canon, undo } = built;
   if (audit !== null && early !== null) auditFloors(audit, run, vertices, early, deviationFloor(run, canon.mesh, vertices), false);
-  const phase: SkinningInspection['phase'] = vertices.length > 1 ? 'boundary-run' : 'removal';
+  const phase: SkinningInspection['phase'] = kind;
   if (vertices.length > 1 && run.plant === 'run-skips-rows') {
     followSkinning(run, phase);
     return null;
   }
   const measured = measureAgainstTargets(run, canon.mesh, 'candidate');
+  if (touched.length > 0 && lineRows.length === 0) lineRows = lineRowsOf(run, vertices, touched);
   const blocking =
-    firstBlockingRow(measured, run.input.targets.artFit) ??
+    firstBlockingRow(measured, run.input.targets.artFit, lineRows) ??
     (run.plant === 'amplitude-gates-steps' ? ((measured.candidates[0]?.geometry?.rows ?? []).find((r) => (r.code === 'MQ_DEFORM_LOAD' || r.code === 'MQ_ALLOCATION_CONTRAST') && r.state === 'undeclared') ?? null) : null);
   if (blocking !== null) {
     undo();
@@ -2201,6 +2383,14 @@ function delaunayFlips(run: Run, plant: ReductionPlant | null): FlipResult {
   const alive = work.alive.reduce((n, a) => n + (a ? 1 : 0), 0);
   const maxFlips = (alive * (alive - 1)) / 2;
   const guarded = new Set(run.protectedEdges.map(([a, b]) => edgeKey(a, b)));
+  // Issue #1326: every edge between consecutive kept line vertices is held as a protected edge is — the pass flips none.
+  if (run.lines !== null && plant !== 'line-flips-unguarded') {
+    for (const line of run.lines.lines) {
+      const chain = line.vertices.filter((v) => work.alive[v]);
+      const pairs = line.closed ? chain.length : chain.length - 1;
+      for (let k = 0; k < pairs; k++) guarded.add(edgeKey(chain[k], chain[(k + 1) % chain.length]));
+    }
+  }
   const jump = input.protect.weightJump;
   const regions = plant === 'flips-ignore-regions' ? [] : input.targets.regions;
   const heldCache = new Map<string, boolean>();
@@ -2497,8 +2687,10 @@ function reduceValidated(
       stepRasters: steps,
       skinning: null,
       hooks,
+      lines: null,
     };
     run.skinning = skinningRunOf(run, skinningAdmitted);
+    run.lines = lineRunOf(run);
 
     // Issue #1268: a replay ends in its own termination, never as an exhausted budget; a stop the run never reaches
     // leaves the run's own termination, which then carries `stopAfterAccepted` saying so.
@@ -2731,5 +2923,120 @@ function effectiveOf(input: MeshReductionInput, measured: EffectiveSettings, sou
     ...(amplitude === undefined ? {} : { motionAmplitude: amplitude }),
     ...(input.retriangulate === undefined ? {} : { retriangulate: input.retriangulate }),
     ...(input.removalOrder === undefined ? {} : { removalOrder: input.removalOrder }),
+    ...(input.lines === undefined ? {} : { lines: input.lines }),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// named lines (issue #1326, docs/MESH_REDUCTION.md §11)
+// ---------------------------------------------------------------------------
+
+/**
+ * The input's lines as the steps read them, or null when `lines` was left out. An open line's two ends and every
+ * vertex two lines list — a crossing or the end of a shared run — are added to the protected vertices: an end has one
+ * neighbour on the line, so no chord can stand for it, and removing a shared vertex would make two chains disagree
+ * about where they meet. Every other line vertex stays a candidate, held by the steps to its line.
+ */
+function lineRunOf(run: Run): LineRun | null {
+  const declared = run.input.lines;
+  if (declared === undefined) return null;
+  const of = new Map<number, number[]>();
+  const at = declared.map((line, li) => {
+    const here = new Map<number, number>();
+    line.vertices.forEach((v, k) => {
+      here.set(v, k);
+      const list = of.get(v);
+      if (list === undefined) of.set(v, [li]);
+      else list.push(li);
+    });
+    return here;
+  });
+  for (const line of declared) {
+    if (!line.closed) {
+      run.protectedVertices.add(line.vertices[0]);
+      run.protectedVertices.add(line.vertices[line.vertices.length - 1]);
+    }
+  }
+  if (run.plant !== 'line-crossings-unkept') for (const [v, list] of of) if (list.length > 1) run.protectedVertices.add(v);
+  return { lines: declared, of, at };
+}
+
+/** The lines an operation removing `vertices` touches — those listing any of them — ascending, which is declared order. */
+function touchedLines(run: Run, vertices: readonly number[]): number[] {
+  const out = new Set<number>();
+  for (const v of vertices) for (const li of run.lines!.of.get(v) ?? []) out.add(li);
+  return [...out].sort((a, b) => a - b);
+}
+
+/** What a line asks before its row: a closed line keeps three vertices and an open one its ends. Null when the operation leaves both. */
+function lineStructure(run: Run, vertices: readonly number[], touched: readonly number[]): string | null {
+  const { work } = run;
+  for (const li of touched) {
+    const line = run.lines!.lines[li];
+    const kept = line.vertices.filter((v) => work.alive[v] && !vertices.includes(v)).length;
+    if (line.closed && kept < 3) return `line "${line.name}": removing ${vertices.join(', ')} would leave ${kept} of its vertices kept; required at least 3 on a closed line`;
+    if (!line.closed && (vertices.includes(line.vertices[0]) || vertices.includes(line.vertices[line.vertices.length - 1]))) {
+      return `line "${line.name}": removing ${vertices.join(', ')} would remove an end of the open line; required both ends kept`;
+    }
+  }
+  return null;
+}
+
+/**
+ * The rows of the touched lines on the chain the operation leaves — the measurement's own rows (`lineDeviationRows`),
+ * over the source's points by source index: a line vertex is kept when it is alive and not removed by the operation.
+ */
+function lineRowsOf(run: Run, vertices: readonly number[], touched: readonly number[]): MeasureRow[] {
+  const { work } = run;
+  const gone = new Set(vertices);
+  return lineDeviationRows(
+    run.input.attachment,
+    touched.map((li) => run.lines!.lines[li]),
+    run.input.source.points,
+    (v) => (work.alive[v] && !gone.has(v) ? v : null),
+  );
+}
+
+/**
+ * The chords a removal must keep (`ChordsFor`), or null when no declared line is touched or a plant takes the chords
+ * away: for each line listing `v`, its kept neighbours before and after `v` in listed order (wrapping on a closed
+ * line), skipping what the operation has already removed. A side with no kept neighbour — an open line's end — has
+ * no chord.
+ */
+function chordsForRun(run: Run, vertices: readonly number[]): ChordsFor {
+  if (run.lines === null || run.plant === 'line-chord-unconstrained' || run.plant === 'line-join-unchecked') return null;
+  if (!vertices.some((v) => run.lines!.of.has(v))) return null;
+  const { work } = run;
+  const lines = run.lines;
+  return (v, gone) => {
+    const out: Chord[] = [];
+    for (const li of lines.of.get(v) ?? []) {
+      const line = lines.lines[li];
+      const list = line.vertices;
+      const k = lines.at[li].get(v)!;
+      const keptAt = (i: number): boolean => work.alive[list[i]] && !gone.has(list[i]) && list[i] !== v;
+      let a = -1;
+      let c = -1;
+      for (let step = 1; step < list.length; step++) {
+        const i = k - step;
+        if (i < 0 && !line.closed) break;
+        const j = (i + list.length) % list.length;
+        if (keptAt(j)) {
+          a = list[j];
+          break;
+        }
+      }
+      for (let step = 1; step < list.length; step++) {
+        const i = k + step;
+        if (i >= list.length && !line.closed) break;
+        const j = i % list.length;
+        if (keptAt(j)) {
+          c = list[j];
+          break;
+        }
+      }
+      if (a !== -1 && c !== -1 && a !== c) out.push({ a, c, line: line.name });
+    }
+    return out;
   };
 }