@sdata/web-vue 3.26.0 → 3.28.0

package/es/thinking-orb/engine/core.js

@@ -0,0 +1,104 @@
+//#region components/thinking-orb/engine/core.ts
+function lerp(a, b, f) {
+	return a + (b - a) * f;
+}
+function frac(x) {
+	return x - Math.floor(x);
+}
+/** Value noise on a 2D lattice — smooth, deterministic, cheap. */
+function vnoise(x, y) {
+	const xi = Math.floor(x);
+	const yi = Math.floor(y);
+	let fx = x - xi;
+	let fy = y - yi;
+	fx = fx * fx * (3 - 2 * fx);
+	fy = fy * fy * (3 - 2 * fy);
+	const a = hashD(xi, yi);
+	const b = hashD(xi + 1, yi);
+	const c = hashD(xi, yi + 1);
+	const d = hashD(xi + 1, yi + 1);
+	return a + (b - a) * fx + (c - a) * fy + (a - b - c + d) * fx * fy;
+}
+/** Deterministic hash in [0, 1). */
+function hashD(a, b) {
+	const h = Math.sin(a * 12.9898 + b * 78.233) * 43758.5453;
+	return h - Math.floor(h);
+}
+/** Stable directions on a unit sphere (Fibonacci lattice). */
+function fibDir(i, n) {
+	const golden = Math.PI * (3 - Math.sqrt(5));
+	const y = 1 - 2 * (i + .5) / n;
+	const rad = Math.sqrt(1 - y * y);
+	const a = i * golden;
+	return [
+		rad * Math.cos(a),
+		y,
+		rad * Math.sin(a)
+	];
+}
+/** Shortest signed angular distance, wrapped to (-π, π]. */
+function angleDelta(a, b) {
+	return Math.atan2(Math.sin(a - b), Math.cos(a - b));
+}
+/** Shared spin + tilt + orthographic projection. */
+function makeProj(yaw, tilt, cx, cy, scale) {
+	const st = Math.sin(tilt);
+	const ct = Math.cos(tilt);
+	const sy = Math.sin(yaw);
+	const cyw = Math.cos(yaw);
+	return (x, y, z) => {
+		const x1 = x * cyw + z * sy;
+		const z1 = -x * sy + z * cyw;
+		const y1 = y * ct - z1 * st;
+		const z2 = y * st + z1 * ct;
+		return [
+			cx + x1 * scale,
+			cy - y1 * scale,
+			z2
+		];
+	};
+}
+/**
+* Painter: z-sort far→near, matte grayscale dots. On dark substrates the
+* ink value is mirrored (1 - white) so near dots read bright — the same
+* depth language on an inverted substrate.
+*/
+function paint(ctx, dots, dark, rMin = .3) {
+	dots.sort((a, b) => a.z - b.z);
+	for (const d of dots) {
+		var _d$a;
+		const alpha = (_d$a = d.a) !== null && _d$a !== void 0 ? _d$a : 1;
+		if (alpha < .02) continue;
+		const w = Math.min(1, Math.max(0, d.white));
+		const g = Math.round((dark ? 1 - w : w) * 255);
+		ctx.fillStyle = `rgba(${g},${g},${g},${alpha})`;
+		ctx.beginPath();
+		ctx.arc(d.x, d.y, Math.max(rMin, d.r), 0, Math.PI * 2);
+		ctx.fill();
+	}
+}
+/** Stroke pass for edge-based modes. Runs before `paint` so nodes sit on top. */
+function paintLines(ctx, lines, dark) {
+	for (const l of lines) {
+		var _l$a;
+		const alpha = (_l$a = l.a) !== null && _l$a !== void 0 ? _l$a : 1;
+		if (alpha < .02) continue;
+		const w = Math.min(1, Math.max(0, l.white));
+		const g = Math.round((dark ? 1 - w : w) * 255);
+		ctx.strokeStyle = `rgba(${g},${g},${g},${alpha})`;
+		ctx.lineWidth = l.w;
+		ctx.beginPath();
+		ctx.moveTo(l.x1, l.y1);
+		ctx.lineTo(l.x2, l.y2);
+		ctx.stroke();
+	}
+}
+/**
+* Dot radii were tuned for a 300pt frame; sub-linear scaling keeps small
+* spinners legible. Lower pow = radii shrink less with size.
+*/
+function radiusScale(size, pow) {
+	return Math.pow(size / 300, pow);
+}
+//#endregion
+export { angleDelta, fibDir, frac, hashD, lerp, makeProj, paint, paintLines, radiusScale, vnoise };

