pollyroll 0.1.0

package/dist/chunk-OEMS7CZP.cjs

@@ -0,0 +1,251 @@
+'use strict';
+
+// src/core/notation.ts
+var PollyrollSyntaxError = class extends Error {
+  index;
+  constructor(message, index) {
+    super(message);
+    this.name = "PollyrollSyntaxError";
+    this.index = index;
+  }
+};
+var MAX_LENGTH = 256;
+var MAX_TERMS = 20;
+var MAX_COUNT = 100;
+var MAX_DICE = 200;
+var MAX_CONSTANT = 999999;
+var WHITESPACE = /\s/;
+var SIZES = {
+  "4": "d4",
+  "6": "d6",
+  "8": "d8",
+  "10": "d10",
+  "12": "d12",
+  "20": "d20",
+  "100": "d100"
+};
+var isDigit = (c) => c >= "0" && c <= "9";
+function parse(notation) {
+  if (typeof notation !== "string") {
+    throw new PollyrollSyntaxError("Notation must be a string", 0);
+  }
+  if (notation.length > MAX_LENGTH) {
+    throw new PollyrollSyntaxError("Notation is longer than 256 characters", MAX_LENGTH);
+  }
+  const chars = [];
+  const origin = [];
+  for (let i = 0; i < notation.length; i++) {
+    const c = notation.charAt(i);
+    if (WHITESPACE.test(c)) continue;
+    chars.push(c >= "A" && c <= "Z" ? c.toLowerCase() : c);
+    origin.push(i);
+  }
+  if (chars.length === 0) {
+    throw new PollyrollSyntaxError("Notation is empty", 0);
+  }
+  let pos = 0;
+  const peek = (offset = 0) => chars[pos + offset] ?? "";
+  const word2 = (w) => chars.slice(pos, pos + w.length).join("") === w;
+  const fail = (message, at) => new PollyrollSyntaxError(message, origin[at] ?? notation.length);
+  const unexpected = () => {
+    const at = origin[pos];
+    return at === void 0 ? fail("Unexpected end of notation", pos) : fail(`Unexpected character "${notation.charAt(at)}"`, pos);
+  };
+  const digits = () => {
+    let s = "";
+    while (isDigit(peek())) {
+      s += peek();
+      pos++;
+    }
+    return s;
+  };
+  const parseDie = () => {
+    const c = peek();
+    if (c === "%" || c === "f") {
+      pos++;
+      return c === "%" ? "d100" : "dF";
+    }
+    if (!isDigit(c)) throw unexpected();
+    const sizeAt = pos;
+    const size = digits();
+    const die = SIZES[size];
+    if (!die) throw fail(`Unsupported die size d${size}`, sizeAt);
+    return die;
+  };
+  const parseTerm = (sign2) => {
+    if (word2("adv") || word2("dis")) {
+      const mode = peek() === "a" ? "kh" : "kl";
+      pos += 3;
+      return { kind: "dice", sign: sign2, count: 2, die: "d20", keep: { mode, n: 1 }, explode: false };
+    }
+    let count = 1;
+    if (isDigit(peek())) {
+      const countAt = pos;
+      count = Number(digits());
+      if (word2("adv") || word2("dis")) throw fail("adv and dis take no dice count", pos);
+      if (peek() !== "d") {
+        if (count > MAX_CONSTANT) throw fail("Constant is larger than 999999", countAt);
+        return { kind: "constant", sign: sign2, value: count };
+      }
+      if (count < 1 || count > MAX_COUNT) {
+        throw fail("Dice count must be between 1 and 100", countAt);
+      }
+    } else if (peek() !== "d") {
+      throw unexpected();
+    }
+    pos++;
+    const die = parseDie();
+    let keep = null;
+    let explode = false;
+    for (; ; ) {
+      const c = peek();
+      const next = peek(1);
+      if (c === "!" || c === "x") {
+        if (explode) throw fail("A term can explode only once", pos);
+        if (die === "dF") throw fail("Fudge dice cannot explode", pos);
+        explode = true;
+        pos++;
+      } else if (c === "k" || c === "d") {
+        if (keep) throw fail("A term can have only one keep or drop", pos);
+        const side = next === "h" || next === "l" ? next : c === "k" ? "h" : "l";
+        const mode = c === "k" ? side === "h" ? "kh" : "kl" : side === "h" ? "dh" : "dl";
+        let nAt = pos;
+        pos += next === side ? 2 : 1;
+        let n = 1;
+        if (isDigit(peek())) {
+          nAt = pos;
+          n = Number(digits());
+        }
+        if (n < 1 || n > count)
+          throw fail(`Keep or drop count must be between 1 and ${count}`, nAt);
+        keep = { mode, n };
+      } else {
+        break;
+      }
+    }
+    return { kind: "dice", sign: sign2, count, die, keep, explode };
+  };
+  const terms = [];
+  let total = 0;
+  let sign = 1;
+  if (peek() === "+" || peek() === "-") {
+    sign = peek() === "-" ? -1 : 1;
+    pos++;
+  }
+  for (; ; ) {
+    const start = pos;
+    const term = parseTerm(sign);
+    terms.push(term);
+    if (terms.length > MAX_TERMS) throw fail("Notation has more than 20 terms", start);
+    if (term.kind === "dice") {
+      total += term.count;
+      if (total > MAX_DICE) throw fail("Notation has more than 200 dice", start);
+    }
+    const c = peek();
+    if (c === "") break;
+    if (c !== "+" && c !== "-") throw unexpected();
+    sign = c === "-" ? -1 : 1;
+    pos++;
+  }
+  if (total === 0) {
+    throw new PollyrollSyntaxError("Notation has no dice", 0);
+  }
+  return { terms };
+}
+
+// src/core/evaluate.ts
+var ascending = (list) => list.map(([, i]) => i).sort((a, b) => a - b);
+function evaluate(event) {
+  const buckets = parse(event.notation).terms.filter((t) => t.kind === "dice").map((term) => ({ term, dice: [] }));
+  for (const die of event.dice) {
+    const bucket = buckets[die.group];
+    if (!bucket) throw new TypeError(`die group ${die.group} is out of range`);
+    bucket.dice.push(die.value);
+  }
+  let total = event.modifier;
+  const groups = buckets.map(({ term, dice }) => {
+    const pairs = [];
+    dice.forEach((v, i) => {
+      if (v !== null) pairs.push([v, i]);
+    });
+    if (pairs.length < dice.length) {
+      total = null;
+      return { die: term.die, dice, kept: [], dropped: [], subtotal: null };
+    }
+    let keep = pairs;
+    let drop = [];
+    if (term.keep) {
+      const { mode, n } = term.keep;
+      const dir = mode === "kh" || mode === "dh" ? -1 : 1;
+      const ranked = pairs.slice().sort(([va, a], [vb, b]) => dir * (va - vb) || a - b);
+      [keep, drop] = mode[0] === "k" ? [ranked.slice(0, n), ranked.slice(n)] : [ranked.slice(n), ranked.slice(0, n)];
+    }
+    let subtotal = 0;
+    for (const [v] of keep) subtotal += term.sign * v;
+    if (total !== null) total += subtotal;
+    return { die: term.die, dice, kept: ascending(keep), dropped: ascending(drop), subtotal };
+  });
+  return { total, modifier: event.modifier, groups };
+}
+
+// src/core/rng.ts
+var TWO_32 = 2 ** 32;
+var SEED_PATTERN = /^[0-9a-f]{32}$/;
+var word = new Uint32Array(1);
+function rejectionInt(max, draw) {
+  if (!Number.isInteger(max) || max < 1 || max > TWO_32) {
+    throw new RangeError(`maxExclusive must be an integer in [1, 2^32], got ${max}`);
+  }
+  const limit = TWO_32 - TWO_32 % max;
+  let u = draw();
+  while (u >= limit) u = draw();
+  return u % max;
+}
+function cryptoInt(maxExclusive) {
+  return rejectionInt(maxExclusive, () => {
+    let u = 0;
+    for (const w of globalThis.crypto.getRandomValues(word)) u = w;
+    return u;
+  });
+}
+function generateSeed() {
+  const words = globalThis.crypto.getRandomValues(new Uint32Array(4));
+  let seed = "";
+  for (const w of words) seed += w.toString(16).padStart(8, "0");
+  return seed;
+}
+function isSeed(value) {
+  return typeof value === "string" && SEED_PATTERN.test(value);
+}
+function createSeedRng(seed) {
+  if (!isSeed(seed)) throw new TypeError("seed must be 32 lowercase hex characters");
+  const part = (i) => parseInt(seed.slice(i * 8, i * 8 + 8), 16) | 0;
+  let a = part(0);
+  let b = part(1);
+  let c = part(2);
+  let d = part(3);
+  const u32 = () => {
+    let t = a + b | 0;
+    a = b ^ b >>> 9;
+    b = c + (c << 3) | 0;
+    c = c << 21 | c >>> 11;
+    d = d + 1 | 0;
+    t = t + d | 0;
+    c = c + t | 0;
+    return t >>> 0;
+  };
+  for (let i = 0; i < 12; i++) u32();
+  return {
+    u32,
+    float: () => u32() / TWO_32,
+    int: (maxExclusive) => rejectionInt(maxExclusive, u32)
+  };
+}
+
+exports.PollyrollSyntaxError = PollyrollSyntaxError;
+exports.createSeedRng = createSeedRng;
+exports.cryptoInt = cryptoInt;
+exports.evaluate = evaluate;
+exports.generateSeed = generateSeed;
+exports.isSeed = isSeed;
+exports.parse = parse;

