@aethervtt/shard-dice 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,322 @@
+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_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
+};

package/dist/layout.d.ts

@@ -0,0 +1,75 @@
+import { type AssetRef, type FieldValue, type Infer, ShardError } from '@aethervtt/shard-core';
+import { type DieDefinition } from './definition.js';
+export declare const FaceMarkSchema: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+    kind: import("@aethervtt/shard-core").FieldType<"blank" | "glyph" | "pips" | "text", "u8">;
+    text: import("@aethervtt/shard-core").FieldType<string, "object">;
+    font: import("@aethervtt/shard-core").FieldType<AssetRef<"Font"> | null, "object">;
+    size: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    weight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    underline: import("@aethervtt/shard-core").FieldType<"always" | "auto" | "never", "u8">;
+    count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    glyph: import("@aethervtt/shard-core").FieldType<string, "object">;
+    rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>, "object">;
+/** A face layout: `data/**\/*.dice-layout.json`. */
+export declare const FaceLayout: import("@aethervtt/shard-assets").DataType<{
+    readonly version: import("@aethervtt/shard-core").FieldType<number, "u8">;
+    readonly id: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly default: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        kind: import("@aethervtt/shard-core").FieldType<"blank" | "glyph" | "pips" | "text", "u8">;
+        text: import("@aethervtt/shard-core").FieldType<string, "object">;
+        font: import("@aethervtt/shard-core").FieldType<AssetRef<"Font"> | null, "object">;
+        size: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        weight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        underline: import("@aethervtt/shard-core").FieldType<"always" | "auto" | "never", "u8">;
+        count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+        glyph: import("@aethervtt/shard-core").FieldType<string, "object">;
+        rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    }>, "object">;
+    readonly overrides: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        value: import("@aethervtt/shard-core").FieldType<number, "u16">;
+        mark: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+            kind: import("@aethervtt/shard-core").FieldType<"blank" | "glyph" | "pips" | "text", "u8">;
+            text: import("@aethervtt/shard-core").FieldType<string, "object">;
+            font: import("@aethervtt/shard-core").FieldType<AssetRef<"Font"> | null, "object">;
+            size: import("@aethervtt/shard-core").FieldType<number, "f32">;
+            weight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+            underline: import("@aethervtt/shard-core").FieldType<"always" | "auto" | "never", "u8">;
+            count: import("@aethervtt/shard-core").FieldType<number, "u8">;
+            glyph: import("@aethervtt/shard-core").FieldType<string, "object">;
+            rotation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+        }>, "object">;
+    }>[], "object">;
+}, "dice/FaceLayout">;
+export type FaceLayoutValue = Infer<typeof FaceLayout>;
+export type FaceMark = FieldValue<typeof FaceMarkSchema>;
+/** A mark ready to draw: text resolved to characters, pips to a count. */
+export interface ResolvedMark {
+    kind: 'text' | 'pips' | 'glyph' | 'blank';
+    text: string;
+    font: AssetRef | null;
+    size: number;
+    weight: number;
+    underline: boolean;
+    count: number;
+    glyph: string;
+    /** Radians, clockwise. */
+    rotation: number;
+}
+/** Numbers on every face: each value's label, in the built-in numerals. */
+export declare const NUMBERS_LAYOUT: FaceLayoutValue;
+/** Pips on every face (up to 9). */
+export declare const PIPS_LAYOUT: FaceLayoutValue;
+/** The layout a die uses when its skin names none: pips on a d6, numbers everywhere else. */
+export declare function defaultLayoutFor(def: DieDefinition): FaceLayoutValue;
+/** Whether a label reads as another label of the die when the die is turned around. */
+export declare function ambiguousLabel(def: DieDefinition, label: string): boolean;
+/** The mark a value prints under a layout. */
+export declare function resolveMark(layout: FaceLayoutValue, def: DieDefinition, value: number): ResolvedMark;
+/**
+ * What a layout can't show on a die, by value: pips past 9, a glyph that isn't registered, text a
+ * font can't draw. Paths point into the layout.
+ */
+export declare function layoutProblems(layout: FaceLayoutValue, def: DieDefinition, canDraw?: (text: string, font: AssetRef | null) => boolean): ShardError[];
+/** The built-in numerals draw digits only. */
+export declare function builtinCanDraw(text: string, font: AssetRef | null): boolean;

package/dist/layout.js

