@vibuca/synth8-player 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sven Hemmer
+
+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

@@ -0,0 +1,73 @@
+# @vibuca/synth8-player
+
+Tone.js player for Synt8 patterns.
+
+This package plays patterns compiled by `@vibuca/synth8-core`.
+
+## Install
+
+```bash
+npm install @vibuca/synth8-core @vibuca/synth8-player
+```
+
+## Usage
+
+```ts
+import { compile } from "@vibuca/synth8-core";
+import { play, stop } from "@vibuca/synth8-player";
+
+const pattern = compile(`
+  song(
+    beat("kick+hihat snare hihat snare"),
+    melody("c4 e4 g4 e4")
+  )
+`);
+
+await play(pattern, { bpm: 120 });
+
+// later
+stop();
+```
+
+## API
+
+### `play(pattern, options)`
+
+Plays a compiled Synt8 pattern.
+
+```ts
+play(pattern, { bpm: 120 });
+```
+
+Options:
+
+```ts
+type PlayOptions = {
+  bpm: number;
+};
+```
+
+### `stop()`
+
+Stops playback.
+
+```ts
+stop();
+```
+
+## Supported events
+
+`@vibuca/synth8-player` supports:
+
+```ts
+{ type: "drum", value: "kick" }
+{ type: "note", value: "c4" }
+```
+
+Drums are synthesized with Tone.js percussion voices.
+
+Notes are played with a Tone.js synth.
+
+## License
+
+MIT

package/dist/drum/drum-synths.d.ts

@@ -0,0 +1,10 @@
+import * as Tone from "tone";
+declare const kick: Tone.MembraneSynth;
+declare const snare: Tone.NoiseSynth;
+declare const hihat: Tone.MetalSynth;
+declare const clap: Tone.NoiseSynth;
+declare const openhat: Tone.MetalSynth;
+declare const tom: Tone.MembraneSynth;
+declare const rim: Tone.MetalSynth;
+declare const cowbell: Tone.AmplitudeEnvelope;
+export { kick, snare, hihat, clap, openhat, tom, rim, cowbell };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Pattern } from '@vibuca/synth8-core';
+export type PlayOptions = {
+    bpm?: number;
+};
+export declare const play: (pattern: Pattern, options?: PlayOptions) => Promise<void>;
+export declare const stop: () => void;

package/dist/index.js

@@ -0,0 +1,102 @@
+import * as e from "tone";
+//#region src/drum/drum-synths.ts
+var t = new e.MembraneSynth().toDestination(), n = new e.NoiseSynth({
+	noise: { type: "white" },
+	envelope: {
+		attack: .001,
+		decay: .15,
+		sustain: 0
+	}
+}).toDestination(), r = new e.MetalSynth({
+	envelope: {
+		attack: .001,
+		decay: .05,
+		release: .01
+	},
+	harmonicity: 5.1,
+	modulationIndex: 32,
+	resonance: 4e3,
+	octaves: 1.5
+});
+r.frequency.value = 300, r.toDestination();
+var i = new e.NoiseSynth({
+	noise: { type: "white" },
+	envelope: {
+		attack: .001,
+		decay: .12,
+		sustain: 0
+	}
+}).toDestination(), a = new e.MetalSynth({
+	envelope: {
+		attack: .001,
+		decay: .35,
+		release: .1
+	},
+	harmonicity: 5.1,
+	modulationIndex: 24,
+	resonance: 5e3,
+	octaves: 1.5
+});
+a.frequency.value = 350, a.toDestination();
+var o = new e.MembraneSynth().toDestination(), s = new e.MetalSynth({ envelope: {
+	attack: .001,
+	decay: .08,
+	release: .01
+} });
+s.frequency.value = 800, s.toDestination();
+var c = new e.AmplitudeEnvelope({
+	attack: .001,
+	decay: .18,
+	sustain: 0,
+	release: .03
+}).toDestination(), l = new e.Oscillator(540, "square").connect(c), u = new e.Oscillator(800, "square").connect(c);
+l.start(), u.start();
+//#endregion
+//#region src/index.ts
+var d = new e.PolySynth(e.Synth).toDestination(), f = (e, l) => {
+	switch (e) {
+		case "kick":
+			t.triggerAttackRelease("C1", "8n", l);
+			break;
+		case "snare":
+			n.triggerAttackRelease("16n", l);
+			break;
+		case "clap":
+			i.triggerAttackRelease("16n", l);
+			break;
+		case "hihat":
+			r.triggerAttackRelease("32n", l);
+			break;
+		case "openhat":
+			a.triggerAttackRelease("8n", l);
+			break;
+		case "tom":
+			o.triggerAttackRelease("G1", "8n", l);
+			break;
+		case "rim":
+			s.triggerAttackRelease("32n", l);
+			break;
+		case "cowbell":
+			c.triggerAttackRelease("16n", l);
+			break;
+		default: console.warn(`Unknown drum sound: ${e}`);
+	}
+}, p = async (t, n = {}) => {
+	let r = n.bpm ?? 120;
+	await e.start();
+	let i = e.getTransport();
+	i.stop(), i.cancel(), i.bpm.value = r;
+	let a = 60 / r, o = t.length * a;
+	for (let e of t.events) {
+		let t = e.time * a;
+		i.scheduleRepeat((t) => {
+			e.type === "drum" && f(e.value, t), e.type === "note" && d.triggerAttackRelease(e.value, e.dur, t);
+		}, o, t);
+	}
+	i.start();
+}, m = () => {
+	let t = e.getTransport();
+	t.stop(), t.cancel();
+};
+//#endregion
+export { p as play, m as stop };

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@vibuca/synth8-player",
+  "version": "0.1.1",
+  "type": "module",
+  "license": "MIT",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    }
+  },
+  "dependencies": {
+    "tone": "^15.1.22",
+    "@vibuca/synth8-core": "0.1.1"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "vite build"
+  }
+}

