@unoverse-platform/studio 0.1.26 → 0.1.28

package/vendor/sdk/lib/orb/engine/ribbon.ts

@@ -0,0 +1,93 @@
+// Ribbon: an undulating sash of parallel strands rides a great circle —
+// the "composing" state. The tuned preset freezes the 3D tumble
+// (spin 0), leaving the traveling undulation on a fixed band.
+//
+// The same painter also drives "breathing" (ring), via the `faceOn` flag:
+// a face-on circle whose radius — not its out-of-plane offset — undulates,
+// so it reads as a ring slowly morphing rather than a sash in orbit.
+
+import type { Dot, ModeDraw } from './types';
+import { fibDir, makeProj, paint, radiusScale } from './core';
+
+export const drawRibbon: ModeDraw = (ctx, size, t, dark, o) => {
+  const cx = size / 2;
+  const cy = size / 2;
+  const R = (size / 2) * 0.78;
+  // spin scales the 3D tumble; spin=0 freezes the band's orientation,
+  // leaving only the traveling undulation
+  const spin = o.spin ?? 1;
+  const camTilt = 0.3;
+  const pt = makeProj(t * 0.1 * spin, camTilt, cx, cy, 1);
+  const rs = radiusScale(size, o.rsPow ?? 0.6);
+
+  const dots: Dot[] = [];
+  const ghostN = o.ghostN ?? 150;
+  for (let i = 0; i < ghostN; i++) {
+    const d = fibDir(i, ghostN);
+    const [px, py, z] = pt(d[0] * R, d[1] * R, d[2] * R);
+    const depth = (z / R + 1) / 2;
+    dots.push({ x: px, y: py, z, r: 0.8 * rs, white: 0.78, a: 0.1 + 0.22 * depth });
+  }
+
+  // The band plane, precessing (frozen when spin=0). The projection squashes
+  // the band's great circle vertically by cos(ta + camTilt); face-on sets
+  // ta = -camTilt so that term is 1 and the band reads as a true circle
+  // rather than ribbon's tilted ellipse.
+  const ya = t * 0.24 * spin;
+  const ta = o.faceOn ? -camTilt : 0.55 + 0.3 * Math.sin(t * 0.18) * spin;
+  const ux = Math.cos(ya);
+  const uy = 0;
+  const uz = Math.sin(ya);
+  const vx = -uz * Math.sin(ta);
+  const vy = Math.cos(ta);
+  const vz = ux * Math.sin(ta);
+  // plane normal n = u × v
+  const nx = uy * vz - uz * vy;
+  const ny = uz * vx - ux * vz;
+  const nz = ux * vy - uy * vx;
+
+  // Radial lobes swell past R, so pull the base radius in by (most of) the
+  // wobble amplitude. The silhouette then stays inside the frame however far
+  // the deformation is pushed, while lobes keep getting deeper relative to
+  // the mean radius.
+  const wobAmp = 0.23 * (o.wobMul ?? 1);
+  const baseR = o.faceOn ? R / (1 + 0.85 * wobAmp) : R;
+
+  const baseLanes = o.lanes ?? 5;
+  const segs = o.segs ?? 88;
+  const lanes = Math.max(1, Math.round(baseLanes * (o.bandMul ?? 1)));
+  for (let w = 0; w < lanes; w++) {
+    const laneOff = (w - (lanes - 1) / 2) * 0.075;
+    const edge = Math.abs(w - (lanes - 1) / 2) / Math.max(1, (lanes - 1) / 2);
+    for (let k = 0; k < segs; k++) {
+      const a = (k / segs) * 2 * Math.PI;
+      // the undulation: two traveling waves along the band; wobMul
+      // scales the deformation — 0 is a clean band
+      const wob =
+        (0.16 * Math.sin(a * 3 - t * 1.7 + w * 0.22) + 0.07 * Math.sin(a * 5 + t * 1.1)) * (o.wobMul ?? 1);
+      // A normal-direction wobble is cancelled by the re-normalisation below:
+      // the point lands back on the sphere, so the silhouette is pinned at R
+      // and the deformation can only ever pull dots inward. Face-on instead
+      // modulates the in-plane RADIUS, so lobes genuinely swell outward and
+      // pinch inward. Ribbon keeps the original out-of-plane sash wobble.
+      const radial = o.faceOn ? 1 + wob : 1;
+      const off = o.faceOn ? laneOff : laneOff + wob;
+      const x = ux * Math.cos(a) + vx * Math.sin(a) + nx * off;
+      const y = uy * Math.cos(a) + vy * Math.sin(a) + ny * off;
+      const z = uz * Math.cos(a) + vz * Math.sin(a) + nz * off;
+      const l = Math.sqrt(x * x + y * y + z * z);
+      const rr = baseR * radial;
+      const [px, py, zr] = pt((x / l) * rr, (y / l) * rr, (z / l) * rr);
+      const depth = (zr / R + 1) / 2;
+      dots.push({
+        x: px,
+        y: py,
+        z: zr,
+        r: ((o.rBase ?? 1.1) + (o.rDepth ?? 1.7) * depth) * (1 - 0.25 * edge) * rs,
+        white: 0.52 - 0.44 * depth + 0.18 * edge,
+        a: 0.4 + 0.6 * depth
+      });
+    }
+  }
+  paint(ctx, dots, dark, o.rMin);
+};

