@cardstack/choreo 0.0.0 → 0.1.0-unstable.1

package/dist/gesture.js

@@ -0,0 +1,111 @@
+/**
+ * `c.gesture` — the live drag as a first-class geometry source (§6.1, §6.4).
+ *
+ * A document-level pointer tracker (listeners, not timers) keeps the last
+ * pointer position and a short velocity window. A Move that borrows
+ * `{{c.gesture}}` as its `@from` starts from wherever the finger let go —
+ * sized as the sprite, centred on the pointer — and any spring that flies
+ * it inherits the pointer's velocity, so a toss leaves at the speed it was
+ * thrown.
+ */
+
+const GESTURE = {
+  gesture: true
+};
+function isGestureRef(v) {
+  return typeof v === 'object' && v !== null && v.gesture === true;
+}
+let samples = [];
+let tracking = false;
+function record(event) {
+  const now = performance.now();
+  samples.push({
+    t: now,
+    x: event.clientX,
+    y: event.clientY
+  });
+  if (samples.length > 8) {
+    samples.shift();
+  }
+}
+
+/** idempotent; the first <Choreo> turns it on */
+function trackGestures() {
+  if (tracking || typeof window === 'undefined') {
+    return;
+  }
+  tracking = true;
+  window.addEventListener('pointerdown', record, {
+    capture: true,
+    passive: true
+  });
+  window.addEventListener('pointermove', record, {
+    capture: true,
+    passive: true
+  });
+  window.addEventListener('pointerup', record, {
+    capture: true,
+    passive: true
+  });
+}
+
+/** the pointer's page position now, or null before any pointer event */
+function gesturePoint() {
+  const last = samples[samples.length - 1];
+  return last ? {
+    x: last.x,
+    y: last.y
+  } : null;
+}
+
+/** units per second over the recent window — what a spring inherits */
+function gestureVelocity() {
+  if (samples.length < 2) {
+    return {
+      x: 0,
+      y: 0
+    };
+  }
+  const now = performance.now();
+  const recent = samples.filter(s => now - s.t < 120);
+  const a = recent[0] ?? samples[samples.length - 2];
+  const b = samples[samples.length - 1];
+  const dt = (b.t - a.t) / 1000;
+  if (dt <= 0) {
+    return {
+      x: 0,
+      y: 0
+    };
+  }
+  return {
+    x: (b.x - a.x) / dt,
+    y: (b.y - a.y) / dt
+  };
+}
+
+/** the gesture as a box: the sprite\'s own size, centred on the pointer */
+function gestureBounds(size) {
+  const point = gesturePoint();
+  if (!point) {
+    return null;
+  }
+  const page = {
+    height: size.height,
+    width: size.width,
+    x: point.x - size.width / 2,
+    y: point.y - size.height / 2
+  };
+  return {
+    context: page,
+    page,
+    parent: page
+  };
+}
+
+/** test-support: forget everything between tests */
+function resetGestures() {
+  samples = [];
+}
+
+export { GESTURE, gestureBounds, gesturePoint, gestureVelocity, isGestureRef, resetGestures, trackGestures };
+//# sourceMappingURL=gesture.js.map

package/dist/gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gesture.js","sources":["../src/gesture.ts"],"sourcesContent":["/**\n * `c.gesture` — the live drag as a first-class geometry source (§6.1, §6.4).\n *\n * A document-level pointer tracker (listeners, not timers) keeps the last\n * pointer position and a short velocity window. A Move that borrows\n * `{{c.gesture}}` as its `@from` starts from wherever the finger let go —\n * sized as the sprite, centred on the pointer — and any spring that flies\n * it inherits the pointer's velocity, so a toss leaves at the speed it was\n * thrown.\n */\nimport type { Bounds, Rect } from './types.ts';\n\nexport interface GestureRef {\n  gesture: true;\n}\n\nexport const GESTURE: GestureRef = { gesture: true };\n\nexport function isGestureRef(v: unknown): v is GestureRef {\n  return (\n    typeof v === 'object' &&\n    v !== null &&\n    (v as { gesture?: unknown }).gesture === true\n  );\n}\n\ninterface Sample {\n  t: number;\n  x: number;\n  y: number;\n}\n\nlet samples: Sample[] = [];\nlet tracking = false;\n\nfunction record(event: PointerEvent) {\n  const now = performance.now();\n  samples.push({ t: now, x: event.clientX, y: event.clientY });\n  if (samples.length > 8) {\n    samples.shift();\n  }\n}\n\n/** idempotent; the first <Choreo> turns it on */\nexport function trackGestures() {\n  if (tracking || typeof window === 'undefined') {\n    return;\n  }\n  tracking = true;\n  window.addEventListener('pointerdown', record, {\n    capture: true,\n    passive: true,\n  });\n  window.addEventListener('pointermove', record, {\n    capture: true,\n    passive: true,\n  });\n  window.addEventListener('pointerup', record, {\n    capture: true,\n    passive: true,\n  });\n}\n\n/** the pointer's page position now, or null before any pointer event */\nexport function gesturePoint(): { x: number; y: number } | null {\n  const last = samples[samples.length - 1];\n  return last ? { x: last.x, y: last.y } : null;\n}\n\n/** units per second over the recent window — what a spring inherits */\nexport function gestureVelocity(): { x: number; y: number } {\n  if (samples.length < 2) {\n    return { x: 0, y: 0 };\n  }\n  const now = performance.now();\n  const recent = samples.filter((s) => now - s.t < 120);\n  const a = recent[0] ?? samples[samples.length - 2]!;\n  const b = samples[samples.length - 1]!;\n  const dt = (b.t - a.t) / 1000;\n  if (dt <= 0) {\n    return { x: 0, y: 0 };\n  }\n  return { x: (b.x - a.x) / dt, y: (b.y - a.y) / dt };\n}\n\n/** the gesture as a box: the sprite\\'s own size, centred on the pointer */\nexport function gestureBounds(size: Rect): Bounds | null {\n  const point = gesturePoint();\n  if (!point) {\n    return null;\n  }\n  const page: Rect = {\n    height: size.height,\n    width: size.width,\n    x: point.x - size.width / 2,\n    y: point.y - size.height / 2,\n  };\n  return { context: page, page, parent: page };\n}\n\n/** test-support: forget everything between tests */\nexport function resetGestures() {\n  samples = [];\n}\n"],"names":["GESTURE","gesture","isGestureRef","v","samples","tracking","record","event","now","performance","push","t","x","clientX","y","clientY","length","shift","trackGestures","window","addEventListener","capture","passive","gesturePoint","last","gestureVelocity","recent","filter","s","a","b","dt","gestureBounds","size","point","page","height","width","context","parent","resetGestures"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export { after, at } from './anchors.js';
+export { createArming } from './arming.js';
+export { beacon } from './beacon.js';
+export { Choreo } from './choreo.js';
+export { easeIn, easeInAndOut, easeOut } from './easings.js';
+export { choreoHostAt, choreoHostById, closestChoreo } from './registry.js';
+export { appliedCamera, toLocal, toPage } from './space.js';
+export { StepComponent, toMs } from './steps.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/measure.js

