@aethervtt/shard-dice 0.0.0-stage → 0.2.0

package/dist/hull.js

@@ -0,0 +1,154 @@
+import {
+  add,
+  cross,
+  dot,
+  EPSILON,
+  length,
+  normalize,
+  qConj,
+  qFromBasis,
+  qKey,
+  qMul,
+  qRotate,
+  round,
+  scale,
+  stableTangent,
+  sub
+} from "./math.js";
+function pointsOf(flat) {
+  const out = [];
+  for (let i = 0; i + 2 < flat.length; i += 3) out.push([flat[i], flat[i + 1], flat[i + 2]]);
+  return out;
+}
+const compareVector = (a, b) => a[1] - b[1] || a[2] - b[2] || a[0] - b[0];
+function convexFaces(points) {
+  const faces = /* @__PURE__ */ new Map();
+  const n = points.length;
+  for (let a = 0; a < n - 2; a++) {
+    for (let b = a + 1; b < n - 1; b++) {
+      for (let c = b + 1; c < n; c++) {
+        let normal = cross(sub(points[b], points[a]), sub(points[c], points[a]));
+        if (dot(normal, normal) < 1e-10) continue;
+        normal = normalize(normal);
+        const d = dot(normal, points[a]);
+        let positive = false;
+        let negative = false;
+        for (const p of points) {
+          const side = dot(normal, p) - d;
+          if (side > EPSILON) positive = true;
+          else if (side < -EPSILON) negative = true;
+          if (positive && negative) break;
+        }
+        if (positive && negative) continue;
+        if (positive) normal = scale(normal, -1);
+        const plane = dot(normal, points[a]);
+        const members = [];
+        for (let i = 0; i < n; i++) {
+          if (Math.abs(dot(normal, points[i]) - plane) < EPSILON * 3) members.push(i);
+        }
+        const key = members.join(":");
+        if (faces.has(key)) continue;
+        let center = [0, 0, 0];
+        for (const i of members) center = add(center, points[i]);
+        center = scale(center, 1 / members.length);
+        faces.set(key, { vertices: orderAround(members, points, normal, center), normal, center });
+      }
+    }
+  }
+  return [...faces.values()].sort((l, r) => compareVector(l.normal, r.normal));
+}
+function orderAround(members, points, normal, center) {
+  const t = stableTangent(normal);
+  const b = cross(normal, t);
+  const angle = (i) => {
+    const d = sub(points[i], center);
+    return Math.atan2(dot(d, b), dot(d, t));
+  };
+  return [...members].sort((l, r) => angle(l) - angle(r));
+}
+function tangentPolytope(normals) {
+  const triangles = convexFaces(normals);
+  const points = [];
+  const cells = normals.map(() => []);
+  for (const tri of triangles) {
+    const [a, b, c] = tri.vertices;
+    const na = normals[a];
+    const nb = normals[b];
+    const nc = normals[c];
+    const det = dot(na, cross(nb, nc));
+    const p = scale(add(add(cross(nb, nc), cross(nc, na)), cross(na, nb)), 1 / det);
+    const index = points.push(p) - 1;
+    for (const i of tri.vertices) cells[i].push(index);
+  }
+  const faces = normals.map((normal, i) => {
+    let center = [0, 0, 0];
+    for (const v of cells[i]) center = add(center, points[v]);
+    center = scale(center, 1 / cells[i].length);
+    return { vertices: orderAround(cells[i], points, normal, center), normal, center };
+  });
+  return { points, faces };
+}
+function hasPoint(points, p) {
+  for (const q of points) {
+    const dx = q[0] - p[0];
+    const dy = q[1] - p[1];
+    const dz = q[2] - p[2];
+    if (dx * dx + dy * dy + dz * dz < EPSILON * EPSILON * 9) return true;
+  }
+  return false;
+}
+function isSymmetry(points, q) {
+  for (const p of points) if (!hasPoint(points, qRotate(q, p))) return false;
+  return true;
+}
+function basisOf(a, b, c) {
+  const x = normalize(sub(b, a));
+  const ac = sub(c, a);
+  const yRaw = sub(ac, scale(x, dot(ac, x)));
+  if (length(yRaw) < 1e-6) return void 0;
+  const y = normalize(yRaw);
+  return [x, y, cross(x, y)];
+}
+function symmetryGroup(points) {
+  const n = points.length;
+  let anchor;
+  for (let b = 1; b < n && !anchor; b++) {
+    for (let c = b + 1; c < n && !anchor; c++) {
+      if (length(cross(sub(points[b], points[0]), sub(points[c], points[0]))) > 1e-4)
+        anchor = [0, b, c];
+    }
+  }
+  if (!anchor) return [];
+  const [p0, p1, p2] = anchor.map((i) => points[i]);
+  const d01 = length(sub(p1, p0));
+  const d02 = length(sub(p2, p0));
+  const d12 = length(sub(p2, p1));
+  const source = basisOf(p0, p1, p2);
+  const fromSource = qConj(qFromBasis(...source));
+  const found = /* @__PURE__ */ new Map();
+  for (let a = 0; a < n; a++) {
+    for (let b = 0; b < n; b++) {
+      if (b === a || Math.abs(length(sub(points[b], points[a])) - d01) > EPSILON * 10) continue;
+      for (let c = 0; c < n; c++) {
+        if (c === a || c === b) continue;
+        if (Math.abs(length(sub(points[c], points[a])) - d02) > EPSILON * 10) continue;
+        if (Math.abs(length(sub(points[c], points[b])) - d12) > EPSILON * 10) continue;
+        const target = basisOf(points[a], points[b], points[c]);
+        if (!target) continue;
+        const q = qMul(qFromBasis(...target), fromSource);
+        const moved = qRotate(q, p0);
+        if (length(sub(moved, points[a])) > EPSILON * 10) continue;
+        if (!isSymmetry(points, q)) continue;
+        found.set(qKey(q), q.map(round));
+      }
+    }
+  }
+  return [...found.entries()].sort(([l], [r]) => l.localeCompare(r)).map(([, q]) => q);
+}
+export {
+  convexFaces,
+  isSymmetry,
+  pointsOf,
+  symmetryGroup,
+  tangentPolytope
+};

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { DICE_AUDIO_BUS } from './audio.js';
+export { allDiceAttachments, DICE_BUDGETS, type DiceAttachmentContext, type DiceAttachmentDef, type DiceSceneContext, defineDiceAttachment, findDiceAttachment, MAX_ATTACHMENTS, setDiceBudgets, } from './attachments.js';
+export { BUILTIN_DICE, D4, D6, D8, D10, D10_TENS, D12, D20, D100_BALL, DIE_KINDS, type DieKind, KIND_DEFINITIONS, kindSides, percentileValues, registerBuiltinDice, } from './builtins.js';
+export { CELL_PAD, type CellLayout, cellLayout, type FaceCell, MARK_RANGE } from './cells.js';
+export { DiceDie, DiceRollRequest } from './components.js';
+export { allDice, type DieDefinition, type DieGeometry, defineDie, dieGeometry, dieHash, findDie, frameOf, labelOf, physicalScale, requireDie, type ValueFrame, validateDieDefinition, } from './definition.js';
+export { DieDefinitionAsset, type DieDefinitionAssetValue, dieDefinitionOf, } from './definition-asset.js';
+export { type DiceCondition, type DiceEffect, DiceEffectRecipe, type DiceEffectRecipeValue, diceEffectRecipe, type MatchedRecipe, matchRecipes, RECIPE_LIMITS, recipeProblems, } from './effects.js';
+export { allDiceEntrances, type DiceEntranceContext, type DiceEntranceDef, defineDiceEntrance, findDiceEntrance, MAX_ENTRANCES, } from './entrances.js';
+export { BUILTIN_FAMILIES, GLASS, METAL, RESIN, SOLID } from './families.js';
+export { allDiceGlyphs, BUILTIN_GLYPHS, type DiceGlyph, type DiceGlyphDef, defineDiceGlyph, findDiceGlyph, parseSvgPath, registerBuiltinGlyphs, } from './glyphs.js';
+export { landingCorrection, markAngle, naturalValue, restingHeight, restRotation, topAlignment, } from './landing.js';
+export { ambiguousLabel, defaultLayoutFor, FaceLayout, type FaceLayoutValue, type FaceMark, layoutProblems, NUMBERS_LAYOUT, PIPS_LAYOUT, type ResolvedMark, resolveMark, } from './layout.js';
+export { type BakeMarksOptions, bakeMarks, clearMarkCache, MARK_MARGIN, type MarkAtlas, markAtlasKey, markPlacements, type Placement as MarkPlacement, } from './marks.js';
+export { allDiceFamilies, DICE_FIELDS, DICE_SHADERS, type DiceFamily, type DiceFamilyOptions, defineDiceFamily, findDiceFamily, isDiceMaterial, } from './material.js';
+export { dieMesh, floorQuad } from './mesh.js';
+export { diceMethods } from './methods.js';
+export { NUMERAL_HEIGHT } from './numerals.js';
+export { type DicePluginOptions, dicePlugin, TOP_DOWN } from './plugin.js';
+export { type DiceThumbnail, type DiceThumbnailOptions, renderDiceThumbnail } from './preview.js';
+export { type DiceQuality, type DiceQualityChoice, resolveDiceQuality } from './quality.js';
+export { type DiceLookKey, type DiceResourceEntry, DiceResources, RELEASE_AFTER_MS, } from './resources.js';
+export { type DiceQualityPreference, type DiceRoll, type DiceRollDie, expandRoll, type PhysicalDie, presentationScale, rollTrackRequest, viewportTray, } from './roll.js';
+export { BALL_DAMPING, DICE_CLEANUP_STEP, DICE_GROUPS, DICE_SETTLE_RULE, type DiceSettleParams, type DiceTray, diceSettle, outsideTray, restingFlat, } from './settle.js';
+export { BUILTIN_SKINS, DICE_SKINS, DiceSkin, type DiceSkinValue, type DiceSkinVariant, diceSkin, IMPACT_SOUNDS, type ImpactSound, MAX_SKIN_EFFECTS, type SkinContext, skinVariant, validateDiceSkin, } from './skin.js';
+export { ACCENT_CUES, type AccentCue, accentSamples, DiceSoundBank, IMPACT_LAYERS, IMPACT_VARIATIONS, impactLayer, impactSamples, impactStrength, wavBytes, } from './sound.js';
+export { studioEnvironment } from './studio.js';
+export { ANIMATED_DEMAND, type DiceOutcome, type DicePhase, type DicePlayOptions, DiceTable, type DiceTableOptions, DiceTableState, ENTRANCE_DEMAND, ENTRANCE_WAIT_MS, PRESENTATION_DEMAND, PREVIEW_TRAY, } from './table.js';
+export { DICE_CONTACTS, DICE_GRAVITY, DICE_MAX_STEPS, DICE_STEP, type DiceTrackDie, type DiceTrackRequest, diceSettleParams, diceTrackScene, LAUNCH_EDGES, type LaunchEdge, laneLayout, launchEdgeOf, MAX_DICE, PLACED_DROP_STEPS, placeDie, placedFrom, placementSpots, seedOf, type UnlandedReason, unlandedDice, } from './track.js';
+export { DiceTray as DiceTrayMaterial, TRAY_SHADERS } from './tray.js';
+export { type DiceVariantEntry, diceVariants } from './variants.js';
+export { type DiceWindow, spawnDiceWindow } from './windows.js';

