@unrulysystems/native-motion-core 0.1.0-alpha.0

package/dist/component/resolve.js

@@ -0,0 +1,97 @@
+// SPEC-COMPONENT §2 — the pure target-merge + base-resolution functions (REQ-API-002/010/011/012/017).
+// Two responsibilities, two pure functions on the verifier seam:
+//   • resolveTarget(base, target) — REQ-API-012 overlay: apply a partial target onto the live value set.
+//     Keys in the target retarget; keys absent from the target retain their live value; a target NEVER
+//     resets an unlisted property. There is no "full visual state" the author must restate.
+//   • resolveStartValue / hostBaseValue — REQ-API-011 base resolution: the STARTING value of a property
+//     appearing in a target with no prior live value — the resolved `style` value if present, else the
+//     documented host base. Identical across engines (the base derives from the registry value type, not
+//     from any host), so no engine supplies a divergent implicit default.
+// Both are pure and deterministic: same inputs → same result, independent of clock or host (REQ-API-017).
+// Host-agnostic (REQ-CORE-003) — reads only the SUBSET registry (relative import).
+import { UNIVERSAL_SUBSET } from "../subset/index.js";
+import { captureBoundedArray, capturedArrayDescription } from "./boundedArray.js";
+import { InvalidTargetError } from "./validate.js";
+// Overlay `target` onto the live `base` value set (REQ-API-012). Returns a fresh, complete value set: every
+// key present in either input appears once; a key in `target` takes the target value (retarget), a key only
+// in `base` retains its live value (hold). Never mutates its inputs; never resets a property the target did
+// not mention. A target value may be a keyframe array (ResolvedTargetValue), so the merge is typed to carry it.
+export function resolveTarget(base, target) {
+    // Hold every unlisted base key, then overlay the target. A keyframe ARRAY value is CLONED (and frozen)
+    // as it is captured — a resolved snapshot (a presence exit target, a retarget origin) is resolved-once
+    // and held-immutable, so it must not alias a caller-owned array whose later mutation would change it in
+    // place (REQ-API-017; review major c8d4e61a705b). Keyframe elements are scalars, so a shallow clone is a
+    // full copy. A fresh object each call — the inputs stay immutable.
+    const merged = {};
+    for (const key of Object.keys(base))
+        merged[key] = captureValue(key, base[key]);
+    for (const key of Object.keys(target))
+        merged[key] = captureValue(key, target[key]);
+    return merged;
+}
+// Capture a resolved value independently of its caller: a keyframe array is cloned + frozen (so a later
+// source mutation cannot reach the snapshot, and the snapshot itself cannot be mutated downstream); a
+// scalar is already immutable and passes through.
+function captureValue(key, value) {
+    if (!Array.isArray(value))
+        return value;
+    const capture = captureBoundedArray(value);
+    if (capture.kind !== 'captured') {
+        throw new InvalidTargetError(undefined, key, capturedArrayDescription(capture), 'keyframe arrays must have a safe bounded length (REQ-API-033)');
+    }
+    if (capture.values.length < 2) {
+        throw new InvalidTargetError(undefined, key, capture.values, 'a keyframe array must have at least two keyframes (REQ-API-033)');
+    }
+    for (let index = 0; index < capture.values.length; index++) {
+        if (!Object.hasOwn(capture.values, index)) {
+            throw new InvalidTargetError(undefined, key, capture.values, `keyframe array is missing index ${index} (REQ-API-033)`);
+        }
+    }
+    return capture.values;
+}
+// REQ-API-011: the STARTING (from) value of a property that appears in a target with no prior live value.
+// The resolved `style` value if the style prop specifies it, else the documented host base. Pure.
+export function resolveStartValue(key, resolution) {
+    const styled = resolution?.style?.[key];
+    return styled !== undefined ? styled : hostBaseValue(key);
+}
+// T23 B2a2: the discrete-start refusal is TYPED so the component boundary can apply the
+// severity law to exactly this case (production report + refuse the key) without message
+// sniffing; unknown/complex host-base refusals stay plain loud errors on every severity.
+export class DiscreteHostBaseError extends Error {
+    constructor(key) {
+        super(`no documented host base value for discrete '${key}': the host default diverges across ` +
+            'engines — provide the starting keyword via initial/style/variants.');
+        this.name = 'DiscreteHostBaseError';
+    }
+}
+// The documented host base value for a universal property (REQ-API-011) — the value it animates FROM when
+// neither a live value nor a `style` value exists. Derived from the registry value type so it is a SINGLE
+// source of truth and identical across engines (no host parameter, no engine-divergent default): scale and
+// opacity rest at 1; translations, dimensions, spacing, radii, border widths, and angles rest at 0; colors
+// rest at fully-transparent black. complex/gesture capabilities have no scalar base and fail loud, as does
+// an unknown property.
+export function hostBaseValue(key) {
+    const entry = UNIVERSAL_SUBSET.get(key);
+    if (entry === undefined) {
+        throw new Error(`no documented host base value for unknown property '${key}': it is not a universal-subset property.`);
+    }
+    switch (entry.valueType) {
+        case 'unitless':
+            // opacity and scale/scaleX/scaleY are the only unitless universal properties; all rest at 1.
+            return 1;
+        case 'length':
+        case 'angle':
+            return 0;
+        case 'rgba':
+            return 'rgba(0, 0, 0, 0)';
+        case 'discrete':
+            // T23 B: the host default for a discrete keyword DIVERGES across engines (web block vs RN
+            // flex for display) — there is no engine-identical documented base, so the start value must
+            // come from `initial`/`style`/a variant, never a silent host default.
+            throw new DiscreteHostBaseError(key);
+        case 'complex':
+        case 'gesture':
+            throw new Error(`no documented host base value for '${key}' (valueType '${entry.valueType}'): it is not an animatable scalar/color property.`);
+    }
+}

