rig-parts 1.83.0 → 1.83.1

package/docs/AUTHORING.md

@@ -668,8 +668,19 @@ Taken layers replace the target's tag, keeping the donor's tag and
 `depth_median`, so existing hair/blink classification continues to read `from`.
 Larger depth draws behind smaller depth. Numeric ties keep manifest order only
 inside one original run. Equal or null depths **across** runs are ambiguous
-and refused, even if the plan gives an order. A supplied plan reversing the
-mixed-run depth order is also refused; `--propose-plan` drafts the depth order.
+and refused, even if the plan gives an order. Plan-order checks compare only
+different original runs' layers whose original supports intersect (both alpha
+> 8, in the target-run canvas, without dilation). Disjoint supports have no
+visible order; intersecting bounding boxes alone do not establish overlap.
+Within one role band, larger depth must draw behind smaller depth. In a two-run
+plan, full-run rows follow the proposer's head-fallback roles before scalar
+depth: back hair, body, headwear/earwear, face, head details, front hair. Thus
+fallback headwear is after the body and before the face, and fallback front
+hair stays over the face even when its donor depth is larger. Roles come from
+source tags, never part names. Head-run rows and single-run plans keep scalar
+depth order. A supplied plan reversing an overlapping mixed-run pair under
+these rules is refused; `--propose-plan` drafts the same order. Null/tied depth
+ambiguity remains a refusal even for disjoint supports.
 Replacing a layer with hidden companion art is refused because independent
 hidden-art identity has not been declared. Active scalar depth sheets (`depth`
 opt-in or already bound sheets) are also refused: selecting donor art does not
@@ -4451,7 +4462,7 @@ those settings. Changing a config seed alone cannot change a no-config run.
 | <a id="ASSEMBLE_TAKE_TAG_IN_RUN"></a>`ASSEMBLE_TAKE_TAG_IN_RUN` | selected donor does not hold the tag | choose a tag present in that donor |
 | <a id="ASSEMBLE_TAKE_SUPPORT"></a>`ASSEMBLE_TAKE_SUPPORT` | selected layer has zero alpha > 8 pixels | choose a nonempty donor layer |
 | <a id="ASSEMBLE_TAKE_DEPTH_AMBIGUOUS"></a>`ASSEMBLE_TAKE_DEPTH_AMBIGUOUS` | different original runs have equal or null depths | use a run with distinct numeric depths; do not invent an inter-run tie order |
-| <a id="ASSEMBLE_TAKE_PLAN_ORDER"></a>`ASSEMBLE_TAKE_PLAN_ORDER` | supplied plan reverses mixed-run depth order | use the depth order drafted by `assemble --propose-plan` |
+| <a id="ASSEMBLE_TAKE_PLAN_ORDER"></a>`ASSEMBLE_TAKE_PLAN_ORDER` | supplied plan reverses an overlapping mixed-run pair: two-run full-layer head roles first, scalar depth within a role band (head-run and single-run rows use scalar depth); names the parts and support intersection | use the order drafted by `assemble --propose-plan`; fallback headwear follows the body and precedes the face, front hair follows the face; disjoint supports impose no plan-order constraint |
 | <a id="ASSEMBLE_TAKE_GEOMETRY"></a>`ASSEMBLE_TAKE_GEOMETRY` | missing target head, unequal run canvases or unequal original input dimensions | supply matching geometry; the check does not resize inputs |
 | <a id="ASSEMBLE_TAKE_META"></a>`ASSEMBLE_TAKE_META` | donor `meta.json` lacks a readable prompt ID or seed | retain the original run metadata |
 | <a id="ASSEMBLE_TAKE_INPUT"></a>`ASSEMBLE_TAKE_INPUT` | declared donor input PNG cannot be read | name its original PNG relative to the config |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "1.83.0",
