studio-engine 0.115.1.rc1 → 0.115.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fabe1d2bfd93ef94f291f09e43bc3c6116cbd80023cfffb91d77af00d9bbfbc6
-  data.tar.gz: ec6b825a90b3bbbf1ef0c4183ffe1f0b2555a34429df2d6877c8f7c4c94f838f
+  metadata.gz: 34882e3c979d460aab938a9bd07a2a520222068592dd7b2bbc5e6d7b114cbd4f
+  data.tar.gz: e3a4a039830a9c071526bc9410c11f62f7ff2ed70a3c68d842f2ec0502daf93f
 SHA512:
-  metadata.gz: 8ac4e8a7fc5a8510ec63eb126ed44110a3205e072d2adf4861dfefcae0584de24ac2eb3624958c15c0a15e11a986dc1608116b51013d76879fb8cc26b1129516
-  data.tar.gz: d358e292cf4c84be548bf75235ec4613d9d9a3b9c9ddec008879976b696198b7ff1608ca3b46a82bd20d2e419f39f97b12aa7df08556ab808faca510a853d84c
+  metadata.gz: 94324fdda382908f9b3630cf6f7a3866f75e111b879888e65aff870d2e5e9dccc985315cbe14935197e091f284fa6b454f9f9341a341eb5cb2bd1dd8bdf3b4b5
+  data.tar.gz: 6dc861ab2e2d4837549d77b43cf03e751c35051e06981df58cee66aa9c20a89ca395a8c23397b939aacbde8f96e4abaaca927faf3775f8db31c19f78bd1f1f16

data/CHANGELOG.md

@@ -4,6 +4,40 @@ The format is [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). This pro
 
 ## Unreleased
 
+### Added
+
+- **One Node tooling package, shipped in the gem** (`lib/studio/node_tooling/`,
+  see its `README.md`). `versions.json` pins Node 22, `@playwright/test`
+  1.62.1 and `axe-core` 4.11.0. `playwright_base.js` holds the browser lane's
+  shared defaults; `e2e_helpers.js` holds `watchPageErrors` and
+  `blockOffsiteRequests`; `node_test/register.mjs` lets `node --test` import a
+  module by its importmap name. `bin/rails studio:node:link` links it at
+  `node_modules/.studio-engine` (run it after `npm ci`), and
+  `bin/rails studio:node:check` exits 1, naming each pin a host drifts from. No
+  host change is needed until a host adopts it.
+
+### Changed
+
+- **The engine runs Node 22.** `.tool-versions` reads `nodejs 22`, both
+  `engine-ci.yml` Node steps read it through `node-version-file`, and
+  `package.json` pins `@playwright/test` at exactly 1.62.1. The engine's
+  Playwright config and e2e helpers build on the shared package, and resolve to
+  the same config as before.
+
+### Fixed
+
+- **`studio/studio_confetti` resolves `"canvas-confetti"` on every page.** In
+  0.115.1.rc1 the head loaded it with `javascript_include_tag ..., type:
+  "module"`, which also sends a `Link: rel=modulepreload` response header. The
+  browser acts on that header before it parses the import map, so on a page
+  whose head parsed slowly it resolved the module's bare import against no map
+  and threw `TypeError: Failed to resolve module specifier "canvas-confetti"`
+  (11 hub e2e specs: the boards and `/dreams`). The head now imports it with
+  `javascript_import_module_tag` below the map, which sends no header. No host
+  change is needed. A module the head loads by URL may import no bare specifier
+  (`test/views/head_url_modules_import_no_bare_specifier_test.rb`), and the e2e
+  lab now sends the Link header Rails sends, which its stub had dropped.
+
 ## 0.115.1 — 2026-10-27
 
 ### Changed

data/README.md

@@ -127,6 +127,23 @@ A migrating host also moves every other reader of the preset, not only the
 build: any production code or test that `require`s or reads the preset's text
 reads `theme.css` instead.
 
+## Node tooling
+
+The gem ships the one Node tooling package every app shares, in
+`lib/studio/node_tooling/` (its `README.md` lists the files): the pins
+(`versions.json`: Node 22, `@playwright/test` 1.62.1, `axe-core` 4.11.0), a
+Playwright config base, the shared e2e helpers, and the `node --test` importmap
+hooks.
+
+```bash
+bin/rails studio:node:link    # node_modules/.studio-engine -> the package; run after npm ci
+bin/rails studio:node:check   # exits 1, naming each pin this app drifts from
+```
+
+An app pins Node in `.tool-versions` (`nodejs 22`), the file mise and
+`actions/setup-node`'s `node-version-file` both read.
+`docs/FRONT_END_STANDARD.md`, "Node tooling", has the rest.
+
 ## Configuration
 
 Each consuming app configures the engine in `config/initializers/studio.rb`:

data/app/javascript/studio/studio_confetti.js

@@ -3,9 +3,10 @@
   vendored canvas-confetti (app/assets/javascripts/studio/canvas_confetti.js,
   pinned as "canvas-confetti", no CDN).
 
-  An ES module (the head loads it with a type="module" tag after the import
-  map). It imports canvas-confetti for its side effect, which defines the
-  library's global `confetti`, and exports:
+  An ES module (the head imports it with an inline module tag after the import
+  map, never by URL: a URL tag's Link modulepreload header would resolve the
+  bare import below before the map exists). It imports canvas-confetti for its
+  side effect, which defines the library's global `confetti`, and exports:
 
     import { burst, cannons, confetti } from "studio/studio_confetti"
     burst(cardEl)    // radial burst behind a card/modal

data/app/views/layouts/studio/_head.html.erb

@@ -195,7 +195,13 @@
     take every bare specifier on the page down with it. The ones below that load by
     URL (type="module" with a src) are external files, not inline scripts: they
     carry no body and need no nonce under a policy that allows 'self'. The session
-    store (studio/_session_stamp, above) is the one classic script, and says why. %>
+    store (studio/_session_stamp, above) is the one classic script, and says why.
+    A MODULE LOADED BY URL MUST IMPORT NO BARE SPECIFIER. javascript_include_tag
+    also sends a `Link: rel=modulepreload` response header, which the browser
+    acts on before it parses this map, so a bare import in that module can
+    resolve against no map at all and fail for good (0.115.1.rc1, task
+    confetti-resolves-on-hub). A module with bare imports takes a
+    javascript_import_module_tag, which sends no header. %>
 <%# THE ENGINE'S BROWSER BOOT (studio/application): its every-page Stimulus
     controllers, the pinned stack, and the Alpine shims. A module tag, so it
     carries the nonce. %>
@@ -238,13 +244,19 @@
     module that owns it. Its imports import nothing, and studio/alpine_shims
     imports it, so a failed boot leaves a page its uploads. %>
 <%= javascript_import_module_tag "studio/alpine_scopes" %>
-<%# CONFETTI, BY URL. studio/studio_confetti imports the vendored canvas-confetti
-    (pinned "canvas-confetti", app/assets/javascripts/studio/canvas_confetti.js:
-    no CDN, same-origin) and exports burst, cannons and confetti. It also keeps
-    the deprecated globals window.studioConfetti and window.confetti, which
-    studio/head_chrome's fireSuccessConfetti and host classic code still call.
-    Before Alpine, so both exist by the time an x-init can fire one. %>
-<%= javascript_include_tag "studio/studio_confetti", type: "module", "data-turbo-track": "reload" %>
+<%# CONFETTI, BY ITS OWN DOOR, AND NOT BY URL. studio/studio_confetti imports the
+    vendored canvas-confetti by its bare pin ("canvas-confetti",
+    app/assets/javascripts/studio/canvas_confetti.js: no CDN, same-origin) and
+    exports burst, cannons and confetti. It also keeps the deprecated globals
+    window.studioConfetti and window.confetti, which studio/head_chrome's
+    fireSuccessConfetti and host classic code still call. Before Alpine, so both
+    exist by the time an x-init can fire one.
+    An inline module tag, never javascript_include_tag: that helper's Link
+    modulepreload header had the browser resolve "canvas-confetti" before the
+    map above existed, so on a page whose head parsed slowly (the hub's boards
+    and /dreams) the module failed with "Failed to resolve module specifier"
+    (e2e/confetti_resolves_under_a_slow_head.spec.js). %>
+<%= javascript_import_module_tag "studio/studio_confetti" %>
 <%# ALPINE LOADS AFTER THE MODULE TAGS, and the order is the contract. Module
     scripts (and deferred classic ones) execute in document order, so by the time
     Alpine starts, studio/application has defined the shims it evaluates

data/lib/studio/node_tooling/README.md

