Add MIDI import and Faust playback renderers

.gitattributes

@@ -0,0 +1,2 @@
+frontend/vendor/faustwasm/libfaust-wasm/*.data filter=lfs diff=lfs merge=lfs -text
+frontend/vendor/faustwasm/libfaust-wasm/*.wasm filter=lfs diff=lfs merge=lfs -text

backend/app/continuator_adapter.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from pathlib import Path
 import os
 import sys
+from tempfile import TemporaryDirectory
 import threading
 
 import mido
@@ -40,10 +42,27 @@ class NoContinuationAvailable(RuntimeError):
     """Raised when the engine cannot generate a continuation."""
 
 
+class MidiImportError(RuntimeError):
+    """Raised when uploaded MIDI files cannot be imported."""
+
+
+@dataclass(frozen=True)
+class ImportedMidiPhrase:
+    file_name: str
+    payload: PhrasePayload
+
+
 def _round_float(value: float) -> float:
     return round(float(value), 6)
 
 
+def _normalize_uploaded_file_name(raw_name: str | None, fallback: str) -> str:
+    candidate = (raw_name or fallback).replace("\\", "/")
+    parts = [part for part in candidate.split("/") if part and part not in {".", ".."}]
+    normalized = "/".join(parts)
+    return normalized or fallback
+
+
 def _normalize_notes(notes: list[object]) -> list[object]:
     normalized = [note.copy() if hasattr(note, "copy") else note for note in notes]
     if not normalized:
@@ -126,15 +145,26 @@ def _notes_to_events(notes: list[object]) -> list[PlaybackMidiEvent]:
 
 
 def _build_phrase_payload(notes: list[object]) -> PhrasePayload:
+    raw_notes = list(notes)
     normalized_notes = _normalize_notes(notes)
     note_payload = [_note_to_schema(note) for note in normalized_notes]
     events = _notes_to_events(normalized_notes)
     duration_seconds = max((note.end_seconds for note in note_payload), default=0.0)
+    handoff_seconds = None
+    if raw_notes:
+        last_note = raw_notes[-1]
+        next_onset_beats = max(
+            0.0,
+            float(last_note.start_time)
+            + max(0.0, float(last_note.duration) + float(getattr(last_note, "next_start_delta", 0.0))),
+        )
+        handoff_seconds = _round_float(next_onset_beats / 2.0)
 
     return PhrasePayload(
         event_count=len(events),
         note_count=len(note_payload),
         duration_seconds=_round_float(duration_seconds),
+        handoff_seconds=handoff_seconds,
         events=events,
         notes=note_payload,
     )
@@ -159,6 +189,7 @@ class ContinuatorSessionEngine:
         forget_past: bool = False,
         keep_last_inputs: int = 20,
         decay_mode: str = "full",
+        markov_order: int = 4,
         seed_midi_file: Path | None = None,
         seed_midi_folder: Path | None = None,
     ) -> None:
@@ -167,23 +198,33 @@ class ContinuatorSessionEngine:
         self._forget_past = forget_past
         self._keep_last_inputs = keep_last_inputs
         self._decay_mode = decay_mode
+        self._markov_order = markov_order
         self._seed_midi_file = seed_midi_file
         self._seed_midi_folder = seed_midi_folder
         self._seed_sequence_count = 0
         self._lock = threading.RLock()
         self._continuator = self._create_engine()
 
-    def _create_engine(self) -> Continuator2:
-        midi_file = str(self._seed_midi_file) if self._seed_midi_file else None
-        engine = Continuator2(midi_file=midi_file, transposition=self._transposition)
-        if self._seed_midi_folder:
+    def _create_engine(self, *, load_seed_material: bool = True) -> Continuator2:
+        midi_file = None
+        if load_seed_material and self._seed_midi_file:
+            midi_file = str(self._seed_midi_file)
+
+        engine = Continuator2(
+            midi_file=midi_file,
+            kmax=self._markov_order,
+            transposition=self._transposition,
+        )
+        if load_seed_material and self._seed_midi_folder:
             engine.learn_folder(str(self._seed_midi_folder), transpose=self._transposition)
         engine.set_learn_input(self._default_learn_input)
         engine.set_transpose(self._transposition)
         engine.set_forget(self._forget_past)
         engine.set_keep_last(self._keep_last_inputs)
         engine.set_decay_mode(self._decay_mode)
-        self._seed_sequence_count = len(getattr(engine.vom, "input_sequences", []))
+        self._seed_sequence_count = (
+            len(getattr(engine.vom, "input_sequences", [])) if load_seed_material else 0
+        )
         return engine
 
     def apply_settings(
@@ -194,22 +235,48 @@ class ContinuatorSessionEngine:
         forget_past: bool | None = None,
         keep_last_inputs: int | None = None,
         decay_mode: str | None = None,
+        markov_order: int | None = None,
     ) -> None:
         with self._lock:
+            rebuild_required = markov_order is not None and markov_order != self._markov_order
+            preserved_payloads: list[PhrasePayload] = []
+            preserved_seed_count = self._seed_sequence_count
+            if rebuild_required:
+                preserved_payloads, preserved_seed_count = self.get_memory_snapshot()
+
             if learn_input is not None:
                 self._default_learn_input = learn_input
-                self._continuator.set_learn_input(learn_input)
             if transposition is not None:
                 self._transposition = transposition
-                self._continuator.set_transpose(transposition)
             if forget_past is not None:
                 self._forget_past = forget_past
-                self._continuator.set_forget(forget_past)
             if keep_last_inputs is not None:
                 self._keep_last_inputs = keep_last_inputs
-                self._continuator.set_keep_last(keep_last_inputs)
             if decay_mode is not None:
                 self._decay_mode = decay_mode
+            if markov_order is not None:
+                self._markov_order = markov_order
+
+            if rebuild_required:
+                self._continuator = self._create_engine(load_seed_material=False)
+                for payload in preserved_payloads:
+                    phrase_events = [MidiEvent.model_validate(event) for event in payload.events]
+                    try:
+                        self._learn_phrase_events_locked(phrase_events, transpose=False)
+                    except NoContinuationAvailable:
+                        continue
+                self._seed_sequence_count = min(preserved_seed_count, len(preserved_payloads))
+                return
+
+            if learn_input is not None:
+                self._continuator.set_learn_input(learn_input)
+            if transposition is not None:
+                self._continuator.set_transpose(transposition)
+            if forget_past is not None:
+                self._continuator.set_forget(forget_past)
+            if keep_last_inputs is not None:
+                self._continuator.set_keep_last(keep_last_inputs)
+            if decay_mode is not None:
                 self._continuator.set_decay_mode(decay_mode)
 
     def reset(self) -> None:
@@ -223,22 +290,132 @@ class ContinuatorSessionEngine:
             seed_count = min(self._seed_sequence_count, len(payloads))
             return payloads, seed_count
 
+    def _learn_phrase_events_locked(
+        self,
+        phrase_events: list[MidiEvent],
+        *,
+        transpose: bool,
+    ) -> PhrasePayload:
+        messages = [_event_to_mido_message(event) for event in phrase_events]
+        input_phrase = self._continuator.get_phrase_from_mido(messages)
+        if not input_phrase:
+            raise NoContinuationAvailable(
+                "The stored phrase did not contain any complete notes to rebuild."
+            )
+        self._continuator.learn_phrase(input_phrase, transpose)
+        return _build_phrase_payload(input_phrase)
+
     def learn_phrase_events(self, phrase_events: list[MidiEvent]) -> PhrasePayload:
         with self._lock:
-            messages = [_event_to_mido_message(event) for event in phrase_events]
-            input_phrase = self._continuator.get_phrase_from_mido(messages)
-            if not input_phrase:
+            return self._learn_phrase_events_locked(
+                phrase_events,
+                transpose=self._continuator.transpose,
+            )
+
+    def import_midi_files(
+        self,
+        midi_files: list[tuple[str, bytes]],
+    ) -> tuple[list[ImportedMidiPhrase], list[str]]:
+        with self._lock:
+            imported: list[ImportedMidiPhrase] = []
+            skipped: list[str] = []
+            with TemporaryDirectory(prefix="continuator-midi-import-") as temp_dir:
+                temp_root = Path(temp_dir)
+                for index, (raw_name, raw_bytes) in enumerate(midi_files):
+                    file_name = _normalize_uploaded_file_name(
+                        raw_name,
+                        f"imported_{index + 1}.mid",
+                    )
+                    suffix = Path(file_name).suffix.lower()
+                    if suffix not in {".mid", ".midi"} or not raw_bytes:
+                        skipped.append(file_name)
+                        continue
+
+                    temp_path = temp_root / f"upload_{index:04d}{suffix}"
+                    temp_path.write_bytes(raw_bytes)
+                    try:
+                        notes = list(self._continuator.extract_notes(str(temp_path)))
+                    except Exception:
+                        skipped.append(file_name)
+                        continue
+
+                    if not notes:
+                        skipped.append(file_name)
+                        continue
+
+                    self._continuator.learn_phrase(notes, self._continuator.transpose)
+                    imported.append(
+                        ImportedMidiPhrase(
+                            file_name=file_name,
+                            payload=_build_phrase_payload(notes),
+                        )
+                    )
+
+            if not imported:
+                raise MidiImportError("No importable MIDI files were found in the selection.")
+
+            return imported, skipped
+
+    def generate_phrase(
+        self,
+        note_count: int | None = None,
+        enforce_end_constraint: bool = True,
+    ) -> tuple[PhrasePayload, str | None]:
+        with self._lock:
+            if not getattr(self._continuator.vom, "input_sequences", []):
                 raise NoContinuationAvailable(
-                    "The stored phrase did not contain any complete notes to rebuild."
+                    "The Continuator memory is empty. Load MIDI or learn a phrase first."
                 )
-            self._continuator.learn_phrase(input_phrase, self._continuator.transpose)
-            return _build_phrase_payload(input_phrase)
+
+            target_note_count = note_count or 12
+            status_message = None
+            if enforce_end_constraint:
+                constraints = {target_note_count: self._continuator.get_end_vp()}
+                generated_sequence = self._continuator.sample_sequence(
+                    prefix=None,
+                    length=target_note_count + 1,
+                    constraints=constraints,
+                )
+                if generated_sequence is None:
+                    generated_sequence = self._continuator.sample_sequence(
+                        prefix=None,
+                        length=target_note_count,
+                        constraints={},
+                    )
+                    status_message = (
+                        "Generated from memory without the hard end constraint "
+                        "because the exact-ending version had no solution."
+                    )
+            else:
+                generated_sequence = self._continuator.sample_sequence(
+                    prefix=None,
+                    length=target_note_count,
+                    constraints={},
+                )
+
+            if generated_sequence is None:
+                raise NoContinuationAvailable(
+                    "The Continuator could not generate a fresh phrase from the current memory."
+                )
+
+            rendered_vp_sequence = generated_sequence
+            if rendered_vp_sequence and rendered_vp_sequence[-1] == self._continuator.get_end_vp():
+                rendered_vp_sequence = rendered_vp_sequence[:-1]
+
+            if not rendered_vp_sequence:
+                raise NoContinuationAvailable(
+                    "The Continuator returned an empty phrase from the current memory."
+                )
+
+            rendered_sequence = self._continuator.realize_vp_sequence(rendered_vp_sequence)
+            return _build_phrase_payload(rendered_sequence), status_message
 
     def continue_phrase(
         self,
         phrase_events: list[MidiEvent],
         learn_input: bool | None = None,
         continuation_note_count: int | None = None,
+        enforce_end_constraint: bool = True,
     ) -> tuple[PhrasePayload, PhrasePayload, str | None]:
         with self._lock:
             messages = [_event_to_mido_message(event) for event in phrase_events]
@@ -254,22 +431,29 @@ class ContinuatorSessionEngine:
                 self._continuator.learn_phrase(input_phrase, self._continuator.transpose)
 
             status_message = None
-            constraints = {target_note_count: self._continuator.get_end_vp()}
-            generated_sequence = self._continuator.sample_sequence(
-                prefix=input_phrase,
-                length=target_note_count + 1,
-                constraints=constraints,
-            )
-            if generated_sequence is None:
+            if enforce_end_constraint:
+                constraints = {target_note_count: self._continuator.get_end_vp()}
+                generated_sequence = self._continuator.sample_sequence(
+                    prefix=input_phrase,
+                    length=target_note_count + 1,
+                    constraints=constraints,
+                )
+                if generated_sequence is None:
+                    generated_sequence = self._continuator.sample_sequence(
+                        prefix=input_phrase,
+                        length=target_note_count,
+                        constraints={},
+                    )
+                    status_message = (
+                        "Used a same-length continuation without the hard end constraint "
+                        "because the exact-ending version had no solution."
+                    )
+            else:
                 generated_sequence = self._continuator.sample_sequence(
                     prefix=input_phrase,
                     length=target_note_count,
                     constraints={},
                 )
-                status_message = (
-                    "Used a same-length continuation without the hard end constraint "
-                    "because the exact-ending version had no solution."
-                )
 
             if generated_sequence is None:
                 raise NoContinuationAvailable("The Continuator could not find a valid continuation.")

backend/app/main.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from fastapi import Cookie, Depends, FastAPI, HTTPException, Query, Request, Response
+from fastapi import Cookie, Depends, FastAPI, File, HTTPException, Query, Request, Response, UploadFile
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 
@@ -20,6 +20,9 @@ from .schemas import (
     ContinueResponse,
     CreateSessionRequest,
     CreateSessionResponse,
+    GeneratePhraseRequest,
+    GeneratePhraseResponse,
+    ImportMidiResponse,
     LoginRequest,
     LogoutResponse,
     OpenSessionResponse,
@@ -32,7 +35,7 @@ from .schemas import (
     UpdateSessionSettingsResponse,
     UserSessionsResponse,
 )
-from .session_manager import NoContinuationAvailable, SessionManager, UnknownSessionError
+from .session_manager import MidiImportError, NoContinuationAvailable, SessionManager, UnknownSessionError
 from .storage import PhraseStorage
 
 
@@ -236,6 +239,29 @@ def continue_phrase(
         raise HTTPException(status_code=409, detail=str(error)) from error
 
 
+@app.post(
+    "/api/sessions/{session_id}/generate",
+    response_model=GeneratePhraseResponse,
+    tags=["continuator"],
+)
+def generate_phrase(
+    session_id: str,
+    payload: GeneratePhraseRequest,
+    current_user: AuthenticatedUser | None = Depends(get_optional_current_user),
+) -> GeneratePhraseResponse:
+    try:
+        return session_manager.generate_phrase(
+            session_id,
+            None if current_user is None else current_user.id,
+            note_count=payload.note_count,
+            enforce_end_constraint=payload.enforce_end_constraint,
+        )
+    except UnknownSessionError as error:
+        raise HTTPException(status_code=404, detail=f"Unknown session: {error.args[0]}") from error
+    except NoContinuationAvailable as error:
+        raise HTTPException(status_code=409, detail=str(error)) from error
+
+
 @app.get(
     "/api/sessions/{session_id}/history",
     response_model=SessionHistoryResponse,
@@ -274,6 +300,35 @@ def session_memory(
         raise HTTPException(status_code=404, detail=f"Unknown session: {error.args[0]}") from error
 
 
+@app.post(
+    "/api/sessions/{session_id}/import-midi",
+    response_model=ImportMidiResponse,
+    tags=["session"],
+)
+async def import_session_midi(
+    session_id: str,
+    files: list[UploadFile] = File(...),
+    current_user: AuthenticatedUser | None = Depends(get_optional_current_user),
+) -> ImportMidiResponse:
+    uploaded_files: list[tuple[str, bytes]] = []
+    try:
+        for index, upload in enumerate(files):
+            file_name = upload.filename or f"imported_{index + 1}.mid"
+            uploaded_files.append((file_name, await upload.read()))
+        return session_manager.import_midi_files(
+            session_id,
+            None if current_user is None else current_user.id,
+            uploaded_files,
+        )
+    except UnknownSessionError as error:
+        raise HTTPException(status_code=404, detail=f"Unknown session: {error.args[0]}") from error
+    except MidiImportError as error:
+        raise HTTPException(status_code=400, detail=str(error)) from error
+    finally:
+        for upload in files:
+            await upload.close()
+
+
 @app.post(
     "/api/sessions/{session_id}/reset",
     response_model=ResetSessionResponse,

backend/app/schemas.py

@@ -36,6 +36,7 @@ class PhrasePayload(BaseModel):
     event_count: int = Field(ge=0)
     note_count: int = Field(ge=0)
     duration_seconds: float = Field(ge=0.0)
+    handoff_seconds: float | None = Field(default=None, ge=0.0)
     events: list[PlaybackMidiEvent]
     notes: list[PhraseNote]
 
@@ -46,6 +47,7 @@ class CreateSessionRequest(BaseModel):
     forget_past: bool = False
     keep_last_inputs: int = Field(default=20, ge=1, le=500)
     decay_mode: DecayMode = "full"
+    markov_order: int = Field(default=4, ge=1, le=16)
 
 
 class SessionConfiguration(BaseModel):
@@ -54,6 +56,7 @@ class SessionConfiguration(BaseModel):
     forget_past: bool
     keep_last_inputs: int = Field(ge=1, le=500)
     decay_mode: DecayMode
+    markov_order: int = Field(default=4, ge=1, le=16)
     seeded: bool
 
 
@@ -68,6 +71,7 @@ class ContinueRequest(BaseModel):
     phrase: list[MidiEvent] = Field(min_length=1)
     learn_input: bool | None = None
     continuation_note_count: int | None = Field(default=None, ge=1)
+    enforce_end_constraint: bool = True
 
 
 class ContinueResponse(BaseModel):
@@ -79,6 +83,35 @@ class ContinueResponse(BaseModel):
     status_message: str | None = None
 
 
+class GeneratePhraseRequest(BaseModel):
+    note_count: int | None = Field(default=None, ge=1, le=512)
+    enforce_end_constraint: bool = True
+
+
+class GeneratePhraseResponse(BaseModel):
+    session_id: str
+    request_id: str
+    created_at: str
+    generated_phrase: PhrasePayload
+    status_message: str | None = None
+
+
+class ImportedMidiFileSummary(BaseModel):
+    file_name: str = Field(min_length=1)
+    event_count: int = Field(ge=0)
+    note_count: int = Field(ge=0)
+    duration_seconds: float = Field(ge=0.0)
+
+
+class ImportMidiResponse(BaseModel):
+    session_id: str
+    created_at: str
+    imported_file_count: int = Field(ge=0)
+    skipped_file_count: int = Field(ge=0)
+    imported_files: list[ImportedMidiFileSummary]
+    skipped_files: list[str] = Field(default_factory=list)
+
+
 class HistoryItem(BaseModel):
     id: str
     request_id: str
@@ -129,6 +162,7 @@ class UpdateSessionSettingsRequest(BaseModel):
     forget_past: bool | None = None
     keep_last_inputs: int | None = Field(default=None, ge=1, le=500)
     decay_mode: DecayMode | None = None
+    markov_order: int | None = Field(default=None, ge=1, le=16)
 
 
 class UpdateSessionSettingsResponse(BaseModel):

backend/app/session_manager.py

@@ -6,13 +6,16 @@ from pathlib import Path
 import threading
 import uuid
 
-from .continuator_adapter import ContinuatorSessionEngine, NoContinuationAvailable
+from .continuator_adapter import ContinuatorSessionEngine, MidiImportError, NoContinuationAvailable
 from .schemas import (
     ContinueRequest,
     ContinueResponse,
     CreateSessionRequest,
     CreateSessionResponse,
+    GeneratePhraseResponse,
     HistoryItem,
+    ImportedMidiFileSummary,
+    ImportMidiResponse,
     MemoryPhraseItem,
     MidiEvent,
     OpenSessionResponse,
@@ -72,6 +75,7 @@ class SessionManager:
             forget_past=request.forget_past,
             keep_last_inputs=request.keep_last_inputs,
             decay_mode=request.decay_mode,
+            markov_order=request.markov_order,
             seeded=self.seeded,
         )
 
@@ -82,6 +86,7 @@ class SessionManager:
             forget_past=configuration.forget_past,
             keep_last_inputs=configuration.keep_last_inputs,
             decay_mode=configuration.decay_mode,
+            markov_order=configuration.markov_order,
             seed_midi_file=self.seed_midi_file,
             seed_midi_folder=self.seed_midi_folder,
         )
@@ -262,6 +267,7 @@ class SessionManager:
             request.phrase,
             learn_input=should_learn,
             continuation_note_count=request.continuation_note_count,
+            enforce_end_constraint=request.enforce_end_constraint,
         )
 
         state.last_seen_at = created_at
@@ -294,6 +300,85 @@ class SessionManager:
             status_message=status_message,
         )
 
+    def generate_phrase(
+        self,
+        session_id: str,
+        owner_user_id: str | None,
+        note_count: int | None = None,
+        enforce_end_constraint: bool = True,
+    ) -> GeneratePhraseResponse:
+        state = self._require_session(session_id, owner_user_id)
+        created_at = utc_now_iso()
+        request_id = uuid.uuid4().hex
+        generated_phrase, status_message = state.engine.generate_phrase(
+            note_count=note_count,
+            enforce_end_constraint=enforce_end_constraint,
+        )
+
+        state.last_seen_at = created_at
+        self.storage.touch_session(state.session_id, created_at)
+        self.storage.log_phrase(
+            phrase_id=uuid.uuid4().hex,
+            request_id=request_id,
+            session_id=state.session_id,
+            kind="generated",
+            created_at=created_at,
+            learned=False,
+            payload=generated_phrase.model_dump(mode="json"),
+        )
+
+        return GeneratePhraseResponse(
+            session_id=state.session_id,
+            request_id=request_id,
+            created_at=created_at,
+            generated_phrase=generated_phrase,
+            status_message=status_message,
+        )
+
+    def import_midi_files(
+        self,
+        session_id: str,
+        owner_user_id: str | None,
+        midi_files: list[tuple[str, bytes]],
+    ) -> ImportMidiResponse:
+        state = self._require_session(session_id, owner_user_id)
+        if not midi_files:
+            raise MidiImportError("Select at least one MIDI file to import.")
+
+        created_at = utc_now_iso()
+        request_id = uuid.uuid4().hex
+        imported_files, skipped_files = state.engine.import_midi_files(midi_files)
+
+        state.last_seen_at = created_at
+        self.storage.touch_session(state.session_id, created_at)
+        for index, imported_file in enumerate(imported_files):
+            self.storage.log_phrase(
+                phrase_id=f"{request_id}-import-{index:04d}",
+                request_id=request_id,
+                session_id=state.session_id,
+                kind="input",
+                created_at=created_at,
+                learned=True,
+                payload=imported_file.payload.model_dump(mode="json"),
+            )
+
+        return ImportMidiResponse(
+            session_id=state.session_id,
+            created_at=created_at,
+            imported_file_count=len(imported_files),
+            skipped_file_count=len(skipped_files),
+            imported_files=[
+                ImportedMidiFileSummary(
+                    file_name=imported_file.file_name,
+                    event_count=imported_file.payload.event_count,
+                    note_count=imported_file.payload.note_count,
+                    duration_seconds=imported_file.payload.duration_seconds,
+                )
+                for imported_file in imported_files
+            ],
+            skipped_files=skipped_files,
+        )
+
     def get_history(
         self,
         session_id: str,
@@ -378,6 +463,7 @@ class SessionManager:
 
 
 __all__ = [
+    "MidiImportError",
     "NoContinuationAvailable",
     "SessionManager",
     "UnknownSessionError",

backend/requirements.txt

@@ -3,4 +3,4 @@ uvicorn[standard]>=0.30,<1
 pydantic>=2.7,<3
 numpy>=2.0,<3
 mido>=1.3,<2
-
+python-multipart>=0.0.9,<1

backend/vendor/ctor/continuator.py

@@ -230,27 +230,30 @@ class Continuator2:
         pending_notes = np.empty(128, dtype=object)
         pending_start_times = np.zeros(128)
         current_time = 0
-        for track in mid.tracks:
-            for msg in track:
-                current_time += 2 * mido.tick2second(msg.time, ticks_per_beat=resolution, tempo=500000)  # in beats
-                if msg.type == 'set_tempo':
-                    self.tempo_msgs.append(msg.tempo)
-                if msg.type == "note_on" and msg.velocity > 0:
-                    new_note = Note(msg.note, msg.velocity, 0)
-                    notes.append(new_note)  # Store MIDI note number
-                    pending_notes[msg.note] = new_note
-                    pending_start_times[msg.note] = current_time
-                    new_note.set_start_time(current_time)
-                    new_note.set_duration(1)  # beat
-                if msg.type == "note_off" or (msg.type == "note_on" and msg.velocity == 0):
-                    if pending_notes[msg.note] is None:
-                        print("found 0 velocity note, skipping it")
-                        continue
-                    pending_note = pending_notes[msg.note]
-                    duration = current_time - pending_start_times[msg.note]
-                    pending_note.set_duration(duration)
-                    pending_notes[msg.note] = None
-                    pending_start_times[msg.note] = 0
+        for msg in mido.merge_tracks(mid.tracks):
+            current_time += 2 * mido.tick2second(
+                msg.time,
+                ticks_per_beat=resolution,
+                tempo=500000,
+            )  # in beats
+            if msg.type == 'set_tempo':
+                self.tempo_msgs.append(msg.tempo)
+            if msg.type == "note_on" and msg.velocity > 0:
+                new_note = Note(msg.note, msg.velocity, 0)
+                notes.append(new_note)  # Store MIDI note number
+                pending_notes[msg.note] = new_note
+                pending_start_times[msg.note] = current_time
+                new_note.set_start_time(current_time)
+                new_note.set_duration(1)  # beat
+            if msg.type == "note_off" or (msg.type == "note_on" and msg.velocity == 0):
+                if pending_notes[msg.note] is None:
+                    print("found 0 velocity note, skipping it")
+                    continue
+                pending_note = pending_notes[msg.note]
+                duration = current_time - pending_start_times[msg.note]
+                pending_note.set_duration(duration)
+                pending_notes[msg.note] = None
+                pending_start_times[msg.note] = 0
         # sets the note status w/r their neighbors
         self.set_delta_notes(notes)
         return np.array(notes)

backend/vendor/midi_stuff/mini_muse.py

@@ -164,25 +164,28 @@ class Realized_Chord:
         pending_notes = np.empty(128, dtype=object)
         pending_start_times = np.zeros(128)
         current_time = 0
-        for track in mid.tracks:
-            for msg in track:
-                current_time += 2 * mido.tick2second(msg.time, ticks_per_beat=resolution, tempo=500000)  # in beats
-                if msg.type == "note_on" and msg.velocity > 0:
-                    new_note = Note(msg.note, msg.velocity, 0)
-                    notes.append(new_note)  # Store MIDI note number
-                    pending_notes[msg.note] = new_note
-                    pending_start_times[msg.note] = current_time
-                    new_note.set_start_time(current_time)
-                    new_note.set_duration(1)  # beat
-                if msg.type == "note_off" or (msg.type == "note_on" and msg.velocity == 0):
-                    if pending_notes[msg.note] is None:
-                        print("found 0 velocity note, skipping it")
-                        continue
-                    pending_note = pending_notes[msg.note]
-                    duration = current_time - pending_start_times[msg.note]
-                    pending_note.set_duration(duration)
-                    pending_notes[msg.note] = None
-                    pending_start_times[msg.note] = 0
+        for msg in mido.merge_tracks(mid.tracks):
+            current_time += 2 * mido.tick2second(
+                msg.time,
+                ticks_per_beat=resolution,
+                tempo=500000,
+            )  # in beats
+            if msg.type == "note_on" and msg.velocity > 0:
+                new_note = Note(msg.note, msg.velocity, 0)
+                notes.append(new_note)  # Store MIDI note number
+                pending_notes[msg.note] = new_note
+                pending_start_times[msg.note] = current_time
+                new_note.set_start_time(current_time)
+                new_note.set_duration(1)  # beat
+            if msg.type == "note_off" or (msg.type == "note_on" and msg.velocity == 0):
+                if pending_notes[msg.note] is None:
+                    print("found 0 velocity note, skipping it")
+                    continue
+                pending_note = pending_notes[msg.note]
+                duration = current_time - pending_start_times[msg.note]
+                pending_note.set_duration(duration)
+                pending_notes[msg.note] = None
+                pending_start_times[msg.note] = 0
         return np.array(notes)
 
     @classmethod

frontend/app.js

@@ -1,8 +1,35 @@
-const BROWSER_SYNTH_ID = "__browser_synth__";
+const DEFAULT_PLAYBACK_CHOICE = "browser_triangle";
+const FAUST_CLAVIER_ID = "faust_clavier";
+const FAUST_CUSTOM_ID = "faust_custom";
+const WEB_MIDI_RENDERER_ID = "web_midi";
+const PLAYBACK_CHOICE_SEPARATOR = "::";
 const PHRASE_TIMEOUT_MS = 1000;
 const PLAYBACK_START_DELAY_MS = 80;
 const INFINITE_MIN_LOOKAHEAD_MS = 600;
 const INFINITE_MAX_LOOKAHEAD_MS = 2200;
+const FAUST_WASM_ESM_URL = "/assets/vendor/faustwasm/esm/index.js";
+const FAUST_WASM_JS_URL = "/assets/vendor/faustwasm/libfaust-wasm/libfaust-wasm.js";
+const FAUST_WASM_DATA_URL = "/assets/vendor/faustwasm/libfaust-wasm/libfaust-wasm.data";
+const FAUST_WASM_BINARY_URL = "/assets/vendor/faustwasm/libfaust-wasm/libfaust-wasm.wasm";
+const FAUST_CLAVIER_DSP_URL = "/assets/faust/continuator-clavier.dsp";
+const FAUST_CUSTOM_TEMPLATE_DSP_URL = "/assets/faust/custom-poly-template.dsp";
+const FAUST_CUSTOM_SOURCE_STORAGE_KEY = "continuator.faust.custom.source";
+const FAUST_CUSTOM_VALUES_STORAGE_KEY = "continuator.faust.custom.values";
+const FAUST_UI_CONTROL_TYPES = new Set([
+  "hslider",
+  "vslider",
+  "nentry",
+  "checkbox",
+  "button",
+]);
+const FAUST_POLY_RESERVED_SUFFIXES = [
+  "/gate",
+  "/freq",
+  "/gain",
+  "/key",
+  "/vel",
+  "/velocity",
+];
 
 const elements = {
   serverStatus: document.querySelector("#server-status"),
@@ -60,10 +87,34 @@ const elements = {
   viewTabs: document.querySelectorAll("[data-view-tab]"),
   midiInputSelect: document.querySelector("#midi-input-select"),
   midiOutputSelect: document.querySelector("#midi-output-select"),
+  faustRendererPanel: document.querySelector("#faust-renderer-panel"),
+  faustClavierPanel: document.querySelector("#faust-clavier-panel"),
+  faustCustomPanel: document.querySelector("#faust-custom-panel"),
+  faustRendererStatus: document.querySelector("#faust-renderer-status"),
+  faustRendererHint: document.querySelector("#faust-renderer-hint"),
+  faustBrightnessInput: document.querySelector("#faust-brightness-input"),
+  faustBrightnessValue: document.querySelector("#faust-brightness-value"),
+  faustHardnessInput: document.querySelector("#faust-hardness-input"),
+  faustHardnessValue: document.querySelector("#faust-hardness-value"),
+  faustDampingInput: document.querySelector("#faust-damping-input"),
+  faustDampingValue: document.querySelector("#faust-damping-value"),
+  faustReleaseInput: document.querySelector("#faust-release-input"),
+  faustReleaseValue: document.querySelector("#faust-release-value"),
+  faustBodyInput: document.querySelector("#faust-body-input"),
+  faustBodyValue: document.querySelector("#faust-body-value"),
+  faustStereoInput: document.querySelector("#faust-stereo-input"),
+  faustStereoValue: document.querySelector("#faust-stereo-value"),
+  faustCustomCodeInput: document.querySelector("#faust-custom-code-input"),
+  faustCustomCompileButton: document.querySelector("#faust-custom-compile-button"),
+  faustCustomResetButton: document.querySelector("#faust-custom-reset-button"),
+  faustCustomDirtyState: document.querySelector("#faust-custom-dirty-state"),
+  faustCustomControls: document.querySelector("#faust-custom-controls"),
+  faustCustomControlsHint: document.querySelector("#faust-custom-controls-hint"),
   learnInputToggle: document.querySelector("#learn-input-toggle"),
   autoSendToggle: document.querySelector("#auto-send-toggle"),
   transposeToggle: document.querySelector("#transpose-toggle"),
   forgetToggle: document.querySelector("#forget-toggle"),
+  markovOrderInput: document.querySelector("#markov-order-input"),
   keepLastInput: document.querySelector("#keep-last-input"),
   decayModeSelect: document.querySelector("#decay-mode-select"),
   continuationLengthInput: document.querySelector("#continuation-length-input"),
@@ -72,9 +123,14 @@ const elements = {
   createSessionButton: document.querySelector("#create-session-button"),
   resetSessionButton: document.querySelector("#reset-session-button"),
   applySettingsButton: document.querySelector("#apply-settings-button"),
+  importMidiFilesButton: document.querySelector("#import-midi-files-button"),
+  importMidiFolderButton: document.querySelector("#import-midi-folder-button"),
+  midiImportInput: document.querySelector("#midi-import-input"),
+  midiFolderImportInput: document.querySelector("#midi-folder-import-input"),
   connectMidiButton: document.querySelector("#connect-midi-button"),
   refreshMidiButton: document.querySelector("#refresh-midi-button"),
   sendPhraseButton: document.querySelector("#send-phrase-button"),
+  generateMemoryButton: document.querySelector("#generate-memory-button"),
   replayGeneratedButton: document.querySelector("#replay-generated-button"),
   clearPhraseButton: document.querySelector("#clear-phrase-button"),
 };
@@ -90,6 +146,8 @@ const state = {
   sessionConfiguration: null,
   lastCapturedPhrase: [],
   lastGeneratedPhrase: null,
+  lastCapturedAt: 0,
+  lastGeneratedAt: 0,
   historyItems: [],
   memoryItems: [],
   savedSessions: [],
@@ -104,10 +162,98 @@ const state = {
   infiniteScheduleTimerId: null,
   infiniteAbortController: null,
   infiniteRunId: 0,
+  customFaustSource: "",
+  customFaustTemplateSource: "",
+  customFaustControlDescriptors: [],
+  customFaustControlBindings: [],
 };
 
-class BrowserSynth {
-  constructor() {
+function midiToFrequency(note) {
+  return 440 * 2 ** ((note - 69) / 12);
+}
+
+function createTriangleVoice(context, destination, note, velocity, at) {
+  const oscillator = new OscillatorNode(context, {
+    type: "triangle",
+    frequency: midiToFrequency(note),
+  });
+  const gain = new GainNode(context, { gain: 0.0001 });
+  oscillator.connect(gain).connect(destination);
+  gain.gain.setValueAtTime(0.0001, at);
+  gain.gain.exponentialRampToValueAtTime(
+    Math.max(0.03, (velocity / 127) * 0.2),
+    at + 0.015,
+  );
+  oscillator.start(at);
+
+  return {
+    release(releaseAt, releaseSeconds = 0.08) {
+      gain.gain.cancelScheduledValues(releaseAt);
+      gain.gain.setValueAtTime(Math.max(0.0001, gain.gain.value), releaseAt);
+      gain.gain.exponentialRampToValueAtTime(0.0001, releaseAt + releaseSeconds);
+      oscillator.stop(releaseAt + releaseSeconds + 0.02);
+    },
+  };
+}
+
+function createElectricVoice(context, destination, note, velocity, at) {
+  const frequency = midiToFrequency(note);
+  const filter = new BiquadFilterNode(context, {
+    type: "lowpass",
+    frequency: 3200,
+    Q: 0.8,
+  });
+  const gain = new GainNode(context, { gain: 0.0001 });
+  const bodyGain = new GainNode(context, { gain: 0.82 });
+  const shimmerGain = new GainNode(context, { gain: 0.18 });
+  const bodyOscillator = new OscillatorNode(context, {
+    type: "triangle",
+    frequency,
+  });
+  const shimmerOscillator = new OscillatorNode(context, {
+    type: "sine",
+    frequency: frequency * 2,
+  });
+
+  bodyOscillator.connect(bodyGain).connect(filter);
+  shimmerOscillator.connect(shimmerGain).connect(filter);
+  filter.connect(gain).connect(destination);
+
+  const peak = Math.max(0.025, (velocity / 127) * 0.17);
+  const sustain = Math.max(0.015, peak * 0.55);
+  gain.gain.setValueAtTime(0.0001, at);
+  gain.gain.exponentialRampToValueAtTime(peak, at + 0.01);
+  gain.gain.exponentialRampToValueAtTime(sustain, at + 0.12);
+  filter.frequency.setValueAtTime(3200, at);
+  filter.frequency.exponentialRampToValueAtTime(1500, at + 0.18);
+
+  bodyOscillator.start(at);
+  shimmerOscillator.start(at);
+
+  return {
+    release(releaseAt, releaseSeconds = 0.16) {
+      gain.gain.cancelScheduledValues(releaseAt);
+      gain.gain.setValueAtTime(Math.max(0.0001, gain.gain.value), releaseAt);
+      gain.gain.exponentialRampToValueAtTime(0.0001, releaseAt + releaseSeconds);
+      bodyOscillator.stop(releaseAt + releaseSeconds + 0.03);
+      shimmerOscillator.stop(releaseAt + releaseSeconds + 0.03);
+    },
+  };
+}
+
+class BrowserAudioRenderer {
+  constructor({
+    id,
+    label,
+    masterGain = 0.18,
+    createVoice,
+    groupLabel = "Browser Renderers",
+  }) {
+    this.id = id;
+    this.label = label;
+    this.masterGain = masterGain;
+    this.createVoice = createVoice;
+    this.groupLabel = groupLabel;
     this.context = null;
     this.master = null;
     this.activeVoices = new Map();
@@ -116,7 +262,7 @@ class BrowserSynth {
   async ensureContext() {
     if (!this.context) {
       this.context = new window.AudioContext();
-      this.master = new window.GainNode(this.context, { gain: 0.18 });
+      this.master = new GainNode(this.context, { gain: this.masterGain });
       this.master.connect(this.context.destination);
     }
     if (this.context.state === "suspended") {
@@ -124,12 +270,17 @@ class BrowserSynth {
     }
   }
 
-  key(note, channel) {
-    return `${channel}:${note}`;
+  async createPlaybackSession() {
+    await this.ensureContext();
+    return {};
   }
 
-  midiToFrequency(note) {
-    return 440 * 2 ** ((note - 69) / 12);
+  getDisplayName() {
+    return this.label;
+  }
+
+  key(note, channel) {
+    return `${channel}:${note}`;
   }
 
   noteOn(note, channel, velocity) {
@@ -139,21 +290,9 @@ class BrowserSynth {
 
     const at = this.context.currentTime + 0.001;
     const key = this.key(note, channel);
-    const oscillator = new OscillatorNode(this.context, {
-      type: "triangle",
-      frequency: this.midiToFrequency(note),
-    });
-    const gain = new GainNode(this.context, { gain: 0.0001 });
-    oscillator.connect(gain).connect(this.master);
-    gain.gain.setValueAtTime(0.0001, at);
-    gain.gain.exponentialRampToValueAtTime(
-      Math.max(0.03, (velocity / 127) * 0.2),
-      at + 0.015,
-    );
-    oscillator.start(at);
-
+    const voice = this.createVoice(this.context, this.master, note, velocity, at);
     const existing = this.activeVoices.get(key) || [];
-    existing.push({ oscillator, gain });
+    existing.push(voice);
     this.activeVoices.set(key, existing);
   }
 
@@ -168,32 +307,358 @@ class BrowserSynth {
       return;
     }
 
-    const at = this.context.currentTime + 0.001;
     const voice = voices.shift();
-    voice.gain.gain.cancelScheduledValues(at);
-    voice.gain.gain.setValueAtTime(Math.max(0.0001, voice.gain.gain.value), at);
-    voice.gain.gain.exponentialRampToValueAtTime(0.0001, at + 0.08);
-    voice.oscillator.stop(at + 0.1);
+    voice.release(this.context.currentTime + 0.001);
     if (!voices.length) {
       this.activeVoices.delete(key);
     }
   }
 
-  stop() {
-    if (!this.context) {
+  dispatchEvent(playback, event) {
+    if (event.type === "note_on" && event.velocity > 0) {
+      this.noteOn(event.note, event.channel, event.velocity);
       return;
     }
+    this.noteOff(event.note, event.channel);
+  }
+
+  stopVoices(releaseSeconds = 0.04) {
+    if (!this.context) {
+      return false;
+    }
 
     const at = this.context.currentTime + 0.001;
+    const hadVoices = this.activeVoices.size > 0;
     for (const voices of this.activeVoices.values()) {
       for (const voice of voices) {
-        voice.gain.gain.cancelScheduledValues(at);
-        voice.gain.gain.setValueAtTime(Math.max(0.0001, voice.gain.gain.value), at);
-        voice.gain.gain.exponentialRampToValueAtTime(0.0001, at + 0.04);
-        voice.oscillator.stop(at + 0.06);
+        voice.release(at, releaseSeconds);
       }
     }
     this.activeVoices.clear();
+    return hadVoices;
+  }
+
+  stopPlayback() {
+    this.stopVoices(0.04);
+  }
+
+  panicPlayback() {
+    return this.stopVoices(0.02);
+  }
+
+  panicTarget() {
+    return this.stopVoices(0.02);
+  }
+}
+
+function walkFaustUi(items, visit) {
+  for (const item of items || []) {
+    if (Array.isArray(item?.items)) {
+      walkFaustUi(item.items, visit);
+      continue;
+    }
+    visit(item);
+  }
+}
+
+let faustApiPromise = null;
+let faustCompilerBundlePromise = null;
+
+function safeLocalStorageGet(key) {
+  try {
+    return window.localStorage?.getItem(key) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function safeLocalStorageSet(key, value) {
+  try {
+    if (!window.localStorage) {
+      return;
+    }
+    if (value == null) {
+      window.localStorage.removeItem(key);
+      return;
+    }
+    window.localStorage.setItem(key, value);
+  } catch {
+    // Ignore private-browsing or storage-denied failures.
+  }
+}
+
+function createFaustParamPathMap(ui) {
+  const paramPaths = new Map();
+  walkFaustUi(ui, (item) => {
+    const shortname = String(item?.shortname || "");
+    const address = String(item?.address || "");
+    const label = String(item?.label || "");
+    if (!address) {
+      return;
+    }
+    paramPaths.set(address, address);
+    if (shortname && !paramPaths.has(shortname)) {
+      paramPaths.set(shortname, address);
+    }
+    if (label) {
+      const labelTail = label.split("/").pop() || label;
+      const simplifiedLabel = labelTail.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+      if (labelTail && !paramPaths.has(labelTail)) {
+        paramPaths.set(labelTail, address);
+      }
+      if (simplifiedLabel && !paramPaths.has(simplifiedLabel)) {
+        paramPaths.set(simplifiedLabel, address);
+      }
+      const lowercaseLabel = simplifiedLabel.toLowerCase();
+      if (lowercaseLabel && !paramPaths.has(lowercaseLabel)) {
+        paramPaths.set(lowercaseLabel, address);
+      }
+    }
+  });
+  return paramPaths;
+}
+
+async function loadFaustApi() {
+  if (!faustApiPromise) {
+    faustApiPromise = import(FAUST_WASM_ESM_URL);
+  }
+  return faustApiPromise;
+}
+
+async function getFaustCompilerBundle() {
+  if (!faustCompilerBundlePromise) {
+    faustCompilerBundlePromise = (async () => {
+      const api = await loadFaustApi();
+      const faustModule = await api.instantiateFaustModuleFromFile(
+        FAUST_WASM_JS_URL,
+        FAUST_WASM_DATA_URL,
+        FAUST_WASM_BINARY_URL,
+      );
+      return {
+        api,
+        compiler: new api.FaustCompiler(new api.LibFaust(faustModule)),
+      };
+    })();
+  }
+  return faustCompilerBundlePromise;
+}
+
+class FaustPolyRenderer {
+  constructor({
+    id,
+    label,
+    dspUrl,
+    getCode = null,
+    voices = 24,
+    controlDefaults = {},
+    groupLabel = "Faust Instruments",
+    idleDetail = "Ready when you route playback here.",
+  }) {
+    this.id = id;
+    this.label = label;
+    this.dspUrl = dspUrl;
+    this.getCode = getCode;
+    this.voices = voices;
+    this.groupLabel = groupLabel;
+    this.context = null;
+    this.generator = null;
+    this.node = null;
+    this.codePromise = null;
+    this.initializationPromise = null;
+    this.paramPaths = new Map();
+    this.controlValues = new Map(Object.entries(controlDefaults));
+    this.ui = [];
+    this.status = "Idle";
+    this.statusDetail = idleDetail;
+    this.lastError = null;
+    this.lastCompiledCode = null;
+  }
+
+  getDisplayName() {
+    return this.label;
+  }
+
+  setStatus(status, detail) {
+    this.status = status;
+    if (detail != null) {
+      this.statusDetail = detail;
+    }
+    syncFaustRendererPanel();
+  }
+
+  async ensureContext() {
+    if (!this.context) {
+      this.context = new window.AudioContext();
+    }
+    if (this.context.state === "suspended") {
+      await this.context.resume();
+    }
+  }
+
+  async loadCode(forceRefresh = false) {
+    if (this.getCode) {
+      const code = await this.getCode();
+      if (!String(code || "").trim()) {
+        throw new Error("No Faust DSP source is available.");
+      }
+      return code;
+    }
+
+    if (!this.codePromise || forceRefresh) {
+      this.codePromise = fetch(this.dspUrl).then(async (response) => {
+        if (!response.ok) {
+          throw new Error(`Unable to load the Faust DSP (${response.status}).`);
+        }
+        return response.text();
+      });
+    }
+    return this.codePromise;
+  }
+
+  captureParamPaths(ui) {
+    this.paramPaths = createFaustParamPathMap(ui);
+  }
+
+  applyControlValues() {
+    if (!this.node) {
+      return;
+    }
+
+    this.controlValues.forEach((value, key) => {
+      const path = this.paramPaths.get(key);
+      if (path) {
+        this.node.setParamValue(path, Number(value));
+      }
+    });
+  }
+
+  getUi() {
+    return this.ui;
+  }
+
+  async ensureNode({ forceRecompile = false } = {}) {
+    await this.ensureContext();
+    if (this.node && !forceRecompile) {
+      return this.node;
+    }
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+
+    const previousNode = this.node;
+    const previousGenerator = this.generator;
+    const previousUi = this.ui;
+    const previousParamPaths = this.paramPaths;
+    this.initializationPromise = (async () => {
+      this.lastError = null;
+      this.setStatus("Loading", `Compiling ${this.label}…`);
+      const [{ api, compiler }, code] = await Promise.all([
+        getFaustCompilerBundle(),
+        this.loadCode(forceRecompile),
+      ]);
+      const generator = new api.FaustPolyDspGenerator();
+      const compiledGenerator = await generator.compile(compiler, this.id, code, "-ftz 2");
+      if (!compiledGenerator) {
+        throw new Error("Faust compilation returned no renderer.");
+      }
+      const nextNode = await compiledGenerator.createNode(this.context, this.voices, this.id);
+      if (!nextNode) {
+        throw new Error("Faust could not create a playable WebAudio node.");
+      }
+      nextNode.connect(this.context.destination);
+      const nextUi = compiledGenerator.getUI();
+      const nextParamPaths = createFaustParamPathMap(nextUi);
+      this.generator = compiledGenerator;
+      this.node = nextNode;
+      this.ui = nextUi;
+      this.paramPaths = nextParamPaths;
+      this.lastCompiledCode = code;
+      this.applyControlValues();
+      if (previousNode && previousNode !== nextNode) {
+        previousNode.allNotesOff?.(true);
+        previousNode.disconnect?.();
+      }
+      this.setStatus("Ready", `${this.voices} polyphonic voices are ready.`);
+      return nextNode;
+    })()
+      .catch((error) => {
+        if (this.node && this.node !== previousNode) {
+          this.node.allNotesOff?.(true);
+          this.node.disconnect?.();
+        }
+        this.node = previousNode;
+        this.generator = previousGenerator;
+        this.ui = previousUi;
+        this.paramPaths = previousParamPaths;
+        this.lastError = error instanceof Error ? error : new Error(String(error));
+        this.setStatus("Error", this.lastError.message);
+        throw this.lastError;
+      })
+      .finally(() => {
+        this.initializationPromise = null;
+      });
+
+    return this.initializationPromise;
+  }
+
+  async prepare(options = {}) {
+    await this.ensureNode(options);
+  }
+
+  setControlValue(key, value) {
+    const numericValue = Number(value);
+    if (!Number.isFinite(numericValue)) {
+      return;
+    }
+
+    this.controlValues.set(key, numericValue);
+    const path = this.paramPaths.get(key);
+    if (this.node && path) {
+      this.node.setParamValue(path, numericValue);
+    }
+    syncFaustRendererPanel();
+  }
+
+  getControlValue(key) {
+    return Number(this.controlValues.get(key));
+  }
+
+  async createPlaybackSession() {
+    const node = await this.ensureNode();
+    return { node };
+  }
+
+  dispatchEvent(playback, event) {
+    if (!playback?.node) {
+      return;
+    }
+
+    if (event.type === "note_on" && event.velocity > 0) {
+      playback.node.keyOn(event.channel, event.note, event.velocity);
+      return;
+    }
+
+    playback.node.keyOff(event.channel, event.note, event.velocity || 0);
+  }
+
+  stopPlayback(playback) {
+    playback?.node?.allNotesOff?.(false);
+  }
+
+  panicPlayback(playback) {
+    if (!playback?.node) {
+      return false;
+    }
+    playback.node.allNotesOff?.(true);
+    return true;
+  }
+
+  panicTarget() {
+    if (!this.node) {
+      return false;
+    }
+    this.node.allNotesOff?.(true);
+    return true;
   }
 }
 
@@ -308,7 +773,171 @@ class PhraseRecorder {
   }
 }
 
-const synth = new BrowserSynth();
+const browserPlaybackRenderers = [
+  new BrowserAudioRenderer({
+    id: "browser_triangle",
+    label: "Browser Triangle",
+    masterGain: 0.18,
+    createVoice: createTriangleVoice,
+  }),
+  new BrowserAudioRenderer({
+    id: "browser_electric",
+    label: "Browser Electric",
+    masterGain: 0.16,
+    createVoice: createElectricVoice,
+  }),
+];
+
+const faustClavierRenderer = new FaustPolyRenderer({
+  id: FAUST_CLAVIER_ID,
+  label: "Faust Clavier",
+  dspUrl: FAUST_CLAVIER_DSP_URL,
+  voices: 24,
+  controlDefaults: {
+    brightness: 0.58,
+    hardness: 0.34,
+    damping: 0.42,
+    release: 0.95,
+    body: 0.33,
+    stereo: 0.45,
+  },
+});
+
+const customFaustRenderer = new FaustPolyRenderer({
+  id: FAUST_CUSTOM_ID,
+  label: "Custom Faust",
+  getCode: async () => {
+    if (state.customFaustSource.trim()) {
+      return state.customFaustSource;
+    }
+    return loadCustomFaustTemplate();
+  },
+  voices: 24,
+  idleDetail: "Paste or edit a polyphonic Faust instrument, then compile it locally.",
+});
+
+const faustClavierControls = [
+  {
+    key: "brightness",
+    input: elements.faustBrightnessInput,
+    output: elements.faustBrightnessValue,
+    format: (value) => Number(value).toFixed(2),
+  },
+  {
+    key: "hardness",
+    input: elements.faustHardnessInput,
+    output: elements.faustHardnessValue,
+    format: (value) => Number(value).toFixed(2),
+  },
+  {
+    key: "damping",
+    input: elements.faustDampingInput,
+    output: elements.faustDampingValue,
+    format: (value) => Number(value).toFixed(2),
+  },
+  {
+    key: "release",
+    input: elements.faustReleaseInput,
+    output: elements.faustReleaseValue,
+    format: (value) => `${Number(value).toFixed(2)} s`,
+  },
+  {
+    key: "body",
+    input: elements.faustBodyInput,
+    output: elements.faustBodyValue,
+    format: (value) => Number(value).toFixed(2),
+  },
+  {
+    key: "stereo",
+    input: elements.faustStereoInput,
+    output: elements.faustStereoValue,
+    format: (value) => Number(value).toFixed(2),
+  },
+];
+
+const localPlaybackRenderers = [
+  ...browserPlaybackRenderers,
+  faustClavierRenderer,
+  customFaustRenderer,
+];
+
+const webMidiRenderer = {
+  id: WEB_MIDI_RENDERER_ID,
+
+  async createPlaybackSession(targetId) {
+    const output = midiOutputById(targetId);
+    if (!output) {
+      throw new Error("Selected MIDI output is unavailable.");
+    }
+    await output.open();
+    return {
+      output,
+      targetId,
+      activeOutputNotes: new Set(),
+    };
+  },
+
+  getDisplayName(targetId) {
+    const output = midiOutputById(targetId);
+    return output ? output.name || output.id : "Unavailable MIDI output";
+  },
+
+  dispatchEvent(playback, event) {
+    const status =
+      event.type === "note_on" && event.velocity > 0
+        ? 0x90 | (event.channel & 0x0f)
+        : 0x80 | (event.channel & 0x0f);
+    sendOutputMessage(playback.output, [status, event.note, event.velocity]);
+
+    const key = outputNoteKey(event.note, event.channel);
+    if (event.type === "note_on" && event.velocity > 0) {
+      playback.activeOutputNotes.add(key);
+    } else {
+      playback.activeOutputNotes.delete(key);
+    }
+  },
+
+  stopPlayback(playback) {
+    if (!playback.output) {
+      return;
+    }
+
+    playback.activeOutputNotes.forEach((key) => {
+      const [channelRaw, noteRaw] = key.split(":");
+      const channel = Number(channelRaw);
+      const note = Number(noteRaw);
+      sendOutputMessage(playback.output, [0x80 | (channel & 0x0f), note, 0]);
+    });
+    sendMidiPanicToOutput(playback.output);
+  },
+
+  panicPlayback(playback) {
+    if (!playback?.output) {
+      return false;
+    }
+    return sendMidiPanicToOutput(playback.output);
+  },
+
+  async panicTarget(targetId) {
+    const output = midiOutputById(targetId);
+    if (!output) {
+      return false;
+    }
+    try {
+      await output.open();
+    } catch {
+      return false;
+    }
+    return sendMidiPanicToOutput(output);
+  },
+};
+
+const playbackRendererRegistry = new Map(
+  [...localPlaybackRenderers, webMidiRenderer].map((renderer) => [
+    renderer.id,
+    renderer,
+  ]),
+);
 const recorder = new PhraseRecorder(
   PHRASE_TIMEOUT_MS,
   (events, completed) => {
@@ -316,10 +945,9 @@ const recorder = new PhraseRecorder(
     renderCapturedStats(events, notes, completed);
   },
   async (phrase) => {
-    state.lastCapturedPhrase = phrase;
+    rememberCapturedPhrase(phrase);
     const notes = eventsToNotes(phrase);
     renderCapturedStats(phrase, notes, true);
-    updateInfiniteActionState();
     setPhraseMessage(
       `Phrase complete: ${phrase.length} events / ${notes.length} notes captured.`,
     );
@@ -352,6 +980,60 @@ function pluralize(value, singular, plural = `${singular}s`) {
   return `${value} ${value === 1 ? singular : plural}`;
 }
 
+function rememberCapturedPhrase(events) {
+  state.lastCapturedPhrase = Array.isArray(events) ? events : [];
+  state.lastCapturedAt = Date.now();
+  updateInfiniteActionState();
+}
+
+function rememberGeneratedPhrase(payload) {
+  state.lastGeneratedPhrase = payload || null;
+  state.lastGeneratedAt = Date.now();
+  updateInfiniteActionState();
+}
+
+function clearRememberedPhrases() {
+  state.lastCapturedPhrase = [];
+  state.lastGeneratedPhrase = null;
+  state.lastCapturedAt = 0;
+  state.lastGeneratedAt = 0;
+  updateInfiniteActionState();
+}
+
+function latestLoopSeedEvents() {
+  const generatedEvents = state.lastGeneratedPhrase?.events || [];
+  if (generatedEvents.length && state.lastGeneratedAt >= state.lastCapturedAt) {
+    return generatedEvents;
+  }
+  if (state.lastCapturedPhrase.length) {
+    return state.lastCapturedPhrase;
+  }
+  return generatedEvents;
+}
+
+function preferredGenerationNoteCount(referenceEvents = null) {
+  const requestedNoteCount = normalizedContinuationNoteCount(
+    elements.continuationLengthInput.value,
+  );
+  if (requestedNoteCount != null) {
+    return requestedNoteCount;
+  }
+
+  if (referenceEvents?.length) {
+    return Math.max(1, eventsToNotes(referenceEvents).length);
+  }
+
+  if (state.lastGeneratedPhrase?.note_count) {
+    return Math.max(1, Number(state.lastGeneratedPhrase.note_count));
+  }
+
+  if (state.lastCapturedPhrase.length) {
+    return Math.max(1, eventsToNotes(state.lastCapturedPhrase).length);
+  }
+
+  return 12;
+}
+
 function renderAccountTrigger() {
   if (state.authUser) {
     const username = state.authUser.username;
@@ -474,6 +1156,14 @@ function normalizedKeepLastInputs(value) {
   return Math.min(500, Math.max(1, Math.round(parsed)));
 }
 
+function normalizedMarkovOrder(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return 4;
+  }
+  return Math.min(16, Math.max(1, Math.round(parsed)));
+}
+
 function normalizedContinuationNoteCount(value) {
   if (value == null || value === "") {
     return null;
@@ -485,6 +1175,10 @@ function normalizedContinuationNoteCount(value) {
   return Math.max(1, Math.round(parsed));
 }
 
+function hasMidiFileExtension(name) {
+  return /\.(mid|midi)$/i.test(String(name || ""));
+}
+
 function validateAuthCredentials() {
   const username = elements.authUsernameInput.value.trim();
   const password = elements.authPasswordInput.value;
@@ -540,8 +1234,15 @@ function continuationDurationMs(payload) {
   );
 }
 
+function continuationHandoffMs(payload) {
+  if (payload?.handoff_seconds != null) {
+    return Math.max(0, Math.round(Number(payload.handoff_seconds) * 1000));
+  }
+  return continuationDurationMs(payload);
+}
+
 function infiniteLookaheadMs(payload) {
-  const durationMs = continuationDurationMs(payload);
+  const durationMs = continuationHandoffMs(payload);
   return Math.min(
     INFINITE_MAX_LOOKAHEAD_MS,
     Math.max(INFINITE_MIN_LOOKAHEAD_MS, Math.round(durationMs * 0.4)),
@@ -553,18 +1254,20 @@ function readSessionSettingsFromControls() {
     learn_input: elements.learnInputToggle.checked,
     transposition: elements.transposeToggle.checked,
     forget_past: elements.forgetToggle.checked,
+    markov_order: normalizedMarkovOrder(elements.markovOrderInput.value),
     keep_last_inputs: normalizedKeepLastInputs(elements.keepLastInput.value),
     decay_mode: elements.decayModeSelect.value,
   };
 }
 
 function describeSessionSettings(settings) {
+  const orderLabel = `K=${settings.markov_order}`;
   const transposeLabel = settings.transposition ? "Transpose on" : "Transpose off";
   const memoryLabel = settings.forget_past
     ? `Keep last ${settings.keep_last_inputs} phrases`
     : "Keep full memory";
   const decayLabel = `Decay ${settings.decay_mode}`;
-  return [transposeLabel, memoryLabel, decayLabel];
+  return [orderLabel, transposeLabel, memoryLabel, decayLabel];
 }
 
 function renderSessionSettingsSummary() {
@@ -588,6 +1291,9 @@ function syncSettingsControls(configuration) {
   elements.learnInputToggle.checked = configuration.learn_input;
   elements.transposeToggle.checked = configuration.transposition;
   elements.forgetToggle.checked = configuration.forget_past;
+  elements.markovOrderInput.value = String(
+    normalizedMarkovOrder(configuration.markov_order),
+  );
   elements.keepLastInput.value = String(configuration.keep_last_inputs);
   elements.decayModeSelect.value = configuration.decay_mode;
   updateKeepLastFieldState();
@@ -625,15 +1331,13 @@ function formatTimestamp(value) {
 
 function clearPhraseBuffers() {
   stopInfiniteMode({ stopPlayback: true, silent: true });
-  state.lastCapturedPhrase = [];
-  state.lastGeneratedPhrase = null;
+  clearRememberedPhrases();
   state.previewedHistoryIndex = null;
   state.previewedMemoryIndex = null;
   recorder.reset();
   renderCapturedStats([], [], false);
   renderGeneratedStats(null);
   syncPreviewSelection();
-  updateInfiniteActionState();
   setPhraseStatus("Waiting for MIDI");
 }
 
@@ -795,13 +1499,12 @@ function revealPreviewTarget(kind) {
 
 function previewPhrasePayload(payload, kind, message) {
   if (kind === "generated") {
-    state.lastGeneratedPhrase = payload;
+    rememberGeneratedPhrase(payload);
     renderGeneratedStats(payload);
   } else {
-    state.lastCapturedPhrase = payload.events;
+    rememberCapturedPhrase(payload.events);
     renderCapturedStats(payload.events, payload.notes, true);
   }
-  updateInfiniteActionState();
   setPhraseMessage(message);
   revealPreviewTarget(kind);
 }
@@ -884,6 +1587,7 @@ function createMemorySummaryMarkup(memory) {
   if (memory.summary.seeded_phrase_count) {
     chips.push(`${memory.summary.seeded_phrase_count} seed`);
   }
+  chips.push(`K=${memory.configuration.markov_order}`);
   chips.push(memory.configuration.transposition ? "Transpose on" : "Transpose off");
   chips.push(
     memory.configuration.forget_past
@@ -1328,7 +2032,12 @@ async function refreshSessionActivity() {
   await Promise.all([refreshHistory(), refreshMemory()]);
 }
 
-function buildContinuationRequestBody(phraseEvents, learnInput, signal = null) {
+function buildContinuationRequestBody(
+  phraseEvents,
+  learnInput,
+  signal = null,
+  enforceEndConstraint = true,
+) {
   const continuationNoteCount = normalizedContinuationNoteCount(
     elements.continuationLengthInput.value,
   );
@@ -1336,6 +2045,7 @@ function buildContinuationRequestBody(phraseEvents, learnInput, signal = null) {
     session_id: state.sessionId,
     phrase: phraseEvents,
     learn_input: learnInput,
+    enforce_end_constraint: enforceEndConstraint,
   };
   if (continuationNoteCount != null) {
     requestBody.continuation_note_count = continuationNoteCount;
@@ -1352,76 +2062,617 @@ function buildContinuationRequestBody(phraseEvents, learnInput, signal = null) {
   };
 }
 
-function defaultContinuationMessage(payload, continuationNoteCount) {
-  return (
-    payload.status_message ||
-    (continuationNoteCount == null
-      ? `Continuation generated: ${payload.generated_phrase.note_count} notes returned.`
-      : `Continuation generated: ${payload.generated_phrase.note_count} notes returned from a ${continuationNoteCount}-note request.`)
+function defaultContinuationMessage(payload, continuationNoteCount) {
+  return (
+    payload.status_message ||
+    (continuationNoteCount == null
+      ? `Continuation generated: ${payload.generated_phrase.note_count} notes returned.`
+      : `Continuation generated: ${payload.generated_phrase.note_count} notes returned from a ${continuationNoteCount}-note request.`)
+  );
+}
+
+function applyContinuationPayload(payload) {
+  rememberCapturedPhrase(payload.input_phrase.events);
+  renderCapturedStats(payload.input_phrase.events, payload.input_phrase.notes, true);
+  rememberGeneratedPhrase(payload.generated_phrase);
+  renderGeneratedStats(payload.generated_phrase);
+}
+
+function applyGeneratedPhrasePayload(payload) {
+  rememberGeneratedPhrase(payload);
+  renderGeneratedStats(payload);
+}
+
+function defaultMidiImportMessage(payload) {
+  const importedCount = Number(payload?.imported_file_count || 0);
+  const skippedCount = Number(payload?.skipped_file_count || 0);
+  const importedNames = Array.isArray(payload?.imported_files)
+    ? payload.imported_files
+        .map((item) => item?.file_name)
+        .filter((value) => typeof value === "string" && value.length)
+    : [];
+
+  let message = `Imported ${pluralize(importedCount, "MIDI file")} into the current session memory.`;
+  if (importedNames.length) {
+    const shownNames = importedNames.slice(0, 3).join(", ");
+    const overflow = importedNames.length > 3 ? `, and ${importedNames.length - 3} more` : "";
+    message += ` ${shownNames}${overflow}.`;
+  }
+  if (skippedCount) {
+    message += ` Skipped ${pluralize(skippedCount, "file")} that were empty, unreadable, or not MIDI.`;
+  }
+  return message;
+}
+
+function defaultMemoryGenerationMessage(payload, requestedNoteCount) {
+  return (
+    payload.status_message ||
+    `Fresh phrase generated from memory: ${payload.generated_phrase.note_count} notes returned from a ${requestedNoteCount}-note request.`
+  );
+}
+
+async function requestContinuationFromEvents(
+  phraseEvents,
+  {
+    learnInput = elements.learnInputToggle.checked,
+    statusLabel = "Sending",
+    signal = null,
+    enforceEndConstraint = true,
+  } = {},
+) {
+  if (!phraseEvents?.length) {
+    throw new Error("No completed phrase is ready yet.");
+  }
+
+  await ensureSession();
+  setPhraseStatus(statusLabel);
+  const { continuationNoteCount, fetchOptions } = buildContinuationRequestBody(
+    phraseEvents,
+    learnInput,
+    signal,
+    enforceEndConstraint,
+  );
+  const payload = await requestJson("/api/continue", fetchOptions);
+  return { payload, continuationNoteCount };
+}
+
+async function requestMemoryGeneration(
+  {
+    noteCount = preferredGenerationNoteCount(),
+    statusLabel = "Generating",
+    signal = null,
+    enforceEndConstraint = true,
+  } = {},
+) {
+  await ensureSession();
+  setPhraseStatus(statusLabel);
+  const requestBody = {
+    note_count: noteCount,
+    enforce_end_constraint: enforceEndConstraint,
+  };
+  const payload = await requestJson(`/api/sessions/${state.sessionId}/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(requestBody),
+    signal,
+  });
+  return { payload, noteCount };
+}
+
+async function sendCurrentPhrase() {
+  stopInfiniteMode({ stopPlayback: true, silent: true });
+  const { payload, continuationNoteCount } = await requestContinuationFromEvents(
+    state.lastCapturedPhrase,
+    { learnInput: elements.learnInputToggle.checked },
+  );
+  applyContinuationPayload(payload);
+  if (payload.generated_phrase.event_count > 0) {
+    await playPayload(payload.generated_phrase);
+  }
+  await refreshSessionActivity();
+  await refreshSavedSessions();
+  setPhraseStatus(payload.generated_phrase.note_count ? "Generated" : "Primed");
+  setPhraseMessage(defaultContinuationMessage(payload, continuationNoteCount));
+}
+
+async function generateFreshPhrase() {
+  stopInfiniteMode({ stopPlayback: true, silent: true });
+  const { payload, noteCount } = await requestMemoryGeneration({
+    noteCount: preferredGenerationNoteCount(),
+    statusLabel: "Generating",
+  });
+  applyGeneratedPhrasePayload(payload.generated_phrase);
+  if (payload.generated_phrase.event_count > 0) {
+    await playPayload(payload.generated_phrase);
+  }
+  await refreshSessionActivity();
+  await refreshSavedSessions();
+  setPhraseStatus(payload.generated_phrase.note_count ? "Generated" : "Primed");
+  setPhraseMessage(defaultMemoryGenerationMessage(payload, noteCount));
+}
+
+async function importSelectedMidiFiles(fileList, selectionLabel = "selection") {
+  const selectedFiles = Array.from(fileList || []);
+  if (!selectedFiles.length) {
+    return;
+  }
+
+  const midiFiles = selectedFiles.filter((file) =>
+    hasMidiFileExtension(file.webkitRelativePath || file.name),
+  );
+  if (!midiFiles.length) {
+    throw new Error(`No MIDI files were found in the selected ${selectionLabel}.`);
+  }
+
+  stopInfiniteMode({ stopPlayback: true, silent: true });
+  await ensureSession();
+
+  const formData = new FormData();
+  midiFiles.forEach((file, index) => {
+    const uploadName =
+      file.webkitRelativePath || file.name || `imported_${index + 1}.mid`;
+    formData.append("files", file, uploadName);
+  });
+
+  setPhraseMessage(
+    `Importing ${pluralize(midiFiles.length, "MIDI file")} into the current session memory...`,
+  );
+  const payload = await requestJson(`/api/sessions/${state.sessionId}/import-midi`, {
+    method: "POST",
+    body: formData,
+  });
+
+  await refreshSessionActivity();
+  await refreshSavedSessions();
+  setControlView("continuator");
+  setActivityView("memory");
+  setSessionStatus("Ready");
+  setPhraseStatus(state.lastCapturedPhrase.length ? "Phrase ready" : "Waiting for MIDI");
+  setPhraseMessage(defaultMidiImportMessage(payload));
+}
+
+async function checkServer() {
+  const payload = await requestJson("/health");
+  elements.serverStatus.textContent = payload.ok
+    ? payload.seeded
+      ? "Healthy / seeded"
+      : "Healthy / empty memory"
+    : "Unavailable";
+}
+
+function midiOutputById(outputId) {
+  if (!state.midiAccess || !outputId) {
+    return null;
+  }
+  return state.midiAccess.outputs.get(outputId) || null;
+}
+
+function selectedPlaybackChoiceValue() {
+  return elements.midiOutputSelect.value || DEFAULT_PLAYBACK_CHOICE;
+}
+
+function encodePlaybackChoice(rendererId, targetId = null) {
+  return targetId
+    ? `${rendererId}${PLAYBACK_CHOICE_SEPARATOR}${targetId}`
+    : rendererId;
+}
+
+function parsePlaybackChoice(choiceValue) {
+  if (!choiceValue) {
+    return {
+      rendererId: DEFAULT_PLAYBACK_CHOICE,
+      targetId: null,
+    };
+  }
+
+  const [rendererId, ...targetParts] = String(choiceValue).split(
+    PLAYBACK_CHOICE_SEPARATOR,
+  );
+  return {
+    rendererId: rendererId || DEFAULT_PLAYBACK_CHOICE,
+    targetId: targetParts.length
+      ? targetParts.join(PLAYBACK_CHOICE_SEPARATOR)
+      : null,
+  };
+}
+
+function resolvePlaybackChoice(choiceValue = selectedPlaybackChoiceValue()) {
+  const { rendererId, targetId } = parsePlaybackChoice(choiceValue);
+  const renderer =
+    playbackRendererRegistry.get(rendererId) ||
+    playbackRendererRegistry.get(DEFAULT_PLAYBACK_CHOICE) ||
+    null;
+  return {
+    value: encodePlaybackChoice(renderer?.id || rendererId, targetId),
+    rendererId: renderer?.id || rendererId,
+    targetId,
+    renderer,
+  };
+}
+
+function selectedPlaybackChoice() {
+  return resolvePlaybackChoice(selectedPlaybackChoiceValue());
+}
+
+function playbackChoiceLabel(choiceValue = selectedPlaybackChoiceValue()) {
+  const choice = resolvePlaybackChoice(choiceValue);
+  return choice.renderer
+    ? choice.renderer.getDisplayName(choice.targetId)
+    : "Unavailable renderer";
+}
+
+async function loadCustomFaustTemplate() {
+  if (state.customFaustTemplateSource) {
+    return state.customFaustTemplateSource;
+  }
+
+  const response = await fetch(FAUST_CUSTOM_TEMPLATE_DSP_URL);
+  if (!response.ok) {
+    throw new Error(`Unable to load the Custom Faust starter template (${response.status}).`);
+  }
+  state.customFaustTemplateSource = await response.text();
+  return state.customFaustTemplateSource;
+}
+
+async function initializeCustomFaustSource() {
+  const storedSource = safeLocalStorageGet(FAUST_CUSTOM_SOURCE_STORAGE_KEY);
+  if (storedSource && storedSource.trim()) {
+    state.customFaustSource = storedSource;
+    elements.faustCustomCodeInput.value = storedSource;
+    return;
+  }
+
+  const template = await loadCustomFaustTemplate();
+  state.customFaustSource = template;
+  elements.faustCustomCodeInput.value = template;
+  safeLocalStorageSet(FAUST_CUSTOM_SOURCE_STORAGE_KEY, template);
+}
+
+function setCustomFaustSource(source, { persist = true } = {}) {
+  state.customFaustSource = String(source ?? "");
+  if (
+    document.activeElement !== elements.faustCustomCodeInput &&
+    elements.faustCustomCodeInput.value !== state.customFaustSource
+  ) {
+    elements.faustCustomCodeInput.value = state.customFaustSource;
+  }
+  if (persist) {
+    safeLocalStorageSet(FAUST_CUSTOM_SOURCE_STORAGE_KEY, state.customFaustSource);
+  }
+}
+
+function selectedFaustRenderer(choiceValue = selectedPlaybackChoiceValue()) {
+  const renderer = resolvePlaybackChoice(choiceValue).renderer;
+  return renderer instanceof FaustPolyRenderer ? renderer : null;
+}
+
+function selectedRendererIsFaust(choiceValue = selectedPlaybackChoiceValue()) {
+  return Boolean(selectedFaustRenderer(choiceValue));
+}
+
+function selectedRendererIsCustomFaust(choiceValue = selectedPlaybackChoiceValue()) {
+  return resolvePlaybackChoice(choiceValue).rendererId === FAUST_CUSTOM_ID;
+}
+
+function clampFaustControlValue(value, descriptor) {
+  if (descriptor.kind !== "range") {
+    return value >= 0.5 ? 1 : 0;
+  }
+  return Math.min(descriptor.max, Math.max(descriptor.min, value));
+}
+
+function faustMetaMap(item) {
+  const meta = {};
+  for (const entry of item?.meta || []) {
+    for (const [key, value] of Object.entries(entry || {})) {
+      meta[key] = value;
+    }
+  }
+  return meta;
+}
+
+function faustLabel(item) {
+  const rawLabel = String(item?.label || item?.shortname || item?.address || "Control");
+  const label = rawLabel.split("/").pop() || rawLabel;
+  const withSpaces = label.replace(/_/g, " ").trim();
+  return withSpaces ? withSpaces.charAt(0).toUpperCase() + withSpaces.slice(1) : "Control";
+}
+
+function faustControlPrecision(step) {
+  const numericStep = Number(step);
+  if (!Number.isFinite(numericStep) || numericStep <= 0 || numericStep >= 1) {
+    return 0;
+  }
+  return Math.min(4, Math.max(0, Math.ceil(-Math.log10(numericStep))));
+}
+
+function formatFaustControlValue(descriptor, value) {
+  if (descriptor.kind === "toggle") {
+    return value >= 0.5 ? "On" : "Off";
+  }
+  const precision = faustControlPrecision(descriptor.step);
+  const formatted = Number(value).toFixed(precision);
+  return descriptor.unit ? `${formatted} ${descriptor.unit}` : formatted;
+}
+
+function loadStoredCustomFaustValues() {
+  const stored = safeLocalStorageGet(FAUST_CUSTOM_VALUES_STORAGE_KEY);
+  if (!stored) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(stored);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function persistCustomFaustValues() {
+  if (!state.customFaustControlDescriptors.length) {
+    safeLocalStorageSet(FAUST_CUSTOM_VALUES_STORAGE_KEY, null);
+    return;
+  }
+
+  const snapshot = {};
+  for (const descriptor of state.customFaustControlDescriptors) {
+    snapshot[descriptor.key] = customFaustRenderer.getControlValue(descriptor.key);
+  }
+  safeLocalStorageSet(FAUST_CUSTOM_VALUES_STORAGE_KEY, JSON.stringify(snapshot));
+}
+
+function buildCustomFaustControlDescriptors(ui) {
+  const storedValues = loadStoredCustomFaustValues();
+  const descriptors = [];
+  walkFaustUi(ui, (item) => {
+    if (!FAUST_UI_CONTROL_TYPES.has(item?.type)) {
+      return;
+    }
+
+    const address = String(item?.address || "");
+    const meta = faustMetaMap(item);
+    if (!address || meta.hidden === "1") {
+      return;
+    }
+    if (FAUST_POLY_RESERVED_SUFFIXES.some((suffix) => address.endsWith(suffix))) {
+      return;
+    }
+
+    const kind =
+      item.type === "checkbox" || item.type === "button" ? "toggle" : "range";
+    const descriptor = {
+      key: address,
+      kind,
+      label: faustLabel(item),
+      unit: String(meta.unit || ""),
+      min: Number.isFinite(Number(item?.min)) ? Number(item.min) : 0,
+      max: Number.isFinite(Number(item?.max)) ? Number(item.max) : 1,
+      step:
+        Number.isFinite(Number(item?.step)) && Number(item.step) > 0
+          ? Number(item.step)
+          : kind === "range"
+            ? 0.01
+            : 1,
+      defaultValue: Number.isFinite(Number(item?.init)) ? Number(item.init) : 0,
+    };
+
+    const existingValue = customFaustRenderer.controlValues.get(descriptor.key);
+    const storedValue = storedValues[descriptor.key];
+    const nextValue = Number.isFinite(Number(existingValue))
+      ? Number(existingValue)
+      : Number.isFinite(Number(storedValue))
+        ? Number(storedValue)
+        : descriptor.defaultValue;
+    descriptor.value = clampFaustControlValue(nextValue, descriptor);
+    descriptors.push(descriptor);
+  });
+
+  customFaustRenderer.controlValues = new Map(
+    descriptors.map((descriptor) => [descriptor.key, descriptor.value]),
   );
+  return descriptors;
 }
 
-function applyContinuationPayload(payload) {
-  state.lastCapturedPhrase = payload.input_phrase.events;
-  renderCapturedStats(payload.input_phrase.events, payload.input_phrase.notes, true);
-  state.lastGeneratedPhrase = payload.generated_phrase;
-  renderGeneratedStats(payload.generated_phrase);
-  updateInfiniteActionState();
-}
+function rebuildCustomFaustControls() {
+  elements.faustCustomControls.replaceChildren();
+  state.customFaustControlBindings = [];
 
-async function requestContinuationFromEvents(
-  phraseEvents,
-  {
-    learnInput = elements.learnInputToggle.checked,
-    statusLabel = "Sending",
-    signal = null,
-  } = {},
-) {
-  if (!phraseEvents?.length) {
-    throw new Error("No completed phrase is ready yet.");
+  if (!state.customFaustControlDescriptors.length) {
+    return;
   }
 
-  await ensureSession();
-  setPhraseStatus(statusLabel);
-  const { continuationNoteCount, fetchOptions } = buildContinuationRequestBody(
-    phraseEvents,
-    learnInput,
-    signal,
-  );
-  const payload = await requestJson("/api/continue", fetchOptions);
-  return { payload, continuationNoteCount };
-}
+  const fragment = document.createDocumentFragment();
+  state.customFaustControlDescriptors.forEach((descriptor, index) => {
+    const field = document.createElement("div");
+    field.className = "field faust-field";
+
+    const labelRow = document.createElement("div");
+    labelRow.className = "faust-label-row";
+
+    const label = document.createElement("label");
+    const output = document.createElement("output");
+    const inputId = `faust-custom-control-${index}`;
+    label.setAttribute("for", inputId);
+    output.setAttribute("for", inputId);
+    label.textContent = descriptor.label;
+
+    let input;
+    if (descriptor.kind === "toggle") {
+      input = document.createElement("input");
+      input.type = "checkbox";
+      input.id = inputId;
+      input.checked = descriptor.value >= 0.5;
+      input.addEventListener("change", () => {
+        const nextValue = input.checked ? 1 : 0;
+        descriptor.value = nextValue;
+        customFaustRenderer.setControlValue(descriptor.key, nextValue);
+        persistCustomFaustValues();
+        syncFaustRendererPanel();
+      });
+    } else {
+      input = document.createElement("input");
+      input.type = "range";
+      input.id = inputId;
+      input.min = String(descriptor.min);
+      input.max = String(descriptor.max);
+      input.step = String(descriptor.step);
+      input.value = String(descriptor.value);
+      input.addEventListener("input", () => {
+        const nextValue = clampFaustControlValue(Number(input.value), descriptor);
+        descriptor.value = nextValue;
+        customFaustRenderer.setControlValue(descriptor.key, nextValue);
+        persistCustomFaustValues();
+        syncFaustRendererPanel();
+      });
+    }
 
-async function sendCurrentPhrase() {
-  stopInfiniteMode({ stopPlayback: true, silent: true });
-  const { payload, continuationNoteCount } = await requestContinuationFromEvents(
-    state.lastCapturedPhrase,
-    { learnInput: elements.learnInputToggle.checked },
-  );
-  applyContinuationPayload(payload);
-  if (payload.generated_phrase.event_count > 0) {
-    await playPayload(payload.generated_phrase);
+    output.textContent = formatFaustControlValue(descriptor, descriptor.value);
+    labelRow.append(label, output);
+    field.append(labelRow, input);
+    fragment.append(field);
+    state.customFaustControlBindings.push({ descriptor, input, output });
+  });
+
+  elements.faustCustomControls.append(fragment);
+}
+
+function syncCustomFaustControls() {
+  const customSelected = selectedRendererIsCustomFaust();
+  const inputsEnabled =
+    customSelected &&
+    customFaustRenderer.status !== "Loading" &&
+    customFaustRenderer.status !== "Error";
+  for (const binding of state.customFaustControlBindings) {
+    const currentValue = customFaustRenderer.getControlValue(binding.descriptor.key);
+    binding.descriptor.value = clampFaustControlValue(currentValue, binding.descriptor);
+    if (binding.descriptor.kind === "toggle") {
+      binding.input.checked = binding.descriptor.value >= 0.5;
+    } else if (binding.input.value !== String(binding.descriptor.value)) {
+      binding.input.value = String(binding.descriptor.value);
+    }
+    binding.input.disabled = !inputsEnabled;
+    binding.output.textContent = formatFaustControlValue(
+      binding.descriptor,
+      binding.descriptor.value,
+    );
   }
-  await refreshSessionActivity();
-  await refreshSavedSessions();
-  setPhraseStatus(payload.generated_phrase.note_count ? "Generated" : "Primed");
-  setPhraseMessage(defaultContinuationMessage(payload, continuationNoteCount));
+
+  elements.faustCustomControlsHint.hidden = state.customFaustControlBindings.length > 0;
+  if (state.customFaustControlBindings.length) {
+    return;
+  }
+  if (customFaustRenderer.status === "Ready") {
+    elements.faustCustomControlsHint.textContent =
+      "This DSP compiled successfully, but it does not expose any visible user parameters.";
+    return;
+  }
+  elements.faustCustomControlsHint.textContent =
+    "Compile a polyphonic instrument to expose its parameters.";
 }
 
-async function checkServer() {
-  const payload = await requestJson("/health");
-  elements.serverStatus.textContent = payload.ok
-    ? payload.seeded
-      ? "Healthy / seeded"
-      : "Healthy / empty memory"
-    : "Unavailable";
+function customFaustHasPendingChanges() {
+  return state.customFaustSource !== (customFaustRenderer.lastCompiledCode || "");
 }
 
-function selectedMidiOutput() {
-  if (!state.midiAccess) {
-    return null;
+function customFaustDirtyCopy() {
+  if (!state.customFaustSource.trim()) {
+    return "Paste or write a Faust DSP before compiling.";
+  }
+  if (customFaustRenderer.status === "Loading") {
+    return "Compiling the current source in your browser…";
+  }
+  if (customFaustHasPendingChanges()) {
+    return customFaustRenderer.lastCompiledCode
+      ? "Edits are saved locally. Compile to replace the last working build with these changes."
+      : "Compile to turn this source into the active renderer.";
+  }
+  if (customFaustRenderer.status === "Ready") {
+    return "The editor matches the currently active compiled renderer.";
   }
-  return state.midiAccess.outputs.get(elements.midiOutputSelect.value) || null;
+  return "Compile to turn the latest source into the active renderer.";
+}
+
+function refreshCustomFaustControlState() {
+  state.customFaustControlDescriptors = buildCustomFaustControlDescriptors(
+    customFaustRenderer.getUi(),
+  );
+  rebuildCustomFaustControls();
+  persistCustomFaustValues();
+}
+
+function syncFaustRendererPanel() {
+  const selectedRenderer = selectedFaustRenderer();
+  const faustSelected = Boolean(selectedRenderer);
+  elements.faustRendererPanel.hidden = !faustSelected;
+  elements.faustClavierPanel.hidden = !faustSelected || selectedRenderer?.id !== FAUST_CLAVIER_ID;
+  elements.faustCustomPanel.hidden = !faustSelected || selectedRenderer?.id !== FAUST_CUSTOM_ID;
+  elements.faustRendererStatus.textContent = selectedRenderer?.status || "Idle";
+
+  let hint = "Faust instruments are compiled locally in your browser the first time you use them.";
+  if (selectedRenderer?.lastError) {
+    hint = `Faust renderer error: ${selectedRenderer.lastError.message}`;
+  } else if (selectedRenderer?.id === FAUST_CLAVIER_ID) {
+    if (selectedRenderer.status === "Loading") {
+      hint =
+        "Compiling the built-in Faust Clavier in your browser. Once it is ready, these controls update the live renderer.";
+    } else if (selectedRenderer.status === "Ready") {
+      hint =
+        "These controls are live on the built-in Faust Clavier. They shape attack, damping, release, body resonance, and stereo spread.";
+    }
+  } else if (selectedRenderer?.id === FAUST_CUSTOM_ID) {
+    if (selectedRenderer.status === "Loading") {
+      hint = "Compiling your Custom Faust source in the browser and rebuilding its parameter panel.";
+    } else if (customFaustHasPendingChanges()) {
+      hint =
+        "Custom Faust keeps using the last compiled build until you compile the latest source in the editor.";
+    } else if (selectedRenderer.status === "Ready") {
+      hint =
+        "The Custom Faust renderer is active. Any visible Faust controls from your DSP appear below automatically.";
+    }
+  }
+  elements.faustRendererHint.textContent = hint;
+
+  for (const control of faustClavierControls) {
+    const value = faustClavierRenderer.getControlValue(control.key);
+    const inputValue = String(value);
+    if (control.input.value !== inputValue) {
+      control.input.value = inputValue;
+    }
+    control.input.disabled =
+      !faustSelected ||
+      selectedRenderer?.id !== FAUST_CLAVIER_ID ||
+      selectedRenderer.status === "Loading";
+    control.output.textContent = control.format(value);
+  }
+
+  if (document.activeElement !== elements.faustCustomCodeInput) {
+    elements.faustCustomCodeInput.value = state.customFaustSource;
+  }
+  elements.faustCustomCompileButton.disabled =
+    !state.customFaustSource.trim() || customFaustRenderer.status === "Loading";
+  elements.faustCustomResetButton.disabled = customFaustRenderer.status === "Loading";
+  elements.faustCustomDirtyState.textContent = customFaustDirtyCopy();
+  syncCustomFaustControls();
+}
+
+async function createPlaybackSession(choiceValue = selectedPlaybackChoiceValue()) {
+  const choice = resolvePlaybackChoice(choiceValue);
+  if (!choice.renderer) {
+    throw new Error("Selected playback renderer is unavailable.");
+  }
+
+  const rendererState = (await choice.renderer.createPlaybackSession?.(choice.targetId)) || {};
+  return {
+    renderer: choice.renderer,
+    rendererId: choice.renderer.id,
+    targetId: choice.targetId,
+    choiceValue: choice.value,
+    timerIds: new Set(),
+    cleanupTimerId: null,
+    handoffAtMs: performance.now(),
+    endsAtMs: performance.now(),
+    ...rendererState,
+  };
 }
 
 function outputNoteKey(note, channel) {
@@ -1436,6 +2687,50 @@ function sendOutputMessage(output, message) {
   }
 }
 
+function sendMidiPanicToOutput(output) {
+  if (!output) {
+    return false;
+  }
+
+  for (let channel = 0; channel < 16; channel += 1) {
+    sendOutputMessage(output, [0xb0 | channel, 64, 0]);
+    sendOutputMessage(output, [0xb0 | channel, 121, 0]);
+    for (let note = 0; note < 128; note += 1) {
+      sendOutputMessage(output, [0x80 | (channel & 0x0f), note, 0]);
+    }
+    sendOutputMessage(output, [0xb0 | channel, 123, 0]);
+    sendOutputMessage(output, [0xb0 | channel, 120, 0]);
+  }
+  return true;
+}
+
+async function sendPlaybackPanic() {
+  let sent = false;
+  const activePlayback = state.activePlayback;
+
+  if (activePlayback?.renderer?.panicPlayback) {
+    sent = (await activePlayback.renderer.panicPlayback(activePlayback)) || sent;
+  }
+
+  for (const renderer of localPlaybackRenderers) {
+    if (activePlayback?.renderer === renderer) {
+      continue;
+    }
+    sent = (await renderer.panicTarget()) || sent;
+  }
+
+  const selectedChoice = selectedPlaybackChoice();
+  const matchesActiveSelection =
+    activePlayback &&
+    activePlayback.rendererId === selectedChoice.rendererId &&
+    activePlayback.targetId === selectedChoice.targetId;
+  if (!matchesActiveSelection && selectedChoice.renderer?.panicTarget) {
+    sent = (await selectedChoice.renderer.panicTarget(selectedChoice.targetId)) || sent;
+  }
+
+  return sent;
+}
+
 function stopActivePlayback() {
   const playback = state.activePlayback;
   if (!playback) {
@@ -1445,51 +2740,16 @@ function stopActivePlayback() {
   playback.timerIds.forEach((timerId) => {
     window.clearTimeout(timerId);
   });
-
-  if (playback.output) {
-    playback.activeOutputNotes.forEach((key) => {
-      const [channelRaw, noteRaw] = key.split(":");
-      const channel = Number(channelRaw);
-      const note = Number(noteRaw);
-      sendOutputMessage(playback.output, [0x80 | (channel & 0x0f), note, 0]);
-    });
-
-    for (let channel = 0; channel < 16; channel += 1) {
-      sendOutputMessage(playback.output, [0xb0 | channel, 64, 0]);
-      sendOutputMessage(playback.output, [0xb0 | channel, 123, 0]);
-      sendOutputMessage(playback.output, [0xb0 | channel, 120, 0]);
-    }
-  }
-
-  synth.stop();
+  playback.timerIds.clear();
+  playback.cleanupTimerId = null;
+  playback.renderer?.stopPlayback?.(playback);
   state.activePlayback = null;
   updateInfiniteActionState();
   return true;
 }
 
 function dispatchPlaybackEvent(playback, event) {
-  if (playback.output) {
-    const status =
-      event.type === "note_on" && event.velocity > 0
-        ? 0x90 | (event.channel & 0x0f)
-        : 0x80 | (event.channel & 0x0f);
-    sendOutputMessage(playback.output, [status, event.note, event.velocity]);
-
-    const key = outputNoteKey(event.note, event.channel);
-    if (event.type === "note_on" && event.velocity > 0) {
-      playback.activeOutputNotes.add(key);
-    } else {
-      playback.activeOutputNotes.delete(key);
-    }
-    return;
-  }
-
-  if (event.type === "note_on" && event.velocity > 0) {
-    synth.noteOn(event.note, event.channel, event.velocity);
-    return;
-  }
-
-  synth.noteOff(event.note, event.channel);
+  playback.renderer?.dispatchEvent?.(playback, event);
 }
 
 async function playPayload(
@@ -1506,26 +2766,7 @@ async function playPayload(
   let playback = state.activePlayback;
   if (!append || !playback) {
     stopActivePlayback();
-
-    let output = null;
-    if (elements.midiOutputSelect.value !== BROWSER_SYNTH_ID) {
-      output = selectedMidiOutput();
-      if (output) {
-        await output.open();
-      }
-    }
-
-    if (!output) {
-      await synth.ensureContext();
-    }
-
-    playback = {
-      output,
-      timerIds: new Set(),
-      activeOutputNotes: new Set(),
-      cleanupTimerId: null,
-      endsAtMs: performance.now(),
-    };
+    playback = await createPlaybackSession();
     state.activePlayback = playback;
   }
 
@@ -1537,6 +2778,7 @@ async function playPayload(
 
   const scheduleDelayMs = Math.max(0, startDelayMs);
   const scheduleBaseMs = performance.now();
+  const handoffMs = continuationHandoffMs(payload);
   let cursorMs = 0;
   for (const event of payload.events) {
     cursorMs += event.delta_seconds * 1000;
@@ -1559,6 +2801,10 @@ async function playPayload(
   }, scheduleDelayMs + cursorMs + 200);
   playback.cleanupTimerId = cleanupTimerId;
   playback.timerIds.add(cleanupTimerId);
+  playback.handoffAtMs = Math.max(
+    playback.handoffAtMs,
+    scheduleBaseMs + scheduleDelayMs + handoffMs,
+  );
   playback.endsAtMs = Math.max(playback.endsAtMs, scheduleBaseMs + scheduleDelayMs + cursorMs);
   updateInfiniteActionState();
 }
@@ -1603,12 +2849,14 @@ function stopLoopAndPlayback(message) {
 
   if (hadInfiniteState) {
     stopInfiniteMode({ stopPlayback: true, silent: true });
+    void sendPlaybackPanic();
     setPhraseStatus(state.lastCapturedPhrase.length ? "Phrase ready" : "Waiting for MIDI");
     setPhraseMessage(message || "Infinite mode stopped.");
     return true;
   }
 
   if (stopActivePlayback()) {
+    void sendPlaybackPanic();
     setPhraseStatus(state.lastCapturedPhrase.length ? "Phrase ready" : "Waiting for MIDI");
     setPhraseMessage(message || "Playback stopped.");
     return true;
@@ -1624,8 +2872,8 @@ function scheduleInfiniteStep(prefixPayload, runId) {
 
   clearInfiniteScheduler();
   const remainingPlaybackMs = state.activePlayback
-    ? Math.max(0, state.activePlayback.endsAtMs - performance.now())
-    : continuationDurationMs(prefixPayload);
+    ? Math.max(0, state.activePlayback.handoffAtMs - performance.now())
+    : continuationHandoffMs(prefixPayload);
   const delayMs = Math.max(0, remainingPlaybackMs - infiniteLookaheadMs(prefixPayload));
 
   state.infiniteScheduleTimerId = window.setTimeout(() => {
@@ -1648,30 +2896,70 @@ async function runInfiniteStep(prefixEvents, runId) {
   state.infiniteAbortController = abortController;
   updateInfiniteActionState();
 
+  const continueInfiniteFromMemory = async (reason) => {
+    const { payload } = await requestMemoryGeneration({
+      noteCount: preferredGenerationNoteCount(prefixEvents),
+      statusLabel: state.activePlayback ? "Re-seeding from memory" : "Generating from memory",
+      signal: abortController.signal,
+      enforceEndConstraint: false,
+    });
+    if (!state.infiniteModeEnabled || runId !== state.infiniteRunId) {
+      return true;
+    }
+
+    const generatedPhrase = payload.generated_phrase;
+    if (!generatedPhrase.event_count) {
+      throw new Error("the memory fallback returned an empty phrase");
+    }
+
+    applyGeneratedPhrasePayload(generatedPhrase);
+    const startDelayMs = state.activePlayback
+      ? Math.max(0, state.activePlayback.handoffAtMs - performance.now())
+      : PLAYBACK_START_DELAY_MS;
+    await playPayload(generatedPhrase, {
+      startDelayMs,
+      append: Boolean(state.activePlayback),
+    });
+    await refreshSessionActivity();
+    await refreshSavedSessions();
+    if (!state.infiniteModeEnabled || runId !== state.infiniteRunId) {
+      return true;
+    }
+
+    setPhraseStatus("Infinite");
+    setPhraseMessage(
+      payload.status_message ||
+        `Infinite mode resumed from memory because ${reason}.`,
+    );
+    scheduleInfiniteStep(generatedPhrase, runId);
+    return true;
+  };
+
   try {
     const { payload } = await requestContinuationFromEvents(prefixEvents, {
       learnInput: false,
       statusLabel: state.activePlayback ? "Queueing next" : "Sending",
       signal: abortController.signal,
+      enforceEndConstraint: false,
     });
     if (!state.infiniteModeEnabled || runId !== state.infiniteRunId) {
       return;
     }
 
-    applyContinuationPayload(payload);
-    if (!payload.generated_phrase.event_count) {
-      stopInfiniteMode({
-        stopPlayback: false,
-        message: "Infinite mode stopped because the latest continuation was empty.",
-      });
-      setPhraseStatus("Primed");
+    const generatedPhrase = payload.generated_phrase;
+    applyContinuationPayload({
+      ...payload,
+      generated_phrase: generatedPhrase,
+    });
+    if (!generatedPhrase.event_count) {
+      await continueInfiniteFromMemory("the latest continuation was empty");
       return;
     }
 
     const startDelayMs = state.activePlayback
-      ? Math.max(0, state.activePlayback.endsAtMs - performance.now())
+      ? Math.max(0, state.activePlayback.handoffAtMs - performance.now())
       : PLAYBACK_START_DELAY_MS;
-    await playPayload(payload.generated_phrase, {
+    await playPayload(generatedPhrase, {
       startDelayMs,
       append: Boolean(state.activePlayback),
     });
@@ -1683,13 +2971,25 @@ async function runInfiniteStep(prefixEvents, runId) {
 
     setPhraseStatus("Infinite");
     setPhraseMessage(
-      `Infinite mode running: ${payload.generated_phrase.note_count} notes queued from the latest continuation.`,
+      `Infinite mode running: ${generatedPhrase.note_count} notes queued from the latest continuation.`,
     );
-    scheduleInfiniteStep(payload.generated_phrase, runId);
+    scheduleInfiniteStep(generatedPhrase, runId);
   } catch (error) {
     if (error.name === "AbortError") {
       return;
     }
+
+    try {
+      const resumed = await continueInfiniteFromMemory(
+        "the latest continuation reached a dead end",
+      );
+      if (resumed) {
+        return;
+      }
+    } catch (fallbackError) {
+      error = fallbackError;
+    }
+
     if (runId === state.infiniteRunId) {
       stopInfiniteMode({
         stopPlayback: false,
@@ -1723,9 +3023,7 @@ async function startInfiniteMode() {
     return;
   }
 
-  const seedEvents = state.lastCapturedPhrase.length
-    ? state.lastCapturedPhrase
-    : state.lastGeneratedPhrase?.events || [];
+  const seedEvents = latestLoopSeedEvents();
   if (!seedEvents.length) {
     setPhraseMessage("Play or preview a phrase before starting infinite mode.", true);
     return;
@@ -1746,13 +3044,18 @@ async function startInfiniteMode() {
     const { payload } = await requestContinuationFromEvents(seedEvents, {
       learnInput: elements.learnInputToggle.checked,
       signal: abortController.signal,
+      enforceEndConstraint: false,
     });
     if (!state.infiniteModeEnabled || runId !== state.infiniteRunId) {
       return;
     }
 
-    applyContinuationPayload(payload);
-    if (!payload.generated_phrase.event_count) {
+    const generatedPhrase = payload.generated_phrase;
+    applyContinuationPayload({
+      ...payload,
+      generated_phrase: generatedPhrase,
+    });
+    if (!generatedPhrase.event_count) {
       stopInfiniteMode({
         stopPlayback: false,
         message: "Infinite mode stopped because the first continuation was empty.",
@@ -1761,7 +3064,7 @@ async function startInfiniteMode() {
       return;
     }
 
-    await playPayload(payload.generated_phrase);
+    await playPayload(generatedPhrase);
     await refreshSessionActivity();
     await refreshSavedSessions();
     if (!state.infiniteModeEnabled || runId !== state.infiniteRunId) {
@@ -1770,9 +3073,9 @@ async function startInfiniteMode() {
 
     setPhraseStatus("Infinite");
     setPhraseMessage(
-      `Infinite mode running: ${payload.generated_phrase.note_count} notes in the first continuation.`,
+      `Infinite mode running: ${generatedPhrase.note_count} notes in the first continuation.`,
     );
-    scheduleInfiniteStep(payload.generated_phrase, runId);
+    scheduleInfiniteStep(generatedPhrase, runId);
   } catch (error) {
     if (error.name === "AbortError") {
       return;
@@ -1793,15 +3096,59 @@ async function startInfiniteMode() {
   }
 }
 
+function populatePlaybackChoices() {
+  const outputs = state.midiAccess ? [...state.midiAccess.outputs.values()] : [];
+  const previousChoiceValue = selectedPlaybackChoiceValue();
+  const availableChoices = new Set([
+    ...localPlaybackRenderers.map((renderer) => encodePlaybackChoice(renderer.id)),
+    ...outputs.map((output) =>
+      encodePlaybackChoice(WEB_MIDI_RENDERER_ID, output.id),
+    ),
+  ]);
+
+  const localRendererGroups = new Map();
+  for (const renderer of localPlaybackRenderers) {
+    const groupLabel = renderer.groupLabel || "Playback Renderers";
+    const existing = localRendererGroups.get(groupLabel) || [];
+    existing.push(
+      `<option value="${encodePlaybackChoice(renderer.id)}">${renderer.getDisplayName()}</option>`,
+    );
+    localRendererGroups.set(groupLabel, existing);
+  }
+  const midiOptions = outputs
+    .map(
+      (output) =>
+        `<option value="${encodePlaybackChoice(
+          WEB_MIDI_RENDERER_ID,
+          output.id,
+        )}">${output.name || output.id}</option>`,
+    )
+    .join("");
+
+  elements.midiOutputSelect.disabled = false;
+  elements.midiOutputSelect.innerHTML = [
+    ...Array.from(localRendererGroups.entries()).map(
+      ([groupLabel, options]) =>
+        `<optgroup label="${groupLabel}">${options.join("")}</optgroup>`,
+    ),
+    midiOptions ? `<optgroup label="External MIDI">${midiOptions}</optgroup>` : "",
+  ]
+    .filter(Boolean)
+    .join("");
+  elements.midiOutputSelect.value = availableChoices.has(previousChoiceValue)
+    ? previousChoiceValue
+    : DEFAULT_PLAYBACK_CHOICE;
+  updateSelectedOutput();
+}
+
 async function populateMidiSelectors() {
+  populatePlaybackChoices();
   if (!state.midiAccess) {
     return;
   }
 
   const inputs = [...state.midiAccess.inputs.values()];
-  const outputs = [...state.midiAccess.outputs.values()];
   const previousInputId = elements.midiInputSelect.value;
-  const previousOutputId = elements.midiOutputSelect.value;
 
   elements.midiInputSelect.disabled = false;
   elements.midiInputSelect.innerHTML = inputs.length
@@ -1813,23 +3160,6 @@ async function populateMidiSelectors() {
         .join("")
     : `<option value="">No MIDI inputs found</option>`;
 
-  elements.midiOutputSelect.disabled = false;
-  const outputOptions = [
-    `<option value="${BROWSER_SYNTH_ID}">Browser Synth</option>`,
-    ...outputs.map(
-      (output) =>
-        `<option value="${output.id}">${output.name || output.id}</option>`,
-    ),
-  ];
-  elements.midiOutputSelect.innerHTML = outputOptions.join("");
-  elements.midiOutputSelect.value =
-    previousOutputId &&
-    (previousOutputId === BROWSER_SYNTH_ID ||
-      state.midiAccess.outputs.has(previousOutputId))
-      ? previousOutputId
-      : BROWSER_SYNTH_ID;
-  updateSelectedOutput();
-
   if (inputs.length) {
     const inputId = state.midiAccess.inputs.has(previousInputId)
       ? previousInputId
@@ -1919,14 +3249,20 @@ async function connectMidi() {
 }
 
 function updateSelectedOutput() {
-  const outputId = elements.midiOutputSelect.value;
-  if (outputId === BROWSER_SYNTH_ID) {
-    setSelectedOutputName("Browser Synth");
-    return;
+  setSelectedOutputName(playbackChoiceLabel());
+  syncFaustRendererPanel();
+}
+
+async function compileCustomFaustFromEditor() {
+  const source = elements.faustCustomCodeInput.value;
+  if (!source.trim()) {
+    throw new Error("Paste or write a Faust DSP before compiling.");
   }
 
-  const output = selectedMidiOutput();
-  setSelectedOutputName(output ? output.name || output.id : "Unavailable output");
+  setCustomFaustSource(source);
+  stopLoopAndPlayback("Stopped playback before recompiling Custom Faust.");
+  await customFaustRenderer.prepare({ forceRecompile: true });
+  refreshCustomFaustControlState();
 }
 
 function clearPhrases() {
@@ -2102,6 +3438,15 @@ function bindEvents() {
     }
   });
 
+  elements.generateMemoryButton.addEventListener("click", async () => {
+    try {
+      await generateFreshPhrase();
+    } catch (error) {
+      setPhraseMessage(error.message, true);
+      setPhraseStatus("Error");
+    }
+  });
+
   elements.replayGeneratedButton.addEventListener("click", async () => {
     if (!state.lastGeneratedPhrase) {
       setPhraseMessage("No generated phrase is available yet.", true);
@@ -2152,16 +3497,59 @@ function bindEvents() {
 
   elements.midiOutputSelect.addEventListener("change", async () => {
     updateSelectedOutput();
-    const output = selectedMidiOutput();
-    if (output) {
-      try {
+    const choice = selectedPlaybackChoice();
+    try {
+      if (choice.rendererId === WEB_MIDI_RENDERER_ID) {
+        const output = midiOutputById(choice.targetId);
+        if (!output) {
+          setPhraseMessage("The selected MIDI output is unavailable.", true);
+          return;
+        }
         await output.open();
-      } catch (error) {
-        setPhraseMessage(error.message, true);
-        return;
+      } else if (choice.renderer instanceof FaustPolyRenderer) {
+        await choice.renderer.prepare();
+        if (choice.rendererId === FAUST_CUSTOM_ID) {
+          refreshCustomFaustControlState();
+        }
       }
+      setPhraseMessage(`Playback renderer set to ${elements.selectedOutputName.textContent}.`);
+    } catch (error) {
+      setPhraseMessage(error.message, true);
+    } finally {
+      syncFaustRendererPanel();
+    }
+  });
+
+  faustClavierControls.forEach((control) => {
+    control.input.addEventListener("input", () => {
+      faustClavierRenderer.setControlValue(control.key, control.input.value);
+    });
+  });
+
+  elements.faustCustomCodeInput.addEventListener("input", () => {
+    setCustomFaustSource(elements.faustCustomCodeInput.value);
+    syncFaustRendererPanel();
+  });
+
+  elements.faustCustomCompileButton.addEventListener("click", async () => {
+    try {
+      await compileCustomFaustFromEditor();
+      setPhraseMessage("Custom Faust compiled and is ready for playback.");
+    } catch (error) {
+      setPhraseMessage(error.message, true);
+      setPhraseStatus("Error");
+    }
+  });
+
+  elements.faustCustomResetButton.addEventListener("click", async () => {
+    try {
+      const starter = await loadCustomFaustTemplate();
+      setCustomFaustSource(starter);
+      syncFaustRendererPanel();
+      setPhraseMessage("Restored the Custom Faust starter template. Compile to use it.");
+    } catch (error) {
+      setPhraseMessage(error.message, true);
     }
-    setPhraseMessage(`Playback output set to ${elements.selectedOutputName.textContent}.`);
   });
 
   elements.learnInputToggle.addEventListener("change", () => {
@@ -2172,6 +3560,13 @@ function bindEvents() {
     renderSessionSettingsSummary();
   });
 
+  elements.markovOrderInput.addEventListener("change", () => {
+    elements.markovOrderInput.value = String(
+      normalizedMarkovOrder(elements.markovOrderInput.value),
+    );
+    renderSessionSettingsSummary();
+  });
+
   elements.forgetToggle.addEventListener("change", () => {
     updateKeepLastFieldState();
     renderSessionSettingsSummary();
@@ -2196,6 +3591,36 @@ function bindEvents() {
       noteCount == null ? "" : String(noteCount);
   });
 
+  elements.importMidiFilesButton.addEventListener("click", () => {
+    elements.midiImportInput.click();
+  });
+
+  elements.importMidiFolderButton.addEventListener("click", () => {
+    elements.midiFolderImportInput.click();
+  });
+
+  elements.midiImportInput.addEventListener("change", async (event) => {
+    const input = event.target;
+    try {
+      await importSelectedMidiFiles(input.files, "file selection");
+    } catch (error) {
+      setPhraseMessage(error.message, true);
+    } finally {
+      input.value = "";
+    }
+  });
+
+  elements.midiFolderImportInput.addEventListener("change", async (event) => {
+    const input = event.target;
+    try {
+      await importSelectedMidiFiles(input.files, "folder");
+    } catch (error) {
+      setPhraseMessage(error.message, true);
+    } finally {
+      input.value = "";
+    }
+  });
+
   window.addEventListener("resize", () => {
     drawPianoRoll(
       elements.inputRoll,
@@ -2209,13 +3634,20 @@ function bindEvents() {
 
 async function initialize() {
   bindEvents();
+  try {
+    await initializeCustomFaustSource();
+  } catch (error) {
+    setPhraseMessage(error.message, true);
+  }
+  populatePlaybackChoices();
   syncAuthUI();
   renderSavedSessions([]);
   clearCurrentSessionState();
   setControlView("perform");
   setActivityView("history");
   setSelectedInputName("No MIDI input selected");
-  setSelectedOutputName("Browser Synth");
+  updateSelectedOutput();
+  syncFaustRendererPanel();
   setLastMidiEvent("None yet");
   updateKeepLastFieldState();
   renderSessionSettingsSummary();

frontend/faust/continuator-clavier.dsp

@@ -0,0 +1,73 @@
+import("stdfaust.lib");
+
+declare name "Continuator Clavier";
+declare options "[midi:on][nvoices:24]";
+
+freq = hslider("freq[hidden:1]", 440.0, 20.0, 20000.0, 0.01);
+gain = hslider("gain[hidden:1]", 0.3, 0.0, 1.0, 0.001);
+gate = button("gate[hidden:1]");
+
+brightness =
+  hslider("Continuator Clavier/[0]brightness[style:knob]", 0.58, 0.0, 1.0, 0.01)
+  : si.smoo;
+hardness =
+  hslider("Continuator Clavier/[1]hardness[style:knob]", 0.34, 0.0, 1.0, 0.01)
+  : si.smoo;
+damping =
+  hslider("Continuator Clavier/[2]damping[style:knob]", 0.42, 0.0, 1.0, 0.01)
+  : si.smoo;
+release =
+  hslider(
+    "Continuator Clavier/[3]release[unit:s][style:knob]",
+    0.95,
+    0.08,
+    4.0,
+    0.01
+  )
+  : si.smoo;
+body =
+  hslider("Continuator Clavier/[4]body[style:knob]", 0.33, 0.0, 1.0, 0.01)
+  : si.smoo;
+stereo =
+  hslider("Continuator Clavier/[5]stereo[style:knob]", 0.45, 0.0, 1.0, 0.01)
+  : si.smoo;
+
+strike = en.adsr(
+  0.0015 + (1.0 - hardness) * 0.008,
+  0.08 + damping * 0.14,
+  0.0,
+  0.10 + release * 0.22,
+  gate
+);
+tail = en.adsr(
+  0.002,
+  0.18 + damping * 0.18,
+  0.0,
+  release,
+  gate
+);
+
+velocity = max(0.03, pow(gain, 0.72 - hardness * 0.28));
+cutoff = 900.0 + brightness * 7800.0;
+overtone = 2.0 + brightness * 2.6;
+pan = stereo * 0.32 * sin(freq * 0.0017);
+
+excitation =
+  os.osc(freq) * 0.17 +
+  os.sawtooth(freq * overtone) * (0.012 + brightness * 0.07) +
+  os.osc(freq * (3.0 + brightness * 4.0)) * (0.01 + hardness * 0.05) +
+  no.noise * (0.001 + hardness * 0.016);
+
+bodyResonance =
+  os.osc(freq * 0.5) * (0.018 + body * 0.075) +
+  os.osc(freq * 1.5) * (0.006 + body * 0.022);
+
+voice = (
+  ((excitation * strike) : fi.lowpass(3, cutoff)) +
+  (bodyResonance * tail)
+) * velocity;
+
+left = voice * sqrt(0.5 * (1.0 - pan));
+right = voice * sqrt(0.5 * (1.0 + pan));
+
+process = left, right;

frontend/faust/custom-poly-template.dsp

@@ -0,0 +1,41 @@
+import("stdfaust.lib");
+
+declare name "Continuator Custom Starter";
+declare options "[midi:on][nvoices:24]";
+
+freq = hslider("freq[hidden:1]", 440.0, 20.0, 20000.0, 0.01);
+gain = hslider("gain[hidden:1]", 0.3, 0.0, 1.0, 0.001);
+gate = button("gate[hidden:1]");
+
+tone =
+  hslider("Custom Starter/[0]tone[style:knob]", 0.62, 0.0, 1.0, 0.01)
+  : si.smoo;
+release =
+  hslider(
+    "Custom Starter/[1]release[unit:s][style:knob]",
+    0.90,
+    0.08,
+    4.0,
+    0.01
+  )
+  : si.smoo;
+detune =
+  hslider("Custom Starter/[2]detune[style:knob]", 0.16, 0.0, 1.0, 0.01)
+  : si.smoo;
+air =
+  hslider("Custom Starter/[3]air[style:knob]", 0.22, 0.0, 1.0, 0.01)
+  : si.smoo;
+
+env = en.adsr(0.004, 0.12, 0.0, release, gate);
+velocity = max(0.04, pow(gain, 0.74));
+cutoff = 700.0 + tone * 7600.0;
+
+body =
+  os.sawtooth(freq) * 0.12 +
+  os.osc(freq * 2.0) * (0.03 + tone * 0.06) +
+  os.osc(freq * (1.0 + detune * 0.02)) * (0.02 + detune * 0.08) +
+  no.noise * (0.001 + air * 0.012);
+
+voice = ((body : fi.lowpass(3, cutoff)) * env) * velocity;
+
+process = voice, voice;

frontend/index.html

@@ -321,8 +321,8 @@
                   <div>
                     <h3>MIDI I/O</h3>
                     <p class="section-copy">
-                      Connect browser MIDI, choose ports, and capture phrases
-                      from your keyboard.
+                      Connect browser MIDI, choose an input, and route playback
+                      to browser renderers or external synths.
                     </p>
                   </div>
                 </div>
@@ -341,9 +341,9 @@
                   </select>
                 </div>
                 <div class="field">
-                  <label for="midi-output-select">Playback Output</label>
+                  <label for="midi-output-select">Playback Renderer</label>
                   <select id="midi-output-select" disabled>
-                    <option>Browser Synth</option>
+                    <option>Browser Triangle</option>
                   </select>
                 </div>
                 <label class="toggle">
@@ -356,8 +356,8 @@
                     <dd id="selected-input-name">None</dd>
                   </div>
                   <div>
-                    <dt>Selected Output</dt>
-                    <dd id="selected-output-name">Browser Synth</dd>
+                    <dt>Selected Renderer</dt>
+                    <dd id="selected-output-name">Browser Triangle</dd>
                   </div>
                   <div>
                     <dt>Last MIDI Event</dt>
@@ -370,6 +370,163 @@
                 </dl>
               </section>
 
+              <section id="faust-renderer-panel" class="panel-section accent-section" hidden>
+                <div class="section-head">
+                  <div>
+                    <h3>Faust Renderer</h3>
+                    <p class="section-copy">
+                      Route playback through the built-in Clavier or compile
+                      your own polyphonic Faust instrument directly in the
+                      browser.
+                    </p>
+                  </div>
+                  <div id="faust-renderer-status" class="status-pill">Idle</div>
+                </div>
+                <div id="faust-clavier-panel">
+                  <div class="faust-control-grid">
+                    <div class="field faust-field">
+                      <div class="faust-label-row">
+                        <label for="faust-brightness-input">Brightness</label>
+                        <output id="faust-brightness-value" for="faust-brightness-input">0.58</output>
+                      </div>
+                      <input
+                        id="faust-brightness-input"
+                        type="range"
+                        min="0"
+                        max="1"
+                        step="0.01"
+                        value="0.58"
+                      />
+                    </div>
+                    <div class="field faust-field">
+                      <div class="faust-label-row">
+                        <label for="faust-hardness-input">Hardness</label>
+                        <output id="faust-hardness-value" for="faust-hardness-input">0.34</output>
+                      </div>
+                      <input
+                        id="faust-hardness-input"
+                        type="range"
+                        min="0"
+                        max="1"
+                        step="0.01"
+                        value="0.34"
+                      />
+                    </div>
+                    <div class="field faust-field">
+                      <div class="faust-label-row">
+                        <label for="faust-damping-input">Damping</label>
+                        <output id="faust-damping-value" for="faust-damping-input">0.42</output>
+                      </div>
+                      <input
+                        id="faust-damping-input"
+                        type="range"
+                        min="0"
+                        max="1"
+                        step="0.01"
+                        value="0.42"
+                      />
+                    </div>
+                    <div class="field faust-field">
+                      <div class="faust-label-row">
+                        <label for="faust-release-input">Release</label>
+                        <output id="faust-release-value" for="faust-release-input">0.95 s</output>
+                      </div>
+                      <input
+                        id="faust-release-input"
+                        type="range"
+                        min="0.08"
+                        max="4"
+                        step="0.01"
+                        value="0.95"
+                      />
+                    </div>
+                    <div class="field faust-field">
+                      <div class="faust-label-row">
+                        <label for="faust-body-input">Body</label>
+                        <output id="faust-body-value" for="faust-body-input">0.33</output>
+                      </div>
+                      <input
+                        id="faust-body-input"
+                        type="range"
+                        min="0"
+                        max="1"
+                        step="0.01"
+                        value="0.33"
+                      />
+                    </div>
+                    <div class="field faust-field">
+                      <div class="faust-label-row">
+                        <label for="faust-stereo-input">Stereo</label>
+                        <output id="faust-stereo-value" for="faust-stereo-input">0.45</output>
+                      </div>
+                      <input
+                        id="faust-stereo-input"
+                        type="range"
+                        min="0"
+                        max="1"
+                        step="0.01"
+                        value="0.45"
+                      />
+                    </div>
+                  </div>
+                </div>
+                <div id="faust-custom-panel" hidden>
+                  <div class="section-head faust-section-head">
+                    <div>
+                      <h4>Custom Faust</h4>
+                      <p class="section-copy">
+                        Paste a polyphonic Faust DSP with hidden
+                        <code>freq</code>, <code>gain</code>, and
+                        <code>gate</code> controls, then compile it locally.
+                      </p>
+                    </div>
+                    <div class="button-row faust-editor-actions">
+                      <button id="faust-custom-compile-button" type="button">
+                        Compile &amp; Use
+                      </button>
+                      <button
+                        id="faust-custom-reset-button"
+                        class="ghost"
+                        type="button"
+                      >
+                        Restore Starter
+                      </button>
+                    </div>
+                  </div>
+                  <div class="field faust-editor-field">
+                    <label for="faust-custom-code-input">DSP Source</label>
+                    <textarea
+                      id="faust-custom-code-input"
+                      class="faust-code-input"
+                      spellcheck="false"
+                      autocapitalize="off"
+                      autocomplete="off"
+                    ></textarea>
+                    <p id="faust-custom-dirty-state" class="field-hint">
+                      Edits stay local to this browser. Compile to turn the
+                      latest source into the active renderer.
+                    </p>
+                  </div>
+                  <div class="section-head faust-section-head">
+                    <div>
+                      <h4>Custom Parameters</h4>
+                      <p class="section-copy">
+                        Visible Faust controls appear here automatically after a
+                        successful compile.
+                      </p>
+                    </div>
+                  </div>
+                  <div id="faust-custom-controls" class="faust-control-grid"></div>
+                  <p id="faust-custom-controls-hint" class="field-hint">
+                    Compile a polyphonic instrument to expose its parameters.
+                  </p>
+                </div>
+                <p id="faust-renderer-hint" class="field-hint">
+                  Faust instruments are compiled locally in your browser the
+                  first time you use them.
+                </p>
+              </section>
+
               <section class="panel-section">
                 <div class="section-head">
                   <div>
@@ -382,6 +539,9 @@
                 </div>
                 <div class="button-row">
                   <button id="send-phrase-button">Send Phrase</button>
+                  <button id="generate-memory-button" class="ghost">
+                    Generate From Memory
+                  </button>
                   <button id="replay-generated-button" class="ghost">Replay Output</button>
                   <button id="clear-phrase-button" class="ghost">Clear</button>
                 </div>
@@ -486,6 +646,21 @@
                       <input id="transpose-toggle" type="checkbox" />
                       <span>Transpose incoming phrases before learning</span>
                     </label>
+                    <div class="field">
+                      <label for="markov-order-input">Markov order K</label>
+                      <input
+                        id="markov-order-input"
+                        type="number"
+                        min="1"
+                        max="16"
+                        step="1"
+                        value="4"
+                      />
+                      <p class="field-hint">
+                        Higher K follows longer contexts, but can hit dead ends
+                        sooner.
+                      </p>
+                    </div>
                     <div class="field">
                       <label for="decay-mode-select">Decay mode</label>
                       <select id="decay-mode-select">
@@ -536,6 +711,55 @@
                   </div>
                 </dl>
               </section>
+
+              <section class="panel-section accent-section">
+                <div class="section-head">
+                  <div>
+                    <h3>MIDI Import</h3>
+                    <p class="section-copy">
+                      Load existing MIDI files into the current Continuator
+                      session and use them as live memory.
+                    </p>
+                  </div>
+                </div>
+                <div class="button-row">
+                  <button
+                    id="import-midi-files-button"
+                    class="ghost"
+                    type="button"
+                  >
+                    Import MIDI Files
+                  </button>
+                  <button
+                    id="import-midi-folder-button"
+                    class="ghost"
+                    type="button"
+                  >
+                    Import MIDI Folder
+                  </button>
+                </div>
+                <p class="field-hint">
+                  Imported phrases are learned into the active session memory
+                  and logged like other learned inputs. Folder import works
+                  best in Chromium-based browsers.
+                </p>
+                <input
+                  id="midi-import-input"
+                  type="file"
+                  accept=".mid,.midi,audio/midi"
+                  multiple
+                  hidden
+                />
+                <input
+                  id="midi-folder-import-input"
+                  type="file"
+                  accept=".mid,.midi,audio/midi"
+                  multiple
+                  webkitdirectory
+                  directory
+                  hidden
+                />
+              </section>
             </div>
           </section>
 
@@ -640,6 +864,6 @@
       </section>
     </main>
 
-    <script type="module" src="/assets/app.js?v=20260423-readme-panel"></script>
+    <script type="module" src="/assets/app.js?v=20260423-faust-custom"></script>
   </body>
 </html>

frontend/styles.css

@@ -621,6 +621,11 @@ input[type="number"] {
   padding: 12px 14px;
 }
 
+input[type="range"] {
+  width: 100%;
+  accent-color: var(--accent);
+}
+
 input[type="number"]:disabled {
   opacity: 0.55;
 }
@@ -740,6 +745,68 @@ input[type="password"]:disabled {
   line-height: 1.45;
 }
 
+.faust-control-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 14px;
+  margin-bottom: 12px;
+}
+
+.faust-field {
+  margin-bottom: 0;
+  padding: 14px 16px;
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.04);
+  border: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.faust-label-row {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.faust-label-row output {
+  color: var(--secondary);
+  font-size: 0.82rem;
+  font-variant-numeric: tabular-nums;
+}
+
+.faust-section-head {
+  margin-top: 18px;
+}
+
+.faust-editor-actions {
+  margin-bottom: 0;
+  flex-wrap: wrap;
+}
+
+.faust-editor-field {
+  margin-bottom: 16px;
+}
+
+.faust-code-input {
+  width: 100%;
+  min-height: 260px;
+  padding: 16px;
+  border-radius: 18px;
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  background: rgba(7, 14, 20, 0.72);
+  color: var(--text);
+  font: 0.88rem/1.6 "SFMono-Regular", "Fira Code", "IBM Plex Mono", monospace;
+  resize: vertical;
+}
+
+.faust-code-input:focus {
+  outline: 1px solid rgba(109, 211, 206, 0.4);
+  border-color: rgba(109, 211, 206, 0.42);
+}
+
+.faust-code-input::selection {
+  background: rgba(244, 162, 97, 0.28);
+}
+
 .info-grid {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -1034,6 +1101,10 @@ input[type="password"]:disabled {
     grid-template-columns: 1fr;
   }
 
+  .faust-control-grid {
+    grid-template-columns: 1fr;
+  }
+
   .piano-roll {
     height: 206px;
   }

frontend/vendor/faustwasm/libfaust-wasm/libfaust-wasm.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8f904edbf2c2aa3297e5c5896ec0714ec1599f292cf508b46b24c5068976539
+size 2208439

frontend/vendor/faustwasm/libfaust-wasm/libfaust-wasm.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5322717e99bb1d3888c59297faf77a2c43bef85cf8081da57d1ebe0652312285
+size 3130696

package-lock.json

@@ -0,0 +1,32 @@
+{
+  "name": "continuator_front",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "@grame/faustwasm": "^0.16.1"
+      }
+    },
+    "node_modules/@grame/faustwasm": {
+      "version": "0.16.1",
+      "resolved": "https://registry.npmjs.org/@grame/faustwasm/-/faustwasm-0.16.1.tgz",
+      "integrity": "sha512-bc3AbJm4bPyS8ilvTnsbxjrFYqUO73uN5oatfMlJPsSvdzx/50q5ViMilmGdNV/Xrf7pbNdwu8Wka5ZwOraxwA==",
+      "license": "LGPL-3.0",
+      "dependencies": {
+        "@types/emscripten": "^1.39.10"
+      },
+      "bin": {
+        "faust2sndfile-ts": "scripts/faust2sndfile.js",
+        "faust2svg-ts": "scripts/faust2svg.js",
+        "faust2wasm-ts": "scripts/faust2wasm.js"
+      }
+    },
+    "node_modules/@types/emscripten": {
+      "version": "1.41.5",
+      "resolved": "https://registry.npmjs.org/@types/emscripten/-/emscripten-1.41.5.tgz",
+      "integrity": "sha512-cMQm7pxu6BxtHyqJ7mQZ2kXWV5SLmugybFdHCBbJ5eHzOo6VhBckEgAT3//rP5FwPHNPeEiq4SmQ5ucBwsOo4Q==",
+      "license": "MIT"
+    }
+  }
+}

package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "@grame/faustwasm": "^0.16.1"
+  }
+}