package/dist/index.cjs

@@ -0,0 +1,155 @@
+'use strict';
+
+var chunkOEMS7CZP_cjs = require('./chunk-OEMS7CZP.cjs');
+
+// src/core/dice.ts
+function dieRange(type) {
+  return type === "dF" ? [-1, 1] : [1, Number(type.slice(1))];
+}
+var MAX_WAVE = 10;
+
+// src/core/roll.ts
+function createRoll(notation, opts = {}) {
+  const ast = chunkOEMS7CZP_cjs.parse(notation);
+  const rng = opts.rng ?? chunkOEMS7CZP_cjs.cryptoInt;
+  const seed = opts.seed ?? chunkOEMS7CZP_cjs.generateSeed();
+  if (!chunkOEMS7CZP_cjs.isSeed(seed)) throw new TypeError("seed must be 32 lowercase hex characters");
+  const terms = [];
+  let modifier = 0;
+  for (const term of ast.terms) {
+    if (term.kind === "dice") terms.push(term);
+    else modifier += term.sign * term.value;
+  }
+  const dice = [];
+  const roll = (term, group, wave, next) => {
+    const [min, max] = dieRange(term.die);
+    const size = max - min + 1;
+    const r = rng(size);
+    if (!Number.isInteger(r) || r < 0 || r >= size) {
+      throw new RangeError(`rng must return an integer in [0, ${size}), got ${r}`);
+    }
+    const value = r + min;
+    dice.push({ type: term.die, value, group, wave });
+    if (term.explode && value === max) next.push([term, group]);
+  };
+  let pending = [];
+  terms.forEach((term, group) => {
+    for (let i = 0; i < term.count; i++) roll(term, group, 0, pending);
+  });
+  for (let wave = 1; wave <= MAX_WAVE && pending.length > 0; wave++) {
+    const next = [];
+    for (const [term, group] of pending) roll(term, group, wave, next);
+    pending = next;
+  }
+  const event = {
+    v: 1,
+    id: globalThis.crypto.randomUUID(),
+    notation,
+    dice,
+    modifier,
+    seed,
+    createdAt: Date.now()
+  };
+  if (opts.skin !== void 0) event.skin = opts.skin;
+  if (opts.rollerId !== void 0) event.rollerId = opts.rollerId;
+  if (opts.audience !== void 0) event.audience = opts.audience;
+  return event;
+}
+
+// src/core/event.ts
+var MAX_EVENT_DICE = 2200;
+var isObj = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+var isStr = (x, min, max) => typeof x === "string" && x.length >= min && x.length <= max;
+var isInt = (x, min, max) => typeof x === "number" && Number.isInteger(x) && x >= min && x <= max;
+var isUnit = (x) => typeof x === "number" && x >= 0 && x <= 1;
+var oneOf = (x, words) => typeof x === "string" && words.split(" ").includes(x);
+var optional = (x, test) => x === void 0 || test(x);
+var all = (list, test) => {
+  for (const x of list) if (!test(x)) return false;
+  return true;
+};
+var isColor = (x) => isStr(x, 0, 64);
+var isMaterial = (m) => isObj(m) ? isUnit(m.metalness) && isUnit(m.roughness) && "clearcoat transmission tint sparkle".split(" ").every((k) => optional(m[k], isUnit)) : oneOf(m, "plastic metal wood glass stone gem");
+var isSkin = (s) => isObj(s) ? isMaterial(s.material) && (Array.isArray(s.color) ? s.color.length === 2 && all(s.color, isColor) : isColor(s.color)) && isColor(s.labelColor) && optional(s.labelStyle, (x) => oneOf(x, "engraved printed embossed")) && optional(s.pattern, (x) => oneOf(x, "none gradient speckle marble wood swirl")) && optional(s.font, (x) => isStr(x, 1, 128)) : isStr(s, 1, 64);
+var isId = (x) => isStr(x, 1, 128);
+var isAudience = (a) => Array.isArray(a) ? a.length <= 100 && all(a, isId) : oneOf(a, "all dm");
+function redact(event) {
+  const dice = event.dice.filter((die) => die.wave === 0).map((die) => ({ ...die, value: null }));
+  const copy = { ...event, dice };
+  const { audience, skin } = event;
+  if (Array.isArray(audience)) copy.audience = audience.slice();
+  if (typeof skin === "object") {
+    const { color } = skin;
+    copy.skin = { ...skin, color: typeof color === "string" ? color : [color[0], color[1]] };
+  }
+  return copy;
+}
+function check(e) {
+  if (!isObj(e) || e.v !== 1 || !isId(e.id) || typeof e.notation !== "string" || !chunkOEMS7CZP_cjs.isSeed(e.seed) || typeof e.createdAt !== "number" || !(e.createdAt >= 0 && e.createdAt < Infinity) || !optional(e.skin, isSkin) || !optional(e.rollerId, isId) || !optional(e.audience, isAudience)) {
+    return false;
+  }
+  const terms = [];
+  let modifier = 0;
+  for (const t of chunkOEMS7CZP_cjs.parse(e.notation).terms) {
+    if (t.kind === "dice") terms.push(t);
+    else modifier += t.sign * t.value;
+  }
+  const dice = e.dice;
+  if (e.modifier !== modifier || !Array.isArray(dice) || dice.length < 1 || dice.length > MAX_EVENT_DICE) {
+    return false;
+  }
+  const W = MAX_WAVE + 1;
+  const count = new Array(terms.length * W).fill(0);
+  const maxed = count.slice();
+  const hidden = terms.map(() => false);
+  const get = (list, i) => list[i] ?? 0;
+  let lastWave = 0;
+  for (const die of dice) {
+    if (!isObj(die)) return false;
+    const { type, group, wave, value } = die;
+    if (!isInt(group, 0, terms.length - 1)) return false;
+    const term = terms[group];
+    if (!term || term.die !== type || !isInt(wave, lastWave, term.explode ? MAX_WAVE : 0)) {
+      return false;
+    }
+    lastWave = wave;
+    const [min, max] = dieRange(term.die);
+    if (value === null) hidden[group] = true;
+    else if (!isInt(value, min, max)) return false;
+    const k = group * W + wave;
+    count[k] = get(count, k) + 1;
+    if (value === max) maxed[k] = get(maxed, k) + 1;
+  }
+  return terms.every((term, g) => {
+    const at = (list, w) => get(list, g * W + w);
+    if (at(count, 0) !== term.count) return false;
+    for (let w = 1; term.explode && w <= MAX_WAVE; w++) {
+      const limit = hidden[g] ? at(count, w - 1) : at(maxed, w - 1);
+      if (hidden[g] ? at(count, w) > limit : at(count, w) !== limit) return false;
+    }
+    return true;
+  });
+}
+function isRollEvent(input) {
+  try {
+    return check(input);
+  } catch {
+    return false;
+  }
+}
+
+Object.defineProperty(exports, "PollyrollSyntaxError", {
+  enumerable: true,
+  get: function () { return chunkOEMS7CZP_cjs.PollyrollSyntaxError; }
+});
+Object.defineProperty(exports, "evaluate", {
+  enumerable: true,
+  get: function () { return chunkOEMS7CZP_cjs.evaluate; }
+});
+Object.defineProperty(exports, "parse", {
+  enumerable: true,
+  get: function () { return chunkOEMS7CZP_cjs.parse; }
+});
+exports.createRoll = createRoll;
+exports.isRollEvent = isRollEvent;
+exports.redact = redact;