package/dist/index.js

@@ -0,0 +1,324 @@
+import { DICE_AUDIO_BUS } from "./audio.js";
+import {
+  allDiceAttachments,
+  DICE_BUDGETS,
+  defineDiceAttachment,
+  findDiceAttachment,
+  MAX_ATTACHMENTS,
+  setDiceBudgets
+} from "./attachments.js";
+import {
+  BUILTIN_DICE,
+  D4,
+  D6,
+  D8,
+  D10,
+  D10_TENS,
+  D12,
+  D20,
+  D100_BALL,
+  DIE_KINDS,
+  KIND_DEFINITIONS,
+  kindSides,
+  percentileValues,
+  registerBuiltinDice
+} from "./builtins.js";
+import { CELL_PAD, cellLayout, MARK_RANGE } from "./cells.js";
+import { DiceDie, DiceRollRequest } from "./components.js";
+import {
+  allDice,
+  defineDie,
+  dieGeometry,
+  dieHash,
+  findDie,
+  frameOf,
+  labelOf,
+  physicalScale,
+  requireDie,
+  validateDieDefinition
+} from "./definition.js";
+import {
+  DieDefinitionAsset,
+  dieDefinitionOf
+} from "./definition-asset.js";
+import {
+  DiceEffectRecipe,
+  diceEffectRecipe,
+  matchRecipes,
+  RECIPE_LIMITS,
+  recipeProblems
+} from "./effects.js";
+import {
+  allDiceEntrances,
+  defineDiceEntrance,
+  findDiceEntrance,
+  MAX_ENTRANCES
+} from "./entrances.js";
+import { BUILTIN_FAMILIES, GLASS, METAL, RESIN, SOLID } from "./families.js";
+import {
+  allDiceGlyphs,
+  BUILTIN_GLYPHS,
+  defineDiceGlyph,
+  findDiceGlyph,
+  parseSvgPath,
+  registerBuiltinGlyphs
+} from "./glyphs.js";
+import {
+  landingCorrection,
+  markAngle,
+  naturalValue,
+  restingHeight,
+  restRotation,
+  topAlignment
+} from "./landing.js";
+import {
+  ambiguousLabel,
+  defaultLayoutFor,
+  FaceLayout,
+  layoutProblems,
+  NUMBERS_LAYOUT,
+  PIPS_LAYOUT,
+  resolveMark
+} from "./layout.js";
+import {
+  bakeMarks,
+  clearMarkCache,
+  MARK_MARGIN,
+  markAtlasKey,
+  markPlacements
+} from "./marks.js";
+import {
+  allDiceFamilies,
+  DICE_FIELDS,
+  DICE_SHADERS,
+  defineDiceFamily,
+  findDiceFamily,
+  isDiceMaterial
+} from "./material.js";
+import { dieMesh, floorQuad } from "./mesh.js";
+import { diceMethods } from "./methods.js";
+import { NUMERAL_HEIGHT } from "./numerals.js";
+import { dicePlugin, TOP_DOWN } from "./plugin.js";
+import { renderDiceThumbnail } from "./preview.js";
+import { resolveDiceQuality } from "./quality.js";
+import {
+  DiceResources,
+  RELEASE_AFTER_MS
+} from "./resources.js";
+import {
+  expandRoll,
+  presentationScale,
+  rollTrackRequest,
+  viewportTray
+} from "./roll.js";
+import {
+  BALL_DAMPING,
+  DICE_CLEANUP_STEP,
+  DICE_GROUPS,
+  DICE_SETTLE_RULE,
+  diceSettle,
+  outsideTray,
+  restingFlat
+} from "./settle.js";
+import {
+  BUILTIN_SKINS,
+  DICE_SKINS,
+  DiceSkin,
+  diceSkin,
+  IMPACT_SOUNDS,
+  MAX_SKIN_EFFECTS,
+  skinVariant,
+  validateDiceSkin
+} from "./skin.js";
+import {
+  ACCENT_CUES,
+  accentSamples,
+  DiceSoundBank,
+  IMPACT_LAYERS,
+  IMPACT_VARIATIONS,
+  impactLayer,
+  impactSamples,
+  impactStrength,
+  wavBytes
+} from "./sound.js";
+import { studioEnvironment } from "./studio.js";
+import {
+  ANIMATED_DEMAND,
+  DiceTable,
+  DiceTableState,
+  ENTRANCE_DEMAND,
+  ENTRANCE_WAIT_MS,
+  PRESENTATION_DEMAND,
+  PREVIEW_TRAY
+} from "./table.js";
+import {
+  DICE_CONTACTS,
+  DICE_GRAVITY,
+  DICE_MAX_STEPS,
+  DICE_STEP,
+  diceSettleParams,
+  diceTrackScene,
+  LAUNCH_EDGES,
+  laneLayout,
+  launchEdgeOf,
+  MAX_DICE,
+  PLACED_DROP_STEPS,
+  placeDie,
+  placedFrom,
+  placementSpots,
+  seedOf,
+  unlandedDice
+} from "./track.js";
+import { DiceTray, TRAY_SHADERS } from "./tray.js";
+import { diceVariants } from "./variants.js";
+import { spawnDiceWindow } from "./windows.js";
+export {
+  ACCENT_CUES,
+  ANIMATED_DEMAND,
+  BALL_DAMPING,
+  BUILTIN_DICE,
+  BUILTIN_FAMILIES,
+  BUILTIN_GLYPHS,
+  BUILTIN_SKINS,
+  CELL_PAD,
+  D10,
+  D100_BALL,
+  D10_TENS,
+  D12,
+  D20,
+  D4,
+  D6,
+  D8,
+  DICE_AUDIO_BUS,
+  DICE_BUDGETS,
+  DICE_CLEANUP_STEP,
+  DICE_CONTACTS,
+  DICE_FIELDS,
+  DICE_GRAVITY,
+  DICE_GROUPS,
+  DICE_MAX_STEPS,
+  DICE_SETTLE_RULE,
+  DICE_SHADERS,
+  DICE_SKINS,
+  DICE_STEP,
+  DIE_KINDS,
+  DiceDie,
+  DiceEffectRecipe,
+  DiceResources,
+  DiceRollRequest,
+  DiceSkin,
+  DiceSoundBank,
+  DiceTable,
+  DiceTableState,
+  DiceTray as DiceTrayMaterial,
+  DieDefinitionAsset,
+  ENTRANCE_DEMAND,
+  ENTRANCE_WAIT_MS,
+  FaceLayout,
+  GLASS,
+  IMPACT_LAYERS,
+  IMPACT_SOUNDS,
+  IMPACT_VARIATIONS,
+  KIND_DEFINITIONS,
+  LAUNCH_EDGES,
+  MARK_MARGIN,
+  MARK_RANGE,
+  MAX_ATTACHMENTS,
+  MAX_DICE,
+  MAX_ENTRANCES,
+  MAX_SKIN_EFFECTS,
+  METAL,
+  NUMBERS_LAYOUT,
+  NUMERAL_HEIGHT,
+  PIPS_LAYOUT,
+  PLACED_DROP_STEPS,
+  PRESENTATION_DEMAND,
+  PREVIEW_TRAY,
+  RECIPE_LIMITS,
+  RELEASE_AFTER_MS,
+  RESIN,
+  SOLID,
+  TOP_DOWN,
+  TRAY_SHADERS,
+  accentSamples,
+  allDice,
+  allDiceAttachments,
+  allDiceEntrances,
+  allDiceFamilies,
+  allDiceGlyphs,
+  ambiguousLabel,
+  bakeMarks,
+  cellLayout,
+  clearMarkCache,
+  defaultLayoutFor,
+  defineDiceAttachment,
+  defineDiceEntrance,
+  defineDiceFamily,
+  defineDiceGlyph,
+  defineDie,
+  diceEffectRecipe,
+  diceMethods,
+  dicePlugin,
+  diceSettle,
+  diceSettleParams,
+  diceSkin,
+  diceTrackScene,
+  diceVariants,
+  dieDefinitionOf,
+  dieGeometry,
+  dieHash,
+  dieMesh,
+  expandRoll,
+  findDiceAttachment,
+  findDiceEntrance,
+  findDiceFamily,
+  findDiceGlyph,
+  findDie,
+  floorQuad,
+  frameOf,
+  impactLayer,
+  impactSamples,
+  impactStrength,
+  isDiceMaterial,
+  kindSides,
+  labelOf,
+  landingCorrection,
+  laneLayout,
+  launchEdgeOf,
+  layoutProblems,
+  markAngle,
+  markAtlasKey,
+  markPlacements,
+  matchRecipes,
+  naturalValue,
+  outsideTray,
+  parseSvgPath,
+  percentileValues,
+  physicalScale,
+  placeDie,
+  placedFrom,
+  placementSpots,
+  presentationScale,
+  recipeProblems,
+  registerBuiltinDice,
+  registerBuiltinGlyphs,
+  renderDiceThumbnail,
+  requireDie,
+  resolveDiceQuality,
+  resolveMark,
+  restRotation,
+  restingFlat,
+  restingHeight,
+  rollTrackRequest,
+  seedOf,
+  setDiceBudgets,
+  skinVariant,
+  spawnDiceWindow,
+  studioEnvironment,
+  topAlignment,
+  unlandedDice,
+  validateDiceSkin,
+  validateDieDefinition,
+  viewportTray,
+  wavBytes
+};

