@astryxdesign/core 0.7.8 → 0.7.9-canary.07992bb

package/dist/internal/spinner-rotor.js

@@ -0,0 +1,16 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+/**
+ * @file spinner-rotor.ts
+ * @input Spinner's shared rotor
+ * @output `@astryxdesign/core/internal/spinner-rotor`: SPINNER_ARC_FRACTION,
+ *   spinnerRotorStyles and syncRotationPhase, re-exported by name for Lab's
+ *   indeterminate CircularProgress
+ * @position An internal entry reserved for Astryx's own packages. It is
+ *   undocumented, outside the public API and its compatibility promise, and
+ *   versioned in lockstep with Core. The `@astryx/no-core-internal-import`
+ *   lint rule allows it only in Core and Lab. Core components import the
+ *   same modules by relative path. Named re-exports only.
+ *
+ * SYNC: When modified, update scripts/sync-exports.js.
+ */
+export { SPINNER_ARC_FRACTION, spinnerRotorStyles, syncRotationPhase } from "../Spinner/spinnerRotor.js";

package/dist/internal/touch.d.ts

@@ -1,6 +1,8 @@
 /**
  * @file touch.ts
- * @input The gesture core: the arena, the recognizers, and their geometry
+ * @input The gesture core: the arena, the recognizers, and their geometry;
+ *   the pan, the motion animator and the motion math that Lab's
+ *   useRefreshControl reads
  * @output `@astryxdesign/core/internal/touch`: the gesture core's primitives
  *   for Lab components, re-exported by name
  * @position An internal entry reserved for Astryx's own packages:
@@ -23,4 +25,15 @@ export { angleBetween, centroid, distance, travel, unwrapAngle, } from '../gestu
 export { LongPressGestureRecognizer } from '../gestures/LongPressGestureRecognizer.js';
 export { TapGestureRecognizer } from '../gestures/TapGestureRecognizer.js';
 export { DEFAULT_ENVIRONMENT } from '../gestures/types.js';
+export { PanGestureRecognizer } from '../gestures/PanGestureRecognizer.js';
+export type { PanGestureRecognizerOptions } from '../gestures/PanGestureRecognizer.js';
+export type { GestureEventContext, GestureTouch, PointerKind, } from '../gestures/types.js';
+export { useGestureRecognizer } from '../gestures/useGestureRecognizer.js';
+export { createMotionAnimator } from '../motion/animator.js';
+export type { Animator as MotionAnimator, AnimatorOptions as MotionAnimatorOptions, MotionCurve, } from '../motion/animator.js';
+export { cubicBezier } from '../motion/bezier.js';
+export { mapProgress } from '../motion/progress.js';
+export { parseCssEasing, parseMotionRoleValue } from '../motion/roles.js';
+export { rubberBand, rubberBandInverse, rubberBandSlope, } from '../motion/rubberBand.js';
+export { scroll } from '../motion/uikit/scroll.js';
 //# sourceMappingURL=touch.d.ts.map

package/dist/internal/touch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"touch.d.ts","sourceRoot":"","sources":["../../src/internal/touch.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AACpE,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV,mBAAmB,EACnB,YAAY,GACb,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAC,0BAA0B,EAAC,MAAM,wCAAwC,CAAC;AAClF,OAAO,EAAC,oBAAoB,EAAC,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"touch.d.ts","sourceRoot":"","sources":["../../src/internal/touch.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AACpE,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV,mBAAmB,EACnB,YAAY,GACb,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAC,0BAA0B,EAAC,MAAM,wCAAwC,CAAC;AAClF,OAAO,EAAC,oBAAoB,EAAC,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAOtD,OAAO,EAAC,oBAAoB,EAAC,MAAM,kCAAkC,CAAC;AACtE,YAAY,EAAC,2BAA2B,EAAC,MAAM,kCAAkC,CAAC;AAClF,YAAY,EACV,mBAAmB,EACnB,YAAY,EACZ,WAAW,GACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAC,oBAAoB,EAAC,MAAM,kCAAkC,CAAC;AAGtE,OAAO,EAAC,oBAAoB,EAAC,MAAM,oBAAoB,CAAC;AACxD,YAAY,EACV,QAAQ,IAAI,cAAc,EAC1B,eAAe,IAAI,qBAAqB,EACxC,WAAW,GACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAC,cAAc,EAAE,oBAAoB,EAAC,MAAM,iBAAiB,CAAC;AACrE,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC"}

package/dist/internal/touch.js

@@ -2,7 +2,9 @@
 
 /**
  * @file touch.ts
- * @input The gesture core: the arena, the recognizers, and their geometry
+ * @input The gesture core: the arena, the recognizers, and their geometry;
+ *   the pan, the motion animator and the motion math that Lab's
+ *   useRefreshControl reads
  * @output `@astryxdesign/core/internal/touch`: the gesture core's primitives
  *   for Lab components, re-exported by name
  * @position An internal entry reserved for Astryx's own packages:
@@ -25,4 +27,20 @@ export { ALL_NATIVE_TOUCH, GestureRecognizer, isActive, isTerminal, isTransition
 export { angleBetween, centroid, distance, travel, unwrapAngle } from "../gestures/geometry.js";
 export { LongPressGestureRecognizer } from "../gestures/LongPressGestureRecognizer.js";
 export { TapGestureRecognizer } from "../gestures/TapGestureRecognizer.js";
-export { DEFAULT_ENVIRONMENT } from "../gestures/types.js";
+export { DEFAULT_ENVIRONMENT } from "../gestures/types.js";
+
+// Lab's useRefreshControl reads these: its pull's pan and the hook that
+// starts it. It also reads the motion animator and math, and the scroll
+// view's bounce spring, for its pull, settle and end. Its indicator fades
+// along the settle's curve, and the motion-role parsers read the theme's
+// tokens for its end.
+export { PanGestureRecognizer } from "../gestures/PanGestureRecognizer.js";
+export { useGestureRecognizer } from "../gestures/useGestureRecognizer.js";
+// The animator's internal factory. The public one, `createAnimator`, plays
+// only the theme's state-change motion.
+export { createMotionAnimator } from "../motion/animator.js";
+export { cubicBezier } from "../motion/bezier.js";
+export { mapProgress } from "../motion/progress.js";
+export { parseCssEasing, parseMotionRoleValue } from "../motion/roles.js";
+export { rubberBand, rubberBandInverse, rubberBandSlope } from "../motion/rubberBand.js";
+export { scroll } from "../motion/uikit/scroll.js";

package/dist/motion/carryAnimations.d.ts

@@ -0,0 +1,58 @@
+type Writable = Record<string, unknown>;
+/** One animation's state, read before the browser starts it afresh. */
+export interface SavedAnimation {
+    animation: Animation;
+    name: string;
+    target: Element | null;
+    pseudoElement: string | null;
+    values: Writable;
+    effectValues: Writable;
+    timing: EffectTiming | null;
+    keyframes: ComputedKeyframe[] | null;
+    playState: AnimationPlayState;
+    replaceState: AnimationReplaceState;
+}
+/**
+ * Reads one animation's state generically, from what the platform exposes.
+ * That is every accessor with a setter on the animation's and its effect's
+ * prototype chains, every field of the effect's timing, and its keyframes. Only values
+ * that differ from the recreated animation's are written back, so a value the
+ * stylesheet controls stays under its control. A few members are not plain
+ * state and are written in their own step (`ORDERED`). The Animation and
+ * effect objects themselves cannot be carried over: the old ones keep their
+ * listeners and promises.
+ */
+export declare function saveAnimation(animation: Animation): SavedAnimation;
+/**
+ * Puts each state `saved` holds on the CSS animations and transitions of
+ * `root` and its subtree that are not among `survivors`. Each CSS animation
+ * the browser started afresh takes the state of the one it replaces. It is
+ * matched by element, pseudo-element and name, in order, and then by name
+ * alone (an effect script moved to another element or pseudo-element). Each
+ * transition whose animation no longer runs resumes as a script animation in
+ * its state. One started afresh that replaces none is finished: an entrance
+ * that had played and been dropped, or a transition from `@starting-style`.
+ * Script animations are left as they are.
+ */
+export declare function restoreAnimations(root: Element, saved: ReadonlyArray<SavedAnimation>, survivors: ReadonlySet<Animation>): void;
+/** The CSS animations and transitions `saveAnimations` read. */
+export type SavedAnimations = ReadonlyArray<SavedAnimation>;
+/**
+ * Reads the state of every CSS animation and transition of `root` and its
+ * subtree, for `carryAnimations` to give a copy of it.
+ */
+export declare function saveAnimations(root: Element): SavedAnimations;
+/**
+ * Carries on in `copy`, a clone of the root `saved` was read from, now laid
+ * out, the CSS animations and transitions its element ran. A clone starts
+ * each CSS animation again and runs no transition but a `@starting-style`
+ * one. So each CSS animation the clone started takes the state of its
+ * element's, and each transition runs on as a script animation. One the
+ * clone started that its element no longer ran is finished: an entrance that
+ * had played, or a `@starting-style` transition. `copyOf` maps each element
+ * of the cloned subtree to its copy. The element's own animations keep
+ * running, so the copy's take no id or event handler.
+ */
+export declare function carryAnimations(saved: SavedAnimations, copy: Element, copyOf: (element: Element) => Element | null): void;
+export {};
+//# sourceMappingURL=carryAnimations.d.ts.map