package/src/index.ts

@@ -0,0 +1,92 @@
+import * as Tone from "tone";
+import { kick, snare, hihat, clap, openhat, tom, cowbell, rim } from "./drum/drum-synths";
+import type { Pattern } from "@vibuca/synth8-core";
+
+export type PlayOptions = {
+    bpm?: number;
+};
+
+const synth = new Tone.PolySynth(Tone.Synth).toDestination();
+
+const playDrum = (value: string, time: number) => {
+    switch (value) {
+        case "kick":
+            kick.triggerAttackRelease("C1", "8n", time);
+            break;
+
+        case "snare":
+            snare.triggerAttackRelease("16n", time);
+            break;
+
+        case "clap":
+            clap.triggerAttackRelease("16n", time);
+            break;
+
+        case "hihat":
+            hihat.triggerAttackRelease("32n", time);
+            break;
+
+        case "openhat":
+            openhat.triggerAttackRelease("8n", time);
+            break;
+
+        case "tom":
+            tom.triggerAttackRelease("G1", "8n", time);
+            break;
+
+        case "rim":
+            rim.triggerAttackRelease("32n", time);
+            break;
+
+        case "cowbell":
+            cowbell.triggerAttackRelease("16n", time);
+            break;
+
+        default:
+            console.warn(`Unknown drum sound: ${value}`);
+    }
+};
+
+export const play = async (
+    pattern: Pattern,
+    options: PlayOptions = {}
+): Promise<void> => {
+    const bpm = options.bpm ?? 120;
+
+    await Tone.start();
+
+    const transport = Tone.getTransport();
+    transport.stop();
+    transport.cancel();
+    transport.bpm.value = bpm;
+
+    const secondsPerBeat = 60 / bpm;
+    const loopDuration = pattern.length * secondsPerBeat;
+
+    for (const event of pattern.events) {
+        const eventOffset = event.time * secondsPerBeat;
+
+        transport.scheduleRepeat(
+            (time) => {
+                if (event.type === "drum") {
+                    playDrum(event.value, time);
+                }   
+
+                if (event.type === "note") {
+                    synth.triggerAttackRelease(event.value, event.dur, time);
+
+                }
+            },
+            loopDuration,
+            eventOffset
+        );
+    }
+
+    transport.start();
+};
+
+export const stop = (): void => {
+    const transport = Tone.getTransport();
+    transport.stop();
+    transport.cancel();
+};