@@ -0,0 +1,27 @@
+# studio-engine Node tooling
+
+The one Node tooling package every host shares. It ships inside the gem, so a
+host gets it with the engine it already bundles: no npm registry, no token.
+
+- `versions.json`: the pin set. Node's major, and the exact version of every
+  shared npm package. A host that declares one of these packages declares it at
+  exactly this version.
+- `playwright_base.js`: the browser lane's shared defaults (one chromium
+  project, one worker, a Rails `webServer` on `/up`).
+- `e2e_helpers.js`: `watchPageErrors` and `blockOffsiteRequests`.
+- `node_test/register.mjs` and `node_test/importmap_hooks.mjs`: let `node --test`
+  import a module by the bare name the importmap pins it under.
+
+Every file here requires only `node:` builtins and its own siblings, because it
+is loaded from the gem's directory, which has no `node_modules`.
+
+A host links the package into its own tree and checks itself against the pins:
+
+```sh
+bin/rails studio:node:link    # node_modules/.studio-engine -> this directory
+bin/rails studio:node:check   # exits 1, naming each pin the host drifts from
+```
+
+Run `link` after `npm ci`, because `npm ci` deletes `node_modules`. Then
+`require("./node_modules/.studio-engine/playwright_base.js")`. The adoption
+steps are in the engine repository's `docs/FRONT_END_STANDARD.md`, "Node tooling".

data/lib/studio/node_tooling/e2e_helpers.js

@@ -0,0 +1,74 @@
+// studio-engine's shared browser-lane helpers. Requires only node: builtins, so it
+// loads from the gem's directory (see README.md).
+
+const fs = require("node:fs");
+
+const LOCAL_HOSTS = new Set(["127.0.0.1", "localhost"]);
+
+function isOffOrigin(url) {
+  if (!url || !/^https?:/.test(url)) return false;
+  return !LOCAL_HOSTS.has(new URL(url).hostname);
+}
+
+// Collect everything the page THREW or logged as an error.
+//
+// `pageerror` is the cheapest detector there is for a script that never ran: the
+// phantom-element defect threw a SyntaxError on every load while the response
+// bytes were valid and the server-side guard passed.
+//
+// It hears every frame on the page, a third party's included: Playwright delivers a
+// cross-origin frame's console to the page's `console` event. `ownOriginOnly: true`
+// scopes that out BY ORIGIN, never by message text. A console error is dropped only
+// when the script that logged it was served from another host, and a thrown error
+// only when every frame of its stack was. An error with no location or no stack is
+// kept, because it cannot be shown to be someone else's. The default counts
+// everything.
+function watchPageErrors(page, { ownOriginOnly = false } = {}) {
+  const errors = [];
+  page.on("pageerror", (error) => {
+    if (ownOriginOnly) {
+      const sources = (error.stack || "").match(/https?:\/\/[^\s)]+/g) || [];
+      if (sources.length > 0 && sources.every(isOffOrigin)) return;
+    }
+    errors.push(`pageerror: ${error.message}`);
+  });
+  page.on("console", (message) => {
+    if (message.type() !== "error") return;
+    if (ownOriginOnly && isOffOrigin(message.location().url)) return;
+    errors.push(`console.error: ${message.text()}`);
+  });
+  return errors;
+}
+
+// Answer every request that leaves this origin, so the lane cannot depend on the
+// public internet.
+//
+// ANSWERED, NOT ABORTED. route.abort() makes Chromium log `Failed to load resource:
+// net::ERR_FAILED`, which watchPageErrors counts. An empty 200 logs nothing, and
+// the page falls back as it would offline.
+//
+// `pinned` maps an off-origin URL to `{ file, contentType }`: a file loaded with
+// Subresource Integrity cannot be answered empty (the digest fails and Chromium
+// logs it), so it is answered with a byte-exact local copy. The response carries
+// `access-control-allow-origin: *`, because a `crossorigin` tag refuses a CORS
+// response without it before checking the digest.
+async function blockOffsiteRequests(page, { pinned = {} } = {}) {
+  await page.route("**/*", (route) => {
+    const url = new URL(route.request().url());
+    if (LOCAL_HOSTS.has(url.hostname)) return route.continue();
+
+    const copy = pinned[url.href];
+    if (copy) {
+      return route.fulfill({
+        status: 200,
+        contentType: copy.contentType,
+        headers: { "access-control-allow-origin": "*" },
+        body: fs.readFileSync(copy.file),
+      });
+    }
+
+    return route.fulfill({ status: 200, body: "" });
+  });
+}
+
+module.exports = { isOffOrigin, watchPageErrors, blockOffsiteRequests };