package/es/thinking-orb/engine/lattice.d.ts

@@ -0,0 +1,4 @@
+import type { ModeDraw } from './types';
+export declare const drawGlobe: ModeDraw;
+export declare const drawRubik: ModeDraw;
+export declare const drawWave: ModeDraw;

package/es/thinking-orb/engine/lattice.js

@@ -0,0 +1,188 @@
+import { angleDelta, hashD, makeProj, paint, radiusScale } from "./core.js";
+//#region components/thinking-orb/engine/lattice.ts
+function solveCycle(time, count, slotDur, rest) {
+	const tc = time % (2 * count * slotDur + rest);
+	const amount = Array(count).fill(0);
+	let active = -1;
+	if (tc < 2 * count * slotDur) {
+		const slot = Math.floor(tc / slotDur);
+		const p = (tc - slot * slotDur) / slotDur;
+		const cl = Math.min(1, p / .7);
+		const ep = 1 - Math.pow(1 - cl, 3);
+		if (slot < count) {
+			for (let i = 0; i < slot; i++) amount[i] = 1;
+			amount[slot] = ep;
+			active = slot;
+		} else {
+			const u = 2 * count - 1 - slot;
+			for (let i = 0; i < u; i++) amount[i] = 1;
+			amount[u] = 1 - ep;
+			active = u;
+		}
+	}
+	return {
+		amount,
+		active
+	};
+}
+function applyMoves(pt3, moves, sc) {
+	let [x, y, z] = pt3;
+	let inActive = false;
+	for (let i = 0; i < moves.length; i++) {
+		if (sc.amount[i] <= 0) continue;
+		const mv = moves[i];
+		const coord = mv.axis === 0 ? x : mv.axis === 1 ? y : z;
+		if (coord < mv.lo || coord >= mv.hi) continue;
+		if (i === sc.active) inActive = true;
+		const a = mv.ang * sc.amount[i];
+		const ca = Math.cos(a);
+		const sa = Math.sin(a);
+		if (mv.axis === 0) {
+			const y2 = y * ca - z * sa;
+			z = y * sa + z * ca;
+			y = y2;
+		} else if (mv.axis === 1) {
+			const x2 = x * ca + z * sa;
+			z = -x * sa + z * ca;
+			x = x2;
+		} else {
+			const x2 = x * ca - y * sa;
+			y = x * sa + y * ca;
+			x = x2;
+		}
+	}
+	return [
+		x,
+		y,
+		z,
+		inActive
+	];
+}
+function makeMoves(count) {
+	const moves = [];
+	for (let i = 0; i < count; i++) {
+		const axis = Math.min(2, Math.floor(hashD(i, 2.3) * 3));
+		const lo = -1 + .5 * Math.min(3, Math.floor(hashD(i, 5.9) * 4));
+		const dir = hashD(i, 7.7) < .5 ? 1 : -1;
+		moves.push({
+			axis,
+			lo,
+			hi: lo + .5,
+			ang: dir * Math.PI / 2
+		});
+	}
+	return moves;
+}
+var drawGlobe = (ctx, size, t, dark, o) => {
+	var _o$scanMul, _o$rsPow, _o$dimBase, _o$latRings, _o$lonDensity;
+	const spin = .5;
+	const cx = size / 2;
+	const cy = size / 2;
+	const radius = size / 2 * .82;
+	const tilt = .4 + .06 * Math.sin(t * .35);
+	const pt = makeProj(t * spin, tilt, cx, cy, radius);
+	const scan = t * (spin + (1.7 - spin) * ((_o$scanMul = o.scanMul) !== null && _o$scanMul !== void 0 ? _o$scanMul : 1));
+	const rs = radiusScale(size, (_o$rsPow = o.rsPow) !== null && _o$rsPow !== void 0 ? _o$rsPow : .6);
+	const dimBase = (_o$dimBase = o.dimBase) !== null && _o$dimBase !== void 0 ? _o$dimBase : 1;
+	const dots = [];
+	const latRings = (_o$latRings = o.latRings) !== null && _o$latRings !== void 0 ? _o$latRings : 17;
+	const lonDensity = (_o$lonDensity = o.lonDensity) !== null && _o$lonDensity !== void 0 ? _o$lonDensity : 44;
+	for (let li = 0; li <= latRings; li++) {
+		const lat = -Math.PI / 2 + li / latRings * Math.PI;
+		const cosLat = Math.cos(lat);
+		const sinLat = Math.sin(lat);
+		const lonCount = Math.max(1, Math.round(Math.abs(cosLat) * lonDensity));
+		for (let lj = 0; lj < lonCount; lj++) {
+			var _o$rBase, _o$rDepth, _o$rBoost, _o$inkFar, _o$inkSpan;
+			const lon = lj / lonCount * 2 * Math.PI;
+			const [px, py, z] = pt(cosLat * Math.cos(lon), sinLat, cosLat * Math.sin(lon));
+			const depth = (z + 1) / 2;
+			const d = angleDelta(lon + t * spin, scan);
+			const boost = Math.exp(-(d * d) / .18) * Math.max(0, z);
+			dots.push({
+				x: px,
+				y: py,
+				z,
+				r: (((_o$rBase = o.rBase) !== null && _o$rBase !== void 0 ? _o$rBase : .6) + ((_o$rDepth = o.rDepth) !== null && _o$rDepth !== void 0 ? _o$rDepth : 1.7) * depth + ((_o$rBoost = o.rBoost) !== null && _o$rBoost !== void 0 ? _o$rBoost : 1) * boost) * rs,
+				white: ((_o$inkFar = o.inkFar) !== null && _o$inkFar !== void 0 ? _o$inkFar : .62) - ((_o$inkSpan = o.inkSpan) !== null && _o$inkSpan !== void 0 ? _o$inkSpan : .54) * depth,
+				a: dimBase + (1 - dimBase) * Math.min(1, boost)
+			});
+		}
+	}
+	paint(ctx, dots, dark, o.rMin);
+};
+var drawRubik = (ctx, size, t, dark, o) => {
+	var _o$rsPow2, _o$moveCount, _o$latRings2, _o$lonDensity2;
+	const cx = size / 2;
+	const cy = size / 2;
+	const R = size / 2 * .82;
+	const pt = makeProj(t * .55, .35 + .1 * Math.sin(t * .9), cx, cy, R);
+	const rs = radiusScale(size, (_o$rsPow2 = o.rsPow) !== null && _o$rsPow2 !== void 0 ? _o$rsPow2 : .6);
+	const moveCount = (_o$moveCount = o.moveCount) !== null && _o$moveCount !== void 0 ? _o$moveCount : 14;
+	const moves = makeMoves(moveCount);
+	const sc = solveCycle(t, moveCount, .42, 1.2);
+	const dots = [];
+	const latRings = (_o$latRings2 = o.latRings) !== null && _o$latRings2 !== void 0 ? _o$latRings2 : 15;
+	const lonDensity = (_o$lonDensity2 = o.lonDensity) !== null && _o$lonDensity2 !== void 0 ? _o$lonDensity2 : 40;
+	for (let li = 0; li <= latRings; li++) {
+		const lat = -Math.PI / 2 + li / latRings * Math.PI;
+		const cosLat = Math.cos(lat);
+		const sinLat = Math.sin(lat);
+		const lonCount = Math.max(1, Math.round(Math.abs(cosLat) * lonDensity));
+		for (let lj = 0; lj < lonCount; lj++) {
+			var _o$rBase2, _o$rDepth2, _o$rActive, _o$inkFar2, _o$inkSpan2;
+			const lon = lj / lonCount * 2 * Math.PI;
+			const [x, y, z, inActive] = applyMoves([
+				cosLat * Math.cos(lon),
+				sinLat,
+				cosLat * Math.sin(lon)
+			], moves, sc);
+			const [px, py, zr] = pt(x, y, z);
+			const depth = (zr + 1) / 2;
+			dots.push({
+				x: px,
+				y: py,
+				z: zr,
+				r: (((_o$rBase2 = o.rBase) !== null && _o$rBase2 !== void 0 ? _o$rBase2 : .6) + ((_o$rDepth2 = o.rDepth) !== null && _o$rDepth2 !== void 0 ? _o$rDepth2 : 1.7) * depth + (inActive ? (_o$rActive = o.rActive) !== null && _o$rActive !== void 0 ? _o$rActive : .3 : 0)) * rs,
+				white: ((_o$inkFar2 = o.inkFar) !== null && _o$inkFar2 !== void 0 ? _o$inkFar2 : .62) - ((_o$inkSpan2 = o.inkSpan) !== null && _o$inkSpan2 !== void 0 ? _o$inkSpan2 : .54) * depth - (inActive ? .14 : 0)
+			});
+		}
+	}
+	paint(ctx, dots, dark, o.rMin);
+};
+var drawWave = (ctx, size, t, dark, o) => {
+	var _o$rsPow3, _o$rings, _o$lonDensity3;
+	const cx = size / 2;
+	const cy = size / 2;
+	const R = size / 2 * .874;
+	const pt = makeProj(t * .18, .38, cx, cy, 1);
+	const rs = radiusScale(size, (_o$rsPow3 = o.rsPow) !== null && _o$rsPow3 !== void 0 ? _o$rsPow3 : .6);
+	const dots = [];
+	const rings = (_o$rings = o.rings) !== null && _o$rings !== void 0 ? _o$rings : 15;
+	const lonDensity = (_o$lonDensity3 = o.lonDensity) !== null && _o$lonDensity3 !== void 0 ? _o$lonDensity3 : 40;
+	for (let ri = 0; ri <= rings; ri++) {
+		const lat = -Math.PI / 2 + ri / rings * Math.PI;
+		const cosLat = Math.cos(lat);
+		const sinLat = Math.sin(lat);
+		const w = .62 * Math.sin(t * 2.1 - ri * .52) + .38 * Math.sin(t * 1.27 + ri * .83);
+		const rr = R * (.88 + .105 * w);
+		const lonCount = Math.max(1, Math.round(Math.abs(cosLat) * lonDensity));
+		for (let lj = 0; lj < lonCount; lj++) {
+			var _o$rBase3, _o$rDepth3;
+			const lon = lj / lonCount * 2 * Math.PI;
+			const [px, py, z] = pt(cosLat * Math.cos(lon) * rr, sinLat * rr, cosLat * Math.sin(lon) * rr);
+			const depth = (z / R + 1) / 2;
+			const crest = Math.max(0, w);
+			dots.push({
+				x: px,
+				y: py,
+				z,
+				r: (((_o$rBase3 = o.rBase) !== null && _o$rBase3 !== void 0 ? _o$rBase3 : .6) + ((_o$rDepth3 = o.rDepth) !== null && _o$rDepth3 !== void 0 ? _o$rDepth3 : 1.7) * depth) * (1 + .4 * crest) * rs,
+				white: .66 - .56 * depth - .1 * crest
+			});
+		}
+	}
+	paint(ctx, dots, dark, o.rMin);
+};
+//#endregion
+export { drawGlobe, drawRubik, drawWave };

