@aethervtt/shard-dice 0.1.0 → 0.2.0

package/dist/audio.d.ts

@@ -0,0 +1,19 @@
+import { type AssetRef, type World } from '@aethervtt/shard-core';
+/** Default category for dice, including procedural fallback sounds. */
+export declare const DICE_AUDIO_BUS = "dice";
+/** Preserve host controls; a configured mixer must explicitly include its dice route. */
+export declare function ensureDiceAudioBus(world: World): void;
+/** A roll owns preparation and instances, independently of rendering and the host's storage. */
+export declare class DiceAudioSession {
+    private readonly bindings;
+    private readonly leases;
+    private readonly instances;
+    private closed;
+    private readonly world;
+    private readonly gain;
+    constructor(world: World, gain: number);
+    prepare(refs: readonly AssetRef[]): Promise<void>;
+    /** Returns true for configured bindings, even when silent, so defaults do not also play. */
+    play(ref: AssetRef | null, seed: number, strength: number, pitch: number, value: number, high: boolean, low: boolean, count: number, contact?: number, gain?: number): boolean;
+    dispose(): void;
+}

package/dist/audio.js

@@ -0,0 +1,187 @@
+import {
+  AudioBuses,
+  AudioEvent,
+  AudioEventsState,
+  AudioMixState,
+  AudioState,
+  audioEvents,
+  playAudioEvent,
+  prepareAudio,
+  stopAudioEvent
+} from "@aethervtt/shard-audio";
+import { ShardError } from "@aethervtt/shard-core";
+const DICE_AUDIO_BUS = "dice";
+const INPUTS = ["strength", "pitch", "value", "high", "low", "count", "contact"];
+function ensureDiceAudioBus(world) {
+  if (!world.hasResource(AudioState)) return;
+  const graph = world.tryResource(AudioMixState)?.graph;
+  if (graph && !graph.buses.some((bus) => bus.id === DICE_AUDIO_BUS && !bus.return))
+    throw new ShardError("dice/audio-bus", "The active mixer needs an ordinary dice bus", {
+      hint: "Add dice under master in the host mixer before rolling.",
+      path: "/buses"
+    });
+  const buses = world.resource(AudioBuses);
+  buses[DICE_AUDIO_BUS] ??= { volume: 1, muted: false, parent: "master" };
+  if (buses[DICE_AUDIO_BUS].parent !== "master" || buses[DICE_AUDIO_BUS].userDomain === false)
+    throw new ShardError(
+      "dice/audio-bus",
+      "Dice must be an ordinary category directly under master",
+      {
+        hint: "Independent dice user controls require their own category, including effect tails.",
+        path: "/buses/dice"
+      }
+    );
+}
+function key(ref) {
+  return ref.guid ?? ref.path ?? "";
+}
+class DiceAudioSession {
+  bindings = /* @__PURE__ */ new Map();
+  leases = [];
+  instances = [];
+  closed = false;
+  world;
+  gain;
+  constructor(world, gain) {
+    this.world = world;
+    this.gain = gain;
+  }
+  async prepare(refs) {
+    if (this.closed || this.gain <= 0 || !this.world.hasResource(AudioState)) return;
+    ensureDiceAudioBus(this.world);
+    if (refs.length && !this.world.hasResource(AudioEventsState))
+      throw new ShardError(
+        "dice/audio-events-missing",
+        "Authored dice sounds need audioEventsPlugin",
+        {
+          hint: "Install audioEventsPlugin alongside audioPlugin, or remove the event bindings."
+        }
+      );
+    try {
+      for (const ref of refs) {
+        if (this.closed) return;
+        if (this.bindings.has(key(ref))) continue;
+        const lease = await prepareAudio(this.world, ref);
+        if (this.closed) {
+          lease.release();
+          return;
+        }
+        this.leases.push(lease);
+        const plan = lease.events[0];
+        if (!plan || lease.events.length !== 1)
+          throw new ShardError("dice/audio-event", "Dice bindings require one audio event");
+        const definition = plan.definition;
+        if (definition.mode !== "oneshot" || definition.layers.some((layer) => layer.spatial))
+          throw new ShardError(
+            "dice/audio-event",
+            "Dice presentation events must be flat one-shots"
+          );
+        const buses = this.world.resource(AudioBuses);
+        for (const layer of definition.layers) {
+          let bus = layer.bus || definition.bus;
+          let depth = 0;
+          while (bus && bus !== DICE_AUDIO_BUS && depth++ < 64) bus = buses[bus]?.parent ?? "";
+          if (bus !== DICE_AUDIO_BUS)
+            throw new ShardError("dice/audio-bus", "Dice event layers must route through dice", {
+              path: `/layers/${layer.id}/bus`,
+              hint: "Set the event bus to dice or a child bus in the host mixer."
+            });
+        }
+        const inputs = [];
+        for (const parameter of definition.parameters) {
+          if (!INPUTS.includes(parameter.name)) continue;
+          if (parameter.readonly || parameter.kind === "label" || ["strength", "pitch"].includes(parameter.name) && parameter.kind !== "continuous")
+            throw new ShardError("dice/audio-parameter", `Invalid dice input ${parameter.name}`, {
+              path: `/parameters/${parameter.name}`,
+              hint: "Use writable numeric inputs; strength and pitch must be continuous."
+            });
+          inputs.push(parameter.name);
+        }
+        this.bindings.set(key(ref), { ref: plan.source ?? ref, inputs, revision: plan.revision });
+      }
+    } catch (error) {
+      this.dispose();
+      throw error;
+    }
+  }
+  /** Returns true for configured bindings, even when silent, so defaults do not also play. */
+  play(ref, seed, strength, pitch, value, high, low, count, contact = 0, gain = 1) {
+    if (!ref) return false;
+    if (this.closed || this.gain <= 0 || !this.world.hasResource(AudioState)) return true;
+    const binding = this.bindings.get(key(ref));
+    if (!binding)
+      throw new ShardError("dice/audio-not-prepared", "Prepare the dice event before playback");
+    const current = this.world.resource(AudioEvent.store).get(binding.ref);
+    if (!current || JSON.stringify(AudioEvent.serialize(current)) !== binding.revision)
+      throw new ShardError("dice/audio-changed", "A dice event changed during its roll", {
+        hint: "Start a new roll to prepare the changed event and validate its routing and inputs."
+      });
+    const parameters = {};
+    for (let i = 0; i < binding.inputs.length; i++) {
+      const input = binding.inputs[i];
+      switch (input) {
+        case "strength":
+          parameters[input] = strength;
+          break;
+        case "pitch":
+          parameters[input] = pitch;
+          break;
+        case "value":
+          parameters[input] = value;
+          break;
+        case "high":
+          parameters[input] = high ? 1 : 0;
+          break;
+        case "low":
+          parameters[input] = low ? 1 : 0;
+          break;
+        case "count":
+          parameters[input] = count;
+          break;
+        case "contact":
+          parameters[input] = contact;
+          break;
+      }
+    }
+    const state = audioEvents(this.world);
+    let keep = 0;
+    for (let i = 0; i < this.instances.length; i++) {
+      const id = this.instances[i];
+      for (let j = 0; j < state.instances.length; j++) {
+        const instance = state.instances[j];
+        if (instance?.id === id && instance.state !== "ended" && instance.state !== "failed") {
+          this.instances[keep++] = id;
+          break;
+        }
+      }
+    }
+    this.instances.length = keep;
+    try {
+      this.instances.push(
+        playAudioEvent(this.world, binding.ref, {
+          seed: seed >>> 0,
+          volume: this.gain * gain,
+          parameters
+        })
+      );
+    } catch (error) {
+      if (!(error instanceof ShardError) || error.code !== "audio/capacity") throw error;
+    }
+    return true;
+  }
+  dispose() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.world.hasResource(AudioEventsState))
+      for (const id of this.instances) stopAudioEvent(this.world, id, { release: 0 });
+    for (const lease of this.leases) lease.release();
+    this.instances.length = 0;
+    this.leases.length = 0;
+    this.bindings.clear();
+  }
+}
+export {
+  DICE_AUDIO_BUS,
+  DiceAudioSession,
+  ensureDiceAudioBus
+};