data/lib/studio/node_tooling/node_test/importmap_hooks.mjs

@@ -0,0 +1,48 @@
+// Resolve importmap specifiers under `node --test` the way the browser does.
+//
+// In the browser, config/importmap.rb pins a directory under a prefix (`board`,
+// `cyvasse`, `studio`), and the modules import each other as "board/colors".
+// Node has no import map, so this hook maps each prefix onto the same files. A
+// bare top-level name with a file of its own in `topLevelDir`
+// (`import … from "chat_follow"`, pinned by name) maps the same way.
+//
+// A Rails app has no package.json "type", so Node has to guess each .js file's
+// format. Files under `esmDirs` are ES modules (that is what the browser loads),
+// so this hook says so instead.
+//
+// Configured by register.mjs through `initialize(data)`; it holds no app's names.
+import { existsSync } from "node:fs";
+
+let prefixes = [];
+let topLevel = null;
+let esmDirs = [];
+
+const asDir = (url) => (url.endsWith("/") ? url : `${url}/`);
+
+export function initialize({ root, prefixes: map = {}, topLevelDir = null, esmDirs: dirs = [] } = {}) {
+  const base = asDir(String(root));
+  prefixes = Object.entries(map).map(([prefix, dir]) => [prefix, asDir(new URL(dir, base).href)]);
+  topLevel = topLevelDir ? asDir(new URL(topLevelDir, base).href) : null;
+  esmDirs = dirs.map((dir) => asDir(new URL(dir, base).href));
+}
+
+function mapped(specifier) {
+  for (const [prefix, dir] of prefixes) {
+    const match = specifier.startsWith(`${prefix}/`) && /^[\w/-]+$/.test(specifier.slice(prefix.length + 1));
+    if (match) return new URL(`${specifier.slice(prefix.length + 1)}.js`, dir).href;
+  }
+  if (topLevel && /^[a-z_]+$/.test(specifier)) {
+    const file = new URL(`${specifier}.js`, topLevel);
+    if (existsSync(file)) return file.href;
+  }
+  return null;
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  const target = mapped(specifier);
+  const resolved = await nextResolve(target || specifier, context);
+  if (resolved.url.endsWith(".js") && esmDirs.some((dir) => resolved.url.startsWith(dir))) {
+    return { ...resolved, format: "module" };
+  }
+  return resolved;
+}

data/lib/studio/node_tooling/node_test/register.mjs

@@ -0,0 +1,20 @@
+// Installs importmap_hooks.mjs for `node --test`. A host's own register file
+// (loaded with `node --import`) names its prefixes and calls this once:
+//
+//   import { registerImportmapHooks } from "../../../node_modules/.studio-engine/node_test/register.mjs";
+//   registerImportmapHooks({
+//     root: new URL("../../../", import.meta.url),
+//     prefixes: { board: "app/javascript/board/" },
+//     topLevelDir: "app/javascript/",
+//     esmDirs: ["app/javascript/", "test/javascript/"],
+//   });
+//
+// Paths are relative to `root`, the host's Rails root.
+import { register } from "node:module";
+
+export function registerImportmapHooks({ root, prefixes = {}, topLevelDir = null, esmDirs = [] }) {
+  if (!root) throw new Error("registerImportmapHooks: root is required");
+  register("./importmap_hooks.mjs", import.meta.url, {
+    data: { root: String(root), prefixes, topLevelDir, esmDirs },
+  });
+}

data/lib/studio/node_tooling/playwright_base.js