package/dist/index.d.cts

@@ -0,0 +1,22 @@
+import { R as RollAst, C as CreateRollOptions, a as RollEvent, b as RollSummary } from './types-CnzvkHmJ.cjs';
+export { A as Audience, c as ConstantTerm, D as DiceTerm, d as DieType, K as KeepMode, L as LabelStyle, M as MaterialParams, e as MaterialPreset, P as PatternName, f as RollGroupSummary, g as RollTerm, h as RolledDie, S as Skin, i as SkinRef } from './types-CnzvkHmJ.cjs';
+
+declare class PollyrollSyntaxError extends Error {
+    readonly index: number;
+    constructor(message: string, index: number);
+}
+declare function parse(notation: string): RollAst;
+
+declare function createRoll(notation: string, opts?: CreateRollOptions): RollEvent;
+
+declare function evaluate(event: RollEvent): RollSummary;
+
+/**
+ * Copy of `event` with every value set to null and explosion dice (wave ≥ 1) removed, so the
+ * number of dice reveals nothing about the hidden values.
+ */
+declare function redact(event: RollEvent): RollEvent;
+/** True when `input` is a structurally valid v1 `RollEvent`. Never throws. */
+declare function isRollEvent(input: unknown): input is RollEvent;
+
+export { CreateRollOptions, PollyrollSyntaxError, RollAst, RollEvent, RollSummary, createRoll, evaluate, isRollEvent, parse, redact };

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+import { R as RollAst, C as CreateRollOptions, a as RollEvent, b as RollSummary } from './types-CnzvkHmJ.js';
+export { A as Audience, c as ConstantTerm, D as DiceTerm, d as DieType, K as KeepMode, L as LabelStyle, M as MaterialParams, e as MaterialPreset, P as PatternName, f as RollGroupSummary, g as RollTerm, h as RolledDie, S as Skin, i as SkinRef } from './types-CnzvkHmJ.js';
+
+declare class PollyrollSyntaxError extends Error {
+    readonly index: number;
+    constructor(message: string, index: number);
+}
+declare function parse(notation: string): RollAst;
+
+declare function createRoll(notation: string, opts?: CreateRollOptions): RollEvent;
+
+declare function evaluate(event: RollEvent): RollSummary;
+
+/**
+ * Copy of `event` with every value set to null and explosion dice (wave ≥ 1) removed, so the
+ * number of dice reveals nothing about the hidden values.
+ */
+declare function redact(event: RollEvent): RollEvent;
+/** True when `input` is a structurally valid v1 `RollEvent`. Never throws. */
+declare function isRollEvent(input: unknown): input is RollEvent;
+
+export { CreateRollOptions, PollyrollSyntaxError, RollAst, RollEvent, RollSummary, createRoll, evaluate, isRollEvent, parse, redact };