@@ -0,0 +1,99 @@
+import { defineParticipantArg } from 'glimmer-motion';
+
+/**
+ * One measurement layer, for everything that measures.
+ *
+ * The region and the beacon registry both turn a DOMRect into the three spaces
+ * a step can ask for — page, region-relative, offset-parent-relative — and they
+ * have to agree exactly, because a Move routinely reads one sprite's `page` and
+ * another's. Ember Animated learned the same thing the hard way and ended up
+ * with a single bounds module; two copies of `minus` that drift by a scroll
+ * offset produce a flight that lands next to its target, which is the kind of
+ * bug that looks like a spring problem for a day.
+ */
+// `pack`'s type is declared in registry.ts, which the published declarations reach
+defineParticipantArg('pack', (el, pack) => {
+  if (pack === 'content') {
+    el.setAttribute('data-choreo-pack', 'content');
+  } else {
+    el.removeAttribute('data-choreo-pack');
+  }
+});
+
+/** a box in page space */
+const rect = r => ({
+  height: r.height,
+  width: r.width,
+  x: r.left,
+  y: r.top
+});
+
+/** `a` expressed relative to `b`'s top-left, keeping a's size */
+const minus = (a, b) => ({
+  height: a.height,
+  width: a.width,
+  x: a.left - b.left,
+  y: a.top - b.top
+});
+
+/** an element's box together with the box it is positioned inside */
+
+/**
+ * The shrink-wrap of `el`'s contents — the ink — not the stretched layout
+ * box. A full-bleed title (`left:0; right:0; width:auto`) still has a
+ * word-sized range; Crossing crop must match THAT, or the type explodes
+ * into a viewport strip. Empty / collapsed → undefined, so the frame wins.
+ */
+const inkBox = el => {
+  const doc = el.ownerDocument;
+  if (!doc) {
+    return undefined;
+  }
+  const range = doc.createRange();
+  range.selectNodeContents(el);
+  const r = range.getBoundingClientRect();
+  if (r.width < 0.5 && r.height < 0.5) {
+    return undefined;
+  }
+  return r;
+};
+const substanceOf = el => {
+  const marked = el.querySelector('[data-choreo-substance]')?.getBoundingClientRect();
+  if (marked) {
+    return marked;
+  }
+  if (el.getAttribute('data-choreo-pack') === 'content') {
+    return inkBox(el);
+  }
+  return undefined;
+};
+
+/** the containing block a `position: absolute` child would be placed against */
+const offsetBox = el => (el.offsetParent ?? el.parentElement ?? el).getBoundingClientRect();
+const measure = el => ({
+  el: el.getBoundingClientRect(),
+  // read with the geometry, while the element is still attached: a removed
+  // skin is detached DOM by the time a crossing asks what color it wore
+  paint: getComputedStyle(el).backgroundColor,
+  parent: offsetBox(el),
+  // Keynote matches OBJECTS, not slide frames: an element may declare its
+  // visible subject with [data-choreo-substance], or pack="content" (the
+  // shrink-wrap / ink, no extra node). Captured with the geometry for
+  // the same reason paint is.
+  substance: substanceOf(el)
+});
+
+/** the three spaces, from a snapshot and the region's own box */
+const boundsOf = (snap, root) => ({
+  context: minus(snap.el, root),
+  page: rect(snap.el),
+  paint: snap.paint,
+  parent: minus(snap.el, snap.parent),
+  substance: snap.substance && rect(snap.substance)
+});
+
+/** measure an element straight into bounds — what a beacon needs */
+const measureBounds = (el, root) => boundsOf(measure(el), root);
+
+export { boundsOf, inkBox, measure, measureBounds, minus, offsetBox, rect };
+//# sourceMappingURL=measure.js.map

