@hum2music/web 0.0.0-stage → 0.1.0

package/package.json

@@ -1,6 +1,24 @@
 {
   "name": "@hum2music/web",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Hum2Music's localhost UI server (Bun.serve API plus a static, build-free frontend).",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/hum2music/hum2music",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hum2music/hum2music.git",
+    "directory": "apps/web"
+  },
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "files": ["src", "public"],
+  "dependencies": {
+    "@hum2music/audio-analysis": "0.1.0",
+    "@hum2music/harmony": "0.1.0",
+    "@hum2music/expression": "0.1.0",
+    "@hum2music/midi": "0.1.0",
+    "@hum2music/arrangement": "0.1.0",
+    "@hum2music/rendering": "0.1.0"
+  }
+}

package/public/app.js

@@ -0,0 +1,295 @@
+// Pure audio helpers (no DOM dependency) — exported so they can be unit
+// tested directly under Bun, in addition to running in the browser.
+
+export function downmixToMono(audioBuffer) {
+  const channels = audioBuffer.numberOfChannels;
+  const length = audioBuffer.length;
+  const mono = new Float32Array(length);
+  for (let channel = 0; channel < channels; channel++) {
+    const data = audioBuffer.getChannelData(channel);
+    for (let i = 0; i < length; i++) mono[i] += data[i] / channels;
+  }
+  return mono;
+}
+
+export function encodeWavPcm16(samples, sampleRate) {
+  const numChannels = 1;
+  const bitsPerSample = 16;
+  const blockAlign = (numChannels * bitsPerSample) / 8;
+  const byteRate = sampleRate * blockAlign;
+  const dataSize = samples.length * blockAlign;
+
+  const buffer = new ArrayBuffer(44 + dataSize);
+  const view = new DataView(buffer);
+
+  writeAscii(view, 0, "RIFF");
+  view.setUint32(4, 36 + dataSize, true);
+  writeAscii(view, 8, "WAVE");
+  writeAscii(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, numChannels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, byteRate, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitsPerSample, true);
+  writeAscii(view, 36, "data");
+  view.setUint32(40, dataSize, true);
+
+  for (let i = 0; i < samples.length; i++) {
+    const clamped = Math.max(-1, Math.min(1, samples[i]));
+    view.setInt16(44 + i * 2, Math.round(clamped * 32767), true);
+  }
+
+  return buffer;
+}
+
+export function writeAscii(view, offset, text) {
+  for (let i = 0; i < text.length; i++) view.setUint8(offset + i, text.charCodeAt(i));
+}
+
+// Everything below touches the DOM/Web Audio/MediaDevices APIs, so it's
+// skipped entirely when this module is imported in a non-browser test
+// environment (see tests/web/app.test.ts).
+if (typeof document !== "undefined") {
+  initUI();
+}
+
+function initUI() {
+  const fileInput = document.getElementById("file-input");
+  const recordButton = document.getElementById("record-button");
+  const recordStatus = document.getElementById("record-status");
+  const analysisSection = document.getElementById("analysis-section");
+  const arrangementSection = document.getElementById("arrangement-section");
+  const exportSection = document.getElementById("export-section");
+  const pitchCanvas = document.getElementById("pitch-canvas");
+  const tempoCandidatesEl = document.getElementById("tempo-candidates");
+  const keyCandidatesEl = document.getElementById("key-candidates");
+  const notesSummaryEl = document.getElementById("notes-summary");
+  const chordEditorEl = document.getElementById("chord-editor");
+  const instrumentToggles = Array.from(document.querySelectorAll(".instrument-toggle"));
+  const styleSelect = document.getElementById("style-select");
+  const songStructureCheckbox = document.getElementById("song-structure-checkbox");
+  const humanizeSlider = document.getElementById("humanize-slider");
+  const humanizeValueEl = document.getElementById("humanize-value");
+  const seedInput = document.getElementById("seed-input");
+  const regenerateButton = document.getElementById("regenerate-button");
+  const downloadMidiButton = document.getElementById("download-midi-button");
+  const downloadWavButton = document.getElementById("download-wav-button");
+  const downloadJsonButton = document.getElementById("download-json-button");
+
+  let lastAnalysis = null;
+  let currentChords = [];
+  let mediaRecorder = null;
+  let recordedChunks = [];
+
+  fileInput.addEventListener("change", async () => {
+    const file = fileInput.files[0];
+    if (!file) return;
+    const wavBlob = await decodeToWavBlob(await file.arrayBuffer());
+    await analyze(wavBlob);
+  });
+
+  recordButton.addEventListener("click", async () => {
+    if (mediaRecorder && mediaRecorder.state === "recording") {
+      mediaRecorder.stop();
+      return;
+    }
+
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    recordedChunks = [];
+    mediaRecorder = new MediaRecorder(stream);
+    mediaRecorder.addEventListener("dataavailable", (event) => recordedChunks.push(event.data));
+    mediaRecorder.addEventListener("stop", async () => {
+      recordStatus.textContent = "解析中...";
+      const blob = new Blob(recordedChunks, { type: mediaRecorder.mimeType });
+      const wavBlob = await decodeToWavBlob(await blob.arrayBuffer());
+      await analyze(wavBlob);
+      stream.getTracks().forEach((track) => track.stop());
+      recordButton.textContent = "マイク録音開始";
+    });
+
+    mediaRecorder.start();
+    recordButton.textContent = "録音停止";
+    recordStatus.textContent = "録音中...";
+  });
+
+  humanizeSlider.addEventListener("input", () => {
+    humanizeValueEl.textContent = humanizeSlider.value;
+  });
+
+  regenerateButton.addEventListener("click", async () => {
+    if (!lastAnalysis) return;
+    regenerateButton.disabled = true;
+    regenerateButton.textContent = "生成中...";
+    try {
+      await regenerateMidi();
+    } finally {
+      regenerateButton.disabled = false;
+      regenerateButton.textContent = "再生成";
+    }
+  });
+
+  downloadMidiButton.addEventListener("click", async () => {
+    const blob = await fetchExport("/api/export/midi");
+    if (blob) downloadBlob(blob, "song.mid");
+  });
+
+  downloadWavButton.addEventListener("click", async () => {
+    const blob = await fetchExport("/api/export/wav");
+    if (blob) downloadBlob(blob, "song.wav");
+  });
+
+  downloadJsonButton.addEventListener("click", () => {
+    if (!lastAnalysis) return;
+    downloadBlob(new Blob([JSON.stringify(lastAnalysis, null, 2)], { type: "application/json" }), "analysis.json");
+  });
+
+  async function decodeToWavBlob(arrayBuffer) {
+    const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+    const audioContext = new AudioContextClass();
+    const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+    const mono = downmixToMono(audioBuffer);
+    const wavBuffer = encodeWavPcm16(mono, audioBuffer.sampleRate);
+    await audioContext.close();
+    return new Blob([wavBuffer], { type: "audio/wav" });
+  }
+
+  async function analyze(wavBlob) {
+    const formData = new FormData();
+    formData.append("audio", wavBlob, "input.wav");
+
+    const response = await fetch("/api/analyze", { method: "POST", body: formData });
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({ error: response.statusText }));
+      alert(`解析に失敗しました: ${body.error ?? response.statusText}`);
+      return;
+    }
+
+    lastAnalysis = await response.json();
+    currentChords = lastAnalysis.chords.map((chord) => ({ ...chord }));
+    renderAnalysis(lastAnalysis);
+    renderChordEditor(currentChords);
+    analysisSection.hidden = false;
+    arrangementSection.hidden = false;
+    exportSection.hidden = false;
+  }
+
+  function renderAnalysis(analysis) {
+    drawPitchCurve(analysis.pitchCurve, analysis.notes);
+    tempoCandidatesEl.textContent = analysis.tempoCandidates
+      .map((c) => `${c.bpm} BPM (${Math.round(c.confidence * 100)}%)`)
+      .join(", ");
+    keyCandidatesEl.textContent = analysis.keyCandidates
+      .slice(0, 3)
+      .map((c) => `${c.tonic} ${c.mode} (${Math.round(c.confidence * 100)}%)`)
+      .join(", ");
+    notesSummaryEl.textContent = `検出ノート数: ${analysis.notes.length} / 推定BPM: ${analysis.selectedBpm}`;
+  }
+
+  function renderChordEditor(chords) {
+    chordEditorEl.replaceChildren();
+    chords.forEach((chord, index) => {
+      const label = document.createElement("label");
+      label.textContent = `bar ${index + 1}: `;
+      const input = document.createElement("input");
+      input.type = "text";
+      input.value = chord.symbol;
+      input.size = 6;
+      input.addEventListener("input", () => {
+        currentChords[index] = { ...currentChords[index], symbol: input.value };
+      });
+      label.appendChild(input);
+      chordEditorEl.appendChild(label);
+    });
+  }
+
+  function drawPitchCurve(pitchCurve, notes) {
+    const ctx = pitchCanvas.getContext("2d");
+    ctx.clearRect(0, 0, pitchCanvas.width, pitchCanvas.height);
+
+    const voiced = pitchCurve.filter((frame) => frame.voiced && frame.f0Hz !== null);
+    if (voiced.length === 0) return;
+
+    const maxTimeMs = pitchCurve[pitchCurve.length - 1].timeMs || 1;
+    const minHz = Math.min(...voiced.map((frame) => frame.f0Hz));
+    const maxHz = Math.max(...voiced.map((frame) => frame.f0Hz));
+    const hzRange = maxHz - minHz || 1;
+
+    ctx.strokeStyle = "#3366cc";
+    ctx.beginPath();
+    let drawing = false;
+    for (const frame of pitchCurve) {
+      if (!frame.voiced || frame.f0Hz === null) {
+        drawing = false;
+        continue;
+      }
+      const x = (frame.timeMs / maxTimeMs) * pitchCanvas.width;
+      const y = pitchCanvas.height - ((frame.f0Hz - minHz) / hzRange) * pitchCanvas.height;
+      if (!drawing) {
+        ctx.moveTo(x, y);
+        drawing = true;
+      } else {
+        ctx.lineTo(x, y);
+      }
+    }
+    ctx.stroke();
+
+    ctx.fillStyle = "#cc3366";
+    for (const note of notes) {
+      const x = (note.startMs / maxTimeMs) * pitchCanvas.width;
+      const midiHz = 440 * Math.pow(2, (note.midiPitch - 69) / 12);
+      const y = pitchCanvas.height - ((midiHz - minHz) / hzRange) * pitchCanvas.height;
+      ctx.fillRect(x - 2, y - 2, 4, 4);
+    }
+  }
+
+  function selectedInstruments() {
+    return instrumentToggles.filter((toggle) => toggle.checked).map((toggle) => toggle.value);
+  }
+
+  function buildExportRequestBody() {
+    return {
+      notes: lastAnalysis.notes,
+      chords: currentChords,
+      instruments: selectedInstruments(),
+      style: styleSelect.value,
+      songStructure: songStructureCheckbox.checked,
+      humanize: Number(humanizeSlider.value),
+      seed: Number(seedInput.value),
+      bpm: lastAnalysis.selectedBpm,
+    };
+  }
+
+  async function regenerateMidi() {
+    const response = await fetch("/api/export/midi", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(buildExportRequestBody()),
+    });
+    if (!response.ok) alert("MIDI生成に失敗しました");
+  }
+
+  async function fetchExport(path) {
+    if (!lastAnalysis) return null;
+    const response = await fetch(path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(buildExportRequestBody()),
+    });
+    if (!response.ok) {
+      alert("書き出しに失敗しました");
+      return null;
+    }
+    return response.blob();
+  }
+
+  function downloadBlob(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const anchor = document.createElement("a");
+    anchor.href = url;
+    anchor.download = filename;
+    anchor.click();
+    URL.revokeObjectURL(url);
+  }
+}

