claude-exode-mcp 7.5.7 → 7.5.8

package/src/rive/convert.js

@@ -0,0 +1,1779 @@
+// @ts-nocheck
+// GENERATED by scripts/sync-lottie-converter.mjs from editor/src/utils/rive. Edit there, then re-run.
+// Rive (.riv) -> Exode artboard.
+//
+// Rive's scene graph maps closely onto Exode's: every TransformComponent
+// (Node, Shape, Bone, …) becomes a Group with x, y, rotation (radians ->
+// degrees), scale and opacity. Rive draws drawables in reverse stream order,
+// which for its depth-first stream is the same as reversing children at every
+// level, so the hierarchy is kept. A Shape's paths are merged into one
+// compound outline in the shape's space, drawn once per fill/stroke in paint
+// order. Written for the Exode runtime and editor as they are (see the Lottie
+// converter for the same adaptations): Groups get clipContent: false, strokes
+// are multiplied by their accumulated scale, even-odd fills are re-wound for
+// the nonzero-only runtime, gradient opacity is folded into the stops, and a
+// transition without conditions waits for its exit time via `delay`.
+//
+// Pure TypeScript with no editor imports.
+import { argb, isA, readRiv } from './reader.js';
+import { PROPS } from './schema.generated.js';
+import { parseFont } from './font.js';
+import { solveLayouts, isLayoutParticipant } from './layout.js';
+const r3 = (n) => Math.round(n * 1000) / 1000;
+const DEG = 180 / Math.PI;
+const baseTransform = () => ({ x: 0, y: 0, rotation: 0, scale_x: 1, scale_y: 1, opacity: 1, skew_x: 0, skew_y: 0 });
+const noStroke = () => ({ color: '#000000', width: 0, opacity: 0, isEnabled: false });
+const CONSTRAINTS = new Set(['IKConstraint', 'TransformConstraint', 'TranslationConstraint', 'RotationConstraint', 'ScaleConstraint']);
+function indexScene(ab) {
+    const byIndex = ab.slots;
+    const children = new Map();
+    for (const o of ab.slots) {
+        if (!o || o === ab.artboard || !isA(o.type, 'Component'))
+            continue;
+        const p = o.props.parentId ?? 0;
+        const list = children.get(p) || [];
+        list.push(o);
+        children.set(p, list);
+    }
+    // Animations: LinearAnimation > KeyedObject(objectId) > KeyedProperty(propertyKey) > KeyFrame*.
+    const animations = [];
+    const machines = [];
+    let anim = null, objId = -1, prop = null, machine = null;
+    for (const o of ab.stream) {
+        if (o.type === 'LinearAnimation') {
+            const fps = o.props.fps || 60;
+            const start = o.props.enableWorkArea ? o.props.workStart || 0 : 0;
+            const end = o.props.enableWorkArea ? o.props.workEnd || o.props.duration : o.props.duration;
+            anim = { obj: o, keyed: new Map(), fps, start, end: end || 0 };
+            animations.push(anim);
+            machine = null;
+        }
+        else if (o.type === 'StateMachine') {
+            machine = [o];
+            machines.push(machine);
+            anim = null;
+        }
+        else if (machine) {
+            machine.push(o);
+        }
+        else if (anim && o.type === 'KeyedObject') {
+            objId = o.props.objectId;
+            if (!anim.keyed.has(objId))
+                anim.keyed.set(objId, new Map());
+        }
+        else if (anim && o.type === 'KeyedProperty') {
+            prop = propName(o.props.propertyKey);
+            if (prop && !anim.keyed.get(objId).has(prop))
+                anim.keyed.get(objId).set(prop, []);
+        }
+        else if (anim && prop && isA(o.type, 'KeyFrame')) {
+            const it = o.props.interpolatorId;
+            anim.keyed.get(objId).get(prop).push({
+                frame: o.props.frame || 0,
+                value: o.props.value,
+                type: o.props.interpolationType ?? 1,
+                interpolator: it !== undefined && it !== -1 && it < byIndex.length ? byIndex[it] : null,
+                color: o.type === 'KeyFrameColor',
+            });
+        }
+    }
+    // Joysticks re-apply their x/y animations after everything else, at a time set
+    // by the stick position (-1..1 -> start..end). Those properties are a held pose,
+    // so bake it into the base props and stop the animation from driving them.
+    for (const j of ab.slots) {
+        if (!j || j.type !== 'Joystick')
+            continue;
+        const flags = j.props.joystickFlags || 0;
+        for (const [id, v] of [[j.props.xId, flags & 1 ? -(j.props.x || 0) : j.props.x || 0], [j.props.yId, flags & 2 ? -(j.props.y || 0) : j.props.y || 0]]) {
+            const a = id !== undefined && id >= 0 ? animations[id] : undefined;
+            if (!a)
+                continue;
+            const frame = a.start + ((v + 1) / 2) * (a.end - a.start);
+            for (const [objId, props] of a.keyed) {
+                const o = byIndex[objId];
+                if (!o)
+                    continue;
+                for (const [name, keys] of props)
+                    if (keys.length)
+                        o.props[name] = keyedAt(keys, frame);
+            }
+            a.keyed = new Map();
+        }
+    }
+    const constraints = [];
+    for (const c of ab.slots) {
+        if (!c || !CONSTRAINTS.has(c.type))
+            continue;
+        const owner = byIndex[c.props.parentId ?? 0];
+        const tid = c.props.targetId;
+        const target = tid !== undefined && tid >= 0 && tid < byIndex.length ? byIndex[tid] : null;
+        if (!owner || owner.index === 0 || !isA(owner.type, 'TransformComponent'))
+            continue;
+        if (c.type === 'IKConstraint') {
+            if (!target || !isA(owner.type, 'Bone'))
+                continue;
+            const chain = [owner];
+            for (let b = owner, n = c.props.parentBoneCount ?? 0; n > 0; n--) {
+                const up = byIndex[b.props.parentId ?? 0];
+                if (!up || !isA(up.type, 'Bone'))
+                    break;
+                chain.unshift(up);
+                b = up;
+            }
+            constraints.push({ c, owner, target, chain });
+        }
+        else
+            constraints.push({ c, owner, target });
+    }
+    return { ab, byIndex, children, animations, machines, constraints, poseCache: new Map() };
+}
+const propName = (key) => (PROPS[key] ? PROPS[key][0] : null);
+// ---------------------------------------------------------------- evaluation
+const bezier = (x1, y1, x2, y2) => (x) => {
+    const cx = 3 * x1, bx = 3 * (x2 - x1) - cx, ax = 1 - cx - bx;
+    const cy = 3 * y1, by = 3 * (y2 - y1) - cy, ay = 1 - cy - by;
+    let t = x;
+    for (let i = 0; i < 8; i++) {
+        const v = ((ax * t + bx) * t + cx) * t - x;
+        const d = (3 * ax * t + 2 * bx) * t + cx;
+        if (Math.abs(v) < 1e-6 || Math.abs(d) < 1e-6)
+            break;
+        t -= v / d;
+    }
+    t = Math.max(0, Math.min(1, t));
+    return ((ay * t + by) * t + cy) * t;
+};
+const lerpColor = (a, b, f) => {
+    const ch = (c, s) => (c >>> s) & 255;
+    const mix = (s) => Math.round(ch(a, s) + (ch(b, s) - ch(a, s)) * f);
+    return ((mix(24) << 24) | (mix(16) << 16) | (mix(8) << 8) | mix(0)) >>> 0;
+};
+function easeOf(k) {
+    if (k.type === 0)
+        return null; // hold
+    const it = k.interpolator;
+    if (k.type === 2 && it && (it.type === 'CubicEaseInterpolator' || it.type === 'CubicValueInterpolator'))
+        return bezier(it.props.x1 ?? 0.42, it.props.y1 ?? 0, it.props.x2 ?? 0.58, it.props.y2 ?? 1);
+    if (it && it.type === 'ElasticInterpolator') {
+        const amp = it.props.amplitude ?? 1, period = it.props.period ?? 0.5, easing = it.props.easingValue ?? 1;
+        const s = period / (2 * Math.PI) * Math.asin(1 / Math.max(amp, 1));
+        const out = (t) => (t <= 0 ? 0 : t >= 1 ? 1 : Math.max(amp, 1) * Math.pow(2, -10 * t) * Math.sin((t - s) * (2 * Math.PI) / period) + 1);
+        return easing === 0 ? (t => 1 - out(1 - t)) : easing === 1 ? out : (t => (t < 0.5 ? (1 - out(1 - 2 * t)) / 2 : (out(2 * t - 1) + 1) / 2));
+    }
+    return f => f;
+}
+/** Value of a keyed property at a frame. */
+function keyedAt(keys, frame) {
+    if (frame <= keys[0].frame)
+        return keys[0].value;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const a = keys[i], b = keys[i + 1];
+        if (frame >= b.frame)
+            continue;
+        const ease = easeOf(a);
+        if (!ease || typeof a.value !== 'number' || typeof b.value !== 'number')
+            return a.value;
+        const f = ease((frame - a.frame) / ((b.frame - a.frame) || 1));
+        return a.color ? lerpColor(a.value, b.value, Math.max(0, Math.min(1, f))) : a.value + (b.value - a.value) * f;
+    }
+    return keys[keys.length - 1].value;
+}
+/** Object props at a frame of an animation (static props overlaid with keyed values). */
+const propsAt = (o, anim, frame) => {
+    const m = anim?.keyed.get(o.index);
+    if (!m)
+        return o.props;
+    const out = { ...o.props };
+    m.forEach((keys, name) => { if (keys.length)
+        out[name] = keyedAt(keys, frame); });
+    return out;
+};
+const mul = (p, q) => [p[0] * q[0] + p[2] * q[1], p[1] * q[0] + p[3] * q[1], p[0] * q[2] + p[2] * q[3], p[1] * q[2] + p[3] * q[3], p[0] * q[4] + p[2] * q[5] + p[4], p[1] * q[4] + p[3] * q[5] + p[5]];
+const applyM = (m, x, y) => [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+/** A child Bone sits at its parent bone's tip. */
+const boneLocal = (s, o, p, anim, frame) => {
+    if (o.type !== 'Bone')
+        return p;
+    const parent = s.byIndex[o.props.parentId ?? 0];
+    if (!parent || (parent.type !== 'Bone' && parent.type !== 'RootBone'))
+        return p;
+    return { ...p, x: propsAt(parent, anim, frame).length ?? 0, y: 0 };
+};
+const localM = (p) => {
+    const c = Math.cos(p.rotation || 0), s = Math.sin(p.rotation || 0), sx = p.scaleX ?? 1, sy = p.scaleY ?? 1;
+    return [c * sx, s * sx, -s * sy, c * sy, p.x || 0, p.y || 0];
+};
+const CIRCLE = 0.552284749831;
+/** A path's vertices (in path space) at a frame. */
+function pathVertices(s, path, anim, frame) {
+    let p = propsAt(path, anim, frame);
+    const so = s.sizeOverride?.get(path.index);
+    if (so)
+        p = { ...p, width: so.w, height: so.h };
+    const w = p.width || 0, h = p.height || 0, ox0 = -(p.originX ?? 0.5) * w, oy0 = -(p.originY ?? 0.5) * h;
+    const straight = (x, y, radius = 0) => ({ x, y, ix: x, iy: y, ox: x, oy: y, radius, cubic: false });
+    if (path.type === 'Rectangle') {
+        const link = p.linkCornerRadius !== false, tl = p.cornerRadiusTL || 0;
+        return { closed: true, verts: [straight(ox0, oy0, tl), straight(ox0 + w, oy0, link ? tl : p.cornerRadiusTR || 0), straight(ox0 + w, oy0 + h, link ? tl : p.cornerRadiusBR || 0), straight(ox0, oy0 + h, link ? tl : p.cornerRadiusBL || 0)] };
+    }
+    if (path.type === 'Ellipse') {
+        const rx = w / 2, ry = h / 2, cx = ox0 + rx, cy = oy0 + ry, kx = rx * CIRCLE, ky = ry * CIRCLE;
+        const c = (x, y, ix, iy, ox, oy) => ({ x, y, ix, iy, ox, oy, radius: 0, cubic: true });
+        return { closed: true, verts: [
+                c(cx, cy - ry, cx - kx, cy - ry, cx + kx, cy - ry), c(cx + rx, cy, cx + rx, cy - ky, cx + rx, cy + ky),
+                c(cx, cy + ry, cx + kx, cy + ry, cx - kx, cy + ry), c(cx - rx, cy, cx - rx, cy + ky, cx - rx, cy - ky),
+            ] };
+    }
+    if (path.type === 'Triangle')
+        return { closed: true, verts: [straight(ox0 + w / 2, oy0), straight(ox0 + w, oy0 + h), straight(ox0, oy0 + h)] };
+    if (path.type === 'Polygon' || path.type === 'Star') {
+        const n = path.type === 'Star' ? (p.points || 5) * 2 : (p.points || 5);
+        const hw = w / 2, hh = h / 2, cx = ox0 + hw, cy = oy0 + hh, inner = p.innerRadius ?? 0.5;
+        const verts = [];
+        for (let i = 0; i < n; i++) {
+            const a = -Math.PI / 2 + (i * 2 * Math.PI) / n;
+            const k = path.type === 'Star' && i % 2 ? inner : 1;
+            verts.push(straight(cx + Math.cos(a) * hw * k, cy + Math.sin(a) * hh * k, p.cornerRadius || 0));
+        }
+        return { closed: true, verts };
+    }
+    // PointsPath: vertex children.
+    const verts = [];
+    for (const v of s.children.get(path.index) || []) {
+        if (!isA(v.type, 'PathVertex'))
+            continue;
+        const q = propsAt(v, anim, frame);
+        const x = q.x || 0, y = q.y || 0;
+        if (v.type === 'StraightVertex')
+            verts.push(straight(x, y, q.radius || 0));
+        else if (v.type === 'CubicMirroredVertex') {
+            const dx = Math.cos(q.rotation || 0) * (q.distance || 0), dy = Math.sin(q.rotation || 0) * (q.distance || 0);
+            verts.push({ x, y, ix: x - dx, iy: y - dy, ox: x + dx, oy: y + dy, radius: 0, cubic: true });
+        }
+        else if (v.type === 'CubicAsymmetricVertex') {
+            const c = Math.cos(q.rotation || 0), sn = Math.sin(q.rotation || 0);
+            verts.push({ x, y, ix: x - c * (q.inDistance || 0), iy: y - sn * (q.inDistance || 0), ox: x + c * (q.outDistance || 0), oy: y + sn * (q.outDistance || 0), radius: 0, cubic: true });
+        }
+        else if (v.type === 'CubicDetachedVertex')
+            verts.push({ x, y, ix: x + Math.cos(q.inRotation || 0) * (q.inDistance || 0), iy: y + Math.sin(q.inRotation || 0) * (q.inDistance || 0), ox: x + Math.cos(q.outRotation || 0) * (q.outDistance || 0), oy: y + Math.sin(q.outRotation || 0) * (q.outDistance || 0), radius: 0, cubic: true });
+    }
+    return { verts, closed: p.isClosed !== false };
+}
+/**
+ * Rive skinning: each tendon contributes bone.world x inverse(bind); a vertex
+ * blends up to four of those by its 8-bit weights and applies the blend to its
+ * bind-pose world position (skin.world x vertex). Cubic handles carry their own weights.
+ */
+function skinVertices(s, path, skin, verts, anim, frame) {
+    const sk = skin.props;
+    const bindWorld = [sk.xx ?? 1, sk.xy ?? 0, sk.yx ?? 0, sk.yy ?? 1, sk.tx ?? 0, sk.ty ?? 0];
+    const tendons = (s.children.get(skin.index) || []).filter(k => k.type === 'Tendon');
+    const bones = [[1, 0, 0, 1, 0, 0]];
+    for (const t of tendons) {
+        const tp = t.props;
+        const bind = [tp.xx ?? 1, tp.xy ?? 0, tp.yx ?? 0, tp.yy ?? 1, tp.tx ?? 0, tp.ty ?? 0];
+        const bone = s.byIndex[tp.boneId];
+        bones.push(bone ? mul(worldOf(s, bone, anim, frame), invM(bind)) : invM(bind));
+    }
+    const deform = (x, y, indices, weights) => {
+        const m = [0, 0, 0, 0, 0, 0];
+        let total = 0;
+        for (let i = 0; i < 4; i++) {
+            const w = (weights >>> (i * 8)) & 255;
+            if (!w)
+                continue;
+            const b = bones[(indices >>> (i * 8)) & 255] || bones[0];
+            for (let k = 0; k < 6; k++)
+                m[k] += b[k] * (w / 255);
+            total += w;
+        }
+        const [wx, wy] = applyM(bindWorld, x, y);
+        return total ? applyM(m, wx, wy) : [wx, wy];
+    };
+    const vertexObjs = (s.children.get(path.index) || []).filter(k => isA(k.type, 'PathVertex'));
+    return verts.map((v, i) => {
+        const vo = vertexObjs[i];
+        const wt = vo && (s.children.get(vo.index) || []).find(k => k.type === 'Weight' || k.type === 'CubicWeight');
+        if (!wt) {
+            const [x, y] = applyM(bindWorld, v.x, v.y);
+            const [ix, iy] = applyM(bindWorld, v.ix, v.iy);
+            const [ox, oy] = applyM(bindWorld, v.ox, v.oy);
+            return { ...v, x, y, ix, iy, ox, oy };
+        }
+        const w = wt.props;
+        const [x, y] = deform(v.x, v.y, w.indices ?? 1, w.values ?? 255);
+        if (!v.cubic)
+            return { ...v, x, y, ix: x, iy: y, ox: x, oy: y };
+        const [ix, iy] = deform(v.ix, v.iy, w.inIndices ?? w.indices ?? 1, w.inValues ?? w.values ?? 255);
+        const [ox, oy] = deform(v.ox, v.oy, w.outIndices ?? w.indices ?? 1, w.outValues ?? w.values ?? 255);
+        return { ...v, x, y, ix, iy, ox, oy };
+    });
+}
+/** Vertices -> Exode points, rounding straight corners the way Rive does (natural rounding). */
+function toPoints(verts, closed, m) {
+    const n = verts.length;
+    const out = [];
+    const push = (x, y, ix, iy, ox, oy, curved) => {
+        const [X, Y] = applyM(m, x, y), [IX, IY] = applyM(m, ix, iy), [OX, OY] = applyM(m, ox, oy);
+        out.push({ x: X, y: Y, in_x: IX, in_y: IY, out_x: OX, out_y: OY, pointType: curved ? 'smooth' : 'corner' });
+    };
+    for (let i = 0; i < n; i++) {
+        const v = verts[i];
+        const hasPrev = closed || i > 0, hasNext = closed || i < n - 1;
+        if (!v.cubic && v.radius && hasPrev && hasNext) {
+            const prev = verts[(i - 1 + n) % n], next = verts[(i + 1) % n];
+            const px = (prev.cubic ? prev.ox : prev.x) - v.x, py = (prev.cubic ? prev.oy : prev.y) - v.y;
+            const nx = (next.cubic ? next.ix : next.x) - v.x, ny = (next.cubic ? next.iy : next.y) - v.y;
+            const lp = Math.hypot(px, py) || 1, ln = Math.hypot(nx, ny) || 1;
+            const tpx = px / lp, tpy = py / lp, tnx = nx / ln, tny = ny / ln;
+            const r = Math.min(Math.abs(v.radius), lp / 2, ln / 2);
+            const angle = Math.abs(Math.atan2(tpx * tny - tpy * tnx, tpx * tnx + tpy * tny));
+            const ideal = Math.min(r, Math.tan(Math.PI / (2 * ((2 * Math.PI) / (angle || 1e-6)))) * r * (4 / 3));
+            const ex = v.x + tpx * r, ey = v.y + tpy * r, xx = v.x + tnx * r, xy = v.y + tny * r;
+            push(ex, ey, ex, ey, ex + -tpx * ideal, ey + -tpy * ideal, true);
+            push(xx, xy, xx + -tnx * ideal, xy + -tny * ideal, xx, xy, true);
+        }
+        else {
+            push(v.x, v.y, v.ix, v.iy, v.ox, v.oy, v.cubic);
+        }
+    }
+    if (out.length) {
+        out[0].moveTo = true;
+        if (closed)
+            out[out.length - 1].closePath = true;
+    }
+    return out;
+}
+const area = (c) => c.reduce((s, p, i) => { const q = c[(i + 1) % c.length]; return s + p.x * q.y - q.x * p.y; }, 0) / 2;
+const inside = (pt, poly) => { let c = false; for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const a = poly[i], b = poly[j];
+    if ((a.y > pt.y) !== (b.y > pt.y) && pt.x < ((b.x - a.x) * (pt.y - a.y)) / ((b.y - a.y) || 1e-9) + a.x)
+        c = !c;
+} return c; };
+const reverse = (c) => {
+    const r = [...c].reverse().map(p => ({ ...p, in_x: p.out_x, in_y: p.out_y, out_x: p.in_x, out_y: p.in_y, moveTo: false, closePath: false }));
+    r[0].moveTo = true;
+    if (c[c.length - 1].closePath)
+        r[r.length - 1].closePath = true;
+    return r;
+};
+/** Nonzero-only runtime: alternate contour direction by nesting depth so it fills like even-odd. */
+const evenOdd = (contours) => contours.length < 2 ? contours : contours.map((c, i) => {
+    const depth = contours.reduce((d, o, j) => (j !== i && o.length > 2 && inside(c[0], o) ? d + 1 : d), 0);
+    return (area(c) > 0) === (depth % 2 === 0) ? c : reverse(c);
+});
+/** A Shape's compound outline (shape space) at a frame. */
+function shapeContours(s, shape, anim, frame, eo) {
+    const contours = [];
+    for (const c of s.children.get(shape.index) || []) {
+        if (!isA(c.type, 'Path'))
+            continue;
+        const p = propsAt(c, anim, frame);
+        if ((p.pathFlags ?? 0) & 1)
+            continue; // Path::isHidden is bit 0; bit 1 is not "hidden"
+        const { verts, closed } = pathVertices(s, c, anim, frame);
+        if (!verts.length)
+            continue;
+        const skin = (s.children.get(c.index) || []).find(k => k.type === 'Skin');
+        if (skin) {
+            // Deformed points are in artboard space; bring them into the shape's space.
+            const toShape = invM(worldOf(s, shape, anim, frame));
+            contours.push(toPoints(skinVertices(s, c, skin, verts, anim, frame), closed, toShape));
+        }
+        else
+            contours.push(toPoints(verts, closed, localM(p)));
+    }
+    return eo ? evenOdd(contours) : contours;
+}
+const bbox = (pts) => {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of pts)
+        for (const [x, y] of [[p.x, p.y], [p.in_x, p.in_y], [p.out_x, p.out_y]]) {
+            x0 = Math.min(x0, x);
+            y0 = Math.min(y0, y);
+            x1 = Math.max(x1, x);
+            y1 = Math.max(y1, y);
+        }
+    return { x0, y0, x1, y1, w: Math.max(0, x1 - x0), h: Math.max(0, y1 - y0) };
+};
+/** Path size; the runtime scales points by width / baseWidth, so a straight line must not be 0 wide. */
+const dim = (v) => Math.max(1, r3(v));
+const ptsToData = (pts) => {
+    const parts = [];
+    let start = 0;
+    pts.forEach((p, i) => {
+        if (p.moveTo || i === 0) {
+            parts.push(`M${r3(p.x)} ${r3(p.y)}`);
+            start = i;
+        }
+        else {
+            const q = pts[i - 1];
+            parts.push(`C${r3(q.out_x)} ${r3(q.out_y)} ${r3(p.in_x)} ${r3(p.in_y)} ${r3(p.x)} ${r3(p.y)}`);
+        }
+        if (p.closePath) {
+            const st = pts[start];
+            parts.push(`C${r3(p.out_x)} ${r3(p.out_y)} ${r3(st.in_x)} ${r3(st.in_y)} ${r3(st.x)} ${r3(st.y)} Z`);
+        }
+    });
+    return parts.join(' ');
+};
+const DRAW_TYPES = new Set(['Shape', 'Image', 'Text', 'NestedArtboard', 'NestedArtboardLeaf', 'NestedArtboardLayout']);
+/** Artboard-space transform of a component at a frame. */
+function worldOf(s, o, anim, frame) {
+    const chain = [];
+    for (let c = o, g = 0; c && c.index !== 0 && g < 64; c = s.byIndex[c.props.parentId ?? 0] || null, g++)
+        if (isA(c.type, 'TransformComponent'))
+            chain.unshift(c);
+    const pose = poseAt(s, anim, frame);
+    return chain.reduce((m, c) => pose.world.get(c.index) || mul(m, localM(localProps(s, c, anim, frame, pose))), [1, 0, 0, 1, 0, 0]);
+}
+/** A component's local transform props at a frame, with bone tips and IK solves applied. */
+function localProps(s, c, anim, frame, pose = poseAt(s, anim, frame)) {
+    const p = boneLocal(s, c, propsAt(c, anim, frame), anim, frame);
+    return pose.rot.has(c.index) ? { ...p, rotation: pose.rot.get(c.index) } : p;
+}
+const decompose = (m) => {
+    const d = m[0] * m[0] + m[1] * m[1], sx = Math.sqrt(d);
+    return { x: m[4], y: m[5], rotation: Math.atan2(m[1], m[0]), scaleX: sx, scaleY: sx ? (m[0] * m[3] - m[2] * m[1]) / sx : 0, skew: Math.atan2(m[0] * m[2] + m[1] * m[3], d) };
+};
+const compose = (c) => {
+    const cs = Math.cos(c.rotation), sn = Math.sin(c.rotation);
+    const m = [cs * c.scaleX, sn * c.scaleX, -sn * c.scaleY, cs * c.scaleY, c.x, c.y];
+    if (c.skew) {
+        m[2] = m[0] * c.skew + m[2];
+        m[3] = m[1] * c.skew + m[3];
+    }
+    return m;
+};
+const wrapAngle = (from, to) => {
+    const a = from % (Math.PI * 2), b = to % (Math.PI * 2);
+    let d = b - a;
+    if (d > Math.PI)
+        d -= Math.PI * 2;
+    else if (d < -Math.PI)
+        d += Math.PI * 2;
+    return [a, d];
+};
+/**
+ * Rive IK (ik_constraint.cpp): one bone aims at the target; two bones solve the
+ * triangle by the law of cosines; longer chains solve each bone against the tip.
+ * Strength blends from the FK rotation. Solves run in file order, each seeing the
+ * ones before it, and only change chain bones' local rotations.
+ */
+function poseAt(s, anim, frame) {
+    let byFrame = s.poseCache.get(anim);
+    if (!byFrame) {
+        byFrame = new Map();
+        s.poseCache.set(anim, byFrame);
+    }
+    let pose = byFrame.get(frame);
+    if (pose)
+        return pose;
+    pose = { rot: new Map(), world: new Map() };
+    byFrame.set(frame, pose); // later solves read the earlier ones through this
+    if (!s.constraints.length)
+        return pose;
+    const ov = pose.rot;
+    const parentWorld = (b) => { const p = s.byIndex[b.props.parentId ?? 0]; return p && p.index !== 0 && isA(p.type, 'TransformComponent') ? worldOf(s, p, anim, frame) : [1, 0, 0, 1, 0, 0]; };
+    const pos = (m) => [m[4], m[5]];
+    const dir = (m, x, y) => [m[0] * x + m[2] * y, m[1] * x + m[3] * y];
+    const ang = (v) => Math.atan2(v[1], v[0]);
+    for (const { c, owner, target, chain } of s.constraints) {
+        if (!chain) {
+            otherConstraint(s, c, owner, target, anim, frame, pose, parentWorld);
+            continue;
+        }
+        const tw = worldOf(s, target, anim, frame);
+        const T = pos(tw);
+        const fk = chain.map(b => localProps(s, b, anim, frame, pose).rotation || 0);
+        const solved = new Map();
+        const set = (b, r) => { solved.set(b.index, r); ov.set(b.index, r); };
+        const solve2 = (i, tipIdx) => {
+            const b1 = chain[i], b2 = chain[tipIdx], first = chain[i + 1];
+            const iw = invM(parentWorld(b1));
+            const w1 = worldOf(s, b1, anim, frame), wc = worldOf(s, first, anim, frame), w2 = worldOf(s, b2, anim, frame);
+            const tipLen = propsAt(b2, anim, frame).length ?? 0;
+            const pA = applyM(iw, ...pos(w1)), pC = applyM(iw, ...pos(wc)), pB = applyM(iw, ...applyM(w2, tipLen, 0)), pBT = applyM(iw, ...T);
+            const a = Math.hypot(pB[0] - pC[0], pB[1] - pC[1]), b = Math.hypot(pC[0] - pA[0], pC[1] - pA[1]);
+            const cv = [pBT[0] - pA[0], pBT[1] - pA[1]], cl = Math.hypot(...cv);
+            const clamp = (v) => Math.max(-1, Math.min(1, v));
+            const A = Math.acos(clamp((-a * a + b * b + cl * cl) / (2 * b * cl || 1e-9)));
+            const C = Math.acos(clamp((a * a + b * b - cl * cl) / (2 * a * b || 1e-9)));
+            let corr = 0;
+            if (b2.props.parentId !== b1.index) {
+                const second = chain[i + 2];
+                const wB = applyM(w2, tipLen, 0), wC = pos(wc);
+                corr = -ang(dir(invM(parentWorld(second)), wB[0] - wC[0], wB[1] - wC[1]));
+            }
+            const inv = !!c.props.invertDirection;
+            set(b1, inv ? ang(cv) - A : A + ang(cv));
+            set(first, (inv ? -C + Math.PI : C - Math.PI) + corr);
+        };
+        if (chain.length === 1) {
+            const b = chain[0];
+            const d = dir(invM(parentWorld(b)), T[0] - worldOf(s, b, anim, frame)[4], T[1] - worldOf(s, b, anim, frame)[5]);
+            set(b, ang(d));
+        }
+        else if (chain.length === 2)
+            solve2(0, 1);
+        else
+            for (let i = 0; i < chain.length - 1; i++)
+                solve2(i, chain.length - 1);
+        const k = c.props.strength ?? 1;
+        if (k !== 1)
+            chain.forEach((b, i) => {
+                if (!solved.has(b.index))
+                    return;
+                const from = fk[i] % (Math.PI * 2), to = solved.get(b.index) % (Math.PI * 2);
+                let d = to - from;
+                if (d > Math.PI)
+                    d -= Math.PI * 2;
+                else if (d < -Math.PI)
+                    d += Math.PI * 2;
+                ov.set(b.index, from + d * k);
+            });
+    }
+    return pose;
+}
+/** Transform / translation / rotation / scale constraints (constraints/*.cpp): set the owner's world transform. */
+function otherConstraint(s, c, owner, tgt, anim, frame, pose, parentWorld) {
+    const p = propsAt(c, anim, frame);
+    const t = p.strength ?? 1, ti = 1 - t;
+    const A = worldOf(s, owner, anim, frame);
+    const srcLocal = (p.sourceSpaceValue ?? 0) === 1, dstLocal = (p.destSpaceValue ?? 0) === 1;
+    const targetWorld = () => { let B = worldOf(s, tgt, anim, frame); if (srcLocal)
+        B = mul(invM(parentWorld(tgt)), B); return B; };
+    if (c.type === 'TransformConstraint') {
+        if (!tgt)
+            return;
+        const b = s.bounds?.(tgt) || { x: 0, y: 0, w: 0, h: 0 };
+        let B = mul(worldOf(s, tgt, anim, frame), [1, 0, 0, 1, b.x + b.w * (p.originX ?? 0), b.y + b.h * (p.originY ?? 0)]);
+        if (srcLocal)
+            B = mul(invM(parentWorld(tgt)), B);
+        if (dstLocal)
+            B = mul(parentWorld(owner), B);
+        const ca = decompose(A), cb = decompose(B);
+        const [a0, d] = wrapAngle(ca.rotation, cb.rotation);
+        pose.world.set(owner.index, compose({ rotation: a0 + d * t, x: ca.x * ti + cb.x * t, y: ca.y * ti + cb.y * t, scaleX: ca.scaleX * ti + cb.scaleX * t, scaleY: ca.scaleY * ti + cb.scaleY * t, skew: ca.skew * ti + cb.skew * t }));
+        return;
+    }
+    const own = propsAt(owner, anim, frame);
+    const clampLocal = (p.minMaxSpaceValue ?? 0) === 1;
+    if (c.type === 'TranslationConstraint') {
+        let bx = A[4], by = A[5];
+        if (tgt) {
+            const B = targetWorld();
+            bx = B[4];
+            by = B[5];
+            const lx = p.offset ? own.x || 0 : 0, ly = p.offset ? own.y || 0 : 0;
+            if (!p.doesCopy)
+                bx = dstLocal ? 0 : A[4];
+            else
+                bx = bx * (p.copyFactor ?? 1) + lx;
+            if (!p.doesCopyY)
+                by = dstLocal ? 0 : A[5];
+            else
+                by = by * (p.copyFactorY ?? 1) + ly;
+            if (dstLocal)
+                [bx, by] = applyM(parentWorld(owner), bx, by);
+        }
+        if (clampLocal)
+            [bx, by] = applyM(invM(parentWorld(owner)), bx, by);
+        if (p.max && bx > p.maxValue)
+            bx = p.maxValue;
+        if (p.min && bx < p.minValue)
+            bx = p.minValue;
+        if (p.maxY && by > p.maxValueY)
+            by = p.maxValueY;
+        if (p.minY && by < p.minValueY)
+            by = p.minValueY;
+        if (clampLocal)
+            [bx, by] = applyM(parentWorld(owner), bx, by);
+        const W = [...A];
+        W[4] = A[4] * ti + bx * t;
+        W[5] = A[5] * ti + by * t;
+        pose.world.set(owner.index, W);
+        return;
+    }
+    const ca = decompose(A);
+    let cb = { ...ca };
+    if (tgt) {
+        cb = decompose(targetWorld());
+        if (c.type === 'RotationConstraint') {
+            if (!p.doesCopy)
+                cb.rotation = dstLocal ? 0 : ca.rotation;
+            else {
+                cb.rotation *= p.copyFactor ?? 1;
+                if (p.offset)
+                    cb.rotation += own.rotation || 0;
+            }
+        }
+        else {
+            if (!p.doesCopy)
+                cb.scaleX = dstLocal ? 1 : ca.scaleX;
+            else {
+                cb.scaleX *= p.copyFactor ?? 1;
+                if (p.offset)
+                    cb.scaleX *= own.scaleX ?? 1;
+            }
+            if (!p.doesCopyY)
+                cb.scaleY = dstLocal ? 1 : ca.scaleY;
+            else {
+                cb.scaleY *= p.copyFactorY ?? 1;
+                if (p.offset)
+                    cb.scaleY *= own.scaleY ?? 1;
+            }
+        }
+        if (dstLocal)
+            cb = decompose(mul(parentWorld(owner), compose(cb)));
+    }
+    if (clampLocal)
+        cb = decompose(mul(invM(parentWorld(owner)), compose(cb)));
+    if (c.type === 'RotationConstraint') {
+        if (p.min || p.max) {
+            const center = p.min && p.max ? (p.minValue + p.maxValue) / 2 : p.max ? p.maxValue : p.minValue;
+            let r = cb.rotation - center;
+            r -= Math.PI * 2 * Math.floor((r + Math.PI) / (Math.PI * 2));
+            r += center;
+            if (p.max && r > p.maxValue)
+                r = p.maxValue;
+            if (p.min && r < p.minValue)
+                r = p.minValue;
+            cb.rotation = r;
+        }
+    }
+    else {
+        if (p.max && cb.scaleX > p.maxValue)
+            cb.scaleX = p.maxValue;
+        if (p.min && cb.scaleX < p.minValue)
+            cb.scaleX = p.minValue;
+        if (p.maxY && cb.scaleY > p.maxValueY)
+            cb.scaleY = p.maxValueY;
+        if (p.minY && cb.scaleY < p.minValueY)
+            cb.scaleY = p.minValueY;
+    }
+    if (clampLocal)
+        cb = decompose(mul(parentWorld(owner), compose(cb)));
+    const out = { ...ca };
+    if (c.type === 'RotationConstraint') {
+        const [a0, d] = wrapAngle(ca.rotation, cb.rotation);
+        out.rotation = a0 + d * t;
+    }
+    else {
+        out.scaleX = ca.scaleX * ti + cb.scaleX * t;
+        out.scaleY = ca.scaleY * ti + cb.scaleY * t;
+    }
+    pose.world.set(owner.index, compose(out));
+}
+/** Components whose transform a constraint changes (IK chain bones and constraint owners). */
+const constrained = (s) => new Set(s.constraints.flatMap(k => (k.chain || [k.owner]).map(b => b.index)));
+const invM = (m) => { const d = m[0] * m[3] - m[1] * m[2] || 1e-12; return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[3] * m[4]) / d, (m[1] * m[4] - m[0] * m[5]) / d]; };
+const mapPts = (pts, m) => pts.map(p => { const [x, y] = applyM(m, p.x, p.y), [ix, iy] = applyM(m, p.in_x, p.in_y), [ox, oy] = applyM(m, p.out_x, p.out_y); return { ...p, x, y, in_x: ix, in_y: iy, out_x: ox, out_y: oy }; });
+const descendants = (s, o, out = []) => { out.push(o); for (const c of s.children.get(o.index) || [])
+    descendants(s, c, out); return out; };
+/** A clipping shape's outline in its parent node's space at a frame. */
+function clipOutline(s, clip, node, anim, frame) {
+    const src = s.byIndex[clip.props.sourceId];
+    if (!src)
+        return [];
+    const toNode = invM(worldOf(s, node, anim, frame));
+    const pts = [];
+    for (const sh of descendants(s, src).filter(c => c.type === 'Shape')) {
+        const m = mul(toNode, worldOf(s, sh, anim, frame));
+        for (const c of shapeContours(s, sh, anim, frame, clip.props.fillRule === 1))
+            pts.push(...mapPts(c, m));
+    }
+    return pts;
+}
+function emitClips(ctx, node, g) {
+    const s = ctx.s;
+    const clips = (s.children.get(node.index) || []).filter(k => k.type === 'ClippingShape' && k.props.isVisible !== false);
+    clips.forEach((clip, k) => {
+        const pts = clipOutline(s, clip, node, null, 0);
+        if (!pts.length)
+            return;
+        const b = bbox(pts);
+        const id = `${ctx.pre}${node.index}_clip${k}`;
+        const o = {
+            id, name: clip.props.name || 'Clip', type: 'Shape', parentId: g.id, transform: baseTransform(),
+            geometry: { type: 'Path', points: pts, is_closed: true, width: dim(b.w), height: dim(b.h), baseWidth: dim(b.w), baseHeight: dim(b.h), isMask: true },
+            style: { fill: { type: 'Solid', color: '#000000', opacity: 0 }, stroke: noStroke() }, isVisible: true,
+        };
+        // Clips shape everything after them in the Group, so they go first.
+        g.children.unshift(id);
+        ctx.objects.push(o);
+        const src = s.byIndex[clip.props.sourceId];
+        const involved = new Set();
+        if (src)
+            descendants(s, src).forEach(c => { involved.add(c.index); for (let p = c, guard = 0; p && guard < 64; p = p.index === 0 ? null : s.byIndex[p.props.parentId ?? 0] || null, guard++)
+                involved.add(p.index); });
+        for (let p = node, guard = 0; p && guard < 64; p = p.index === 0 ? null : s.byIndex[p.props.parentId ?? 0] || null, guard++)
+            involved.add(p.index);
+        for (const a of s.animations) {
+            if (![...involved].some(i => a.keyed.has(i))) {
+                if (!src || !descendants(s, src).some(c => (s.children.get(c.index) || []).some(v => a.keyed.has(v.index))))
+                    continue;
+            }
+            const frames = [];
+            for (let f = a.start; f <= a.end + 1e-6; f++)
+                frames.push(Math.min(f, a.end));
+            const per = frames.map(f => clipOutline(s, clip, node, a, f));
+            if (!per.every(q => q.length === pts.length)) {
+                ctx.warnings.add('A clipping path changes its vertex count while animating');
+                continue;
+            }
+            const tracks = ctx.tracksByAnim.get(a);
+            ['x', 'y', 'in_x', 'in_y', 'out_x', 'out_y'].forEach(fd => pts.forEach((_, j) => {
+                const series = per.map(q => q[j][fd]);
+                if (series.every(v => Math.abs(v - series[0]) < 1e-4))
+                    return;
+                tracks.push({ id: `t_${id}_${j}_${fd}`, object_id: id, property: `geometry.points.${j}.${fd}`, keyframes: frames.map((f, i) => ({ id: `k_${id}_${j}_${fd}_${i}`, time: r3((f - a.start) / a.fps), value: r3(series[i]), easing: 'linear' })) });
+            }));
+        }
+    });
+}
+const mimeOf = (b) => (b[0] === 0x89 ? 'image/png' : b[0] === 0xff ? 'image/jpeg' : b[0] === 0x52 && b[8] === 0x57 ? 'image/webp' : 'image/png');
+const b64 = (b) => { let s = ''; for (let i = 0; i < b.length; i += 0x8000)
+    s += String.fromCharCode(...b.subarray(i, i + 0x8000)); return typeof btoa === 'function' ? btoa(s) : globalThis.Buffer.from(b).toString('base64'); };
+function emitImage(ctx, img, host) {
+    const assets = ctx.file.assets;
+    const entry = assets[img.props.assetId];
+    if (!entry) {
+        ctx.warnings.add('An image references a missing asset');
+        return;
+    }
+    if (!entry.bytes) {
+        ctx.warnings.add(`Image "${entry.asset.props.name || 'image'}" is not embedded in the .riv (hosted or referenced assets are not downloaded)`);
+        return;
+    }
+    const w = entry.asset.props.width || 0, h = entry.asset.props.height || 0;
+    if (!(w > 0 && h > 0)) {
+        ctx.warnings.add('An image asset has no size');
+        return;
+    }
+    if ((ctx.s.children.get(img.index) || []).some(k => k.type === 'Mesh'))
+        ctx.warnings.add('Image meshes (deformation) are not imported');
+    const src = `data:${mimeOf(entry.bytes)};base64,${b64(entry.bytes)}`;
+    const id = `${ctx.pre}${img.index}_img`;
+    const o = {
+        id, name: img.props.name || 'Image', type: 'Shape', parentId: host.id,
+        transform: { ...baseTransform(), x: r3(w / 2 - (img.props.originX ?? 0.5) * w), y: r3(h / 2 - (img.props.originY ?? 0.5) * h) },
+        geometry: { type: 'Image', src, originalSrc: src, width: w, height: h }, style: { fill: { type: 'None', opacity: 0 } }, isVisible: true,
+    };
+    host.children.push(id);
+    ctx.objects.push(o);
+}
+function group(ctx, id, name, parent) {
+    const g = {
+        id, name, type: 'Group', transform: baseTransform(), width: 1, height: 1,
+        geometry: { type: 'Rectangle', width: 1, height: 1, corner_radius: 0 },
+        style: { fill: { type: 'None', opacity: 0 }, stroke: noStroke() },
+        clipContent: false, isVisible: true, isLocked: false, isExpanded: false, children: [],
+    };
+    if (parent) {
+        g.parentId = parent.id;
+        parent.children.push(id);
+    }
+    ctx.objects.push(g);
+    return g;
+}
+/** World scale (geometric mean of |sx|, |sy|) of a component at a frame, for screen-space strokes. */
+function worldScale(s, o, anim, frame) {
+    let k = 1;
+    for (let c = o, guard = 0; c && c.index !== 0 && guard < 64; c = s.byIndex[c.props.parentId ?? 0] || null, guard++) {
+        if (!isA(c.type, 'TransformComponent'))
+            continue;
+        const p = propsAt(c, anim, frame);
+        k *= Math.sqrt(Math.abs((p.scaleX ?? 1) * (p.scaleY ?? 1)));
+    }
+    return k;
+}
+/** Does a skinned path move in this animation (any tendon bone or its ancestors keyed, or the shape itself)? */
+function skinMoves(s, a, path) {
+    const skin = (s.children.get(path.index) || []).find(k => k.type === 'Skin');
+    if (!skin)
+        return false;
+    const ids = new Set();
+    const up = (o) => { for (let c = o, g = 0; c && g < 64; c = c.index === 0 ? null : s.byIndex[c.props.parentId ?? 0] || null, g++)
+        ids.add(c.index); };
+    for (const t of (s.children.get(skin.index) || []).filter(k => k.type === 'Tendon'))
+        up(s.byIndex[t.props.boneId]);
+    up(path);
+    const ik = constrained(s);
+    if (a.keyed.size && [...ids].some(i => ik.has(i)))
+        return true;
+    return [...ids].some(i => a.keyed.has(i));
+}
+const ancestorsAnimated = (s, o, prop) => s.animations.some(a => {
+    for (let c = o, guard = 0; c && guard < 64; c = c.index === 0 ? null : s.byIndex[c.props.parentId ?? 0] || null, guard++) {
+        const m = a.keyed.get(c.index);
+        if (m && prop.some(p => m.has(p)))
+            return true;
+    }
+    return false;
+});
+function paintFill(paint, s, anim, frame, box) {
+    const kids = s.children.get(paint.index) || [];
+    const mutator = kids.find(k => k.type === 'SolidColor' || k.type === 'LinearGradient' || k.type === 'RadialGradient');
+    if (!mutator)
+        return { type: 'Solid', color: '#000000', opacity: 0 };
+    const mp = propsAt(mutator, anim, frame);
+    if (mutator.type === 'SolidColor') {
+        const [c, a] = argb(mp.colorValue ?? 0xff747474);
+        return { type: 'Solid', color: c, opacity: a };
+    }
+    const op = mp.opacity ?? 1;
+    const stops = (s.children.get(mutator.index) || []).filter(k => k.type === 'GradientStop').map(k => {
+        const q = propsAt(k, anim, frame);
+        const [c, a] = argb(q.colorValue ?? 0xffffffff);
+        return { offset: r3(q.position ?? 0), color: c, opacity: r3(a * op) };
+    }).sort((a, b) => a.offset - b.offset);
+    // Gradient points are in the shape's space; normalise around the object origin.
+    const w = box.w || 1, h = box.h || 1;
+    const nx = (x) => r3((x - box.cx + w / 2) / w), ny = (y) => r3((y - box.cy + h / 2) / h);
+    if (mutator.type === 'RadialGradient')
+        return { type: 'RadialGradient', center: [nx(mp.startX || 0), ny(mp.startY || 0)], radius: r3(Math.hypot((mp.endX || 0) - (mp.startX || 0), (mp.endY || 0) - (mp.startY || 0)) / Math.max(w, h)), stops, opacity: 1 };
+    return { type: 'LinearGradient', start: [nx(mp.startX || 0), ny(mp.startY || 0)], end: [nx(mp.endX || 0), ny(mp.endY || 0)], stops, opacity: 1 };
+}
+// ---------------------------------------------------------------- text
+const fontCache = new WeakMap();
+function fontFor(ctx, assetIndex) {
+    if (assetIndex === undefined)
+        return null;
+    let m = fontCache.get(ctx.file);
+    if (!m) {
+        m = new Map();
+        fontCache.set(ctx.file, m);
+    }
+    if (!m.has(assetIndex)) {
+        const a = ctx.file.assets[assetIndex];
+        let f = null;
+        try {
+            f = a?.bytes ? parseFont(a.bytes) : null;
+        }
+        catch {
+            f = null;
+        }
+        m.set(assetIndex, f);
+    }
+    return m.get(assetIndex);
+}
+/** One loadable family name: drop size/weight words a static instance carries in its name. */
+const familyOf = (f) => {
+    const name = (f?.family || 'Inter').replace(/\s+\d+pt$/i, '').replace(/\s+(Thin|ExtraLight|Extra Light|UltraLight|Light|Regular|Medium|SemiBold|Semi Bold|DemiBold|Bold|ExtraBold|Extra Bold|UltraBold|Black|Heavy|Italic)$/i, '').trim();
+    return /^[a-zA-Z0-9\s_-]+$/.test(name) ? name : 'Inter';
+};
+/** Rive line metrics for a run: natural height is ascent + descent (no line gap); custom line height is px. */
+const runAscent = (r) => (r.font ? r.font.ascent : 0.97) * r.size;
+const runLineHeight = (r) => (r.lineHeight >= 0 ? r.lineHeight : ((r.font ? r.font.ascent + r.font.descent : 1.21) * r.size));
+/** Greedy line breaking with the font's advances; returns each line's width and height. */
+function layoutLines(runs, maxWidth, wrap) {
+    const chars = [];
+    for (const r of runs)
+        for (const c of r.text) {
+            const cp = c.codePointAt(0);
+            const adv = r.font ? r.font.advance(cp) : 0.55;
+            chars.push({ c, w: (adv || (r.font ? r.font.advance(0x20) || 0.3 : 0.55)) * r.size + r.letterSpacing, r });
+        }
+    const lines = [];
+    let start = 0;
+    const finish = (from, to) => {
+        let end = to;
+        while (end > from && /\s/.test(chars[end - 1].c))
+            end--;
+        let w = 0;
+        for (let i = from; i < end; i++)
+            w += chars[i].w;
+        let h = 0;
+        for (let i = from; i < Math.max(to, from + 1) && i < chars.length; i++)
+            h = Math.max(h, runLineHeight(chars[i].r));
+        if (!h)
+            h = runs.length ? runLineHeight(runs[runs.length - 1]) : 0;
+        lines.push({ w, h });
+    };
+    let w = 0, lastBreak = -1;
+    for (let i = 0; i < chars.length; i++) {
+        const ch = chars[i];
+        if (ch.c === '\n') {
+            finish(start, i);
+            start = i + 1;
+            w = 0;
+            lastBreak = -1;
+            continue;
+        }
+        w += ch.w;
+        if (/\s/.test(ch.c)) {
+            lastBreak = i + 1;
+            continue;
+        }
+        if (wrap && maxWidth > 0 && w > maxWidth && i > start) {
+            const at = lastBreak > start ? lastBreak : i;
+            finish(start, at);
+            start = at;
+            w = 0;
+            lastBreak = -1;
+            for (let k = start; k <= i; k++)
+                w += chars[k].w;
+        }
+    }
+    finish(start, chars.length);
+    return lines;
+}
+const TEXT_LEADING = { 'Inter': 0.35, 'Roboto': 0.45, 'Montserrat': 0.40, 'Outfit': 0.35, 'Open Sans': 0.40, 'Poppins': 0.45, 'Playfair Display': 0.35, 'Lora': 0.40, 'Lato': 0.35, 'Bebas Neue': 0.45, 'Oswald': 0.40 };
+/**
+ * Rive Text -> a native Text object inside the Text's group. Rive lays lines out
+ * from the box's top-left and shifts the box by -origin x size; the runtime centres
+ * the box on the object, so the object sits at the box centre.
+ */
+function textLayout(ctx, text) {
+    const s = ctx.s;
+    const p = text.props;
+    const runs = [];
+    for (const k of s.children.get(text.index) || []) {
+        if (k.type !== 'TextValueRun')
+            continue;
+        const style = s.byIndex[k.props.styleId ?? -1];
+        if (!style || !isA(style.type, 'TextStyle'))
+            continue;
+        const sp = style.props;
+        const font = fontFor(ctx, sp.fontAssetId);
+        const wght = (s.children.get(style.index) || []).find(a => a.type === 'TextStyleAxis' && a.props.tag === 0x77676874);
+        runs.push({ text: String(k.props.text ?? ''), style, size: sp.fontSize ?? 12, lineHeight: sp.lineHeight ?? -1, letterSpacing: sp.letterSpacing ?? 0, font, family: familyOf(font), weight: Math.round(wght ? wght.props.axisValue : font?.weight ?? 400), italic: !!font?.italic });
+    }
+    const full = runs.map(r => r.text).join('');
+    if (!runs.length || !full)
+        return null;
+    const sizing = p.sizingValue ?? 0; // 0 auto width, 1 auto height, 2 fixed
+    const wrap = sizing !== 0 && (p.wrapValue ?? 0) === 0;
+    const lines = layoutLines(runs, p.width || 0, wrap);
+    const contentW = Math.max(0, ...lines.map(l => l.w));
+    const contentH = lines.reduce((a, l) => a + l.h, 0);
+    const W = sizing === 0 ? contentW : p.width || contentW;
+    const H = sizing === 2 ? p.height || contentH : contentH;
+    return { runs, full, sizing, wrap, W, H };
+}
+function emitText(ctx, text, g) {
+    const s = ctx.s;
+    const p = text.props;
+    const lay = textLayout(ctx, text);
+    if (!lay)
+        return;
+    const { runs, full, sizing, wrap, W, H } = lay;
+    if (runs.some(r => !r.font))
+        ctx.warnings.add('Some text uses a font that is not embedded; Inter is used instead');
+    if ((s.children.get(text.index) || []).some(k => k.type === 'TextModifierGroup'))
+        ctx.warnings.add('Text modifiers (per-glyph animation) are not imported');
+    // Main style: the one covering most characters; other runs become segments.
+    const count = new Map();
+    runs.forEach(r => count.set(r.style, (count.get(r.style) || 0) + r.text.length));
+    const main = runs.reduce((a, b) => ((count.get(b.style) || 0) > (count.get(a.style) || 0) ? b : a));
+    const paints = (r) => (s.children.get(r.style.index) || []).filter(k => isA(k.type, 'ShapePaint') && k.props.isVisible !== false);
+    const box = { cx: 0, cy: 0, w: W || 1, h: H || 1 };
+    const fillOf = (r) => { const f = paints(r).find(k => k.type === 'Fill'); return f ? paintFill(f, s, null, 0, box) : { type: 'Solid', color: '#000000', opacity: 0 }; };
+    const strokePaint = paints(main).find(k => k.type === 'Stroke');
+    const align = ['left', 'right', 'center'][p.alignValue ?? 0] || 'left';
+    // Auto-width text gets headroom so the browser's own metrics don't wrap it; the box grows away from its aligned edge.
+    const slack = sizing === 0 || !wrap ? Math.ceil(main.size * 0.3) + 2 : 0;
+    const shift = align === 'center' ? 0 : align === 'right' ? -slack / 2 : slack / 2;
+    const lhPx = Math.max(...runs.map(runLineHeight));
+    const maxSize = Math.max(...runs.map(r => r.size));
+    const fam = main.family;
+    const a = main.font ? main.font.ascent : 0.97, d = main.font ? main.font.descent : 0.24;
+    const engineBaseline = (TEXT_LEADING[fam] ?? 0.5) * (lhPx - main.size) + (a / (a + d)) * main.size;
+    const drop = runAscent(main) - engineBaseline;
+    const geometry = {
+        type: 'Text', text: full, width: r3(W + slack), height: r3(H), isPointText: false,
+        fontSize: main.size, fontFamily: fam, fontWeight: main.weight, fontStyle: main.italic ? 'italic' : 'normal',
+        lineHeight: r3(lhPx / maxSize), letterSpacing: main.letterSpacing, textAlign: align,
+    };
+    if (sizing === 2) {
+        geometry.autoHeight = false;
+        geometry.textVerticalAlign = ['top', 'bottom', 'middle'][p.verticalAlignValue ?? 0] || 'top';
+    }
+    if (Math.abs(drop) >= 0.05)
+        geometry.baselineShift = r3(drop);
+    if (p.paragraphSpacing)
+        geometry.paragraphSpacing = p.paragraphSpacing;
+    const key = (r) => JSON.stringify([r.size, r.family, r.weight, r.italic, fillOf(r)]);
+    if (runs.some(r => key(r) !== key(main))) {
+        geometry.enableSegments = true;
+        geometry.segments = runs.map(r => ({ text: r.text, fill: fillOf(r), fontSize: r.size, fontFamily: r.family, fontWeight: r.weight, fontStyle: r.italic ? 'italic' : 'normal' }));
+    }
+    let stroke = noStroke();
+    if (strokePaint) {
+        const sf = paintFill(strokePaint, s, null, 0, box);
+        stroke = { ...noStroke(), isEnabled: true, color: sf.color || sf.stops?.[0]?.color || '#000000', opacity: sf.opacity ?? 1, width: r3(strokePaint.props.thickness ?? 1), lineJoin: ['miter', 'round', 'bevel'][strokePaint.props.join ?? 0] || 'miter', lineCap: ['butt', 'round', 'square'][strokePaint.props.cap ?? 0] || 'butt', alignment: 'center' };
+    }
+    const id = `${g.id}_text`;
+    const o = {
+        id, name: text.props.name || full.slice(0, 24), type: 'Text', parentId: g.id,
+        transform: { ...baseTransform(), x: r3(W * (0.5 - (p.originX ?? 0)) + shift), y: r3(H * (0.5 - (p.originY ?? 0))) },
+        geometry, style: { fill: fillOf(main), stroke }, isVisible: true,
+    };
+    g.children.push(id);
+    ctx.objects.push(o);
+}
+// ---------------------------------------------------------------- nested artboards
+/** Wraps a frame of an animation's local time the way its loop mode does (globalToLocalSeconds). */
+const localFrame = (a, f) => {
+    const len = a.end - a.start;
+    if (len <= 0)
+        return a.start;
+    const loop = a.obj.props.loopValue ?? 0;
+    let t = f - a.start;
+    if (loop === 1)
+        t = ((t % len) + len) % len;
+    else if (loop === 2) {
+        const p = ((t % (2 * len)) + 2 * len) % (2 * len);
+        t = p > len ? 2 * len - p : p;
+    }
+    else
+        t = Math.max(0, Math.min(len, t));
+    return a.start + t;
+};
+/** Prefix every id in converted state machine layers / inputs so nested instances never collide. */
+function prefixMachine(m, pre, label) {
+    const ids = new Map();
+    const re = (id) => { if (!id)
+        return id; if (!ids.has(id))
+        ids.set(id, `${pre}${id}`); return ids.get(id); };
+    for (const i of m.inputs) {
+        i.id = re(i.id);
+        i.name = `${label} · ${i.name}`;
+    }
+    for (const l of m.layers) {
+        l.id = re(l.id);
+        l.name = `${label} · ${l.name}`;
+        l.entryStateId = re(l.entryStateId);
+        for (const st of l.states) {
+            st.id = re(st.id);
+            for (const t of st.transitions || []) {
+                t.id = re(t.id);
+                t.targetStateId = re(t.targetStateId);
+                for (const c of t.conditions || []) {
+                    c.inputId = re(c.inputId);
+                    c.inputName = `${label} · ${c.inputName}`;
+                }
+            }
+        }
+    }
+    return m;
+}
+/**
+ * NestedArtboard: the referenced artboard drawn at the component's transform with
+ * its origin at the component (frameOrigin off). Simple animations and state
+ * machines become layers of their own; remap animations follow the parent timeline.
+ */
+function emitNested(ctx, o, g) {
+    const target = ctx.file.artboards[o.props.artboardId ?? -1];
+    if (!target) {
+        ctx.warnings.add('A nested artboard references a missing artboard');
+        return;
+    }
+    if (ctx.depth >= 5 || target === ctx.s.ab) {
+        ctx.warnings.add('Nested artboards deeper than 5 levels are not imported');
+        return;
+    }
+    const sub = indexScene(target);
+    const pre = `${g.id}_`;
+    const label = o.props.name || target.artboard.props.name || 'Nested';
+    const nestedAnims = (ctx.s.children.get(o.index) || []).filter(k => isA(k.type, 'NestedAnimation'));
+    // Remaps: static ones hold a pose; keyed ones resample the nested timeline at each parent frame.
+    const remapInto = new Map(); // synthetic sub anim -> parent anim
+    const bake = (src, f) => { for (const [objId, props] of src.keyed) {
+        const t = sub.byIndex[objId];
+        if (t)
+            for (const [name, keys] of props)
+                if (keys.length)
+                    t.props[name] = keyedAt(keys, localFrame(src, f));
+    } };
+    for (const n of nestedAnims) {
+        const src = sub.animations[n.props.animationId ?? -1];
+        if (!src)
+            continue;
+        // A paused simple animation still applies its first frame.
+        if (n.type === 'NestedSimpleAnimation' && !n.props.isPlaying && (n.props.mix ?? 1) > 0) {
+            bake(src, src.start);
+            continue;
+        }
+        if (n.type !== 'NestedRemapAnimation')
+            continue;
+        const keyedIn = ctx.s.animations.filter(a => a.keyed.get(n.index)?.get('time')?.length);
+        if (!keyedIn.length) {
+            bake(src, src.start + (n.props.time ?? 0) * (src.end - src.start));
+            continue;
+        }
+        for (const pa of keyedIn) {
+            const timeKeys = pa.keyed.get(n.index).get('time');
+            const keyed = new Map();
+            for (const [objId, props] of src.keyed) {
+                const m = new Map();
+                for (const [name, keys] of props) {
+                    if (!keys.length)
+                        continue;
+                    const out = [];
+                    for (let f = pa.start; f <= pa.end; f++) {
+                        const lf = localFrame(src, src.start + keyedAt(timeKeys, f) * (src.end - src.start));
+                        out.push({ frame: f, value: keyedAt(keys, lf), type: typeof keys[0].value === 'number' ? 1 : 0, interpolator: null, color: keys[0].color });
+                    }
+                    m.set(name, out);
+                }
+                keyed.set(objId, m);
+            }
+            const syn = { obj: src.obj, keyed, fps: pa.fps, start: pa.start, end: pa.end, synthetic: true };
+            sub.animations.push(syn);
+            remapInto.set(syn, pa);
+        }
+    }
+    const sctx = { ...ctx, s: sub, pre, depth: ctx.depth + 1, tracksByAnim: new Map(sub.animations.map(a => [a, []])), rivToExode: new Map() };
+    sub.bounds = boundsHook(sctx);
+    setupLayouts(sctx);
+    let host = g;
+    if (o.type === 'NestedArtboardLeaf') {
+        // Leaf: fit the artboard into its layout parent's box (computeAlignment in renderer.cpp).
+        const par = ctx.s.byIndex[o.props.parentId ?? 0];
+        const T = target.artboard.props, tw = T.width || 1, th = T.height || 1;
+        const content = { x: -(T.originX || 0) * tw, y: -(T.originY || 0) * th, w: tw, h: th };
+        let frame = content;
+        if (par && isA(par.type, 'LayoutComponent')) {
+            const pw = par.props.width || 0, ph = par.props.height || 0;
+            frame = par.index === 0 ? { x: -(par.props.originX || 0) * pw, y: -(par.props.originY || 0) * ph, w: pw, h: ph } : { x: 0, y: 0, w: pw, h: ph };
+        }
+        const fit = o.props.fit ?? 0, ax = o.props.alignmentX ?? 0, ay = o.props.alignmentY ?? 0;
+        let sx = 1, sy = 1;
+        const fx = frame.w / content.w, fy = frame.h / content.h;
+        if (fit === 0) {
+            sx = fx;
+            sy = fy;
+        }
+        else if (fit === 1)
+            sx = sy = Math.min(fx, fy);
+        else if (fit === 2)
+            sx = sy = Math.max(fx, fy);
+        else if (fit === 3)
+            sx = sy = fx;
+        else if (fit === 4)
+            sx = sy = fy;
+        else if (fit === 6)
+            sx = sy = Math.min(1, Math.min(fx, fy));
+        else if (fit === 7)
+            ctx.warnings.add('Layout-fit nested artboards are imported at their authored size');
+        const x = -content.x - content.w / 2 - (ax * content.w) / 2, y = -content.y - content.h / 2 - (ay * content.h) / 2;
+        const tx = frame.x + frame.w / 2 + (ax * frame.w) / 2, ty = frame.y + frame.h / 2 + (ay * frame.h) / 2;
+        host = group(sctx, `${pre}fit`, 'Fit', g);
+        host.transform = { ...host.transform, x: r3(tx + sx * x), y: r3(ty + sy * y), scale_x: r3(sx), scale_y: r3(sy) };
+    }
+    const inner = group(sctx, `${pre}artboard`, target.artboard.props.name || 'Artboard', host);
+    if (target.artboard.props.clip) {
+        const A = target.artboard.props, W = A.width || 0, H = A.height || 0;
+        inner.clipContent = true;
+        inner.width = W;
+        inner.height = H;
+        inner.geometry = { type: 'Rectangle', width: W, height: H, corner_radius: 0 };
+        // The clip box is centred on the group; move the group there and the content back.
+        inner.transform.x = r3(W / 2 - (A.originX || 0) * W);
+        inner.transform.y = r3(H / 2 - (A.originY || 0) * H);
+        const content = group(sctx, `${pre}content`, 'Content', inner);
+        content.transform.x = -inner.transform.x;
+        content.transform.y = -inner.transform.y;
+        emitArtboardContent(sctx, content, false);
+    }
+    else
+        emitArtboardContent(sctx, inner, false);
+    for (const [syn, pa] of remapInto)
+        ctx.tracksByAnim.get(pa)?.push(...(sctx.tracksByAnim.get(syn) || []));
+    const playing = nestedAnims.filter(k => (k.type === 'NestedSimpleAnimation' && k.props.isPlaying) || k.type === 'NestedStateMachine');
+    if (!playing.length || o.props.isPaused)
+        return;
+    const { animations, ids } = buildAnimations(sctx);
+    const speed = o.props.speed ?? 1;
+    if (speed !== 1 && speed > 0)
+        for (const a of animations) {
+            a.tracks.forEach((t) => t.keyframes.forEach((k) => (k.time = r3(k.time / speed))));
+            a.duration = r3(a.duration / speed);
+        }
+    const used = new Set();
+    playing.forEach((n, k) => {
+        if (n.type === 'NestedSimpleAnimation') {
+            const id = ids[n.props.animationId ?? -1];
+            const a = animations.find(x => x.id === id);
+            if (!a)
+                return;
+            const sp = n.props.speed ?? 1;
+            if (sp !== 1 && sp > 0) {
+                a.tracks.forEach((t) => t.keyframes.forEach((q) => (q.time = r3(q.time / sp))));
+                a.duration = r3(a.duration / sp);
+            }
+            used.add(id);
+            const lid = `${pre}layer_${k}`;
+            ctx.out.layers.push({ id: lid, name: `${label} · ${a.name}`, entryStateId: `${lid}_play`, states: [{ id: `${lid}_play`, name: a.name, animationId: id, loop: a.loop, transitions: [] }] });
+        }
+        else {
+            const sm = sub.machines[n.props.animationId ?? -1];
+            if (!sm)
+                return;
+            const m = prefixMachine(stateMachine(sctx, sm, ids), `${pre}${k}_`, label);
+            m.layers.forEach((l) => l.states.forEach((st) => st.animationId && used.add(st.animationId)));
+            ctx.out.layers.push(...m.layers);
+            ctx.out.inputs.push(...m.inputs);
+        }
+    });
+    ctx.out.animations.push(...animations.filter(a => used.has(a.id)));
+}
+// Rive feather strength -> runtime blur px (calibrated against the Rive renderer).
+const RIVE_FEATHER = 0.5;
+const BLEND = { 3: 'source-over', 14: 'screen', 15: 'overlay', 16: 'darken', 17: 'lighten', 18: 'color-dodge', 19: 'color-burn', 20: 'hard-light', 21: 'soft-light', 22: 'difference', 23: 'exclusion', 24: 'multiply', 25: 'hue', 26: 'saturation', 27: 'color', 28: 'luminosity' };
+function emitShape(ctx, shape, host) {
+    const s = ctx.s;
+    const kids = s.children.get(shape.index) || [];
+    const paints = kids.filter(k => isA(k.type, 'ShapePaint') && k.props.isVisible !== false);
+    const anims = s.animations;
+    const pathMoves = (a, k) => a.keyed.has(k.index) || (s.children.get(k.index) || []).some(v => a.keyed.has(v.index)) || skinMoves(s, a, k);
+    const geoAnimated = anims.some(a => kids.some(k => isA(k.type, 'Path') && pathMoves(a, k)));
+    for (const paint of paints) {
+        const isStroke = paint.type === 'Stroke';
+        const eo = !isStroke && paint.props.fillRule === 1;
+        const contours = shapeContours(s, shape, null, 0, eo);
+        const pts = contours.flat();
+        if (!pts.length)
+            continue;
+        const b = bbox(pts);
+        const id = `${ctx.pre}${shape.index}_p${paint.index}`;
+        // Width/height = point box, so the runtime draws points as authored.
+        const geometry = { type: 'Path', points: pts, is_closed: pts.some(p => p.closePath), width: dim(b.w), height: dim(b.h), baseWidth: dim(b.w), baseHeight: dim(b.h), fillRule: 'nonzero' };
+        if (!geoAnimated)
+            geometry.data = ptsToData(pts);
+        const box = { cx: 0, cy: 0, w: b.w, h: b.h };
+        const fill = paintFill(paint, s, null, 0, box);
+        const o = { id, name: `${shape.props.name || 'Shape'} · ${paint.props.name || (isStroke ? 'Stroke' : 'Fill')}`, type: 'Shape', parentId: host.id, transform: baseTransform(), geometry, isVisible: true, isLocked: false };
+        if (!isStroke)
+            o.style = { fill, stroke: noStroke() };
+        else {
+            const scale = paint.props.transformAffectsStroke === false ? 1 : worldScale(s, shape, null, 0);
+            const stroke = {
+                width: r3((paint.props.thickness ?? 1) * scale), opacity: fill.type === 'Solid' ? fill.opacity : 1, alignment: 'center',
+                lineCap: paint.props.cap === 1 ? 'round' : paint.props.cap === 2 ? 'square' : 'butt',
+                lineJoin: paint.props.join === 1 ? 'round' : paint.props.join === 2 ? 'bevel' : 'miter',
+                isEnabled: true, color: fill.type === 'Solid' ? fill.color : (fill.stops?.[0]?.color || '#000000'),
+                ...(fill.type !== 'Solid' ? { fill } : {}),
+            };
+            const trim = (s.children.get(paint.index) || []).find(k => k.type === 'TrimPath');
+            if (trim) {
+                const t = trim.props;
+                Object.assign(stroke, { trimStart: r3(Math.min(t.start ?? 0, t.end ?? 1)), trimEnd: r3(Math.max(t.start ?? 0, t.end ?? 1)), trimOffset: r3((((t.offset ?? 0) % 1) + 1) % 1) });
+                if ((t.modeValue ?? 1) === 2)
+                    ctx.warnings.add('Sequential trim paths are imported as synchronized');
+            }
+            if ((s.children.get(paint.index) || []).some(k => k.type === 'DashPath' || k.type === 'Dash'))
+                ctx.warnings.add('Dashed strokes are not imported');
+            o.style = { fill: { type: 'Solid', color: '#000000', opacity: 0 }, stroke };
+        }
+        const blend = BLEND[shape.props.blendModeValue ?? 3];
+        if (blend && blend !== 'source-over')
+            o.style.compositeOperation = blend;
+        const feather = (s.children.get(paint.index) || []).find(k => k.type === 'Feather');
+        if (feather) {
+            const fp = feather.props;
+            const blur = (fp.strength ?? 12) * RIVE_FEATHER;
+            if (fp.inner) {
+                // Inner feather: the paint shows only as a soft band inside the edge.
+                const c = o.style.fill.type === 'Solid' ? o.style.fill : { color: '#000000', opacity: 1 };
+                o.style.effects = [{ type: 'InnerShadow', isEnabled: true, color: c.color, opacity: c.opacity, blur: r3(blur), offsetX: r3(fp.offsetX || 0), offsetY: r3(fp.offsetY || 0), spread: 0 }];
+                o.style.fill = { type: 'Solid', color: '#000000', opacity: 0 };
+                if (!(blur > 0))
+                    o.isVisible = false;
+            }
+            else if (blur > 0)
+                o.style.blur = { amount: r3(blur) };
+        }
+        host.children.push(id);
+        ctx.objects.push(o);
+        ctx.rivToExode.set(paint.index, id);
+        // Animation: geometry, paint colour, stroke width/trim.
+        for (const a of anims) {
+            const tracks = ctx.tracksByAnim.get(a);
+            const frames = [];
+            for (let f = a.start; f <= a.end + 1e-6; f++)
+                frames.push(Math.min(f, a.end));
+            const sec = (f) => r3((f - a.start) / a.fps);
+            const sample = (prop, fn, tol = 0.01) => {
+                const keys = frames.map(f => ({ time: sec(f), value: fn(f), easing: 'linear' }));
+                if (keys.every(k => k.value === keys[0].value))
+                    return;
+                const kept = keys.filter((k, i) => i === 0 || i === keys.length - 1 || typeof k.value !== 'number' || Math.abs((keys[i - 1].value + keys[i + 1].value) / 2 - k.value) > tol || k.value !== keys[i - 1].value);
+                tracks.push({ id: `t_${id}_${prop.replace(/\W+/g, '_')}`, object_id: id, property: prop, keyframes: kept.map((k, i) => ({ id: `k_${id}_${prop.replace(/\W+/g, '_')}_${i}`, ...k, value: typeof k.value === 'number' ? r3(k.value) : k.value })) });
+            };
+            if (geoAnimated && kids.some(k => isA(k.type, 'Path') && pathMoves(a, k))) {
+                const per = frames.map(f => shapeContours(s, shape, a, f, eo).flat());
+                if (per.every(p => p.length === pts.length)) {
+                    ['x', 'y', 'in_x', 'in_y', 'out_x', 'out_y'].forEach(fd => pts.forEach((_, j) => sample(`geometry.points.${j}.${fd}`, f => per[frames.indexOf(f)][j][fd], 0.05)));
+                }
+                else
+                    ctx.warnings.add('A path changes its vertex count while animating; it is imported at its first frame');
+            }
+            const mutator = (s.children.get(paint.index) || []).find(k => k.type === 'SolidColor' || k.type === 'LinearGradient' || k.type === 'RadialGradient');
+            if (mutator && mutator.type === 'SolidColor' && a.keyed.get(mutator.index)?.has('colorValue')) {
+                const base = isStroke ? 'style.stroke' : 'style.fill';
+                sample(`${base}.color`, f => argb(propsAt(mutator, a, f).colorValue)[0]);
+                sample(`${base}.opacity`, f => argb(propsAt(mutator, a, f).colorValue)[1], 0.002);
+            }
+            else if (mutator && mutator.type !== 'SolidColor' && (a.keyed.has(mutator.index) || (s.children.get(mutator.index) || []).some(k => a.keyed.has(k.index)))) {
+                const base = isStroke ? 'style.stroke.fill' : 'style.fill';
+                const first = paintFill(paint, s, a, a.start, box);
+                first.stops.forEach((_, j) => {
+                    sample(`${base}.stops.${j}.color`, f => paintFill(paint, s, a, f, box).stops[j]?.color);
+                    sample(`${base}.stops.${j}.opacity`, f => paintFill(paint, s, a, f, box).stops[j]?.opacity, 0.002);
+                    sample(`${base}.stops.${j}.offset`, f => paintFill(paint, s, a, f, box).stops[j]?.offset, 0.002);
+                });
+                (first.type === 'RadialGradient' ? [['center', 0], ['center', 1]] : [['start', 0], ['start', 1], ['end', 0], ['end', 1]]).forEach(([k, d]) => sample(`${base}.${k}.${d}`, f => paintFill(paint, s, a, f, box)[k][d], 0.002));
+            }
+            if (isStroke) {
+                const scaleMoves = paint.props.transformAffectsStroke !== false && ancestorsAnimated(s, shape, ['scaleX', 'scaleY']);
+                if (a.keyed.get(paint.index)?.has('thickness') || scaleMoves)
+                    sample('style.stroke.width', f => (propsAt(paint, a, f).thickness ?? 1) * (paint.props.transformAffectsStroke === false ? 1 : worldScale(s, shape, a, f)), 0.02);
+                const trim = (s.children.get(paint.index) || []).find(k => k.type === 'TrimPath');
+                if (trim && a.keyed.has(trim.index)) {
+                    sample('style.stroke.trimStart', f => { const t = propsAt(trim, a, f); return Math.min(t.start ?? 0, t.end ?? 1); }, 0.002);
+                    sample('style.stroke.trimEnd', f => { const t = propsAt(trim, a, f); return Math.max(t.start ?? 0, t.end ?? 1); }, 0.002);
+                    sample('style.stroke.trimOffset', f => { const t = propsAt(trim, a, f); return (((t.offset ?? 0) % 1) + 1) % 1; }, 0.002);
+                }
+            }
+            if (a.keyed.get(paint.index)?.has('isVisible'))
+                sample('visible', f => propsAt(paint, a, f).isVisible !== false);
+        }
+    }
+}
+/** Local transform of a constrained component (its world under its parent's world), decomposed. */
+function localPose(s, o, anim, frame) {
+    const parent = s.byIndex[o.props.parentId ?? 0];
+    const pw = parent && parent.index !== 0 && isA(parent.type, 'TransformComponent') ? worldOf(s, parent, anim, frame) : [1, 0, 0, 1, 0, 0];
+    return decompose(mul(invM(pw), worldOf(s, o, anim, frame)));
+}
+/** Constraint-driven transforms, sampled per frame wherever the solve moves them. */
+function constraintTracks(ctx, o, id) {
+    const s = ctx.s;
+    for (const a of s.animations) {
+        if (!a.keyed.size)
+            continue;
+        const poses = [];
+        for (let f = a.start; f <= a.end; f++)
+            poses.push(localPose(s, o, a, f));
+        const chans = [['x', t => t.x], ['y', t => t.y], ['rotation', t => t.rotation * DEG], ['scale_x', t => t.scaleX], ['scale_y', t => t.scaleY]];
+        for (const [prop, get] of chans) {
+            const vals = poses.map(get);
+            // Unwrap so a tween never spins the long way round.
+            if (prop === 'rotation')
+                for (let i = 1; i < vals.length; i++)
+                    while (Math.abs(vals[i] - vals[i - 1]) > 180)
+                        vals[i] -= Math.sign(vals[i] - vals[i - 1]) * 360;
+            if (Math.max(...vals) - Math.min(...vals) < (prop.startsWith('scale') ? 0.001 : 0.05))
+                continue;
+            const kf = vals.map((v, i) => ({ id: `k_${id}_c${prop}_${i}`, time: r3(i / a.fps), value: r3(v), easing: 'linear' }));
+            ctx.tracksByAnim.get(a).push({ id: `t_${id}_${prop}`, object_id: id, property: prop, keyframes: kf });
+        }
+    }
+}
+/** Native keyframes for an affine-mapped transform property; Rive easing lives on the starting key. */
+function transformTracks(ctx, o, id) {
+    if (constrained(ctx.s).has(o.index))
+        constraintTracks(ctx, o, id);
+    for (const a of ctx.s.animations) {
+        const m = a.keyed.get(o.index);
+        if (!m)
+            continue;
+        const tracks = ctx.tracksByAnim.get(a);
+        const map = [['x', 'x', v => v], ['y', 'y', v => v], ['rotation', 'rotation', v => v * DEG], ['scaleX', 'scale_x', v => v], ['scaleY', 'scale_y', v => v], ['opacity', 'opacity', v => Math.max(0, Math.min(1, v))]];
+        for (const [rive, ex, fn] of map) {
+            if (rive !== 'opacity' && constrained(ctx.s).has(o.index))
+                continue;
+            const keys = m.get(rive);
+            if (!keys?.length)
+                continue;
+            const easingOf = (k) => {
+                if (k.type === 0)
+                    return 'StepEnd';
+                const it = k.interpolator;
+                if (k.type === 2 && it && (it.type === 'CubicEaseInterpolator' || it.type === 'CubicValueInterpolator'))
+                    return `cubic-bezier(${r3(it.props.x1 ?? 0.42)},${r3(it.props.y1 ?? 0)},${r3(it.props.x2 ?? 0.58)},${r3(it.props.y2 ?? 1)})`;
+                if (it && it.type === 'ElasticInterpolator')
+                    return null;
+                return 'linear';
+            };
+            const sec = (f) => r3((f - a.start) / a.fps);
+            let out;
+            if (keys.every(k => easingOf(k) !== null)) {
+                out = keys.map((k, i) => ({ time: sec(k.frame), value: r3(fn(k.value)), easing: i < keys.length - 1 ? easingOf(k) : 'linear' }));
+            }
+            else {
+                out = [];
+                for (let f = a.start; f <= a.end; f++)
+                    out.push({ time: sec(f), value: r3(fn(keyedAt(keys, f))), easing: 'linear' });
+            }
+            tracks.push({ id: `t_${id}_${ex}`, object_id: id, property: ex, keyframes: out.map((k, i) => ({ id: `k_${id}_${ex}_${i}`, ...k })) });
+        }
+    }
+}
+function emitComponent(ctx, o, parent) {
+    const s = ctx.s;
+    if (!isA(o.type, 'TransformComponent') && o.type !== 'Artboard')
+        return;
+    if (o.type === 'Artboard')
+        return;
+    const p = localProps(s, o, null, 0);
+    const id = `${ctx.pre}${o.index}`;
+    const g = group(ctx, id, o.props.name || o.type, parent);
+    g.transform = { ...baseTransform(), x: r3(p.x || 0), y: r3(p.y || 0), rotation: r3((p.rotation || 0) * DEG), scale_x: r3(p.scaleX ?? 1), scale_y: r3(p.scaleY ?? 1), opacity: r3(Math.max(0, Math.min(1, p.opacity ?? 1))) };
+    const box = s.layout?.get(o.index);
+    if (box && isLayoutParticipant(o)) {
+        // Layouts sit where the solve puts them (the artboard's own origin shifts its direct children).
+        const par = s.byIndex[o.props.parentId ?? 0];
+        const A = s.ab.artboard.props;
+        let x = box.x, y = box.y;
+        if (par && par.index === 0) {
+            const [aw, ah] = artboardSize(s);
+            x -= (A.originX || 0) * aw;
+            y -= (A.originY || 0) * ah;
+        }
+        if (o.type === 'Text') {
+            x += (o.props.originX ?? 0) * box.w;
+            y += (o.props.originY ?? 0) * box.h;
+        }
+        if (o.type === 'NestedArtboardLayout') {
+            const t = ctx.file.artboards[o.props.artboardId ?? -1]?.artboard.props;
+            if (t) {
+                x += (t.originX || 0) * (t.width || 0);
+                y += (t.originY || 0) * (t.height || 0);
+            }
+        }
+        g.transform = { ...g.transform, x: r3(x), y: r3(y) };
+        if (o.type === 'LayoutComponent')
+            emitLayoutPaints(ctx, o, g, box);
+    }
+    if (constrained(s).has(o.index)) {
+        const t = localPose(s, o, null, 0);
+        g.transform = { ...g.transform, x: r3(t.x), y: r3(t.y), rotation: r3(t.rotation * DEG), scale_x: r3(t.scaleX), scale_y: r3(t.scaleY) };
+    }
+    if (isA(o.type, 'Drawable') && ((p.drawableFlags ?? 0) & 1))
+        g.isVisible = false;
+    ctx.rivToExode.set(o.index, id);
+    transformTracks(ctx, o, id);
+    if (o.type === 'Shape')
+        emitShape(ctx, o, g);
+    else if (o.type === 'Image')
+        emitImage(ctx, o, g);
+    else if (o.type === 'Text')
+        emitText(ctx, o, g);
+    else if (isA(o.type, 'NestedArtboard'))
+        emitNested(ctx, o, g);
+    else if (DRAW_TYPES.has(o.type))
+        ctx.warnings.add(`${o.type} layers are not imported yet`);
+    if (o.type === 'Bone' || o.type === 'RootBone') { /* transform-only */ }
+    // Rive draws later siblings first: reverse children for Exode's bottom-to-top order.
+    const kids = (s.children.get(o.index) || []).filter(k => isA(k.type, 'TransformComponent') && !isA(k.type, 'Path'));
+    for (const k of [...kids].reverse())
+        emitComponent(ctx, k, g);
+    if (o.type === 'Solo')
+        soloVisibility(ctx, o, kids);
+    emitClips(ctx, o, g);
+}
+/** A layout's own fills and strokes draw its box (rounded by the style's corner radii). */
+function emitLayoutPaints(ctx, o, g, box) {
+    const s = ctx.s;
+    const st = (o.props.styleId !== undefined ? s.byIndex[o.props.styleId] : null)?.props || {};
+    const paints = (s.children.get(o.index) || []).filter(k => isA(k.type, 'ShapePaint') && k.props.isVisible !== false);
+    for (const pnt of paints) {
+        const fill = paintFill(pnt, s, null, 0, { cx: box.w / 2, cy: box.h / 2, w: box.w, h: box.h });
+        const isStroke = pnt.type === 'Stroke';
+        const o2 = {
+            id: `${ctx.pre}${o.index}_bg${pnt.index}`, name: isStroke ? 'Layout stroke' : 'Layout fill', type: 'Shape', parentId: g.id,
+            transform: { ...baseTransform(), x: r3(box.w / 2), y: r3(box.h / 2) },
+            geometry: { type: 'Rectangle', width: r3(box.w), height: r3(box.h), corner_radius: r3(st.cornerRadiusTL || 0) },
+            style: isStroke
+                ? { fill: { type: 'Solid', color: '#000000', opacity: 0 }, stroke: { ...noStroke(), isEnabled: true, color: fill.color || '#000000', opacity: fill.opacity ?? 1, width: r3(pnt.props.thickness ?? 1), alignment: 'center' } }
+                : { fill, stroke: noStroke() },
+            isVisible: true,
+        };
+        g.children.unshift(o2.id);
+        ctx.objects.push(o2);
+    }
+}
+/** Solo shows only its active child; activeComponentId may be keyed (held values). */
+function soloVisibility(ctx, solo, kids) {
+    const byId = new Map(ctx.objects.map(x => [x.id, x]));
+    for (const k of kids) {
+        const obj = byId.get(`${ctx.pre}${k.index}`);
+        if (!obj)
+            continue;
+        if (k.index !== solo.props.activeComponentId)
+            obj.isVisible = false;
+        for (const a of ctx.s.animations) {
+            const keys = a.keyed.get(solo.index)?.get('activeComponentId');
+            if (!keys?.length)
+                continue;
+            const sec = (f) => r3((f - a.start) / a.fps);
+            const kf = [{ time: 0, value: keyedAt(keys, a.start) === k.index }, ...keys.filter(q => q.frame > a.start).map(q => ({ time: sec(q.frame), value: q.value === k.index }))];
+            ctx.tracksByAnim.get(a).push({ id: `t_${obj.id}_solo`, object_id: obj.id, property: 'visible', keyframes: kf.map((q, i) => ({ id: `k_${obj.id}_solo_${i}`, ...q, easing: 'StepEnd' })) });
+        }
+    }
+}
+// ---------------------------------------------------------------- state machines
+function stateMachine(ctx, objs, animIds) {
+    const sm = objs[0];
+    const inputs = [];
+    const layers = [];
+    const inputIds = [];
+    let layer = null, state = null, transition = null;
+    let stateIndex = 0;
+    const states = [];
+    const pendingTargets = [];
+    for (const o of objs.slice(1)) {
+        const p = o.props;
+        if (o.type === 'StateMachineNumber' || o.type === 'StateMachineBool' || o.type === 'StateMachineTrigger') {
+            const id = `in_${sm.index}_${inputs.length}_${String(p.name || 'input').replace(/\W+/g, '_')}`;
+            const type = o.type === 'StateMachineNumber' ? 'Number' : o.type === 'StateMachineBool' ? 'Boolean' : 'Trigger';
+            const value = type === 'Number' ? p.value ?? 0 : type === 'Boolean' ? !!p.value : false;
+            inputs.push({ id, name: p.name || id, value: { type, value, defaultValue: value } });
+            inputIds.push(id);
+        }
+        else if (o.type === 'StateMachineLayer') {
+            layer = { id: `layer_${layers.length}_${String(p.name || 'Layer').replace(/\W+/g, '_')}`, name: p.name || `Layer ${layers.length + 1}`, entryStateId: '', states: [] };
+            layers.push(layer);
+            stateIndex = 0;
+            states.length = 0;
+        }
+        else if (layer && isA(o.type, 'LayerState')) {
+            state = { id: `${layer.id}_s${stateIndex++}`, name: o.type === 'AnimationState' ? `State ${stateIndex}` : o.type.replace('State', ''), kind: o.type, loop: true, transitions: [] };
+            if (o.type === 'AnimationState' && animIds[p.animationId] !== undefined) {
+                state.animationId = animIds[p.animationId];
+                state.name = ctx.s.animations[p.animationId]?.obj.props.name || state.name;
+                state.loop = (ctx.s.animations[p.animationId]?.obj.props.loopValue ?? 0) !== 0;
+            }
+            if (isA(o.type, 'BlendState'))
+                ctx.warnings.add('Blend states are imported as plain states');
+            states.push(state);
+            layer.states.push(state);
+        }
+        else if (state && o.type === 'StateTransition') {
+            transition = { id: `${state.id}_t${state.transitions.length}`, targetStateId: '', duration: 0, conditions: [] };
+            pendingTargets.push({ t: transition, to: p.stateToId, layer });
+            // Exit time: hold the transition until the state has played that long.
+            const flags = p.flags ?? 0;
+            if (flags & 4 /* enableExitTime */) {
+                const anim = state.animationId ? ctx.s.animations[animIds.indexOf(state.animationId)] : null;
+                const durSec = anim ? (anim.end - anim.start) / anim.fps : 0;
+                const exit = (flags & 8) /* exitTimeIsPercentage */ ? ((p.exitTime ?? 0) / 100) * durSec : (p.exitTime ?? 0) / 1000;
+                transition.delay = r3(exit);
+            }
+            state.transitions.push(transition);
+        }
+        else if (transition && isA(o.type, 'TransitionInputCondition')) {
+            const inputId = inputIds[p.inputId];
+            const input = inputs.find(i => i.id === inputId);
+            if (!input)
+                continue;
+            const ops = ['Equal', 'NotEqual', 'LessEqual', 'GreaterEqual', 'LessThan', 'GreaterThan'];
+            if (o.type === 'TransitionTriggerCondition')
+                transition.conditions.push({ inputId, inputName: input.name, op: 'IsTrue', value: true });
+            else if (o.type === 'TransitionBoolCondition')
+                transition.conditions.push({ inputId, inputName: input.name, op: (p.opValue ?? 0) === 0 ? 'IsTrue' : 'IsFalse', value: (p.opValue ?? 0) === 0 });
+            else
+                transition.conditions.push({ inputId, inputName: input.name, op: ops[p.opValue ?? 0] || 'Equal', value: p.value ?? 0 });
+        }
+        else if (isA(o.type, 'StateMachineListener')) {
+            ctx.warnings.add('State machine listeners (pointer events) are not imported yet');
+        }
+    }
+    // Resolve targets (stateToId indexes the layer's states) and wire Entry / Any.
+    // stateToId indexes the layer's states in stream order (entry/any/exit included).
+    for (const { t, to, layer: l } of pendingTargets)
+        t.targetStateId = l.states[to]?.id || '';
+    for (const l of layers) {
+        const entry = l.states.find((st) => st.kind === 'EntryState');
+        const first = entry?.transitions[0]?.targetStateId;
+        // Exode has no entry/any/exit pseudo-states: enter the entry's target directly;
+        // the runtime already checks every state's transitions globally, so Any-state
+        // transitions keep working from wherever they sit.
+        l.entryStateId = first || l.states.find((st) => st.animationId)?.id || l.states[0]?.id || '';
+        const any = l.states.find((st) => st.kind === 'AnyState');
+        const host = l.states.find((st) => st.id === l.entryStateId && st.kind === 'AnimationState') || l.states.find((st) => st.kind === 'AnimationState');
+        if (any && host && any !== host)
+            host.transitions.push(...any.transitions);
+        for (const st of l.states)
+            st.transitions = st.transitions.filter((t) => t.targetStateId && l.states.some((x) => x.id === t.targetStateId && x.kind !== 'ExitState'));
+        l.states = l.states.filter((st) => st.kind !== 'EntryState' && st.kind !== 'ExitState' && st.kind !== 'AnyState');
+        l.states.forEach((st) => { delete st.kind; });
+    }
+    return { name: sm.props.name || 'State Machine', inputs, layers: layers.filter(l => l.states.length) };
+}
+// ---------------------------------------------------------------- entry
+export function convertRive(data, opts = {}) {
+    const file = data.artboards ? data : readRiv(data);
+    if (!file.artboards.length)
+        throw new Error('The .riv file has no artboards');
+    const pick = typeof opts.artboard === 'number' ? file.artboards[opts.artboard]
+        : typeof opts.artboard === 'string' ? file.artboards.find(a => a.artboard.props.name === opts.artboard) : file.artboards[0];
+    const ab = pick || file.artboards[0];
+    const s = indexScene(ab);
+    const ctx = { s, file, pre: 'riv_', depth: 0, out: { animations: [], layers: [], inputs: [] }, objects: [], warnings: new Set(), tracksByAnim: new Map(s.animations.map(a => [a, []])), rivToExode: new Map() };
+    s.bounds = boundsHook(ctx);
+    setupLayouts(ctx);
+    const A = ab.artboard.props;
+    const root0 = s.layout?.get(0);
+    const W = root0?.w || A.width || 500, H = root0?.h || A.height || 500;
+    let background = opts.background ?? 'transparent';
+    const root = group(ctx, 'riv_root', A.name || 'Artboard', null);
+    root.transform.x = r3((A.originX || 0) * W);
+    root.transform.y = r3((A.originY || 0) * H);
+    const solid = emitArtboardContent(ctx, root, !opts.background);
+    if (solid)
+        background = solid;
+    if (file.unknownTypes.size)
+        ctx.warnings.add(`Unknown Rive object types ${[...file.unknownTypes].join(', ')} were skipped`);
+    const { animations, ids: animIds } = buildAnimations(ctx);
+    let machine;
+    if (s.machines.length) {
+        machine = stateMachine(ctx, s.machines[0], animIds);
+        if (s.machines.length > 1)
+            ctx.warnings.add('Only the first state machine is imported');
+    }
+    if (!machine || !machine.layers.length) {
+        const first = animations[0];
+        machine = { inputs: [], layers: first ? [{ id: 'layer_riv_timeline', name: 'Timeline', entryStateId: 'state_riv_play', states: [{ id: 'state_riv_play', name: first.name, animationId: first.id, loop: first.loop, transitions: [] }] }] : [] };
+    }
+    // Nested artboards play on layers of their own, next to the main ones.
+    animations.push(...ctx.out.animations);
+    machine.layers.push(...ctx.out.layers);
+    machine.inputs.push(...ctx.out.inputs);
+    // Explicit stacking in draw order (depth first).
+    const byId = new Map(ctx.objects.map(o => [o.id, o]));
+    let z = 0;
+    const stack = (o) => { o.zIndex = z++; (o.children || []).forEach((cid) => { const c = byId.get(cid); if (c)
+        stack(c); }); };
+    ctx.objects.filter(o => !o.parentId).forEach(stack);
+    const artboard = {
+        id: `artboard_rive_${String(A.name || 'artboard').replace(/\W+/g, '_')}`,
+        name: A.name || 'Rive artboard', width: W, height: H, cornerRadius: 0, fit: 'Contain',
+        backgroundColor: background, opacity: 1, objects: ctx.objects, animations,
+        navigation: [], animationFlow: [], stateVariables: [],
+        stateMachine: { inputs: machine.inputs, layers: machine.layers },
+        source: { kind: 'rive', version: `${file.major}.${file.minor}`, artboard: A.name, artboards: file.artboards.map(a => a.artboard.props.name) },
+    };
+    const tracks = animations.reduce((n, a) => n + a.tracks.length, 0);
+    const keyframes = animations.reduce((n, a) => n + a.tracks.reduce((m, t) => m + t.keyframes.length, 0), 0);
+    return { artboard, warnings: [...ctx.warnings], stats: { objects: ctx.objects.length, animations: animations.length, stateMachines: s.machines.length, tracks, keyframes } };
+}
+/** Artboard size, after a hugging artboard takes its content size. */
+const artboardSize = (s) => { const b = s.layout?.get(0), A = s.ab.artboard.props; return [b?.w || A.width || 500, b?.h || A.height || 500]; };
+/** Solve the scene's layouts and size the first parametric path of shapes directly in a layout (propagateSize). */
+function setupLayouts(ctx) {
+    const s = ctx.s;
+    if (!s.ab.stream.some(o => o.type === 'LayoutComponent' || o.type === 'NestedArtboardLayout'))
+        return;
+    s.layout = solveLayouts(s, s.ab.artboard, o => {
+        if (o.type === 'Text') {
+            const l = textLayout(ctx, o);
+            return { w: l?.W || 0, h: l?.H || 0 };
+        }
+        const t = ctx.file.artboards[o.props.artboardId ?? -1]?.artboard.props;
+        return { w: t?.width || 0, h: t?.height || 0 };
+    });
+    s.sizeOverride = new Map();
+    for (const [idx, box] of s.layout) {
+        const l = s.byIndex[idx];
+        if (!l || l.type !== 'LayoutComponent' || l.props.styleId === undefined)
+            continue;
+        const sized = (c) => {
+            for (const k of s.children.get(c.index) || []) {
+                if (k.type === 'Shape') {
+                    const path = (s.children.get(k.index) || []).find(q => isA(q.type, 'ParametricPath'));
+                    if (path)
+                        s.sizeOverride.set(path.index, { w: box.w, h: box.h });
+                }
+                else if (k.type === 'Solo')
+                    sized(k);
+            }
+        };
+        sized(l);
+    }
+}
+/** Constraint bounds of a Text box or a shape's path, in its own space. */
+function boundsHook(ctx) {
+    const s = ctx.s;
+    return o => {
+        if (o.type === 'Text') {
+            const l = textLayout(ctx, o);
+            return l ? { x: -l.W * (o.props.originX ?? 0), y: -l.H * (o.props.originY ?? 0), w: l.W, h: l.H } : null;
+        }
+        if (o.type === 'Shape') {
+            const pts = shapeContours(s, o, null, 0, false).flat();
+            if (!pts.length)
+                return null;
+            const b = bbox(pts);
+            return { x: b.x0, y: b.y0, w: b.w, h: b.h };
+        }
+        return null;
+    };
+}
+/** An artboard's own paints (background) and its component tree under `root`. Returns a colour when the background is one opaque solid fill. */
+function emitArtboardContent(ctx, root, solidToBackground) {
+    const s = ctx.s;
+    const A = s.ab.artboard.props;
+    const [W, H] = artboardSize(s);
+    // Content coordinates are relative to the artboard origin; its box spans -origin x size.
+    const ox = (A.originX || 0) * W, oy = (A.originY || 0) * H;
+    const bgPaints = (s.children.get(0) || []).filter(k => isA(k.type, 'ShapePaint'));
+    let solid = null;
+    for (const pnt of bgPaints) {
+        const fill = paintFill(pnt, s, null, 0, { cx: W / 2 - ox, cy: H / 2 - oy, w: W, h: H });
+        if (solidToBackground && pnt.type === 'Fill' && fill.type === 'Solid' && fill.opacity >= 0.999 && bgPaints.length === 1) {
+            solid = fill.color;
+            continue;
+        }
+        const o = { id: `${ctx.pre}bg_${pnt.index}`, name: 'Artboard background', type: 'Shape', parentId: root.id, transform: { ...baseTransform(), x: r3(W / 2 - ox), y: r3(H / 2 - oy) }, geometry: { type: 'Rectangle', width: W, height: H, corner_radius: 0 }, style: { fill, stroke: noStroke() }, isVisible: true };
+        root.children.push(o.id);
+        ctx.objects.push(o);
+    }
+    const top = (s.children.get(0) || []).filter(k => isA(k.type, 'TransformComponent') && !isA(k.type, 'Path'));
+    for (const k of [...top].reverse())
+        emitComponent(ctx, k, root);
+    const ab = s.ab;
+    if (ab.stream.some(o => o.type === 'DrawRules' || o.type === 'DrawTarget'))
+        ctx.warnings.add('Custom draw order (draw rules) is not imported; hierarchy order is used');
+    if (ab.stream.some(o => o.type !== 'Artboard' && isA(o.type, 'LayoutComponent')))
+        ctx.warnings.add('Rive layouts are solved once at import (flex rows/columns, gaps, padding, alignment); wrap, grid and layout animation are not');
+    const unsupported = ab.stream.filter(o => isA(o.type, 'Constraint') && !CONSTRAINTS.has(o.type)).map(o => o.type);
+    if (unsupported.length)
+        ctx.warnings.add(`Constraints not imported: ${[...new Set(unsupported)].join(', ')}`);
+    return solid;
+}
+/** One Exode animation per Rive timeline of this scene (ping-pong unrolled, speed applied); ids align with s.animations. */
+function buildAnimations(ctx) {
+    const animations = [];
+    const ids = [];
+    ctx.s.animations.forEach((a, i) => {
+        if (a.synthetic) {
+            ids.push('');
+            return;
+        }
+        const id = `anim_${ctx.pre}${i}_${String(a.obj.props.name || 'Animation').replace(/\W+/g, '_')}`;
+        let tracks = ctx.tracksByAnim.get(a);
+        let duration = r3((a.end - a.start) / a.fps);
+        const loopValue = a.obj.props.loopValue ?? 0;
+        if (loopValue === 2) {
+            tracks = tracks.map(t => {
+                const back = [...t.keyframes].reverse().slice(1).map((k, j) => ({ ...k, id: `${k.id}_pp${j}`, time: r3(2 * duration - k.time) }));
+                return { ...t, keyframes: [...t.keyframes, ...back] };
+            });
+            duration = r3(duration * 2);
+        }
+        const speed = a.obj.props.speed ?? 1;
+        if (speed !== 1 && speed > 0) {
+            tracks.forEach(t => t.keyframes.forEach((k) => (k.time = r3(k.time / speed))));
+            duration = r3(duration / speed);
+        }
+        animations.push({ id, name: (ctx.depth ? `${ctx.pre.replace(/_$/, '')} · ` : '') + (a.obj.props.name || `Animation ${i + 1}`), duration, loop: loopValue !== 0, tracks });
+        ids.push(id);
+    });
+    return { animations, ids };
+}
+//# sourceMappingURL=convert.js.map