@m4l-jweb/build 0.9.1 → 0.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m4l-jweb/build",
-  "version": "0.9.1",
+  "version": "0.9.9",
   "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.1"
+    "@m4l-jweb/wrapper": "0.9.9"
   }
 }

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,205 +748,7 @@ function downloadChain(ctx) {
   lines.push(line("obj-prepend-maxurl-progress", 0, unmatchedId, 0));
 }
 
-/**
- * "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()`
@@ -1078,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,

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,