@@ -0,0 +1,63 @@
+// studio-engine's shared Playwright defaults.
+//
+// A plain object, not a defineConfig() call: this file is loaded from the gem's
+// directory, which has no node_modules, so it cannot require @playwright/test.
+// The host requires its own copy and wraps the result:
+//
+//   const { defineConfig } = require("@playwright/test");
+//   const { studioPlaywrightConfig } = require("./node_modules/.studio-engine/playwright_base.js");
+//   module.exports = defineConfig(studioPlaywrightConfig({
+//     defaultPort: "3000",
+//     webServer: { command: "bin/rails server -p $E2E_PORT" },
+//   }));
+//
+// Every key of `overrides` replaces the default of the same name; `use` merges
+// one level deep, so a host can add `reducedMotion` and keep `baseURL`.
+
+const DEFAULTS = Object.freeze({
+  testDir: "./e2e",
+  timeout: 30_000,
+  retries: 0,
+  workers: 1,
+});
+
+// The base URL, from the environment first: PW_BASE_URL (or BASE_URL) points the
+// lane at a stack someone else booted, and then no webServer is started.
+function studioBaseURL({ defaultPort, env = process.env } = {}) {
+  const port = env.E2E_PORT || String(defaultPort);
+  const external = env.PW_BASE_URL || env.BASE_URL || null;
+  return { port, external, baseURL: external || `http://127.0.0.1:${port}` };
+}
+
+// A Rails server Playwright boots and waits on. `/up` is the Rails health check
+// every app in the ecosystem keeps.
+function railsWebServer({ command, port, env = {}, timeout = 120_000, ci = !!process.env.CI }) {
+  if (!command) throw new Error("railsWebServer: a command is required");
+  return {
+    command,
+    url: `http://127.0.0.1:${port}/up`,
+    reuseExistingServer: !ci,
+    timeout,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { RAILS_ENV: "test", E2E_PORT: String(port), ...env },
+  };
+}
+
+function studioPlaywrightConfig({ defaultPort, webServer, env = process.env, use = {}, ...overrides } = {}) {
+  if (!defaultPort) throw new Error("studioPlaywrightConfig: defaultPort is required");
+  const { port, external, baseURL } = studioBaseURL({ defaultPort, env });
+  const config = {
+    ...DEFAULTS,
+    forbidOnly: !!env.CI,
+    projects: [{ name: "chromium", use: { browserName: "chromium" } }],
+    ...overrides,
+    use: { baseURL, headless: true, ...use },
+  };
+  if (!external && webServer) {
+    config.webServer = railsWebServer({ ci: !!env.CI, ...webServer, port });
+  }
+  return config;
+}
+
+module.exports = { DEFAULTS, studioBaseURL, railsWebServer, studioPlaywrightConfig };

data/lib/studio/node_tooling/versions.json

@@ -0,0 +1,5 @@
+{
+  "node": "22",
+  "@playwright/test": "1.62.1",
+  "axe-core": "4.11.0"
+}

data/lib/studio/node_tooling.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "pathname"
+
+module Studio
+  # The engine's Node tooling package (lib/studio/node_tooling/README.md): the
+  # one pin set, the shared Playwright base and helpers, and the node:test hooks.
+  #
+  # The gem's path is resolved here in Ruby, never by Node running bundler (the
+  # same rule Studio::TailwindEntry keeps). `link!` puts a symlink at a fixed
+  # path in the host, so a host's playwright.config.js or test register file
+  # requires `./node_modules/.studio-engine/...` with no shell-out.
+  #
+  # `drift` holds a host to the pins: Node's major in `.tool-versions` (what
+  # mise and actions/setup-node's `node-version-file` read) and package.json
+  # `engines`, and the exact version of every pinned package the host declares,
+  # in package.json and in package-lock.json. A pinned package the host does not
+  # declare is not drift: no host is made to install what it does not use.
+  module NodeTooling
+    ROOT = Pathname(__dir__).join("node_tooling").freeze
+    LINK = "node_modules/.studio-engine"
+
+    module_function
+
+    def root = ROOT
+
+    # The host the rake tasks act on. A method of its own so a test can point
+    # the tasks at a temporary host without defining a Rails constant.
+    def host_root = ::Rails.root
+
+    def versions = JSON.parse(ROOT.join("versions.json").read)
+
+    def link_path(app_root) = Pathname(app_root).join(LINK)
+
+    # Idempotent. Replaces a stale link (an older gem's directory); refuses a
+    # real directory or file at the path rather than deleting someone's work.
+    def link!(app_root)
+      path = link_path(app_root)
+      if path.symlink?
+        return path if path.readlink == ROOT
+
+        path.delete
+      elsif path.exist?
+        raise ArgumentError, "#{path} exists and is not a symlink; move it aside and link again"
+      end
+      FileUtils.mkdir_p(path.dirname)
+      File.symlink(ROOT, path)
+      path
+    end
+
+    # Every way the host at `app_root` differs from versions.json, one sentence
+    # each. Empty when it matches.
+    def drift(app_root)
+      app_root = Pathname(app_root)
+      pins = versions
+      major = pins.fetch("node")
+      problems = node_version_drift(app_root, major)
+
+      package = read_json(app_root.join("package.json"))
+      return problems unless package
+
+      engines = package.dig("engines", "node")
+      unless engines == "#{major}.x"
+        problems << "package.json engines.node is #{engines.inspect}; the pin is \"#{major}.x\""
+      end
+
+      lock = read_json(app_root.join("package-lock.json"))
+      pins.except("node").each do |name, version|
+        declared = package.dig("devDependencies", name) || package.dig("dependencies", name)
+        next unless declared
+
+        problems << "package.json declares #{name} #{declared.inspect}; the pin is \"#{version}\"" unless declared == version
+        locked = lock&.dig("packages", "node_modules/#{name}", "version")
+        problems << "package-lock.json locks #{name} at #{locked.inspect}; the pin is \"#{version}\"" unless locked == version
+      end
+      problems
+    end
+
+    def node_version_drift(app_root, major)
+      file = app_root.join(".tool-versions")
+      return ["no .tool-versions; it should read \"nodejs #{major}\""] unless file.file?
+
+      line = file.read.lines.map(&:split).find { |tool, *| %w[nodejs node].include?(tool) }
+      return [".tool-versions names no nodejs; it should read \"nodejs #{major}\""] unless line
+      return [] if line[1] == major
+
+      [".tool-versions reads \"#{line.join(" ")}\"; it should read \"nodejs #{major}\""]
+    end
+
+    def read_json(path)
+      path.file? ? JSON.parse(path.read) : nil
+    end
+  end
+end