package/vendor/sdk/lib/orb/engine/rings.ts

@@ -0,0 +1,239 @@
+/**
+ * RING MODES — a LOCAL Unoverse addition to the vendored thinking-orbs engine.
+ * Kept in its own file so an upstream update never conflicts with it.
+ *
+ * WHY THESE EXIST. Every vendored mode draws a full 3-D sphere, which is right when the
+ * orb IS the subject. Put a face in the middle and the sphere stops being the subject:
+ * you see the leftover rim of a globe fighting the portrait. These modes are ANNULAR BY
+ * CONSTRUCTION — every mark lives between `rIn` and `rOut`, so the centre is empty by
+ * design and the animation frames the face instead of colliding with it.
+ *
+ * THE MATERIAL IS LIGHT, NOT INK. An earlier version bent the engine's halftone language
+ * into a circle and produced a ring of beads: hard-edged, evenly spaced, mechanically
+ * distributed — a loading spinner, not a presence. The premium reference (Apple's
+ * Intelligence glow) is built by one technique: the same path stroked several times, each
+ * pass wider, blurrier and fainter than the last, so a crisp core sits inside a bloom of
+ * its own light. That is `glow()`. Everything else is which path, and how it moves.
+ *
+ * NOTHING MAY LOOK LIKE A SPINNER. A bright head chasing a tail around a circle is the
+ * single most dated shape in this space, so no mode owns a travelling OBJECT. Where a
+ * mode needs direction, the LIGHT moves through a still form (a conic gradient sweeping
+ * its luminance) rather than a mark moving along a path — the difference between a lamp
+ * behind a curtain and a torch on a track.
+ *
+ * House style otherwise: no perfect circles (radii warp under drifting low-frequency
+ * noise), no countable frequencies (rates are incommensurate, so patterns never repeat on
+ * a beat), and no pass at full strength — the ring reads as light around the subject,
+ * never as chrome on top of it.
+ *
+ * Blur is `shadowBlur`, deliberately: `ctx.filter` is unsupported in older Safari and the
+ * vendored engine avoids it on purpose, whereas a shadow at zero offset is a real blurred
+ * copy of the stroke and works everywhere the rest of this engine runs.
+ */
+import { inkCss, vnoise } from './core';
+import type { ModeDraw } from './types';
+import type { ModeOpts } from './profiles';
+
+const TAU = Math.PI * 2;
+
+/** The annulus a ring mode may draw in, plus a scale factor off the 200px reference. */
+function band(size: number, o: ModeOpts) {
+  const c = size / 2;
+  const R = size / 2;
+  // Defaults clear a face occupying ~0.56 of the box (avatar-orb's 112px in 200px) and
+  // its shadow; `rIn`/`rOut` retune the band for any other face ratio.
+  const rIn = R * (o.rIn ?? 0.62);
+  const rOut = R * (o.rOut ?? 0.97);
+  return { cx: c, cy: c, rIn, rOut, rMid: (rIn + rOut) / 2, span: (rOut - rIn) / 2, s: size / 200 };
+}
+
+type Band = ReturnType<typeof band>;
+/** How a pass paints at a given alpha — a flat ink, or a gradient that varies round the ring. */
+type PaintAt = (alpha: number) => string | CanvasGradient;
+
+/**
+ * THE GLOW. One path, stroked four times: a wide, heavily blurred, nearly transparent
+ * bloom first, then progressively tighter and stronger passes, ending on a thin crisp
+ * core. Painted in that order so the core lands on top of its own halo.
+ */
+function glow(
+  ctx: CanvasRenderingContext2D,
+  path: () => void,
+  w: number,
+  alpha: number,
+  paintAt: PaintAt,
+  shadowAt: (alpha: number) => string,
+): void {
+  const passes = [
+    { lw: w * 3.4, blur: 26, a: alpha * 0.14 },
+    { lw: w * 2.1, blur: 14, a: alpha * 0.26 },
+    { lw: w * 1.25, blur: 6, a: alpha * 0.5 },
+    { lw: w * 0.5, blur: 0, a: alpha },
+  ];
+  ctx.lineCap = 'round';
+  ctx.lineJoin = 'round';
+  for (const p of passes) {
+    if (p.a < 0.004) continue;
+    ctx.save();
+    ctx.beginPath();
+    path();
+    ctx.lineWidth = Math.max(0.4, p.lw);
+    ctx.strokeStyle = paintAt(p.a);
+    if (p.blur) {
+      ctx.shadowBlur = p.blur * (w / 3);
+      // a shadow takes a colour, never a gradient — so it uses the flat ink
+      ctx.shadowColor = shadowAt(p.a);
+    }
+    ctx.stroke();
+    ctx.restore();
+  }
+}
+
+/** Flat ink of a given depth — the ordinary case. */
+const flat = (white: number, dark: boolean): PaintAt => (a) => inkCss(white, dark, a);
+
+/**
+ * A conic gradient whose luminance peaks once and falls away round the ring, so the ring
+ * is brighter on one side without anything travelling along it. `at` rotates the peak.
+ * Falls back to flat ink where `createConicGradient` is unavailable (older Safari), which
+ * costs the directionality and nothing else.
+ */
+function sweepPaint(ctx: CanvasRenderingContext2D, b: Band, white: number, dark: boolean, at: number, floor = 0.14): PaintAt {
+  const make = (ctx as unknown as { createConicGradient?: (a: number, x: number, y: number) => CanvasGradient })
+    .createConicGradient;
+  if (typeof make !== 'function') return flat(white, dark);
+  return (alpha) => {
+    const g = make.call(ctx, at, b.cx, b.cy);
+    const STOPS = 16;
+    for (let i = 0; i <= STOPS; i++) {
+      const f = i / STOPS;
+      // cos² window: full at the peak, easing to `floor` on the far side, seamless at the wrap
+      const env = ((Math.cos(f * TAU) + 1) / 2) ** 2;
+      g.addColorStop(f, inkCss(white, dark, alpha * (floor + (1 - floor) * env)));
+    }
+    return g;
+  };
+}
+
+/** A closed curve through `pts`, smoothed with quadratics through the midpoints. */
+function closedCurve(ctx: CanvasRenderingContext2D, pts: Array<[number, number]>): void {
+  const n = pts.length;
+  const mx = (a: [number, number], b: [number, number]): [number, number] => [
+    (a[0] + b[0]) / 2,
+    (a[1] + b[1]) / 2,
+  ];
+  const start = mx(pts[n - 1], pts[0]);
+  ctx.moveTo(start[0], start[1]);
+  for (let i = 0; i < n; i++) {
+    const p = pts[i];
+    const m = mx(p, pts[(i + 1) % n]);
+    ctx.quadraticCurveTo(p[0], p[1], m[0], m[1]);
+  }
+  ctx.closePath();
+}
+
+/** Sample a warped ring: radius = rMid + span · f(angle). */
+function ringPts(b: Band, n: number, f: (a: number, i: number) => number): Array<[number, number]> {
+  const pts: Array<[number, number]> = [];
+  for (let i = 0; i < n; i++) {
+    const a = (i / n) * TAU;
+    const rr = b.rMid + b.span * f(a, i);
+    pts.push([b.cx + Math.cos(a) * rr, b.cy + Math.sin(a) * rr]);
+  }
+  return pts;
+}
+
+/**
+ * `halo` — a soft aura, breathing. Two slow lobes drift against each other under a
+ * noise wander, so the form is never a circle and never repeats on a countable beat.
+ * Nothing arrives, nothing leaves: for an assistant at rest.
+ */
+export const drawHalo: ModeDraw = (ctx, size, t, dark, o) => {
+  const b = band(size, o);
+  const breathe = 0.5 + 0.5 * Math.sin(t * 0.5);
+  const pts = ringPts(b, Math.round(o.samples ?? 88), (a, i) => {
+    const lobes = Math.sin(a * 2 + t * 0.33) * 0.34 + Math.sin(a * 3 - t * 0.21) * 0.22;
+    const wander = (vnoise(i * 0.05, t * 0.16) - 0.5) * 0.9;
+    return 0.3 * lobes + 0.22 * wander + 0.16 * (breathe - 0.5);
+  });
+  const white = o.white ?? 0.26;
+  glow(ctx, () => closedCurve(ctx, pts), (o.w ?? 3) * b.s, 0.34 + 0.2 * breathe, flat(white, dark), flat(white, dark) as (a: number) => string);
+};
+
+/**
+ * `sonar` / `pulse` — concentric rings of light, travelling INWARD (`dir: -1`) or
+ * OUTWARD (`dir: +1`). One painter, two meanings, because they are the same gesture
+ * mirrored: rings arriving are sound reaching a listener, rings leaving are a voice
+ * carrying. Each swells and settles over its life so none ever pops into existence.
+ */
+export const drawRipple: ModeDraw = (ctx, size, t, dark, o) => {
+  const b = band(size, o);
+  const waves = Math.round(o.waves ?? 2);
+  const rate = o.rate ?? 0.2;
+  const out = (o.dir ?? -1) > 0;
+  const white = o.white ?? 0.32;
+  const ink = flat(white, dark);
+  // a still, very faint seat where the rings are born (outward) or land (inward)
+  const seat = out ? b.rIn + b.span * 0.15 : b.rMid + b.span * 0.55;
+  glow(ctx, () => ctx.arc(b.cx, b.cy, seat, 0, TAU), (o.w ?? 2.4) * b.s, 0.07, ink, ink as (a: number) => string);
+  for (let w = 0; w < waves; w++) {
+    const f = (((t * rate + w / waves) % 1) + 1) % 1; // 0 → 1 over a wave's life
+    const rr = out ? b.rIn + (b.rOut - b.rIn) * f : b.rOut - (b.rOut - b.rIn) * f;
+    const fade = Math.sin(Math.PI * f) ** 1.3; // eases in AND out
+    if (fade < 0.02) continue;
+    const pts = ringPts(b, Math.round(o.samples ?? 72), (a) => (rr - b.rMid) / b.span + Math.sin(a * 2 - t * 0.3) * 0.1);
+    glow(ctx, () => closedCurve(ctx, pts), (o.w ?? 2.6) * b.s, (o.peak ?? 0.3) * fade, ink, ink as (a: number) => string);
+  }
+};
+
+/**
+ * `shimmer` — thinking. NOT a mark going round: the ring holds still (drifting only as
+ * every mode here drifts) and its LUMINANCE moves, two conic sweeps at incommensurate,
+ * counter-rotating rates passing through each other. Where they coincide the ring
+ * brightens for a moment and then the moment passes. Reads as something being considered,
+ * with no spinner anywhere in it.
+ */
+export const drawShimmer: ModeDraw = (ctx, size, t, dark, o) => {
+  const b = band(size, o);
+  const white = o.white ?? 0.2;
+  const ink = flat(white, dark) as (a: number) => string;
+  const rate = o.rate ?? 0.5;
+  const peak = o.peak ?? 0.46;
+  const samples = Math.round(o.samples ?? 84);
+  // THREE rings at different radii, each lit by its own sweep at its own rate. One ring
+  // varying in brightness is too quiet to read as activity; three at incommensurate rates
+  // drift through each other, so bright regions build and part without ever lining up
+  // twice the same way. Depth does the work a faster spin would otherwise be asked to do.
+  const layers = [
+    { seat: 0, rate: rate, alpha: 1, w: 1 },
+    { seat: -0.62, rate: -rate * 0.61, alpha: 0.62, w: 0.72 },
+    { seat: 0.6, rate: rate * 0.37, alpha: 0.52, w: 0.66 },
+  ];
+  for (const L of layers) {
+    const phase = t * L.rate;
+    const pts = ringPts(b, samples, (a, i) => {
+      // the ring SWELLS where its light is — luminance and form move together, which is
+      // what makes it read as one lit object rather than a texture over a circle
+      const lit = ((Math.cos(a - phase) + 1) / 2) ** 2;
+      const lobes = Math.sin(a * 2 + t * 0.19) * 0.26 + Math.sin(a * 3 - t * 0.13) * 0.16;
+      const wander = (vnoise(i * 0.05 + L.seat * 7, t * 0.1) - 0.5) * 0.6;
+      return L.seat * 0.42 + 0.2 * lobes + 0.16 * wander + 0.22 * lit;
+    });
+    glow(
+      ctx,
+      () => closedCurve(ctx, pts),
+      (o.w ?? 2.8) * b.s * L.w,
+      peak * L.alpha,
+      sweepPaint(ctx, b, white, dark, phase, 0.05),
+      ink,
+    );
+  }
+};
+
+/** Base profiles for the ring modes (same role as engine/profiles BASE_PROFILES). */
+export const RING_PROFILES: Record<string, ModeOpts> = {
+  halo: { samples: 88, w: 3, white: 0.26 },
+  sonar: { samples: 72, waves: 2, rate: 0.2, dir: -1, w: 2.6, white: 0.32, peak: 0.3 },
+  pulse: { samples: 72, waves: 3, rate: 0.26, dir: 1, w: 2.6, white: 0.3, peak: 0.34 },
+  shimmer: { samples: 84, rate: 0.5, w: 2.8, white: 0.2, peak: 0.46 },
+};

