@pixodesk/svg-animator-web 1.0.34 → 1.0.39

package/dist/index.prerendered-waapi.umd.js

@@ -50,12 +50,12 @@ var PixodeskAnimator = (() => {
   // src/index.prerendered-waapi.ts
   var index_prerendered_waapi_exports = {};
   __export(index_prerendered_waapi_exports, {
-    PX_ANIMATOR_DATA_KEY: () => PX_ANIMATOR_DATA_KEY,
+    PX_ANIMATOR_DOC_KEY: () => PX_ANIMATOR_DOC_KEY,
     createAnimator: () => createPrerenderedWaapiAnimator,
     setupAnimationTriggers: () => setupAnimationTriggers
   });
 
-  // ../svg-animator-core/src/PxAnimatorUtil.ts
+  // ../svg-animator-core/src/util/PxAnimatorUtil.ts
   function bezierToSvgPath(path, forceCurves = false) {
     var _a, _b, _c, _d;
     const v = path.v;
@@ -280,7 +280,7 @@ var PixodeskAnimator = (() => {
     }
     return void 0;
   }
-  var COLOUR_ATTR_NAMES = /* @__PURE__ */ new Set(["color", "fill", "flood-color", "lighting-color", "stop-color", "stroke"]);
+  var COLOR_ATTR_NAMES = /* @__PURE__ */ new Set(["color", "fill", "flood-color", "lighting-color", "stop-color", "stroke"]);
   var TRANSFORM_FN_NAMES = /* @__PURE__ */ new Set(["translate", "rotate", "scale", "skew"]);
   var PCT_BASED_ATTR_NAMES = /* @__PURE__ */ new Set(["offset-distance", "offsetDistance"]);
   function composeTransformParts(parts, opts) {
@@ -478,29 +478,687 @@ var PixodeskAnimator = (() => {
     return cubicBezier(flipped);
   }
 
-  // ../svg-animator-core/src/PxAnimatorConstants.ts
-  var PxAnimatorMode = {
+  // ../svg-animator-core/src/schema/PxSchema.ts
+  var PX_UNKNOWN_KEY_ERROR = "unexpected extra key";
+  function pathStr(path) {
+    if (!path.length) return ".";
+    let result = "";
+    for (const seg of path) {
+      if (seg.startsWith("[")) result += seg;
+      else result += (result ? "." : "") + seg;
+    }
+    return result;
+  }
+  var Base = class {
+    _canSanitize(raw) {
+      return this.isValid(raw);
+    }
+    optional() {
+      return new Optional(this);
+    }
+  };
+  var Optional = class extends Base {
+    constructor(inner) {
+      super();
+      this.inner = inner;
+      this._default = void 0;
+    }
+    sanitize(raw) {
+      if (raw === void 0 || raw === null) return void 0;
+      return this.inner._canSanitize(raw) ? this.inner.sanitize(raw) : void 0;
+    }
+    isValid(raw, ctx, path) {
+      if (raw === void 0 || raw === null) return true;
+      return this.inner.isValid(raw, ctx, path);
+    }
+    _canSanitize(raw) {
+      return raw === void 0 || raw === null || this.inner._canSanitize(raw);
+    }
+  };
+  var Str = class extends Base {
+    constructor(_default = "") {
+      super();
+      this._default = _default;
+    }
+    sanitize(raw) {
+      return typeof raw === "string" ? raw : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (typeof raw === "string") return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected string, got " + typeof raw);
+      return false;
+    }
+  };
+  var Num = class extends Base {
+    constructor(_default = 0) {
+      super();
+      this._default = _default;
+    }
+    sanitize(raw) {
+      return typeof raw === "number" && isFinite(raw) ? raw : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (typeof raw === "number" && isFinite(raw)) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected finite number, got " + JSON.stringify(raw));
+      return false;
+    }
+  };
+  var Bool = class extends Base {
+    constructor(_default = false) {
+      super();
+      this._default = _default;
+    }
+    sanitize(raw) {
+      return typeof raw === "boolean" ? raw : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (typeof raw === "boolean") return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected boolean, got " + typeof raw);
+      return false;
+    }
+  };
+  var Literal = class extends Base {
+    constructor(value) {
+      super();
+      this.value = value;
+      this._default = value;
+    }
+    sanitize(raw) {
+      return raw === this.value ? this.value : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (raw === this.value) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected " + JSON.stringify(this.value) + ", got " + JSON.stringify(raw));
+      return false;
+    }
+  };
+  var Enum = class extends Base {
+    constructor(values, defaultVal) {
+      super();
+      this.values = values;
+      this._default = defaultVal != null ? defaultVal : values[0];
+    }
+    sanitize(raw) {
+      return this.values.includes(raw) ? raw : this._default;
+    }
+    isValid(raw, ctx, path) {
+      if (this.values.includes(raw)) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected one of " + this.values.map((v) => JSON.stringify(v)).join(" | ") + ", got " + JSON.stringify(raw));
+      return false;
+    }
+  };
+  var UNION_MEMBER_ERROR_LIMIT = 4;
+  var Union = class extends Base {
+    constructor(schemas, defaultVal) {
+      super();
+      this.schemas = schemas;
+      /** Structural tag read by {@link describeSchema} — `schemas` alone cannot tell Union from Tuple. */
+      this._kind = "union";
+      this._default = defaultVal != null ? defaultVal : schemas[0]._default;
+    }
+    sanitize(raw) {
+      for (const s of this.schemas) {
+        if (s.isValid(raw)) return s.sanitize(raw);
+      }
+      return this._default;
+    }
+    isValid(raw, ctx, path) {
+      var _a;
+      const probe = ctx && { errors: [], warnings: [], strict: ctx.strict };
+      if (this.schemas.some((s) => s.isValid(raw, probe, path ? [...path] : void 0))) return true;
+      if (!ctx) return false;
+      const base = pathStr(path != null ? path : []);
+      ctx.errors.push(base + ": no union member matched for value " + ((_a = JSON.stringify(raw)) != null ? _a : "").slice(0, 240));
+      let best;
+      let bestDepth = -1;
+      const leafExpectations = [];
+      for (const member of this.schemas) {
+        const sink = { errors: [], warnings: [], strict: ctx.strict };
+        member.isValid(raw, sink, path ? [...path] : void 0);
+        if (!sink.errors.length) continue;
+        const depth = Math.max(...sink.errors.map((e) => e.slice(0, e.indexOf(":")).length));
+        if (depth > bestDepth || depth === bestDepth && best && sink.errors.length < best.length) {
+          bestDepth = depth;
+          best = sink.errors;
+        }
+        if (depth <= base.length) {
+          for (const e of sink.errors) {
+            const m = /: expected (.+?), got /.exec(e);
+            if (m && !leafExpectations.includes(m[1])) leafExpectations.push(m[1]);
+          }
+        }
+      }
+      if (best && bestDepth > base.length) {
+        for (const e of best.slice(0, UNION_MEMBER_ERROR_LIMIT)) {
+          if (!ctx.errors.includes(e)) ctx.errors.push(e);
+        }
+      } else if (leafExpectations.length) {
+        ctx.errors.push(base + ": expected " + leafExpectations.join(" | "));
+      }
+      return false;
+    }
+    _canSanitize(raw) {
+      return this.schemas.some((s) => s._canSanitize(raw));
+    }
+  };
+  var DiscriminatedUnion = class extends Base {
+    constructor(_key, _schemas, defaultVal) {
+      var _a;
+      super();
+      this._key = _key;
+      this._schemas = _schemas;
+      /** Structural tag read by {@link describeSchema}. */
+      this._kind = "discriminatedUnion";
+      this._default = defaultVal != null ? defaultVal : _schemas[0]._default;
+      this._map = /* @__PURE__ */ new Map();
+      for (const s of _schemas) {
+        const keySchema = s._shape[_key];
+        if (!keySchema) continue;
+        const literal = (_a = keySchema.inner) != null ? _a : keySchema;
+        this._map.set(literal._default, s);
+        if (keySchema.inner) this._absentMember = s;
+      }
+    }
+    _findSchema(raw) {
+      if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+      const val = raw[this._key];
+      if (val === void 0 || val === null) return this._absentMember;
+      return this._map.get(val);
+    }
+    sanitize(raw) {
+      var _a;
+      return ((_a = this._findSchema(raw)) != null ? _a : this._schemas[0]).sanitize(raw);
+    }
+    isValid(raw, ctx, path) {
+      const schema = this._findSchema(raw);
+      if (!schema) {
+        const val = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw[this._key] : void 0;
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": no discriminated union member matched " + this._key + "=" + JSON.stringify(val));
+        return false;
+      }
+      return schema.isValid(raw, ctx, path);
+    }
+    _canSanitize(raw) {
+      if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return false;
+      const schema = this._findSchema(raw);
+      return schema ? schema._canSanitize(raw) : this._schemas[0]._canSanitize(raw);
+    }
+  };
+  var Obj = class extends Base {
+    constructor(_shape) {
+      super();
+      this._shape = _shape;
+      const d = {};
+      for (const key of Object.keys(_shape)) d[key] = _shape[key]._default;
+      this._default = d;
+    }
+    sanitize(raw) {
+      const src = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+      const out = {};
+      for (const key of Object.keys(this._shape)) {
+        const v = this._shape[key].sanitize(src[key]);
+        if (v !== void 0) out[key] = v;
+      }
+      return out;
+    }
+    isValid(raw, ctx, path) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected object, got " + (Array.isArray(raw) ? "array" : typeof raw));
+        return false;
+      }
+      const obj = raw;
+      const p = path != null ? path : [];
+      let ok = true;
+      for (const key of Object.keys(this._shape)) {
+        p.push(key);
+        if (!this._shape[key].isValid(obj[key], ctx, p)) ok = false;
+        p.pop();
+      }
+      if (ctx == null ? void 0 : ctx.strict) {
+        for (const key of Object.keys(obj)) {
+          if (key in this._shape) continue;
+          if (obj[key] === void 0) continue;
+          p.push(key);
+          ctx.errors.push(pathStr(p) + ": " + PX_UNKNOWN_KEY_ERROR);
+          p.pop();
+          ok = false;
+        }
+      }
+      return ok;
+    }
+    _canSanitize(raw) {
+      return !!raw && typeof raw === "object" && !Array.isArray(raw);
+    }
+  };
+  var OpenObj = class extends Base {
+    constructor(_shape, _openSchema) {
+      super();
+      this._shape = _shape;
+      this._openSchema = _openSchema;
+      const d = {};
+      for (const key of Object.keys(_shape)) d[key] = _shape[key]._default;
+      this._default = d;
+    }
+    sanitize(raw) {
+      const src = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+      const out = __spreadValues({}, src);
+      for (const key of Object.keys(this._shape)) {
+        const v = this._shape[key].sanitize(src[key]);
+        if (v !== void 0) out[key] = v;
+      }
+      if (this._openSchema) {
+        for (const key of Object.keys(src)) {
+          if (!(key in this._shape)) out[key] = this._openSchema.sanitize(src[key]);
+        }
+      }
+      return out;
+    }
+    isValid(raw, ctx, path) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected object, got " + (Array.isArray(raw) ? "array" : typeof raw));
+        return false;
+      }
+      const obj = raw;
+      const p = path != null ? path : [];
+      let ok = true;
+      for (const key of Object.keys(this._shape)) {
+        p.push(key);
+        if (!this._shape[key].isValid(obj[key], ctx, p)) ok = false;
+        p.pop();
+      }
+      if (this._openSchema) {
+        for (const key of Object.keys(obj)) {
+          if (key in this._shape) continue;
+          p.push(key);
+          if (!this._openSchema.isValid(obj[key], ctx, p)) ok = false;
+          p.pop();
+        }
+      }
+      return ok;
+    }
+    _canSanitize(raw) {
+      return !!raw && typeof raw === "object" && !Array.isArray(raw);
+    }
+  };
+  var Arr = class extends Base {
+    constructor(item) {
+      super();
+      this.item = item;
+      this._default = [];
+    }
+    sanitize(raw) {
+      if (!Array.isArray(raw)) return [];
+      const out = [];
+      for (const el of raw) {
+        if (this.item._canSanitize(el)) out.push(this.item.sanitize(el));
+      }
+      return out;
+    }
+    isValid(raw, ctx, path) {
+      if (!Array.isArray(raw)) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected array, got " + typeof raw);
+        return false;
+      }
+      const p = path != null ? path : [];
+      let ok = true;
+      for (let i = 0; i < raw.length; i++) {
+        p.push("[" + i + "]");
+        if (!this.item.isValid(raw[i], ctx, p)) ok = false;
+        p.pop();
+      }
+      return ok;
+    }
+    _canSanitize(raw) {
+      return Array.isArray(raw);
+    }
+  };
+  var Rec = class extends Base {
+    constructor(value) {
+      super();
+      this.value = value;
+      /** Structural tag read by {@link describeSchema}. */
+      this._kind = "record";
+      this._default = {};
+    }
+    sanitize(raw) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+      const out = {};
+      for (const [k, v] of Object.entries(raw)) {
+        if (this.value._canSanitize(v)) out[k] = this.value.sanitize(v);
+      }
+      return out;
+    }
+    isValid(raw, ctx, path) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected object/record, got " + (Array.isArray(raw) ? "array" : typeof raw));
+        return false;
+      }
+      const p = path != null ? path : [];
+      let ok = true;
+      for (const [k, v] of Object.entries(raw)) {
+        p.push(k);
+        if (!this.value.isValid(v, ctx, p)) ok = false;
+        p.pop();
+      }
+      return ok;
+    }
+    _canSanitize(raw) {
+      return !!raw && typeof raw === "object" && !Array.isArray(raw);
+    }
+  };
+  var Any = class extends Base {
+    constructor() {
+      super(...arguments);
+      this._default = void 0;
+    }
+    sanitize(raw) {
+      return raw;
+    }
+    isValid(_raw, _ctx, _path) {
+      return true;
+    }
+    _canSanitize(_raw) {
+      return true;
+    }
+  };
+  var Defined = class extends Base {
+    constructor() {
+      super(...arguments);
+      this._default = void 0;
+    }
+    sanitize(raw) {
+      return raw;
+    }
+    isValid(raw, ctx, path) {
+      if (raw !== void 0) return true;
+      ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": required value is missing");
+      return false;
+    }
+    _canSanitize(raw) {
+      return raw !== void 0;
+    }
+  };
+  var Lazy = class extends Base {
+    constructor(fn, _default) {
+      super();
+      this.fn = fn;
+      this._default = _default;
+      this.resolved = null;
+    }
+    get schema() {
+      var _a;
+      return (_a = this.resolved) != null ? _a : this.resolved = this.fn();
+    }
+    sanitize(raw) {
+      return this.schema.sanitize(raw);
+    }
+    isValid(raw, ctx, path) {
+      return this.schema.isValid(raw, ctx, path);
+    }
+    _canSanitize(raw) {
+      return this.schema._canSanitize(raw);
+    }
+  };
+  var Tuple = class extends Base {
+    constructor(schemas) {
+      super();
+      this.schemas = schemas;
+      /** Structural tag read by {@link describeSchema} — `schemas` alone cannot tell Tuple from Union. */
+      this._kind = "tuple";
+      this._default = schemas.map((s) => s._default);
+    }
+    sanitize(raw) {
+      if (!Array.isArray(raw) || raw.length !== this.schemas.length) return this._default;
+      return this.schemas.map((s, i) => s.sanitize(raw[i]));
+    }
+    isValid(raw, ctx, path) {
+      if (!Array.isArray(raw) || raw.length !== this.schemas.length) {
+        ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": expected tuple of length " + this.schemas.length + ", got " + (Array.isArray(raw) ? "array[" + raw.length + "]" : typeof raw));
+        return false;
+      }
+      const p = path != null ? path : [];
+      let ok = true;
+      for (let i = 0; i < this.schemas.length; i++) {
+        p.push("[" + i + "]");
+        if (!this.schemas[i].isValid(raw[i], ctx, p)) ok = false;
+        p.pop();
+      }
+      return ok;
+    }
+    // Require exact length so wrong-length arrays are dropped rather than repaired to default.
+    _canSanitize(raw) {
+      return Array.isArray(raw) && raw.length === this.schemas.length;
+    }
+  };
+  function implementsInterface() {
+    return (schema) => schema;
+  }
+  var px = {
+    /** Matches a string. Default: '' or provided value. */
+    string: (defaultVal = "") => new Str(defaultVal),
+    /** Matches a finite number. Default: 0 or provided value. */
+    number: (defaultVal = 0) => new Num(defaultVal),
+    /** Matches a boolean. Default: false or provided value. */
+    boolean: (defaultVal = false) => new Bool(defaultVal),
+    /** Matches one exact primitive value; its default is the value itself. */
+    literal: (value) => new Literal(value),
+    /** Matches one of a fixed set of string/number values. Default: first value. */
+    enum: (values, defaultVal) => new Enum(values, defaultVal),
+    /**
+     * Returns the first schema whose isValid passes.
+     * TypeScript infers the union of all member types automatically.
+     */
+    union: (schemas, defaultVal) => new Union(schemas, defaultVal),
+    /**
+     * Discriminated union — reads `raw[key]`, finds the member schema whose
+     * literal at `key` matches, then delegates sanitize/isValid to that member.
+     * Each member must be an object schema with a `px.literal(...)` at `key`.
+     * TypeScript infers the union of all member types automatically.
+     */
+    discriminatedUnion: (key, schemas) => new DiscriminatedUnion(key, schemas),
+    /** Typed object — unknown keys are stripped. Required fields fall back to their default. */
+    object: (shape) => new Obj(shape),
+    /**
+     * Open object — validates known keys; passes unknown keys through as-is,
+     * or validates/sanitizes them against `openSchema` when provided.
+     */
+    openObject: (shape, openSchema) => new OpenObj(shape, openSchema),
+    /**
+     * Creates a new closed object schema by merging a base schema's shape with additional fields.
+     * The base can be the result of px.object() or px.openObject() — anything with a _shape property.
+     *
+     * @example
+     * const PxSvgNodeSchema = px.extendedObject(PxNodeBase, { width: px.number().optional() });
+     */
+    extendedObject: (base, extra) => new Obj(__spreadValues(__spreadValues({}, base._shape), extra)),
+    /** Array whose unrecoverable items are filtered out. Default: []. */
+    array: (item) => new Arr(item),
+    /** String-keyed record whose unrecoverable values are dropped. Default: {}. */
+    record: (value) => new Rec(value),
+    /** Passes anything through unchanged — always valid. */
+    any: () => new Any(),
+    /** Anything EXCEPT `undefined` — an open type whose presence is required (V6). */
+    defined: () => new Defined(),
+    /** Fixed-length tuple — validates element count and each position individually. */
+    tuple: (schemas) => new Tuple(schemas),
+    /** Defers schema creation — required for recursive types. Must supply a default value. */
+    lazy: (fn, defaultVal) => new Lazy(fn, defaultVal)
+  };
+
+  // ../svg-animator-core/src/format/PxAnimatorConstants.ts
+  var PxFillMode = {
+    forwards: "forwards",
+    backwards: "backwards",
+    both: "both",
+    none: "none"
+  };
+  var PxPlaybackDirection = {
+    normal: "normal",
+    reverse: "reverse",
+    alternate: "alternate",
+    alternateReverse: "alternate-reverse"
+  };
+  var PxStartOn = {
+    load: "load",
+    mouseOver: "mouseOver",
+    click: "click",
+    scrollIntoView: "scrollIntoView",
+    programmatic: "programmatic"
+  };
+  var PxOutAction = {
+    continue: "continue",
+    pause: "pause",
+    reset: "reset",
+    reverse: "reverse"
+  };
+  var PxFinishAction = {
+    hold: "hold",
+    reset: "reset"
+  };
+  var PxScrollKind = {
+    view: "view",
+    scroll: "scroll"
+  };
+  var PxScrollAxis = {
+    block: "block",
+    inline: "inline",
+    x: "x",
+    y: "y"
+  };
+  var PxScrollSource = {
+    nearest: "nearest",
+    root: "root"
+  };
+  var PxPinAlign = {
+    top: "top",
+    center: "center",
+    bottom: "bottom"
+  };
+  var PxScrollPhase = {
+    cover: "cover",
+    contain: "contain",
+    entry: "entry",
+    exit: "exit",
+    entryCrossing: "entry-crossing",
+    exitCrossing: "exit-crossing"
+  };
+  var PxAlongPathMode = {
+    sampled: "sampled",
+    offsetPath: "offsetPath"
+  };
+  var PX_TIMELINE_SHARED_KEYS = ["duration", "iterations", "engine", "frameRate"];
+  var PX_TIME_ONLY_TIMELINE_KEYS = ["trigger", "delay", "fillMode", "direction"];
+  var PX_FLAT_RUNTIME_VIEW_KEYS = [
+    ...PX_TIMELINE_SHARED_KEYS,
+    ...PX_TIME_ONLY_TIMELINE_KEYS,
+    "fill",
+    "resetOnFinish",
+    "timelineSource",
+    "scroll"
+  ];
+  var PxTimelineEngine = {
+    native: "native",
+    js: "js"
+  };
+  var PxTimelineEngineExtra = __spreadProps(__spreadValues({}, PxTimelineEngine), {
+    auto: "auto"
+  });
+  var PX_TRIGGER_DEFAULTS = {
+    startOn: "load",
+    outAction: "continue",
+    scrollIntoViewThreshold: 0
+  };
+  function resolveTrigger(trigger) {
+    var _a, _b, _c;
+    return {
+      startOn: (_a = trigger == null ? void 0 : trigger.startOn) != null ? _a : PX_TRIGGER_DEFAULTS.startOn,
+      outAction: (_b = trigger == null ? void 0 : trigger.outAction) != null ? _b : PX_TRIGGER_DEFAULTS.outAction,
+      scrollIntoViewThreshold: (_c = trigger == null ? void 0 : trigger.scrollIntoViewThreshold) != null ? _c : PX_TRIGGER_DEFAULTS.scrollIntoViewThreshold
+    };
+  }
+  var PxLoopRepeatAt = {
+    /** Segment from the START; the repetition runs BEFORE the first keyframe
+     *  (intro loops that play until the main timeline begins). */
+    start: "start",
+    /** DEFAULT — segment from the END; the repetition runs AFTER the last keyframe
+     *  (idle/outro loops that continue once the main timeline has finished). */
+    end: "end"
+  };
+  var PxLoopDirection = {
+    /** DEFAULT — cycle: every repetition replays the segment the same way round. */
+    normal: "normal",
+    /** Ping-pong: repetitions alternate forward / backward. */
+    alternate: "alternate"
+  };
+  var PxMaskType = {
+    luminance: "luminance",
+    alpha: "alpha"
+  };
+  var PxUnits = {
+    userSpaceOnUse: "userSpaceOnUse",
+    objectBoundingBox: "objectBoundingBox"
+  };
+  var PxCloneWithout = {
+    translate: "translate"
+    // transform: 'transform',   // future: drop rotate/scale too (content only)
+  };
+  var PxPathOverflow = {
+    clip: "clip",
+    extend: "extend"
+  };
+  var PxLengthAdjust = {
+    spacing: "spacing",
+    spacingAndGlyphs: "spacingAndGlyphs"
+  };
+  var PxTextPathMethod = {
+    align: "align",
+    stretch: "stretch"
+  };
+  var PxTextPathSpacing = {
     auto: "auto",
-    waapi: "waapi",
-    frames: "frames"
+    exact: "exact"
+  };
+  var PxStrokeTrimSubPaths = {
+    separate: "separate",
+    combined: "combined"
   };