package/public/index.html

@@ -0,0 +1,73 @@
+<!doctype html>
+<html lang="ja">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Hum2Music</title>
+    <link rel="stylesheet" href="/style.css" />
+  </head>
+  <body>
+    <h1>Hum2Music</h1>
+    <p class="note">
+      鼻歌から複数トラック（メロディー/ピアノ/ベース/ドラム）の楽曲プレビューを生成します。
+      自動編曲は決定的なルールベースの簡易実装です。
+    </p>
+
+    <section id="input-section">
+      <h2>Input</h2>
+      <label>WAVファイルを選択: <input type="file" id="file-input" accept="audio/*" /></label>
+      <button id="record-button" type="button">マイク録音開始</button>
+      <span id="record-status"></span>
+    </section>
+
+    <section id="analysis-section" hidden>
+      <h2>Analysis</h2>
+      <canvas id="pitch-canvas" width="800" height="200"></canvas>
+      <p><strong>BPM候補:</strong> <span id="tempo-candidates"></span></p>
+      <p><strong>調性候補:</strong> <span id="key-candidates"></span></p>
+      <p id="notes-summary"></p>
+    </section>
+
+    <section id="arrangement-section" hidden>
+      <h2>Arrangement</h2>
+
+      <fieldset>
+        <legend>楽器</legend>
+        <label><input type="checkbox" class="instrument-toggle" value="piano" checked /> Piano</label>
+        <label><input type="checkbox" class="instrument-toggle" value="bass" checked /> Bass</label>
+        <label><input type="checkbox" class="instrument-toggle" value="drums" checked /> Drums</label>
+        <label><input type="checkbox" class="instrument-toggle" value="guitar" checked /> Guitar</label>
+      </fieldset>
+
+      <fieldset>
+        <legend>コード進行（編集可）</legend>
+        <div id="chord-editor"></div>
+      </fieldset>
+
+      <label>
+        Style:
+        <select id="style-select">
+          <option value="pop">Pop</option>
+          <option value="ballad">Ballad</option>
+        </select>
+      </label>
+      <label><input type="checkbox" id="song-structure-checkbox" /> 曲構造に応じてグルーヴを変化させる</label>
+
+      <label>
+        Humanize: <input type="range" id="humanize-slider" min="0" max="1" step="0.05" value="0" />
+        <span id="humanize-value">0</span>
+      </label>
+      <label>Seed: <input type="number" id="seed-input" value="42" /></label>
+      <button id="regenerate-button" type="button">再生成</button>
+    </section>
+
+    <section id="export-section" hidden>
+      <h2>Export</h2>
+      <button id="download-midi-button" type="button">MIDIダウンロード</button>
+      <button id="download-wav-button" type="button">WAVダウンロード</button>
+      <button id="download-json-button" type="button">JSONダウンロード</button>
+    </section>
+
+    <script type="module" src="/app.js"></script>
+  </body>
+</html>