package/es/thinking-orb/engine/morph.d.ts

@@ -0,0 +1,2 @@
+import type { ModeDraw } from './types';
+export declare const drawMorph: ModeDraw;

package/es/thinking-orb/engine/morph.js

@@ -0,0 +1,111 @@
+import { paint } from "./core.js";
+//#region components/thinking-orb/engine/morph.ts
+function smoothE(x) {
+	return x * x * (3 - 2 * x);
+}
+function polyPath(verts) {
+	const V = verts.length;
+	const L = [];
+	let total = 0;
+	for (let i = 0; i < V; i++) {
+		const a = verts[i];
+		const b = verts[(i + 1) % V];
+		const l = Math.hypot(b[0] - a[0], b[1] - a[1]);
+		L.push(l);
+		total += l;
+	}
+	return (f) => {
+		let target = f * total;
+		let i = 0;
+		while (target > L[i] && i < V - 1) {
+			target -= L[i];
+			i++;
+		}
+		const a = verts[i];
+		const b = verts[(i + 1) % V];
+		const ff = L[i] ? Math.min(1, target / L[i]) : 0;
+		return [a[0] + (b[0] - a[0]) * ff, a[1] + (b[1] - a[1]) * ff];
+	};
+}
+var CIRCLE = (f) => {
+	const a = -Math.PI / 2 + f * 2 * Math.PI;
+	return [Math.cos(a) * .24, Math.sin(a) * .24];
+};
+var CYCLE = [
+	CIRCLE,
+	polyPath([
+		[0, -.26],
+		[.24, .16],
+		[-.24, .16]
+	]),
+	polyPath([
+		[0, -.2],
+		[.2, -.2],
+		[.2, .2],
+		[-.2, .2],
+		[-.2, -.2]
+	])
+];
+function morphN(d) {
+	return Math.max(6, Math.round(34 * d));
+}
+var HOLD = 1.4;
+var MORPH = .9;
+var SEG = 2.3;
+var drawMorph = (ctx, size, t, dark, o) => {
+	var _o$spread, _o$iconD, _o$rDot;
+	const K = CYCLE.length;
+	const tc = t % (SEG * K);
+	const k = Math.floor(tc / SEG);
+	const local = tc - k * SEG;
+	const m = local > HOLD ? smoothE((local - HOLD) / MORPH) : 0;
+	const sprd = (_o$spread = o.spread) !== null && _o$spread !== void 0 ? _o$spread : 1;
+	const pA = CYCLE[k];
+	const pB = CYCLE[(k + 1) % K];
+	const M = 160;
+	const pts = [];
+	for (let i = 0; i < M; i++) {
+		const f = i / M;
+		const a = pA(f);
+		const b = pB(f);
+		pts.push([(a[0] + (b[0] - a[0]) * m) * sprd, (a[1] + (b[1] - a[1]) * m) * sprd]);
+	}
+	const L = [];
+	let total = 0;
+	for (let i = 0; i < M; i++) {
+		const a = pts[i];
+		const b = pts[(i + 1) % M];
+		const l = Math.hypot(b[0] - a[0], b[1] - a[1]);
+		L.push(l);
+		total += l;
+	}
+	const n = morphN((_o$iconD = o.iconD) !== null && _o$iconD !== void 0 ? _o$iconD : 1);
+	const re = ((_o$rDot = o.rDot) !== null && _o$rDot !== void 0 ? _o$rDot : .021) * 1.35 * sprd;
+	const pulse = 1 + .02 * Math.sin(local * 3.1);
+	const dots = [];
+	const c2 = size / 2;
+	let seg = 0;
+	let acc = 0;
+	for (let k2 = 0; k2 < n; k2++) {
+		const target = k2 / n * total;
+		while (acc + L[seg] < target && seg < M - 1) {
+			acc += L[seg];
+			seg++;
+		}
+		const a = pts[seg];
+		const b = pts[(seg + 1) % M];
+		const f = L[seg] ? Math.min(1, (target - acc) / L[seg]) : 0;
+		const x = (a[0] + (b[0] - a[0]) * f) * pulse;
+		const y = (a[1] + (b[1] - a[1]) * f) * pulse;
+		dots.push({
+			x: c2 + x * size,
+			y: c2 + y * size,
+			z: 0,
+			r: Math.max(.35, re * size),
+			white: .1
+		});
+	}
+	paint(ctx, dots, dark, o.rMin);
+};
+//#endregion
+export { drawMorph };