package/vendor/sdk/lib/orb/engine/types.ts

@@ -0,0 +1,14 @@
+// Engine-level contracts shared by every mode implementation.
+
+import type { ModeOpts } from './profiles';
+
+export type { Dot, Line } from './core';
+
+/** One frame painter: draws a mode into a 2D context at CSS-px `size`. */
+export type ModeDraw = (
+  ctx: CanvasRenderingContext2D,
+  size: number,
+  t: number,
+  dark: boolean,
+  opts: ModeOpts
+) => void;

package/vendor/sdk/lib/orb/engine/web.ts

@@ -0,0 +1,98 @@
+// Web: a constellation wires itself — the "connecting" state. Nodes drift
+// on the sphere under slow value noise; any pair closer than `thr` grows an
+// edge, and bright packets run along randomly re-picked node pairs.
+
+import type { Dot, Line, ModeDraw } from './types';
+import { fibDir, frac, hashD, lerp, makeProj, paint, paintLines, radiusScale, vnoise } from './core';
+
+export const drawWeb: ModeDraw = (ctx, size, t, dark, o) => {
+  const cx = size / 2;
+  const cy = size / 2;
+  const R = (size / 2) * 0.8 * (o.spread ?? 1);
+  // note the projector carries the radius as its scale, so node vectors stay
+  // unit-length and distances below are in unit-sphere space
+  const pt = makeProj(t * 0.12, 0.32, cx, cy, R);
+  const rs = radiusScale(size, o.rsPow ?? 0.6);
+
+  const nodeN = o.nodeN ?? 30;
+  const thr = o.thr ?? 0.72;
+  const nodeR = o.nodeR ?? 1.4;
+  const nodeRDepth = o.nodeRDepth ?? 1.8;
+
+  // nodes: fib lattice + slow noise wander, renormalised to the surface
+  const nodes: Array<[number, number, number]> = [];
+  for (let i = 0; i < nodeN; i++) {
+    const d = fibDir(i, nodeN);
+    const x = d[0] + 0.3 * (vnoise(i * 0.31 + 9, t * 0.24) - 0.5) * 2;
+    const y = d[1] + 0.3 * (vnoise(i * 0.53 + 27, t * 0.21) - 0.5) * 2;
+    const z = d[2] + 0.3 * (vnoise(i * 0.77 + 55, t * 0.27) - 0.5) * 2;
+    const l = Math.sqrt(x * x + y * y + z * z);
+    nodes.push([x / l, y / l, z / l]);
+  }
+
+  const lines: Line[] = [];
+  const dots: Dot[] = [];
+
+  // edges between close neighbours, alpha by proximity + depth
+  for (let i = 0; i < nodeN; i++) {
+    for (let j = i + 1; j < nodeN; j++) {
+      const dx = nodes[i][0] - nodes[j][0];
+      const dy = nodes[i][1] - nodes[j][1];
+      const dz = nodes[i][2] - nodes[j][2];
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (dist >= thr) continue;
+      const [x1, y1, z1] = pt(nodes[i][0], nodes[i][1], nodes[i][2]);
+      const [x2, y2, z2] = pt(nodes[j][0], nodes[j][1], nodes[j][2]);
+      const depth = ((z1 + z2) / 2 + 1) / 2;
+      lines.push({
+        x1,
+        y1,
+        x2,
+        y2,
+        white: 0.42,
+        a: (1 - dist / thr) * (0.3 + 0.55 * depth),
+        w: Math.max(0.6, (o.lineW ?? 0.8) * rs)
+      });
+    }
+  }
+
+  for (let i = 0; i < nodeN; i++) {
+    const [px, py, z] = pt(nodes[i][0], nodes[i][1], nodes[i][2]);
+    const depth = (z + 1) / 2;
+    const pulse = 1 + 0.25 * Math.sin(t * 1.4 + i * 2.7);
+    dots.push({
+      x: px,
+      y: py,
+      z,
+      r: (nodeR + nodeRDepth * depth) * pulse * rs,
+      white: 0.55 - 0.45 * depth
+    });
+  }
+
+  // signals: bright packets running between paired nodes
+  const signals = o.signals ?? 5;
+  for (let s = 0; s < signals; s++) {
+    const seg = Math.floor(t * 0.55 + s * 7.31);
+    const a = Math.floor(hashD(seg, s * 3.1 + 1.7) * nodeN);
+    const b = Math.floor(hashD(seg, s * 5.7 + 4.2) * nodeN);
+    if (a === b) continue;
+    const f = frac(t * 0.55 + s * 7.31);
+    const x = lerp(nodes[a][0], nodes[b][0], f);
+    const y = lerp(nodes[a][1], nodes[b][1], f);
+    const z = lerp(nodes[a][2], nodes[b][2], f);
+    const l = Math.max(1e-6, Math.sqrt(x * x + y * y + z * z));
+    const [px, py, zr] = pt(x / l, y / l, z / l);
+    const depth = (zr + 1) / 2;
+    dots.push({
+      x: px,
+      y: py,
+      z: zr,
+      r: (nodeR * 1.5 + nodeRDepth * depth) * rs,
+      white: 0.05,
+      a: 0.5 + 0.5 * depth
+    });
+  }
+
+  paintLines(ctx, lines, dark);
+  paint(ctx, dots, dark, o.rMin);
+};