-  var PxAnimatorEngine = {
-    waapi: PxAnimatorMode.waapi,
-    frames: PxAnimatorMode.frames
+  var TRANSFORM_ATTR = "transform";
+  var TRANSFORM_PART = {
+    translate: "translate",
+    rotate: "rotate",
+    scale: "scale",
+    origin: "origin"
   };
-  var PxLoopExtend = {
-    /** Segment from the START; the animation is extended BEFORE the first keyframe
-     *  (intro loops that run before the main timeline begins). */
-    before: "before",
-    /** DEFAULT — segment from the END; extended AFTER the last keyframe (idle/outro
-     *  loops that continue once the main timeline has finished). */
-    after: "after"
+  var PX_TRANSFORM_PART_KEYS = [
+    TRANSFORM_PART.translate,
+    TRANSFORM_PART.rotate,
+    TRANSFORM_PART.scale,
+    TRANSFORM_PART.origin
+  ];
+  var PxGradientSpreadMethod = {
+    pad: "pad",
+    reflect: "reflect",
+    repeat: "repeat"
+  };
+  var PxGradientType = {
+    linear: "linear",
+    radial: "radial"
   };
   function getAnimatorConfig(doc) {
     var _a;
     const cfg = (doc == null ? void 0 : doc.animator) || ((_a = doc == null ? void 0 : doc.meta) == null ? void 0 : _a.animator);
-    return cfg ? flattenAnimatorTimeline(cfg) : void 0;
-  }
+    if (!cfg) return void 0;
+    const memoised = wireViewMemo.get(cfg);
+    if (memoised) return memoised;
+    const wire = cfg;
+    const stray = PX_FLAT_RUNTIME_VIEW_KEYS.filter((k) => wire[k] !== void 0);
+    const source = stray.length ? __spreadValues({}, wire) : cfg;
+    for (const k of stray) delete source[k];
+    const view = flattenAnimatorTimeline(source);
+    wireViewMemo.set(cfg, view);
+    return view;
+  }
+  var wireViewMemo = /* @__PURE__ */ new WeakMap();
   var flattenMemo = /* @__PURE__ */ new WeakMap();
   function flattenAnimatorTimeline(cfg) {
     const timeline = cfg.timeline;
@@ -508,13 +1166,14 @@ var PixodeskAnimator = (() => {
     const memoised = flattenMemo.get(cfg);
     if (memoised) return memoised;
     const _a = cfg, { timeline: _dropped } = _a, flat = __objRest(_a, ["timeline"]);
+    if (timeline.engine !== void 0) flat.engine = timeline.engine;
+    if (timeline.frameRate !== void 0) flat.frameRate = timeline.frameRate;
     if (timeline.type === "scroll" || timeline.type === "view") {
       flat.timelineSource = "scroll";
       if (timeline.duration !== void 0) flat.duration = timeline.duration;
       if (timeline.iterations !== void 0) flat.iterations = timeline.iterations;
       const scroll = __spreadValues({}, flat.scroll || {});
       scroll.kind = timeline.type;
-      if (timeline.engine !== void 0) scroll.driver = timeline.engine;
       if (timeline.axis !== void 0) scroll.axis = timeline.axis;
       if (timeline.source !== void 0) scroll.source = timeline.source;
       if (timeline.subject !== void 0) scroll.subject = timeline.subject;
@@ -525,21 +1184,21 @@ var PixodeskAnimator = (() => {
       else if (pin && typeof pin === "object") {
         scroll.pin = true;
         if (pin.align !== void 0) scroll.pinAlign = pin.align;
-        if (pin.top !== void 0) scroll.pinTop = pin.top;
+        if (pin.offset !== void 0) scroll.pinOffset = pin.offset;
         if (pin.distance !== void 0) scroll.pinDistance = pin.distance;
       }
       flat.scroll = scroll;
     } else {
       if (timeline.duration !== void 0) flat.duration = timeline.duration;
       if (timeline.trigger !== void 0) {
-        const _b = timeline.trigger, { onFinish } = _b, restTrigger = __objRest(_b, ["onFinish"]);
+        const _b = timeline.trigger, { finishAction } = _b, restTrigger = __objRest(_b, ["finishAction"]);
         if (Object.keys(restTrigger).length) flat.trigger = restTrigger;
-        if (onFinish !== void 0) flat.resetOnFinish = onFinish === "reset";
+        if (finishAction !== void 0) flat.resetOnFinish = finishAction === "reset";
       }
       if (timeline.delay !== void 0) flat.delay = timeline.delay;
       if (timeline.iterations !== void 0) flat.iterations = timeline.iterations;
       if (timeline.direction !== void 0) flat.direction = timeline.direction;
-      if (timeline.fill !== void 0) flat.fill = timeline.fill;
+      if (timeline.fillMode !== void 0) flat.fill = timeline.fillMode;
     }
     flattenMemo.set(cfg, flat);
     return flat;
@@ -557,10 +1216,384 @@ var PixodeskAnimator = (() => {
     return Object.entries(animateById).map(([id, anim]) => ({ id: id.startsWith("#") ? id.slice(1) : id, animate: anim }));
   }
 
-  // ../svg-animator-core/src/PxMotionPath.ts
-  function getKfTranslate(kf) {
+  // ../svg-animator-core/src/format/PxAnimatorTypes.ts
+  var PxEasingOrRefSchema = px.union([
+    px.string(),
+    px.tuple([px.number(), px.number(), px.number(), px.number()])
+  ]);
+  var PxKeyframeValueSchema = implementsInterface()(px.union([
+    px.string(),
+    // e.g. for colors
+    px.number(),
+    px.array(px.number()),
+    // ORDER LAW: the key-discriminated object shape (`{pathData}`) comes BEFORE the
+    // all-optional transform-parts record. In default (non-strict) mode that record accepts
+    // ANY object (every key optional, unknown keys ignored), so listing it earlier made
+    // Union.sanitize route `{pathData}` values into it and strip them to `{}` —
+    // silent morph-data loss (repro: the editor's keyframeValueSanitize spec). Validity is
+    // order-independent (`some()`); only sanitize routing depends on this order.
+    px.object({ pathData: px.string() }),
+    // Gradient `stops` timeline — each kf value is the full stops-array snapshot.
+    px.lazy(() => px.array(PxGradientStopSchema), []),
+    px.lazy(() => PxTransformPartsSchema, {})
+  ]));
+  var PxKeyframeSchema = implementsInterface()(px.object({
+    time: px.number().optional(),
+    value: PxKeyframeValueSchema.optional(),
+    easing: PxEasingOrRefSchema.optional(),
+    tangentOut: px.tuple([px.number(), px.number()]).optional(),
+    tangentIn: px.tuple([px.number(), px.number()]).optional()
+    // (`selected` — editor timeline-selection UI state — was REMOVED from the wire
+    // (review §1.3): editor data lives under `meta`. The editor still carries it on
+    // its internal COPY-PASTE payload, which never validates against this schema.)
+  }));
+  var anyKf = (kf) => kf;
+  var kfTime = (kf) => {
+    var _a, _b;
+    return (_b = (_a = anyKf(kf).time) != null ? _a : anyKf(kf).t) != null ? _b : 0;
+  };
+  var kfValue = (kf) => {
+    var _a;
+    return (_a = anyKf(kf).value) != null ? _a : anyKf(kf).v;
+  };
+  var kfEasing = (kf) => {
     var _a;
-    const v = (_a = kf.value) != null ? _a : kf.v;
+    return (_a = anyKf(kf).easing) != null ? _a : anyKf(kf).e;
+  };
+  var kfTangentIn = (kf) => anyKf(kf).tangentIn;
+  var kfTangentOut = (kf) => anyKf(kf).tangentOut;
+  var PxLoopSchema = implementsInterface()(px.object({
+    segmentCount: px.number().optional(),
+    repeatAt: px.enum([PxLoopRepeatAt.start, PxLoopRepeatAt.end]).optional(),
+    direction: px.enum([PxLoopDirection.normal, PxLoopDirection.alternate]).optional()
+  }));
+  var PxPropertyAnimationSchema = implementsInterface()(px.object({
+    value: PxKeyframeValueSchema.optional(),
+    keyframes: px.array(PxKeyframeSchema).optional(),
+    loop: px.union([PxLoopSchema, px.boolean()]).optional(),
+    autoOrient: px.boolean().optional(),
+    alongPathMode: px.enum([PxAlongPathMode.sampled, PxAlongPathMode.offsetPath]).optional()
+  }));
+  var PxTransformPartsSchema = implementsInterface()(px.object({
+    translate: px.tuple([px.number(), px.number()]).optional(),
+    rotate: px.number().optional(),
+    skew: px.number().optional(),
+    scale: px.tuple([px.number(), px.number()]).optional(),
+    origin: px.tuple([px.number(), px.number()]).optional()
+  }));
+  var PxTransformValueSchema = px.union([
+    px.string(),
+    PxTransformPartsSchema,
+    px.object({ value: PxTransformPartsSchema }),
+    PxPropertyAnimationSchema
+  ]);
+  var PxAnimationDefinitionSchema = implementsInterface()(
+    px.record(PxPropertyAnimationSchema)
+  );
+  var PxElementAnimationSchema = implementsInterface()(px.union([
+    px.string(),
+    px.array(px.union([px.string(), PxAnimationDefinitionSchema])),
+    PxAnimationDefinitionSchema
+  ]));
+  var PxTriggerSchema = implementsInterface()(px.object({
+    startOn: px.enum([PxStartOn.load, PxStartOn.mouseOver, PxStartOn.click, PxStartOn.scrollIntoView, PxStartOn.programmatic], PX_TRIGGER_DEFAULTS.startOn).optional(),
+    outAction: px.enum([PxOutAction.continue, PxOutAction.pause, PxOutAction.reset, PxOutAction.reverse], PX_TRIGGER_DEFAULTS.outAction).optional(),
+    // What happens after a NATURAL finish — `'hold'` (default: keep the end state per
+    // `fill`) or `'reset'` (snap back to the start state). Pairs with `outAction` ("what
+    // happens when the trigger condition ends"); both end-of-life knobs now read alike.
+    finishAction: px.enum([PxFinishAction.hold, PxFinishAction.reset]).optional(),
+    scrollIntoViewThreshold: px.number().optional()
+  }));
+  var PxGlyphSchema = implementsInterface()(px.object({
+    width: px.number(),
+    pathData: px.string()
+  }));
+  var PxGlyphFontSchema = implementsInterface()(px.object({
+    fontFamily: px.string(),
+    fontStyle: px.string(),
+    ascent: px.number(),
+    unitsPerEm: px.number(),
+    glyphs: px.record(PxGlyphSchema)
+  }));
+  var PxDefsSchema = implementsInterface()(px.object({
+    easings: px.record(px.tuple([px.number(), px.number(), px.number(), px.number()])).optional(),
+    animations: px.record(PxAnimationDefinitionSchema).optional(),
+    // Review §2.6: the schema now matches the declared type — a style preset is a flat
+    // record of string|number attribute values, nothing nested.
+    styles: px.record(px.record(px.union([px.string(), px.number()]))).optional(),
+    fonts: px.record(PxGlyphFontSchema).optional()
+  }));
+  var PxScrollRangePointSchema = implementsInterface()(px.object({
+    phase: px.enum([
+      PxScrollPhase.cover,
+      PxScrollPhase.contain,
+      PxScrollPhase.entry,
+      PxScrollPhase.exit,
+      PxScrollPhase.entryCrossing,
+      PxScrollPhase.exitCrossing
+    ]).optional(),
+    fraction: px.number().optional()
+  }));
+  var PxScrollRangeSchema = px.object({
+    start: PxScrollRangePointSchema.optional(),
+    end: PxScrollRangePointSchema.optional()
+  });
+  var PxScrollSchema = implementsInterface()(px.object({
+    kind: px.enum([PxScrollKind.view, PxScrollKind.scroll]).optional(),
+    axis: px.enum([PxScrollAxis.block, PxScrollAxis.inline, PxScrollAxis.x, PxScrollAxis.y]).optional(),
+    source: px.enum([PxScrollSource.nearest, PxScrollSource.root]).optional(),
+    // Free-form: the two keywords `parent`/`scroller` plus any CSS selector.
+    subject: px.string().optional(),
+    smoothing: px.number().optional(),
+    pin: px.boolean().optional(),
+    pinAlign: px.enum([PxPinAlign.top, PxPinAlign.center, PxPinAlign.bottom]).optional(),
+    pinOffset: px.number().optional(),
+    pinDistance: px.number().optional(),
+    range: PxScrollRangeSchema.optional()
+  }));
+  var PxTimelinePinSchema = implementsInterface()(px.object({
+    align: px.enum([PxPinAlign.top, PxPinAlign.center, PxPinAlign.bottom]).optional(),
+    offset: px.number().optional(),
+    distance: px.number().optional()
+  }));
+  var PxTimelineEngineSchema = px.enum([PxTimelineEngineExtra.auto, PxTimelineEngineExtra.native, PxTimelineEngineExtra.js]).optional();
+  var PxTimeTimelineSchema = implementsInterface()(px.object({
+    type: px.literal("time").optional(),
+    engine: PxTimelineEngineSchema,
+    frameRate: px.number().optional(),
+    // §2.8: duration is a property of the TIMELINE — how long one pass takes.
+    duration: px.number().optional(),
+    trigger: PxTriggerSchema.optional(),
+    delay: px.number().optional(),
+    iterations: px.union([px.number(), px.literal("infinite")]).optional(),
+    // `fillMode` on the wire (CSS `animation-fill-mode`; the runtime view calls it `fill`)
+    // — never `fill`, which is paint everywhere else in the format.
+    fillMode: px.enum([PxFillMode.forwards, PxFillMode.backwards, PxFillMode.both, PxFillMode.none]).optional(),
+    direction: px.enum([PxPlaybackDirection.normal, PxPlaybackDirection.reverse, PxPlaybackDirection.alternate, PxPlaybackDirection.alternateReverse]).optional()
+  }));
+  var scrollishTimelineShape = {
+    // §2.8: duration is a property of the TIMELINE — under scrubbing it is the keyframe
+    // span the scroll range maps onto.
+    duration: px.number().optional(),
+    // Finite repeat count IS meaningful when scrubbing — the scroll range maps onto
+    // duration × iterations (rule D4; `'infinite'` cannot map to a range, so no literal here).
+    iterations: px.number().optional(),
+    engine: PxTimelineEngineSchema,
+    frameRate: px.number().optional(),
+    axis: px.enum([PxScrollAxis.block, PxScrollAxis.inline, PxScrollAxis.x, PxScrollAxis.y]).optional(),
+    source: px.enum([PxScrollSource.nearest, PxScrollSource.root]).optional(),
+    subject: px.string().optional(),
+    // 'parent' | 'scroller' | any CSS selector
+    smoothing: px.number().optional(),
+    // ms
+    pin: px.union([px.boolean(), PxTimelinePinSchema]).optional(),
+    range: PxScrollRangeSchema.optional()
+  };
+  var PxScrollTimelineSchema = implementsInterface()(
+    px.object(__spreadValues({ type: px.literal("scroll") }, scrollishTimelineShape))
+  );
+  var PxViewTimelineSchema = implementsInterface()(
+    px.object(__spreadValues({ type: px.literal("view") }, scrollishTimelineShape))
+  );
+  var PxTimelineSchema = px.discriminatedUnion("type", [
+    PxTimeTimelineSchema,
+    // first = the member an absent `type` selects
+    PxScrollTimelineSchema,
+    PxViewTimelineSchema
+  ]);
+  var PxAnimatorConfigSchema = implementsInterface()(px.object({
+    // (`mode`, `duration` and `frameRate` live INSIDE `timeline` on the wire — §2.8; they exist
+    // at this level only on the runtime view, like the rest of the playback dynamics.)
+    // THE spelling of "what advances progress" — clock / scroll / view (review §2.1).
+    timeline: PxTimelineSchema.optional(),
+    definitions: PxDefsSchema.optional(),
+    animateById: px.record(PxElementAnimationSchema).optional(),
+    debugGlobalName: px.string().optional(),
+    // Declared HERE because this is a closed object: an undeclared key would be stripped by
+    // `sanitize` and flagged by strict validation on our own files.
+    version: px.string().optional()
+  }));
+  var PxBindingSchema = implementsInterface()(px.object({
+    id: px.string(),
+    animate: PxElementAnimationSchema
+  }));
+  var PxAttrValueSchema = px.union([
+    px.string(),
+    px.number(),
+    px.array(px.number()),
+    // Structured static — `{value: …}` (read-accepted transitional spelling, S1).
+    // `defined`, not `any`: the KEY's presence is what identifies this branch (V6).
+    px.object({ value: px.defined() }),
+    // Bare transform parts record — the canonical static `transform` on the wire (T2).
+    PxTransformPartsSchema
+  ]);
+  var PxAnimatableNumberSchema = px.union([
+    px.number(),
+    PxPropertyAnimationSchema,
+    px.object({ value: px.number() })
+  ]);
+  var PxAnimatableVec2Schema = px.union([
+    px.tuple([px.number(), px.number()]),
+    PxPropertyAnimationSchema,
+    px.object({ value: px.tuple([px.number(), px.number()]) })
+  ]);
+  var PxAnimatableStringSchema = px.union([
+    px.string(),
+    PxPropertyAnimationSchema,
+    px.object({ value: px.string() })
+  ]);
+  var PxTransformByEffectSchema = implementsInterface()(px.object({
+    translate: PxAnimatableVec2Schema.optional(),
+    rotate: PxAnimatableNumberSchema.optional(),
+    scale: PxAnimatableVec2Schema.optional(),
+    skew: PxAnimatableNumberSchema.optional(),
+    origin: PxAnimatableVec2Schema.optional()
+  }));
+  var PxRepeaterEffectSchema = implementsInterface()(px.object({
+    // STATIC config, not a channel (V2/SCHEMA-DESIGN R5): the copy COUNT is read
+    // once at expansion time and never sampled — plain number, no `keyframes`.
+    copies: px.number().optional(),
+    translate: PxAnimatableVec2Schema.optional(),
+    rotate: PxAnimatableNumberSchema.optional(),
+    skew: PxAnimatableNumberSchema.optional(),
+    scale: PxAnimatableVec2Schema.optional(),
+    origin: PxAnimatableVec2Schema.optional()
+  }));
+  var PxMaskedByEffectSchema = implementsInterface()(px.object({
+    source: px.string().optional(),
+    maskType: px.enum([PxMaskType.luminance, PxMaskType.alpha]).optional(),
+    maskUnits: px.enum([PxUnits.userSpaceOnUse, PxUnits.objectBoundingBox]).optional(),
+    maskContentUnits: px.enum([PxUnits.userSpaceOnUse, PxUnits.objectBoundingBox]).optional(),
+    x: px.number().optional(),
+    y: px.number().optional(),
+    width: px.number().optional(),
+    height: px.number().optional()
+  }));
+  var PxClipPathEffectSchema = implementsInterface()(px.object({
+    pathData: PxAnimatableStringSchema.optional()
+  }));
+  var PxStrokeTrimEffectSchema = implementsInterface()(px.object({
+    offset: PxAnimatableNumberSchema.optional(),
+    range: PxAnimatableVec2Schema.optional(),
+    subPaths: px.enum([PxStrokeTrimSubPaths.separate, PxStrokeTrimSubPaths.combined]).optional()
+  }));
+  var PxRetimeEffectSchema = implementsInterface()(px.object({
+    start: px.number().optional(),
+    stretch: px.number().optional(),
+    timeCrop: px.tuple([px.number(), px.number()]).optional()
+  }));
+  var PxCloneEffectSchema = implementsInterface()(px.object({
+    // Subtractive on purpose: the `<use>` can only point at one wrapper layer of the
+    // source, so the choices form a ladder — 'translate' now, maybe 'transform' later.
+    without: px.enum([PxCloneWithout.translate]).optional(),
+    source: px.string().optional(),
+    retime: PxRetimeEffectSchema.optional()
+  }));
+  var PxGradientStopSchema = implementsInterface()(px.object({
+    offset: px.number(),
+    color: px.string()
+  }));
+  var PxAnimatableGradientStopsSchema = px.union([
+    px.array(PxGradientStopSchema),
+    px.object({ value: px.array(PxGradientStopSchema) }),
+    PxPropertyAnimationSchema
+  ]);
+  var PxFillGradientEffectSchema = implementsInterface()(px.object({
+    // Contextual kind — the `type` convention, see `PxNodeBase.type`.
+    type: px.enum([PxGradientType.linear, PxGradientType.radial]),
+    start: PxAnimatableVec2Schema.optional(),
+    end: PxAnimatableVec2Schema.optional(),
+    center: PxAnimatableVec2Schema.optional(),
+    radius: PxAnimatableNumberSchema.optional(),
+    focal: PxAnimatableVec2Schema.optional(),
+    stops: PxAnimatableGradientStopsSchema.optional(),
+    gradientUnits: px.enum([PxUnits.userSpaceOnUse, PxUnits.objectBoundingBox]).optional(),
+    spreadMethod: px.enum([PxGradientSpreadMethod.pad, PxGradientSpreadMethod.reflect, PxGradientSpreadMethod.repeat]).optional(),
+    gradientTransform: px.string().optional()
+  }));
+  var PxStrokeGradientEffectSchema = PxFillGradientEffectSchema;
+  var PxTextPathEffectSchema = implementsInterface()(px.object({
+    pathData: px.string(),
+    pathOverflow: px.enum([PxPathOverflow.clip, PxPathOverflow.extend]).optional(),
+    lengthAdjust: px.enum([PxLengthAdjust.spacing, PxLengthAdjust.spacingAndGlyphs]).optional(),
+    method: px.enum([PxTextPathMethod.align, PxTextPathMethod.stretch]).optional(),
+    spacing: px.enum([PxTextPathSpacing.auto, PxTextPathSpacing.exact]).optional(),
+    startOffset: PxAnimatableNumberSchema.optional(),
+    textLength: PxAnimatableNumberSchema.optional()
+  }));
+  var PxTextEffectSchema = implementsInterface()(px.object({
+    useGlyphs: px.boolean().optional()
+  }));
+  var PxEffectsSchema = implementsInterface()(px.object({
+    transformBy: PxTransformByEffectSchema.optional(),
+    repeater: PxRepeaterEffectSchema.optional(),
+    maskedBy: PxMaskedByEffectSchema.optional(),
+    clipPath: PxClipPathEffectSchema.optional(),
+    strokeTrim: PxStrokeTrimEffectSchema.optional(),
+    clone: PxCloneEffectSchema.optional(),
+    fillGradient: PxFillGradientEffectSchema.optional(),
+    strokeGradient: PxStrokeGradientEffectSchema.optional(),
+    textPath: PxTextPathEffectSchema.optional(),
+    text: PxTextEffectSchema.optional()
+  }));
+  var PxNodeBase = px.openObject({
+    // CONVENTION (SCHEMA-DESIGN R1 / issues N4): `type` is the ONE word for "what
+    // kind of thing is this", discriminated by its CARRIER — here the node TAG
+    // (`rect`, `text`), and inside a sub-object that object's kind (`fillGradient.type`,
+    // `fillGradient.type`, editor `preset.type`). Each sits in its own object, so
+    // the carrier disambiguates completely; synonyms (`cloneKind`, `presetShape`)
+    // would add words that all mean "type" and still need the carrier to read.
+    // Guarding a `type` SLOT against a wrong VALUE is the job of strict enums
+    // (issues V3), never of distinct key names.
+    type: px.string(),
+    // The escape hatch for elements that carry a REAL `type` attribute — `<feTurbulence
+    // type="fractalNoise">`, `<feFuncR type="table">`, `<feColorMatrix type="saturate">`.
+    // `type` is taken by the tag name, so the attribute travels here and the renderer puts
+    // it back (`PxAnimatorDOM.renderNode`, `PxRnRender`). Declared here — not merely
+    // documented — because a wire key that is not in a schema is invisible to the
+    // minifier's reserve list and gets renamed (MINIFICATION-BOUNDARY-PLAN.md §1.1).
+    domType: px.string().optional(),
+    // Text content of a `<text>` / `<tspan>`. Declared, so a non-string value is a schema error
+    // and the minifier reserves the key; `text` is NOT an alias for it and is not read anywhere.
+    textContent: px.string().optional(),
+    id: px.string().optional(),
+    meta: px.any().optional(),
+    // Player-effects bucket emitted by the Editor's lightweight design format.
+    // Consumed and removed by `applyPlayerEffects` before any other normalization
+    // (see `createAnimatorImpl`), so downstream code never sees it.
+    effects: PxEffectsSchema.optional(),
+    // `PxElementAnimation` (not just `PxAnimationDefinition`) — accepts
+    // string ref / array of refs / inline definition / mixed array; mirrors
+    // `animator.animateById` map values and what `processNode` resolves at runtime.
+    animate: PxElementAnimationSchema.optional(),
+    style: px.union([px.string(), px.record(px.union([px.string(), px.number()]))]).optional()
+  }, PxAttrValueSchema);
+  var PxNodeSchema = px.openObject(__spreadProps(__spreadValues({}, PxNodeBase._shape), {
+    children: px.lazy(() => px.array(PxNodeSchema), []).optional()
+  }), PxAttrValueSchema);
+  var PxSvgNodeExtra = px.object({
+    // `"100%"` and other SVG length strings are legal here — a number-only slot rejected
+    // real documents (e.g. apple-store-look-14-main.json) at the root <svg>.
+    width: px.union([px.number(), px.string()]).optional(),
+    height: px.union([px.number(), px.string()]).optional(),
+    viewBox: px.string().optional(),
+    animator: PxAnimatorConfigSchema.optional()
+  });
+  var PxAnimatedSvgDocumentSchema = px.openObject(__spreadProps(__spreadValues(__spreadValues({}, PxNodeBase._shape), PxSvgNodeExtra._shape), {
+    type: px.literal("svg"),
+    // override string → literal to require 'svg'
+    children: px.array(PxNodeSchema).optional()
+  }), PxAttrValueSchema);
+  var PxBezierPathSchema = implementsInterface()(px.object({
+    v: px.array(px.array(px.number())),
+    i: px.array(px.array(px.number())).optional(),
+    o: px.array(px.array(px.number())).optional(),
+    c: px.boolean().optional()
+  }));
+
+  // ../svg-animator-core/src/materialize/PxMotionPath.ts
+  function getKfTranslate(kf) {
+    const v = kfValue(kf);
     if (!v) return void 0;
     if (Array.isArray(v) && v.length >= 2 && typeof v[0] === "number" && typeof v[1] === "number") {
       return [v[0], v[1]];
@@ -570,31 +1603,27 @@ var PixodeskAnimator = (() => {
     return void 0;
   }
   function getKfTime(kf) {
-    var _a, _b;
-    return (_b = (_a = kf.time) != null ? _a : kf.t) != null ? _b : 0;
+    return kfTime(kf);
   }
   function getKfEasing(kf) {
-    var _a;
-    return (_a = kf.easing) != null ? _a : kf.e;
+    return kfEasing(kf);
   }
   function propAnimIsMotionPath(anim) {
-    var _a, _b;
     const kfs = anim.keyframes;
     if (!Array.isArray(kfs)) return false;
     if (anim.autoOrient) return true;
     for (const kf of kfs) {
-      if (((_a = kf.tangentIn) != null ? _a : kf.ti) || ((_b = kf.tangentOut) != null ? _b : kf.to)) return true;
+      if (kfTangentIn(kf) || kfTangentOut(kf)) return true;
     }
     return false;
   }
   var _segmentCache = /* @__PURE__ */ new WeakMap();
   function getSegmentCache(prevKf, nextKf, prevPos, nextPos) {
-    var _a, _b;
     let byNext = _segmentCache.get(prevKf);
     const existing = byNext == null ? void 0 : byNext.get(nextKf);
     if (existing) return existing;
-    const to = (_a = prevKf.tangentOut) != null ? _a : prevKf.to;
-    const ti = (_b = nextKf.tangentIn) != null ? _b : nextKf.ti;
+    const to = kfTangentOut(prevKf);
+    const ti = kfTangentIn(nextKf);
     const P1 = [prevPos[0] + (to ? to[0] : 0), prevPos[1] + (to ? to[1] : 0)];
     const P2 = [nextPos[0] + (ti ? ti[0] : 0), nextPos[1] + (ti ? ti[1] : 0)];
     const lut = bezier2D_arcLengthLUT(prevPos, P1, P2, nextPos);
@@ -616,7 +1645,7 @@ var PixodeskAnimator = (() => {
   var DEFAULT_FLATNESS_TOL = 0.5;
   var DEFAULT_ROTATION_TOL = 5;
   var DEFAULT_MAX_SAMPLES = 32;
-  function materialiseMotionPathInPropAnim(anim, opts) {
+  function materializeMotionPathInPropAnim(anim, opts) {
     var _a, _b, _c;
     if (!propAnimIsMotionPath(anim)) return anim;
     const kfs = anim.keyframes;
@@ -648,7 +1677,7 @@ var PixodeskAnimator = (() => {
       if (autoOrient && i > 0) {
         insertSharpCornerStepKfIfNeeded(out, prevKf, nextKf, prevPos, nextPos, rotationTol);
       }
-      materialiseSegment(out, prevKf, nextKf, prevPos, nextPos, autoOrient, flatnessTol, rotationTol, maxSamples);
+      materializeSegment(out, prevKf, nextKf, prevPos, nextPos, autoOrient, flatnessTol, rotationTol, maxSamples);
     }
     const lastInE = getKfEasing(kfs[kfs.length - 1]);
     if (lastInE) out[out.length - 1].e = lastInE;
@@ -658,10 +1687,9 @@ var PixodeskAnimator = (() => {
     return result;
   }
   function unwrapAutoOrientRotations(kfs) {
-    var _a;
     let prev;
     for (const kf of kfs) {
-      const v = (_a = kf.v) != null ? _a : kf.value;
+      const v = kfValue(kf);
       if (!v || typeof v.rotate !== "number") continue;
       if (prev === void 0) {
         prev = v.rotate;
@@ -678,8 +1706,7 @@ var PixodeskAnimator = (() => {
     return { t: time, v: value };
   }
   function getKfValueParts(kf) {
-    var _a;
-    const v = (_a = kf.value) != null ? _a : kf.v;
+    const v = kfValue(kf);
     if (!v || typeof v !== "object" || Array.isArray(v)) return void 0;
     return v;
   }
@@ -740,9 +1767,8 @@ var PixodeskAnimator = (() => {
     return d;
   }
   function insertSharpCornerStepKfIfNeeded(out, prevKf, nextKf, prevPos, nextPos, rotationTol) {
-    var _a;
     const lastKf = out[out.length - 1];
-    const lastV = (_a = lastKf.v) != null ? _a : lastKf.value;
+    const lastV = kfValue(lastKf);
     const prevExit = lastV == null ? void 0 : lastV.rotate;
     if (typeof prevExit !== "number") return;
     const boundaryV = getKfValueParts(prevKf);
@@ -765,7 +1791,7 @@ var PixodeskAnimator = (() => {
     out.push(makeOutKf(stepTime, dupValue));
   }
   var CORNER_STEP_AFTER_BOUNDARY_MS = 0.05;
-  function materialiseSegment(out, prevKf, nextKf, prevPos, nextPos, autoOrient, flatnessTol, rotationTol, maxSamples) {
+  function materializeSegment(out, prevKf, nextKf, prevPos, nextPos, autoOrient, flatnessTol, rotationTol, maxSamples) {
     const seg = getSegmentCache(prevKf, nextKf, prevPos, nextPos);
     const prevTime = getKfTime(prevKf);
     const nextTime = getKfTime(nextKf);
@@ -889,7 +1915,7 @@ var PixodeskAnimator = (() => {
     return Math.abs(cross) / Math.sqrt(len2);
   }
 
-  // ../svg-animator-core/src/PxDefinitions.ts
+  // ../svg-animator-core/src/animation/PxDefinitions.ts
   var LOOP_JUMP_SHIFT_MS = 1;
   function deepEqualValue(a, b) {
     if (a === b) return true;
@@ -981,8 +2007,8 @@ var PixodeskAnimator = (() => {
     return typeof value === "string" && extractPathData(value) !== void 0;
   }
   function normalizePathValue(value) {
-    if (value && typeof value === "object" && typeof value.path === "string") {
-      const d = extractPathData(value.path);
+    if (value && typeof value === "object" && typeof value.pathData === "string") {
+      const d = extractPathData(value.pathData);
       return d ? { paths: parseSvgPathToBezier(d) } : value;
     }
     if (value && typeof value === "object" && "paths" in value) {
@@ -990,8 +2016,8 @@ var PixodeskAnimator = (() => {
       if (Array.isArray(pathsArray) && pathsArray.length > 0) {
         if (isPathString(pathsArray[0])) {
           const paths = [];
-          for (const pathStr of pathsArray) {
-            const d = extractPathData(pathStr);
+          for (const pathStr2 of pathsArray) {
+            const d = extractPathData(pathStr2);
             if (d) {
               paths.push(...parseSvgPathToBezier(d));
             }
@@ -1004,8 +2030,8 @@ var PixodeskAnimator = (() => {
     if (Array.isArray(value)) {
       if (value.length > 0 && isPathString(value[0])) {
         const paths = [];
-        for (const pathStr of value) {
-          const d = extractPathData(pathStr);
+        for (const pathStr2 of value) {
+          const d = extractPathData(pathStr2);
           if (d) {
             paths.push(...parseSvgPathToBezier(d));
           }
@@ -1066,7 +2092,7 @@ var PixodeskAnimator = (() => {
       const bPaths = (_b = b == null ? void 0 : b.paths) != null ? _b : Array.isArray(b) ? b : [];
       return { paths: interpolateBeziers(aPaths, bPaths, t) };
     }
-    if (COLOUR_ATTR_NAMES.has(propName)) {
+    if (COLOR_ATTR_NAMES.has(propName)) {
       return interpolateColor(a || [0, 0, 0, 1], b || [0, 0, 0, 1], t);
     }
     if (propName === "transform" && typeof a === "object" && a !== null && !Array.isArray(a) && typeof b === "object" && b !== null && !Array.isArray(b)) {
@@ -1102,7 +2128,7 @@ var PixodeskAnimator = (() => {
     const totalIntervals = keyframes.length - 1;
     const segCount = clamp((_a = loop.segmentCount) != null ? _a : totalIntervals, 1, totalIntervals);
     let segKfs;
-    if (loop.extend === PxLoopExtend.before) {
+    if (loop.repeatAt === PxLoopRepeatAt.start) {
       segKfs = keyframes.slice(0, segCount + 1);
     } else {
       segKfs = keyframes.slice(totalIntervals - segCount);
@@ -1110,7 +2136,7 @@ var PixodeskAnimator = (() => {
     const firstT = (_b = keyframes[0].t) != null ? _b : 0;
     const lastT = (_c = keyframes[keyframes.length - 1].t) != null ? _c : 0;
     let fillStart, fillEnd;
-    if (loop.extend === PxLoopExtend.before) {
+    if (loop.repeatAt === PxLoopRepeatAt.start) {
       fillStart = 0;
       fillEnd = firstT;
     } else {
@@ -1123,21 +2149,18 @@ var PixodeskAnimator = (() => {
     const segEndT = (_e = segKfs[segKfs.length - 1].t) != null ? _e : 0;
     const segDuration = segEndT - segStartT;
     if (segDuration <= 0) return keyframes;
-    const template = segKfs.map((kf) => {
-      var _a2, _b2;
-      return {
-        relT: (kf.t - segStartT) / segDuration,
-        v: kf.v,
-        e: kf.e,
-        tangentIn: (_a2 = kf.tangentIn) != null ? _a2 : kf.ti,
-        tangentOut: (_b2 = kf.tangentOut) != null ? _b2 : kf.to
-      };
-    });
+    const template = segKfs.map((kf) => ({
+      relT: (kf.t - segStartT) / segDuration,
+      v: kf.v,
+      e: kf.e,
+      tangentIn: kfTangentIn(kf),
+      tangentOut: kfTangentOut(kf)
+    }));
     const fullReps = Math.floor(fillDuration / segDuration);
     const remainder = fillDuration - fullReps * segDuration;
     const partialFraction = remainder / segDuration;
     const looped = [];
-    const separateBoundary = loop.extend !== PxLoopExtend.before;
+    const separateBoundary = loop.repeatAt !== PxLoopRepeatAt.start;
     const originalTerminalKf = keyframes[keyframes.length - 1];
     let terminalEasingOverride;
     let hasTerminalEasingOverride = false;
@@ -1245,30 +2268,30 @@ var PixodeskAnimator = (() => {
         looped.push(pushed);
       }
     }
-    if (loop.extend === PxLoopExtend.before) {
+    if (loop.repeatAt === PxLoopRepeatAt.start) {
       if (partialFraction > 1e-9) {
-        const isReversed = !!loop.alternate && fullReps % 2 === 0;
+        const isReversed = loop.direction === PxLoopDirection.alternate && fullReps % 2 === 0;
         appendRepTail(fillStart, isReversed, partialFraction);
       }
       for (let rep = 0; rep < fullReps; rep++) {
         const distFromBoundary = fullReps - 1 - rep;
-        const isReversed = !!loop.alternate && distFromBoundary % 2 === 0;
+        const isReversed = loop.direction === PxLoopDirection.alternate && distFromBoundary % 2 === 0;
         const repStart = fillStart + remainder + rep * segDuration;
         appendRep(repStart, isReversed);
       }
     } else {
       for (let rep = 0; rep < fullReps; rep++) {
-        const isReversed = !!loop.alternate && rep % 2 === 0;
+        const isReversed = loop.direction === PxLoopDirection.alternate && rep % 2 === 0;
         const repStart = fillStart + rep * segDuration;
         appendRep(repStart, isReversed);
       }
       if (partialFraction > 1e-9) {
-        const isReversed = !!loop.alternate && fullReps % 2 === 0;
+        const isReversed = loop.direction === PxLoopDirection.alternate && fullReps % 2 === 0;
         const repStart = fillStart + fullReps * segDuration;
         appendRep(repStart, isReversed, partialFraction);
       }
     }
-    if (loop.extend === PxLoopExtend.before) {
+    if (loop.repeatAt === PxLoopRepeatAt.start) {
       return [...looped, ...keyframes];
     } else {
       if (hasTerminalEasingOverride && keyframes.length > 0) {
@@ -1280,34 +2303,34 @@ var PixodeskAnimator = (() => {
     }
   }
   function normalizeKeyframes(propName, propAnim, duration, defs) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a;
     const keyframes = propAnim.keyframes || [];
     const normalized = [];
     for (const kf of keyframes) {
-      const timePct = (_b = (_a = kf.time) != null ? _a : kf.t) != null ? _b : 0;
-      let value = (_c = kf.value) != null ? _c : kf.v;
-      const easing = (_d = kf.easing) != null ? _d : kf.e;
+      const timePct = kfTime(kf);
+      let value = kfValue(kf);
+      const easing = kfEasing(kf);
       if (propName === "d") {
         value = normalizePathValue(value);
       }
       const propNameKebab = isCamelCaseWord(propName) ? camelCaseToKebabWordIfNeeded(propName) : propName;
-      if (COLOUR_ATTR_NAMES.has(propNameKebab)) {
-        value = (_e = parseColor(value)) != null ? _e : value;
+      if (COLOR_ATTR_NAMES.has(propNameKebab)) {
+        value = (_a = parseColor(value)) != null ? _a : value;
       }
       const normKf = {
         t: timePct,
         v: value,
         e: resolveEasing(easing, defs)
       };
-      const tIn = (_f = kf.tangentIn) != null ? _f : kf.ti;
-      const tOut = (_g = kf.tangentOut) != null ? _g : kf.to;
+      const tIn = kfTangentIn(kf);
+      const tOut = kfTangentOut(kf);
       if (tIn) normKf.tangentIn = tIn;
       if (tOut) normKf.tangentOut = tOut;
       normalized.push(normKf);
     }
     normalized.sort((a, b) => {
-      var _a2, _b2;
-      return ((_a2 = a.t) != null ? _a2 : 0) - ((_b2 = b.t) != null ? _b2 : 0);
+      var _a2, _b;
+      return ((_a2 = a.t) != null ? _a2 : 0) - ((_b = b.t) != null ? _b : 0);
     });
     const loopRaw = propAnim.loop;
     const loop = loopRaw === true ? {} : loopRaw || void 0;
@@ -1334,7 +2357,7 @@ var PixodeskAnimator = (() => {
     const staticParts = staticTransform && typeof staticTransform === "object" && !Array.isArray(staticTransform) ? staticTransform : parseTransformParts(staticTransform);
     if (!staticParts || !Object.keys(staticParts).length) return animDef;
     const mergeKfValue = (v) => v && typeof v === "object" && !Array.isArray(v) ? __spreadValues(__spreadValues({}, staticParts), v) : v;
-    const transformAnim = animDef["transform"];
+    const transformAnim = animDef[TRANSFORM_ATTR];
     if (transformAnim && typeof transformAnim === "object") {
       const anim = transformAnim;
       if (Array.isArray(anim.keyframes)) {
@@ -1359,7 +2382,7 @@ var PixodeskAnimator = (() => {
     delete rest[ch];
     return __spreadProps(__spreadValues({}, rest), { transform: lifted });
   }
-  function normalizeAnimationDefinition(animDef, duration, defs, engine = PxAnimatorEngine.waapi) {
+  function normalizeAnimationDefinition(animDef, duration, defs, engine = PxTimelineEngine.native) {
     const normalized = {};
     for (const [propName, propAnim] of Object.entries(animDef)) {
       if (propName === "transform" && propAnim.alongPathMode === "offsetPath" && animDef["offsetDistance"] !== void 0) {
@@ -1370,12 +2393,12 @@ var PixodeskAnimator = (() => {
         const out = { keyframes: normalizedKfs };
         if (propAnim.autoOrient !== void 0) out.autoOrient = propAnim.autoOrient;
         if (propAnim.loop !== void 0) out.loop = propAnim.loop;
-        normalized[propName] = engine === PxAnimatorEngine.waapi && propName === "transform" ? materialiseMotionPathInPropAnim(out) : out;
+        normalized[propName] = engine === PxTimelineEngine.native && propName === "transform" ? materializeMotionPathInPropAnim(out) : out;
       }
     }
     return normalized;
   }
-  function getNormalisedBindings(doc, engine = PxAnimatorEngine.waapi) {
+  function getNormalizedBindings(doc, engine = PxTimelineEngine.native) {
     const animatorConfig = getAnimatorConfig(doc) || {};
     const defs = getDefs(doc);
     const duration = animatorConfig.duration || 1e3;
@@ -1421,13 +2444,116 @@ var PixodeskAnimator = (() => {
     return bindings;
   }
 
-  // src/PxAnimatorTriggers.ts
-  function setupAnimationTriggers(api, config) {
-    const { startOn, outAction = "continue", scrollIntoViewThreshold = 0 } = config;
+  // ../svg-animator-core/src/playback/PxPlaybackTime.ts
+  var PX_RATE_REJECTED = "setPlaybackRate: rate must be finite and non-zero";
+  function isValidPlaybackRate(rate) {
+    return Number.isFinite(rate) && rate !== 0;
+  }
+  function seekCeilingMs(durationMs, iterations) {
+    if (!(durationMs > 0)) return 0;
+    if (iterations === Infinity) return Infinity;
+    return durationMs * (iterations > 0 ? iterations : 1);
+  }
+  function progressSpanMs(durationMs, iterations) {
+    if (!(durationMs > 0)) return 0;
+    if (iterations === Infinity) return durationMs;
+    return durationMs * (iterations > 0 ? iterations : 1);
+  }
+  function clampSeekMs(timeMs, ceilingMs) {
+    if (Number.isNaN(timeMs) || timeMs < 0) return 0;
+    if (Number.isFinite(ceilingMs)) return timeMs > ceilingMs ? ceilingMs : timeMs;
+    return Number.isFinite(timeMs) ? timeMs : 0;
+  }
+  function timeToProgress(timeMs, durationMs, iterations) {
+    const span = progressSpanMs(durationMs, iterations);
+    if (!(span > 0) || !Number.isFinite(timeMs)) return 0;
+    if (timeMs <= 0) return 0;
+    if (iterations === Infinity) return timeMs % span / span;
+    return timeMs >= span ? 1 : timeMs / span;
+  }
+  function progressToTimeMs(progress, durationMs, iterations) {
+    const span = progressSpanMs(durationMs, iterations);
+    if (!(span > 0) || !Number.isFinite(progress)) return 0;
+    if (progress <= 0) return 0;
+    return progress >= 1 ? span : progress * span;
+  }
+
+  // ../svg-animator-core/src/playback/PxDiagnostics.ts
+  var PxDiagnosticKind = {
+    /** The document is wrong — regenerate or repair the file. */
+    document: "document",
+    /** The page or app cannot provide what the document asks for — fix the mount. */
+    host: "host",
+    /** The platform cannot do it and the player degraded — usually nothing to fix. */
+    platform: "platform",
+    /** The call is wrong or self-contradictory — fix the options or props you passed. */
+    usage: "usage",
+    /** The player failed where it did not expect to — report it to us. */
+    internal: "internal"
+  };
+  function asError(error) {
+    return typeof error === "string" ? new Error(error) : error;
+  }
+  function isSilenced(silent, kind) {
+    if (!silent) return false;
+    return silent === true || silent.includes(kind);
+  }
+  function createDiagnostics(config, prefix) {
+    const tag = prefix ? prefix + " " : "";
+    return {
+      warn: (kind, message, detail) => {
+        if (config == null ? void 0 : config.onWarn) {
+          config.onWarn({ kind, message, detail });
+          return;
+        }
+        if (isSilenced(config == null ? void 0 : config.silent, kind)) return;
+        const line = tag + kind + ": " + message;
+        if (detail === void 0) console.warn(line);
+        else console.warn(line, detail);
+      },
+      error: (kind, error) => {
+        const err = asError(error);
+        if (config == null ? void 0 : config.onError) {
+          config.onError({ kind, message: err.message, error: err });
+          return;
+        }
+        if (isSilenced(config == null ? void 0 : config.silent, kind)) return;
+        console.error(tag + kind + ": " + err.message);
+      }
+    };
+  }
+
+  // src/shared/PxAnimatorCallbacks.ts
+  function toEngineCallbacks(inline) {
+    const { onPlay, onPause, onCancel, onFinish, onRemove, onStop, onWarn, onError, silent } = inline != null ? inline : {};
+    const withStop = (own) => own || onStop ? () => {
+      own == null ? void 0 : own();
+      onStop == null ? void 0 : onStop();
+    } : void 0;
+    return {
+      onPlay,
+      onPause: withStop(onPause),
+      onCancel: withStop(onCancel),
+      onFinish: withStop(onFinish),
+      onRemove: withStop(onRemove),
+      onWarn,
+      onError,
+      silent
+    };
+  }
+
+  // src/triggers/PxAnimatorTriggers.ts
+  function setupAnimationTriggers(api, config, diag) {
+    const report = diag != null ? diag : createDiagnostics(void 0, "[PxAnimator]");
+    const cleanups = [];
+    const dispose = () => {
+      for (const undo of cleanups.splice(0)) undo();
+    };
+    const { startOn, outAction, scrollIntoViewThreshold } = resolveTrigger(config);
     const root = api.getRootElement();
     if (!root) {
-      console.warn("setupAnimationTriggers: No root element found for animation.");
-      return api;
+      report.warn(PxDiagnosticKind.host, "setupAnimationTriggers: No root element found for animation.");
+      return dispose;
     }
     let reversed = false;
     const start = () => {
@@ -1462,6 +2588,7 @@ var PixodeskAnimator = (() => {
           startHandler();
         } else {
           window.addEventListener("load", startHandler, { once: true });
+          cleanups.push(() => window.removeEventListener("load", startHandler));
         }
         break;
       }
@@ -1476,6 +2603,10 @@ var PixodeskAnimator = (() => {
         };
         root.addEventListener("mouseenter", mouseOverHandler);
         root.addEventListener("mouseleave", mouseOutHandler);
+        cleanups.push(() => {
+          root.removeEventListener("mouseenter", mouseOverHandler);
+          root.removeEventListener("mouseleave", mouseOutHandler);
+        });
         break;
       }
       case "click": {
@@ -1487,6 +2618,7 @@ var PixodeskAnimator = (() => {
           }
         };
         root.addEventListener("click", clickHandler);
+        cleanups.push(() => root.removeEventListener("click", clickHandler));
         break;
       }
       case "scrollIntoView": {
@@ -1518,31 +2650,31 @@ var PixodeskAnimator = (() => {
           { threshold: thresholdSteps }
         );
         observer.observe(root);
+        cleanups.push(() => observer.disconnect());
         break;
       }
       case "programmatic":
         break;
     }
-    return api;
+    return dispose;
   }
 
-  // src/PxAnimatorFrameLoop.ts
+  // src/engines/PxAnimatorFrameLoop.ts
   function getSelector(id) {
     return "#" + id;
   }
 
-  // src/PxAnimatorWebApi.ts
+  // src/engines/PxAnimatorWebApi.ts
   function createCssKf(kf, t, propName, unsupportedSet) {
-    var _a, _b;
-    let value = (_a = kf.v) != null ? _a : kf.value;
-    const e = (_b = kf.e) != null ? _b : kf.easing;
+    let value = kfValue(kf);
+    const e = kfEasing(kf);
     const cssKf = {
       offset: t,
       easing: e && Array.isArray(e) ? "cubic-bezier(" + e.join(",") + ")" : void 0
     };
     let cssValue;
     let cssKey = propName;
-    if (COLOUR_ATTR_NAMES.has(propName) && Array.isArray(value)) {
+    if (COLOR_ATTR_NAMES.has(propName) && Array.isArray(value)) {
       cssValue = toRGBA(value);
     } else if (propName === "transform" && value !== null && typeof value === "object" && !Array.isArray(value)) {
       cssValue = composeTransformParts(value, { withUnits: true });
@@ -1629,18 +2761,19 @@ var PixodeskAnimator = (() => {
     return result;
   }
   function createWebApiAnimator(doc, callbacks, rootElement, forceEvenIfHasUnsupportedAttrs, scrollTimeline) {
-    var _a;
+    var _a, _b;
     const config = getAnimatorConfig(doc) || {};
+    const diag = createDiagnostics(callbacks, "[PxAnimator]");
     if (!rootElement) {
       if (doc.id) {
         const rootSelector = getSelector(doc.id);
         rootElement = document.querySelector(rootSelector);
-        if (!rootElement) console.warn("createFrameLoopAnimator: No root element found for selector: ", rootSelector);
+        if (!rootElement) diag.warn(PxDiagnosticKind.host, "createWebApiAnimator: No root element found for selector: " + rootSelector);
       } else {
-        console.warn("createFrameLoopAnimator: No root element provided");
+        diag.warn(PxDiagnosticKind.host, "createWebApiAnimator: No root element provided");
       }
     }
-    const bindings = getNormalisedBindings(doc, PxAnimatorEngine.waapi);
+    const bindings = getNormalizedBindings(doc, PxTimelineEngine.native);
     const animations = [];
     const _iterations = config.iterations;
     let iterations;
@@ -1650,18 +2783,18 @@ var PixodeskAnimator = (() => {
     let finishNotified = false;
     let removeCalled = false;
     if (!(bindings == null ? void 0 : bindings.length)) {
-      console.warn("createWebApiAnimator: No animation bindings defined");
+      diag.warn(PxDiagnosticKind.document, "createWebApiAnimator: No animation bindings defined");
     }
     for (const binding of bindings || []) {
       const animDef = binding.animate;
       if (!animDef || typeof animDef !== "object" || Array.isArray(animDef)) {
-        console.warn("createWebApiAnimator: Empty or unresolved binding", binding);
+        diag.warn(PxDiagnosticKind.document, "createWebApiAnimator: Empty or unresolved binding", binding);
         continue;
       }
       const selector = getSelector(binding.id);
       const elements = (rootElement == null ? void 0 : rootElement.querySelectorAll(selector)) || document.querySelectorAll(selector);
       if (elements.length === 0) {
-        console.warn('createWebApiAnimator: No elements found for selector "' + selector + '"');
+        diag.warn(PxDiagnosticKind.host, 'createWebApiAnimator: No elements found for selector "' + selector + '"');
       }
       const keyframesMap = convertToWebApiKeyframes(animDef, unsupportedSet, config);
       const positiveDelay = config.delay && config.delay > 0 ? config.delay : void 0;
@@ -1710,14 +2843,14 @@ var PixodeskAnimator = (() => {
               }
               animations.push(anim);
             } catch (e) {
-              console.warn(e);
+              diag.warn(PxDiagnosticKind.internal, "createWebApiAnimator: could not build the animation", e);
             }
           }
         }
       }
     }
     if (!forceEvenIfHasUnsupportedAttrs && unsupportedSet.size) {
-      console.warn("Unsupported CSS attrs: " + [...unsupportedSet].join(", "));
+      diag.warn(PxDiagnosticKind.platform, "Unsupported CSS attrs: " + [...unsupportedSet].join(", "));
       return null;
     }
     const api = {
@@ -1761,20 +2894,36 @@ var PixodeskAnimator = (() => {
         }
       },
       "setPlaybackRate": (rate) => {
+        if (!isValidPlaybackRate(rate)) {
+          diag.warn(PxDiagnosticKind.usage, PX_RATE_REJECTED);
+          return api;
+        }
         animations.forEach((a) => a.playbackRate = rate);
         return api;
       },
       "getCurrentTime": () => {
-        var _a2, _b;
-        const res = (_b = (_a2 = animations[0]) == null ? void 0 : _a2.currentTime) != null ? _b : null;
+        var _a2, _b2;
+        const res = (_b2 = (_a2 = animations[0]) == null ? void 0 : _a2.currentTime) != null ? _b2 : null;
         return res !== null ? +res : null;
       },
       "setCurrentTime": (time) => {
+        var _a2;
+        const ceiling = seekCeilingMs((_a2 = config.duration) != null ? _a2 : 0, iterations != null ? iterations : 1);
+        const seek = ceiling > 0 ? clampSeekMs(time, ceiling) : Math.max(0, time);
         finishNotified = false;
         animations.forEach((a) => {
-          a.currentTime = time;
+          a.currentTime = seek;
         });
       },
+      "getCurrentProgress": () => {
+        var _a2;
+        const t = api.getCurrentTime();
+        return t === null ? null : timeToProgress(t, (_a2 = config.duration) != null ? _a2 : 0, iterations != null ? iterations : 1);
+      },
+      "setCurrentProgress": (progress) => {
+        var _a2;
+        api.setCurrentTime(progressToTimeMs(progress, (_a2 = config.duration) != null ? _a2 : 0, iterations != null ? iterations : 1));
+      },
       "destroy": () => {
         var _a2;
         api.cancel();
@@ -1785,12 +2934,15 @@ var PixodeskAnimator = (() => {
         }
       }
     };
-    if (config.trigger) {
-      if (config.timelineSource === "scroll") {
-        console.warn("scroll timeline: `animator.trigger` is ignored (triggers do not apply to scroll-driven playback)");
-      } else {
-        setupAnimationTriggers(api, config.trigger);
-      }
+    if (config.timelineSource === "scroll") {
+      if (config.trigger) diag.warn(PxDiagnosticKind.usage, "scroll timeline: `animator.trigger` is ignored (triggers do not apply to scroll-driven playback)");
+    } else {
+      const detachTriggers = setupAnimationTriggers(api, (_b = config.trigger) != null ? _b : {}, diag);
+      const destroyEngine = api.destroy.bind(api);
+      api.destroy = () => {
+        detachTriggers();
+        destroyEngine();
+      };
     }
     if (scrollTimeline) {
       animations.forEach((a) => a.play());
@@ -1798,7 +2950,7 @@ var PixodeskAnimator = (() => {
     return api;
   }
 
-  // src/PxAnimatorBind.ts
+  // src/engines/PxAnimatorBind.ts
   function finaliseAnimator(animatorConfig, callbacks, make) {
     let apiRef;
     let effectiveCallbacks = callbacks;
@@ -1813,27 +2965,27 @@ var PixodeskAnimator = (() => {
     }
     const res = make(effectiveCallbacks);
     apiRef = res;
-    if (animatorConfig.debugInstName) {
-      window[animatorConfig.debugInstName] = res;
+    if (animatorConfig.debugGlobalName) {
+      window[animatorConfig.debugGlobalName] = res;
     }
     return res;
   }
-  function requireData(options) {
-    if (!(options == null ? void 0 : options.data)) throw new Error("createAnimator: `data` is required");
-    return options.data;
+  function requireDoc(options) {
+    if (!(options == null ? void 0 : options.doc)) throw new Error("createAnimator: `doc` is required");
+    return options.doc;
   }
   function createPrerenderedWaapiAnimator(options) {
-    const doc = requireData(options);
+    const doc = requireDoc(options);
     const animatorConfig = getAnimatorConfig(doc) || {};
     return finaliseAnimator(
       animatorConfig,
-      options.callbacks,
+      toEngineCallbacks(options),
       (cb) => createWebApiAnimator(doc, cb, null, true)
     );
   }
 
-  // src/PxAnimatorKeys.ts
-  var PX_ANIMATOR_DATA_KEY = "data";
+  // src/shared/PxAnimatorKeys.ts
+  var PX_ANIMATOR_DOC_KEY = "doc";
   return __toCommonJS(index_prerendered_waapi_exports);
 })();
 //# sourceMappingURL=index.prerendered-waapi.umd.js.map