@m4l-jweb/build 1.0.0 → 1.1.0

package/package.json

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

package/src/chains.mjs

@@ -126,8 +126,8 @@ export const AUDIO_OUT = "obj-plugout";
  * buffer takes its name from its creation argument and there is no documented runtime
  * rename), so the scoping has to be a load-time substitution Max itself performs.
  *
- * `#0` WAS TRIED AND DOES NOT WORK (spike, doc/TODO.md item 0, run 2026-07-17 in
- * Live). `#0` is documented for abstractions, and an .amxd device patcher turned out
+ * `#0` WAS TRIED AND DOES NOT WORK (spike run 2026-07-17 in Live; see
+ * doc/MAX-FACTS.md). `#0` is documented for abstractions, and an .amxd device patcher turned out
  * not to count as one: the token stayed literal in every instance, so writer and
  * reader still agreed on one global name and the collision survived, silently.
  *
@@ -645,8 +645,8 @@ function crushChain(ctx) {
  * drives - the app resolves that (our own filter, or an Auto Filter the user placed by
  * hand) and says so. That is what makes this bigger than an LFO on our own DSP: a slot
  * can point at any parameter in the set. **LOM ids are not stable across set reloads**,
- * so the app must re-bind on load and must never persist a raw id - see the diff rules
- * in doc/TODO.md item 1.
+ * so the app must re-bind on load and must never persist a raw id - see bindRemote() in
+ * @m4l-jweb/bridge for the rule.
  *
  * NOT IN THE SIGNAL PATH. It touches no audio: `ctx.audioIn`/`setAudioOut` are never
  * called, so `remote` composes with any chain list without taking a stage. It has no

package/src/index.mjs

@@ -8,7 +8,7 @@
  *   wrapper/device.ts  - extra [js] message handlers, concatenated last
  */
 import archiver from "archiver";
-import { createReadStream, createWriteStream, existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync } from "node:fs";
+import { cpSync, createReadStream, createWriteStream, existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync } from "node:fs";
 import { copyFile, rename, stat } from "node:fs/promises";
 import { execFileSync } from "node:child_process";
 import { createRequire } from "node:module";
@@ -283,6 +283,43 @@ export async function generatePatchers(root) {
  * wrapper.js. The loose ui.html/wrapper.js are for inspection, not a runtime
  * requirement.
  */
+/**
+ * Deliver a `site:` window's content as a SIDECAR FOLDER, and tell the wrapper
+ * where it is.
+ *
+ * Every other window rides inside wrapper.js as base64 and is written to a real
+ * file on first load. That works because a window is one self-contained HTML file
+ * of a few hundred kB. A whole prebuilt site is tens of MB across hundreds of
+ * files, and base64 is 4 bytes per 3 - so it ships as a plain folder next to the
+ * .amxd instead, and the wrapper points the window's [jweb] at
+ * `file:///<device folder>/<device>-site/<window>/index.html`.
+ *
+ * The cost is honest and documented: the .amxd is no longer self-contained, and
+ * the folder has to travel with it. The wrapper says so out loud when the folder
+ * is missing rather than opening a blank window.
+ */
+function siteWindowsBanner(root, outDir, d, surface) {
+  const windows = surface?.windows ?? {};
+  const ids = Object.keys(windows).filter((id) => windows[id].site);
+  if (!ids.length) return "";
+
+  const map = {};
+  for (const id of ids) {
+    const from = path.join(root, windows[id].site);
+    if (!existsSync(path.join(from, "index.html"))) {
+      throw new Error(
+        `window "${id}" of "${d.name}" declares site "${windows[id].site}", but there is no index.html there - ` +
+          `build the site first (this repo: \`pnpm build:repl\`)`,
+      );
+    }
+    const rel = `${d.name}-site/${id}`;
+    cpSync(from, path.join(outDir, rel), { recursive: true });
+    map[id] = `${rel}/index.html`;
+    console.log(`m4l-jweb: ${windows[id].site} -> dist/${path.basename(outDir)}/${rel}/ (sidecar)`);
+  }
+  return `var SITE_WINDOWS = ${JSON.stringify(map)};\n`;
+}
+
 export async function packageDevices(root) {
   const dist = path.join(root, "dist");
   const { name, version } = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
@@ -333,7 +370,7 @@ export async function packageDevices(root) {
     // The device's declared watches ride in as a data banner, like the build stamp:
     // WATCH_SPECS is what the packaged wrapper's setupWatches() attaches observers from.
     const watch = await loadWatch(root, d.ui ?? d.name);
-    let wrapperData = banner + watchSpecsBanner(watch) + wrapperJs;
+    let wrapperData = banner + watchSpecsBanner(watch) + siteWindowsBanner(root, outDir, d, await loadSurface(root, d.ui ?? d.name)) + wrapperJs;
     const uiDirContent = readdirSync(path.join(dist, "ui", d.ui ?? d.name)).filter((f) => f.endsWith(".html"));
 
     // Main UI payload
@@ -420,6 +457,14 @@ export async function packageDevices(root) {
     for (const f of installers) {
       archive.file(path.join(templates, f), { name: f, mode: 0o755 });
     }
+    // A `site:` window's sidecar folder is part of the release, not an extra: the
+    // .amxd alone opens that window empty. It is a directory rather than a listed
+    // file, so it is added as a tree.
+    for (const d of readdirSync(outDir, { withFileTypes: true })) {
+      if (d.isDirectory() && d.name.slice(-5) === "-site") {
+        archive.directory(path.join(outDir, d.name), `${name}/${d.name}`);
+      }
+    }
     archive.finalize();
   });
 

package/src/surface.mjs

@@ -202,8 +202,44 @@ const PITCH_Y = 56;
 export function computeNativeSlots(surface) {
   const native = surface?.layout?.native;
   if (!native || native.params.length === 0) return { slots: new Map(), width: 0 };
-  const rows = native.rows ?? 3;
   const slots = new Map();
+
+  // ROW SIZES, given explicitly: `rows: [1, 4, 4]` is one control on the first row
+  // and four on each of the next two. Column-major filling cannot express that -
+  // a transport button above two banks of dials came out interleaved with them -
+  // and it is what a panel actually wants to say.
+  if (Array.isArray(native.rows)) {
+    let i = 0;
+    let y = MARGIN;
+    let width = 0;
+    for (let r = 0; r < native.rows.length; r++) {
+      let x = MARGIN;
+      let rowH = 0;
+      for (let c = 0; c < native.rows[r] && i < native.params.length; c++, i++) {
+        const id = native.params[i];
+        const [w, h] = NATIVE_SIZE[surface.params[id].kind];
+        slots.set(id, [x, y, w, h]);
+        x += w + MARGIN;
+        rowH = Math.max(rowH, h);
+      }
+      width = Math.max(width, x);
+      y += Math.max(rowH, PITCH_Y - MARGIN) + MARGIN;
+    }
+    // Anything the rows did not account for still needs a rect, or it would have no
+    // presentation and simply not appear. Put it on one more row rather than
+    // silently dropping it.
+    let x = MARGIN;
+    for (; i < native.params.length; i++) {
+      const id = native.params[i];
+      const [w, h] = NATIVE_SIZE[surface.params[id].kind];
+      slots.set(id, [x, y, w, h]);
+      x += w + MARGIN;
+      width = Math.max(width, x);
+    }
+    return { slots, width };
+  }
+
+  const rows = native.rows ?? 3;
   let row = 0;
   let colW = 0;
   let x = MARGIN;
@@ -528,9 +564,11 @@ export function applySurface(ctx) {
  */
 const FLOAT_MSG = "window flags grow close title float, window exec";
 
-function floatBoxes(spec) {
+function floatBoxes(spec, audio = false) {
   if (!spec.alwaysOnTop) return [];
-  const y = 96 + spec.height + 80;
+  // A sounding window shows its patching canvas, so anything that is not the page
+  // is parked above the origin, out of sight (see FITTED WINDOWS).
+  const y = audio ? -140 : 96 + spec.height + 80;
   return [
     { box: { id: "obj-float-loadbang", maxclass: "newobj", text: "loadbang", numinlets: 1, numoutlets: 1, outlettype: ["bang"], patching_rect: [220, y, 60, 22] } },
     // A MESSAGE box - the comma is what makes it two messages, which is the point.
@@ -547,6 +585,136 @@ function floatLines(spec) {
   ];
 }
 
+/**
+ * The `[jweb~]` a sounding window holds, and the pair of `[outlet]`s its L and R
+ * leave the subpatcher on.
+ *
+ * ------------------------------------------------------------------------------
+ * WHY A SUBPATCHER CAN CARRY A SIGNAL AT ALL
+ *
+ * An `[outlet]` inside a `[p]` is typeless until something is wired to it; wire a
+ * signal to it and the corresponding outlet on the parent `[p]` box IS a signal
+ * outlet. What decides WHICH outlet is which is the x position of the outlet boxes
+ * in the subpatcher - left to right - which is why L sits at x=16, R at x=56 and
+ * the message outlet far right at x=200. The `[p]` box declares the result in
+ * `outlettype` so the saved file already says signal, signal, message.
+ *
+ * The device view's own `[jweb~]` (templates/base.json) has exactly this shape:
+ * three outlets, L, R and the page's messages. A window is the same object in a
+ * subpatcher, so the `webaudio` chain's mix stage applies unchanged.
+ */
+function audioWindowBoxes(id, spec) {
+  return [
+    {
+      box: {
+        id: "obj-jweb",
+        maxclass: "jweb~",
+        numinlets: 1,
+        numoutlets: 3,
+        outlettype: ["signal", "signal", ""],
+        rendermode: 1,
+        // On the PATCHING canvas at the origin, filling the window. See FITTED
+        // WINDOWS below for why this one is not in presentation like the others.
+        patching_rect: [0, 0, spec.width, spec.height],
+        varname: "obj-jweb",
+      },
+    },
+    { box: { id: "obj-out-l", maxclass: "outlet", patching_rect: [16, HELPER_Y + 80, 30, 30], numinlets: 1, numoutlets: 0, comment: "signal L" } },
+    { box: { id: "obj-out-r", maxclass: "outlet", patching_rect: [56, HELPER_Y + 80, 30, 30], numinlets: 1, numoutlets: 0, comment: "signal R" } },
+  ];
+}
+
+/**
+ * FITTED WINDOWS - where the plumbing goes so the page can own the window.
+ *
+ * A window that is worth resizing (an editor, a whole REPL) has to have its page
+ * grow with it, and the wrapper does that by writing the [jweb]'s rect at runtime.
+ * MEASURED, in this repo: a runtime rect change is accepted but never redrawn when
+ * the object is shown in PRESENTATION - which is how every window here was laid
+ * out. On the patching canvas it does redraw, and that is the whole reason a
+ * sounding window is built differently: `openinpresentation` is off, the page sits
+ * at the canvas origin, and everything else - the inlet, the receive, the tag, the
+ * outlets - is moved ABOVE the origin, off the top of what the window shows.
+ *
+ * The plain window is untouched by this and stays in presentation. It is a fixed
+ * reference card; nothing about it wants to be dragged bigger.
+ */
+const HELPER_Y = -260;
+
+/**
+ * Sum a sounding window into the device's audio path, and make sure its page is
+ * actually LOADED.
+ *
+ * The mix is the `webaudio` chain's stage shape (chains.mjs), claimed here because
+ * `applyWindows` runs before `closeAudio` - the window is just another stage in the
+ * series, and `ctx.audioIn`/`ctx.setAudioOut` are the hand-off.
+ *
+ * The keepalive is the part that is NOT obvious. A `[jweb]` in a subpatcher whose
+ * window has never been opened may never load its page, and a page that never
+ * loaded has no AudioContext and makes no sound - a device that is silent until the
+ * user happens to open a window would be a trap. So `loadbang` pulses the window
+ * open and closes it again a moment later: the page loads, the audio starts, and
+ * the window is out of the way. It is deliberately a PULSE and not a hidden open -
+ * `[pcontrol]`'s `close` is the same message the app sends, so nothing special
+ * needs to be true about the window afterwards.
+ */
+function mixAudioWindow(ctx, id, subpatcherId, pcontrolId) {
+  const { boxes, lines, device } = ctx;
+
+  // openAudio() leaves ctx.audioIn throwing on a MIDI device, but its message talks
+  // about chains. Say what is actually wrong here.
+  if (!ctx.audioTail) {
+    throw new Error(
+      `window "${id}" is declared \`audio: true\`, but device "${device?.name}" is type "${device?.type}". ` +
+        `A sounding window needs the signal path: set \`type: "audio"\` or \`type: "instrument"\` in patcher/devices.mjs.`,
+    );
+  }
+
+  for (const ch of [0, 1]) {
+    const [srcId, srcOut] = ctx.audioIn(ch);
+    const mixId = `obj-window-${id}-mix-${ch === 0 ? "l" : "r"}`;
+    boxes.push(box(mixId, "+~", { numinlets: 2, numoutlets: 1, outlettype: ["signal"] }));
+    lines.push(line(srcId, srcOut, mixId, 0)); // whatever the last stage left
+    lines.push(line(subpatcherId, ch, mixId, 1)); // the window's page
+    ctx.setAudioOut(ch, mixId, 0);
+  }
+
+  // The LEVEL of what this window is playing, as messages, for a page to draw.
+  //
+  // It has to be messages: [jweb~] is "Web browser with audio output" - one control
+  // inlet, no signal inlet - so no page can be handed a signal, and the device view
+  // cannot see the window's audio any other way. [peakamp~] reports the peak since
+  // the last report, which is what a meter wants and costs a float per channel per
+  // interval rather than a stream of samples.
+  const tap = (suffix) => `obj-window-${id}-peak-${suffix}`;
+  // 10 ms - fast enough that the trace reads as the shape of the sound rather than a
+  // meter twitching. It is still an ENVELOPE and not a waveform: what crosses is one
+  // float per channel per report, not samples, because no page can be handed audio.
+  boxes.push(box(tap("l"), "peakamp~ 10", { numinlets: 1, numoutlets: 1, outlettype: ["float"] }));
+  boxes.push(box(tap("r"), "peakamp~ 10", { numinlets: 1, numoutlets: 1, outlettype: ["float"] }));
+  // `pak` and not `pack`: both inlets hot, so a change on either channel reports
+  // rather than waiting for the left one to move.
+  boxes.push(box(tap("pak"), "pak f f", { numinlets: 2, numoutlets: 1, outlettype: [""] }));
+  boxes.push(box(tap("pre"), `prepend window_level ${id}`, { numinlets: 1, numoutlets: 1, outlettype: [""] }));
+  lines.push(line(subpatcherId, 0, tap("l"), 0));
+  lines.push(line(subpatcherId, 1, tap("r"), 0));
+  lines.push(line(tap("l"), 0, tap("pak"), 0));
+  lines.push(line(tap("r"), 0, tap("pak"), 1));
+  lines.push(line(tap("pak"), 0, tap("pre"), 0));
+  lines.push(line(tap("pre"), 0, ctx.unmatchedId, 0));
+
+  const ka = (suffix) => `obj-window-${id}-ka-${suffix}`;
+  boxes.push(box(ka("loadbang"), "loadbang", { numinlets: 1, numoutlets: 1, outlettype: ["bang"] }));
+  boxes.push(box(ka("open"), "open", { maxclass: "message", numinlets: 2, numoutlets: 1 }));
+  boxes.push(box(ka("delay"), "delay 1500", { numinlets: 2, numoutlets: 1, outlettype: ["bang"] }));
+  boxes.push(box(ka("close"), "close", { maxclass: "message", numinlets: 2, numoutlets: 1 }));
+  lines.push(line(ka("loadbang"), 0, ka("open"), 0));
+  lines.push(line(ka("loadbang"), 0, ka("delay"), 0));
+  lines.push(line(ka("delay"), 0, ka("close"), 0));
+  lines.push(line(ka("open"), 0, pcontrolId, 0));
+  lines.push(line(ka("close"), 0, pcontrolId, 0));
+}
+
 export function applyWindows(ctx) {
   const { boxes, lines, surface, unmatchedId } = ctx;
   const windowIds = surface?.windows ? Object.keys(surface.windows) : [];
@@ -596,6 +764,11 @@ export function applyWindows(ctx) {
     const pcontrolId = `obj-window-${id}-pcontrol`;
     boxes.push(box(pcontrolId, "pcontrol"));
 
+    // A SOUNDING window: [jweb~] with two signal outlets ahead of the message one.
+    // Everything above this point - the route, the triggers, [pcontrol] - is the
+    // same for both kinds, because opening a window is opening a window.
+    const audio = !!spec.audio;
+
     const subpatcherId = `obj-window-${id}-sub`;
     lines.push(line(pcontrolId, 0, subpatcherId, 0));
     // The window's [jweb] can now TALK BACK. Its output leaves the subpatcher on an
@@ -603,7 +776,10 @@ export function applyWindows(ctx) {
     // device view feeds. It is tagged `window <id>` inside (below), so the wrapper
     // tells the two apart and can answer the right one. Without this the window's
     // page could display but never send a message: the [jweb] outlet went nowhere.
-    lines.push(line(subpatcherId, 0, unmatchedId, 0));
+    //
+    // On a sounding window the messages are the LAST outlet: 0 and 1 are the page's
+    // L and R.
+    lines.push(line(subpatcherId, audio ? 2 : 0, unmatchedId, 0));
     boxes.push({
       box: {
         id: subpatcherId,
@@ -613,16 +789,22 @@ export function applyWindows(ctx) {
         // subpatcher that has no inlets, so [pcontrol] would end up wired to
         // NOTHING - silently, in the saved file. That was attempt 1.
         numinlets: 1,
-        numoutlets: 1,
-        outlettype: [""],
+        numoutlets: audio ? 3 : 1,
+        outlettype: audio ? ["signal", "signal", ""] : [""],
+        // A scripting name, so [js] can reach INTO this subpatcher at runtime
+        // (getnamed -> subpatcher()). That is how the window's page is resized to
+        // follow the window - see followWindowSizes() in the wrapper.
+        varname: `window-${id}`,
         patching_rect: [16, 620, 120, 22],
         patcher: {
           fileversion: 1,
           appversion: { major: 8, minor: 0, revision: 0, architecture: "x64", modernui: 1 },
           rect: [100, 100, spec.width, spec.height],
-          openinpresentation: 1,
+          // A sounding window shows its PATCHING canvas, so the page can be resized
+          // at runtime - see FITTED WINDOWS above.
+          openinpresentation: audio ? 0 : 1,
           boxes: [
-            { box: { id: "obj-in", maxclass: "inlet", patching_rect: [16, 16, 30, 30], numinlets: 0, numoutlets: 1, outlettype: [""] } },
+            { box: { id: "obj-in", maxclass: "inlet", patching_rect: [16, audio ? HELPER_Y : 16, 30, 30], numinlets: 0, numoutlets: 1, outlettype: [""] } },
             // The page's URL cannot be WIRED here - this [jweb] is inside a
             // subpatcher and the wrapper's [js] is outside it. The wrapper reaches
             // it by NAME instead (messnamed), once the payload is extracted.
@@ -634,21 +816,26 @@ export function applyWindows(ctx) {
                 numinlets: 0,
                 numoutlets: 1,
                 outlettype: [""],
-                patching_rect: [16, 56, 160, 22],
-              },
-            },
-            {
-              box: {
-                id: "obj-jweb",
-                maxclass: "jweb",
-                numinlets: 1,
-                numoutlets: 2,
-                outlettype: ["", ""],
-                patching_rect: [16, 96, spec.width, spec.height],
-                presentation: 1,
-                presentation_rect: [0, 0, spec.width, spec.height],
+                patching_rect: [16, audio ? HELPER_Y + 40 : 56, 160, 22],
               },
             },
+            ...(audio
+              ? audioWindowBoxes(id, spec)
+              : [
+                  {
+                    box: {
+                      id: "obj-jweb",
+                      maxclass: "jweb",
+                      numinlets: 1,
+                      numoutlets: 2,
+                      outlettype: ["", ""],
+                      patching_rect: [16, 96, spec.width, spec.height],
+                      presentation: 1,
+                      presentation_rect: [0, 0, spec.width, spec.height],
+                      varname: "obj-jweb",
+                    },
+                  },
+                ]),
             // TAG the window's messages with which window they are, so the wrapper's
             // `window()` can answer THIS window (its [jweb] has no cord from [js], so
             // a reply goes back by name). The page emits bare selectors; the tag is
@@ -662,22 +849,41 @@ export function applyWindows(ctx) {
                 numinlets: 1,
                 numoutlets: 1,
                 outlettype: [""],
-                patching_rect: [16, 96 + spec.height + 16, 160, 22],
+                // On a sounding window the signal outlets own the left of the row,
+                // and outlet ORDER is x order - so the messages move right.
+                patching_rect: [audio ? 200 : 16, audio ? HELPER_Y + 40 : 96 + spec.height + 16, 160, 22],
               },
             },
-            { box: { id: "obj-out", maxclass: "outlet", patching_rect: [16, 96 + spec.height + 48, 30, 30], numinlets: 1, numoutlets: 0 } },
-            ...floatBoxes(spec),
+            {
+              box: {
+                id: "obj-out",
+                maxclass: "outlet",
+                patching_rect: [audio ? 200 : 16, audio ? HELPER_Y + 80 : 96 + spec.height + 48, 30, 30],
+                numinlets: 1,
+                numoutlets: 0,
+              },
+            },
+            ...floatBoxes(spec, audio),
           ],
           lines: [
             { patchline: { source: ["obj-recv", 0], destination: ["obj-jweb", 0] } },
             // [jweb] outlet 0 is the page's messages; tag them and send them out.
-            { patchline: { source: ["obj-jweb", 0], destination: ["obj-tag", 0] } },
+            // On [jweb~] that is outlet 2 - 0 and 1 carry the sound.
+            { patchline: { source: ["obj-jweb", audio ? 2 : 0], destination: ["obj-tag", 0] } },
             { patchline: { source: ["obj-tag", 0], destination: ["obj-out", 0] } },
+            ...(audio
+              ? [
+                  { patchline: { source: ["obj-jweb", 0], destination: ["obj-out-l", 0] } },
+                  { patchline: { source: ["obj-jweb", 1], destination: ["obj-out-r", 0] } },
+                ]
+              : []),
             ...floatLines(spec),
           ],
         },
       },
     });
+
+    if (audio) mixAudioWindow(ctx, id, subpatcherId, pcontrolId);
   });
 }
 

package/templates/install-mac.sh

@@ -61,6 +61,16 @@ for f in "$src"/*.adg "$src"/*.adv; do
 	echo "  installed $(basename "$f") (preset)"
 done
 
+# A `site:` window's content is a whole prebuilt site - too big to ride inside the
+# .amxd as a payload - so it ships as a folder NEXT TO the device and has to be
+# installed with it. Without the folder the device still plays; that window opens
+# empty, and the wrapper says so in the Max console.
+for d in "$src"/*-site; do
+	[ -d "$d" ] || continue
+	cp -R "$d" "$dest/"
+	echo "  installed $(basename "$d")/ (site sidecar)"
+done
+
 echo "Installed to $dest"
 echo "In Live: User Library > Max For Live > $device_name"
 echo "NOTE: Live embeds a copy of the device in the set. Instances already"

package/templates/install-windows.ps1

@@ -65,6 +65,15 @@ foreach ($f in @(Get-ChildItem (Join-Path $src "*.adg") -ErrorAction SilentlyCon
     Write-Host "  installed $($f.Name) (preset)"
 }
 
+# A `site:` window's content is a whole prebuilt site - too big to ride inside the
+# .amxd as a payload - so it ships as a folder NEXT TO the device and has to be
+# installed with it. Without the folder the device still plays; that window opens
+# empty, and the wrapper says so in the Max console.
+foreach ($d in @(Get-ChildItem (Join-Path $src "*-site") -Directory -ErrorAction SilentlyContinue)) {
+    Copy-Item $d.FullName $dest -Recurse -Force
+    Write-Host "  installed $($d.Name)/ (site sidecar)"
+}
+
 Write-Host "Installed to $dest"
 Write-Host "In Live: User Library > Max For Live > $deviceName"
 Write-Host "NOTE: Live embeds a copy of the device in the set. Instances already"

package/templates/starter/package.json

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