@aethervtt/shard-dice 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,3 @@
-# Temporary Holding Version
+# @aethervtt/shard-dice
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/attachments.d.ts

@@ -0,0 +1,79 @@
+import type { AudioClipAsset, PlaySoundOptions } from '@aethervtt/shard-audio';
+import { type AssetRef, type Entity, type World } from '@aethervtt/shard-core';
+import type { ScreenEffectParams } from '@aethervtt/shard-render';
+import type { DieKind } from './builtins.js';
+import type { AccentCue } from './sound.js';
+export declare const MAX_ATTACHMENTS = 4;
+/**
+ * What the registries hold scenes to (0065): vertices an attachment or an entrance may declare, and
+ * an entrance's longest run. Module-wide, like the registries: set them before defining.
+ */
+export declare const DICE_BUDGETS: {
+    attachmentVertices: number;
+    entranceVertices: number;
+    entranceMs: number;
+};
+/** Raises (or lowers) the budgets; call it before defining attachments and entrances. */
+export declare function setDiceBudgets(budgets: Partial<typeof DICE_BUDGETS>): void;
+/** What a host scene on a die (an attachment, or an entrance, 0065) can reach and do. */
+export interface DiceSceneContext {
+    world: World;
+    /** The die: parent what you spawn to it (ChildOf) so it follows the die. */
+    die: Entity;
+    kind: DieKind;
+    value: number;
+    label: string;
+    /** The die's world scale. */
+    scale: number;
+    /** From the recipe effect that named the scene, so one scene serves many skins. */
+    params: Record<string, unknown>;
+    /** The dice camera: face it (spawnDiceWindow). */
+    camera: Entity;
+    /** From the roll and the die: variation that's the same for every viewer. */
+    seed: number;
+    /** The roll's sound gain, 0..1 (`sound` applies it). */
+    soundGain: number;
+    /** Where a world point (default: the die) is in the dice view's CSS pixels; null behind the camera. */
+    screen(point?: ArrayLike<number>): [number, number] | null;
+    /**
+     * Publishes (or refreshes) a lens field (0063) centered on the die, in the dice view's CSS
+     * pixels. False when the table doesn't allow fields (reduced motion, effects off, large pools)
+     * or 4 others are live.
+     */
+    lens(field: {
+        radius: number;
+        strength: number;
+        ttlMs?: number;
+    }): boolean;
+    /**
+     * Publishes (or refreshes) a screen effect (0065) of this kind, centered on the die (or `at`),
+     * for the host's table to draw (`fire`). False when the table doesn't allow effects or 8 are live.
+     */
+    effect(effect: {
+        kind: string;
+        radius: number;
+        ttlMs?: number;
+        params?: ScreenEffectParams;
+        at?: ArrayLike<number>;
+    }): boolean;
+    /** Plays a clip at the roll's sound gain (a range scales too); stopped when the roll ends. -1 without audio. */
+    sound(clip: AssetRef | AudioClipAsset, options?: PlaySoundOptions): number;
+    /** Plays one of the package's accent cues. */
+    cue(cue: AccentCue, gain?: number): void;
+}
+export type DiceAttachmentContext = DiceSceneContext;
+export interface DiceAttachmentDef {
+    /** Vertices it draws, within `DICE_BUDGETS.attachmentVertices`: declared, and held to. */
+    vertices: number;
+    /** Spawns the scene. Returns what it spawned (the package despawns it). */
+    spawn(ctx: DiceAttachmentContext): Entity[];
+    /**
+     * Runs each frame while it's alive, with seconds since it spawned; frames keep coming while any
+     * attachment has one. Return true to keep it, false when it's done (it's despawned).
+     */
+    update?(ctx: DiceAttachmentContext, seconds: number, entities: readonly Entity[]): boolean;
+}
+/** Registers a scene recipes can attach to landed dice by name. */
+export declare function defineDiceAttachment(name: string, def: DiceAttachmentDef): DiceAttachmentDef;
+export declare function findDiceAttachment(name: string): DiceAttachmentDef | undefined;
+export declare function allDiceAttachments(): string[];