package/es/thinking-orb/engine/orbits.d.ts

@@ -0,0 +1,2 @@
+import type { ModeDraw } from './types';
+export declare const drawOrbits: ModeDraw;

package/es/thinking-orb/engine/orbits.js

@@ -0,0 +1,65 @@
+import { hashD, makeProj, paint, radiusScale } from "./core.js";
+//#region components/thinking-orb/engine/orbits.ts
+var drawOrbits = (ctx, size, t, dark, o) => {
+	var _o$rsPow, _o$orbitN, _o$ghostN, _o$particles;
+	const cx = size / 2;
+	const cy = size / 2;
+	const R = size / 2 * .82;
+	const pt = makeProj(t * .12, .3, cx, cy, 1);
+	const rs = radiusScale(size, (_o$rsPow = o.rsPow) !== null && _o$rsPow !== void 0 ? _o$rsPow : .6);
+	const dots = [];
+	const orbitN = (_o$orbitN = o.orbitN) !== null && _o$orbitN !== void 0 ? _o$orbitN : 12;
+	const ghostN = (_o$ghostN = o.ghostN) !== null && _o$ghostN !== void 0 ? _o$ghostN : 40;
+	const particles = (_o$particles = o.particles) !== null && _o$particles !== void 0 ? _o$particles : 3;
+	for (let orb = 0; orb < orbitN; orb++) {
+		const h1 = hashD(orb, 1.7);
+		const h2 = hashD(orb, 5.2);
+		const h3 = hashD(orb, 8.9);
+		const ro = R * (.45 + .52 * h1);
+		const th = h1 * 2 * Math.PI;
+		const phi = Math.acos(2 * h2 - 1);
+		const nx = Math.sin(phi) * Math.cos(th);
+		const ny = Math.cos(phi);
+		const nz = Math.sin(phi) * Math.sin(th);
+		let ux = -ny;
+		let uy = nx;
+		const uz = 0;
+		const ul = Math.max(1e-6, Math.sqrt(ux * ux + uy * uy));
+		ux /= ul;
+		uy /= ul;
+		const vx = ny * uz - nz * uy;
+		const vy = nz * ux - nx * uz;
+		const vz = nx * uy - ny * ux;
+		const speed = (.25 + .55 * h3) * (h3 > .5 ? 1 : -1);
+		for (let k = 0; k < ghostN; k++) {
+			var _o$ghostR, _o$ghostA;
+			const a = k / ghostN * 2 * Math.PI;
+			const [px, py, z] = pt((ux * Math.cos(a) + vx * Math.sin(a)) * ro, (uy * Math.cos(a) + vy * Math.sin(a)) * ro, (uz * Math.cos(a) + vz * Math.sin(a)) * ro);
+			const depth = (z / ro + 1) / 2;
+			dots.push({
+				x: px,
+				y: py,
+				z,
+				r: ((_o$ghostR = o.ghostR) !== null && _o$ghostR !== void 0 ? _o$ghostR : .9) * rs,
+				white: .72,
+				a: ((_o$ghostA = o.ghostA) !== null && _o$ghostA !== void 0 ? _o$ghostA : .5) * (.4 + .6 * depth)
+			});
+		}
+		for (let m = 0; m < particles; m++) {
+			var _o$partR, _o$partRDepth;
+			const a = t * speed + m / particles * 2 * Math.PI + h2 * 6;
+			const [px, py, z] = pt((ux * Math.cos(a) + vx * Math.sin(a)) * ro, (uy * Math.cos(a) + vy * Math.sin(a)) * ro, (uz * Math.cos(a) + vz * Math.sin(a)) * ro);
+			const depth = (z / ro + 1) / 2;
+			dots.push({
+				x: px,
+				y: py,
+				z,
+				r: (((_o$partR = o.partR) !== null && _o$partR !== void 0 ? _o$partR : 1.2) + ((_o$partRDepth = o.partRDepth) !== null && _o$partRDepth !== void 0 ? _o$partRDepth : 1.6) * depth) * rs,
+				white: .3 - .22 * depth
+			});
+		}
+	}
+	paint(ctx, dots, dark, o.rMin);
+};
+//#endregion
+export { drawOrbits };