package/dist/measure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure.js","sources":["../src/measure.ts"],"sourcesContent":["/**\n * One measurement layer, for everything that measures.\n *\n * The region and the beacon registry both turn a DOMRect into the three spaces\n * a step can ask for — page, region-relative, offset-parent-relative — and they\n * have to agree exactly, because a Move routinely reads one sprite's `page` and\n * another's. Ember Animated learned the same thing the hard way and ended up\n * with a single bounds module; two copies of `minus` that drift by a scroll\n * offset produce a flight that lands next to its target, which is the kind of\n * bug that looks like a spring problem for a day.\n */\nimport { defineParticipantArg } from 'glimmer-motion';\n\nimport type { Bounds, Rect } from './types.ts';\n\n// `pack`'s type is declared in registry.ts, which the published declarations reach\ndefineParticipantArg('pack', (el, pack) => {\n  if (pack === 'content') {\n    el.setAttribute('data-choreo-pack', 'content');\n  } else {\n    el.removeAttribute('data-choreo-pack');\n  }\n});\n\n/** a box in page space */\nexport const rect = (r: DOMRect): Rect => ({\n  height: r.height,\n  width: r.width,\n  x: r.left,\n  y: r.top,\n});\n\n/** `a` expressed relative to `b`'s top-left, keeping a's size */\nexport const minus = (a: DOMRect, b: DOMRect): Rect => ({\n  height: a.height,\n  width: a.width,\n  x: a.left - b.left,\n  y: a.top - b.top,\n});\n\n/** an element's box together with the box it is positioned inside */\nexport interface Snapshot {\n  el: DOMRect;\n  /** the computed background at measure time — see Bounds.paint */\n  paint?: string;\n  parent: DOMRect;\n  /** the declared subject's box at measure time — see Bounds.substance */\n  substance?: DOMRect;\n}\n\n/**\n * The shrink-wrap of `el`'s contents — the ink — not the stretched layout\n * box. A full-bleed title (`left:0; right:0; width:auto`) still has a\n * word-sized range; Crossing crop must match THAT, or the type explodes\n * into a viewport strip. Empty / collapsed → undefined, so the frame wins.\n */\nexport const inkBox = (el: Element): DOMRect | undefined => {\n  const doc = el.ownerDocument;\n  if (!doc) {\n    return undefined;\n  }\n  const range = doc.createRange();\n  range.selectNodeContents(el);\n  const r = range.getBoundingClientRect();\n  if (r.width < 0.5 && r.height < 0.5) {\n    return undefined;\n  }\n  return r;\n};\n\nconst substanceOf = (el: Element): DOMRect | undefined => {\n  const marked = el\n    .querySelector('[data-choreo-substance]')\n    ?.getBoundingClientRect();\n  if (marked) {\n    return marked;\n  }\n  if (el.getAttribute('data-choreo-pack') === 'content') {\n    return inkBox(el);\n  }\n  return undefined;\n};\n\n/** the containing block a `position: absolute` child would be placed against */\nexport const offsetBox = (el: Element): DOMRect =>\n  (\n    (el as HTMLElement).offsetParent ??\n    el.parentElement ??\n    el\n  ).getBoundingClientRect();\n\nexport const measure = (el: Element): Snapshot => ({\n  el: el.getBoundingClientRect(),\n  // read with the geometry, while the element is still attached: a removed\n  // skin is detached DOM by the time a crossing asks what color it wore\n  paint: getComputedStyle(el).backgroundColor,\n  parent: offsetBox(el),\n  // Keynote matches OBJECTS, not slide frames: an element may declare its\n  // visible subject with [data-choreo-substance], or pack=\"content\" (the\n  // shrink-wrap / ink, no extra node). Captured with the geometry for\n  // the same reason paint is.\n  substance: substanceOf(el),\n});\n\n/** the three spaces, from a snapshot and the region's own box */\nexport const boundsOf = (snap: Snapshot, root: DOMRect): Bounds => ({\n  context: minus(snap.el, root),\n  page: rect(snap.el),\n  paint: snap.paint,\n  parent: minus(snap.el, snap.parent),\n  substance: snap.substance && rect(snap.substance),\n});\n\n/** measure an element straight into bounds — what a beacon needs */\nexport const measureBounds = (el: Element, root: DOMRect): Bounds =>\n  boundsOf(measure(el), root);\n"],"names":["defineParticipantArg","el","pack","setAttribute","removeAttribute","rect","r","height","width","x","left","y","top","minus","a","b","inkBox","doc","ownerDocument","undefined","range","createRange","selectNodeContents","getBoundingClientRect","substanceOf","marked","querySelector","getAttribute","offsetBox","offsetParent","parentElement","measure","paint","getComputedStyle","backgroundColor","parent","substance","boundsOf","snap","root","context","page","measureBounds"],"mappings":"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"}

package/dist/path.js