package/dist/attachments.js

@@ -0,0 +1,43 @@
+import { ShardError } from "@aethervtt/shard-core";
+const MAX_ATTACHMENTS = 4;
+const DICE_BUDGETS = {
+  attachmentVertices: 12e3,
+  entranceVertices: 6e4,
+  entranceMs: 8e3
+};
+function setDiceBudgets(budgets) {
+  Object.assign(DICE_BUDGETS, budgets);
+}
+const attachments = /* @__PURE__ */ new Map();
+function defineDiceAttachment(name, def) {
+  const budget = DICE_BUDGETS.attachmentVertices;
+  if (!(def.vertices > 0) || def.vertices > budget) {
+    throw new ShardError(
+      "dice/attachment-budget",
+      `Attachment "${name}" declares ${def.vertices} vertices; the budget is ${budget}`,
+      { hint: "Draw fewer vertices, split the effect, or raise it with setDiceBudgets first." }
+    );
+  }
+  const existing = attachments.get(name);
+  if (existing && existing !== def) {
+    throw new ShardError("dice/registry-conflict", `Attachment "${name}" is already defined`, {
+      hint: "Give the new attachment its own name."
+    });
+  }
+  attachments.set(name, def);
+  return def;
+}
+function findDiceAttachment(name) {
+  return attachments.get(name);
+}
+function allDiceAttachments() {
+  return [...attachments.keys()].sort();
+}
+export {
+  DICE_BUDGETS,
+  MAX_ATTACHMENTS,
+  allDiceAttachments,
+  defineDiceAttachment,
+  findDiceAttachment,
+  setDiceBudgets
+};

package/dist/builtins.d.ts

@@ -0,0 +1,25 @@
+import { type DieDefinition } from './definition.js';
+export declare const D4: DieDefinition;
+export declare const D6: DieDefinition;
+export declare const D8: DieDefinition;
+/** A d10 printing 1–9 and 0 (the value 10). Opposite digits sum to 9, so it doesn't opt in. */
+export declare const D10: DieDefinition;
+/** A percentile's tens die: the d10's shape and numbering, printing 10–90 and 00 (the value 10). */
+export declare const D10_TENS: DieDefinition;
+export declare const D12: DieDefinition;
+export declare const D20: DieDefinition;
+export declare const D100_BALL: DieDefinition;
+export declare const BUILTIN_DICE: readonly DieDefinition[];
+/** Registers the built-ins (idempotent). The dice plugin calls it; tests and tools can too. */
+export declare function registerBuiltinDice(): void;
+/** The kinds a roll names, and the definitions each plays (percentile plays two). */
+export declare const DIE_KINDS: readonly ['d4', 'd6', 'd8', 'd10', 'd12', 'd20', 'd100', 'percentile'];
+export type DieKind = (typeof DIE_KINDS)[number];
+export declare const KIND_DEFINITIONS: Readonly<Record<DieKind, readonly string[]>>;
+/** The values a kind can show: percentile 1..100 over its two dice. */
+export declare function kindSides(kind: DieKind): number;
+/**
+ * A percentile value as its two dice's values: tens then units. 100 shows 00 and 0, and 7 shows 00
+ * and 7. Each d10 value 10 prints as its zero ('00' on the tens die, '0' on the units die).
+ */
+export declare function percentileValues(value: number): [number, number];

package/dist/builtins.js