+  "version": "1.83.1",
   "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": {

package/src/assemble.ts

@@ -6048,6 +6048,18 @@ export const PROPOSE_HEAD_TAGS: readonly string[] = [
   'eyebrow-l',
 ];
 
+/** #869: two-run full rows are body rows or head fallbacks, regardless of part spelling.
+ * Within one band the run's depth order survives; the bands encode the proposer's roles.
+ */
+export function fullPlanBand(tag: string): number {
+  if (tag === 'back hair') return 0;
+  if (!PROPOSE_HEAD_TAGS.includes(tag)) return 1;
+  if (tag === 'headwear' || tag === 'earwear') return 2;
+  if (tag === 'face') return 3;
+  if (tag === 'front hair') return 5;
+  return 4;
+}
+
 /** #863: prefer suitable head layers; only unusable head candidates may fall back for these tags. */
 const HEAD_FALLBACK_TAGS: readonly string[] = ['back hair', 'face', 'front hair'];
 
@@ -6106,7 +6118,7 @@ function fmt0(v: number): string {
  * A suitable head candidate is retained. Every fallback names the two rig
  * areas and the reason. A `headwear`/`earwear` the head run drops or
  * shrinks (its rig-pixel area below 0.8 of the full run's) is taken from the
- * full run instead, drawn right after `back hair` — noted. `front hair` and
+ * full run instead, drawn after the body and before the face — noted. `front hair` and
  * `back hair` taken from the head run are extended below the crop from the
  * full run when the full run's layer reaches more than 8 rig pixels below the
  * crop line. A lone `handwear` layer is named `sleeves`.
@@ -6232,7 +6244,7 @@ export function proposePlan(full0: LayerSet, head0: LayerSet, g: Geometry, minPx
     return tag !== 'nose' && !(run === 'head' && tag === 'face' && headFaceRefusal !== null) &&
       l !== undefined && l.opaqueRunPx >= floor && !implausible(run, tag, 'not proposed');
   };
-  const body = runs.full.filter((l) => !PROPOSE_HEAD_TAGS.includes(l.tag) && ok('full', l.tag)).map((l) => l.tag);
+  const body = runs.full.filter((l) => fullPlanBand(l.tag) === 1 && ok('full', l.tag)).map((l) => l.tag);
   // Issue #256: an author-made layer is proposed from the run that holds it, at its place in that run's draw order,
   // like any layer; one both runs hold is proposed once, from the full run when the full run's is proposed, and the note says so.
   const authorBoth = runs.head.filter((l) => readAuthorTag(l.tag) !== null && body.includes(l.tag)).map((l) => l.tag);
@@ -6279,15 +6291,15 @@ export function proposePlan(full0: LayerSet, head0: LayerSet, g: Geometry, minPx
     const draw = t === 'back hair' ? 'behind the body and face' : t === 'face' ? 'before head details and front hair' : 'in front of the face';
     notes.push(`${t}: head run ${fmt0(hp)} rig px (${reason}); full run ${fmt0(fp)} rig px -> full-run layer, drawn ${draw}`);
   }
-  for (const t of ['headwear', 'earwear']) {
+  // Keep the full run's order inside the accessory band, including mixed donors.
+  for (const { tag: t } of runs.full.filter(l => fullPlanBand(l.tag) === 2)) {
     const hl = find('head', t);
     const fl = find('full', t);
     const hp = hl !== undefined ? hl.opaqueRunPx * headArea : 0;
     const fp = fl !== undefined ? fl.opaqueRunPx * fullArea : 0;
     if (ok('full', t) && hp < 0.8 * fp) {
       drop(t);
-      const at = plan.length > 0 && plan[0][2] === 'back hair' ? 1 : 0;
-      plan.splice(at, 0, [PROPOSE_ALIAS[t], 'full', t]);
+      plan.push([PROPOSE_ALIAS[t], 'full', t]);
       notes.push(`${t}: head run ${fmt0(hp)} rig px < 0.8 x full run ${fmt0(fp)} -> full-run layer, drawn behind the face`);
     }
   }

package/src/takelayers.ts

@@ -2,7 +2,7 @@
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import type { EarlyConfig, PlanEntry, Run } from './config.ts';
-import { CORE_KERNEL } from './assemble.ts';
+import { CORE_KERNEL, fullPlanBand } from './assemble.ts';
 import { makeInputs } from './inputs.ts';
 import { OPAQUE_ALPHA_ABOVE, readLayers, type Layer, type LayerSet } from './layers.ts';
 import { PartsError, refuseIfAny, type Problem } from './errors.ts';
@@ -51,6 +51,16 @@ function identity(layer: Layer, canvas: LayerSet['canvas'], donor: Raster, targe
 export function takeLayerNote(source: TakenLayerSource): string {
   return `take ${source.run}:${source.tag} from ${source.run_dir}; prompt_id ${source.prompt_id}; seed ${source.seed}; st_input ${source.st_input}; support ${source.support_px} run px; checked ${source.checked_px} input px; differing ${source.differing_px}; alpha > ${OPAQUE_ALPHA_ABOVE}, ${CORE_KERNEL}x${CORE_KERNEL} margin`;
 }
+/** Intersection of original alpha supports in the common target-run canvas; no bbox or dilation proxy. */
+function supportOverlap(a: Layer, b: Layer): number {
+  let px = 0;
+  for (let y = Math.max(a.top, b.top); y < Math.min(a.bottom, b.bottom); y++)
+    for (let x = Math.max(a.left, b.left); x < Math.min(a.right, b.right); x++) {
+      if (a.pixels.data[((y - a.top) * a.pixels.width + x - a.left) * 4 + 3] > OPAQUE_ALPHA_ABOVE &&
+          b.pixels.data[((y - b.top) * b.pixels.width + x - b.left) * 4 + 3] > OPAQUE_ALPHA_ABOVE) px++;
+    }
+  return px;
+}
 /** Apply every declaration together, so replacing all tied layers from one run can retain its known order. */
 export function applyTakenLayers(runs: { full: LayerSet; head: LayerSet; single: boolean }, painting: Raster, cfg: Pick<EarlyConfig, 'seethrough' | 'depth'> & { assemble: { take?: TakeLayers[]; plan?: PlanEntry[] } }, configPath: string): { full: LayerSet; head: LayerSet; single: boolean; notes: string[] } {
   const declarations = cfg.assemble.take ?? [];
@@ -99,7 +109,14 @@ export function applyTakenLayers(runs: { full: LayerSet; head: LayerSet; single:
     const selected = (cfg.assemble.plan ?? []).filter(p => p[1] === run).map(p => ({ part: p[0], layer: list.find(l => l.name === p[2]) }));
     for (let i = 0; i < selected.length; i++) for (let j = i + 1; j < selected.length; j++) {
       const a = selected[i], b = selected[j];
-      if (a.layer !== undefined && b.layer !== undefined && origin(a.layer) !== origin(b.layer) && list.indexOf(a.layer) > list.indexOf(b.layer)) problems.push({ code: 'ASSEMBLE_TAKE_PLAN_ORDER', object: `${run} plan parts "${a.part}" / "${b.part}"`, detail: `plan order reverses mixed-run depths ${a.layer.depth} / ${b.layer.depth}; put the larger depth behind, as in assemble --propose-plan` });
+      if (a.layer === undefined || b.layer === undefined || origin(a.layer) === origin(b.layer)) continue;
+      const overlap = supportOverlap(a.layer, b.layer);
+      if (overlap === 0) continue;
+      // Only full rows in a two-run plan have the proposer's fallback roles.
+      // Head rows and one-run plans retain the scalar order, as do peers in a band.
+      const band = !runs.single && run === 'full' ? fullPlanBand(a.layer.name) - fullPlanBand(b.layer.name) : 0;
+      const reversed = band === 0 ? list.indexOf(a.layer) > list.indexOf(b.layer) : band > 0;
+      if (reversed) problems.push({ code: 'ASSEMBLE_TAKE_PLAN_ORDER', object: `${run} plan parts "${a.part}" / "${b.part}"`, detail: `plan order reverses ${band === 0 ? `mixed-run depths ${a.layer.depth} / ${b.layer.depth}; put the larger depth behind` : `two-run full-layer roles "${a.layer.name}" / "${b.layer.name}"; order back hair, body, headwear/earwear, face, head details, front hair`}; supports overlap at ${overlap} run px (alpha > ${OPAQUE_ALPHA_ABOVE}); use assemble --propose-plan` });
     }
     refuseIfAny(problems);
     const replaced = new Set(declarations.filter(d => d.run === run).flatMap(d => d.tags));