@m4l-jweb/build 0.9.5 → 1.0.0

package/README.md

@@ -0,0 +1,42 @@
+# @m4l-jweb/build
+
+The CLI. It reads a device manifest and writes finished, installable `.amxd` files - generating the Max patcher, compiling the `[js]` wrapper, and freezing your UI bundle inside the device. No Max editor is opened at any point.
+
+Part of **[m4l-jweb](https://github.com/alienmind/m4l-jweb)** - build Ableton Live devices (`.amxd`) from a TypeScript repo: React UI, LiveAPI glue, CI builds, no Max editor.
+
+## Install
+
+```bash
+pnpm add @m4l-jweb/build
+```
+
+## Usage
+
+```bash
+# in a device repo
+pnpm m4l-jweb build       # patchers + wrapper + .amxd, end to end
+pnpm m4l-jweb patchers    # just regenerate the patcher JSON
+pnpm m4l-jweb wrapper     # just recompile the [js] wrapper
+pnpm m4l-jweb install     # copy the built devices into your User Library
+pnpm m4l-jweb init        # scaffold a new device repo
+```
+
+## Notes
+
+- Devices are declared as data in `patcher/devices.mjs` - a name, a `type` (`midi` / `audio` / `instrument`), and a list of **chains**. Patch cords become code review.
+- Chains are small functions that each claim a stage of the signal or message path: `webaudio` (the page's own audio, via `[jweb~]`), `midiin`, `midiout`, `lowpass`, `gain`, `download`, `remote`, and your own in `patcher/chains.mjs`.
+- The generated patcher is checked before it is written - duplicate box ids and unrouted selectors fail the build rather than producing a device that loads and silently does nothing.
+
+## Requirements
+
+Ableton Live 12 with Max 9. Devices are built on `[jweb~]`, the browser view with signal outlets; older hosts are unverified.
+
+## Links
+
+- [Repository and full README](https://github.com/alienmind/m4l-jweb)
+- [Architecture](https://github.com/alienmind/m4l-jweb/blob/main/doc/ARCHITECTURE.md)
+- [What Max actually does: the measured facts](https://github.com/alienmind/m4l-jweb/blob/main/doc/MAX-FACTS.md)
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m4l-jweb/build",
-  "version": "0.9.5",
+  "version": "1.0.0",
   "description": "m4l-jweb: the CLI that builds and packages a device repo into installable Max for Live devices.",
   "type": "module",
   "license": "MIT",
@@ -34,6 +34,6 @@
     "archiver": "^7.0.1",
     "esbuild": "^0.25.0",
     "typescript": "^5.7.0",
-    "@m4l-jweb/wrapper": "0.9.5"
+    "@m4l-jweb/wrapper": "1.0.0"
   }
 }

package/src/chains.mjs

@@ -82,7 +82,7 @@ export function removeLine(lines, srcId, dstId) {
  * and fatal in Live - it is the bang every LiveAPI observer is created from.
  */
 export function claimAppMessages(ctx, routeId, unmatchedOutlet) {
-  const [srcId, srcOutlet] = ctx.appOut ?? [ctx.jwebId, 0];
+  const [srcId, srcOutlet] = ctx.appOut ?? [ctx.jwebId, 2];
 
   // Nobody has claimed the stream yet, and yet [jweb] no longer reaches the
   // wrapper: a chain cut that cord by hand (the old `removeLine(jwebId,
@@ -748,435 +748,7 @@ function downloadChain(ctx) {
   lines.push(line("obj-prepend-maxurl-progress", 0, unmatchedId, 0));
 }
 
-/**
- * "renderplay" - double-buffered, transport-locked loop playback of a rendered WAV pair.
- *
- * This is the Max half of the SUPERDOUGH Rendering design (m4l-strudel
- * doc/IDEA-STRUDEL-INSTRUMENT.md, section D.3). The app renders a Strudel pattern to a
- * WAV, `saveToFile`s it next to the device, then:
- *
- *   app -> render_load <slot> <path> <lengthBeats>  -> [js] resolves path
- *                                                    -> render_replace -> [buffer~ <name>]
- *          render_arm <slot>                         -> swap playback to it at the boundary
- *          render_stop                               -> fade out
- *   app <- render_ready <slot>                       when the WAV finished loading
- *
- * TRANSPORT LOCK - the mechanism, and why THIS one. The design names `phasor~ @lock` as
- * the first idea and flags it UNVERIFIED, because an arbitrary loop length (7 beats, say)
- * does not spell as a note value and the tempo math is fragile. This implements the
- * design's fallback instead: both slots play through [groove~ @loop 1] (the same player
- * the `samples` chain proves), and a control-rate boundary detector HARD RE-SYNCS both
- * grooves to position 0 at every loop boundary. The boundary is read straight off the
- * host transport - [plugsync~] outlet 6 is song position in beats (a signal; the
- * m4l-strudel engine already samples it via [snapshot~]) - so `floor(beats / lengthBeats)`
- * increments exactly once per loop, and [change] turns each increment into the re-sync
- * bang. No tempo arithmetic, no note-value spelling: the loop is pinned to the transport
- * by restarting it on the transport's own beat count. Drift between re-syncs is at most
- * one control tick (~10 ms) and is hidden under the crossfade, which is the fallback's
- * whole point.
- *
- * CROSSFADE, NOT GATING. Both grooves always play, phase-aligned by the shared re-sync;
- * only the [line~] gains move. `render_arm <slot>` stores the target slot; at the next
- * boundary the stored index is read out and each slot's gain ramps to (armed==slot) over
- * 15 ms. So the swap always lands on a loop boundary and a half-faded old loop is never
- * heard mid-cycle.
- *
- * ORIGINATES SOUND, like `samples`: it SUMS into the signal path ([+~]) rather than
- * claiming a stage, and the buffer names are instance-scoped (`deviceBufName`).
- *
- * OPEN (S3, verified in Live, not here): the exact re-sync timing and the equal-power
- * curve of the crossfade are tuning knobs to confirm by ear on real transport; and the
- * first loop before the first boundary bang plays at the initial gains (slot 0 up), so a
- * device should `render_arm` slot 0 once at start. See doc/TEST-CHAIN-RENDERPLAY.md.
- */
-function renderplayChain(ctx) {
-  const { boxes, lines, device, jwebId, unmatchedId } = ctx;
-  const slots = device?.renderSlots;
-  if (!Array.isArray(slots) || slots.length !== 2) {
-    throw new Error(
-      `the "renderplay" chain needs exactly two renderSlots on device "${device?.name}", got ${JSON.stringify(slots)}. ` +
-        `It is double-buffered by design: one slot loops while the other loads the next render.`,
-    );
-  }
-  const bufName = (slot) => deviceBufName(device, slot);
-  const slotList = slots.join(" ");
 
-  // App stream: claim render_arm / render_stop / render_sync here; render_load falls through
-  // the last outlet to the wrapper (it needs the path resolved, like `samples`' buffer_load).
-  // render_sync <slot> <positionMs> relocates a slot's groove to a transport phase; it is
-  // appended last so render_arm/render_stop keep their outlet indices.
-  boxes.push(box("obj-render-route", "route render_arm render_stop render_sync", { numoutlets: 4, outlettype: ["", "", "", ""] }));
-  claimAppMessages(ctx, "obj-render-route", 3);
-
-  // The wrapper resolves the path and hands the load back on its AUX outlet as
-  // `render_replace <slot> <absPath>` - one symbol, so Live-library spaces survive.
-  boxes.push(box("obj-render-replaceroute", "route render_replace", { numoutlets: 2, outlettype: ["", ""] }));
-  lines.push(line(unmatchedId, 1, "obj-render-replaceroute", 0));
-
-  // route strips the selector, so the slot name is the first word now: dispatch per slot.
-  const slotOutlets = { numoutlets: slots.length + 1, outlettype: slots.map(() => "").concat("") };
-  boxes.push(box("obj-render-loadslot", `route ${slotList}`, slotOutlets));
-  lines.push(line("obj-render-replaceroute", 0, "obj-render-loadslot", 0));
-
-  // Boundary clock: the MASTER groove's OWN loop, not the host transport. [plugsync~]
-  // outlet 6 (song-position-in-beats) was measured stuck at 0 while the transport played
-  // (its outlet semantics differ by host), so timing the loop off it left the whole device
-  // silent. groove~'s LAST outlet is a 0..1 sync ramp of loop position, and the groove is
-  // the one thing we confirmed is running - so it is the reliable clock. `[<~ 0.5]` turns
-  // the ramp into a once-per-loop square (1 in the first half, 0 in the second), and
-  // `[edge~]` bangs on its rising edge - which happens right as the ramp wraps to 0, i.e.
-  // at the loop boundary. Slot 0 is the master; both slots share the loop length.
-  // (Transport-BAR alignment is deferred: the loop is self-clocked, not pinned to Live's
-  // bar. Revisit once a host beat source that actually advances is found - S3 open item.)
-  boxes.push(box("obj-render-syncgate", "<~ 0.5", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-  boxes.push(box("obj-render-syncedge", "edge~", { numinlets: 1, numoutlets: 2, outlettype: ["bang", "bang"] }));
-  boxes.push(box("obj-render-boundary", "t b b", { numinlets: 1, numoutlets: 2, outlettype: ["bang", "bang"] }));
-  lines.push(line(`obj-render-groove-${slots[0]}`, 2, "obj-render-syncgate", 0)); // master sync ramp
-  lines.push(line("obj-render-syncgate", 0, "obj-render-syncedge", 0));
-  lines.push(line("obj-render-syncedge", 0, "obj-render-boundary", 0)); // outlet 0 = rising edge = loop wrap
-
-  // A boundary applies the gains only when a swap is PENDING - the first boundary after an
-  // arm (and the first after load). [gate 1 1] starts OPEN so slot 0 fades up on load; the
-  // boundary passes its bang through, then CLOSES the gate. So a held selection is not
-  // re-ramped every loop - that per-loop re-trigger was the audible tick, and it also fought
-  // render_stop (the next boundary kept re-raising the gain the stop had just faded out).
-  // An arm re-opens the gate for exactly one boundary; stop closes it and ramps to silence.
-  // [t b b] fires right-to-left: the bang goes THROUGH the gate (right) before the gate is
-  // closed behind it (left).
-  boxes.push(box("obj-render-pending", "gate 1 1", { numinlets: 2, numoutlets: 1, outlettype: ["bang"] }));
-  boxes.push(box("obj-render-pendclose", "0", { maxclass: "message", numinlets: 2, numoutlets: 1 }));
-  lines.push(line("obj-render-boundary", 1, "obj-render-pending", 1)); // right, first: bang through the gate
-  lines.push(line("obj-render-boundary", 0, "obj-render-pendclose", 0)); // left, then: close behind it
-  lines.push(line("obj-render-pendclose", 0, "obj-render-pending", 0));
-  lines.push(line("obj-render-pending", 0, "obj-render-armed", 0)); // gated bang -> read armed -> gains
-
-  // Armed slot index (0/1): stored cold by an arm, read out by a pending boundary.
-  boxes.push(box("obj-render-armed", "i 0", { numinlets: 2, numoutlets: 1, outlettype: ["int"] }));
-  boxes.push(box("obj-render-armslot", `route ${slotList}`, slotOutlets));
-  lines.push(line("obj-render-route", 0, "obj-render-armslot", 0)); // render_arm <slot>
-
-  // render_sync <slot> <positionMs>: strip the slot, drop <positionMs> into that slot's
-  // groove~ left inlet as a float = a playback position in ms (per slot, in the forEach
-  // below). The conductor sends this on (re)start / relocate to pin the loop to Live's exact
-  // transport phase; then rate-1 @loop HOLDS the lock (shared clock, no per-loop re-sync).
-  // The self-clocked boundary above is only the transport-STOPPED fallback - a sync just
-  // moves the play head, it does not fight the loop. See doc/TEST-CHAIN-RENDERPLAY.md.
-  boxes.push(box("obj-render-syncslot", `route ${slotList}`, slotOutlets));
-  lines.push(line("obj-render-route", 2, "obj-render-syncslot", 0)); // render_sync <slot> <positionMs>
-
-  // An arm re-opens the pending gate (for the next boundary to apply the swap); a stop
-  // closes it (so no boundary re-raises the gain the stop is fading out).
-  boxes.push(box("obj-render-pendopen", "1", { maxclass: "message", numinlets: 2, numoutlets: 1 }));
-  lines.push(line("obj-render-route", 0, "obj-render-pendopen", 0)); // any render_arm
-  lines.push(line("obj-render-pendopen", 0, "obj-render-pending", 0));
-  lines.push(line("obj-render-route", 1, "obj-render-pendclose", 0)); // render_stop also closes it
-
-  // Arm stores the target index only (below); the grooves start when their WAV LOADS (so
-  // an arm never restarts a playing groove and clicks), and the crossfade gains move at the
-  // BOUNDARY, so a swap lands on the loop boundary rather than the instant you click. That
-  // makes the transport meaningful: with it stopped there are no boundaries, so nothing
-  // becomes audible; start it and the armed slot fades up at the next boundary.
-
-  // Summing buses, per channel: (slotA*gainA) + (slotB*gainB), then + the device input.
-  boxes.push(box("obj-render-sumslots-l", "+~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-  boxes.push(box("obj-render-sumslots-r", "+~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-
-  slots.forEach((slot, i) => {
-    const buf = `obj-render-buf-${slot}`;
-    const groove = `obj-render-groove-${slot}`;
-
-    // buffer~: outlet 1 bangs when a read completes. replace, then report render_ready.
-    boxes.push(box(buf, `buffer~ ${bufName(slot)}`, { numinlets: 1, numoutlets: 2, outlettype: ["float", "bang"] }));
-    boxes.push(box(`obj-render-replace-${slot}`, "prepend replace"));
-    lines.push(line("obj-render-loadslot", i, `obj-render-replace-${slot}`, 0));
-    lines.push(line(`obj-render-replace-${slot}`, 0, buf, 0));
-    boxes.push(box(`obj-render-ready-${slot}`, `prepend render_ready ${slot}`));
-    lines.push(line(buf, 1, `obj-render-ready-${slot}`, 0));
-    lines.push(line(`obj-render-ready-${slot}`, 0, jwebId, 0));
-    // Start this groove looping the moment its WAV has loaded (buffer~ read-complete bang).
-    // It free-runs from here via @loop 1; the gain stays 0 until a boundary raises it.
-    lines.push(line(buf, 1, `obj-render-resync-${slot}`, 0));
-
-    // Player: [groove~ <buf> 2 @loop 1] at rate 1 (the WAV's own tempo; a tempo change is
-    // a full re-render, so rate stays 1). Two signal outlets = L/R.
-    boxes.push(box(`obj-render-rate-${slot}`, "sig~ 1.", { numinlets: 1, numoutlets: 1, outlettype: ["signal"] }));
-    boxes.push(box(groove, `groove~ ${bufName(slot)} 2 @loop 1`, { numinlets: 3, numoutlets: 3, outlettype: ["signal", "signal", "signal"] }));
-    lines.push(line(`obj-render-rate-${slot}`, 0, groove, 0));
-
-    // Start message: a bare `0` (a start position in ms) into groove~'s left inlet starts
-    // the loop from the top. Banged once, from the buffer read-complete above.
-    boxes.push(box(`obj-render-resync-${slot}`, "0", { maxclass: "message", numinlets: 2, numoutlets: 1 }));
-    lines.push(line(`obj-render-resync-${slot}`, 0, groove, 0));
-
-    // render_sync target: a float position (ms) from obj-render-syncslot relocates THIS
-    // groove's play head to the transport phase. Same inlet, same semantics as the resync 0.
-    lines.push(line("obj-render-syncslot", i, groove, 0));
-
-    // Gain: this slot's target = (armed == i). At the boundary the armed index is read
-    // out, [== i] gives 0/1, [pack <v> 50] makes the `<target> 50ms` list for [line~] - a
-    // short equal-ish crossfade at the boundary.
-    boxes.push(box(`obj-render-istarget-${slot}`, `expr $i1 == ${i}`, { numinlets: 1, numoutlets: 1, outlettype: ["int"] }));
-    boxes.push(box(`obj-render-gainpack-${slot}`, "pack 0. 400", { numinlets: 2, numoutlets: 1, outlettype: [""] }));
-    boxes.push(box(`obj-render-gain-${slot}`, "line~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-    lines.push(line("obj-render-armed", 0, `obj-render-istarget-${slot}`, 0));
-    lines.push(line(`obj-render-istarget-${slot}`, 0, `obj-render-gainpack-${slot}`, 0));
-    lines.push(line(`obj-render-gainpack-${slot}`, 0, `obj-render-gain-${slot}`, 0));
-
-    // render_stop: ramp this slot's gain to 0 over 500 ms - a clearly audible fade. The
-    // pending gate (closed by stop) keeps the next boundary from re-raising it.
-    boxes.push(box(`obj-render-stopgain-${slot}`, "0. 500", { maxclass: "message", numinlets: 2, numoutlets: 1 }));
-    lines.push(line("obj-render-route", 1, `obj-render-stopgain-${slot}`, 0));
-    lines.push(line(`obj-render-stopgain-${slot}`, 0, `obj-render-gain-${slot}`, 0));
-
-    // Apply the gain to each channel, then sum into the per-channel bus.
-    const mulL = `obj-render-mul-l-${slot}`;
-    const mulR = `obj-render-mul-r-${slot}`;
-    boxes.push(box(mulL, "*~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-    boxes.push(box(mulR, "*~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-    lines.push(line(groove, 0, mulL, 0));
-    lines.push(line(groove, 1, mulR, 0));
-    lines.push(line(`obj-render-gain-${slot}`, 0, mulL, 1));
-    lines.push(line(`obj-render-gain-${slot}`, 0, mulR, 1));
-    lines.push(line(mulL, 0, "obj-render-sumslots-l", i));
-    lines.push(line(mulR, 0, "obj-render-sumslots-r", i));
-
-    // Arm: store this slot's index (cold) in [i]. That is ALL an arm does - it queues the
-    // target. The next transport boundary reads it out and fades the gains, so the swap
-    // lands on the loop boundary, not the instant you click. lengthBeats rode in on
-    // render_load and reaches the boundary detector's cold inlet via render_len below.
-    boxes.push(box(`obj-render-armidx-${slot}`, `${i}`, { maxclass: "message", numinlets: 2, numoutlets: 1 }));
-    lines.push(line("obj-render-armslot", i, `obj-render-armidx-${slot}`, 0));
-    lines.push(line(`obj-render-armidx-${slot}`, 0, "obj-render-armed", 1)); // cold store, no output
-  });
-
-  // render_len still arrives from the wrapper (it carries lengthBeats alongside the path)
-  // but the self-clocked boundary no longer needs it: a [route render_len] swallows it so
-  // it does not fall through to the wrapper as an unknown message. (Kept for when
-  // transport-bar alignment returns and wants the loop length again.)
-  boxes.push(box("obj-render-lenroute", "route render_len", { numoutlets: 2, outlettype: ["", ""] }));
-  lines.push(line(unmatchedId, 1, "obj-render-lenroute", 0));
-
-  // Sum the two per-channel buses onto the device's signal path and become its tail.
-  for (const [ch, sumId] of [
-    [0, "obj-render-sumslots-l"],
-    [1, "obj-render-sumslots-r"],
-  ]) {
-    const [srcId, srcOut] = ctx.audioIn(ch);
-    const outId = `obj-render-out-${ch}`;
-    boxes.push(box(outId, "+~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-    lines.push(line(srcId, srcOut, outId, 0)); // the device input (silence on an instrument)
-    lines.push(line(sumId, 0, outId, 1)); // the rendered mix
-    ctx.setAudioOut(ch, outId, 0);
-  }
-
-  // KNOWN MINOR ARTIFACT (S3): a faint tick at the loop wrap, from [groove~]'s loop-point
-  // interpolation. The WAV loops seamlessly (whole-cycle sine, matched value AND slope at
-  // the seam) and the gains are no longer re-triggered per loop, so this is groove~ itself
-  // reading across the boundary. It is worst on a pure sine (the hardest case for loop
-  // clicks) and is typically inaudible on real rendered content. Proper declick, if ever
-  // needed on real material: drive playback from a [phasor~] into [play~]/[wave~], or bake a
-  // few-ms equal-power loop crossfade into the render. Deferred - not worth it on a tone.
-}
-
-/**
- * "samples" - the first chain that ORIGINATES a sound: a named [buffer~] per slot,
- * loaded from a file on disk, played back through [groove~] into the signal path.
- *
- *   app -> buffer_load <slot> <path>  -> [js] (resolves the path)
- *                                     -> buffer_replace -> [buffer~ <name>]
- *          buffer_play <slot>         -> [groove~] set + play
- *          buffer_stop                -> [groove~] stop
- *   app <- buffer_ready <slot> <sr> <ms> <chans>   when the read actually completed
- *          buffer_error <slot> <msg>                when there was no file to read
- *
- * THE BYTES NEVER CROSS THE BRIDGE. [buffer~] reads the file itself; what travels in
- * Max messages is a path and, coming back, a description of what landed - the same
- * rule the `download` chain follows, which is how you get the file there in the
- * first place.
- *
- * WAV/AIFF/Next-Sun ONLY. [buffer~]'s `read`/`replace` does not take MP3 - that list
- * (MP3, OGG, FLAC, M4A) is [sfplay~]'s, which streams from disk rather than filling a
- * buffer, and is therefore a different chain. A format it cannot read is an error in
- * the Max console and NO bang, so the app's promise times out rather than lying.
- *
- * WHAT LOADED IS NOT WHAT YOU ASKED FOR, so the chain reports what it GOT. `replace`
- * resizes the buffer and adopts the FILE's channel count and sample rate, so a slot
- * is not mono because you wanted it to be. [info~] is banged from the buffer's own
- * "read completed" outlet (outlet 1 - outlet 0 is a mouse position in the editing
- * window) and reports sample rate, duration and channels; the app derives frames from
- * those. A frame count on its own is not proof of a read: a failed `replace` leaves
- * the PREVIOUS contents in place, so "there are samples in there" says nothing. The
- * bang does - it only fires when a read completed - and until it does the app's
- * promise is still open (see loadSample() in @m4l-jweb/bridge, which is where the
- * timeout lives).
- *
- * info~'s outlets fire right-to-left, so the LAST one to arrive is outlet 0, the
- * sample rate - which is therefore the one wired to [pack]'s hot inlet. Wire it the
- * other way round and the message goes out carrying the PREVIOUS load's numbers.
- *
- * ONE VOICE, DELIBERATELY. `groove~` takes `set <buffer-name>` to switch buffers, so
- * one stereo player covers N slots: this is a PREVIEW - the sample browser's "let me
- * hear it, through the track" - not a sampler. Polyphony is the `instrument` chain,
- * and it is still open (doc/TODO.md item 2).
- *
- * It SUMS into the signal path rather than claiming it ([+~]), because it makes sound
- * of its own: on an audio effect the preview plays over the track's audio, and on an
- * instrument there is nothing at the input to add.
- *
- * The buffer names are INSTANCE-SCOPED (`deviceBufName`, `---buf-<device>-<slot>`), so
- * two copies of this device on two tracks own separate buffers. They used to be global
- * to Max and generated from the device name alone, which meant the second copy loaded
- * silently stole the first's samples.
- *
- * Slots default to one, named "preview". `slots: ["kick", "snare"]` in the manifest
- * gives you more.
- */
-function samplesChain(ctx) {
-  const { boxes, lines, device, jwebId, unmatchedId } = ctx;
-  const slots = device?.slots ?? ["preview"];
-  // Instance-scoped, for the same reason the instrument's are: two copies of a preview
-  // device on two tracks are two devices, and a global name would hand both the same
-  // buffer. `---` expands per device instance in Live - see deviceBufName.
-  const bufName = (slot) => deviceBufName(device, slot);
-
-  // `buffer_load` is NOT claimed from [jweb]. It goes on to the wrapper, which
-  // resolves the path and hands it back on its AUX OUTLET as `buffer_replace <slot>
-  // <abs path>` - the same shape the `download` chain takes `maxurl` in.
-  //
-  // The detour is the whole fix. The app writes a path relative to the device's
-  // folder (that is where fetchToFile puts the file), and [buffer~] does not resolve
-  // it that way: a bare name is looked up in MAX'S SEARCH PATH, which the device's
-  // folder is not in, so a file that was downloaded correctly reports "can't open".
-  // The resolved path then contains SPACES on a normal Live install ("Ableton
-  // Library"), and a path travelling through the patcher as message text would split
-  // there into atoms. Out of [js] it stays one symbol.
-  boxes.push(box("obj-samples-route", "route buffer_play buffer_stop", { numoutlets: 3, outlettype: ["", "", ""] }));
-  claimAppMessages(ctx, "obj-samples-route", 2);
-
-  boxes.push(box("obj-samples-replaceroute", "route buffer_replace", { numoutlets: 2, outlettype: ["", ""] }));
-  lines.push(line(unmatchedId, 1, "obj-samples-replaceroute", 0));
-
-  // `route` strips the selector, so the slot name is now the first word of both
-  // remaining messages: a second route per stream dispatches on it.
-  const slotList = slots.join(" ");
-  const slotOutlets = { numoutlets: slots.length + 1, outlettype: slots.map(() => "").concat("") };
-  boxes.push(box("obj-samples-loadslot", `route ${slotList}`, slotOutlets));
-  boxes.push(box("obj-samples-playslot", `route ${slotList}`, slotOutlets));
-  lines.push(line("obj-samples-replaceroute", 0, "obj-samples-loadslot", 0));
-  lines.push(line("obj-samples-route", 0, "obj-samples-playslot", 0));
-
-  // The player. `groove~ <buffer> 2` = two signal outlets (plus a loop-sync outlet),
-  // and it MIXES a buffer with more channels down rather than dropping them.
-  // @loop 0 makes it a one-shot: a preview that loops forever is a preview you have
-  // to fight. [sig~ 1.] is the playback rate, in the left inlet, which is a SIGNAL
-  // inlet - a float there means something else entirely (a position, in ms).
-  boxes.push(box("obj-samples-rate", "sig~ 1.", { numinlets: 1, numoutlets: 1, outlettype: ["signal"] }));
-  boxes.push(
-    box("obj-samples-groove", `groove~ ${bufName(slots[0])} 2 @loop 0`, {
-      numinlets: 3,
-      numoutlets: 3,
-      outlettype: ["signal", "signal", "signal"],
-    }),
-  );
-  lines.push(line("obj-samples-rate", 0, "obj-samples-groove", 0));
-
-  // MONO FOLD. `groove~ <buf> 2` hard-wires two signal outlets to L and R, and a
-  // MONO buffer drives outlet 0 ONLY - so a mono file (most of tidal-drum-machines
-  // is mono) plays in one ear. The channel count is not a build-time fact: [info~]
-  // MEASURES it when the buffer loads. So gate the R channel at RUNTIME - a
-  // [selector~ 2] whose control says which groove~ outlet is the real right channel:
-  //   input 1 = groove~ outlet 1 (a stereo file's true R)
-  //   input 2 = groove~ outlet 0 (fold the mono signal to R as well)
-  // The control is the currently-loaded slot's channel count run through
-  // [expr ($i1==1)+1]: mono(1) -> 2 (fold), stereo(2) -> 1 (real R). The L channel
-  // always takes groove~ outlet 0, so it needs no gate.
-  boxes.push(box("obj-samples-rsel", "selector~ 2", { numinlets: 3, numoutlets: 1, outlettype: ["signal"] }));
-  boxes.push(box("obj-samples-rgate", "expr ($i1==1)+1", { numinlets: 1, numoutlets: 1, outlettype: ["int"] }));
-  lines.push(line("obj-samples-groove", 1, "obj-samples-rsel", 1)); // stereo R -> input 1
-  lines.push(line("obj-samples-groove", 0, "obj-samples-rsel", 2)); // mono fold -> input 2
-  lines.push(line("obj-samples-rgate", 0, "obj-samples-rsel", 0)); // which one, per loaded slot
-
-  // Stop: a bare `buffer_stop` arrives from [route] as a BANG - the word is gone -
-  // so re-materialize it in a message box, or groove~ hears nothing it knows.
-  boxes.push(box("obj-samples-stopmsg", "stop", { maxclass: "message", numinlets: 2, numoutlets: 1 }));
-  lines.push(line("obj-samples-route", 1, "obj-samples-stopmsg", 0));
-  lines.push(line("obj-samples-stopmsg", 0, "obj-samples-groove", 0));
-
-  slots.forEach((slot, i) => {
-    const buf = `obj-samples-buf-${slot}`;
-    const info = `obj-samples-info-${slot}`;
-
-    // buffer~: outlet 0 is a mouse position, outlet 1 is the bang on a completed
-    // read. Only the second one means anything here.
-    boxes.push(box(buf, `buffer~ ${bufName(slot)}`, { numinlets: 1, numoutlets: 2, outlettype: ["float", "bang"] }));
-    boxes.push(box(`obj-samples-replace-${slot}`, "prepend replace"));
-    lines.push(line("obj-samples-loadslot", i, `obj-samples-replace-${slot}`, 0));
-    lines.push(line(`obj-samples-replace-${slot}`, 0, buf, 0));
-
-    // What actually landed. info~'s outlets: 0 = sample rate, 6 = duration in ms,
-    // 8 = number of channels (per its reference page - do not count them from
-    // memory). They fire right-to-left, so 0 arrives last and is the hot one.
-    boxes.push(
-      box(info, `info~ ${bufName(slot)}`, {
-        numinlets: 1,
-        numoutlets: 10,
-        outlettype: ["float", "list", "float", "float", "float", "float", "float", "", "int", ""],
-      }),
-    );
-    boxes.push(box(`obj-samples-pack-${slot}`, "pack 0. 0. 0", { numinlets: 3, numoutlets: 1, outlettype: [""] }));
-    boxes.push(box(`obj-samples-ready-${slot}`, `prepend buffer_ready ${slot}`));
-
-    lines.push(line(buf, 1, info, 0)); // the read completed - ask what it was
-    lines.push(line(info, 8, `obj-samples-pack-${slot}`, 2)); // channels (fires first)
-    lines.push(line(info, 6, `obj-samples-pack-${slot}`, 1)); // duration, ms
-    lines.push(line(info, 0, `obj-samples-pack-${slot}`, 0)); // sample rate - hot, last
-    lines.push(line(`obj-samples-pack-${slot}`, 0, `obj-samples-ready-${slot}`, 0));
-    lines.push(line(`obj-samples-ready-${slot}`, 0, jwebId, 0));
-
-    // Retain THIS slot's measured channel count, so play can re-assert the mono
-    // fold for whichever buffer is loaded into the one shared groove~. [info~]
-    // outlet 8 stores it in [f]'s cold inlet (no output); the play trigger bangs it
-    // out to the shared gate below. Every slot's [f] feeds that one gate.
-    boxes.push(box(`obj-samples-chans-${slot}`, "f", { numinlets: 2, numoutlets: 1, outlettype: [""] }));
-    lines.push(line(info, 8, `obj-samples-chans-${slot}`, 1)); // measured channels, cold-stored
-    lines.push(line(`obj-samples-chans-${slot}`, 0, "obj-samples-rgate", 0));
-
-    // Play: pick the buffer, THEN start it. Two cords out of one outlet fire in an
-    // order Max chooses, so the sequence goes through a [t b b] - right outlet
-    // first - and never through a fan-out. Starting the OLD buffer and then
-    // switching is exactly the bug that looks like "the wrong sample previewed".
-    boxes.push(box(`obj-samples-trig-${slot}`, "t b b b", { numinlets: 1, numoutlets: 3, outlettype: ["bang", "bang", "bang"] }));
-    boxes.push(box(`obj-samples-set-${slot}`, `set ${bufName(slot)}`, { maxclass: "message", numinlets: 2, numoutlets: 1 }));
-    // A float in groove~'s left inlet is a playback POSITION in ms, and 0 is "from
-    // the beginning" - which is also what starts it after a `stop`.
-    boxes.push(box(`obj-samples-start-${slot}`, "0", { maxclass: "message", numinlets: 2, numoutlets: 1 }));
-
-    // [t] fires right-to-left, so: set the fold gate, THEN the buffer, THEN start -
-    // the gate and the buffer are both in place before groove~ makes a sound.
-    lines.push(line("obj-samples-playslot", i, `obj-samples-trig-${slot}`, 0));
-    lines.push(line(`obj-samples-trig-${slot}`, 2, `obj-samples-chans-${slot}`, 0)); // first: assert the fold
-    lines.push(line(`obj-samples-trig-${slot}`, 1, `obj-samples-set-${slot}`, 0)); // then: set the buffer
-    lines.push(line(`obj-samples-trig-${slot}`, 0, `obj-samples-start-${slot}`, 0)); // ...then play it
-    lines.push(line(`obj-samples-set-${slot}`, 0, "obj-samples-groove", 0));
-    lines.push(line(`obj-samples-start-${slot}`, 0, "obj-samples-groove", 0));
-  });
-
-  // Sum into the signal path: this chain MAKES sound, it does not process what came
-  // before. Claiming the stage instead would silence the track the preview plays over.
-  for (const [ch, id] of [
-    [0, "obj-samples-mix-l"],
-    [1, "obj-samples-mix-r"],
-  ]) {
-    const [srcId, srcOut] = ctx.audioIn(ch);
-    boxes.push(box(id, "+~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-    lines.push(line(srcId, srcOut, id, 0));
-    // L takes groove~ outlet 0 directly; R takes the mono-fold [selector~] instead
-    // of groove~ outlet 1, so a mono buffer reaches both ears.
-    if (ch === 0) lines.push(line("obj-samples-groove", 0, id, 1));
-    else lines.push(line("obj-samples-rsel", 0, id, 1));
-    ctx.setAudioOut(ch, id, 0);
-  }
-}
 
 /**
  * "delay" - a feedback delay, sent from a dry/wet knob: `.delay()`, `.delaytime()`
@@ -1308,244 +880,32 @@ function reverbChain(ctx) {
   }
 }
 
-/**
- * The [poly~] voice patch: ONE played note, start to finish, as its own patcher.
- *
- * [poly~] loads N copies of this and hands each `note` message to the first voice
- * whose [thispoly~] is not busy - so polyphony and voice-stealing are Max's job, not
- * the app's, which is the whole reason to spend a [poly~] rather than run N groove~s
- * and a scheduler by hand. Max cannot embed this inline (no factory device does; they
- * all ship it as a named .maxpat), so the build freezes it into the .amxd as a
- * dependency and [poly~] resolves it by name from the device's own bundle - the same
- * way `Analogue Drums.amxd` carries `analog.Kick~.maxpat` (checked on disk).
- *
- * MULTI-SAMPLE. A voice can play ANY of the device's slots - one named [buffer~] per
- * slot - so the instrument is a keymap, not one repitched sample. The voice request at
- * [in 1] is the list `slot rate velocity durMs channels`:
- *   - slot       -> which buffer: [sel 0 1 ...] picks the matching `set <bufName>`
- *                   message, so groove~ switches to that slot's buffer before it starts.
- *   - rate       -> playback RATE straight into [sig~] -> groove~'s left (signal) inlet.
- *                   EXPLICIT, not derived: the app decides whether a note plays a
- *                   dedicated sample at rate 1 or a repitched one at rate 2, which is
- *                   what makes this a multi-sample keymap rather than one stretched
- *                   buffer. No pitch->rate arithmetic here.
- *   - velocity   -> amplitude, /127, on both channels' [*~].
- *   - durMs      -> when to FREE the voice: [delay durMs] -> 0 to [thispoly~] and
- *                   `stop` to groove~. The app times the note; Max holds the voice
- *                   exactly that long. A one-shot past the sample's end is silent
- *                   anyway (@loop 0), so this only bounds the allocation.
- *   - channels   -> the mono fold, the SAME runtime gate the samples chain uses: a
- *                   mono buffer drives groove~ outlet 0 only, so a [selector~ 2] keyed
- *                   on the measured channel count folds it into R (see samplesChain).
- *
- * The order is sequenced with [t]: the whole list reaches [unpack] (buffer selected,
- * rate, gate and duration all set) BEFORE the voice marks itself busy and starts
- * groove~ from 0. Buffer-select is separate from start - `set <buf>` switches the
- * buffer WITHOUT playing, and only the seq's `0` starts it - so a note never begins on
- * the previous note's buffer or rate.
- */
-function instrumentVoicePatch(bufNames) {
-  let vy = 40;
-  const vbox = (id, text, extra = {}) => ({
-    box: { id, maxclass: "newobj", text, numinlets: 1, numoutlets: 1, outlettype: [""], patching_rect: [24, (vy += 30), 150, 22], ...extra },
-  });
-  const vmsg = (id, text) => ({
-    box: { id, maxclass: "message", text, numinlets: 2, numoutlets: 1, outlettype: [""], patching_rect: [200, (vy += 30), 90, 22] },
-  });
-
-  const L = (s, so, d, di) => ({ patchline: { source: [s, so], destination: [d, di] } });
-
-  const boxes = [
-    vbox("v-in", "in 1", { numinlets: 0, numoutlets: 1 }),
-    vbox("v-trig", "t b l", { numoutlets: 2, outlettype: ["bang", ""] }),
-    vbox("v-unpack", "unpack 0 0. 0 0 0", { numoutlets: 5, outlettype: ["int", "float", "int", "int", "int"] }),
-    vbox("v-seq", "t b b", { numoutlets: 2, outlettype: ["bang", "bang"] }),
-    vmsg("v-busy", "1"),
-    vmsg("v-start", "0"),
-    vbox("v-thispoly", "thispoly~", { numoutlets: 2, outlettype: ["int", "int"] }),
-    // slot -> which buffer. [sel] fires the matching outlet; the last (rightmost) is
-    // the no-match passthrough, left unwired.
-    vbox("v-sel", `sel ${bufNames.map((_, i) => i).join(" ")}`, { numoutlets: bufNames.length + 1, outlettype: bufNames.map(() => "bang").concat("") }),
-    vbox("v-sig", "sig~", { numoutlets: 1, outlettype: ["signal"] }),
-    vbox("v-vel", "/ 127.", { outlettype: ["float"] }),
-    // groove~ starts on the FIRST slot's buffer; `set` switches it per note.
-    vbox("v-groove", `groove~ ${bufNames[0]} 2 @loop 0`, { numinlets: 3, numoutlets: 3, outlettype: ["signal", "signal", "signal"] }),
-    vbox("v-gate", "expr ($i1==1)+1", { outlettype: ["int"] }),
-    vbox("v-rsel", "selector~ 2", { numinlets: 3, numoutlets: 1, outlettype: ["signal"] }),
-    vbox("v-ampL", "*~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }),
-    vbox("v-ampR", "*~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }),
-    vbox("v-del", "delay", { numinlets: 2, numoutlets: 1, outlettype: ["bang"] }),
-    vbox("v-free", "t b b", { numoutlets: 2, outlettype: ["bang", "bang"] }),
-    vmsg("v-freebusy", "0"),
-    vmsg("v-stop", "stop"),
-    vbox("v-out1", "out~ 1", { numinlets: 1, numoutlets: 0 }),
-    vbox("v-out2", "out~ 2", { numinlets: 1, numoutlets: 0 }),
-  ];
-
-  const lines = [
-    L("v-in", 0, "v-trig", 0),
-    // list first (right outlet), then the start sequence (left) - values before play.
-    L("v-trig", 1, "v-unpack", 0),
-    L("v-trig", 0, "v-seq", 0),
-    L("v-unpack", 0, "v-sel", 0), // slot -> pick a buffer
-    L("v-unpack", 1, "v-sig", 0), // rate (explicit) -> signal rate
-    L("v-sig", 0, "v-groove", 0),
-    L("v-unpack", 2, "v-vel", 0), // velocity -> amp
-    L("v-vel", 0, "v-ampL", 1),
-    L("v-vel", 0, "v-ampR", 1),
-    L("v-unpack", 3, "v-del", 1), // duration -> delay time (cold)
-    L("v-unpack", 4, "v-gate", 0), // channels -> mono fold gate
-    L("v-gate", 0, "v-rsel", 0),
-    // the start sequence: mark busy, then start groove~ from 0 AND arm the free timer.
-    L("v-seq", 1, "v-busy", 0),
-    L("v-busy", 0, "v-thispoly", 0),
-    L("v-seq", 0, "v-start", 0),
-    L("v-start", 0, "v-groove", 0),
-    L("v-seq", 0, "v-del", 0), // bang the delay: it fires after durMs
-    // groove~ out: L direct, R via the mono-fold selector (stereo R vs. folded mono).
-    L("v-groove", 0, "v-ampL", 0),
-    L("v-groove", 1, "v-rsel", 1), // stereo R
-    L("v-groove", 0, "v-rsel", 2), // mono fold
-    L("v-rsel", 0, "v-ampR", 0),
-    L("v-ampL", 0, "v-out1", 0),
-    L("v-ampR", 0, "v-out2", 0),
-    // free the voice when the note's duration elapses.
-    L("v-del", 0, "v-free", 0),
-    L("v-free", 1, "v-freebusy", 0),
-    L("v-freebusy", 0, "v-thispoly", 0),
-    L("v-free", 0, "v-stop", 0),
-    L("v-stop", 0, "v-groove", 0),
-  ];
-
-  // One `set <buffer>, ` message per slot: [sel] outlet i switches groove~ to that
-  // slot's buffer WITHOUT starting it (the seq's `0` does that). A trailing comma
-  // would start it; there is none, deliberately.
-  bufNames.forEach((buf, i) => {
-    const setId = `v-set-${i}`;
-    boxes.push(vmsg(setId, `set ${buf}`));
-    lines.push(L("v-sel", i, setId, 0));
-    lines.push(L(setId, 0, "v-groove", 0));
-  });
-
-  return {
-    patcher: {
-      fileversion: 1,
-      appversion: { major: 8, minor: 0, revision: 0, architecture: "x64", modernui: 1 },
-      rect: [100, 100, 320, 600],
-      boxes,
-      lines,
-    },
-  };
-}
+
+
 
 /**
- * "instrument" - the marquee: a [poly~] of sample voices over a KEYMAP of named
- * buffers, PLAYED by the note contract the bridge exports. `samples` made the first
- * sound as ONE preview voice; this is the other half - N voices, N buffers, Max doing
- * the allocation and stealing.
- *
- *   app -> voice_play <slot> <rate> <vel> <durMs> <chans>  -> [route] -> [prepend note] -> [poly~]
- *          buffer_load <slot> <path>                       -> [js] resolves -> [buffer~ <slot>]
- *   app <- buffer_ready <slot> <sr> <ms> <chans>            when that slot's read completed
- *
- * The load path is the samples chain's, deliberately: the bytes never cross the bridge
- * ([buffer~] reads the file, the wrapper resolves the path on its aux outlet), and the
- * reply reports what [info~] MEASURED, not what was asked for. Every slot is its own
- * named [buffer~]; the voice picks one per note by index and plays it at the rate the
- * app chose - so a dedicated sample plays at rate 1 and a repitched one at rate 2,
- * which is the app's decision, not the chain's.
- *
- * `slots: ["c", "e", "g"]` in the manifest is three buffers; the default is one
- * ("voice"). The buffer names are INSTANCE-SCOPED (`deviceBufName`): each copy of the
- * device owns its own, which is what lets a drum rack exist on two tracks at once.
- * `---` scopes per DEVICE, so the voice spells the same name the device does - see
- * deviceBufName.
- *
- * It SUMS into the signal path ([+~]): an instrument makes sound where there was none
- * at its input, so there is nothing to claim a stage over.
+ * "webaudio" - the primary audio source for modern m4l-jweb devices.
+ * It takes the L and R signal outlets from [jweb~] (outlets 0 and 1)
+ * and pipes them directly into the device's audio path.
  */
-function instrumentChain(ctx) {
-  const { boxes, lines, device, jwebId, unmatchedId } = ctx;
-  const slots = device?.slots ?? ["voice"];
-  const bufName = (slot) => deviceBufName(device, slot);
-  const voices = device?.voices ?? 8;
-  const voiceFile = `${device?.name}-voice.maxpat`;
-
-  // The frozen voice patch (a keymap of every slot's buffer), and the [poly~] that
-  // loads N copies of it. The voice spells the buffers exactly as the device does:
-  // `---` is device-scoped, so no id travels through poly~'s arguments.
-  ctx.extras.push({ name: voiceFile, data: instrumentVoicePatch(slots.map((s) => voiceBufName(device, s))) });
-  // [poly~]'s name is the file WITHOUT its extension, per Max's abstraction lookup.
-  boxes.push(
-    box(`obj-instr-poly`, `poly~ ${voiceFile.replace(/\.maxpat$/, "")} ${voices}`, {
-      numinlets: 1,
-      numoutlets: 2,
-      outlettype: ["signal", "signal"],
-    }),
-  );
+function webaudioChain(ctx) {
+  const { boxes, lines, jwebId } = ctx;
 
-  // voice_play -> `note <slot> <rate> <vel> <durMs> <chans>` -> poly~. `route` strips
-  // the selector, leaving the bare args; `prepend note` is the word poly~ dispatches on
-  // to pick a free voice. Claimed in series so ui_ready still reaches the wrapper.
-  boxes.push(box("obj-instr-playroute", "route voice_play", { numoutlets: 2, outlettype: ["", ""] }));
-  claimAppMessages(ctx, "obj-instr-playroute", 1);
-  boxes.push(box("obj-instr-note", "prepend note"));
-  lines.push(line("obj-instr-playroute", 0, "obj-instr-note", 0));
-  lines.push(line("obj-instr-note", 0, "obj-instr-poly", 0));
-
-  // The load path, from the wrapper's aux outlet - identical in shape to samples: a
-  // bare buffer name resolves against MAX'S SEARCH PATH, not the device folder, so the
-  // wrapper resolves it and hands back `buffer_replace <slot> <abs path>`. One buffer
-  // per slot, dispatched by slot name (route matches a whole word).
-  boxes.push(box("obj-instr-replaceroute", "route buffer_replace", { numoutlets: 2, outlettype: ["", ""] }));
-  lines.push(line(unmatchedId, 1, "obj-instr-replaceroute", 0));
-  boxes.push(box("obj-instr-loadslot", `route ${slots.join(" ")}`, { numoutlets: slots.length + 1, outlettype: slots.map(() => "").concat("") }));
-  lines.push(line("obj-instr-replaceroute", 0, "obj-instr-loadslot", 0));
-
-  slots.forEach((slot, i) => {
-    const buf = `obj-instr-buf-${slot}`;
-    const info = `obj-instr-info-${slot}`;
-    boxes.push(box(buf, `buffer~ ${bufName(slot)}`, { numinlets: 1, numoutlets: 2, outlettype: ["float", "bang"] }));
-    boxes.push(box(`obj-instr-replace-${slot}`, "prepend replace"));
-    lines.push(line("obj-instr-loadslot", i, `obj-instr-replace-${slot}`, 0));
-    lines.push(line(`obj-instr-replace-${slot}`, 0, buf, 0));
-
-    // Report what LOADED, from the read-completed outlet (1). info~ fires right-to-left,
-    // so the sample rate (outlet 0) arrives last and drives [pack]'s hot inlet.
-    boxes.push(
-      box(info, `info~ ${bufName(slot)}`, {
-        numinlets: 1,
-        numoutlets: 10,
-        outlettype: ["float", "list", "float", "float", "float", "float", "float", "", "int", ""],
-      }),
-    );
-    boxes.push(box(`obj-instr-pack-${slot}`, "pack 0. 0. 0", { numinlets: 3, numoutlets: 1, outlettype: [""] }));
-    boxes.push(box(`obj-instr-ready-${slot}`, `prepend buffer_ready ${slot}`));
-    lines.push(line(buf, 1, info, 0));
-    lines.push(line(info, 8, `obj-instr-pack-${slot}`, 2)); // channels
-    lines.push(line(info, 6, `obj-instr-pack-${slot}`, 1)); // duration ms
-    lines.push(line(info, 0, `obj-instr-pack-${slot}`, 0)); // sample rate, hot
-    lines.push(line(`obj-instr-pack-${slot}`, 0, `obj-instr-ready-${slot}`, 0));
-    lines.push(line(`obj-instr-ready-${slot}`, 0, jwebId, 0));
-  });
-
-  // Sum the voices into the signal path - an instrument originates sound.
-  for (const [ch, id] of [
-    [0, "obj-instr-mix-l"],
-    [1, "obj-instr-mix-r"],
-  ]) {
+  for (const ch of [0, 1]) {
     const [srcId, srcOut] = ctx.audioIn(ch);
+    const id = `obj-webaudio-mix-${ch === 0 ? "l" : "r"}`;
+
     boxes.push(box(id, "+~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
-    lines.push(line(srcId, srcOut, id, 0));
-    lines.push(line("obj-instr-poly", ch, id, 1));
+    lines.push(line(srcId, srcOut, id, 0)); // The device input
+    lines.push(line(jwebId, ch, id, 1));    // jweb~ output
+
     ctx.setAudioOut(ch, id, 0);
   }
 }
 
 export const CHAINS = {
+  webaudio: webaudioChain,
   midiin: midiInChain,
-  samples: samplesChain,
-  instrument: instrumentChain,
   midiout: midiOutChain,
   passthrough: passthroughChain,
   gain: gainChain,
@@ -1557,7 +917,6 @@ export const CHAINS = {
   reverb: reverbChain,
   remote: remoteChain,
   download: downloadChain,
-  renderplay: renderplayChain,
 };
 
 /**

package/templates/base.json

@@ -69,10 +69,10 @@
 				"box": {
 					"disablefind": 0,
 					"id": "obj-jweb",
-					"maxclass": "jweb",
+					"maxclass": "jweb~",
 					"numinlets": 1,
-					"numoutlets": 1,
-					"outlettype": [""],
+					"numoutlets": 3,
+					"outlettype": ["signal", "signal", ""],
 					"patching_rect": [16.0, 104.0, 400.0, 169.0],
 					"presentation": 1,
 					"presentation_rect": [0.0, 0.0, 420.0, 169.0],
@@ -84,7 +84,7 @@
 			{ "patchline": { "destination": ["obj-midiout", 0], "source": ["obj-midiin", 0] } },
 			{ "patchline": { "destination": ["obj-js", 0], "source": ["obj-thisdevice", 0] } },
 			{ "patchline": { "destination": ["obj-jweb", 0], "source": ["obj-js", 0] } },
-			{ "patchline": { "destination": ["obj-js", 0], "source": ["obj-jweb", 0] } }
+			{ "patchline": { "destination": ["obj-js", 0], "source": ["obj-jweb", 2] } }
 		],
 		"latency": 0,
 		"is_mpe": 0,

package/templates/starter/package.json

@@ -17,13 +17,13 @@
     "format": "prettier --write \"src/**/*.{ts,tsx,css}\" \"scripts/*.mjs\" \"patcher/*.mjs\""
   },
   "dependencies": {
-    "@m4l-jweb/bridge": "^0.9.0",
-    "@m4l-jweb/surface": "^0.9.0",
+    "@m4l-jweb/bridge": "^1.0.0",
+    "@m4l-jweb/surface": "^1.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@m4l-jweb/build": "^0.9.0",
+    "@m4l-jweb/build": "^1.0.0",
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",