@pixodesk/svg-animator-core 1.0.35 → 1.0.39

package/dist/index.cjs

@@ -51,7 +51,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   BASELINE_PLAYER_VERSION: () => BASELINE_PLAYER_VERSION,
-  COLOUR_ATTR_NAMES: () => COLOUR_ATTR_NAMES,
+  COLOR_ATTR_NAMES: () => COLOR_ATTR_NAMES,
   CSS_ONLY_STYLE_PROPS: () => CSS_ONLY_STYLE_PROPS,
   DEFAULT_DURATION_MS: () => DEFAULT_DURATION_MS,
   DISALLOWED_SVG_TAGS_LOWER: () => DISALLOWED_SVG_TAGS_LOWER,
@@ -64,45 +64,65 @@ __export(index_exports, {
   PX_ANIM_ATTR_NAME: () => PX_ANIM_ATTR_NAME,
   PX_ANIM_SRC_ATTR_NAME: () => PX_ANIM_SRC_ATTR_NAME,
   PX_PLAYER_SCHEMA_VERSION: () => PX_PLAYER_SCHEMA_VERSION,
+  PX_RATE_REJECTED: () => PX_RATE_REJECTED,
   PX_TRANSFORM_PART_KEYS: () => PX_TRANSFORM_PART_KEYS,
+  PX_TRIGGER_DEFAULTS: () => PX_TRIGGER_DEFAULTS,
   PX_UNKNOWN_KEY_ERROR: () => PX_UNKNOWN_KEY_ERROR,
+  PxAlongPathMode: () => PxAlongPathMode,
   PxAnimatedSvgDocumentSchema: () => PxAnimatedSvgDocumentSchema,
   PxAnimationDefinitionSchema: () => PxAnimationDefinitionSchema,
   PxAnimatorConfigSchema: () => PxAnimatorConfigSchema,
   PxAttrValueSchema: () => PxAttrValueSchema,
   PxBezierPathSchema: () => PxBezierPathSchema,
   PxBindingSchema: () => PxBindingSchema,
+  PxClipPathEffectSchema: () => PxClipPathEffectSchema,
   PxCloneEffectSchema: () => PxCloneEffectSchema,
   PxCloneWithout: () => PxCloneWithout,
+  PxControlMode: () => PxControlMode,
   PxDefsSchema: () => PxDefsSchema,
+  PxDiagnosticKind: () => PxDiagnosticKind,
   PxEasingOrRefSchema: () => PxEasingOrRefSchema,
   PxEffectsSchema: () => PxEffectsSchema,
   PxElementAnimationSchema: () => PxElementAnimationSchema,
   PxFillGradientEffectSchema: () => PxFillGradientEffectSchema,
+  PxFillMode: () => PxFillMode,
+  PxFinishAction: () => PxFinishAction,
   PxGradientSpreadMethod: () => PxGradientSpreadMethod,
   PxGradientStopSchema: () => PxGradientStopSchema,
   PxGradientType: () => PxGradientType,
-  PxGradientUnits: () => PxGradientUnits,
   PxKeyframeSchema: () => PxKeyframeSchema,
   PxKeyframeValueSchema: () => PxKeyframeValueSchema,
+  PxLengthAdjust: () => PxLengthAdjust,
   PxLoopDirection: () => PxLoopDirection,
   PxLoopRepeatAt: () => PxLoopRepeatAt,
   PxLoopSchema: () => PxLoopSchema,
+  PxMaskType: () => PxMaskType,
   PxMaskedByEffectSchema: () => PxMaskedByEffectSchema,
   PxNodeBase: () => PxNodeBase,
   PxNodeSchema: () => PxNodeSchema,
+  PxOutAction: () => PxOutAction,
+  PxPathOverflow: () => PxPathOverflow,
+  PxPinAlign: () => PxPinAlign,
+  PxPlaybackDirection: () => PxPlaybackDirection,
   PxPropertyAnimationSchema: () => PxPropertyAnimationSchema,
   PxRepeaterEffectSchema: () => PxRepeaterEffectSchema,
   PxRetimeEffectSchema: () => PxRetimeEffectSchema,
+  PxScrollAxis: () => PxScrollAxis,
+  PxScrollKind: () => PxScrollKind,
+  PxScrollPhase: () => PxScrollPhase,
   PxScrollRangePointSchema: () => PxScrollRangePointSchema,
   PxScrollRangeSchema: () => PxScrollRangeSchema,
   PxScrollSchema: () => PxScrollSchema,
+  PxScrollSource: () => PxScrollSource,
+  PxStartOn: () => PxStartOn,
   PxStrokeGradientEffectSchema: () => PxStrokeGradientEffectSchema,
   PxStrokeTrimEffectSchema: () => PxStrokeTrimEffectSchema,
   PxStrokeTrimSubPaths: () => PxStrokeTrimSubPaths,
   PxSvgNodeExtra: () => PxSvgNodeExtra,
   PxTextEffectSchema: () => PxTextEffectSchema,
   PxTextPathEffectSchema: () => PxTextPathEffectSchema,
+  PxTextPathMethod: () => PxTextPathMethod,
+  PxTextPathSpacing: () => PxTextPathSpacing,
   PxTimelineEngine: () => PxTimelineEngine,
   PxTimelineEngineExtra: () => PxTimelineEngineExtra,
   PxTimelinePinSchema: () => PxTimelinePinSchema,
@@ -111,8 +131,8 @@ __export(index_exports, {
   PxTransformPartsSchema: () => PxTransformPartsSchema,
   PxTransformValueSchema: () => PxTransformValueSchema,
   PxTriggerSchema: () => PxTriggerSchema,
+  PxUnits: () => PxUnits,
   STYLE_ATTR_NAMES: () => STYLE_ATTR_NAMES,
-  TEXT_ATTR: () => TEXT_ATTR,
   TEXT_CONTENT_ATTR: () => TEXT_CONTENT_ATTR,
   TRANSFORM_FN_NAMES: () => TRANSFORM_FN_NAMES,
   WIRE_VERSION_KEY: () => WIRE_VERSION_KEY,
@@ -126,12 +146,16 @@ __export(index_exports, {
   calcAnimationValues: () => calcAnimationValues,
   camelCaseToKebabWordIfNeeded: () => camelCaseToKebabWordIfNeeded,
   clamp: () => clamp,
+  clampSeekMs: () => clampSeekMs,
   collectSampleTimes: () => collectSampleTimes,
   compareWireVersion: () => compareWireVersion,
   composeTransformParts: () => composeTransformParts,
+  controlModeTakesOverTrigger: () => controlModeTakesOverTrigger,
   convertPlayerDocument: () => convertPlayerDocument,
   createBasicFrameLoopAnimator: () => createBasicFrameLoopAnimator,
+  createDiagnostics: () => createDiagnostics,
   createPathSampler: () => createPathSampler,
+  createRunClock: () => createRunClock,
   cubicBezier: () => cubicBezier,
   deepClone: () => deepClone,
   describeSchema: () => describeSchema,
@@ -142,7 +166,7 @@ __export(index_exports, {
   evaluateMotionPathSegment: () => evaluateMotionPathSegment,
   extendedPathForBrowser: () => extendedPathForBrowser,
   flattenAnimatorTimeline: () => flattenAnimatorTimeline,
-  foldAnimatorConfigShortcuts: () => foldAnimatorConfigShortcuts,
+  foldTimelineOverride: () => foldTimelineOverride,
   formatWireVersion: () => formatWireVersion,
   generateNewIds: () => generateNewIds,
   generateUniqueId: () => generateUniqueId,
@@ -150,7 +174,7 @@ __export(index_exports, {
   getBindings: () => getBindings,
   getChildren: () => getChildren,
   getDefs: () => getDefs,
-  getNormalisedBindings: () => getNormalisedBindings,
+  getNormalizedBindings: () => getNormalizedBindings,
   getNormalizedProps: () => getNormalizedProps,
   interpolateBeziers: () => interpolateBeziers,
   interpolateValue: () => interpolateValue,
@@ -158,6 +182,7 @@ __export(index_exports, {
   isPxElementFileFormat: () => isPxElementFileFormat,
   isPxElementFileFormatDeep: () => isPxElementFileFormatDeep,
   isScrollTimeline: () => isScrollTimeline,
+  isValidPlaybackRate: () => isValidPlaybackRate,
   jsonElementFactory: () => jsonElementFactory,
   kebabToCamelCaseWord: () => kebabToCamelCaseWord,
   kfEasing: () => kfEasing,
@@ -166,15 +191,15 @@ __export(index_exports, {
   kfTime: () => kfTime,
   kfValue: () => kfValue,
   layoutGlyphTextChars: () => layoutGlyphTextChars,
-  materialiseAllInTree: () => materialiseAllInTree,
-  materialiseAnimatedUseInstances: () => materialiseAnimatedUseInstances,
-  materialiseGlyphText: () => materialiseGlyphText,
-  materialiseGlyphTextAlongPath: () => materialiseGlyphTextAlongPath,
-  materialiseGlyphTextHorizontal: () => materialiseGlyphTextHorizontal,
-  materialiseInternalLoopsInPropAnim: () => materialiseInternalLoopsInPropAnim,
-  materialiseInternalLoopsInTree: () => materialiseInternalLoopsInTree,
-  materialiseMotionPathInPropAnim: () => materialiseMotionPathInPropAnim,
-  materialiseMotionPathsInTree: () => materialiseMotionPathsInTree,
+  materializeAllInTree: () => materializeAllInTree,
+  materializeAnimatedUseInstances: () => materializeAnimatedUseInstances,
+  materializeGlyphText: () => materializeGlyphText,
+  materializeGlyphTextAlongPath: () => materializeGlyphTextAlongPath,
+  materializeGlyphTextHorizontal: () => materializeGlyphTextHorizontal,
+  materializeInternalLoopsInPropAnim: () => materializeInternalLoopsInPropAnim,
+  materializeInternalLoopsInTree: () => materializeInternalLoopsInTree,
+  materializeMotionPathInPropAnim: () => materializeMotionPathInPropAnim,
+  materializeMotionPathsInTree: () => materializeMotionPathsInTree,
   mayUseNativeScrollTimeline: () => mayUseNativeScrollTimeline,
   mergeAnimatorConfig: () => mergeAnimatorConfig,
   mergeStaticTransformIntoAnimDef: () => mergeStaticTransformIntoAnimDef,
@@ -182,15 +207,19 @@ __export(index_exports, {
   parseTransformParts: () => parseTransformParts,
   parseWireVersion: () => parseWireVersion,
   planSchemaRelease: () => planSchemaRelease,
+  progressSpanMs: () => progressSpanMs,
+  progressToTimeMs: () => progressToTimeMs,
   propAnimIsMotionPath: () => propAnimIsMotionPath,
   px: () => px,
   readWireVersion: () => readWireVersion,
   releaseLogProblems: () => releaseLogProblems,
   reportDocumentDiagnostics: () => reportDocumentDiagnostics,
+  resolveControlMode: () => resolveControlMode,
   resolveStyle: () => resolveStyle,
   resolveTimelineEngine: () => resolveTimelineEngine,
+  resolveTrigger: () => resolveTrigger,
   reverseEasing: () => reverseEasing,
-  sanitiseAttributeValue: () => sanitiseAttributeValue,
+  sanitizeAttributeValue: () => sanitizeAttributeValue,
   schemaFieldUniverse: () => schemaFieldUniverse,
   schemaKeys: () => schemaKeys,
   scrollOffsetProgress: () => scrollOffsetProgress,
@@ -198,9 +227,11 @@ __export(index_exports, {
   scrollResolveAxis: () => scrollResolveAxis,
   scrollTotalDurationMs: () => scrollTotalDurationMs,
   scrollViewProgress: () => scrollViewProgress,
+  seekCeilingMs: () => seekCeilingMs,
   shiftAnimatable: () => shiftAnimatable,
   splitEasing: () => splitEasing,
   subdivideCubicBezier: () => subdivideCubicBezier,
+  timeToProgress: () => timeToProgress,
   toRGBA: () => toRGBA,
   validateDocument: () => validateDocument,
   validateNodeEffects: () => validateNodeEffects,
@@ -439,7 +470,7 @@ function parseColor(s) {
   }
   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) {
@@ -822,6 +853,7 @@ var Enum = class extends Base {
     return false;
   }
 };
+var UNION_MEMBER_ERROR_LIMIT = 4;
 var Union = class extends Base {
   constructor(schemas, defaultVal) {
     super();
@@ -840,7 +872,35 @@ var Union = class extends Base {
     var _a2;
     const probe = ctx && { errors: [], warnings: [], strict: ctx.strict };
     if (this.schemas.some((s) => s.isValid(raw, probe, path ? [...path] : void 0))) return true;
-    ctx == null ? void 0 : ctx.errors.push(pathStr(path != null ? path : []) + ": no union member matched for value " + ((_a2 = JSON.stringify(raw)) != null ? _a2 : "").slice(0, 240));
+    if (!ctx) return false;
+    const base = pathStr(path != null ? path : []);
+    ctx.errors.push(base + ": no union member matched for value " + ((_a2 = JSON.stringify(raw)) != null ? _a2 : "").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) {
@@ -1519,10 +1579,78 @@ function releaseLogProblems(releases, steps, declared, baseline) {
 }
 
 // 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 PX_ANIM_SRC_ATTR_NAME = "data-px-animation-src";
 var PX_ANIM_ATTR_NAME = "_px_animator";
+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"
@@ -1539,6 +1667,50 @@ function isNativeForced(engine) {
 function mayUseNativeScrollTimeline(engine) {
   return engine !== PxTimelineEngineExtra.js;
 }
+var PX_TRIGGER_DEFAULTS = {
+  startOn: "load",
+  outAction: "continue",
+  scrollIntoViewThreshold: 0
+};
+var PxControlMode = {
+  /** No control props — the document's trigger decides, and nothing is taken over. */
+  static: "static",
+  /** `progress` / `time` — the host scrubs; the component seeks and stays paused. */
+  fixedTime: "fixedTime",
+  /** `play` / `pause` — the host drives playback with booleans. */
+  play: "play",
+  /** `autoplay` — the document's own trigger starts it. */
+  autoplay: "autoplay"
+};
+function resolveControlMode(props) {
+  const hasFixedTime = props.progress !== void 0 || props.time !== void 0;
+  const hasPlayPause = props.play !== void 0 || props.pause !== void 0;
+  const hasAutoplay = !!props.autoplay;
+  const warnings = [];
+  const named = (a, b, winner) => a + " and " + b + " were both set \u2014 " + winner + " wins, " + (winner === a ? b : a) + " is ignored.";
+  if (hasFixedTime) {
+    if (hasPlayPause) warnings.push(named("progress/time", "play/pause", "progress/time"));
+    if (hasAutoplay) warnings.push(named("progress/time", "autoplay", "progress/time"));
+    return { mode: PxControlMode.fixedTime, warnings };
+  }
+  if (hasPlayPause) {
+    if (hasAutoplay) warnings.push(named("play/pause", "autoplay", "play/pause"));
+    return { mode: PxControlMode.play, warnings };
+  }
+  if (hasAutoplay) return { mode: PxControlMode.autoplay, warnings };
+  return { mode: PxControlMode.static, warnings };
+}
+function controlModeTakesOverTrigger(mode) {
+  return mode !== PxControlMode.autoplay;
+}
+function resolveTrigger(trigger) {
+  var _a2, _b, _c;
+  return {
+    startOn: (_a2 = trigger == null ? void 0 : trigger.startOn) != null ? _a2 : 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). */
@@ -1585,7 +1757,6 @@ var PxStrokeTrimSubPaths = {
   separate: "separate",
   combined: "combined"
 };
-var TEXT_ATTR = "text";
 var TEXT_CONTENT_ATTR = "textContent";
 var CLASS_ATTR = "class";
 var TRANSFORM_ATTR = "transform";
@@ -1597,7 +1768,6 @@ var INTERNAL_ATTRS = /* @__PURE__ */ new Set([
   "meta",
   "animate",
   "effects",
-  TEXT_ATTR,
   TEXT_CONTENT_ATTR
 ]);
 var TRANSFORM_PART = {
@@ -1612,10 +1782,6 @@ var PX_TRANSFORM_PART_KEYS = [
   TRANSFORM_PART.scale,
   TRANSFORM_PART.origin
 ];
-var PxGradientUnits = {
-  userSpaceOnUse: "userSpaceOnUse",
-  objectBoundingBox: "objectBoundingBox"
-};
 var PxGradientSpreadMethod = {
   pad: "pad",
   reflect: "reflect",
@@ -1634,8 +1800,18 @@ function isPxElementFileFormat(fileJson) {
 function getAnimatorConfig(doc) {
   var _a2;
   const cfg = (doc == null ? void 0 : doc.animator) || ((_a2 = doc == null ? void 0 : doc.meta) == null ? void 0 : _a2.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;
@@ -1661,7 +1837,7 @@ function flattenAnimatorTimeline(cfg) {
     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;
@@ -1722,9 +1898,9 @@ function nestAnimatorTimeline(cfg) {
       if (scroll.subject !== void 0) timeline2.subject = scroll.subject;
       if (scroll.smoothing !== void 0) timeline2.smoothing = scroll.smoothing;
       if (scroll.range !== void 0) timeline2.range = scroll.range;
-      const hasPinParams = scroll.pinAlign !== void 0 || scroll.pinTop !== void 0 || scroll.pinDistance !== void 0;
+      const hasPinParams = scroll.pinAlign !== void 0 || scroll.pinOffset !== void 0 || scroll.pinDistance !== void 0;
       if (hasPinParams) {
-        timeline2.pin = __spreadValues(__spreadValues(__spreadValues({}, scroll.pinAlign !== void 0 ? { align: scroll.pinAlign } : {}), scroll.pinTop !== void 0 ? { top: scroll.pinTop } : {}), scroll.pinDistance !== void 0 ? { distance: scroll.pinDistance } : {});
+        timeline2.pin = __spreadValues(__spreadValues(__spreadValues({}, scroll.pinAlign !== void 0 ? { align: scroll.pinAlign } : {}), scroll.pinOffset !== void 0 ? { offset: scroll.pinOffset } : {}), scroll.pinDistance !== void 0 ? { distance: scroll.pinDistance } : {});
       } else if (scroll.pin !== void 0) {
         timeline2.pin = scroll.pin;
       }
@@ -1772,14 +1948,13 @@ var PxKeyframeValueSchema = implementsInterface()(px.union([
   // e.g. for colors
   px.number(),
   px.array(px.number()),
-  // ORDER LAW: the key-discriminated object shapes (`{path}`, `{paths}`) come BEFORE the
+  // 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 `{path}`/`{paths}` values into it and strip them to `{}` —
+  // 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({ path: px.string() }),
-  px.lazy(() => px.object({ paths: px.array(PxBezierPathSchema) }), { paths: [] }),
+  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, {})
@@ -1819,7 +1994,7 @@ var PxPropertyAnimationSchema = implementsInterface()(px.object({
   keyframes: px.array(PxKeyframeSchema).optional(),
   loop: px.union([PxLoopSchema, px.boolean()]).optional(),
   autoOrient: px.boolean().optional(),
-  alongPathMode: px.enum(["sampled", "offsetPath"]).optional()
+  alongPathMode: px.enum([PxAlongPathMode.sampled, PxAlongPathMode.offsetPath]).optional()
 }));
 var PxTransformPartsSchema = implementsInterface()(px.object({
   translate: px.tuple([px.number(), px.number()]).optional(),
@@ -1843,17 +2018,17 @@ var PxElementAnimationSchema = implementsInterface()(px.union([
   PxAnimationDefinitionSchema
 ]));
 var PxTriggerSchema = implementsInterface()(px.object({
-  startOn: px.enum(["load", "mouseOver", "click", "scrollIntoView", "programmatic"]).optional(),
-  outAction: px.enum(["continue", "pause", "reset", "reverse"]).optional(),
+  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(["hold", "reset"]).optional(),
+  finishAction: px.enum([PxFinishAction.hold, PxFinishAction.reset]).optional(),
   scrollIntoViewThreshold: px.number().optional()
 }));
 var PxGlyphSchema = implementsInterface()(px.object({
   width: px.number(),
-  d: px.string()
+  pathData: px.string()
 }));
 var PxGlyphFontSchema = implementsInterface()(px.object({
   fontFamily: px.string(),
@@ -1870,9 +2045,15 @@ var PxDefsSchema = implementsInterface()(px.object({
   styles: px.record(px.record(px.union([px.string(), px.number()]))).optional(),
   fonts: px.record(PxGlyphFontSchema).optional()
 }));
-var PX_SCROLL_PHASES = ["cover", "contain", "entry", "exit", "entry-crossing", "exit-crossing"];
 var PxScrollRangePointSchema = implementsInterface()(px.object({
-  phase: px.enum(PX_SCROLL_PHASES).optional(),
+  phase: px.enum([
+    PxScrollPhase.cover,
+    PxScrollPhase.contain,
+    PxScrollPhase.entry,
+    PxScrollPhase.exit,
+    PxScrollPhase.entryCrossing,
+    PxScrollPhase.exitCrossing
+  ]).optional(),
   fraction: px.number().optional()
 }));
 var PxScrollRangeSchema = px.object({
@@ -1880,21 +2061,21 @@ var PxScrollRangeSchema = px.object({
   end: PxScrollRangePointSchema.optional()
 });
 var PxScrollSchema = implementsInterface()(px.object({
-  kind: px.enum(["view", "scroll"]).optional(),
-  axis: px.enum(["block", "inline", "x", "y"]).optional(),
-  source: px.enum(["nearest", "root"]).optional(),
+  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(["top", "center", "bottom"]).optional(),
-  pinTop: px.number().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(["top", "center", "bottom"]).optional(),
-  top: px.number().optional(),
+  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();
@@ -1909,8 +2090,8 @@ var PxTimeTimelineSchema = implementsInterface()(px.object({
   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(["forwards", "backwards", "both", "none"]).optional(),
-  direction: px.enum(["normal", "reverse", "alternate", "alternate-reverse"]).optional()
+  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
@@ -1921,8 +2102,8 @@ var scrollishTimelineShape = {
   iterations: px.number().optional(),
   engine: PxTimelineEngineSchema,
   frameRate: px.number().optional(),
-  axis: px.enum(["block", "inline", "x", "y"]).optional(),
-  source: px.enum(["nearest", "root"]).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(),
@@ -2011,7 +2192,7 @@ var PxMaskedByEffectSchema = implementsInterface()(px.object({
   height: px.number().optional()
 }));
 var PxClipPathEffectSchema = implementsInterface()(px.object({
-  d: PxAnimatableStringSchema.optional()
+  pathData: PxAnimatableStringSchema.optional()
 }));
 var PxStrokeTrimEffectSchema = implementsInterface()(px.object({
   offset: PxAnimatableNumberSchema.optional(),
@@ -2048,7 +2229,7 @@ var PxFillGradientEffectSchema = implementsInterface()(px.object({
   radius: PxAnimatableNumberSchema.optional(),
   focal: PxAnimatableVec2Schema.optional(),
   stops: PxAnimatableGradientStopsSchema.optional(),
-  gradientUnits: px.enum([PxGradientUnits.userSpaceOnUse, PxGradientUnits.objectBoundingBox]).optional(),
+  gradientUnits: px.enum([PxUnits.userSpaceOnUse, PxUnits.objectBoundingBox]).optional(),
   spreadMethod: px.enum([PxGradientSpreadMethod.pad, PxGradientSpreadMethod.reflect, PxGradientSpreadMethod.repeat]).optional(),
   gradientTransform: px.string().optional()
 }));
@@ -2094,11 +2275,71 @@ function validateNodeEffects(root, opts) {
   walk(root, "root");
   return warnings;
 }
-function validateDocument(doc) {
-  const ctx = { errors: [], warnings: [], strict: true };
+function validateGlyphFontRefs(root, fonts) {
+  if (!fonts || !Object.keys(fonts).length) return [];
+  const problems = [];
+  const walk = (node, path, inherited, inGlyphText) => {
+    var _a2, _b;
+    if (!node) return;
+    const own = typeof node.fontFamily === "string" ? node.fontFamily : void 0;
+    const family = own != null ? own : inherited;
+    const isGlyphText = inGlyphText || node.type === "text" && !!((_b = (_a2 = node.effects) == null ? void 0 : _a2.text) == null ? void 0 : _b.useGlyphs);
+    if (isGlyphText && own && !Object.prototype.hasOwnProperty.call(fonts, own)) {
+      const problem = path + ': glyph-mode text uses font-family "' + own + '", which has no entry in animator.definitions.fonts';
+      if (!problems.includes(problem)) problems.push(problem);
+    }
+    if (Array.isArray(node.children)) {
+      node.children.forEach((c, i) => walk(c, path + ".children[" + i + "]", family, isGlyphText));
+    }
+  };
+  walk(root, "root", void 0, false);
+  return problems;
+}
+function validateEasingRefs(root, easings) {
+  const problems = [];
+  const walk = (node, path) => {
+    if (Array.isArray(node)) {
+      node.forEach((item, i) => walk(item, path + "[" + i + "]"));
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+    const easing = node.easing;
+    if (typeof easing === "string" && !(easings && Object.prototype.hasOwnProperty.call(easings, easing))) {
+      const problem = path + '.easing: "' + easing + '" names no entry in animator.definitions.easings \u2014 it will play linear';
+      if (!problems.includes(problem)) problems.push(problem);
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "easing") continue;
+      if (value && typeof value === "object") walk(value, path + "." + key);
+    }
+  };
+  walk(root, "root");
+  return problems;
+}
+function validateVersionStamp(doc) {
+  var _a2;
+  const version = (_a2 = getAnimatorConfig(doc)) == null ? void 0 : _a2.version;
+  if (version === void 0) return [];
+  if (parseWireVersion(version) !== void 0) return [];
+  return ["root.animator.version: " + JSON.stringify(version) + ' is not a version stamp ("a.b" or "a.b.c") \u2014 it reads as unstamped'];
+}
+function validateDocument(doc, opts) {
+  var _a2;
+  const strict = (opts == null ? void 0 : opts.strict) !== false;
+  const ctx = { errors: [], warnings: [], strict };
   const problems = PxAnimatedSvgDocumentSchema.isValid(doc, ctx, ["root"]) ? [] : [...ctx.errors];
   if (doc && typeof doc === "object") {
-    for (const w of validateNodeEffects(doc, { strict: true })) {
+    for (const w of validateNodeEffects(doc, { strict })) {
+      if (!problems.includes(w)) problems.push(w);
+    }
+    const defs = (_a2 = getAnimatorConfig(doc)) == null ? void 0 : _a2.definitions;
+    for (const w of validateGlyphFontRefs(doc, defs == null ? void 0 : defs.fonts)) {
+      if (!problems.includes(w)) problems.push(w);
+    }
+    for (const w of validateEasingRefs(doc, defs == null ? void 0 : defs.easings)) {
+      if (!problems.includes(w)) problems.push(w);
+    }
+    for (const w of validateVersionStamp(doc)) {
       if (!problems.includes(w)) problems.push(w);
     }
   }
@@ -2121,10 +2362,13 @@ var PxNodeBase = px.openObject({
   // 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 normalisation
+  // 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
@@ -2156,8 +2400,8 @@ var PxBezierPathSchema = implementsInterface()(px.object({
   c: px.boolean().optional()
 }));
 function isPxElementFileFormatDeep(fileJson) {
-  const valid = PxAnimatedSvgDocumentSchema.isValid(fileJson);
-  return { valid, errors: valid ? [] : ["Document failed schema validation"] };
+  const errors = validateDocument(fileJson, { strict: false });
+  return { valid: errors.length === 0, errors };
 }
 
 // src/util/PxIdUtil.ts
@@ -2316,7 +2560,7 @@ function isDangerousAttrName(nameLower) {
   if (nameLower.startsWith("on")) return true;
   return false;
 }
-function sanitiseAttributeValue(name, value) {
+function sanitizeAttributeValue(name, value) {
   const nameLower = name.toLowerCase();
   if (isDangerousAttrName(nameLower)) {
     console.warn("Attribute blocked (event handler / dangerous): ", nameLower);
@@ -2355,7 +2599,7 @@ function getNormalizedProps(props) {
     if (INTERNAL_ATTRS.has(key)) continue;
     if (key === "style") continue;
     let value = props[rawKey];
-    if (COLOUR_ATTR_NAMES.has(key) && Array.isArray(value)) {
+    if (COLOR_ATTR_NAMES.has(key) && Array.isArray(value)) {
       propsCopy[key] = toRGBA(value);
     } else if (key === "transform" && value !== null && typeof value === "object" && !Array.isArray(value) && !value.keyframes) {
       const parts = value.value && typeof value.value === "object" ? value.value : value;
@@ -2376,7 +2620,7 @@ function getNormalizedProps(props) {
   return propsCopy;
 }
 
-// src/materialise/PxMotionPath.ts
+// src/materialize/PxMotionPath.ts
 function getKfTranslate(kf) {
   const v = kfValue(kf);
   if (!v) return void 0;
@@ -2457,7 +2701,7 @@ function tFromArcFraction(lut, arcFrac) {
 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 _a2, _b, _c;
   if (!propAnimIsMotionPath(anim)) return anim;
   const kfs = anim.keyframes;
@@ -2489,7 +2733,7 @@ function materialiseMotionPathInPropAnim(anim, opts) {
     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;
@@ -2603,7 +2847,7 @@ function insertSharpCornerStepKfIfNeeded(out, prevKf, nextKf, prevPos, nextPos,
   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);
@@ -2726,16 +2970,16 @@ function perpDist(q, pA, pB) {
   const cross = (q[0] - pA[0]) * dy - (q[1] - pA[1]) * dx;
   return Math.abs(cross) / Math.sqrt(len2);
 }
-function materialiseMotionPathsInTree(root, opts) {
-  const out = walkAndMaterialise(root, opts);
+function materializeMotionPathsInTree(root, opts) {
+  const out = walkAndMaterialize(root, opts);
   return out != null ? out : root;
 }
-function walkAndMaterialise(node, opts) {
+function walkAndMaterialize(node, opts) {
   let newChildren;
   if (node.children) {
     for (let i = 0; i < node.children.length; i++) {
       const ch = node.children[i];
-      const ret = walkAndMaterialise(ch, opts);
+      const ret = walkAndMaterialize(ch, opts);
       if (ret !== null) {
         if (!newChildren) newChildren = node.children.slice();
         newChildren[i] = ret;
@@ -2748,9 +2992,9 @@ function walkAndMaterialise(node, opts) {
     const animDef = animBucket;
     const transformAnim = animDef.transform;
     if (transformAnim && typeof transformAnim === "object" && propAnimIsMotionPath(transformAnim)) {
-      const materialised = materialiseMotionPathInPropAnim(transformAnim, opts);
-      if (materialised !== transformAnim) {
-        newAnimate = __spreadProps(__spreadValues({}, animDef), { transform: materialised });
+      const materialized = materializeMotionPathInPropAnim(transformAnim, opts);
+      if (materialized !== transformAnim) {
+        newAnimate = __spreadProps(__spreadValues({}, animDef), { transform: materialized });
       }
     }
   }
@@ -2853,8 +3097,8 @@ function isPathString(value) {
   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) {
@@ -2938,7 +3182,7 @@ function interpolateValue(propName, a, b, t) {
     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)) {
@@ -3160,7 +3404,7 @@ function normalizeKeyframes(propName, propAnim, duration, defs) {
       value = normalizePathValue(value);
     }
     const propNameKebab = isCamelCaseWord(propName) ? camelCaseToKebabWordIfNeeded(propName) : propName;
-    if (COLOUR_ATTR_NAMES.has(propNameKebab)) {
+    if (COLOR_ATTR_NAMES.has(propNameKebab)) {
       value = (_a2 = parseColor(value)) != null ? _a2 : value;
     }
     const normKf = {
@@ -3194,20 +3438,20 @@ function mergeAnimationDefinitions(animations) {
   }
   return merged;
 }
-function materialiseInternalLoopsInPropAnim(propName, propAnim, duration) {
+function materializeInternalLoopsInPropAnim(propName, propAnim, duration) {
   const loopRaw = propAnim.loop;
   if (loopRaw === void 0 || loopRaw === null || loopRaw === false) return propAnim;
   const loop = loopRaw === true ? {} : loopRaw;
   const rawKfs = propAnim.keyframes;
   if (!Array.isArray(rawKfs) || rawKfs.length < 2) return propAnim;
   const propNameKebab = isCamelCaseWord(propName) ? camelCaseToKebabWordIfNeeded(propName) : propName;
-  const isColour = COLOUR_ATTR_NAMES.has(propNameKebab);
+  const isColor = COLOR_ATTR_NAMES.has(propNameKebab);
   const kfs = rawKfs.map((kf) => {
     var _a2;
     const t = kfTime(kf);
     let v = kfValue(kf);
     if (propName === "d") v = normalizePathValue(v);
-    if (isColour) v = (_a2 = parseColor(v)) != null ? _a2 : v;
+    if (isColor) v = (_a2 = parseColor(v)) != null ? _a2 : v;
     const e = kfEasing(kf);
     const out2 = { t, v, e };
     const tIn = kfTangentIn(kf);
@@ -3221,15 +3465,15 @@ function materialiseInternalLoopsInPropAnim(propName, propAnim, duration) {
   if (propAnim.autoOrient !== void 0) out.autoOrient = propAnim.autoOrient;
   return out;
 }
-function materialiseInternalLoopsInTree(root, duration) {
-  const ret = walkAndMaterialiseLoops(root, duration);
+function materializeInternalLoopsInTree(root, duration) {
+  const ret = walkAndMaterializeLoops(root, duration);
   return ret != null ? ret : root;
 }
-function walkAndMaterialiseLoops(node, duration) {
+function walkAndMaterializeLoops(node, duration) {
   let newChildren;
   if (node.children) {
     for (let i = 0; i < node.children.length; i++) {
-      const ret = walkAndMaterialiseLoops(node.children[i], duration);
+      const ret = walkAndMaterializeLoops(node.children[i], duration);
       if (ret !== null) {
         if (!newChildren) newChildren = node.children.slice();
         newChildren[i] = ret;
@@ -3242,10 +3486,10 @@ function walkAndMaterialiseLoops(node, duration) {
     const animDef = animBucket;
     for (const propName of Object.keys(animDef)) {
       const propAnim = animDef[propName];
-      const materialised = materialiseInternalLoopsInPropAnim(propName, propAnim, duration);
-      if (materialised !== propAnim) {
+      const materialized = materializeInternalLoopsInPropAnim(propName, propAnim, duration);
+      if (materialized !== propAnim) {
         if (!newAnimate) newAnimate = __spreadValues({}, animDef);
-        newAnimate[propName] = materialised;
+        newAnimate[propName] = materialized;
       }
     }
   }
@@ -3300,12 +3544,12 @@ function normalizeAnimationDefinition(animDef, duration, defs, engine = PxTimeli
       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 === PxTimelineEngine.native && propName === "transform" ? materialiseMotionPathInPropAnim(out) : out;
+      normalized[propName] = engine === PxTimelineEngine.native && propName === "transform" ? materializeMotionPathInPropAnim(out) : out;
     }
   }
   return normalized;
 }
-function getNormalisedBindings(doc, engine = PxTimelineEngine.native) {
+function getNormalizedBindings(doc, engine = PxTimelineEngine.native) {
   const animatorConfig = getAnimatorConfig(doc) || {};
   const defs = getDefs(doc);
   const duration = animatorConfig.duration || 1e3;
@@ -3396,7 +3640,7 @@ function calcPropertyValue(propName, propAnim, progress) {
       nextPaths,
       localProgress
     ).map((bz) => bezierToSvgPath(bz)).join("");
-  } else if (COLOUR_ATTR_NAMES.has(cssAttrName)) {
+  } else if (COLOR_ATTR_NAMES.has(cssAttrName)) {
     cssValue = toRGBA(interpolateColor(
       prevV || [0, 0, 0, 1],
       nextV || [0, 0, 0, 1],
@@ -3557,8 +3801,8 @@ function applyUseOffsetToG(gNode) {
   return gNode;
 }
 
-// src/materialise/PxAnimatorUseMaterialiser.ts
-function materialiseAnimatedUseInstances(root) {
+// src/materialize/PxAnimatorUseMaterializer.ts
+function materializeAnimatedUseInstances(root) {
   var _a2;
   const idMap = buildIdMap(root);
   const animatedIds = computeAnimatedSubtreeIds(root, idMap);
@@ -3567,7 +3811,7 @@ function materialiseAnimatedUseInstances(root) {
   const genId3 = () => "_lw_use_mat_" + ++idCounter;
   const rootViewport = readRootViewport(root);
   const defsCollector = [];
-  const walked = walkAndMaterialise2(root, idMap, animatedIds, genId3, defsCollector, rootViewport);
+  const walked = walkAndMaterialize2(root, idMap, animatedIds, genId3, defsCollector, rootViewport);
   if (defsCollector.length === 0) return walked;
   const defsNode = { type: "defs", children: defsCollector };
   const newChildren = [...(_a2 = walked.children) != null ? _a2 : [], defsNode];
@@ -3640,7 +3884,7 @@ function stripHash(href) {
   if (typeof href !== "string") return void 0;
   return href.startsWith("#") ? href.slice(1) : href;
 }
-function materialiseOneUse(useNode, target, idMap, animatedIds, genId3, defsCollector, rootViewport) {
+function materializeOneUse(useNode, target, idMap, animatedIds, genId3, defsCollector, rootViewport) {
   var _a2, _b, _c, _d;
   const clone2 = deepClonePxNode(target);
   regenerateIdsAndRewriteRefs(clone2, genId3);
@@ -3648,8 +3892,8 @@ function materialiseOneUse(useNode, target, idMap, animatedIds, genId3, defsColl
   const useW = (_b = (_a2 = numericAttr(useNode.width)) != null ? _a2 : symbolViewBox == null ? void 0 : symbolViewBox[2]) != null ? _b : rootViewport[0];
   const useH = (_d = (_c = numericAttr(useNode.height)) != null ? _c : symbolViewBox == null ? void 0 : symbolViewBox[3]) != null ? _d : rootViewport[1];
   const rewrittenClone = clone2.type === "symbol" ? rewriteSymbolRootToGroup(clone2, genId3, defsCollector, useW, useH) : clone2;
-  const materialisedClone = walkAndMaterialise2(rewrittenClone, idMap, animatedIds, genId3, defsCollector, rootViewport);
-  const newNode = __spreadProps(__spreadValues({}, useNode), { type: "g", children: [materialisedClone] });
+  const materializedClone = walkAndMaterialize2(rewrittenClone, idMap, animatedIds, genId3, defsCollector, rootViewport);
+  const newNode = __spreadProps(__spreadValues({}, useNode), { type: "g", children: [materializedClone] });
   delete newNode.href;
   delete newNode.width;
   delete newNode.height;
@@ -3687,18 +3931,18 @@ function parseViewBox(v) {
   if (parts.length < 4 || parts.some((n) => !Number.isFinite(n))) return void 0;
   return [parts[0], parts[1], parts[2], parts[3]];
 }
-function walkAndMaterialise2(node, idMap, animatedIds, genId3, defsCollector, rootViewport) {
+function walkAndMaterialize2(node, idMap, animatedIds, genId3, defsCollector, rootViewport) {
   if (node.type === "use" && typeof node.href === "string") {
     const targetId = stripHash(node.href);
     if (targetId && animatedIds.has(targetId)) {
       const target = idMap.get(targetId);
-      if (target) return materialiseOneUse(node, target, idMap, animatedIds, genId3, defsCollector, rootViewport);
+      if (target) return materializeOneUse(node, target, idMap, animatedIds, genId3, defsCollector, rootViewport);
     }
   }
   if (!node.children) return node;
   let changed = false;
   const newChildren = node.children.map((ch) => {
-    const m = walkAndMaterialise2(ch, idMap, animatedIds, genId3, defsCollector, rootViewport);
+    const m = walkAndMaterialize2(ch, idMap, animatedIds, genId3, defsCollector, rootViewport);
     if (m !== ch) changed = true;
     return m;
   });
@@ -3723,7 +3967,7 @@ function readAnimatable(raw) {
     const obj = raw;
     const kfs = obj.keyframes;
     if (kfs) {
-      const out = { kind: "animated" /* Animated */, keyframes: kfs.map(normaliseKeyframe), autoOrient: obj.autoOrient, loop: obj.loop };
+      const out = { kind: "animated" /* Animated */, keyframes: kfs.map(normalizeKeyframe), autoOrient: obj.autoOrient, loop: obj.loop };
       const base = (_a2 = obj.value) != null ? _a2 : obj.v;
       if (base !== void 0 && out.kind === "animated" /* Animated */) out.base = base;
       return out;
@@ -3751,7 +3995,7 @@ function writeAnimatableChannel(node, attrName, read, opts) {
   const baseline = (_d = (_b = read.base) != null ? _b : (_a2 = read.keyframes[0]) == null ? void 0 : _a2.value) != null ? _d : (_c = read.keyframes[0]) == null ? void 0 : _c.v;
   if (baseline !== void 0) node[attrName] = toOut(baseline);
 }
-function normaliseKeyframe(kf) {
+function normalizeKeyframe(kf) {
   if (!kf || typeof kf !== "object") return kf;
   const k = kf;
   if (k.t === void 0 && k.v === void 0 && k.e === void 0 && k.to === void 0 && k.ti === void 0) {
@@ -4263,10 +4507,10 @@ function formatOffset(o) {
 
 // src/effects/clipping/clipPathEffect.ts
 function applyClipPathEffect(node, fx, ctx) {
-  if (!(fx == null ? void 0 : fx.d)) return node;
+  if (!(fx == null ? void 0 : fx.pathData)) return node;
   const clipId = genId(ctx, "clip");
   const pathChild = { type: "path" };
-  const read = readAnimatable(fx.d);
+  const read = readAnimatable(fx.pathData);
   if (read.kind !== "absent" /* Absent */) {
     if (read.kind === "static" /* Static */) {
       pathChild.d = pathString(read.value);
@@ -4281,7 +4525,7 @@ function applyClipPathEffect(node, fx, ctx) {
 }
 function pathString(v) {
   if (typeof v === "string") return v;
-  if (v && typeof v === "object" && typeof v.path === "string") return v.path;
+  if (v && typeof v === "object" && typeof v.pathData === "string") return v.pathData;
   return void 0;
 }
 
@@ -4328,8 +4572,8 @@ function wrapInverseTransform(inner, fx, ctx) {
 }
 function wrapInversePart(inner, part, raw, origin, ctx) {
   if (raw === void 0) return inner;
-  const normalisedRaw = part === "scale" /* Scale */ && Array.isArray(raw) ? [raw[0] / 100, raw[1] / 100] : raw;
-  const v = readAnimatable(normalisedRaw);
+  const normalizedRaw = part === "scale" /* Scale */ && Array.isArray(raw) ? [raw[0] / 100, raw[1] / 100] : raw;
+  const v = readAnimatable(normalizedRaw);
   if (v.kind === "static" /* Static */) {
     return { type: "g", transform: { value: partsRecord(part, invertPartValue(part, v.value), origin) }, children: [inner] };
   }
@@ -4730,7 +4974,7 @@ function synthesiseScale(raw, i) {
 }
 
 // src/effects/reference/retimeEffect.ts
-var RETIME_MATERIALISATION_MODE_INLINE_G = false;
+var RETIME_MATERIALIZATION_MODE_INLINE_G = false;
 function asRetime(r) {
   var _a2, _b;
   return { start: (_a2 = r.start) != null ? _a2 : 0, stretch: (_b = r.stretch) != null ? _b : 1 };
@@ -4815,11 +5059,11 @@ function applyAllRetimeEffects(root, ctx) {
     if (!retime) continue;
     const crop = retime.timeCrop;
     clearCloneRetime(useNode);
-    materialiseRetime(useNode, asRetime(retime), ctx);
+    materializeRetime(useNode, asRetime(retime), ctx);
     if (crop) applyTimeCrop(useNode, crop, ctx);
   }
 }
-function materialiseRetime(useNode, retime, ctx) {
+function materializeRetime(useNode, retime, ctx) {
   const targetId = stripHash2(useNode.href);
   if (!targetId) {
     ctx.errors.push("retime: <use> has no href to follow");
@@ -4827,7 +5071,7 @@ function materialiseRetime(useNode, retime, ctx) {
   }
   const chainRootId = buildChainClone(targetId, retime, ctx, /* @__PURE__ */ new Set());
   if (!chainRootId) return;
-  if (RETIME_MATERIALISATION_MODE_INLINE_G) {
+  if (RETIME_MATERIALIZATION_MODE_INLINE_G) {
     const cloneNode = ctx.idMap.get(chainRootId);
     useNode.type = "g";
     delete useNode.href;
@@ -4867,13 +5111,13 @@ function buildChainClone(targetId, accum, ctx, chain) {
       if (subId2) cloneNode.href = "#" + subId2;
     }
   } else {
-    materialiseNestedRetimeUses(cloneNode, accum, ctx, chain, targetId);
+    materializeNestedRetimeUses(cloneNode, accum, ctx, chain, targetId);
   }
   ctx.defs.push(cloneNode);
   if (typeof cloneNode.id === "string") ctx.idMap.set(cloneNode.id, cloneNode);
   return typeof cloneNode.id === "string" ? cloneNode.id : void 0;
 }
-function materialiseNestedRetimeUses(node, accum, ctx, chain, parentTargetId) {
+function materializeNestedRetimeUses(node, accum, ctx, chain, parentTargetId) {
   const visit = (n) => {
     var _a2;
     const retime = readCloneRetime(n);
@@ -5074,10 +5318,10 @@ function numRange(v) {
 function estimateTextAdvance(node) {
   let chars = 0, maxFont = 16;
   const walk = (el) => {
-    var _a2, _b;
+    var _a2;
     const fs = parseFloat(String((_a2 = el.fontSize) != null ? _a2 : "")) || 0;
     if (fs) maxFont = Math.max(maxFont, fs);
-    const t = (_b = el.text) != null ? _b : el.textContent;
+    const t = el.textContent;
     if (typeof t === "string") chars += t.length;
     if (el.children) for (const c of el.children) walk(c);
   };
@@ -5232,7 +5476,6 @@ var TEXT_ATTR_KEYS = [
   "stroke",
   "strokeWidth",
   "effects",
-  TEXT_ATTR,
   TEXT_CONTENT_ATTR,
   "xml:space"
 ];
@@ -5342,8 +5585,8 @@ function missingGlyphBoxEm(advanceEm, ascentEm) {
   const ix0 = x0 + t, ix1 = x1 - t, iyb = -t, iyt = y1 + t;
   return outer + "M" + ix0 + " " + iyb + "L" + ix0 + " " + iyt + "L" + ix1 + " " + iyt + "L" + ix1 + " " + iyb + "Z";
 }
-function materialiseGlyphTextHorizontal(node, opts) {
-  var _a2, _b, _c, _d;
+function materializeGlyphTextHorizontal(node, opts) {
+  var _a2, _b, _c;
   const { glyphs, create = jsonElementFactory, warnings } = opts;
   const soleFont = soleFontOf(glyphs);
   const pen = { x: (_a2 = parseLen(node.x)) != null ? _a2 : 0, y: (_b = parseLen(node.y)) != null ? _b : 0 };
@@ -5360,8 +5603,8 @@ function materialiseGlyphTextHorizontal(node, opts) {
     for (let i = 0; i < content.length; i++) {
       const ch = content.charAt(i);
       const g = gf == null ? void 0 : gf.glyphs[ch];
-      if (g && g.d) {
-        placements.push({ glyphD: g.d, m: [scale, 0, 0, scale, pen.x, pen.y], paint, line, x: pen.x, y: pen.y, scale });
+      if (g && g.pathData) {
+        placements.push({ glyphD: g.pathData, m: [scale, 0, 0, scale, pen.x, pen.y], paint, line, x: pen.x, y: pen.y, scale });
         pen.x += g.width * scale;
       } else if (/\S/.test(ch)) {
         const advEm = g && g.width > 0 ? g.width : MISSING_GLYPH_ADVANCE_EM * upm;
@@ -5375,7 +5618,7 @@ function materialiseGlyphTextHorizontal(node, opts) {
     }
   };
   const walk = (el, parentStyle) => {
-    var _a3, _b2, _c2, _d2;
+    var _a3, _b2, _c2;
     const s = resolveStyle2(el, parentStyle);
     const x = parseLen(el.x);
     const y = parseLen(el.y);
@@ -5387,14 +5630,14 @@ function materialiseGlyphTextHorizontal(node, opts) {
     if (y !== void 0) pen.y = y;
     pen.x += (_a3 = parseLen(el.dx)) != null ? _a3 : 0;
     pen.y += (_b2 = parseLen(el.dy)) != null ? _b2 : 0;
-    const content = (_c2 = str(el[TEXT_CONTENT_ATTR])) != null ? _c2 : str(el[TEXT_ATTR]);
-    if (content && !((_d2 = el.children) == null ? void 0 : _d2.length)) renderChars(content, s);
+    const content = str(el[TEXT_CONTENT_ATTR]);
+    if (content && !((_c2 = el.children) == null ? void 0 : _c2.length)) renderChars(content, s);
     if (el.children) for (const ch of el.children) walk(ch, s);
   };
   const rootStyle = rootStyleOf(node);
   if (node.children) for (const ch of node.children) walk(ch, rootStyle);
-  const rootContent = (_c = str(node[TEXT_CONTENT_ATTR])) != null ? _c : str(node[TEXT_ATTR]);
-  if (rootContent && !((_d = node.children) == null ? void 0 : _d.length)) renderChars(rootContent, rootStyle);
+  const rootContent = str(node[TEXT_CONTENT_ATTR]);
+  if (rootContent && !((_c = node.children) == null ? void 0 : _c.length)) renderChars(rootContent, rootStyle);
   const anchor = str(node.textAnchor);
   if (anchor === "middle" || anchor === "end") {
     for (const p of placements) {
@@ -5406,7 +5649,7 @@ function materialiseGlyphTextHorizontal(node, opts) {
   return toGroup(node, buildPaths(placements, create, warnings), create);
 }
 function layoutGlyphTextChars(node, opts) {
-  var _a2, _b, _c, _d, _e, _f;
+  var _a2, _b, _c, _d, _e;
   if ((_a2 = opts.alongPath) == null ? void 0 : _a2.pathD) return layoutGlyphTextCharsAlongPath(node, opts.alongPath.pathD, opts);
   const { glyphs, warnings } = opts;
   const soleFont = soleFontOf(glyphs);
@@ -5430,7 +5673,7 @@ function layoutGlyphTextChars(node, opts) {
     }
   };
   const walk = (el, parentStyle) => {
-    var _a3, _b2, _c2, _d2;
+    var _a3, _b2, _c2;
     const s = resolveStyle2(el, parentStyle);
     const x = parseLen(el.x);
     const y = parseLen(el.y);
@@ -5442,8 +5685,8 @@ function layoutGlyphTextChars(node, opts) {
     if (y !== void 0) pen.y = y;
     pen.x += (_a3 = parseLen(el.dx)) != null ? _a3 : 0;
     pen.y += (_b2 = parseLen(el.dy)) != null ? _b2 : 0;
-    const content = (_c2 = str(el[TEXT_CONTENT_ATTR])) != null ? _c2 : str(el[TEXT_ATTR]);
-    if (content && !((_d2 = el.children) == null ? void 0 : _d2.length)) renderChars(content, s);
+    const content = str(el[TEXT_CONTENT_ATTR]);
+    if (content && !((_c2 = el.children) == null ? void 0 : _c2.length)) renderChars(content, s);
     if (el.children) for (const ch of el.children) walk(ch, s);
   };
   const rootStyle = rootStyleOf(node);
@@ -5457,8 +5700,8 @@ function layoutGlyphTextChars(node, opts) {
       boxes.push({ x: pen.x, y: pen.y, width: 0, ascent: ((_d = gf == null ? void 0 : gf.ascent) != null ? _d : 0.9 * upm) * (s.fontSize / upm), fontSize: s.fontSize, line });
     }
   }
-  const rootContent = (_e = str(node[TEXT_CONTENT_ATTR])) != null ? _e : str(node[TEXT_ATTR]);
-  if (rootContent && !((_f = node.children) == null ? void 0 : _f.length)) renderChars(rootContent, rootStyle);
+  const rootContent = str(node[TEXT_CONTENT_ATTR]);
+  if (rootContent && !((_e = node.children) == null ? void 0 : _e.length)) renderChars(rootContent, rootStyle);
   const anchor = str(node.textAnchor);
   if (anchor === "middle" || anchor === "end") {
     for (const b of boxes) {
@@ -5466,8 +5709,8 @@ function layoutGlyphTextChars(node, opts) {
       b.x += anchor === "middle" ? -w / 2 : -w;
     }
   }
-  return boxes.map((_g) => {
-    var _h = _g, { line: _l } = _h, b = __objRest(_h, ["line"]);
+  return boxes.map((_f) => {
+    var _g = _f, { line: _l } = _g, b = __objRest(_g, ["line"]);
     return b;
   });
 }
@@ -5483,14 +5726,14 @@ function layoutGlyphTextCharsAlongPath(node, pathD, opts) {
   const chars = [];
   let adv = 0;
   const walk = (el, parentStyle) => {
-    var _a3, _b2, _c;
+    var _a3, _b2;
     const s = resolveStyle2(el, parentStyle);
-    const content = (_a3 = str(el[TEXT_CONTENT_ATTR])) != null ? _a3 : str(el[TEXT_ATTR]);
-    if (content && !((_b2 = el.children) == null ? void 0 : _b2.length)) {
+    const content = str(el[TEXT_CONTENT_ATTR]);
+    if (content && !((_a3 = el.children) == null ? void 0 : _a3.length)) {
       const gf = glyphFontFor(s, glyphs, soleFont, warnings);
       const upm = (gf == null ? void 0 : gf.unitsPerEm) || 1e3;
       const scale = s.fontSize / upm;
-      const ascent = ((_c = gf == null ? void 0 : gf.ascent) != null ? _c : 0.9 * upm) * scale;
+      const ascent = ((_b2 = gf == null ? void 0 : gf.ascent) != null ? _b2 : 0.9 * upm) * scale;
       for (let i = 0; i < content.length; i++) {
         const ch = content.charAt(i);
         const g = gf == null ? void 0 : gf.glyphs[ch];
@@ -5537,21 +5780,21 @@ function collectAlongPathCells(node, glyphs, soleFont, warnings) {
   const cells = [];
   let adv = 0;
   const walk = (el, parentStyle) => {
-    var _a2, _b, _c;
+    var _a2, _b;
     const s = resolveStyle2(el, parentStyle);
-    const content = (_a2 = str(el[TEXT_CONTENT_ATTR])) != null ? _a2 : str(el[TEXT_ATTR]);
-    if (content && !((_b = el.children) == null ? void 0 : _b.length)) {
+    const content = str(el[TEXT_CONTENT_ATTR]);
+    if (content && !((_a2 = el.children) == null ? void 0 : _a2.length)) {
       const gf = glyphFontFor(s, glyphs, soleFont, warnings);
       if (gf) {
         const scale = s.fontSize / gf.unitsPerEm;
-        const ascentEm = (_c = gf.ascent) != null ? _c : 0.9 * gf.unitsPerEm;
+        const ascentEm = (_b = gf.ascent) != null ? _b : 0.9 * gf.unitsPerEm;
         const paint = paintOf(s);
         for (let i = 0; i < content.length; i++) {
           const ch = content.charAt(i);
           const g = gf.glyphs[ch];
-          if (g && g.d) {
+          if (g && g.pathData) {
             const glyphAdv = g.width * scale;
-            cells.push({ glyphD: g.d, widthEm: g.width, scale, paint, midBase: adv + glyphAdv / 2 });
+            cells.push({ glyphD: g.pathData, widthEm: g.width, scale, paint, midBase: adv + glyphAdv / 2 });
             adv += glyphAdv;
           } else if (/\S/.test(ch)) {
             const wEm = g && g.width > 0 ? g.width : MISSING_GLYPH_ADVANCE_EM * gf.unitsPerEm;
@@ -5582,7 +5825,7 @@ function alongPathNodeOffsets(node) {
     perp: (_c = parseLen(node.dy)) != null ? _c : 0
   };
 }
-function materialiseGlyphTextAlongPath(node, pathD, startOffset, opts, textLength, pathOverflow) {
+function materializeGlyphTextAlongPath(node, pathD, startOffset, opts, textLength, pathOverflow) {
   const { glyphs, create = jsonElementFactory, warnings } = opts;
   const sampler = pathD ? createPathSampler(pathD) : null;
   if (!sampler) {
@@ -5661,8 +5904,8 @@ function buildAnimatedAlongPath(cells, sampler, distOf, times, loop, create, isC
   const onPath = (dist) => dist >= 0 && dist <= sampler.totalLength;
   const out = [];
   for (const c of cells) {
-    const centred = [c.scale, 0, 0, c.scale, -c.scale * (c.widthEm / 2), 0];
-    const d = transformPathData(c.glyphD, centred);
+    const centered = [c.scale, 0, 0, c.scale, -c.scale * (c.widthEm / 2), 0];
+    const d = transformPathData(c.glyphD, centered);
     const sampleKf = (dist, time) => {
       const { x, y, angle } = sampler.sampleAtDistance(dist);
       const cos = Math.cos(angle), sin = Math.sin(angle);
@@ -5754,9 +5997,9 @@ function toGroup(node, children, create) {
   }
   return create("g", gProps, children);
 }
-function materialiseGlyphText(node, opts) {
-  if (opts.alongPath) return materialiseGlyphTextAlongPath(node, opts.alongPath.pathD, opts.alongPath.startOffset, opts, opts.alongPath.textLength, opts.alongPath.pathOverflow);
-  return materialiseGlyphTextHorizontal(node, opts);
+function materializeGlyphText(node, opts) {
+  if (opts.alongPath) return materializeGlyphTextAlongPath(node, opts.alongPath.pathD, opts.alongPath.startOffset, opts, opts.alongPath.textLength, opts.alongPath.pathOverflow);
+  return materializeGlyphTextHorizontal(node, opts);
 }
 function applyTextGlyphsEffect(node, fx, ctx) {
   if (!(fx == null ? void 0 : fx.useGlyphs)) return node;
@@ -5764,14 +6007,14 @@ function applyTextGlyphsEffect(node, fx, ctx) {
     ctx.warnings.push("textGlyphs: no definitions.fonts \u2014 left as native <text>");
     return node;
   }
-  return materialiseGlyphTextHorizontal(node, { glyphs: ctx.glyphs, warnings: ctx.warnings });
+  return materializeGlyphTextHorizontal(node, { glyphs: ctx.glyphs, warnings: ctx.warnings });
 }
 function applyTextGlyphsAlongPath(node, ctx, pathD, startOffset, textLength, pathOverflow) {
   if (!ctx.glyphs) {
     ctx.warnings.push("textGlyphs: no definitions.fonts");
     return null;
   }
-  return materialiseGlyphTextAlongPath(node, pathD, startOffset, { glyphs: ctx.glyphs, warnings: ctx.warnings }, textLength, pathOverflow);
+  return materializeGlyphTextAlongPath(node, pathD, startOffset, { glyphs: ctx.glyphs, warnings: ctx.warnings }, textLength, pathOverflow);
 }
 
 // src/effects/stroke/strokeTrimEffect.ts
@@ -6173,7 +6416,7 @@ function applyPlayerEffects_retime(node, ctx) {
   return node;
 }
 
-// src/materialise/PxOffsetPathMaterialiser.ts
+// src/materialize/PxOffsetPathMaterializer.ts
 function cubicAt(p0, c1, c2, p1, t) {
   const u = 1 - t;
   const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
@@ -6239,7 +6482,7 @@ function buildOffsetPath(propAnim) {
   }
   return { pathStr: d, distanceKfs, autoOrient: !!propAnim.autoOrient, anchor };
 }
-function materialiseOffsetPathsInTree(root) {
+function materializeOffsetPathsInTree(root) {
   const walk = (node) => {
     var _a2;
     let out = node;
@@ -6283,16 +6526,16 @@ function materialiseOffsetPathsInTree(root) {
   return walk(root);
 }
 
-// src/materialise/PxAnimatorMaterialiseAll.ts
-function materialiseAllInTree(doc, engine, opts) {
+// src/materialize/PxAnimatorMaterializeAll.ts
+function materializeAllInTree(doc, engine, opts) {
   var _a2, _b;
   let root = applyPlayerEffects(doc).root;
-  root = materialiseOffsetPathsInTree(root);
+  root = materializeOffsetPathsInTree(root);
   const duration = (_b = (_a2 = getAnimatorConfig(root)) == null ? void 0 : _a2.duration) != null ? _b : DEFAULT_DURATION_MS;
-  root = materialiseInternalLoopsInTree(root, duration);
+  root = materializeInternalLoopsInTree(root, duration);
   if (engine === PxTimelineEngine.native) {
-    root = materialiseMotionPathsInTree(root, opts == null ? void 0 : opts.motionPath);
-    root = materialiseAnimatedUseInstances(root);
+    root = materializeMotionPathsInTree(root, opts == null ? void 0 : opts.motionPath);
+    root = materializeAnimatedUseInstances(root);
     root = pruneUnreferencedDefs(root);
   }
   return root;
@@ -6327,6 +6570,66 @@ function pruneUnreferencedDefs(root) {
   return root;
 }
 
+// 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;
+}
+function createRunClock(ceilingMs, nowFn = Date.now) {
+  let baseMs = 0;
+  let startedAt = 0;
+  let running = false;
+  let rate = 1;
+  const value = () => running ? clampSeekMs(baseMs + (nowFn() - startedAt) * rate, ceilingMs) : clampSeekMs(baseMs, ceilingMs);
+  return {
+    now: value,
+    isRunning: () => running,
+    start: (r, atMs) => {
+      baseMs = clampSeekMs(atMs != null ? atMs : value(), ceilingMs);
+      rate = isValidPlaybackRate(r) ? r : 1;
+      startedAt = nowFn();
+      running = true;
+    },
+    stop: () => {
+      baseMs = value();
+      startedAt = 0;
+      running = false;
+    },
+    seek: (ms) => {
+      baseMs = clampSeekMs(ms, ceilingMs);
+      if (running) startedAt = nowFn();
+    }
+  };
+}
+
 // src/playback/PxFrameLoop.ts
 function requestFrame(cb) {
   const g = globalThis;
@@ -6344,7 +6647,7 @@ function cancelFrame(handle) {
 function createBasicFrameLoopAnimator(doc, adapter, callbacks) {
   var _a2;
   const config = getAnimatorConfig(doc) || {};
-  const bindings = getNormalisedBindings(doc, PxTimelineEngine.js);
+  const bindings = getNormalizedBindings(doc, PxTimelineEngine.js);
   const _iterations = config.iterations;
   let iterations = 1;
   if (typeof _iterations === "number") iterations = _iterations || 1;
@@ -6574,8 +6877,8 @@ function createBasicFrameLoopAnimator(doc, adapter, callbacks) {
       finishAnim(true);
     },
     "setPlaybackRate": (rate) => {
-      if (!isFinite(rate) || rate === 0) {
-        console.warn("setPlaybackRate: rate must be finite and non-zero");
+      if (!isValidPlaybackRate(rate)) {
+        console.warn(PX_RATE_REJECTED);
         return;
       }
       let current = getRawAnimTime();
@@ -6589,13 +6892,16 @@ function createBasicFrameLoopAnimator(doc, adapter, callbacks) {
       return getAnimCurrentTime();
     },
     "setCurrentTime": (newTime) => {
-      if (newTime < 0) newTime = 0;
-      if (Number.isFinite(totalDuration) && newTime > totalDuration) newTime = totalDuration;
+      newTime = clampSeekMs(newTime, totalDuration);
       timeBeforeLastStartMs = newTime;
       if (playing) lastStartedTs = Date.now();
       if (!Number.isFinite(totalDuration) || newTime < totalDuration) finishCalled = false;
       renderFrame(getAnimCurrentTime());
     },
+    "getCurrentProgress": () => timeToProgress(getAnimCurrentTime(), duration, iterations),
+    "setCurrentProgress": (progress) => {
+      api.setCurrentTime(progressToTimeMs(progress, duration, iterations));
+    },
     "destroy": () => {
       var _a3;
       api.cancel();
@@ -6605,6 +6911,51 @@ function createBasicFrameLoopAnimator(doc, adapter, callbacks) {
   return api;
 }
 
+// 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/effects/PlayerEffectsUtil.visualModel.ts
 var IDENTITY = [1, 0, 0, 1, 0, 0];
 function mul(m, n) {
@@ -6877,32 +7228,30 @@ function mergeTimeline(base, patch, warn) {
   }
   return merged;
 }
-function foldAnimatorConfigShortcuts(config, shortcuts) {
+function foldTimelineOverride(timeline, shortcuts) {
   let base;
-  if (typeof config === "string") {
+  if (typeof timeline === "string") {
     try {
-      base = JSON.parse(config);
+      base = JSON.parse(timeline);
     } catch (e) {
-      console.warn("animator config: not valid JSON \u2014 ignored", e);
+      console.warn("timeline override: not valid JSON \u2014 ignored", e);
       base = void 0;
     }
   } else {
-    base = config != null ? config : void 0;
+    base = timeline != null ? timeline : void 0;
   }
   const { duration, delay, iterations, startOn } = shortcuts;
   if (duration === void 0 && delay === void 0 && iterations === void 0 && startOn === void 0) {
-    return base;
+    return base === void 0 ? void 0 : { timeline: base };
   }
   const out = isPlainObject(base) ? __spreadValues({}, base) : {};
-  const timeline = __spreadValues({}, out.timeline);
-  if (duration !== void 0) timeline.duration = duration;
-  if (delay !== void 0) timeline.delay = delay;
-  if (iterations !== void 0) timeline.iterations = iterations;
+  if (duration !== void 0) out.duration = duration;
+  if (delay !== void 0) out.delay = delay;
+  if (iterations !== void 0) out.iterations = iterations;
   if (startOn !== void 0) {
-    timeline.trigger = __spreadProps(__spreadValues({}, timeline.trigger), { startOn });
+    out.trigger = __spreadProps(__spreadValues({}, out.trigger), { startOn });
   }
-  out.timeline = timeline;
-  return out;
+  return { timeline: out };
 }
 function mergeAnimatorConfig(base, patch) {
   const warnings = [];
@@ -6970,26 +7319,12 @@ function applyAnimatorConfig(doc, patch, opts) {
 
 // src/format/PxDocumentDiagnostic.ts
 var MAX_REPORTED = 6;
-var LEGACY_FLAT_KEYS = [
-  ...PX_TIMELINE_SHARED_KEYS,
-  ...PX_TIME_ONLY_TIMELINE_KEYS,
-  "fill",
-  "resetOnFinish",
-  "timelineSource",
-  "scroll"
-];
-var isLegacyFlatAnimatorKey = (w) => LEGACY_FLAT_KEYS.some((k) => w.indexOf("animator." + k + ":") >= 0);
 function diagnoseDocument(doc) {
-  let all;
   try {
-    all = validateDocument(doc);
+    return { problems: validateDocument(doc) };
   } catch (e) {
-    return { problems: [], legacy: [] };
+    return { problems: [] };
   }
-  const problems = [];
-  const legacy = [];
-  for (const w of all) (isLegacyFlatAnimatorKey(w) ? legacy : problems).push(w);
-  return { problems, legacy };
 }
 function reportDocumentDiagnostics(doc, where) {
   const { problems } = diagnoseDocument(doc);
@@ -7003,7 +7338,7 @@ function reportDocumentDiagnostics(doc, where) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BASELINE_PLAYER_VERSION,
-  COLOUR_ATTR_NAMES,
+  COLOR_ATTR_NAMES,
   CSS_ONLY_STYLE_PROPS,
   DEFAULT_DURATION_MS,
   DISALLOWED_SVG_TAGS_LOWER,
@@ -7016,45 +7351,65 @@ function reportDocumentDiagnostics(doc, where) {
   PX_ANIM_ATTR_NAME,
   PX_ANIM_SRC_ATTR_NAME,
   PX_PLAYER_SCHEMA_VERSION,
+  PX_RATE_REJECTED,
   PX_TRANSFORM_PART_KEYS,
+  PX_TRIGGER_DEFAULTS,
   PX_UNKNOWN_KEY_ERROR,
+  PxAlongPathMode,
   PxAnimatedSvgDocumentSchema,
   PxAnimationDefinitionSchema,
   PxAnimatorConfigSchema,
   PxAttrValueSchema,
   PxBezierPathSchema,
   PxBindingSchema,
+  PxClipPathEffectSchema,
   PxCloneEffectSchema,
   PxCloneWithout,
+  PxControlMode,
   PxDefsSchema,
+  PxDiagnosticKind,
   PxEasingOrRefSchema,
   PxEffectsSchema,
   PxElementAnimationSchema,
   PxFillGradientEffectSchema,
+  PxFillMode,
+  PxFinishAction,
   PxGradientSpreadMethod,
   PxGradientStopSchema,
   PxGradientType,
-  PxGradientUnits,
   PxKeyframeSchema,
   PxKeyframeValueSchema,
+  PxLengthAdjust,
   PxLoopDirection,
   PxLoopRepeatAt,
   PxLoopSchema,
+  PxMaskType,
   PxMaskedByEffectSchema,
   PxNodeBase,
   PxNodeSchema,
+  PxOutAction,
+  PxPathOverflow,
+  PxPinAlign,
+  PxPlaybackDirection,
   PxPropertyAnimationSchema,
   PxRepeaterEffectSchema,
   PxRetimeEffectSchema,
+  PxScrollAxis,
+  PxScrollKind,
+  PxScrollPhase,
   PxScrollRangePointSchema,
   PxScrollRangeSchema,
   PxScrollSchema,
+  PxScrollSource,
+  PxStartOn,
   PxStrokeGradientEffectSchema,
   PxStrokeTrimEffectSchema,
   PxStrokeTrimSubPaths,
   PxSvgNodeExtra,
   PxTextEffectSchema,
   PxTextPathEffectSchema,
+  PxTextPathMethod,
+  PxTextPathSpacing,
   PxTimelineEngine,
   PxTimelineEngineExtra,
   PxTimelinePinSchema,
@@ -7063,8 +7418,8 @@ function reportDocumentDiagnostics(doc, where) {
   PxTransformPartsSchema,
   PxTransformValueSchema,
   PxTriggerSchema,
+  PxUnits,
   STYLE_ATTR_NAMES,
-  TEXT_ATTR,
   TEXT_CONTENT_ATTR,
   TRANSFORM_FN_NAMES,
   WIRE_VERSION_KEY,
@@ -7078,12 +7433,16 @@ function reportDocumentDiagnostics(doc, where) {
   calcAnimationValues,
   camelCaseToKebabWordIfNeeded,
   clamp,
+  clampSeekMs,
   collectSampleTimes,
   compareWireVersion,
   composeTransformParts,
+  controlModeTakesOverTrigger,
   convertPlayerDocument,
   createBasicFrameLoopAnimator,
+  createDiagnostics,
   createPathSampler,
+  createRunClock,
   cubicBezier,
   deepClone,
   describeSchema,
@@ -7094,7 +7453,7 @@ function reportDocumentDiagnostics(doc, where) {
   evaluateMotionPathSegment,
   extendedPathForBrowser,
   flattenAnimatorTimeline,
-  foldAnimatorConfigShortcuts,
+  foldTimelineOverride,
   formatWireVersion,
   generateNewIds,
   generateUniqueId,
@@ -7102,7 +7461,7 @@ function reportDocumentDiagnostics(doc, where) {
   getBindings,
   getChildren,
   getDefs,
-  getNormalisedBindings,
+  getNormalizedBindings,
   getNormalizedProps,
   interpolateBeziers,
   interpolateValue,
@@ -7110,6 +7469,7 @@ function reportDocumentDiagnostics(doc, where) {
   isPxElementFileFormat,
   isPxElementFileFormatDeep,
   isScrollTimeline,
+  isValidPlaybackRate,
   jsonElementFactory,
   kebabToCamelCaseWord,
   kfEasing,
@@ -7118,15 +7478,15 @@ function reportDocumentDiagnostics(doc, where) {
   kfTime,
   kfValue,
   layoutGlyphTextChars,
-  materialiseAllInTree,
-  materialiseAnimatedUseInstances,
-  materialiseGlyphText,
-  materialiseGlyphTextAlongPath,
-  materialiseGlyphTextHorizontal,
-  materialiseInternalLoopsInPropAnim,
-  materialiseInternalLoopsInTree,
-  materialiseMotionPathInPropAnim,
-  materialiseMotionPathsInTree,
+  materializeAllInTree,
+  materializeAnimatedUseInstances,
+  materializeGlyphText,
+  materializeGlyphTextAlongPath,
+  materializeGlyphTextHorizontal,
+  materializeInternalLoopsInPropAnim,
+  materializeInternalLoopsInTree,
+  materializeMotionPathInPropAnim,
+  materializeMotionPathsInTree,
   mayUseNativeScrollTimeline,
   mergeAnimatorConfig,
   mergeStaticTransformIntoAnimDef,
@@ -7134,15 +7494,19 @@ function reportDocumentDiagnostics(doc, where) {
   parseTransformParts,
   parseWireVersion,
   planSchemaRelease,
+  progressSpanMs,
+  progressToTimeMs,
   propAnimIsMotionPath,
   px,
   readWireVersion,
   releaseLogProblems,
   reportDocumentDiagnostics,
+  resolveControlMode,
   resolveStyle,
   resolveTimelineEngine,
+  resolveTrigger,
   reverseEasing,
-  sanitiseAttributeValue,
+  sanitizeAttributeValue,
   schemaFieldUniverse,
   schemaKeys,
   scrollOffsetProgress,
@@ -7150,9 +7514,11 @@ function reportDocumentDiagnostics(doc, where) {
   scrollResolveAxis,
   scrollTotalDurationMs,
   scrollViewProgress,
+  seekCeilingMs,
   shiftAnimatable,
   splitEasing,
   subdivideCubicBezier,
+  timeToProgress,
   toRGBA,
   validateDocument,
   validateNodeEffects,