@vvfx/dsl-ir 0.0.1-beta.10

package/dist/index.mjs

@@ -0,0 +1,4418 @@
+/*!
+ * Name: @vvfx/dsl-ir
+ * Description: Editable DSL and Animation IR bidirectional converter
+ * Author: Ant Group CO., Ltd.
+ * Contributors: 澄弈
+ * Version: v0.0.1-beta.10
+ */
+
+import { IREndBehavior, assertIRScene, isIRId } from '@vvfx/animation-ir';
+import { getIRResourceSourceUrl, getIRSceneEntryComposition, createIRResourceSource, createIRScene } from '@vvfx/animation-ir/adapter';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+
+var byteToHex = [];
+for(var i = 0; i < 256; ++i){
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset) {
+    if (offset === void 0) offset = 0;
+    return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+    if (!getRandomValues) {
+        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+        getRandomValues = crypto.getRandomValues.bind(crypto);
+    }
+    return getRandomValues(rnds8);
+}
+
+var randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = {
+    randomUUID: randomUUID
+};
+
+function _v4(options, buf, offset) {
+    var _ref, _options_random;
+    options = options || {};
+    var rnds = (_ref = (_options_random = options.random) != null ? _options_random : options.rng == null ? void 0 : options.rng.call(options)) != null ? _ref : rng();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    rnds[6] = rnds[6] & 0x0f | 0x40;
+    rnds[8] = rnds[8] & 0x3f | 0x80;
+    return unsafeStringify(rnds);
+}
+function v4(options, buf, offset) {
+    if (native.randomUUID && true && !options) {
+        return native.randomUUID();
+    }
+    return _v4(options);
+}
+
+var HEX_COLOR_PATTERN = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var EPSILON$1 = 1e-6;
+/** Generate a 32-character hexadecimal UUID v4. */ function createId() {
+    return v4().replaceAll('-', '');
+}
+/** Convert normalized RGB(A) channels to a canonical hex color. */ function colorToHex(color) {
+    var _color_, _color_1, _color_2, _color_3;
+    var colorChannels = [
+        (_color_ = color[0]) != null ? _color_ : 0,
+        (_color_1 = color[1]) != null ? _color_1 : 0,
+        (_color_2 = color[2]) != null ? _color_2 : 0,
+        color.length >= 4 ? (_color_3 = color[3]) != null ? _color_3 : 1 : 1
+    ];
+    var hexParts = colorChannels.map(function(channel) {
+        var byteValue = Math.max(0, Math.min(255, Math.round(channel * 255)));
+        return byteValue.toString(16).padStart(2, '0');
+    });
+    return hexParts[3] === 'ff' ? "#" + hexParts.slice(0, 3).join('') : "#" + hexParts.join('');
+}
+/** Normalize supported hex forms for semantic comparison. */ function normalizeHex(hexColor) {
+    var normalizedHex = hexColor.replace(/^#/, '').toLowerCase();
+    if (normalizedHex.length === 3) {
+        var _ref = [
+            normalizedHex[0] + normalizedHex[0],
+            normalizedHex[1] + normalizedHex[1],
+            normalizedHex[2] + normalizedHex[2]
+        ], red = _ref[0], green = _ref[1], blue = _ref[2];
+        return "#" + red + green + blue;
+    }
+    if (normalizedHex.length === 6) {
+        return "#" + normalizedHex;
+    }
+    if (normalizedHex.length === 8) {
+        var alpha = normalizedHex.slice(6, 8);
+        return alpha === 'ff' ? "#" + normalizedHex.slice(0, 6) : "#" + normalizedHex;
+    }
+    return hexColor.toLowerCase();
+}
+/** Compare nullable hex colors after normalization. */ function isHexEqual(leftHex, rightHex) {
+    if (leftHex == null && rightHex == null) {
+        return true;
+    }
+    if (leftHex == null || rightHex == null) {
+        return false;
+    }
+    return normalizeHex(leftHex) === normalizeHex(rightHex);
+}
+function isValidHexColor(value) {
+    return typeof value === 'string' && HEX_COLOR_PATTERN.test(value);
+}
+function hexToIRColor(hexColor) {
+    var hex = hexColor.replace(/^#/, '');
+    if (hex.length === 3) {
+        return [
+            parseHexByte("" + hex[0] + hex[0], hexColor) / 255,
+            parseHexByte("" + hex[1] + hex[1], hexColor) / 255,
+            parseHexByte("" + hex[2] + hex[2], hexColor) / 255,
+            1
+        ];
+    }
+    if (hex.length === 6 || hex.length === 8) {
+        return [
+            parseHexByte(hex.slice(0, 2), hexColor) / 255,
+            parseHexByte(hex.slice(2, 4), hexColor) / 255,
+            parseHexByte(hex.slice(4, 6), hexColor) / 255,
+            hex.length === 8 ? parseHexByte(hex.slice(6, 8), hexColor) / 255 : 1
+        ];
+    }
+    throw new Error("[dsl-ir:color] Invalid hex color: " + hexColor);
+}
+function resolveFiniteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function secondsToFrames(seconds, frameRate) {
+    return resolveFiniteNumber(seconds, 0) * frameRate;
+}
+function isScalarEqual(leftValue, rightValue) {
+    return Math.abs(leftValue - rightValue) <= EPSILON$1;
+}
+function isNumberArrayEqual(leftValues, rightValues) {
+    if (leftValues.length !== rightValues.length) {
+        return false;
+    }
+    return leftValues.every(function(value, index) {
+        return Math.abs(value - rightValues[index]) <= EPSILON$1;
+    });
+}
+function isRecord$1(value) {
+    return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
+}
+function toJSONPath(path) {
+    if (path === '') {
+        return '$';
+    }
+    return path.startsWith('$') ? path : "$." + path;
+}
+function parseHexByte(value, source) {
+    if (!/^[\da-fA-F]{2}$/.test(value)) {
+        throw new Error("[dsl-ir:color] Invalid hex color: " + source);
+    }
+    return parseInt(value, 16);
+}
+
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+
+function _is_native_reflect_construct() {
+    // Since Reflect.construct can't be properly polyfilled, some
+    // implementations (e.g. core-js@2) don't set the correct internal slots.
+    // Those polyfills don't allow us to subclass built-ins, so we need to
+    // use our fallback implementation.
+    try {
+        // If the internal slots aren't set, this throws an error similar to
+        //   TypeError: this is not a Boolean object.
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function _is_native_reflect_construct() {
+        return !!result;
+    })();
+}
+
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function _wrap_native_super(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") throw new TypeError("Super expression must either be null or a function");
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike) {
+        if (it) o = it;
+        var i = 0;
+        return function() {
+            if (i >= o.length) return {
+                done: true
+            };
+            return {
+                done: false,
+                value: o[i++]
+            };
+        };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+var DSL_CODE_LABELS = {
+    R001: 'DSL 根不是对象',
+    R002: '缺少 meta',
+    R003: '缺少 layers',
+    R004: 'layers 不是数组',
+    M001: 'meta 必填字段缺失',
+    M002a: 'meta.name 类型错误',
+    M002b: 'meta.duration 类型错误',
+    M002c: 'meta.fps 类型错误',
+    M002d: 'meta.width 类型错误',
+    M002e: 'meta.height 类型错误',
+    M002f: 'meta.loop 类型错误',
+    M003: 'background_color 类型错误',
+    M004: 'background_color 非十六进制',
+    M005: 'fps 必须 > 0',
+    M006: 'width/height 必须 > 0',
+    M007: 'duration 非正数',
+    L001: '图层缺少 id',
+    L002: 'id 不是字符串',
+    L003: 'id 为空字符串',
+    L004: 'name 缺失',
+    L005: 'name 不是字符串',
+    L006: 'type 缺失',
+    L007: 'type 非法枚举',
+    L008: 'width 缺失',
+    L009: 'width 非法',
+    L010: 'height 缺失',
+    L011: 'height 非法',
+    L012: 'description 缺失',
+    L013: 'description 不是对象',
+    L014: 'description.self 缺失',
+    L015: 'description.composite 缺失',
+    L016: 'description 字段非字符串',
+    L018: 'time_range 非二元数组',
+    L019: 'time_range 元素非数值',
+    L020: 'time_range 不可见',
+    L021: '图层项非对象',
+    L022: 'children 不是数组',
+    L023: 'time_range 超出 composition 范围',
+    L024: '图片层或粒子层尺寸必须大于 0',
+    P001: '变换属性缺失',
+    P002: '变换属性非对象',
+    P003: 'a 缺失',
+    P004: 'a 不是布尔值',
+    P005: '静态属性缺 value',
+    P006: '静态属性出现 animation',
+    P007: '动画属性缺 animation',
+    P008: 'animation 非数组',
+    P009: '动画属性出现 value',
+    P010: 'animation 为空',
+    P011: '三维属性 value 不是三元数组',
+    P012: 'opacity value 非标量',
+    P013: 'value 元素非数值',
+    P014: 'opacity value 越界',
+    P015: 'anchor 不支持动画',
+    C001: '曲线段非对象',
+    C002: 't 缺失',
+    C003: 't 非二元数组',
+    C004: 't 起止逆序',
+    C005: 't 元素非数值',
+    C006: 'start 缺失',
+    C007: 'end 缺失',
+    C008: '三维属性起止非三元数组',
+    C009: 'opacity 起止不是一元数组',
+    C010: 'opacity 起止为裸标量',
+    C011: 'easing 非四元数组(会触发下游崩溃)',
+    C012: 'easing 元素非数值',
+    C013: 'in/out 出现在非 position 属性',
+    C014: 'in/out 非三元数组',
+    C016: '曲线 t 越界',
+    S002: '曲线时间重叠',
+    S003: '曲线时间空隙',
+    S004: '曲线未单调',
+    X001: '图层 id 全局重复',
+    X002: 'parent 自引用',
+    X003: 'parent 非字符串',
+    X004: 'parent 引用悬空',
+    X005: 'parent 与物理嵌套不一致',
+    X006: 'parent 链成环',
+    A001: '图片层缺 asset',
+    A002: 'asset 非对象',
+    A003: 'asset.source 缺失',
+    A004: 'asset.source 非法枚举',
+    A005: 'llm_svg 的 format 非 svg',
+    A006: 'llm_svg 缺 svg',
+    A007: 'llm_svg 缺 prompt',
+    A008: 'user 缺 url',
+    A009: 'user 的 prompt 非空',
+    A010: 'null 层有不必要的 asset',
+    A011: '文字层缺 text 块',
+    A012: 'text 非对象',
+    A013: 'text.content 缺失/非字符串',
+    A014: 'text.size 缺失/非数值',
+    A015: 'text.color 缺失/非字符串',
+    A016: '图片层有不必要的 text',
+    A017: '文字层有不必要的 asset',
+    A018: 'text.font 类型错误',
+    A019: 'text.align 非法枚举',
+    A020: '文字排版数值非法',
+    A021: 'asset.url 类型错误',
+    A022: '粒子层缺 particle 块',
+    A023: 'particle 不是对象',
+    A024: '非粒子层有不必要的 particle 块',
+    A025: '粒子层有不必要的 asset',
+    A026: '粒子层有不必要的 text',
+    PT001: 'particle.emission 缺失或不是对象',
+    PT002: 'rateOverTime 非法',
+    PT003: 'bursts 不是数组',
+    PT004: 'burst 字段非法',
+    PT005: 'particle 包含未知字段',
+    PT006: 'particle.options 缺失或不是对象',
+    PT007: 'maxCount 非法',
+    PT008: 'startLifetime 非法',
+    PT009: 'particle.shape 非法'
+};
+
+var ValueType = /*#__PURE__*/ function(ValueType) {
+    ValueType[ValueType["CONSTANT"] = 0] = "CONSTANT";
+    ValueType[ValueType["RANDOM"] = 4] = "RANDOM";
+    return ValueType;
+}({});
+
+var PARTICLE_SHAPE_NAMES = [
+    'None',
+    'Sphere',
+    'Cone',
+    'Hemisphere',
+    'Circle',
+    'Donut',
+    'Rectangle',
+    'RectangleEdge',
+    'Edge',
+    'Texture'
+];
+var PARTICLE_SHAPE_BASE_FIELDS = [
+    'type',
+    'shape',
+    'arcMode',
+    'alignSpeedDirection',
+    'upDirection',
+    'turbulenceX',
+    'turbulenceY',
+    'turbulenceZ'
+];
+var PARTICLE_SHAPE_FIELDS_BY_TYPE = {
+    0: [
+        'type',
+        'shape',
+        'upDirection',
+        'turbulenceX',
+        'turbulenceY',
+        'turbulenceZ'
+    ],
+    1: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'radius',
+        'arc'
+    ]),
+    2: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'angle',
+        'radius',
+        'arc'
+    ]),
+    3: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'radius',
+        'arc'
+    ]),
+    4: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'radius',
+        'arc'
+    ]),
+    5: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'radius',
+        'donutRadius',
+        'arc'
+    ]),
+    6: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'width',
+        'height'
+    ]),
+    7: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'width',
+        'height'
+    ]),
+    8: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'width'
+    ]),
+    9: [].concat(PARTICLE_SHAPE_BASE_FIELDS, [
+        'detail',
+        'random',
+        'width',
+        'height'
+    ])
+};
+var PARTICLE_SHAPE_NUMBER_FIELDS_BY_TYPE = {
+    0: [],
+    1: [
+        'radius',
+        'arc'
+    ],
+    2: [
+        'angle',
+        'radius',
+        'arc'
+    ],
+    3: [
+        'radius',
+        'arc'
+    ],
+    4: [
+        'radius',
+        'arc'
+    ],
+    5: [
+        'radius',
+        'donutRadius',
+        'arc'
+    ],
+    6: [
+        'width',
+        'height'
+    ],
+    7: [
+        'width',
+        'height'
+    ],
+    8: [
+        'width'
+    ],
+    9: [
+        'random',
+        'width',
+        'height'
+    ]
+};
+function lintParticle(particle, layer, particlePath) {
+    var issues = [];
+    reportUnknownFields(particle, new Set([
+        'shape',
+        'options',
+        'emission'
+    ]), 'PT005', particlePath, issues);
+    if (Object.hasOwn(particle, 'shape')) {
+        checkParticleShapeValue(particle['shape'], "" + particlePath + ".shape", issues);
+    }
+    checkParticleOptionsValue(particle['options'], "" + particlePath + ".options", issues);
+    checkParticleEmissionValue(particle['emission'], layer, "" + particlePath + ".emission", issues);
+    return issues;
+}
+function checkParticleShapeValue(value, shapePath, issues) {
+    if (!isRecord$1(value)) {
+        addIssue$1(issues, 'PT009', "particle.shape is " + describeValueType$1(value) + ", expected an object", shapePath);
+        return;
+    }
+    var type = value['type'];
+    if (!isIntegerInRange$1(type, 0, PARTICLE_SHAPE_NAMES.length - 1)) {
+        addIssue$1(issues, 'PT009', 'particle.shape.type must be an integer from 0 to 9', "" + shapePath + ".type");
+        return;
+    }
+    var expectedName = PARTICLE_SHAPE_NAMES[type];
+    reportUnknownFields(value, new Set(PARTICLE_SHAPE_FIELDS_BY_TYPE[type]), 'PT009', shapePath, issues);
+    if (value['shape'] !== expectedName) {
+        addIssue$1(issues, 'PT009', "particle.shape.shape must be " + JSON.stringify(expectedName) + " when type is " + String(type), "" + shapePath + ".shape");
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(PARTICLE_SHAPE_NUMBER_FIELDS_BY_TYPE[type]), _step; !(_step = _iterator()).done;){
+        var field = _step.value;
+        if (!isFiniteNumber(value[field])) {
+            addIssue$1(issues, 'PT009', "particle.shape." + field + " must be a finite number", shapePath + "." + field);
+        }
+    }
+    for(var _i = 0, _iter = [
+        'turbulenceX',
+        'turbulenceY',
+        'turbulenceZ'
+    ]; _i < _iter.length; _i++){
+        var field1 = _iter[_i];
+        if (Object.hasOwn(value, field1) && !isTaggedParticleShapeExpression(value[field1])) {
+            addIssue$1(issues, 'PT009', "particle.shape." + field1 + " must be a tagged two-element expression", shapePath + "." + field1);
+        }
+    }
+    if (type === 0) {
+        if (Object.hasOwn(value, 'upDirection') && !isFiniteNumberArray$1(value['upDirection'])) {
+            addIssue$1(issues, 'PT009', 'particle.shape.upDirection must contain finite numbers', "" + shapePath + ".upDirection");
+        }
+        return;
+    }
+    if (!isIntegerInRange$1(value['arcMode'], 0, 3)) {
+        addIssue$1(issues, 'PT009', 'particle.shape.arcMode must be an integer from 0 to 3', "" + shapePath + ".arcMode");
+    }
+    if (Object.hasOwn(value, 'alignSpeedDirection') && typeof value['alignSpeedDirection'] !== 'boolean') {
+        addIssue$1(issues, 'PT009', 'particle.shape.alignSpeedDirection must be a boolean', "" + shapePath + ".alignSpeedDirection");
+    }
+    if (Object.hasOwn(value, 'upDirection') && !isFiniteNumberTuple$1(value['upDirection'], 3)) {
+        addIssue$1(issues, 'PT009', 'particle.shape.upDirection must contain three finite numbers', "" + shapePath + ".upDirection");
+    }
+    if (type === 9) {
+        checkParticleTextureShapeDetail(value['detail'], "" + shapePath + ".detail", issues);
+    }
+}
+function checkParticleTextureShapeDetail(value, detailPath, issues) {
+    if (!isRecord$1(value)) {
+        addIssue$1(issues, 'PT009', 'particle.shape.detail must be an object', detailPath);
+        return;
+    }
+    reportUnknownFields(value, new Set([
+        'width',
+        'height',
+        'block',
+        'anchors'
+    ]), 'PT009', detailPath, issues);
+    for(var _i = 0, _iter = [
+        'width',
+        'height'
+    ]; _i < _iter.length; _i++){
+        var field = _iter[_i];
+        if (!isFiniteNumber(value[field])) {
+            addIssue$1(issues, 'PT009', "particle.shape.detail." + field + " must be a finite number", detailPath + "." + field);
+        }
+    }
+    if (!isFiniteNumberTuple$1(value['block'], 2)) {
+        addIssue$1(issues, 'PT009', 'particle.shape.detail.block must contain two finite numbers', "" + detailPath + ".block");
+    }
+    if (!isFiniteNumberArray$1(value['anchors'])) {
+        addIssue$1(issues, 'PT009', 'particle.shape.detail.anchors must contain finite numbers', "" + detailPath + ".anchors");
+    }
+}
+function checkParticleOptionsValue(value, optionsPath, issues) {
+    if (!isRecord$1(value)) {
+        addIssue$1(issues, 'PT006', "particle.options is " + describeValueType$1(value) + ", expected an object", optionsPath);
+        return;
+    }
+    reportUnknownFields(value, new Set([
+        'maxCount',
+        'startLifetime'
+    ]), 'PT005', optionsPath, issues);
+    var maxCount = value['maxCount'];
+    if (!isFiniteNumber(maxCount) || !Number.isInteger(maxCount) || maxCount <= 0) {
+        addIssue$1(issues, 'PT007', 'particle.options.maxCount must be a positive integer', "" + optionsPath + ".maxCount");
+    }
+    if (!isParticleNumberExpression(value['startLifetime'], true)) {
+        addIssue$1(issues, 'PT008', 'particle.options.startLifetime must be a valid positive NumberExpression', "" + optionsPath + ".startLifetime");
+    }
+}
+function checkParticleEmissionValue(value, layer, emissionPath, issues) {
+    if (!isRecord$1(value)) {
+        addIssue$1(issues, 'PT001', "particle.emission is " + describeValueType$1(value) + ", expected an object", emissionPath);
+        return;
+    }
+    reportUnknownFields(value, new Set([
+        'rateOverTime',
+        'bursts'
+    ]), 'PT005', emissionPath, issues);
+    if (!isParticleNumberExpression(value['rateOverTime'], false)) {
+        addIssue$1(issues, 'PT002', 'particle.emission.rateOverTime must be a valid non-negative NumberExpression', "" + emissionPath + ".rateOverTime");
+    }
+    if (!Object.hasOwn(value, 'bursts')) {
+        return;
+    }
+    var bursts = value['bursts'];
+    if (!Array.isArray(bursts)) {
+        addIssue$1(issues, 'PT003', 'particle.emission.bursts must be an array', "" + emissionPath + ".bursts");
+        return;
+    }
+    bursts.forEach(function(burst, index) {
+        checkParticleBurst(burst, layer, emissionPath + ".bursts[" + index + "]", issues);
+    });
+}
+function checkParticleBurst(value, layer, burstPath, issues) {
+    if (!isRecord$1(value)) {
+        addIssue$1(issues, 'PT004', "particle burst is " + describeValueType$1(value) + ", expected an object", burstPath);
+        return;
+    }
+    reportUnknownFields(value, new Set([
+        'time',
+        'count',
+        'cycles',
+        'interval'
+    ]), 'PT004', burstPath, issues);
+    var time = value['time'];
+    var duration = readLayerDuration(layer);
+    if (!isFiniteNumber(time) || time < 0 || duration != null && time >= duration) {
+        addIssue$1(issues, 'PT004', 'particle burst time must be within the layer duration', "" + burstPath + ".time");
+    }
+    if (!isNonNegativeInteger(value['count'])) {
+        addIssue$1(issues, 'PT004', 'particle burst count must be a non-negative integer', "" + burstPath + ".count");
+    }
+    if (Object.hasOwn(value, 'cycles') && !isNonNegativeInteger(value['cycles'])) {
+        addIssue$1(issues, 'PT004', 'particle burst cycles must be a non-negative integer; 0 means unbounded', "" + burstPath + ".cycles");
+    }
+    if (Object.hasOwn(value, 'interval') && (!isFiniteNumber(value['interval']) || value['interval'] < 0)) {
+        addIssue$1(issues, 'PT004', 'particle burst interval must be a non-negative finite number', "" + burstPath + ".interval");
+    }
+    var cycles = Object.hasOwn(value, 'cycles') ? value['cycles'] : 1;
+    var interval = Object.hasOwn(value, 'interval') ? value['interval'] : 0;
+    if (isNonNegativeInteger(cycles) && (cycles === 0 || cycles > 1) && (!isFiniteNumber(interval) || interval <= 0)) {
+        addIssue$1(issues, 'PT004', 'particle burst interval must be greater than 0 when cycles is 0 or greater than 1', "" + burstPath + ".interval");
+    }
+    if (duration != null && isFiniteNumber(time) && time >= 0 && time < duration && isPositiveInteger(cycles) && isFiniteNumber(interval) && interval >= 0 && time + (cycles - 1) * interval >= duration) {
+        addIssue$1(issues, 'PT004', 'particle burst cycles extend beyond the layer duration', burstPath);
+    }
+}
+function reportUnknownFields(value, fieldSet, code, path, issues) {
+    for(var _iterator = _create_for_of_iterator_helper_loose(Object.keys(value)), _step; !(_step = _iterator()).done;){
+        var field = _step.value;
+        if (!fieldSet.has(field)) {
+            addIssue$1(issues, code, "unknown field " + JSON.stringify(field), path + "." + field);
+        }
+    }
+}
+function isParticleNumberExpression(value, positive) {
+    if (!Array.isArray(value) || value.length !== 2) {
+        return false;
+    }
+    var expression = value;
+    var type = expression[0];
+    var payload = expression[1];
+    if (type === ValueType.CONSTANT) {
+        return isParticleNumber(payload, positive);
+    }
+    if (type === ValueType.RANDOM) {
+        return isFiniteNumberTuple$1(payload, 2) && isParticleNumber(payload[0], positive) && isParticleNumber(payload[1], positive) && payload[0] <= payload[1];
+    }
+    return false;
+}
+function isParticleNumber(value, positive) {
+    return isFiniteNumber(value) && (positive ? value > 0 : value >= 0);
+}
+function readLayerDuration(layer) {
+    var timeRange = layer['time_range'];
+    if (!isFiniteNumberTuple$1(timeRange, 2)) {
+        return null;
+    }
+    return timeRange[1] - timeRange[0];
+}
+function isFiniteNumberTuple$1(value, length) {
+    return Array.isArray(value) && value.length === length && value.every(isFiniteNumber);
+}
+function isFiniteNumberArray$1(value) {
+    return Array.isArray(value) && value.every(isFiniteNumber);
+}
+function isTaggedParticleShapeExpression(value) {
+    return Array.isArray(value) && value.length === 2 && Number.isInteger(value[0]);
+}
+function isIntegerInRange$1(value, minimum, maximum) {
+    return isFiniteNumber(value) && Number.isInteger(value) && value >= minimum && value <= maximum;
+}
+function isNonNegativeInteger(value) {
+    return isFiniteNumber(value) && Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+    return isFiniteNumber(value) && Number.isInteger(value) && value > 0;
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function describeValueType$1(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (Array.isArray(value)) {
+        return 'an array';
+    }
+    return typeof value === "undefined" ? "undefined" : _type_of(value);
+}
+function addIssue$1(issues, code, message, path) {
+    issues.push({
+        code: code,
+        message: message,
+        path: path
+    });
+}
+
+var SPATIAL_PROPERTIES = [
+    'position',
+    'rotation',
+    'scale',
+    'anchor'
+];
+var VALID_LAYER_TYPE_SET = new Set([
+    'null',
+    'layer',
+    'text',
+    'particle'
+]);
+var VALID_ASSET_SOURCE_SET = new Set([
+    'user',
+    'llm_svg'
+]);
+var EPSILON = 1e-9;
+/** Lint an unnormalized DSL value while preserving issue severity. */ function lintDSL(dsl) {
+    var context = {
+        issues: [],
+        duration: null
+    };
+    if (containsCircularReference(dsl)) {
+        addIssue(context, 'ERROR', 'R001', 'DSL root contains circular references, expected a JSON-compatible object', '');
+        return createLintReport(context.issues);
+    }
+    if (!checkRoot(dsl, context)) {
+        return createLintReport(context.issues);
+    }
+    checkMeta(dsl, context);
+    var entries = walkLayers(dsl['layers'], context);
+    for(var _iterator = _create_for_of_iterator_helper_loose(entries), _step; !(_step = _iterator()).done;){
+        var entry = _step.value;
+        checkLayerBase(entry, context);
+        checkProperties(entry, context);
+        checkLayerContent(entry, context);
+    }
+    checkLayerRelationships(entries, context);
+    return createLintReport(context.issues);
+}
+/**
+ * Validate DSL and return the public validation result.
+ * Strings are interpreted as raw JSON. File-system paths are intentionally not
+ * accepted so the same validator works unchanged in Node.js and browsers.
+ */ function validateDSL(dsl, options) {
+    if (options === void 0) options = {};
+    var coerced = coerceInput(dsl);
+    if ('error' in coerced) {
+        return createInputErrorResult(coerced.error);
+    }
+    var report = lintDSL(coerced.value);
+    var errors = report.issues.filter(function(issue) {
+        return issue.severity === 'ERROR';
+    }).map(convertToValidationIssue);
+    var warnings = report.issues.filter(function(issue) {
+        return issue.severity === 'WARNING';
+    }).map(convertToValidationIssue);
+    var hasFailed = errors.length > 0 || options.strict === true && warnings.length > 0;
+    return {
+        result: hasFailed ? 'fail' : 'pass',
+        summary: errors.length + " errors, " + warnings.length + " warnings",
+        errors: errors,
+        warnings: warnings
+    };
+}
+/** Error thrown when a value cannot be used as a valid DSL composition. */ var DSLValidationError = /*#__PURE__*/ function(TypeError1) {
+    _inherits(DSLValidationError, TypeError1);
+    function DSLValidationError(issues) {
+        var _this;
+        _this = TypeError1.call(this, issues.map(function(issue) {
+            return issue.code + ": " + issue.message;
+        }).join('; ')) || this;
+        _this.name = 'DSLValidationError';
+        _this.issues = issues;
+        return _this;
+    }
+    DSLValidationError.fromValidationResult = function fromValidationResult(validationResult) {
+        return new DSLValidationError([].concat(validationResult.errors, validationResult.warnings));
+    };
+    return DSLValidationError;
+}(_wrap_native_super(TypeError));
+function coerceInput(dsl) {
+    if (typeof dsl !== 'string') {
+        if (isRecord$1(dsl)) {
+            if (containsCircularReference(dsl)) {
+                return {
+                    error: 'DSL value contains circular references and cannot be represented as JSON'
+                };
+            }
+            return {
+                value: dsl
+            };
+        }
+        return {
+            error: "expected a DSL object or raw JSON string, got " + describeValueType(dsl)
+        };
+    }
+    var firstCharacter = dsl.trimStart()[0];
+    if (firstCharacter !== '{' && firstCharacter !== '[') {
+        return {
+            error: 'expected raw DSL JSON text beginning with { or ['
+        };
+    }
+    try {
+        return {
+            value: JSON.parse(dsl)
+        };
+    } catch (error) {
+        return {
+            error: "invalid JSON: " + (_instanceof(error, Error) ? error.message : String(error))
+        };
+    }
+}
+function createInputErrorResult(message) {
+    return {
+        result: 'fail',
+        summary: 'input cannot be read as DSL JSON',
+        errors: [
+            {
+                code: 'INPUT_ERROR',
+                label: '输入无法解析为 DSL JSON',
+                message: message,
+                path: '',
+                layerId: null
+            }
+        ],
+        warnings: []
+    };
+}
+function createLintReport(issues) {
+    var errorCount = issues.filter(function(issue) {
+        return issue.severity === 'ERROR';
+    }).length;
+    var warningCount = issues.length - errorCount;
+    return {
+        ok: issues.length === 0,
+        hasErrors: errorCount > 0,
+        counts: {
+            ERROR: errorCount,
+            WARNING: warningCount
+        },
+        issues: issues
+    };
+}
+function convertToValidationIssue(issue) {
+    var _DSL_CODE_LABELS_issue_code;
+    return {
+        code: issue.code,
+        label: (_DSL_CODE_LABELS_issue_code = DSL_CODE_LABELS[issue.code]) != null ? _DSL_CODE_LABELS_issue_code : '',
+        message: issue.message,
+        path: issue.path,
+        layerId: issue.layerId
+    };
+}
+function addIssue(context, severity, code, message, path, layerId) {
+    if (layerId === void 0) layerId = null;
+    context.issues.push({
+        severity: severity,
+        code: code,
+        message: message,
+        path: path,
+        layerId: layerId
+    });
+}
+function checkRoot(dsl, context) {
+    if (!isRecord$1(dsl)) {
+        addIssue(context, 'ERROR', 'R001', "DSL root is " + describeValueType(dsl) + ", expected an object", '');
+        return false;
+    }
+    if (!hasValue(dsl, 'meta')) {
+        addIssue(context, 'ERROR', 'R002', "missing 'meta' object", 'meta');
+    }
+    if (!hasValue(dsl, 'layers')) {
+        addIssue(context, 'ERROR', 'R003', "missing 'layers' array", 'layers');
+    } else if (!Array.isArray(dsl['layers'])) {
+        addIssue(context, 'ERROR', 'R004', "layers is " + describeValueType(dsl['layers']) + ", expected an array", 'layers');
+    }
+    return true;
+}
+function checkMeta(dsl, context) {
+    var meta = dsl['meta'];
+    if (!isRecord$1(meta)) {
+        return;
+    }
+    var required = [
+        [
+            'name',
+            'string',
+            function(value) {
+                return typeof value === 'string';
+            },
+            'M002a'
+        ],
+        [
+            'duration',
+            'number',
+            isNumber,
+            'M002b'
+        ],
+        [
+            'fps',
+            'integer',
+            isIntLike,
+            'M002c'
+        ],
+        [
+            'width',
+            'integer',
+            isIntLike,
+            'M002d'
+        ],
+        [
+            'height',
+            'integer',
+            isIntLike,
+            'M002e'
+        ],
+        [
+            'loop',
+            'boolean',
+            function(value) {
+                return typeof value === 'boolean';
+            },
+            'M002f'
+        ]
+    ];
+    for(var _iterator = _create_for_of_iterator_helper_loose(required), _step; !(_step = _iterator()).done;){
+        var _step_value = _step.value, field = _step_value[0], expected = _step_value[1], accepts = _step_value[2], code = _step_value[3];
+        if (!hasValue(meta, field)) {
+            addIssue(context, 'ERROR', 'M001', "meta." + field + " is missing", "meta." + field);
+        } else if (!accepts(meta[field])) {
+            addIssue(context, 'ERROR', code, "meta." + field + " is " + describeValueType(meta[field]) + ", expected " + expected, "meta." + field);
+        }
+    }
+    if (meta['background_color'] != null) {
+        var background = meta['background_color'];
+        if (typeof background !== 'string') {
+            addIssue(context, 'ERROR', 'M003', "meta.background_color is " + describeValueType(background) + ", expected a string", 'meta.background_color');
+        } else if (!isValidHexColor(background)) {
+            addIssue(context, 'ERROR', 'M004', "meta.background_color " + formatValue(background) + " is not a supported hex color", 'meta.background_color');
+        }
+    }
+    var fps = meta['fps'];
+    var width = meta['width'];
+    var height = meta['height'];
+    var duration = meta['duration'];
+    if (isIntLike(fps) && fps <= 0) {
+        addIssue(context, 'ERROR', 'M005', "meta.fps is " + formatNumber(fps) + ", must be > 0", 'meta.fps');
+    }
+    if (isIntLike(width) && width <= 0) {
+        addIssue(context, 'ERROR', 'M006', "meta.width is " + formatNumber(width) + ", must be > 0", 'meta.width');
+    }
+    if (isIntLike(height) && height <= 0) {
+        addIssue(context, 'ERROR', 'M006', "meta.height is " + formatNumber(height) + ", must be > 0", 'meta.height');
+    }
+    if (isNumber(duration)) {
+        if (duration <= 0) {
+            addIssue(context, 'ERROR', 'M007', "meta.duration is " + formatNumber(duration) + ", must be > 0", 'meta.duration');
+        } else {
+            context.duration = duration;
+        }
+    }
+}
+function walkLayers(layers, context) {
+    var entries = [];
+    if (!Array.isArray(layers)) {
+        return entries;
+    }
+    var visitLayer = function visitLayer1(layer, path, physicalParentId) {
+        if (!isRecord$1(layer)) {
+            addIssue(context, 'ERROR', 'L021', "layer entry is " + describeValueType(layer) + ", expected an object", path, physicalParentId);
+            return;
+        }
+        var layerId = readLayerId(layer);
+        entries.push({
+            layer: layer,
+            path: path,
+            layerId: layerId,
+            physicalParentId: physicalParentId
+        });
+        var children = layer['children'];
+        if (children == null) {
+            return;
+        }
+        if (!Array.isArray(children)) {
+            addIssue(context, 'ERROR', 'L022', "children is " + describeValueType(children) + ", expected an array", "" + path + ".children", layerId);
+            return;
+        }
+        children.forEach(function(child, index) {
+            return visitLayer(child, path + ".children[" + index + "]", layerId);
+        });
+    };
+    layers.forEach(function(layer, index) {
+        return visitLayer(layer, "layers[" + index + "]", null);
+    });
+    return entries;
+}
+function checkLayerBase(entry, context) {
+    var layer = entry.layer, path = entry.path, layerId = entry.layerId;
+    if (!hasValue(layer, 'id')) {
+        addIssue(context, 'ERROR', 'L001', 'id is missing', "" + path + ".id");
+    } else if (typeof layer['id'] !== 'string') {
+        addIssue(context, 'ERROR', 'L002', "id is " + describeValueType(layer['id']) + ", expected a string", "" + path + ".id");
+    } else if (layer['id'] === '') {
+        addIssue(context, 'ERROR', 'L003', 'id is an empty string', "" + path + ".id");
+    }
+    if (!hasValue(layer, 'name')) {
+        addIssue(context, 'ERROR', 'L004', 'name is missing', "" + path + ".name");
+    } else if (typeof layer['name'] !== 'string') {
+        addIssue(context, 'ERROR', 'L005', "name is " + describeValueType(layer['name']) + ", expected a string", "" + path + ".name");
+    }
+    if (!hasValue(layer, 'type')) {
+        addIssue(context, 'ERROR', 'L006', 'type is missing', "" + path + ".type");
+    } else if (!VALID_LAYER_TYPE_SET.has(String(layer['type']))) {
+        addIssue(context, 'ERROR', 'L007', "type " + formatValue(layer['type']) + " not in {null, layer, text, particle}", "" + path + ".type");
+    }
+    for(var _i = 0, _iter = [
+        [
+            'width',
+            'L008',
+            'L009'
+        ],
+        [
+            'height',
+            'L010',
+            'L011'
+        ]
+    ]; _i < _iter.length; _i++){
+        var _iter__i = _iter[_i], field = _iter__i[0], missingCode = _iter__i[1], typeCode = _iter__i[2];
+        if (!hasValue(layer, field)) {
+            addIssue(context, 'ERROR', missingCode, "" + field + " is missing", path + "." + field);
+        } else if (!isNumber(layer[field])) {
+            addIssue(context, 'ERROR', typeCode, field + " is " + describeValueType(layer[field]) + ", expected a number", path + "." + field);
+        } else if (layer[field] < 0) {
+            addIssue(context, 'ERROR', typeCode, field + " is " + formatNumber(layer[field]) + ", expected a number greater than or equal to 0", path + "." + field);
+        }
+    }
+    var description = layer['description'];
+    if (!hasValue(layer, 'description')) {
+        addIssue(context, 'ERROR', 'L012', 'description is missing', "" + path + ".description");
+    } else if (!isRecord$1(description)) {
+        addIssue(context, 'ERROR', 'L013', "description is " + describeValueType(description) + ", expected an object", "" + path + ".description");
+    } else {
+        for(var _i1 = 0, _iter1 = [
+            [
+                'self',
+                'L014'
+            ],
+            [
+                'composite',
+                'L015'
+            ]
+        ]; _i1 < _iter1.length; _i1++){
+            var _iter__i1 = _iter1[_i1], field1 = _iter__i1[0], code = _iter__i1[1];
+            if (!hasValue(description, field1)) {
+                addIssue(context, 'ERROR', code, "description." + field1 + " is missing", path + ".description." + field1);
+            } else if (typeof description[field1] !== 'string') {
+                addIssue(context, 'ERROR', 'L016', "description." + field1 + " is " + describeValueType(description[field1]) + ", expected a string", path + ".description." + field1);
+            }
+        }
+    }
+    var timeRange = layer['time_range'];
+    var hasNumericTimeRange = false;
+    if (timeRange === undefined) {
+        return;
+    }
+    if (!Array.isArray(timeRange) || timeRange.length !== 2) {
+        var got = Array.isArray(timeRange) ? "array of length " + timeRange.length : describeValueType(timeRange);
+        addIssue(context, 'ERROR', 'L018', "time_range is " + got + ", expected [number, number]", "" + path + ".time_range");
+    } else if (!timeRange.every(isNumber)) {
+        addIssue(context, 'ERROR', 'L019', 'time_range elements must be numbers', "" + path + ".time_range");
+    } else {
+        hasNumericTimeRange = true;
+    }
+    if (hasNumericTimeRange && Array.isArray(timeRange)) {
+        var start = timeRange[0];
+        var end = timeRange[1];
+        if (start > end) {
+            addIssue(context, 'ERROR', 'L020', "time_range [" + formatNumber(start) + ", " + formatNumber(end) + "] — start must be <= end", "" + path + ".time_range", layerId);
+        } else if (start === end) {
+            addIssue(context, 'WARNING', 'L020', "time_range [" + formatNumber(start) + ", " + formatNumber(end) + "] has zero duration", "" + path + ".time_range", layerId);
+        }
+        if (context.duration != null && (start < -EPSILON || end > context.duration + EPSILON)) {
+            addIssue(context, 'WARNING', 'L023', "time_range [" + formatNumber(start) + ", " + formatNumber(end) + "] falls outside [0, " + formatNumber(context.duration) + "]", "" + path + ".time_range", layerId);
+        }
+    }
+}
+function checkProperties(entry, context) {
+    var _loop = function() {
+        var propertyName = _step.value;
+        var dimension = propertyName === 'opacity' ? 'scalar' : 3;
+        var propertyPath = path + "." + propertyName;
+        var property = layer[propertyName];
+        if (propertyName !== 'position' && property === undefined) {
+            return "continue";
+        }
+        if (property == null) {
+            addIssue(context, 'ERROR', 'P001', "" + propertyName + " is missing", propertyPath, layerId);
+            return "continue";
+        }
+        if (!isRecord$1(property)) {
+            addIssue(context, 'ERROR', 'P002', propertyName + " is " + describeValueType(property) + ", expected an object", propertyPath, layerId);
+            return "continue";
+        }
+        var animated = property['a'];
+        if (!hasValue(property, 'a')) {
+            addIssue(context, 'ERROR', 'P003', "" + propertyName + ".a is missing", "" + propertyPath + ".a", layerId);
+            return "continue";
+        }
+        if (typeof animated !== 'boolean') {
+            addIssue(context, 'ERROR', 'P004', propertyName + ".a is " + describeValueType(animated) + ", expected a boolean", "" + propertyPath + ".a", layerId);
+            return "continue";
+        }
+        var hasAnimation = hasValue(property, 'animation');
+        var hasValueField = hasValue(property, 'value');
+        if (!animated) {
+            checkStaticValue(propertyName, dimension, property, propertyPath, layerId, context);
+            if (hasAnimation) {
+                addIssue(context, 'ERROR', 'P006', "" + propertyName + ".animation present while a=false", "" + propertyPath + ".animation", layerId);
+            }
+            return "continue";
+        }
+        if (propertyName === 'anchor') {
+            addIssue(context, 'ERROR', 'P015', 'anchor animation is unsupported; anchor must use a static value', propertyPath, layerId);
+        }
+        if (!hasAnimation) {
+            addIssue(context, 'ERROR', 'P007', "" + propertyName + ".animation missing while a=true", "" + propertyPath + ".animation", layerId);
+            return "continue";
+        }
+        var animation = property['animation'];
+        if (!Array.isArray(animation)) {
+            addIssue(context, 'ERROR', 'P008', propertyName + ".animation is " + describeValueType(animation) + ", expected an array", "" + propertyPath + ".animation", layerId);
+            return "continue";
+        }
+        if (hasValueField) {
+            addIssue(context, 'ERROR', 'P009', "" + propertyName + ".value present while a=true", "" + propertyPath + ".value", layerId);
+        }
+        if (animation.length === 0) {
+            addIssue(context, 'WARNING', 'P010', "" + propertyName + ".animation is empty (no segments)", "" + propertyPath + ".animation", layerId);
+            return "continue";
+        }
+        var animationPath = "" + propertyPath + ".animation";
+        var curves = animation.map(function(curve, index) {
+            return checkCurve(propertyName, dimension, curve, animationPath + "[" + index + "]", layerId, context);
+        });
+        checkContinuity(propertyName, curves, animationPath, layerId, context);
+    };
+    var layer = entry.layer, path = entry.path, layerId = entry.layerId;
+    for(var _iterator = _create_for_of_iterator_helper_loose([].concat(SPATIAL_PROPERTIES, [
+        'opacity'
+    ])), _step; !(_step = _iterator()).done;)_loop();
+}
+function checkStaticValue(propertyName, dimension, property, propertyPath, layerId, context) {
+    var value = property['value'];
+    if (!hasValue(property, 'value')) {
+        addIssue(context, 'ERROR', 'P005', "" + propertyName + ".value missing while a=false", "" + propertyPath + ".value", layerId);
+        return;
+    }
+    if (dimension === 3) {
+        if (!Array.isArray(value) || value.length !== 3) {
+            var got = Array.isArray(value) ? "array length " + value.length : describeValueType(value);
+            addIssue(context, 'ERROR', 'P011', propertyName + ".value must be a 3-element array, got " + got, "" + propertyPath + ".value", layerId);
+            return;
+        }
+        if (!value.every(isNumber)) {
+            addIssue(context, 'WARNING', 'P013', "" + propertyName + ".value has non-numeric elements", "" + propertyPath + ".value", layerId);
+        }
+    } else if (!isNumber(value)) {
+        addIssue(context, 'ERROR', 'P012', "opacity.value is " + describeValueType(value) + ", expected a number", "" + propertyPath + ".value", layerId);
+    } else if (value < -EPSILON || value > 1 + EPSILON) {
+        addIssue(context, 'ERROR', 'P014', "opacity.value " + formatNumber(value) + " out of [0, 1]", "" + propertyPath + ".value", layerId);
+    }
+}
+function checkCurve(propertyName, dimension, curve, segmentPath, layerId, context) {
+    if (!isRecord$1(curve)) {
+        addIssue(context, 'ERROR', 'C001', "animation segment is " + describeValueType(curve) + ", expected an object", segmentPath, layerId);
+        return null;
+    }
+    var timeRange = curve['t'];
+    var isTimeRangeValid = false;
+    if (!hasValue(curve, 't')) {
+        addIssue(context, 'ERROR', 'C002', 't is missing', "" + segmentPath + ".t", layerId);
+    } else if (!Array.isArray(timeRange) || timeRange.length !== 2) {
+        var got = Array.isArray(timeRange) ? "array length " + timeRange.length : describeValueType(timeRange);
+        addIssue(context, 'ERROR', 'C003', "t must be a 2-element array, got " + got, "" + segmentPath + ".t", layerId);
+    } else if (!timeRange.every(isNumber)) {
+        addIssue(context, 'ERROR', 'C005', 't elements must be numbers', "" + segmentPath + ".t", layerId);
+    } else {
+        isTimeRangeValid = true;
+    }
+    if (isTimeRangeValid && Array.isArray(timeRange)) {
+        var start = timeRange[0];
+        var end = timeRange[1];
+        if (start >= end) {
+            addIssue(context, 'ERROR', 'C004', "t [" + formatNumber(start) + ", " + formatNumber(end) + "] — start >= end", "" + segmentPath + ".t", layerId);
+        }
+        if (context.duration != null && (start < -EPSILON || end > context.duration + EPSILON)) {
+            addIssue(context, 'WARNING', 'C016', "t [" + formatNumber(start) + ", " + formatNumber(end) + "] falls outside [0, " + formatNumber(context.duration) + "]", "" + segmentPath + ".t", layerId);
+        }
+    }
+    var isStartValid = checkCurveEndpoint(dimension, curve, 'start', 'C006', segmentPath, layerId, context);
+    var isEndValid = checkCurveEndpoint(dimension, curve, 'end', 'C007', segmentPath, layerId, context);
+    var easing = curve['easing'];
+    if (!hasValue(curve, 'easing')) {
+        addIssue(context, 'ERROR', 'C011', 'easing is missing', "" + segmentPath + ".easing", layerId);
+    } else if (!Array.isArray(easing) || easing.length !== 4) {
+        var got1 = Array.isArray(easing) ? "array length " + easing.length : describeValueType(easing);
+        addIssue(context, 'ERROR', 'C011', "easing must be a 4-element array [x1,y1,x2,y2], got " + got1, "" + segmentPath + ".easing", layerId);
+    } else if (!easing.every(isNumber)) {
+        addIssue(context, 'ERROR', 'C012', 'easing elements must be numbers', "" + segmentPath + ".easing", layerId);
+    } else if (easing[0] < 0 || easing[0] > 1 || easing[2] < 0 || easing[2] > 1) {
+        addIssue(context, 'ERROR', 'C012', 'easing x control points must be in the [0, 1] range', "" + segmentPath + ".easing", layerId);
+    }
+    for(var _i = 0, _iter = [
+        'in',
+        'out'
+    ]; _i < _iter.length; _i++){
+        var key = _iter[_i];
+        if (!hasValue(curve, key)) {
+            continue;
+        }
+        if (propertyName !== 'position') {
+            addIssue(context, 'ERROR', 'C013', "'" + key + "' tangent only allowed on position, not " + propertyName, segmentPath + "." + key, layerId);
+        } else {
+            var tangent = curve[key];
+            if (!Array.isArray(tangent) || tangent.length !== 3 || !tangent.every(isNumber)) {
+                var got2 = Array.isArray(tangent) ? "array length " + tangent.length : describeValueType(tangent);
+                addIssue(context, 'ERROR', 'C014', "'" + key + "' must be a finite 3-element array, got " + got2, segmentPath + "." + key, layerId);
+            }
+        }
+    }
+    if (!isTimeRangeValid || !isStartValid || !isEndValid || !Array.isArray(timeRange)) {
+        return null;
+    }
+    return {
+        t: [
+            timeRange[0],
+            timeRange[1]
+        ],
+        start: curve['start'],
+        end: curve['end']
+    };
+}
+function checkCurveEndpoint(dimension, curve, key, missingCode, segmentPath, layerId, context) {
+    var value = curve[key];
+    if (!hasValue(curve, key)) {
+        addIssue(context, 'ERROR', missingCode, "" + key + " is missing", segmentPath + "." + key, layerId);
+        return false;
+    }
+    if (dimension === 3) {
+        if (!Array.isArray(value) || value.length !== 3) {
+            var got = Array.isArray(value) ? "array length " + value.length : describeValueType(value);
+            addIssue(context, 'ERROR', 'C008', key + " must be a 3-element array, got " + got, segmentPath + "." + key, layerId);
+            return false;
+        }
+        if (!value.every(isNumber)) {
+            addIssue(context, 'ERROR', 'C008', "" + key + " must contain finite numbers", segmentPath + "." + key, layerId);
+            return false;
+        }
+        return true;
+    }
+    if (isNumber(value)) {
+        if (value < -EPSILON || value > 1 + EPSILON) {
+            addIssue(context, 'ERROR', 'C009', "" + key + " must be in the [0, 1] range", segmentPath + "." + key, layerId);
+            return false;
+        }
+        addIssue(context, 'WARNING', 'C010', key + " is a scalar " + formatNumber(value) + "; expected a 1-element array (accepted and normalized)", segmentPath + "." + key, layerId);
+        return true;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 1) {
+            if (!isNumber(value[0]) || value[0] < -EPSILON || value[0] > 1 + EPSILON) {
+                addIssue(context, 'ERROR', 'C009', "" + key + " must contain one finite number in the [0, 1] range", segmentPath + "." + key, layerId);
+                return false;
+            }
+            return true;
+        }
+        addIssue(context, 'ERROR', 'C009', key + " must be a 1-element array, got array length " + value.length, segmentPath + "." + key, layerId);
+        return false;
+    }
+    addIssue(context, 'ERROR', 'C009', key + " is " + describeValueType(value) + ", expected a 1-element array", segmentPath + "." + key, layerId);
+    return false;
+}
+function checkContinuity(propertyName, curves, animationPath, layerId, context) {
+    var validCurves = curves.filter(function(curve) {
+        return curve != null;
+    });
+    for(var index = 0; index < validCurves.length - 1; index++){
+        var left = validCurves[index];
+        var right = validCurves[index + 1];
+        var path = animationPath + "[segments " + index + "->" + (index + 1) + "]";
+        if (left.t[1] > right.t[0] + EPSILON) {
+            addIssue(context, 'WARNING', 'S002', propertyName + ": segments " + index + "/" + (index + 1) + " overlap (t " + formatValue(left.t) + " / " + formatValue(right.t) + ")", path, layerId);
+        } else if (left.t[1] < right.t[0] - EPSILON) {
+            addIssue(context, 'WARNING', 'S003', propertyName + ": gap between segments " + index + "/" + (index + 1) + " (t " + formatValue(left.t) + " / " + formatValue(right.t) + ")", path, layerId);
+        }
+        if (right.t[0] < left.t[0] - EPSILON) {
+            addIssue(context, 'WARNING', 'S004', propertyName + ": segments not monotonic at " + index + "/" + (index + 1) + " (t " + formatValue(left.t) + " / " + formatValue(right.t) + ")", path, layerId);
+        }
+    }
+}
+function checkLayerContent(entry, context) {
+    var layer = entry.layer, path = entry.path, layerId = entry.layerId;
+    var layerType = layer['type'];
+    if (typeof layerType !== 'string' || !VALID_LAYER_TYPE_SET.has(layerType)) {
+        return;
+    }
+    var asset = layer['asset'];
+    var hasAsset = hasValue(layer, 'asset');
+    var particle = layer['particle'];
+    var hasParticle = hasValue(layer, 'particle');
+    if (layerType !== 'particle' && hasParticle) {
+        addIssue(context, 'WARNING', 'A024', "type=" + layerType + " has a particle block (ignored)", "" + path + ".particle", layerId);
+    }
+    if (layerType === 'null') {
+        if (hasAsset) {
+            addIssue(context, 'WARNING', 'A010', 'null layer has an asset (ignored)', "" + path + ".asset", layerId);
+        }
+        return;
+    }
+    if (layerType === 'layer') {
+        if (!hasAsset) {
+            addIssue(context, 'ERROR', 'A001', 'type=layer requires an asset', "" + path + ".asset", layerId);
+        } else if (!isRecord$1(asset)) {
+            addIssue(context, 'ERROR', 'A002', "asset is " + describeValueType(asset) + ", expected an object", "" + path + ".asset", layerId);
+        } else {
+            checkAssetFields(asset, "" + path + ".asset", layerId, context);
+        }
+        if (hasValue(layer, 'text')) {
+            addIssue(context, 'WARNING', 'A016', 'type=layer has a text block (ignored)', "" + path + ".text", layerId);
+        }
+        if (isNumber(layer['width']) && layer['width'] <= 0 || isNumber(layer['height']) && layer['height'] <= 0) {
+            addIssue(context, 'ERROR', 'L024', 'image layers require width and height greater than 0', path, layerId);
+        }
+        return;
+    }
+    if (layerType === 'particle') {
+        if (isNumber(layer['width']) && layer['width'] <= 0 || isNumber(layer['height']) && layer['height'] <= 0) {
+            addIssue(context, 'ERROR', 'L024', 'particle layers require width and height greater than 0', path, layerId);
+        }
+        if (!hasParticle) {
+            addIssue(context, 'ERROR', 'A022', 'type=particle requires a particle block', "" + path + ".particle", layerId);
+        } else if (!isRecord$1(particle)) {
+            addIssue(context, 'ERROR', 'A023', "particle is " + describeValueType(particle) + ", expected an object", "" + path + ".particle", layerId);
+        } else {
+            for(var _iterator = _create_for_of_iterator_helper_loose(lintParticle(particle, layer, "" + path + ".particle")), _step; !(_step = _iterator()).done;){
+                var issue = _step.value;
+                addIssue(context, 'ERROR', issue.code, issue.message, issue.path, layerId);
+            }
+        }
+        if (hasAsset) {
+            addIssue(context, 'WARNING', 'A025', 'type=particle has an asset (ignored)', "" + path + ".asset", layerId);
+        }
+        if (hasValue(layer, 'text')) {
+            addIssue(context, 'WARNING', 'A026', 'type=particle has a text block (ignored)', "" + path + ".text", layerId);
+        }
+        return;
+    }
+    var text = layer['text'];
+    if (!hasValue(layer, 'text')) {
+        addIssue(context, 'ERROR', 'A011', 'type=text requires a text block', "" + path + ".text", layerId);
+    } else if (!isRecord$1(text)) {
+        addIssue(context, 'ERROR', 'A012', "text is " + describeValueType(text) + ", expected an object", "" + path + ".text", layerId);
+    } else {
+        for(var _i = 0, _iter = [
+            [
+                'content',
+                'A013',
+                'string'
+            ],
+            [
+                'size',
+                'A014',
+                'number'
+            ],
+            [
+                'color',
+                'A015',
+                'string'
+            ]
+        ]; _i < _iter.length; _i++){
+            var _iter__i = _iter[_i], field = _iter__i[0], code = _iter__i[1], expected = _iter__i[2];
+            var value = text[field];
+            if (!hasValue(text, field)) {
+                addIssue(context, 'ERROR', code, "text." + field + " is missing", path + ".text." + field, layerId);
+            } else if (expected === 'number' && !isNumber(value)) {
+                addIssue(context, 'ERROR', code, "text." + field + " is " + describeValueType(value) + ", expected a number", path + ".text." + field, layerId);
+            } else if (expected === 'string' && typeof value !== 'string') {
+                addIssue(context, 'ERROR', code, "text." + field + " is " + describeValueType(value) + ", expected a string", path + ".text." + field, layerId);
+            }
+        }
+        if (isNumber(text['size']) && text['size'] < 0) {
+            addIssue(context, 'ERROR', 'A014', "text.size is " + formatNumber(text['size']) + ", expected a number greater than or equal to 0", "" + path + ".text.size", layerId);
+        }
+        if (typeof text['color'] === 'string' && !isValidHexColor(text['color'])) {
+            addIssue(context, 'ERROR', 'A015', "text.color " + formatValue(text['color']) + " is not a supported hex color", "" + path + ".text.color", layerId);
+        }
+        if (hasValue(text, 'font') && typeof text['font'] !== 'string') {
+            addIssue(context, 'ERROR', 'A018', 'text.font must be a string', "" + path + ".text.font", layerId);
+        }
+        if (hasValue(text, 'align') && text['align'] !== 'left' && text['align'] !== 'center' && text['align'] !== 'right') {
+            addIssue(context, 'ERROR', 'A019', 'text.align must be left, center, or right', "" + path + ".text.align", layerId);
+        }
+        for(var _i1 = 0, _iter1 = [
+            'line_height',
+            'letter_spacing'
+        ]; _i1 < _iter1.length; _i1++){
+            var field1 = _iter1[_i1];
+            if (hasValue(text, field1) && !isNumber(text[field1])) {
+                addIssue(context, 'ERROR', 'A020', "text." + field1 + " must be a finite number", path + ".text." + field1, layerId);
+            }
+        }
+    }
+    if (hasAsset) {
+        addIssue(context, 'WARNING', 'A017', 'type=text has an asset (ignored)', "" + path + ".asset", layerId);
+    }
+}
+function checkAssetFields(asset, assetPath, layerId, context) {
+    var source = asset['source'];
+    if (!hasValue(asset, 'source')) {
+        addIssue(context, 'ERROR', 'A003', 'asset.source is missing', "" + assetPath + ".source", layerId);
+        return;
+    }
+    if (typeof source !== 'string' || !VALID_ASSET_SOURCE_SET.has(source)) {
+        addIssue(context, 'ERROR', 'A004', "asset.source " + formatValue(source) + " not in {user, llm_svg}", "" + assetPath + ".source", layerId);
+        return;
+    }
+    if (source === 'llm_svg') {
+        if (asset['format'] !== 'svg') {
+            addIssue(context, 'ERROR', 'A005', "asset.format is " + formatValue(asset['format']) + ", must be 'svg' for llm_svg", "" + assetPath + ".format", layerId);
+        }
+        if (typeof asset['svg'] !== 'string') {
+            addIssue(context, 'ERROR', 'A006', 'asset.svg must be a string', "" + assetPath + ".svg", layerId);
+        }
+        if (typeof asset['prompt'] !== 'string') {
+            addIssue(context, 'ERROR', 'A007', 'asset.prompt must be a string', "" + assetPath + ".prompt", layerId);
+        }
+        if (asset['url'] !== undefined && typeof asset['url'] !== 'string') {
+            addIssue(context, 'ERROR', 'A021', 'asset.url must be a string when present', "" + assetPath + ".url", layerId);
+        } else if (typeof asset['url'] === 'string' && asset['url'] !== '' && !isAbsoluteResourceUrl(asset['url'])) {
+            addIssue(context, 'ERROR', 'A021', 'asset.url must be absolute or a Data URL when non-empty', "" + assetPath + ".url", layerId);
+        }
+    } else {
+        if (typeof asset['url'] !== 'string') {
+            addIssue(context, 'ERROR', 'A008', 'asset.url must be a string', "" + assetPath + ".url", layerId);
+        } else if (!isAbsoluteResourceUrl(asset['url'])) {
+            addIssue(context, 'ERROR', 'A008', 'asset.url must be absolute or a Data URL', "" + assetPath + ".url", layerId);
+        }
+        if (asset['prompt'] !== '') {
+            addIssue(context, 'ERROR', 'A009', "asset.prompt must be '' for source=user, got " + formatValue(asset['prompt']), "" + assetPath + ".prompt", layerId);
+        }
+    }
+}
+function checkLayerRelationships(entries, context) {
+    var firstLayerById = new Map();
+    var layerCountById = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(entries), _step; !(_step = _iterator()).done;){
+        var entry = _step.value;
+        var _layerCountById_get;
+        if (entry.layerId == null) {
+            continue;
+        }
+        layerCountById.set(entry.layerId, ((_layerCountById_get = layerCountById.get(entry.layerId)) != null ? _layerCountById_get : 0) + 1);
+        if (!firstLayerById.has(entry.layerId)) {
+            firstLayerById.set(entry.layerId, entry);
+        }
+    }
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(entries), _step1; !(_step1 = _iterator1()).done;){
+        var entry1 = _step1.value;
+        var _layerCountById_get1;
+        if (entry1.layerId == null || ((_layerCountById_get1 = layerCountById.get(entry1.layerId)) != null ? _layerCountById_get1 : 0) <= 1) {
+            continue;
+        }
+        addIssue(context, 'ERROR', 'X001', "id " + formatValue(entry1.layerId) + " is not globally unique (" + layerCountById.get(entry1.layerId) + " occurrences)", "" + entry1.path + ".id", entry1.layerId);
+    }
+    var logicalParentIdByLayer = new Map();
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(entries), _step2; !(_step2 = _iterator2()).done;){
+        var entry2 = _step2.value;
+        var parent = entry2.layer['parent'];
+        var resolvedParentId = null;
+        if (parent == null) {
+            resolvedParentId = null;
+        } else if (typeof parent !== 'string') {
+            addIssue(context, 'ERROR', 'X003', "parent is " + describeValueType(parent) + ", expected a string or null", "" + entry2.path + ".parent", entry2.layerId);
+        } else if (entry2.layerId != null && parent === entry2.layerId) {
+            addIssue(context, 'ERROR', 'X002', "parent " + formatValue(parent) + " references own id (self-reference)", "" + entry2.path + ".parent", entry2.layerId);
+        } else if (!firstLayerById.has(parent)) {
+            addIssue(context, 'ERROR', 'X004', "parent " + formatValue(parent) + " not found (dangling reference)", "" + entry2.path + ".parent", entry2.layerId);
+        } else {
+            resolvedParentId = parent;
+        }
+        logicalParentIdByLayer.set(entry2, resolvedParentId);
+        if (resolvedParentId != null && entry2.physicalParentId !== resolvedParentId) {
+            addIssue(context, 'WARNING', 'X005', "parent=" + formatValue(resolvedParentId) + " but physical nesting under " + formatValue(entry2.physicalParentId) + " (parent wins)", "" + entry2.path + ".parent", entry2.layerId);
+        } else if (resolvedParentId == null && parent == null && entry2.physicalParentId != null) {
+            addIssue(context, 'WARNING', 'X005', "layer nested under " + formatValue(entry2.physicalParentId) + " but parent is null/absent", "" + entry2.path + ".parent", entry2.layerId);
+        }
+    }
+    checkParentCycles(entries, firstLayerById, logicalParentIdByLayer, context);
+}
+function checkParentCycles(entries, firstLayerById, logicalParentIdByLayer, context) {
+    var resolvedLayerSet = new Set();
+    var cycleEntries = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(entries), _step; !(_step = _iterator()).done;){
+        var _loop = function() {
+            var currentId = current.layerId;
+            if (currentId == null) {
+                return "break";
+            }
+            if (visitedLayerIdSet.has(currentId)) {
+                var cycleStartIndex = pathEntries.findIndex(function(entry) {
+                    return entry.layerId === currentId;
+                });
+                if (cycleStartIndex >= 0) {
+                    var _cycleEntries;
+                    (_cycleEntries = cycleEntries).push.apply(_cycleEntries, [].concat(pathEntries.slice(cycleStartIndex)));
+                }
+                return "break";
+            }
+            if (resolvedLayerSet.has(current)) {
+                return "break";
+            }
+            pathEntries.push(current);
+            visitedLayerIdSet.add(currentId);
+            var parentId = logicalParentIdByLayer.get(current);
+            current = parentId == null ? undefined : firstLayerById.get(parentId);
+        };
+        var start = _step.value;
+        if (resolvedLayerSet.has(start)) {
+            continue;
+        }
+        var pathEntries = [];
+        var visitedLayerIdSet = new Set();
+        var current = start;
+        while(current != null){
+            var _ret = _loop();
+            if (_ret === "break") break;
+        }
+        pathEntries.forEach(function(entry) {
+            return resolvedLayerSet.add(entry);
+        });
+    }
+    var reportedCycleLayerSet = new Set();
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(cycleEntries), _step1; !(_step1 = _iterator1()).done;){
+        var entry = _step1.value;
+        if (reportedCycleLayerSet.has(entry)) {
+            continue;
+        }
+        reportedCycleLayerSet.add(entry);
+        addIssue(context, 'ERROR', 'X006', "layer " + formatValue(entry.layerId) + " is part of a parent-pointer cycle", "" + entry.path + ".parent", entry.layerId);
+    }
+}
+function readLayerId(layer) {
+    var id = layer['id'];
+    return typeof id === 'string' && id.length > 0 ? id : null;
+}
+function containsCircularReference(value, ancestorSet) {
+    if (ancestorSet === void 0) ancestorSet = new WeakSet();
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object' || value === null) {
+        return false;
+    }
+    if (ancestorSet.has(value)) {
+        return true;
+    }
+    ancestorSet.add(value);
+    var hasCircularChild = Object.values(value).some(function(child) {
+        return containsCircularReference(child, ancestorSet);
+    });
+    ancestorSet.delete(value);
+    return hasCircularChild;
+}
+function hasValue(object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key) && object[key] != null;
+}
+function isNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isIntLike(value) {
+    return isNumber(value) && Number.isInteger(value);
+}
+function isAbsoluteResourceUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch (unused) {
+        return false;
+    }
+}
+function describeValueType(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    if (isRecord$1(value)) {
+        return 'object';
+    }
+    return typeof value === "undefined" ? "undefined" : _type_of(value);
+}
+function formatValue(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (typeof value === 'boolean') {
+        return String(value);
+    }
+    if (typeof value === 'number') {
+        return formatNumber(value);
+    }
+    if (typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return "[" + value.map(formatValue).join(', ') + "]";
+    }
+    if (isRecord$1(value)) {
+        return "{" + Object.entries(value).map(function(param) {
+            var key = param[0], item = param[1];
+            return formatValue(key) + ": " + formatValue(item);
+        }).join(', ') + "}";
+    }
+    return String(value);
+}
+function formatNumber(value) {
+    if (Number.isNaN(value)) {
+        return 'NaN';
+    }
+    if (value === Infinity) {
+        return 'Infinity';
+    }
+    if (value === -Infinity) {
+        return '-Infinity';
+    }
+    return String(value);
+}
+
+function assembleDSLResult(baselineScene, baselineComposition, dslLayerByIRId, layerMapping, diagnostics) {
+    var _baselineComposition_name;
+    var layers = assembleDSLHierarchy(baselineComposition.layers, dslLayerByIRId);
+    var frameRate = baselineComposition.frameRate;
+    return {
+        dsl: {
+            meta: {
+                name: (_baselineComposition_name = baselineComposition.name) != null ? _baselineComposition_name : baselineComposition.id,
+                duration: Math.max(0, (baselineComposition.outPoint - baselineComposition.inPoint) / frameRate),
+                fps: frameRate,
+                width: baselineComposition.width,
+                height: baselineComposition.height,
+                loop: baselineComposition.endBehavior === IREndBehavior.Loop,
+                background_color: baselineComposition.backgroundColor != null ? colorToHex(baselineComposition.backgroundColor) : null
+            },
+            layers: layers
+        },
+        preservedData: {
+            baselineScene: baselineScene,
+            layerMapping: layerMapping
+        },
+        diagnostics: diagnostics
+    };
+}
+function assembleDSLHierarchy(sourceLayers, dslLayerByIRId) {
+    var rootLayers = [];
+    // IR is bottom-to-top while each DSL sibling array is top-to-bottom.
+    for(var _iterator = _create_for_of_iterator_helper_loose(sourceLayers), _step; !(_step = _iterator()).done;){
+        var sourceLayer = _step.value;
+        var convertedLayer = dslLayerByIRId.get(sourceLayer.id);
+        if (convertedLayer == null) {
+            continue;
+        }
+        var parentLayerId = sourceLayer.parentId;
+        var parentLayer = parentLayerId != null ? dslLayerByIRId.get(parentLayerId) : undefined;
+        if (parentLayer != null) {
+            var _parentLayer, _children;
+            (_children = (_parentLayer = parentLayer).children) != null ? _children : _parentLayer.children = [];
+            parentLayer.children.unshift(convertedLayer);
+        } else {
+            rootLayers.unshift(convertedLayer);
+        }
+    }
+    return rootLayers;
+}
+
+function mapDSLParticleExpressionToIR(expression) {
+    if (expression[0] === ValueType.RANDOM) {
+        return {
+            type: 'randomBetweenConstants',
+            min: expression[1][0],
+            max: expression[1][1]
+        };
+    }
+    return {
+        type: 'constant',
+        value: expression[1]
+    };
+}
+function mapIRParticleExpressionToDSL(expression) {
+    switch(expression.type){
+        case 'constant':
+            return [
+                ValueType.CONSTANT,
+                expression.value
+            ];
+        case 'randomBetweenConstants':
+            return [
+                ValueType.RANDOM,
+                [
+                    expression.min,
+                    expression.max
+                ]
+            ];
+        case 'curve':
+            var _ref;
+            var _expression_keyframes_;
+            return [
+                ValueType.CONSTANT,
+                (_ref = (_expression_keyframes_ = expression.keyframes[0]) == null ? void 0 : _expression_keyframes_.value) != null ? _ref : 0
+            ];
+    }
+}
+function isDSLCompatibleParticleExpression(expression) {
+    return expression.type === 'constant' || expression.type === 'randomBetweenConstants';
+}
+function isDSLNumberExpressionEqual(left, right) {
+    if (left[0] !== right[0]) {
+        return false;
+    }
+    if (left[0] === ValueType.CONSTANT && right[0] === ValueType.CONSTANT) {
+        return Object.is(left[1], right[1]);
+    }
+    if (left[0] === ValueType.RANDOM && right[0] === ValueType.RANDOM) {
+        return Object.is(left[1][0], right[1][0]) && Object.is(left[1][1], right[1][1]);
+    }
+    return false;
+}
+
+/** Static defaults for absent transform channels. */ var TRANSFORM_FALLBACK = {
+    position: [
+        0,
+        0,
+        0
+    ],
+    rotation: [
+        0,
+        0,
+        0
+    ],
+    scale: [
+        1,
+        1,
+        1
+    ],
+    anchor: [
+        0,
+        0,
+        0
+    ],
+    opacity: 1
+};
+function getLayerStackingOrder(layer) {
+    var _value_;
+    var _layer_position_animation_;
+    var value = layer.position.a ? (_layer_position_animation_ = layer.position.animation[0]) == null ? void 0 : _layer_position_animation_.start : layer.position.value;
+    return Array.isArray(value) ? (_value_ = value[2]) != null ? _value_ : 0 : 0;
+}
+function withPositionZ(position, depth) {
+    var result = structuredClone(position);
+    if (result.a) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(result.animation), _step; !(_step = _iterator()).done;){
+            var segment = _step.value;
+            segment.start[2] = depth;
+            segment.end[2] = depth;
+        }
+    } else if (Array.isArray(result.value)) {
+        result.value[2] = depth;
+    }
+    return result;
+}
+
+function convertIRParticleToDSL(layer, frameRate, layerPath, diagnostics) {
+    var convertExpression = function convertExpression(expression, fieldPath) {
+        if (!isDSLCompatibleParticleExpression(expression)) {
+            diagnostics.push({
+                code: 'PARTICLE_EXPRESSION_PROJECTED',
+                severity: 'warning',
+                action: 'approximated',
+                path: layerPath + ".content." + fieldPath,
+                sourceId: layer.id,
+                feature: fieldPath,
+                message: "Particle " + fieldPath + " uses an IR " + expression.type + " expression and was projected to a representative editable DSL value; the baseline IR preserves the original expression until this field is edited."
+            });
+        }
+        return mapIRParticleExpressionToDSL(expression);
+    };
+    return {
+        options: {
+            maxCount: layer.content.maxParticles,
+            startLifetime: convertExpression(layer.content.startLifetime, 'startLifetime')
+        },
+        emission: _extends({
+            rateOverTime: convertExpression(layer.content.emission.rateOverTime, 'emission.rateOverTime')
+        }, layer.content.emission.bursts != null && {
+            bursts: layer.content.emission.bursts.map(function(burst) {
+                return {
+                    time: burst.frameOffset / frameRate,
+                    count: burst.count,
+                    cycles: burst.cycleCount === 'infinite' ? 0 : burst.cycleCount,
+                    interval: burst.repeatIntervalFrames / frameRate
+                };
+            })
+        })
+    };
+}
+
+var LINEAR_EASING = [
+    0,
+    0,
+    1,
+    1
+];
+function convertIRLayersToDSL(baselineComposition, assets, frameRate) {
+    var layerMapping = {
+        layers: {}
+    };
+    var diagnostics = [];
+    var dslLayerByIRId = new Map();
+    var imageAssetById = new Map(assets.filter(function(asset) {
+        return asset.type === 'image';
+    }).map(function(asset) {
+        return [
+            asset.id,
+            asset
+        ];
+    }));
+    var fontAssetById = new Map(assets.filter(function(asset) {
+        return asset.type === 'font';
+    }).map(function(asset) {
+        return [
+            asset.id,
+            asset
+        ];
+    }));
+    for(var _iterator = _create_for_of_iterator_helper_loose(baselineComposition.layers.entries()), _step; !(_step = _iterator()).done;){
+        var _step_value = _step.value, layerIndex = _step_value[0], layer = _step_value[1];
+        var layerId = layer.id;
+        var layerPath = "$.compositions[id=" + JSON.stringify(baselineComposition.id) + "].layers[" + layerIndex + "]";
+        var convertedLayer = convertIRLayerToDSL(layer, layerId, imageAssetById, fontAssetById, frameRate, layerPath, diagnostics);
+        convertedLayer.position = withPositionZ(convertedLayer.position, layerIndex);
+        layerMapping.layers[layerId] = {
+            irCompositionId: baselineComposition.id,
+            irLayerId: layer.id
+        };
+        dslLayerByIRId.set(layer.id, convertedLayer);
+        collectDiagnostics(layer, layerId, layerPath, diagnostics);
+        if (convertedLayer.type === 'null' && isVisualLayerWithoutAsset(layer, convertedLayer.asset)) {
+            diagnostics.push({
+                code: 'LAYER_ASSET_NOT_MATERIALIZED',
+                severity: 'warning',
+                action: 'approximated',
+                path: "" + layerPath + ".content.assetId",
+                sourceId: layerId,
+                feature: 'asset',
+                message: "Visual layer type '" + layer.type + "' has no materialized URL asset and was projected to DSL type=null; the baseline scene preserves the original visual data."
+            });
+        }
+    }
+    return {
+        dslLayerByIRId: dslLayerByIRId,
+        layerMapping: layerMapping,
+        diagnostics: diagnostics
+    };
+}
+function convertIRLayerToDSL(layer, layerId, imageAssetById, fontAssetById, frameRate, layerPath, diagnostics) {
+    var _layer_parentId, _layer_name, _layer_name1;
+    var _layer_transform, _layer_transform1, _layer_transform2, _layer_transform3;
+    var size = resolveLayerSize(layer);
+    var asset = convertIRAssetToDSL(layer, imageAssetById);
+    var layerType = mapLayerType$1(layer, asset);
+    var parentId = (_layer_parentId = layer.parentId) != null ? _layer_parentId : null;
+    var convertedLayer = {
+        id: layerId,
+        name: (_layer_name = layer.name) != null ? _layer_name : layer.id,
+        type: layerType,
+        width: size.width,
+        height: size.height,
+        description: {
+            self: (_layer_name1 = layer.name) != null ? _layer_name1 : layer.id,
+            composite: ''
+        },
+        parent: parentId,
+        time_range: [
+            layer.time.inFrame / frameRate,
+            layer.time.outFrame / frameRate
+        ],
+        position: convertIRVec3PropertyToDSL((_layer_transform = layer.transform) == null ? void 0 : _layer_transform.position, TRANSFORM_FALLBACK.position, frameRate, true),
+        rotation: convertIRLayerRotationToDSL(layer, frameRate),
+        scale: convertIRVec3PropertyToDSL((_layer_transform1 = layer.transform) == null ? void 0 : _layer_transform1.scale, TRANSFORM_FALLBACK.scale, frameRate, false),
+        anchor: convertIRVec3PropertyToDSL((_layer_transform2 = layer.transform) == null ? void 0 : _layer_transform2.anchor, TRANSFORM_FALLBACK.anchor, frameRate, false),
+        opacity: convertIRNumberPropertyToDSL((_layer_transform3 = layer.transform) == null ? void 0 : _layer_transform3.opacity, TRANSFORM_FALLBACK.opacity, frameRate),
+        children: []
+    };
+    if (layerType === 'layer' && asset != null) {
+        convertedLayer.asset = asset;
+    }
+    if (layer.type === 'text') {
+        convertedLayer.text = convertIRTextToDSL(layer, fontAssetById);
+    }
+    if (layer.type === 'particle') {
+        convertedLayer.particle = convertIRParticleToDSL(layer, frameRate, layerPath, diagnostics);
+    }
+    return convertedLayer;
+}
+function mapLayerType$1(layer, asset) {
+    if (layer.type === 'particle') {
+        return 'particle';
+    }
+    if (layer.type === 'text') {
+        return 'text';
+    }
+    if (layer.type === 'null' || layer.type === 'precomp') {
+        return 'null';
+    }
+    return asset != null ? 'layer' : 'null';
+}
+function isVisualLayerWithoutAsset(layer, asset) {
+    return layer.type !== 'null' && layer.type !== 'precomp' && layer.type !== 'text' && layer.type !== 'particle' && asset == null;
+}
+function resolveLayerSize(layer) {
+    if (layer.localBounds != null) {
+        var _layer_localBounds = layer.localBounds, width = _layer_localBounds.width, height = _layer_localBounds.height;
+        return {
+            width: width,
+            height: height
+        };
+    }
+    return {
+        width: 0,
+        height: 0
+    };
+}
+function convertIRAssetToDSL(layer, imageAssetById) {
+    if (layer.type !== 'image') {
+        return undefined;
+    }
+    var imageAsset = imageAssetById.get(layer.content.assetId);
+    if (imageAsset == null) {
+        return undefined;
+    }
+    return {
+        url: getIRResourceSourceUrl(imageAsset.source),
+        source: 'user',
+        prompt: ''
+    };
+}
+function convertIRTextToDSL(layer, fontAssetById) {
+    var text = layer.content;
+    var fontAsset = fontAssetById.get(text.fontAssetId);
+    if (fontAsset == null) {
+        throw new TypeError("[dsl-ir] Text layer '" + layer.id + "' references a missing Font Asset: " + text.fontAssetId);
+    }
+    return _extends({
+        content: text.text,
+        font: fontAsset.family,
+        size: text.fontSize,
+        color: colorToHex(text.color)
+    }, text.textAlign != null && {
+        align: text.textAlign
+    }, {
+        line_height: text.lineHeight
+    }, text.letterSpacing != null && {
+        letter_spacing: text.letterSpacing
+    });
+}
+function convertIRLayerRotationToDSL(layer, frameRate) {
+    var _layer_transform;
+    var rotation = (_layer_transform = layer.transform) == null ? void 0 : _layer_transform.rotation;
+    if (rotation == null) {
+        return convertIRVec3PropertyToDSL(undefined, TRANSFORM_FALLBACK.rotation, frameRate, false);
+    }
+    return convertIRRotationToDSL(rotation, frameRate);
+}
+/**
+ * Merge per-axis rotation into the DSL's 3D vector track.
+ *
+ * Aligned channels retain their shared easing. Independent axes fall back to
+ * a union-of-keyframe-times projection.
+ */ function convertIRRotationToDSL(rotation, frameRate) {
+    var rotationChannels = [
+        rotation.x,
+        rotation.y,
+        rotation.z
+    ];
+    var animatedChannels = rotationChannels.filter(function(channel) {
+        return (channel == null ? void 0 : channel.type) === 'keyframed';
+    });
+    if (animatedChannels.length === 0) {
+        return {
+            a: false,
+            value: [
+                readNumberStatic(rotation.x, 0),
+                readNumberStatic(rotation.y, 0),
+                readNumberStatic(rotation.z, 0)
+            ]
+        };
+    }
+    if (isRotationChannelSetAligned(animatedChannels)) {
+        var templateChannel = animatedChannels[0];
+        var keyframes = templateChannel.keyframes.map(function(keyframe, index) {
+            var hasEndValue = animatedChannels.some(function(channel) {
+                var _channel_keyframes_index;
+                return ((_channel_keyframes_index = channel.keyframes[index]) == null ? void 0 : _channel_keyframes_index.endValue) != null;
+            });
+            return _extends({
+                frame: keyframe.frame,
+                value: readAlignedRotationValue(rotation, index)
+            }, hasEndValue && {
+                endValue: readAlignedRotationEndValue(rotation, index)
+            }, keyframe.hold != null && {
+                hold: keyframe.hold
+            }, keyframe.inTangent != null && {
+                inTangent: keyframe.inTangent
+            }, keyframe.outTangent != null && {
+                outTangent: keyframe.outTangent
+            });
+        });
+        return convertIRKeyframesToDSLProperty(keyframes, TRANSFORM_FALLBACK.rotation, frameRate, false);
+    }
+    var keyframeFrameSet = new Set();
+    for(var _iterator = _create_for_of_iterator_helper_loose(rotationChannels), _step; !(_step = _iterator()).done;){
+        var channel = _step.value;
+        if ((channel == null ? void 0 : channel.type) === 'keyframed' && channel.keyframes != null) {
+            for(var _iterator1 = _create_for_of_iterator_helper_loose(channel.keyframes), _step1; !(_step1 = _iterator1()).done;){
+                var keyframe = _step1.value;
+                keyframeFrameSet.add(keyframe.frame);
+            }
+        }
+    }
+    // Keep Array.from: loose SWC array-spread lowering does not expand Set in dist.
+    var sortedFrames = Array.from(keyframeFrameSet).sort(function(leftFrame, rightFrame) {
+        return leftFrame - rightFrame;
+    });
+    var keyframes1 = sortedFrames.map(function(frame) {
+        return {
+            frame: frame,
+            value: [
+                readNumberAtFrame(rotation.x, frame, 0),
+                readNumberAtFrame(rotation.y, frame, 0),
+                readNumberAtFrame(rotation.z, frame, 0)
+            ]
+        };
+    });
+    return convertIRKeyframesToDSLProperty(keyframes1, TRANSFORM_FALLBACK.rotation, frameRate, false);
+}
+function isRotationChannelSetAligned(rotationChannels) {
+    var templateChannel = rotationChannels[0];
+    return rotationChannels.every(function(channel) {
+        return channel.keyframes.length === templateChannel.keyframes.length && channel.keyframes.every(function(keyframe, index) {
+            return isRotationKeyframeAligned(keyframe, templateChannel.keyframes[index]);
+        });
+    });
+}
+function isRotationKeyframeAligned(left, right) {
+    return Math.abs(left.frame - right.frame) < EPSILON$1 && left.hold === right.hold && isBezierHandleEqual(left.inTangent, right.inTangent) && isBezierHandleEqual(left.outTangent, right.outTangent);
+}
+function isBezierHandleEqual(left, right) {
+    if (left == null || right == null) {
+        return left === right;
+    }
+    return Math.abs(left.x - right.x) < EPSILON$1 && Math.abs(left.y - right.y) < EPSILON$1;
+}
+function readAlignedRotationValue(rotation, index) {
+    return [
+        readAlignedAxisValue(rotation.x, index),
+        readAlignedAxisValue(rotation.y, index),
+        readAlignedAxisValue(rotation.z, index)
+    ];
+}
+function readAlignedRotationEndValue(rotation, index) {
+    return [
+        readAlignedAxisEndValue(rotation.x, index),
+        readAlignedAxisEndValue(rotation.y, index),
+        readAlignedAxisEndValue(rotation.z, index)
+    ];
+}
+function readAlignedAxisValue(channel, index) {
+    var _ref, _ref1;
+    var _channel_keyframes_index;
+    return (channel == null ? void 0 : channel.type) === 'keyframed' ? (_ref = (_channel_keyframes_index = channel.keyframes[index]) == null ? void 0 : _channel_keyframes_index.value) != null ? _ref : 0 : (_ref1 = channel == null ? void 0 : channel.value) != null ? _ref1 : 0;
+}
+function readAlignedAxisEndValue(channel, index) {
+    var _ref, _ref1, _ref2;
+    var _channel_keyframes_index, _channel_keyframes_, _channel_keyframes_index1;
+    if ((channel == null ? void 0 : channel.type) !== 'keyframed') {
+        var _ref3;
+        return (_ref3 = channel == null ? void 0 : channel.value) != null ? _ref3 : 0;
+    }
+    return (_ref = (_ref1 = (_ref2 = (_channel_keyframes_index = channel.keyframes[index]) == null ? void 0 : _channel_keyframes_index.endValue) != null ? _ref2 : (_channel_keyframes_ = channel.keyframes[index + 1]) == null ? void 0 : _channel_keyframes_.value) != null ? _ref1 : (_channel_keyframes_index1 = channel.keyframes[index]) == null ? void 0 : _channel_keyframes_index1.value) != null ? _ref : 0;
+}
+function convertIRVec3PropertyToDSL(property, fallback, frameRate, includeSpatialTangents) {
+    if ((property == null ? void 0 : property.type) === 'keyframed') {
+        return convertIRKeyframesToDSLProperty(property.keyframes, fallback, frameRate, includeSpatialTangents);
+    }
+    return {
+        a: false,
+        value: (property == null ? void 0 : property.value) != null ? [].concat(property.value) : [].concat(fallback)
+    };
+}
+function convertIRNumberPropertyToDSL(property, fallback, frameRate) {
+    var _ref;
+    if ((property == null ? void 0 : property.type) === 'keyframed') {
+        return convertIRKeyframesToDSLProperty(property.keyframes, fallback, frameRate, false);
+    }
+    return {
+        a: false,
+        value: (_ref = property == null ? void 0 : property.value) != null ? _ref : fallback
+    };
+}
+function convertIRKeyframesToDSLProperty(keyframes, fallback, frameRate, includeSpatialTangents) {
+    if (keyframes.length < 2) {
+        var _ref;
+        var _keyframes_;
+        return {
+            a: false,
+            value: (_ref = (_keyframes_ = keyframes[0]) == null ? void 0 : _keyframes_.value) != null ? _ref : fallback
+        };
+    }
+    var animation = [];
+    for(var keyframeIndex = 0; keyframeIndex < keyframes.length - 1; keyframeIndex++){
+        var _currentKeyframe_endValue, _ref1, _ref2, _ref3, _ref4;
+        var _currentKeyframe_outTangent, _currentKeyframe_outTangent1, _nextKeyframe_inTangent, _nextKeyframe_inTangent1;
+        var currentKeyframe = keyframes[keyframeIndex];
+        var nextKeyframe = keyframes[keyframeIndex + 1];
+        var endValue = (_currentKeyframe_endValue = currentKeyframe.endValue) != null ? _currentKeyframe_endValue : nextKeyframe.value;
+        var easing = [
+            (_ref1 = (_currentKeyframe_outTangent = currentKeyframe.outTangent) == null ? void 0 : _currentKeyframe_outTangent.x) != null ? _ref1 : LINEAR_EASING[0],
+            (_ref2 = (_currentKeyframe_outTangent1 = currentKeyframe.outTangent) == null ? void 0 : _currentKeyframe_outTangent1.y) != null ? _ref2 : LINEAR_EASING[1],
+            (_ref3 = (_nextKeyframe_inTangent = nextKeyframe.inTangent) == null ? void 0 : _nextKeyframe_inTangent.x) != null ? _ref3 : LINEAR_EASING[2],
+            (_ref4 = (_nextKeyframe_inTangent1 = nextKeyframe.inTangent) == null ? void 0 : _nextKeyframe_inTangent1.y) != null ? _ref4 : LINEAR_EASING[3]
+        ];
+        animation.push(_extends({
+            t: [
+                currentKeyframe.frame / frameRate,
+                nextKeyframe.frame / frameRate
+            ],
+            start: convertIRPropertyValueToArray(currentKeyframe.value),
+            end: convertIRPropertyValueToArray(currentKeyframe.hold === true ? currentKeyframe.value : endValue),
+            easing: easing
+        }, includeSpatialTangents && currentKeyframe.spatialOut != null && {
+            out: convertIRSpatialTangentToDSL(currentKeyframe.spatialOut)
+        }, includeSpatialTangents && nextKeyframe.spatialIn != null && {
+            in: convertIRSpatialTangentToDSL(nextKeyframe.spatialIn)
+        }));
+    }
+    return {
+        a: true,
+        animation: animation
+    };
+}
+function convertIRSpatialTangentToDSL(value) {
+    var _value_, _value_1, _value_2;
+    return [
+        (_value_ = value[0]) != null ? _value_ : 0,
+        (_value_1 = value[1]) != null ? _value_1 : 0,
+        (_value_2 = value[2]) != null ? _value_2 : 0
+    ];
+}
+function convertIRPropertyValueToArray(value) {
+    return Array.isArray(value) ? [].concat(value) : [
+        value
+    ];
+}
+function readNumberStatic(property, fallback) {
+    var _property_value;
+    if (property == null || property.type === 'keyframed') {
+        return fallback;
+    }
+    return (_property_value = property.value) != null ? _property_value : fallback;
+}
+function readNumberAtFrame(property, frame, fallback) {
+    var _ref;
+    var _property_keyframes;
+    if (property == null) {
+        return fallback;
+    }
+    if (property.type === 'static') {
+        var _property_value;
+        return (_property_value = property.value) != null ? _property_value : fallback;
+    }
+    var keyframe = (_property_keyframes = property.keyframes) == null ? void 0 : _property_keyframes.find(function(candidate) {
+        return Math.abs(candidate.frame - frame) < EPSILON$1;
+    });
+    return (_ref = keyframe == null ? void 0 : keyframe.value) != null ? _ref : fallback;
+}
+function collectDiagnostics(layer, layerId, layerPath, diagnostics) {
+    var _layer_content;
+    var preservedFields = [];
+    var unsupportedFeatures = [];
+    collectPreservedField(preservedFields, layer.visible === false ? layer.visible : undefined, 'visible');
+    collectPreservedField(preservedFields, layer.endBehavior != null && layer.endBehavior !== 'destroy' ? layer.endBehavior : undefined, 'endBehavior');
+    collectPreservedField(preservedFields, layer.blendMode, 'blendMode');
+    collectPreservedField(preservedFields, layer.mask, 'mask');
+    collectPreservedField(preservedFields, layer.matte, 'matte');
+    collectPreservedField(preservedFields, layer.localBounds != null && layer.localBounds.x !== 0 ? layer.localBounds.x : undefined, 'localBounds.x');
+    collectPreservedField(preservedFields, layer.localBounds != null && layer.localBounds.y !== 0 ? layer.localBounds.y : undefined, 'localBounds.y');
+    collectPreservedField(preservedFields, layer.type === 'shape' ? (_layer_content = layer.content) == null ? void 0 : _layer_content.shapes : undefined, 'shapes');
+    collectPreservedField(preservedFields, layer.type === 'solid' ? layer.content.color : undefined, 'content.color');
+    if (layer.type === 'particle') {
+        collectPreservedField(preservedFields, isDSLCompatibleParticleExpression(layer.content.startLifetime) ? undefined : layer.content.startLifetime, 'content.startLifetime');
+        collectPreservedField(preservedFields, isDSLCompatibleParticleExpression(layer.content.emission.rateOverTime) ? undefined : layer.content.emission.rateOverTime, 'content.emission.rateOverTime');
+    }
+    if (layer.type === 'shape') {
+        unsupportedFeatures.push('shape');
+    }
+    if (layer.type === 'solid') {
+        unsupportedFeatures.push('solid');
+    }
+    if (layer.type === 'precomp') {
+        unsupportedFeatures.push(layer.type);
+    }
+    if (layer.mask != null || layer.matte != null) {
+        unsupportedFeatures.push('mask');
+    }
+    var uniquePreservedFields = Array.from(new Set(preservedFields));
+    var uniqueUnsupportedFeatures = Array.from(new Set(unsupportedFeatures));
+    if (uniqueUnsupportedFeatures.length > 0) {
+        diagnostics.push({
+            code: 'LAYER_HAS_UNSUPPORTED_FEATURES',
+            severity: 'warning',
+            action: 'unsupported',
+            path: layerPath,
+            sourceId: layerId,
+            feature: uniqueUnsupportedFeatures.join(','),
+            message: "Layer contains features outside the editable DSL surface: " + uniqueUnsupportedFeatures.join(', ')
+        });
+    }
+    if (uniquePreservedFields.length > 0) {
+        diagnostics.push({
+            code: 'LAYER_FIELDS_PRESERVED_IN_BASE_IR',
+            severity: 'info',
+            action: 'normalized',
+            path: layerPath,
+            sourceId: layerId,
+            feature: uniquePreservedFields.join(','),
+            message: "Fields preserved in baseline scene: " + uniquePreservedFields.join(', ')
+        });
+    }
+}
+function collectPreservedField(preservedFields, value, fieldName) {
+    if (value == null) {
+        return;
+    }
+    if (Array.isArray(value) && value.length === 0) {
+        return;
+    }
+    preservedFields.push(fieldName);
+}
+
+/** Expand referenced IR Compositions into the editable DSL tree. */ function expandDSLPrecompositions(dslResult, convertIRSceneEntryToDSL) {
+    var irScene = dslResult.preservedData.baselineScene;
+    var context = {
+        irScene: irScene,
+        compositionById: new Map(irScene.compositions.map(function(composition) {
+            return [
+                composition.id,
+                composition
+            ];
+        })),
+        layerMapping: dslResult.preservedData.layerMapping,
+        diagnostics: dslResult.diagnostics,
+        visitedCompositionIdSet: new Set([
+            irScene.entryCompositionId
+        ]),
+        convertIRSceneEntryToDSL: convertIRSceneEntryToDSL
+    };
+    expandPrecompLayerTree(dslResult.dsl.layers, getIRSceneEntryComposition(irScene), context);
+}
+function expandPrecompLayerTree(layers, sourceComposition, context) {
+    var layerById = new Map(sourceComposition.layers.map(function(layer) {
+        return [
+            layer.id,
+            layer
+        ];
+    }));
+    for(var _iterator = _create_for_of_iterator_helper_loose(layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        var _layer_children;
+        var referencedComposition = resolveReferencedComposition(layer.id, context.layerMapping, layerById, context);
+        var children = (_layer_children = layer.children) != null ? _layer_children : [];
+        if (referencedComposition != null && children.length === 0) {
+            expandPrecompChildren(layer, referencedComposition, context);
+            continue;
+        }
+        if (children.length > 0) {
+            expandPrecompLayerTree(children, sourceComposition, context);
+        }
+    }
+}
+function expandPrecompChildren(parentLayer, referencedComposition, context) {
+    if (context.visitedCompositionIdSet.has(referencedComposition.id)) {
+        context.diagnostics.push({
+            code: 'PRECOMP_EXPAND_CYCLE_SKIPPED',
+            severity: 'warning',
+            action: 'unsupported',
+            path: '$.layers',
+            sourceId: parentLayer.id,
+            feature: 'precomp-cycle',
+            message: "Precomp '" + referencedComposition.id + "' was not expanded because it would create a cycle."
+        });
+        return;
+    }
+    context.visitedCompositionIdSet.add(referencedComposition.id);
+    try {
+        var _context_diagnostics, _parentLayer_children;
+        var _parentLayer, _children;
+        var childScene = _extends({}, context.irScene, {
+            entryCompositionId: referencedComposition.id
+        });
+        var childResult = context.convertIRSceneEntryToDSL(childScene);
+        var prefix = parentLayer.id + "__precomp_" + sanitizeIdPart(referencedComposition.id) + "__";
+        var children = cloneExpandedLayers(childResult.dsl.layers, {
+            prefix: prefix,
+            parentLayerId: parentLayer.id,
+            irCompositionId: referencedComposition.id,
+            childLayerMapping: childResult.preservedData.layerMapping,
+            targetLayerMapping: context.layerMapping
+        });
+        (_context_diagnostics = context.diagnostics).push.apply(_context_diagnostics, [].concat(childResult.diagnostics));
+        (_children = (_parentLayer = parentLayer).children) != null ? _children : _parentLayer.children = [];
+        (_parentLayer_children = parentLayer.children).push.apply(_parentLayer_children, [].concat(children));
+        expandPrecompLayerTree(children, referencedComposition, context);
+    } finally{
+        context.visitedCompositionIdSet.delete(referencedComposition.id);
+    }
+}
+function cloneExpandedLayers(layers, options) {
+    var expandedLayerIdBySourceId = buildExpandedLayerIdBySourceId(layers, options.prefix);
+    var cloneExpandedLayer = function cloneExpandedLayer1(layer, fallbackParentId) {
+        var _expandedLayerIdBySourceId_get, _expandedLayerIdBySourceId_get1, _layer_children;
+        var clonedLayer = structuredClone(layer);
+        var expandedLayerId = (_expandedLayerIdBySourceId_get = expandedLayerIdBySourceId.get(layer.id)) != null ? _expandedLayerIdBySourceId_get : "" + options.prefix + layer.id;
+        clonedLayer.id = expandedLayerId;
+        clonedLayer.parent = layer.parent != null ? (_expandedLayerIdBySourceId_get1 = expandedLayerIdBySourceId.get(layer.parent)) != null ? _expandedLayerIdBySourceId_get1 : fallbackParentId : fallbackParentId;
+        clonedLayer.children = ((_layer_children = layer.children) != null ? _layer_children : []).map(function(childLayer) {
+            return cloneExpandedLayer(childLayer, expandedLayerId);
+        });
+        registerExpandedLayer(layer.id, clonedLayer, options);
+        return clonedLayer;
+    };
+    return layers.map(function(layer) {
+        return cloneExpandedLayer(layer, options.parentLayerId);
+    });
+}
+function buildExpandedLayerIdBySourceId(layers, prefix, expandedLayerIdBySourceId) {
+    if (expandedLayerIdBySourceId === void 0) expandedLayerIdBySourceId = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        var _layer_children;
+        expandedLayerIdBySourceId.set(layer.id, "" + prefix + layer.id);
+        buildExpandedLayerIdBySourceId((_layer_children = layer.children) != null ? _layer_children : [], prefix, expandedLayerIdBySourceId);
+    }
+    return expandedLayerIdBySourceId;
+}
+function registerExpandedLayer(sourceLayerId, expandedLayer, options) {
+    var childMapping = options.childLayerMapping.layers[sourceLayerId];
+    if (childMapping == null) {
+        return;
+    }
+    var expandedSource = {
+        irCompositionId: options.irCompositionId,
+        parentLayerId: options.parentLayerId,
+        baselineTransform: {
+            position: structuredClone(expandedLayer.position),
+            scale: structuredClone(expandedLayer.scale),
+            rotation: structuredClone(expandedLayer.rotation),
+            anchor: structuredClone(expandedLayer.anchor),
+            opacity: structuredClone(expandedLayer.opacity)
+        },
+        baselineLayer: _extends({
+            name: expandedLayer.name,
+            type: expandedLayer.type,
+            width: expandedLayer.width,
+            height: expandedLayer.height,
+            description: structuredClone(expandedLayer.description),
+            parent: expandedLayer.parent,
+            timeRange: structuredClone(expandedLayer.time_range)
+        }, expandedLayer.text != null && {
+            text: structuredClone(expandedLayer.text)
+        }, expandedLayer.asset != null && {
+            asset: structuredClone(expandedLayer.asset)
+        }, expandedLayer.particle != null && {
+            particle: structuredClone(expandedLayer.particle)
+        })
+    };
+    options.targetLayerMapping.layers[expandedLayer.id] = {
+        irCompositionId: options.irCompositionId,
+        irLayerId: childMapping.irLayerId,
+        expandedSource: expandedSource
+    };
+}
+function resolveReferencedComposition(dslLayerId, layerMapping, layerById, context) {
+    var mapping = layerMapping.layers[dslLayerId];
+    var sourceLayer = mapping != null ? layerById.get(mapping.irLayerId) : undefined;
+    return (sourceLayer == null ? void 0 : sourceLayer.type) === 'precomp' ? context.compositionById.get(sourceLayer.content.compositionId) : undefined;
+}
+function sanitizeIdPart(value) {
+    return value.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+/** Convert Animation IR to editable DSL and retain source-neutral data for the reverse conversion. */ function convertIRToDSL(baselineScene) {
+    assertIRScene(baselineScene);
+    var baselineSnapshot = structuredClone(baselineScene);
+    var result = convertIRSceneEntryToDSL(baselineSnapshot);
+    expandDSLPrecompositions(result, convertIRSceneEntryToDSL);
+    validateConvertedDSL(result);
+    return result;
+}
+function validateConvertedDSL(result) {
+    var _result_diagnostics;
+    var validationResult = validateDSL(result.dsl);
+    if (validationResult.result === 'fail') {
+        throw DSLValidationError.fromValidationResult(validationResult);
+    }
+    (_result_diagnostics = result.diagnostics).push.apply(_result_diagnostics, [].concat(validationResult.warnings.map(function(warning) {
+        return _extends({
+            code: warning.code,
+            severity: 'warning',
+            action: 'unsupported',
+            path: toJSONPath(warning.path)
+        }, warning.layerId != null && {
+            sourceId: warning.layerId
+        }, {
+            message: warning.message
+        });
+    })));
+}
+function convertIRSceneEntryToDSL(baselineScene) {
+    var baselineComposition = getIRSceneEntryComposition(baselineScene);
+    var convertedLayers = convertIRLayersToDSL(baselineComposition, baselineScene.assets, baselineComposition.frameRate);
+    return assembleDSLResult(baselineScene, baselineComposition, convertedLayers.dslLayerByIRId, convertedLayers.layerMapping, convertedLayers.diagnostics);
+}
+
+function convertDSLPropertyToIRVec3(property, frameRate, fallback, includeSpatialTangents) {
+    if (includeSpatialTangents === void 0) includeSpatialTangents = false;
+    var _ref;
+    if ((property == null ? void 0 : property.a) === true) {
+        if (property.animation.length > 0) {
+            return {
+                type: 'keyframed',
+                keyframes: convertDSLCurvesToIRKeyframes(property.animation, frameRate, function(value) {
+                    return convertDSLValueToIRVec3(value, fallback);
+                }, includeSpatialTangents)
+            };
+        }
+        return {
+            type: 'static',
+            value: [].concat(fallback)
+        };
+    }
+    return {
+        type: 'static',
+        value: convertDSLValueToIRVec3((_ref = property == null ? void 0 : property.value) != null ? _ref : fallback, fallback)
+    };
+}
+function convertDSLPropertyToStaticIRVec3(property, fallback) {
+    var _ref;
+    var _property_animation_;
+    if ((property == null ? void 0 : property.a) !== true) {
+        var _ref1;
+        return {
+            type: 'static',
+            value: convertDSLValueToIRVec3((_ref1 = property == null ? void 0 : property.value) != null ? _ref1 : fallback, fallback)
+        };
+    }
+    return {
+        type: 'static',
+        value: convertDSLValueToIRVec3((_ref = (_property_animation_ = property.animation[0]) == null ? void 0 : _property_animation_.start) != null ? _ref : fallback, fallback)
+    };
+}
+function convertDSLPropertyToIRNumber(property, frameRate, fallback) {
+    var _ref;
+    if ((property == null ? void 0 : property.a) === true) {
+        if (property.animation.length > 0) {
+            return {
+                type: 'keyframed',
+                keyframes: convertDSLCurvesToIRKeyframes(property.animation, frameRate, function(value) {
+                    return convertDSLValueToIRNumber(value, fallback);
+                }, false)
+            };
+        }
+        return {
+            type: 'static',
+            value: fallback
+        };
+    }
+    return {
+        type: 'static',
+        value: convertDSLValueToIRNumber((_ref = property == null ? void 0 : property.value) != null ? _ref : fallback, fallback)
+    };
+}
+function convertDSLPropertyToIRRotation(property, frameRate, fallback) {
+    var rotationVector = convertDSLPropertyToIRVec3(property, frameRate, fallback, false);
+    return {
+        x: projectVectorAxis(rotationVector, 0),
+        y: projectVectorAxis(rotationVector, 1),
+        z: projectVectorAxis(rotationVector, 2)
+    };
+}
+function projectVectorAxis(property, axisIndex) {
+    if (property.type === 'static') {
+        var _property_value_axisIndex;
+        return {
+            type: 'static',
+            value: (_property_value_axisIndex = property.value[axisIndex]) != null ? _property_value_axisIndex : 0
+        };
+    }
+    return {
+        type: 'keyframed',
+        keyframes: property.keyframes.map(function(keyframe) {
+            var _keyframe_value_axisIndex, _keyframe_endValue_axisIndex;
+            return _extends({
+                frame: keyframe.frame,
+                value: (_keyframe_value_axisIndex = keyframe.value[axisIndex]) != null ? _keyframe_value_axisIndex : 0
+            }, keyframe.endValue != null && {
+                endValue: (_keyframe_endValue_axisIndex = keyframe.endValue[axisIndex]) != null ? _keyframe_endValue_axisIndex : 0
+            }, keyframe.hold != null && {
+                hold: keyframe.hold
+            }, keyframe.inTangent != null && {
+                inTangent: keyframe.inTangent
+            }, keyframe.outTangent != null && {
+                outTangent: keyframe.outTangent
+            });
+        })
+    };
+}
+function convertDSLCurvesToIRKeyframes(animationCurves, frameRate, convertValue, includeSpatialTangents) {
+    var keyframes = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(animationCurves), _step; !(_step = _iterator()).done;){
+        var curve = _step.value;
+        var startValue = convertValue(curve.start);
+        var endValue = convertValue(curve.end);
+        var spatialOut = includeSpatialTangents ? convertDSLSpatialTangentToIR(curve.out) : undefined;
+        var spatialIn = includeSpatialTangents ? convertDSLSpatialTangentToIR(curve.in) : undefined;
+        var startKeyframe = _extends({
+            frame: secondsToFrames(curve.t[0], frameRate),
+            value: startValue,
+            endValue: endValue,
+            outTangent: {
+                x: curve.easing[0],
+                y: curve.easing[1]
+            }
+        }, spatialOut != null && {
+            spatialOut: spatialOut
+        });
+        var endKeyframe = _extends({
+            frame: secondsToFrames(curve.t[1], frameRate),
+            value: endValue,
+            inTangent: {
+                x: curve.easing[2],
+                y: curve.easing[3]
+            }
+        }, spatialIn != null && {
+            spatialIn: spatialIn
+        });
+        appendOrMergeKeyframe(keyframes, startKeyframe);
+        appendOrMergeKeyframe(keyframes, endKeyframe);
+    }
+    return normalizeKeyframeOrder(keyframes);
+}
+function normalizeKeyframeOrder(keyframes) {
+    var sortedKeyframes = [].concat(keyframes).sort(function(left, right) {
+        return left.frame - right.frame;
+    });
+    var normalizedKeyframes = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(sortedKeyframes), _step; !(_step = _iterator()).done;){
+        var keyframe = _step.value;
+        appendOrMergeKeyframe(normalizedKeyframes, keyframe);
+    }
+    return normalizedKeyframes;
+}
+function convertDSLSpatialTangentToIR(value) {
+    if ((value == null ? void 0 : value.length) === 2) {
+        return [
+            value[0],
+            value[1]
+        ];
+    }
+    if ((value == null ? void 0 : value.length) === 3) {
+        return [
+            value[0],
+            value[1],
+            value[2]
+        ];
+    }
+    return undefined;
+}
+function appendOrMergeKeyframe(keyframes, keyframe) {
+    var previousKeyframe = keyframes[keyframes.length - 1];
+    if (previousKeyframe == null || previousKeyframe.frame !== keyframe.frame) {
+        keyframes.push(keyframe);
+        return;
+    }
+    previousKeyframe.value = keyframe.value;
+    if (keyframe.endValue != null) {
+        previousKeyframe.endValue = keyframe.endValue;
+    }
+    if (keyframe.inTangent != null) {
+        previousKeyframe.inTangent = keyframe.inTangent;
+    }
+    if (keyframe.outTangent != null) {
+        previousKeyframe.outTangent = keyframe.outTangent;
+    }
+    if (keyframe.spatialIn != null) {
+        previousKeyframe.spatialIn = keyframe.spatialIn;
+    }
+    if (keyframe.spatialOut != null) {
+        previousKeyframe.spatialOut = keyframe.spatialOut;
+    }
+}
+function convertDSLValueToIRVec3(value, fallback) {
+    if (Array.isArray(value)) {
+        return [
+            resolveFiniteNumber(value[0], fallback[0]),
+            resolveFiniteNumber(value[1], fallback[1]),
+            resolveFiniteNumber(value[2], fallback[2])
+        ];
+    }
+    return [
+        resolveFiniteNumber(value, fallback[0]),
+        fallback[1],
+        fallback[2]
+    ];
+}
+function convertDSLValueToIRNumber(value, fallback) {
+    return resolveFiniteNumber(Array.isArray(value) ? value[0] : value, fallback);
+}
+
+var DEFAULT_FONT_FAMILY = 'sans-serif';
+function normalizeDSLFontFamily(family) {
+    var normalizedFamily = family == null ? void 0 : family.trim();
+    return normalizedFamily != null && normalizedFamily !== '' ? normalizedFamily : DEFAULT_FONT_FAMILY;
+}
+function ensureSystemFontAsset(assets, family, style, weight) {
+    var normalizedFamily = normalizeDSLFontFamily(family);
+    var existingAsset = assets.find(function(asset) {
+        return asset.type === 'font' && asset.family === normalizedFamily && asset.style === style && asset.weight === weight && asset.source.kind === 'system';
+    });
+    if (existingAsset != null) {
+        return existingAsset.id;
+    }
+    var assetId = createId();
+    assets.push({
+        id: assetId,
+        type: 'font',
+        family: normalizedFamily,
+        style: style,
+        weight: weight,
+        source: {
+            kind: 'system'
+        }
+    });
+    return assetId;
+}
+function estimateTextBounds(text) {
+    var width = text.text.length * text.fontSize * 0.6 + text.letterSpacing * Math.max(text.text.length - 1, 0);
+    return {
+        width: Math.max(width, 1),
+        height: Math.max(text.fontSize * 1.2, 1)
+    };
+}
+function resolveAssetUrl(asset) {
+    if (asset.source === 'user') {
+        return asset.url;
+    }
+    if (asset.url != null && asset.url !== '') {
+        return asset.url;
+    }
+    return "data:image/svg+xml;charset=utf-8," + encodeURIComponent(asset.svg);
+}
+
+var TEXT_PROPERTY_FIELDS = [
+    'content',
+    'font',
+    'size',
+    'color',
+    'align',
+    'line_height',
+    'letter_spacing'
+];
+/**
+ * Structural, epsilon-tolerant equality between two editable-DSL properties.
+ *
+ * Used for preserved-data change detection so writeback replaces only edited
+ * fields in the IR snapshot.
+ */ function isAnimatedPropertyEqual(leftProperty, rightProperty) {
+    if (leftProperty === undefined || rightProperty === undefined) {
+        return leftProperty === rightProperty;
+    }
+    if (leftProperty.a !== rightProperty.a) {
+        return false;
+    }
+    if (!leftProperty.a) {
+        return !rightProperty.a && isNumberArrayEqual(toNumberArray(leftProperty.value), toNumberArray(rightProperty.value));
+    }
+    if (!rightProperty.a) {
+        return false;
+    }
+    if (leftProperty.animation.length !== rightProperty.animation.length) {
+        return false;
+    }
+    return leftProperty.animation.every(function(curve, curveIndex) {
+        return isAnimationCurveEqual(curve, rightProperty.animation[curveIndex]);
+    });
+}
+function collectTextPropertyChanges(baselineText, editedText) {
+    var changes = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(TEXT_PROPERTY_FIELDS), _step; !(_step = _iterator()).done;){
+        var field = _step.value;
+        var oldValue = baselineText[field];
+        var newValue = editedText[field];
+        var isEqual = field === 'color' ? isHexEqual(oldValue, newValue) : Object.is(oldValue, newValue);
+        if (!isEqual) {
+            changes.push({
+                field: field,
+                oldValue: oldValue,
+                newValue: newValue
+            });
+        }
+    }
+    return changes;
+}
+function readTextProperties(layer) {
+    return layer.type === 'text' && layer.text != null ? layer.text : undefined;
+}
+function isAssetEqual(leftAsset, rightAsset) {
+    if (leftAsset.source !== rightAsset.source) {
+        return false;
+    }
+    if (leftAsset.source === 'user' && rightAsset.source === 'user') {
+        return leftAsset.url === rightAsset.url;
+    }
+    return leftAsset.source === 'llm_svg' && rightAsset.source === 'llm_svg' && leftAsset.url === rightAsset.url && leftAsset.svg === rightAsset.svg && leftAsset.prompt === rightAsset.prompt;
+}
+function isAnimationCurveEqual(leftCurve, rightCurve) {
+    return isNumberArrayEqual(leftCurve.t, rightCurve.t) && isNumberArrayEqual(leftCurve.start, rightCurve.start) && isNumberArrayEqual(leftCurve.end, rightCurve.end) && isNumberArrayEqual(leftCurve.easing, rightCurve.easing) && isNumberArrayEqual(toNumberArray(leftCurve.out), toNumberArray(rightCurve.out)) && isNumberArrayEqual(toNumberArray(leftCurve.in), toNumberArray(rightCurve.in));
+}
+function toNumberArray(value) {
+    if (value == null) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [
+        value
+    ];
+}
+
+function convertDSLParticleToIRContent(particle, frameRate) {
+    return {
+        maxParticles: particle.options.maxCount,
+        startLifetime: mapDSLParticleExpressionToIR(particle.options.startLifetime),
+        emission: _extends({
+            rateOverTime: mapDSLParticleExpressionToIR(particle.emission.rateOverTime)
+        }, particle.emission.bursts != null && {
+            bursts: mapDSLParticleBurstsToIR(particle.emission.bursts, frameRate)
+        })
+    };
+}
+function mapDSLParticleBurstsToIR(bursts, frameRate) {
+    return bursts.map(function(burst) {
+        var _burst_cycles, _burst_interval;
+        return {
+            frameOffset: secondsToFrames(burst.time, frameRate),
+            count: burst.count,
+            cycleCount: burst.cycles === 0 ? 'infinite' : (_burst_cycles = burst.cycles) != null ? _burst_cycles : 1,
+            repeatIntervalFrames: secondsToFrames((_burst_interval = burst.interval) != null ? _burst_interval : 0, frameRate)
+        };
+    });
+}
+
+function updateIRParticle(irLayer, editedLayer, baselineLayer, frameRate, reportChange) {
+    var editedParticle = editedLayer.particle;
+    var baselineParticle = baselineLayer.particle;
+    if (irLayer.type !== 'particle' || editedParticle == null || baselineParticle == null) {
+        return;
+    }
+    if (editedParticle.options.maxCount !== baselineParticle.options.maxCount) {
+        var previousValue = irLayer.content.maxParticles;
+        irLayer.content.maxParticles = editedParticle.options.maxCount;
+        reportChange({
+            kind: 'layer',
+            op: 'set',
+            field: 'particle.options.maxCount',
+            layerId: editedLayer.id,
+            oldValue: previousValue,
+            newValue: editedParticle.options.maxCount
+        });
+    }
+    if (!isDSLNumberExpressionEqual(editedParticle.options.startLifetime, baselineParticle.options.startLifetime)) {
+        var previousValue1 = irLayer.content.startLifetime;
+        irLayer.content.startLifetime = mapDSLParticleExpressionToIR(editedParticle.options.startLifetime);
+        reportChange({
+            kind: 'layer',
+            op: 'set',
+            field: 'particle.options.startLifetime',
+            layerId: editedLayer.id,
+            oldValue: previousValue1,
+            newValue: irLayer.content.startLifetime
+        });
+    }
+    if (!isDSLNumberExpressionEqual(editedParticle.emission.rateOverTime, baselineParticle.emission.rateOverTime)) {
+        var previousValue2 = irLayer.content.emission.rateOverTime;
+        irLayer.content.emission.rateOverTime = mapDSLParticleExpressionToIR(editedParticle.emission.rateOverTime);
+        reportChange({
+            kind: 'layer',
+            op: 'set',
+            field: 'particle.emission.rateOverTime',
+            layerId: editedLayer.id,
+            oldValue: previousValue2,
+            newValue: irLayer.content.emission.rateOverTime
+        });
+    }
+    if (!areParticleBurstsEqual(editedParticle.emission.bursts, baselineParticle.emission.bursts)) {
+        var previousValue3 = irLayer.content.emission.bursts;
+        var updatedBursts = editedParticle.emission.bursts == null ? undefined : mapDSLParticleBurstsToIR(editedParticle.emission.bursts, frameRate);
+        if (updatedBursts == null) {
+            delete irLayer.content.emission.bursts;
+        } else {
+            irLayer.content.emission.bursts = updatedBursts;
+        }
+        reportChange({
+            kind: 'layer',
+            op: updatedBursts == null ? 'delete' : 'set',
+            field: 'particle.emission.bursts',
+            layerId: editedLayer.id,
+            oldValue: previousValue3,
+            newValue: updatedBursts
+        });
+    }
+}
+function areParticleBurstsEqual(left, right) {
+    if (left == null || right == null) {
+        return left === right;
+    }
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every(function(burst, index) {
+        var other = right[index];
+        return other != null && Object.is(burst.time, other.time) && Object.is(burst.count, other.count) && Object.is(burst.cycles, other.cycles) && Object.is(burst.interval, other.interval);
+    });
+}
+
+function updateIRLayer(irLayer, irScene, editedLayer, baselineLayer, dslPath, frameRate, strict, reportWarning, reportChange) {
+    var _editedLayer_parent, _baselineLayer_parent;
+    if (editedLayer.name !== baselineLayer.name) {
+        var previousName = irLayer.name;
+        irLayer.name = editedLayer.name;
+        reportChange({
+            kind: 'layer',
+            op: 'set',
+            field: 'name',
+            layerId: editedLayer.id,
+            oldValue: previousName,
+            newValue: editedLayer.name
+        });
+    }
+    if (editedLayer.type !== baselineLayer.type) {
+        reportUnsupportedLayerEdit(strict, reportWarning, 'LAYER_TYPE_CHANGE_IGNORED', "type change on layer '" + editedLayer.id + "' ('" + baselineLayer.type + "' -> '" + editedLayer.type + "') is ignored.", editedLayer.id, "" + dslPath + ".type");
+    }
+    if (editedLayer.description.self !== baselineLayer.description.self || editedLayer.description.composite !== baselineLayer.description.composite) {
+        reportUnsupportedLayerEdit(strict, reportWarning, 'LAYER_DESCRIPTION_CHANGE_IGNORED', "description change on layer '" + editedLayer.id + "' is not represented in Animation IR and is ignored.", editedLayer.id, "" + dslPath + ".description");
+    }
+    if (((_editedLayer_parent = editedLayer.parent) != null ? _editedLayer_parent : null) !== ((_baselineLayer_parent = baselineLayer.parent) != null ? _baselineLayer_parent : null)) {
+        reportUnsupportedLayerEdit(strict, reportWarning, 'PARENT_CHANGE_IGNORED', "parent change on layer '" + editedLayer.id + "' " + ("('" + baselineLayer.parent + "' -> '" + editedLayer.parent + "') is ignored in this mode."), editedLayer.id, "" + dslPath + ".parent");
+    }
+    updateIRTransform(irLayer, editedLayer, baselineLayer, frameRate, reportChange);
+    updateIRTiming(irLayer, editedLayer, baselineLayer, frameRate, reportChange);
+    updateIRText(irLayer, irScene, editedLayer, baselineLayer, reportChange);
+    updateIRParticle(irLayer, editedLayer, baselineLayer, frameRate, reportChange);
+    updateIRLocalBounds(irLayer, editedLayer, reportChange);
+    updateIRAsset(irLayer, irScene, editedLayer, baselineLayer, reportChange);
+}
+function updateIRLocalBounds(irLayer, editedLayer, reportChange) {
+    var _ref, _ref1, _ref2, _ref3, _ref4, _ref5;
+    if (irLayer.type !== 'text' && irLayer.type !== 'image' && irLayer.type !== 'particle') {
+        return;
+    }
+    var previousBounds = irLayer.localBounds;
+    var estimatedBounds = irLayer.type === 'text' ? estimateTextBounds(irLayer.content) : undefined;
+    var fallbackWidth = (_ref = (_ref1 = previousBounds == null ? void 0 : previousBounds.width) != null ? _ref1 : estimatedBounds == null ? void 0 : estimatedBounds.width) != null ? _ref : editedLayer.width;
+    var fallbackHeight = (_ref2 = (_ref3 = previousBounds == null ? void 0 : previousBounds.height) != null ? _ref3 : estimatedBounds == null ? void 0 : estimatedBounds.height) != null ? _ref2 : editedLayer.height;
+    var updatedBounds = {
+        x: (_ref4 = previousBounds == null ? void 0 : previousBounds.x) != null ? _ref4 : 0,
+        y: (_ref5 = previousBounds == null ? void 0 : previousBounds.y) != null ? _ref5 : 0,
+        width: Number.isFinite(editedLayer.width) && editedLayer.width > 0 ? editedLayer.width : fallbackWidth,
+        height: Number.isFinite(editedLayer.height) && editedLayer.height > 0 ? editedLayer.height : fallbackHeight
+    };
+    if (previousBounds != null && isScalarEqual(updatedBounds.x, previousBounds.x) && isScalarEqual(updatedBounds.y, previousBounds.y) && isScalarEqual(updatedBounds.width, previousBounds.width) && isScalarEqual(updatedBounds.height, previousBounds.height)) {
+        return;
+    }
+    irLayer.localBounds = updatedBounds;
+    reportChange({
+        kind: 'layer',
+        op: 'set',
+        field: 'localBounds',
+        layerId: editedLayer.id,
+        oldValue: previousBounds,
+        newValue: updatedBounds
+    });
+}
+function reportUnsupportedLayerEdit(strict, reportWarning, code, message, layerId, path) {
+    var formattedMessage = "[dsl-ir:preserved-data] " + message;
+    if (strict) {
+        throw new Error(formattedMessage);
+    }
+    reportWarning({
+        code: code,
+        message: formattedMessage,
+        path: path,
+        layerId: layerId
+    });
+}
+function updateIRTransform(irLayer, editedLayer, baselineLayer, frameRate, reportChange) {
+    // Create the transform lazily so no-op updates preserve the baseline shape.
+    var ensureTransform = function ensureTransform() {
+        var _irLayer, _transform;
+        return (_transform = (_irLayer = irLayer).transform) != null ? _transform : _irLayer.transform = {};
+    };
+    if (!isAnimatedPropertyEqual(withPositionZ(editedLayer.position, 0), withPositionZ(baselineLayer.position, 0))) {
+        var _irLayer_transform;
+        var sourcePosition = (_irLayer_transform = irLayer.transform) == null ? void 0 : _irLayer_transform.position;
+        var position = convertDSLPropertyToIRVec3(withPositionZ(editedLayer.position, 0), frameRate, TRANSFORM_FALLBACK.position, true);
+        if ((sourcePosition == null ? void 0 : sourcePosition.type) === 'static') {
+            if (position.type === 'static') {
+                position.value[2] = sourcePosition.value[2];
+            } else {
+                for(var _iterator = _create_for_of_iterator_helper_loose(position.keyframes), _step; !(_step = _iterator()).done;){
+                    var keyframe = _step.value;
+                    keyframe.value[2] = sourcePosition.value[2];
+                    if (keyframe.endValue != null) {
+                        keyframe.endValue[2] = sourcePosition.value[2];
+                    }
+                }
+            }
+        }
+        if ((sourcePosition == null ? void 0 : sourcePosition.type) === 'keyframed') {
+            var depths = sourcePosition.keyframes.flatMap(function(keyframe) {
+                var _keyframe_endValue;
+                return [
+                    keyframe.value[2],
+                    ((_keyframe_endValue = keyframe.endValue) != null ? _keyframe_endValue : keyframe.value)[2]
+                ];
+            });
+            var constantDepth = depths.every(function(depth) {
+                return depth === depths[0];
+            });
+            if (position.type === 'static' && constantDepth) {
+                var _depths_;
+                position.value[2] = (_depths_ = depths[0]) != null ? _depths_ : 0;
+            } else if (position.type === 'keyframed') {
+                var _loop = function() {
+                    var keyframe = _step1.value;
+                    var _ref, _ref1;
+                    var source = sourcePosition.keyframes.find(function(candidate) {
+                        return candidate.frame === keyframe.frame;
+                    });
+                    if (source == null && !constantDepth) {
+                        throw new Error('[dsl-ir] Position timing edits on layers with animated source depth are unsupported.');
+                    }
+                    keyframe.value[2] = (_ref = (_ref1 = source == null ? void 0 : source.value[2]) != null ? _ref1 : depths[0]) != null ? _ref : 0;
+                    if (keyframe.endValue != null) {
+                        var _ref2, _ref3, _ref4;
+                        var _this;
+                        keyframe.endValue[2] = (_ref2 = (_ref3 = (_this = (_ref4 = source == null ? void 0 : source.endValue) != null ? _ref4 : source == null ? void 0 : source.value) == null ? void 0 : _this[2]) != null ? _ref3 : depths[0]) != null ? _ref2 : 0;
+                    }
+                };
+                for(var _iterator1 = _create_for_of_iterator_helper_loose(position.keyframes), _step1; !(_step1 = _iterator1()).done;)_loop();
+            } else {
+                throw new Error('[dsl-ir] Replacing animated source depth with static position is unsupported.');
+            }
+        }
+        ensureTransform().position = position;
+        reportChange({
+            kind: 'transform',
+            op: 'set',
+            field: 'position',
+            layerId: editedLayer.id,
+            oldValue: baselineLayer.position,
+            newValue: editedLayer.position
+        });
+    }
+    if (editedLayer.rotation !== undefined && !isAnimatedPropertyEqual(editedLayer.rotation, baselineLayer.rotation)) {
+        var transform = ensureTransform();
+        transform.rotation = convertDSLPropertyToIRRotation(editedLayer.rotation, frameRate, TRANSFORM_FALLBACK.rotation);
+        reportChange({
+            kind: 'transform',
+            op: 'set',
+            field: 'rotation',
+            layerId: editedLayer.id,
+            oldValue: baselineLayer.rotation,
+            newValue: editedLayer.rotation
+        });
+    }
+    if (editedLayer.scale !== undefined && !isAnimatedPropertyEqual(editedLayer.scale, baselineLayer.scale)) {
+        ensureTransform().scale = convertDSLPropertyToIRVec3(editedLayer.scale, frameRate, TRANSFORM_FALLBACK.scale, false);
+        reportChange({
+            kind: 'transform',
+            op: 'set',
+            field: 'scale',
+            layerId: editedLayer.id,
+            oldValue: baselineLayer.scale,
+            newValue: editedLayer.scale
+        });
+    }
+    if (editedLayer.anchor !== undefined && !isAnimatedPropertyEqual(editedLayer.anchor, baselineLayer.anchor)) {
+        ensureTransform().anchor = convertDSLPropertyToStaticIRVec3(editedLayer.anchor, TRANSFORM_FALLBACK.anchor);
+        reportChange({
+            kind: 'transform',
+            op: 'set',
+            field: 'anchor',
+            layerId: editedLayer.id,
+            oldValue: baselineLayer.anchor,
+            newValue: editedLayer.anchor
+        });
+    }
+    if (editedLayer.opacity !== undefined && !isAnimatedPropertyEqual(editedLayer.opacity, baselineLayer.opacity)) {
+        ensureTransform().opacity = convertDSLPropertyToIRNumber(editedLayer.opacity, frameRate, TRANSFORM_FALLBACK.opacity);
+        reportChange({
+            kind: 'transform',
+            op: 'set',
+            field: 'opacity',
+            layerId: editedLayer.id,
+            oldValue: baselineLayer.opacity,
+            newValue: editedLayer.opacity
+        });
+    }
+}
+function updateIRTiming(irLayer, editedLayer, baselineLayer, frameRate, reportChange) {
+    if (editedLayer.time_range === undefined || baselineLayer.time_range !== undefined && isScalarEqual(editedLayer.time_range[0], baselineLayer.time_range[0]) && isScalarEqual(editedLayer.time_range[1], baselineLayer.time_range[1])) {
+        return;
+    }
+    var previousTime = irLayer.time;
+    irLayer.time = _extends({}, irLayer.time, {
+        inFrame: editedLayer.time_range[0] * frameRate,
+        outFrame: editedLayer.time_range[1] * frameRate
+    });
+    reportChange({
+        kind: 'timing',
+        op: 'set',
+        field: 'time_range',
+        layerId: editedLayer.id,
+        oldValue: previousTime,
+        newValue: editedLayer.time_range
+    });
+}
+function updateIRText(irLayer, irScene, editedLayer, baselineLayer, reportChange) {
+    var _normalizedEditedText_font;
+    var editedText = readTextProperties(editedLayer);
+    var baselineText = readTextProperties(baselineLayer);
+    if (irLayer.type !== 'text' || editedText == null) {
+        return;
+    }
+    var normalizedEditedText = normalizeTextPropertiesForIR(editedText, irLayer.content);
+    var textChanges = baselineText != null ? collectTextPropertyChanges(baselineText, normalizedEditedText) : [];
+    if (baselineText != null && textChanges.length === 0) {
+        return;
+    }
+    var previousText = irLayer.content;
+    var currentFontAsset = resolveFontAsset(irScene, irLayer.content.fontAssetId);
+    var fontAssetId = baselineText == null || textChanges.some(function(change) {
+        return change.field === 'font';
+    }) ? ensureSystemFontAsset(irScene.assets, (_normalizedEditedText_font = normalizedEditedText.font) != null ? _normalizedEditedText_font : currentFontAsset.family, currentFontAsset.style, currentFontAsset.weight) : irLayer.content.fontAssetId;
+    irLayer.content = buildUpdatedTextData(irLayer.content, normalizedEditedText, fontAssetId);
+    if (baselineText == null) {
+        reportChange({
+            kind: 'text',
+            op: 'set',
+            field: 'text',
+            layerId: editedLayer.id,
+            oldValue: previousText,
+            newValue: normalizedEditedText
+        });
+    } else {
+        for(var _iterator = _create_for_of_iterator_helper_loose(textChanges), _step; !(_step = _iterator()).done;){
+            var _step_value = _step.value, field = _step_value.field, oldValue = _step_value.oldValue, newValue = _step_value.newValue;
+            reportChange({
+                kind: 'text',
+                op: 'set',
+                field: "text." + field,
+                layerId: editedLayer.id,
+                oldValue: oldValue,
+                newValue: newValue
+            });
+        }
+    }
+}
+function normalizeTextPropertiesForIR(text, currentText) {
+    var currentFontSize = Number.isFinite(currentText.fontSize) && currentText.fontSize > 0 ? currentText.fontSize : 16;
+    var fontSize = Number.isFinite(text.size) && text.size > 0 ? text.size : currentFontSize;
+    var lineHeight = text.line_height != null && Number.isFinite(text.line_height) && text.line_height > 0 ? text.line_height : fontSize;
+    var fontFamily = text.font != null ? normalizeDSLFontFamily(text.font) : undefined;
+    return _extends({}, text, {
+        size: fontSize,
+        line_height: lineHeight
+    }, fontFamily != null && {
+        font: fontFamily
+    });
+}
+function buildUpdatedTextData(currentText, editedText, fontAssetId) {
+    var _editedText_align, _editedText_letter_spacing, _editedText_line_height;
+    return {
+        text: editedText.content,
+        fontAssetId: fontAssetId,
+        fontSize: editedText.size,
+        color: hexToIRColor(editedText.color),
+        textAlign: (_editedText_align = editedText.align) != null ? _editedText_align : currentText.textAlign,
+        letterSpacing: (_editedText_letter_spacing = editedText.letter_spacing) != null ? _editedText_letter_spacing : currentText.letterSpacing,
+        lineHeight: (_editedText_line_height = editedText.line_height) != null ? _editedText_line_height : currentText.lineHeight
+    };
+}
+function resolveFontAsset(irScene, fontAssetId) {
+    var fontAsset = irScene.assets.find(function(asset) {
+        return asset.type === 'font' && asset.id === fontAssetId;
+    });
+    if (fontAsset == null) {
+        throw new TypeError("[dsl-ir] Text references a missing Font Asset: " + fontAssetId);
+    }
+    return fontAsset;
+}
+function updateIRAsset(irLayer, irScene, editedLayer, baselineLayer, reportChange) {
+    if (irLayer.type !== 'image' || editedLayer.asset == null) {
+        return;
+    }
+    var imageAsset = irScene.assets.find(function(asset) {
+        return asset.type === 'image' && asset.id === irLayer.content.assetId;
+    });
+    if (imageAsset == null) {
+        return;
+    }
+    if (baselineLayer.asset != null && isAssetEqual(editedLayer.asset, baselineLayer.asset)) {
+        return;
+    }
+    var editedUrl = resolveAssetUrl(editedLayer.asset);
+    var baselineUrl = baselineLayer.asset != null ? resolveAssetUrl(baselineLayer.asset) : undefined;
+    if (editedUrl !== '' && editedUrl !== baselineUrl) {
+        var previousUrl = getIRResourceSourceUrl(imageAsset.source);
+        if (countImageAssetReferences(irScene, imageAsset.id) > 1) {
+            var clonedAssetId = createAvailableRecombineAssetId(irScene);
+            imageAsset = _extends({}, imageAsset, {
+                id: clonedAssetId
+            });
+            irScene.assets.push(imageAsset);
+            irLayer.content.assetId = clonedAssetId;
+        }
+        imageAsset.source = createIRResourceSource(editedUrl);
+        reportChange({
+            kind: 'asset',
+            op: 'set',
+            field: 'asset.url',
+            layerId: editedLayer.id,
+            oldValue: previousUrl,
+            newValue: editedUrl
+        });
+    }
+}
+function countImageAssetReferences(irScene, assetId) {
+    return irScene.compositions.reduce(function(count, composition) {
+        return count + composition.layers.filter(function(layer) {
+            return layer.type === 'image' && layer.content.assetId === assetId;
+        }).length;
+    }, 0);
+}
+function createAvailableRecombineAssetId(irScene) {
+    var existingAssetIdSet = new Set(irScene.assets.map(function(asset) {
+        return asset.id;
+    }));
+    while(true){
+        var candidate = createId();
+        if (!existingAssetIdSet.has(candidate)) {
+            return candidate;
+        }
+    }
+}
+
+/** Apply edited sibling order without changing parent relationships. */ function updateLayerOrder(updatedIR, editedLayers, irLayerIdByEditedLayer, reportChange, rootDSLParentId) {
+    var irLayerById = new Map(updatedIR.layers.map(function(layer) {
+        return [
+            layer.id,
+            layer
+        ];
+    }));
+    var childIRLayerIdsByParentIRLayerId = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(updatedIR.layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        var parentLayerId = layer.parentId;
+        if (parentLayerId != null) {
+            var _childIRLayerIdsByParentIRLayerId_get;
+            var childLayerIds = (_childIRLayerIdsByParentIRLayerId_get = childIRLayerIdsByParentIRLayerId.get(parentLayerId)) != null ? _childIRLayerIdsByParentIRLayerId_get : [];
+            childLayerIds.push(layer.id);
+            childIRLayerIdsByParentIRLayerId.set(parentLayerId, childLayerIds);
+        }
+    }
+    updateSiblingGroups(editedLayers, undefined, {
+        updatedIR: updatedIR,
+        irLayerIdByEditedLayer: irLayerIdByEditedLayer,
+        irLayerById: irLayerById,
+        childIRLayerIdsByParentIRLayerId: childIRLayerIdsByParentIRLayerId,
+        reportChange: reportChange,
+        rootDSLParentId: rootDSLParentId
+    });
+}
+function updateSiblingGroups(siblingLayers, parentLayer, context) {
+    updateIRSiblingOrder(siblingLayers, parentLayer, context);
+    for(var _iterator = _create_for_of_iterator_helper_loose(siblingLayers), _step; !(_step = _iterator()).done;){
+        var sibling = _step.value;
+        var _sibling_children;
+        updateSiblingGroups((_sibling_children = sibling.children) != null ? _sibling_children : [], sibling, context);
+    }
+}
+function updateIRSiblingOrder(siblingLayers, parentLayer, context) {
+    var _ref, _ref1, _ref2;
+    var parentIRLayerId = parentLayer != null ? context.irLayerIdByEditedLayer.get(parentLayer) : undefined;
+    if (parentLayer != null && parentIRLayerId == null) {
+        return;
+    }
+    var expectedParentId = (_ref = (_ref1 = parentLayer == null ? void 0 : parentLayer.id) != null ? _ref1 : context.rootDSLParentId) != null ? _ref : null;
+    var orderedSiblings = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(siblingLayers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        var _layer_parent;
+        var irLayerId = context.irLayerIdByEditedLayer.get(layer);
+        if (irLayerId == null) {
+            continue;
+        }
+        var irLayer = context.irLayerById.get(irLayerId);
+        if (irLayer == null || ((_layer_parent = layer.parent) != null ? _layer_parent : null) !== expectedParentId || irLayer.parentId !== parentIRLayerId) {
+            continue;
+        }
+        orderedSiblings.push({
+            layer: layer,
+            subtreeLayerIdSet: collectIRSubtreeLayerIds(irLayerId, context.childIRLayerIdsByParentIRLayerId)
+        });
+    }
+    if (orderedSiblings.length < 2) {
+        return;
+    }
+    var ownerByIRLayerId = new Map();
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(orderedSiblings), _step1; !(_step1 = _iterator1()).done;){
+        var sibling = _step1.value;
+        for(var _iterator2 = _create_for_of_iterator_helper_loose(sibling.subtreeLayerIdSet), _step2; !(_step2 = _iterator2()).done;){
+            var irLayerId1 = _step2.value;
+            ownerByIRLayerId.set(irLayerId1, sibling);
+        }
+    }
+    var currentIROrder = collectOwnerOrder(context.updatedIR.layers, function(layer) {
+        return ownerByIRLayerId.get(layer.id);
+    });
+    var currentDSLOrder = [].concat(currentIROrder).reverse();
+    orderedSiblings.sort(function(left, right) {
+        return getLayerStackingOrder(right.layer) - getLayerStackingOrder(left.layer) || currentDSLOrder.indexOf(left) - currentDSLOrder.indexOf(right);
+    });
+    if (currentDSLOrder.length !== orderedSiblings.length || isOwnerOrderEqual(currentDSLOrder, orderedSiblings)) {
+        return;
+    }
+    var reorderedLayers = reorderOwnedEntries(context.updatedIR.layers, [].concat(orderedSiblings).reverse(), function(layer) {
+        return ownerByIRLayerId.get(layer.id);
+    });
+    if (reorderedLayers == null) {
+        return;
+    }
+    context.updatedIR.layers = reorderedLayers;
+    var changedParentLayerId = (_ref2 = parentLayer == null ? void 0 : parentLayer.id) != null ? _ref2 : context.rootDSLParentId;
+    context.reportChange(_extends({
+        kind: 'layer',
+        op: 'set',
+        field: 'order'
+    }, changedParentLayerId != null && {
+        layerId: changedParentLayerId
+    }, {
+        oldValue: currentDSLOrder.map(function(sibling) {
+            return sibling.layer.id;
+        }),
+        newValue: orderedSiblings.map(function(sibling) {
+            return sibling.layer.id;
+        })
+    }));
+}
+function collectIRSubtreeLayerIds(rootLayerId, childIRLayerIdsByParentIRLayerId, subtreeLayerIdSet) {
+    if (subtreeLayerIdSet === void 0) subtreeLayerIdSet = new Set();
+    var _childIRLayerIdsByParentIRLayerId_get;
+    if (subtreeLayerIdSet.has(rootLayerId)) {
+        return subtreeLayerIdSet;
+    }
+    subtreeLayerIdSet.add(rootLayerId);
+    for(var _iterator = _create_for_of_iterator_helper_loose((_childIRLayerIdsByParentIRLayerId_get = childIRLayerIdsByParentIRLayerId.get(rootLayerId)) != null ? _childIRLayerIdsByParentIRLayerId_get : []), _step; !(_step = _iterator()).done;){
+        var childLayerId = _step.value;
+        collectIRSubtreeLayerIds(childLayerId, childIRLayerIdsByParentIRLayerId, subtreeLayerIdSet);
+    }
+    return subtreeLayerIdSet;
+}
+function collectOwnerOrder(entries, resolveOwner) {
+    var owners = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(entries), _step; !(_step = _iterator()).done;){
+        var entry = _step.value;
+        var owner = resolveOwner(entry);
+        if (owner != null && !owners.includes(owner)) {
+            owners.push(owner);
+        }
+    }
+    return owners;
+}
+function isOwnerOrderEqual(left, right) {
+    return left.length === right.length && left.every(function(owner, index) {
+        return owner === right[index];
+    });
+}
+function reorderOwnedEntries(entries, orderedOwners, resolveOwner) {
+    var entriesByOwner = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(orderedOwners), _step; !(_step = _iterator()).done;){
+        var owner = _step.value;
+        entriesByOwner.set(owner, []);
+    }
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(entries), _step1; !(_step1 = _iterator1()).done;){
+        var entry = _step1.value;
+        var owner1 = resolveOwner(entry);
+        if (owner1 != null) {
+            var _entriesByOwner_get;
+            (_entriesByOwner_get = entriesByOwner.get(owner1)) == null ? void 0 : _entriesByOwner_get.push(entry);
+        }
+    }
+    if (orderedOwners.some(function(owner) {
+        var _ref;
+        var _entriesByOwner_get;
+        return ((_ref = (_entriesByOwner_get = entriesByOwner.get(owner)) == null ? void 0 : _entriesByOwner_get.length) != null ? _ref : 0) === 0;
+    })) {
+        return undefined;
+    }
+    var reorderedOwnedEntries = orderedOwners.flatMap(function(owner) {
+        var _entriesByOwner_get;
+        return (_entriesByOwner_get = entriesByOwner.get(owner)) != null ? _entriesByOwner_get : [];
+    });
+    var reorderedIndex = 0;
+    return entries.map(function(entry) {
+        if (resolveOwner(entry) == null) {
+            return entry;
+        }
+        return reorderedOwnedEntries[reorderedIndex++];
+    });
+}
+
+/** Apply previously validated DSL to a clone of the baseline IR. */ function updateValidatedIRFromDSL(baselineScene, editedDocument, layerMapping, options) {
+    var _loop = function() {
+        var _step_value = _step3.value, baselineLayer = _step_value.layer, path = _step_value.path;
+        var _layerMapping_layers_baselineLayer_id;
+        var irLayerId = (_layerMapping_layers_baselineLayer_id = layerMapping.layers[baselineLayer.id]) == null ? void 0 : _layerMapping_layers_baselineLayer_id.irLayerId;
+        if (irLayerId == null) {
+            return "continue";
+        }
+        var editedLayer = matchEditedLayer(baselineLayer, path, {
+            editedLayerById: editedLayerById,
+            editedLayerByPath: editedLayerByPath,
+            matchedEditedLayerSet: matchedEditedLayerSet
+        });
+        if (editedLayer == null) {
+            var _layerMapping_layers_baselineLayer_id1;
+            var expandedSource = (_layerMapping_layers_baselineLayer_id1 = layerMapping.layers[baselineLayer.id]) == null ? void 0 : _layerMapping_layers_baselineLayer_id1.expandedSource;
+            var expandedComposition = expandedSource != null ? compositionById.get(expandedSource.irCompositionId) : undefined;
+            if (expandedSource != null && (expandedComposition == null ? void 0 : expandedComposition.layers.some(function(layer) {
+                return layer.id === irLayerId;
+            })) === true) {
+                var _deletedExpandedIRLayerIdsByCompositionId_get;
+                var deletedIds = (_deletedExpandedIRLayerIdsByCompositionId_get = deletedExpandedIRLayerIdsByCompositionId.get(expandedSource.irCompositionId)) != null ? _deletedExpandedIRLayerIdsByCompositionId_get : new Set();
+                deletedIds.add(irLayerId);
+                deletedExpandedIRLayerIdsByCompositionId.set(expandedSource.irCompositionId, deletedIds);
+                semanticallyDeletedExpandedDSLIds.add(baselineLayer.id);
+            } else {
+                deletedIRLayerIdSet.add(irLayerId);
+            }
+            reportChange({
+                kind: 'layer',
+                op: 'delete',
+                layerId: baselineLayer.id
+            });
+            return "continue";
+        }
+        var irLayer = clonedLayerByIRId.get(irLayerId);
+        if (irLayer == null) {
+            return "continue";
+        }
+        matchedEditedLayerSet.add(editedLayer);
+        irLayerIdByEditedLayer.set(editedLayer, irLayerId);
+        updateIRLayer(irLayer, updatedScene, editedLayer, baselineLayer, path, targetFrameRate, strict, reportWarning, reportChange);
+    }, _loop1 = function() {
+        var editedLayer = _step4.value;
+        var _editedPathByLayer_get;
+        var _layerMapping_layers_editedLayer_id;
+        if (matchedEditedLayerSet.has(editedLayer)) {
+            return "continue";
+        }
+        var expandedSource = (_layerMapping_layers_editedLayer_id = layerMapping.layers[editedLayer.id]) == null ? void 0 : _layerMapping_layers_editedLayer_id.expandedSource;
+        if (expandedSource != null) {
+            var mappingEntry = layerMapping.layers[editedLayer.id];
+            var targetComposition = compositionById.get(expandedSource.irCompositionId);
+            var targetLayer = (mappingEntry == null ? void 0 : mappingEntry.irLayerId) != null ? targetComposition == null ? void 0 : targetComposition.layers.find(function(layer) {
+                return layer.id === mappingEntry.irLayerId;
+            }) : undefined;
+            if (targetComposition != null && targetLayer != null && (mappingEntry == null ? void 0 : mappingEntry.irLayerId) != null) {
+                var _editedPathByLayer_get1;
+                updateIRLayer(targetLayer, updatedScene, editedLayer, buildExpandedBaselineLayer(editedLayer, expandedSource), (_editedPathByLayer_get1 = editedPathByLayer.get(editedLayer)) != null ? _editedPathByLayer_get1 : '$.layers', targetFrameRate, strict, reportWarning, reportChange);
+                expandedIRLayerIdByEditedLayer.set(editedLayer, mappingEntry.irLayerId);
+                editedExpandedCompositionById.set(expandedSource.irCompositionId, targetComposition);
+            }
+            return "continue";
+        }
+        var message = "[dsl-ir:preserved-data] edited layer '" + editedLayer.id + "' matches no baseline scene layer; new layers are not supported in this mode.";
+        if (strict) {
+            throw new Error(message);
+        }
+        reportWarning({
+            code: 'INVENTED_LAYER',
+            message: message,
+            path: (_editedPathByLayer_get = editedPathByLayer.get(editedLayer)) != null ? _editedPathByLayer_get : '$.layers',
+            layerId: editedLayer.id
+        });
+    }, _loop2 = function() {
+        var _step_value = _step5.value, dslLayerId = _step_value[0], mappingEntry = _step_value[1];
+        var _deletedExpandedIRLayerIdsByCompositionId_get;
+        var expandedSource = mappingEntry.expandedSource;
+        var irLayerId = mappingEntry.irLayerId;
+        if (expandedSource == null || irLayerId == null || editedLayerById.has(dslLayerId) || !editedLayerById.has(expandedSource.parentLayerId) || semanticallyDeletedExpandedDSLIds.has(dslLayerId)) {
+            return "continue";
+        }
+        var composition = compositionById.get(expandedSource.irCompositionId);
+        if ((composition == null ? void 0 : composition.layers.some(function(layer) {
+            return layer.id === irLayerId;
+        })) !== true) {
+            return "continue";
+        }
+        var deletedIds = (_deletedExpandedIRLayerIdsByCompositionId_get = deletedExpandedIRLayerIdsByCompositionId.get(expandedSource.irCompositionId)) != null ? _deletedExpandedIRLayerIdsByCompositionId_get : new Set();
+        deletedIds.add(irLayerId);
+        deletedExpandedIRLayerIdsByCompositionId.set(expandedSource.irCompositionId, deletedIds);
+        semanticallyDeletedExpandedDSLIds.add(dslLayerId);
+        reportChange({
+            kind: 'layer',
+            op: 'delete',
+            layerId: dslLayerId
+        });
+    };
+    if (options === void 0) options = {};
+    var strict = options.strict === true;
+    var reportWarning = createWarningReporter(options.onWarning);
+    var reportChange = createChangeReporter(options.onChange);
+    var baselineDSLResult = convertIRToDSL(baselineScene);
+    var baselineDSL = baselineDSLResult.dsl;
+    var editedDSL = structuredClone(editedDocument);
+    var updatedScene = structuredClone(baselineScene);
+    var updatedIR = getIRSceneEntryComposition(updatedScene);
+    var compositionById = new Map(updatedScene.compositions.map(function(composition) {
+        return [
+            composition.id,
+            composition
+        ];
+    }));
+    var targetFrameRate = editedDSL.meta.fps;
+    // Reframe the clone first; comparisons still use the untouched baseline DSL in seconds.
+    for(var _iterator = _create_for_of_iterator_helper_loose(updatedScene.compositions), _step; !(_step = _iterator()).done;){
+        var composition = _step.value;
+        updateIRFrameRate(composition, targetFrameRate, reportChange, composition.id === updatedIR.id);
+    }
+    updateIRComposition(updatedIR, editedDSL, baselineDSL, targetFrameRate, reportChange);
+    var baselineLayers = collectLayersWithPaths(baselineDSL.layers);
+    var editedLayerEntries = collectLayersWithPaths(editedDSL.layers);
+    var editedLayers = editedLayerEntries.map(function(entry) {
+        return entry.layer;
+    });
+    var editedPathByLayer = new Map(editedLayerEntries.map(function(entry) {
+        return [
+            entry.layer,
+            entry.path
+        ];
+    }));
+    var editedLayerById = new Map();
+    var editedLayerByPath = new Map();
+    for(var _iterator1 = _create_for_of_iterator_helper_loose(editedLayerEntries), _step1; !(_step1 = _iterator1()).done;){
+        var _step_value = _step1.value, layer = _step_value.layer, path = _step_value.path;
+        var previousEntry = editedLayerById.get(layer.id);
+        if (previousEntry != null) {
+            throw new Error("[dsl-ir:preserved-data] Duplicate layer id '" + layer.id + "'; earlier occurrence at path '" + previousEntry.path + "'.");
+        }
+        editedLayerById.set(layer.id, {
+            layer: layer,
+            path: path
+        });
+        editedLayerByPath.set(path, layer);
+    }
+    var clonedLayerByIRId = new Map();
+    for(var _iterator2 = _create_for_of_iterator_helper_loose(updatedIR.layers), _step2; !(_step2 = _iterator2()).done;){
+        var layer1 = _step2.value;
+        clonedLayerByIRId.set(layer1.id, layer1);
+    }
+    // Track object identity because edited IDs may have changed.
+    var matchedEditedLayerSet = new Set();
+    var irLayerIdByEditedLayer = new Map();
+    var deletedIRLayerIdSet = new Set();
+    var deletedExpandedIRLayerIdsByCompositionId = new Map();
+    var semanticallyDeletedExpandedDSLIds = new Set();
+    for(var _iterator3 = _create_for_of_iterator_helper_loose(baselineLayers), _step3; !(_step3 = _iterator3()).done;)_loop();
+    var expandedIRLayerIdByEditedLayer = new Map();
+    var editedExpandedCompositionById = new Map();
+    for(var _iterator4 = _create_for_of_iterator_helper_loose(editedLayers), _step4; !(_step4 = _iterator4()).done;)_loop1();
+    for(var _iterator5 = _create_for_of_iterator_helper_loose(Object.entries(layerMapping.layers)), _step5; !(_step5 = _iterator5()).done;)_loop2();
+    removeIRLayers(updatedIR, deletedIRLayerIdSet, reportChange);
+    for(var _iterator6 = _create_for_of_iterator_helper_loose(deletedExpandedIRLayerIdsByCompositionId), _step6; !(_step6 = _iterator6()).done;){
+        var _step_value1 = _step6.value, compositionId = _step_value1[0], deletedLayerIds = _step_value1[1];
+        var composition1 = compositionById.get(compositionId);
+        if (composition1 != null) {
+            removeIRLayers(composition1, deletedLayerIds, reportChange);
+        }
+    }
+    updateLayerOrder(updatedIR, editedDSL.layers, irLayerIdByEditedLayer, reportChange);
+    updateExpandedCompositionLayerOrder(editedDSL.layers, editedExpandedCompositionById, layerMapping, expandedIRLayerIdByEditedLayer, reportChange);
+    assertIRScene(updatedScene);
+    return updatedScene;
+}
+function buildExpandedBaselineLayer(editedLayer, expandedSource) {
+    var baseline = expandedSource.baselineLayer;
+    var transform = expandedSource.baselineTransform;
+    if (baseline == null || transform == null) {
+        return structuredClone(editedLayer);
+    }
+    return _extends({}, structuredClone(editedLayer), {
+        name: baseline.name,
+        type: baseline.type,
+        width: baseline.width,
+        height: baseline.height,
+        description: structuredClone(baseline.description),
+        parent: baseline.parent,
+        time_range: structuredClone(baseline.timeRange),
+        position: structuredClone(transform.position),
+        scale: structuredClone(transform.scale),
+        rotation: structuredClone(transform.rotation),
+        anchor: structuredClone(transform.anchor),
+        opacity: structuredClone(transform.opacity)
+    }, baseline.text != null && {
+        text: structuredClone(baseline.text)
+    }, baseline.asset != null && {
+        asset: structuredClone(baseline.asset)
+    }, baseline.particle != null && {
+        particle: structuredClone(baseline.particle)
+    });
+}
+function updateExpandedCompositionLayerOrder(layers, compositionById, layerMapping, irLayerIdByEditedLayer, reportChange) {
+    for(var _iterator = _create_for_of_iterator_helper_loose(layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        var _layer_children;
+        var children = (_layer_children = layer.children) != null ? _layer_children : [];
+        var firstExpandedSource = children.map(function(child) {
+            var _layerMapping_layers_child_id;
+            return (_layerMapping_layers_child_id = layerMapping.layers[child.id]) == null ? void 0 : _layerMapping_layers_child_id.expandedSource;
+        }).find(function(source) {
+            return source != null;
+        });
+        var targetComposition = firstExpandedSource != null ? compositionById.get(firstExpandedSource.irCompositionId) : undefined;
+        if (targetComposition != null) {
+            updateLayerOrder(targetComposition, children, irLayerIdByEditedLayer, reportChange, layer.id);
+        }
+        updateExpandedCompositionLayerOrder(children, compositionById, layerMapping, irLayerIdByEditedLayer, reportChange);
+    }
+}
+function matchEditedLayer(baselineLayer, path, context) {
+    var _context_editedLayerById_get;
+    var layerById = (_context_editedLayerById_get = context.editedLayerById.get(baselineLayer.id)) == null ? void 0 : _context_editedLayerById_get.layer;
+    if (layerById != null) {
+        return layerById;
+    }
+    var layerByPath = context.editedLayerByPath.get(path);
+    if (layerByPath != null && !context.matchedEditedLayerSet.has(layerByPath) && layerByPath.name === baselineLayer.name) {
+        return layerByPath;
+    }
+    return undefined;
+}
+function collectLayersWithPaths(layers, prefix, entries) {
+    if (prefix === void 0) prefix = '$.layers';
+    if (entries === void 0) entries = [];
+    layers.forEach(function(layer, index) {
+        var _layer_children;
+        var path = prefix + "[" + index + "]";
+        entries.push({
+            layer: layer,
+            path: path
+        });
+        collectLayersWithPaths((_layer_children = layer.children) != null ? _layer_children : [], "" + path + ".children", entries);
+    });
+    return entries;
+}
+function createWarningReporter(onWarning) {
+    if (onWarning == null) {
+        return function() {};
+    }
+    return function(param) {
+        var code = param.code, message = param.message, path = param.path, layerId = param.layerId;
+        var warning = {
+            level: 'warning',
+            code: code,
+            message: message
+        };
+        if (path != null) {
+            warning.path = path;
+        }
+        if (layerId != null) {
+            warning.layerId = layerId;
+        }
+        onWarning(warning);
+    };
+}
+function createChangeReporter(onChange) {
+    if (onChange == null) {
+        return function() {};
+    }
+    return function(change) {
+        var normalizedChange = _extends({
+            kind: change.kind,
+            op: change.op
+        }, change.field != null && {
+            field: change.field
+        }, change.layerId != null && {
+            layerId: change.layerId
+        }, change.oldValue !== undefined && {
+            oldValue: structuredClone(change.oldValue)
+        }, change.newValue !== undefined && {
+            newValue: structuredClone(change.newValue)
+        }, change.note != null && {
+            note: change.note
+        });
+        onChange(normalizedChange);
+    };
+}
+function removeIRLayers(updatedIR, deletedIRLayerIdSet, reportChange) {
+    if (deletedIRLayerIdSet.size === 0) {
+        return;
+    }
+    updatedIR.layers = updatedIR.layers.filter(function(layer) {
+        return !deletedIRLayerIdSet.has(layer.id);
+    });
+    for(var _iterator = _create_for_of_iterator_helper_loose(updatedIR.layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        if (layer.parentId != null && deletedIRLayerIdSet.has(layer.parentId)) {
+            delete layer.parentId;
+            reportChange({
+                kind: 'layer',
+                op: 'delete',
+                field: 'parentId',
+                layerId: layer.id
+            });
+        }
+        if (layer.matte != null && deletedIRLayerIdSet.has(layer.matte.sourceLayerId)) {
+            var previousMatte = layer.matte;
+            delete layer.matte;
+            reportChange({
+                kind: 'layer',
+                op: 'delete',
+                field: 'matte',
+                layerId: layer.id,
+                oldValue: previousMatte
+            });
+        }
+    }
+}
+/** Scale frame-based IR timing so a frame-rate change preserves playback duration. */ function updateIRFrameRate(updatedIR, targetFrameRate, reportChange, reportCompositionChange) {
+    if (reportCompositionChange === void 0) reportCompositionChange = true;
+    var previousFrameRate = updatedIR.frameRate;
+    if (isScalarEqual(targetFrameRate, previousFrameRate)) {
+        return;
+    }
+    var frameRateScale = targetFrameRate / previousFrameRate;
+    updatedIR.frameRate = targetFrameRate;
+    updatedIR.inPoint *= frameRateScale;
+    updatedIR.outPoint *= frameRateScale;
+    for(var _iterator = _create_for_of_iterator_helper_loose(updatedIR.layers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        var _layer_transform, _layer_transform1, _layer_transform_rotation, _layer_transform2, _layer_transform_rotation1, _layer_transform3, _layer_transform_rotation2, _layer_transform4, _layer_transform5;
+        layer.time.inFrame *= frameRateScale;
+        layer.time.outFrame *= frameRateScale;
+        if (layer.type === 'precomp' && layer.time.sourceStartFrame != null) {
+            layer.time.sourceStartFrame *= frameRateScale;
+        }
+        reframeAnimatedProperty((_layer_transform = layer.transform) == null ? void 0 : _layer_transform.position, frameRateScale);
+        reframeAnimatedProperty((_layer_transform1 = layer.transform) == null ? void 0 : _layer_transform1.scale, frameRateScale);
+        reframeAnimatedProperty((_layer_transform2 = layer.transform) == null ? void 0 : (_layer_transform_rotation = _layer_transform2.rotation) == null ? void 0 : _layer_transform_rotation.x, frameRateScale);
+        reframeAnimatedProperty((_layer_transform3 = layer.transform) == null ? void 0 : (_layer_transform_rotation1 = _layer_transform3.rotation) == null ? void 0 : _layer_transform_rotation1.y, frameRateScale);
+        reframeAnimatedProperty((_layer_transform4 = layer.transform) == null ? void 0 : (_layer_transform_rotation2 = _layer_transform4.rotation) == null ? void 0 : _layer_transform_rotation2.z, frameRateScale);
+        reframeAnimatedProperty((_layer_transform5 = layer.transform) == null ? void 0 : _layer_transform5.opacity, frameRateScale);
+        if (layer.type === 'particle') {
+            var _layer_content_emission_bursts;
+            for(var _iterator1 = _create_for_of_iterator_helper_loose((_layer_content_emission_bursts = layer.content.emission.bursts) != null ? _layer_content_emission_bursts : []), _step1; !(_step1 = _iterator1()).done;){
+                var burst = _step1.value;
+                burst.frameOffset *= frameRateScale;
+                burst.repeatIntervalFrames *= frameRateScale;
+            }
+        }
+    }
+    if (reportCompositionChange) {
+        reportChange({
+            kind: 'composition',
+            op: 'set',
+            field: 'fps',
+            oldValue: previousFrameRate,
+            newValue: targetFrameRate
+        });
+    }
+}
+function reframeAnimatedProperty(property, frameRateScale) {
+    if ((property == null ? void 0 : property.type) !== 'keyframed') {
+        return;
+    }
+    for(var _iterator = _create_for_of_iterator_helper_loose(property.keyframes), _step; !(_step = _iterator()).done;){
+        var keyframe = _step.value;
+        keyframe.frame *= frameRateScale;
+    }
+}
+function updateIRComposition(updatedIR, editedDSL, baselineDSL, frameRate, reportChange) {
+    var _editedDSL_meta_background_color;
+    var baselineMeta = baselineDSL.meta;
+    if (editedDSL.meta.name !== baselineMeta.name) {
+        var previousName = updatedIR.name;
+        updatedIR.name = editedDSL.meta.name;
+        reportChange({
+            kind: 'composition',
+            op: 'set',
+            field: 'name',
+            oldValue: previousName,
+            newValue: editedDSL.meta.name
+        });
+    }
+    if (!isScalarEqual(editedDSL.meta.duration, baselineMeta.duration)) {
+        updatedIR.outPoint = updatedIR.inPoint + editedDSL.meta.duration * frameRate;
+        reportChange({
+            kind: 'composition',
+            op: 'set',
+            field: 'duration',
+            oldValue: baselineMeta.duration,
+            newValue: editedDSL.meta.duration
+        });
+    }
+    if (Number.isFinite(editedDSL.meta.width) && editedDSL.meta.width > 0 && editedDSL.meta.width !== baselineMeta.width) {
+        var previousWidth = updatedIR.width;
+        updatedIR.width = editedDSL.meta.width;
+        reportChange({
+            kind: 'composition',
+            op: 'set',
+            field: 'width',
+            oldValue: previousWidth,
+            newValue: editedDSL.meta.width
+        });
+    }
+    if (Number.isFinite(editedDSL.meta.height) && editedDSL.meta.height > 0 && editedDSL.meta.height !== baselineMeta.height) {
+        var previousHeight = updatedIR.height;
+        updatedIR.height = editedDSL.meta.height;
+        reportChange({
+            kind: 'composition',
+            op: 'set',
+            field: 'height',
+            oldValue: previousHeight,
+            newValue: editedDSL.meta.height
+        });
+    }
+    var baselineLoop = baselineMeta.loop;
+    if (editedDSL.meta.loop !== baselineLoop) {
+        updatedIR.endBehavior = editedDSL.meta.loop ? IREndBehavior.Loop : IREndBehavior.Destroy;
+        reportChange({
+            kind: 'composition',
+            op: 'set',
+            field: 'loop',
+            oldValue: baselineLoop,
+            newValue: editedDSL.meta.loop
+        });
+    }
+    var baselineBackgroundColor = baselineMeta.background_color;
+    var editedBackgroundColor = (_editedDSL_meta_background_color = editedDSL.meta.background_color) != null ? _editedDSL_meta_background_color : null;
+    if (!isHexEqual(editedBackgroundColor, baselineBackgroundColor)) {
+        updatedIR.backgroundColor = editedBackgroundColor != null ? hexToIRColor(editedBackgroundColor) : undefined;
+        reportChange({
+            kind: 'composition',
+            op: 'set',
+            field: 'background_color',
+            oldValue: baselineBackgroundColor,
+            newValue: editedBackgroundColor
+        });
+    }
+}
+
+/** Convert DSL to a clone of the baseline IR carried by the adapter-owned preserved data. */ function convertDSLToIRWithPreservedData(composition, preservedData, options) {
+    if (options === void 0) options = {};
+    assertIRToDSLPreservedData(preservedData);
+    var diagnostics = [];
+    var scene = updateValidatedIRFromDSL(preservedData.baselineScene, composition, preservedData.layerMapping, _extends({}, options, {
+        onWarning: function onWarning(warning) {
+            var _warning_path;
+            diagnostics.push(_extends({
+                code: warning.code,
+                severity: 'warning',
+                action: 'unsupported',
+                path: (_warning_path = warning.path) != null ? _warning_path : warning.layerId != null ? '$.layers' : '$'
+            }, warning.layerId != null && {
+                sourceId: warning.layerId
+            }, {
+                message: warning.message
+            }));
+            options.onWarning == null ? void 0 : options.onWarning.call(options, warning);
+        }
+    }));
+    return {
+        scene: scene,
+        diagnostics: diagnostics
+    };
+}
+function assertIRToDSLPreservedData(preservedData) {
+    if (preservedData == null || (typeof preservedData === "undefined" ? "undefined" : _type_of(preservedData)) !== 'object') {
+        throw new TypeError('[dsl-ir:preserved-data] Expected an IR-to-DSL preserved data object.');
+    }
+    if (!isRecord$1(preservedData.layerMapping)) {
+        throw new TypeError('[dsl-ir:preserved-data] Invalid IR-to-DSL layer mapping.');
+    }
+    assertIRScene(preservedData.baselineScene);
+    assertLayerMapping(preservedData.layerMapping, preservedData.baselineScene);
+}
+function assertLayerMapping(layerMapping, baselineScene) {
+    var _loop = function() {
+        var _step_value = _step.value, dslLayerId = _step_value[0], entry = _step_value[1];
+        if (dslLayerId === '' || !isRecord$1(entry)) {
+            throw new TypeError("[dsl-ir:preserved-data] Invalid mapping entry for DSL layer '" + dslLayerId + "'.");
+        }
+        var irCompositionId = entry['irCompositionId'];
+        var irLayerId = entry['irLayerId'];
+        var composition = typeof irCompositionId === 'string' ? compositionById.get(irCompositionId) : undefined;
+        if (composition == null || typeof irLayerId !== 'string' || !composition.layers.some(function(layer) {
+            return layer.id === irLayerId;
+        })) {
+            throw new TypeError("[dsl-ir:preserved-data] Invalid mapping entry for DSL layer '" + dslLayerId + "'.");
+        }
+        if (entry['expandedSource'] !== undefined && !isExpandedLayerSource(entry['expandedSource'], layers)) {
+            throw new TypeError("[dsl-ir:preserved-data] Invalid expanded mapping for DSL layer '" + dslLayerId + "'.");
+        }
+    };
+    var layers = layerMapping['layers'];
+    if (!isRecord$1(layers)) {
+        throw new TypeError('[dsl-ir:preserved-data] Layer mapping entries must be an object.');
+    }
+    var compositionById = new Map(baselineScene.compositions.map(function(composition) {
+        return [
+            composition.id,
+            composition
+        ];
+    }));
+    for(var _iterator = _create_for_of_iterator_helper_loose(Object.entries(layers)), _step; !(_step = _iterator()).done;)_loop();
+}
+function isExpandedLayerSource(value, layerEntries) {
+    if (!isRecord$1(value) || typeof value['irCompositionId'] !== 'string' || typeof value['parentLayerId'] !== 'string' || !Object.hasOwn(layerEntries, value['parentLayerId']) || !isRecord$1(value['baselineTransform']) || !isRecord$1(value['baselineLayer'])) {
+        return false;
+    }
+    var transform = value['baselineTransform'];
+    var layer = value['baselineLayer'];
+    return [
+        'position',
+        'scale',
+        'rotation',
+        'anchor',
+        'opacity'
+    ].every(function(field) {
+        return isRecord$1(transform[field]);
+    }) && typeof layer['name'] === 'string' && (layer['type'] === 'null' || layer['type'] === 'layer' || layer['type'] === 'text' || layer['type'] === 'particle') && (layer['type'] !== 'particle' || isRecord$1(layer['particle'])) && typeof layer['width'] === 'number' && Number.isFinite(layer['width']) && typeof layer['height'] === 'number' && Number.isFinite(layer['height']) && isRecord$1(layer['description']) && Array.isArray(layer['timeRange']) && layer['timeRange'].length === 2;
+}
+
+function assembleIRComposition(composition, layers) {
+    var frameRate = composition.meta.fps;
+    var durationFrames = secondsToFrames(composition.meta.duration, frameRate);
+    return _extends({
+        id: createId(),
+        name: composition.meta.name,
+        width: composition.meta.width,
+        height: composition.meta.height,
+        frameRate: frameRate,
+        inPoint: 0,
+        outPoint: durationFrames
+    }, composition.meta.background_color != null && {
+        backgroundColor: hexToIRColor(composition.meta.background_color)
+    }, {
+        endBehavior: composition.meta.loop ? IREndBehavior.Loop : IREndBehavior.Destroy,
+        layers: layers
+    });
+}
+
+/** Convert authored 2D DSL sibling groups to flat IR layers in bottom-to-top painter order. */ function convertDSLLayersToIR(composition, imageAssets, fontAssets) {
+    if (imageAssets === void 0) imageAssets = [];
+    if (fontAssets === void 0) fontAssets = [];
+    var flattenedLayers = flattenLayersInRenderOrder(composition.layers);
+    var irLayerIdByDSLId = new Map();
+    for(var _iterator = _create_for_of_iterator_helper_loose(flattenedLayers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value.layer;
+        if (!irLayerIdByDSLId.has(layer.id)) {
+            irLayerIdByDSLId.set(layer.id, convertLayerIdToIR(layer.id));
+        }
+    }
+    return flattenedLayers.map(function(param) {
+        var layer = param.layer, nestedParentId = param.nestedParentId;
+        var _layer_parent, _irLayerIdByDSLId_get;
+        var parentId = (_layer_parent = layer.parent) != null ? _layer_parent : nestedParentId;
+        return convertLayerToIR(layer, {
+            layerId: (_irLayerIdByDSLId_get = irLayerIdByDSLId.get(layer.id)) != null ? _irLayerIdByDSLId_get : convertLayerIdToIR(layer.id),
+            parentLayerId: parentId != null ? irLayerIdByDSLId.get(parentId) : undefined,
+            compositionDurationSeconds: composition.meta.duration,
+            frameRate: composition.meta.fps
+        }, imageAssets, fontAssets);
+    });
+}
+function convertLayerToIR(layer, context, imageAssets, fontAssets) {
+    var layerType = mapLayerType(layer.type);
+    var imageAssetId = layerType === 'image' && layer.asset != null ? createId() : undefined;
+    var textContent = layer.type === 'text' && layer.text != null ? convertTextData(layer.text, fontAssets) : undefined;
+    var particleContent = layer.type === 'particle' ? convertDSLParticleToIRContent(requireParticleProperties(layer), context.frameRate) : undefined;
+    if (imageAssetId != null && layer.asset != null) {
+        imageAssets.push({
+            id: imageAssetId,
+            type: 'image',
+            source: createIRResourceSource(resolveAssetUrl(layer.asset))
+        });
+    }
+    var convertedLayer = _extends({
+        id: context.layerId,
+        name: layer.name,
+        type: layerType,
+        time: convertLayerTime(layer, context.compositionDurationSeconds, context.frameRate)
+    }, context.parentLayerId != null && {
+        parentId: context.parentLayerId
+    }, {
+        visible: true
+    }, imageAssetId != null && {
+        content: {
+            assetId: imageAssetId
+        }
+    }, textContent != null && {
+        content: textContent
+    }, particleContent != null && {
+        content: particleContent
+    }, {
+        transform: {
+            position: convertDSLPositionToIR(layer.position, context.frameRate),
+            rotation: convertDSLPropertyToIRRotation(layer.rotation, context.frameRate, [
+                0,
+                0,
+                0
+            ]),
+            scale: convertDSLPropertyToIRVec3(layer.scale, context.frameRate, [
+                1,
+                1,
+                1
+            ]),
+            anchor: convertDSLPropertyToStaticIRVec3(layer.anchor, [
+                0,
+                0,
+                0
+            ]),
+            opacity: convertDSLPropertyToIRNumber(layer.opacity, context.frameRate, 1)
+        }
+    });
+    if (textContent != null) {
+        convertedLayer.localBounds = resolveTextLocalBounds(layer, textContent);
+    } else if (layer.width > 0 && layer.height > 0) {
+        convertedLayer.localBounds = {
+            x: 0,
+            y: 0,
+            width: layer.width,
+            height: layer.height
+        };
+    }
+    return convertedLayer;
+}
+function convertDSLPositionToIR(position, frameRate) {
+    var result = convertDSLPropertyToIRVec3(position, frameRate, [
+        0,
+        0,
+        0
+    ], true);
+    // Authored DSL uses Z for stacking; its pixel coordinates stay on the 2D plane.
+    if (result.type === 'static') {
+        result.value[2] = 0;
+    } else {
+        for(var _iterator = _create_for_of_iterator_helper_loose(result.keyframes), _step; !(_step = _iterator()).done;){
+            var keyframe = _step.value;
+            keyframe.value[2] = 0;
+            if (keyframe.endValue != null) {
+                keyframe.endValue[2] = 0;
+            }
+        }
+    }
+    return result;
+}
+function requireParticleProperties(layer) {
+    if (layer.particle == null) {
+        throw new TypeError("[dsl-ir] Particle layer '" + layer.id + "' requires particle data.");
+    }
+    return layer.particle;
+}
+function resolveTextLocalBounds(layer, text) {
+    var estimatedBounds = estimateTextBounds(text);
+    return {
+        x: 0,
+        y: 0,
+        width: Number.isFinite(layer.width) && layer.width > 0 ? layer.width : estimatedBounds.width,
+        height: Number.isFinite(layer.height) && layer.height > 0 ? layer.height : estimatedBounds.height
+    };
+}
+function convertLayerIdToIR(layerId) {
+    return isIRId(layerId) ? layerId : createId();
+}
+function flattenLayersInRenderOrder(layers, nestedParentId, flattenedLayers) {
+    if (nestedParentId === void 0) nestedParentId = null;
+    if (flattenedLayers === void 0) flattenedLayers = [];
+    var orderedLayers = [].concat(layers).sort(function(left, right) {
+        return getLayerStackingOrder(left) - getLayerStackingOrder(right) || left.id.localeCompare(right.id);
+    });
+    for(var _iterator = _create_for_of_iterator_helper_loose(orderedLayers), _step; !(_step = _iterator()).done;){
+        var layer = _step.value;
+        var _layer_children;
+        flattenedLayers.push({
+            layer: layer,
+            nestedParentId: nestedParentId
+        });
+        flattenLayersInRenderOrder((_layer_children = layer.children) != null ? _layer_children : [], layer.id, flattenedLayers);
+    }
+    return flattenedLayers;
+}
+function mapLayerType(type) {
+    switch(type){
+        case 'layer':
+            return 'image';
+        case 'text':
+            return 'text';
+        case 'null':
+            return 'null';
+        case 'particle':
+            return 'particle';
+    }
+}
+function convertLayerTime(layer, compositionDurationSeconds, frameRate) {
+    var _layer_time_range, _layer_time_range1;
+    var startSeconds = resolveFiniteNumber((_layer_time_range = layer.time_range) == null ? void 0 : _layer_time_range[0], 0);
+    var endSeconds = resolveFiniteNumber((_layer_time_range1 = layer.time_range) == null ? void 0 : _layer_time_range1[1], compositionDurationSeconds);
+    return {
+        inFrame: secondsToFrames(startSeconds, frameRate),
+        outFrame: secondsToFrames(endSeconds, frameRate)
+    };
+}
+function convertTextData(text, fontAssets) {
+    var _text_align;
+    var fontFamily = normalizeDSLFontFamily(text.font);
+    // DSL text cannot express style or weight, so new IR fonts use the canonical normal/400 defaults.
+    var fontAssetId = ensureSystemFontAsset(fontAssets, fontFamily, 'normal', 400);
+    var fontSize = Number.isFinite(text.size) && text.size > 0 ? text.size : 16;
+    return {
+        text: text.content,
+        fontAssetId: fontAssetId,
+        fontSize: fontSize,
+        color: hexToIRColor(text.color !== '' ? text.color : '#000000'),
+        letterSpacing: resolveFiniteNumber(text.letter_spacing, 0),
+        lineHeight: text.line_height != null && Number.isFinite(text.line_height) && text.line_height > 0 ? text.line_height : fontSize,
+        textAlign: (_text_align = text.align) != null ? _text_align : 'left'
+    };
+}
+
+/** Convert an editable DSL composition into a shared Animation IR scene. */ function convertDSLToIR(composition, options) {
+    if (options === void 0) options = {};
+    var validationResult = validateDSL(composition, {
+        strict: options.strict
+    });
+    if (validationResult.result === 'fail') {
+        throw DSLValidationError.fromValidationResult(validationResult);
+    }
+    var diagnostics = reportDSLValidationWarnings(validationResult.warnings, options);
+    if (options.preservedData != null) {
+        var preservedResult = convertDSLToIRWithPreservedData(composition, options.preservedData, options);
+        assertIRScene(preservedResult.scene);
+        return {
+            scene: preservedResult.scene,
+            diagnostics: [].concat(diagnostics, preservedResult.diagnostics)
+        };
+    }
+    var imageAssets = [];
+    var fontAssets = [];
+    var convertedLayers = convertDSLLayersToIR(composition, imageAssets, fontAssets);
+    var scene = createIRScene(assembleIRComposition(composition, convertedLayers), [].concat(imageAssets, fontAssets));
+    assertIRScene(scene);
+    return {
+        scene: scene,
+        diagnostics: diagnostics
+    };
+}
+function reportDSLValidationWarnings(warnings, options) {
+    return warnings.map(function(warning) {
+        var path = toJSONPath(warning.path);
+        options.onWarning == null ? void 0 : options.onWarning.call(options, _extends({
+            level: 'warning',
+            code: warning.code,
+            message: warning.message,
+            path: path
+        }, warning.layerId != null && {
+            layerId: warning.layerId
+        }));
+        return _extends({
+            code: warning.code,
+            severity: 'warning',
+            action: 'unsupported',
+            path: path
+        }, warning.layerId != null && {
+            sourceId: warning.layerId
+        }, {
+            message: warning.message
+        });
+    });
+}
+
+function parseParticleShape(value) {
+    if (!isRecord(value) || !isIntegerInRange(value['type'], 0, 9)) {
+        return undefined;
+    }
+    var type = value['type'];
+    if (type === 0) {
+        return _extends({
+            type: 0,
+            shape: 'None'
+        }, projectDirectionExpressions(value), isFiniteNumberArray(value['upDirection']) && {
+            upDirection: [].concat(value['upDirection'])
+        });
+    }
+    var base = projectShapeBase(value);
+    if (base == null) {
+        return undefined;
+    }
+    switch(type){
+        case 1:
+            {
+                var radial = projectRadialFields(value);
+                return radial == null ? undefined : _extends({
+                    type: 1,
+                    shape: 'Sphere'
+                }, base, radial);
+            }
+        case 2:
+            {
+                var radial1 = projectRadialFields(value);
+                var angle = readFiniteNumber(value['angle']);
+                return radial1 == null || angle == null ? undefined : _extends({
+                    type: 2,
+                    shape: 'Cone'
+                }, base, {
+                    angle: angle
+                }, radial1);
+            }
+        case 3:
+            {
+                var radial2 = projectRadialFields(value);
+                return radial2 == null ? undefined : _extends({
+                    type: 3,
+                    shape: 'Hemisphere'
+                }, base, radial2);
+            }
+        case 4:
+            {
+                var radial3 = projectRadialFields(value);
+                return radial3 == null ? undefined : _extends({
+                    type: 4,
+                    shape: 'Circle'
+                }, base, radial3);
+            }
+        case 5:
+            {
+                var radial4 = projectRadialFields(value);
+                var donutRadius = readFiniteNumber(value['donutRadius']);
+                return radial4 == null || donutRadius == null ? undefined : _extends({
+                    type: 5,
+                    shape: 'Donut'
+                }, base, radial4, {
+                    donutRadius: donutRadius
+                });
+            }
+        case 6:
+            {
+                var rectangle = projectRectangleFields(value);
+                return rectangle == null ? undefined : _extends({
+                    type: 6,
+                    shape: 'Rectangle'
+                }, base, rectangle);
+            }
+        case 7:
+            {
+                var rectangle1 = projectRectangleFields(value);
+                return rectangle1 == null ? undefined : _extends({
+                    type: 7,
+                    shape: 'RectangleEdge'
+                }, base, rectangle1);
+            }
+        case 8:
+            {
+                var width = readFiniteNumber(value['width']);
+                return width == null ? undefined : _extends({
+                    type: 8,
+                    shape: 'Edge'
+                }, base, {
+                    width: width
+                });
+            }
+        case 9:
+            return projectTextureShape(value, base);
+    }
+}
+function projectRadialFields(value) {
+    var radius = readFiniteNumber(value['radius']);
+    var arc = readFiniteNumber(value['arc']);
+    if (radius == null || arc == null) {
+        return undefined;
+    }
+    return {
+        radius: radius,
+        arc: arc
+    };
+}
+function projectRectangleFields(value) {
+    var width = readFiniteNumber(value['width']);
+    var height = readFiniteNumber(value['height']);
+    if (width == null || height == null) {
+        return undefined;
+    }
+    return {
+        width: width,
+        height: height
+    };
+}
+function projectTextureShape(value, base) {
+    var detail = projectTextureShapeDetail(value['detail']);
+    var random = readFiniteNumber(value['random']);
+    var width = readFiniteNumber(value['width']);
+    var height = readFiniteNumber(value['height']);
+    if (detail == null || random == null || width == null || height == null) {
+        return undefined;
+    }
+    return _extends({
+        type: 9,
+        shape: 'Texture'
+    }, base, {
+        detail: detail,
+        random: random,
+        width: width,
+        height: height
+    });
+}
+function projectTextureShapeDetail(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    var width = readFiniteNumber(value['width']);
+    var height = readFiniteNumber(value['height']);
+    var block = value['block'];
+    var anchors = value['anchors'];
+    if (width == null || height == null || !isFiniteNumberTuple(block, 2) || !isFiniteNumberArray(anchors)) {
+        return undefined;
+    }
+    return {
+        width: width,
+        height: height,
+        block: [
+            block[0],
+            block[1]
+        ],
+        anchors: [].concat(anchors)
+    };
+}
+function projectShapeBase(value) {
+    var arcMode = value['arcMode'] === undefined ? 0 : value['arcMode'];
+    if (!isParticleShapeArcMode(arcMode)) {
+        return undefined;
+    }
+    return _extends({
+        arcMode: arcMode
+    }, typeof value['alignSpeedDirection'] === 'boolean' && {
+        alignSpeedDirection: value['alignSpeedDirection']
+    }, isFiniteNumberTuple(value['upDirection'], 3) && {
+        upDirection: [
+            value['upDirection'][0],
+            value['upDirection'][1],
+            value['upDirection'][2]
+        ]
+    }, projectDirectionExpressions(value));
+}
+function projectDirectionExpressions(value) {
+    var result = {};
+    for(var _i = 0, _iter = [
+        'turbulenceX',
+        'turbulenceY',
+        'turbulenceZ'
+    ]; _i < _iter.length; _i++){
+        var field = _iter[_i];
+        var expression = value[field];
+        if (isTaggedExpression(expression)) {
+            result[field] = [
+                expression[0],
+                structuredClone(expression[1])
+            ];
+        }
+    }
+    return result;
+}
+function readFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function isFiniteNumberArray(value) {
+    return Array.isArray(value) && value.every(function(entry) {
+        return readFiniteNumber(entry) != null;
+    });
+}
+function isFiniteNumberTuple(value, length) {
+    return isFiniteNumberArray(value) && value.length === length;
+}
+function isTaggedExpression(value) {
+    return Array.isArray(value) && value.length === 2 && Number.isInteger(value[0]);
+}
+function isIntegerInRange(value, minimum, maximum) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= minimum && value <= maximum;
+}
+function isParticleShapeArcMode(value) {
+    return isIntegerInRange(value, 0, 3);
+}
+function isRecord(value) {
+    return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && !Array.isArray(value);
+}
+
+export { DSLValidationError, convertDSLToIR, convertIRToDSL, parseParticleShape, validateDSL };
+//# sourceMappingURL=index.mjs.map