package/dist/motion/carryAnimations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"carryAnimations.d.ts","sourceRoot":"","sources":["../../src/motion/carryAnimations.ts"],"names":[],"mappings":"AA+BA,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAsDxC,uEAAuE;AACvE,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,QAAQ,CAAC;IACjB,YAAY,EAAE,QAAQ,CAAC;IACvB,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAAC;IACrC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,YAAY,EAAE,qBAAqB,CAAC;CACrC;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,CAyBlE;AAsJD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,aAAa,CAAC,cAAc,CAAC,EACpC,SAAS,EAAE,WAAW,CAAC,SAAS,CAAC,GAChC,IAAI,CA8CN;AAED,gEAAgE;AAChE,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;AAE5D;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,CAQ7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC3C,IAAI,CASN"}

package/dist/motion/carryAnimations.js

@@ -0,0 +1,305 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file carryAnimations.ts
+ * @input The CSS animations and transitions of an element and its subtree,
+ *   read before the browser starts them afresh
+ * @output Exports `saveAnimations` and `carryAnimations`, which carry them on
+ *   in a clone of the element. Also `saveAnimation` and `restoreAnimations`,
+ *   which put them back after a display reset
+ * @position Motion foundation; the transient copy (transientCopy.ts) and the
+ *   layer runtime's re-placement (Layer/preserveAnimations.ts) use it
+ */
+
+/**
+ * Animation members written in a fixed order rather than generically: the
+ * timeline before the range that is measured on it, the rate before the
+ * time, and the start time (or, for a paused animation, the current time)
+ * last, once the play state is set. `effect` is not
+ * replaced, because a CSS animation whose effect script replaces leaves the
+ * stylesheet's control; its state is copied onto the new effect instead.
+ */
+const ORDERED = new Set(['effect', 'timeline', 'rangeStart', 'rangeEnd', 'playbackRate', 'startTime', 'currentTime']);
+/** Every accessor with a setter on `object`'s prototype chain. */
+function writableAccessors(object) {
+  const names = new Set();
+  for (let proto = Object.getPrototypeOf(object); proto != null && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(proto))) {
+      if (descriptor.set != null) {
+        names.add(name);
+      }
+    }
+  }
+  return [...names];
+}
+
+/**
+ * A textual form of a value that is compared by content rather than by
+ * identity: a CSS numeric value (as in a timeline range offset) through its
+ * serialization, a plain object (a range) through its members. Anything else
+ * is compared by identity (`null`).
+ */
+function contentOf(value) {
+  if (typeof CSSNumericValue !== 'undefined' && value instanceof CSSNumericValue) {
+    return value.toString();
+  }
+  if (value != null && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.entries(value).map(([key, inner]) => `${key}:${contentOf(inner) ?? String(inner)}`).join(';');
+  }
+  return null;
+}
+function differs(a, b) {
+  if (a === b) {
+    return false;
+  }
+  const textA = contentOf(a);
+  return textA == null || textA !== contentOf(b);
+}
+
+/** One animation's state, read before the browser starts it afresh. */
+
+/**
+ * Reads one animation's state generically, from what the platform exposes.
+ * That is every accessor with a setter on the animation's and its effect's
+ * prototype chains, every field of the effect's timing, and its keyframes. Only values
+ * that differ from the recreated animation's are written back, so a value the
+ * stylesheet controls stays under its control. A few members are not plain
+ * state and are written in their own step (`ORDERED`). The Animation and
+ * effect objects themselves cannot be carried over: the old ones keep their
+ * listeners and promises.
+ */
+export function saveAnimation(animation) {
+  const effect = animation.effect;
+  const values = {};
+  for (const name of writableAccessors(animation)) {
+    values[name] = animation[name];
+  }
+  const effectValues = {};
+  if (effect != null) {
+    for (const name of writableAccessors(effect)) {
+      effectValues[name] = effect[name];
+    }
+  }
+  return {
+    animation,
+    name: animation.animationName ?? '',
+    target: effect?.target ?? null,
+    pseudoElement: effect?.pseudoElement ?? null,
+    values,
+    effectValues,
+    timing: effect?.getTiming() ?? null,
+    keyframes: effect?.getKeyframes() ?? null,
+    playState: animation.playState,
+    replaceState: animation.replaceState
+  };
+}
+function write(object, name, value) {
+  object[name] = value;
+}
+
+/** Give `next` the effect state `saved` had: every writable member. */
+function restoreEffect(next, saved) {
+  for (const name of writableAccessors(next)) {
+    if (name in saved.effectValues && differs(saved.effectValues[name], next[name])) {
+      write(next, name, saved.effectValues[name]);
+    }
+  }
+  if (saved.timing != null) {
+    const timing = next.getTiming();
+    const changed = {};
+    for (const [field, value] of Object.entries(saved.timing)) {
+      if (differs(value, timing[field])) {
+        changed[field] = value;
+      }
+    }
+    if (Object.keys(changed).length > 0) {
+      next.updateTiming(changed);
+    }
+  }
+  if (saved.keyframes != null && JSON.stringify(saved.keyframes) !== JSON.stringify(next.getKeyframes())) {
+    next.setKeyframes(saved.keyframes);
+  }
+}
+
+/** Give `next` the state `saved` had, member by member. */
+function restore(next, saved) {
+  const effect = next.effect;
+  if (effect != null) {
+    restoreEffect(effect, saved);
+  }
+  const current = next;
+  for (const name of ['timeline', 'rangeStart', 'rangeEnd']) {
+    if (name in saved.values && differs(saved.values[name], current[name])) {
+      write(next, name, saved.values[name]);
+    }
+  }
+  for (const name of writableAccessors(next)) {
+    if (!ORDERED.has(name) && name in saved.values && differs(saved.values[name], current[name])) {
+      write(next, name, saved.values[name]);
+    }
+  }
+  if (saved.replaceState === 'persisted' && next.replaceState !== 'persisted') {
+    next.persist();
+  }
+  const rate = saved.values.playbackRate;
+  if (typeof rate === 'number' && rate !== next.playbackRate) {
+    next.playbackRate = rate;
+  }
+  if (saved.playState === 'paused' && next.playState !== 'paused') {
+    next.pause();
+  } else if (saved.playState !== 'paused' && next.playState === 'paused') {
+    next.play();
+  }
+  // A running animation is anchored to its timeline by its start time, which
+  // carries its current time on exactly. A paused one has none and keeps its
+  // current time. A finished one holds its end: finishing it again holds the
+  // same time, though its start time is then counted from now, since script
+  // cannot set a start time and a held time together.
+  const start = saved.values.startTime;
+  const time = saved.values.currentTime;
+  if (saved.playState === 'finished') {
+    next.finish();
+  } else if (start != null) {
+    next.startTime = start;
+  } else if (time != null) {
+    next.currentTime = time;
+  }
+}
+
+/** Resume a cancelled CSS transition with a script animation in its state. */
+function resumeTransition(saved) {
+  if (saved.target == null || saved.keyframes == null) {
+    return;
+  }
+  const replacement = saved.target.animate(saved.keyframes, {
+    pseudoElement: saved.pseudoElement ?? undefined
+  });
+  restore(replacement, saved);
+}
+function isTransition(animation) {
+  return typeof CSSTransition !== 'undefined' && animation instanceof CSSTransition;
+}
+function isCssAnimation(animation) {
+  return typeof CSSAnimation !== 'undefined' && animation instanceof CSSAnimation;
+}
+
+/**
+ * Finishes an animation that ends: an infinite one cannot be finished, and is
+ * left as it runs.
+ */
+function finishIfItEnds(animation) {
+  const end = animation.effect?.getComputedTiming().endTime;
+  if (end != null && Number.isFinite(Number(end)) && animation.playbackRate !== 0) {
+    animation.finish();
+  }
+}
+
+/** The members a copy's animation does not take: its element's keep them. */
+const IDENTITY_MEMBERS = new Set(['id', 'onfinish', 'oncancel', 'onremove']);
+
+/**
+ * `saved` for an animation that carries on on the copy of its element:
+ * aimed at the copy, without the element's id and event handlers.
+ */
+function retarget(saved, copyOf) {
+  const target = saved.target == null ? null : copyOf(saved.target);
+  if (target == null) {
+    return null;
+  }
+  const values = Object.fromEntries(Object.entries(saved.values).filter(([name]) => !IDENTITY_MEMBERS.has(name)));
+  const effectValues = {
+    ...saved.effectValues
+  };
+  if ('target' in effectValues) {
+    effectValues.target = target;
+  }
+  return {
+    ...saved,
+    target,
+    values,
+    effectValues
+  };
+}
+
+/**
+ * Puts each state `saved` holds on the CSS animations and transitions of
+ * `root` and its subtree that are not among `survivors`. Each CSS animation
+ * the browser started afresh takes the state of the one it replaces. It is
+ * matched by element, pseudo-element and name, in order, and then by name
+ * alone (an effect script moved to another element or pseudo-element). Each
+ * transition whose animation no longer runs resumes as a script animation in
+ * its state. One started afresh that replaces none is finished: an entrance
+ * that had played and been dropped, or a transition from `@starting-style`.
+ * Script animations are left as they are.
+ */
+export function restoreAnimations(root, saved, survivors) {
+  const after = root.getAnimations({
+    subtree: true
+  });
+  const current = new Set(after);
+  const cancelled = [];
+  for (const state of saved) {
+    if (current.has(state.animation)) {
+      continue;
+    }
+    if (isTransition(state.animation)) {
+      resumeTransition(state);
+    } else {
+      cancelled.push(state);
+    }
+  }
+  const recreated = after.filter(animation => (isCssAnimation(animation) || isTransition(animation)) && !survivors.has(animation));
+  const unmatched = [];
+  for (const animation of recreated) {
+    const effect = animation.effect;
+    const name = animation.animationName ?? '';
+    const index = cancelled.findIndex(state => state.name === name && state.target === (effect?.target ?? null) && state.pseudoElement === (effect?.pseudoElement ?? null));
+    if (index === -1) {
+      unmatched.push(animation);
+    } else {
+      restore(animation, cancelled.splice(index, 1)[0]);
+    }
+  }
+  for (const animation of unmatched) {
+    const name = animation.animationName ?? '';
+    const index = cancelled.findIndex(state => state.name === name);
+    if (index === -1) {
+      finishIfItEnds(animation);
+    } else {
+      restore(animation, cancelled.splice(index, 1)[0]);
+    }
+  }
+}
+
+/** The CSS animations and transitions `saveAnimations` read. */
+
+/**
+ * Reads the state of every CSS animation and transition of `root` and its
+ * subtree, for `carryAnimations` to give a copy of it.
+ */
+export function saveAnimations(root) {
+  if (typeof root.getAnimations !== 'function') {
+    return [];
+  }
+  return root.getAnimations({
+    subtree: true
+  }).filter(animation => isCssAnimation(animation) || isTransition(animation)).map(saveAnimation);
+}
+
+/**
+ * Carries on in `copy`, a clone of the root `saved` was read from, now laid
+ * out, the CSS animations and transitions its element ran. A clone starts
+ * each CSS animation again and runs no transition but a `@starting-style`
+ * one. So each CSS animation the clone started takes the state of its
+ * element's, and each transition runs on as a script animation. One the
+ * clone started that its element no longer ran is finished: an entrance that
+ * had played, or a `@starting-style` transition. `copyOf` maps each element
+ * of the cloned subtree to its copy. The element's own animations keep
+ * running, so the copy's take no id or event handler.
+ */
+export function carryAnimations(saved, copy, copyOf) {
+  if (typeof copy.getAnimations !== 'function') {
+    return;
+  }
+  restoreAnimations(copy, saved.flatMap(state => retarget(state, copyOf) ?? []), new Set());
+}

