@hatiolab/figure-model 0.2.15 → 0.3.0

package/dist/authoring-actions.js

@@ -47,6 +47,101 @@ export const FIGURE_FACES = { left: 'x', right: 'x', bottom: 'y', top: 'y', back
 export const FIGURE_JOINT_TYPES = ['fixed', 'revolute', 'prismatic'];
 const SIGN = { left: -1, right: 1, bottom: -1, top: 1, back: -1, front: 1 };
 const OPPOSITE = { left: 'right', right: 'left', bottom: 'top', top: 'bottom', back: 'front', front: 'back' };
+/** The joints a follower follows, each with its multiplier: one for a one-leader mimic, none for a joint that leads itself. */
+export function figureMimicLeadersOf(j) {
+    const mimic = j.mimic;
+    if (!mimic || typeof mimic !== 'object')
+        return [];
+    if (Object.hasOwn(mimic, 'sum'))
+        return Array.isArray(mimic.sum) ? mimic.sum : [];
+    return [{ joint: mimic.joint, multiplier: mimic.multiplier }];
+}
+/** Whether a length is written as something to follow: one source, or a sum of one term or more, each with a source. */
+const followsSomething = (measure) => {
+    const terms = followedTermsOf(measure)?.terms;
+    return Array.isArray(terms) && terms.length > 0 && terms.every(t => !!t?.from);
+};
+/** A length that follows something, as its terms and its margin; undefined for a number (or nothing). */
+function followedTermsOf(measure) {
+    if (!measure || typeof measure !== 'object')
+        return undefined;
+    if (Object.hasOwn(measure, 'sum')) {
+        const m = measure;
+        return { terms: m.sum, plus: m.plus ?? 0, sum: true };
+    }
+    const m = measure;
+    return { terms: [{ from: m.from, ...(m.times !== undefined ? { times: m.times } : {}) }], plus: m.plus ?? 0, sum: false };
+}
+const everyKey = () => (...keys) => keys;
+const JOINT_FIELDS = {
+    joint: everyKey()('id', 'type', 'body0', 'body1', 'origin', 'axis', 'lowerLimit', 'upperLimit', 'travel', 'state', 'mimic', 'repeat'),
+    body0: everyKey()('part', 'face', 'plane'),
+    body1: everyKey()('part', 'face'),
+    origin: everyKey()('facing', 'gap', 'align', 'turn', 'twist'),
+    axes: everyKey()('x', 'y', 'z'),
+    alignment: everyKey()('mm'),
+    measure: everyKey()('from', 'times', 'plus', 'sum'),
+    term: everyKey()('from', 'times'),
+    source: everyKey()('of', 'axis', 'input', 'part'),
+    travel: everyKey()('source', 'times', 'plus', 'sum'),
+    state: everyKey()('id', 'label', 'start', 'sweep'),
+    mimic: everyKey()('joint', 'multiplier', 'offset', 'sum'),
+    leader: everyKey()('joint', 'multiplier'),
+    repeat: everyKey()('axis', 'pitch', 'count', 'rise'),
+    rise: everyKey()('axis', 'mm')
+};
+/** Refuses, by name, a key of a joint record or of an object in it that this kernel does not know. A key left undefined is no field. */
+function knownJointFields(j, path) {
+    const only = (o, allowed, at) => {
+        if (!o || typeof o !== 'object' || Array.isArray(o))
+            return;
+        for (const [k, v] of Object.entries(o))
+            if (v !== undefined && !allowed.includes(k))
+                fail('JOINT_SCHEMA', at, `${k} is a field this kernel does not know`);
+    };
+    const source = (s, at) => only(s, JOINT_FIELDS.source, at);
+    const measure = (m, at) => {
+        if (!m || typeof m !== 'object')
+            return;
+        only(m, JOINT_FIELDS.measure, at);
+        source(m.from, `${at}.from`);
+        if (Array.isArray(m.sum))
+            for (const [i, t] of m.sum.entries()) {
+                only(t, JOINT_FIELDS.term, `${at}.sum.${i}`);
+                source(t?.from, `${at}.sum.${i}.from`);
+            }
+    };
+    only(j, JOINT_FIELDS.joint, path);
+    only(j.body0, JOINT_FIELDS.body0, `${path}.body0`);
+    only(j.body1, JOINT_FIELDS.body1, `${path}.body1`);
+    const o = j.origin;
+    only(o, JOINT_FIELDS.origin, `${path}.origin`);
+    if (o && typeof o === 'object') {
+        measure(o.gap, `${path}.origin.gap`);
+        only(o.turn, JOINT_FIELDS.axes, `${path}.origin.turn`);
+        only(o.align, JOINT_FIELDS.axes, `${path}.origin.align`);
+        for (const [axis, a] of Object.entries(o.align && typeof o.align === 'object' ? o.align : {})) {
+            only(a, JOINT_FIELDS.alignment, `${path}.origin.align.${axis}`);
+            measure(a?.mm, `${path}.origin.align.${axis}.mm`);
+        }
+    }
+    if (j.travel && typeof j.travel === 'object') {
+        only(j.travel, JOINT_FIELDS.travel, `${path}.travel`);
+        source(j.travel.source, `${path}.travel.source`);
+        if (Array.isArray(j.travel.sum))
+            measure({ sum: j.travel.sum }, `${path}.travel`);
+    }
+    only(j.state, JOINT_FIELDS.state, `${path}.state`);
+    only(j.mimic, JOINT_FIELDS.mimic, `${path}.mimic`);
+    if (Array.isArray(j.mimic?.sum))
+        for (const [i, t] of j.mimic.sum.entries())
+            only(t, JOINT_FIELDS.leader, `${path}.mimic.sum.${i}`);
+    only(j.repeat, JOINT_FIELDS.repeat, `${path}.repeat`);
+    if (j.repeat && typeof j.repeat === 'object') {
+        measure(j.repeat.pitch, `${path}.repeat.pitch`);
+        only(j.repeat.rise, JOINT_FIELDS.rise, `${path}.repeat.rise`);
+    }
+}
 const clone = (asset) => structuredClone(asset);
 const nodeById = (m, id) => m.nodes.find((n) => n.id === id);
 const writerOf = (m, ref) => m.nodes.find((n) => Object.values(n.outputs).includes(ref));
@@ -300,9 +395,29 @@ function measureRef(m, asset, name, measure, hint, path) {
             fail('SCHEMA', path, 'a finite length is required');
         return constantOf(m, 'mm', measure, 'd');
     }
-    if (!measure || typeof measure !== 'object' || !measure.from)
+    if (!measure || typeof measure !== 'object' || !(Object.hasOwn(measure, 'sum') || measure.from))
         fail('SCHEMA', path, 'a length is a number of millimetres, or something to follow');
-    return scaled(m, name, sourceRef(m, asset, measure.from, path), measure.times ?? 1, measure.plus ?? 0, hint);
+    const { terms, plus, sum } = followedTermsOf(measure);
+    const refs = termRefs(m, asset, terms, plus, path);
+    /* One term is written as it always was; a sum adds its terms, then the margin (the same add@1 and mul@1 nodes). */
+    if (!sum)
+        return scaled(m, name, refs[0].ref, refs[0].k, plus, hint);
+    return scaled(m, name, sumOf(m, name, refs, `${hint}.sum`), 1, plus, hint);
+}
+/** Each term of a followed length as a graph reference and its multiple, every one checked as a one-term length is. */
+function termRefs(m, asset, terms, plus, path) {
+    if (!Array.isArray(terms) || !terms.length)
+        fail('SCHEMA', path, 'a sum has one term or more');
+    if (!Number.isFinite(plus))
+        fail('SCHEMA', path, 'finite times and plus required');
+    return terms.map((t, i) => {
+        const at = terms.length > 1 ? `${path}.sum.${i}` : path;
+        if (!t || typeof t !== 'object' || !t.from)
+            fail('SCHEMA', at, 'a length is a number of millimetres, or something to follow');
+        if (!Number.isFinite(t.times ?? 1))
+            fail('SCHEMA', at, 'finite times and plus required');
+        return { ref: sourceRef(m, asset, t.from, at), k: t.times ?? 1 };
+    });
 }
 /** Σ k·ref, written as nodes, with nothing emitted for a weight of zero and no node for a single term. */
 function sumOf(m, name, terms, hint) {
@@ -407,19 +522,23 @@ function linkDimension(asset, a) {
     const mine = stableDimension(m, a.part, a.axis, path);
     if (followsAlready(m, a.part, a.axis) && !a.replace)
         fail('DIMENSION_LINKED', path, `${a.part}'s ${a.axis} already follows something; pass replace to change what it follows, or unlink it first`);
-    const times = a.times ?? 1;
+    const sum = Object.hasOwn(a, 'sum');
+    const terms = sum ? a.sum : [{ from: a.source, ...(a.times !== undefined ? { times: a.times } : {}) }];
     const plus = a.plus ?? 0;
-    if (!Number.isFinite(times) || !Number.isFinite(plus))
-        fail('SCHEMA', path, 'finite times and plus required');
-    if (a.source.of === 'part' && a.source.part === a.part && a.source.axis === a.axis)
-        fail('DIMENSION_CYCLE', path, `${a.part}'s ${a.axis} cannot follow itself`);
-    const from = sourceRef(m, asset, a.source, path);
-    if (from === mine)
-        fail('DIMENSION_CYCLE', path, `${a.part}'s ${a.axis} cannot follow itself`);
-    if (reaches(m, from, mine))
-        fail('DIMENSION_CYCLE', path, `${String(a.source.of === 'part' ? a.source.part : a.source.of)} already follows ${a.part}'s ${a.axis}`);
+    /* Each term is checked for a loop as a one-term link is: none may read the measure it would set. */
+    for (const t of Array.isArray(terms) ? terms : [])
+        if (t?.from?.of === 'part' && t.from.part === a.part && t.from.axis === a.axis)
+            fail('DIMENSION_CYCLE', path, `${a.part}'s ${a.axis} cannot follow itself`);
+    const refs = termRefs(m, asset, terms, plus, path);
+    for (const [i, { ref }] of refs.entries()) {
+        const source = terms[i].from;
+        if (ref === mine)
+            fail('DIMENSION_CYCLE', path, `${a.part}'s ${a.axis} cannot follow itself`);
+        if (reaches(m, ref, mine))
+            fail('DIMENSION_CYCLE', path, `${String(source.of === 'part' ? source.part : source.of)} already follows ${a.part}'s ${a.axis}`);
+    }
     const name = namer(m, `${a.part}.${a.axis}`);
-    const value = scaled(m, name, from, times, plus, 'follows');
+    const value = sum ? scaled(m, name, sumOf(m, name, refs, 'follows.sum'), 1, plus, 'follows') : scaled(m, name, refs[0].ref, refs[0].k, plus, 'follows');
     const node = nodeById(m, `${a.part}.dimension.${a.axis}`);
     const was = node.args[0];
     const owned = ownInput(m, a.part, was) ? was : `${a.part}.size.${a.axis}`;
@@ -1236,6 +1355,7 @@ function checkJoint(asset, j) {
     const path = `joints.${String(j?.id)}`;
     if (!j || typeof j.id !== 'string' || !j.id.trim())
         fail('JOINT_SCHEMA', 'joints', 'a joint has an id');
+    knownJointFields(j, path);
     if (!FIGURE_JOINT_TYPES.includes(j.type))
         fail('JOINT_SCHEMA', path, `${String(j.type)} is not a joint type; ${FIGURE_JOINT_TYPES.join(', ')}`);
     if (!j.body1 || typeof j.body1.part !== 'string')
@@ -1275,19 +1395,38 @@ function checkJoint(asset, j) {
         const [lo, hi] = [j.lowerLimit, j.upperLimit];
         if (!(Number.isFinite(lo) && Number.isFinite(hi) && lo < hi))
             fail('JOINT_SCHEMA', path, `a ${j.type} joint has both limits, lower below upper`);
-        if (!(lo <= 0 && 0 <= hi))
-            fail('JOINT_SCHEMA', path, 'the rest pose is the joint at 0, so its limits hold 0');
+        /*
+          The rest pose is every joint at 0 -- the kinematic reference its axis is read at (joint-list.ts) -- and 0 need not
+          be a value the joint may take: a joint limited to 10..80 still has its reference at 0 (ADR-0107 J4). Its starting
+          value, the stored state default, is held to its limits as every control's is (addMotion).
+        */
     }
     if (j.mimic) {
-        const leader = others.find(o => o.id === j.mimic.joint);
-        if (!leader || leader.type === 'fixed')
-            fail('JOINT_SCHEMA', path, `${String(j.mimic.joint)} is not a moving joint to follow`);
-        if (leader.mimic)
-            fail('JOINT_SCHEMA', path, `${leader.id} follows another joint; follow the one it follows`);
-        if ((leader.type === 'prismatic') !== (j.type === 'prismatic'))
-            fail('JOINT_SCHEMA', path, 'a joint follows one that moves the same way: a slide a slide, a turn a turn');
-        if (!Number.isFinite(j.mimic.multiplier))
-            fail('JOINT_SCHEMA', path, 'a mimic has a multiplier');
+        /*
+          One leader or a sum of them (ADR-0107 decision 2), each held to the same rules: a moving joint that leads itself
+          -- so a follower is never a leader and no loop can close -- that moves the way this one does (degrees are not
+          added to millimetres), named once, with a finite multiplier.
+        */
+        const sum = Object.hasOwn(j.mimic, 'sum');
+        if (sum && !(Array.isArray(j.mimic.sum) && j.mimic.sum.length))
+            fail('JOINT_SCHEMA', path, 'a mimic sum follows one joint or more');
+        const seen = new Set();
+        for (const t of figureMimicLeadersOf(j)) {
+            const leader = others.find(o => o.id === t?.joint);
+            if (!leader || leader.type === 'fixed')
+                fail('JOINT_SCHEMA', path, `${String(t?.joint)} is not a moving joint to follow`);
+            if (seen.has(leader.id))
+                fail('JOINT_SCHEMA', path, `${leader.id} is followed twice; a sum names each joint once`);
+            seen.add(leader.id);
+            if (leader.mimic)
+                fail('JOINT_SCHEMA', path, `${leader.id} follows another joint; follow the one it follows`);
+            if ((leader.type === 'prismatic') !== (j.type === 'prismatic'))
+                fail('JOINT_SCHEMA', path, `${leader.id} ${leader.type === 'prismatic' ? 'slides' : 'turns'}; a joint follows ones that move the same way: a slide a slide, a turn a turn`);
+            if (!Number.isFinite(t.multiplier))
+                fail('JOINT_SCHEMA', path, 'a mimic has a multiplier');
+        }
+        if (j.mimic.offset !== undefined && !Number.isFinite(j.mimic.offset))
+            fail('JOINT_SCHEMA', path, "a mimic's offset is a number in the joint's unit");
     }
     if (j.origin?.twist !== undefined && !Number.isFinite(j.origin.twist))
         fail('JOINT_SCHEMA', `${path}.origin.twist`, 'a twist is a number of degrees');
@@ -1324,7 +1463,7 @@ function checkJoint(asset, j) {
             fail('JOINT_SCHEMA', row, `a row runs along X, Y or Z, not ${String(r.axis)}`);
         if (r.axis.toLowerCase() === FIGURE_FACES[childFaceOf(asset.document.model, j)])
             fail('JOINT_SCHEMA', row, `a row runs across the face it is fastened to; ${r.axis} is out of that face`);
-        if (typeof r.pitch === 'number' ? !(Number.isFinite(r.pitch) && r.pitch > 0) : !(r.pitch && typeof r.pitch === 'object' && r.pitch.from))
+        if (typeof r.pitch === 'number' ? !(Number.isFinite(r.pitch) && r.pitch > 0) : !followsSomething(r.pitch))
             fail('GEOMETRY_DOMAIN', row, 'a row has a positive pitch, or one that follows a length');
         if (r.count !== undefined && !(Number.isSafeInteger(r.count) && r.count >= 1 && r.count <= REPEAT_LIMIT))
             fail('GEOMETRY_DOMAIN', row, `a row has 1 to ${REPEAT_LIMIT} copies`);
@@ -1407,7 +1546,7 @@ function writeJoint(asset, j) {
     const kind = j.type === 'prismatic' ? 'slide' : 'turn';
     const unit = j.type === 'prismatic' ? (j.travel ? 'ratio' : 'mm') : 'deg';
     const range = j.lowerLimit !== undefined && j.upperLimit !== undefined ? { min: j.lowerLimit, max: j.upperLimit } : j.type === 'revolute' ? { min: -180, max: 180 } : { min: 0, max: 1 };
-    const leader = j.mimic && (asset.joints ?? []).find(o => o.id === j.mimic.joint);
+    const leaders = figureMimicLeadersOf(j).map(t => ({ leader: (asset.joints ?? []).find(o => o.id === t.joint), k: t.multiplier }));
     /* The axis turned into the parent's frame too: one of its axes, either way along it. */
     const along = mv3(back, AXES.map(a => (a === j.axis.toLowerCase() ? 1 : 0)));
     const axisIndex = along.findIndex(v => Math.abs(Math.abs(v) - 1) < 1e-9);
@@ -1417,7 +1556,7 @@ function writeJoint(asset, j) {
         kind: 'add-motion',
         part: child,
         motion: { kind, axis: AXES[axisIndex] },
-        state: { id: stateIdOf(j), unit, min: range.min, max: range.max, start: j.state?.start ?? 0, ...(j.state?.label !== undefined ? { label: j.state.label } : {}), ...(j.state?.sweep !== undefined ? { sweep: j.state.sweep } : {}) },
+        state: { id: stateIdOf(j), unit, min: range.min, max: range.max, start: j.state?.start ?? Math.min(range.max, Math.max(range.min, 0)), ...(j.state?.label !== undefined ? { label: j.state.label } : {}), ...(j.state?.sweep !== undefined ? { sweep: j.state.sweep } : {}) },
         ...(j.travel ? { travel: j.travel } : {}),
         replace: true
     }, 
@@ -1426,7 +1565,13 @@ function writeJoint(asset, j) {
       stroke is a share of a length has a control of 0..1, and multiplying that gave a follower a number with no length
       (the telescopic conveyor, 2026-09-25). For a leader whose control is its distance the two are one value.
     */
-    leader ? { of: nodeById(m, `${leader.body1.part}.motion`)?.args[3] ?? stateIdOf(leader), k: j.mimic.multiplier, c: j.mimic.offset ?? 0 } : undefined, along[axisIndex] > 0 ? 1 : -1);
+    j.mimic
+        ? {
+            terms: leaders.map(({ leader, k }) => ({ of: nodeById(m, `${leader.body1.part}.motion`)?.args[3] ?? stateIdOf(leader), k })),
+            c: j.mimic.offset ?? 0,
+            sum: Object.hasOwn(j.mimic, 'sum')
+        }
+        : undefined, along[axisIndex] > 0 ? 1 : -1);
     if (j.repeat)
         repeatPart(asset, j);
 }
@@ -1711,7 +1856,45 @@ function stripJoint(asset, j) {
         dropIfUnused(asset, ref, ownInput(m, child, ref) ? ref : undefined);
     place.args = [place.args[0], pose.outputs.pose];
 }
-/** Joints in an order each can be written in: its parent's joint and the joint it mimics first. */
+/**
+ * Every length a joint record holds that may follow something, read as a measure, with a way to write it back: the
+ * gap, a row's pitch, a slide's travel (its one-term form names the source `source`, and without one is `plus` mm)
+ * and each offset across the face. Renaming a part and taking one away read and write them all alike.
+ */
+function jointMeasures(j) {
+    const out = [];
+    if (j.origin?.gap !== undefined)
+        out.push({ at: 'gap', get: () => j.origin.gap, set: v => (j.origin.gap = v) });
+    if (j.repeat)
+        out.push({ at: 'pitch', get: () => j.repeat.pitch, set: v => (j.repeat.pitch = v) });
+    if (j.travel) {
+        const t = j.travel;
+        out.push({
+            at: 'travel',
+            get: () => (Object.hasOwn(t, 'sum') ? { sum: t.sum, ...(t.plus !== undefined ? { plus: t.plus } : {}) } : t.source ? { from: t.source, ...(t.times !== undefined ? { times: t.times } : {}), ...(t.plus !== undefined ? { plus: t.plus } : {}) } : (t.plus ?? 0)),
+            set: v => {
+                const f = followedTermsOf(v);
+                j.travel = !f ? { plus: v } : f.sum ? { sum: f.terms, ...(f.plus ? { plus: f.plus } : {}) } : { source: f.terms[0].from, ...(f.terms[0].times !== undefined ? { times: f.terms[0].times } : {}), ...(v.plus !== undefined ? { plus: v.plus } : {}) };
+            }
+        });
+    }
+    for (const axis of Object.keys(j.origin?.align ?? {})) {
+        const how = j.origin.align[axis];
+        if (how && typeof how === 'object' && Object.hasOwn(how, 'mm'))
+            out.push({ at: `align.${axis}`, get: () => how.mm, set: v => (how.mm = v) });
+    }
+    return out;
+}
+/** The same measure with each term's source put through `to`, in the form it was written. */
+function mapMeasureSources(measure, to) {
+    const f = followedTermsOf(measure);
+    if (!f)
+        return measure;
+    if (f.sum)
+        return { ...measure, sum: f.terms.map(t => ({ ...t, from: to(t.from) })) };
+    return { ...measure, from: to(f.terms[0].from) };
+}
+/** Joints in an order each can be written in: its parent's joint and the joints it mimics first. */
 function writingOrder(joints) {
     const done = new Set();
     const out = [];
@@ -1721,7 +1904,7 @@ function writingOrder(joints) {
             if (done.has(j.id))
                 return false;
             const up = 'part' in j.body0 ? byChild.get(j.body0.part) : undefined;
-            return (!up || done.has(up.id)) && (!j.mimic || done.has(j.mimic.joint));
+            return (!up || done.has(up.id)) && figureMimicLeadersOf(j).every(t => done.has(t.joint));
         });
         if (!ready.length)
             fail('JOINT_TREE', 'joints', 'the joints do not make a tree');
@@ -1742,8 +1925,10 @@ function rewriteJoints(asset) {
       2026-09-25). The names are made first, so every joint measures the same references.
     */
     for (const j of joints)
-        if (j.travel?.source && j.travel.source.of === 'part')
-            stableDimension(asset.document.model, j.travel.source.part, j.travel.source.axis, `joints.${j.id}.travel`);
+        for (const { at, get } of jointMeasures(j))
+            for (const t of followedTermsOf(get())?.terms ?? [])
+                if (t?.from?.of === 'part')
+                    stableDimension(asset.document.model, t.from.part, t.from.axis, `joints.${j.id}.${at}`);
     const order = writingOrder(joints);
     const keep = { ...asset.stateDefaults };
     /* What hangs from a row's part is drawn through the row; it is a part of its own again while the joints are written. */
@@ -1765,7 +1950,11 @@ function rewriteJoints(asset) {
  * nodes are made from them (ADR-0093). Renaming or deleting a part in the graph alone left records naming a part that
  * was no longer there, and the author could not save (TARGET_ABSENT on joints.*, 2026-09-25).
  */
-/** The records follow a part's new name -- as a joint's parent, as its child, and as the joint a follower follows -- and the nodes are made again from them. */
+/**
+ * The records follow a part's new name -- as a joint's parent, as its child, and as the joint a follower follows -- and
+ * the nodes are made again from them. Nothing is frozen: a length that followed the part still follows it, and the
+ * stored design inputs keep their values under the carried names, so the figure stands as it did at every size.
+ */
 export function renameFigurePartInJoints(asset, from, to) {
     const joints = asset.joints;
     if (!joints?.length)
@@ -1790,14 +1979,23 @@ export function renameFigurePartInJoints(asset, from, to) {
     if (out.occupancy)
         out.occupancy = carried(out.occupancy);
     out.designInputs = Object.fromEntries(Object.entries(out.designInputs ?? {}).map(([k, v]) => [carried(k), v]));
-    asset.joints = joints.map(j => ({
-        ...j,
-        id: name(j.id),
-        body0: 'part' in j.body0 ? { ...j.body0, part: name(j.body0.part) } : j.body0,
-        body1: { ...j.body1, part: name(j.body1.part) },
-        ...(j.mimic ? { mimic: { ...j.mimic, joint: name(j.mimic.joint) } } : {}),
-        ...(j.state?.id !== undefined ? { state: { ...j.state, id: name(j.state.id) } } : {})
-    }));
+    /* A length that follows the part's measure follows it under its new name, in each term of a sum too. */
+    const source = (s) => (s?.of === 'part' ? { ...s, part: name(s.part) } : s);
+    asset.joints = joints.map(was => {
+        const j = structuredClone(was);
+        for (const { get, set } of jointMeasures(j))
+            set(mapMeasureSources(get(), source));
+        return {
+            ...j,
+            id: name(j.id),
+            body0: 'part' in j.body0 ? { ...j.body0, part: name(j.body0.part) } : j.body0,
+            body1: { ...j.body1, part: name(j.body1.part) },
+            ...(j.mimic
+                ? { mimic: Object.hasOwn(j.mimic, 'sum') ? { ...j.mimic, sum: figureMimicLeadersOf(j).map(t => ({ ...t, joint: name(t.joint) })) } : { ...j.mimic, joint: name(j.mimic.joint) } }
+                : {}),
+            ...(j.state?.id !== undefined ? { state: { ...j.state, id: name(j.state.id) } } : {})
+        };
+    });
     rewriteJoints(asset);
 }
 /**
@@ -1889,6 +2087,11 @@ export function releaseFigurePartJoints(asset, part, options = {}) {
     const children = joints.filter(j => 'part' in j.body0 && j.body0.part === part);
     if (own?.repeat && children.length)
         fail('PART_ROW', part, `${children.map(j => j.body1.part).join(', ')} ${children.length > 1 ? 'hang' : 'hangs'} in the row ${part}, on every copy; take ${children.length > 1 ? 'them' : 'it'} off first`);
+    /*
+      Every number frozen below -- a follower's range and start, a measure that followed the part, a value read from it --
+      is evaluated at the asset's stored design inputs and state defaults: the figure as it is authored, so its placement
+      there is what it was. At another instance size the frozen numbers no longer follow.
+    */
     const inputs = (over = {}) => ({ ...a.designInputs, ...a.stateDefaults, ...over });
     const controls = m.inputs.filter((i) => i.role === 'state');
     const rest = Object.fromEntries(controls.map((i) => [i.id, Math.min(i.max, Math.max(i.min, 0))]));
@@ -1899,47 +2102,78 @@ export function releaseFigurePartJoints(asset, part, options = {}) {
     const going = new Set([...(own ? [own.id] : []), ...children.map(j => j.id)]);
     /* A follower has no control of its own, so its own record's nominal id is not taken. */
     const taken = new Set([...m.inputs.map((i) => i.id), ...joints.filter(j => !j.mimic).map(stateIdOf)]);
-    for (const f of joints.filter(o => o.mimic && going.has(o.mimic.joint) && !going.has(o.id))) {
-        const leader = joints.find(o => o.id === f.mimic.joint);
-        const leaderPart = leader.body1.part;
-        const quantity = nodeById(m, `${leaderPart}.motion`)?.args[3] ?? stateIdOf(leader);
-        const state = m.inputs.find((i) => i.id === stateIdOf(leader));
-        const distance = (value) => Number(graph.evaluate(inputs({ [stateIdOf(leader)]: value })).values[quantity]);
+    for (const f of joints.filter(o => figureMimicLeadersOf(o).some(t => going.has(t.joint)) && !going.has(o.id))) {
+        /*
+          A sum whose leaders all go is a control of its own over what the sum came to, as one leader's follower is. One
+          whose other leaders stay would follow them and stand still by the rest -- what it should then be is not said, so
+          it is refused by name rather than made up.
+        */
+        const staying = figureMimicLeadersOf(f).filter(t => !going.has(t.joint));
+        if (staying.length)
+            fail('PART_FOLLOWED', part, `${f.id} follows ${staying.map(t => t.joint).join(', ')} as well as a joint that goes with ${part}; make ${f.id} follow only the joints that stay first`);
+        const terms = figureMimicLeadersOf(f).map(t => {
+            const leader = joints.find(o => o.id === t.joint);
+            const quantity = nodeById(m, `${leader.body1.part}.motion`)?.args[3] ?? stateIdOf(leader);
+            const state = m.inputs.find((i) => i.id === stateIdOf(leader));
+            const distance = (value) => Number(graph.evaluate(inputs({ [stateIdOf(leader)]: value })).values[quantity]);
+            const [a, b] = [distance(state?.min ?? 0) * t.multiplier, distance(state?.max ?? 1) * t.multiplier];
+            return { lo: Math.min(a, b), hi: Math.max(a, b), now: Number(now[quantity]) * t.multiplier };
+        });
         const turn = f.type === 'revolute';
         const toUnit = (base) => round6(turn ? (base * 180) / Math.PI : base);
         const offset = (f.mimic.offset ?? 0) * (turn ? Math.PI / 180 : 1);
-        const follow = (base) => toUnit(base * f.mimic.multiplier + offset);
-        const [lo, hi] = [follow(distance(state?.min ?? 0)), follow(distance(state?.max ?? 1))].sort((x, y) => x - y);
+        /*
+          Each leader moves on its own control, so the sum's least and greatest are each term's, added (a negative multiplier
+          swaps a term's ends, above). When leaders are driven by one upstream input -- not the case today, a leader leads
+          itself -- the summed range is conservative: it holds every value the sum can take, not the exact reach.
+        */
+        const total = (pick) => toUnit(terms.reduce((sum, t, i) => (i ? sum + pick(t) : pick(t)), 0) + offset);
+        const [lo, hi] = [total(t => t.lo), total(t => t.hi)];
         let id = f.body1.part;
         for (let n = 2; taken.has(id); n++)
             id = `${f.body1.part}-${n}`;
         taken.add(id);
-        const start = Math.min(hi, Math.max(lo, follow(Number(now[quantity]))));
+        const start = Math.min(hi, Math.max(lo, total(t => t.now)));
         const { mimic: _led, travel: _share, ...alone } = f;
         joints = joints.map(o => o.id === f.id ? { ...alone, lowerLimit: lo, upperLimit: hi, state: { ...(f.state ?? {}), id, start } } : o);
         notice.controls.push({ part: f.body1.part, control: id, min: lo, max: hi });
     }
-    /* A value in a record that followed the part: the number it is now. */
+    /*
+      A value in a record that followed the part: the number it is now -- at the stored design inputs (above). In a sum, each term that reads the part becomes
+      its number, added to the margin, and the terms that read something else still follow; no term left, the number.
+    */
     const freezeMeasure = (measure, where) => {
-        if (!measure || typeof measure !== 'object' || measure.from.of !== 'part' || measure.from.part !== part)
+        const f = followedTermsOf(measure);
+        if (!f || !f.terms.some(t => t.from?.of === 'part' && t.from.part === part))
             return measure;
         const probe = structuredClone(m);
-        const ref = stableDimension(probe, part, measure.from.axis, where);
-        const value = round6(Number(compileFigureGraph(probe).evaluate(inputs()).values[ref]) * (measure.times ?? 1) + (measure.plus ?? 0));
-        notice.fixed.push({ part: where, value, unit: 'mm' });
-        return value;
+        let frozen = 0;
+        const rest = [];
+        for (const t of f.terms) {
+            if (!(t.from.of === 'part' && t.from.part === part)) {
+                rest.push(t);
+                continue;
+            }
+            const ref = stableDimension(probe, part, t.from.axis, where);
+            frozen += Number(compileFigureGraph(probe).evaluate(inputs()).values[ref]) * (t.times ?? 1);
+        }
+        if (!rest.length) {
+            const value = round6(frozen + f.plus);
+            notice.fixed.push({ part: where, value, unit: 'mm' });
+            return value;
+        }
+        notice.fixed.push({ part: where, value: round6(frozen), unit: 'mm' });
+        return { sum: rest, ...(round6(frozen + f.plus) ? { plus: round6(frozen + f.plus) } : {}) };
     };
     joints = joints.map(j => {
         if (j.id === own?.id || children.includes(j))
             return j;
         const out = structuredClone(j);
-        if (out.origin?.gap !== undefined)
-            out.origin.gap = freezeMeasure(out.origin.gap, j.body1.part);
-        if (out.repeat)
-            out.repeat.pitch = freezeMeasure(out.repeat.pitch, j.body1.part);
-        if (out.travel?.source?.of === 'part' && out.travel.source.part === part) {
-            const plus = freezeMeasure({ from: out.travel.source, times: out.travel.times, plus: out.travel.plus }, j.body1.part);
-            out.travel = { plus };
+        for (const { get, set } of jointMeasures(out)) {
+            const was = get();
+            const fixed = freezeMeasure(was, j.body1.part);
+            if (fixed !== was)
+                set(fixed);
         }
         return out;
     });
@@ -2152,7 +2386,7 @@ function setJoint(asset, joint) {
             j.origin = { ...(j.origin ?? {}), turn: Object.fromEntries(AXES.map((a, i) => [a, turn[i]])) };
     }
     const joints = (asset.joints ?? []).filter(o => o.id !== j.id);
-    const followers = joints.filter(o => o.mimic?.joint === j.id);
+    const followers = joints.filter(o => figureMimicLeadersOf(o).some(t => t.joint === j.id));
     if (followers.length && j.type === 'fixed')
         fail('JOINT_SCHEMA', `joints.${j.id}`, `${followers.map(f => f.id).join(', ')} follow ${j.id}; it cannot stop moving`);
     asset.joints = [...joints, j];
@@ -2213,7 +2447,7 @@ function removeJoint(asset, id) {
     const j = joints.find(o => o.id === id);
     if (!j)
         fail('EDIT_TARGET', `joints.${id}`, `there is no joint ${id}`);
-    const followers = joints.filter(o => o.mimic?.joint === id);
+    const followers = joints.filter(o => figureMimicLeadersOf(o).some(t => t.joint === id));
     if (followers.length)
         fail('JOINT_SCHEMA', `joints.${id}`, `${followers.map(f => f.id).join(', ')} follow ${id}; remove them first`);
     const m = asset.document.model;
@@ -2315,10 +2549,28 @@ function addMotion(asset, a, follow, sign = 1) {
     const name = namer(m, `${a.part}.motion`);
     let quantity = st?.id;
     if (follow) {
-        /* A mimic: the leader's value times k plus c, and no control of its own. */
-        const scaledId = name('mimic');
-        m.nodes.push({ id: scaledId, op: 'mul@1', args: [follow.of, constantOf(m, 'ratio', follow.k, 'k')], outputs: { value: `${scaledId}.value` } });
-        quantity = `${scaledId}.value`;
+        /*
+          A mimic: the leader's value times k plus c, and no control of its own. A sum is each leader's value times its own
+          k, added up, then c -- written with the same mul@1 and add@1 a one-leader mimic is, so a pose step runs it as it
+          runs that (ADR-0108), and the gate reads it by the same operators.
+        */
+        if (!follow.sum) {
+            const scaledId = name('mimic');
+            m.nodes.push({ id: scaledId, op: 'mul@1', args: [follow.terms[0].of, constantOf(m, 'ratio', follow.terms[0].k, 'k')], outputs: { value: `${scaledId}.value` } });
+            quantity = `${scaledId}.value`;
+        }
+        else
+            for (const [i, t] of follow.terms.entries()) {
+                const scaledId = name(`mimic.${i}`);
+                m.nodes.push({ id: scaledId, op: 'mul@1', args: [t.of, constantOf(m, 'ratio', t.k, 'k')], outputs: { value: `${scaledId}.value` } });
+                if (!i)
+                    quantity = `${scaledId}.value`;
+                else {
+                    const added = name(`mimic.${i}.sum`);
+                    m.nodes.push({ id: added, op: 'add@1', args: [quantity, `${scaledId}.value`], outputs: { value: `${added}.value` } });
+                    quantity = `${added}.value`;
+                }
+            }
         if (follow.c) {
             const plus = name('mimic.offset');
             /* The offset is in the follower's own unit: millimetres for a slide, degrees for a turn. */
@@ -2375,8 +2627,16 @@ function addMotion(asset, a, follow, sign = 1) {
         if (!a.travel)
             fail('SCHEMA', path, 'a ratio control needs travel: how far the part goes at 1');
         const travel = a.travel;
-        const base = travel.source ? sourceRef(m, asset, travel.source, path) : constantOf(m, 'mm', travel.plus ?? 0, 'd');
-        const length = travel.source ? scaled(m, name, base, travel.times ?? 1, travel.plus ?? 0, 'travel') : base;
+        let length;
+        if (Object.hasOwn(travel, 'sum')) {
+            /* A stroke that is a sum of lengths: the terms added, then the margin, as any followed length (ADR-0107). */
+            const plus = travel.plus ?? 0;
+            length = scaled(m, name, sumOf(m, name, termRefs(m, asset, travel.sum, plus, `${path}.travel`), 'travel.sum'), 1, plus, 'travel');
+        }
+        else {
+            const base = travel.source ? sourceRef(m, asset, travel.source, path) : constantOf(m, 'mm', travel.plus ?? 0, 'd');
+            length = travel.source ? scaled(m, name, base, travel.times ?? 1, travel.plus ?? 0, 'travel') : base;
+        }
         const id = name('distance');
         m.nodes.push({ id, op: 'mul@1', args: [quantity, length], outputs: { value: `${id}.value` } });
         quantity = `${id}.value`;