proscenium 0.24.2-x86_64-linux → 0.25.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a33dbc6045d6adb9bedfe29baec84bb0d6f582196ecafc664206b396d0ece2a
-  data.tar.gz: 4a54f176e92d4a8068d7793c2478877dc21092d57e59a902d2fd54a20eefb2d3
+  metadata.gz: 53a0eb7404c00e8bc3c60aaa156ad30832aa8844a2909483c5f2c63a67a683fe
+  data.tar.gz: e75ff41a520488a59f9676d004411b0253ef2041f72c25ca56601858ef9642c8
 SHA512:
-  metadata.gz: db95c41e72d8dd0d8d84017b5d827020a945b8b7b596e1e469531414279b63a26ad70f89d86bd39e8883dbe267eb94e966c259c6a9954b2ace9d0c9fe9261adc
-  data.tar.gz: 318ac8b887c26630b1aaf5d5083d28d491fe3a1f9ee249f3644ad182ad39650484568f7b2235470e13c916bc29226ed8a6f5efc519c524cab24a8d0b10e755b7
+  metadata.gz: f217daf0ae30983a26e0788d0b756af205ea0ab0643fc1f35ce01f56906a3d2577ed6db6256839988e27167384567cff244ec4e7a87187bc1565761b5fe84782
+  data.tar.gz: 33b083ff243ece1e473585e3891e1f8a069cc46f50adf5411dc64d2375ff7164381f7b8d59c19dd7287f613c3cecb2a34981355086ca57daf19de53ae78f8ed3

data/README.md