package/es/thinking-orb/engine/profiles.d.ts

@@ -0,0 +1,6 @@
+export interface ModeOpts {
+    [key: string]: number | undefined;
+}
+export declare function scaleCounts(opts: ModeOpts, scale: number): ModeOpts;
+export declare function scaleRadii(opts: ModeOpts, scale: number): ModeOpts;
+export declare const BASE_PROFILES: Record<string, ModeOpts>;

package/es/thinking-orb/engine/profiles.js

@@ -0,0 +1,150 @@
+import _objectSpread2 from "../../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
+//#region components/thinking-orb/engine/profiles.ts
+var COUNT_PAIRS = [
+	["latRings", "lonDensity"],
+	["rings", "lonDensity"],
+	["lanes", "segs"]
+];
+var COUNT_KEYS = [
+	"orbitN",
+	"ghostN",
+	"nodeN",
+	"strandN",
+	"signals"
+];
+var ICON_DENSITY_KEYS = ["iconD"];
+var RADIUS_KEYS = [
+	"rBase",
+	"rDepth",
+	"rActive",
+	"rDot",
+	"ghostR",
+	"partR",
+	"partRDepth",
+	"nodeR",
+	"nodeRDepth"
+];
+function scaleCounts(opts, scale) {
+	const out = _objectSpread2({}, opts);
+	const done = /* @__PURE__ */ new Set();
+	const rt = Math.sqrt(scale);
+	for (const [a, b] of COUNT_PAIRS) {
+		const va = out[a];
+		const vb = out[b];
+		if (va != null && vb != null && !done.has(a) && !done.has(b)) {
+			out[a] = Math.max(2, Math.round(va * rt));
+			out[b] = Math.max(2, Math.round(vb * rt));
+			done.add(a);
+			done.add(b);
+		}
+	}
+	for (const k of COUNT_KEYS) {
+		const v = out[k];
+		if (v != null && v !== 0 && !done.has(k)) out[k] = Math.max(1, Math.round(v * scale));
+	}
+	for (const k of ICON_DENSITY_KEYS) {
+		const v = out[k];
+		if (v != null) out[k] = Math.max(.02, v * scale);
+	}
+	return out;
+}
+function scaleRadii(opts, scale) {
+	var _out$rSizeMul;
+	const out = _objectSpread2({}, opts);
+	for (const k of RADIUS_KEYS) {
+		const v = out[k];
+		if (v != null) out[k] = v * scale;
+	}
+	out.rSizeMul = ((_out$rSizeMul = out.rSizeMul) !== null && _out$rSizeMul !== void 0 ? _out$rSizeMul : 1) * scale;
+	return out;
+}
+/** Base (fine) profiles per mode, before preset multipliers. */
+var BASE_PROFILES = {
+	globe: {
+		latRings: 17,
+		lonDensity: 44,
+		rBase: .6,
+		rDepth: 1.7,
+		rBoost: 1,
+		inkFar: .62,
+		inkSpan: .54,
+		rsPow: .6,
+		rMin: .3
+	},
+	orbits: {
+		orbitN: 12,
+		ghostN: 40,
+		ghostR: .9,
+		ghostA: .5,
+		particles: 3,
+		partR: 1.2,
+		partRDepth: 1.6,
+		rsPow: .6,
+		rMin: .3
+	},
+	rubik: {
+		latRings: 15,
+		lonDensity: 40,
+		moveCount: 14,
+		rBase: .6,
+		rDepth: 1.7,
+		rActive: .3,
+		inkFar: .62,
+		inkSpan: .54,
+		rsPow: .6,
+		rMin: .3
+	},
+	wave: {
+		rings: 15,
+		lonDensity: 40,
+		rBase: .6,
+		rDepth: 1.7,
+		rsPow: .6,
+		rMin: .3
+	},
+	web: {
+		nodeN: 30,
+		thr: .72,
+		signals: 5,
+		nodeR: 1.4,
+		nodeRDepth: 1.8,
+		lineW: .8,
+		rsPow: .6,
+		rMin: .3
+	},
+	braid: {
+		strandN: 52,
+		turns: 3,
+		ghostN: 150,
+		rBase: 1.2,
+		rDepth: 1.8,
+		rsPow: .6,
+		rMin: .3
+	},
+	ribbon: {
+		lanes: 5,
+		segs: 88,
+		ghostN: 150,
+		rBase: 1.1,
+		rDepth: 1.7,
+		rsPow: .6,
+		rMin: .3
+	},
+	ring: {
+		lanes: 5,
+		segs: 88,
+		ghostN: 0,
+		faceOn: 1,
+		rBase: 1.1,
+		rDepth: 1.7,
+		rsPow: .6,
+		rMin: .3
+	},
+	morph: {
+		rDot: .021,
+		iconD: 1,
+		rMin: .25
+	}
+};
+//#endregion
+export { BASE_PROFILES, scaleCounts, scaleRadii };