package/public/style.css

@@ -0,0 +1,32 @@
+body {
+  font-family: system-ui, sans-serif;
+  max-width: 840px;
+  margin: 2rem auto;
+  padding: 0 1rem;
+  color: #222;
+}
+
+h1 {
+  margin-bottom: 0.25rem;
+}
+
+.note {
+  color: #666;
+  font-size: 0.9rem;
+}
+
+section {
+  border-top: 1px solid #ddd;
+  padding: 1rem 0;
+}
+
+canvas {
+  background: #fafafa;
+  border: 1px solid #ddd;
+  width: 100%;
+  height: 200px;
+}
+
+button {
+  cursor: pointer;
+}

package/src/api/analyze.ts

@@ -0,0 +1,57 @@
+import {
+  decodeWav,
+  detectPitchYin,
+  removePitchOutliers,
+  smoothPitchTrajectory,
+  transcribeMelody,
+} from "@hum2music/audio-analysis";
+import { analyzeHarmony, type TimedNote } from "@hum2music/harmony";
+
+export async function handleAnalyze(request: Request): Promise<Response> {
+  const formData = await request.formData();
+  const file = formData.get("audio");
+
+  if (!(file instanceof Blob)) {
+    return jsonError(400, "Missing 'audio' file field");
+  }
+
+  let sampleRate: number;
+  let samples: Float32Array;
+  try {
+    ({ sampleRate, samples } = decodeWav(await file.arrayBuffer()));
+  } catch (error) {
+    return jsonError(400, `Could not decode audio: ${(error as Error).message}`);
+  }
+
+  // Recomputes the pitch track for display (transcribeMelody runs the same
+  // YIN pass internally) — a known inefficiency, acceptable for a local,
+  // single-request preview endpoint. See tasks/STATUS.md.
+  const pitchCurve = smoothPitchTrajectory(removePitchOutliers(detectPitchYin(samples, sampleRate)));
+  const notes = transcribeMelody(samples, sampleRate);
+
+  if (notes.length === 0) {
+    return jsonError(422, "No valid pitch could be detected in the input audio.");
+  }
+
+  const timedNotes: TimedNote[] = notes.map((note) => ({
+    pitch: note.midiPitch,
+    startMs: note.startMs,
+    durationMs: note.durationMs,
+    velocity: note.velocity,
+  }));
+  const harmony = analyzeHarmony(timedNotes);
+
+  return Response.json({
+    sampleRate,
+    pitchCurve,
+    notes,
+    tempoCandidates: harmony.tempoCandidates,
+    selectedBpm: harmony.selectedBpm,
+    keyCandidates: harmony.keyCandidates,
+    chords: harmony.chords,
+  });
+}
+
+function jsonError(status: number, error: string): Response {
+  return Response.json({ error }, { status });
+}