package/dist/index.js

@@ -0,0 +1,140 @@
+import { parse, cryptoInt, generateSeed, isSeed } from './chunk-JIYQHWUA.js';
+export { PollyrollSyntaxError, evaluate, parse } from './chunk-JIYQHWUA.js';
+
+// src/core/dice.ts
+function dieRange(type) {
+  return type === "dF" ? [-1, 1] : [1, Number(type.slice(1))];
+}
+var MAX_WAVE = 10;
+
+// src/core/roll.ts
+function createRoll(notation, opts = {}) {
+  const ast = parse(notation);
+  const rng = opts.rng ?? cryptoInt;
+  const seed = opts.seed ?? generateSeed();
+  if (!isSeed(seed)) throw new TypeError("seed must be 32 lowercase hex characters");
+  const terms = [];
+  let modifier = 0;
+  for (const term of ast.terms) {
+    if (term.kind === "dice") terms.push(term);
+    else modifier += term.sign * term.value;
+  }
+  const dice = [];
+  const roll = (term, group, wave, next) => {
+    const [min, max] = dieRange(term.die);
+    const size = max - min + 1;
+    const r = rng(size);
+    if (!Number.isInteger(r) || r < 0 || r >= size) {
+      throw new RangeError(`rng must return an integer in [0, ${size}), got ${r}`);
+    }
+    const value = r + min;
+    dice.push({ type: term.die, value, group, wave });
+    if (term.explode && value === max) next.push([term, group]);
+  };
+  let pending = [];
+  terms.forEach((term, group) => {
+    for (let i = 0; i < term.count; i++) roll(term, group, 0, pending);
+  });
+  for (let wave = 1; wave <= MAX_WAVE && pending.length > 0; wave++) {
+    const next = [];
+    for (const [term, group] of pending) roll(term, group, wave, next);
+    pending = next;
+  }
+  const event = {
+    v: 1,
+    id: globalThis.crypto.randomUUID(),
+    notation,
+    dice,
+    modifier,
+    seed,
+    createdAt: Date.now()
+  };
+  if (opts.skin !== void 0) event.skin = opts.skin;
+  if (opts.rollerId !== void 0) event.rollerId = opts.rollerId;
+  if (opts.audience !== void 0) event.audience = opts.audience;
+  return event;
+}
+
+// src/core/event.ts
+var MAX_EVENT_DICE = 2200;
+var isObj = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+var isStr = (x, min, max) => typeof x === "string" && x.length >= min && x.length <= max;
+var isInt = (x, min, max) => typeof x === "number" && Number.isInteger(x) && x >= min && x <= max;
+var isUnit = (x) => typeof x === "number" && x >= 0 && x <= 1;
+var oneOf = (x, words) => typeof x === "string" && words.split(" ").includes(x);
+var optional = (x, test) => x === void 0 || test(x);
+var all = (list, test) => {
+  for (const x of list) if (!test(x)) return false;
+  return true;
+};
+var isColor = (x) => isStr(x, 0, 64);
+var isMaterial = (m) => isObj(m) ? isUnit(m.metalness) && isUnit(m.roughness) && "clearcoat transmission tint sparkle".split(" ").every((k) => optional(m[k], isUnit)) : oneOf(m, "plastic metal wood glass stone gem");
+var isSkin = (s) => isObj(s) ? isMaterial(s.material) && (Array.isArray(s.color) ? s.color.length === 2 && all(s.color, isColor) : isColor(s.color)) && isColor(s.labelColor) && optional(s.labelStyle, (x) => oneOf(x, "engraved printed embossed")) && optional(s.pattern, (x) => oneOf(x, "none gradient speckle marble wood swirl")) && optional(s.font, (x) => isStr(x, 1, 128)) : isStr(s, 1, 64);
+var isId = (x) => isStr(x, 1, 128);
+var isAudience = (a) => Array.isArray(a) ? a.length <= 100 && all(a, isId) : oneOf(a, "all dm");
+function redact(event) {
+  const dice = event.dice.filter((die) => die.wave === 0).map((die) => ({ ...die, value: null }));
+  const copy = { ...event, dice };
+  const { audience, skin } = event;
+  if (Array.isArray(audience)) copy.audience = audience.slice();
+  if (typeof skin === "object") {
+    const { color } = skin;
+    copy.skin = { ...skin, color: typeof color === "string" ? color : [color[0], color[1]] };
+  }
+  return copy;
+}
+function check(e) {
+  if (!isObj(e) || e.v !== 1 || !isId(e.id) || typeof e.notation !== "string" || !isSeed(e.seed) || typeof e.createdAt !== "number" || !(e.createdAt >= 0 && e.createdAt < Infinity) || !optional(e.skin, isSkin) || !optional(e.rollerId, isId) || !optional(e.audience, isAudience)) {
+    return false;
+  }
+  const terms = [];
+  let modifier = 0;
+  for (const t of parse(e.notation).terms) {
+    if (t.kind === "dice") terms.push(t);
+    else modifier += t.sign * t.value;
+  }
+  const dice = e.dice;
+  if (e.modifier !== modifier || !Array.isArray(dice) || dice.length < 1 || dice.length > MAX_EVENT_DICE) {
+    return false;
+  }
+  const W = MAX_WAVE + 1;
+  const count = new Array(terms.length * W).fill(0);
+  const maxed = count.slice();
+  const hidden = terms.map(() => false);
+  const get = (list, i) => list[i] ?? 0;
+  let lastWave = 0;
+  for (const die of dice) {
+    if (!isObj(die)) return false;
+    const { type, group, wave, value } = die;
+    if (!isInt(group, 0, terms.length - 1)) return false;
+    const term = terms[group];
+    if (!term || term.die !== type || !isInt(wave, lastWave, term.explode ? MAX_WAVE : 0)) {
+      return false;
+    }
+    lastWave = wave;
+    const [min, max] = dieRange(term.die);
+    if (value === null) hidden[group] = true;
+    else if (!isInt(value, min, max)) return false;
+    const k = group * W + wave;
+    count[k] = get(count, k) + 1;
+    if (value === max) maxed[k] = get(maxed, k) + 1;
+  }
+  return terms.every((term, g) => {
+    const at = (list, w) => get(list, g * W + w);
+    if (at(count, 0) !== term.count) return false;
+    for (let w = 1; term.explode && w <= MAX_WAVE; w++) {
+      const limit = hidden[g] ? at(count, w - 1) : at(maxed, w - 1);
+      if (hidden[g] ? at(count, w) > limit : at(count, w) !== limit) return false;
+    }
+    return true;
+  });
+}
+function isRollEvent(input) {
+  try {
+    return check(input);
+  } catch {
+    return false;
+  }
+}
+
+export { createRoll, isRollEvent, redact };

