@aethervtt/shard-dice 0.0.0-stage → 0.1.0

package/dist/test-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test-worker.js

@@ -0,0 +1,12 @@
+import { parentPort } from "node:worker_threads";
+import { serveTracks } from "@aethervtt/shard-physics/worker";
+import { DICE_SETTLE_RULE, diceSettle } from "./settle.js";
+const port = parentPort;
+serveTracks({
+  rules: { [DICE_SETTLE_RULE]: diceSettle },
+  scope: {
+    postMessage: (message, transfer) => port.postMessage(message, transfer),
+    addEventListener: (_type, listener) => port.on("message", (data) => listener({ data })),
+    close: () => port.close()
+  }
+});

package/dist/track.d.ts

@@ -0,0 +1,70 @@
+import type { Track, TrackContactOptions, TrackScene } from '@aethervtt/shard-physics/track';
+import { type DieGeometry } from './definition.js';
+import { type Q4, type V3 } from './math.js';
+import { type DiceSettleParams, type DiceTray } from './settle.js';
+export declare const LAUNCH_EDGES: readonly ['left', 'right', 'top', 'bottom'];
+export type LaunchEdge = (typeof LAUNCH_EDGES)[number];
+export interface DiceTrackDie {
+    /** A registered definition's id. */
+    definition: string;
+    /** World scale of the unit-radius die. */
+    scale: number;
+    /** Dropped dice are heavier on friction and lighter on bounce. */
+    dropped?: boolean;
+}
+export interface DiceTrackRequest {
+    /** Every random choice (edge, lanes, velocities, spin, starting orientations) derives from it. */
+    seed: string | number;
+    tray: DiceTray;
+    dice: DiceTrackDie[];
+    /** The tray edge the dice come in from; chosen from the seed when omitted. */
+    launch?: LaunchEdge;
+}
+export declare const DICE_STEP: number;
+export declare const DICE_MAX_STEPS = 480;
+/** The steps a placed die takes to drop into its spot. */
+export declare const PLACED_DROP_STEPS = 20;
+export declare const DICE_GRAVITY = -18.5;
+/** Contacts as the impact synth hears them. */
+export declare const DICE_CONTACTS: TrackContactOptions;
+export declare const MAX_DICE = 32;
+export declare const seedOf: (seed: string | number) => number;
+/** The launch edge a request's seed picks (or the one it names). */
+export declare function launchEdgeOf(request: DiceTrackRequest): LaunchEdge;
+/**
+ * The 0053 scene of a throw: a walled tray, and the dice thrown in from one edge in lanes. Every
+ * number comes from the seed; the definitions' geometry and scales shape the colliders, so the
+ * scene hash covers them and the tray too.
+ */
+export declare function diceTrackScene(request: DiceTrackRequest): TrackScene;
+/** The data `dice-settle` needs about a request's dice. */
+export declare function diceSettleParams(request: DiceTrackRequest): DiceSettleParams;
+export type UnlandedReason = 'outside' | 'cocked';
+/**
+ * Per die, why the track can't show it landed: it ended outside the tray, or not resting flat
+ * (a track that hit maxSteps). Null for a die that landed.
+ */
+export declare function unlandedDice(track: Track, request: DiceTrackRequest): (UnlandedReason | null)[];
+/**
+ * Where reduced motion puts each die: rows centered in the tray, in roll order, left to right and
+ * far to near.
+ */
+export declare function laneLayout(request: DiceTrackRequest): V3[];
+/**
+ * Free spots for the dice the track can't show: for each, the grid spot nearest to where it
+ * ended (clamped into the tray) that no landed or already placed die is near.
+ */
+export declare function placementSpots(track: Track, request: DiceTrackRequest, unlanded: readonly (UnlandedReason | null)[]): (V3 | null)[];
+/**
+ * Where dice that aren't in the physics land (0065's entrance dice): for each wanted point (tray
+ * coordinates), the grid spot nearest it that none of `taken` (where the physical dice ended) and no
+ * earlier entrance die is near. `dice` are every die on the tray, for the spacing.
+ */
+export declare function entranceSpots(tray: DiceTray, dice: readonly DiceTrackDie[], taken: readonly V3[], wants: readonly V3[]): V3[];
+/**
+ * Rewrites a die's last steps so it drops straight down into `spot`, resting at `rotation`: the
+ * placed fallback, honest and deterministic. Earlier steps are the physics as recorded.
+ */
+export declare function placeDie(track: Track, body: number, spot: V3, rotation: Q4, geometry: DieGeometry, scale: number): void;
+/** The step a placed die starts dropping at. */
+export declare const placedFrom: (track: Track) => number;