@@ -0,0 +1,335 @@
+import { defineDie } from "./definition.js";
+const PHI = (1 + Math.sqrt(5)) / 2;
+function unitRadius(points) {
+  const c = [0, 1, 2].map((k) => points.reduce((s, p) => s + p[k], 0) / points.length);
+  const centered = points.map((p) => p.map((v, k) => v - c[k]));
+  const r = Math.max(...centered.map((p) => Math.sqrt(p[0] ** 2 + p[1] ** 2 + p[2] ** 2)));
+  return Float32Array.from(centered.flatMap((p) => p.map((v) => v / r)));
+}
+const R0 = 0.7799999713897705;
+const R1 = 0.6310332417488098;
+const R2 = 0.24103325605392456;
+const Z1 = 0.45847249031066895;
+const Z2 = 0.7418240904808044;
+const RING = 0.10557281225919724;
+const TRAPEZOHEDRON = Float32Array.from([
+  0,
+  1,
+  0,
+  0,
+  -1,
+  0,
+  R0,
+  RING,
+  0,
+  R1,
+  -RING,
+  Z1,
+  R2,
+  RING,
+  Z2,
+  -R2,
+  -RING,
+  Z2,
+  -R1,
+  RING,
+  Z1,
+  -R0,
+  -RING,
+  0,
+  -R1,
+  RING,
+  -Z1,
+  -R2,
+  -RING,
+  -Z2,
+  R2,
+  RING,
+  -Z2,
+  R1,
+  -RING,
+  -Z1
+]);
+function dodecahedron() {
+  const inverse = 1 / PHI;
+  const out = [];
+  for (const x of [-1, 1]) for (const y of [-1, 1]) for (const z of [-1, 1]) out.push([x, y, z]);
+  for (const a of [-inverse, inverse]) {
+    for (const b of [-PHI, PHI]) out.push([0, a, b], [a, b, 0], [b, 0, a]);
+  }
+  return out;
+}
+const D10_VALUES = {
+  "1:9:10:11": 8,
+  "1:7:8:9": 10,
+  "1:2:3:11": 2,
+  "1:5:6:7": 4,
+  "1:3:4:5": 6,
+  "0:8:9:10": 3,
+  "0:2:10:11": 5,
+  "0:6:7:8": 7,
+  "0:2:3:4": 9,
+  "0:4:5:6": 1
+};
+const D4 = {
+  version: 1,
+  id: "d4",
+  sides: 4,
+  vertices: unitRadius([
+    [1, 1, 1],
+    [-1, -1, 1],
+    [-1, 1, -1],
+    [1, -1, -1]
+  ]),
+  read: "vertex",
+  // Aether numbers the d4's vertices by direction: sorted by y, then z, then x.
+  values: { "0": 4, "1": 2, "2": 3, "3": 1 },
+  collider: "hull",
+  sizeMm: 15,
+  bevel: 0.06,
+  markScale: 0.31
+};
+const D6 = {
+  version: 1,
+  id: "d6",
+  sides: 6,
+  vertices: unitRadius([
+    [-1, -1, -1],
+    [-1, -1, 1],
+    [-1, 1, -1],
+    [-1, 1, 1],
+    [1, -1, -1],
+    [1, -1, 1],
+    [1, 1, -1],
+    [1, 1, 1]
+  ]),
+  read: "face",
+  values: {
+    "0:1:4:5": 1,
+    "0:2:4:6": 2,
+    "0:1:2:3": 3,
+    "4:5:6:7": 4,
+    "1:3:5:7": 5,
+    "2:3:6:7": 6
+  },
+  collider: "hull",
+  sizeMm: 16,
+  bevel: 0.082,
+  markScale: 0.5,
+  oppositesSum: true
+};
+const D8 = {
+  version: 1,
+  id: "d8",
+  sides: 8,
+  vertices: unitRadius([
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 1, 0],
+    [0, -1, 0],
+    [0, 0, 1],
+    [0, 0, -1]
+  ]),
+  read: "face",
+  values: {
+    "1:3:5": 2,
+    "0:3:5": 6,
+    "1:3:4": 8,
+    "0:3:4": 4,
+    "1:2:5": 5,
+    "0:2:5": 1,
+    "1:2:4": 3,
+    "0:2:4": 7
+  },
+  collider: "hull",
+  sizeMm: 16,
+  bevel: 0.082,
+  markScale: 0.4,
+  oppositesSum: true
+};
+const D10 = {
+  version: 1,
+  id: "d10",
+  sides: 10,
+  vertices: TRAPEZOHEDRON,
+  read: "face",
+  values: D10_VALUES,
+  labels: { 10: "0" },
+  collider: "hull",
+  sizeMm: 16,
+  bevel: 0.13,
+  markScale: 0.36
+};
+const D10_TENS = {
+  version: 1,
+  id: "d10-tens",
+  sides: 10,
+  vertices: TRAPEZOHEDRON,
+  read: "face",
+  values: D10_VALUES,
+  labels: {
+    1: "10",
+    2: "20",
+    3: "30",
+    4: "40",
+    5: "50",
+    6: "60",
+    7: "70",
+    8: "80",
+    9: "90",
+    10: "00"
+  },
+  collider: "hull",
+  sizeMm: 16,
+  bevel: 0.13,
+  markScale: 0.32
+};
+const D12 = {
+  version: 1,
+  id: "d12",
+  sides: 12,
+  vertices: unitRadius(dodecahedron()),
+  read: "face",
+  values: {
+    "1:5:9:11:15": 4,
+    "0:4:8:9:15": 7,
+    "4:5:13:15:19": 11,
+    "0:1:9:10:16": 5,
+    "0:2:8:10:14": 10,
+    "4:6:8:13:14": 1,
+    "1:3:11:16:17": 12,
+    "5:7:11:17:19": 3,
+    "2:3:10:12:16": 2,
+    "6:7:13:18:19": 8,
+    "2:6:12:14:18": 9,
+    "3:7:12:17:18": 6
+  },
+  collider: "hull",
+  sizeMm: 14,
+  bevel: 0.082,
+  markScale: 0.42,
+  oppositesSum: true
+};
+const D20 = {
+  version: 1,
+  id: "d20",
+  sides: 20,
+  vertices: unitRadius([
+    [-1, PHI, 0],
+    [1, PHI, 0],
+    [-1, -PHI, 0],
+    [1, -PHI, 0],
+    [0, -1, PHI],
+    [0, 1, PHI],
+    [0, -1, -PHI],
+    [0, 1, -PHI],
+    [PHI, 0, -1],
+    [PHI, 0, 1],
+    [-PHI, 0, -1],
+    [-PHI, 0, 1]
+  ]),
+  read: "face",
+  values: {
+    "2:3:6": 1,
+    "2:3:4": 19,
+    "2:6:10": 13,
+    "3:6:8": 7,
+    "2:4:11": 10,
+    "3:4:9": 3,
+    "2:10:11": 12,
+    "3:8:9": 17,
+    "6:7:10": 6,
+    "6:7:8": 16,
+    "4:5:11": 5,
+    "4:5:9": 15,
+    "0:10:11": 4,
+    "1:8:9": 9,
+    "0:7:10": 18,
+    "1:7:8": 11,
+    "0:5:11": 14,
+    "1:5:9": 8,
+    "0:1:7": 2,
+    "0:1:5": 20
+  },
+  collider: "hull",
+  sizeMm: 18,
+  bevel: 0.082,
+  markScale: 0.38,
+  oppositesSum: true
+};
+function fibonacciSphere(count) {
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  const out = new Float32Array(count * 3);
+  for (let i = 0; i < count; i++) {
+    const y = 1 - (i + 0.5) * 2 / count;
+    const r = Math.sqrt(1 - y * y);
+    const a = i * golden;
+    out[i * 3] = Math.cos(a) * r;
+    out[i * 3 + 1] = y;
+    out[i * 3 + 2] = Math.sin(a) * r;
+  }
+  return out;
+}
+const D100_BALL = {
+  version: 1,
+  id: "d100-ball",
+  sides: 100,
+  vertices: fibonacciSphere(100),
+  read: "face",
+  values: Object.fromEntries(Array.from({ length: 100 }, (_, i) => [String(i), i + 1])),
+  collider: "ball",
+  sizeMm: 22,
+  bevel: 0.1,
+  markScale: 0.3
+};
+const BUILTIN_DICE = [
+  D4,
+  D6,
+  D8,
+  D10,
+  D10_TENS,
+  D12,
+  D20,
+  D100_BALL
+];
+let registered = false;
+function registerBuiltinDice() {
+  if (registered) return;
+  registered = true;
+  for (const def of BUILTIN_DICE) defineDie(def);
+}
+const DIE_KINDS = ["d4", "d6", "d8", "d10", "d12", "d20", "d100", "percentile"];
+const KIND_DEFINITIONS = {
+  d4: ["d4"],
+  d6: ["d6"],
+  d8: ["d8"],
+  d10: ["d10"],
+  d12: ["d12"],
+  d20: ["d20"],
+  d100: ["d100-ball"],
+  percentile: ["d10-tens", "d10"]
+};
+function kindSides(kind) {
+  return kind === "percentile" || kind === "d100" ? 100 : Number(kind.slice(1));
+}
+function percentileValues(value) {
+  const tens = Math.floor(value % 100 / 10);
+  const units = value % 10;
+  return [tens === 0 ? 10 : tens, units === 0 ? 10 : units];
+}
+export {
+  BUILTIN_DICE,
+  D10,
+  D100_BALL,
+  D10_TENS,
+  D12,
+  D20,
+  D4,
+  D6,
+  D8,
+  DIE_KINDS,
+  KIND_DEFINITIONS,
+  kindSides,
+  percentileValues,
+  registerBuiltinDice
+};