package/dist/react.cjs

@@ -0,0 +1,50 @@
+'use client';
+'use strict';
+
+var react = require('react');
+var render = require('pollyroll/render');
+
+// src/react/index.ts
+
+// src/react/skin.ts
+var skinChanged = (next, last) => JSON.stringify(next) !== JSON.stringify(last);
+
+// src/react/index.ts
+function useDiceTray(ref, opts) {
+  const [tray, setTray] = react.useState(null);
+  const optsRef = react.useRef(opts);
+  optsRef.current = opts;
+  const skinRef = react.useRef(opts?.skin);
+  react.useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const created = render.createDiceTray(el, optsRef.current);
+    skinRef.current = optsRef.current?.skin;
+    setTray(created);
+    return () => {
+      created.dispose();
+      setTray(null);
+    };
+  }, [ref]);
+  const skin = opts?.skin;
+  react.useEffect(() => {
+    if (!tray || skin === void 0 || !skinChanged(skin, skinRef.current)) return;
+    skinRef.current = skin;
+    tray.setSkin(skin);
+  }, [tray, skin]);
+  return tray;
+}
+function DiceTray(props) {
+  const { trayRef, className, style, ...opts } = props;
+  const ref = react.useRef(null);
+  const tray = useDiceTray(ref, opts);
+  react.useImperativeHandle(trayRef, () => tray, [tray]);
+  return react.createElement("div", {
+    ref,
+    className,
+    style: { position: "absolute", inset: 0, pointerEvents: "none", ...style }
+  });
+}
+
+exports.DiceTray = DiceTray;
+exports.useDiceTray = useDiceTray;