data/lib/studio/version.rb

@@ -1,3 +1,3 @@
 module Studio
-  VERSION = "0.115.1.rc1"
+  VERSION = "0.115.1"
 end

data/lib/studio.rb

@@ -22,6 +22,7 @@ require "studio/geo/lookup"
 require "studio/link_preview"
 require "studio/engine"
 require "studio/tailwind_entry"
+require "studio/node_tooling"
 require "studio/color_scale"
 require "studio/environment_banner"
 require "studio/theme_resolver"

data/lib/tasks/studio_node.rake

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# The engine's Node tooling package (lib/studio/node_tooling/README.md). Neither
+# task loads :environment; both need only Rails.root (Studio::NodeTooling.host_root).
+namespace :studio do
+  namespace :node do
+    desc "Link studio-engine's Node tooling package at node_modules/.studio-engine (run after npm ci)"
+    task :link do
+      root = Studio::NodeTooling.host_root
+      path = Studio::NodeTooling.link!(root)
+      puts "studio-engine: #{path.relative_path_from(root)} -> #{Studio::NodeTooling.root}"
+    end
+
+    desc "Fail when this app's Node pins drift from studio-engine's versions.json"
+    task :check do
+      problems = Studio::NodeTooling.drift(Studio::NodeTooling.host_root)
+      if problems.empty?
+        puts "studio-engine: Node tooling matches the pins #{Studio::NodeTooling.versions.to_json}"
+      else
+        abort(["studio-engine: Node tooling drifts from the pins:", *problems.map { |p| "  - #{p}" }].join("\n"))
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: studio-engine
 version: !ruby/object:Gem::Version
-  version: 0.115.1.rc1
+  version: 0.115.1
 platform: ruby
 authors:
 - Alex McRitchie
@@ -774,6 +774,13 @@ files:
 - lib/studio/navbar_slots.rb
 - lib/studio/navbar_wordmark.rb
 - lib/studio/newsletter.rb
+- lib/studio/node_tooling.rb
+- lib/studio/node_tooling/README.md
+- lib/studio/node_tooling/e2e_helpers.js
+- lib/studio/node_tooling/node_test/importmap_hooks.mjs
+- lib/studio/node_tooling/node_test/register.mjs
+- lib/studio/node_tooling/playwright_base.js
+- lib/studio/node_tooling/versions.json
 - lib/studio/oauth_identity.rb
 - lib/studio/partial_block.rb
 - lib/studio/profile_image.rb
@@ -799,6 +806,7 @@ files:
 - lib/studio/version.rb
 - lib/tasks/studio_email.rake
 - lib/tasks/studio_knowledge.rake
+- lib/tasks/studio_node.rake
 - lib/tasks/studio_trash.rake
 - studio-engine.gemspec
 homepage: https://github.com/McRitchie-Studio/studio-engine