package/dist/cells.d.ts

@@ -0,0 +1,33 @@
+import type { DieGeometry } from './definition.js';
+import { type V3 } from './math.js';
+export interface FaceCell {
+    face: number;
+    /** The value the face reads (undefined on a d4: its marks are per corner). */
+    value: number | undefined;
+    col: number;
+    row: number;
+    /** The face's frame: marks read up along `bitangent`. */
+    tangent: V3;
+    bitangent: V3;
+    center: V3;
+    /** Half the side of the square, in face units, that maps onto the cell's inner square. */
+    extent: number;
+}
+export interface CellLayout {
+    cols: number;
+    rows: number;
+    /** Cell side in atlas pixels. */
+    cell: number;
+    /** Margin inside each cell, as a fraction of its side. */
+    pad: number;
+    faces: FaceCell[];
+}
+export declare const CELL_PAD = 0.06;
+/** Distance range of the atlas, in pixels: marks shade from ±range / 2 of their outline. */
+export declare const MARK_RANGE = 8;
+/** The cells of a die's faces: a near-square grid, faces in polytope order. */
+export declare function cellLayout(g: DieGeometry): CellLayout;
+/** A point on a face in its cell's pixels: x right, y up from the cell's bottom-left corner. */
+export declare function cellPixel(layout: CellLayout, cell: FaceCell, p: V3): [number, number];
+/** A point on a face as atlas UVs (v down, as textures sample). */
+export declare function cellUv(layout: CellLayout, cell: FaceCell, p: V3, out: number[], o: number): void;