package/es/thinking-orb/engine/registry.d.ts

@@ -0,0 +1,3 @@
+import type { ModeKey } from '../presets';
+import type { ModeDraw } from './types';
+export declare const MODE_DRAWS: Record<ModeKey, ModeDraw>;

package/es/thinking-orb/engine/registry.js

@@ -0,0 +1,20 @@
+import { drawBraid } from "./braid.js";
+import { drawGlobe, drawRubik, drawWave } from "./lattice.js";
+import { drawMorph } from "./morph.js";
+import { drawOrbits } from "./orbits.js";
+import { drawRibbon } from "./ribbon.js";
+import { drawWeb } from "./web.js";
+//#region components/thinking-orb/engine/registry.ts
+var MODE_DRAWS = {
+	orbits: drawOrbits,
+	globe: drawGlobe,
+	rubik: drawRubik,
+	wave: drawWave,
+	web: drawWeb,
+	braid: drawBraid,
+	ribbon: drawRibbon,
+	ring: drawRibbon,
+	morph: drawMorph
+};
+//#endregion
+export { MODE_DRAWS };

package/es/thinking-orb/engine/ribbon.d.ts

@@ -0,0 +1,2 @@
+import type { ModeDraw } from './types';
+export declare const drawRibbon: ModeDraw;