@@ -0,0 +1,272 @@
+/**
+ * THE CAMERA'S PATH — the arithmetic behind `c.Camera3D @through`, and
+ * the only place in Choreo that owns a curve rather than a tween.
+ *
+ * Everything here is a pure function of PROGRESS. That is the whole
+ * point: a seek must land the shot exactly where playing there would, so
+ * nothing in this file may remember a previous frame. A spline that is
+ * sampled rather than integrated can be scrubbed, rendered a frame at a
+ * time, and played, and all three agree by construction.
+ */
+
+/**
+ * One cardinal-spline component: Hermite through p1 and p2, tangents off
+ * p0 and p3 scaled by `k = (1 - tension) / 2`. Tension 0 is the classic
+ * Catmull-Rom — lively, and loose enough to overshoot between waypoints
+ * that change direction; 1 collapses the tangents and the path goes
+ * piecewise-linear. The default (0.5) is the steady hand: it still crosses
+ * every waypoint with continuous velocity, but it does not sway on the way.
+ */
+function crVal(p0, p1, p2, p3, u, k) {
+  const m1 = k * (p2 - p0);
+  const m2 = k * (p3 - p1);
+  const u2 = u * u;
+  const u3 = u2 * u;
+  return (2 * u3 - 3 * u2 + 1) * p1 + (u3 - 2 * u2 + u) * m1 + (-2 * u3 + 3 * u2) * p2 + (u3 - u2) * m2;
+}
+
+/**
+ * Resolve a `@through` path's control points: the pose in force first, then
+ * each waypoint with its omissions carried forward. If ANY point carries a
+ * look, every point gets one (the origin, when unstated), so the aim is
+ * splined by the same arithmetic as the pose.
+ */
+function resolveThrough(from, through) {
+  const aimed = !!from.look || through.some(w => w.look);
+  const seed = {
+    ...from,
+    look: aimed ? from.look ?? {
+      x: 0,
+      y: 0,
+      z: 0
+    } : undefined
+  };
+  const pts = [seed];
+  let prev = seed;
+  for (const w of through) {
+    const p = {
+      dolly: w.dolly ?? prev.dolly,
+      look: aimed ? w.look ?? prev.look : undefined,
+      pitch: w.pitch ?? prev.pitch,
+      x: w.x ?? prev.x,
+      y: w.y ?? prev.y,
+      yaw: w.yaw ?? prev.yaw
+    };
+    pts.push(p);
+    prev = p;
+  }
+  return pts;
+}
+
+/** the shot a slot position falls in — points [a, e), window [w0, w1) */
+
+/**
+ * WHICH SHOT A SLOT POSITION IS IN. A waypoint marked `cut` opens a new
+ * one, and the two facts a caller needs about it are the points it may
+ * reach for and the slice of the clock it owns — the second so that
+ * nothing (a sample, a settle) ever reads across a seam.
+ */
+function shotAt(through, points, segs, s) {
+  /* the seams, in point indices (+1: the seed sits at 0) */
+  let seams;
+  for (const [n, w] of through.entries()) {
+    if (w.cut) {
+      (seams ??= []).push(n + 1);
+    }
+  }
+  let a = 0;
+  let e = points;
+  let w0 = 0;
+  let w1 = segs;
+  if (seams) {
+    if (seams[0] === 1) {
+      /* a leading cut: the seed never plays */
+      a = 1;
+      seams = seams.slice(1);
+    }
+    for (const seam of seams) {
+      if (s < seam) {
+        e = seam;
+        w1 = seam;
+        break;
+      }
+      a = seam;
+      w0 = seam;
+    }
+  }
+  return {
+    a,
+    e,
+    w0,
+    w1
+  };
+}
+
+/**
+ * Sample the spline at overall progress p ∈ [0, 1] (uniform segments).
+ *
+ * SPLICES (docs/choreo-splices.md): a waypoint marked `cut` starts a new
+ * SHOT. Each shot is a clamped spline of its own points — endpoint
+ * tangents one-sided, so no shot's velocity crosses a seam — and each
+ * shot's window runs from its first slot to the next seam, its points
+ * spread uniformly across it. The outgoing shot therefore plays through
+ * the seam instant (its motion stretches by one slot rather than
+ * parking), the incoming one begins exactly on it, and the sampled pose
+ * is a step function at the seam. Waypoints keep their uniform slots, so
+ * cues anchored to waypoint moments keep their clock. A cut on the first
+ * waypoint drops the pose-in-force seed: the score opens inside its
+ * first shot.
+ */
+function sampleThrough(from, through, progress, tension) {
+  const k = (1 - (tension ?? 0.5)) / 2;
+  const pts = resolveThrough(from, through);
+  const segs = pts.length - 1;
+  const s = Math.min(segs - 1e-9, Math.max(0, progress * segs));
+  const {
+    a,
+    e,
+    w0,
+    w1
+  } = shotAt(through, pts.length, segs, s);
+  const m = e - a;
+  const lam = m === 1 ? 0 : Math.max(0, Math.min(1 - 1e-9, (s - w0) / (w1 - w0)));
+  const ss = lam * (m - 1);
+  const i = a + Math.floor(ss);
+  const u = m === 1 ? 0 : ss - Math.floor(ss);
+  /* clamped to the SHOT: the far side of a seam does not exist here */
+  const P = j => pts[Math.max(a, Math.min(e - 1, j))];
+  const p0 = P(i - 1);
+  const p1 = P(i);
+  const p2 = P(i + 1);
+  const p3 = P(i + 2);
+  const v = key => crVal(p0[key], p1[key], p2[key], p3[key], u, k);
+  const out = {
+    dolly: v('dolly'),
+    pitch: v('pitch'),
+    x: v('x'),
+    y: v('y'),
+    yaw: v('yaw')
+  };
+  if (p1.look && p2.look) {
+    const l = a => crVal((p0.look ?? p1.look)[a], p1.look[a], p2.look[a], (p3.look ?? p2.look)[a], u, k);
+    out.look = {
+      x: l('x'),
+      y: l('y'),
+      z: l('z')
+    };
+  }
+  return out;
+}
+/**
+ * A SETTLE — the operator's second hand, written as a function of time.
+ *
+ * A cardinal spline crosses its waypoints with continuous velocity but
+ * not continuous acceleration: at every control point the curvature
+ * steps, and the eye reads that step as a tick. The usual cure is a
+ * spring chasing the pose, which works and costs the two things a
+ * seekable engine cannot pay — it remembers the last frame, so a scrub
+ * lands somewhere a play would not, and it lags, so the camera is always
+ * behind the score by however much smoothing it was given.
+ *
+ * This is the same cure without either cost: the reported pose is a
+ * Hann-weighted average of the SAME spline sampled around the current
+ * progress. Averaging a curve is a low-pass filter, and a Hann window
+ * kills the acceleration steps outright, so the result is a hand rather
+ * than a mechanism. Being centred, it has no lag — it reads slightly
+ * ahead of the score exactly as much as it reads behind. Being an
+ * average of one pure function, it is still a pure function: play,
+ * scrub and frame-by-frame render all report the same pose.
+ *
+ * TWO EDGES IT MUST NOT CROSS. A cut is a step in the pose on purpose,
+ * and an average that straddled it would smear the cut into a very fast
+ * pan. The window is therefore TAPERED to the shot the progress is in:
+ * near either edge the kernel shrinks to the room it has, reaching zero
+ * at the edge itself. So a cut stays a cut, a path still lands exactly
+ * on its last waypoint, and the pose handed forward to the next cue is
+ * the waypoint rather than an average of one — the filter is an identity
+ * at every boundary and a smoother everywhere else.
+ *
+ * The taper is `tanh`, not a `min`, and the difference is the whole
+ * reason it works. A hard `min(width, 2 × room)` has a corner in it
+ * where the two branches meet, and a filter whose width has a corner
+ * puts one back into what it filters: measured against a path with two
+ * right-angle corners in it, the hard taper LOST ground as the window
+ * widened (worst jerk 8.7e-4 at a window of 0.175, 2.5e-3 at 0.3) while
+ * the smooth one held 8.0e-4 at every width against 4.2e-3 unfiltered.
+ * `tanh(x) ≤ x` everywhere, which is what keeps the taps inside the
+ * shot; it is smooth, which is what keeps the tick out.
+ *
+ * `width` is in progress, not seconds: the kinks being filtered are at
+ * the waypoints, which are spread uniformly across the clock, so a
+ * window measured against the clock is a window measured against the
+ * spacing of the things it exists to smooth. The caller converts.
+ */
+function settleThrough(from, through, progress, tension, width, taps = 15) {
+  const pts = resolveThrough(from, through);
+  const segs = pts.length - 1;
+  const s = Math.min(segs - 1e-9, Math.max(0, progress * segs));
+  const {
+    w0,
+    w1
+  } = shotAt(through, pts.length, segs, s);
+  const lo = w0 / segs;
+  const hi = w1 / segs;
+  const p = Math.min(hi, Math.max(lo, progress));
+  /* tapered: the kernel never reaches past the shot it is in */
+  const room = Math.min(p - lo, hi - p);
+  const w = width > 0 ? width * Math.tanh(2 * room / width) : 0;
+  if (!(w > 1e-6) || taps < 3) {
+    return sampleThrough(from, through, progress, tension);
+  }
+  const aimed = !!from.look || through.some(t => t.look);
+  let sum = 0;
+  let dolly = 0;
+  let pitch = 0;
+  let x = 0;
+  let y = 0;
+  let yaw = 0;
+  let lx = 0;
+  let ly = 0;
+  let lz = 0;
+  for (let i = 0; i < taps; i += 1) {
+    /* the tap fractions avoid 0 and 1, where a Hann window is zero and
+       the sample would be carried for nothing */
+    const f = (i + 1) / (taps + 1);
+    const weight = 0.5 - 0.5 * Math.cos(2 * Math.PI * f);
+    const at = p + (f - 0.5) * w;
+    const q = sampleThrough(from, through, at, tension);
+    sum += weight;
+    dolly += weight * q.dolly;
+    pitch += weight * q.pitch;
+    x += weight * q.x;
+    y += weight * q.y;
+    /* yaw is averaged as a NUMBER, not as an angle, because the spline
+       under it interpolates yaw as a number too — a score unwraps its
+       own turns (`Camera3DStep.through`) and the filter must agree with
+       the curve it is filtering rather than second-guess it */
+    yaw += weight * q.yaw;
+    if (aimed && q.look) {
+      lx += weight * q.look.x;
+      ly += weight * q.look.y;
+      lz += weight * q.look.z;
+    }
+  }
+  const out = {
+    dolly: dolly / sum,
+    pitch: pitch / sum,
+    x: x / sum,
+    y: y / sum,
+    yaw: yaw / sum
+  };
+  if (aimed) {
+    out.look = {
+      x: lx / sum,
+      y: ly / sum,
+      z: lz / sum
+    };
+  }
+  return out;
+}
+
+export { sampleThrough, settleThrough };
+//# sourceMappingURL=path.js.map