package/dist/cells.js

@@ -0,0 +1,53 @@
+import { cross, dot, stableTangent, sub } from "./math.js";
+const CELL_PAD = 0.06;
+const MARK_RANGE = 8;
+const layouts = /* @__PURE__ */ new WeakMap();
+function cellLayout(g) {
+  const cached = layouts.get(g);
+  if (cached) return cached;
+  const faces = g.polytope.faces;
+  const cols = Math.ceil(Math.sqrt(faces.length));
+  const rows = Math.ceil(faces.length / cols);
+  const cell = faces.length <= 24 ? 128 : 64;
+  const out = faces.map((face, i) => {
+    const value = g.faceValues[i];
+    const frame = value === void 0 ? void 0 : g.frames[value - 1];
+    const tangent = frame ? frame.tangent : stableTangent(face.normal);
+    const bitangent = frame ? frame.bitangent : cross(face.normal, tangent);
+    let extent = 1e-6;
+    for (const v of face.vertices) {
+      const d = sub(g.polytope.points[v], face.center);
+      extent = Math.max(extent, Math.abs(dot(d, tangent)), Math.abs(dot(d, bitangent)));
+    }
+    return {
+      face: i,
+      value,
+      col: i % cols,
+      row: Math.floor(i / cols),
+      tangent,
+      bitangent,
+      center: face.center,
+      extent
+    };
+  });
+  const layout = { cols, rows, cell, pad: CELL_PAD, faces: out };
+  layouts.set(g, layout);
+  return layout;
+}
+function cellPixel(layout, cell, p) {
+  const d = sub(p, cell.center);
+  const k = layout.cell * (1 - 2 * layout.pad) / (2 * cell.extent);
+  return [layout.cell / 2 + dot(d, cell.tangent) * k, layout.cell / 2 + dot(d, cell.bitangent) * k];
+}
+function cellUv(layout, cell, p, out, o) {
+  const [x, y] = cellPixel(layout, cell, p);
+  out[o] = (cell.col * layout.cell + x) / (layout.cols * layout.cell);
+  out[o + 1] = (cell.row * layout.cell + (layout.cell - y)) / (layout.rows * layout.cell);
+}
+export {
+  CELL_PAD,
+  MARK_RANGE,
+  cellLayout,
+  cellPixel,
+  cellUv
+};