package/dist/component/transition.cjs

@@ -0,0 +1,352 @@
+"use strict";
+// SPEC-COMPONENT §2 — the transition unit boundary (REQ-API-001). The public `Transition` (in ./types)
+// speaks Motion's SECONDS convention; the internal SPRING (`SpringConfig`) and TIMING (`TimingConfig`)
+// resolvers consume MILLISECONDS. These pure converters are the SINGLE crossing point, so the internal
+// millisecond unit never leaks into the authored public surface and a Motion-idiomatic transition config
+// resolves identically here. Host-agnostic (REQ-CORE-003) — relative imports only.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTransitionForKey = resolveTransitionForKey;
+exports.toSpringConfig = toSpringConfig;
+exports.effectiveTransitionEase = effectiveTransitionEase;
+exports.normalizeTransitionEaseAlias = normalizeTransitionEaseAlias;
+exports.toRepeatFoldOptions = toRepeatFoldOptions;
+exports.toDelayMs = toDelayMs;
+exports.toTimingConfig = toTimingConfig;
+exports.isTimingLaneTransition = isTimingLaneTransition;
+exports.isDurationZeroInstantTransition = isDurationZeroInstantTransition;
+exports.toTimingLaneConfig = toTimingLaneConfig;
+exports.toKeyframesConfig = toKeyframesConfig;
+const timing_1 = require("../timing.cjs");
+const types_1 = require("./types.cjs");
+// Motion authors durations in seconds; the SPRING/TIMING generators are seeded in milliseconds. This is the
+// only conversion factor, named rather than inlined so the seconds↔ms boundary is explicit.
+const MS_PER_SECOND = 1000;
+const TRANSITION_MAP_KEYS = new Set(['default', 'layout', ...types_1.TARGET_PROPERTY_KEYS]);
+function isTransitionMapKey(key) {
+    return TRANSITION_MAP_KEYS.has(key);
+}
+function flatTransitionSnapshot(source) {
+    const out = Object.create(null);
+    for (const key of Reflect.ownKeys(source)) {
+        if (typeof key !== 'string' || key === 'inherit' || isTransitionMapKey(key))
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor === undefined)
+            continue;
+        Object.defineProperty(out, key, {
+            value: source[key],
+            enumerable: descriptor.enumerable === true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return Object.freeze(out);
+}
+/**
+ * Resolve one Motion consumer against an authored transition map. The result is a detached flat
+ * bag: map entries never cross into a generator, and nested maps never recurse. Validation/capture
+ * owns malformed-shape refusal; this selector assumes that boundary has passed and preserves the
+ * pin's key → default → root precedence.
+ */
+function resolveTransitionForKey(transition, key) {
+    const source = transition;
+    const named = isTransitionMapKey(key) ? source[key] : undefined;
+    const fallback = source['default'];
+    const selected = named !== undefined && named !== null
+        ? named
+        : fallback !== undefined && fallback !== null
+            ? fallback
+            : transition;
+    if (selected === transition)
+        return flatTransitionSnapshot(source);
+    const root = flatTransitionSnapshot(source);
+    const nested = selected;
+    if (nested['inherit'] !== true) {
+        // Motion's getValueTransition returns a replacing child bag unchanged. The separate delay
+        // rebase in animateTarget supplies only its orchestration delay before spreading this bag, so
+        // an ordinary selected bag does not inherit the root transition's delay (motion-dom@12.42.2).
+        return flatTransitionSnapshot(nested);
+    }
+    const merged = Object.create(null);
+    for (const key of Reflect.ownKeys(root)) {
+        const descriptor = Object.getOwnPropertyDescriptor(root, key);
+        if (descriptor !== undefined)
+            Object.defineProperty(merged, key, { ...descriptor, configurable: true, writable: true });
+    }
+    const child = flatTransitionSnapshot(nested);
+    for (const key of Reflect.ownKeys(child)) {
+        const descriptor = Object.getOwnPropertyDescriptor(child, key);
+        if (descriptor !== undefined)
+            Object.defineProperty(merged, key, { ...descriptor, configurable: true, writable: true });
+    }
+    return Object.freeze(merged);
+}
+// Bridge the public `Transition` to the internal spring `SpringConfig`. `duration` crosses seconds→ms;
+// `visualDuration` is already seconds in both surfaces (passthrough); the physics options are unit-
+// consistent with Motion. Absent fields are omitted entirely (not written as `undefined`) so the result
+// satisfies `exactOptionalPropertyTypes`.
+function toSpringConfig(transition) {
+    const config = {};
+    if (transition.stiffness !== undefined)
+        config.stiffness = transition.stiffness;
+    if (transition.damping !== undefined)
+        config.damping = transition.damping;
+    if (transition.mass !== undefined)
+        config.mass = transition.mass;
+    if (transition.bounce !== undefined)
+        config.bounce = transition.bounce;
+    if (transition.velocity !== undefined)
+        config.velocity = transition.velocity;
+    // U7c (REQ-SPRING-014): the authored settle thresholds cross verbatim — unit-free passthroughs
+    // (the velocity precedent). An explicit 0 is forwarded as PRESENT; the `||=` quirk (0 ≡ absent,
+    // motion-dom@12.42.2 spring.ts:275-280) resolves in the solver's `||` read, never here.
+    if (transition.restDelta !== undefined)
+        config.restDelta = transition.restDelta;
+    if (transition.restSpeed !== undefined)
+        config.restSpeed = transition.restSpeed;
+    if (transition.visualDuration !== undefined)
+        config.visualDuration = transition.visualDuration;
+    if (transition.duration !== undefined)
+        config.duration = transition.duration * MS_PER_SECOND;
+    return config;
+}
+// Bridge the public `Transition` to the internal `TimingConfig` (tween path). `duration` crosses
+// seconds→ms; `ease` passes through. Absent fields omitted (exactOptionalPropertyTypes).
+// Family-2 / T20: `easings` and `easing` are Motion catalog aliases of `ease`.
+// Dual authorship is refused at validate.
+function effectiveTransitionEase(transition) {
+    if (transition.ease !== undefined)
+        return transition.ease;
+    if (transition.easings !== undefined)
+        return transition.easings;
+    return transition.easing;
+}
+// Rewrite `easings` → `ease` for host pass-through (web motion.div speaks `ease`). Identity when
+// only `ease` is authored. Dual authorship never reaches here (validate refuses first).
+// Preserve null-prototype + freeze + own descriptors from captureTransition (G-INV-8): object
+// spread would re-open prototype pollution and drop non-enumerable own keys.
+// Explicit `ease: undefined` / `easings: undefined` are ABSENT (same law, 00i0nt) — strip those
+// own keys so nested config merge cannot treat them as present values that clobber a parent.
+const EASE_ALIAS_KEYS = ['easings', 'easing'];
+function normalizeFlatTransitionEaseAlias(transition) {
+    const source = transition;
+    const hasOwnEase = Object.hasOwn(transition, 'ease');
+    const easeIsExplicitUndefined = hasOwnEase && source['ease'] === undefined;
+    let aliasKey;
+    let aliasValue;
+    let aliasExplicitUndefined = false;
+    for (const key of EASE_ALIAS_KEYS) {
+        if (!Object.hasOwn(transition, key))
+            continue;
+        const value = source[key];
+        if (value === undefined) {
+            aliasExplicitUndefined = true;
+            continue;
+        }
+        if (aliasKey === undefined) {
+            aliasKey = key;
+            aliasValue = value;
+        }
+    }
+    if (aliasKey === undefined) {
+        if (!easeIsExplicitUndefined && !aliasExplicitUndefined)
+            return transition;
+        const stripped = Object.create(null);
+        let changed = false;
+        for (const key of Reflect.ownKeys(transition)) {
+            if (key === 'ease' && source[key] === undefined) {
+                changed = true;
+                continue;
+            }
+            if ((key === 'easings' || key === 'easing') && source[key] === undefined) {
+                changed = true;
+                continue;
+            }
+            const descriptor = Object.getOwnPropertyDescriptor(transition, key);
+            if (descriptor === undefined)
+                continue;
+            Object.defineProperty(stripped, key, {
+                value: descriptor.value,
+                enumerable: descriptor.enumerable === true,
+                configurable: true,
+                writable: true,
+            });
+        }
+        return changed ? Object.freeze(stripped) : transition;
+    }
+    const captured = Object.create(null);
+    for (const key of Reflect.ownKeys(transition)) {
+        if (key === 'easings' || key === 'easing')
+            continue;
+        if (key === 'ease' && source[key] === undefined)
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(transition, key);
+        if (descriptor === undefined)
+            continue;
+        Object.defineProperty(captured, key, {
+            value: descriptor.value,
+            enumerable: descriptor.enumerable === true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    Object.defineProperty(captured, 'ease', {
+        value: aliasValue,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+    return Object.freeze(captured);
+}
+const TRANSITION_MAP_KEYS_FOR_ALIAS = new Set([
+    'default',
+    'layout',
+    ...types_1.TARGET_PROPERTY_KEYS,
+]);
+/**
+ * Canonicalize the public `easings` alias at both legal transition levels. The pin-facing web/native
+ * consumers never receive nested bags directly, but MotionConfig and variant inheritance can carry a
+ * captured map through several handoff boundaries before the consumer selector runs. Normalize exactly
+ * one nested bag level; recursive maps are a validation error, not an invitation to walk unbounded data.
+ */
+function normalizeTransitionEaseAlias(transition) {
+    const root = normalizeFlatTransitionEaseAlias(transition);
+    const source = transition;
+    let changed = root !== transition;
+    const replacements = new Map();
+    for (const key of Reflect.ownKeys(transition)) {
+        if (typeof key !== 'string' || !TRANSITION_MAP_KEYS_FOR_ALIAS.has(key))
+            continue;
+        const nested = source[key];
+        if (typeof nested !== 'object' ||
+            nested === null ||
+            Array.isArray(nested) ||
+            (Object.getPrototypeOf(nested) !== Object.prototype && Object.getPrototypeOf(nested) !== null))
+            continue;
+        const normalized = normalizeFlatTransitionEaseAlias(nested);
+        if (normalized !== nested) {
+            changed = true;
+            replacements.set(key, normalized);
+        }
+    }
+    if (!changed)
+        return root;
+    const out = Object.create(null);
+    for (const key of Reflect.ownKeys(root)) {
+        const descriptor = Object.getOwnPropertyDescriptor(root, key);
+        if (descriptor === undefined)
+            continue;
+        Object.defineProperty(out, key, {
+            value: replacements.get(key) ?? descriptor.value,
+            enumerable: descriptor.enumerable === true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return Object.freeze(out);
+}
+function toRepeatFoldOptions(transition) {
+    const repeat = transition.repeat;
+    if (repeat === undefined || repeat <= 0)
+        return null;
+    return {
+        repeat,
+        repeatType: transition.repeatType ?? 'loop',
+        repeatDelayMs: (transition.repeatDelay ?? 0) * MS_PER_SECOND,
+    };
+}
+// T18-b (REQ-TIMING-004 / REQ-API-050): the public `delay` crosses seconds→ms HERE, at the same
+// boundary as every other public time (duration in toTimingConfig/toKeyframesConfig, repeatDelay
+// above) — the rebase consumes milliseconds. Absent reads as 0, the pin's default.
+function toDelayMs(transition) {
+    return (transition.delay ?? 0) * MS_PER_SECOND;
+}
+function toTimingConfig(transition) {
+    const config = {};
+    if (transition.duration !== undefined)
+        config.duration = transition.duration * MS_PER_SECOND;
+    // The scalar TWEEN path takes a SINGLE easing only. A per-segment `ease` LIST (R8 M2-B) is a
+    // keyframe-array param carried exclusively by `toKeyframesConfig`; passing a list here would break
+    // `resolveEasing` (it expects one easing). A list on a scalar target is a cross-field error caught
+    // by `keyframeTimingRefusal`, so dropping it here is safe and keeps the tween path total.
+    const ease = effectiveTransitionEase(transition);
+    if (ease !== undefined && !(0, timing_1.isEasingList)(ease))
+        config.ease = ease;
+    return config;
+}
+// transition-default-selection F6: the pin's timing LANE predicate, and the ONE rule both drivers
+// and validation read. `isTransitionDefined` counts an authored duration AND the ease spellings
+// (only the orchestration keys are exempt, is-transition-defined.ts:4-29), and a DEFINED-but-
+// typeless bag resolves through the keyframes/timing generator at the 300ms default
+// (motion-dom@12.42.2 JSAnimation.ts:106-116 `type = keyframesGenerator`,
+// generators/keyframes.ts:25 `duration = 300`) — never the spring backstop. The lane is therefore:
+// type omitted AND (an authored duration OR an authored ease spelling — `ease`/`easings`/`easing`,
+// the 00i0nt alias law). Inertia narrows off by its literal `type`.
+//
+// The duration arm is REQ-TIMING-006's: the pin's `isTransitionDefined({ duration })` is TRUE, so
+// `animateMotionValue` SKIPS the per-key `getDefaultTransition` (the spring, REQ-SPRING-012) and
+// `JSAnimation.initAnimation` falls through `type = keyframesGenerator` (motion-value.ts:68-71,
+// JSAnimation.ts:104,115-116) — an authored scalar transition with `duration` and no `type` runs
+// the keyframes/timing generator, monotone, NEVER a duration-spring. This predicate SUBSUMES that
+// arm; the narrower `isDurationOnlyTransition` it superseded at every call site was removed rather
+// than left as dead exported surface, so do not reintroduce a duration-only predicate here.
+//
+// The ease-only arm is the F6 addition and is why an absent `duration` does NOT imply the spring
+// backstop: `{ ease: 'linear' }` matches. It keeps its authored ease verbatim —
+// `toTimingLaneConfig` injects easeOut ONLY when no spelling is authored, so no injection fires
+// here. An orchestration-only bag matches NEITHER arm and keeps the spring backstop: unreachable
+// on the component path (the controller's flat arm already merged the per-key default under it,
+// REQ-SPRING-012) but held as the defensive default.
+function isTimingLaneTransition(transition) {
+    if (transition.type !== undefined)
+        return false;
+    if (transition.duration !== undefined)
+        return true;
+    return effectiveTransitionEase(transition) !== undefined;
+}
+// transition-default-selection F5: the duration-zero half of the pin's `makeAnimationInstant`
+// guard (motion-dom@12.42.2 animation/interfaces/motion-value.ts:89-98 —
+// `(options as any).type === false || (options.duration === 0 && !options.repeatDelay)`; the
+// `type === false` half is the U7a lane, which the drivers check beside this one). The routing is
+// TYPE-INDEPENDENT — a typed spring with `duration: 0` instants too — and honors the pin's
+// truthiness: an authored `repeatDelay: 0` reads as absent. A repeatDelay-bearing bag is EXEMPT:
+// it keeps its normal generator (the pin builds a real animation whose zero-length plays are
+// separated by the repeatDelay gaps).
+function isDurationZeroInstantTransition(transition) {
+    if (transition.type === 'inertia')
+        return false;
+    return transition.duration === 0 && !transition.repeatDelay;
+}
+// REQ-TIMING-006 + transition-default-selection F1: the timing LANE's config — the ONE builder
+// every timing-lane consumer reads (both drivers' scalar arms, the presence exit lane). The pin's
+// `animateMotionValue` options base is `{ keyframes: [null, target], ease: "easeOut", ...valueTransition }`
+// (motion-dom@12.42.2 motion-value.ts:45-49), so only an AUTHORED ease spelling overrides:
+// whenever the timing lane is selected — a typed tween OR a duration-only untyped bag — and no
+// ease spelling is authored, the ease is [0, 0, 0.58, 1], never the generator default
+// [0.25, 0.1, 0.35, 1] (REQ-TIMING-002, whose default now governs only the pin's per-key default
+// tween, default-transitions.ts:35-48). Any authored spelling (`ease`/`easings`/`easing`, the
+// 00i0nt alias law) suppresses the injection. Mirrors the sealed layout-lane law (REQ-LAYOUT-023
+// a, 7htzcf).
+function toTimingLaneConfig(transition) {
+    const config = toTimingConfig(transition);
+    if (effectiveTransitionEase(transition) === undefined)
+        config.ease = 'easeOut';
+    return config;
+}
+// Bridge the public `Transition` to the internal `KeyframesConfig` (the multi-keyframe timing path,
+// REQ-API-033). `duration` crosses seconds→ms; `ease` passes through — a single easing (applied to
+// every segment) OR a per-SEGMENT list (R8 M2-B, law d); `times` (custom 0–1 offsets) passes through
+// as-is (offsets are unitless, no seconds→ms crossing). Absent fields omitted
+// (exactOptionalPropertyTypes). Shape validation happens before this bridge; target-count fallback is
+// owned by the shared core/UI keyframe normalization seam.
+function toKeyframesConfig(transition) {
+    const config = {};
+    if (transition.duration !== undefined)
+        config.duration = transition.duration * MS_PER_SECOND;
+    const ease = effectiveTransitionEase(transition);
+    if (ease !== undefined)
+        config.ease = ease;
+    if (transition.times !== undefined)
+        config.times = transition.times;
+    return config;
+}

package/dist/component/transition.d.cts

@@ -0,0 +1,33 @@
+import type { KeyframesConfig } from "../keyframes.cjs";
+import type { RepeatType } from "../repeat.cjs";
+import { type TimingConfig } from "../timing.cjs";
+import type { InertiaTransition, SpringConfig } from "../transition.cjs";
+import { type Transition } from "./types.cjs";
+/**
+ * Resolve one Motion consumer against an authored transition map. The result is a detached flat
+ * bag: map entries never cross into a generator, and nested maps never recurse. Validation/capture
+ * owns malformed-shape refusal; this selector assumes that boundary has passed and preserves the
+ * pin's key → default → root precedence.
+ */
+export declare function resolveTransitionForKey(transition: Transition, key: string): Transition;
+export declare function toSpringConfig(transition: Transition): SpringConfig;
+export declare function effectiveTransitionEase(transition: Transition): Transition['ease'] | Transition['easings'] | Transition['easing'];
+/**
+ * Canonicalize the public `easings` alias at both legal transition levels. The pin-facing web/native
+ * consumers never receive nested bags directly, but MotionConfig and variant inheritance can carry a
+ * captured map through several handoff boundaries before the consumer selector runs. Normalize exactly
+ * one nested bag level; recursive maps are a validation error, not an invitation to walk unbounded data.
+ */
+export declare function normalizeTransitionEaseAlias(transition: Transition): Transition;
+export interface RepeatFoldOptions {
+    readonly repeat: number;
+    readonly repeatType: RepeatType;
+    readonly repeatDelayMs: number;
+}
+export declare function toRepeatFoldOptions(transition: Transition): RepeatFoldOptions | null;
+export declare function toDelayMs(transition: Transition): number;
+export declare function toTimingConfig(transition: Transition): TimingConfig;
+export declare function isTimingLaneTransition(transition: Transition | InertiaTransition): boolean;
+export declare function isDurationZeroInstantTransition(transition: Transition | InertiaTransition): boolean;
+export declare function toTimingLaneConfig(transition: Transition): TimingConfig;
+export declare function toKeyframesConfig(transition: Transition): KeyframesConfig;

package/dist/component/transition.d.ts

@@ -0,0 +1,33 @@
+import type { KeyframesConfig } from "../keyframes.js";
+import type { RepeatType } from "../repeat.js";
+import { type TimingConfig } from "../timing.js";
+import type { InertiaTransition, SpringConfig } from "../transition.js";
+import { type Transition } from "./types.js";
+/**
+ * Resolve one Motion consumer against an authored transition map. The result is a detached flat
+ * bag: map entries never cross into a generator, and nested maps never recurse. Validation/capture
+ * owns malformed-shape refusal; this selector assumes that boundary has passed and preserves the
+ * pin's key → default → root precedence.
+ */
+export declare function resolveTransitionForKey(transition: Transition, key: string): Transition;
+export declare function toSpringConfig(transition: Transition): SpringConfig;
+export declare function effectiveTransitionEase(transition: Transition): Transition['ease'] | Transition['easings'] | Transition['easing'];
+/**
+ * Canonicalize the public `easings` alias at both legal transition levels. The pin-facing web/native
+ * consumers never receive nested bags directly, but MotionConfig and variant inheritance can carry a
+ * captured map through several handoff boundaries before the consumer selector runs. Normalize exactly
+ * one nested bag level; recursive maps are a validation error, not an invitation to walk unbounded data.
+ */
+export declare function normalizeTransitionEaseAlias(transition: Transition): Transition;
+export interface RepeatFoldOptions {
+    readonly repeat: number;
+    readonly repeatType: RepeatType;
+    readonly repeatDelayMs: number;
+}
+export declare function toRepeatFoldOptions(transition: Transition): RepeatFoldOptions | null;
+export declare function toDelayMs(transition: Transition): number;
+export declare function toTimingConfig(transition: Transition): TimingConfig;
+export declare function isTimingLaneTransition(transition: Transition | InertiaTransition): boolean;
+export declare function isDurationZeroInstantTransition(transition: Transition | InertiaTransition): boolean;
+export declare function toTimingLaneConfig(transition: Transition): TimingConfig;
+export declare function toKeyframesConfig(transition: Transition): KeyframesConfig;