package/dist/path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.js","sources":["../src/path.ts"],"sourcesContent":["/**\n * THE CAMERA'S PATH — the arithmetic behind `c.Camera3D @through`, and\n * the only place in Choreo that owns a curve rather than a tween.\n *\n * Everything here is a pure function of PROGRESS. That is the whole\n * point: a seek must land the shot exactly where playing there would, so\n * nothing in this file may remember a previous frame. A spline that is\n * sampled rather than integrated can be scrubbed, rendered a frame at a\n * time, and played, and all three agree by construction.\n */\nimport type { Camera3DState, Camera3DWaypoint } from './types.ts';\n\n/**\n * One cardinal-spline component: Hermite through p1 and p2, tangents off\n * p0 and p3 scaled by `k = (1 - tension) / 2`. Tension 0 is the classic\n * Catmull-Rom — lively, and loose enough to overshoot between waypoints\n * that change direction; 1 collapses the tangents and the path goes\n * piecewise-linear. The default (0.5) is the steady hand: it still crosses\n * every waypoint with continuous velocity, but it does not sway on the way.\n */\nfunction crVal(\n  p0: number,\n  p1: number,\n  p2: number,\n  p3: number,\n  u: number,\n  k: number,\n) {\n  const m1 = k * (p2 - p0);\n  const m2 = k * (p3 - p1);\n  const u2 = u * u;\n  const u3 = u2 * u;\n  return (\n    (2 * u3 - 3 * u2 + 1) * p1 +\n    (u3 - 2 * u2 + u) * m1 +\n    (-2 * u3 + 3 * u2) * p2 +\n    (u3 - u2) * m2\n  );\n}\n\n/**\n * Resolve a `@through` path's control points: the pose in force first, then\n * each waypoint with its omissions carried forward. If ANY point carries a\n * look, every point gets one (the origin, when unstated), so the aim is\n * splined by the same arithmetic as the pose.\n */\nfunction resolveThrough(\n  from: Camera3DState,\n  through: Camera3DWaypoint[],\n): Camera3DState[] {\n  const aimed = !!from.look || through.some((w) => w.look);\n  const seed: Camera3DState = {\n    ...from,\n    look: aimed ? (from.look ?? { x: 0, y: 0, z: 0 }) : undefined,\n  };\n  const pts = [seed];\n  let prev = seed;\n  for (const w of through) {\n    const p: Camera3DState = {\n      dolly: w.dolly ?? prev.dolly,\n      look: aimed ? (w.look ?? prev.look) : undefined,\n      pitch: w.pitch ?? prev.pitch,\n      x: w.x ?? prev.x,\n      y: w.y ?? prev.y,\n      yaw: w.yaw ?? prev.yaw,\n    };\n    pts.push(p);\n    prev = p;\n  }\n  return pts;\n}\n\n/** the shot a slot position falls in — points [a, e), window [w0, w1) */\ninterface Shot {\n  /** first point of the shot */\n  a: number;\n  /** one past its last point */\n  e: number;\n  /** the shot's window, in slot units */\n  w0: number;\n  w1: number;\n}\n\n/**\n * WHICH SHOT A SLOT POSITION IS IN. A waypoint marked `cut` opens a new\n * one, and the two facts a caller needs about it are the points it may\n * reach for and the slice of the clock it owns — the second so that\n * nothing (a sample, a settle) ever reads across a seam.\n */\nfunction shotAt(\n  through: Camera3DWaypoint[],\n  points: number,\n  segs: number,\n  s: number,\n): Shot {\n  /* the seams, in point indices (+1: the seed sits at 0) */\n  let seams: number[] | undefined;\n  for (const [n, w] of through.entries()) {\n    if (w.cut) {\n      (seams ??= []).push(n + 1);\n    }\n  }\n  let a = 0;\n  let e = points;\n  let w0 = 0;\n  let w1 = segs;\n  if (seams) {\n    if (seams[0] === 1) {\n      /* a leading cut: the seed never plays */\n      a = 1;\n      seams = seams.slice(1);\n    }\n    for (const seam of seams) {\n      if (s < seam) {\n        e = seam;\n        w1 = seam;\n        break;\n      }\n      a = seam;\n      w0 = seam;\n    }\n  }\n  return { a, e, w0, w1 };\n}\n\n/**\n * Sample the spline at overall progress p ∈ [0, 1] (uniform segments).\n *\n * SPLICES (docs/choreo-splices.md): a waypoint marked `cut` starts a new\n * SHOT. Each shot is a clamped spline of its own points — endpoint\n * tangents one-sided, so no shot's velocity crosses a seam — and each\n * shot's window runs from its first slot to the next seam, its points\n * spread uniformly across it. The outgoing shot therefore plays through\n * the seam instant (its motion stretches by one slot rather than\n * parking), the incoming one begins exactly on it, and the sampled pose\n * is a step function at the seam. Waypoints keep their uniform slots, so\n * cues anchored to waypoint moments keep their clock. A cut on the first\n * waypoint drops the pose-in-force seed: the score opens inside its\n * first shot.\n */\nexport function sampleThrough(\n  from: Camera3DState,\n  through: Camera3DWaypoint[],\n  progress: number,\n  tension?: number,\n): Camera3DState {\n  const k = (1 - (tension ?? 0.5)) / 2;\n  const pts = resolveThrough(from, through);\n  const segs = pts.length - 1;\n  const s = Math.min(segs - 1e-9, Math.max(0, progress * segs));\n  const { a, e, w0, w1 } = shotAt(through, pts.length, segs, s);\n  const m = e - a;\n  const lam =\n    m === 1 ? 0 : Math.max(0, Math.min(1 - 1e-9, (s - w0) / (w1 - w0)));\n  const ss = lam * (m - 1);\n  const i = a + Math.floor(ss);\n  const u = m === 1 ? 0 : ss - Math.floor(ss);\n  /* clamped to the SHOT: the far side of a seam does not exist here */\n  const P = (j: number) => pts[Math.max(a, Math.min(e - 1, j))]!;\n  const p0 = P(i - 1);\n  const p1 = P(i);\n  const p2 = P(i + 1);\n  const p3 = P(i + 2);\n  const v = (key: 'dolly' | 'pitch' | 'x' | 'y' | 'yaw') =>\n    crVal(p0[key], p1[key], p2[key], p3[key], u, k);\n  const out: Camera3DState = {\n    dolly: v('dolly'),\n    pitch: v('pitch'),\n    x: v('x'),\n    y: v('y'),\n    yaw: v('yaw'),\n  };\n  if (p1.look && p2.look) {\n    const l = (a: 'x' | 'y' | 'z') =>\n      crVal(\n        (p0.look ?? p1.look)![a],\n        p1.look![a],\n        p2.look![a],\n        (p3.look ?? p2.look)![a],\n        u,\n        k,\n      );\n    out.look = { x: l('x'), y: l('y'), z: l('z') };\n  }\n  return out;\n}\n/**\n * A SETTLE — the operator's second hand, written as a function of time.\n *\n * A cardinal spline crosses its waypoints with continuous velocity but\n * not continuous acceleration: at every control point the curvature\n * steps, and the eye reads that step as a tick. The usual cure is a\n * spring chasing the pose, which works and costs the two things a\n * seekable engine cannot pay — it remembers the last frame, so a scrub\n * lands somewhere a play would not, and it lags, so the camera is always\n * behind the score by however much smoothing it was given.\n *\n * This is the same cure without either cost: the reported pose is a\n * Hann-weighted average of the SAME spline sampled around the current\n * progress. Averaging a curve is a low-pass filter, and a Hann window\n * kills the acceleration steps outright, so the result is a hand rather\n * than a mechanism. Being centred, it has no lag — it reads slightly\n * ahead of the score exactly as much as it reads behind. Being an\n * average of one pure function, it is still a pure function: play,\n * scrub and frame-by-frame render all report the same pose.\n *\n * TWO EDGES IT MUST NOT CROSS. A cut is a step in the pose on purpose,\n * and an average that straddled it would smear the cut into a very fast\n * pan. The window is therefore TAPERED to the shot the progress is in:\n * near either edge the kernel shrinks to the room it has, reaching zero\n * at the edge itself. So a cut stays a cut, a path still lands exactly\n * on its last waypoint, and the pose handed forward to the next cue is\n * the waypoint rather than an average of one — the filter is an identity\n * at every boundary and a smoother everywhere else.\n *\n * The taper is `tanh`, not a `min`, and the difference is the whole\n * reason it works. A hard `min(width, 2 × room)` has a corner in it\n * where the two branches meet, and a filter whose width has a corner\n * puts one back into what it filters: measured against a path with two\n * right-angle corners in it, the hard taper LOST ground as the window\n * widened (worst jerk 8.7e-4 at a window of 0.175, 2.5e-3 at 0.3) while\n * the smooth one held 8.0e-4 at every width against 4.2e-3 unfiltered.\n * `tanh(x) ≤ x` everywhere, which is what keeps the taps inside the\n * shot; it is smooth, which is what keeps the tick out.\n *\n * `width` is in progress, not seconds: the kinks being filtered are at\n * the waypoints, which are spread uniformly across the clock, so a\n * window measured against the clock is a window measured against the\n * spacing of the things it exists to smooth. The caller converts.\n */\nexport function settleThrough(\n  from: Camera3DState,\n  through: Camera3DWaypoint[],\n  progress: number,\n  tension: number | undefined,\n  width: number,\n  taps = 15,\n): Camera3DState {\n  const pts = resolveThrough(from, through);\n  const segs = pts.length - 1;\n  const s = Math.min(segs - 1e-9, Math.max(0, progress * segs));\n  const { w0, w1 } = shotAt(through, pts.length, segs, s);\n  const lo = w0 / segs;\n  const hi = w1 / segs;\n  const p = Math.min(hi, Math.max(lo, progress));\n  /* tapered: the kernel never reaches past the shot it is in */\n  const room = Math.min(p - lo, hi - p);\n  const w = width > 0 ? width * Math.tanh((2 * room) / width) : 0;\n  if (!(w > 1e-6) || taps < 3) {\n    return sampleThrough(from, through, progress, tension);\n  }\n  const aimed = !!from.look || through.some((t) => t.look);\n  let sum = 0;\n  let dolly = 0;\n  let pitch = 0;\n  let x = 0;\n  let y = 0;\n  let yaw = 0;\n  let lx = 0;\n  let ly = 0;\n  let lz = 0;\n  for (let i = 0; i < taps; i += 1) {\n    /* the tap fractions avoid 0 and 1, where a Hann window is zero and\n       the sample would be carried for nothing */\n    const f = (i + 1) / (taps + 1);\n    const weight = 0.5 - 0.5 * Math.cos(2 * Math.PI * f);\n    const at = p + (f - 0.5) * w;\n    const q = sampleThrough(from, through, at, tension);\n    sum += weight;\n    dolly += weight * q.dolly;\n    pitch += weight * q.pitch;\n    x += weight * q.x;\n    y += weight * q.y;\n    /* yaw is averaged as a NUMBER, not as an angle, because the spline\n       under it interpolates yaw as a number too — a score unwraps its\n       own turns (`Camera3DStep.through`) and the filter must agree with\n       the curve it is filtering rather than second-guess it */\n    yaw += weight * q.yaw;\n    if (aimed && q.look) {\n      lx += weight * q.look.x;\n      ly += weight * q.look.y;\n      lz += weight * q.look.z;\n    }\n  }\n  const out: Camera3DState = {\n    dolly: dolly / sum,\n    pitch: pitch / sum,\n    x: x / sum,\n    y: y / sum,\n    yaw: yaw / sum,\n  };\n  if (aimed) {\n    out.look = { x: lx / sum, y: ly / sum, z: lz / sum };\n  }\n  return out;\n}\n"],"names":["crVal","p0","p1","p2","p3","u","k","m1","m2","u2","u3","resolveThrough","from","through","aimed","look","some","w","seed","x","y","z","undefined","pts","prev","p","dolly","pitch","yaw","push","shotAt","points","segs","s","seams","n","entries","cut","a","e","w0","w1","slice","seam","sampleThrough","progress","tension","length","Math","min","max","m","lam","ss","i","floor","P","j","v","key","out","l","settleThrough","width","taps","lo","hi","room","tanh","t","sum","lx","ly","lz","f","weight","cos","PI","at","q"],"mappings":"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"}