package/dist/components.d.ts

@@ -0,0 +1,14 @@
+/** A die on the table. Spawned and despawned by the dice table; read-only to everyone else. */
+export declare const DiceDie: import("@aethervtt/shard-core").ComponentDef<{
+    readonly index: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly kind: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly definition: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly value: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly label: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly dropped: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;
+/** Scene hook: an entity with this plays its roll when it appears (for shard screenshot, tests). */
+export declare const DiceRollRequest: import("@aethervtt/shard-core").ComponentDef<{
+    readonly roll: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+    readonly replace: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;

package/dist/components.js

@@ -0,0 +1,27 @@
+import { defineComponent, t } from "@aethervtt/shard-core";
+const DiceDie = defineComponent(
+  "dice/Die",
+  {
+    index: t.u8({ description: "Its body in the roll (percentile dice are two bodies)." }),
+    kind: t.string({ description: "The roll die kind: d4 \u2026 d20, d100, percentile." }),
+    definition: t.string({ description: "The die definition it shows." }),
+    value: t.u16({ description: "The definition's value on top once landed." }),
+    label: t.string({ description: "The printed mark on top." }),
+    dropped: t.bool({ description: "A dropped die: excluded from effects and attachments." })
+  },
+  { description: "A die the dice table is presenting." }
+);
+const DiceRollRequest = defineComponent(
+  "dice/RollRequest",
+  {
+    roll: t.json({
+      description: "A DiceRoll: { id, dice: [{ kind, value, skin: { guid } }], seed, tray, motion, \u2026 }."
+    }),
+    replace: t.bool({ description: "Dismiss a roll that is playing instead of waiting for it." })
+  },
+  { description: "Plays a dice roll when spawned; removed once the table takes it." }
+);
+export {
+  DiceDie,
+  DiceRollRequest
+};

package/dist/definition-asset.d.ts

@@ -0,0 +1,19 @@
+import { type Infer } from '@aethervtt/shard-core';
+import type { DieDefinition } from './definition.js';
+export declare const DieDefinitionAsset: import("@aethervtt/shard-assets").DataType<{
+    readonly version: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly id: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly sides: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly vertices: import("@aethervtt/shard-core").FieldType<number[], "object">;
+    readonly read: import("@aethervtt/shard-core").FieldType<"face" | "vertex", "u8">;
+    readonly values: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+    readonly labels: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").JsonValue, "object">;
+    readonly collider: import("@aethervtt/shard-core").FieldType<"ball" | "hull", "u8">;
+    readonly sizeMm: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly bevel: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly markScale: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly oppositesSum: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}, "dice/DieDefinition">;
+export type DieDefinitionAssetValue = Infer<typeof DieDefinitionAsset>;
+/** The definition a `*.die.json` describes (check it with validateDieDefinition). */
+export declare function dieDefinitionOf(value: DieDefinitionAssetValue): DieDefinition;