package/dist/react.d.cts

@@ -0,0 +1,22 @@
+import { Ref, CSSProperties, ReactElement, RefObject } from 'react';
+import { TrayOptions, DiceTray as DiceTray$1 } from 'pollyroll/render';
+
+/**
+ * Creates a tray on ref.current after mount and disposes it on unmount. Options are read once;
+ * only `skin` is reactive, applied when it changes by value (an undefined skin is ignored).
+ */
+declare function useDiceTray(ref: RefObject<HTMLElement | null>, opts?: TrayOptions): DiceTray$1 | null;
+interface DiceTrayProps extends TrayOptions {
+    /** Receives the tray once created, and null after unmount. */
+    trayRef?: Ref<DiceTray$1 | null>;
+    className?: string;
+    /** Merged after the overlay defaults. */
+    style?: CSSProperties;
+}
+/**
+ * Overlay: a div styled position:absolute; inset:0; pointer-events:none, hosting the tray canvas.
+ * Tray options are read once on mount; only `skin` is reactive (applied when it changes by value).
+ */
+declare function DiceTray(props: DiceTrayProps): ReactElement;
+
+export { DiceTray, type DiceTrayProps, useDiceTray };

package/dist/react.d.ts

@@ -0,0 +1,22 @@
+import { Ref, CSSProperties, ReactElement, RefObject } from 'react';
+import { TrayOptions, DiceTray as DiceTray$1 } from 'pollyroll/render';
+
+/**
+ * Creates a tray on ref.current after mount and disposes it on unmount. Options are read once;
+ * only `skin` is reactive, applied when it changes by value (an undefined skin is ignored).
+ */
+declare function useDiceTray(ref: RefObject<HTMLElement | null>, opts?: TrayOptions): DiceTray$1 | null;
+interface DiceTrayProps extends TrayOptions {
+    /** Receives the tray once created, and null after unmount. */
+    trayRef?: Ref<DiceTray$1 | null>;
+    className?: string;
+    /** Merged after the overlay defaults. */
+    style?: CSSProperties;
+}
+/**
+ * Overlay: a div styled position:absolute; inset:0; pointer-events:none, hosting the tray canvas.
+ * Tray options are read once on mount; only `skin` is reactive (applied when it changes by value).
+ */
+declare function DiceTray(props: DiceTrayProps): ReactElement;
+
+export { DiceTray, type DiceTrayProps, useDiceTray };