@cardstack/choreo 0.0.0 → 0.1.0-unstable.1

package/dist/steps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.js","sources":["../src/steps.gts"],"sourcesContent":["/**\n * The timeline, declared in the template. Each step renders a hidden marker\n * so the region can read the tree back in document order — nesting in the\n * markup IS the sequence/parallel nesting. Nothing here animates; the region\n * compiles these into cues when a render pass produces a changeset.\n */\nimport Component from '@glimmer/component';\nimport { modifier } from 'ember-modifier';\n\nimport { type AnchorRef, at } from './anchors.ts';\nimport type { BeaconRef } from './beacons.ts';\nimport type { GestureRef } from './gesture.ts';\nimport type {\n  Block,\n  Camera3DWaypoint,\n  DeliveryBy,\n  DeliveryOrder,\n  DeriveContext,\n  Easing,\n  PropSource,\n  PropValue,\n  Query,\n  Rect,\n  SpringSpec,\n  TimelineNode,\n} from './types.ts';\n\ninterface Provider {\n  node(): TimelineNode;\n}\n\nconst providers = new WeakMap<Element, Provider>();\n\n/** unnamed crossings still need a stable, unique inner anchor name */\nlet crossings = 0;\n\n/** the steps directly inside an element, in document order; a nested <Choreo> is another region's */\nexport function collect(el: Element): TimelineNode[] {\n  const out: TimelineNode[] = [];\n  for (const child of Array.from(el.children)) {\n    if (child.hasAttribute('data-choreo')) {\n      continue;\n    }\n    const provider = providers.get(child);\n    if (provider) {\n      out.push(provider.node());\n    } else {\n      out.push(...collect(child));\n    }\n  }\n  return out;\n}\n\n/**\n * args that are the step's own; every other named arg is a property to animate.\n * `rotate` is NOT here although Move has a `@rotate` arg: on a Tween or\n * Spring it is a property (Keynote's Spin), and Move never reads its props.\n */\nconst RESERVED = new Set([\n  'align',\n  'at',\n  'by',\n  'delay',\n  'duration',\n  'ease',\n  'fill',\n  'from',\n  'name',\n  'of',\n  'order',\n  'path',\n  'read',\n  'repeat',\n  'repeatType',\n  'rest',\n  'shadow',\n  'size',\n  'space',\n  'spring',\n  'stagger',\n  'swap',\n  'to',\n  'times',\n]);\n\n/** the pre-seconds spellings, kept only to fail loudly with the new name */\nconst RENAMED: Record<string, string> = {\n  crossfade: '@swap',\n  ms: '@duration (in seconds)',\n  overlap: '@stagger (in seconds)',\n};\n\nfunction propsOf(args: Record<string, unknown>): Record<string, PropSource> {\n  const props: Record<string, PropSource> = {};\n  for (const key of Object.keys(args)) {\n    if (args[key] === undefined) {\n      continue;\n    }\n    if (RENAMED[key]) {\n      throw new Error(`choreo: @${key} was renamed — use ${RENAMED[key]}`);\n    }\n    if (!RESERVED.has(key)) {\n      props[key] = args[key] as PropSource;\n    }\n  }\n  return props;\n}\n\n/**\n * The template speaks seconds, as Motion does; the compiler's clock is ms.\n * A composite step writes node literals, which are BELOW that boundary —\n * so it converts its own seconds args here, and `undefined` stays\n * `undefined` so an unset arg still means \"take the default\".\n */\nexport function toMs<T extends number | undefined>(\n  seconds: T,\n): T extends number ? number : number | undefined {\n  // the conditional return type is the whole point — a required `ms` field\n  // takes toMs(x) without a null check when x is a number — and TypeScript\n  // cannot verify a conditional return from inside, so the cast is the\n  // price of stating it\n  return (\n    seconds === undefined ? undefined : seconds * 1000\n  ) as T extends number ? number : number | undefined;\n}\n\nconst msOf = toMs;\n\n/** the args every step shares — a composite step extends this */\nexport interface StepArgsBase {\n  [prop: string]: unknown;\n  /** `{{at 'name' 0.4}}` / `{{after 'name' 0.2}}` — start against a named step */\n  at?: AnchorRef;\n  /** seconds before the step starts, inside its slot */\n  delay?: number;\n  /** a label other steps may anchor against */\n  name?: string;\n  /** seconds between one matched sprite and the next, in document order */\n  stagger?: number;\n}\n\n/** …and the args of a step that names sprites */\nexport interface StepArgs extends StepArgsBase {\n  of: Query | Query[];\n}\n\n/**\n * The base every step is built on, and the public seam for a COMPOSITE\n * step — a new word in the timeline that expands into the built-in\n * vocabulary. `c.Crossing` is one, and is written in nothing but this.\n *\n * Subclass it, implement `node()`, and render the component anywhere\n * inside a `<Choreo>`: the region reads the tree back in document order\n * and your node takes its place in it.\n *\n * ```gts\n * export class Reveal extends StepComponent<StepArgs & { rise?: number }> {\n *   node(): TimelineNode {\n *     const { of, name, rise = 12 } = this.args;\n *     return {\n *       at: this.args.at,\n *       children: [\n *         { kind: 'tween', generic: true, of, ms: 240, props: { opacity: [0, 1] } },\n *         { kind: 'tween', generic: true, of, ms: 240, props: { y: [rise, 0] } },\n *       ],\n *       kind: 'parallel',\n *       name,\n *     };\n *   }\n * }\n * ```\n *\n * **`node()` is called on every pass**, and its result is fingerprinted to\n * decide whether an edited timeline replays the run. So it must be pure\n * and cheap: no measurement, no DOM writes, no tracked writes (a tracked\n * write re-renders, which replays the pass, which calls `node()`). And\n * because functions in the tree are compared by identity, a `node()` that\n * allocates a fresh closure per call declares an edit on every pass —\n * hoist property functions to module scope.\n *\n * Two conventions worth keeping: mark children `generic: true` so a\n * sibling step can claim a sprite away from your defaults (the yield\n * rule, §4.7), and derive any inner `name` from your own `@name` so two\n * of your step in one timeline do not collide.\n */\nexport abstract class StepComponent<A extends StepArgsBase> extends Component<{\n  Args: A;\n}> {\n  abstract node(): TimelineNode;\n  mark = modifier((el: Element) => {\n    providers.set(el, this);\n    return () => providers.delete(el);\n  });\n  <template>\n    <span hidden data-choreo-step {{this.mark}}></span>\n  </template>\n}\n\nexport class Tween extends StepComponent<\n  StepArgs & {\n    /** split a text sprite's delivery: by word, character, or paragraph */\n    by?: DeliveryBy;\n    /** seconds, as Motion counts them */\n    duration: number;\n    ease?: Easing;\n    order?: DeliveryOrder;\n    /** extra plays after the first; `Infinity` is an ambient loop whose phase rides the run clock */\n    repeat?: number;\n    repeatType?: 'loop' | 'mirror' | 'reverse';\n    /** Normalized keyframe offsets, one per value in every keyframe track. */\n    times?: number[];\n  }\n> {\n  node(): TimelineNode {\n    const { of, by, duration, ease, delay, order, repeat, repeatType, times } =\n      this.args;\n    return {\n      at: this.args.at,\n      by,\n      delay: msOf(delay),\n      ease,\n      kind: 'tween',\n      name: this.args.name,\n      ms: duration * 1000,\n      of,\n      order,\n      props: propsOf(this.args),\n      repeat,\n      repeatType,\n      times,\n      stagger: msOf(this.args.stagger),\n    };\n  }\n}\n\nexport class Spring extends StepComponent<\n  StepArgs & {\n    by?: DeliveryBy;\n    order?: DeliveryOrder;\n    spring?: SpringSpec;\n  }\n> {\n  node(): TimelineNode {\n    const { of, by, spring, delay, order } = this.args;\n    return {\n      at: this.args.at,\n      by,\n      delay: msOf(delay),\n      kind: 'spring',\n      name: this.args.name,\n      of,\n      order,\n      props: propsOf(this.args),\n      spring,\n      stagger: msOf(this.args.stagger),\n    };\n  }\n}\n\nexport class Move extends StepComponent<\n  StepArgs & {\n    /** seconds; with @ease, the tween form of the flight */\n    duration?: number;\n    ease?: string | readonly number[];\n    /** `{{c.beacon 'compose'}}` or `{{c.gesture}}` — fly in from that box */\n    from?: BeaconRef | GestureRef;\n    /** an SVG path for the journey, drawn from where the sprite stands */\n    path?: string;\n    /** 'auto' orients along the tangent; a number adds a constant offset */\n    rotate?: 'auto' | number;\n    size?: boolean | 'crop' | 'scale';\n    /** measure the delta in 'page' (default) or the sprite's 'parent' space */\n    space?: 'page' | 'parent';\n    spring?: SpringSpec;\n    /** counterpart skins: 'during' (default), 'settle', or 'none' */\n    swap?: 'during' | 'none' | 'settle';\n    /** `{{c.beacon 'trash'}}` — fly out to that box rather than to where the sprite landed */\n    to?: BeaconRef;\n  }\n> {\n  node(): TimelineNode {\n    const {\n      of,\n      duration,\n      ease,\n      delay,\n      path,\n      rotate,\n      space,\n      spring,\n      size,\n      swap,\n      from,\n      to,\n      stagger,\n    } = this.args;\n    propsOf(this.args); // no properties — evaluated for the renamed-arg errors\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      ease,\n      from,\n      kind: 'move',\n      name: this.args.name,\n      ms: msOf(duration),\n      of,\n      path,\n      rotate,\n      size,\n      space,\n      spring,\n      stagger: msOf(stagger),\n      swap,\n      to,\n    };\n  }\n}\n\nexport class Hold extends StepComponent<\n  StepArgs & { duration?: number; fill?: boolean }\n> {\n  node(): TimelineNode {\n    const { of, duration, delay, fill, stagger } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      fill,\n      kind: 'hold',\n      name: this.args.name,\n      ms: msOf(duration),\n      of,\n      props: propsOf(this.args),\n      stagger: msOf(stagger),\n    };\n  }\n}\n\n/**\n * `<c.Wait />` — a hole in a sequence. It has no subject: `@of` is accepted\n * (a wait can be laddered across sprites with `@stagger`) but never needed.\n */\nexport class Wait extends StepComponent<\n  StepArgsBase & { duration: number; of?: Query | Query[] }\n> {\n  node(): TimelineNode {\n    const { of, duration, delay, stagger } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      kind: 'wait',\n      name: this.args.name,\n      ms: duration * 1000,\n      of,\n      stagger: msOf(stagger),\n    };\n  }\n}\n\n/**\n * `<c.Perform />` — a semantic command on the timeline (§C4). It occupies\n * an instant, positioned like any step (sequence order, `@at`, `@delay`),\n * and carries `@action` (required), `@target` and `@payload` to the\n * region's dispatcher (`<Choreo @onPerform>`). The fold's law: forward\n * playback dispatches it once as the clock crosses it; a seek past it\n * includes it; a seek before it resets the host and replays the remaining\n * prefix. Commands are idempotent statements of state — `lightbox.open`,\n * never `lightbox.toggle`.\n */\nexport class Perform extends StepComponent<\n  StepArgsBase & { action: string; payload?: unknown; target?: string }\n> {\n  node(): TimelineNode {\n    const { action, delay, payload, target } = this.args;\n    return {\n      action,\n      at: this.args.at,\n      delay: msOf(delay),\n      kind: 'perform',\n      name: this.args.name,\n      payload,\n      target,\n    };\n  }\n}\n\n/**\n * `<c.Scroll />` — animate the sprite's scroll container so the sprite lands\n * at `@align`; occupies the sequence like any step (§6.1).\n */\n/**\n * `<c.Attach @region @duration />` — drive another region's run over a\n * window of this one's clock. Positioned like any step (sequence order,\n * `@at`, `@delay`); `@in` and `@rate` map the window onto the child's own\n * seconds; `@end` says what happens past it; `@exact` refuses a child\n * that cannot be driven exactly (a spring, a follow).\n */\nexport class Attach extends StepComponent<\n  StepArgsBase & {\n    duration: number;\n    end?: 'hold' | 'remove';\n    exact?: boolean;\n    in?: number;\n    rate?: number;\n    region: string;\n  }\n> {\n  node(): TimelineNode {\n    const { delay, duration, end, exact, rate, region } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      end,\n      exact,\n      in: this.args.in,\n      kind: 'attach',\n      ms: duration * 1000,\n      name: this.args.name,\n      rate,\n      region,\n    };\n  }\n}\n\nexport class Scroll extends StepComponent<\n  StepArgs & { align?: 'center' | 'end' | 'start'; duration?: number }\n> {\n  node(): TimelineNode {\n    const { of, align, duration, delay, stagger } = this.args;\n    return {\n      align,\n      at: this.args.at,\n      delay: msOf(delay),\n      kind: 'scroll',\n      ms: msOf(duration),\n      name: this.args.name,\n      of,\n      stagger: msOf(stagger),\n    };\n  }\n}\n\n/**\n * `<c.Raise />` — promote the sprites to the region's elevated layer for the\n * span of its block (or `@duration`): above every stacking context and clip\n * in the region, with measured continuity both ways. `@shadow` casts on the\n * layer below (§6.3).\n */\nexport class Raise extends StepComponent<\n  StepArgs & { duration?: number; shadow?: boolean }\n> {\n  node(): TimelineNode {\n    const { of, duration, delay, shadow, stagger } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      kind: 'raise',\n      ms: msOf(duration),\n      name: this.args.name,\n      of,\n      shadow,\n      stagger: msOf(stagger),\n    };\n  }\n}\n\n/**\n * `<c.Camera />` — the region's frame as a step (§6.3): `@zoom` / `@x` /\n * `@y` animate the scene, `@origin` aims the zoom at a sprite, `@steady`\n * names sprites that keep their size against it (damped by default).\n * `@fit` is the other, more common shape — dive on this sprite and CENTRE\n * it, zoom and pan computed from rest-layout geometry (`@margin` sets the\n * share of the frame it fills); pass `null` to fit nothing: back to rest.\n */\nexport class Camera extends StepComponent<\n  StepArgsBase & {\n    duration?: number;\n    ease?: Easing;\n    fit?: Query | null;\n    margin?: number;\n    of?: Query | Query[];\n    origin?: Query;\n    spring?: SpringSpec;\n    steady?: Query | Query[];\n    x?: number;\n    y?: number;\n    zoom?: number;\n  }\n> {\n  node(): TimelineNode {\n    const { duration, ease, delay, fit, margin, origin, spring, steady } =\n      this.args;\n    const { x, y, zoom } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      ease,\n      fit,\n      kind: 'camera',\n      margin,\n      ms: msOf(duration),\n      name: this.args.name,\n      of: this.args.of ?? {},\n      origin,\n      spring,\n      steady,\n      x,\n      y,\n      zoom,\n    };\n  }\n}\n\n/**\n * `<c.Camera3D @yaw={{-24}} @pitch={{-6}} @dolly={{0.9}} />` — the shot,\n * for a scene Choreo is not the one drawing.\n *\n * `c.Camera` moves the region's own frame, which is a 2D transform on real\n * DOM. A 3D scene has no such frame: its camera belongs to whatever is\n * rendering it. So this step carries the POSE and nothing else — yaw and\n * pitch in degrees, dolly as a multiple of the host's own framing — and\n * the region hands it to `@onCamera3D` every frame it changes. The host\n * applies it to three.js, to a CSS 3D stage, to anything that takes three\n * numbers.\n *\n * What Choreo keeps is the part it is actually good at: the pose is a pure\n * function of the clock, so a scrub lands the shot exactly where playing\n * there would, and a preset expands into this one seekable cue rather than\n * a second scheduler.\n *\n * `@by` makes it relative — added to the pose in force when the cue\n * starts, the way `Pan` and `SlowZoom` are relative — so a drift composes\n * with whatever shot preceded it.\n */\nexport class Camera3D extends StepComponent<\n  StepArgsBase & {\n    by?: boolean;\n    dolly?: number;\n    duration?: number;\n    ease?: Easing;\n    /** the orbit centre, in the host's scene units — tweened with the pose */\n    look?: { x: number; y: number; z: number };\n    of?: Query | Query[];\n    pitch?: number;\n    /** smoothing window for a path, seconds — see Camera3DStep.settle */\n    settle?: number;\n    spring?: SpringSpec;\n    /** the path's grip, 0 lively .. 1 linear — see Camera3DStep.tension */\n    tension?: number;\n    /** waypoints for a spline path — see Camera3DStep.through */\n    through?: Camera3DWaypoint[];\n    x?: number;\n    y?: number;\n    yaw?: number;\n  }\n> {\n  node(): TimelineNode {\n    const {\n      by,\n      delay,\n      dolly,\n      duration,\n      ease,\n      look,\n      pitch,\n      settle,\n      spring,\n      tension,\n      through,\n      x,\n      y,\n      yaw,\n    } = this.args;\n    return {\n      at: this.args.at,\n      by,\n      delay: msOf(delay),\n      dolly,\n      ease,\n      kind: 'camera3d',\n      look,\n      ms: msOf(duration),\n      name: this.args.name,\n      of: this.args.of ?? {},\n      pitch,\n      settle,\n      spring,\n      tension,\n      through,\n      x,\n      y,\n      yaw,\n    };\n  }\n}\n\n/* ---- the direction vocabulary (notes/choreo-composition.md C5) ----\n   Presets expand into the SAME seekable camera cue — sugar, never a new\n   runtime primitive. Frame and Aim are absolute (computed from measured\n   geometry at compile); Pan and SlowZoom are RELATIVE, resolved against\n   the pose in force when the cue starts, so they compose with whatever\n   shot preceded them and reconstruct under random access like any cue. */\n\n/**\n * `<c.Frame @of={{c.id 'hero'}} @padding={{0.8}} />` — fit-and-centre the\n * target: the fit camera under its editorial name. `@padding` is the\n * share of the frame the target fills on whichever axis fits first.\n */\nexport class Frame extends StepComponent<\n  StepArgsBase & {\n    duration?: number;\n    ease?: Easing;\n    of: Query | null;\n    padding?: number;\n    spring?: SpringSpec;\n    steady?: Query | Query[];\n  }\n> {\n  node(): TimelineNode {\n    const { duration, ease, delay, of, padding, spring, steady } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      ease,\n      fit: of,\n      kind: 'camera',\n      margin: padding,\n      ms: msOf(duration),\n      name: this.args.name,\n      of: {},\n      spring,\n      steady,\n    };\n  }\n}\n\n/**\n * `<c.Aim @of={{c.id 'hero'}} />` — recentre the picture on the target\n * with the zoom HELD: the reframe that does not change magnification.\n */\nexport class Aim extends StepComponent<\n  StepArgsBase & {\n    duration?: number;\n    ease?: Easing;\n    of: Query;\n    spring?: SpringSpec;\n    steady?: Query | Query[];\n  }\n> {\n  node(): TimelineNode {\n    const { duration, ease, delay, of, spring, steady } = this.args;\n    return {\n      aim: of,\n      at: this.args.at,\n      delay: msOf(delay),\n      ease,\n      kind: 'camera',\n      ms: msOf(duration),\n      name: this.args.name,\n      of: {},\n      spring,\n      steady,\n    };\n  }\n}\n\n/**\n * `<c.Pan @x={{40}} @y={{-20}} />` — shift the picture by exactly this\n * many pixels from wherever it stands. Relative on purpose: a pan after\n * any shot means \"from here\", not \"to there\".\n */\nexport class Pan extends StepComponent<\n  StepArgsBase & {\n    duration?: number;\n    ease?: Easing;\n    spring?: SpringSpec;\n    steady?: Query | Query[];\n    x?: number;\n    y?: number;\n  }\n> {\n  node(): TimelineNode {\n    const { duration, ease, delay, spring, steady, x, y } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      ease,\n      kind: 'camera',\n      ms: msOf(duration),\n      name: this.args.name,\n      of: {},\n      panBy: { x, y },\n      spring,\n      steady,\n    };\n  }\n}\n\n/**\n * `<c.SlowZoom @by={{1.05}} @duration={{2}} />` — multiply the zoom in\n * force: the push-in (or, below 1, the pull-back) that gives a hold its\n * life. The aim in force is kept, so it pushes toward what the previous\n * shot was looking at.\n */\nexport class SlowZoom extends StepComponent<\n  StepArgsBase & {\n    by: number;\n    duration?: number;\n    ease?: Easing;\n    spring?: SpringSpec;\n    steady?: Query | Query[];\n  }\n> {\n  node(): TimelineNode {\n    const { by, duration, ease, delay, spring, steady } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      ease,\n      kind: 'camera',\n      ms: msOf(duration),\n      name: this.args.name,\n      of: {},\n      spring,\n      steady,\n      zoomBy: by,\n    };\n  }\n}\n\n/**\n * `<c.Tether />` — geometry continuously derived from sprites (§6.1):\n * `@path` receives both endpoints' region-relative boxes every frame and\n * returns the path data the wire draws.\n */\nexport class Tether extends StepComponent<\n  StepArgsBase & {\n    duration?: number;\n    from: Query;\n    of?: Query | Query[];\n    path: (from: Rect, to: Rect) => string;\n    to: Query;\n  }\n> {\n  node(): TimelineNode {\n    const { duration, delay, from, path, to } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(delay),\n      from,\n      kind: 'tether',\n      ms: msOf(duration),\n      name: this.args.name,\n      of: this.args.of,\n      path,\n      to,\n    };\n  }\n}\n\n/**\n * `<c.Crossing />` — the canned scene crossing (§4.7): what only the old\n * scene had fades as the flight lifts off, everything paired flies (skins\n * swapping per `@swap`), and what only the new scene has fades in near the\n * settle. One step in the template; a whole overlapped score on the clock —\n * Keynote's Magic Move does not wait for the dissolve to finish before the\n * movers leave, and a crossing that does reads as three acts, not one.\n *\n * It is also the reference COMPOSITE step, and deliberately written in\n * nothing but the public seam (`StepComponent`, `toMs`, `at`, and node\n * literals): if this needed a privilege an author could not have, the\n * contract on `StepComponent` would be a lie.\n */\nexport class Crossing extends StepComponent<\n  StepArgsBase & {\n    /** seconds to fade what only the new scene has */\n    arrive?: number;\n    /** the tween form of the flight */\n    duration?: number;\n    ease?: Easing;\n    /** seconds to fade what only the old scene had */\n    leave?: number;\n    /** arrivals start at this fraction of the flight — near the settle */\n    overlap?: number;\n    /**\n     * The flight's size mode. Default `'crop'` — uniform scale from\n     * width, tops pinned, extra height clipped. `'scale'` stretches\n     * per-axis; `true` writes layout width/height (reflows a grid row).\n     */\n    size?: boolean | 'crop' | 'scale';\n    spring?: SpringSpec;\n    /** the counterpart-skin policy, forwarded to the flight */\n    swap?: 'during' | 'none' | 'settle';\n  }\n> {\n  /**\n   * The flight is addressable from outside — `{{at 'page:flight' 0.5}}`\n   * for a step that wants to ride the move itself. Derived from this\n   * crossing's own `@name` rather than fixed, so two crossings in one\n   * timeline do not collide over it; unnamed, it takes a per-instance\n   * number, which is stable for the life of the component and so does not\n   * disturb the tree fingerprint between passes.\n   */\n  private flightName = `${this.args.name ?? `crossing-${++crossings}`}:flight`;\n\n  node(): TimelineNode {\n    const {\n      arrive = 0.22,\n      duration,\n      ease,\n      leave = 0.18,\n      overlap = 0.7,\n      size = 'crop',\n      spring,\n      swap,\n    } = this.args;\n    const FLIGHT = this.flightName;\n    return {\n      at: this.args.at,\n      delay: toMs(this.args.delay),\n      name: this.args.name,\n      children: [\n        {\n          generic: true,\n          kind: 'tween',\n          ms: toMs(leave),\n          of: { onstage: true, type: 'departed' },\n          props: { opacity: 0 },\n        },\n        {\n          ease,\n          generic: true,\n          kind: 'move',\n          ms: toMs(duration),\n          name: FLIGHT,\n          of: { type: 'received' },\n          // iOS's rule: uniform scale matched by cover, the aspect mismatch\n          // cropped by the interpolating window — never a stretch, and\n          // never layout (a receiver animating real width/height reflows\n          // its whole row for the flight). Overridable; the default stays\n          // crop so a crossing in a grid cannot stretch the row.\n          size,\n          spring,\n          swap,\n        },\n        {\n          generic: true,\n          kind: 'hold',\n          of: { type: 'received' },\n          props: { zIndex: 2 },\n        },\n        {\n          at: at(FLIGHT, overlap),\n          generic: true,\n          kind: 'tween',\n          ms: toMs(arrive),\n          of: { onstage: true, type: 'inserted' },\n          props: { opacity: [0, 1] },\n        },\n      ],\n      kind: 'parallel',\n    };\n  }\n}\n\n/**\n * `<c.Follow />` — a value DERIVED from the scene rather than interpolated\n * between two keyframes (§4.10). `@to` names what to read; `@read` gets\n * the pass's measurements every frame — each source's resting boxes\n * (`from`, `to`) and its composed position this frame (`now`), plus the\n * follower's own `rest` — and returns the properties to write; `@rest`\n * says what those properties are when nothing is driving them, so a\n * measure pass can put the element back.\n *\n * ```gts\n * <c.Follow @of={{c.id 'badge'}} @to={{c.id 'card'}}\n *           @read={{corner}} @rest={{hash x=0 y=0}} />\n * ```\n *\n * `@read` never sees the live page. Everything it is handed was measured\n * by the pass or composed from the run's own values, so it cannot read\n * back what it wrote last frame and it cannot force a style recalculation\n * mid-move — pure by construction, and correct under interruption because\n * a replacement pass re-measures (docs/postmortem-follow.md).\n *\n * Three things it is not: it is not accelerated (a derived value is\n * computed on the main thread, every frame — the price, and the same one\n * `c.Tether` pays); it may not write layout, only transform, opacity and\n * filter; and `@read` must still be a pure function of its context,\n * because the run is scrubbable in both directions and a value with\n * memory could not be sought back to.\n */\nexport class Follow extends StepComponent<\n  StepArgs & {\n    duration?: number;\n    read: (ctx: DeriveContext) => Record<string, PropValue>;\n    rest: Record<string, PropValue>;\n    to: Query | Query[];\n  }\n> {\n  node(): TimelineNode {\n    const { duration, of, read, rest, to } = this.args;\n    return {\n      at: this.args.at,\n      delay: msOf(this.args.delay),\n      kind: 'follow',\n      ms: msOf(duration),\n      name: this.args.name,\n      of,\n      read,\n      rest,\n      stagger: msOf(this.args.stagger),\n      to,\n    };\n  }\n}\n\n/**\n * `<c.Gate />` — park the run until `c.advance()`; `@delay` opens it by\n * itself after that many seconds (§4.1). A gate is a pause, and a pause is\n * a total order: it may only stand in a sequence that no parallel contains.\n */\nexport class Gate extends Component<{\n  Args: { delay?: number };\n}> {\n  node(): TimelineNode {\n    return { kind: 'gate', ms: msOf(this.args.delay) };\n  }\n  mark = modifier((el: Element) => {\n    providers.set(el, this);\n    return () => providers.delete(el);\n  });\n  <template>\n    <span hidden data-choreo-step {{this.mark}}></span>\n  </template>\n}\n\n/**\n * A block is a step's equal to the anchor system: it takes `@name`, `@at`\n * and `@delay` on the same terms, so a composite step — a `node()` that\n * returns a block — is something the rest of the score can point at.\n */\nabstract class BlockComponent extends Component<{\n  Args: {\n    /** `{{at 'name' 0.4}}` / `{{after 'name'}}` — start against a named step or block */\n    at?: AnchorRef;\n    /** seconds before the block's contents start, inside its slot */\n    delay?: number;\n    /** a label other steps may anchor against; the block's span is its contents */\n    name?: string;\n  };\n  Blocks: { default: [] };\n}> {\n  abstract readonly kind: Block['kind'];\n  private el?: Element;\n  node(): Block {\n    return {\n      at: this.args.at,\n      children: this.el ? collect(this.el) : [],\n      delay: msOf(this.args.delay),\n      kind: this.kind,\n      name: this.args.name,\n    };\n  }\n  mark = modifier((el: Element) => {\n    this.el = el;\n    providers.set(el, this);\n    return () => {\n      providers.delete(el);\n      this.el = undefined;\n    };\n  });\n  <template>\n    <span hidden data-choreo-block {{this.mark}}>{{yield}}</span>\n  </template>\n}\n\nexport class Sequence extends BlockComponent {\n  readonly kind = 'sequence';\n}\nexport class Parallel extends BlockComponent {\n  readonly kind = 'parallel';\n}\n"],"names":["providers","WeakMap","crossings","collect","el","out","child","Array","from","children","hasAttribute","provider","get","push","node","RESERVED","Set","RENAMED","crossfade","ms","overlap","propsOf","args","props","key","Object","keys","undefined","Error","has","toMs","seconds","msOf","StepComponent","Component","mark","modifier","set","delete","setComponentTemplate","precompileTemplate","strictMode","Tween","of","by","duration","ease","delay","order","repeat","repeatType","times","at","kind","name","stagger","Spring","spring","Move","path","rotate","space","size","swap","to","Hold","fill","Wait","Perform","action","payload","target","Attach","end","exact","rate","region","in","Scroll","align","Raise","shadow","Camera","fit","margin","origin","steady","x","y","zoom","Camera3D","dolly","look","pitch","settle","tension","through","yaw","Frame","padding","Aim","aim","Pan","panBy","SlowZoom","zoomBy","Tether","Crossing","flightName","arrive","leave","FLIGHT","generic","onstage","type","opacity","zIndex","Follow","read","rest","Gate","BlockComponent","Sequence","Parallel"],"mappings":"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"}

package/dist/test-support/index.js

@@ -0,0 +1,150 @@
+import { settled } from '@ember/test-helpers';
+import { registerMotionReset, animationsSettled, setupMotion } from 'glimmer-motion/test-support';
+import { frame, visualElementStore } from 'motion-dom';
+import { resetBeacons } from '../beacons.js';
+import { resetBarrier } from '../far.js';
+import { resetGestures } from '../gesture.js';
+import { activeRuns } from '../run.js';
+
+/**
+ * @cardstack/choreo/test-support — how a test drives and checks <Choreo>.
+ *
+ *   import { animationsSettled } from 'glimmer-motion/test-support';
+ *   import { live, orphanCount, setupChoreo } from '@cardstack/choreo/test-support';
+ *
+ *   module('…', function (hooks) {
+ *     setupRenderingTest(hooks);
+ *     setupChoreo(hooks);
+ *
+ *     test('…', async function (assert) {
+ *       await render(<template>…</template>);
+ *       await click(live('.open')!);
+ *       await animationsSettled();
+ *       assert.strictEqual(orphanCount(), 0);
+ *     });
+ *   });
+ *
+ * `setupChoreo()` is the one setup call a Choreo suite makes. It is
+ * `setupMotion()`, and Choreo's document-wide state — the beacon registry, the
+ * far-match barrier, the gesture samples — is reset alongside glimmer-motion's
+ * own, because loading this module adds those resets to `resetMotion()`.
+ *
+ * They are document-wide by design: a beacon in the chrome has to be visible to
+ * a region in an outlet, and the barrier exists to see across regions. That is
+ * right for an app and a leak between tests: a torn-down element still holding
+ * the name "trash" wins the first-registration race against the next test's
+ * real one.
+ */
+registerMotionReset(resetBeacons);
+registerMotionReset(resetGestures);
+registerMotionReset(resetBarrier);
+const nextFrame = () => new Promise(resolve => frame.postRender(() => resolve()));
+
+/* ---- setup ---- */
+
+/** `setupMotion(hooks)`, with Choreo's resets among the ones it runs */
+function setupChoreo(hooks) {
+  setupMotion(hooks);
+}
+
+/* ---- driving the run from a test (§8.3) ---- */
+
+/** open every parked gate and settle the segment it releases */
+async function advanceGate() {
+  for (const run of activeRuns) {
+    if (run.parked) {
+      run.advance();
+    }
+  }
+  await animationsSettled();
+}
+
+/** set every live run's clock, in seconds — a scrubbed still */
+async function seekTo(seconds) {
+  for (const run of activeRuns) {
+    run.pause();
+    run.time = seconds;
+  }
+  await settled();
+  await nextFrame();
+}
+
+/* ---- Choreo invariants, shared by the contract suite and the soak ---- */
+
+const testRoot = () => document.querySelector('#ember-testing') ?? document.body;
+
+/** how many leavers are parked in a <Choreo> orphan layer right now */
+function orphanCount(root = testRoot()) {
+  return [...root.querySelectorAll('[data-choreo-orphans]')].reduce((n, layer) => n + layer.children.length, 0);
+}
+
+/**
+ * The first LIVE match for `selector` — the copy that is still part of the
+ * rendered tree, never a leaver parked in a region's orphan layer.
+ *
+ * Mid-crossing an identity exists twice: the arriving element in the live
+ * tree, and the departing skin the region locked into `[data-choreo-orphans]`
+ * so it can be flown and faded. That layer is the region's FIRST child, so a
+ * bare `querySelector` answers with the ghost — an element whose component
+ * has already been torn down, whose listeners are gone, and whose box is
+ * where the OLD scene stood. Clicking it does nothing; measuring it measures
+ * the past. Neither failure names itself.
+ *
+ * So any assertion or interaction a test performs while a crossing may be
+ * aloft should come through here. A raised sprite (`c.Raise`) is deliberately
+ * still live: it is the real element on a different layer, not a copy.
+ */
+function live(selector, root = testRoot()) {
+  return liveAll(selector, root)[0] ?? null;
+}
+
+/** every live match for `selector`, in document order — see `live()` */
+function liveAll(selector, root = testRoot()) {
+  return [...root.querySelectorAll(selector)].filter(el => !el.closest('[data-choreo-orphans]'));
+}
+
+/**
+ * Elements still wearing a transform that nothing is animating.
+ *
+ * The identity spellings (`translateX(0px)`, `scale(1)`) are rest: the engine
+ * writes them and they are harmless. Anything else, once everything has
+ * settled, is a value somebody borrowed and never gave back.
+ */
+const IDENTITY = /^(translate[XYZ]?\(0px\)\s*|translate\(0px,\s*0px\)\s*|scale[XY]?\(1\)\s*|rotate\(0deg\)\s*)+$/;
+function strandedTransforms(root = testRoot()) {
+  return [...root.querySelectorAll('*')].filter(el => {
+    const t = el.style.transform;
+    if (!t || t === 'none' || IDENTITY.test(t)) {
+      return false;
+    }
+    // a region root's transform is its camera, and a directed plane
+    // RESTS transformed — a held zoom is a pose, not a leak
+    if (el.hasAttribute('data-choreo')) {
+      return false;
+    }
+    return !isFollower(el);
+  }).map(el => `${el.tagName.toLowerCase()}.${el.className}: ${el.style.transform}`);
+}
+
+/**
+ * Is this element's transform owned by somebody else?
+ *
+ * A shared-element pair is one identity with two elements, and only one of them
+ * leads. The follower is projected onto the lead's box on purpose — that is
+ * what makes the crossfade possible — so a thumbnail sitting behind an open
+ * lightbox wears a large scale at rest and is entirely correct.
+ *
+ * Without this, "no element kept a transform" fails for any stage a test
+ * happens to leave open, which reads exactly like a leak and is not one.
+ */
+function isFollower(el) {
+  const projection = visualElementStore.get(el)?.projection;
+  if (!projection || projection.isLead()) {
+    return false;
+  }
+  const lead = projection.getStack()?.lead;
+  return Boolean(lead?.instance?.isConnected);
+}
+
+export { advanceGate, live, liveAll, orphanCount, seekTo, setupChoreo, strandedTransforms };
+//# sourceMappingURL=index.js.map

package/dist/test-support/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/test-support/index.ts"],"sourcesContent":["/**\n * @cardstack/choreo/test-support — how a test drives and checks <Choreo>.\n *\n *   import { animationsSettled } from 'glimmer-motion/test-support';\n *   import { live, orphanCount, setupChoreo } from '@cardstack/choreo/test-support';\n *\n *   module('…', function (hooks) {\n *     setupRenderingTest(hooks);\n *     setupChoreo(hooks);\n *\n *     test('…', async function (assert) {\n *       await render(<template>…</template>);\n *       await click(live('.open')!);\n *       await animationsSettled();\n *       assert.strictEqual(orphanCount(), 0);\n *     });\n *   });\n *\n * `setupChoreo()` is the one setup call a Choreo suite makes. It is\n * `setupMotion()`, and Choreo's document-wide state — the beacon registry, the\n * far-match barrier, the gesture samples — is reset alongside glimmer-motion's\n * own, because loading this module adds those resets to `resetMotion()`.\n *\n * They are document-wide by design: a beacon in the chrome has to be visible to\n * a region in an outlet, and the barrier exists to see across regions. That is\n * right for an app and a leak between tests: a torn-down element still holding\n * the name \"trash\" wins the first-registration race against the next test's\n * real one.\n */\nimport { settled } from '@ember/test-helpers';\nimport {\n  animationsSettled,\n  registerMotionReset,\n  setupMotion,\n} from 'glimmer-motion/test-support';\nimport { frame, visualElementStore } from 'motion-dom';\n\nimport { resetBeacons } from '../beacons.ts';\nimport { resetBarrier } from '../far.ts';\nimport { resetGestures } from '../gesture.ts';\nimport { activeRuns } from '../run.ts';\n\nregisterMotionReset(resetBeacons);\nregisterMotionReset(resetGestures);\nregisterMotionReset(resetBarrier);\n\nconst nextFrame = () =>\n  new Promise<void>((resolve) => frame.postRender(() => resolve()));\n\n/* ---- setup ---- */\n\n/** `setupMotion(hooks)`, with Choreo's resets among the ones it runs */\nexport function setupChoreo(hooks: Parameters<typeof setupMotion>[0]) {\n  setupMotion(hooks);\n}\n\n/* ---- driving the run from a test (§8.3) ---- */\n\n/** open every parked gate and settle the segment it releases */\nexport async function advanceGate(): Promise<void> {\n  for (const run of activeRuns) {\n    if (run.parked) {\n      run.advance();\n    }\n  }\n  await animationsSettled();\n}\n\n/** set every live run's clock, in seconds — a scrubbed still */\nexport async function seekTo(seconds: number): Promise<void> {\n  for (const run of activeRuns) {\n    run.pause();\n    run.time = seconds;\n  }\n  await settled();\n  await nextFrame();\n}\n\n/* ---- Choreo invariants, shared by the contract suite and the soak ---- */\n\nconst testRoot = () =>\n  (document.querySelector('#ember-testing') ?? document.body) as HTMLElement;\n\n/** how many leavers are parked in a <Choreo> orphan layer right now */\nexport function orphanCount(root: HTMLElement = testRoot()): number {\n  return [...root.querySelectorAll('[data-choreo-orphans]')].reduce(\n    (n, layer) => n + layer.children.length,\n    0,\n  );\n}\n\n/**\n * The first LIVE match for `selector` — the copy that is still part of the\n * rendered tree, never a leaver parked in a region's orphan layer.\n *\n * Mid-crossing an identity exists twice: the arriving element in the live\n * tree, and the departing skin the region locked into `[data-choreo-orphans]`\n * so it can be flown and faded. That layer is the region's FIRST child, so a\n * bare `querySelector` answers with the ghost — an element whose component\n * has already been torn down, whose listeners are gone, and whose box is\n * where the OLD scene stood. Clicking it does nothing; measuring it measures\n * the past. Neither failure names itself.\n *\n * So any assertion or interaction a test performs while a crossing may be\n * aloft should come through here. A raised sprite (`c.Raise`) is deliberately\n * still live: it is the real element on a different layer, not a copy.\n */\nexport function live<E extends Element = HTMLElement>(\n  selector: string,\n  root: ParentNode = testRoot(),\n): E | null {\n  return liveAll<E>(selector, root)[0] ?? null;\n}\n\n/** every live match for `selector`, in document order — see `live()` */\nexport function liveAll<E extends Element = HTMLElement>(\n  selector: string,\n  root: ParentNode = testRoot(),\n): E[] {\n  return [...root.querySelectorAll<E>(selector)].filter(\n    (el) => !el.closest('[data-choreo-orphans]'),\n  );\n}\n\n/**\n * Elements still wearing a transform that nothing is animating.\n *\n * The identity spellings (`translateX(0px)`, `scale(1)`) are rest: the engine\n * writes them and they are harmless. Anything else, once everything has\n * settled, is a value somebody borrowed and never gave back.\n */\nconst IDENTITY =\n  /^(translate[XYZ]?\\(0px\\)\\s*|translate\\(0px,\\s*0px\\)\\s*|scale[XY]?\\(1\\)\\s*|rotate\\(0deg\\)\\s*)+$/;\n\nexport function strandedTransforms(root: HTMLElement = testRoot()): string[] {\n  return [...root.querySelectorAll<HTMLElement>('*')]\n    .filter((el) => {\n      const t = el.style.transform;\n      if (!t || t === 'none' || IDENTITY.test(t)) {\n        return false;\n      }\n      // a region root's transform is its camera, and a directed plane\n      // RESTS transformed — a held zoom is a pose, not a leak\n      if (el.hasAttribute('data-choreo')) {\n        return false;\n      }\n      return !isFollower(el);\n    })\n    .map(\n      (el) =>\n        `${el.tagName.toLowerCase()}.${el.className}: ${el.style.transform}`,\n    );\n}\n\n/**\n * Is this element's transform owned by somebody else?\n *\n * A shared-element pair is one identity with two elements, and only one of them\n * leads. The follower is projected onto the lead's box on purpose — that is\n * what makes the crossfade possible — so a thumbnail sitting behind an open\n * lightbox wears a large scale at rest and is entirely correct.\n *\n * Without this, \"no element kept a transform\" fails for any stage a test\n * happens to leave open, which reads exactly like a leak and is not one.\n */\nfunction isFollower(el: HTMLElement): boolean {\n  const projection = visualElementStore.get(el)?.projection;\n  if (!projection || projection.isLead()) {\n    return false;\n  }\n  const lead = projection.getStack()?.lead;\n  return Boolean(lead?.instance?.isConnected);\n}\n"],"names":["registerMotionReset","resetBeacons","resetGestures","resetBarrier","nextFrame","Promise","resolve","frame","postRender","setupChoreo","hooks","setupMotion","advanceGate","run","activeRuns","parked","advance","animationsSettled","seekTo","seconds","pause","time","settled","testRoot","document","querySelector","body","orphanCount","root","querySelectorAll","reduce","n","layer","children","length","live","selector","liveAll","filter","el","closest","IDENTITY","strandedTransforms","t","style","transform","test","hasAttribute","isFollower","map","tagName","toLowerCase","className","projection","visualElementStore","get","isLead","lead","getStack","Boolean","instance","isConnected"],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/package.json

@@ -1,12 +1,207 @@
 {
   "name": "@cardstack/choreo",
-  "version": "0.0.0",
-  "description": "Placeholder reserving this name. Real releases are published from https://github.com/cardstack/boxel.",
-  "license": "MIT",
+  "version": "0.1.0-unstable.1",
+  "description": "Motion, Choreographed. A changeset and a timeline over a whole render pass, on glimmer-motion.",
+  "keywords": [
+    "ember-addon",
+    "animation",
+    "choreography",
+    "motion",
+    "glimmer",
+    "transition",
+    "timeline"
+  ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/cardstack/boxel.git",
+    "url": "https://github.com/cardstack/boxel.git",
     "directory": "packages/choreo"
   },
-  "files": ["README.md"]
-}
+  "license": "MIT",
+  "author": "Cardstack",
+  "exports": {
+    ".": {
+      "developing:choreo": "./src/index.ts",
+      "types": "./declarations/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./test-support": {
+      "developing:choreo": "./src/test-support/index.ts",
+      "types": "./declarations/test-support/index.d.ts",
+      "default": "./dist/test-support/index.js"
+    },
+    "./choreo": {
+      "developing:choreo": "./src/choreo.gts",
+      "types": "./declarations/choreo.d.ts",
+      "default": "./dist/choreo.js"
+    },
+    "./film/clip": {
+      "developing:choreo": "./src/film/clip.gts",
+      "types": "./declarations/film/clip.d.ts",
+      "default": "./dist/film/clip.js"
+    },
+    "./film/film": {
+      "developing:choreo": "./src/film/film.gts",
+      "types": "./declarations/film/film.d.ts",
+      "default": "./dist/film/film.js"
+    },
+    "./film/graph/adjust": {
+      "developing:choreo": "./src/film/graph/adjust.gts",
+      "types": "./declarations/film/graph/adjust.d.ts",
+      "default": "./dist/film/graph/adjust.js"
+    },
+    "./film/graph/host": {
+      "developing:choreo": "./src/film/graph/host.gts",
+      "types": "./declarations/film/graph/host.d.ts",
+      "default": "./dist/film/graph/host.js"
+    },
+    "./film/graph/nodes": {
+      "developing:choreo": "./src/film/graph/nodes.gts",
+      "types": "./declarations/film/graph/nodes.d.ts",
+      "default": "./dist/film/graph/nodes.js"
+    },
+    "./film/joins": {
+      "developing:choreo": "./src/film/joins.gts",
+      "types": "./declarations/film/joins.d.ts",
+      "default": "./dist/film/joins.js"
+    },
+    "./film/overlays": {
+      "developing:choreo": "./src/film/overlays.gts",
+      "types": "./declarations/film/overlays.d.ts",
+      "default": "./dist/film/overlays.js"
+    },
+    "./film/picture": {
+      "developing:choreo": "./src/film/picture.gts",
+      "types": "./declarations/film/picture.d.ts",
+      "default": "./dist/film/picture.js"
+    },
+    "./film/plate": {
+      "developing:choreo": "./src/film/plate.gts",
+      "types": "./declarations/film/plate.d.ts",
+      "default": "./dist/film/plate.js"
+    },
+    "./film/player": {
+      "developing:choreo": "./src/film/player.gts",
+      "types": "./declarations/film/player.d.ts",
+      "default": "./dist/film/player.js"
+    },
+    "./film/rail": {
+      "developing:choreo": "./src/film/rail.gts",
+      "types": "./declarations/film/rail.d.ts",
+      "default": "./dist/film/rail.js"
+    },
+    "./film/titles": {
+      "developing:choreo": "./src/film/titles.gts",
+      "types": "./declarations/film/titles.d.ts",
+      "default": "./dist/film/titles.js"
+    },
+    "./steps": {
+      "developing:choreo": "./src/steps.gts",
+      "types": "./declarations/steps.d.ts",
+      "default": "./dist/steps.js"
+    },
+    "./*": {
+      "developing:choreo": "./src/*.ts",
+      "types": "./declarations/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./addon-main.js": "./addon-main.cjs"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "declarations/*",
+        "declarations/*/index"
+      ]
+    }
+  },
+  "files": [
+    "addon-main.cjs",
+    "declarations",
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@embroider/addon-shim": "^1.8.9",
+    "decorator-transforms": "^2.3.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.10",
+    "@babel/plugin-transform-runtime": "^7.29.0",
+    "@babel/plugin-transform-typescript": "^7.16.8",
+    "@babel/runtime": "^7.22.11",
+    "@cardstack/choreo-eslint-config": "0.0.0",
+    "@ember/library-tsconfig": "^1.1.3",
+    "@ember/test-helpers": "^4.0.5",
+    "@embroider/addon-dev": "^8.0.0",
+    "@embroider/config-meta-loader": "^1.0.0",
+    "@embroider/core": "^4.6.3",
+    "@embroider/macros": "^1.20.2",
+    "@embroider/vite": "^1.7.10",
+    "@glimmer/component": "^2.0.0",
+    "@glimmer/tracking": "^1.1.2",
+    "@glimmer/validator": "^0.95.0",
+    "@glint/ember-tsc": "1.5.0",
+    "@glint/template": "^1.7.7",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@types/qunit": "^2.19.12",
+    "babel-plugin-ember-template-compilation": "^2.4.1",
+    "concurrently": "^8.2.2",
+    "ember-modifier": "^4.3.0",
+    "ember-qunit": "^9.0.4",
+    "ember-source": "~6.10.0",
+    "ember-strict-application-resolver": "^0.1.0",
+    "ember-template-lint": "^7.8.1",
+    "eslint": "^9.39.4",
+    "glimmer-motion": "0.1.0-unstable.1",
+    "motion-dom": "13.4.5",
+    "motion-utils": "13.3.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-ember-template-tag": "^2.0.0",
+    "qunit": "^2.24.1",
+    "qunit-dom": "^3.5.0",
+    "rollup": "^4.18.1",
+    "testem": "^3.10.1",
+    "typescript": "~5.9.3",
+    "vite": "^6.3.2"
+  },
+  "peerDependenciesMeta": {
+    "@ember/test-helpers": {
+      "optional": true
+    }
+  },
+  "ember-addon": {
+    "version": 2,
+    "type": "addon",
+    "main": "addon-main.cjs",
+    "app-js": {}
+  },
+  "peerDependencies": {
+    "@ember/test-helpers": ">=3.0.0",
+    "@glimmer/component": "^2.0.0",
+    "ember-modifier": "^4.3.0",
+    "ember-source": ">=5.4.0",
+    "glimmer-motion": "0.1.0-unstable.1",
+    "motion-dom": "^13.4.5",
+    "motion-utils": "^13.3.0"
+  },
+  "scripts": {
+    "build": "rollup --config && node scripts/fix-declarations.mjs",
+    "check:packed-exports": "node ../glimmer-motion/scripts/check-exports.mjs --packed",
+    "format": "prettier . --cache --write",
+    "lint": "concurrently \"pnpm:lint:*(!fix)\" --names \"lint:\" --prefixColors auto",
+    "lint:fix": "concurrently \"pnpm:lint:*:fix\" --names \"fix:\" --prefixColors auto && pnpm run format",
+    "lint:format": "prettier . --cache --check",
+    "lint:hbs": "ember-template-lint .",
+    "lint:hbs:fix": "ember-template-lint . --fix",
+    "lint:js": "eslint . --cache",
+    "lint:js:fix": "eslint . --fix",
+    "lint:exports": "node ../glimmer-motion/scripts/check-exports.mjs --source",
+    "lint:types": "ember-tsc --noEmit",
+    "start": "rollup --config --watch",
+    "test": "vite build --mode=development --out-dir dist-tests && testem --file testem.cjs ci --port 0",
+    "start:test": "vite dev --open /tests/"
+  }
+}