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

package/dist/types.d.ts

@@ -45,6 +45,7 @@ export type BeamBootOptions = {
     /** VM environment variables. */
     env?: Record<string, string>;
     ttySize: TtySize;
+    noshell: boolean;
     createModule: CreateModuleFn<EmscriptenModule>;
     emit: (event: BeamEvent) => void;
 };
@@ -66,6 +67,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 +80,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++) {
@@ -405,7 +466,7 @@ function start(options) {
     };
 }
 async function boot(opts, state, vm) {
-    const { otpAssetsRoot, emulatorArgs, extraArgs, env, ttySize, createModule, emit, } = opts;
+    const { otpAssetsRoot, emulatorArgs, extraArgs, env, ttySize, noshell, createModule, emit, } = opts;
     const loadedFsData = await loadFsData(otpAssetsRoot);
     if (!loadedFsData.ok) {
         return { ok: false, error: loadedFsData.error };
@@ -424,22 +485,34 @@ async function boot(opts, state, vm) {
         LINES: String(ttySize.rows),
         ERL_INETRC: INETRC_PATH,
     };
+    let emitError = function (payload) {
+        emitError = null;
+        state.isVmReady = false;
+        emit({ type: "otp:error", payload });
+    };
     const moduleConfig = {
         print: (text) => emit({ type: "otp:stdout", payload: UTF8.encode(text) }),
         printErr: (text) => emit({ type: "otp:stderr", payload: UTF8.encode(text) }),
-        onExit: (code) => emit({ type: "otp:error", payload: { kind: "exit", data: code } }),
-        onAbort: (text) => emit({ type: "otp:error", payload: { kind: "abort", data: text } }),
+        onExit: (code) => emitError?.({ kind: "exit", data: code }),
+        onAbort: (text) => emitError?.({ kind: "abort", data: text }),
         onBeamMessage: (text) => {
+            if (emitError === null) {
+                return;
+            }
             const event = deserializeBridgeMessage(text);
             if (event === null)
                 return;
+            if (event.type === "otp:error") {
+                emitError(event.payload);
+                return;
+            }
             if (handleVmReady(event))
                 return;
             if (handleAppReady(event))
                 return;
             emit(event);
         },
-        onError: (text) => emit({ type: "otp:error", payload: { kind: "error", data: text } }),
+        onError: (text) => emitError?.({ kind: "error", data: text }),
         onStdinConsumed: (size) => emit({ type: "otp:stdin-consumed", payload: size }),
         onTrackedValueDelete: (key) => emit({ type: "otp:tracked-value-delete", payload: key }),
         onTtyChunk: (fd, chunk) => emit({
@@ -449,6 +522,7 @@ async function boot(opts, state, vm) {
         arguments: buildArgs({
             appNames: fsData.appNames,
             entrypoint: fsData.entrypoint,
+            noshell,
             emulator: emulatorArgs ?? [],
             extra: extraArgs ?? [],
         }),
@@ -516,8 +590,10 @@ function toPopcornError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return err("worker:load", { message });
 }
-function buildArgs({ appNames, entrypoint, emulator, extra, }) {
+function buildArgs({ appNames, entrypoint, noshell, emulator, extra, }) {
     const args = [...emulator, "--", ...BASE_ARGS, "-boot", BOOT_NAME];
+    if (noshell)
+        args.push("-noshell");
     for (const app of CORE_APPS) {
         args.push("-pa", `/lib/${app}/ebin`);
     }
@@ -714,6 +790,7 @@ self.onmessage = async (event) => {
                 extraArgs: data.payload.extraArgs,
                 env: data.payload.env,
                 ttySize: data.payload.ttySize,
+                noshell: data.payload.noshell,
                 createModule,
                 emit: toMain,
             });
@@ -743,7 +820,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.3",
   "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