package/dist/landing.d.ts

@@ -0,0 +1,29 @@
+import { type DieDefinition, type DieGeometry } from './definition.js';
+import { type Q4, type V3 } from './math.js';
+/** Screen-up as a direction on the floor (the camera's up, flattened). */
+export declare function floorUp(screenUp: ArrayLike<number>): V3;
+/** The value on top for a body rotation: the one whose direction points most nearly up. */
+export declare function naturalValue(die: DieDefinition | DieGeometry, rotation: ArrayLike<number>): number;
+/** How nearly the top value's direction points up: 1 when it's exactly vertical. */
+export declare function topAlignment(die: DieDefinition | DieGeometry, rotation: ArrayLike<number>): number;
+/**
+ * The angle (radians) between a value's mark-up on screen and screen-up, both flattened onto the
+ * floor, for a die shown at `rotation`.
+ */
+export declare function markAngle(die: DieDefinition | DieGeometry, rotation: ArrayLike<number>, value: number, screenUp?: ArrayLike<number>): number;
+/**
+ * The correction for a die that came to rest at `finalRotation`: a symmetry C of its collider,
+ * post-multiplied onto every sampled rotation (shown = rotation · C), that puts `target` where the
+ * natural value is. Among the symmetries that do, it's the one whose mark reads closest to
+ * screen-up. A ball's group is every rotation, so its target ends exactly up and upright. Throws
+ * `dice/invalid-value` for a value the die can't show.
+ */
+export declare function landingCorrection(die: DieDefinition | DieGeometry, finalRotation: ArrayLike<number>, target: number, screenUp?: ArrayLike<number>): Q4;
+/**
+ * A rotation that rests `target` on top with its mark exactly toward screen-up: reduced motion,
+ * placed dice and thumbnails. The face opposite rests on the floor (a d4 rests on the face
+ * opposite its vertex).
+ */
+export declare function restRotation(die: DieDefinition | DieGeometry, target: number, screenUp?: ArrayLike<number>): Q4;
+/** The height of the die's center above the floor at `rotation`: its lowest point touches it. */
+export declare function restingHeight(die: DieDefinition | DieGeometry, rotation: ArrayLike<number>, scale: number): number;