package/vendor/sdk/lib/orb/index.ts

@@ -0,0 +1,20 @@
+/**
+ * The Orb primitive's drawing engine — VENDORED from `thinking-orbs`
+ * (https://github.com/Jakubantalik/thinking-orbs, MIT © 2026 Jakub Antalik),
+ * with two LOCAL EXTENSIONS, each marked at its site: free numeric `size`
+ * (tuning snaps to the nearest baked preset — ThinkingOrb.tsx) and a brand
+ * `ink` the painters tint toward, fed from the served `color` token
+ * (engine/core.ts setInk). Nine hand-tuned "assistant is doing something" animations,
+ * drawn procedurally on a plain 2D canvas — no WebGL, no filters — which is
+ * what makes the spec portable: each native SDK (iOS/Compose/Flutter/RN)
+ * reimplements the same draw loops with its platform's own 2D canvas.
+ *
+ * This is the sanctioned shape for rich motion (the SkeletonView precedent):
+ * the SDK owns ONE generic draw behavior; every authoring decision — which
+ * state, what size, what speed — stays DATA in the definition (`type: Orb`).
+ * Keyframe animations (styles/semantic/keyframes) remain the tool for
+ * element motion; the Orb is for pictures computed per-frame, which keyframe
+ * interpolation cannot express (no per-frame math, no depth occlusion).
+ */
+export { ThinkingOrb } from "./ThinkingOrb";
+export type { ThinkingOrbProps, OrbState, OrbSize, OrbTheme } from "./types";