package/dist/motion/transientCopy.d.ts

@@ -4,7 +4,8 @@ export declare function isCopyable(element: Element): boolean;
  * A copy that takes no part: no ids or test ids, no form or radio group (a
  * copied checked radio would uncheck the live one), no label for a live
  * control, and copied frames and media load nothing. Scrolled descendants
- * keep their offsets once the copy is laid out (`placeOver`).
+ * keep their offsets. The CSS animations and transitions running in it carry
+ * on from where they were, once the copy is laid out (`placeOver`).
  */
 export declare function inertCopy(element: HTMLElement): HTMLElement | null;
 /** The background `element` shows: its own, or the nearest ancestor's. */
@@ -12,7 +13,8 @@ export declare function paintedBackground(element: Element): string;
 /**
  * Lay `element` over `rect` (viewport coordinates), absolutely, as the last
  * child of `host`, wherever its containing block is: no ancestor's position
- * changes.
+ * changes. A copy's scrolled descendants then restore their offsets, and the
+ * CSS animations and transitions its element ran carry on in it.
  */
 export declare function placeOver(element: HTMLElement, host: Element, rect: DOMRect): void;
 /**

package/dist/motion/transientCopy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transientCopy.d.ts","sourceRoot":"","sources":["../../src/motion/transientCopy.ts"],"names":[],"mappings":"AAiCA,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEpD;AAqHD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CA0ClE;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAQ1D;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,GACZ,IAAI,CAwDN;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG;IACrD,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,IAAI,CA8CP;AAID;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,EAAE,CA6BrD"}
+{"version":3,"file":"transientCopy.d.ts","sourceRoot":"","sources":["../../src/motion/transientCopy.ts"],"names":[],"mappings":"AA0CA,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEpD;AA+HD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CA8ClE;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAQ1D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,OAAO,GACZ,IAAI,CAiEN;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG;IACrD,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,IAAI,CAoDP;AAID;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,EAAE,CA6BrD"}

package/dist/motion/transientCopy.js

@@ -15,9 +15,12 @@
  * technology, carries no ids or test ids, joins no form or radio group (a
  * copied checked radio would uncheck the live one), and its frames and media
  * load nothing. Laying it out changes no ancestor's position, and a scaled
- * host draws it at the old size. Laid in a host outside the element's own
- * ancestors, it keeps what it inherited from them: its inherited properties
- * and custom properties that differ from the host's are written on it.
+ * host draws it at the old size. A clone restarts each CSS animation and runs
+ * no transition but a `@starting-style` one; the copy carries on its
+ * element's from where they were.
+ * Laid in a host outside the element's own ancestors, it keeps what it
+ * inherited from them: its inherited properties and custom properties that
+ * differ from the host's are written on it.
  * Limits: a rule keyed on a removed `id`, or matched through an ancestor
  * between the host and the element (`.collapsed .label`), does not style the
  * copy as it styled the element; and content holding a canvas whose pixels read back
@@ -28,6 +31,8 @@
  * SYNC: When modified, update /packages/core/src/motion/animatedLayout.ts
  */
 