package/dist/registry.js

@@ -0,0 +1,55 @@
+import { setParticipantHost } from 'glimmer-motion';
+
+/**
+ * A region is a participant host (glimmer-motion/participant): its root
+ * renders `data-motion-host` beside `data-choreo`, and registering a region
+ * here registers it as that element's participant host too, so the {{motion}}
+ * elements inside join it. The lookups below are Choreo's own, for code that
+ * already speaks in regions.
+ */
+
+// The `{{motion}}` args a region adds, typed here because the package's root
+// declarations re-export this module; measure.ts, which applies `pack`, is
+// reached only at runtime, so an augmentation there would not ship.
+
+/** anything that can put a node on a region's timeline — a step component, or a lane from outside */
+
+const hosts = new WeakMap();
+/** regions rendered with `@id`, so an attachment can name one without a DOM query per frame */
+const hostsById = new Map();
+function setChoreoHost(el, host) {
+  const id = el.getAttribute('data-choreo');
+  if (host) {
+    hosts.set(el, host);
+    setParticipantHost(el, host);
+    if (id) {
+      hostsById.set(id, host);
+    }
+  } else {
+    // a region re-keyed under the same id may already have registered its
+    // successor: only the entry that is THIS host's comes off
+    const mine = hosts.get(el);
+    hosts.delete(el);
+    setParticipantHost(el, undefined);
+    if (id && mine && hostsById.get(id) === mine) {
+      hostsById.delete(id);
+    }
+  }
+}
+function closestChoreo(el) {
+  const root = el.parentElement?.closest('[data-choreo]');
+  return root ? hosts.get(root) : undefined;
+}
+
+/** the host of a region element itself (not an ancestor's) */
+function choreoHostAt(el) {
+  return hosts.get(el);
+}
+
+/** the host of the region rendered with `@id` — a lane's way of naming the region it plays in */
+function choreoHostById(id) {
+  return hostsById.get(id);
+}
+
+export { choreoHostAt, choreoHostById, closestChoreo, setChoreoHost };
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sources":["../src/registry.ts"],"sourcesContent":["/**\n * A region is a participant host (glimmer-motion/participant): its root\n * renders `data-motion-host` beside `data-choreo`, and registering a region\n * here registers it as that element's participant host too, so the {{motion}}\n * elements inside join it. The lookups below are Choreo's own, for code that\n * already speaks in regions.\n */\nimport { type ParticipantHost, setParticipantHost } from 'glimmer-motion';\n\nimport type { ChoreoRun } from './run.ts';\nimport type { ChoreoNode, TimelineNode } from './types.ts';\n\n// The `{{motion}}` args a region adds, typed here because the package's root\n// declarations re-export this module; measure.ts, which applies `pack`, is\n// reached only at runtime, so an augmentation there would not ship.\ndeclare module 'glimmer-motion/participant' {\n  interface ParticipantArgs {\n    /**\n     * How Choreo measures this element for a shape-matched flight.\n     * `'box'` (default) is the layout border box — right for plates, cards,\n     * stages. `'content'` is the shrink-wrap (the ink): a full-bleed title\n     * still matches as a word. Written as `data-choreo-pack`; an explicit\n     * `[data-choreo-substance]` descendant still wins.\n     */\n    pack?: 'box' | 'content';\n  }\n}\n\n/** anything that can put a node on a region's timeline — a step component, or a lane from outside */\nexport interface ChoreoProvider {\n  node(): TimelineNode;\n}\n\nexport interface ChoreoHost extends ParticipantHost {\n  /** a destroyed participant asks whether the region still needs its element; true → the region unmounts it later */\n  claim(node: ChoreoNode): boolean;\n  /**\n   * SPIKE (Lane): a provider from OUTSIDE the region's markup — a parent's\n   * lane addressed at this region — whose node joins the tree the region\n   * collects on every pass, after its own steps. Returns the remover.\n   */\n  contribute(provider: ChoreoProvider): () => void;\n  /** the run the region is playing or holding, for an attachment to drive; null between runs */\n  currentRun(): ChoreoRun | null;\n  register(node: ChoreoNode): () => void;\n}\n\nconst hosts = new WeakMap<Element, ChoreoHost>();\n/** regions rendered with `@id`, so an attachment can name one without a DOM query per frame */\nconst hostsById = new Map<string, ChoreoHost>();\n\nexport function setChoreoHost(el: Element, host: ChoreoHost | undefined) {\n  const id = el.getAttribute('data-choreo');\n  if (host) {\n    hosts.set(el, host);\n    setParticipantHost(el, host);\n    if (id) {\n      hostsById.set(id, host);\n    }\n  } else {\n    // a region re-keyed under the same id may already have registered its\n    // successor: only the entry that is THIS host's comes off\n    const mine = hosts.get(el);\n    hosts.delete(el);\n    setParticipantHost(el, undefined);\n    if (id && mine && hostsById.get(id) === mine) {\n      hostsById.delete(id);\n    }\n  }\n}\n\nexport function closestChoreo(el: Element): ChoreoHost | undefined {\n  const root = el.parentElement?.closest('[data-choreo]');\n  return root ? hosts.get(root) : undefined;\n}\n\n/** the host of a region element itself (not an ancestor's) */\nexport function choreoHostAt(el: Element): ChoreoHost | undefined {\n  return hosts.get(el);\n}\n\n/** the host of the region rendered with `@id` — a lane's way of naming the region it plays in */\nexport function choreoHostById(id: string): ChoreoHost | undefined {\n  return hostsById.get(id);\n}\n"],"names":["hosts","WeakMap","hostsById","Map","setChoreoHost","el","host","id","getAttribute","set","setParticipantHost","mine","get","delete","undefined","closestChoreo","root","parentElement","closest","choreoHostAt","choreoHostById"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMA;AACA;AACA;;AAcA;;AAmBA,MAAMA,KAAK,GAAG,IAAIC,OAAO,EAAuB;AAChD;AACA,MAAMC,SAAS,GAAG,IAAIC,GAAG,EAAsB;AAExC,SAASC,aAAaA,CAACC,EAAW,EAAEC,IAA4B,EAAE;AACvE,EAAA,MAAMC,EAAE,GAAGF,EAAE,CAACG,YAAY,CAAC,aAAa,CAAC;AACzC,EAAA,IAAIF,IAAI,EAAE;AACRN,IAAAA,KAAK,CAACS,GAAG,CAACJ,EAAE,EAAEC,IAAI,CAAC;AACnBI,IAAAA,kBAAkB,CAACL,EAAE,EAAEC,IAAI,CAAC;AAC5B,IAAA,IAAIC,EAAE,EAAE;AACNL,MAAAA,SAAS,CAACO,GAAG,CAACF,EAAE,EAAED,IAAI,CAAC;AACzB,IAAA;AACF,EAAA,CAAC,MAAM;AACL;AACA;AACA,IAAA,MAAMK,IAAI,GAAGX,KAAK,CAACY,GAAG,CAACP,EAAE,CAAC;AAC1BL,IAAAA,KAAK,CAACa,MAAM,CAACR,EAAE,CAAC;AAChBK,IAAAA,kBAAkB,CAACL,EAAE,EAAES,SAAS,CAAC;AACjC,IAAA,IAAIP,EAAE,IAAII,IAAI,IAAIT,SAAS,CAACU,GAAG,CAACL,EAAE,CAAC,KAAKI,IAAI,EAAE;AAC5CT,MAAAA,SAAS,CAACW,MAAM,CAACN,EAAE,CAAC;AACtB,IAAA;AACF,EAAA;AACF;AAEO,SAASQ,aAAaA,CAACV,EAAW,EAA0B;EACjE,MAAMW,IAAI,GAAGX,EAAE,CAACY,aAAa,EAAEC,OAAO,CAAC,eAAe,CAAC;EACvD,OAAOF,IAAI,GAAGhB,KAAK,CAACY,GAAG,CAACI,IAAI,CAAC,GAAGF,SAAS;AAC3C;;AAEA;AACO,SAASK,YAAYA,CAACd,EAAW,EAA0B;AAChE,EAAA,OAAOL,KAAK,CAACY,GAAG,CAACP,EAAE,CAAC;AACtB;;AAEA;AACO,SAASe,cAAcA,CAACb,EAAU,EAA0B;AACjE,EAAA,OAAOL,SAAS,CAACU,GAAG,CAACL,EAAE,CAAC;AAC1B;;;;"}