package/vendor/sdk/lib/orb/presets.ts

@@ -0,0 +1,181 @@
+// The shipped tunings: nine states × two sizes, baked from the inkform
+// mini-page tuning session. `count`/`size` are multipliers over the base
+// fine profiles; `speed` multiplies the shared clock. Resolved once per
+// (state, size) pair and cached — the render loop sees plain numbers.
+
+import type { ModeOpts } from './engine/profiles';
+import { BASE_PROFILES, scaleCounts, scaleRadii } from './engine/profiles';
+import { RING_PROFILES } from './engine/rings';
+import type { OrbSize, OrbState } from './types';
+
+export type ModeKey =
+  | 'orbits'
+  | 'globe'
+  | 'rubik'
+  | 'wave'
+  | 'web'
+  | 'braid'
+  | 'ribbon'
+  | 'ring'
+  | 'morph'
+  // LOCAL (Unoverse): annular modes for framing a face — engine/rings.ts
+  | 'halo'
+  | 'sonar'
+  | 'shimmer'
+  | 'pulse';
+
+export const STATE_TO_MODE: Record<OrbState, ModeKey> = {
+  working: 'orbits',
+  searching: 'globe',
+  solving: 'rubik',
+  listening: 'wave',
+  connecting: 'web',
+  weaving: 'braid',
+  composing: 'ribbon',
+  breathing: 'ring',
+  shaping: 'morph',
+  // LOCAL (Unoverse): each annular state maps 1:1 to its own painter.
+  halo: 'halo',
+  sonar: 'sonar',
+  shimmer: 'shimmer',
+  pulse: 'pulse'
+};
+
+/**
+ * THE ENERGY STANDARD (local to Unoverse).
+ *
+ * `speed: 1` must mean ONE felt pace across the whole vocabulary, or a design decision
+ * taken against one state is wrong for the next — which is exactly what a shared knob on
+ * a design-system component promises. The unit is a VISUAL CYCLE: the time for a mode's
+ * dominant motion to come back round (a swell to travel, a wave to arrive, a head to lap).
+ *
+ * The annular modes are solved to it exactly (see their block below). The vendored sphere
+ * modes keep their author's relative tuning — hand-made per mode and better than anything
+ * re-derived blind — scaled by ONE factor, because that tuning was made for an orb that IS
+ * the subject at chat-avatar scale; behind a face, or beside content, it reads hot.
+ */
+const CYCLE_SECONDS = 4;
+/**
+ * A state that is DOING something earns more energy than one at rest — waiting and
+ * listening are receptive and should sit still; thinking and responding are work in
+ * progress and read as stalled at the resting pace. Same standard, shorter cycle.
+ */
+const ACTIVE_CYCLE = 2.5;
+const SPHERE_CALM = 0.45;
+
+/**
+ * Solve a mode's baked speed from its OWN dominant rate, so one cycle lands on the
+ * standard. `turns` is what the rate is measured against — a full revolution for motion
+ * around the ring, or 1 for a mode whose rate is already "lives per unit t" (sonar).
+ * Retuning a rate constant in engine/rings only means updating the number passed here.
+ */
+const solve = (ratePerT: number, turns = 2 * Math.PI, cycle = CYCLE_SECONDS) => turns / (ratePerT * cycle);
+/** Inline scale reads a touch quicker — a small mark needs more motion to register. */
+const SMALL = 1.2;
+
+interface Preset {
+  speed: number;
+  count: number;
+  size: number;
+  /** Extra mode opts merged verbatim after scaling. */
+  extra?: ModeOpts;
+}
+
+const PRESETS: Record<ModeKey, Record<OrbSize, Preset>> = {
+  orbits: {
+    64: { speed: 1.885, count: 1, size: 1 },
+    20: { speed: 3.9, count: 0.238, size: 2.4 }
+  },
+  globe: {
+    64: { speed: 2.015, count: 0.42, size: 1.15, extra: { scanMul: 4.08, dimBase: 0.45 } },
+    20: { speed: 2.665, count: 0.105, size: 1.75, extra: { scanMul: 4.335, dimBase: 0.45 } }
+  },
+  rubik: {
+    64: { speed: 1.82, count: 0.35, size: 1.05 },
+    20: { speed: 1.95, count: 0.088, size: 1.9 }
+  },
+  wave: {
+    64: { speed: 4.388, count: 0.341, size: 1 },
+    20: { speed: 3.998, count: 0.105, size: 1.6 }
+  },
+  web: {
+    64: { speed: 3.315, count: 1.35, size: 0.95 },
+    20: { speed: 6.63, count: 0.25, size: 1.52 }
+  },
+  braid: {
+    64: { speed: 1.625, count: 0.5, size: 1 },
+    20: { speed: 2.75, count: 0.1125, size: 1.36 }
+  },
+  ribbon: {
+    64: { speed: 2.34, count: 0.25, size: 0.85, extra: { spin: 0, bandMul: 3.9, wobMul: 1 } },
+    20: { speed: 3.12, count: 0.051, size: 1.073, extra: { spin: 0, bandMul: 4.94, wobMul: 1 } }
+  },
+  ring: {
+    64: { speed: 3.24, count: 0.25, size: 0.956, extra: { spin: 0, bandMul: 3.627, wobMul: 0.368 } },
+    20: { speed: 3.78, count: 0.028, size: 1.622, extra: { spin: 0, bandMul: 3.968, wobMul: 0.565 } }
+  },
+  morph: {
+    64: { speed: 2.405, count: 0.702, size: 0.395, extra: { spread: 1.45 } },
+    20: { speed: 2.08, count: 0.53, size: 1.011, extra: { spread: 1.45 } }
+  },
+  // LOCAL (Unoverse): the annular set, tuned to THE STANDARD above rather than by eye.
+  // Each speed is solved, not guessed, from that mode's own dominant rate so one visual
+  // cycle lands on CYCLE_SECONDS: halo breathes at 0.5, a sonar wave lives 1/0.2, a
+  // shimmer sweep laps at 0.5, a pulse wave lives 1/0.26. Change a rate constant in
+  // engine/rings and the only edit here is the number handed to solve(). Resting states
+  // (halo, sonar) use CYCLE_SECONDS; working ones (shimmer, pulse) use ACTIVE_CYCLE.
+  // At inline scale the band is a few px wide, so samples drop and strokes thin.
+  // `count`/`size` stay 1: scaleCounts/scaleRadii only know the vendored modes' key
+  // names, so a multiplier would silently do nothing to a ring mode's samples/w.
+  halo: {
+    64: { speed: solve(0.5), count: 1, size: 1 },
+    20: { speed: solve(0.5) * SMALL, count: 1, size: 1, extra: { rIn: 0.5, rOut: 0.98, samples: 56, w: 2.2 } }
+  },
+  sonar: {
+    // rate is "lives per unit t", not an angle — so it solves against 1 turn, not 2π
+    64: { speed: solve(0.2, 1), count: 1, size: 1 },
+    20: { speed: solve(0.2, 1) * SMALL, count: 1, size: 1, extra: { rIn: 0.44, rOut: 0.98, samples: 48, waves: 2, w: 2 } }
+  },
+  shimmer: {
+    64: { speed: solve(0.5, 2 * Math.PI, ACTIVE_CYCLE), count: 1, size: 1 },
+    20: {
+      speed: solve(0.5, 2 * Math.PI, ACTIVE_CYCLE) * SMALL,
+      count: 1,
+      size: 1,
+      extra: { rIn: 0.5, rOut: 0.98, samples: 56, w: 2.2 }
+    }
+  },
+  pulse: {
+    64: { speed: solve(0.26, 1, ACTIVE_CYCLE), count: 1, size: 1 },
+    20: { speed: solve(0.26, 1, ACTIVE_CYCLE) * SMALL, count: 1, size: 1, extra: { rIn: 0.44, rOut: 0.98, samples: 48, waves: 2, w: 2 } }
+  }
+};
+
+export interface Resolved {
+  mode: ModeKey;
+  speed: number;
+  opts: ModeOpts;
+}
+
+const cache = new Map<string, Resolved>();
+
+/** Resolve a (state, size) pair to its mode + fully-scaled draw options. */
+export function resolvePreset(state: OrbState, size: OrbSize): Resolved {
+  const key = `${state}-${size}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
+
+  const mode = STATE_TO_MODE[state];
+  const preset = PRESETS[mode][size];
+  let opts: ModeOpts = { ...(BASE_PROFILES[mode] ?? RING_PROFILES[mode]) };
+  if (preset.count !== 1) opts = scaleCounts(opts, preset.count);
+  if (preset.size !== 1) opts = scaleRadii(opts, preset.size);
+  if (preset.extra) opts = { ...opts, ...preset.extra };
+
+  // The sphere set is pulled into the ring set's energy band; the ring set is already
+  // solved to it, so it passes through untouched (see THE ENERGY STANDARD).
+  const speed = preset.speed * (RING_PROFILES[mode] ? 1 : SPHERE_CALM);
+  const resolved: Resolved = { mode, speed, opts };
+  cache.set(key, resolved);
+  return resolved;
+}