package/src/api/export-midi.ts

@@ -0,0 +1,28 @@
+import { writeMultiTrackMidiFile } from "@hum2music/midi";
+import { jsonError, resolveComposition, type ExportRequestBody } from "./shared";
+
+export async function handleExportMidi(request: Request): Promise<Response> {
+  let body: ExportRequestBody;
+  try {
+    body = (await request.json()) as ExportRequestBody;
+  } catch {
+    return jsonError(400, "Request body must be JSON");
+  }
+
+  if (!Array.isArray(body.notes) || body.notes.length === 0) {
+    return jsonError(400, "'notes' must be a non-empty array");
+  }
+
+  const { tracks, bpm } = resolveComposition(body);
+  const midiBytes = writeMultiTrackMidiFile(
+    tracks.map((track) => ({ notes: track.notes, channel: track.channel, programNumber: track.programNumber })),
+    { bpm },
+  );
+
+  return new Response(midiBytes, {
+    headers: {
+      "Content-Type": "audio/midi",
+      "Content-Disposition": 'attachment; filename="song.mid"',
+    },
+  });
+}

package/src/api/export-wav.ts

@@ -0,0 +1,61 @@
+import { encodeWavPcm16, midiNoteToFrequency } from "@hum2music/audio-analysis";
+import {
+  classifyDrumNote,
+  renderToSamples,
+  type DrumRenderNote,
+  type PitchedRenderNote,
+  type Timbre,
+} from "@hum2music/rendering";
+import { jsonError, resolveComposition, type ExportRequestBody } from "./shared";
+
+export async function handleExportWav(request: Request): Promise<Response> {
+  let body: ExportRequestBody;
+  try {
+    body = (await request.json()) as ExportRequestBody;
+  } catch {
+    return jsonError(400, "Request body must be JSON");
+  }
+
+  if (!Array.isArray(body.notes) || body.notes.length === 0) {
+    return jsonError(400, "'notes' must be a non-empty array");
+  }
+
+  const { tracks } = resolveComposition(body);
+  const pitchedNotes: PitchedRenderNote[] = [];
+  const drumNotes: DrumRenderNote[] = [];
+
+  for (const track of tracks) {
+    if (track.instrument === "drums") {
+      for (const note of track.notes) {
+        drumNotes.push({
+          startMs: note.startMs,
+          durationMs: note.durationMs,
+          velocity: note.velocity,
+          drumType: classifyDrumNote(note.pitch),
+        });
+      }
+    } else {
+      const timbre = track.instrument as Timbre;
+      for (const note of track.notes) {
+        pitchedNotes.push({
+          startMs: note.startMs,
+          durationMs: note.durationMs,
+          velocity: note.velocity,
+          frequencyHz: midiNoteToFrequency(note.pitch),
+          timbre,
+        });
+      }
+    }
+  }
+
+  const seed = typeof body.seed === "number" ? body.seed : undefined;
+  const samples = renderToSamples(pitchedNotes, drumNotes, { seed });
+  const wavBytes = encodeWavPcm16(samples, 44100);
+
+  return new Response(wavBytes, {
+    headers: {
+      "Content-Type": "audio/wav",
+      "Content-Disposition": 'attachment; filename="song.wav"',
+    },
+  });
+}

