@swmansion/popcorn 0.4.0-next.0 → 0.4.0-next.2

package/dist/plugins/vite.mjs

@@ -5,9 +5,9 @@ import { r as runtimeDirectory, p as popcorn$1 } from './shared.mjs';
 import 'node:child_process';
 import 'node:os';
 import 'node:util';
-import 'node:zlib';
 
-const CORS_HEADERS = {
+/** Headers required by the threaded WebAssembly runtime. */
+const crossOriginIsolationHeaders = {
     "Cross-Origin-Opener-Policy": "same-origin",
     "Cross-Origin-Embedder-Policy": "require-corp",
 };
@@ -22,7 +22,7 @@ const distDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
  * import { popcorn } from "@swmansion/popcorn/vite";
  *
  * export default defineConfig({
- *   plugins: [popcorn({ rootDir: "../my_app", app: "my_app" })],
+ *   plugins: [popcorn({ rootDir: "../my_app" })],
  * });
  * ```
  *
@@ -43,8 +43,8 @@ function popcorn(options) {
     let dirty = false;
     let outDir;
     let assetsDir = "assets";
-    // Dev/preview: pack once at first request, re-pack lazily after the app's
-    // compiled beams change. A single in-flight promise dedupes concurrent
+    // Dev/preview: pack once at server startup, then re-pack lazily after the
+    // app's compiled beams change. A single in-flight promise dedupes concurrent
     // requests; a change during a re-pack re-sets `dirty` so it isn't lost.
     const ensurePrepared = () => {
         if (prepared !== undefined && !dirty)
@@ -95,24 +95,21 @@ function popcorn(options) {
         const filePath = resolve(assetsRoot, requestPath.slice(requestRoot.length));
         if (!isUnder(assetsRoot, filePath)) {
             res.statusCode = 403;
-            setHeaders(res);
             res.end("Forbidden");
             return;
         }
         try {
             const compressible = isCompressible(filePath);
             const encoding = compressible
-                ? selectEncoding(req.headers["accept-encoding"]?.toString(), options.brotli ?? false)
+                ? selectEncoding(req.headers["accept-encoding"]?.toString())
                 : { name: null, suffix: "" };
             if (compressible && encoding.name === null) {
                 res.statusCode = 406;
-                setHeaders(res);
                 res.setHeader("Vary", "Accept-Encoding");
                 res.end("No supported content encoding");
                 return;
             }
             const content = await readFile(`${filePath}${encoding.suffix}`);
-            setHeaders(res);
             setContentType(res, filePath);
             res.setHeader("Vary", "Accept-Encoding");
             if (encoding.name !== null) {
@@ -122,7 +119,6 @@ function popcorn(options) {
         }
         catch {
             res.statusCode = 404;
-            setHeaders(res);
             res.end("Not found");
         }
     };
@@ -144,10 +140,6 @@ function popcorn(options) {
                         },
                     ],
                 },
-                // COOP/COEP must be on every response (SharedArrayBuffer/pthreads),
-                // including the worker/beam files Vite serves from the package itself.
-                server: { headers: CORS_HEADERS },
-                preview: { headers: CORS_HEADERS },
             };
         },
         configResolved(config) {
@@ -155,8 +147,9 @@ function popcorn(options) {
             outDir = resolve(config.root, config.build.outDir);
             assetsDir = config.build.assetsDir;
         },
-        configureServer(server) {
+        async configureServer(server) {
             const rootDir = resolve(options.rootDir);
+            server.httpServer?.prependListener("request", setIsolationHeaders);
             server.watcher.add(rootDir);
             server.watcher.on("all", (_event, file) => {
                 if (isUnder(rootDir, file))
@@ -164,10 +157,14 @@ function popcorn(options) {
             });
             server.middlewares.use(serve);
             server.httpServer?.once("close", cleanup);
+            await ensurePrepared();
+            dirty = false;
         },
-        configurePreviewServer(server) {
+        async configurePreviewServer(server) {
+            server.httpServer?.prependListener("request", setIsolationHeaders);
             server.middlewares.use(serve);
             server.httpServer?.once("close", cleanup);
+            await ensurePrepared();
         },
         async closeBundle() {
             assert(outDir !== undefined, "outDir was not resolved");
@@ -187,8 +184,8 @@ function popcorn(options) {
 function isCompressible(path) {
     return path.endsWith(".tar") || path.endsWith(".wasm");
 }
-function selectEncoding(header, useBrotli) {
-    if (useBrotli && header?.includes("br")) {
+function selectEncoding(header) {
+    if (header?.includes("br")) {
         return { name: "br", suffix: ".br" };
     }
     if (header?.includes("gzip"))
@@ -199,8 +196,8 @@ function isUnder(dir, file) {
     const rel = relative(dir, file);
     return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
 }
-function setHeaders(res) {
-    for (const [key, value] of Object.entries(CORS_HEADERS)) {
+function setIsolationHeaders(_req, res) {
+    for (const [key, value] of Object.entries(crossOriginIsolationHeaders)) {
         res.setHeader(key, value);
     }
 }
@@ -224,4 +221,4 @@ function assert(ok, message) {
     }
 }
 
-export { popcorn };
+export { crossOriginIsolationHeaders, popcorn };

package/dist/popcorn.d.ts

@@ -123,6 +123,7 @@ export declare class Popcorn<Output extends TtyOutput = "text"> {
     private readonly eventHandlers;
     private readonly pendingSends;
     private readonly pendingCalls;
+    private readonly readyWaiters;
     private callSeq;
     private readonly trackedValues;
     private trackedKeySeq;
@@ -137,7 +138,7 @@ export declare class Popcorn<Output extends TtyOutput = "text"> {
      *
      * Call {@link boot} to start the VM.
      **/
-    constructor(opts: PopcornOpts<Output>);
+    constructor(opts?: PopcornOpts<Output>);
     private spawnWorker;
     /**
      * Creates an instance and waits for {@link boot}.
@@ -146,7 +147,7 @@ export declare class Popcorn<Output extends TtyOutput = "text"> {
      *
      * @returns Ok tuple or `runtime:eval-unavailable` if the page blocks JavaScript evaluation.
      */
-    static init<Output extends TtyOutput = "text">(opts: PopcornOpts<Output>): Promise<Result<Popcorn<Output>>>;
+    static init<Output extends TtyOutput = "text">(opts?: PopcornOpts<Output>): Promise<Result<Popcorn<Output>>>;
     /**
      * Starts the VM and waits for its bridge and entrypoint application.
      *
@@ -229,8 +230,11 @@ export declare class Popcorn<Output extends TtyOutput = "text"> {
     private castBridge;
     private nextCallId;
     private runJs;
+    private handleReadyRequest;
+    private flushReadyWaiters;
+    private sendReadyReply;
     private asRef;
-    private sendRunJsReply;
+    private sendBridgeReply;
     private jsWithCurrentEnv;
     private reviveHandles;
     /** Maps pids and `TrackedValue`s during encoding, collecting handles into

package/dist/types.d.ts

@@ -66,6 +66,9 @@ export type BeamEvent = {
 } | {
     type: "otp:run_js";
     payload: RunJsRequest;
+} | {
+    type: "otp:await-ready";
+    payload: ReadyRequest;
 } | {
     type: "otp:tracked-value-delete";
     payload: number;
@@ -76,6 +79,9 @@ export type RunJsRequest = {
     replyTo: Uint8Array;
     return: "value" | "ref";
 };
+export type ReadyRequest = {
+    replyTo: Uint8Array;
+};
 /**
  * VM shutdown notification.
  *

package/dist/worker.mjs

@@ -240,7 +240,7 @@ function readMainEvent(value) {
         case "popcorn:stdin":
         case "popcorn:tty-resize":
         case "popcorn:send":
-        case "popcorn:run-js-reply":
+        case "popcorn:bridge-reply":
             return data;
         default:
             unreachable();
@@ -269,6 +269,11 @@ function deserializeBridgeMessage(text) {
                         return: parsed.return,
                     },
                 };
+            case "await_ready":
+                return {
+                    type: "otp:await-ready",
+                    payload: { replyTo: base64ToBytes(parsed.reply_to) },
+                };
             default:
                 return null;
         }
@@ -289,7 +294,12 @@ function getTransferables(event) {
     return [event.payload.buffer];
 }
 function isBridgeEnvelope(value) {
-    const KNOWN_MESSAGE_TYPES = ["vm_message", "vm_error", "run_js"];
+    const KNOWN_MESSAGE_TYPES = [
+        "vm_message",
+        "vm_error",
+        "run_js",
+        "await_ready",
+    ];
     const data = objectWithKeys(value, ["type"]);
     return data !== null && KNOWN_MESSAGE_TYPES.includes(data.type);
 }
@@ -314,31 +324,82 @@ const T = {
     PREFIX_N: 155,
     /// entry type=dir, '5' in ASCII
     TYPE_DIR: 53,
+    /// entry type=PAX extended header, 'x' in ASCII
+    TYPE_PAX: 120,
 };
 function extractTar(data, onDir, onFile) {
     check(data.length % T.BLK_N === 0, "tar:bad_chunk");
     const decoder = new TextDecoder();
     let offset = 0;
+    let paxPath = null;
     while (offset + T.BLK_N <= data.length) {
         const header = data.slice(offset, offset + T.BLK_N);
-        if (isZeroBlock(header))
+        if (isZeroBlock(header)) {
+            check(paxPath === null, "tar:dangling_pax");
             break;
+        }
         const name = readString(decoder, header, T.NAME_OFF, T.NAME_N);
         const prefix = readString(decoder, header, T.PREFIX_OFF, T.PREFIX_N);
-        const fullName = prefix ? `${prefix}/${name}` : name;
+        const headerName = prefix ? `${prefix}/${name}` : name;
         const size = parseOctal(readString(decoder, header, T.SIZE_OFF, T.SIZE_N));
         const type = header[T.TYPEFLAG_OFF];
         offset += T.BLK_N;
-        const path = fullName.startsWith("/") ? fullName : `/${fullName}`;
-        if (type === T.TYPE_DIR) {
-            onDir(path);
+        check(offset + size <= data.length, "tar:truncated_entry");
+        const contents = data.slice(offset, offset + size);
+        if (type === T.TYPE_PAX) {
+            check(paxPath === null, "tar:unexpected_pax");
+            paxPath = readPaxPath(decoder, contents);
         }
-        else if (fullName) {
-            const contents = data.slice(offset, offset + size);
-            onFile(path, contents);
+        else {
+            const fullName = paxPath ?? headerName;
+            paxPath = null;
+            const path = fullName.startsWith("/") ? fullName : `/${fullName}`;
+            if (type === T.TYPE_DIR) {
+                onDir(path);
+            }
+            else if (fullName) {
+                onFile(path, contents);
+            }
         }
         offset += Math.ceil(size / T.BLK_N) * T.BLK_N;
     }
+    check(paxPath === null, "tar:dangling_pax");
+}
+function readPaxPath(decoder, data) {
+    let offset = 0;
+    let path = null;
+    while (offset < data.length) {
+        const { length, recordStart } = readPaxLength(decoder, data, offset);
+        const recordEnd = offset + length;
+        offset = recordEnd;
+        const [key, value] = readPaxRecord(decoder, data, recordStart, recordEnd);
+        if (key === "path") {
+            check(value.length > 0, "tar:bad_pax_path");
+            path = value;
+        }
+    }
+    check(path !== null, "tar:missing_pax_path");
+    return path;
+}
+function readPaxLength(decoder, data, offset) {
+    const SPACE = 32;
+    const separator = data.indexOf(SPACE, offset);
+    check(separator > offset, "tar:bad_pax_length");
+    const source = decoder.decode(data.subarray(offset, separator));
+    const length = Number(source);
+    const isInt = Number.isSafeInteger(length) && length >= 0 && String(length) === source;
+    check(isInt, "tar:bad_pax_length");
+    return { length, recordStart: separator + 1 };
+}
+function readPaxRecord(decoder, data, start, end) {
+    const record = decoder.decode(data.subarray(start, end));
+    check(record.endsWith("\n"), "tar:bad_pax_record");
+    const separator = record.indexOf("=");
+    check(separator > 0, "tar:bad_pax_record");
+    const key = record.slice(0, separator);
+    // drop '\n'
+    const value = record.slice(separator + 1, -1);
+    return [key, value];
 }
 function isZeroBlock(block) {
     for (let i = 0; i < block.length; i++) {
@@ -743,7 +804,7 @@ self.onmessage = async (event) => {
             });
             break;
         }
-        case "popcorn:run-js-reply": {
+        case "popcorn:bridge-reply": {
             // ignore the `send()` result, process could've died
             check(instance !== null);
             instance.send(data.payload.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/popcorn",
-  "version": "0.4.0-next.0",
+  "version": "0.4.0-next.2",
   "description": "JS bindings for BEAM/OTP in WebAssembly",
   "type": "module",
   "license": "Apache-2.0",
@@ -56,14 +56,14 @@
     }
   },
   "devDependencies": {
-    "@playwright/test": "^1.61.1",
+    "@playwright/test": "1.63.0",
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/node": "^25.0.8",
     "esbuild": "^0.25.0",
     "rollup": "^4.55.1",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
-    "vite": "^7.3.1"
+    "vite": "^7.3.6"
   },
   "scripts": {
     "build": "rollup -c",

package/dist/plugins/beam_tools/lib/popcorn/beam_tools/beam_patcher.ex

@@ -1,184 +0,0 @@
-defmodule Popcorn.BeamTools.BeamPatcher do
-  @moduledoc """
-  Replaces functions in a compiled BEAM with implementations taken from a patch
-  module, by merging both modules as Core Erlang and recompiling with the host
-  compiler.
-
-  A patch function replaces the original of the same name and arity, including
-  for calls made from the original module's own code. Exported patch functions
-  listed in `-compile([{popcorn_patch_private, [{f, a}]}])` stay private.
-  `popcorn_module:f(...)` calls the original implementation of `f`.
-  """
-
-  @orig_prefix "popcorn_orig"
-  @patch_prefix "popcorn_patch"
-
-  @doc """
-  Compiles `patch_path` and merges it into the BEAM at `beam_path`, overwriting it.
-  """
-  def patch_beam(beam_path, patch_path) do
-    with {:ok, original} <- read_ast(beam_path),
-         {:ok, patch} <- compile_patch(patch_path) do
-      beam =
-        original
-        |> merge_modules(patch)
-        |> serialize()
-
-      File.write!(beam_path, beam)
-      :ok
-    end
-  end
-
-  defp read_ast(beam_path) do
-    case :beam_lib.chunks(to_charlist(beam_path), [:abstract_code]) do
-      {:ok, {_module, [abstract_code: {_backend, abstract_code}]}} ->
-        {:ok, _module, ast} = :compile.noenv_forms(abstract_code, [:to_core])
-        {:ok, ast}
-
-      _ ->
-        err(:unpatchable_beam, beam_path)
-    end
-  end
-
-  defp compile_patch(patch_path) do
-    case :compile.file(to_charlist(patch_path), [:binary, :debug_info, :return_errors, :to_core]) do
-      {:ok, _module, ast} ->
-        {:ok, ast}
-
-      {:error, errors, _warnings} ->
-        err(:bad_patch, {patch_path, errors})
-    end
-  end
-
-  defp serialize(ast) do
-    {:ok, _module, beam} = :compile.noenv_forms(ast, [:from_core, debug_info: {:core_v1, ast}])
-    beam
-  end
-
-  defp merge_modules(orig_ast, patch_ast) do
-    {:c_module, _meta, module_spec, orig_exports, orig_specs, orig_body} = orig_ast
-    {:c_module, _meta, _module_spec, patch_exports, patch_specs, patch_body} = patch_ast
-    private_overrides = private_overrides(patch_specs)
-    orig_exports = MapSet.new(orig_exports, fn {:c_var, _meta, fa} -> fa end)
-
-    patch_exports =
-      patch_exports
-      |> MapSet.new(fn {:c_var, _meta, fa} -> fa end)
-      |> MapSet.difference(private_overrides)
-      |> MapSet.difference(MapSet.new(module_info: 0, module_info: 1))
-
-    exports = MapSet.union(orig_exports, patch_exports)
-    replaced = MapSet.union(patch_exports, private_overrides)
-
-    # Everything the patch does not replace keeps its name: the module's own
-    # `-nifs` declarations and internal calls refer to private functions by name.
-    # Replaced originals are renamed rather than dropped so a patch can delegate
-    # to them; an original nothing delegates to is dead code and the compiler
-    # removes it. Patch-private helpers are renamed so they cannot collide with
-    # an original of the same name.
-    orig_body = rename_replaced_funs(orig_body, replaced)
-
-    patch_body =
-      patch_body
-      |> rename_funs_and_local_calls(%{prefix: @patch_prefix, except: replaced})
-      |> inject_original_calls(replaced)
-
-    exports_ast = exports |> Enum.sort() |> Enum.map(&{:c_var, [], &1})
-
-    {:c_module, [], module_spec, exports_ast, orig_specs ++ patch_specs, patch_body ++ orig_body}
-  end
-
-  defp private_overrides(patch_specs) do
-    patch_specs
-    |> Enum.flat_map(fn
-      {{:c_literal, _meta1, :compile}, {:c_literal, _meta2, params}} -> params
-      _other -> []
-    end)
-    |> Enum.flat_map(fn
-      {:popcorn_patch_private, funs} -> List.wrap(funs)
-      _other -> []
-    end)
-    |> MapSet.new()
-  end
-
-  defp rename_replaced_funs(ast, funs) do
-    Enum.map(ast, fn
-      {{:c_var, var_meta, {fun, arity}}, definition} ->
-        if {fun, arity} in funs do
-          {{:c_var, var_meta, {prefixed(@orig_prefix, fun), arity}}, definition}
-        else
-          {{:c_var, var_meta, {fun, arity}}, definition}
-        end
-
-      form ->
-        form
-    end)
-  end
-
-  defp inject_original_calls(ast, replaced) do
-    with {:c_call, call_meta, mod_ast, fun_ast, args} <- ast,
-         {:c_literal, _mod_meta, :popcorn_module} <- mod_ast,
-         {:c_literal, fun_meta, fun} <- fun_ast do
-      arity = length(args)
-      original = if {fun, arity} in replaced, do: prefixed(@orig_prefix, fun), else: fun
-
-      {:c_apply, call_meta, {:c_var, fun_meta, {original, arity}}, args}
-    else
-      _other -> traverse(ast, &inject_original_calls(&1, replaced))
-    end
-  end
-
-  defp rename_funs_and_local_calls({:c_var, meta, {function, arity} = fa} = ast, ctx)
-       when is_atom(function) and is_integer(arity) do
-    if fa in ctx.except do
-      ast
-    else
-      {:c_var, meta, {prefixed(ctx.prefix, function), arity}}
-    end
-  end
-
-  defp rename_funs_and_local_calls({:function, {function, arity} = fa} = ast, ctx)
-       when is_atom(function) and is_integer(arity) do
-    if fa in ctx.except do
-      ast
-    else
-      {:function, {prefixed(ctx.prefix, function), arity}}
-    end
-  end
-
-  defp rename_funs_and_local_calls({:id, {line, col, id}}, ctx) do
-    id =
-      case Atom.to_string(id) do
-        "-" <> id -> id
-        id -> id
-      end
-
-    {:id, {line, col, prefixed("-" <> ctx.prefix, id)}}
-  end
-
-  defp rename_funs_and_local_calls(ast, ctx) do
-    traverse(ast, &rename_funs_and_local_calls(&1, ctx))
-  end
-
-  defp prefixed(prefix, name), do: String.to_atom("#{prefix}_#{name}")
-
-  defp traverse(ast, fun) when is_tuple(ast) do
-    ast |> Tuple.to_list() |> fun.() |> List.to_tuple()
-  end
-
-  defp traverse([h | t], fun) do
-    [fun.(h) | fun.(t)]
-  end
-
-  defp traverse(ast, _fun) do
-    ast
-  end
-
-  defp err(:unpatchable_beam, beam_path) do
-    {:error, %{code: "unpatchable_beam", beam: beam_path}}
-  end
-
-  defp err(:bad_patch, {patch_path, errors}) do
-    {:error, %{code: "bad_patch", patch: patch_path, errors: inspect(errors)}}
-  end
-end

package/dist/plugins/beam_tools/lib/popcorn/beam_tools/cli.ex

@@ -1,74 +0,0 @@
-defmodule Popcorn.BeamTools.CLI do
-  alias Popcorn.BeamTools.Packager
-
-  @options [
-    root_dir: :string,
-    entrypoint_app: :string,
-    extra_app: [:string, :keep],
-    out_dir: :string,
-    runtimes_dir: :string,
-    runtime_variant: :string,
-    strip: :boolean
-  ]
-
-  @required_options [:root_dir, :out_dir, :runtimes_dir]
-
-  def main(argv) do
-    if String.to_integer(System.otp_release()) < 27 do
-      IO.puts(:stderr, "Popcorn requires OTP 27 or later")
-      System.halt(1)
-    end
-
-    argv
-    |> run()
-    |> report()
-    |> encode_json()
-    |> IO.puts()
-  end
-
-  def run(argv) do
-    with {:ok, options} <- parse_argv(argv) do
-      Packager.run(options)
-    end
-  end
-
-  defp parse_argv(argv) do
-    {opts, [], invalid} = OptionParser.parse(argv, strict: @options)
-    missing_opts = Enum.reject(@required_options, &Keyword.has_key?(opts, &1))
-
-    case {invalid, missing_opts} do
-      {[], []} ->
-        options =
-          opts
-          |> Keyword.delete(:extra_app)
-          |> Map.new()
-          |> Map.put(:extra_apps, Keyword.get_values(opts, :extra_app))
-          |> Map.put_new(:entrypoint_app, nil)
-          |> Map.put_new(:runtime_variant, nil)
-          |> Map.put_new(:strip, false)
-
-        {:ok, options}
-
-      _ ->
-        bad_args(invalid, missing_opts)
-    end
-  end
-
-  defp bad_args(invalid, missing_opts) do
-    invalid =
-      Enum.map(invalid, fn {option, value} ->
-        %{option: option, value: value}
-      end)
-
-    missing = Enum.map(missing_opts, &to_string/1)
-
-    {:error, %{code: "bad_args", invalid: invalid, missing: missing}}
-  end
-
-  defp report({:ok, report}), do: report
-  defp report({:error, error}), do: %{ok: false, error: error}
-
-  defp encode_json(term) do
-    term |> :json.encode() |> IO.iodata_to_binary()
-  end
-end