@vvfx/ge-ir 0.0.1-beta.5 → 0.0.1-beta.7

package/dist/index.mjs

@@ -3,10 +3,10 @@
  * Description: Galacean Effects and animation IR bidirectional conversion package
  * Author: Ant Group CO., Ltd.
  * Contributors: 澄弈
- * Version: v0.0.1-beta.5
+ * Version: v0.0.1-beta.7
  */
 
-import { IRBlendMode, IRShapePrimitiveType, IRFillType, IRLineCap, IRLineJoin, IRShapeFillRule, IREndBehavior, validateIRCompositionWithWarnings } from '@vvfx/animation-ir';
+import { IRBlendMode, IRShapePrimitiveType, IRFillType, IRLineCap, IRLineJoin, IREndBehavior, validateIRCompositionOrThrow } from '@vvfx/animation-ir';
 import { v4 } from 'uuid';
 
 function _extends() {
@@ -60,6 +60,92 @@ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
     throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
+/** Read GE layer passthrough data. */ function getEffectsLayerSpecific(ir, layer) {
+    var _layer_specific;
+    return ir.source === 'effects' ? (_layer_specific = layer.specific) == null ? void 0 : _layer_specific.effects : undefined;
+}
+/** Read GE composition passthrough data. */ function getEffectsCompositionSpecific(ir) {
+    var _ir_specific;
+    return ir.source === 'effects' ? (_ir_specific = ir.specific) == null ? void 0 : _ir_specific.effects : undefined;
+}
+var EFFECTS_ANIMATION_SPECIFIC_KEYS = [
+    'positionOverLifetime',
+    'rotationOverLifetime',
+    'sizeOverLifetime',
+    'colorOverLifetime'
+];
+var KEYS_BY_INVALIDATION_TARGET = {
+    position: [
+        'positionOverLifetime'
+    ],
+    rotation: [
+        'rotationOverLifetime',
+        'sourceHierarchy'
+    ],
+    scale: [
+        'sizeOverLifetime',
+        'sourceHierarchy'
+    ],
+    color: [
+        'colorOverLifetime'
+    ],
+    opacity: [
+        'colorOverLifetime'
+    ],
+    anchor: [
+        'sourceHierarchy'
+    ],
+    mask: [
+        'mask'
+    ],
+    precomp: [
+        'precompRefId',
+        'precompContent'
+    ]
+};
+/**
+ * Remove raw GE values that would otherwise shadow an edited normalized field.
+ * Empty `effects` and `specific` containers are pruned so serialization stays clean.
+ */ function invalidateEffectsLayerSpecific(layer, target) {
+    var _layer_specific;
+    var effects = (_layer_specific = layer.specific) == null ? void 0 : _layer_specific.effects;
+    if (effects == null) {
+        return [];
+    }
+    var removed = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(KEYS_BY_INVALIDATION_TARGET[target]), _step; !(_step = _iterator()).done;){
+        var key = _step.value;
+        if (key in effects) {
+            delete effects[key];
+            removed.push(key);
+        }
+    }
+    if (Object.keys(effects).length === 0 && layer.specific != null) {
+        delete layer.specific.effects;
+    }
+    if (layer.specific != null && Object.keys(layer.specific).length === 0) {
+        delete layer.specific;
+    }
+    return removed;
+}
+/** Whether invalidating opacity would also discard a GE color animation. */ function hasEffectsColorAnimationPassthrough(layer) {
+    var _layer_specific_effects, _layer_specific;
+    var color = (_layer_specific = layer.specific) == null ? void 0 : (_layer_specific_effects = _layer_specific.effects) == null ? void 0 : _layer_specific_effects.colorOverLifetime;
+    if (color == null) {
+        return false;
+    }
+    return Object.keys(color).some(function(channelKey) {
+        return channelKey !== 'opacity';
+    });
+}
+/** Whether the layer retains any raw GE animation payload. */ function hasEffectsAnimationPassthrough(layer) {
+    var _layer_specific;
+    var effects = (_layer_specific = layer.specific) == null ? void 0 : _layer_specific.effects;
+    return effects != null && EFFECTS_ANIMATION_SPECIFIC_KEYS.some(function(key) {
+        return effects[key] != null;
+    });
+}
+
 var DEFAULT_CAMERA_Z = 8;
 var DEFAULT_CAMERA_FOV = 60;
 var DEFAULT_CLIP_MODE = 1;