package/dist/landing.js

@@ -0,0 +1,93 @@
+import { dieGeometry, frameOf } from "./definition.js";
+import {
+  angleBetween,
+  dot,
+  EPSILON,
+  length,
+  normalize,
+  qConj,
+  qFromFrames,
+  qMul,
+  qNormalize,
+  qRotate,
+  sub
+} from "./math.js";
+const UP = [0, 1, 0];
+const geometryOf = (die) => "frames" in die ? die : dieGeometry(die);
+const quat = (q) => qNormalize([q[0], q[1], q[2], q[3]]);
+function floorUp(screenUp) {
+  const flat = [screenUp[0], 0, screenUp[2]];
+  const l = length(flat);
+  return l > 1e-6 ? [flat[0] / l, 0, flat[2] / l] : [0, 0, -1];
+}
+function naturalValue(die, rotation) {
+  const g = geometryOf(die);
+  const q = quat(rotation);
+  let best = g.frames[0].value;
+  let height = Number.NEGATIVE_INFINITY;
+  for (const frame of g.frames) {
+    const y = qRotate(q, frame.normal)[1];
+    if (y > height) {
+      height = y;
+      best = frame.value;
+    }
+  }
+  return best;
+}
+function topAlignment(die, rotation) {
+  const g = geometryOf(die);
+  if (g.definition.collider === "ball") return 1;
+  const q = quat(rotation);
+  let height = Number.NEGATIVE_INFINITY;
+  for (const frame of g.frames) height = Math.max(height, qRotate(q, frame.normal)[1]);
+  return height;
+}
+function markAngle(die, rotation, value, screenUp = [0, 0, -1]) {
+  const g = geometryOf(die);
+  const b = qRotate(quat(rotation), frameOf(g, value).bitangent);
+  return angleBetween(normalize([b[0], 0, b[2]]), floorUp(screenUp));
+}
+function landingCorrection(die, finalRotation, target, screenUp = [0, 0, -1]) {
+  const g = geometryOf(die);
+  const frame = frameOf(g, target);
+  const r = quat(finalRotation);
+  const up = floorUp(screenUp);
+  if (g.definition.collider === "ball") {
+    return qNormalize(qMul(qConj(r), qFromFrames(frame.normal, frame.bitangent, UP, up)));
+  }
+  const natural = frameOf(g, naturalValue(g, r));
+  let best;
+  let score = Number.NEGATIVE_INFINITY;
+  for (const c of g.symmetries) {
+    if (length(sub(qRotate(c, frame.normal), natural.normal)) > EPSILON * 10) continue;
+    const b = qRotate(r, qRotate(c, frame.bitangent));
+    const s = dot(normalize([b[0], 0, b[2]]), up);
+    if (s > score + 1e-9) {
+      score = s;
+      best = c;
+    }
+  }
+  return best ?? [0, 0, 0, 1];
+}
+function restRotation(die, target, screenUp = [0, 0, -1]) {
+  const g = geometryOf(die);
+  const frame = frameOf(g, target);
+  return qFromFrames(frame.normal, frame.bitangent, UP, floorUp(screenUp));
+}
+function restingHeight(die, rotation, scale) {
+  const g = geometryOf(die);
+  if (g.definition.collider === "ball") return scale;
+  const q = quat(rotation);
+  let low = 0;
+  for (const p of g.points) low = Math.min(low, qRotate(q, p)[1]);
+  return -low * scale;
+}
+export {
+  floorUp,
+  landingCorrection,
+  markAngle,
+  naturalValue,
+  restRotation,
+  restingHeight,
+  topAlignment
+};