package/dist/effects.d.ts

@@ -20,6 +20,7 @@ declare const EFFECT: import("@aethervtt/shard-core").FieldType<import("@aetherv
     count: import("@aethervtt/shard-core").FieldType<number, "u8">;
     durationMs: import("@aethervtt/shard-core").FieldType<number, "u16">;
     cue: import("@aethervtt/shard-core").FieldType<"arcane-spark" | "resin-chime" | "void-whump", "u8">;
+    event: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"audio/AudioEvent"> | null, "object">;
     gain: import("@aethervtt/shard-core").FieldType<number, "f32">;
     radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
     strength: import("@aethervtt/shard-core").FieldType<number, "f32">;
@@ -52,6 +53,7 @@ export declare const DiceEffectRecipe: import("@aethervtt/shard-assets").DataTyp
         count: import("@aethervtt/shard-core").FieldType<number, "u8">;
         durationMs: import("@aethervtt/shard-core").FieldType<number, "u16">;
         cue: import("@aethervtt/shard-core").FieldType<"arcane-spark" | "resin-chime" | "void-whump", "u8">;
+        event: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"audio/AudioEvent"> | null, "object">;
         gain: import("@aethervtt/shard-core").FieldType<number, "f32">;
         radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
         strength: import("@aethervtt/shard-core").FieldType<number, "f32">;

package/dist/effects.js

@@ -37,6 +37,9 @@ const EFFECT = t.struct(
     cue: t.enum(["resin-chime", "arcane-spark", "void-whump"], {
       description: "sound-accent: the cue."
     }),
+    event: t.handle("audio/AudioEvent", {
+      description: "sound-accent: optional authored event replacing the procedural cue."
+    }),
     gain: t.f32({ default: 0.7, min: 0, max: 1, description: "sound-accent: 0..1." }),
     radius: t.f32({
       default: 150,
@@ -72,6 +75,7 @@ const DiceEffectRecipe = defineDataType(
   },
   {
     extension: "dice-effect",
+    lazyDependencies: true,
     description: "Effects a skin plays when a roll matches its conditions."
   }
 );

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { DICE_AUDIO_BUS } from './audio.js';
 export { allDiceAttachments, DICE_BUDGETS, type DiceAttachmentContext, type DiceAttachmentDef, type DiceSceneContext, defineDiceAttachment, findDiceAttachment, MAX_ATTACHMENTS, setDiceBudgets, } from './attachments.js';
 export { BUILTIN_DICE, D4, D6, D8, D10, D10_TENS, D12, D20, D100_BALL, DIE_KINDS, type DieKind, KIND_DEFINITIONS, kindSides, percentileValues, registerBuiltinDice, } from './builtins.js';
 export { CELL_PAD, type CellLayout, cellLayout, type FaceCell, MARK_RANGE } from './cells.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+import { DICE_AUDIO_BUS } from "./audio.js";
 import {
   allDiceAttachments,
   DICE_BUDGETS,
@@ -188,6 +189,7 @@ export {
   D4,
   D6,
   D8,
+  DICE_AUDIO_BUS,
   DICE_BUDGETS,
   DICE_CLEANUP_STEP,
   DICE_CONTACTS,

package/dist/plugin.js

@@ -19,6 +19,7 @@ import {
 import { definePlugin } from "@aethervtt/shard-runtime";
 import { Textures } from "@aethervtt/shard-texture";
 import { lookAt, Transform } from "@aethervtt/shard-transform";
+import { ensureDiceAudioBus } from "./audio.js";
 import { KIND_DEFINITIONS, registerBuiltinDice } from "./builtins.js";
 import { DiceDie, DiceRollRequest } from "./components.js";
 import { DieDefinitionAsset } from "./definition-asset.js";
@@ -119,6 +120,7 @@ function dicePlugin(options = {}) {
       for (const family of allDiceFamilies())
         if (family.module) shaders[family.module.path] = family.module.source;
       registerShaders(world.resource(Shaders), shaders);
+      ensureDiceAudioBus(world);
       const table = world.resource(DiceTable);
       const quad = world.resource(Meshes).add(floorQuad(), "dice:tray");
       const trayMaterial = world.resource(Materials).add(new MaterialAsset({}, DiceTray), "dice:tray");

package/dist/preview.js

@@ -1,3 +1,4 @@
+import { assetServer } from "@aethervtt/shard-assets";
 import { ShardError } from "@aethervtt/shard-core";
 import { encodePng } from "@aethervtt/shard-protocol";
 import {
@@ -15,6 +16,7 @@ import {
   Shaders
 } from "@aethervtt/shard-render";
 import { FrameDemand, LOADING_DEMAND } from "@aethervtt/shard-runtime";
+import { Fonts } from "@aethervtt/shard-text";
 import { lookAt, Transform } from "@aethervtt/shard-transform";
 import { dieGeometry, requireDie } from "./definition.js";
 import { restingHeight, restRotation } from "./landing.js";
@@ -43,7 +45,17 @@ async function renderDiceThumbnail(app, options) {
   }
   const g = dieGeometry(requireDie(die.definition));
   const skinKey = options.skin.guid ?? options.skin.path ?? "";
-  const entry = table.resources.acquire(g, skinKey, skin, die.kind, (r) => table.layout(r), {});
+  const layoutRef = skin.variants[die.kind].layout;
+  if (layoutRef && !table.layout(layoutRef)) await assetServer(world).load(layoutRef);
+  const layout = layoutRef ? table.layout(layoutRef) : void 0;
+  if (layout) {
+    for (const mark of [layout.default, ...layout.overrides.map((override) => override.mark)])
+      if (mark.kind === "text" && mark.font && !world.tryResource(Fonts)?.get(mark.font))
+        await assetServer(world).load(mark.font);
+  }
+  const entry = table.resources.acquire(g, skinKey, skin, die.kind, (r) => table.layout(r), {
+    font: (ref) => world.tryResource(Fonts)?.get(ref)
+  });
   const material = table.resources.material(entry, {
     blended: options.blended ?? table.resources.blendedByNature(entry),
     dropped: false

package/dist/skin.d.ts

@@ -22,6 +22,9 @@ export declare const DiceSkin: import("@aethervtt/shard-assets").DataType<{
     }>, "object">>>, "object">;
     readonly sounds: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
         impact: import("@aethervtt/shard-core").FieldType<"glass" | "metal" | "resin" | "wood", "u8">;
+        impactEvent: import("@aethervtt/shard-core").FieldType<AssetRef<"audio/AudioEvent"> | null, "object">;
+        entranceEvent: import("@aethervtt/shard-core").FieldType<AssetRef<"audio/AudioEvent"> | null, "object">;
+        resultEvent: import("@aethervtt/shard-core").FieldType<AssetRef<"audio/AudioEvent"> | null, "object">;
         accent: import("@aethervtt/shard-core").FieldType<"" | "arcane-spark" | "resin-chime" | "void-whump", "u8">;
     }>, "object">;
     readonly effects: import("@aethervtt/shard-core").FieldType<(AssetRef<"dice/DiceEffectRecipe"> | null)[], "object">;

package/dist/skin.js

@@ -39,6 +39,15 @@ const DiceSkin = defineDataType(
     sounds: t.struct(
       {
         impact: t.enum(IMPACT_SOUNDS, { description: "What contacts sound like." }),
+        impactEvent: t.handle("audio/AudioEvent", {
+          description: "Optional authored hit, replacing procedural contacts and landing knocks."
+        }),
+        entranceEvent: t.handle("audio/AudioEvent", {
+          description: "Optional authored sound when an entrance scene starts."
+        }),
+        resultEvent: t.handle("audio/AudioEvent", {
+          description: "Optional authored landing accent, under the one-cue budget."
+        }),
         accent: t.enum(["", "resin-chime", "arcane-spark", "void-whump"], {
           description: "A cue played when the dice land (with effects on). Empty: none."
         })
@@ -51,6 +60,7 @@ const DiceSkin = defineDataType(
   },
   {
     extension: "dice-skin",
+    lazyDependencies: true,
     description: "A dice skin: family, parameters, variants, sounds, effects."
   }
 );

package/dist/table.d.ts

@@ -91,6 +91,8 @@ export declare class DiceTableState {
     recipe(ref: AssetRef): DiceEffectRecipeValue | undefined;
     /** Loads what the roll's layouts need (fonts), makes the dice's resources, then records or places. */
     private prepare;
+    private prepareAudio;
+    private eventSound;
     private loadFonts;
     private acquire;
     private screenUp;

package/dist/table.js

@@ -43,6 +43,7 @@ import {
   findDiceAttachment,
   MAX_ATTACHMENTS
 } from "./attachments.js";
+import { DICE_AUDIO_BUS, DiceAudioSession } from "./audio.js";
 import { DiceDie } from "./components.js";
 import { dieGeometry, requireDie } from "./definition.js";
 import {
@@ -101,7 +102,7 @@ const PICK = new Int32Array(IMPACTS_PER_FRAME);
 const POWER = new Float32Array(IMPACTS_PER_FRAME);
 const IMPACT_VOLUME = [0, 0];
 const IMPACT_PITCH = [0, 0];
-const IMPACT_SOUND = { bus: "sfx", volume: IMPACT_VOLUME, pitch: IMPACT_PITCH };
+const IMPACT_SOUND = { bus: DICE_AUDIO_BUS, volume: IMPACT_VOLUME, pitch: IMPACT_PITCH };
 const ACCENT_LEVEL = 0.4;
 function screenOf(world, camera, x, y, z, out) {
   const cam = world.resource(Cameras).get(camera);
@@ -226,6 +227,8 @@ class DiceTableState {
       degraded: false,
       live: [],
       voices: [],
+      cuePlayed: false,
+      audio: new DiceAudioSession(this.world, Math.max(0, Math.min(1, roll.soundGain ?? 1))),
       shadowsBefore: void 0,
       trayShadow: Number.NaN,
       fps: 0,
@@ -361,6 +364,8 @@ class DiceTableState {
       await this.loadSkins(p);
       if (p.done) return;
       this.chooseEntrances(p);
+      await this.prepareAudio(p);
+      if (p.done) return;
       this.acquire(p);
       p.request = rollTrackRequest(
         p.roll,
@@ -380,6 +385,7 @@ class DiceTableState {
       if (recording) this.recordings++;
       if (p.soundGain > 0 && this.world.tryResource(AudioState)) {
         for (const skin of new Set(p.skins)) {
+          if (skin.sounds.impactEvent) continue;
           this.sounds.prepare(skin.sounds.impact, (clip) => preloadSound(this.world, clip));
         }
       }
@@ -398,6 +404,41 @@ class DiceTableState {
       else this.fail(p, err);
     }
   }
+  async prepareAudio(p) {
+    if (p.soundGain <= 0 || p.reduced || !this.world.hasResource(AudioState)) return;
+    const refs = [];
+    for (const skin of new Set(p.skins)) {
+      if (skin.sounds.impactEvent) refs.push(skin.sounds.impactEvent);
+      if (p.effects && skin.sounds.resultEvent) refs.push(skin.sounds.resultEvent);
+    }
+    for (const run of p.entrances) {
+      const ref = p.skins[run.die].sounds.entranceEvent;
+      if (ref && run.def && !run.fallback) refs.push(ref);
+    }
+    if (p.effects)
+      for (const matched of p.matched) {
+        if (matched.anchors.length === 0) continue;
+        for (const effect of matched.recipe.effects)
+          if (effect.kind === "sound-accent" && effect.event) refs.push(effect.event);
+      }
+    await p.audio.prepare(refs);
+  }
+  eventSound(p, ref, die, salt, strength = 1, contact = 0, gain = 1) {
+    if (!ref) return false;
+    const d = p.dice[die];
+    return p.audio.play(
+      ref,
+      p.soundSeed ^ Math.imul(salt + 1, 2654435761),
+      strength,
+      p.pitch[die] ?? 1,
+      d.rolled,
+      d.high,
+      d.low,
+      p.dice.length,
+      contact,
+      gain
+    );
+  }
   async loadFonts(p) {
     const fonts = this.world.tryResource(Fonts);
     const wanted = /* @__PURE__ */ new Map();
@@ -665,20 +706,24 @@ class DiceTableState {
     if (this.resources.nextRelease() <= now) this.resources.sweep(now);
     const p = this.current;
     if (!p || p.done) return;
-    const dt = Math.min(world.resource(Time).delta, MAX_STEP_S);
-    if (p.phase === "tumble") this.tumble(p, dt);
-    if (!Number.isNaN(p.landedAt)) this.settleLook(p, now);
-    if (!Number.isNaN(p.fadeFrom)) this.fade(p, now);
-    if (p.entrances.length > 0) this.entrancesFrame(p, now);
-    if (p.runs.length > 0) this.accent(p, now);
-    if (p.phase === "accent" && now >= p.accentEndsAt) this.rest(p);
-    this.attachmentsFrame(p, now);
-    if (p.fps > 0 && !p.reduced && p.entities.length > 0 && !p.done) {
-      const demand = world.resource(FrameDemand);
-      if (p.fps === Number.POSITIVE_INFINITY) demand.hold(ANIMATED_DEMAND);
-      else demand.after(1e3 / p.fps);
+    try {
+      const dt = Math.min(world.resource(Time).delta, MAX_STEP_S);
+      if (p.phase === "tumble") this.tumble(p, dt);
+      if (!Number.isNaN(p.landedAt)) this.settleLook(p, now);
+      if (!Number.isNaN(p.fadeFrom)) this.fade(p, now);
+      if (p.entrances.length > 0) this.entrancesFrame(p, now);
+      if (p.runs.length > 0) this.accent(p, now);
+      if (p.phase === "accent" && now >= p.accentEndsAt) this.rest(p);
+      this.attachmentsFrame(p, now);
+      if (p.fps > 0 && !p.reduced && p.entities.length > 0 && !p.done) {
+        const demand = world.resource(FrameDemand);
+        if (p.fps === Number.POSITIVE_INFINITY) demand.hold(ANIMATED_DEMAND);
+        else demand.after(1e3 / p.fps);
+      }
+      if (p.phase === "rest" && now >= p.restEndsAt) this.finish(p, "finished");
+    } catch (error) {
+      this.fail(p, error);
     }
-    if (p.phase === "rest" && now >= p.restEndsAt) this.finish(p, "finished");
   }
   tumble(p, dt) {
     const world = this.world;
@@ -767,6 +812,7 @@ class DiceTableState {
     p.lastImpact[a] = t;
     if (b >= 0) p.lastImpact[b] = t;
     const tray = b < 0;
+    if (this.eventSound(p, p.skins[a].sounds.impactEvent, a, k, strength, tray ? 0 : 1)) return;
     const variation = ((Math.imul(k + 1, 2654435761) ^ p.soundSeed) >>> 0) % IMPACT_VARIATIONS;
     const clip = this.sounds.impact(
       p.skins[a].sounds.impact,
@@ -799,11 +845,12 @@ class DiceTableState {
     const audio = world.tryResource(AudioState);
     if (audio && p.soundGain > 0) {
       const i = p.placed.findIndex(Boolean);
-      if (i >= 0) {
+      if (i >= 0 && !this.eventSound(p, p.skins[i].sounds.impactEvent, i, 1e5 + i, 0.5)) {
         const clip = this.sounds.impact(p.skins[i].sounds.impact, "tray", 1, 0);
         const level = 0.14 * p.soundGain;
         p.voices.push(
           playSound(world, clip, {
+            bus: DICE_AUDIO_BUS,
             volume: [level * 0.8, level],
             pitch: [p.pitch[i] * 0.9, p.pitch[i] * 0.98]
           })
@@ -971,6 +1018,7 @@ class DiceTableState {
   }
   /** Starts a matched recipe's effects on `anchors`. Returns how long the longest runs, ms. */
   playRecipe(p, m, anchors, now, budget) {
+    if (anchors.length === 0) return 0;
     let longest = 0;
     const at = this.centroid(p, anchors);
     for (const effect of m.recipe.effects) {
@@ -980,9 +1028,11 @@ class DiceTableState {
         continue;
       }
       if (effect.kind === "sound-accent") {
-        if (budget.cue) continue;
+        if (budget.cue || p.cuePlayed) continue;
         budget.cue = true;
-        this.accentSound(p, effect.cue, effect.gain);
+        p.cuePlayed = true;
+        if (!this.eventSound(p, effect.event, anchors[0], 2e5 + anchors[0], 1, 0, effect.gain))
+          this.accentSound(p, effect.cue, effect.gain);
         continue;
       }
       if (!at) continue;
@@ -1017,9 +1067,12 @@ class DiceTableState {
       if (p.playedRecipes.has(m.recipe.id)) continue;
       longest = Math.max(longest, this.playRecipe(p, m, m.anchors, now, budget));
     }
-    if (!budget.cue) {
-      const i = p.dice.findIndex((d, k) => !d.dropped && p.skins[k].sounds.accent);
-      if (i >= 0) this.accentSound(p, p.skins[i].sounds.accent, 0.6);
+    if (!budget.cue && !p.cuePlayed) {
+      const i = p.dice.findIndex(
+        (d, k) => !d.dropped && (p.skins[k].sounds.resultEvent || p.skins[k].sounds.accent)
+      );
+      if (i >= 0 && !this.eventSound(p, p.skins[i].sounds.resultEvent, i, 3e5 + i))
+        this.accentSound(p, p.skins[i].sounds.accent, 0.6);
     }
     if (longest === 0 && p.live.length === 0) return false;
     p.phase = "accent";
@@ -1030,7 +1083,9 @@ class DiceTableState {
   accentSound(p, cue, gain) {
     if (!this.world.tryResource(AudioState) || p.soundGain <= 0) return;
     const level = ACCENT_LEVEL * gain * p.soundGain;
-    p.voices.push(playSound(this.world, this.sounds.accent(cue), { volume: level }));
+    p.voices.push(
+      playSound(this.world, this.sounds.accent(cue), { bus: DICE_AUDIO_BUS, volume: level })
+    );
   }
   startRun(p, run) {
     const world = this.world;
@@ -1208,7 +1263,7 @@ class DiceTableState {
         const g = p.soundGain;
         const v = options.volume ?? 1;
         const volume = typeof v === "number" ? v * g : [v[0] * g, v[1] * g];
-        const voice = playSound(world, clip, { ...options, volume });
+        const voice = playSound(world, clip, { bus: DICE_AUDIO_BUS, ...options, volume });
         p.voices.push(voice);
         return voice;
       },
@@ -1457,6 +1512,8 @@ class DiceTableState {
         `Entrance "${run.name}" spawned more than its ${def.vertices} vertices; its die drops in instead.`
       );
       world.set(p.entities[run.die], Visibility, { mode: "visible" });
+    } else {
+      this.eventSound(p, p.skins[run.die].sounds.entranceEvent, run.die, 4e5 + run.die);
     }
   }
   /** Each frame while an entrance is alive: scenes, the die's landing, its result ramp. */
@@ -1536,6 +1593,8 @@ class DiceTableState {
   entranceImpact(p, run) {
     const strength = run.def?.impact ?? 0.8;
     if (strength <= 0 || p.soundGain <= 0 || !this.world.tryResource(AudioState)) return;
+    if (this.eventSound(p, p.skins[run.die].sounds.impactEvent, run.die, 5e5 + run.die, strength))
+      return;
     const variation = ((p.soundSeed ^ Math.imul(run.die + 7, 2654435761)) >>> 0) % IMPACT_VARIATIONS;
     const clip = this.sounds.impact(
       p.skins[run.die].sounds.impact,
@@ -1547,6 +1606,7 @@ class DiceTableState {
     const pitch = p.pitch[run.die] ?? 1;
     p.voices.push(
       playSound(this.world, clip, {
+        bus: DICE_AUDIO_BUS,
         volume: [level * 0.8, level],
         pitch: [pitch * 0.94, pitch * 1.06]
       })
@@ -1571,6 +1631,7 @@ class DiceTableState {
     p.done = true;
     p.unlisten?.();
     p.abort.abort();
+    p.audio.dispose();
     const world = this.world;
     const now = this.options.now();
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aethervtt/shard-dice",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -20,19 +20,19 @@
     "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"
+    "@aethervtt/shard-assets": "0.2.0",
+    "@aethervtt/shard-audio": "0.2.0",
+    "@aethervtt/shard-core": "0.2.0",
+    "@aethervtt/shard-gpu": "0.2.0",
+    "@aethervtt/shard-mesh": "0.2.0",
+    "@aethervtt/shard-particles": "0.2.0",
+    "@aethervtt/shard-physics": "0.2.0",
+    "@aethervtt/shard-protocol": "0.2.0",
+    "@aethervtt/shard-render": "0.2.0",
+    "@aethervtt/shard-runtime": "0.2.0",
+    "@aethervtt/shard-text": "0.2.0",
+    "@aethervtt/shard-texture": "0.2.0",
+    "@aethervtt/shard-transform": "0.2.0"
   },
   "repository": {
     "type": "git",
@@ -44,6 +44,6 @@
     "provenance": true
   },
   "shard": {
-    "buildSha": "8e14c9896f82a3554b156f1ffdd68f2cc3e7d78a"
+    "buildSha": "32c22a3944ed23f5d1baa90bf7cc9fae724f5fd8"
   }
 }