@@ -0,0 +1,137 @@
+import { defineDataType } from "@aethervtt/shard-assets";
+import { ShardError, t } from "@aethervtt/shard-core";
+import { labelOf } from "./definition.js";
+import { findDiceGlyph } from "./glyphs.js";
+const MARK_FIELDS = {
+  kind: t.enum(["text", "pips", "glyph", "blank"], {
+    description: "text prints characters (the value's label unless `text` says otherwise); pips draws dots; glyph draws a registered vector path; blank prints nothing."
+  }),
+  text: t.string({ description: "Text marks: what to print. Empty prints the value's label." }),
+  font: t.handle("Font", {
+    description: "Text marks: the font's outlines. Null uses the built-in numerals (digits only)."
+  }),
+  size: t.f32({ default: 1, min: 0.2, max: 2, description: "Scales the die's mark size." }),
+  weight: t.f32({
+    default: 0.035,
+    min: -0.05,
+    max: 0.12,
+    unit: "em",
+    description: "Thickens (or thins) text and glyph strokes, from the distance field."
+  }),
+  underline: t.enum(["auto", "always", "never"], {
+    description: "auto underlines a label that reads as another of the die\u2019s labels upside down (6 and 9, 16 and 91)."
+  }),
+  count: t.u8({ max: 9, description: "Pips: how many. 0 draws the value." }),
+  glyph: t.string({
+    description: "Glyph marks: the name of a registered glyph (defineDiceGlyph)."
+  }),
+  rotation: t.f32({ unit: "deg", description: "Turns the mark on its face, clockwise." })
+};
+const FaceMarkSchema = t.struct(MARK_FIELDS, { description: "One mark on a face." });
+const FaceLayout = defineDataType(
+  "dice/FaceLayout",
+  {
+    version: t.u8({ default: 1, min: 1, max: 1, description: "Format version: 1." }),
+    id: t.string({ description: "A name for tools and errors." }),
+    default: FaceMarkSchema,
+    overrides: t.list(
+      t.struct({
+        value: t.u16({ min: 1, max: 100, description: "The value (not the face) it overrides." }),
+        mark: FaceMarkSchema
+      }),
+      { description: "Marks for particular values, by value." }
+    )
+  },
+  {
+    extension: "dice-layout",
+    description: "What each value of a die prints: a default mark, and overrides by value."
+  }
+);
+const mark = (m) => ({
+  ...FaceMarkSchema.defaultValue(),
+  ...m
+});
+const NUMBERS_LAYOUT = {
+  version: 1,
+  id: "numbers",
+  default: mark({ kind: "text" }),
+  overrides: []
+};
+const PIPS_LAYOUT = {
+  version: 1,
+  id: "pips",
+  default: mark({ kind: "pips" }),
+  overrides: []
+};
+function defaultLayoutFor(def) {
+  return def.id === "d6" ? PIPS_LAYOUT : NUMBERS_LAYOUT;
+}
+const TURNED = { "0": "0", "1": "1", "6": "9", "8": "8", "9": "6" };
+function upsideDown(label) {
+  let out = "";
+  for (let i = label.length - 1; i >= 0; i--) {
+    const c = TURNED[label[i]];
+    if (c === void 0) return void 0;
+    out += c;
+  }
+  return out;
+}
+function ambiguousLabel(def, label) {
+  const turned = upsideDown(label);
+  if (turned === void 0 || turned === label) return false;
+  for (let v = 1; v <= def.sides; v++) if (labelOf(def, v) === turned) return true;
+  return false;
+}
+function resolveMark(layout, def, value) {
+  const m = layout.overrides.find((o) => o.value === value)?.mark ?? layout.default;
+  const text = m.kind === "text" ? m.text || labelOf(def, value) : "";
+  return {
+    kind: m.kind,
+    text,
+    font: m.font,
+    size: m.size,
+    weight: m.weight,
+    underline: m.kind === "text" && (m.underline === "always" || m.underline === "auto" && ambiguousLabel(def, text)),
+    count: m.kind === "pips" ? m.count || value : 0,
+    glyph: m.glyph,
+    rotation: m.rotation * Math.PI / 180
+  };
+}
+function layoutProblems(layout, def, canDraw = builtinCanDraw) {
+  const out = [];
+  for (let value = 1; value <= def.sides; value++) {
+    const index = layout.overrides.findIndex((o) => o.value === value);
+    const path = index >= 0 ? `/overrides/${index}/mark` : "/default";
+    const m = resolveMark(layout, def, value);
+    let problem;
+    if (m.kind === "pips" && (m.count < 1 || m.count > 9)) problem = `${m.count} pips (1 to 9 draw)`;
+    else if (m.kind === "glyph" && !findDiceGlyph(m.glyph))
+      problem = m.glyph ? `glyph "${m.glyph}", which isn't registered` : "a glyph with no name";
+    else if (m.kind === "text" && !canDraw(m.text, m.font))
+      problem = `"${m.text}", which the font can't draw`;
+    if (problem) {
+      out.push(
+        new ShardError(
+          "dice/layout-missing-value",
+          `Layout "${layout.id}" can't show ${value} on a ${def.id}: it asks for ${problem}`,
+          { path, hint: `Give value ${value} a mark the die can draw, in overrides.` }
+        )
+      );
+    }
+  }
+  return out;
+}
+function builtinCanDraw(text, font) {
+  return font !== null || /^[0-9]+$/.test(text);
+}
+export {
+  FaceLayout,
+  FaceMarkSchema,
+  NUMBERS_LAYOUT,
+  PIPS_LAYOUT,
+  ambiguousLabel,
+  builtinCanDraw,
+  defaultLayoutFor,
+  layoutProblems,
+  resolveMark
+};