package/src/api/shared.ts

@@ -0,0 +1,105 @@
+import {
+  ARRANGEABLE_INSTRUMENTS,
+  composeTracks,
+  type ArrangeableInstrument,
+} from "@hum2music/arrangement";
+import type { ChordEvent } from "@hum2music/core";
+import { analyzeHarmony, type TimedNote } from "@hum2music/harmony";
+import { noteEventsToMidiNotes, type MidiNoteEvent } from "@hum2music/midi";
+
+export interface ExportRequestNote {
+  midiPitch: number;
+  startMs: number;
+  durationMs: number;
+  velocity: number;
+}
+
+export interface ExportRequestBody {
+  notes?: ExportRequestNote[];
+  /** Omit (or leave empty) for melody-only export; provide to arrange piano/bass/drums. May be user-edited. */
+  chords?: ChordEvent[];
+  instruments?: string[];
+  humanize?: number;
+  seed?: number;
+  bpm?: number;
+  /** "pop" (default) or "ballad"; see packages/arrangement/src/style.ts. */
+  style?: string;
+  /** When true, humanize intensity varies by detected repeated section instead of staying flat. */
+  songStructure?: boolean;
+}
+
+export interface ResolvedTrack {
+  instrument: string;
+  notes: MidiNoteEvent[];
+  channel: number;
+  programNumber?: number;
+}
+
+export function jsonError(status: number, error: string): Response {
+  return Response.json({ error }, { status });
+}
+
+/**
+ * Resolves a request into ms-based, export-ready tracks. Shared by
+ * /api/export/midi and /api/export/wav so both honor the same instrument
+ * selection and chord progression (auto-detected or user-edited).
+ *
+ * - No chords and no humanize: raw passthrough of the posted notes (no
+ *   quantization), matching the CLI's `transcribe` default behavior.
+ * - No chords but humanize > 0: quantizes the melody (needed for
+ *   humanization) but arranges no instrument tracks.
+ * - Chords present: full melody + requested-instrument arrangement.
+ */
+export function resolveComposition(body: ExportRequestBody): { tracks: ResolvedTrack[]; bpm: number } {
+  const notes = body.notes ?? [];
+  const humanizeAmount = typeof body.humanize === "number" ? body.humanize : 0;
+  const seed = typeof body.seed === "number" ? body.seed : undefined;
+  const hasChords = Array.isArray(body.chords) && body.chords.length > 0;
+
+  if (!hasChords && humanizeAmount <= 0) {
+    const bpm = body.bpm ?? 120;
+    const rawNotes: MidiNoteEvent[] = notes.map((note) => ({
+      pitch: note.midiPitch,
+      startMs: note.startMs,
+      durationMs: note.durationMs,
+      velocity: note.velocity,
+    }));
+    return { tracks: [{ instrument: "melody", notes: rawNotes, channel: 0 }], bpm };
+  }
+
+  const timedNotes: TimedNote[] = notes.map((note) => ({
+    pitch: note.midiPitch,
+    startMs: note.startMs,
+    durationMs: note.durationMs,
+    velocity: note.velocity,
+  }));
+  const harmony = analyzeHarmony(timedNotes, { overrideBpm: body.bpm });
+  const bpm = harmony.selectedBpm;
+
+  const composed = composeTracks({
+    melody: harmony.melody,
+    chords: body.chords ?? [],
+    instruments: hasChords ? parseInstruments(body.instruments) : [],
+    humanizeAmount,
+    seed,
+    bpm,
+    style: body.style,
+    songSections: body.songStructure ? harmony.songSections : undefined,
+  });
+
+  const tracks: ResolvedTrack[] = composed.map((track) => ({
+    instrument: track.instrument,
+    notes: noteEventsToMidiNotes(track.notes, bpm),
+    channel: track.channel,
+    programNumber: track.programNumber,
+  }));
+
+  return { tracks, bpm };
+}
+
+function parseInstruments(raw: string[] | undefined): ArrangeableInstrument[] {
+  if (!raw) return [...ARRANGEABLE_INSTRUMENTS];
+  return raw.filter((value): value is ArrangeableInstrument =>
+    (ARRANGEABLE_INSTRUMENTS as readonly string[]).includes(value),
+  );
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./server";

package/src/server.ts

@@ -0,0 +1,43 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { handleAnalyze } from "./api/analyze";
+import { handleExportMidi } from "./api/export-midi";
+import { handleExportWav } from "./api/export-wav";
+
+const PUBLIC_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../public");
+
+export function startServer(port: number): ReturnType<typeof Bun.serve> {
+  return Bun.serve({
+    port,
+    async fetch(request) {
+      const url = new URL(request.url);
+
+      if (request.method === "POST" && url.pathname === "/api/analyze") {
+        return handleAnalyze(request);
+      }
+      if (request.method === "POST" && url.pathname === "/api/export/midi") {
+        return handleExportMidi(request);
+      }
+      if (request.method === "POST" && url.pathname === "/api/export/wav") {
+        return handleExportWav(request);
+      }
+
+      return serveStatic(url.pathname);
+    },
+  });
+}
+
+async function serveStatic(pathname: string): Promise<Response> {
+  const relativePath = pathname === "/" ? "/index.html" : pathname;
+  const filePath = resolve(PUBLIC_DIR, "." + relativePath);
+
+  if (!filePath.startsWith(PUBLIC_DIR)) {
+    return new Response("Forbidden", { status: 403 });
+  }
+
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) {
+    return new Response("Not found", { status: 404 });
+  }
+  return new Response(file);
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-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.