@vvfx/ge-ir 0.0.1-beta.4 → 0.0.1-beta.6

package/dist/index.mjs

@@ -3,12 +3,11 @@
  * Description: Galacean Effects and animation IR bidirectional conversion package
  * Author: Ant Group CO., Ltd.
  * Contributors: 澄弈
- * Version: v0.0.1-beta.4
+ * Version: v0.0.1-beta.6
  */
 
-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';
-import { BezierKeyframeType, ValueType, JSONSceneVersion } from '@galacean/effects-specification';
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -61,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;
@@ -258,6 +343,878 @@ function buildSubCompositionTrack(collector, delay, duration, endBehavior) {
     return trackId;
 }
 
+/**
+ * JSON 版本
+ */ var JSONSceneVersion;
+(function(JSONSceneVersion) {
+    JSONSceneVersion["1_0"] = "1.0";
+    JSONSceneVersion["1_1"] = "1.1";
+    JSONSceneVersion["1_2"] = "1.2";
+    JSONSceneVersion["1_3"] = "1.3";
+    JSONSceneVersion["1_5"] = "1.5";
+    JSONSceneVersion["1_8"] = "1.8";
+    JSONSceneVersion["2_0"] = "2.0";
+    JSONSceneVersion["2_1"] = "2.1";
+    JSONSceneVersion["2_2"] = "2.2";
+    JSONSceneVersion["2_3"] = "2.3";
+    JSONSceneVersion["2_4"] = "2.4";
+    JSONSceneVersion["3_0"] = "3.0";
+    JSONSceneVersion["3_1"] = "3.1";
+    JSONSceneVersion["3_2"] = "3.2";
+    JSONSceneVersion["3_3"] = "3.3";
+    JSONSceneVersion["3_4"] = "3.4";
+    JSONSceneVersion["3_5"] = "3.5";
+    JSONSceneVersion["3_6"] = "3.6";
+    JSONSceneVersion["3_7"] = "3.7";
+    JSONSceneVersion["LATEST"] = "3.7";
+})(JSONSceneVersion || (JSONSceneVersion = {}));
+
+/*********************************************/ /*               元素属性参数类型               */ /*********************************************/ /**
+ * 渲染等级
+ */ var RenderLevel;
+(function(RenderLevel) {
+    RenderLevel["S"] = "S";
+    RenderLevel["APlus"] = "A+";
+    RenderLevel["A"] = "A";
+    RenderLevel["BPlus"] = "B+";
+    RenderLevel["B"] = "B";
+})(RenderLevel || (RenderLevel = {}));
+/**
+ * 混合模式
+ */ var BlendingMode;
+(function(BlendingMode) {
+    /**
+     * 普通混合模式
+     */ BlendingMode[BlendingMode["ALPHA"] = 0] = "ALPHA";
+    /**
+     * 叠加混合模式
+     */ BlendingMode[BlendingMode["ADD"] = 1] = "ADD";
+    /**
+     * 相乘混合模式
+     */ BlendingMode[BlendingMode["MULTIPLY"] = 2] = "MULTIPLY";
+    /**
+     * 亮度混合模式
+     */ BlendingMode[BlendingMode["BRIGHTNESS"] = 3] = "BRIGHTNESS";
+    /**
+     * 减色混合模式
+     */ BlendingMode[BlendingMode["SUBTRACTION"] = 4] = "SUBTRACTION";
+    /**
+     * 强光混合模式
+     */ BlendingMode[BlendingMode["STRONG_LIGHT"] = 5] = "STRONG_LIGHT";
+    /**
+     * 弱光混合模式
+     */ BlendingMode[BlendingMode["WEAK_LIGHT"] = 6] = "WEAK_LIGHT";
+    /**
+     * 亮度叠加混合模式
+     */ BlendingMode[BlendingMode["SUPERPOSITION"] = 7] = "SUPERPOSITION";
+})(BlendingMode || (BlendingMode = {}));
+/**
+ * 单双面模式
+ */ var SideMode;
+(function(SideMode) {
+    /**
+     * 双面模式
+     */ SideMode[SideMode["DOUBLE"] = 1032] = "DOUBLE";
+    /**
+     * 正面模式
+     */ SideMode[SideMode["FRONT"] = 1028] = "FRONT";
+    /**
+     * 背面模式
+     */ SideMode[SideMode["BACK"] = 1029] = "BACK";
+})(SideMode || (SideMode = {}));
+/**
+ *  元素是否被蒙版遮挡/反向遮挡
+ */ var ObscuredMode;
+(function(ObscuredMode) {
+    /**
+     * 无
+     */ // NONE = 0,
+    // /**
+    //  * 蒙版
+    //  */
+    // MASK = 1,
+    /**
+     * 被遮挡
+     */ ObscuredMode[ObscuredMode["OBSCURED"] = 2] = "OBSCURED";
+    /**
+     * 被反向遮挡
+     */ ObscuredMode[ObscuredMode["REVERSE_OBSCURED"] = 3] = "REVERSE_OBSCURED";
+})(ObscuredMode || (ObscuredMode = {}));
+/**
+ * 发射器形状
+ */ var ParticleEmitterShapeType;
+(function(ParticleEmitterShapeType) {
+    /**
+     * 没有类型
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["NONE"] = 0] = "NONE";
+    /**
+     * 圆球
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["SPHERE"] = 1] = "SPHERE";
+    /**
+     * 圆锥
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["CONE"] = 2] = "CONE";
+    /**
+     * 半球
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["HEMISPHERE"] = 3] = "HEMISPHERE";
+    /**
+     * 圆
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["CIRCLE"] = 4] = "CIRCLE";
+    /**
+     * 圆环
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["DONUT"] = 5] = "DONUT";
+    /**
+     * 矩形
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["RECTANGLE"] = 6] = "RECTANGLE";
+    /**
+     * 矩形框
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["RECTANGLE_EDGE"] = 7] = "RECTANGLE_EDGE";
+    /**
+     * 直线
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["EDGE"] = 8] = "EDGE";
+    /**
+     * 贴图
+     */ ParticleEmitterShapeType[ParticleEmitterShapeType["TEXTURE"] = 9] = "TEXTURE";
+})(ParticleEmitterShapeType || (ParticleEmitterShapeType = {}));
+/**
+ * 插件类型
+ */ var PluginType;
+(function(PluginType) {
+    /**
+     * 陀螺仪
+     */ PluginType[PluginType["GYROSCOPE"] = 0] = "GYROSCOPE";
+    /**
+     * Spine
+     */ PluginType[PluginType["SPINE"] = 1] = "SPINE";
+})(PluginType || (PluginType = {}));
+/**
+ * 交互类型
+ */ var InteractType;
+(function(InteractType) {
+    /**
+     * 点击
+     */ InteractType[InteractType["CLICK"] = 0] = "CLICK";
+    /**
+     * 消息
+     * 前端收到 onMessageItem 回调
+     */ InteractType[InteractType["MESSAGE"] = 1] = "MESSAGE";
+    /**
+     * 拖拽
+     */ InteractType[InteractType["DRAG"] = 2] = "DRAG";
+})(InteractType || (InteractType = {}));
+/**
+ * 交互行为
+ */ var InteractBehavior;
+(function(InteractBehavior) {
+    /**
+     * 无
+     */ InteractBehavior[InteractBehavior["NONE"] = 0] = "NONE";
+    /**
+     * 通知
+     */ InteractBehavior[InteractBehavior["NOTIFY"] = 1] = "NOTIFY";
+    /**
+     * 重置播放器
+     */ InteractBehavior[InteractBehavior["RESUME_PLAYER"] = 2] = "RESUME_PLAYER";
+    /**
+     * 清除元素
+     */ InteractBehavior[InteractBehavior["REMOVE"] = 3] = "REMOVE";
+    /**
+     * 暂停播放器
+     */ InteractBehavior[InteractBehavior["PAUSE"] = 4] = "PAUSE";
+})(InteractBehavior || (InteractBehavior = {}));
+/**
+ * 元素类型
+ */ var ItemType;
+(function(ItemType) {
+    /**
+     * 错误元素
+     */ ItemType["base"] = "0";
+    /**
+     * 图层元素
+     */ ItemType["sprite"] = "1";
+    /**
+     * 粒子元素
+     */ ItemType["particle"] = "2";
+    /**
+     * 空节点元素
+     */ ItemType["null"] = "3";
+    /**
+     * 交互元素
+     */ ItemType["interact"] = "4";
+    /**
+     * 插件元素
+     */ ItemType["plugin"] = "5";
+    /**
+     * 相机元素
+     */ ItemType["camera"] = "6";
+    /**
+     * 预合成元素
+     */ ItemType["composition"] = "7";
+    /**
+     * Spine 元素
+     */ ItemType["spine"] = "spine";
+    /**
+     * Mesh 元素
+     */ ItemType["mesh"] = "mesh";
+    /**
+     * 节点树元素
+     */ ItemType["tree"] = "tree";
+    /**
+     * 文本元素
+     */ ItemType["text"] = "text";
+    /**
+     * 灯光元素
+     */ ItemType["light"] = "light";
+    /**
+     * 天空盒元素
+     */ ItemType["skybox"] = "skybox";
+    /**
+     * 特效元素
+     */ ItemType["effect"] = "effect";
+    /**
+     * 形状元素
+     */ ItemType["shape"] = "shape";
+    /**
+     * 后处理元素
+     */ ItemType["postProcessVolume"] = "postProcessVolume";
+    /**
+     * 节点元素
+     */ ItemType["node"] = "node";
+    /**
+     * 视频元素
+     */ ItemType["video"] = "video";
+    /**
+     * 音频元素
+     */ ItemType["audio"] = "audio";
+    /**
+     * 富文本元素
+     */ ItemType["richtext"] = "richtext";
+})(ItemType || (ItemType = {}));
+/**
+ * 渲染模式
+ */ var RenderMode;
+(function(RenderMode) {
+    /**
+     * 广告牌模式
+     */ RenderMode[RenderMode["BILLBOARD"] = 0] = "BILLBOARD";
+    /**
+     * 网格模式
+     */ RenderMode[RenderMode["MESH"] = 1] = "MESH";
+    /**
+     * 垂直广告牌模式
+     */ RenderMode[RenderMode["VERTICAL_BILLBOARD"] = 2] = "VERTICAL_BILLBOARD";
+    /**
+     * 水平广告牌模式
+     */ RenderMode[RenderMode["HORIZONTAL_BILLBOARD"] = 3] = "HORIZONTAL_BILLBOARD";
+})(RenderMode || (RenderMode = {}));
+/**
+ * 变换中心
+ */ var ParticleOrigin;
+(function(ParticleOrigin) {
+    /**
+     * 水平和垂直中点
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_CENTER"] = 0] = "PARTICLE_ORIGIN_CENTER";
+    /**
+     * 水平左侧 垂直顶部
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_LEFT_TOP"] = 1] = "PARTICLE_ORIGIN_LEFT_TOP";
+    /**
+     * 水平左侧 垂直中间
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_LEFT_CENTER"] = 2] = "PARTICLE_ORIGIN_LEFT_CENTER";
+    /**
+     * 水平左侧 垂直底部
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_LEFT_BOTTOM"] = 3] = "PARTICLE_ORIGIN_LEFT_BOTTOM";
+    /**
+     * 水平中间 垂直顶部
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_CENTER_TOP"] = 4] = "PARTICLE_ORIGIN_CENTER_TOP";
+    /**
+     * 水平中间 垂直底部
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_CENTER_BOTTOM"] = 5] = "PARTICLE_ORIGIN_CENTER_BOTTOM";
+    /**
+     * 水平右侧 垂直顶部
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_RIGHT_TOP"] = 6] = "PARTICLE_ORIGIN_RIGHT_TOP";
+    /**
+     * 水平右侧 垂直中间
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_RIGHT_CENTER"] = 7] = "PARTICLE_ORIGIN_RIGHT_CENTER";
+    /**
+     * 水平右侧 垂直底部
+     */ ParticleOrigin[ParticleOrigin["PARTICLE_ORIGIN_RIGHT_BOTTOM"] = 8] = "PARTICLE_ORIGIN_RIGHT_BOTTOM";
+})(ParticleOrigin || (ParticleOrigin = {}));
+var RenderType;
+(function(RenderType) {
+    RenderType["Opaque"] = "Opaque";
+    RenderType["Transparent"] = "Transparent";
+})(RenderType || (RenderType = {}));
+var RenderFace;
+(function(RenderFace) {
+    RenderFace["Both"] = "Both";
+    RenderFace["Back"] = "Back";
+    RenderFace["Front"] = "Front";
+})(RenderFace || (RenderFace = {}));
+
+var CameraClipMode;
+(function(CameraClipMode) {
+    /**
+     * 剪裁上下
+     */ CameraClipMode[CameraClipMode["portrait"] = 1] = "portrait";
+    /**
+     * 剪裁左右
+     */ CameraClipMode[CameraClipMode["landscape"] = 0] = "landscape";
+})(CameraClipMode || (CameraClipMode = {}));
+
+/*********************************************/ /*               基本数值属性参数              */ /*********************************************/ var ValueType;
+(function(ValueType) {
+    /**
+     * 常数
+     */ ValueType[ValueType["CONSTANT"] = 0] = "CONSTANT";
+    /**
+     * 二维常数向量
+     */ ValueType[ValueType["CONSTANT_VEC2"] = 1] = "CONSTANT_VEC2";
+    /**
+     * 三维常数向量
+     */ ValueType[ValueType["CONSTANT_VEC3"] = 2] = "CONSTANT_VEC3";
+    /**
+     * 四维常数向量
+     */ ValueType[ValueType["CONSTANT_VEC4"] = 3] = "CONSTANT_VEC4";
+    /**
+     * 随机数
+     */ ValueType[ValueType["RANDOM"] = 4] = "RANDOM";
+    /**
+     * 直线
+     */ ValueType[ValueType["LINE"] = 5] = "LINE";
+    /**
+     * 曲线（Hermite 曲线）
+     * @deprecated 使用 BEZIER_CURVE 替代，此类型仅用于旧数据迁移兼容
+     */ ValueType[ValueType["CURVE"] = 6] = "CURVE";
+    /**
+     * 贝塞尔路径
+     * @deprecated 使用 BEZIER_CURVE_PATH 替代，此类型仅用于旧数据迁移兼容
+     */ ValueType[ValueType["BEZIER_PATH"] = 7] = "BEZIER_PATH";
+    /**
+     * 颜色
+     */ ValueType[ValueType["RGBA_COLOR"] = 8] = "RGBA_COLOR";
+    /**
+     * 渐变色
+     */ ValueType[ValueType["GRADIENT_COLOR"] = 9] = "GRADIENT_COLOR";
+    /**
+     * 蒙版形状点集
+     */ ValueType[ValueType["SHAPE_POINTS"] = 10] = "SHAPE_POINTS";
+    /**
+     * 蒙版形状切分
+     */ ValueType[ValueType["SHAPE_SPLITS"] = 11] = "SHAPE_SPLITS";
+    /**
+     * 直线路径
+     */ ValueType[ValueType["LINEAR_PATH"] = 12] = "LINEAR_PATH";
+    /**
+     * 多色
+     */ ValueType[ValueType["COLORS"] = 13] = "COLORS";
+    /**
+     * 二进制指针
+     */ ValueType[ValueType["BINARY"] = 20] = "BINARY";
+    /**
+     * 贝塞尔曲线
+     */ ValueType[ValueType["BEZIER_CURVE"] = 21] = "BEZIER_CURVE";
+    /**
+     * 贝塞尔曲线路径
+     */ ValueType[ValueType["BEZIER_CURVE_PATH"] = 22] = "BEZIER_CURVE_PATH";
+    /**
+     * 贝塞尔曲线四元数
+     */ ValueType[ValueType["BEZIER_CURVE_QUAT"] = 23] = "BEZIER_CURVE_QUAT";
+    /**
+     * 颜色曲线
+     */ ValueType[ValueType["COLOR_CURVE"] = 24] = "COLOR_CURVE";
+    /**
+     * Vector4 曲线
+     */ ValueType[ValueType["VECTOR4_CURVE"] = 25] = "VECTOR4_CURVE";
+    /**
+     * Vector2 曲线
+     */ ValueType[ValueType["VECTOR2_CURVE"] = 26] = "VECTOR2_CURVE";
+    /**
+     * Vector3 曲线
+     */ ValueType[ValueType["VECTOR3_CURVE"] = 27] = "VECTOR3_CURVE";
+})(ValueType || (ValueType = {}));
+/**
+ * 关键帧类型
+ */ var BezierKeyframeType;
+(function(BezierKeyframeType) {
+    BezierKeyframeType[BezierKeyframeType["AUTO"] = 0] = "AUTO";
+    BezierKeyframeType[BezierKeyframeType["EASE"] = 1] = "EASE";
+    BezierKeyframeType[BezierKeyframeType["EASE_IN"] = 2] = "EASE_IN";
+    BezierKeyframeType[BezierKeyframeType["EASE_OUT"] = 3] = "EASE_OUT";
+    BezierKeyframeType[BezierKeyframeType["LINE"] = 4] = "LINE";
+    BezierKeyframeType[BezierKeyframeType["HOLD"] = 5] = "HOLD";
+    BezierKeyframeType[BezierKeyframeType["LINE_OUT"] = 6] = "LINE_OUT";
+})(BezierKeyframeType || (BezierKeyframeType = {}));
+
+/**
+ * 结束行为
+ */ var EndBehavior;
+(function(EndBehavior) {
+    /**
+     * 销毁
+     */ EndBehavior[EndBehavior["destroy"] = 0] = "destroy";
+    /**
+     * 重播
+     */ EndBehavior[EndBehavior["restart"] = 5] = "restart";
+    /**
+     * 无限播放
+     */ EndBehavior[EndBehavior["forward"] = 2] = "forward";
+    /**
+     * 冻结
+     */ EndBehavior[EndBehavior["freeze"] = 4] = "freeze";
+})(EndBehavior || (EndBehavior = {}));
+
+/**
+ * 粒子交互行为
+ */ var ParticleInteractionBehavior;
+(function(ParticleInteractionBehavior) {
+    /**
+     * 无
+     */ ParticleInteractionBehavior[ParticleInteractionBehavior["none"] = 0] = "none";
+    /**
+     * 移出粒子
+     */ ParticleInteractionBehavior[ParticleInteractionBehavior["removeParticle"] = 1] = "removeParticle";
+})(ParticleInteractionBehavior || (ParticleInteractionBehavior = {}));
+
+var ShapeArcMode;
+(function(ShapeArcMode) {
+    /**
+     * 随机
+     */ ShapeArcMode[ShapeArcMode["RANDOM"] = 0] = "RANDOM";
+    /**
+     * 单向循环
+     */ ShapeArcMode[ShapeArcMode["UNIDIRECTIONAL_CYCLE"] = 1] = "UNIDIRECTIONAL_CYCLE";
+    /**
+     * 双向循环
+     */ ShapeArcMode[ShapeArcMode["BIDIRECTIONAL_CYCLE"] = 2] = "BIDIRECTIONAL_CYCLE";
+    /**
+     * 均匀爆发
+     */ ShapeArcMode[ShapeArcMode["UNIFORM_BURST"] = 3] = "UNIFORM_BURST";
+})(ShapeArcMode || (ShapeArcMode = {}));
+
+var LightType;
+(function(LightType) {
+    /**
+     * 点光源
+     */ LightType["point"] = "point";
+    /**
+     * 聚光灯
+     */ LightType["spot"] = "spot";
+    /**
+     * 方向光
+     */ LightType["directional"] = "directional";
+    /**
+     * 环境光
+     */ LightType["ambient"] = "ambient";
+})(LightType || (LightType = {}));
+
+var ModelBoundingType;
+(function(ModelBoundingType) {
+    ModelBoundingType[ModelBoundingType["box"] = 2] = "box";
+    ModelBoundingType[ModelBoundingType["sphere"] = 3] = "sphere";
+})(ModelBoundingType || (ModelBoundingType = {}));
+
+var CameraType;
+(function(CameraType) {
+    CameraType["orthographic"] = "orthographic";
+    CameraType["perspective"] = "perspective";
+})(CameraType || (CameraType = {}));
+
+// 材质类型
+var MaterialType;
+(function(MaterialType) {
+    MaterialType["unlit"] = "unlit";
+    MaterialType["pbr"] = "pbr";
+    // 头发材质，在 pbr 材质基础上扩展
+    MaterialType["hair"] = "hair";
+})(MaterialType || (MaterialType = {}));
+// 混合模式
+var MaterialBlending;
+(function(MaterialBlending) {
+    MaterialBlending[MaterialBlending["opaque"] = 100] = "opaque";
+    MaterialBlending[MaterialBlending["masked"] = 101] = "masked";
+    MaterialBlending[MaterialBlending["translucent"] = 102] = "translucent";
+    MaterialBlending[MaterialBlending["additive"] = 103] = "additive";
+})(MaterialBlending || (MaterialBlending = {}));
+
+/**
+ * 3D渲染模式：将渲染过程中的中间结果输出，主要用于排查渲染效果问题，支持 pbr 和 unlit 材质
+ */ var RenderMode3D;
+(function(RenderMode3D) {
+    /**
+     * 正常渲染
+     */ RenderMode3D["none"] = "none";
+    /**
+     * 纹理坐标
+     */ RenderMode3D["uv"] = "uv";
+    /**
+     * 世界坐标法线
+     */ RenderMode3D["normal"] = "normal";
+    /**
+     * 基础颜色
+     */ RenderMode3D["basecolor"] = "basecolor";
+    /**
+     * 基础颜色 Alpha
+     */ RenderMode3D["alpha"] = "alpha";
+    /**
+     * 金属度
+     */ RenderMode3D["metallic"] = "metallic";
+    /**
+     * 粗超度
+     */ RenderMode3D["roughness"] = "roughness";
+    /**
+     * 环境遮蔽
+     */ RenderMode3D["ao"] = "ao";
+    /**
+     * 自发光
+     */ RenderMode3D["emissive"] = "emissive";
+    /**
+     * 漫反射
+     */ RenderMode3D["diffuse"] = "diffuse";
+})(RenderMode3D || (RenderMode3D = {}));
+
+var TextOverflow;
+(function(TextOverflow) {
+    /**
+     * visible 模式下，文本内容超出边界框时，会继续显示内容，不进行裁剪或缩放。
+     */ TextOverflow[TextOverflow["visible"] = 0] = "visible";
+    /**
+     * display 模式下，会显示所有文本，文本字号大小会根据边界框调整。
+     */ TextOverflow[TextOverflow["display"] = 1] = "display";
+    /**
+     * clip 模式下，当文本内容超出边界框时，多余的会被截断。
+     */ TextOverflow[TextOverflow["clip"] = 2] = "clip";
+    /**
+     * ellipsis 模式下，会使用（...）来代替超出边界框的内容。
+     */ TextOverflow[TextOverflow["ellipsis"] = 3] = "ellipsis";
+})(TextOverflow || (TextOverflow = {}));
+var TextSizeMode;
+(function(TextSizeMode) {
+    /**
+     * 自适应宽度
+     */ TextSizeMode[TextSizeMode["autoWidth"] = 0] = "autoWidth";
+    /**
+     * 自适应高度
+     */ TextSizeMode[TextSizeMode["autoHeight"] = 1] = "autoHeight";
+    /**
+     * 固定宽高
+     */ TextSizeMode[TextSizeMode["fixed"] = 2] = "fixed";
+})(TextSizeMode || (TextSizeMode = {}));
+var TextBaseline;
+(function(TextBaseline) {
+    /**
+     * 文本顶对齐。
+     */ TextBaseline[TextBaseline["top"] = 0] = "top";
+    /**
+     * 文本垂直居中对齐。
+     */ TextBaseline[TextBaseline["middle"] = 1] = "middle";
+    /**
+     * 文本底对齐。
+     */ TextBaseline[TextBaseline["bottom"] = 2] = "bottom";
+})(TextBaseline || (TextBaseline = {}));
+var TextAlignment;
+(function(TextAlignment) {
+    /**
+     * text alignment starts from（x,y) to right direction
+     * 从 (x,y) 开始第一个字符，向右边延伸
+     */ TextAlignment[TextAlignment["left"] = 0] = "left";
+    /**
+     * (x,y) is middle position of text, where (left + right)/2 =(x,y)
+     * (x,y) 为文字中间位置，（最左位置 + 最右位置)/2 = (x,y)
+     */ TextAlignment[TextAlignment["middle"] = 1] = "middle";
+    /**
+     * text alignment ends with（x,y) from left direction
+     * 从 (x,y) 结束最后一个字符，向左边延伸
+     */ TextAlignment[TextAlignment["right"] = 2] = "right";
+})(TextAlignment || (TextAlignment = {}));
+var TextVerticalAlign;
+(function(TextVerticalAlign) {
+    /**
+     * 文本顶对齐。
+     */ TextVerticalAlign[TextVerticalAlign["top"] = 0] = "top";
+    /**
+     * 文本垂直居中对齐。
+     */ TextVerticalAlign[TextVerticalAlign["middle"] = 1] = "middle";
+    /**
+     * 文本底对齐。
+     */ TextVerticalAlign[TextVerticalAlign["bottom"] = 2] = "bottom";
+})(TextVerticalAlign || (TextVerticalAlign = {}));
+/**
+ * 文本字重
+ */ var TextWeight;
+(function(TextWeight) {
+    /**
+     * 正常
+     */ TextWeight["normal"] = "normal";
+    /**
+     * 粗体
+     */ TextWeight["bold"] = "bold";
+    /**
+     * 瘦体
+     */ TextWeight["lighter"] = "lighter";
+})(TextWeight || (TextWeight = {}));
+/**
+ * 文本样式
+ */ var FontStyle;
+(function(FontStyle) {
+    /**
+     * 正常
+     */ FontStyle["normal"] = "normal";
+    /**
+     * 斜体
+     */ FontStyle["italic"] = "italic";
+    /**
+     * 倾斜体
+     */ FontStyle["oblique"] = "oblique";
+})(FontStyle || (FontStyle = {}));
+
+var FillType;
+(function(FillType) {
+    FillType[FillType["Solid"] = 0] = "Solid";
+    FillType[FillType["GradientLinear"] = 1] = "GradientLinear";
+    FillType[FillType["GradientRadial"] = 2] = "GradientRadial";
+    FillType[FillType["GradientAngular"] = 3] = "GradientAngular";
+    FillType[FillType["Texture"] = 4] = "Texture";
+})(FillType || (FillType = {}));
+var TexturePaintScaleMode;
+(function(TexturePaintScaleMode) {
+    TexturePaintScaleMode[TexturePaintScaleMode["Fill"] = 0] = "Fill";
+    TexturePaintScaleMode[TexturePaintScaleMode["Fit"] = 1] = "Fit";
+    TexturePaintScaleMode[TexturePaintScaleMode["Crop"] = 2] = "Crop";
+    TexturePaintScaleMode[TexturePaintScaleMode["Tile"] = 3] = "Tile";
+})(TexturePaintScaleMode || (TexturePaintScaleMode = {}));
+
+/**
+ * 矢量图形类型
+ */ var ShapePrimitiveType;
+(function(ShapePrimitiveType) {
+    /**
+     * 自定义图形
+     */ ShapePrimitiveType[ShapePrimitiveType["Custom"] = 0] = "Custom";
+    /**
+     * 矩形
+     */ ShapePrimitiveType[ShapePrimitiveType["Rectangle"] = 1] = "Rectangle";
+    /**
+     * 椭圆
+     */ ShapePrimitiveType[ShapePrimitiveType["Ellipse"] = 2] = "Ellipse";
+    /**
+     * 多边形
+     */ ShapePrimitiveType[ShapePrimitiveType["Polygon"] = 3] = "Polygon";
+    /**
+     * 星形
+     */ ShapePrimitiveType[ShapePrimitiveType["Star"] = 4] = "Star";
+})(ShapePrimitiveType || (ShapePrimitiveType = {}));
+
+var LineCap;
+(function(LineCap) {
+    /** 默认值。向线条的每个末端添加平直的边缘 */ LineCap[LineCap["Butt"] = 0] = "Butt";
+    /** 向线条的每个末端添加圆形线帽 */ LineCap[LineCap["Round"] = 1] = "Round";
+    /** 向线条的每个末端添加正方形线帽 */ LineCap[LineCap["Square"] = 2] = "Square";
+})(LineCap || (LineCap = {}));
+var LineJoin;
+(function(LineJoin) {
+    /** 创建圆角 */ LineJoin[LineJoin["Round"] = 0] = "Round";
+    /** 创建斜角 */ LineJoin[LineJoin["Bevel"] = 1] = "Bevel";
+    /** 创建尖角 */ LineJoin[LineJoin["Miter"] = 2] = "Miter";
+})(LineJoin || (LineJoin = {}));
+
+var NodeDataType;
+(function(NodeDataType) {
+    NodeDataType["AnimationClipNodeData"] = "AnimationClipNodeData";
+    NodeDataType["BlendNodeData"] = "BlendNodeData";
+    NodeDataType["ApplyAdditiveNodeData"] = "ApplyAdditiveNodeData";
+    NodeDataType["LayerBlendNodeData"] = "LayerBlendNodeData";
+    NodeDataType["StateMachineNodeData"] = "StateMachineNodeData";
+    NodeDataType["TransitionNodeData"] = "TransitionNodeData";
+    NodeDataType["StateNodeData"] = "StateNodeData";
+    NodeDataType["ConstFloatNodeData"] = "ConstFloatNodeData";
+    NodeDataType["ConstBoolNodeData"] = "ConstBoolNodeData";
+    NodeDataType["ControlParameterBoolNodeData"] = "ControlParameterBoolNodeData";
+    NodeDataType["ControlParameterFloatNodeData"] = "ControlParameterFloatNodeData";
+    NodeDataType["ControlParameterTriggerNodeData"] = "ControlParameterTriggerNodeData";
+    NodeDataType["NotNodeData"] = "NotNodeData";
+    NodeDataType["AndNodeData"] = "AndNodeData";
+    NodeDataType["OrNodeData"] = "OrNodeData";
+    NodeDataType["EqualNodeData"] = "EqualNodeData";
+    NodeDataType["GreaterNodeData"] = "GreaterNodeData";
+    NodeDataType["LessNodeData"] = "LessNodeData";
+})(NodeDataType || (NodeDataType = {}));
+
+/**
+ * 动态换图类型
+ * @since 1.1.0
+ */ var BackgroundType;
+(function(BackgroundType) {
+    BackgroundType["video"] = "video";
+    BackgroundType["image"] = "image";
+})(BackgroundType || (BackgroundType = {}));
+/**
+ * 多媒体资源类型
+ * @since 2.1.0
+ */ var MultimediaType;
+(function(MultimediaType) {
+    MultimediaType["video"] = "video";
+    MultimediaType["audio"] = "audio";
+})(MultimediaType || (MultimediaType = {}));
+var HevcVideoCodec;
+(function(HevcVideoCodec) {
+    HevcVideoCodec["L30"] = "hev1.1.0.L30.B0";
+    HevcVideoCodec["L60"] = "hev1.1.0.L60.B0";
+    HevcVideoCodec["L63"] = "hev1.1.0.L63.B0";
+    HevcVideoCodec["L90"] = "hev1.1.0.L90.B0";
+    HevcVideoCodec["L93"] = "hev1.1.0.L93.B0";
+    HevcVideoCodec["L120"] = "hev1.1.0.L120.B0";
+    HevcVideoCodec["L150"] = "hev1.1.0.L150.B0";
+    HevcVideoCodec["L180"] = "hev1.1.0.L180.B0";
+})(HevcVideoCodec || (HevcVideoCodec = {}));
+
+var DataType;
+(function(DataType) {
+    DataType["VFXItemData"] = "VFXItemData";
+    // Assets
+    DataType["Material"] = "Material";
+    DataType["Shader"] = "Shader";
+    DataType["Geometry"] = "Geometry";
+    DataType["Texture"] = "Texture";
+    DataType["Image"] = "Image";
+    DataType["AnimationClip"] = "AnimationClip";
+    DataType["BinaryAsset"] = "BinaryAsset";
+    // Timeline
+    DataType["TrackAsset"] = "TrackAsset";
+    DataType["TimelineAsset"] = "TimelineAsset";
+    DataType["ObjectBindingTrack"] = "ObjectBindingTrack";
+    DataType["TransformTrack"] = "TransformTrack";
+    DataType["SpriteColorTrack"] = "SpriteColorTrack";
+    DataType["ActivationTrack"] = "ActivationTrack";
+    DataType["SubCompositionTrack"] = "SubCompositionTrack";
+    DataType["FloatPropertyTrack"] = "FloatPropertyTrack";
+    DataType["ColorPropertyTrack"] = "ColorPropertyTrack";
+    DataType["Vector2PropertyTrack"] = "Vector2PropertyTrack";
+    DataType["Vector3PropertyTrack"] = "Vector3PropertyTrack";
+    DataType["Vector4PropertyTrack"] = "Vector4PropertyTrack";
+    DataType["TransformPlayableAsset"] = "TransformPlayableAsset";
+    DataType["SpriteColorPlayableAsset"] = "SpriteColorPlayableAsset";
+    DataType["ActivationPlayableAsset"] = "ActivationPlayableAsset";
+    DataType["SubCompositionPlayableAsset"] = "SubCompositionPlayableAsset";
+    DataType["FloatPropertyPlayableAsset"] = "FloatPropertyPlayableAsset";
+    DataType["ColorPropertyPlayableAsset"] = "ColorPropertyPlayableAsset";
+    DataType["Vector2PropertyPlayableAsset"] = "Vector2PropertyPlayableAsset";
+    DataType["Vector3PropertyPlayableAsset"] = "Vector3PropertyPlayableAsset";
+    DataType["Vector4PropertyPlayableAsset"] = "Vector4PropertyPlayableAsset";
+    // Components
+    DataType["MeshComponent"] = "MeshComponent";
+    DataType["SkyboxComponent"] = "SkyboxComponent";
+    DataType["LightComponent"] = "LightComponent";
+    DataType["CameraComponent"] = "CameraComponent";
+    DataType["ModelPluginComponent"] = "ModelPluginComponent";
+    DataType["TreeComponent"] = "TreeComponent";
+    DataType["AnimationComponent"] = "AnimationComponent";
+    DataType["SpineComponent"] = "SpineComponent";
+    DataType["VideoComponent"] = "VideoComponent";
+    DataType["AudioComponent"] = "AudioComponent";
+    DataType["RichTextComponent"] = "RichTextComponent";
+    DataType["OrientationComponent"] = "OrientationComponent";
+    DataType["ShapeComponent"] = "ShapeComponent";
+    DataType["SpriteComponent"] = "SpriteComponent";
+    DataType["ParticleSystem"] = "ParticleSystem";
+    DataType["InteractComponent"] = "InteractComponent";
+    DataType["CameraController"] = "CameraController";
+    DataType["PostProcessVolume"] = "PostProcessVolume";
+    DataType["EffectComponent"] = "EffectComponent";
+    DataType["TextComponent"] = "TextComponent";
+    DataType["AnimationGraphAsset"] = "AnimationGraphAsset";
+    DataType["CompositionComponent"] = "CompositionComponent";
+    DataType["FFDComponent"] = "FFDComponent";
+    DataType["FrameComponent"] = "FrameComponent";
+    DataType["Animator"] = "Animator";
+    // Non-EffectObject
+    DataType["TimelineClip"] = "TimelineClip";
+})(DataType || (DataType = {}));
+
+var GeometryType;
+(function(GeometryType) {
+    /**
+     * Draw single points.
+     */ GeometryType[GeometryType["POINTS"] = 0] = "POINTS";
+    /**
+     * Draw lines. Each vertex connects to the one after it.
+     */ GeometryType[GeometryType["LINES"] = 1] = "LINES";
+    /**
+     * Draw lines. Each set of two vertices is treated as a separate line segment.
+     */ GeometryType[GeometryType["LINE_LOOP"] = 2] = "LINE_LOOP";
+    /**
+     * Draw a connected group of line segments from the first vertex to the last.
+     */ GeometryType[GeometryType["LINE_STRIP"] = 3] = "LINE_STRIP";
+    /**
+     * Draw triangles. Each set of three vertices creates a separate triangle.
+     */ GeometryType[GeometryType["TRIANGLES"] = 4] = "TRIANGLES";
+    /**
+     * Draw a connected strip of triangles.
+     */ GeometryType[GeometryType["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+    /**
+     * Draw a connected group of triangles. Each vertex connects to the previous and the first vertex in the fan.
+     */ GeometryType[GeometryType["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+})(GeometryType || (GeometryType = {}));
+var VertexFormatType;
+(function(VertexFormatType) {
+    VertexFormatType[VertexFormatType["Float16"] = 0] = "Float16";
+    VertexFormatType[VertexFormatType["Float32"] = 1] = "Float32";
+    VertexFormatType[VertexFormatType["Int8"] = 2] = "Int8";
+    VertexFormatType[VertexFormatType["Int16"] = 3] = "Int16";
+    VertexFormatType[VertexFormatType["Int32"] = 4] = "Int32";
+    VertexFormatType[VertexFormatType["UInt8"] = 5] = "UInt8";
+    VertexFormatType[VertexFormatType["UInt16"] = 6] = "UInt16";
+    VertexFormatType[VertexFormatType["UInt32"] = 7] = "UInt32";
+})(VertexFormatType || (VertexFormatType = {}));
+var IndexFormatType;
+(function(IndexFormatType) {
+    IndexFormatType[IndexFormatType["None"] = -1] = "None";
+    IndexFormatType[IndexFormatType["UInt8"] = 0] = "UInt8";
+    IndexFormatType[IndexFormatType["UInt16"] = 1] = "UInt16";
+    IndexFormatType[IndexFormatType["UInt32"] = 2] = "UInt32";
+})(IndexFormatType || (IndexFormatType = {}));
+// BINORMAL[n]	Binormal	float4
+// BLENDINDICES[n]	混合索引	uint
+// BLENDWEIGHT[n]	混合权重	FLOAT
+// COLOR[n]	漫射和反射颜色	float4
+// NORMAL[n]	法向矢量	float4
+// POSITION[n]	对象空间中的顶点位置。	float4
+// POSITIONT	变换的顶点位置。	float4
+// PSIZE[n]	点大小	FLOAT
+// TANGENT[n]	正切	float4
+// TEXCOORD[n]	纹理坐标	float4
+// POSITION_BS[n]	Blend Shape 空间中的顶点位置	float4
+// NORMAL_BS[n]	Blend Shape 空间中的法向矢量	float4
+// TANGENT_BS[n]	Blend Shape 空间中的正切矢量	float4
+var VertexBufferSemantic;
+(function(VertexBufferSemantic) {
+    VertexBufferSemantic["Position"] = "POSITION";
+    VertexBufferSemantic["Uv"] = "TEXCOORD0";
+    VertexBufferSemantic["Uv2"] = "TEXCOORD1";
+    VertexBufferSemantic["Normal"] = "NORMAL";
+    VertexBufferSemantic["Tangent"] = "TANGENT";
+    VertexBufferSemantic["Color"] = "COLOR";
+    VertexBufferSemantic["Joints"] = "JOINTS";
+    VertexBufferSemantic["Weights"] = "WEIGHTS";
+    //
+    VertexBufferSemantic["PositionBS0"] = "POSITION_BS0";
+    VertexBufferSemantic["PositionBS1"] = "POSITION_BS1";
+    VertexBufferSemantic["PositionBS2"] = "POSITION_BS2";
+    VertexBufferSemantic["PositionBS3"] = "POSITION_BS3";
+    VertexBufferSemantic["PositionBS4"] = "POSITION_BS4";
+    VertexBufferSemantic["PositionBS5"] = "POSITION_BS5";
+    VertexBufferSemantic["PositionBS6"] = "POSITION_BS6";
+    VertexBufferSemantic["PositionBS7"] = "POSITION_BS7";
+    VertexBufferSemantic["NormalBS0"] = "NORMAL_BS0";
+    VertexBufferSemantic["NormalBS1"] = "NORMAL_BS1";
+    VertexBufferSemantic["NormalBS2"] = "NORMAL_BS2";
+    VertexBufferSemantic["NormalBS3"] = "NORMAL_BS3";
+    VertexBufferSemantic["TangentBS0"] = "TANGENT_BS0";
+    VertexBufferSemantic["TangentBS1"] = "TANGENT_BS1";
+    VertexBufferSemantic["TangentBS2"] = "TANGENT_BS2";
+    VertexBufferSemantic["TangentBS3"] = "TANGENT_BS3";
+})(VertexBufferSemantic || (VertexBufferSemantic = {}));
+
+JSONSceneVersion.LATEST;
+
 var DEFAULT_OUT_TANGENT = {
     x: 0.33,
     y: 0.33
@@ -322,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
@@ -370,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
@@ -390,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
@@ -402,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,
@@ -420,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
             ]
@@ -501,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
@@ -611,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';
 }
 
 /**
@@ -632,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 {
@@ -655,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
@@ -693,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
         ];
     }
-    var value = scale.value;
+    if (scale.keyframed && scale.keyframes.length !== 1) {
+        return [
+            1,
+            1
+        ];
+    }
+    var value = scale.keyframed ? (_scale_keyframes_ = scale.keyframes[0]) == null ? void 0 : _scale_keyframes_.value : scale.value;
     if (!Array.isArray(value)) {
         return [
             1,
@@ -713,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;
     }
@@ -730,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;
@@ -786,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;
 }
@@ -805,86 +1743,20 @@ 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) {
         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 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 positionOverLifetime = passthroughPosition != null ? passthroughPosition : buildPositionAnim(layer, transform, timeContext, ctx);
     var rotationOverLifetime = passthroughRotation != null ? passthroughRotation : buildRotationAnim(transform, timeContext);
     var sizeOverLifetime = passthroughSize != null ? passthroughSize : buildSizeAnim(transform, timeContext);
     return {
@@ -893,11 +1765,13 @@ function buildTransformAnimation(layer, ctx) {
         sizeOverLifetime: sizeOverLifetime
     };
 }
-function buildPositionAnim(transform, timeContext, ctx) {
+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;
@@ -905,28 +1779,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);
         }
     }
@@ -965,112 +1839,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;
@@ -1082,25 +1883,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;
+    }
+    if (!property.keyframed) {
+        return property.value !== 0 ? [
+            ValueType.CONSTANT,
+            property.value
+        ] : undefined;
     }
-    return (_ref = (_rotation_keyframes = rotation.keyframes) == null ? void 0 : _rotation_keyframes.some(function(keyframe) {
-        var _keyframe_value_axis, _ref;
+    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({
@@ -1122,30 +1944,31 @@ 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;
     }
@@ -1163,6 +1986,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 {
@@ -1174,12 +2006,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
             ]
         };
     }
@@ -1261,18 +2093,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) {
@@ -1289,21 +2123,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);
@@ -1319,7 +2152,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);
     }
@@ -1345,7 +2179,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;
 }
@@ -1366,7 +2200,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 = {
@@ -1401,7 +2235,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;
 }
@@ -1423,7 +2257,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;
 }
@@ -1431,21 +2265,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);
@@ -1473,18 +2321,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;
@@ -1495,8 +2331,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];
 }
@@ -1508,10 +2342,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 {
@@ -1520,7 +2350,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,
@@ -1528,13 +2358,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]
@@ -1572,8 +2401,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),
@@ -1594,7 +2423,7 @@ function mapCustomPaths(paths, ratio) {
             });
         }
         shapes.push({
-            close: path.close,
+            close: path.closed,
             indexes: indexes
         });
     }
@@ -1605,100 +2434,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;
 }
@@ -1707,7 +2490,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');
@@ -1717,7 +2500,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+',
@@ -1753,19 +2536,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+',
@@ -1809,14 +2592,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);
@@ -1861,9 +2643,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);
@@ -1876,13 +2660,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+',
@@ -1913,35 +2706,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];
@@ -1952,7 +2734,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);
@@ -1979,7 +2761,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+',
@@ -2008,19 +2790,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, {
@@ -2055,7 +2842,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) {
@@ -2068,7 +2855,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+',
@@ -2201,16 +2988,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 [
@@ -2281,13 +3072,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();
@@ -2295,7 +3083,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';
@@ -2487,8 +3275,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;
@@ -2513,8 +3301,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,
@@ -2531,47 +3319,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,
@@ -2583,7 +3365,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
             }
         ],
@@ -2616,10 +3398,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
@@ -2627,7 +3409,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'];
@@ -2639,7 +3421,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.
@@ -2654,15 +3436,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;
@@ -2678,9 +3460,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) {
@@ -2742,8 +3524,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.
@@ -2752,7 +3534,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'];
@@ -2787,7 +3569,8 @@ function advanceTransformOnlyParentLinkParents(items, itemById, processedByItemI
         }
     }
     // Merge all parent IDs that need adjustment.
-    var allParentIds = new Set([].concat(parentAdvanceMap.keys(), parentExtendMap.keys()));
+    // Materialize Map iterators: loose SWC array-spread lowering assumes arrays.
+    var allParentIds = new Set([].concat(Array.from(parentAdvanceMap.keys()), Array.from(parentExtendMap.keys())));
     // Apply adjustments: update parent item delay/duration and sync ActivationTrack clips.
     for(var _iterator1 = _create_for_of_iterator_helper_loose(allParentIds), _step1; !(_step1 = _iterator1()).done;){
         var parentId1 = _step1.value;
@@ -2887,18 +3670,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) {
@@ -2918,13 +3701,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);
             }
         }
     }
@@ -2932,25 +3715,72 @@ function applyVisibilityStep(ir, state) {
         items: collector.items,
         miscs: collector.miscs,
         processedItems: processedItems,
-        transformOnlyParentLinkItemIds: transformOnlyParentLinkItemIds,
+        independentLifetimeChildItemIds: independentLifetimeChildItemIds,
         roundNumber: roundNumber
     });
 }
 
+var OMIT = Symbol('omit-json-value');
+/** Return a detached value whose runtime shape is stable across JSON persistence. */ function normalizeJsonValue(value) {
+    var normalized = normalize(value, '$', false);
+    if (normalized === OMIT) {
+        throw new TypeError('[ge-ir] A top-level JSON value cannot be undefined.');
+    }
+    return normalized;
+}
+function normalize(value, path, inArray) {
+    if (value === undefined) {
+        return inArray ? null : OMIT;
+    }
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new TypeError("[ge-ir] Non-finite number at " + path + " is not JSON-compatible.");
+        }
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(function(item, index) {
+            var normalizedItem = normalize(item, path + "[" + index + "]", true);
+            if (normalizedItem === OMIT) {
+                throw new TypeError("[ge-ir] Array item at " + path + "[" + index + "] could not be normalized.");
+            }
+            return normalizedItem;
+        });
+    }
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object') {
+        throw new TypeError("[ge-ir] " + (typeof value === "undefined" ? "undefined" : _type_of(value)) + " at " + path + " is not JSON-compatible.");
+    }
+    var prototype = Reflect.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError("[ge-ir] Non-plain object at " + path + " is not JSON-compatible.");
+    }
+    var result = {};
+    for(var _iterator = _create_for_of_iterator_helper_loose(Object.entries(value)), _step; !(_step = _iterator()).done;){
+        var _step_value = _step.value, key = _step_value[0], item = _step_value[1];
+        var normalizedItem = normalize(item, path + "." + key, false);
+        if (normalizedItem !== OMIT) {
+            result[key] = normalizedItem;
+        }
+    }
+    return result;
+}
+
 /**
  * Convert an IR composition to a GE JSONScene.
  *
- * All IR sources (lottie, dsl2ge, 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.
+ * All IR sources (lottie, dsl, future) go through this single unified
+ * 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 = {
@@ -2993,15 +3823,15 @@ function applyVisibilityStep(ir, state) {
     }
     // 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, {
@@ -3012,7 +3842,7 @@ function applyVisibilityStep(ir, state) {
         width: width,
         height: height,
         frameRate: frameRate,
-        geComponentIdToNewId: geComponentIdToNewId,
+        GEComponentIdToNewId: GEComponentIdToNewId,
         maskLookup: {
             getItemId: function getItemId(idx) {
                 return layerToItemId[idx];
@@ -3027,7 +3857,7 @@ function applyVisibilityStep(ir, state) {
     });
     collector.items.reverse();
     processedItems.reverse();
-    return mergePreservedPrecompScene(assembleScene(workingIR, collector, processedItems, duration), workingIR);
+    return normalizeJsonValue(mergePreservedPrecompScene(assembleScene(workingIR, collector, processedItems, duration), workingIR));
 }
 function processLayer(layer, ctx) {
     if (layer.type === 'precomp') {
@@ -3045,16 +3875,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).
@@ -3073,7 +3903,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;
                 }
@@ -3092,13 +3922,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',
@@ -3280,10 +4110,7 @@ function indexById(entries) {
     return map;
 }
 function cloneJson$1(value) {
-    if (value === undefined) {
-        return value;
-    }
-    return JSON.parse(JSON.stringify(value));
+    return normalizeJsonValue(value);
 }
 function isRecord$2(value) {
     return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
@@ -3321,23 +4148,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) {
@@ -3357,7 +4186,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'];
@@ -3565,16 +4397,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;
@@ -3623,7 +4465,7 @@ function parseBezierKeyframes(curves, startFrame, endFrame) {
         };
         if (i === 0) {
             keyframes.push(_extends({
-                t: frameTime,
+                frame: frameTime,
                 value: v0
             }, isHold ? {
                 hold: true
@@ -3643,7 +4485,7 @@ function parseBezierKeyframes(curves, startFrame, endFrame) {
                 y: inverseLerp(prevV0, prevV1, prevInCpY)
             };
             keyframes.push(_extends({
-                t: frameTime,
+                frame: frameTime,
                 value: v0,
                 inTangent: inTangent
             }, isHold ? {
@@ -3662,7 +4504,7 @@ function parseBezierKeyframes(curves, startFrame, endFrame) {
         y: inverseLerp(lastSeg[1], lastSeg[7], lastSeg[5])
     };
     keyframes.push({
-        t: lastFrameTime,
+        frame: lastFrameTime,
         value: lastV1,
         inTangent: lastInTangent
     });
@@ -3758,7 +4600,7 @@ function parsePositionTimingKeyframes(curves, startFrame, endFrame) {
         };
         if (i === 0) {
             result.push({
-                t: frameTime,
+                frame: frameTime,
                 outTangent: outTangent
             });
         } else {
@@ -3768,7 +4610,7 @@ function parsePositionTimingKeyframes(curves, startFrame, endFrame) {
                 y: inverseLerp(prevSeg[0], prevSeg[6], prevSeg[5])
             };
             result.push({
-                t: frameTime,
+                frame: frameTime,
                 outTangent: outTangent,
                 inTangent: inTangent
             });
@@ -3781,7 +4623,7 @@ function parsePositionTimingKeyframes(curves, startFrame, endFrame) {
         y: inverseLerp(lastSeg[0], lastSeg[6], lastSeg[5])
     };
     result.push({
-        t: lastFrameTime,
+        frame: lastFrameTime,
         inTangent: lastInTangent
     });
     return result;
@@ -3798,12 +4640,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'];
@@ -3883,7 +4722,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) {
@@ -3932,83 +4771,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'];
@@ -4021,70 +4803,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);
     }
-    var sortedTimes = [].concat(allTimes).sort(function(a, b) {
+    // Keep Array.from: loose SWC array-spread lowering does not expand Set in dist.
+    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,
@@ -4130,10 +4914,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,
@@ -4165,11 +4949,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) {
@@ -4199,7 +4983,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;
@@ -4323,7 +5107,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 ? [
@@ -4332,85 +5116,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,
@@ -4419,13 +5218,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;
@@ -4440,7 +5239,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,
@@ -4451,45 +5250,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'];
@@ -4501,8 +5305,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;
@@ -4513,34 +5317,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) {
@@ -4581,7 +5401,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;
@@ -4695,19 +5515,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'];
@@ -4728,7 +5546,9 @@ function mergeNullAndSprite(nullDesc, childDesc, ctx) {
                 0
             ]
         };
-        merged.displaySize = {
+        merged.localBounds = {
+            x: 0,
+            y: 0,
             width: layerWidth,
             height: layerHeight
         };
@@ -4741,17 +5561,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,
@@ -4780,7 +5604,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;
@@ -4844,8 +5668,8 @@ function convertGEToIR(scene, options) {
     var layers = merged.map(function(d) {
         return d.layer;
     });
-    return {
-        source: 'ge',
+    return normalizeJsonValue({
+        source: 'effects',
         name: ctx.compositionName,
         width: ctx.width,
         height: ctx.height,
@@ -4855,14 +5679,14 @@ 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_name, _item_visible, _ref, _item_delay, _ref1, _item_duration, _ref2;
     var _item_transform;
     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);
@@ -4871,19 +5695,19 @@ 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';
@@ -4895,18 +5719,18 @@ function parseItemToLayer(item, itemId, index, ctx) {
         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) {
@@ -4920,10 +5744,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;
         }
@@ -4965,10 +5785,10 @@ function parseItemToLayer(item, itemId, index, ctx) {
         var _item_transform1;
         var itemSize = (_item_transform1 = item['transform']) == null ? void 0 : _item_transform1['size'];
         if (itemSize != null) {
-            var _ref2;
+            var _ref3;
             var layerWidth = itemSize.x / ctx.ratio;
             var layerHeight = itemSize.y / ctx.ratio;
-            var anchorScale = (_ref2 = componentData == null ? void 0 : componentData.anchorScale) != null ? _ref2 : [
+            var anchorScale = (_ref3 = componentData == null ? void 0 : componentData.anchorScale) != null ? _ref3 : [
                 0.5,
                 0.5
             ];
@@ -5033,35 +5853,46 @@ function parseItemToLayer(item, itemId, index, ctx) {
             }
         }
     }
-    // Display size from item transform.size
-    var displaySize;
+    // Layer-local bounds from item transform.size
+    var localBounds;
     var itemSize1 = (_item_transform = item['transform']) == null ? void 0 : _item_transform['size'];
-    if (itemSize1 != null) {
-        displaySize = {
+    if (itemSize1 != null && itemSize1.x > 0 && itemSize1.y > 0) {
+        localBounds = {
+            x: 0,
+            y: 0,
             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;
@@ -5069,38 +5900,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)
         }
@@ -5113,7 +5945,7 @@ function hasPrecompItem(itemIds, ctx) {
     });
 }
 function cloneJson(value) {
-    return JSON.parse(JSON.stringify(value));
+    return normalizeJsonValue(value);
 }
 function isRecord(value) {
     return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
@@ -5123,16 +5955,14 @@ function isRecord(value) {
  * 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, 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