rig-parts 2.4.1 → 2.5.0

package/cli.ts

@@ -783,7 +783,9 @@ usage:
       --seam overrides config.assemble.seam, otherwise ${DEFAULT_SEAM_RULE}. --project says where a layer takes
       the painting's pixel: core (the reference's) erodes every layer's top-most
       opaque area by 5x5 first, so a part a few pixels wide takes none; visible
-      erodes only along a rim where a later layer is in front. It defaults to
+      erodes only along a rim where a later layer is in front, and resolves the
+      parts' edges from the painting (the line and coverage where two parts
+      meet, issue #953). --project overrides config.assemble.project, otherwise
       ${DEFAULT_PROJECT_RULE}.
 
   rig-parts assemble --propose-plan --source <painting.png> --full <dir|psd>
@@ -864,8 +866,8 @@ usage:
       green build ends with the pack line beside the spineboy yardstick and the
       three artifact paths — skeleton .json, .atlas and the packed page: the
       packed atlas is the result, the loose parts are the intermediate it was
-      made from. --seam overrides config.assemble.seam, otherwise ${DEFAULT_SEAM_RULE}; --project to
-      ${DEFAULT_PROJECT_RULE} (both as for assemble), --page-edges to ${DEFAULT_PAGE_EDGES} and
+      made from. --seam overrides config.assemble.seam, otherwise ${DEFAULT_SEAM_RULE}; --project overrides
+      config.assemble.project, otherwise ${DEFAULT_PROJECT_RULE} (both as for assemble), --page-edges to ${DEFAULT_PAGE_EDGES} and
       --pack-shape to ${DEFAULT_PACK_SHAPE} (as for check; both packed builds, rig's gate
       and check's artifact, take them). --requirements is forwarded to check
       (as for check); the file's own shape is read before assemble runs, and
@@ -1745,8 +1747,8 @@ function cmdAssemble(args: string[]): number {
   if (!propose && !flags.has('--out')) return usage('assemble needs --out <dir>');
   const seam = flags.get('--seam');
   if (seam !== undefined && !(SEAM_RULES as readonly string[]).includes(seam)) return usage(`--seam ${seam}; one of ${SEAM_RULES.join(', ')} is required`);
-  const project = flags.get('--project') ?? DEFAULT_PROJECT_RULE;
-  if (!(PROJECT_RULES as readonly string[]).includes(project)) return usage(`--project ${project}; one of ${PROJECT_RULES.join(', ')} is required`);
+  const project = flags.get('--project');
+  if (project !== undefined && !(PROJECT_RULES as readonly string[]).includes(project)) return usage(`--project ${project}; one of ${PROJECT_RULES.join(', ')} is required`);
   const [source, full, config] = ['--source', '--full', '--config'].map((f) => flags.get(f) as string);
   const head = flags.get('--head') ?? null;
   const writePath = flags.get('--write-config');
@@ -1772,7 +1774,7 @@ function cmdAssemble(args: string[]): number {
     }
     const out = flags.get('--out') as string;
     assembleStage(
-      { source, full, head, config, ...(flags.has('--requirements') ? { requirements: flags.get('--requirements') as string } : {}), ...(seam === undefined ? {} : { seam: seam as SeamRule }), project: project as ProjectRule, ...(alts.length === 0 ? {} : { alts }) },
+      { source, full, head, config, ...(flags.has('--requirements') ? { requirements: flags.get('--requirements') as string } : {}), ...(seam === undefined ? {} : { seam: seam as SeamRule }), ...(project === undefined ? {} : { project: project as ProjectRule }), ...(alts.length === 0 ? {} : { alts }) },
       { partsJson: join(out, 'rig', 'parts.json'), partsDir: join(out, 'rig', 'parts'), recomposite: join(out, 'render', 'recomposite_rig.png'), errorMap: join(out, 'render', ERROR_MAP_FILE) },
       console.log,
     );
@@ -1965,8 +1967,8 @@ function cmdBuild(args: string[]): number {
   if (on.has('--all-sets') && flags.has('--set')) return usage('--set and --all-sets are two modes; give one');
   const seam = flags.get('--seam');
   if (seam !== undefined && !(SEAM_RULES as readonly string[]).includes(seam)) return usage(`--seam ${seam}; one of ${SEAM_RULES.join(', ')} is required`);
-  const project = flags.get('--project') ?? DEFAULT_PROJECT_RULE;
-  if (!(PROJECT_RULES as readonly string[]).includes(project)) return usage(`--project ${project}; one of ${PROJECT_RULES.join(', ')} is required`);
+  const project = flags.get('--project');
+  if (project !== undefined && !(PROJECT_RULES as readonly string[]).includes(project)) return usage(`--project ${project}; one of ${PROJECT_RULES.join(', ')} is required`);
   const edges = pageEdgesOf(flags.get('--page-edges'));
   if (!isPageEdges(edges)) return usage(edges);
   const shape = packShapeOf(flags.get('--pack-shape'));
@@ -1988,7 +1990,7 @@ function cmdBuild(args: string[]): number {
   const scratch = mkdtempSync(join(tmpdir(), 'rig-parts-build-'));
   try {
     const r = build(
-      { config, source, full, head, out, ...(seam === undefined ? {} : { seam: seam as SeamRule }), project: project as ProjectRule, loop, pageEdges: edges, packShape: shape, ...(flags.has('--requirements') ? { requirements: flags.get('--requirements') as string } : {}), idleKeys: keys, ...(leadText === undefined ? {} : { leadIn: Number(leadText) }), seamPairs: on.has('--seam-pairs'), keepStills: on.has('--keep-stills'), noExtremes: on.has('--no-extremes'), ...(alts.length === 0 ? {} : { alts }), ...(flags.has('--set') ? { set: flags.get('--set') as string } : {}), allSets: on.has('--all-sets'), ...(flags.has('--environment') ? { environment: flags.get('--environment') as string } : {}), ...(flags.has('--wind-band') ? { windBand: flags.get('--wind-band') as string } : {}) },
+      { config, source, full, head, out, ...(seam === undefined ? {} : { seam: seam as SeamRule }), ...(project === undefined ? {} : { project: project as ProjectRule }), loop, pageEdges: edges, packShape: shape, ...(flags.has('--requirements') ? { requirements: flags.get('--requirements') as string } : {}), idleKeys: keys, ...(leadText === undefined ? {} : { leadIn: Number(leadText) }), seamPairs: on.has('--seam-pairs'), keepStills: on.has('--keep-stills'), noExtremes: on.has('--no-extremes'), ...(alts.length === 0 ? {} : { alts }), ...(flags.has('--set') ? { set: flags.get('--set') as string } : {}), allSets: on.has('--all-sets'), ...(flags.has('--environment') ? { environment: flags.get('--environment') as string } : {}), ...(flags.has('--wind-band') ? { windBand: flags.get('--wind-band') as string } : {}) },
       { rig: rigcRunner(bin), check: rigcRunner(bin), checkBin: bin, scratch: join(scratch, 'rig-gate'), stages: {
         assemble: (input, outputs) => runBuildProcess({ stage: 'assemble', bin, input, outputs }, join(scratch, 'workers')),
         rig: (input, _rigc, gateScratch) => runBuildProcess({ stage: 'rig', bin, input, scratch: gateScratch }, join(scratch, 'workers')),

package/docs/AUTHORING.md

@@ -148,6 +148,7 @@ read by no CPU stage).
 | `seethrough.head_box` | inputs (cuts the head image there; optional at the first call); assemble — where the head run sits on the painting | **proposed** by `propose --head-box` from the full run, square, source pixels, shifted inside the painting when needed; the head run must then be fed exactly that crop. With one run (no `--head`, issue #359: an artist's own file, §4 *For artists*) it is left out — there is no crop to place — and a config that sets it is refused (`ASSEMBLE_SINGLE_RUN_HEAD_BOX`) |
 | `seethrough.arm_split` | assemble, `assemble --propose-plan` — separates a single full-run `handwear-r` or `handwear-l` layer that holds both overlapping arms into both arm tags | **authored**, optional (issue #439): `{x?: number, line?: [[x, y], …], order: ["handwear-r", "handwear-l"] \| ["handwear-l", "handwear-r"]}` in `seethrough.resolution` full-run pixels. Exactly one of `x` (image column, `0 <= x <= resolution`) or `line` (a polyline of two or more `[x, y]` points in `[0, resolution]`, interpolated in x along y and clamped above/below its endpoints) is required (`CONFIG_FIELD_PRESENT`, `CONFIG_FIELD_TYPE`), and `order` is `[back_tag, front_tag]`, the draw order of the two separated arm layers (`CONFIG_FIELD_PRESENT`, `CONFIG_FIELD_TYPE`). Pixels at `< splitX(y)` go to `handwear-r` (image left, the subject's right arm) and pixels at `>= splitX(y)` go to `handwear-l` (image right, the subject's left arm). A split line that cuts a horizontal opaque run of the arm layer into more than two segments is refused (`ASSEMBLE_ARM_SPLIT_CUTS_ARM`). Without the declaration, when one arm layer's 8-connected component reaches both wrists under `propose --keypoints`, `propose` emits an `overlapping-arms` `LINT` naming the part, both wrists and `seethrough.arm_split`; absent, no byte of any output moves |
 | `assemble.seam` | assemble, build | **authored**, optional `"near-white"` or `"silhouette"` (issue #905). An explicit `--seam` overrides the config; otherwise this field overrides the existing `near-white` default. An invalid value is `CONFIG_FIELD_TYPE` at `config.assemble.seam`, including when a CLI override is given. Absent, existing build bytes are unchanged. |
+| `assemble.project` | assemble, build | **authored**, optional `"core"` or `"visible"` (issue #953): the projection rule for this character. An explicit `--project` overrides the config; otherwise this field overrides the existing `core` default. An invalid value is `CONFIG_FIELD_TYPE` at `config.assemble.project`, including when a CLI override is given. Absent, existing build bytes are unchanged. |
 | `assemble.rig_scale` | assemble — the rig is `trunc(w × rig_scale)` x `trunc(h × rig_scale)`, and every rig-px value after it (`bones`, `meshes`, `motion`, `patches`, `cuts`) is in that rig's pixels; `check --source` (`CHECK_SOURCE_SIZE`) and `compose` (`SCENE_RIG_SCALE_AGREES`) read it back off `parts.json` | authored; rig pixels per source pixel. 0.5 in both examples (a 1664x2432 painting makes an 832x1216 rig). **Keep the figure about 1,100 to 1,200 rig px tall** — the `H` of `propose`'s `mesh spacing:` note, the height of the parts' boxes together — so for another painting, about 1,150 over the figure's height in painting px: that is the size the proposer's spacing divisor was calibrated at (H 1106–1185, the `mesh spacing` note says so) and the size of the two examples `check`'s bars are derived from, and the proposer and `check` also hold fixed rig-px values that do not scale with it (the fringe's 10 px step, the trunk segments' 18, 20, 30 and 100 px, the 15 px wrist tolerance, the 10-row pendant floor, the seam bar's 50 rig px over 40). What else it trades, measured on `demo` with the README loop from a fresh config at 0.25, 0.5 and 1 (issue #345, rig-c 2.47.1): the same plan and the same ten chains; every bar but the one the uncorrected `demo` always fails (`bottomwear` `TIP_OVER_ROOT`, the README loop's `RL01`) passing at all three; the atlas page 418x606, 832x1205 and 1825x2047; the figure's mesh spacing 16, 32 and 64, so 830, 868 and 932 triangles; the breath 2.5 % of a torso that scales with it; and the proposed bones, scaled to 0.5, off the 0.5 proposal's by up to 38 px at 0.25 and 22.5 px at 1 (the hairpin's origin; the skirt roots 20 and 10.5) — the fixed-px values above. `propose` records it on the proposal as `proposed_rig_scale` (issue #354), and changing `assemble.rig_scale` after the rig sections are written is refused (`CONFIG_PROPOSED_RIG_SCALE`): without that refusal `demo`'s tracked config built at 0.25 gated green and `check` failed only `TIP_OVER_ROOT` on both sleeves (`propose --from-config` named 54 `LINT` lines, links off the art) — re-run `assemble` and `propose` at the new scale. Absent: `CONFIG_FIELD_PRESENT`; 0, negative or not a number: `CONFIG_FIELD_TYPE`; a rig under 1x1: `ASSEMBLE_RIG_SIZE` |
 | `assemble.plan` | assemble; also the list every `meshes`/`regions` key must come from | **proposed** by `assemble --propose-plan`. `[part name, "full" \| "head", See-through tag]`, in draw order back to front. Names are free; roles come from the tag. A layer the author made and added to a run takes `author:<label>` in the tag's place, and has no role (§5, *A layer the author made*). When `generation.control.skeleton` is present and a full-run `handwear-r` or `handwear-l` layer merges sleeve, bare hand and overgarment drape into one layer — a skin-coloured hand cluster (`>= 40` run px, `GHOST_MIN_AREA`, measured `516..4,787` run px across the 9-standee corpus) lies within `0.35` forearm lengths of `<s>_wrist` and non-skin pixels reach more than `1.0x` the forearm length (`<s>_elbow -> <s>_wrist`) below `<s>_wrist` (issue #490; measured `-0.15x..0.45x` on the 6 clean standees vs `1.25x..2.02x` on the 3 merged standees, placing `1.0x` inside the `0.45x..1.25x` gap) — the layer is split into `drape-<s>`, `handwear-<s>` and `hand-<s>` (back to front) when the Euclidean RGB distance between the sleeve median colour above `<s>_wrist` and the drape median colour below `<s>_wrist` is at least `80` (`ARM_DRAPE_COLOR_DISTANCE`, measured `103.6..236.0` on the two distinct-colour merged standees vs `20.8..28.2` on the same-colour merged standee, placing `80` between `28.2` and `103.6`), or refused with `SEETHROUGH_ARM_RUN_MERGED` when the distance is under `80` |
 | `assemble.extend_below_crop` | assemble | **proposed** with the plan: `{part, run, tag}` — a head-run part that reaches the bottom of the head crop is continued from a full-run layer, whole connected components |
@@ -4191,7 +4192,33 @@ takes every other top-most `alpha >= 250` pixel; neither rule takes a fringe pix
 projected from 36,227 to 22,476 (`reference-sample`) and 76,801 to 49,672 (`reference-demo`), recomposite
 error pixels from 4,512 to 4,116 and 11,050 to 9,820, and the check seam from 0.207 to
 0.206 and 0.326 to 0.325, with no other check figure changed. The default stays the
-reference's so the examples stay comparable with it. `build` takes both flags.
+reference's so the examples stay comparable with it. `build` takes both flags, and
+`config.assemble.project` sets the rule per character (an explicit `--project` wins).
+
+Under `visible` the parts' edges are also resolved from the painting (issue #953,
+`src/paintingedges.ts`). A See-through run is capped at its resolution, so every run
+layer is enlarged into the rig and its alpha edge is a soft ramp the painting does not
+have; where two parts meet along a painted line each layer repaints the line on its own
+side of its ramp — a doubled line, a stair-step, or the background through a gap where
+neither is opaque. Within 3 rig px of where two parts' half-coverage lines meet (or a
+part's and the background's), the part drawn in front takes the painting's coverage
+along the axis from the colour behind to its own, its colour unmixed from the colour
+behind, and the part behind is made opaque under it in that colour, so the composite
+is the painting and the rim stays the occluding part's. Where a painted line is darker or
+lighter than both colours, the front part's alpha rises until the composite is within 20
+of the painting. A pixel is left as it was where
+a third part with alpha above 8 covers it, where the painting draws no edge between the
+two (contrast below 40, the recomposite's error limit), where either part is a patch,
+keeps the pixel, feathers it, or is a turn's moving pair. A part's art keeps its
+4-connected pieces (`CONTOUR_ONE_ISLAND` reads them so): a write that would split a piece
+or start a new one is left out. The assemble line says how
+many pixels it resolved and why it left the rest; the pixels it writes are
+`provenance.automatic[].stage: "paintingEdge"`. On the five public examples it lowered
+the recomposite's error pixels under `visible` from 11,780 to 765 (`demo`), 7,427 to
+703 (`reference-demo`), 3,965 to 243 (`reference-sample`), 6,749 to 2,190 (`scarf`)
+and 13,872 to 1,110 (`wind`), and the holes from 1,020 to 62, 453 to 40, 259 to 20,
+291 to 34 and 1,118 to 62; `check` passes the same bars as before on all five. A
+painting patch is read placed on the rig canvas, and is never written. `core` is unchanged.
 
 **`rig --idle-keys ctl|direct`** (and `build --idle-keys`, which forwards the
 value to its rig stage; without the flag, or with `ctl`, a build writes and prints
@@ -4492,8 +4519,9 @@ still ends in the unchanged class by the first comparison.
 
 Automatic value changes are named `sourceProjection`, `extend`, `growRim`,
 `limbCap`, `limbFeather`, `fringeRestore`, `seamOverride`, `armSplit`,
-`headFaceUnderfill`, `ghostCleanup` or `paintingExtension`. `limbSplit` and `limbHybrid` remain
+`headFaceUnderfill`, `ghostCleanup`, `paintingExtension` or `paintingEdge`. `limbSplit` and `limbHybrid` remain
 recognized stage names, but their pure copies do not claim a value change.
+`paintingEdge` (under `visible` only) is a part's edge resolved from the painting;
 `paintingExtension` copies unheld painting samples within an explicit band;
 `painting_extension_px` counts that ownership assignment independently, even
 when restoring raw-layer values makes its final value class unchanged.

package/docs/STABILITY.md

@@ -147,7 +147,7 @@ part name, `[i]` an entry of a list):
 - **generation.control.skeleton**, the pose file it names when it is no built-in — required: `width`, `height`, `points`
 - **seethrough** — required: `resolution`, `steps`, `seed`, `offload`; optional: `head_box`, `arm_split`
 - **seethrough.arm_split** — required: `order`, and one of `x` or `line` (issue #439)
-- **assemble** — required: `rig_scale`, `plan` (from plain `assemble` on); optional: `seam`, `extend_below_crop`, `patches`, `cuts`, `alternates`, `head_face_underfill`, `yield_refused`, `keep_under_occluders`, `extend_painting`, `take`, `editor_receipts`
+- **assemble** — required: `rig_scale`, `plan` (from plain `assemble` on); optional: `seam`, `project`, `extend_below_crop`, `patches`, `cuts`, `alternates`, `head_face_underfill`, `yield_refused`, `keep_under_occluders`, `extend_painting`, `take`, `editor_receipts`
 - **assemble.alternates[i]** — required: `name`; optional: `source`, `full`, `head`, `parts`, `hides`, `head_box`, `cuts`, `skeleton`, `anchor`, `base_anchor`, `drawn`, `tips`, `front`, `layers`, `focus` (issues #454, #465, #543, #652, #664, #666, #719, #780). `focus` is an authored finite `[x, y]` in painting pixels, within its canvas (edges included), refused as CONFIG_SET_FOCUS before assemble output when invalid; only when present, `parts.json` records it with focus_source_size and `sets.json` emits it in setup-world coordinates through the actual rig resize and `src/coords.ts`. Absent focus emits no field or inferred value; changing/removing it requires reassembly
 - **assemble.extend_below_crop[i]** — required: `part`, `run`, `tag`
 - **assemble.extend_painting[i]** — required: `part`, `band`, `max_distance`; optional: `min_held_alpha`, `order` (issues #848, #854, #855; explicit final layer-derived part, half-open rig band and positive four-neighbour path bound; base painting only). The optional integer floor 1–255 admits exact original alpha-over coverage strictly below it; absent or 1 blocks every nonzero holder. Only selected target samples below the floor may take painting RGBA; target samples at/above the floor and every non-target holder remain exact. By default overlapping reachable claims refuse. With `order` on every entry (unique nonnegative safe integers), lower values claim first and their gains block later candidates and paths; array order never breaks ties or supplies missing precedence
@@ -225,6 +225,13 @@ part name, `[i]` an entry of a list):
 Invalid values refuse as `CONFIG_FIELD_TYPE` at `config.assemble.seam`;
 an absent field preserves existing output bytes.
 
+`assemble.project` accepts `core` or `visible` (issue #953). CLI
+`--project` overrides config, then the existing `core` default applies.
+Invalid values refuse as `CONFIG_FIELD_TYPE` at `config.assemble.project`;
+an absent field preserves existing output bytes. The bytes `visible` writes
+are not promised across versions (issue #953 resolves its edges from the
+painting).
+
 `TY14` holds the set of field names in backticks above to the set of names the
 loader's object checks spell (every `c.object(…)` in `src/config.ts`, with the lists
 they name), in both directions, and refuses an object check whose key list it cannot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {
@@ -68,7 +68,7 @@
   },
   "dependencies": {
     "ag-psd": "^31.0.2",
-    "@rig-c/core": "3.2.0"
+    "@rig-c/core": "3.2.1"
   },
   "devDependencies": {
     "@esotericsoftware/spine-core": "4.3.13",

package/src/assemble.ts

@@ -1,4 +1,6 @@
 import { type SeamRule } from './seamrule.ts';
+import { DEFAULT_PROJECT_RULE, type ProjectRule } from './projectrule.ts';
+import { paintingEdges, type PaintingEdgeSkips } from './paintingedges.ts';
 import { edgeLength } from './length.ts';
 import { materialSource, type MaterialSource, materialRows, polygonMaterialEdges, type MaterialRow, type MaterialEdge, type PlacedArt } from './cutmaterial.ts';
 import { unionTakenSources } from './takesource.ts';
@@ -191,23 +193,7 @@ export const SILHOUETTE_LIMIT = 40;
 
 export { DEFAULT_SEAM_RULE, SEAM_RULES, type SeamRule } from './seamrule.ts';
 
-/**
- * Where a layer may take the painting's pixel (`projectSource`). `core` is the
- * reference's rule: the layer's top-most `alpha >= 250` pixels eroded by a 5x5
- * square, so a part a few pixels wide has no core and none of its visible
- * pixels is projected. `visible` keeps the erosion only where it guards
- * something — along a rim where a later layer of the run is in front — and
- * projects every other top-most `alpha >= 250` pixel of the layer.
- */
-export type ProjectRule = 'core' | 'visible';
-export const PROJECT_RULES: readonly ProjectRule[] = ['core', 'visible'];
-
-/**
- * The projection rule a run uses when none is named: the reference's, so the
- * examples stay comparable with it. `visible` was measured on both public
- * examples against it (the change that added the flag); it is opt-in.
- */
-export const DEFAULT_PROJECT_RULE: ProjectRule = 'core';
+export { DEFAULT_PROJECT_RULE, PROJECT_RULES, type ProjectRule } from './projectrule.ts';
 
 // ---------------------------------------------------------------------------
 // inputs
@@ -4598,6 +4584,8 @@ export interface AssembleResult {
   hidden: HiddenArtUse[];
   seamRule: SeamRule;
   projectRule: ProjectRule;
+  /** Issue #953: what `paintingEdges` resolved, under `projectRule: 'visible'` only. */
+  paintingEdges?: PaintingEdgeReading;
   depthReadings?: Array<{ from: string; reading: import('./depthsheets.ts').DepthReading }>;
   /** Visible registered samples clamped within <1 source pixel of a crop. */
   depthClamps?: Array<{ part: string; samples: number }>;
@@ -4613,6 +4601,14 @@ export interface AssembleResult {
   capSplits: SplitCount[];
 }
 
+/** Issue #953: the edge pixels `paintingEdges` resolved, the part pixels it changed, and the edge pixels it left, by reason. */
+export interface PaintingEdgeReading {
+  resolved: number;
+  unseparated: number;
+  changed: number;
+  skipped: PaintingEdgeSkips;
+}
+
 /** A hidden-art layer of a run (issue #359) and what read it: `cuts[i].under`, or a limb segment's cap; none is said. */
 export interface HiddenArtUse {
   /** `<run>:<layer>:hidden`. */
@@ -5588,6 +5584,48 @@ export function assemble(input: AssembleInput): AssembleResult {
       }
     }
   });
+  // Issue #953: under `visible`, the parts' visible edges are the painting's (`paintingEdges`); See-through keeps the hidden surface.
+  const edged = new Map<string, Mask>();
+  let edgeReading: PaintingEdgeReading | null = null;
+  if (projectRule === 'visible') {
+    // paintingEdges reads every image as the whole rig canvas. A plan part's image already is one; a patch is its cut,
+    // placed at record.x / record.y, so it is placed on a canvas here. The step never writes a patch, so a copy is enough.
+    const onRig = (q: PlacedPart): Raster => {
+      const { image, record } = q;
+      if (image.width === W && image.height === H && record.x === 0 && record.y === 0) return image;
+      const whole = newRaster(W, H);
+      for (let y = 0; y < image.height; y++) {
+        const ry = record.y + y;
+        if (ry < 0 || ry >= H) continue;
+        for (let x = 0; x < image.width; x++) {
+          const rx = record.x + x;
+          if (rx < 0 || rx >= W) continue;
+          const s = (y * image.width + x) * 4;
+          whole.data.set(image.data.subarray(s, s + 4), (ry * W + rx) * 4);
+        }
+      }
+      return whole;
+    };
+    const e = paintingEdges(stack.map(onRig), srcr, {
+      painted: paintedFigure(srcr),
+      editable: order.map((d) => !('patch' in d)),
+      keep: keepInOrder,
+      feathered: featheredInOrder,
+      movingPair: input.turnMovingPair === undefined || input.turnMovingPair === null ? null : (a, b) => (input.turnMovingPair as (x: string, y: string) => boolean)(stack[a].record.name, stack[b].record.name),
+      written: (i, p) => {
+        writersInOrder[i][p] = AW.paintingEdge;
+        const d = order[i];
+        if (!('patch' in d)) {
+          const region = pieceAt(d).b.region;
+          if (region !== null && stack[i].image.data[p * 4 + 3] > 0) region.data[p] = 1;
+        }
+      },
+    });
+    order.forEach((d, i) => {
+      if (!('patch' in d) && e.changed[i].data.some((v) => v === 1)) edged.set(pieceAt(d).name, e.changed[i]);
+    });
+    edgeReading = { resolved: e.resolved, unseparated: e.unseparated, changed: e.changed.reduce((a, m) => a + m.data.reduce((x, v) => x + v, 0), 0), skipped: e.skipped };
+  }
   const pushedOf: FringePushed[][] = plan.map(() => []);
   const pushedOfCut: FringePushed[][] = cuts.map(() => []);
   const pushedOfLimb: FringePushed[][] = lim.parts.map(() => []);
@@ -5610,6 +5648,18 @@ export function assemble(input: AssembleInput): AssembleResult {
     ...cuts.map((q, i) => ({ name: q.into, b: pieces[i] as Built, pushed: pushedOfCut[i], at: `config.assemble.cuts[${i}]`, cutFrom: q.from, set: (pp: PlacedPart) => (cutPlaced[i] = pp) })),
     ...lim.parts.map((q, i) => ({ name: q.part, b: limbPieces[i] as Built, pushed: pushedOfLimb[i], at: `config.limbs.${q.limb}.segments[${q.segment}]`, cutFrom: null, limb: q.record, set: (pp: PlacedPart) => (limbPlaced[i] = pp) })),
   ].filter((q) => !taken.has(q.name));
+  /** Issue #953: the part's projected pixels `paintingEdges` rewrote, less those an earlier exclusion already took out of `source_px_taken`. */
+  const edgedTaken = (name: string, st: ProjectionStats, region: Mask | null): number => {
+    const m = edged.get(name);
+    if (m === undefined) return 0;
+    let k = 0;
+    for (let p = 0; p < W * H; p++) {
+      if (m.data[p] !== 1 || st.takenMask.data[p] !== 1 || (region !== null && region.data[p] !== 1)) continue;
+      if (paintingGains.get(name)?.data[p] === 1 || retakeByName.get(name)?.data[p] === 1 || yields.get(name)?.mask.data[p] === 1) continue;
+      k++;
+    }
+    return k;
+  };
   pieceList.forEach(({ name, b, pushed: pushedHere, at, cutFrom, limb, set }) => {
     const { key, r, st, extendKeys, trace, merged, region } = b;
     // A pixel the merge wrote is judged in the extend layer's run, every other
@@ -5625,7 +5675,7 @@ export function assemble(input: AssembleInput): AssembleResult {
       // A pixel outside the piece's region is a base pixel filled from a cut's under image (issue #193): occluded, never visible.
       if (r.data[p * 4 + 3] > OPAQUE_ALPHA_ABOVE && own.clear.data[p] === 1 && (region === null || region.data[p] === 1)) visible.data[p] = 1;
       if (paintingGains.get(name)?.data[p] === 1) visible.data[p] = 1;
-      if (paintingGains.get(name)?.data[p] !== 1 && retakeByName.get(name)?.data[p] !== 1 && yields.get(name)?.mask.data[p] !== 1 && trace.ring.data[p] === 0 && own.takenMask.data[p] === 1 && (region === null || region.data[p] === 1)) projected.data[p] = 1;
+      if (edged.get(name)?.data[p] !== 1 && paintingGains.get(name)?.data[p] !== 1 && retakeByName.get(name)?.data[p] !== 1 && yields.get(name)?.mask.data[p] !== 1 && trace.ring.data[p] === 0 && own.takenMask.data[p] === 1 && (region === null || region.data[p] === 1)) projected.data[p] = 1;
     }
     const { x0, y0, x1, y1, opaque } = measureBox(r);
     if (opaque === 0) {
@@ -5650,7 +5700,7 @@ export function assemble(input: AssembleInput): AssembleResult {
       visible_px: vc.visible_px,
       occluded_px: vc.occluded_px,
       projected_core_px: region === null ? st.core : count(st.coreMask, region),
-      source_px_taken: (region === null ? st.taken : count(st.takenMask, region)) - (yields.get(name)?.reading.yieldedTaken ?? 0) - (retakeByName.get(name) == null ? 0 : count(st.takenMask, retakeByName.get(name)!)) - (paintingGains.has(name) ? count(st.takenMask, paintingGains.get(name)!) : 0),
+      source_px_taken: (region === null ? st.taken : count(st.takenMask, region)) - (yields.get(name)?.reading.yieldedTaken ?? 0) - (retakeByName.get(name) == null ? 0 : count(st.takenMask, retakeByName.get(name)!)) - (paintingGains.has(name) ? count(st.takenMask, paintingGains.get(name)!) : 0) - edgedTaken(name, st, region),
       visible_not_projected_px: vc.visible_not_projected_px,
       refused_drift_px: region === null ? st.refused : count(st.refusedMask, region),
       merged_px: merged,
@@ -5771,6 +5821,7 @@ export function assemble(input: AssembleInput): AssembleResult {
     hidden: [...hiddenUses].map(([layer, readBy]) => ({ layer, readBy })),
     seamRule,
     projectRule,
+    ...(edgeReading === null ? {} : { paintingEdges: edgeReading }),
     ...(headFacePrep.underfillPx > 0 ? { headFaceUnderfillPx: headFacePrep.underfillPx } : {}),
     excluded,
     islands: islandKept.counts,

package/src/build.ts

@@ -1,4 +1,6 @@
 import { DEFAULT_SEAM_RULE } from './seamrule.ts';
+import { DEFAULT_PROJECT_RULE } from './projectrule.ts';
+import { EDGE_CONTRAST } from './paintingedges.ts';
 import { SETUP_PAINTING_LINE, setupPaintingLines } from './setuppainting.ts';
 import { boundaryColourLines } from './boundarycolour.ts';
 import { writeMaterialSources } from './cutmaterialio.ts';
@@ -169,7 +171,8 @@ export interface AssembleStageInput {
   head: string | null;
   config: string;
   seam?: SeamRule;
-  project: ProjectRule;
+  /** `--project`; absent, `config.assemble.project`, then {@link DEFAULT_PROJECT_RULE} (issue #953). */
+  project?: ProjectRule;
   /** `--alt` entries, merged with `config.assemble.alternates` by set name (issue #454). */
   alts?: readonly AlternateCliInput[];
   /**
@@ -335,6 +338,7 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
   // regions and motion, so it requires only what it reads (issue #20).
   const cfg = loadEarlyConfig(input.config, 'assemble');
   const seam = input.seam ?? cfg.assemble.seam ?? DEFAULT_SEAM_RULE;
+  const project = input.project ?? cfg.assemble.project ?? DEFAULT_PROJECT_RULE;
   const src = readSource(input.source);
   const read = readRuns(input.full, input.head);
   // Issue #946: every declared receipt is held to its file, and under `required` every edited image needs one, before anything is assembled.
@@ -346,7 +350,7 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
   const fields = stageFields(cfg, runs.single ? { w: src.width, h: src.height } : null);
   const under = readUnders(input.config, fields.cuts);
   const caps = fields.limbs === undefined ? undefined : readCaps(input.config, fields.limbs);
-  const result = assemble({ source: src, full: runs.full, head: runs.head, depth: cfg.depth, depthBase: dirname(resolve(input.config)), ...fields, under, ...(caps === undefined ? {} : { caps }), seamRule: seam, projectRule: input.project });
+  const result = assemble({ source: src, full: runs.full, head: runs.head, depth: cfg.depth, depthBase: dirname(resolve(input.config)), ...fields, under, ...(caps === undefined ? {} : { caps }), seamRule: seam, projectRule: project });
 
   // Issue #454: alternate painting sets, assembled before any file is written.
   const configDir = dirname(resolve(input.config));
@@ -688,7 +692,7 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
         ...(fields.turnMovingPair === undefined ? {} : { turnMovingPair: fields.turnMovingPair }),
         ...(fields.turn === undefined ? {} : { turn: fields.turn, regions: fields.regions, meshes: fields.meshes, motion: fields.motion }),
         seamRule: seam,
-        projectRule: input.project,
+        projectRule: project,
         ...(altExclude.length === 0 ? {} : { exclude: altExclude }),
         ...(altIslands.length === 0 ? {} : { limbIslands: altIslands }),
         ...(altOthers === undefined ? {} : { otherLimbs: alternateLayerOthers(altOthers, selectedLayers.groups) }),
@@ -805,6 +809,11 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
   if (figurePath !== null) writePng(figurePath, result.figure as Raster);
   const [W, H] = result.parts.rig_size;
   log(`rig-parts assemble: ${result.images.length} part(s) on a ${W}x${H} rig (${result.parts.scale_rig_per_source} rig px per source px), seam rule ${result.seamRule}, projection rule ${result.projectRule}`);
+  // Issue #953: what the painting's edges resolved, under the visible rule only.
+  if (result.paintingEdges !== undefined) {
+    const e = result.paintingEdges;
+    log(`painting edges: ${e.resolved} edge px resolved from the painting (${e.unseparated} against the two reference colours where the window's far sides overlap), ${e.changed} part px changed; left as they were: ${e.skipped.cover} under a part the two-layer model does not carry, ${e.skipped.contrast} where the painting draws no edge (contrast below ${EDGE_CONTRAST}), ${e.skipped.locked} kept, feathered, a patch or a turn's moving pair, ${e.skipped.noBehind} with no behind pixel in the window; ${e.skipped.pieces} part px not written so a part's art keeps its pieces`);
+  }
   // Issue #359: one run, said, so a reader of the lines knows no head run was placed.
   if (runs.single) log(`  one run: ${input.full} holds the face (${SINGLE_RUN_FACE_TAGS.join(', ')}), so no head run is read; every part comes from the full run`);
   // Issue #366: a file that is not the resolution square was padded to it; said, with where parts.json records it. None for a square file.
@@ -2241,7 +2250,8 @@ export interface BuildInput {
   head: string | null;
   out: string;
   seam?: SeamRule;
-  project: ProjectRule;
+  /** `--project`; absent, `config.assemble.project`, then {@link DEFAULT_PROJECT_RULE} (issue #953). */
+  project?: ProjectRule;
   loop: boolean;
   /** `--page-edges` for both packed builds, the rig stage's gate and the check's artifact. */
   pageEdges: PageEdges;
@@ -2446,7 +2456,8 @@ export function build(input: BuildInput, run: BuildRunners, log: Log): BuildResu
     // Issue #607: the bytes this read parsed are the ones check.json's config record hashes, under the path as typed.
     const loaded = loadConfigWithBytes(input.config);
     const seam = input.seam ?? loaded.config.assemble.seam ?? DEFAULT_SEAM_RULE;
-    log(`rig-parts build: ${input.config} -> ${out}, seam rule ${seam}, projection rule ${input.project}, page edges ${input.pageEdges}, pack shape ${input.packShape ?? DEFAULT_PACK_SHAPE}${idleKeys === DEFAULT_IDLE_KEYS ? '' : `, idle keys ${idleKeys}`}${input.loop ? `, with the idle loop${input.leadIn === undefined ? '' : ` after a lead-in of ${input.leadIn} period(s)`}` : ''}`);
+    const project = input.project ?? loaded.config.assemble.project ?? DEFAULT_PROJECT_RULE;
+    log(`rig-parts build: ${input.config} -> ${out}, seam rule ${seam}, projection rule ${project}, page edges ${input.pageEdges}, pack shape ${input.packShape ?? DEFAULT_PACK_SHAPE}${idleKeys === DEFAULT_IDLE_KEYS ? '' : `, idle keys ${idleKeys}`}${input.loop ? `, with the idle loop${input.leadIn === undefined ? '' : ` after a lead-in of ${input.leadIn} period(s)`}` : ''}`);
     configRecord = inputFileRecord(loaded.bytes, input.config);
     req = buildRequirements(input.requirements, loaded.config.requirements, input.config);
     // The same for the requirements file's own shape; its names resolve against the rig, in the check, before it builds.
@@ -2456,7 +2467,7 @@ export function build(input: BuildInput, run: BuildRunners, log: Log): BuildResu
     // And the steady-wind band spec (issue #590), as check reads it.
     if (input.windBand !== undefined) readWindBand(input.windBand);
     stages.assemble(
-      { source: input.source, full: input.full, head: input.head, config: input.config, seam, project: input.project, ...(req === null ? {} : { requirements: req.read }), ...(input.alts === undefined ? {} : { alts: input.alts }) },
+      { source: input.source, full: input.full, head: input.head, config: input.config, seam, project, ...(req === null ? {} : { requirements: req.read }), ...(input.alts === undefined ? {} : { alts: input.alts }) },
       { partsJson: join(out, 'parts.json'), partsDir: join(out, 'parts'), recomposite: join(out, 'recomposite_rig.png'), errorMap: join(out, ERROR_MAP_FILE) },
       prefixed('assemble'),
     );

package/src/config.ts

@@ -1,4 +1,5 @@
 import { SEAM_RULES, type SeamRule } from './seamrule.ts';
+import { PROJECT_RULES, type ProjectRule } from './projectrule.ts';
 import type { TakeLayers } from './takelayers.ts';
 import { paintingExtensionProblems, type PaintingExtension } from './paintingextension.ts';
 import { baseAnchorProblems, type BaseAnchor } from './baseanchor.ts';
@@ -304,6 +305,8 @@ export interface AlternateSetConfig {
 export interface Assemble {
   /** Optional per-character seam rule; an explicit CLI flag wins. */
   seam?: SeamRule;
+  /** Optional per-character projection rule (issue #953); an explicit CLI flag wins. */
+  project?: ProjectRule;
   /** Verified named replacements from another See-through run (#866). */
   take?: TakeLayers[];
   /** Issue #946: receipts for images edited in an image editor; absent, no file is read and no byte moves. */
@@ -1626,7 +1629,7 @@ export interface EarlyConfig {
   depth?: DepthConfig;
   key: string;
   seethrough: SeeThrough;
-  assemble: { rig_scale: number; seam?: SeamRule; take?: TakeLayers[]; editor_receipts?: EditorReceipts; head_face_underfill?: boolean; yield_refused?: boolean; keep_under_occluders?: string[]; extend_painting?: PaintingExtension[] };
+  assemble: { rig_scale: number; seam?: SeamRule; project?: ProjectRule; take?: TakeLayers[]; editor_receipts?: EditorReceipts; head_face_underfill?: boolean; yield_refused?: boolean; keep_under_occluders?: string[]; extend_painting?: PaintingExtension[] };
 }
 
 /** What plain `assemble` reads: the early config plus the plan `--propose-plan` printed. */
@@ -1702,9 +1705,9 @@ function parseEarlyConfigFrom(raw: Json, door: EarlyDoor, base: string | null):
   if (door === 'layers') {
     if ('seethrough' in t) checkSeeThrough(c, t.seethrough);
     if ('assemble' in t) {
-      const a = c.object('config.assemble', t.assemble, sectionRequired(door, 'assemble'), ['plan', 'extend_below_crop', 'patches', 'cuts', 'alternates', 'head_face_underfill', 'yield_refused', 'keep_under_occluders', 'extend_painting', 'take', 'seam', 'editor_receipts']);
+      const a = c.object('config.assemble', t.assemble, sectionRequired(door, 'assemble'), ['plan', 'extend_below_crop', 'patches', 'cuts', 'alternates', 'head_face_underfill', 'yield_refused', 'keep_under_occluders', 'extend_painting', 'take', 'seam', 'project', 'editor_receipts']);
       if (a !== null) {
-        checkSeam(c, a);
+        checkAssembleRules(c, a);
         if ('rig_scale' in a) c.number('config.assemble.rig_scale', a.rig_scale, 'positive');
         if ('head_face_underfill' in a && typeof a.head_face_underfill !== 'boolean') {
           c.fail('CONFIG_FIELD_TYPE', 'config.assemble.head_face_underfill', `is ${show(a.head_face_underfill)}; true or false is required`);
@@ -2503,17 +2506,20 @@ function checkEditorReceipts(c: Check, value: Json): void {
   });
 }
 
-function checkSeam(c: Check, a: Record<string, Json>): void {
+function checkAssembleRules(c: Check, a: Record<string, Json>): void {
   if ('seam' in a && !(SEAM_RULES as readonly unknown[]).includes(a.seam)) {
     c.fail('CONFIG_FIELD_TYPE', 'config.assemble.seam', `is ${show(a.seam)}; one of ${SEAM_RULES.join(', ')} is required`);
   }
+  if ('project' in a && !(PROJECT_RULES as readonly unknown[]).includes(a.project)) {
+    c.fail('CONFIG_FIELD_TYPE', 'config.assemble.project', `is ${show(a.project)}; one of ${PROJECT_RULES.join(', ')} is required`);
+  }
 }
 
 function checkAssemble(c: Check, v: Json, door: 'assemble' | 'full'): { parts: string[]; patches: string[]; cuts: string[] } {
   const required = sectionRequired(door, 'assemble');
-  const a = c.object('config.assemble', v, required.filter((k) => k !== 'plan'), ['plan', 'extend_below_crop', 'patches', 'cuts', 'alternates', 'head_face_underfill', 'yield_refused', 'keep_under_occluders', 'extend_painting', 'take', 'seam', 'editor_receipts']);
+  const a = c.object('config.assemble', v, required.filter((k) => k !== 'plan'), ['plan', 'extend_below_crop', 'patches', 'cuts', 'alternates', 'head_face_underfill', 'yield_refused', 'keep_under_occluders', 'extend_painting', 'take', 'seam', 'project', 'editor_receipts']);
   if (a === null) return { parts: [], patches: [], cuts: [] };
-  checkSeam(c, a);
+  checkAssembleRules(c, a);
   if (required.includes('plan') && !('plan' in a)) {
     c.fail('CONFIG_FIELD_PRESENT', 'config.assemble.plan', 'is absent and required; `assemble --propose-plan` prints one from the two runs — paste its plan and extend_below_crop into config.assemble');
   }

package/src/paintingedges.ts

@@ -0,0 +1,543 @@
+import { OPAQUE_ALPHA_ABOVE } from './layers.ts';
+import { connectedComponents } from './raster/components.ts';
+import { type Mask, newMask, type Raster, RasterError } from './raster/types.ts';
+
+/**
+ * Issue #953, under `projectRule: 'visible'` only: the parts' visible edges are
+ * resolved from the painting, at the rig's own density, and See-through keeps
+ * what lies under another part (its hidden surface) and the partition into
+ * parts. Not in the reference.
+ *
+ * Why: a See-through run is capped at its resolution (1024 on the public
+ * examples, over the padded square of the painting), so every run layer is
+ * enlarged into the rig and its alpha edge is a soft ramp the painting does not
+ * have; where two parts meet along a painted line each layer repaints the line
+ * on its own side of its own ramp, which reads as a doubled line, a stair-step
+ * and, where neither layer is opaque, the background through a gap. Projection
+ * (`projectSource`) recolours only a layer's opaque area, so it cannot reach
+ * either.
+ *
+ * The step reads the final stack (every part on the full rig canvas, in draw
+ * order) and the painting resampled into the rig, and writes alpha and colour
+ * at the pixels near a visible outline. Everything else is unchanged.
+ *
+ * ⚖️ Invariant. Let OWNER(p) be the top-most part with alpha above
+ * {@link EDGE_OWNER_ALPHA} at p, or the background (-1): See-through's own
+ * half-coverage line, which says which parts meet and roughly where. A pixel
+ * is an EDGE pixel when another owner lies within {@link EDGE_RADIUS}
+ * (Chebyshev) — the nearest one, ties to the part drawn in front. Of the pair
+ * (p's owner, that nearest other), FRONT is the one drawn in front and BEHIND
+ * the other (the background is behind every part). Inside the
+ * `(2 * EDGE_RADIUS + 1)²` window around p:
+ *
+ * - the behind colour `Cb` is the per-channel median of the painting over the
+ *   window's BEHIND-owned pixels farthest from FRONT (the window pixels least
+ *   likely to be the edge), so a painted line between the two never sets it;
+ * - the front reference `Cf` is the painting at the window's FRONT-owned pixel
+ *   farthest from `Cb` (max channel, the distance every other assemble limit
+ *   is in; first in scan order on a tie) — a painted line along FRONT's
+ *   outline counts as FRONT, which gives the line to the part drawn in front,
+ *   the part whose outline it is in the rig;
+ * - FRONT's coverage at p is P's position along `Cb -> Cf` (integer dot
+ *   products), normalised by a trimap: 0 at the highest position among the
+ *   BEHIND-side pixels above, 1 at the lowest among FRONT's window pixels
+ *   farthest from BEHIND. Where those two sides do not separate along the axis
+ *   (a side is all edge, or the textures overlap) — counted as `unseparated` —
+ *   the ends are `Cb` and `Cf` themselves. On a mix of the two colours it is
+ *   the mixing weight, and a texture of BEHIND across that axis reads as 0
+ *   rather than as FRONT (measured: a distance-only weight left a 10–27 % halo
+ *   of the face over the hair at 3–4 rig px from the face's edge on
+ *   reference-sample);
+ * - on FRONT's side of See-through's line, a pixel whose colour FRONT itself
+ *   holds deeper in (within half of {@link EDGE_CONTRAST}, and nearer that
+ *   than any BEHIND-side pixel) is FRONT's interior — a lining, a highlight —
+ *   and reads 1, however it falls along the axis.
+ *
+ * A painted pixel no part covers above the owner floor — the gap between two
+ * soft rims — is owned by the nearest part (within `2 * EDGE_RADIUS + 2`), so
+ * the gap is never read as the background's colour.
+ *
+ * The ring rule. Rings are counted in Chebyshev distance from the other owner.
+ * FRONT's coverage never rises going away from FRONT and never falls going
+ * into it: on the inner ring (FRONT-owned, next to the line) it is at least
+ * that of its resolved outer-ring neighbours (a painted line just outside
+ * See-through's line is FRONT's outline, so what lies between is FRONT's too);
+ * deeper inside it is the greater of See-through's own alpha and the
+ * painting's (the ramp past the half line is filled; a light interior is never
+ * holed); farther out it is no more than its neighbour one ring nearer.
+ * Resolved ring by ring, outer before inner.
+ *
+ * FRONT's alpha becomes that coverage (as 0..255, rounded; within
+ * {@link OPAQUE_ALPHA_ABOVE} of 0 or 255 it is snapped there), and its colour
+ * the painting unmixed from `Cb` (`Cb + (P - Cb) / a`, clamped); at `a = 1` that
+ * is the painting's pixel. Where that colour clamps so the composite would
+ * miss the painting by more than half of {@link EDGE_CONTRAST} (a painted line
+ * darker or lighter than both colours), FRONT's alpha rises to the least that
+ * brings it within. Where FRONT does not cover p fully and BEHIND is a
+ * part, BEHIND is made opaque there in `Cb` (in the painting's own colour
+ * where FRONT's alpha is 0), so the flat composite at p is the painting, the
+ * rim stays FRONT's, and BEHIND's hidden surface past the window is untouched.
+ *
+ * A pixel is left as it was — and counted, by reason — when a part drawn in
+ * front of FRONT, or between BEHIND and FRONT, has alpha above
+ * {@link OPAQUE_ALPHA_ABOVE} there (its coverage is not modelled: a
+ * translucent part is never erased; at or below that floor a part is not
+ * opaque anywhere in this package, and it is left as it was); when
+ * `|Cf - Cb|` (max channel) is below {@link EDGE_CONTRAST} (the painting draws
+ * no edge between the two: a pair under the recomposite's error limit cannot
+ * hold an error pixel); when
+ * either part may not be edited (`editable`: a painting patch is the painting
+ * already); when either part keeps the pixel (`keep`, issue #637), feathers it
+ * (`feathered`, a limb's authored soft edge) or the two are a turn's moving
+ * pair; or when the window holds no BEHIND-owned pixel.
+ *
+ * A part's art (alpha above {@link OPAQUE_ALPHA_ABOVE}) keeps its pieces,
+ * read 4-connected as `CONTOUR_ONE_ISLAND` reads them: where the step would
+ * split a piece, each cut-off part is joined back to the piece's largest part
+ * along the path that restores the fewest lowered pixels, and those are not
+ * written; a new piece
+ * holding none of the part's art is not written (`pieces`, counted per part
+ * and pixel). Where that leaves out BEHIND's fill under FRONT, FRONT takes the
+ * painting's pixel at full alpha instead, under the same rule.
+ *
+ * Every decision is read off the stack as it stood before the step, then
+ * applied, so the result does not depend on the order pixels are visited.
+ * Deterministic: integer rig arithmetic, medians by sort, no float reduction
+ * whose order varies.
+ */
+export const EDGE_RADIUS = 3;
+/** The owner's alpha floor: above it a part covers a pixel. Equal to `COVERED_ALPHA` in `src/assemble.ts` (held by the selftest). */
+export const EDGE_OWNER_ALPHA = 128;
+/** The least front contrast resolved, max channel. Equal to `ERROR_LIMIT` in `src/assemble.ts` (held by the selftest). */
+export const EDGE_CONTRAST = 40;
+
+/** Why an edge pixel was left as it was; see {@link paintingEdges}. */
+export interface PaintingEdgeSkips {
+  cover: number;
+  contrast: number;
+  locked: number;
+  noBehind: number;
+  /** Part writes left out so a part's art keeps its 4-connected pieces (counted per part and pixel, not per edge pixel). */
+  pieces: number;
+}
+
+export interface PaintingEdgeResult {
+  /** Per part (stack index), the pixels whose RGBA the step changed. */
+  changed: Mask[];
+  /** Edge pixels resolved (whether or not a value changed), and the ones left. */
+  resolved: number;
+  /** Of `resolved`, the pixels whose two far sides did not separate along the axis, read against `Cb` and `Cf` themselves. */
+  unseparated: number;
+  skipped: PaintingEdgeSkips;
+}
+
+export interface PaintingEdgeOptions {
+  /**
+   * Per rig pixel, 1 where the painting shows figure (`paintedFigure` in
+   * `src/assemble.ts`). A figure pixel no part covers above
+   * {@link EDGE_OWNER_ALPHA} — a gap between two parts' soft rims — is owned by
+   * the nearest part within the cap, not the background: the painting holds
+   * figure there, and taking the behind colour from it would take a painted line.
+   */
+  painted: Uint8Array;
+  /** Per part: whether the step may write it (false for a painting patch). */
+  editable: readonly boolean[];
+  keep?: ReadonlyArray<Mask | null>;
+  feathered?: ReadonlyArray<Mask | null>;
+  /** Two parts a turn moves against each other; their shared edge is left alone. */
+  movingPair?: ((a: number, b: number) => boolean) | null;
+  /** Called once per part and pixel whose RGBA changed. */
+  written?: (part: number, pixel: number) => void;
+}
+
+/** Chebyshev distance to the nearest set pixel, capped at `cap` (two-pass, exact for the 8-neighbour metric). */
+function chebyshev(set: Uint8Array, W: number, H: number, cap: number): Uint8Array {
+  const d = new Uint8Array(W * H).fill(cap);
+  for (let p = 0; p < W * H; p++) if (set[p] === 1) d[p] = 0;
+  for (let y = 0; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      const p = y * W + x;
+      let v = d[p];
+      if (v === 0) continue;
+      if (x > 0) v = Math.min(v, d[p - 1] + 1);
+      if (y > 0) {
+        v = Math.min(v, d[p - W] + 1);
+        if (x > 0) v = Math.min(v, d[p - W - 1] + 1);
+        if (x < W - 1) v = Math.min(v, d[p - W + 1] + 1);
+      }
+      d[p] = Math.min(v, cap);
+    }
+  }
+  for (let y = H - 1; y >= 0; y--) {
+    for (let x = W - 1; x >= 0; x--) {
+      const p = y * W + x;
+      let v = d[p];
+      if (v === 0) continue;
+      if (x < W - 1) v = Math.min(v, d[p + 1] + 1);
+      if (y < H - 1) {
+        v = Math.min(v, d[p + W] + 1);
+        if (x < W - 1) v = Math.min(v, d[p + W + 1] + 1);
+        if (x > 0) v = Math.min(v, d[p + W - 1] + 1);
+      }
+      d[p] = Math.min(v, cap);
+    }
+  }
+  return d;
+}
+
+function maxChannel(a: Uint8ClampedArray, i: number, c: readonly number[]): number {
+  return Math.max(Math.abs(a[i] - c[0]), Math.abs(a[i + 1] - c[1]), Math.abs(a[i + 2] - c[2]));
+}
+
+/** Lower median of a list of integers (sorted copy; deterministic). */
+function median(v: number[]): number {
+  const s = v.slice().sort((a, b) => a - b);
+  return s[(s.length - 1) >> 1];
+}
+
+interface Decision {
+  p: number;
+  front: number;
+  behind: number;
+  /** FRONT's coverage read off the painting (0..255, before the ring rule), and FRONT's own alpha there before the step. */
+  matte: number;
+  own: number;
+  /** Which side of See-through's half-coverage line p is on (FRONT-owned or not), and its distance to the other owner. */
+  inside: boolean;
+  ring: number;
+  cb: [number, number, number];
+}
+
+/** See the invariant above {@link EDGE_RADIUS}. Modifies `parts` (full rig canvases, draw order) in place. */
+export function paintingEdges(parts: Raster[], srcr: Raster, options: PaintingEdgeOptions): PaintingEdgeResult {
+  const W = srcr.width;
+  const H = srcr.height;
+  const n = parts.length;
+  // Every part is read as the whole rig canvas; a cropped image would be read at the wrong place.
+  parts.forEach((r, i) => {
+    if (r.width !== W || r.height !== H) throw new RasterError(`paintingEdges: part ${i} is ${r.width}x${r.height}; the rig canvas ${W}x${H} is required (place a cropped part on it first)`);
+  });
+  const R = EDGE_RADIUS;
+  const cap = 2 * R + 2;
+  const owner = new Int16Array(W * H).fill(-1);
+  for (let p = 0; p < W * H; p++) {
+    for (let i = n - 1; i >= 0; i--) {
+      if (parts[i].data[p * 4 + 3] > EDGE_OWNER_ALPHA) {
+        owner[p] = i;
+        break;
+      }
+    }
+  }
+  // A painted pixel no part covers goes to the nearest part (ties to the one drawn in front); farther than the cap, it stays background.
+  {
+    const near: Uint8Array[] = [];
+    for (let k = 0; k < n; k++) {
+      const set = new Uint8Array(W * H);
+      for (let p = 0; p < W * H; p++) if (owner[p] === k) set[p] = 1;
+      near.push(chebyshev(set, W, H, cap));
+    }
+    const fill: Array<[number, number]> = [];
+    for (let p = 0; p < W * H; p++) {
+      if (owner[p] !== -1 || options.painted[p] !== 1) continue;
+      let best = -1;
+      let bd = cap;
+      for (let k = n - 1; k >= 0; k--) if (near[k][p] < bd) { best = k; bd = near[k][p]; }
+      if (best >= 0) fill.push([p, best]);
+    }
+    for (const [p, k] of fill) owner[p] = k;
+  }
+  // Distance to each owner, the background at index n.
+  const dist: Uint8Array[] = [];
+  for (let k = 0; k <= n; k++) {
+    const set = new Uint8Array(W * H);
+    const label = k === n ? -1 : k;
+    let any = false;
+    for (let p = 0; p < W * H; p++) {
+      if (owner[p] === label) {
+        set[p] = 1;
+        any = true;
+      }
+    }
+    dist.push(any ? chebyshev(set, W, H, cap) : new Uint8Array(W * H).fill(cap));
+  }
+  const distOf = (label: number): Uint8Array => dist[label < 0 ? n : label];
+  const skipped: PaintingEdgeSkips = { cover: 0, contrast: 0, locked: 0, noBehind: 0, pieces: 0 };
+  const decisions: Decision[] = [];
+  let resolved = 0;
+  let unseparated = 0;
+  for (let y = 0; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      const p = y * W + x;
+      const a = owner[p];
+      // The nearest other owner within R; ties to the one drawn in front (the background is behind every part).
+      let b = -2;
+      let bd = R + 1;
+      for (let k = n; k >= 0; k--) {
+        const label = k === n ? -1 : k;
+        if (label === a) continue;
+        const d = dist[k][p];
+        if (d < bd || (d === bd && b !== -2 && label > b)) {
+          if (d <= R) {
+            b = label;
+            bd = d;
+          }
+        }
+      }
+      if (b === -2) continue;
+      const front = Math.max(a, b);
+      const behind = Math.min(a, b);
+      // Coverage the two-layer model cannot carry: anything in front of FRONT, or between BEHIND and FRONT.
+      let covered = false;
+      for (let j = behind + 1; j < n && !covered; j++) if (j !== front && parts[j].data[p * 4 + 3] > OPAQUE_ALPHA_ABOVE) covered = true;
+      if (covered) {
+        skipped.cover++;
+        continue;
+      }
+      if (
+        !options.editable[front] ||
+        (behind >= 0 && !options.editable[behind]) ||
+        options.keep?.[front]?.data[p] === 1 ||
+        (behind >= 0 && options.keep?.[behind]?.data[p] === 1) ||
+        options.feathered?.[front]?.data[p] === 1 ||
+        (behind >= 0 && options.feathered?.[behind]?.data[p] === 1) ||
+        (behind >= 0 && options.movingPair?.(front, behind) === true)
+      ) {
+        skipped.locked++;
+        continue;
+      }
+      const df = distOf(front);
+      const db = distOf(behind);
+      // BEHIND's and FRONT's window pixels farthest from the other: the two sides least likely to be the edge itself.
+      let farB = -1;
+      let farF = -1;
+      const sideB: number[] = [];
+      const sideF: number[] = [];
+      for (let qy = Math.max(0, y - R); qy <= Math.min(H - 1, y + R); qy++) {
+        for (let qx = Math.max(0, x - R); qx <= Math.min(W - 1, x + R); qx++) {
+          const q = qy * W + qx;
+          if (owner[q] === behind) {
+            if (df[q] > farB) {
+              farB = df[q];
+              sideB.length = 0;
+            }
+            if (df[q] === farB) sideB.push(q);
+          } else if (owner[q] === front) {
+            if (db[q] > farF) {
+              farF = db[q];
+              sideF.length = 0;
+            }
+            if (db[q] === farF) sideF.push(q);
+          }
+        }
+      }
+      if (sideB.length === 0) {
+        skipped.noBehind++;
+        continue;
+      }
+      const channel = (c: number): number[] => sideB.map((q) => srcr.data[q * 4 + c]);
+      const cb = [median(channel(0)), median(channel(1)), median(channel(2))];
+      // The front reference: the window's FRONT-owned pixel farthest from Cb (max channel), first in scan order on a tie.
+      let contrast = 0;
+      let ref = -1;
+      for (let qy = Math.max(0, y - R); qy <= Math.min(H - 1, y + R); qy++) {
+        for (let qx = Math.max(0, x - R); qx <= Math.min(W - 1, x + R); qx++) {
+          const q = qy * W + qx;
+          if (owner[q] !== front) continue;
+          const c = maxChannel(srcr.data, q * 4, cb);
+          if (c > contrast) {
+            contrast = c;
+            ref = q;
+          }
+        }
+      }
+      // Every pixel's position along Cb -> Cf, as an integer dot product.
+      const axis = ref < 0 ? [0, 0, 0] : [0, 1, 2].map((c) => srcr.data[ref * 4 + c] - cb[c]);
+      const along = (q: number): number => (srcr.data[q * 4] - cb[0]) * axis[0] + (srcr.data[q * 4 + 1] - cb[1]) * axis[1] + (srcr.data[q * 4 + 2] - cb[2]) * axis[2];
+      if (ref < 0 || contrast < EDGE_CONTRAST) {
+        skipped.contrast++;
+        continue;
+      }
+      // The trimap: BEHIND's far side reads 0 up to its highest position, FRONT's far side 1 from its lowest.
+      // Where the two far sides do not separate along the axis (a side is all edge, or the texture overlaps), Cb and Cf themselves.
+      const sideLo = Math.max(...sideB.map(along));
+      const sideHi = sideF.length === 0 ? -Infinity : Math.min(...sideF.map(along));
+      const separate = sideHi > sideLo;
+      if (!separate) unseparated++;
+      const lo = separate ? sideLo : 0;
+      const hi = separate ? sideHi : along(ref);
+      resolved++;
+      let matte = Math.round((255 * Math.min(hi - lo, Math.max(0, along(p) - lo))) / (hi - lo));
+      // On FRONT's side of the line, a colour FRONT itself holds deeper in (within half the contrast floor, and nearer FRONT than
+      // BEHIND) is FRONT's interior — a light lining, a highlight — not a mix with BEHIND, however it falls along the axis.
+      if (a === front && matte < 255) {
+        let dF = Infinity;
+        let dFdeep = Infinity;
+        for (let qy = Math.max(0, y - R); qy <= Math.min(H - 1, y + R); qy++) {
+          for (let qx = Math.max(0, x - R); qx <= Math.min(W - 1, x + R); qx++) {
+            const q = qy * W + qx;
+            if (q === p || owner[q] !== front) continue;
+            const d = Math.max(Math.abs(srcr.data[q * 4] - srcr.data[p * 4]), Math.abs(srcr.data[q * 4 + 1] - srcr.data[p * 4 + 1]), Math.abs(srcr.data[q * 4 + 2] - srcr.data[p * 4 + 2]));
+            dF = Math.min(dF, d);
+            if (db[q] >= 2) dFdeep = Math.min(dFdeep, d);
+          }
+        }
+        const dOwn = dFdeep === Infinity ? dF : dFdeep;
+        let dB = Infinity;
+        for (const q of sideB) dB = Math.min(dB, Math.max(Math.abs(srcr.data[q * 4] - srcr.data[p * 4]), Math.abs(srcr.data[q * 4 + 1] - srcr.data[p * 4 + 1]), Math.abs(srcr.data[q * 4 + 2] - srcr.data[p * 4 + 2])));
+        if (2 * dOwn <= EDGE_CONTRAST && dOwn < dB) matte = 255;
+      }
+      const own = parts[front].data[p * 4 + 3];
+      decisions.push({ p, front, behind, matte, own, inside: a === front, ring: bd, cb: [cb[0], cb[1], cb[2]] });
+    }
+  }
+  // The ring rule (see the invariant above), resolved ring by ring, the outer ring before the inner one.
+  const at = new Int32Array(W * H).fill(-1);
+  decisions.forEach((q, k) => { at[q.p] = k; });
+  const alphaOf = new Int16Array(decisions.length);
+  const stage = (q: Decision): number => (q.inside ? 2 * q.ring : 2 * q.ring - 1);
+  const order = decisions.map((_, k) => k).sort((u, v) => stage(decisions[u]) - stage(decisions[v]) || u - v);
+  /** The greatest coverage already resolved for the same FRONT among p's 8 neighbours on the given side and ring. */
+  const neighbours = (q: Decision, inside: boolean, ring: number): number => {
+    let best = 0;
+    const x = q.p % W;
+    const y = (q.p - x) / W;
+    for (let dy = -1; dy <= 1; dy++) {
+      for (let dx = -1; dx <= 1; dx++) {
+        const nx = x + dx;
+        const ny = y + dy;
+        if ((dx === 0 && dy === 0) || nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
+        const j = at[ny * W + nx];
+        if (j >= 0 && decisions[j].front === q.front && decisions[j].inside === inside && decisions[j].ring === ring) best = Math.max(best, alphaOf[j]);
+      }
+    }
+    return best;
+  };
+  for (const k of order) {
+    const q = decisions[k];
+    let alpha = q.matte;
+    if (q.inside && q.ring > 1) alpha = Math.max(q.own, q.matte);
+    else if (q.inside) alpha = Math.max(alpha, neighbours(q, false, 1));
+    else if (q.ring > 1) alpha = Math.min(alpha, neighbours(q, false, q.ring - 1));
+    if (alpha <= OPAQUE_ALPHA_ABOVE) alpha = 0;
+    else if (alpha >= 255 - OPAQUE_ALPHA_ABOVE) alpha = 255;
+    alphaOf[k] = alpha;
+  }
+  // Every write is planned first, per part, so a part's pieces can be held before anything lands.
+  const planned: Array<Map<number, readonly [number, number, number, number]>> = parts.map(() => new Map());
+  const plan = (i: number, p: number, r: number, g: number, bl: number, al: number): void => {
+    const d = parts[i].data;
+    const s = p * 4;
+    if (d[s] === r && d[s + 1] === g && d[s + 2] === bl && d[s + 3] === al) return;
+    planned[i].set(p, [r, g, bl, al]);
+  };
+  /** Per part, the pixels it fills as BEHIND, with the FRONT part over them. */
+  const fills: Array<Map<number, number>> = parts.map(() => new Map());
+  decisions.forEach((q, k) => {
+    const s = q.p * 4;
+    const P = [srcr.data[s], srcr.data[s + 1], srcr.data[s + 2]];
+    const unmixAt = (c: number, a: number): number => Math.min(255, Math.max(0, Math.round(q.cb[c] + ((P[c] - q.cb[c]) * 255) / a)));
+    // FRONT's colour is clamped to 0..255, so a pixel the two colours cannot mix at that coverage (a painted line darker or
+    // lighter than both) would miss the painting: FRONT's coverage rises to the least that brings the composite within half
+    // the contrast floor of it (at full coverage it is the painting).
+    const miss = (a: number): number => Math.max(...[0, 1, 2].map((c) => Math.abs(Math.round((unmixAt(c, a) * a + q.cb[c] * (255 - a)) / 255) - P[c])));
+    let alpha = alphaOf[k];
+    if (alpha > 0 && alpha < 255) while (alpha < 255 && 2 * miss(alpha) > EDGE_CONTRAST) alpha++;
+    if (alpha >= 255 - OPAQUE_ALPHA_ABOVE) alpha = 255;
+    const unmix = (c: number): number => unmixAt(c, alpha);
+    if (alpha === 0) plan(q.front, q.p, 0, 0, 0, 0);
+    else if (alpha === 255) plan(q.front, q.p, P[0], P[1], P[2], 255);
+    else plan(q.front, q.p, unmix(0), unmix(1), unmix(2), alpha);
+    if (q.behind >= 0 && alpha < 255) {
+      if (alpha === 0) plan(q.behind, q.p, P[0], P[1], P[2], 255);
+      else plan(q.behind, q.p, q.cb[0], q.cb[1], q.cb[2], 255);
+      fills[q.behind].set(q.p, q.front);
+    }
+  });
+  // A part's art (alpha above the floor) keeps its pieces: rigc takes one closed outline per mesh, read 4-connected
+  // (`CONTOUR_ONE_ISLAND`). A new piece holding none of the part's art is not written.
+  planned.forEach((writes, i) => {
+    if (writes.size === 0) return;
+    const before = newMask(W, H);
+    for (let p = 0; p < W * H; p++) before.data[p] = parts[i].data[p * 4 + 3] > OPAQUE_ALPHA_ABOVE ? 1 : 0;
+    const after = (): Mask => {
+      const m = newMask(W, H);
+      m.data.set(before.data);
+      for (const [p, v] of writes) m.data[p] = v[3] > OPAQUE_ALPHA_ABOVE ? 1 : 0;
+      return m;
+    };
+    const was = connectedComponents(before, 4);
+    let now = connectedComponents(after(), 4);
+    const pieces = new Map<number, Set<number>>();
+    for (let p = 0; p < W * H; p++) {
+      const o = was.labels[p];
+      const l = now.labels[p];
+      if (o === 0 || l === 0) continue;
+      const set = pieces.get(o) ?? new Set<number>();
+      set.add(l);
+      pieces.set(o, set);
+    }
+    // A piece of art the step would split: each cut-off part of it is joined back to its largest part along the path that
+    // restores the fewest lowered pixels (a 0-1 search inside the piece as it was), and only those are not written.
+    for (const [o, set] of pieces) {
+      if (set.size < 2) continue;
+      const labels = [...set].sort((u, v) => now.stats[v].area - now.stats[u].area || u - v);
+      const main = labels[0];
+      const cost = new Int32Array(W * H).fill(-1);
+      const from = new Int32Array(W * H).fill(-1);
+      const deque = new Int32Array(2 * W * H + 2);
+      let head = W * H + 1;
+      let tail = head;
+      const nowOver = after();
+      for (let p = 0; p < W * H; p++) {
+        if (now.labels[p] === main && was.labels[p] === o) {
+          cost[p] = 0;
+          deque[tail++] = p;
+        }
+      }
+      while (head < tail) {
+        const p = deque[head++];
+        const x = p % W;
+        for (const q of [x > 0 ? p - 1 : -1, x < W - 1 ? p + 1 : -1, p - W, p + W]) {
+          if (q < 0 || q >= W * H || was.labels[q] !== o) continue;
+          const step = nowOver.data[q] === 1 ? 0 : 1;
+          if (cost[q] !== -1 && cost[q] <= cost[p] + step) continue;
+          cost[q] = cost[p] + step;
+          from[q] = p;
+          if (step === 0) deque[--head] = q;
+          else deque[tail++] = q;
+        }
+      }
+      for (const l of labels.slice(1)) {
+        let best = -1;
+        for (let p = 0; p < W * H; p++) if (now.labels[p] === l && cost[p] >= 0 && (best < 0 || cost[p] < cost[best])) best = p;
+        for (let p = best; p >= 0 && cost[p] > 0; p = from[p]) {
+          if (nowOver.data[p] === 0 && writes.delete(p)) skipped.pieces++;
+        }
+      }
+    }
+    now = connectedComponents(after(), 4);
+    const holdsArt = new Uint8Array(now.count);
+    for (let p = 0; p < W * H; p++) if (before.data[p] === 1) holdsArt[now.labels[p]] = 1;
+    for (const [p] of [...writes]) {
+      const l = now.labels[p];
+      if (l !== 0 && holdsArt[l] === 0) {
+        writes.delete(p);
+        skipped.pieces++;
+        // A fill BEHIND cannot take: FRONT takes the painting's pixel whole, so the composite there is still the painting
+        // (FRONT is later in draw order, so its own pieces are held after this).
+        const front = fills[i].get(p);
+        if (front !== undefined) planned[front].set(p, [srcr.data[p * 4], srcr.data[p * 4 + 1], srcr.data[p * 4 + 2], 255]);
+      }
+    }
+  });
+  const changed = parts.map(() => newMask(W, H));
+  planned.forEach((writes, i) => {
+    const d = parts[i].data;
+    for (const [p, v] of writes) {
+      d.set(v, p * 4);
+      changed[i].data[p] = 1;
+      options.written?.(i, p);
+    }
+  });
+  return { changed, resolved, unseparated, skipped };
+}

package/src/projectrule.ts

@@ -0,0 +1,22 @@
+/** Shared projection choices for the config reader and assembly. */
+
+/**
+ * Where a layer may take the painting's pixel (`projectSource` in
+ * `src/assemble.ts`). `core` is the reference's rule: the layer's top-most
+ * `alpha >= 250` pixels eroded by a 5x5 square, so a part a few pixels wide has
+ * no core and none of its visible pixels is projected. `visible` keeps the
+ * erosion only where it guards something — along a rim where a later layer of
+ * the run is in front — and projects every other top-most `alpha >= 250` pixel
+ * of the layer; the parts' visible edges are then resolved from the painting
+ * (`paintingEdges`).
+ */
+export type ProjectRule = 'core' | 'visible';
+export const PROJECT_RULES: readonly ProjectRule[] = ['core', 'visible'];
+
+/**
+ * The projection rule a run uses when none is named: the reference's, so the
+ * examples stay comparable with it. `visible` was measured on the public
+ * examples against it (the changes that added the flag and `paintingEdges`);
+ * it is opt-in.
+ */
+export const DEFAULT_PROJECT_RULE: ProjectRule = 'core';

package/src/provenance.ts

@@ -8,7 +8,7 @@ import { crop, type Raster } from './raster/index.ts';
 export const AUTOMATIC_WRITERS = {
   sourceProjection: -1, extend: -2, growRim: -3, limbSplit: -4,
   limbCap: -5, limbHybrid: -6, limbFeather: -7, fringeRestore: -8,
-  seamOverride: -9, armSplit: -10, headFaceUnderfill: -11, ghostCleanup: -12, unattributed: -13, paintingExtension: -14,
+  seamOverride: -9, armSplit: -10, headFaceUnderfill: -11, ghostCleanup: -12, unattributed: -13, paintingExtension: -14, paintingEdge: -15,
 } as const;
 export type AutomaticWriter = keyof typeof AUTOMATIC_WRITERS;
 export interface PixelProvenance {