package/dist/track.js

@@ -0,0 +1,304 @@
+import { quat as quatMath, Rng, ShardError } from "@aethervtt/shard-core";
+import { dieGeometry, requireDie } from "./definition.js";
+import { restingHeight } from "./landing.js";
+import { hashString } from "./math.js";
+import {
+  BALL_DAMPING,
+  DICE_GROUPS,
+  outsideTray,
+  restingFlat
+} from "./settle.js";
+const LAUNCH_EDGES = ["left", "right", "top", "bottom"];
+const DICE_STEP = 1 / 60;
+const DICE_MAX_STEPS = 480;
+const PLACED_DROP_STEPS = 20;
+const DICE_GRAVITY = -18.5;
+const DICE_CONTACTS = { minForce: 0.24, dedupeSteps: 3, max: 1024 };
+const MAX_DICE = 32;
+function checkRequest(request) {
+  const { tray: tray2, dice } = request;
+  if (!(tray2.halfWidth >= 1) || !(tray2.halfDepth >= 1)) {
+    throw new ShardError("dice/invalid-roll", "The tray is smaller than 1 \xD7 1 half-extents", {
+      path: "tray",
+      hint: "Pass the tray the camera shows, e.g. { halfWidth: 5.4, halfDepth: 3.15 }."
+    });
+  }
+  if (dice.length < 1 || dice.length > MAX_DICE) {
+    throw new ShardError("dice/invalid-roll", `A roll has 1 to ${MAX_DICE} physical dice`, {
+      path: "dice"
+    });
+  }
+  dice.forEach((d, i) => {
+    if (!(d.scale > 0.05 && d.scale < 4))
+      throw new ShardError("dice/invalid-roll", `dice[${i}].scale is out of range`, {
+        path: `dice[${i}].scale`
+      });
+  });
+}
+const seedOf = (seed) => typeof seed === "number" ? seed >>> 0 : hashString(seed);
+const signed = (rng) => rng.float() * 2 - 1;
+function randomRotation(rng) {
+  for (; ; ) {
+    const x = signed(rng);
+    const y = signed(rng);
+    const z = signed(rng);
+    const w = signed(rng);
+    const d = x * x + y * y + z * z + w * w;
+    if (d > 1 || d < 0.04) continue;
+    const l = Math.sqrt(d);
+    return [x / l, y / l, z / l, w / l];
+  }
+}
+function spawnFor(index, count, tray2, edge, rng) {
+  const alongX = edge === "left" || edge === "right";
+  const normalHalf = alongX ? tray2.halfWidth : tray2.halfDepth;
+  const tangentHalf = alongX ? tray2.halfDepth : tray2.halfWidth;
+  const spacing = count > 16 ? 0.54 : 0.72;
+  const capacity = Math.max(2, Math.floor(tangentHalf * 2 * 0.76 / spacing));
+  const columns = Math.min(count, capacity);
+  const column = index % columns;
+  const row = Math.floor(index / columns);
+  const sign = edge === "left" || edge === "top" ? -1 : 1;
+  const span = Math.min(tangentHalf * 1.48, Math.max(0, columns - 1) * spacing);
+  const tangent = columns === 1 ? signed(rng) * 0.18 : -span / 2 + column / (columns - 1) * span;
+  const normal = sign * (normalHalf - 0.28 - row * 0.34) + signed(rng) * 0.08;
+  const inward = alongX ? 5.8 + rng.float() * 1.7 : 4.25 + rng.float() * 1.45;
+  const across = -tangent * (0.34 + rng.float() * 0.16) + signed(rng) * 1.35;
+  const y = 1.55 + row * 0.18 + rng.float() * 0.52;
+  const vy = 1.65 + rng.float() * 1.7;
+  return {
+    position: alongX ? [normal, y, tangent] : [tangent, y, normal],
+    velocity: alongX ? [-sign * inward, vy, across] : [across, vy, -sign * inward]
+  };
+}
+function tray(t) {
+  const surface = { friction: 0.62, restitution: 0.24, density: 1 };
+  const wall = (x, z, hx, hz) => ({
+    shape: "cuboid",
+    halfExtents: [hx, 1.35, hz],
+    translation: [x, 1.16, z],
+    ...surface,
+    group: "walls"
+  });
+  const { halfWidth: hw, halfDepth: hd } = t;
+  return [
+    {
+      shape: "cuboid",
+      halfExtents: [hw, 0.16, hd],
+      translation: [0, -0.16, 0],
+      ...surface,
+      group: "floor"
+    },
+    wall(-hw - 0.12, 0, 0.16, hd),
+    wall(hw + 0.12, 0, 0.16, hd),
+    wall(0, -hd - 0.12, hw, 0.16),
+    wall(0, hd + 0.12, hw, 0.16)
+  ];
+}
+function colliderOf(g, scale, dropped) {
+  const surface = {
+    density: dropped ? 0.82 : 1.1,
+    friction: dropped ? 0.72 : 0.54,
+    restitution: dropped ? 0.18 : 0.34,
+    group: "dice"
+  };
+  if (g.definition.collider === "ball") return { shape: "ball", radius: scale, ...surface };
+  const points = new Float32Array(g.points.length * 3);
+  g.points.forEach((p, i) => {
+    points[i * 3] = p[0] * scale;
+    points[i * 3 + 1] = p[1] * scale;
+    points[i * 3 + 2] = p[2] * scale;
+  });
+  return { shape: "convex", points, ...surface };
+}
+function launchEdgeOf(request) {
+  return request.launch ?? new Rng(seedOf(request.seed)).pick(LAUNCH_EDGES);
+}
+function diceTrackScene(request) {
+  checkRequest(request);
+  const rng = new Rng(seedOf(request.seed));
+  const picked = rng.pick(LAUNCH_EDGES);
+  const edge = request.launch ?? picked;
+  const bodies = request.dice.map((die, i) => {
+    const g = dieGeometry(requireDie(die.definition));
+    const spawn = spawnFor(i, request.dice.length, request.tray, edge, rng);
+    const angular = [
+      signed(rng) * (8.5 + rng.float() * 10),
+      signed(rng) * (7 + rng.float() * 11),
+      signed(rng) * (8.5 + rng.float() * 10)
+    ];
+    return {
+      id: `${i}:${die.definition}`,
+      translation: spawn.position,
+      rotation: randomRotation(rng),
+      linear: spawn.velocity,
+      angular,
+      colliders: [colliderOf(g, die.scale, die.dropped ?? false)],
+      ccd: true,
+      linearDamping: 0.16,
+      angularDamping: g.definition.collider === "ball" ? BALL_DAMPING.from : 0.2
+    };
+  });
+  return {
+    version: 1,
+    dim: 3,
+    step: DICE_STEP,
+    maxSteps: DICE_MAX_STEPS,
+    gravity: [0, DICE_GRAVITY, 0],
+    groups: DICE_GROUPS,
+    fixed: tray(request.tray),
+    bodies
+  };
+}
+function diceSettleParams(request) {
+  return {
+    tray: { ...request.tray },
+    bodies: request.dice.map((die) => {
+      const g = dieGeometry(requireDie(die.definition));
+      if (g.definition.collider === "ball") return { directions: [], radius: die.scale };
+      return {
+        directions: g.frames.flatMap((f) => f.normal),
+        points: g.points.flatMap((p) => [p[0] * die.scale, p[1] * die.scale, p[2] * die.scale])
+      };
+    })
+  };
+}
+function unlandedDice(track, request) {
+  const params = diceSettleParams(request);
+  const n = track.bodyCount;
+  const o = track.steps * n;
+  return request.dice.map((_, i) => {
+    const p = track.positions.subarray((o + i) * 3, (o + i) * 3 + 3);
+    const r = track.rotations.subarray((o + i) * 4, (o + i) * 4 + 4);
+    if (outsideTray(p, request.tray)) return "outside";
+    return restingFlat(params.bodies[i], p, r) ? null : "cocked";
+  });
+}
+function laneSpacing(request) {
+  let widest = 0;
+  for (const d of request.dice) {
+    const g = dieGeometry(requireDie(d.definition));
+    widest = Math.max(widest, g.footprint * d.scale);
+  }
+  return widest * 1.18;
+}
+function gridSpots(t, spacing, margin) {
+  const spots = [];
+  const nx = Math.max(1, Math.floor(2 * (t.halfWidth - margin) / spacing) + 1);
+  const nz = Math.max(1, Math.floor(2 * (t.halfDepth - margin) / spacing) + 1);
+  for (let iz = 0; iz < nz; iz++) {
+    for (let ix = 0; ix < nx; ix++) {
+      spots.push([(ix - (nx - 1) / 2) * spacing, 0, (iz - (nz - 1) / 2) * spacing]);
+    }
+  }
+  return spots;
+}
+function laneLayout(request) {
+  const spacing = laneSpacing(request);
+  const n = request.dice.length;
+  const maxColumns = Math.max(1, Math.floor((2 * request.tray.halfWidth - spacing) / spacing) + 1);
+  const columns = Math.min(n, maxColumns, Math.max(1, Math.ceil(Math.sqrt(n * 2.2))));
+  const rows = Math.ceil(n / columns);
+  return request.dice.map((_, i) => {
+    const row = Math.floor(i / columns);
+    const inRow = row === rows - 1 ? n - row * columns : columns;
+    const col = i % columns;
+    return [(col - (inRow - 1) / 2) * spacing, 0, (row - (rows - 1) / 2) * spacing];
+  });
+}
+function placementSpots(track, request, unlanded) {
+  const spacing = laneSpacing(request);
+  const t = request.tray;
+  const margin = spacing * 0.6;
+  const spots = gridSpots(t, spacing, margin);
+  const o = track.steps * track.bodyCount;
+  const taken = [];
+  unlanded.forEach((reason, i) => {
+    if (reason) return;
+    const p = track.positions;
+    taken.push([p[(o + i) * 3], 0, p[(o + i) * 3 + 2]]);
+  });
+  return unlanded.map((reason, i) => {
+    if (!reason) return null;
+    const p = track.positions;
+    const want = [
+      Math.max(-t.halfWidth + margin, Math.min(t.halfWidth - margin, p[(o + i) * 3])),
+      0,
+      Math.max(-t.halfDepth + margin, Math.min(t.halfDepth - margin, p[(o + i) * 3 + 2]))
+    ];
+    const free = spots.filter(
+      (s) => taken.every((q) => (s[0] - q[0]) ** 2 + (s[2] - q[2]) ** 2 >= spacing ** 2 * 0.81)
+    ).sort(
+      (a, b) => (a[0] - want[0]) ** 2 + (a[2] - want[2]) ** 2 - ((b[0] - want[0]) ** 2 + (b[2] - want[2]) ** 2)
+    );
+    const spot = free[0] ?? want;
+    taken.push(spot);
+    return spot;
+  });
+}
+function entranceSpots(tray2, dice, taken, wants) {
+  const spacing = laneSpacing({ dice });
+  const margin = spacing * 0.6;
+  const spots = gridSpots(tray2, spacing, margin);
+  const occupied = taken.slice();
+  return wants.map((w) => {
+    const want = [
+      Math.max(-tray2.halfWidth + margin, Math.min(tray2.halfWidth - margin, w[0])),
+      0,
+      Math.max(-tray2.halfDepth + margin, Math.min(tray2.halfDepth - margin, w[2]))
+    ];
+    let best;
+    let bestD = Number.POSITIVE_INFINITY;
+    for (const s of spots) {
+      if (occupied.some((q) => (s[0] - q[0]) ** 2 + (s[2] - q[2]) ** 2 < spacing ** 2 * 0.81))
+        continue;
+      const d = (s[0] - want[0]) ** 2 + (s[2] - want[2]) ** 2;
+      if (d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    const spot = best ?? want;
+    occupied.push(spot);
+    return spot;
+  });
+}
+function placeDie(track, body, spot, rotation, geometry, scale) {
+  const n = track.bodyCount;
+  const rest = restingHeight(geometry, rotation, scale);
+  const from = Math.max(0, track.steps - PLACED_DROP_STEPS);
+  const drop = 1.4;
+  const q = quatMath.normalize([0, 0, 0, 1], rotation);
+  for (let s = from; s <= track.steps; s++) {
+    const t = track.steps === from ? 1 : (s - from) / (track.steps - from);
+    const o3 = (s * n + body) * 3;
+    const o4 = (s * n + body) * 4;
+    track.positions[o3] = spot[0];
+    track.positions[o3 + 1] = rest + drop * (1 - t * t);
+    track.positions[o3 + 2] = spot[2];
+    track.rotations[o4] = q[0];
+    track.rotations[o4 + 1] = q[1];
+    track.rotations[o4 + 2] = q[2];
+    track.rotations[o4 + 3] = q[3];
+  }
+}
+const placedFrom = (track) => Math.max(0, track.steps - PLACED_DROP_STEPS);
+export {
+  DICE_CONTACTS,
+  DICE_GRAVITY,
+  DICE_MAX_STEPS,
+  DICE_STEP,
+  LAUNCH_EDGES,
+  MAX_DICE,
+  PLACED_DROP_STEPS,
+  diceSettleParams,
+  diceTrackScene,
+  entranceSpots,
+  laneLayout,
+  launchEdgeOf,
+  placeDie,
+  placedFrom,
+  placementSpots,
+  seedOf,
+  unlandedDice
+};

package/dist/tray.d.ts

@@ -0,0 +1,2 @@
+export declare const TRAY_SHADERS: Record<string, string>;
+export declare const DiceTray: import("@aethervtt/shard-render").MaterialType;

package/dist/tray.js

@@ -0,0 +1,43 @@
+import { t } from "@aethervtt/shard-core";
+import { defineMaterial } from "@aethervtt/shard-render";
+const TRAY_SHADERS = {
+  "dice::tray": `
+import shard::pbr::types::VertexOutput;
+import shard::mesh::vertex_instance_data;
+import shard::pbr::catcher::shadow_visibility;
+import material::dice_tray::DiceTray;
+
+override fn vertex_extra(position: vec3f, normal: vec3f, uv: vec2f) -> vec4f {
+  return vec4f(vertex_instance_data().x, 0.0, 0.0, 0.0);
+}
+
+override fn shade(in: VertexOutput) -> vec4f {
+  let blob = in.extra.x;
+  if (blob > 0.0) {
+    // A soft round shadow under a die: dense in the middle, gone at the quad's rim.
+    let r = length(in.uv * 2.0 - 1.0);
+    let a = 1.0 - smoothstep(0.0, 1.0, r);
+    return vec4f(0.0, 0.0, 0.0, a * a * blob * DiceTray.blobOpacity);
+  }
+  return vec4f(0.0, 0.0, 0.0, DiceTray.shadowOpacity * (1.0 - shadow_visibility(in)));
+}`
+};
+const DiceTray = defineMaterial("dice/DiceTray", {
+  extends: "none",
+  blend: "premultiplied",
+  fields: {
+    shadowOpacity: t.f32({ default: 0.55, min: 0, max: 1, description: "Alpha of full shadow." }),
+    blobOpacity: t.f32({
+      default: 0.6,
+      min: 0,
+      max: 1,
+      description: "Alpha of a contact blob under a resting die."
+    })
+  },
+  shader: "dice::tray",
+  description: "The dice tray: invisible but for the shadows it catches and the contact blobs under blended dice (and every die in the large-pool tier)."
+});
+export {
+  DiceTray,
+  TRAY_SHADERS
+};

package/dist/variants.d.ts

@@ -0,0 +1,9 @@
+import type { ShaderVariantSource } from '@aethervtt/shard-render';
+import { type DieKind } from './builtins.js';
+export interface DiceVariantEntry {
+    /** Skins by path or guid, or "*": every skin loaded or in the catalog. Default "*". */
+    skins?: '*' | string[];
+    /** Die kinds, or "*". Default "*". */
+    kinds?: '*' | DieKind[];
+}
+export declare const diceVariants: ShaderVariantSource;

package/dist/variants.js

@@ -0,0 +1,46 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import { DIE_KINDS } from "./builtins.js";
+import { renderDiceThumbnail } from "./preview.js";
+import { DiceSkin } from "./skin.js";
+const diceVariants = {
+  name: "dice",
+  description: 'Dice skins \xD7 die kinds, opaque and blended: { skins?: "*" | [path|guid], kinds?: "*" | [kind] }.',
+  async show(app, entry) {
+    const e = entry ?? {};
+    const world = app.world;
+    const store = world.resource(DiceSkin.store);
+    const ref = (guid, path) => ({
+      type: DiceSkin.name,
+      guid,
+      path
+    });
+    const skins = [];
+    if (e.skins === void 0 || e.skins === "*") {
+      const server = assetServer(world);
+      for (const asset of server.list({ type: DiceSkin.name })) {
+        await server.load(ref(asset.guid, asset.path));
+      }
+      for (const [guid] of store.entries()) skins.push(ref(guid));
+    } else {
+      for (const s of e.skins) {
+        const skin = !store.get(ref(s)) && s.endsWith(".json") ? ref(void 0, s) : ref(s);
+        if (!store.get(skin)) await assetServer(world).load(skin);
+        skins.push(skin);
+      }
+    }
+    const kinds = e.kinds === void 0 || e.kinds === "*" ? DIE_KINDS : e.kinds;
+    let shown = 0;
+    for (const skin of skins) {
+      for (const kind of kinds) {
+        for (const blended of [false, true]) {
+          await renderDiceThumbnail(app, { skin, kind, value: 1, size: 32, blended });
+          shown++;
+        }
+      }
+    }
+    return shown;
+  }
+};
+export {
+  diceVariants
+};

package/dist/windows.d.ts

@@ -0,0 +1,25 @@
+import { type AssetRef, type Entity, type World } from '@aethervtt/shard-core';
+import type { DiceSceneContext } from './attachments.js';
+/** Where a window sits over a die, in die radii. */
+export interface DiceWindow {
+    /** Center from the die's center (or `at`): x right, y up on screen. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Turn on screen, radians counter-clockwise. */
+    turn: number;
+    /** Toward the camera from the die's center, in die radii (0: at its depth). */
+    lift: number;
+    /** Where it's centered in the world, instead of the die's position (an entrance's rest spot). */
+    at?: ArrayLike<number>;
+}
+/**
+ * Spawns a window facing the dice camera over a die, with `material`. A window lifted toward the
+ * camera is moved along the line from the camera and scaled by how much nearer it got, so it covers
+ * the pixels it would at the die's depth: windows at different depths (a disk's far half behind the
+ * die, its near band over it) line up wherever the die is.
+ */
+export declare function spawnDiceWindow(ctx: Pick<DiceSceneContext, 'world' | 'die' | 'scale' | 'camera'>, material: AssetRef<'Material'>, window: DiceWindow): Entity;
+/** Vertices the meshes of `entities` draw (their Mesh3d), for holding scenes to their budgets. */
+export declare function meshVertices(world: World, entities: readonly Entity[]): number;

package/dist/windows.js

@@ -0,0 +1,77 @@
+import { quat } from "@aethervtt/shard-core";
+import { plane } from "@aethervtt/shard-mesh";
+import {
+  Mesh3d,
+  Meshes,
+  MeshMaterial,
+  NotShadowCaster,
+  NotShadowReceiver
+} from "@aethervtt/shard-render";
+import { Transform } from "@aethervtt/shard-transform";
+const quads = /* @__PURE__ */ new WeakMap();
+function quadOf(world) {
+  let mesh = quads.get(world);
+  if (!mesh) {
+    mesh = world.resource(Meshes).add(plane({ size: 2 }), "dice:window");
+    quads.set(world, mesh);
+  }
+  return mesh;
+}
+function spawnDiceWindow(ctx, material, window) {
+  const w = ctx.world;
+  const { rotation: cam, translation: eye } = w.get(ctx.camera, Transform);
+  const [qx, qy, qz, qw] = cam;
+  const rx = 1 - 2 * (qy * qy + qz * qz);
+  const ry = 2 * (qx * qy + qw * qz);
+  const rz = 2 * (qx * qz - qw * qy);
+  const ux = 2 * (qx * qy - qw * qz);
+  const uy = 1 - 2 * (qx * qx + qz * qz);
+  const uz = 2 * (qy * qz + qw * qx);
+  const at = window.at ?? w.get(ctx.die, Transform).translation;
+  const s = ctx.scale;
+  const px = at[0] + (rx * window.x + ux * window.y) * s - eye[0];
+  const py = at[1] + (ry * window.x + uy * window.y) * s - eye[1];
+  const pz = at[2] + (rz * window.x + uz * window.y) * s - eye[2];
+  const dx = at[0] - eye[0];
+  const dy = at[1] - eye[1];
+  const dz = at[2] - eye[2];
+  const d = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  const f = Math.max(0.05, (d - window.lift * s) / d);
+  const face = quat.multiply(
+    [0, 0, 0, 1],
+    cam,
+    quat.multiply(
+      [0, 0, 0, 1],
+      quat.fromEuler([0, 0, 0, 1], 0, 0, window.turn),
+      quat.fromEuler([0, 0, 0, 1], Math.PI / 2, 0, 0)
+    )
+  );
+  return w.spawn(
+    [Mesh3d, { mesh: quadOf(w) }],
+    [MeshMaterial, { material }],
+    NotShadowCaster,
+    NotShadowReceiver,
+    [
+      Transform,
+      {
+        translation: [eye[0] + px * f, eye[1] + py * f, eye[2] + pz * f],
+        rotation: face,
+        scale: [window.width / 2 * s * f, 1, window.height / 2 * s * f]
+      }
+    ]
+  );
+}
+function meshVertices(world, entities) {
+  const meshes = world.resource(Meshes);
+  let n = 0;
+  for (const e of entities) {
+    const ref = world.isAlive(e) ? world.tryGet(e, Mesh3d)?.mesh : void 0;
+    const mesh = ref ? meshes.get(ref) : void 0;
+    if (mesh) n += mesh.positions.length / 3;
+  }
+  return n;
+}
+export {
+  meshVertices,
+  spawnDiceWindow
+};

package/dist/worker.d.ts

@@ -0,0 +1,6 @@
+export { DICE_SETTLE_RULE, diceSettle } from './settle.js';
+/**
+ * The dice worker, bundled by the host's bundler (the `new Worker(new URL(…, import.meta.url))`
+ * form Vite and webpack recognize): 0053's track server with `dice-settle` registered.
+ */
+export declare function diceWorker(): Worker;

package/dist/worker.js

@@ -0,0 +1,9 @@
+import { DICE_SETTLE_RULE, diceSettle } from "./settle.js";
+function diceWorker() {
+  return new Worker(new URL("./dice-worker.js", import.meta.url), { type: "module" });
+}
+export {
+  DICE_SETTLE_RULE,
+  diceSettle,
+  diceWorker
+};

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@aethervtt/shard-dice",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "default": "./dist/worker.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-assets": "0.1.0",
+    "@aethervtt/shard-audio": "0.1.0",
+    "@aethervtt/shard-core": "0.1.0",
+    "@aethervtt/shard-gpu": "0.1.0",
+    "@aethervtt/shard-mesh": "0.1.0",
+    "@aethervtt/shard-particles": "0.1.0",
+    "@aethervtt/shard-physics": "0.1.0",
+    "@aethervtt/shard-protocol": "0.1.0",
+    "@aethervtt/shard-render": "0.1.0",
+    "@aethervtt/shard-runtime": "0.1.0",
+    "@aethervtt/shard-text": "0.1.0",
+    "@aethervtt/shard-texture": "0.1.0",
+    "@aethervtt/shard-transform": "0.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/dice"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
+  }
+}