@@ -48,9 +48,11 @@
 - [JSX](#jsx)
 - [JSON](#json)
 - [rjs is back!](#rjs-is-back)
+- [Testing your JavaScript](#testing-your-javascript)
 - [Resolution](#resolution)
 - [Aliases](#aliases)
 - [Pre-compilation](#precompilation)
+- [Puma `preload_app!` and Cluster Mode](#puma-preload_app-and-cluster-mode)
 - [Thanks](#thanks)
 - [Development](#development)
 
@@ -663,6 +665,109 @@ console.log(version);
 
 Proscenium brings back RJS! Any path ending in .rjs will be served from your Rails app. This allows you to import server rendered javascript.
 
+## Testing your JavaScript
+
+Your app's JavaScript can be tested with [Bun](https://bun.com), importing exactly what Proscenium
+serves - root-absolute paths, extensionless imports, aliases, `@rubygems/*`, CSS modules, SVG
+components, `proscenium/i18n`, `proscenium.env.*` and `.rjs` - with no dev server running and no
+separate build step.
+
+```bash
+rails generate proscenium:bun
+```
+
+That writes `test/proscenium.preload.js` and adds it to your `bunfig.toml` (merging into an
+existing one rather than replacing it). Then write a test that imports your app code:
+
+```jsx
+// test/js/button.test.jsx
+import { expect, test } from "bun:test";
+import Button from "/app/components/button.jsx";
+import styles from "/app/components/button.module.css";
+
+test("the button has its scoped class name", () => {
+  expect(styles.button).toEqual(Button.className);
+});
+```
+
+```bash
+bun test
+```
+
+### What you test is what you ship
+
+Every module you import is fetched through your application's own middleware stack, by a single
+`rails runner` process the preload starts for the run and talks to over a Unix socket. Not rebuilt
+with settings of the test harness's choosing - actually served, the same way a browser request is.
+So your `config.proscenium` settings apply as-is: bundling, minification, code splitting, aliases,
+externals and environment variables are whatever your app is configured to use. `.rjs` files are
+rendered by your own routes.
+
+The test file itself is the one exception, because no browser ever requests one: it is built
+directly rather than served, with its output read as a string instead of written, code splitting
+off, `bun:*`/`node:*` treated as external, and its source map inlined. Never minification, which is
+the setting that would actually change what you are testing.
+
+This matters more than it sounds. Minification decides the *shape* of a CSS module class name -
+minified you get `button_a1b2c3d4`, unminified `button_a1b2c3d4_app-…` - and your views and your
+stylesheets have to agree on which. So the harness does not get a vote: whatever your app is
+configured to do is what runs. Proscenium's own suite fails if the two ever diverge.
+
+Output is minified in production only, so a test failure names a real function on a real line
+rather than a letter at column 80. Note that "production" means a literal `production` Rails
+environment: any name Rails does not recognise - `staging`, `qa`, a per-PR environment - is
+treated as test, and so is served and precompiled unminified.
+
+### Caveats
+
+- **`mock.module` does not reach your own modules.** With bundling on - the Rails default - a
+  module's dependencies are inlined into it, so there is nothing left for a mock to substitute.
+  This catches an existing suite hard. Mock at a boundary the bundle cannot inline: `globalThis`
+  (`fetch`, a namespace a script installs), a property the code reads at call time, or a
+  test-environment `alias` pointing at a recording stub. Anything Proscenium leaves `external` -
+  `.rjs` included, since `*.rjs` is external by default - is resolved by Bun rather than inlined,
+  and a mock keyed on the specifier still will not match, because Bun resolves it to the file
+  Proscenium materialised. (`mock.module("/lib/api")` also cannot work at all: Bun only passes a
+  specifier to a plugin when it contains a `.` or a `:`.)
+- **Put this preload last, and externalise the runner's own tooling.** The plugin's load hook has
+  no namespace filter, so once registered it claims every uncached JavaScript module - including
+  `@testing-library/react` and whatever else your harness needs from node_modules. Registering it
+  after those are loaded and cached is half the answer; adding them to `config.proscenium.external`
+  in the test environment is the other, or each served test file gets its own second copy.
+- **An import map is invisible to Bun.** If bare specifiers reach the browser through
+  `<script type="importmap">`, mirror the same mapping in `compilerOptions.paths` in
+  `tsconfig.json`/`jsconfig.json`, which Bun does read. Otherwise Bun resolves them from
+  node_modules and you test a different copy than you ship - a CommonJS React, most likely, whose
+  named exports it cannot see.
+- **No cache-busting query strings.** `await import("./thing.js?t=" + Date.now())` to force a
+  fresh module cannot work under a bundler, which fixes module identity at build time. Give the
+  module no state to reset instead, or reset it explicitly.
+- **`sideEffects` in package.json is enforced.** A bare `import "./thing.js"` for its side effect
+  is dropped unless that path is listed there, exactly as in a production build.
+- **Code splitting is off, and the harness turns it off for you.** Nothing on the JavaScript side
+  can resolve a `../_asset_chunks/<name>-$HASH$.js` specifier, so the daemon disables splitting in
+  its own process rather than asking you to disable it for your whole test environment - where it
+  would also cost your system tests the chunked output production emits. The cost is that a
+  dynamic `import()` runs here against an inlined module; the chunk fetch itself is a system
+  test's job.
+- **Import statically.** Bun does not run a plugin's load hook for a dynamic `import()`, so
+  `await import("/lib/thing.js")` inside a test will not go through Proscenium.
+- **`.rjs` actions need `skip_forgery_protection`.** Rails refuses a non-XHR GET that returns
+  JavaScript, in the browser as much as under test.
+- **No DOM.** A CSS module still exports its class names, but the `<style>` element Proscenium
+  would append is skipped. Add [happy-dom](https://github.com/capricorn86/happy-dom) if you need
+  one.
+- **`config.proscenium.bundle = false` needs ESM dependencies.** Unbundled, every module is loaded
+  on its own, and a JavaScript runtime cannot load a CommonJS package that way - React 18 included.
+  The same is true in the browser.
+- **Stack traces name your functions, not your source lines.** Output is only minified in
+  production, so a failure points at a real function name and a real line of the built module.
+  It is not mapped back to the original file: a source map is embedded in everything the harness
+  builds, but Bun does not apply one to a module a plugin loaded (measured on Bun 1.3.13). The map
+  costs nothing to carry, so it stays for when Bun does.
+
+- **Node, Deno and Vitest are not supported yet.** They can reuse the same daemon; see `TODOS.md`.
+
 ## Resolution
 
 Proscenium will serve files ending with any of these extension: `js,mjs,ts,css,jsx,tsx` from the following directories, and their sub-directories of your Rails application's root: `/app`, `/lib`, `/config`, `/node_modules`, `/vendor`.
@@ -713,6 +818,14 @@ Rails.configuration.proscenium.precompile = Set[
 
 This will bundle, code split, tree shake, and compile all your JS, TS, JSX, TSX and CSS files and place them in the `public/assets` directory, ready to be served in production.
 
+## Puma `preload_app!` and Cluster Mode
+
+Proscenium's builder is backed by a Go shared library, and Go's runtime has a known, unfixed limitation ([golang/go#15538](https://github.com/golang/go/issues/15538)): if the Go runtime has already been initialized in a process before that process calls `fork()`, the forked child's Go runtime is left in a broken state (only the forking thread survives `fork()`; the Go scheduler and GC's other threads simply vanish) and any subsequent call into Go code in that child can hang or fail.
+
+This matters if you run Puma in cluster mode with `preload_app!` (the app, including gems, is booted once in the master process, then workers are created via `fork()` with no `exec()` afterward). Proscenium itself never triggers this - simply requiring the gem does not initialize the Go runtime, and nothing in Proscenium's own boot sequence calls into it. The Go runtime only initializes lazily, the first time something actually calls a builder method (`build_to_string`, `resolve`, or `compile`).
+
+**Do not call any `Proscenium::Builder` method (directly, or indirectly via the resolver/side-loading) from a Rails initializer or any other code that runs during application boot**, if you use `preload_app!` with `workers`. Doing so initializes the Go runtime in the master process before the fork, and every worker will inherit a broken one. There is no fix available from Go's side - this is a fundamental fork() limitation, not a bug Proscenium can work around. Asset builds and resolves triggered by actual HTTP requests (the normal case) are unaffected, since those always happen after the fork, independently in each worker.
+
 ## Thanks
 
 HUGE thanks 🙏 go to [Evan Wallace](https://github.com/evanw) and his amazing [esbuild](https://esbuild.github.io/) project. Proscenium would not be possible without it, and it is esbuild that makes this so fast and efficient.

data/lib/generators/proscenium/bun/bun_generator.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module Proscenium
+  module Generators
+    # Sets up `bun test` so it can import the same JS, TS, JSX and CSS the app serves.
+    #
+    #   rails generate proscenium:bun
+    #
+    # Safe to run more than once: the preload is created if missing, and bunfig.toml is merged
+    # rather than overwritten, because an app may already have one with its own preloads.
+    class BunGenerator < Rails::Generators::Base
+      PRELOAD_PATH = 'test/proscenium.preload.js'
+      PRELOAD_ENTRY = './test/proscenium.preload.js'
+      BUNFIG_PATH = 'bunfig.toml'
+
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Configure bun test to run against your Proscenium-bundled JavaScript.'
+
+      def create_preload
+        template 'proscenium.preload.js', PRELOAD_PATH
+      end
+
+      def configure_bunfig
+        return create_file(BUNFIG_PATH, default_bunfig) unless File.exist?(bunfig_full_path)
+
+        contents = File.read(bunfig_full_path)
+
+        if already_preloaded?(contents)
+          say_status :identical, BUNFIG_PATH, :blue
+        elsif (updated = with_preload(contents))
+          File.write(bunfig_full_path, updated)
+          say_status :update, BUNFIG_PATH, :green
+        else
+          say_manual_step
+        end
+      end
+
+      def report
+        say ''
+        say 'Now write a test that imports your app code, and run `bun test`:'
+        say ''
+        say '  // test/js/button.test.jsx'
+        say '  import { expect, test } from "bun:test";'
+        say '  import Button from "/app/components/button.jsx";'
+        say ''
+      end
+
+      private
+
+      # Only a real entry counts. The bare string can also appear in a commented-out line, and
+      # reporting "identical" then would silently do nothing for someone who had disabled it.
+      def already_preloaded?(contents)
+        test_table(contents).to_s.match?(/^[^#\n]*["']#{Regexp.escape(PRELOAD_ENTRY)}["']/o)
+      end
+
+      # Returns the whole file with our entry added inside the `[test]` table, or nil when that
+      # cannot be done without risking the file.
+      #
+      # Editing TOML with a regex is how this went wrong before, so the rules are narrow and each
+      # refusal falls through to printing the two lines for the user to add:
+      #
+      #   - a `preload` key outside `[test]` is left alone. It belongs to `bun run`, and appending
+      #     to it put the test preload somewhere `bun test` never reads.
+      #   - `[test]` already present without a `preload` key gets the key inserted into it. The
+      #     previous version appended a second `[test]` table, which is invalid TOML.
+      #   - an existing `[test] preload` array is extended in place, respecting a trailing comma.
+      #     Appending `, "entry"` after one produced `,\n, "entry"`, also invalid TOML.
+      def with_preload(contents)
+        table = test_table(contents)
+
+        return "#{contents.sub(/\n*\z/, "\n")}\n#{default_bunfig}" if table.nil?
+
+        if (array = table[/^[^#\n]*\bpreload\s*=\s*\[.*?\]/m])
+          extended = extend_array(array)
+          return nil if extended.nil?
+
+          # Substituted inside the table, then the table inside the document. `contents.sub(array)`
+          # replaces the FIRST occurrence of that text anywhere - so a root-level `preload` holding
+          # the same entries as `[test]`'s got edited instead, which put the harness in `bun run`,
+          # left `bun test` without it, and reported success.
+          return contents.sub(table) { table.sub(array) { extended } }
+        end
+
+        # `[test]` exists but has no preload key: put one directly under its header.
+        header = table[/\A\[test\][^\n]*\n/]
+        return nil if header.nil?
+
+        contents.sub(table) { table.sub(header, %(#{header}preload = ["#{PRELOAD_ENTRY}"]\n)) }
+      end
+
+      # The `[test]` table's text, from its header to the next table header or end of file. Nil
+      # when the file has no `[test]` table.
+      # The header line may end at EOF rather than a newline. Requiring the newline made a bunfig
+      # whose last line is `[test]` look like it had no `[test]` table at all, and the nil branch
+      # above then appended a second one - the invalid-TOML shape this rewrite exists to avoid.
+      # Matching it here instead leaves `with_preload` unable to find a header to insert under, so
+      # it refuses and prints the two lines for the user to add.
+      def test_table(contents)
+        contents[/^\[test\][^\n]*(?:\n|\z).*?(?=^\[|\z)/m]
+      end
+
+      # Adds our entry to an existing array, keeping the file's own shape. A trailing comma is
+      # respected rather than doubled - appending ", entry" after one is what produced invalid
+      # TOML before. Returns nil when the array's shape is one this cannot edit safely.
+      def extend_array(array)
+        inner = array[/\[(.*)\]/m, 1]
+        entry = %("#{PRELOAD_ENTRY}")
+
+        return array.sub(/\[\s*\]/m, "[#{entry}]") if inner.strip.empty?
+
+        # A comment after the last entry swallows the separator: the inserted `, ` lands inside
+        # `# DOM shim` and the two entries end up with no comma between them - valid input, invalid
+        # output. Putting the comma before the comment means parsing TOML comments, which is the
+        # approximation this file keeps getting punished for. Refuse and let the user do it.
+        # A comment after the last entry swallows the separator: the inserted `, ` lands inside
+        # `# DOM shim` and the two entries end up with no comma between them - valid input, invalid
+        # output. Putting the comma before the comment means parsing TOML comments, which is the
+        # approximation this file keeps getting punished for. Refuse and let the user do it.
+        return nil if inner.match?(/(?<!["'])#/)
+
+        separator = inner.rstrip.end_with?(',') ? '' : ', '
+        array.sub(/(\s*)\]\z/) { "#{separator}#{::Regexp.last_match(1)}#{entry}]" }
+      end
+
+      def say_manual_step
+        say_status :skip, BUNFIG_PATH, :yellow
+        say ''
+        say "  Could not edit #{BUNFIG_PATH} safely. Add this to it by hand:"
+        say ''
+        say '    [test]'
+        say %(    preload = ["#{PRELOAD_ENTRY}"])
+        say ''
+      end
+
+      def bunfig_full_path
+        File.expand_path(BUNFIG_PATH, destination_root)
+      end
+
+      def default_bunfig
+        <<~TOML
+          [test]
+          preload = ["#{PRELOAD_ENTRY}"]
+        TOML
+      end
+    end
+  end
+end

data/lib/generators/proscenium/bun/templates/proscenium.preload.js

@@ -0,0 +1,61 @@
+// Registers Proscenium's Bun plugin, so `bun test` can import the same JS, TS, JSX and CSS your
+// Rails app serves. Generated by `rails generate proscenium:bun`.
+//
+// Everything of substance lives in the gem, so this file should not need to change when
+// Proscenium does.
+//
+// Keep this LAST in bunfig.toml's `preload` list. The plugin claims every uncached JS module, so
+// anything that has to come from node_modules - a DOM shim, a testing library - must already be
+// imported and cached by an earlier preload, or it gets fetched from your Rails app instead.
+
+import { existsSync, mkdirSync, mkdtempSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+// Written to a file rather than read off a pipe, because a pipe cannot be relied on from here.
+// Once happy-dom's GlobalRegistrator has run and a DOM-touching package has been imported - which
+// is the normal state of a preload that comes before this one - every `Bun.spawn`/`Bun.spawnSync`
+// in the process returns a zero-length stdout: exit status 0, empty stderr, no bytes, for any
+// command at all.
+//
+// The file goes in a private directory under the app's own tmp/, beside where the daemon
+// materialises `.rjs` modules, rather than in the shared system temp dir. `mkdtemp` is what makes
+// it safe either way - the name stops being guessable and the create is exclusive by construction,
+// so nobody else on the machine can pre-place a file here and break or redirect the run - but an
+// app-private parent means there is no one else in the directory to begin with.
+mkdirSync("tmp/proscenium", { recursive: true });
+const gemDirDir = mkdtempSync(join("tmp/proscenium", "gem-dir-"));
+const gemDirFile = join(gemDirDir, "gem-dir");
+
+let gemDir = "";
+try {
+  Bun.spawnSync(["bundle", "exec", "ruby", "-e", "print Gem.loaded_specs['proscenium'].gem_dir"], {
+    stdout: Bun.file(gemDirFile),
+    stderr: "inherit",
+  });
+
+  gemDir = (await Bun.file(gemDirFile).text()).trim();
+} catch (error) {
+  // `Bun.spawnSync` throws rather than returning when the command cannot be run at all - no
+  // bundler on PATH, or not a Ruby project - and then the output file was never created, so the
+  // read throws too. Both land here so the message below is the one thing the developer sees.
+  gemDir = "";
+  if (error?.code !== "ENOENT") throw error;
+} finally {
+  rmSync(gemDirDir, { recursive: true, force: true });
+}
+
+// Checked for being a directory, not merely non-empty: bundler writes some of its own
+// diagnostics to stdout ("Could not locate Gemfile", for one), which would otherwise sail past a
+// truthiness check and fail later as an unreadable module path.
+if (!gemDir || !existsSync(gemDir) || !statSync(gemDir).isDirectory()) {
+  throw new Error(
+    "could not locate the proscenium gem. `bundle exec ruby -e \"print " +
+      "Gem.loaded_specs['proscenium'].gem_dir\"` did not name a directory" +
+      (gemDir ? ` - it produced ${JSON.stringify(gemDir.slice(0, 200))}` : " - it produced nothing") +
+      ". Is this a Rails app with proscenium in its Gemfile, and is bundler on PATH?",
+  );
+}
+
+const { register } = await import(`${gemDir}/lib/proscenium/runtime/bootstrap.js`);
+
+await register();

data/lib/proscenium/builder.rb

@@ -8,19 +8,19 @@ module Proscenium
 
     class Result < FFI::Struct
       layout :success, :bool,
-             :response, :string,
-             :content_hash, :string
+             :response, :pointer,
+             :content_hash, :pointer
     end
 
     class ResolveResult < FFI::Struct
       layout :success, :bool,
-             :url_path, :string,
-             :abs_path, :string
+             :url_path, :pointer,
+             :abs_path, :pointer
     end
 
     class CompileResult < FFI::Struct
       layout :success, :bool,
-             :messages, :string
+             :messages, :pointer
     end
 
     module Request
@@ -30,21 +30,27 @@ module Proscenium
 
       enum :environment, [:development, 1, :test, :production]
 
+      # `blocking: true` releases the GVL for the duration of the call, so a build/resolve
+      # doesn't stall unrelated Ruby threads (eg. other requests in a multi-threaded server).
+      # Safe to do because the Go side serialises these calls itself with a mutex - see main.go.
+
       attach_function :build_to_string, [
         :string, # Path or entry point.
         :pointer # Config as JSON.
-      ], Result.by_value
+      ], Result.by_value, blocking: true
 
       attach_function :resolve, [
         :string, # path or entry point
         :pointer # Config as JSON.
-      ], ResolveResult.by_value
+      ], ResolveResult.by_value, blocking: true
 
       attach_function :compile, [
         :pointer # Config as JSON.
-      ], CompileResult.by_value
+      ], CompileResult.by_value, blocking: true
+
+      attach_function :reset_config, [], :void, blocking: true
 
-      attach_function :reset_config, [], :void
+      attach_function :free_cstr, [:pointer], :void
     end
 
     class BuildError < Error
@@ -73,16 +79,16 @@ module Proscenium
       end
     end
 
-    def self.build_to_string(path, root: nil)
-      new(root:).build_to_string(path)
+    def self.build_to_string(path, root: nil, **overrides)
+      new(root:, **overrides).build_to_string(path)
     end
 
-    def self.resolve(path, root: nil)
-      new(root:).resolve(path)
+    def self.resolve(path, root: nil, **overrides)
+      new(root:, **overrides).resolve(path)
     end
 
-    def self.compile(root: nil)
-      new(root:).compile
+    def self.compile(root: nil, **overrides)
+      new(root:, **overrides).compile
     end
 
     # Intended for tests only.
@@ -90,8 +96,13 @@ module Proscenium
       Request.reset_config
     end
 
-    def initialize(root: nil)
-      @request_config = FFI::MemoryPointer.from_string({
+    # `overrides` are merged over the config derived from `Proscenium.config`, and are passed
+    # straight through to the Go side. Intended for callers that are not serving a browser request
+    # and so want different build settings - `Bundle: false`, `Write: false`, `CodeSplitting: false`
+    # - than the app's own configuration. Keys must match `types.ConfigT`; Go silently ignores
+    # any it does not know.
+    def initialize(root: nil, **overrides)
+      config_hash = {
         RootPath: (root || Rails.root).to_s,
         OutputDir: "public#{Proscenium.config.output_dir}",
         GemPath: gem_root,
@@ -104,12 +115,41 @@ module Proscenium
         External: Proscenium.config.external,
         Precompile: Proscenium.config.precompile,
         Debug: Proscenium.config.debug
-      }.to_json)
+      }.merge(overrides)
+
+      @request_config = self.class.request_config_pointer(config_hash)
+    end
+
+    class << self
+      # Building the config JSON and copying it into an FFI::MemoryPointer is the only real cost
+      # in instantiating a Builder (everything else is memoized attribute reads). Since the
+      # config is identical across the vast majority of calls (same root, same Rails env, same
+      # Proscenium.config), skip re-serializing and re-allocating it when nothing has changed.
+      #
+      # Callers keep their own reference to the returned pointer, so a later call replacing the
+      # memo does not invalidate a pointer already in use.
+      #
+      # The hash and its pointer are stored as one frozen pair in one ivar, and assigned once. Two
+      # ivars would need a lock: a reader could see a hash already updated while its pointer still
+      # pointed at the previous config, and get a build made with someone else's settings. One
+      # assignment cannot be observed half-done, so a reader sees either the old pair or the new
+      # one - never a mix - and there is no window for a test to have to reproduce.
+      def request_config_pointer(config_hash)
+        memo = @config_memo
+        return memo[1] if memo && memo[0] == config_hash
+
+        pointer = FFI::MemoryPointer.from_string(config_hash.to_json)
+        @config_memo = [config_hash, pointer].freeze
+
+        pointer
+      end
     end
 
     def build_to_string(path)
       ActiveSupport::Notifications.instrument('build.proscenium', identifier: path) do
-        result = Request.build_to_string(path, @request_config)
+        raw = Request.build_to_string(path, @request_config)
+        result = { success: raw[:success], response: read_and_free(raw[:response]),
+                   content_hash: read_and_free(raw[:content_hash]) }
 
         raise BuildError.new(path, result[:response]) unless result[:success]
 
@@ -119,21 +159,35 @@ module Proscenium
 
     def resolve(path)
       ActiveSupport::Notifications.instrument('resolve.proscenium', identifier: path) do
-        result = Request.resolve(path, @request_config)
+        raw = Request.resolve(path, @request_config)
+        success = raw[:success]
+        url_path = read_and_free(raw[:url_path])
+        abs_path = read_and_free(raw[:abs_path])
 
-        raise ResolveError.new(path, result[:url_path]) unless result[:success]
+        raise ResolveError.new(path, url_path) unless success
 
-        [result[:url_path], result[:abs_path]]
+        [url_path, abs_path]
       end
     end
 
     def compile
-      result = Request.compile(@request_config)
-      result[:success]
+      raw = Request.compile(@request_config)
+      read_and_free(raw[:messages])
+      raw[:success]
     end
 
     private
 
+    # The Go side allocates each of these strings with C.CString, which the Go runtime cannot
+    # see or collect - it must be freed from this side once we're done reading it.
+    def read_and_free(ptr)
+      return nil if ptr.null?
+
+      ptr.read_string
+    ensure
+      Request.free_cstr(ptr)
+    end
+
     # Build the ENV variables as determined by `Proscenium.config.env_vars` and
     # `Proscenium::DEFAULT_ENV_VARS` to pass to esbuild.
     def env_vars

data/lib/proscenium/ext/proscenium.h

@@ -23,6 +23,8 @@ extern const char *_GoStringPtr(_GoString_ s);
 
 #line 3 "main.go"
 
+#include <stdlib.h>
+
 struct Result {
 	int success;
 	char* response;
@@ -101,6 +103,7 @@ extern "C" {
 #endif
 
 extern void reset_config(void);
+extern void free_cstr(char* ptr);
 extern struct Result build_to_string(char* filePath, char* configJson);
 extern struct ResolveResult resolve(char* filePath, char* configJson);
 extern struct CompileResult compile(char* configJson);

data/lib/proscenium/importer.rb

@@ -53,7 +53,9 @@ module Proscenium
           end
 
           transformed_path = ''
-          if Proscenium.config.debug || Rails.env.development?
+          # Mirrors ConfigT#ShouldMinify - the suffix exists whenever identifiers are not
+          # minified, and a class name the stylesheet does not define is worse than a long one.
+          if Proscenium.config.debug || !Rails.env.production?
             rel_path = Pathname.new(abs_path).relative_path_from(Rails.root).sub_ext('')
             transformed_path = "_#{rel_path.to_s.gsub(%r{[@/.+]}, '-')}"
           end