+import { carryAnimations, saveAnimations } from "./carryAnimations.js";
+
 /** Above this many elements, old content is not copied: the new one enters. */
 const MAX_COPIED_ELEMENTS = 1500;
 
@@ -115,11 +120,19 @@ function readInherited(element) {
 /** Scroll offsets a copy restores once laid out (a clone carries none). */
 const scrollOffsets = new WeakMap();
 
+/**
+ * The CSS animations and transitions a copy's element ran, and the copy of
+ * each element in the copied subtree. The copy carries them on once laid out
+ * (`placeOver`).
+ */
+const carriedMotion = new WeakMap();
+
 /**
  * A copy that takes no part: no ids or test ids, no form or radio group (a
  * copied checked radio would uncheck the live one), no label for a live
  * control, and copied frames and media load nothing. Scrolled descendants
- * keep their offsets once the copy is laid out (`placeOver`).
+ * keep their offsets. The CSS animations and transitions running in it carry
+ * on from where they were, once the copy is laid out (`placeOver`).
  */
 export function inertCopy(element) {
   const copy = element.cloneNode(true);
@@ -133,6 +146,10 @@ export function inertCopy(element) {
   });
   scrollOffsets.set(copy, offsets);
   inheritedValues.set(copy, readInherited(element));
+  carriedMotion.set(copy, {
+    saved: saveAnimations(element),
+    copyOf: new Map(sourceNodes.map((node, index) => [node, copyNodes[index]]))
+  });
   for (const node of copyNodes) {
     for (const name of ['id', 'data-testid', 'name', 'form', 'for', 'autofocus']) {
       node.removeAttribute(name);
@@ -170,7 +187,8 @@ export function paintedBackground(element) {
 /**
  * Lay `element` over `rect` (viewport coordinates), absolutely, as the last
  * child of `host`, wherever its containing block is: no ancestor's position
- * changes.
+ * changes. A copy's scrolled descendants then restore their offsets, and the
+ * CSS animations and transitions its element ran carry on in it.
  */
 export function placeOver(element, host, rect) {
   Object.assign(element.style, {
@@ -221,6 +239,11 @@ export function placeOver(element, host, rect) {
       node.scrollLeft = left;
     }
   }
+  const carried = carriedMotion.get(element);
+  if (carried != null) {
+    carriedMotion.delete(element);
+    carryAnimations(carried.saved, element, node => carried.copyOf.get(node) ?? null);
+  }
 }
 
 /**
@@ -264,6 +287,12 @@ export function visiblePartCopy(element) {
   if (values != null) {
     inheritedValues.set(holder, values);
   }
+  // The content's CSS motion carries on when the holder is laid out.
+  const carried = carriedMotion.get(content);
+  if (carried != null) {
+    carriedMotion.set(holder, carried);
+    carriedMotion.delete(content);
+  }
   const box = element.getBoundingClientRect();
   return {
     copy: holder,

package/dist/motion/uikit/gestures.d.ts

@@ -253,6 +253,29 @@ export declare const UIKIT_PRESS: {
         readonly unit: "ms";
     };
 };
+/**
+ * UIMenu presented by a button whose menu is its primary action: how far the
+ * finger that opened it travels before it picks. DropdownMenu's press model
+ * reads a copy in `hooks/menuPressValues.ts`.
+ */
+export declare const UIKIT_MENU_PRESS: {
+    /**
+     * After the menu opens under a still-held finger, the finger travels this
+     * far before it starts picking. The distance is a straight line from the
+     * first sample the menu receives after it opened. Until then nothing is
+     * lit, and lifting acts on nothing.
+     * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+     *   iPhone 17 Pro, gesture-state hook, steps 150 ms apart, Oct 23 2026
+     *   (M-MN2): with the menu open under a held finger and a 1 pt first step,
+     *   moves of (0, 9) and (7, 7) picked nothing; (0, 10), (0, 11), (10, 0),
+     *   (9, 9) and (10, 10) picked; a 9 pt step followed by 3 pt more picked
+     *   nothing
+     */
+    readonly handoff: {
+        readonly value: 10;
+        readonly unit: "px";
+    };
+};
 export declare const UIKIT_VELOCITY: {
     /**
      * UIPanGestureRecognizer.velocity(in:) is this times the newest event's
@@ -567,6 +590,24 @@ export declare const UIKIT_GESTURES: {
             readonly unit: "ms";
         };
     };
+    readonly menuPress: {
+        /**
+         * After the menu opens under a still-held finger, the finger travels this
+         * far before it starts picking. The distance is a straight line from the
+         * first sample the menu receives after it opened. Until then nothing is
+         * lit, and lifting acts on nothing.
+         * @source measured: UIKit lab (injected host app), iOS 26.2 simulator,
+         *   iPhone 17 Pro, gesture-state hook, steps 150 ms apart, Oct 23 2026
+         *   (M-MN2): with the menu open under a held finger and a 1 pt first step,
+         *   moves of (0, 9) and (7, 7) picked nothing; (0, 10), (0, 11), (10, 0),
+         *   (9, 9) and (10, 10) picked; a 9 pt step followed by 3 pt more picked
+         *   nothing
+         */
+        readonly handoff: {
+            readonly value: 10;
+            readonly unit: "px";
+        };
+    };
     readonly velocity: {
         /**
          * UIPanGestureRecognizer.velocity(in:) is this times the newest event's

package/dist/motion/uikit/gestures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gestures.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/gestures.ts"],"names":[],"mappings":"AAgDA,MAAM,MAAM,mBAAmB,GAC7B,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,MAAM;IACzC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;CACpC;AAED,eAAO,MAAM,SAAS;IACpB;;;;;;;OAOG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;OAMG;;;;;IAEH;;;;;OAKG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;;;;IAEH;;;;;;OAMG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,SAAS;IACpB;;;;;;;;;;OAUG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,WAAW;IACtB;;;;;OAKG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;OAMG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,WAAW;IACtB;;;;;;;OAOG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;;;;CAG+C,CAAC;AAErD,eAAO,MAAM,qBAAqB;IAChC;;;;;;OAMG;;;;;IAEH;;;;OAIG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,aAAa;IACxB;;;;;;;OAOG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,WAAW;IACtB;;;;;OAKG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;OAMG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;OAMG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,cAAc;IACzB;;;;;;;;;;;;OAYG;;;;;IAEH;;;;;;;;OAQG;;;;;IAEH;;;;;;;OAOG;;;;;CAE+C,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,WAAW;IACtB;;;;OAIG;;;;;CAE+C,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;QAzPzB;;;;;;;WAOG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;;WAMG;;;;;QAEH;;;;;WAKG;;;;;;;QAKH;;;;;;WAMG;;;;;QAEH;;;;;;WAMG;;;;;;;QAKH;;;;;;;;;;WAUG;;;;;;;QAKH;;;;;WAKG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;;WAMG;;;;;;;QAKH;;;;;;;WAOG;;;;;;;QAKH;;;;;;WAMG;;;;;;;QAMH;;;;;;WAMG;;;;;QAEH;;;;WAIG;;;;;;;QAKH;;;;;;;WAOG;;;;;;;QAKH;;;;;WAKG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;;WAMG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;;WAMG;;;;;;;QAKH;;;;;;;;;;;;WAYG;;;;;QAEH;;;;;;;;WAQG;;;;;QAEH;;;;;;;WAOG;;;;;;CAoCK,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,sKAUxB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAC5C,kBAAkB,EAClB,eAAe,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAWvC,CAAC"}
+{"version":3,"file":"gestures.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/gestures.ts"],"names":[],"mappings":"AAgDA,MAAM,MAAM,mBAAmB,GAC7B,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,MAAM;IACzC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;CACpC;AAED,eAAO,MAAM,SAAS;IACpB;;;;;;;OAOG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;OAMG;;;;;IAEH;;;;;OAKG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;;;;IAEH;;;;;;OAMG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,SAAS;IACpB;;;;;;;;;;OAUG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,WAAW;IACtB;;;;;OAKG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;OAMG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,WAAW;IACtB;;;;;;;OAOG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;;;;CAG+C,CAAC;AAErD,eAAO,MAAM,qBAAqB;IAChC;;;;;;OAMG;;;;;IAEH;;;;OAIG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,aAAa;IACxB;;;;;;;OAOG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,WAAW;IACtB;;;;;OAKG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;OAMG;;;;;IAEH;;;;;OAKG;;;;;IAEH;;;;;;OAMG;;;;;CAE+C,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;;;;;;OAWG;;;;;CAE+C,CAAC;AAErD,eAAO,MAAM,cAAc;IACzB;;;;;;;;;;;;OAYG;;;;;IAEH;;;;;;;;OAQG;;;;;IAEH;;;;;;;OAOG;;;;;CAE+C,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,WAAW;IACtB;;;;OAIG;;;;;CAE+C,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;QA9QzB;;;;;;;WAOG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;;WAMG;;;;;QAEH;;;;;WAKG;;;;;;;QAKH;;;;;;WAMG;;;;;QAEH;;;;;;WAMG;;;;;;;QAKH;;;;;;;;;;WAUG;;;;;;;QAKH;;;;;WAKG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;;WAMG;;;;;;;QAKH;;;;;;;WAOG;;;;;;;QAKH;;;;;;WAMG;;;;;;;QAMH;;;;;;WAMG;;;;;QAEH;;;;WAIG;;;;;;;QAKH;;;;;;;WAOG;;;;;;;QAKH;;;;;WAKG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;;WAMG;;;;;QAEH;;;;;WAKG;;;;;QAEH;;;;;;WAMG;;;;;;;QAUH;;;;;;;;;;;WAWG;;;;;;;QAKH;;;;;;;;;;;;WAYG;;;;;QAEH;;;;;;;;WAQG;;;;;QAEH;;;;;;;WAOG;;;;;;CAqCK,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,sKAUxB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAC5C,kBAAkB,EAClB,eAAe,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAWvC,CAAC"}