@@ -1193,36 +1279,29 @@ function getScalarValue(keyframe, dimensionIndex) {
     for(var i = 0; i < keyframes.length; i++){
         var _kf_outTangent, _kf_inTangent;
         var kf = keyframes[i];
-        var normalizedT = normalizeTime(kf.t, timeContext.startFrame, timeContext.endFrame);
+        var normalizedT = normalizeTime(kf.frame, timeContext.startFrame, timeContext.endFrame);
         timingCurvePoints.push({
             t: normalizedT,
             outTangent: (_kf_outTangent = kf.outTangent) != null ? _kf_outTangent : DEFAULT_OUT_TANGENT,
             inTangent: (_kf_inTangent = kf.inTangent) != null ? _kf_inTangent : DEFAULT_IN_TANGENT
         });
         if (i < keyframes.length - 1) {
-            var _kf_value, _kf_endValue, _nextKf_value, _startPos_, _startPos_1, _stitchEnd_, _stitchEnd_1;
+            var _kf_value, _ref, _kf_endValue, _startPos_, _startPos_1, _segmentEnd_, _segmentEnd_1;
             var nextKf = keyframes[i + 1];
             var startPos = (_kf_value = kf.value) != null ? _kf_value : [
                 0,
                 0,
                 0
             ];
-            // Lottie segment end value: kf.endValue is authoritative; falls back to kf.value (mirrors master's `e ?? s`).
-            // nextKf.value is only used later in the path-fixup pass to stitch adjacent segments.
-            var segmentEnd = kf.hold === true ? startPos : (_kf_endValue = kf.endValue) != null ? _kf_endValue : startPos;
-            var stitchEnd = kf.hold === true ? startPos : (_nextKf_value = nextKf.value) != null ? _nextKf_value : [
-                0,
-                0,
-                0
-            ];
+            var segmentEnd = kf.hold === true ? startPos : (_ref = (_kf_endValue = kf.endValue) != null ? _kf_endValue : nextKf.value) != null ? _ref : startPos;
             pathPoints.push([
                 [
                     (_startPos_ = startPos[0]) != null ? _startPos_ : 0,
                     (_startPos_1 = startPos[1]) != null ? _startPos_1 : 0
                 ],
                 [
-                    (_stitchEnd_ = stitchEnd[0]) != null ? _stitchEnd_ : 0,
-                    (_stitchEnd_1 = stitchEnd[1]) != null ? _stitchEnd_1 : 0
+                    (_segmentEnd_ = segmentEnd[0]) != null ? _segmentEnd_ : 0,
+                    (_segmentEnd_1 = segmentEnd[1]) != null ? _segmentEnd_1 : 0
                 ]
             ]);
             // Spatial control points (per IRKeyframe convention): outgoing CP from
@@ -1241,11 +1320,11 @@ function getScalarValue(keyframe, dimensionIndex) {
                     (_nextKf_spatialIn_1 = nextKf.spatialIn[1]) != null ? _nextKf_spatialIn_1 : 0
                 ];
             } else {
-                var _startPos_2, _startPos_3, _segmentEnd_, _segmentEnd_1;
+                var _startPos_2, _startPos_3, _segmentEnd_2, _segmentEnd_3;
                 var sx = (_startPos_2 = startPos[0]) != null ? _startPos_2 : 0;
                 var sy = (_startPos_3 = startPos[1]) != null ? _startPos_3 : 0;
-                var ex = (_segmentEnd_ = segmentEnd[0]) != null ? _segmentEnd_ : 0;
-                var ey = (_segmentEnd_1 = segmentEnd[1]) != null ? _segmentEnd_1 : 0;
+                var ex = (_segmentEnd_2 = segmentEnd[0]) != null ? _segmentEnd_2 : 0;
+                var ey = (_segmentEnd_3 = segmentEnd[1]) != null ? _segmentEnd_3 : 0;
                 toPoint = [
                     -sx / 3 + ex / 3,
                     -sy / 3 + ey / 3
@@ -1261,10 +1340,6 @@ function getScalarValue(keyframe, dimensionIndex) {
             ]);
         }
     }
-    // Fix up path points: adjacent segments should share endpoints
-    for(var i1 = 0; i1 < pathPoints.length - 1; i1++){
-        pathPoints[i1][1] = pathPoints[i1 + 1][0];
-    }
     // Prepend a static segment if the first keyframe doesn't start at t=0.
     // The bridge segment runs synthetic-at-t=0 → original-kf[0]; for it to be a
     // flat hold the END-side tangent (which `buildPositionTimingCurves` reads as
@@ -1273,7 +1348,7 @@ function getScalarValue(keyframe, dimensionIndex) {
     // the IR convention leaves a first-kf inTangent undefined, or whatever the
     // producer set as a no-op).
     if (timingCurvePoints.length > 0 && timingCurvePoints[0].t > 0) {
-        var _ref, _ref1;
+        var _ref1, _ref2;
         var _pathPoints_, _pathPoints_1;
         timingCurvePoints[0].inTangent = {
             x: 1,
@@ -1291,11 +1366,11 @@ function getScalarValue(keyframe, dimensionIndex) {
             }
         });
         pathPoints.unshift([
-            (_ref = (_pathPoints_ = pathPoints[0]) == null ? void 0 : _pathPoints_[0]) != null ? _ref : [
+            (_ref1 = (_pathPoints_ = pathPoints[0]) == null ? void 0 : _pathPoints_[0]) != null ? _ref1 : [
                 0,
                 0
             ],
-            (_ref1 = (_pathPoints_1 = pathPoints[0]) == null ? void 0 : _pathPoints_1[0]) != null ? _ref1 : [
+            (_ref2 = (_pathPoints_1 = pathPoints[0]) == null ? void 0 : _pathPoints_1[0]) != null ? _ref2 : [
                 0,
                 0
             ]
@@ -1372,10 +1447,13 @@ function buildCurveForDimension(keyframes, timeContext, dimensionIndex) {
         var _kf_outTangent, _nextKf_inTangent;
         var kf = keyframes[i];
         var nextKf = keyframes[i + 1];
-        var t0 = normalizeTime(kf.t, timeContext.startFrame, timeContext.endFrame);
-        var t1 = normalizeTime(nextKf.t, timeContext.startFrame, timeContext.endFrame);
+        var t0 = normalizeTime(kf.frame, timeContext.startFrame, timeContext.endFrame);
+        var t1 = normalizeTime(nextKf.frame, timeContext.startFrame, timeContext.endFrame);
         var v0 = getScalarValue(kf, dimensionIndex);
-        var v1 = kf.hold === true ? v0 : getScalarValue(nextKf, dimensionIndex);
+        var endKeyframe = kf.endValue != null ? _extends({}, kf, {
+            value: kf.endValue
+        }) : nextKf;
+        var v1 = kf.hold === true ? v0 : getScalarValue(endKeyframe, dimensionIndex);
         var outHandle = kf.hold === true ? {
             x: 0,
             y: 0
@@ -1482,20 +1560,11 @@ function buildPositionTimingCurves(points) {
 }
 
 /**
- * True when the layer's parent only inherits transform — visibility and
- * lifetime are independent of the parent's window.
- *
- * Reads `IRLayerReference.linkKind` directly. Producers that don't set the
- * field (e.g. dsl2ge) effectively get `false` here, which is the correct
- * default for "full" parent containment.
- *
- * Lottie's parser sets `linkKind: 'transform-only'` when a child's parent
- * relationship comes from `layer.parent` rather than precomp expansion;
- * `applyPostProcess` consumes this to decide whether to advance the parent's
- * activation track when the child starts earlier.
- */ function isTransformOnlyParentLink(layer) {
+ * True when the child lifetime is independent of its transform parent's
+ * clipping window. An omitted lifetimeMode keeps the legacy clipped default.
+ */ function hasIndependentParentLifetime(layer) {
     var _layer_parent;
-    return ((_layer_parent = layer.parent) == null ? void 0 : _layer_parent.linkKind) === 'transform-only';
+    return ((_layer_parent = layer.parent) == null ? void 0 : _layer_parent.lifetimeMode) === 'independent';
 }
 
 /**
@@ -1503,18 +1572,19 @@ function buildPositionTimingCurves(points) {
  * the time-stretch and offset semantics from `IRTimeContext`.
  *
  * dsl-source IRs leave `stretch` and `offsetFrame` undefined, in which case
- * this collapses to `delay = startFrame / fr` and
+ * this collapses to `delay = (startFrame - compositionInPoint) / fr` and
  * `duration = (endFrame - startFrame) / fr` — exactly what dsl2ge used to
  * compute inline.
  *
  * Zero/negative durations are clamped to a 0.0001 epsilon so GE keeps the
  * activation track alive for the (degenerate) layer.
- */ function computeLayerTiming(layer, frameRate) {
+ */ function computeLayerTiming(layer, frameRate, compositionInPoint) {
+    if (compositionInPoint === void 0) compositionInPoint = 0;
     var _time_stretch, _time_offsetFrame;
     var time = layer.time;
     var stretch = (_time_stretch = time.stretch) != null ? _time_stretch : 1;
     var offsetFrame = (_time_offsetFrame = time.offsetFrame) != null ? _time_offsetFrame : 0;
-    var delay = roundNumber((offsetFrame + time.startFrame * stretch) / frameRate, 4);
+    var delay = roundNumber((offsetFrame + time.startFrame * stretch - compositionInPoint) / frameRate, 4);
     var rawDuration = (time.endFrame - time.startFrame) * stretch / frameRate;
     var layerDuration = rawDuration > 0 ? roundNumber(rawDuration, 4) : 0.0001;
     return {
@@ -1526,37 +1596,29 @@ function buildPositionTimingCurves(points) {
 function computeStaticPosition(layer, ctx, anchorOffsetX, anchorOffsetY) {
     if (anchorOffsetX === void 0) anchorOffsetX = 0;
     if (anchorOffsetY === void 0) anchorOffsetY = 0;
-    var _transform_position;
+    var _transform_position, _transform_position1, _transform_position_keyframes_, _transform_position2;
     var transform = layer.transform;
-    if (transform == null ? void 0 : (_transform_position = transform.position) == null ? void 0 : _transform_position.keyframed) {
+    if ((transform == null ? void 0 : (_transform_position = transform.position) == null ? void 0 : _transform_position.keyframed) === true && transform.position.keyframes.length !== 1) {
         return convert2dTo3dPoint(ctx.width / 2 + anchorOffsetX, ctx.height / 2 + anchorOffsetY, 0, ctx.width, ctx.height);
     }
     var isNullType = layer.type === 'null' || layer.type === 'precomp';
-    if ((transform == null ? void 0 : transform.position) != null && Array.isArray(transform.position.value)) {
+    var positionValue = (transform == null ? void 0 : (_transform_position1 = transform.position) == null ? void 0 : _transform_position1.keyframed) === true ? (_transform_position_keyframes_ = transform.position.keyframes[0]) == null ? void 0 : _transform_position_keyframes_.value : transform == null ? void 0 : (_transform_position2 = transform.position) == null ? void 0 : _transform_position2.value;
+    if (Array.isArray(positionValue)) {
         var _pos_, _pos_1, _pos_2;
-        var pos = transform.position.value;
+        var pos = positionValue;
         return convert2dTo3dPoint(((_pos_ = pos[0]) != null ? _pos_ : 0) + anchorOffsetX, ((_pos_1 = pos[1]) != null ? _pos_1 : 0) + anchorOffsetY, isNullType ? 0 : (_pos_2 = pos[2]) != null ? _pos_2 : 0, ctx.width, ctx.height);
     }
     return convert2dTo3dPoint(ctx.width / 2 + anchorOffsetX, ctx.height / 2 + anchorOffsetY, 0, ctx.width, ctx.height);
 }
 function getStaticAnchor(layer) {
-    var _layer_transform;
-    var anchor = (_layer_transform = layer.transform) == null ? void 0 : _layer_transform.anchor;
-    if (anchor != null && !anchor.keyframed && Array.isArray(anchor.value) && anchor.value.length >= 2) {
+    var _layer_transform_anchor, _layer_transform;
+    var value = (_layer_transform = layer.transform) == null ? void 0 : (_layer_transform_anchor = _layer_transform.anchor) == null ? void 0 : _layer_transform_anchor.value;
+    if (Array.isArray(value) && value.length >= 2) {
         return [
-            anchor.value[0],
-            anchor.value[1]
+            value[0],
+            value[1]
         ];
     }
-    if ((anchor == null ? void 0 : anchor.keyframed) && anchor.keyframes != null && anchor.keyframes.length > 0) {
-        var firstVal = anchor.keyframes[0].value;
-        if (Array.isArray(firstVal) && firstVal.length >= 2) {
-            return [
-                firstVal[0],
-                firstVal[1]
-            ];
-        }
-    }
     return [
         0,
         0
@@ -1564,15 +1626,21 @@ function getStaticAnchor(layer) {
 }
 function getStaticScaleFromIR(layer) {
     var _value_, _value_1;
-    var _layer_transform;
+    var _layer_transform, _scale_keyframes_;
     var scale = (_layer_transform = layer.transform) == null ? void 0 : _layer_transform.scale;
-    if (scale == null || scale.keyframed) {
+    if (scale == null) {
+        return [
+            1,
+            1
+        ];
+    }
+    if (scale.keyframed && scale.keyframes.length !== 1) {
         return [
             1,
             1
         ];
     }
-    var value = scale.value;
+    var value = scale.keyframed ? (_scale_keyframes_ = scale.keyframes[0]) == null ? void 0 : _scale_keyframes_.value : scale.value;
     if (!Array.isArray(value)) {
         return [
             1,
@@ -1584,14 +1652,15 @@ function getStaticScaleFromIR(layer) {
         (_value_1 = value[1]) != null ? _value_1 : 1
     ];
 }
-function applyScalePositionAdjust(position, layer, layerWidth, layerHeight, ratio) {
+function applyScalePositionAdjust(position, layer, bounds, ratio) {
     var staticScale = getStaticScaleFromIR(layer);
-    if (staticScale[0] === 1 && staticScale[1] === 1 || layerWidth <= 0 || layerHeight <= 0) {
+    var x = bounds.x, y = bounds.y, width = bounds.width, height = bounds.height;
+    if (staticScale[0] === 1 && staticScale[1] === 1 || width <= 0 || height <= 0) {
         return position;
     }
     var anchor = getStaticAnchor(layer);
-    var anchorDiffX = anchor[0] - layerWidth / 2;
-    var anchorDiffY = anchor[1] - layerHeight / 2;
+    var anchorDiffX = anchor[0] - (x + width / 2);
+    var anchorDiffY = anchor[1] - (y + height / 2);
     if (Math.abs(anchorDiffX) <= 0.5 && Math.abs(anchorDiffY) <= 0.5) {
         return position;
     }
@@ -1601,43 +1670,46 @@ function applyScalePositionAdjust(position, layer, layerWidth, layerHeight, rati
         position[2]
     ];
 }
-function computeAnchorInfo(layer, layerWidth, layerHeight) {
+function computeAnchorInfo(layer, bounds) {
     var anchor = getStaticAnchor(layer);
+    var x = bounds.x, y = bounds.y, width = bounds.width, height = bounds.height;
+    var localAnchorX = anchor[0] - x;
+    var localAnchorY = anchor[1] - y;
     var anchorScaleX = 0.5;
     var anchorScaleY = 0.5;
     var anchorOffsetX = 0;
     var anchorOffsetY = 0;
-    if (layerWidth > 0 && layerHeight > 0) {
-        anchorScaleX = anchor[0] / layerWidth;
-        anchorScaleY = anchor[1] / layerHeight;
-        anchorOffsetX = -(anchor[0] - layerWidth / 2);
-        anchorOffsetY = -(anchor[1] - layerHeight / 2);
+    if (width > 0 && height > 0) {
+        anchorScaleX = localAnchorX / width;
+        anchorScaleY = localAnchorY / height;
+        anchorOffsetX = -(localAnchorX - width / 2);
+        anchorOffsetY = -(localAnchorY - height / 2);
     }
-    if (layer.type === 'text' && layer.text != null && layerWidth > 0 && layerHeight > 0) {
+    if (layer.type === 'text' && layer.text != null && width > 0 && height > 0) {
         if (layer.text.anchorAdjust === true) {
             if (layer.text.textAlign === 'left') {
-                anchorOffsetX = -(anchor[0] - layerWidth / 2);
-                anchorScaleX = anchor[0] / layerWidth - 0.5;
+                anchorOffsetX = -(localAnchorX - width / 2);
+                anchorScaleX = localAnchorX / width - 0.5;
             }
             if (layer.text.textAlign === 'center') {
-                anchorOffsetX = -anchor[0];
-                anchorScaleX = anchor[0] / layerWidth + 0.5;
+                anchorOffsetX = -localAnchorX;
+                anchorScaleX = localAnchorX / width + 0.5;
             }
             if (layer.text.textAlign === 'right') {
-                anchorOffsetX = -(anchor[0] + layerWidth / 2);
-                anchorScaleX = anchor[0] / layerWidth + 1.5;
+                anchorOffsetX = -(localAnchorX + width / 2);
+                anchorScaleX = localAnchorX / width + 1.5;
             }
             // GE renders glyphs in the lower half of the quad, so offset by half the
             // layer height to align the visible text center with Lottie's anchor.
-            var textHeight = layerHeight / 2;
-            anchorOffsetY = -(anchor[1] + textHeight);
-            anchorScaleY = -anchor[1] / textHeight;
+            var textHeight = height / 2;
+            anchorOffsetY = -(localAnchorY + textHeight);
+            anchorScaleY = -localAnchorY / textHeight;
         }
     }
     var isSpriteForAnchor = layer.type === 'image' || layer.type === 'solid';
     var staticRotationZ = getStaticRotationZ(layer);
     var hasStaticRotation = staticRotationZ != null;
-    if (isSpriteForAnchor && hasStaticRotation && isTransformOnlyParentLink(layer) && (anchorOffsetX !== 0 || anchorOffsetY !== 0)) {
+    if (isSpriteForAnchor && hasStaticRotation && hasIndependentParentLifetime(layer) && (anchorOffsetX !== 0 || anchorOffsetY !== 0)) {
         var rotValue = staticRotationZ != null ? staticRotationZ : 0;
         if (rotValue !== 0) {
             var rad = rotValue * Math.PI / 180;
@@ -1657,15 +1729,10 @@ function computeAnchorInfo(layer, layerWidth, layerHeight) {
     };
 }
 function getStaticRotationZ(layer) {
-    var _layer_transform, _layer_transform_separatedRotation, _layer_transform1;
-    var rotation = (_layer_transform = layer.transform) == null ? void 0 : _layer_transform.rotation;
-    if (rotation != null && !rotation.keyframed && Array.isArray(rotation.value)) {
-        var _rotation_value_;
-        return (_rotation_value_ = rotation.value[2]) != null ? _rotation_value_ : 0;
-    }
-    var separatedRotationZ = (_layer_transform1 = layer.transform) == null ? void 0 : (_layer_transform_separatedRotation = _layer_transform1.separatedRotation) == null ? void 0 : _layer_transform_separatedRotation.z;
-    if (separatedRotationZ != null && !separatedRotationZ.keyframed && typeof separatedRotationZ.value === 'number') {
-        return separatedRotationZ.value;
+    var _layer_transform_rotation, _layer_transform;
+    var rotationZ = (_layer_transform = layer.transform) == null ? void 0 : (_layer_transform_rotation = _layer_transform.rotation) == null ? void 0 : _layer_transform_rotation.z;
+    if (rotationZ != null && !rotationZ.keyframed && typeof rotationZ.value === 'number') {
+        return rotationZ.value;
     }
     return undefined;
 }
@@ -1676,99 +1743,50 @@ function getTimeContext(layer) {
     };
 }
 
-function readGE2IRMetadata(ir, layer) {
-    if (ir.source !== 'ge') {
-        return undefined;
-    }
-    var metadata = layer.metadata;
-    if (metadata == null) {
-        return undefined;
-    }
-    var namespaced = metadata['ge2ir'];
-    if (isRecord$4(namespaced)) {
-        return namespaced;
-    }
-    var legacy = readLegacyGE2IRMetadata(metadata);
-    return Object.keys(legacy).length > 0 ? legacy : undefined;
-}
-function readLegacyGE2IRMetadata(metadata) {
-    var legacy = {};
-    var positionOverLifetime = metadata['positionOverLifetime'];
-    var rotationOverLifetime = metadata['rotationOverLifetime'];
-    var sizeOverLifetime = metadata['sizeOverLifetime'];
-    var colorOverLifetime = metadata['colorOverLifetime'];
-    var geComponentId = metadata['geComponentId'];
-    var geMask = metadata['geMask'];
-    var precompRefId = metadata['precompRefId'];
-    var precompContent = metadata['precompContent'];
-    if (isRecord$4(positionOverLifetime)) {
-        legacy.positionOverLifetime = positionOverLifetime;
-    }
-    if (isRecord$4(rotationOverLifetime)) {
-        legacy.rotationOverLifetime = rotationOverLifetime;
-    }
-    if (isRecord$4(sizeOverLifetime)) {
-        legacy.sizeOverLifetime = sizeOverLifetime;
-    }
-    if (isRecord$4(colorOverLifetime)) {
-        legacy.colorOverLifetime = colorOverLifetime;
-    }
-    if (typeof geComponentId === 'string') {
-        legacy.geComponentId = geComponentId;
-    }
-    if (isRecord$4(geMask)) {
-        legacy.geMask = geMask;
-    }
-    if (typeof precompRefId === 'string') {
-        legacy.precompRefId = precompRefId;
-    }
-    if (isRecord$4(precompContent)) {
-        legacy.precompContent = precompContent;
-    }
-    return legacy;
-}
-function readGE2IRCompositionMetadata(ir) {
-    if (ir.source !== 'ge') {
-        return undefined;
-    }
-    var metadata = ir.metadata;
-    if (metadata == null) {
-        return undefined;
-    }
-    var namespaced = metadata['ge2ir'];
-    return isRecord$4(namespaced) ? namespaced : undefined;
-}
-function isRecord$4(value) {
-    return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
-}
-
 function buildTransformAnimation(layer, ctx) {
-    var transform = layer.transform;
-    if (transform == null) {
+    if (layer.transform == null) {
         return {};
     }
-    var timeContext = getTimeContext(layer);
-    // Passthrough: ge2ir stores raw animation data in metadata to bypass the
+    // Passthrough: ge2ir stores raw animation data in specific.effects to bypass the
     // IR keyframe conversion pipeline. Raw GE data is used verbatim when
     // available; otherwise the standard IR → GE conversion runs.
-    var ge2irMetadata = readGE2IRMetadata(ctx.ir, layer);
-    var passthroughPosition = ge2irMetadata == null ? void 0 : ge2irMetadata.positionOverLifetime;
-    var passthroughRotation = ge2irMetadata == null ? void 0 : ge2irMetadata.rotationOverLifetime;
-    var passthroughSize = ge2irMetadata == null ? void 0 : ge2irMetadata.sizeOverLifetime;
-    var positionOverLifetime = passthroughPosition != null ? passthroughPosition : buildPositionAnim(transform, timeContext, ctx);
-    var rotationOverLifetime = passthroughRotation != null ? passthroughRotation : buildRotationAnim(transform, timeContext);
-    var sizeOverLifetime = passthroughSize != null ? passthroughSize : buildSizeAnim(transform, timeContext);
+    var effectsSpecific = getEffectsLayerSpecific(ctx.ir, layer);
+    var passthroughPosition = effectsSpecific == null ? void 0 : effectsSpecific.positionOverLifetime;
+    var passthroughRotation = effectsSpecific == null ? void 0 : effectsSpecific.rotationOverLifetime;
+    var passthroughSize = effectsSpecific == null ? void 0 : effectsSpecific.sizeOverLifetime;
+    var normalized = buildNormalizedTransformAnimation(layer, ctx);
+    var positionOverLifetime = passthroughPosition != null ? passthroughPosition : normalized.positionOverLifetime;
+    var rotationOverLifetime = passthroughRotation != null ? passthroughRotation : normalized.rotationOverLifetime;
+    var sizeOverLifetime = passthroughSize != null ? passthroughSize : normalized.sizeOverLifetime;
     return {
         positionOverLifetime: positionOverLifetime,
         rotationOverLifetime: rotationOverLifetime,
         sizeOverLifetime: sizeOverLifetime
     };
 }
-function buildPositionAnim(transform, timeContext, ctx) {
+/**
+ * Encode normalized IR transform channels as GE timeline payloads without
+ * consulting composition-specific passthrough data. Sibling converters use
+ * this when they need the canonical curve encoding for a preserved sub-scene.
+ */ function buildNormalizedTransformAnimation(layer, ctx) {
+    var transform = layer.transform;
+    if (transform == null) {
+        return {};
+    }
+    var timeContext = getTimeContext(layer);
+    return {
+        positionOverLifetime: buildPositionAnim(layer, transform, timeContext, ctx),
+        rotationOverLifetime: buildRotationAnim(transform, timeContext),
+        sizeOverLifetime: buildSizeAnim(transform, timeContext)
+    };
+}
+function buildPositionAnim(layer, transform, timeContext, ctx) {
     var _posResult_curves_;
+    var _posResult_pathPoints_;
     if (transform.position == null || !transform.position.keyframed) {
         return undefined;
     }
+    assertContiguousPositionSegments(transform.position, layer);
     var posResult = irPositionKeyframesToGE(transform.position, timeContext);
     if (posResult == null) {
         return undefined;
@@ -1776,28 +1794,28 @@ function buildPositionAnim(transform, timeContext, ctx) {
     var pathPoints = [];
     var controlPoints = [];
     var useKeyframeMode = shouldUseKeyframeMode(transform.position);
-    for(var _iterator = _create_for_of_iterator_helper_loose(posResult.pathPoints), _step; !(_step = _iterator()).done;){
-        var pp = _step.value;
-        var point3d = convert2dTo3dPoint(pp[0][0], pp[0][1], 0, ctx.width, ctx.height);
+    var firstPathPoint = (_posResult_pathPoints_ = posResult.pathPoints[0]) == null ? void 0 : _posResult_pathPoints_[0];
+    if (firstPathPoint != null) {
+        var point3d = convert2dTo3dPoint(firstPathPoint[0], firstPathPoint[1], 0, ctx.width, ctx.height);
         pathPoints.push(point3d);
     }
-    if (posResult.pathPoints.length > 0) {
-        var lastPp = posResult.pathPoints[posResult.pathPoints.length - 1];
-        var lastPoint3d = convert2dTo3dPoint(lastPp[1][0], lastPp[1][1], 0, ctx.width, ctx.height);
-        pathPoints.push(lastPoint3d);
+    for(var _iterator = _create_for_of_iterator_helper_loose(posResult.pathPoints), _step; !(_step = _iterator()).done;){
+        var pathPoint = _step.value;
+        var endPoint3d = convert2dTo3dPoint(pathPoint[1][0], pathPoint[1][1], 0, ctx.width, ctx.height);
+        pathPoints.push(endPoint3d);
     }
     for(var i = 0; i < posResult.controlPoints.length; i++){
         var cp = posResult.controlPoints[i];
-        var pp1 = posResult.pathPoints[i];
+        var pp = posResult.pathPoints[i];
         if (useKeyframeMode) {
-            var dx = pp1[1][0] - pp1[0][0];
-            var dy = pp1[1][1] - pp1[0][1];
-            var cp1 = convert2dTo3dPoint(dx / 3 + pp1[0][0], dy / 3 + pp1[0][1], 0, ctx.width, ctx.height);
-            var cp2 = convert2dTo3dPoint(-dx / 3 + pp1[1][0], -dy / 3 + pp1[1][1], 0, ctx.width, ctx.height);
+            var dx = pp[1][0] - pp[0][0];
+            var dy = pp[1][1] - pp[0][1];
+            var cp1 = convert2dTo3dPoint(dx / 3 + pp[0][0], dy / 3 + pp[0][1], 0, ctx.width, ctx.height);
+            var cp2 = convert2dTo3dPoint(-dx / 3 + pp[1][0], -dy / 3 + pp[1][1], 0, ctx.width, ctx.height);
             controlPoints.push(cp1, cp2);
         } else {
-            var cp11 = convert2dTo3dPoint(cp[0][0] + pp1[0][0], cp[0][1] + pp1[0][1], 0, ctx.width, ctx.height);
-            var cp21 = convert2dTo3dPoint(cp[1][0] + pp1[1][0], cp[1][1] + pp1[1][1], 0, ctx.width, ctx.height);
+            var cp11 = convert2dTo3dPoint(cp[0][0] + pp[0][0], cp[0][1] + pp[0][1], 0, ctx.width, ctx.height);
+            var cp21 = convert2dTo3dPoint(cp[1][0] + pp[1][0], cp[1][1] + pp[1][1], 0, ctx.width, ctx.height);
             controlPoints.push(cp11, cp21);
         }
     }
@@ -1836,112 +1854,39 @@ function buildPositionAnim(transform, timeContext, ctx) {
         ]
     };
 }
+function assertContiguousPositionSegments(position, layer) {
+    var _loop = function(index) {
+        var segmentEnd = position.keyframes[index].endValue;
+        var nextStart = position.keyframes[index + 1].value;
+        if (segmentEnd == null) {
+            return "continue";
+        }
+        var isContiguous = segmentEnd.every(function(value, dimension) {
+            return Math.abs(value - nextStart[dimension]) <= 1e-6;
+        });
+        if (!isContiguous) {
+            throw new Error("[ge-ir] Layer '" + layer.name + "' has a discontiguous position segment at keyframe " + index + "; " + 'GE path animation cannot preserve a segment endValue that differs from the next keyframe value.');
+        }
+    };
+    for(var index = 0; index < position.keyframes.length - 1; index++)_loop(index);
+}
 function buildRotationAnim(transform, timeContext) {
     var result = {};
-    var hasZ = false;
-    var hasX = false;
-    var hasY = false;
     var rotation = transform.rotation;
-    if (rotation != null) {
-        if (rotation.keyframed) {
-            var _curves_, _curves_1, _curves_2;
-            var curves = irVectorKeyframesToGE(rotation, timeContext);
-            if (curves != null && axisHasRotationValue(rotation, 0) && ((_curves_ = curves[0]) == null ? void 0 : _curves_.length)) {
-                result['x'] = [
-                    ValueType.BEZIER_CURVE,
-                    curves[0]
-                ];
-                hasX = true;
-            }
-            if (curves != null && axisHasRotationValue(rotation, 1) && ((_curves_1 = curves[1]) == null ? void 0 : _curves_1.length)) {
-                result['y'] = [
-                    ValueType.BEZIER_CURVE,
-                    curves[1]
-                ];
-                hasY = true;
-            }
-            if (curves != null && axisHasRotationValue(rotation, 2) && ((_curves_2 = curves[2]) == null ? void 0 : _curves_2.length)) {
-                result['z'] = [
-                    ValueType.BEZIER_CURVE,
-                    curves[2]
-                ];
-                hasZ = true;
-            }
-        } else if (rotation.value != null) {
-            var _rotation_value = rotation.value, tmp = _rotation_value[0], x = tmp === void 0 ? 0 : tmp, tmp1 = _rotation_value[1], y = tmp1 === void 0 ? 0 : tmp1, tmp2 = _rotation_value[2], z = tmp2 === void 0 ? 0 : tmp2;
-            if (Math.abs(x) > 0.0001) {
-                result['x'] = [
-                    ValueType.CONSTANT,
-                    x
-                ];
-                hasX = true;
-            }
-            if (Math.abs(y) > 0.0001) {
-                result['y'] = [
-                    ValueType.CONSTANT,
-                    y
-                ];
-                hasY = true;
-            }
-            if (Math.abs(z) > 0.0001) {
-                result['z'] = [
-                    ValueType.CONSTANT,
-                    z
-                ];
-                hasZ = true;
-            }
-        }
-    } else {
-        var _separated_x, _separated_x1, _separated_y, _separated_y1, _separated_z, _separated_z1;
-        var separated = transform.separatedRotation;
-        if (separated == null ? void 0 : (_separated_x = separated.x) == null ? void 0 : _separated_x.keyframed) {
-            var curves1 = irScalarKeyframesToGE(separated.x, timeContext);
-            if (curves1 != null) {
-                result['x'] = [
-                    ValueType.BEZIER_CURVE,
-                    curves1[0]
-                ];
-                hasX = true;
-            }
-        } else if ((separated == null ? void 0 : (_separated_x1 = separated.x) == null ? void 0 : _separated_x1.value) != null && separated.x.value !== 0) {
-            result['x'] = [
-                ValueType.CONSTANT,
-                separated.x.value
-            ];
-            hasX = true;
-        }
-        if (separated == null ? void 0 : (_separated_y = separated.y) == null ? void 0 : _separated_y.keyframed) {
-            var curves2 = irScalarKeyframesToGE(separated.y, timeContext);
-            if (curves2 != null) {
-                result['y'] = [
-                    ValueType.BEZIER_CURVE,
-                    curves2[0]
-                ];
-                hasY = true;
-            }
-        } else if ((separated == null ? void 0 : (_separated_y1 = separated.y) == null ? void 0 : _separated_y1.value) != null && separated.y.value !== 0) {
-            result['y'] = [
-                ValueType.CONSTANT,
-                separated.y.value
-            ];
-            hasY = true;
-        }
-        if (separated == null ? void 0 : (_separated_z = separated.z) == null ? void 0 : _separated_z.keyframed) {
-            var curves3 = irScalarKeyframesToGE(separated.z, timeContext);
-            if (curves3 != null) {
-                result['z'] = [
-                    ValueType.BEZIER_CURVE,
-                    curves3[0]
-                ];
-                hasZ = true;
-            }
-        } else if ((separated == null ? void 0 : (_separated_z1 = separated.z) == null ? void 0 : _separated_z1.value) != null && separated.z.value !== 0) {
-            result['z'] = [
-                ValueType.CONSTANT,
-                separated.z.value
-            ];
-            hasZ = true;
-        }
+    var x = buildRotationAxis(rotation == null ? void 0 : rotation.x, timeContext);
+    var y = buildRotationAxis(rotation == null ? void 0 : rotation.y, timeContext);
+    var z = buildRotationAxis(rotation == null ? void 0 : rotation.z, timeContext);
+    var hasX = x != null;
+    var hasY = y != null;
+    var hasZ = z != null;
+    if (x != null) {
+        result['x'] = x;
+    }
+    if (y != null) {
+        result['y'] = y;
+    }
+    if (z != null) {
+        result['z'] = z;
     }
     if (!hasZ && !hasX && !hasY) {
         return undefined;
@@ -1953,25 +1898,46 @@ function buildRotationAnim(transform, timeContext) {
     }
     return result;
 }
-function axisHasRotationValue(rotation, axis) {
-    var _ref;
-    var _rotation_keyframes;
-    if (!rotation.keyframed) {
-        var _ref1;
-        var _rotation_value;
-        return Math.abs((_ref1 = (_rotation_value = rotation.value) == null ? void 0 : _rotation_value[axis]) != null ? _ref1 : 0) > 0.0001;
+function buildRotationAxis(property, timeContext) {
+    if (property == null) {
+        return undefined;
     }
-    return (_ref = (_rotation_keyframes = rotation.keyframes) == null ? void 0 : _rotation_keyframes.some(function(keyframe) {
-        var _keyframe_value_axis, _ref;
+    if (!property.keyframed) {
+        return property.value !== 0 ? [
+            ValueType.CONSTANT,
+            property.value
+        ] : undefined;
+    }
+    if (property.keyframes.length === 1) {
+        var value = property.keyframes[0].value;
+        return value !== 0 ? [
+            ValueType.CONSTANT,
+            value
+        ] : undefined;
+    }
+    if (!axisHasRotationValue(property)) {
+        return undefined;
+    }
+    var curves = irScalarKeyframesToGE(property, timeContext);
+    return curves != null ? [
+        ValueType.BEZIER_CURVE,
+        curves[0]
+    ] : undefined;
+}
+function axisHasRotationValue(rotation) {
+    return rotation.keyframes.some(function(keyframe) {
         var _keyframe_endValue;
-        return Math.abs((_keyframe_value_axis = keyframe.value[axis]) != null ? _keyframe_value_axis : 0) > 0.0001 || Math.abs((_ref = (_keyframe_endValue = keyframe.endValue) == null ? void 0 : _keyframe_endValue[axis]) != null ? _ref : 0) > 0.0001;
-    })) != null ? _ref : false;
+        return Math.abs(keyframe.value) > 0.0001 || Math.abs((_keyframe_endValue = keyframe.endValue) != null ? _keyframe_endValue : 0) > 0.0001;
+    });
 }
 function buildSizeAnim(transform, timeContext) {
     if (transform.scale == null) {
         return undefined;
     }
     if (transform.scale.keyframed) {
+        if (transform.scale.keyframes.length === 1) {
+            return buildConstantSizeAnimation(transform.scale.keyframes[0].value);
+        }
         var curves = irVectorKeyframesToGE(transform.scale, timeContext);
         if (curves != null && curves.length >= 2) {
             return _extends({
@@ -1993,33 +1959,37 @@ function buildSizeAnim(transform, timeContext) {
         }
         return undefined;
     }
-    var scale = transform.scale.value;
-    if (Array.isArray(scale) && (Math.abs(scale[0] - 1) > 0.0001 || Math.abs(scale[1] - 1) > 0.0001)) {
-        var _scale_;
-        return {
-            separateAxes: true,
-            x: [
-                ValueType.CONSTANT,
-                scale[0]
-            ],
-            y: [
-                ValueType.CONSTANT,
-                scale[1]
-            ],
-            z: [
-                ValueType.CONSTANT,
-                (_scale_ = scale[2]) != null ? _scale_ : 1
-            ]
-        };
+    return buildConstantSizeAnimation(transform.scale.value);
+}
+function buildConstantSizeAnimation(scale) {
+    if (Math.abs(scale[0] - 1) <= 0.0001 && Math.abs(scale[1] - 1) <= 0.0001) {
+        return undefined;
     }
-    return undefined;
+    return {
+        separateAxes: true,
+        x: [
+            ValueType.CONSTANT,
+            scale[0]
+        ],
+        y: [
+            ValueType.CONSTANT,
+            scale[1]
+        ],
+        z: [
+            ValueType.CONSTANT,
+            scale[2]
+        ]
+    };
 }
 function buildColorAnimation(layer, ir) {
-    var _readGE2IRMetadata;
-    var passthroughColor = (_readGE2IRMetadata = readGE2IRMetadata(ir, layer)) == null ? void 0 : _readGE2IRMetadata.colorOverLifetime;
+    var _getEffectsLayerSpecific;
+    var passthroughColor = (_getEffectsLayerSpecific = getEffectsLayerSpecific(ir, layer)) == null ? void 0 : _getEffectsLayerSpecific.colorOverLifetime;
     if (passthroughColor != null) {
         return passthroughColor;
     }
+    return buildNormalizedColorAnimation(layer);
+}
+/** Encode normalized IR opacity as a GE color-over-lifetime payload. */ function buildNormalizedColorAnimation(layer) {
     var transform = layer.transform;
     if ((transform == null ? void 0 : transform.opacity) == null) {
         return undefined;
@@ -2034,6 +2004,15 @@ function buildColorAnimation(layer, ir) {
         };
     }
     if (transform.opacity.keyframed) {
+        if (transform.opacity.keyframes.length === 1) {
+            var opacityValue = transform.opacity.keyframes[0].value;
+            return opacityValue !== 1 ? {
+                opacity: [
+                    ValueType.CONSTANT,
+                    opacityValue
+                ]
+            } : undefined;
+        }
         var curves = irScalarKeyframesToGE(transform.opacity, timeContext);
         if (curves != null) {
             return {
@@ -2045,12 +2024,12 @@ function buildColorAnimation(layer, ir) {
         }
         return undefined;
     }
-    var opacityValue = transform.opacity.value;
-    if (typeof opacityValue === 'number' && opacityValue !== 1) {
+    var opacityValue1 = transform.opacity.value;
+    if (typeof opacityValue1 === 'number' && opacityValue1 !== 1) {
         return {
             opacity: [
                 ValueType.CONSTANT,
-                opacityValue
+                opacityValue1
             ]
         };
     }
@@ -2132,18 +2111,20 @@ function mapBlendingMode(blendMode) {
     return GE_BLENDING_BY_IR_MODE[blendMode];
 }
 
-var DEFAULT_DISPLAY_SIZE = {
+var DEFAULT_LOCAL_BOUNDS = {
+    x: 0,
+    y: 0,
     width: 1,
     height: 1
 };
 /**
- * Read the producer-baked display size from an IR layer. When the producer
- * did not resolve one, returns `fallback` (defaults to `{ 1, 1 }` — the
- * value every existing call site was using inline).
- */ function getLayerDisplaySize(layer, fallback) {
-    if (fallback === void 0) fallback = DEFAULT_DISPLAY_SIZE;
-    var _layer_displaySize;
-    return (_layer_displaySize = layer.displaySize) != null ? _layer_displaySize : fallback;
+ * Read source-neutral local bounds from an IR layer. When the producer
+ * did not resolve one, returns `fallback` (defaults to bounds at the origin
+ * with a one-pixel width and height).
+ */ function getLayerLocalBounds(layer, fallback) {
+    if (fallback === void 0) fallback = DEFAULT_LOCAL_BOUNDS;
+    var _layer_localBounds;
+    return (_layer_localBounds = layer.localBounds) != null ? _layer_localBounds : fallback;
 }
 
 function buildComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
@@ -2160,21 +2141,20 @@ function buildComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
     }
 }
 /**
- * Copy the raw GE mask object (from ge2ir passthrough metadata) onto a freshly
+ * Copy the raw GE mask object (from specific.effects passthrough) onto a freshly
  * built component, as a top-level `mask` field matching GE's structure. For a
  * mask SOURCE this carries `{isMask:true, alphaMaskEnabled}`; for a TARGET it
  * carries `{isMask:false, reference, inverted}` where `reference.id` is still
- * the stale GE1 component id — `applyGeMaskRemap` rewrites it in post-process.
- * No-op for non-ge sources (Lottie masks go through the IRLayerNode.mask path).
- */ function applyGeMask(ir, layer, component) {
-    var _readGE2IRMetadata;
-    var geMask = (_readGE2IRMetadata = readGE2IRMetadata(ir, layer)) == null ? void 0 : _readGE2IRMetadata.geMask;
-    if (geMask != null && component['mask'] == null) {
-        component['mask'] = _extends({}, geMask);
+ * the stale GE1 component id — `applyGEMaskRemap` rewrites it in post-process.
+ * No-op for non-GE sources (Lottie masks go through the IRLayerNode.mask path).
+ */ function applyGEMask(ir, layer, component) {
+    var _getEffectsLayerSpecific;
+    var effectsMask = (_getEffectsLayerSpecific = getEffectsLayerSpecific(ir, layer)) == null ? void 0 : _getEffectsLayerSpecific.mask;
+    if (effectsMask != null && component['mask'] == null) {
+        component['mask'] = _extends({}, effectsMask);
     }
 }
 function buildSpriteComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
-    var _ref;
     var _layer_asset, _layer_asset1;
     var componentId = createId();
     var blending = mapBlendingMode(layer.blendMode);
@@ -2190,7 +2170,8 @@ function buildSpriteComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
         1
     ];
     var textureDataPath;
-    var textureUrl = (_ref = (_layer_asset = layer.asset) == null ? void 0 : _layer_asset.url) != null ? _ref : (_layer_asset1 = layer.asset) == null ? void 0 : _layer_asset1.refId;
+    var assetUrl = (_layer_asset = layer.asset) == null ? void 0 : _layer_asset.url;
+    var textureUrl = assetUrl != null && assetUrl !== '' ? assetUrl : (_layer_asset1 = layer.asset) == null ? void 0 : _layer_asset1.refId;
     if (textureUrl != null && textureUrl !== '' && textureUrl !== 'mask://placeholder') {
         textureDataPath = registerTexture(ctx.collector, textureUrl, ctx.textureCache);
     }
@@ -2216,7 +2197,7 @@ function buildSpriteComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
             roundNumber(anchorScaleY, 4)
         ];
     }
-    applyGeMask(ctx.ir, layer, component);
+    applyGEMask(ctx.ir, layer, component);
     ctx.collector.components.push(component);
     return componentId;
 }
@@ -2237,7 +2218,7 @@ function buildTextComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
     var textWidth = (_textInfo_width = textInfo.width) != null ? _textInfo_width : estimateTextWidth(textInfo.content, textInfo.fontSize, textInfo.letterSpacing);
     var lineHeight = typeof textInfo.lineHeight === 'number' && textInfo.lineHeight > 0 ? textInfo.lineHeight : textInfo.fontSize;
     var textHeight = Math.max((_textInfo_height = textInfo.height) != null ? _textInfo_height : textInfo.fontSize * 1.2, lineHeight);
-    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var _getLayerLocalBounds = getLayerLocalBounds(layer), layerWidth = _getLayerLocalBounds.width, layerHeight = _getLayerLocalBounds.height;
     var textSizeW = roundNumber(ctx.ratio * layerWidth, 4);
     var textSizeH = roundNumber(ctx.ratio * layerHeight, 4);
     var component = {
@@ -2272,7 +2253,7 @@ function buildTextComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx) {
             blending: blending
         })
     };
-    applyGeMask(ctx.ir, layer, component);
+    applyGEMask(ctx.ir, layer, component);
     ctx.collector.components.push(component);
     return componentId;
 }
@@ -2294,7 +2275,7 @@ function buildShapeComponent(layer, itemId, ctx) {
             blending: blending
         })
     });
-    applyGeMask(ctx.ir, layer, component);
+    applyGEMask(ctx.ir, layer, component);
     ctx.collector.components.push(component);
     return componentId;
 }
@@ -2302,21 +2283,35 @@ function buildShapeOptions(shapeData, ratio, ctx) {
     var options = {
         type: mapShapePrimitiveType(shapeData.primitiveType)
     };
-    if (shapeData.size != null) {
-        options['xSize'] = roundNumber(shapeData.size[0] * ratio, 4);
-        options['ySize'] = roundNumber(shapeData.size[1] * ratio, 4);
-    }
-    setScaledNumber(options, shapeData, 'xRadius', ratio);
-    setScaledNumber(options, shapeData, 'yRadius', ratio);
-    setScaledNumber(options, shapeData, 'width', ratio);
-    setScaledNumber(options, shapeData, 'height', ratio);
-    setScaledNumber(options, shapeData, 'innerRadius', ratio);
-    setScaledNumber(options, shapeData, 'outerRadius', ratio);
-    setScaledNumber(options, shapeData, 'radius', ratio);
-    setRawNumber(options, shapeData, 'roundness');
-    setRawNumber(options, shapeData, 'pointCount');
-    setRawNumber(options, shapeData, 'innerRoundness');
-    setRawNumber(options, shapeData, 'outerRoundness');
+    switch(shapeData.primitiveType){
+        case IRShapePrimitiveType.Custom:
+            Object.assign(options, mapCustomPaths(shapeData.customPaths, ratio));
+            break;
+        case IRShapePrimitiveType.Rectangle:
+            var _shapeData_roundness;
+            options['width'] = roundNumber(shapeData.width * ratio, 4);
+            options['height'] = roundNumber(shapeData.height * ratio, 4);
+            options['roundness'] = (_shapeData_roundness = shapeData.roundness) != null ? _shapeData_roundness : 0;
+            break;
+        case IRShapePrimitiveType.Ellipse:
+            options['xRadius'] = roundNumber(shapeData.xRadius * ratio, 4);
+            options['yRadius'] = roundNumber(shapeData.yRadius * ratio, 4);
+            break;
+        case IRShapePrimitiveType.Polygon:
+            var _shapeData_roundness1;
+            options['pointCount'] = shapeData.pointCount;
+            options['radius'] = roundNumber(shapeData.radius * ratio, 4);
+            options['roundness'] = (_shapeData_roundness1 = shapeData.roundness) != null ? _shapeData_roundness1 : 0;
+            break;
+        case IRShapePrimitiveType.Star:
+            var _shapeData_innerRoundness, _shapeData_outerRoundness;
+            options['pointCount'] = shapeData.pointCount;
+            options['innerRadius'] = roundNumber(shapeData.innerRadius * ratio, 4);
+            options['outerRadius'] = roundNumber(shapeData.outerRadius * ratio, 4);
+            options['innerRoundness'] = (_shapeData_innerRoundness = shapeData.innerRoundness) != null ? _shapeData_innerRoundness : 0;
+            options['outerRoundness'] = (_shapeData_outerRoundness = shapeData.outerRoundness) != null ? _shapeData_outerRoundness : 0;
+            break;
+    }
     if (shapeData.fills != null && shapeData.fills.length > 0) {
         options['fills'] = shapeData.fills.map(function(fill) {
             return mapShapePaint(fill, ratio, ctx);
@@ -2344,18 +2339,6 @@ function buildShapeOptions(shapeData, ratio, ctx) {
     if (shapeData.strokeJoin != null) {
         options['strokeJoin'] = mapLineJoin(shapeData.strokeJoin);
     }
-    if (shapeData.fillRule != null) {
-        options['fillRule'] = mapShapeFillRule(shapeData.fillRule);
-    }
-    if (shapeData.customPaths != null && shapeData.customPaths.length > 0) {
-        Object.assign(options, mapCustomPaths(shapeData.customPaths, ratio));
-    }
-    if (shapeData.trimPath != null) {
-        options['trimPath'] = shapeData.trimPath;
-    }
-    if (shapeData.repeater != null) {
-        options['repeater'] = shapeData.repeater;
-    }
     return options;
 }
 var _obj;
@@ -2366,8 +2349,6 @@ var _obj2;
 var LINE_CAP_TO_GE = (_obj2 = {}, _obj2[IRLineCap.Butt] = 0, _obj2[IRLineCap.Round] = 1, _obj2[IRLineCap.Square] = 2, _obj2);
 var _obj3;
 var LINE_JOIN_TO_GE = (_obj3 = {}, _obj3[IRLineJoin.Round] = 0, _obj3[IRLineJoin.Bevel] = 1, _obj3[IRLineJoin.Miter] = 2, _obj3);
-var _obj4;
-var SHAPE_FILL_RULE_TO_GE = (_obj4 = {}, _obj4[IRShapeFillRule.NonZero] = 0, _obj4[IRShapeFillRule.EvenOdd] = 1, _obj4);
 function mapShapePrimitiveType(primitiveType) {
     return SHAPE_PRIMITIVE_TYPE_TO_GE[primitiveType];
 }
@@ -2379,10 +2360,6 @@ function mapLineJoin(lineJoin) {
     var _LINE_JOIN_TO_GE_lineJoin;
     return (_LINE_JOIN_TO_GE_lineJoin = LINE_JOIN_TO_GE[lineJoin]) != null ? _LINE_JOIN_TO_GE_lineJoin : 2;
 }
-function mapShapeFillRule(fillRule) {
-    var _SHAPE_FILL_RULE_TO_GE_fillRule;
-    return (_SHAPE_FILL_RULE_TO_GE_fillRule = SHAPE_FILL_RULE_TO_GE[fillRule]) != null ? _SHAPE_FILL_RULE_TO_GE_fillRule : 0;
-}
 function mapShapePaint(paint, ratio, ctx) {
     if (paint.type === IRFillType.Solid) {
         return {
@@ -2391,7 +2368,7 @@ function mapShapePaint(paint, ratio, ctx) {
         };
     }
     if (paint.type === IRFillType.LinearGradient || paint.type === IRFillType.RadialGradient || paint.type === IRFillType.AngularGradient) {
-        return _extends({
+        return {
             type: FILL_TYPE_TO_GE[paint.type],
             gradientStops: [
                 ValueType.GRADIENT_COLOR,
@@ -2399,13 +2376,12 @@ function mapShapePaint(paint, ratio, ctx) {
             ],
             startPoint: vec2ToGE(paint.gradientStart, ratio),
             endPoint: vec2ToGE(paint.gradientEnd, ratio)
-        }, paint.color != null && {
-            color: colorToGE(paint.color)
-        });
+        };
     }
     if (paint.type === IRFillType.Texture) {
-        var _ref, _paint_texture_url, _paint_scaleMode;
-        var textureUrl = (_ref = (_paint_texture_url = paint.texture.url) != null ? _paint_texture_url : paint.texture.refId) != null ? _ref : paint.texture.id;
+        var _paint_scaleMode;
+        var textureAssetUrl = paint.texture.url;
+        var textureUrl = textureAssetUrl != null && textureAssetUrl !== '' ? textureAssetUrl : paint.texture.refId;
         var texture = textureUrl != null && ctx != null ? registerTexture(ctx.collector, textureUrl, ctx.textureCache) : undefined;
         return _extends({
             type: FILL_TYPE_TO_GE[paint.type]
@@ -2443,8 +2419,8 @@ function mapCustomPaths(paths, ratio) {
         for(var index = 0; index < path.points.length; index++){
             var _ref, _ref1, _ref2, _ref3;
             var point = path.points[index];
-            var easingIn = path.easingIns[index];
-            var easingOut = path.easingOuts[index];
+            var easingIn = path.inTangents[index];
+            var easingOut = path.outTangents[index];
             var pointIndex = points.length;
             points.push({
                 x: roundNumber(point.x * ratio, 4),
@@ -2465,7 +2441,7 @@ function mapCustomPaths(paths, ratio) {
             });
         }
         shapes.push({
-            close: path.close,
+            close: path.closed,
             indexes: indexes
         });
     }
@@ -2476,100 +2452,54 @@ function mapCustomPaths(paths, ratio) {
         shapes: shapes
     };
 }
-function setScaledNumber(options, shapeData, key, ratio) {
-    var value = shapeData[key];
-    if (typeof value === 'number') {
-        options[key] = roundNumber(value * ratio, 4);
-    }
-}
-function setRawNumber(options, shapeData, key) {
-    var value = shapeData[key];
-    if (typeof value === 'number') {
-        options[key] = value;
-    }
-}
 
-function getStaticAnchorBehavior(ir, layer) {
-    if (layer.transformSplit === true) {
+function planGELayerLowering(ir, layer) {
+    var _getEffectsLayerSpecific;
+    var sourceHierarchy = (_getEffectsLayerSpecific = getEffectsLayerSpecific(ir, layer)) == null ? void 0 : _getEffectsLayerSpecific.sourceHierarchy;
+    if (sourceHierarchy === 'null-sprite-pair') {
         return {
             kind: 'split-null-sprite'
         };
     }
-    // B-class real semantic difference — kept as source branch because pre-baking
-    // anchorScale/anchorOffset into the IR would require pulling computeAnchorInfo's
-    // full input set (text anchorAdjust, static-rotation anchor rotation, display
-    // size fallback) into the producer, at high cost with no readability benefit.
-    // The split gate itself is already pre-baked via `transformSplit` above.
-    //
-    // ge source shares the lottie inline-anchor math: ge2ir reverses GE's
-    // `renderer.anchor` into IRLayerNode.transform.anchor (px) + displaySize, so
-    // computeAnchorInfo reproduces the exact anchorScale/anchorOffset that GE had.
-    // Without this, ge layers fall through to the centered [0.5,0.5] default and
-    // their authored anchor (e.g. a top-anchored sweep) is lost on round-trip.
-    // ge never reaches the lottieNeedsTransformSplit geometry check — its split
-    // decision is pre-baked via `transformSplit` by the ge2ir null+sprite merger.
-    if (ir.source === 'lottie' || ir.source === 'ge') {
-        if (ir.source === 'lottie' && lottieNeedsTransformSplit(layer)) {
-            return {
-                kind: 'split-null-sprite'
-            };
-        }
-        // The inline-anchor math needs non-zero dimensions to avoid divide-by-zero
-        // in `computeAnchorInfo`; substitute the legacy {1, 1} fallback at the call site
-        // so the field-level default stays neutral.
-        var _getLayerDisplaySize = getLayerDisplaySize(layer), width = _getLayerDisplaySize.width, height = _getLayerDisplaySize.height;
-        var info = computeAnchorInfo(layer, width, height);
+    var bounds = getLayerLocalBounds(layer);
+    if (sourceHierarchy !== 'single-item' && needsPivotContainer(layer, bounds)) {
         return {
-            kind: 'inline-anchor',
-            anchorScale: [
-                info.anchorScaleX,
-                info.anchorScaleY
-            ],
-            anchorOffset: [
-                info.anchorOffsetX,
-                info.anchorOffsetY
-            ]
+            kind: 'split-null-sprite'
         };
     }
-    // dsl layers with off-center anchor have `transformSplit = true` set by the
-    // producer, caught by the guard at the top. Any layer reaching here is
-    // centered — return the default inline-anchor.
+    var info = computeAnchorInfo(layer, bounds);
     return {
         kind: 'inline-anchor',
         anchorScale: [
-            0.5,
-            0.5
+            info.anchorScaleX,
+            info.anchorScaleY
         ],
         anchorOffset: [
-            0,
-            0
+            info.anchorOffsetX,
+            info.anchorOffsetY
         ]
     };
 }
-function lottieNeedsTransformSplit(layer) {
-    var _transform_rotation, _sep_x, _sep_y, _sep_z, _transform_scale;
+function needsPivotContainer(layer, bounds) {
+    var _rotation_x, _rotation_y, _rotation_z, _transform_scale;
     if (layer.type !== 'image' && layer.type !== 'solid') {
         return false;
     }
-    // Without a producer-baked displaySize we cannot decide off-center;
-    // fall through to inline-anchor (matches the pre-displaySize behavior
-    // where missing dimensions returned the {1, 1} default and never split).
-    var size = layer.displaySize;
-    if (size == null) {
+    if (layer.localBounds == null) {
         return false;
     }
-    var width = size.width, height = size.height;
+    var x = bounds.x, y = bounds.y, width = bounds.width, height = bounds.height;
     if (width <= 0 || height <= 0) {
         return false;
     }
     var anchor = getStaticAnchor(layer);
-    var anchorOffCenter = Math.abs(anchor[0] - width / 2) > 0.5 || Math.abs(anchor[1] - height / 2) > 0.5;
+    var anchorOffCenter = Math.abs(anchor[0] - (x + width / 2)) > 0.5 || Math.abs(anchor[1] - (y + height / 2)) > 0.5;
     if (!anchorOffCenter) {
         return false;
     }
     var transform = layer.transform;
-    var sep = transform == null ? void 0 : transform.separatedRotation;
-    var hasRotationAnim = (transform == null ? void 0 : (_transform_rotation = transform.rotation) == null ? void 0 : _transform_rotation.keyframed) === true || (sep == null ? void 0 : (_sep_x = sep.x) == null ? void 0 : _sep_x.keyframed) === true || (sep == null ? void 0 : (_sep_y = sep.y) == null ? void 0 : _sep_y.keyframed) === true || (sep == null ? void 0 : (_sep_z = sep.z) == null ? void 0 : _sep_z.keyframed) === true;
+    var rotation = transform == null ? void 0 : transform.rotation;
+    var hasRotationAnim = (rotation == null ? void 0 : (_rotation_x = rotation.x) == null ? void 0 : _rotation_x.keyframed) === true || (rotation == null ? void 0 : (_rotation_y = rotation.y) == null ? void 0 : _rotation_y.keyframed) === true || (rotation == null ? void 0 : (_rotation_z = rotation.z) == null ? void 0 : _rotation_z.keyframed) === true;
     var hasScaleAnim = (transform == null ? void 0 : (_transform_scale = transform.scale) == null ? void 0 : _transform_scale.keyframed) === true;
     return hasRotationAnim || hasScaleAnim;
 }
@@ -2578,7 +2508,7 @@ function processNullLayer(layer, ctx) {
     var itemId = createId();
     var layerIndex = layer.index;
     ctx.layerToItemId[layerIndex] = itemId;
-    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate, ctx.ir.inPoint), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
     var animation = buildTransformAnimation(layer, ctx);
     var position = computeStaticPosition(layer, ctx);
     var objectBindingTrackId = buildTimelineTracks(ctx.collector, delay, layerDuration, 4, animation, 'null');
@@ -2588,7 +2518,7 @@ function processNullLayer(layer, ctx) {
         name: layer.name,
         duration: layerDuration,
         type: '3',
-        visible: layer.visibility.enabled && !layer.visibility.hidden,
+        visible: layer.visible,
         endBehavior: 4,
         delay: delay,
         renderLevel: 'B+',
@@ -2624,19 +2554,19 @@ function processPrecompLayer(layer, ctx) {
     var itemId = createId();
     var layerIndex = layer.index;
     ctx.layerToItemId[layerIndex] = itemId;
-    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate, ctx.ir.inPoint), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
     var animation = buildTransformAnimation(layer, ctx);
     var position = computeStaticPosition(layer, ctx);
     var objectBindingTrackId = buildTimelineTracks(ctx.collector, delay, layerDuration, 4, animation, 'precomp');
-    var geMetadata = readGE2IRMetadata(ctx.ir, layer);
-    var content = buildPrecompContent(geMetadata == null ? void 0 : geMetadata.precompContent, geMetadata == null ? void 0 : geMetadata.precompRefId);
+    var effectsSpecific = getEffectsLayerSpecific(ctx.ir, layer);
+    var content = buildPrecompContent(effectsSpecific == null ? void 0 : effectsSpecific.precompContent, effectsSpecific == null ? void 0 : effectsSpecific.precompRefId);
     var item = {
         id: itemId,
         dataType: 'VFXItemData',
         name: layer.name,
         duration: layerDuration,
         type: '7',
-        visible: layer.visibility.enabled && !layer.visibility.hidden,
+        visible: layer.visible,
         endBehavior: 4,
         delay: delay,
         renderLevel: 'B+',
@@ -2680,14 +2610,13 @@ function isRecord$3(value) {
  * the layer's logical position; the sprite/text child carries the visual
  * content offset by the anchor so the pivot is at the right point.
  *
- * Used by both `processParentLayer` (layers referenced as `parent` by others)
- * and `processTransformSplitLayer` (layers with `transformSplit=true`). The
- * only knob is `childScale` — parent-layer callers pass a text-aware scale
- * while transformSplit always uses `[1, 1, 1]`.
- */ function emitNullSpritePair(layer, ctx, childScale) {
+ * Used by both `processParentLayer` and GE lowering for layers that require a
+ * pivot container.
+ */ function emitNullSpritePair(layer, ctx) {
     var layerIndex = layer.index;
-    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
-    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate, ctx.ir.inPoint), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    var bounds = getLayerLocalBounds(layer);
+    var x = bounds.x, y = bounds.y, layerWidth = bounds.width, layerHeight = bounds.height;
     var nullItemId = createId();
     ctx.layerToItemId[layerIndex] = nullItemId;
     var nullAnimation = buildTransformAnimation(layer, ctx);
@@ -2732,9 +2661,11 @@ function isRecord$3(value) {
     });
     var childItemId = createId();
     var anchor = getStaticAnchor(layer);
+    var centerX = x + layerWidth / 2;
+    var centerY = y + layerHeight / 2;
     var childPosition = [
-        -ctx.ratio * (anchor[0] - layerWidth / 2),
-        ctx.ratio * (anchor[1] - layerHeight / 2),
+        -ctx.ratio * (anchor[0] - centerX),
+        ctx.ratio * (anchor[1] - centerY),
         0
     ];
     var childColorAnim = buildColorAnimation(layer, ctx.ir);
@@ -2747,13 +2678,22 @@ function isRecord$3(value) {
     }
     var scaledW = roundNumber(ctx.ratio * layerWidth, 4);
     var scaledH = roundNumber(ctx.ratio * layerHeight, 4);
+    var childScale = layer.type === 'text' ? [
+        scaledW,
+        scaledH,
+        1
+    ] : [
+        1,
+        1,
+        1
+    ];
     var childItem = {
         id: childItemId,
         dataType: 'VFXItemData',
         name: layer.name,
         duration: layerDuration,
         type: getGEItemTypeCode(layer.type),
-        visible: layer.visibility.enabled && !layer.visibility.hidden,
+        visible: layer.visible,
         endBehavior: 0,
         delay: delay,
         renderLevel: 'B+',
@@ -2784,35 +2724,24 @@ function isRecord$3(value) {
     });
 }
 function processParentLayer(layer, ctx) {
-    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
-    var scaledW = roundNumber(ctx.ratio * layerWidth, 4);
-    var scaledH = roundNumber(ctx.ratio * layerHeight, 4);
-    var childScale = layer.type === 'text' ? [
-        scaledW,
-        scaledH,
-        1
-    ] : [
-        1,
-        1,
-        1
-    ];
-    emitNullSpritePair(layer, ctx, childScale);
+    emitNullSpritePair(layer, ctx);
 }
 function processVisualLayer(layer, ctx) {
-    if (layer.type === 'shape' && layer.shapes != null && layer.shapes.length > 0) {
-        processShapeLayerMultiItem(layer, ctx);
+    var strategy = planGELayerLowering(ctx.ir, layer);
+    if (strategy.kind === 'split-null-sprite') {
+        processPivotContainerLayer(layer, ctx);
         return;
     }
-    var strategy = getStaticAnchorBehavior(ctx.ir, layer);
-    if (strategy.kind === 'split-null-sprite') {
-        processTransformSplitLayer(layer, ctx);
+    if (layer.type === 'shape' && layer.shapes != null && layer.shapes.length > 0) {
+        processShapeLayerMultiItem(layer, ctx);
         return;
     }
     var itemId = createId();
     var layerIndex = layer.index;
     ctx.layerToItemId[layerIndex] = itemId;
-    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
-    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate, ctx.ir.inPoint), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    var bounds = getLayerLocalBounds(layer);
+    var layerWidth = bounds.width, layerHeight = bounds.height;
     var scaledW = ctx.ratio * layerWidth;
     var scaledH = ctx.ratio * layerHeight;
     var _strategy_anchorScale = strategy.anchorScale, anchorScaleX = _strategy_anchorScale[0], anchorScaleY = _strategy_anchorScale[1];
@@ -2823,7 +2752,7 @@ function processVisualLayer(layer, ctx) {
         colorOverLifetime: colorAnimation
     });
     var rawPosition = computeStaticPosition(layer, ctx, anchorOffsetX, anchorOffsetY);
-    var position = applyScalePositionAdjust(rawPosition, layer, layerWidth, layerHeight, ctx.ratio);
+    var position = applyScalePositionAdjust(rawPosition, layer, bounds, ctx.ratio);
     var itemType = getGEItemType(layer.type);
     var objectBindingTrackId = buildTimelineTracks(ctx.collector, delay, layerDuration, 0, fullAnimation, itemType);
     var componentId = buildComponent(layer, itemId, anchorScaleX, anchorScaleY, ctx);
@@ -2850,7 +2779,7 @@ function processVisualLayer(layer, ctx) {
         name: layer.name,
         duration: layerDuration,
         type: getGEItemTypeCode(layer.type),
-        visible: layer.visibility.enabled && !layer.visibility.hidden,
+        visible: layer.visible,
         endBehavior: 0,
         delay: delay,
         renderLevel: 'B+',
@@ -2879,19 +2808,24 @@ function processVisualLayer(layer, ctx) {
         layerIndex: layerIndex
     });
 }
-function processTransformSplitLayer(layer, ctx) {
-    emitNullSpritePair(layer, ctx, [
-        1,
-        1,
-        1
-    ]);
+function processPivotContainerLayer(layer, ctx) {
+    emitNullSpritePair(layer, ctx);
 }
 function processShapeLayerMultiItem(layer, ctx) {
     var layerIndex = layer.index;
-    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
-    var _getLayerDisplaySize = getLayerDisplaySize(layer), layerWidth = _getLayerDisplaySize.width, layerHeight = _getLayerDisplaySize.height;
+    var _computeLayerTiming = computeLayerTiming(layer, ctx.frameRate, ctx.ir.inPoint), delay = _computeLayerTiming.delay, layerDuration = _computeLayerTiming.layerDuration;
+    // A GE Shape item commonly has no transform.size, so ge2ir cannot recover
+    // layer-local bounds. Treat missing bounds as empty here: the generic 1×1
+    // fallback would invent a half-pixel anchor offset and shift every rebuilt
+    // shape (notably mask sources) away from its authored position.
+    var bounds = getLayerLocalBounds(layer, {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+    });
     var anchor = getStaticAnchor(layer);
-    var _computeAnchorInfo = computeAnchorInfo(layer, layerWidth, layerHeight), anchorOffsetX = _computeAnchorInfo.anchorOffsetX, anchorOffsetY = _computeAnchorInfo.anchorOffsetY;
+    var _computeAnchorInfo = computeAnchorInfo(layer, bounds), anchorOffsetX = _computeAnchorInfo.anchorOffsetX, anchorOffsetY = _computeAnchorInfo.anchorOffsetY;
     var animation = buildTransformAnimation(layer, ctx);
     var colorAnimation = buildColorAnimation(layer, ctx.ir);
     var fullAnimation = _extends({}, animation, {
@@ -2926,7 +2860,7 @@ function processShapeLayerMultiItem(layer, ctx) {
         });
         // Mask source shape (isMask:true) — copy onto the first shape item only.
         if (shapeIdx === 0) {
-            applyGeMask(ctx.ir, layer, component);
+            applyGEMask(ctx.ir, layer, component);
         }
         ctx.collector.components.push(component);
         if (shapeIdx === 0) {
@@ -2939,7 +2873,7 @@ function processShapeLayerMultiItem(layer, ctx) {
             name: shapeIdx === 0 ? layer.name : layer.name + "_shape_" + shapeIdx,
             duration: layerDuration,
             type: 'shape',
-            visible: layer.visibility.enabled && !layer.visibility.hidden,
+            visible: layer.visible,
             endBehavior: 0,
             delay: delay,
             renderLevel: 'B+',
@@ -3072,16 +3006,20 @@ function deriveDuration(ir) {
 }
 /**
  * Map IR composition end behavior to GE's numeric end-behavior.
- * Lottie IR currently leaves this unset; treat undefined as Loop (5) so the
- * legacy lottie behavior is preserved. dsl2ge writes either Loop or Stop.
+ * Undefined defaults to Restart (5) for backward compatibility. DSL's boolean
+ * loop flag maps to either Restart or Destroy at the adapter boundary.
  */ function mapCompositionEndBehavior(eb) {
-    if (eb == null || eb === IREndBehavior.Loop) {
-        return 5;
-    }
-    if (eb === IREndBehavior.Hold) {
-        return 4;
+    switch(eb){
+        case undefined:
+        case IREndBehavior.Restart:
+            return 5;
+        case IREndBehavior.Forward:
+            return 2;
+        case IREndBehavior.Freeze:
+            return 4;
+        case IREndBehavior.Destroy:
+            return 0;
     }
-    return 0;
 }
 function colorToRoundedRgba(color) {
     return [
@@ -3152,13 +3090,10 @@ function applyMasks(ir, collector, processedItems, ratio, width, height, frameRa
             continue;
         }
         var layerComponentId = lookup.getComponentId(layer.index);
-        buildMaskForLayer(layer, layerItemId, layerComponentId, collector, processedItems, ratio, width, height, frameRate, lookup, maskSlotMeta, componentById, maskData);
+        buildMaskForLayer(layer, layerItemId, layerComponentId, collector, processedItems, ratio, width, height, frameRate, ir.inPoint, lookup, maskSlotMeta, componentById, maskData);
     }
 }
-function getPrimaryPath(mask) {
-    return mask.paths[0];
-}
-function buildMaskForLayer(layer, layerItemId, layerComponentId, collector, processedItems, ratio, width, height, frameRate, lookup, maskSlotMeta, componentById, maskData) {
+function buildMaskForLayer(layer, layerItemId, layerComponentId, collector, processedItems, ratio, width, height, frameRate, compositionInPoint, lookup, maskSlotMeta, componentById, maskData) {
     var mask = maskData != null ? maskData : layer.mask;
     var maskItemId = createId();
     var maskComponentId = createId();
@@ -3166,7 +3101,7 @@ function buildMaskForLayer(layer, layerItemId, layerComponentId, collector, proc
     var _getStaticAnchor = getStaticAnchor(layer), anchorX = _getStaticAnchor[0], anchorY = _getStaticAnchor[1];
     var maskPosX = roundNumber((maskBounds.cx - anchorX) * ratio, 4);
     var maskPosY = roundNumber(-(maskBounds.cy - anchorY) * ratio, 4);
-    var timing = computeLayerTiming(layer, frameRate);
+    var timing = computeLayerTiming(layer, frameRate, compositionInPoint);
     var delay = timing.delay;
     var maskDuration = timing.layerDuration;
     var layerIsParent = lookup.isParentLayer(layer.index) || layer.type === 'null' || layer.type === 'precomp';
@@ -3358,8 +3293,8 @@ function computePointBounds(points) {
     };
 }
 function isMaskExactCrop(mask, layer, width, height, lookup) {
-    var path = getPrimaryPath(mask);
-    if (path == null || path.points.length === 0) {
+    var path = mask.path;
+    if (path.points.length === 0) {
         return true;
     }
     var _computePointBounds = computePointBounds(path.points), minX = _computePointBounds.minX, minY = _computePointBounds.minY, maxX = _computePointBounds.maxX, maxY = _computePointBounds.maxY;
@@ -3384,8 +3319,8 @@ function isMaskExactCrop(mask, layer, width, height, lookup) {
     return false;
 }
 function getMaskBounds(mask) {
-    var path = getPrimaryPath(mask);
-    if (path == null || path.points.length === 0) {
+    var path = mask.path;
+    if (path.points.length === 0) {
         return {
             cx: 0,
             cy: 0,
@@ -3402,47 +3337,41 @@ function getMaskBounds(mask) {
     };
 }
 function isSimpleRectMask(mask) {
-    var path = getPrimaryPath(mask);
-    if (path == null) {
-        return false;
-    }
-    return path.points.length === 4 && path.easingIns.every(function(e) {
-        return Math.abs(e.x) < 0.01 && Math.abs(e.y) < 0.01;
-    }) && path.easingOuts.every(function(e) {
-        return Math.abs(e.x) < 0.01 && Math.abs(e.y) < 0.01;
+    var path = mask.path;
+    return path.points.length === 4 && path.inTangents.every(function(tangent) {
+        return Math.abs(tangent.x) < 0.01 && Math.abs(tangent.y) < 0.01;
+    }) && path.outTangents.every(function(tangent) {
+        return Math.abs(tangent.x) < 0.01 && Math.abs(tangent.y) < 0.01;
     });
 }
 function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ratio) {
-    var _ref;
-    var path = getPrimaryPath(mask);
+    var path = mask.path;
     var customPoints = [];
     var customEasingIns = [];
     var customEasingOuts = [];
     var customIndexes = [];
-    if (path != null) {
-        for(var idx = 0; idx < path.points.length; idx++){
-            var _ref1, _ref2, _ref3, _ref4;
-            var pt = path.points[idx];
-            var ei = path.easingIns[idx];
-            var eo = path.easingOuts[idx];
-            customPoints.push({
-                x: roundNumber((pt.x - bounds.cx) * ratio, 4),
-                y: roundNumber(-(pt.y - bounds.cy) * ratio, 4)
-            });
-            customEasingIns.push({
-                x: roundNumber(((_ref1 = ei == null ? void 0 : ei.x) != null ? _ref1 : 0) * ratio, 4),
-                y: roundNumber(-((_ref2 = ei == null ? void 0 : ei.y) != null ? _ref2 : 0) * ratio, 4)
-            });
-            customEasingOuts.push({
-                x: roundNumber(((_ref3 = eo == null ? void 0 : eo.x) != null ? _ref3 : 0) * ratio, 4),
-                y: roundNumber(-((_ref4 = eo == null ? void 0 : eo.y) != null ? _ref4 : 0) * ratio, 4)
-            });
-            customIndexes.push({
-                point: idx,
-                easingIn: idx,
-                easingOut: idx
-            });
-        }
+    for(var idx = 0; idx < path.points.length; idx++){
+        var _ref, _ref1, _ref2, _ref3;
+        var pt = path.points[idx];
+        var ei = path.inTangents[idx];
+        var eo = path.outTangents[idx];
+        customPoints.push({
+            x: roundNumber((pt.x - bounds.cx) * ratio, 4),
+            y: roundNumber(-(pt.y - bounds.cy) * ratio, 4)
+        });
+        customEasingIns.push({
+            x: roundNumber(((_ref = ei == null ? void 0 : ei.x) != null ? _ref : 0) * ratio, 4),
+            y: roundNumber(-((_ref1 = ei == null ? void 0 : ei.y) != null ? _ref1 : 0) * ratio, 4)
+        });
+        customEasingOuts.push({
+            x: roundNumber(((_ref2 = eo == null ? void 0 : eo.x) != null ? _ref2 : 0) * ratio, 4),
+            y: roundNumber(-((_ref3 = eo == null ? void 0 : eo.y) != null ? _ref3 : 0) * ratio, 4)
+        });
+        customIndexes.push({
+            point: idx,
+            easingIn: idx,
+            easingOut: idx
+        });
     }
     return {
         id: maskComponentId,
@@ -3454,7 +3383,7 @@ function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ra
         easingOuts: customEasingOuts,
         shapes: [
             {
-                close: (_ref = path == null ? void 0 : path.close) != null ? _ref : true,
+                close: path.closed,
                 indexes: customIndexes
             }
         ],
@@ -3487,10 +3416,10 @@ function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ra
  * Remap GE mask references after ge2ir round-trip.
  *
  * ge2ir carries each masked component's raw `mask` object verbatim (via
- * `IRLayerNode.metadata.ge2ir.geMask`), but `mask.reference.id` still points at the
+ * `IRLayerNode.specific.effects.mask`), but `mask.reference.id` still points at the
  * ORIGINAL (GE1) mask-source component id, which ir2ge has regenerated. This
  * pass rewrites every target's `reference.id` from the stale GE1 id to the
- * freshly-minted GE2 component id, using the `geComponentId → newId` map built
+ * freshly-minted GE2 component id, using the `GEComponentId → newId` map built
  * during the layer walk.
  *
  * Mirrors `applyParenting`: an IR-side reference (here the stale id stored in
@@ -3498,7 +3427,7 @@ function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ra
  * no `reference` and are skipped. Dangling references (source not regenerated —
  * e.g. dropped by the null+sprite merger) have their `mask` removed so the GE
  * runtime doesn't choke on an id that resolves to nothing.
- */ function applyGeMaskRemap(collector, geComponentIdToNewId) {
+ */ function applyGEMaskRemap(collector, GEComponentIdToNewId) {
     for(var _iterator = _create_for_of_iterator_helper_loose(collector.components), _step; !(_step = _iterator()).done;){
         var component = _step.value;
         var mask = component['mask'];
@@ -3510,7 +3439,7 @@ function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ra
         if (oldId == null) {
             continue;
         }
-        var newId = geComponentIdToNewId[oldId];
+        var newId = GEComponentIdToNewId[oldId];
         if (newId == null) {
             // Dangling: the referenced source was not regenerated. Drop the mask so
             // the target renders unmasked rather than referencing a nonexistent id.
@@ -3525,15 +3454,15 @@ function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ra
  * Normalize child visibility delays so children never appear before their parent.
  *
  * Topologically sorts items (parent-first) so by the time we process any child
- * its parent's delay/duration are already finalized. For transform-only
- * parent-link children, we instead advance the parent's delay/duration so the
+ * its parent's delay/duration are already finalized. For children with an
+ * independent lifetime, we instead advance the parent's delay/duration so the
  * child can render from its own start time (GE requires the parent to be active
  * for transform inheritance, but the parent-link relationship does not propagate
  * visibility). Only the ActivationTrack clip is updated; TransformTrack
  * keyframes are normalized to the original time range and would hold their
  * first frame value if the track started earlier.
  */ function normalizeChildVisibilityByParentDelays(param) {
-    var items = param.items, miscs = param.miscs, processedItems = param.processedItems, _param_transformOnlyParentLinkItemIds = param.transformOnlyParentLinkItemIds, transformOnlyParentLinkItemIds = _param_transformOnlyParentLinkItemIds === void 0 ? new Set() : _param_transformOnlyParentLinkItemIds, roundNumber = param.roundNumber;
+    var items = param.items, miscs = param.miscs, processedItems = param.processedItems, _param_independentLifetimeChildItemIds = param.independentLifetimeChildItemIds, independentLifetimeChildItemIds = _param_independentLifetimeChildItemIds === void 0 ? new Set() : _param_independentLifetimeChildItemIds, roundNumber = param.roundNumber;
     var itemById = new Map();
     for(var _iterator = _create_for_of_iterator_helper_loose(items), _step; !(_step = _iterator()).done;){
         var item = _step.value;
@@ -3549,9 +3478,9 @@ function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ra
         var misc = _step2.value;
         miscById.set(misc['id'], misc);
     }
-    // Phase 1: Advance transform-only parent-link parents so their children can
+    // Phase 1: Advance transform parents so independent-lifetime children can
     // render from the child's own start time.
-    advanceTransformOnlyParentLinkParents(items, itemById, processedByItemId, miscById, transformOnlyParentLinkItemIds, roundNumber);
+    advanceIndependentLifetimeParents(items, itemById, processedByItemId, miscById, independentLifetimeChildItemIds, roundNumber);
     // Phase 2: Normalize precomp child visibility (unchanged).
     var effectiveDelayCache = new Map();
     function getEffectiveDelay(itemId, visited) {
@@ -3613,8 +3542,8 @@ function buildPolygonMaskComponent(maskComponentId, maskItemId, mask, bounds, ra
         syncTimelineClips(itemId, effectiveDelay, newDuration, processedByItemId, miscById, roundNumber);
     }
 }
-function advanceTransformOnlyParentLinkParents(items, itemById, processedByItemId, miscById, transformOnlyParentLinkItemIds, roundNumber) {
-    if (transformOnlyParentLinkItemIds.size === 0) {
+function advanceIndependentLifetimeParents(items, itemById, processedByItemId, miscById, independentLifetimeChildItemIds, roundNumber) {
+    if (independentLifetimeChildItemIds.size === 0) {
         return;
     }
     // Collect the maximum advance (head) and extension (tail) needed per parent.
@@ -3623,7 +3552,7 @@ function advanceTransformOnlyParentLinkParents(items, itemById, processedByItemI
     for(var _iterator = _create_for_of_iterator_helper_loose(items), _step; !(_step = _iterator()).done;){
         var item = _step.value;
         var _item_delay, _item_duration, _parentItem_delay, _parentItem_duration;
-        if (!transformOnlyParentLinkItemIds.has(item['id'])) {
+        if (!independentLifetimeChildItemIds.has(item['id'])) {
             continue;
         }
         var parentId = item['parentId'];
@@ -3759,18 +3688,18 @@ function syncTimelineClips(itemId, delay, duration, processedByItemId, miscById,
  */ function applyPostProcess(ir, state) {
     applyParentingStep(ir, state);
     applySharedMaskPostProcess(ir, state);
-    applyGeMaskRemapStep(ir, state);
+    applyGEMaskRemapStep(ir, state);
     applyVisibilityStep(ir, state);
 }
-function applyGeMaskRemapStep(ir, state) {
-    // Only ge-sourced compositions carry passthrough mask references that need
+function applyGEMaskRemapStep(ir, state) {
+    // Only Effects-sourced compositions carry passthrough mask references that need
     // remapping. Lottie/dsl masks are built with correct ids by applyMasks and
-    // must not be touched (their reference ids are absent from the ge map, so a
+    // must not be touched (their reference ids are absent from the GE map, so a
     // blind remap would wrongly delete them).
-    if (ir.source !== 'ge' || state.geComponentIdToNewId == null) {
+    if (ir.source !== 'effects' || state.GEComponentIdToNewId == null) {
         return;
     }
-    applyGeMaskRemap(state.collector, state.geComponentIdToNewId);
+    applyGEMaskRemap(state.collector, state.GEComponentIdToNewId);
 }
 function applySharedMaskPostProcess(ir, state) {
     if (state.maskLookup == null || state.ratio == null || state.width == null || state.height == null || state.frameRate == null) {
@@ -3790,13 +3719,13 @@ function applyVisibilityStep(ir, state) {
     if (layerToItemId == null) {
         return;
     }
-    var transformOnlyParentLinkItemIds = new Set();
+    var independentLifetimeChildItemIds = new Set();
     for(var _iterator = _create_for_of_iterator_helper_loose(ir.layers), _step; !(_step = _iterator()).done;){
         var layer = _step.value;
-        if (isTransformOnlyParentLink(layer)) {
+        if (hasIndependentParentLifetime(layer)) {
             var itemId = layerToItemId[layer.index];
             if (itemId != null) {
-                transformOnlyParentLinkItemIds.add(itemId);
+                independentLifetimeChildItemIds.add(itemId);
             }
         }
     }
@@ -3804,7 +3733,7 @@ function applyVisibilityStep(ir, state) {
         items: collector.items,
         miscs: collector.miscs,
         processedItems: processedItems,
-        transformOnlyParentLinkItemIds: transformOnlyParentLinkItemIds,
+        independentLifetimeChildItemIds: independentLifetimeChildItemIds,
         roundNumber: roundNumber
     });
 }
@@ -3861,16 +3790,15 @@ function normalize(value, path, inArray) {
  * Convert an IR composition to a GE JSONScene.
  *
  * All IR sources (lottie, dsl, future) go through this single unified
- * pipeline. Source-specific features are gated by data existence (e.g. mask,
- * precomp, shape layers are absent in dsl IR and naturally skipped);
- * `ir.source` branches are used only for B-class real semantic differences
- * that cannot be expressed via data existence.
+ * pipeline. Normalized animation semantics select the GE lowering plan;
+ * source-specific payloads may preserve authored GE hierarchy or restore
+ * mask and precomp graphs.
  *
  * The optional `duration` arg is a caller override; lottie2ge currently passes
  * the duration computed from the raw json upstream. When omitted, the
  * canonical assembler derives it from `(outPoint - inPoint) / frameRate`.
  */ function convertIRToGE(ir, duration) {
-    validateIRCompositionWithWarnings(ir);
+    validateIRCompositionOrThrow(ir);
     var width = ir.width, height = ir.height, frameRate = ir.frameRate;
     var ratio = get2dTo3dRatio(width, height);
     var collector = {
@@ -3913,15 +3841,15 @@ function normalize(value, path, inArray) {
     }
     // Build GE1-component-id → regenerated-component-id map for mask reference
     // remapping (ge2ir round-trip). Keyed by the original GE component id that
-    // ge2ir stored in metadata; value is the component id this layer minted.
-    var geComponentIdToNewId = {};
+    // ge2ir stored in specific.effects; value is the component id this layer minted.
+    var GEComponentIdToNewId = {};
     for(var _iterator2 = _create_for_of_iterator_helper_loose(workingIR.layers), _step2; !(_step2 = _iterator2()).done;){
         var layer2 = _step2.value;
-        var _readGE2IRMetadata;
-        var geComponentId = (_readGE2IRMetadata = readGE2IRMetadata(workingIR, layer2)) == null ? void 0 : _readGE2IRMetadata.geComponentId;
+        var _getEffectsLayerSpecific;
+        var GEComponentId = (_getEffectsLayerSpecific = getEffectsLayerSpecific(workingIR, layer2)) == null ? void 0 : _getEffectsLayerSpecific.sourceComponentId;
         var newId = layerToComponentId[layer2.index];
-        if (geComponentId != null && newId != null) {
-            geComponentIdToNewId[geComponentId] = newId;
+        if (GEComponentId != null && newId != null) {
+            GEComponentIdToNewId[GEComponentId] = newId;
         }
     }
     applyPostProcess(workingIR, {
@@ -3932,7 +3860,7 @@ function normalize(value, path, inArray) {
         width: width,
         height: height,
         frameRate: frameRate,
-        geComponentIdToNewId: geComponentIdToNewId,
+        GEComponentIdToNewId: GEComponentIdToNewId,
         maskLookup: {
             getItemId: function getItemId(idx) {
                 return layerToItemId[idx];
@@ -3965,16 +3893,16 @@ function processLayer(layer, ctx) {
     }
 }
 function hasGEPrecompMetadata(ir, layer) {
-    var metadata = readGE2IRMetadata(ir, layer);
-    return (metadata == null ? void 0 : metadata.precompRefId) != null || (metadata == null ? void 0 : metadata.precompContent) != null;
+    var specific = getEffectsLayerSpecific(ir, layer);
+    return (specific == null ? void 0 : specific.precompRefId) != null || (specific == null ? void 0 : specific.precompContent) != null;
 }
 /**
- * Extend parent layers' endFrame to cover transform-only children's time spans.
+ * Extend parent layers' endFrame to cover independent child lifetimes.
  *
  * In Lottie, child layers (linked via layer.parent) inherit the parent's transform
  * even after the parent becomes invisible. GE requires the parent item to be active
  * for transform inheritance to work, so we extend the parent's endFrame to cover
- * the full lifetime of its transform-only children.
+ * the full lifetime of children whose lifetime is independent.
  *
  * Keyframes beyond the extended endFrame are NOT included — they represent animation
  * that never plays in Lottie (layer is invisible and has no child needing it).
@@ -3993,7 +3921,7 @@ function hasGEPrecompMetadata(ir, layer) {
         for(var _iterator1 = _create_for_of_iterator_helper_loose(clonedLayers), _step1; !(_step1 = _iterator1()).done;){
             var child = _step1.value;
             var _child_parent;
-            if (((_child_parent = child.parent) == null ? void 0 : _child_parent.index) === layer.index && child.parent.linkKind === 'transform-only') {
+            if (((_child_parent = child.parent) == null ? void 0 : _child_parent.index) === layer.index && child.parent.lifetimeMode === 'independent') {
                 if (child.time.endFrame > maxEnd) {
                     maxEnd = child.time.endFrame;
                 }
@@ -4012,13 +3940,13 @@ function mergePreservedPrecompScene(generated, ir) {
             return !isExcludedPoolEntry(pool, entry, excluded);
         }));
     };
-    var metadata = readGE2IRCompositionMetadata(ir);
-    var sourceScene = metadata == null ? void 0 : metadata.sourceScene;
+    var specific = getEffectsCompositionSpecific(ir);
+    var sourceScene = specific == null ? void 0 : specific.sourceScene;
     if (sourceScene == null) {
         return generated;
     }
     var result = _extends({}, generated);
-    var sourceCompositionId = metadata == null ? void 0 : metadata.sourceCompositionId;
+    var sourceCompositionId = specific == null ? void 0 : specific.sourceCompositionId;
     var excluded = collectRootCompositionIds(sourceScene, sourceCompositionId);
     var pools = [
         'images',
@@ -4238,23 +4166,25 @@ function resolveDataPathId(ref) {
     return typeof id === 'string' ? id : undefined;
 }
 
-function reverseEndBehavior(geBehavior) {
-    if (geBehavior == null) {
+function reverseEndBehavior(GEBehavior) {
+    if (GEBehavior == null) {
         return undefined;
     }
-    switch(geBehavior){
+    switch(GEBehavior){
         case 0:
-            return IREndBehavior.Stop;
+            return IREndBehavior.Destroy;
+        case 2:
+            return IREndBehavior.Forward;
         case 4:
-            return IREndBehavior.Hold;
+            return IREndBehavior.Freeze;
         case 5:
-            return IREndBehavior.Loop;
+            return IREndBehavior.Restart;
         default:
             return undefined;
     }
 }
-function reverseCompositionEndBehavior(geBehavior) {
-    return reverseEndBehavior(geBehavior);
+function reverseCompositionEndBehavior(GEBehavior) {
+    return reverseEndBehavior(GEBehavior);
 }
 
 function buildSceneContext(scene, options) {
@@ -4274,7 +4204,10 @@ function buildSceneContext(scene, options) {
     var frameRate = options.frameRate;
     var ratio = get2dTo3dRatio(width, height);
     var inPoint = 0;
-    var outPoint = Math.round(duration * frameRate);
+    // GE durations are expressed in seconds and are not guaranteed to land on
+    // an integer frame. Preserve the fractional frame so GE → IR → GE does not
+    // shorten or extend the composition at the tail.
+    var outPoint = duration * frameRate;
     var endBehavior = reverseCompositionEndBehavior(composition['endBehavior']);
     var backgroundColor;
     var bg = composition['background'];
@@ -4482,16 +4415,26 @@ function parseStaticTransform(itemTransform, ctx) {
     }
     var eulerHint = itemTransform['eulerHint'];
     if (eulerHint != null) {
-        var hasRotation = Math.abs(eulerHint.x) > 1e-6 || Math.abs(eulerHint.y) > 1e-6 || Math.abs(eulerHint.z) > 1e-6;
-        if (hasRotation) {
-            channels.rotation = {
-                keyframed: false,
-                value: [
-                    eulerHint.x,
-                    eulerHint.y,
-                    eulerHint.z
-                ]
-            };
+        var x = Math.abs(eulerHint.x) > 1e-6 ? {
+            keyframed: false,
+            value: eulerHint.x
+        } : undefined;
+        var y = Math.abs(eulerHint.y) > 1e-6 ? {
+            keyframed: false,
+            value: eulerHint.y
+        } : undefined;
+        var z = Math.abs(eulerHint.z) > 1e-6 ? {
+            keyframed: false,
+            value: eulerHint.z
+        } : undefined;
+        if (x != null || y != null || z != null) {
+            channels.rotation = _extends({}, x != null && {
+                x: x
+            }, y != null && {
+                y: y
+            }, z != null && {
+                z: z
+            });
         }
     }
     return channels;
@@ -4540,7 +4483,7 @@ function parseBezierKeyframes(curves, startFrame, endFrame) {
         };
         if (i === 0) {
             keyframes.push(_extends({
-                t: frameTime,
+                frame: frameTime,
                 value: v0
             }, isHold ? {
                 hold: true
@@ -4560,7 +4503,7 @@ function parseBezierKeyframes(curves, startFrame, endFrame) {
                 y: inverseLerp(prevV0, prevV1, prevInCpY)
             };
             keyframes.push(_extends({
-                t: frameTime,
+                frame: frameTime,
                 value: v0,
                 inTangent: inTangent
             }, isHold ? {
@@ -4579,7 +4522,7 @@ function parseBezierKeyframes(curves, startFrame, endFrame) {
         y: inverseLerp(lastSeg[1], lastSeg[7], lastSeg[5])
     };
     keyframes.push({
-        t: lastFrameTime,
+        frame: lastFrameTime,
         value: lastV1,
         inTangent: lastInTangent
     });
@@ -4675,7 +4618,7 @@ function parsePositionTimingKeyframes(curves, startFrame, endFrame) {
         };
         if (i === 0) {
             result.push({
-                t: frameTime,
+                frame: frameTime,
                 outTangent: outTangent
             });
         } else {
@@ -4685,7 +4628,7 @@ function parsePositionTimingKeyframes(curves, startFrame, endFrame) {
                 y: inverseLerp(prevSeg[0], prevSeg[6], prevSeg[5])
             };
             result.push({
-                t: frameTime,
+                frame: frameTime,
                 outTangent: outTangent,
                 inTangent: inTangent
             });
@@ -4698,7 +4641,7 @@ function parsePositionTimingKeyframes(curves, startFrame, endFrame) {
         y: inverseLerp(lastSeg[0], lastSeg[6], lastSeg[5])
     };
     result.push({
-        t: lastFrameTime,
+        frame: lastFrameTime,
         inTangent: lastInTangent
     });
     return result;
@@ -4715,12 +4658,9 @@ function parseTransformAnimation(asset, startFrame, endFrame, ctx) {
     }
     var rotOverLifetime = asset['rotationOverLifetime'];
     if (rotOverLifetime != null) {
-        var rotResult = parseRotationAnimation(rotOverLifetime, startFrame, endFrame);
-        if (rotResult.rotation != null) {
-            channels.rotation = rotResult.rotation;
-        }
-        if (rotResult.separatedRotation != null) {
-            channels.separatedRotation = rotResult.separatedRotation;
+        var rotation = parseRotationAnimation(rotOverLifetime, startFrame, endFrame);
+        if (rotation != null) {
+            channels.rotation = rotation;
         }
     }
     var sizeOverLifetime = asset['sizeOverLifetime'];
@@ -4800,7 +4740,7 @@ function parsePositionAnimation(posOverLifetime, startFrame, endFrame, ctx) {
         var pp = pathPoints[Math.min(i, pathPoints.length - 1)];
         var pos2d = convert3dTo2dPoint(pp[0], pp[1], (_pp_ = pp[2]) != null ? _pp_ : 0, ctx.width, ctx.height);
         var kf = {
-            t: timing.t,
+            frame: timing.frame,
             value: pos2d
         };
         if (i > startIdx && timing.inTangent != null) {
@@ -4849,83 +4789,26 @@ function parsePositionAnimation(posOverLifetime, startFrame, endFrame, ctx) {
     };
 }
 function parseRotationAnimation(rotOverLifetime, startFrame, endFrame) {
-    var separateAxes = rotOverLifetime['separateAxes'];
+    var separateAxes = rotOverLifetime['separateAxes'] === true;
     var xData = rotOverLifetime['x'];
     var yData = rotOverLifetime['y'];
     var zData = rotOverLifetime['z'];
-    if (separateAxes === true) {
-        var x = parseScalarChannel(xData, startFrame, endFrame);
-        var y = parseScalarChannel(yData, startFrame, endFrame);
-        var z = parseScalarChannel(zData, startFrame, endFrame);
-        var hasMultiAxis = (x != null ? 1 : 0) + (y != null ? 1 : 0) + (z != null ? 1 : 0) > 1;
-        var hasXOrY = x != null || y != null;
-        if (hasMultiAxis || hasXOrY) {
-            return {
-                separatedRotation: _extends({}, x != null && {
-                    x: x
-                }, y != null && {
-                    y: y
-                }, z != null && {
-                    z: z
-                })
-            };
-        }
-        if (z != null) {
-            return {
-                separatedRotation: {
-                    z: z
-                }
-            };
-        }
-    }
-    // Single-axis z rotation (non-separated)
-    if (zData != null) {
-        var z1 = parseScalarChannel(zData, startFrame, endFrame);
-        if (z1 != null) {
-            if (z1.keyframed) {
-                var vecKeyframes = z1.keyframes.map(function(kf) {
-                    var result = {
-                        t: kf.t,
-                        value: [
-                            0,
-                            0,
-                            kf.value
-                        ]
-                    };
-                    if (kf.hold != null) {
-                        result.hold = kf.hold;
-                    }
-                    if (kf.inTangent != null) {
-                        result.inTangent = kf.inTangent;
-                    }
-                    if (kf.outTangent != null) {
-                        result.outTangent = kf.outTangent;
-                    }
-                    return result;
-                });
-                return {
-                    rotation: {
-                        keyframed: true,
-                        keyframes: vecKeyframes
-                    }
-                };
-            }
-            return {
-                rotation: {
-                    keyframed: false,
-                    value: [
-                        0,
-                        0,
-                        z1.value
-                    ]
-                }
-            };
-        }
+    var x = separateAxes ? parseScalarChannel(xData, startFrame, endFrame) : undefined;
+    var y = separateAxes ? parseScalarChannel(yData, startFrame, endFrame) : undefined;
+    var z = parseScalarChannel(zData, startFrame, endFrame);
+    if (x == null && y == null && z == null) {
+        return undefined;
     }
-    return {};
+    return _extends({}, x != null && {
+        x: x
+    }, y != null && {
+        y: y
+    }, z != null && {
+        z: z
+    });
 }
 function parseScaleAnimation(sizeOverLifetime, startFrame, endFrame) {
-    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8;
+    var _ref, _ref1, _ref2;
     var xData = sizeOverLifetime['x'];
     var yData = sizeOverLifetime['y'];
     var zData = sizeOverLifetime['z'];
@@ -4938,71 +4821,72 @@ function parseScaleAnimation(sizeOverLifetime, startFrame, endFrame) {
     var xKeyframed = (x == null ? void 0 : x.keyframed) === true;
     var yKeyframed = (y == null ? void 0 : y.keyframed) === true;
     var zKeyframed = (z == null ? void 0 : z.keyframed) === true;
+    var xStaticValue = (x == null ? void 0 : x.keyframed) === false ? x.value : 1;
+    var yStaticValue = (y == null ? void 0 : y.keyframed) === false ? y.value : 1;
+    var zStaticValue = (z == null ? void 0 : z.keyframed) === false ? z.value : 1;
     if (!xKeyframed && !yKeyframed && !zKeyframed) {
-        var _ref9, _ref10, _ref11;
         return {
             keyframed: false,
             value: [
-                (_ref9 = x == null ? void 0 : x.value) != null ? _ref9 : 1,
-                (_ref10 = y == null ? void 0 : y.value) != null ? _ref10 : 1,
-                (_ref11 = z == null ? void 0 : z.value) != null ? _ref11 : 1
+                xStaticValue,
+                yStaticValue,
+                zStaticValue
             ]
         };
     }
     var xKfs = (_ref = x == null ? void 0 : x.keyframes) != null ? _ref : [
         {
-            t: startFrame,
-            value: (_ref1 = x == null ? void 0 : x.value) != null ? _ref1 : 1
+            frame: startFrame,
+            value: xStaticValue
         },
         {
-            t: endFrame,
-            value: (_ref2 = x == null ? void 0 : x.value) != null ? _ref2 : 1
+            frame: endFrame,
+            value: xStaticValue
         }
     ];
-    var yKfs = (_ref3 = y == null ? void 0 : y.keyframes) != null ? _ref3 : [
+    var yKfs = (_ref1 = y == null ? void 0 : y.keyframes) != null ? _ref1 : [
         {
-            t: startFrame,
-            value: (_ref4 = y == null ? void 0 : y.value) != null ? _ref4 : 1
+            frame: startFrame,
+            value: yStaticValue
         },
         {
-            t: endFrame,
-            value: (_ref5 = y == null ? void 0 : y.value) != null ? _ref5 : 1
+            frame: endFrame,
+            value: yStaticValue
         }
     ];
-    var zKfs = (_ref6 = z == null ? void 0 : z.keyframes) != null ? _ref6 : [
+    var zKfs = (_ref2 = z == null ? void 0 : z.keyframes) != null ? _ref2 : [
         {
-            t: startFrame,
-            value: (_ref7 = z == null ? void 0 : z.value) != null ? _ref7 : 1
+            frame: startFrame,
+            value: zStaticValue
         },
         {
-            t: endFrame,
-            value: (_ref8 = z == null ? void 0 : z.value) != null ? _ref8 : 1
+            frame: endFrame,
+            value: zStaticValue
         }
     ];
-    var allTimes = new Set();
+    var allFrames = new Set();
     for(var _iterator = _create_for_of_iterator_helper_loose(xKfs), _step; !(_step = _iterator()).done;){
         var kf = _step.value;
-        allTimes.add(kf.t);
+        allFrames.add(kf.frame);
     }
     for(var _iterator1 = _create_for_of_iterator_helper_loose(yKfs), _step1; !(_step1 = _iterator1()).done;){
         var kf1 = _step1.value;
-        allTimes.add(kf1.t);
+        allFrames.add(kf1.frame);
     }
     for(var _iterator2 = _create_for_of_iterator_helper_loose(zKfs), _step2; !(_step2 = _iterator2()).done;){
         var kf2 = _step2.value;
-        allTimes.add(kf2.t);
+        allFrames.add(kf2.frame);
     }
     // Keep Array.from: loose SWC array-spread lowering does not expand Set in dist.
-    var sortedTimes = Array.from(allTimes).sort(function(a, b) {
+    var sortedFrames = Array.from(allFrames).sort(function(a, b) {
         return a - b;
     });
-    var keyframes = sortedTimes.map(function(t) {
-        var _ref, _ref1, _ref2;
-        var xv = findValueAtTime(xKfs, t, (_ref = x == null ? void 0 : x.value) != null ? _ref : 1);
-        var yv = findValueAtTime(yKfs, t, (_ref1 = y == null ? void 0 : y.value) != null ? _ref1 : 1);
-        var zv = findValueAtTime(zKfs, t, (_ref2 = z == null ? void 0 : z.value) != null ? _ref2 : 1);
+    var keyframes = sortedFrames.map(function(frame) {
+        var xv = findValueAtFrame(xKfs, frame, xStaticValue);
+        var yv = findValueAtFrame(yKfs, frame, yStaticValue);
+        var zv = findValueAtFrame(zKfs, frame, zStaticValue);
         var kf = {
-            t: t,
+            frame: frame,
             value: [
                 xv.value,
                 yv.value,
@@ -5048,10 +4932,10 @@ function parseScalarChannel(data, startFrame, endFrame) {
     }
     return undefined;
 }
-function findValueAtTime(keyframes, t, defaultValue) {
+function findValueAtFrame(keyframes, frame, defaultValue) {
     for(var _iterator = _create_for_of_iterator_helper_loose(keyframes), _step; !(_step = _iterator()).done;){
         var kf = _step.value;
-        if (Math.abs(kf.t - t) < 1e-6) {
+        if (Math.abs(kf.frame - frame) < 1e-6) {
             return {
                 value: kf.value,
                 outTangent: kf.outTangent,
@@ -5083,11 +4967,11 @@ var IR_BLEND_MODE_BY_GE = {
     15: IRBlendMode.SoftLight,
     16: IRBlendMode.Luminosity
 };
-function reverseBlendMode(geCode) {
-    if (geCode == null) {
+function reverseBlendMode(GECode) {
+    if (GECode == null) {
         return undefined;
     }
-    return IR_BLEND_MODE_BY_GE[geCode];
+    return IR_BLEND_MODE_BY_GE[GECode];
 }
 
 function parseComponent(item, ctx) {
@@ -5117,7 +5001,7 @@ function parseComponent(item, ctx) {
         if (result == null) {
             continue;
         }
-        result.geComponentId = component['id'];
+        result.GEComponentId = component['id'];
         var mask = component['mask'];
         if (mask != null) {
             result.rawMask = mask;
@@ -5241,7 +5125,7 @@ function parseShapeComponent(component, ctx) {
     if (renderer != null) {
         blendMode = reverseBlendMode(renderer['blending']);
     }
-    var shapeData = parseShapeOptions(component, ctx.ratio);
+    var shapeData = parseShapeOptions(component, ctx);
     return {
         type: 'shape',
         shapes: shapeData != null ? [
@@ -5250,85 +5134,100 @@ function parseShapeComponent(component, ctx) {
         blendMode: blendMode
     };
 }
-function parseShapeOptions(component, ratio) {
-    var geType = component['type'];
-    var primitiveType = reverseShapePrimitiveType(geType != null ? geType : 0);
-    var xSize = component['xSize'];
-    var ySize = component['ySize'];
-    var size = [
-        xSize != null ? xSize / ratio : 0,
-        ySize != null ? ySize / ratio : 0
-    ];
-    var shape = {
-        primitiveType: primitiveType,
+function parseShapeOptions(component, ctx) {
+    var GEType = component['type'];
+    var primitiveType = reverseShapePrimitiveType(GEType != null ? GEType : 0);
+    var style = {
         position: [
             0,
             0
         ],
-        size: size,
         fills: [],
         strokes: []
     };
-    var shapeRec = shape;
-    reverseScaledNumber(shapeRec, component, 'xRadius', ratio);
-    reverseScaledNumber(shapeRec, component, 'yRadius', ratio);
-    reverseScaledNumber(shapeRec, component, 'width', ratio);
-    reverseScaledNumber(shapeRec, component, 'height', ratio);
-    reverseScaledNumber(shapeRec, component, 'innerRadius', ratio);
-    reverseScaledNumber(shapeRec, component, 'outerRadius', ratio);
-    reverseScaledNumber(shapeRec, component, 'radius', ratio);
-    reverseRawNumber(shapeRec, component, 'roundness');
-    reverseRawNumber(shapeRec, component, 'pointCount');
-    reverseRawNumber(shapeRec, component, 'innerRoundness');
-    reverseRawNumber(shapeRec, component, 'outerRoundness');
-    var geFills = component['fills'];
-    if (geFills != null) {
-        shape.fills = geFills.map(function(f) {
-            return reverseShapePaint(f, ratio);
+    var GEFills = component['fills'];
+    if (GEFills != null) {
+        style.fills = GEFills.map(function(f) {
+            return reverseShapePaint(f, ctx);
         }).filter(function(f) {
             return f != null;
         });
     }
-    var geStrokes = component['strokes'];
-    if (geStrokes != null) {
-        shape.strokes = geStrokes.map(function(s) {
-            return reverseShapePaint(s, ratio);
+    var GEStrokes = component['strokes'];
+    if (GEStrokes != null) {
+        style.strokes = GEStrokes.map(function(s) {
+            return reverseShapePaint(s, ctx);
         }).filter(function(s) {
             return s != null;
         });
     }
-    var geStrokeWidth = component['strokeWidth'];
-    if (geStrokeWidth != null) {
-        shape.strokeWidth = geStrokeWidth / ratio;
-    }
-    var geStrokeCap = component['strokeCap'];
-    if (geStrokeCap != null) {
-        shape.strokeCap = reverseLineCap(geStrokeCap);
+    var GEStrokeWidth = component['strokeWidth'];
+    if (typeof GEStrokeWidth === 'number' && Number.isFinite(GEStrokeWidth) && GEStrokeWidth >= 0) {
+        style.strokeWidth = GEStrokeWidth / ctx.ratio;
     }
-    var geStrokeJoin = component['strokeJoin'];
-    if (geStrokeJoin != null) {
-        shape.strokeJoin = reverseLineJoin(geStrokeJoin);
+    var GEStrokeCap = component['strokeCap'];
+    if (GEStrokeCap != null) {
+        style.strokeCap = reverseLineCap(GEStrokeCap);
     }
-    var geFillRule = component['fillRule'];
-    if (geFillRule != null) {
-        shape.fillRule = reverseShapeFillRule(geFillRule);
+    var GEStrokeJoin = component['strokeJoin'];
+    if (GEStrokeJoin != null) {
+        style.strokeJoin = reverseLineJoin(GEStrokeJoin);
     }
-    var geShapes = component['shapes'];
-    if (geShapes != null) {
-        var paths = reverseCustomPaths(component, ratio);
-        if (paths.length > 0) {
-            shape.customPaths = paths;
-        }
-    }
-    var trimPath = component['trimPath'];
-    if (trimPath != null) {
-        shape.trimPath = trimPath;
-    }
-    var repeater = component['repeater'];
-    if (repeater != null) {
-        shape.repeater = repeater;
+    switch(primitiveType){
+        case IRShapePrimitiveType.Custom:
+            {
+                var customPaths = reverseCustomPaths(component, ctx.ratio);
+                var firstPath = customPaths[0];
+                return firstPath != null ? _extends({}, style, {
+                    primitiveType: primitiveType,
+                    customPaths: [].concat([
+                        firstPath
+                    ], customPaths.slice(1))
+                }) : undefined;
+            }
+        case IRShapePrimitiveType.Rectangle:
+            {
+                var width = readScaledNumber(component, 'width', ctx.ratio);
+                var height = readScaledNumber(component, 'height', ctx.ratio);
+                return width != null && height != null ? _extends({}, style, {
+                    primitiveType: primitiveType,
+                    width: width,
+                    height: height
+                }, readOptionalNumberField(component, 'roundness')) : undefined;
+            }
+        case IRShapePrimitiveType.Ellipse:
+            {
+                var xRadius = readScaledNumber(component, 'xRadius', ctx.ratio);
+                var yRadius = readScaledNumber(component, 'yRadius', ctx.ratio);
+                return xRadius != null && yRadius != null ? _extends({}, style, {
+                    primitiveType: primitiveType,
+                    xRadius: xRadius,
+                    yRadius: yRadius
+                }) : undefined;
+            }
+        case IRShapePrimitiveType.Polygon:
+            {
+                var pointCount = readPointCount(component);
+                var radius = readScaledNumber(component, 'radius', ctx.ratio);
+                return pointCount != null && radius != null ? _extends({}, style, {
+                    primitiveType: primitiveType,
+                    pointCount: pointCount,
+                    radius: radius
+                }, readOptionalNumberField(component, 'roundness')) : undefined;
+            }
+        case IRShapePrimitiveType.Star:
+            {
+                var pointCount1 = readPointCount(component);
+                var innerRadius = readScaledNumber(component, 'innerRadius', ctx.ratio);
+                var outerRadius = readScaledNumber(component, 'outerRadius', ctx.ratio);
+                return pointCount1 != null && innerRadius != null && outerRadius != null ? _extends({}, style, {
+                    primitiveType: primitiveType,
+                    pointCount: pointCount1,
+                    innerRadius: innerRadius,
+                    outerRadius: outerRadius
+                }, readOptionalNumberField(component, 'innerRoundness'), readOptionalNumberField(component, 'outerRoundness')) : undefined;
+            }
     }
-    return shape;
 }
 var GE_TO_SHAPE_PRIMITIVE_TYPE = {
     0: IRShapePrimitiveType.Custom,
@@ -5337,13 +5236,13 @@ var GE_TO_SHAPE_PRIMITIVE_TYPE = {
     3: IRShapePrimitiveType.Polygon,
     4: IRShapePrimitiveType.Star
 };
-function reverseShapePrimitiveType(geType) {
-    var _GE_TO_SHAPE_PRIMITIVE_TYPE_geType;
-    return (_GE_TO_SHAPE_PRIMITIVE_TYPE_geType = GE_TO_SHAPE_PRIMITIVE_TYPE[geType]) != null ? _GE_TO_SHAPE_PRIMITIVE_TYPE_geType : IRShapePrimitiveType.Custom;
+function reverseShapePrimitiveType(GEType) {
+    var _GE_TO_SHAPE_PRIMITIVE_TYPE_GEType;
+    return (_GE_TO_SHAPE_PRIMITIVE_TYPE_GEType = GE_TO_SHAPE_PRIMITIVE_TYPE[GEType]) != null ? _GE_TO_SHAPE_PRIMITIVE_TYPE_GEType : IRShapePrimitiveType.Custom;
 }
-function reverseShapePaint(paint, ratio) {
-    var geType = paint['type'];
-    if (geType === 0) {
+function reverseShapePaint(paint, ctx) {
+    var GEType = paint['type'];
+    if (GEType === 0) {
         var color = paint['color'];
         if (color == null) {
             return undefined;
@@ -5358,7 +5257,7 @@ function reverseShapePaint(paint, ratio) {
             ]
         };
     }
-    if (geType === 1 || geType === 2 || geType === 3) {
+    if (GEType === 1 || GEType === 2 || GEType === 3) {
         var typeMap = {
             1: IRFillType.LinearGradient,
             2: IRFillType.RadialGradient,
@@ -5369,45 +5268,50 @@ function reverseShapePaint(paint, ratio) {
         var startPoint = paint['startPoint'];
         var endPoint = paint['endPoint'];
         return {
-            type: typeMap[geType],
+            type: typeMap[GEType],
             gradientStops: stops,
             gradientStart: startPoint != null ? [
-                startPoint.x / ratio,
-                -startPoint.y / ratio
+                startPoint.x / ctx.ratio,
+                -startPoint.y / ctx.ratio
             ] : undefined,
             gradientEnd: endPoint != null ? [
-                endPoint.x / ratio,
-                -endPoint.y / ratio
+                endPoint.x / ctx.ratio,
+                -endPoint.y / ctx.ratio
             ] : undefined
         };
     }
+    if (GEType === 4) {
+        var texture = resolveTextureAsset(paint['texture'], ctx);
+        if (texture == null) {
+            return undefined;
+        }
+        var scaleMode = paint['scaleMode'];
+        return _extends({
+            type: IRFillType.Texture,
+            texture: texture
+        }, isTextureScaleMode(scaleMode) && {
+            scaleMode: scaleMode
+        });
+    }
     return undefined;
 }
-function reverseLineCap(geCode) {
-    var _map_geCode;
+function reverseLineCap(GECode) {
+    var _map_GECode;
     var map = {
         0: IRLineCap.Butt,
         1: IRLineCap.Round,
         2: IRLineCap.Square
     };
-    return (_map_geCode = map[geCode]) != null ? _map_geCode : IRLineCap.Butt;
+    return (_map_GECode = map[GECode]) != null ? _map_GECode : IRLineCap.Butt;
 }
-function reverseLineJoin(geCode) {
-    var _map_geCode;
+function reverseLineJoin(GECode) {
+    var _map_GECode;
     var map = {
         0: IRLineJoin.Round,
         1: IRLineJoin.Bevel,
         2: IRLineJoin.Miter
     };
-    return (_map_geCode = map[geCode]) != null ? _map_geCode : IRLineJoin.Miter;
-}
-function reverseShapeFillRule(geCode) {
-    var _map_geCode;
-    var map = {
-        0: IRShapeFillRule.NonZero,
-        1: IRShapeFillRule.EvenOdd
-    };
-    return (_map_geCode = map[geCode]) != null ? _map_geCode : IRShapeFillRule.NonZero;
+    return (_map_GECode = map[GECode]) != null ? _map_GECode : IRLineJoin.Miter;
 }
 function reverseCustomPaths(component, ratio) {
     var points = component['points'];
@@ -5419,8 +5323,8 @@ function reverseCustomPaths(component, ratio) {
     }
     return shapes.map(function(shape) {
         var pathPoints = [];
-        var pathEasingIns = [];
-        var pathEasingOuts = [];
+        var pathInTangents = [];
+        var pathOutTangents = [];
         for(var _iterator = _create_for_of_iterator_helper_loose(shape.indexes), _step; !(_step = _iterator()).done;){
             var idx = _step.value;
             var _ref, _ref1, _ref2, _ref3;
@@ -5431,34 +5335,50 @@ function reverseCustomPaths(component, ratio) {
                 x: pt.x / ratio,
                 y: -pt.y / ratio
             });
-            pathEasingIns.push({
+            pathInTangents.push({
                 x: ((_ref = ei == null ? void 0 : ei.x) != null ? _ref : 0) / ratio,
                 y: -((_ref1 = ei == null ? void 0 : ei.y) != null ? _ref1 : 0) / ratio
             });
-            pathEasingOuts.push({
+            pathOutTangents.push({
                 x: ((_ref2 = eo == null ? void 0 : eo.x) != null ? _ref2 : 0) / ratio,
                 y: -((_ref3 = eo == null ? void 0 : eo.y) != null ? _ref3 : 0) / ratio
             });
         }
         return {
             points: pathPoints,
-            easingIns: pathEasingIns,
-            easingOuts: pathEasingOuts,
-            close: shape.close
+            inTangents: pathInTangents,
+            outTangents: pathOutTangents,
+            closed: shape.close
         };
     });
 }
-function reverseScaledNumber(shape, component, key, ratio) {
+function readScaledNumber(component, key, ratio) {
     var value = component[key];
-    if (typeof value === 'number') {
-        shape[key] = value / ratio;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return undefined;
     }
+    return value / ratio;
 }
-function reverseRawNumber(shape, component, key) {
+function readOptionalNumberField(component, key) {
     var value = component[key];
-    if (typeof value === 'number') {
-        shape[key] = value;
-    }
+    var _obj;
+    return typeof value === 'number' && Number.isFinite(value) ? (_obj = {}, _obj[key] = value, _obj) : {};
+}
+function readPointCount(component) {
+    var value = component['pointCount'];
+    return typeof value === 'number' && Number.isInteger(value) && value >= 2 ? value : undefined;
+}
+function resolveTextureAsset(textureRef, ctx) {
+    var texture = resolveDataPath(ctx.textureById, textureRef);
+    var sourceRef = texture == null ? void 0 : texture['source'];
+    var image = sourceRef != null ? resolveDataPath(ctx.imageById, sourceRef) : undefined;
+    var url = image == null ? void 0 : image['url'];
+    return typeof url === 'string' && url.trim() !== '' ? {
+        url: url
+    } : undefined;
+}
+function isTextureScaleMode(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 3;
 }
 
 function reverseLayerTiming(delay, duration, frameRate) {
@@ -5499,7 +5419,7 @@ function mergeNullSpritePairs(descriptors, ctx) {
         // child is exactly one same-name visual sprite. ir2ge's emitNullSpritePair
         // produces precisely this shape (null + one same-name child). If the null
         // has any OTHER children, it is a genuine Lottie parent null — merging it
-        // into a transformSplit would change the anchor those other children are
+        // into a single semantic layer would change the anchor those other children are
         // parented against, shifting them. Leave such nulls intact.
         if (children.length !== 1) {
             continue;
@@ -5613,19 +5533,17 @@ function isRecord$1(value) {
     return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
 }
 function mergeNullAndSprite(nullDesc, childDesc, ctx) {
-    var _childDesc_layer_transform;
+    var _childDesc_layer_transform, _merged_specific;
     var merged = _extends({}, nullDesc.layer);
     // Take type from child
     merged.type = childDesc.layer.type;
     merged.asset = childDesc.layer.asset;
     merged.text = childDesc.layer.text;
     merged.shapes = childDesc.layer.shapes;
-    merged.shapeLayer = childDesc.layer.shapeLayer;
     merged.solidColor = childDesc.layer.solidColor;
     merged.blendMode = childDesc.layer.blendMode;
-    merged.transformSplit = true;
     // Visibility from child
-    merged.visibility = childDesc.layer.visibility;
+    merged.visible = childDesc.layer.visible;
     // Compute anchor from child position offset
     var childTransform = childDesc.item['transform'];
     var childPosition = childTransform == null ? void 0 : childTransform['position'];
@@ -5646,7 +5564,9 @@ function mergeNullAndSprite(nullDesc, childDesc, ctx) {
                 0
             ]
         };
-        merged.displaySize = {
+        merged.localBounds = {
+            x: 0,
+            y: 0,
             width: layerWidth,
             height: layerHeight
         };
@@ -5659,17 +5579,21 @@ function mergeNullAndSprite(nullDesc, childDesc, ctx) {
         merged.transform.opacity = childDesc.layer.transform.opacity;
     }
     // The merged layer renders the child's visual component, but the parent owns
-    // transform animation passthrough. Deep-merge the ge2ir namespace so neither
-    // side overwrites the other's GE round-trip data.
-    if (childDesc.layer.metadata != null) {
-        var _merged_metadata;
-        var parentGE2IR = isRecord$1((_merged_metadata = merged.metadata) == null ? void 0 : _merged_metadata['ge2ir']) ? merged.metadata['ge2ir'] : undefined;
-        var childGE2IR = isRecord$1(childDesc.layer.metadata['ge2ir']) ? childDesc.layer.metadata['ge2ir'] : undefined;
-        merged.metadata = _extends({}, merged.metadata, childDesc.layer.metadata);
-        if (parentGE2IR != null || childGE2IR != null) {
-            merged.metadata['ge2ir'] = _extends({}, parentGE2IR != null ? parentGE2IR : {}, childGE2IR != null ? childGE2IR : {});
-        }
+    // transform animation passthrough. Deep-merge specific.effects so neither side
+    // loses GE reconstruction data.
+    if (childDesc.layer.specific != null) {
+        var _merged_specific1;
+        var parentEffects = (_merged_specific1 = merged.specific) == null ? void 0 : _merged_specific1.effects;
+        var childEffects = childDesc.layer.specific.effects;
+        merged.specific = _extends({}, merged.specific, childDesc.layer.specific, (parentEffects != null || childEffects != null) && {
+            effects: _extends({}, parentEffects != null ? parentEffects : {}, childEffects != null ? childEffects : {})
+        });
     }
+    merged.specific = _extends({}, merged.specific, {
+        effects: _extends({}, (_merged_specific = merged.specific) == null ? void 0 : _merged_specific.effects, {
+            sourceHierarchy: 'null-sprite-pair'
+        })
+    });
     return {
         itemId: nullDesc.itemId,
         item: nullDesc.item,
@@ -5698,7 +5622,7 @@ function resolveHierarchy(descriptors, ctx) {
         }
         desc1.layer.parent = {
             index: parentIndex,
-            name: parentDesc.layer.name
+            lifetimeMode: 'clipped'
         };
         var parentAnchor = getAnchorFromDesc(parentDesc);
         var pos = (_desc_layer_transform = desc1.layer.transform) == null ? void 0 : _desc_layer_transform.position;
@@ -5763,7 +5687,7 @@ function convertGEToIR(scene, options) {
         return d.layer;
     });
     return normalizeJsonValue({
-        source: 'ge',
+        source: 'effects',
         name: ctx.compositionName,
         width: ctx.width,
         height: ctx.height,
@@ -5773,14 +5697,13 @@ function convertGEToIR(scene, options) {
         backgroundColor: ctx.backgroundColor,
         endBehavior: ctx.endBehavior,
         layers: layers,
-        metadata: buildCompositionMetadata(scene, ctx.compositionId, itemIds, ctx)
+        specific: buildCompositionSpecific(scene, ctx.compositionId, itemIds, ctx)
     });
 }
 function parseItemToLayer(item, itemId, index, ctx) {
-    var _item_name, _item_visible, _ref, _item_delay, _ref1, _item_duration;
-    var _item_transform;
+    var _item_name, _item_visible, _ref, _item_delay, _ref1, _item_duration, _ref2;
     var name = (_item_name = item['name']) != null ? _item_name : "layer_" + index;
-    var geType = item['type'];
+    var GEType = item['type'];
     var visible = (_item_visible = item['visible']) != null ? _item_visible : true;
     var rawTransformPassthrough;
     var timeline = parseTimeline(itemId, ctx);
@@ -5789,42 +5712,50 @@ function parseItemToLayer(item, itemId, index, ctx) {
     var time = reverseLayerTiming(delay, duration, ctx.frameRate);
     var componentData = parseComponent(item, ctx);
     var type;
-    if (geType === '3') {
+    if (GEType === '3') {
         type = 'null';
-    } else if ((componentData == null ? void 0 : componentData.type) === 'text' || geType === 'text') {
+    } else if ((componentData == null ? void 0 : componentData.type) === 'text' || GEType === 'text') {
         type = 'text';
-    } else if ((componentData == null ? void 0 : componentData.type) === 'shape' || geType === 'shape') {
+    } else if ((componentData == null ? void 0 : componentData.type) === 'shape' || GEType === 'shape') {
         type = 'shape';
     } else if ((componentData == null ? void 0 : componentData.type) === 'image') {
         type = 'image';
-    } else if (geType === '7') {
+    } else if (GEType === '7') {
         type = 'precomp';
     } else if ((componentData == null ? void 0 : componentData.solidColor) != null) {
         type = 'solid';
-    } else if (geType === '1') {
+    } else if (GEType === '1') {
         type = 'solid';
     } else {
         type = 'null';
     }
     // Parse transforms
     var itemTransform = item['transform'];
+    var itemSize = readItemSize(itemTransform);
+    var textBounds = type === 'text' && itemSize == null ? readTextBounds(componentData == null ? void 0 : componentData.text) : undefined;
+    var localBounds = itemSize != null ? {
+        x: 0,
+        y: 0,
+        width: itemSize.x / ctx.ratio,
+        height: itemSize.y / ctx.ratio
+    } : textBounds;
     var transform;
     if (itemTransform != null) {
         var staticChannels = parseStaticTransform(itemTransform, ctx);
         transform = _extends({}, staticChannels);
         // Text layers carry their pixel-sizing scale on transform.scale
-        // (scale = ratio × displaySize). ir2ge RECOMPUTES this item scale from
-        // displaySize in processVisualLayer, so keeping it in the IR scale channel
+        // (scale = ratio × local bounds). ir2ge RECOMPUTES this item scale from
+        // localBounds in processVisualLayer, so keeping it in the IR scale channel
         // would make buildSizeAnim emit a duplicate sizeOverLifetime constant that
         // double-scales the glyphs (garbled/stretched text). Drop the static scale
         // for text; genuine text scale animation still rides through
-        // metadata.ge2ir.sizeOverLifetime passthrough.
+        // specific.effects.sizeOverLifetime passthrough.
         if (type === 'text') {
             delete transform.scale;
         }
     }
     // Parse animation from timeline tracks — passthrough raw GE animation data
-    // via metadata. Converting to IR keyframes and back would lose data (ir2ge
+    // via specific.effects. Converting to IR keyframes and back would lose data (ir2ge
     // only handles specific ValueType variants and makes assumptions about
     // static positions). The raw data is injected verbatim by ir2ge.
     if ((timeline == null ? void 0 : timeline.transformAsset) != null) {
@@ -5838,10 +5769,6 @@ function parseItemToLayer(item, itemId, index, ctx) {
         if (animChannels.rotation != null) {
             transform.rotation = animChannels.rotation;
         }
-        if (animChannels.separatedRotation != null) {
-            transform.separatedRotation = animChannels.separatedRotation;
-            delete transform.rotation;
-        }
         if (animChannels.scale != null) {
             transform.scale = animChannels.scale;
         }
@@ -5878,108 +5805,104 @@ function parseItemToLayer(item, itemId, index, ctx) {
             rawColorOverLifetime = col;
         }
     }
-    // Anchor from component — default to center (0.5, 0.5) when not explicitly set
-    if (type !== 'null') {
-        var _item_transform1;
-        var itemSize = (_item_transform1 = item['transform']) == null ? void 0 : _item_transform1['size'];
-        if (itemSize != null) {
-            var _ref2;
-            var layerWidth = itemSize.x / ctx.ratio;
-            var layerHeight = itemSize.y / ctx.ratio;
-            var anchorScale = (_ref2 = componentData == null ? void 0 : componentData.anchorScale) != null ? _ref2 : [
-                0.5,
-                0.5
+    // Anchor from component — default to center (0.5, 0.5) when not explicitly set.
+    // Some GE text has no transform.size, so its bounds come from TextComponent.options.
+    // The anchor itself still follows the same normalized renderer coordinates as every
+    // other visual layer; text alignment and glyph baseline are renderer-internal details.
+    if (type !== 'null' && localBounds != null) {
+        var _ref3;
+        var layerWidth = localBounds.width;
+        var layerHeight = localBounds.height;
+        var anchorScale = (_ref3 = componentData == null ? void 0 : componentData.anchorScale) != null ? _ref3 : [
+            0.5,
+            0.5
+        ];
+        var anchorInfo = reverseGenericAnchor(anchorScale, layerWidth, layerHeight);
+        var anchorX = anchorInfo.anchorX, anchorY = anchorInfo.anchorY, anchorOffsetX = anchorInfo.anchorOffsetX, anchorOffsetY = anchorInfo.anchorOffsetY;
+        if (transform == null) {
+            transform = {};
+        }
+        transform.anchor = {
+            keyframed: false,
+            value: [
+                anchorX,
+                anchorY,
+                0
+            ]
+        };
+        // Reverse the position adjustments ir2ge's processVisualLayer re-applies
+        // for non-centered anchors, so they don't double-apply on round-trip.
+        // Forward order (in 2D-px equivalent): pos += anchorOffset (computeStaticPosition),
+        // then pos += scaleAdjust (applyScalePositionAdjust). We subtract both.
+        var pos = transform.position;
+        if (pos != null && !pos.keyframed && pos.value != null) {
+            var _scale_, _scale_1;
+            var _transform_scale;
+            // scaleAdjust (only when static scale != 1 and anchor off-center by >0.5px):
+            //   3D: x += anchorDiffX*(1-sx)*ratio ; y -= anchorDiffY*(1-sy)*ratio
+            // In 2D-px (÷ratio, y-axis flips sign): x2d += anchorDiffX*(1-sx) ;
+            //   y2d += anchorDiffY*(1-sy)   (the two sign flips cancel).
+            var scale = ((_transform_scale = transform.scale) == null ? void 0 : _transform_scale.keyframed) === false && Array.isArray(transform.scale.value) ? transform.scale.value : [
+                1,
+                1,
+                1
             ];
-            var anchorX = anchorScale[0] * layerWidth;
-            var anchorY = anchorScale[1] * layerHeight;
-            if (transform == null) {
-                transform = {};
+            var sx = (_scale_ = scale[0]) != null ? _scale_ : 1;
+            var sy = (_scale_1 = scale[1]) != null ? _scale_1 : 1;
+            var anchorDiffX = anchorX - layerWidth / 2;
+            var anchorDiffY = anchorY - layerHeight / 2;
+            var anchorOffCenter = Math.abs(anchorDiffX) > 0.5 || Math.abs(anchorDiffY) > 0.5;
+            var hasStaticScale = !(sx === 1 && sy === 1);
+            var scaleAdjustX = 0;
+            var scaleAdjustY = 0;
+            if (hasStaticScale && anchorOffCenter && layerWidth > 0 && layerHeight > 0) {
+                scaleAdjustX = anchorDiffX * (1 - sx);
+                scaleAdjustY = anchorDiffY * (1 - sy);
             }
-            transform.anchor = {
-                keyframed: false,
-                value: [
-                    anchorX,
-                    anchorY,
-                    0
-                ]
-            };
-            // Reverse the position adjustments ir2ge's processVisualLayer re-applies
-            // for non-centered anchors, so they don't double-apply on round-trip.
-            // Forward order (in 2D-px equivalent): pos += anchorOffset (computeStaticPosition),
-            // then pos += scaleAdjust (applyScalePositionAdjust). We subtract both.
-            var pos = transform.position;
-            if (pos != null && !pos.keyframed && pos.value != null) {
-                var _scale_, _scale_1;
-                var _transform_scale;
-                // anchorOffset = -(anchor - size/2), added to the raw 2D position.
-                var anchorOffsetX = -(anchorX - layerWidth / 2);
-                var anchorOffsetY = -(anchorY - layerHeight / 2);
-                // scaleAdjust (only when static scale != 1 and anchor off-center by >0.5px):
-                //   3D: x += anchorDiffX*(1-sx)*ratio ; y -= anchorDiffY*(1-sy)*ratio
-                // In 2D-px (÷ratio, y-axis flips sign): x2d += anchorDiffX*(1-sx) ;
-                //   y2d += anchorDiffY*(1-sy)   (the two sign flips cancel).
-                var scale = ((_transform_scale = transform.scale) == null ? void 0 : _transform_scale.keyframed) === false && Array.isArray(transform.scale.value) ? transform.scale.value : [
-                    1,
-                    1,
-                    1
-                ];
-                var sx = (_scale_ = scale[0]) != null ? _scale_ : 1;
-                var sy = (_scale_1 = scale[1]) != null ? _scale_1 : 1;
-                var anchorDiffX = anchorX - layerWidth / 2;
-                var anchorDiffY = anchorY - layerHeight / 2;
-                var anchorOffCenter = Math.abs(anchorDiffX) > 0.5 || Math.abs(anchorDiffY) > 0.5;
-                var hasStaticScale = !(sx === 1 && sy === 1);
-                var scaleAdjustX = 0;
-                var scaleAdjustY = 0;
-                if (hasStaticScale && anchorOffCenter && layerWidth > 0 && layerHeight > 0) {
-                    scaleAdjustX = anchorDiffX * (1 - sx);
-                    scaleAdjustY = anchorDiffY * (1 - sy);
-                }
-                var totalX = anchorOffsetX + scaleAdjustX;
-                var totalY = anchorOffsetY + scaleAdjustY;
-                if (Math.abs(totalX) > 1e-6 || Math.abs(totalY) > 1e-6) {
-                    var _pos_value_;
-                    transform.position = {
-                        keyframed: false,
-                        value: [
-                            pos.value[0] - totalX,
-                            pos.value[1] - totalY,
-                            (_pos_value_ = pos.value[2]) != null ? _pos_value_ : 0
-                        ]
-                    };
-                }
+            var totalX = anchorOffsetX + scaleAdjustX;
+            var totalY = anchorOffsetY + scaleAdjustY;
+            if (Math.abs(totalX) > 1e-6 || Math.abs(totalY) > 1e-6) {
+                var _pos_value_;
+                transform.position = {
+                    keyframed: false,
+                    value: [
+                        pos.value[0] - totalX,
+                        pos.value[1] - totalY,
+                        (_pos_value_ = pos.value[2]) != null ? _pos_value_ : 0
+                    ]
+                };
             }
         }
     }
-    // Display size from item transform.size
-    var displaySize;
-    var itemSize1 = (_item_transform = item['transform']) == null ? void 0 : _item_transform['size'];
-    if (itemSize1 != null) {
-        displaySize = {
-            width: itemSize1.x / ctx.ratio,
-            height: itemSize1.y / ctx.ratio
-        };
+    var text = (componentData == null ? void 0 : componentData.text) == null ? undefined : _extends({}, componentData.text);
+    var solidColor = type === 'solid' ? (_ref2 = componentData == null ? void 0 : componentData.solidColor) != null ? _ref2 : [
+        1,
+        1,
+        1,
+        1
+    ] : componentData == null ? void 0 : componentData.solidColor;
+    if ((text == null ? void 0 : text.autoWidth) === false) {
+        var _text, _width, _text1, _height;
+        (_width = (_text = text).width) != null ? _width : _text.width = localBounds == null ? void 0 : localBounds.width;
+        (_height = (_text1 = text).height) != null ? _height : _text1.height = localBounds == null ? void 0 : localBounds.height;
     }
     var layer = {
         index: index,
         name: name,
         type: type,
         time: time,
-        visibility: {
-            hidden: !visible,
-            enabled: visible
-        },
+        visible: visible,
         transform: transform,
-        displaySize: displaySize
+        localBounds: localBounds
     };
     if ((componentData == null ? void 0 : componentData.asset) != null) {
         layer.asset = componentData.asset;
     }
-    if ((componentData == null ? void 0 : componentData.solidColor) != null) {
-        layer.solidColor = componentData.solidColor;
+    if (solidColor != null) {
+        layer.solidColor = solidColor;
     }
-    if ((componentData == null ? void 0 : componentData.text) != null) {
-        layer.text = componentData.text;
+    if (text != null) {
+        layer.text = text;
     }
     if ((componentData == null ? void 0 : componentData.shapes) != null) {
         layer.shapes = componentData.shapes;
@@ -5987,38 +5910,39 @@ function parseItemToLayer(item, itemId, index, ctx) {
     if ((componentData == null ? void 0 : componentData.blendMode) != null) {
         layer.blendMode = componentData.blendMode;
     }
-    var geComponentId = componentData == null ? void 0 : componentData.geComponentId;
+    var GEComponentId = componentData == null ? void 0 : componentData.GEComponentId;
     var rawMask = componentData == null ? void 0 : componentData.rawMask;
-    var precompContent = geType === '7' ? item['content'] : undefined;
+    var precompContent = GEType === '7' ? item['content'] : undefined;
     var precompRefId = isRecord(precompContent == null ? void 0 : precompContent['options']) ? precompContent['options']['refId'] : undefined;
-    if (rawTransformPassthrough != null || rawColorOverLifetime != null || geComponentId != null || rawMask != null || typeof precompRefId === 'string' || precompContent != null) {
-        // Mask round-trip: geComponentId is the rendezvous key linking a target's
-        // mask.reference.id (a GE1 component id) to the regenerated GE2 component id.
-        // ir2ge copies ge2ir.geMask onto the rebuilt component and a post-process pass
-        // remaps the stale reference id.
-        var ge2irMetadata = _extends({}, rawTransformPassthrough != null ? rawTransformPassthrough : {}, rawColorOverLifetime != null && {
-            colorOverLifetime: rawColorOverLifetime
-        }, geComponentId != null && {
-            geComponentId: geComponentId
-        }, rawMask != null && {
-            geMask: rawMask
-        }, typeof precompRefId === 'string' && {
-            precompRefId: precompRefId
-        }, precompContent != null && {
-            precompContent: cloneJson(precompContent)
-        });
-        layer.metadata = _extends({}, layer.metadata, {
-            ge2ir: ge2irMetadata
-        });
-    }
+    // Mask round-trip: GEComponentId is the rendezvous key linking a target's
+    // mask.reference.id (a GE1 component id) to the regenerated GE2 component id.
+    // ir2ge copies specific.effects.mask onto the rebuilt component and a post-process pass
+    // remaps the stale reference id. sourceHierarchy records the pre-merge shape;
+    // mergeNullSpritePairs replaces it when a pair collapses into one semantic layer.
+    var effectsSpecific = _extends({
+        sourceHierarchy: 'single-item'
+    }, rawTransformPassthrough != null ? rawTransformPassthrough : {}, rawColorOverLifetime != null && {
+        colorOverLifetime: rawColorOverLifetime
+    }, GEComponentId != null && {
+        sourceComponentId: GEComponentId
+    }, rawMask != null && {
+        mask: rawMask
+    }, typeof precompRefId === 'string' && {
+        precompRefId: precompRefId
+    }, precompContent != null && {
+        precompContent: cloneJson(precompContent)
+    });
+    layer.specific = _extends({}, layer.specific, {
+        effects: effectsSpecific
+    });
     return layer;
 }
-function buildCompositionMetadata(scene, compositionId, itemIds, ctx) {
+function buildCompositionSpecific(scene, compositionId, itemIds, ctx) {
     if (!hasPrecompItem(itemIds, ctx)) {
         return undefined;
     }
     return {
-        ge2ir: {
+        effects: {
             sourceCompositionId: compositionId,
             sourceScene: cloneJson(scene)
         }
@@ -6036,21 +5960,51 @@ function cloneJson(value) {
 function isRecord(value) {
     return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
 }
+function readItemSize(itemTransform) {
+    var size = itemTransform == null ? void 0 : itemTransform['size'];
+    if (!isRecord(size)) {
+        return undefined;
+    }
+    var x = size['x'];
+    var y = size['y'];
+    return typeof x === 'number' && Number.isFinite(x) && x > 0 && typeof y === 'number' && Number.isFinite(y) && y > 0 ? {
+        x: x,
+        y: y
+    } : undefined;
+}
+function readTextBounds(text) {
+    var width = text == null ? void 0 : text.width;
+    var height = text == null ? void 0 : text.height;
+    return typeof width === 'number' && Number.isFinite(width) && width > 0 && typeof height === 'number' && Number.isFinite(height) && height > 0 ? {
+        x: 0,
+        y: 0,
+        width: width,
+        height: height
+    } : undefined;
+}
+function reverseGenericAnchor(anchorScale, width, height) {
+    var anchorX = anchorScale[0] * width;
+    var anchorY = anchorScale[1] * height;
+    return {
+        anchorX: anchorX,
+        anchorY: anchorY,
+        anchorOffsetX: -(anchorX - width / 2),
+        anchorOffsetY: -(anchorY - height / 2)
+    };
+}
 
 /**
  * Read-side accessors for the `IRLayerNode.specific.lottie` slot.
  *
  * The shared generator must not branch on lottie semantics directly — every
- * lottie-specific read goes through these helpers so the rest of `ir2ge` stays
+ * Lottie-specific reads go through these helpers so the rest of ir2ge stays
  * agnostic to the producing tool.
  *
- * `isTransformOnlyParentLink` used to live here, reading
- * `specific.lottie.explicitParent`. It was promoted to a generic IR field
- * (`IRLayerReference.linkKind`); the accessor now lives at `./parent-link.ts`.
+ * Parent lifetime semantics are represented directly by the generic IR relation.
  */ function readLottieSpecific(layer) {
     var _layer_specific;
     return (_layer_specific = layer.specific) == null ? void 0 : _layer_specific.lottie;
 }
 
-export { DEFAULT_CAMERA_FOV, DEFAULT_CAMERA_Z, DEFAULT_CLIP_MODE, assembleScene, buildTimelineTracks, convert2dTo3dPoint, convertGEToIR, convertIRToGE, createId, estimateTextWidth, get2dTo3dRatio, irPositionKeyframesToGE, irScalarKeyframesToGE, irVectorKeyframesToGE, isTransformOnlyParentLink, lerp, normalizeChildVisibilityByParentDelays, readLottieSpecific, roundNumber, shouldUseKeyframeMode, toDataPath };
+export { DEFAULT_CAMERA_FOV, DEFAULT_CAMERA_Z, DEFAULT_CLIP_MODE, assembleScene, buildNormalizedColorAnimation, buildNormalizedTransformAnimation, buildTimelineTracks, convert2dTo3dPoint, convertGEToIR, convertIRToGE, createId, estimateTextWidth, get2dTo3dRatio, getEffectsCompositionSpecific, getEffectsLayerSpecific, hasEffectsAnimationPassthrough, hasEffectsColorAnimationPassthrough, hasIndependentParentLifetime, invalidateEffectsLayerSpecific, irPositionKeyframesToGE, irScalarKeyframesToGE, irVectorKeyframesToGE, lerp, normalizeChildVisibilityByParentDelays, readLottieSpecific, roundNumber, shouldUseKeyframeMode, toDataPath };
 //# sourceMappingURL=index.mjs.map