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

package/README.md

@@ -3,17 +3,22 @@
 Run Elixir in a browser with OTP/BEAM compiled to WebAssembly.
 This prerelease replaces the AtomVM runtime used by Popcorn 0.3.x.
 
+Start with the
+[versioned Popcorn guide](https://popcorn.hexdocs.pm/0.4.0-next.3/introduction.html).
+It includes a complete Mix and Vite tutorial.
+
 ## Install
 
 ```sh
 npm install @swmansion/popcorn@next
 ```
 
-Add `{:popcorn, "0.4.0-next.0"}` to your Elixir application's dependencies.
-Run `mix deps.get` and `mix compile` before building the JavaScript application.
-The bundler plugins invoke Mix locally to package application and standard-library code.
+Add `{:popcorn, "0.4.0-next.3"}` to your Elixir application's dependencies.
+Run `mix deps.get` before building the JavaScript application. The bundler
+plugins invoke Mix locally to compile and package application and
+standard-library code.
 
-Use the toolchain pinned in [popcorn/mise.toml](https://github.com/software-mansion/popcorn/blob/v0.4.0-next.0/popcorn/mise.toml).
+Use the toolchain pinned in [mise.toml](https://github.com/software-mansion/popcorn/blob/v0.4.0-next.3/mise.toml).
 The packager checks host OTP compatibility against the selected runtime's manifest.
 
 ## Configure Vite
@@ -26,13 +31,13 @@ export default defineConfig({
   plugins: [
     popcorn({
       rootDir: "../",
-      app: "my_app",
     }),
   ],
 });
 ```
 
-Set `rootDir` to the compiled Mix project's directory and `app` to its OTP application name.
+Set `rootDir` to the Mix project directory. The current Mix application is the
+default entrypoint. Set `app` to select another OTP application explicitly.
 Use `app: null` to package the base runtime without starting an application.
 
 The npm package contains two variants:
@@ -54,7 +59,7 @@ Use ESM output with those bundlers.
 ```ts
 import { Popcorn } from "@swmansion/popcorn";
 
-const result = await Popcorn.init({});
+const result = await Popcorn.init();
 if (!result.ok) throw result.error;
 
 const vm = result.data;
@@ -62,6 +67,10 @@ const vm = result.data;
 vm.deinit();
 ```
 
+`Popcorn.init()` waits for the OTP application tree to start. Use
+`popcorn.genserver.call()` to call a supervised GenServer from JavaScript.
+Use `popcorn.onEvent()` to receive events from BEAM processes.
+
 ## Serve in production
 
 Serve over HTTPS or localhost. Set these headers on the application and runtime responses:
@@ -73,7 +82,7 @@ Cross-Origin-Embedder-Policy: require-corp
 
 Vite sets these headers for development and preview. Configure your production server separately.
 Serve `.wasm` as `application/wasm`. Serve compressed `.tar.gz` files with `Content-Encoding: gzip` for `.tar` requests.
-The package also emits uncompressed tar files. Brotli variants require `brotli: true` and the corresponding server configuration.
+The package also emits uncompressed tar files and Brotli variants. Brotli uses standard effort by default. Set `brotliEffort: "max"` for maximum compression in release builds.
 
 The JavaScript bridge currently requires a Content Security Policy that permits `unsafe-eval`.
-See the [versioned Elixir API](https://popcorn.hexdocs.pm/0.4.0-next.0/) for interoperability details.
+See the [versioned Elixir API](https://popcorn.hexdocs.pm/0.4.0-next.3/) for interoperability details.

package/dist/events.d.ts

@@ -3,7 +3,7 @@ import { type Mapper } from "./etf";
 import type { AnyValue, BeamBootOptions, BeamEvent, BeamSendPayload, BeamTarget } from "./types";
 type BootEvent = {
     type: "popcorn:boot";
-    payload: Pick<BeamBootOptions, "emulatorArgs" | "extraArgs" | "env" | "ttySize"> & {
+    payload: Pick<BeamBootOptions, "emulatorArgs" | "extraArgs" | "env" | "ttySize" | "noshell"> & {
         otpAssetsRoot?: string;
     };
 };
@@ -24,12 +24,12 @@ type SendEvent = {
     type: "popcorn:send";
     payload: SendRequestPayload;
 };
-export type RunJsReplyPayload = {
+export type BridgeReplyPayload = {
     message: BeamSendPayload;
 };
-type RunJsReplyEvent = {
-    type: "popcorn:run-js-reply";
-    payload: RunJsReplyPayload;
+type BridgeReplyEvent = {
+    type: "popcorn:bridge-reply";
+    payload: BridgeReplyPayload;
 };
 export type SendRequestPayload = {
     id: string;
@@ -60,7 +60,7 @@ type BootEndEvent = {
     type: "popcorn:boot-fail";
     payload: SerializedError;
 };
-export type MainToVmEvent = BootEvent | SendEvent | RunJsReplyEvent | StdinEvent | TtyResizeEvent;
+export type MainToVmEvent = BootEvent | SendEvent | BridgeReplyEvent | StdinEvent | TtyResizeEvent;
 /**
  * A decoded BEAM message payload.
  *
@@ -73,7 +73,7 @@ export declare function readMainEvent(value: unknown): MainToVmEvent;
 export declare function readWorkerEvent(value: unknown): VmToMainEvent;
 export declare function serializeSendPayload(target: BeamTarget, payload: AnyValue, mapper?: Mapper): Result<BeamSendPayload, "bridge:unserializable">;
 export declare function deserializeBridgeMessage(text: string): Extract<BeamEvent, {
-    type: "otp:message" | "otp:error" | "otp:run_js";
+    type: "otp:message" | "otp:error" | "otp:run_js" | "otp:await-ready";
 }> | null;
 /** Usable only from main context. */
 export declare function toVm(worker: Worker, event: MainToVmEvent, transfer?: Transferable[]): void;

package/dist/index.mjs

@@ -480,6 +480,7 @@ function readWorkerEvent(value) {
         case "otp:error":
         case "otp:message":
         case "otp:run_js":
+        case "otp:await-ready":
         case "otp:tracked-value-delete":
         case "popcorn:boot-vm-ready":
         case "popcorn:boot-end":
@@ -553,6 +554,7 @@ class Popcorn {
     eventHandlers = new Set();
     pendingSends = new Map();
     pendingCalls = new Map();
+    readyWaiters = [];
     callSeq = 0;
     trackedValues = new Map();
     trackedKeySeq = 0;
@@ -585,6 +587,9 @@ class Popcorn {
                 this.vmReady = true;
                 this.runJs(data.payload);
                 return;
+            case "otp:await-ready":
+                this.handleReadyRequest(data.payload.replyTo);
+                return;
             case "otp:tracked-value-delete":
                 this.deleteTrackedValue(data.payload);
                 return;
@@ -614,7 +619,7 @@ class Popcorn {
      *
      * Call {@link boot} to start the VM.
      **/
-    constructor(opts) {
+    constructor(opts = {}) {
         const ttySize = opts.tty?.size ?? DEFAULT_TTY_SIZE;
         check(isValidTtySize(ttySize));
         check(opts.beam?.otpAssetsRoot === undefined ||
@@ -647,7 +652,7 @@ class Popcorn {
      *
      * @returns Ok tuple or `runtime:eval-unavailable` if the page blocks JavaScript evaluation.
      */
-    static async init(opts) {
+    static async init(opts = {}) {
         if (!canEval()) {
             return { ok: false, error: err$1("runtime:eval-unavailable", {}) };
         }
@@ -693,6 +698,7 @@ class Popcorn {
         this.Pid = createPidClass();
         this.io = createIoState();
         this.output = resolveOutputHandlers(this.opts);
+        check(this.readyWaiters.length === 0);
         this.state = { status: "booting" };
         return await new Promise((resolve) => {
             const timeoutsMs = { ...DEFAULT_TIMEOUTS_MS, ...this.opts.timeoutsMs };
@@ -724,6 +730,7 @@ class Popcorn {
                         break;
                     case "popcorn:boot-end":
                         this.state = { status: "booted" };
+                        this.flushReadyWaiters();
                         settle({ ok: true, data: this });
                         break;
                     case "popcorn:boot-fail": {
@@ -740,7 +747,11 @@ class Popcorn {
             this.vmWorker.addEventListener("message", onBootMessage);
             toVm(this.vmWorker, {
                 type: "popcorn:boot",
-                payload: { ...this.opts.beam, ttySize: this.ttySize },
+                payload: {
+                    ...this.opts.beam,
+                    ttySize: this.ttySize,
+                    noshell: this.opts.tty === undefined,
+                },
             });
         });
     }
@@ -888,6 +899,7 @@ class Popcorn {
         }
         this.state = { status: "closed", error };
         this.vmReady = false;
+        this.readyWaiters.length = 0;
         for (const resolve of this.pendingSends.values()) {
             resolve({ ok: false, error });
         }
@@ -1054,7 +1066,7 @@ class Popcorn {
             for (const { key, value, cleanup } of tracked) {
                 this.trackedValues.set(key, { value, cleanup });
             }
-            this.sendRunJsReply(command.data);
+            this.sendBridgeReply(command.data);
             return;
         }
         const failure = serializeSendPayload(target, {
@@ -1062,15 +1074,33 @@ class Popcorn {
             error: { unserializable: command.error.data.reason },
         });
         check(failure.ok);
-        this.sendRunJsReply(failure.data);
+        this.sendBridgeReply(failure.data);
+    }
+    handleReadyRequest(replyTo) {
+        if (this.state.status === "booted") {
+            this.sendReadyReply(replyTo);
+            return;
+        }
+        check(this.state.status === "booting");
+        this.readyWaiters.push(replyTo);
+    }
+    flushReadyWaiters() {
+        for (const replyTo of this.readyWaiters)
+            this.sendReadyReply(replyTo);
+        this.readyWaiters.length = 0;
+    }
+    sendReadyReply(replyTo) {
+        const message = serializeSendPayload({ pid: replyTo }, true);
+        check(message.ok);
+        this.sendBridgeReply(message.data);
     }
     asRef(value) {
         if (value instanceof this.TrackedValue)
             return value;
         return new this.TrackedValue(value);
     }
-    sendRunJsReply(message) {
-        toVm(this.vmWorker, { type: "popcorn:run-js-reply", payload: { message } }, [message.etf.buffer]);
+    sendBridgeReply(message) {
+        toVm(this.vmWorker, { type: "popcorn:bridge-reply", payload: { message } }, [message.etf.buffer]);
     }
     jsWithCurrentEnv(code) {
         const make = new Function("TrackedValue", `"use strict"; return (${code});`);

package/dist/plugins/esbuild.mjs

@@ -1,11 +1,10 @@
 import { mkdir, cp, rm } from 'node:fs/promises';
 import { dirname, resolve } from 'node:path';
-import { p as popcorn$1, c as copyRuntime } from './shared.mjs';
+import { p as popcorn$1 } from './shared.mjs';
 import 'node:child_process';
 import 'node:os';
 import 'node:util';
 import 'node:url';
-import 'node:zlib';
 
 /**
  * Copies the worker, VM runtime, and `otp/` assets into the output directory after a successful esbuild build.
@@ -36,12 +35,7 @@ function popcorn(options) {
                 const prepared = await popcorn$1(options);
                 try {
                     await mkdir(outDir, { recursive: true });
-                    await Promise.all([
-                        copyRuntime(outDir, prepared.runtimeVariant),
-                        cp(resolve(prepared.dir, "otp"), resolve(outDir, "otp"), {
-                            recursive: true,
-                        }),
-                    ]);
+                    await cp(prepared.dir, outDir, { recursive: true });
                 }
                 finally {
                     await rm(prepared.dir, { recursive: true, force: true });

package/dist/plugins/rollup.mjs

@@ -1,11 +1,10 @@
 import { mkdir, cp, rm } from 'node:fs/promises';
-import { resolve, dirname } from 'node:path';
-import { p as popcorn$1, c as copyRuntime } from './shared.mjs';
+import { dirname, resolve } from 'node:path';
+import { p as popcorn$1 } from './shared.mjs';
 import 'node:child_process';
 import 'node:os';
 import 'node:util';
 import 'node:url';
-import 'node:zlib';
 
 /**
  * Copies the worker, VM runtime, and `otp/` assets into the output directory after Rollup writes the bundle.
@@ -34,12 +33,7 @@ function popcorn(options) {
             const prepared = await popcorn$1(options);
             try {
                 await mkdir(outDir, { recursive: true });
-                await Promise.all([
-                    copyRuntime(outDir, prepared.runtimeVariant),
-                    cp(resolve(prepared.dir, "otp"), resolve(outDir, "otp"), {
-                        recursive: true,
-                    }),
-                ]);
+                await cp(prepared.dir, outDir, { recursive: true });
             }
             finally {
                 await rm(prepared.dir, { recursive: true, force: true });

package/dist/plugins/shared.d.ts

@@ -1,57 +1,37 @@
+type RuntimeVariant = "core" | "crypto";
 /**
  * Shared options for the Vite, Rollup, and esbuild plugins.
  *
- * Compile the project before the plugin runs.
- * The plugins use the local `mix` executable to package applications and dependencies.
- *
- * On the production server, set `Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp`.
- * Serve compressed variants with the matching `Content-Encoding` header.
+ * The plugins invoke `mix popcorn.cook` in the project directory, which
+ * compiles the project before packaging it.
  */
-type RuntimeVariant = "core" | "crypto";
 export type Options = {
-    /**
-     * Runtime variant override.
-     *
-     * By default, the plugin selects `crypto` when an application requires it and `core` otherwise.
-     */
+    /** Runtime variant override. */
     runtimeVariant?: RuntimeVariant;
-    /**
-     * Mix project directory.
-     *
-     * Reads compiled apps from `_build/$MIX_ENV/lib`, with `MIX_ENV` defaulting to `dev`.
-     */
+    /** Mix project directory. */
     rootDir: string;
     /**
      * OTP application to start after VM boot.
-     *
-     * Use `null` to boot without an entrypoint application.
-     */
-    app: string | null;
-    /**
-     * Additional applications to package with their dependencies.
-     *
-     * Does not start them automatically. Defaults to `[]`.
+     * Defaults to the current Mix application.
      */
+    app?: string | null;
+    /** Additional applications to package with their dependencies. */
     extraApps?: string[];
-    /**
-     * Adds Brotli tarball variants beside the gzip and uncompressed files.
-     *
-     * Defaults to `false`.
-     */
-    brotli?: boolean;
-    /**
-     * Removes nonessential BEAM chunks.
-     *
-     * Experimental. Defaults to `true`.
-     */
+    /** Brotli compression effort. Defaults to `standard`. */
+    brotliEffort?: "standard" | "max";
+    /** Removes nonessential BEAM chunks. Defaults to `true`. */
     strip?: boolean;
+    /** Controls removal of unreachable modules and functions. Defaults to `none`. */
+    treeshake?: TreeshakeOptions;
+};
+export type TreeshakeOptions = {
+    preservedApps?: string[];
 };
 export type Prepared = {
     dir: string;
     runtimeVariant: RuntimeVariant;
     notes: unknown[];
 };
-export declare function popcorn(opts: Options): Promise<Prepared>;
+export declare function popcorn(options: Options): Promise<Prepared>;
 export declare function runtimeDirectory(variant: RuntimeVariant): string;
-export declare function copyRuntime(targetDir: string, variant: RuntimeVariant): Promise<void>;
 export {};

package/dist/plugins/shared.mjs

@@ -1,207 +1,61 @@
 import { execFile } from 'node:child_process';
-import { mkdtemp, rm, mkdir, writeFile, copyFile, readFile } from 'node:fs/promises';
-import { resolve, dirname, normalize, basename } from 'node:path';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
 import { tmpdir } from 'node:os';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
-import { brotliCompress, gzip, constants } from 'node:zlib';
 
 const execFileAsync = promisify(execFile);
-const brotliCompressAsync = promisify(brotliCompress);
-const gzipAsync = promisify(gzip);
-async function popcorn(opts) {
-    const useBrotli = opts.brotli ?? false;
-    const strip = opts.strip ?? true;
-    const assetVariants = [
-        "uncompressed",
-        "gzip",
-        useBrotli && "brotli",
-    ];
-    const preparedDir = await mkdtemp(p `${tmpdir()}/popcorn-otp-`);
+async function popcorn(options) {
+    const dir = await mkdtemp(`${tmpdir()}/popcorn-otp-`);
+    const args = ["popcorn.cook", "--out-dir", dir];
+    if (options.app === null)
+        args.push("--no-app");
+    else if (options.app !== undefined)
+        args.push("--app", options.app);
+    for (const app of options.extraApps ?? [])
+        args.push("--extra-app", app);
+    if (options.runtimeVariant !== undefined) {
+        args.push("--runtime-variant", options.runtimeVariant);
+    }
+    if (options.brotliEffort !== undefined) {
+        args.push("--brotli-effort", options.brotliEffort);
+    }
+    if (options.strip === false)
+        args.push("--no-strip");
+    if (options.treeshake !== undefined) {
+        args.push("--treeshake");
+        for (const app of options.treeshake.preservedApps ?? []) {
+            args.push("--preserved-app", app);
+        }
+    }
     try {
-        const report = await withTmp(async (packedDir) => {
-            const report = await packTarballs({
-                rootDir: resolve(opts.rootDir),
-                outDir: packedDir,
-                runtimeVariant: opts.runtimeVariant,
-                app: opts.app,
-                extraApps: opts.extraApps ?? [],
-                strip,
-            });
-            if (!report.ok) {
-                throw new Error(`[popcorn-otp] ${formatPackError(report.error)}`);
-            }
-            await Promise.all([
-                copy(report.manifestPath, p `${preparedDir}/otp/manifest.json`),
-                copy(report.bootPath, p `${preparedDir}/otp/bin/vm.boot`),
-                copy(report.tarPaths, p `${preparedDir}/otp/lib`, {
-                    variants: assetVariants,
-                }),
-            ]);
-            return report;
+        await execFileAsync("mix", args, {
+            cwd: resolve(options.rootDir),
+            env: { ...process.env, MIX_QUIET: "1" },
         });
+        const manifestPath = resolve(dir, "otp/manifest.json");
+        const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+        assert(manifest.runtimeVariant === "core" ||
+            manifest.runtimeVariant === "crypto", "popcorn.cook did not report a runtime variant");
         return {
-            dir: preparedDir,
-            runtimeVariant: report.runtimeVariant,
-            notes: report.notes ?? [],
+            dir,
+            runtimeVariant: manifest.runtimeVariant,
+            notes: manifest.notes ?? [],
         };
     }
     catch (error) {
-        await rm(preparedDir, { recursive: true, force: true });
+        await rm(dir, { recursive: true, force: true });
         throw error;
     }
 }
 function runtimeDirectory(variant) {
-    if (variant !== "core" && variant !== "crypto") {
-        throw new Error(`[popcorn-otp] Unknown runtime variant: ${variant}`);
-    }
-    return p `${dirname(fileURLToPath(import.meta.url))}/../runtimes/${variant}`;
-}
-async function copyRuntime(targetDir, variant) {
-    const distDir = p `${dirname(fileURLToPath(import.meta.url))}/..`;
-    const runtimeDir = runtimeDirectory(variant);
-    await Promise.all(["worker.mjs", "beam.mjs", "beam.emu.mjs", "beam.wasm"].map((file) => copy(p `${file === "worker.mjs" ? distDir : runtimeDir}/${file}`, p `${targetDir}/${file}`)));
-}
-async function packTarballs(opts) {
-    const { rootDir, outDir, runtimeVariant, app, extraApps, strip } = opts;
-    const toolDir = p `${dirname(fileURLToPath(import.meta.url))}/beam_tools`;
-    const packerArgs = [
-        "run",
-        "--no-start",
-        "-e",
-        "Popcorn.BeamTools.CLI.main(System.argv())",
-        "--",
-        "--root-dir",
-        rootDir,
-        "--out-dir",
-        outDir,
-        "--runtimes-dir",
-        p `${toolDir}/../../runtimes`,
-    ];
-    if (runtimeVariant !== undefined) {
-        packerArgs.push("--runtime-variant", runtimeVariant);
-    }
-    if (app !== null) {
-        packerArgs.push("--entrypoint-app", app);
-    }
-    for (const extraApp of extraApps) {
-        packerArgs.push("--extra-app", extraApp);
-    }
-    if (strip) {
-        packerArgs.push("--strip");
-    }
-    const env = {
-        ...process.env,
-        MIX_BUILD_PATH: p `${outDir}/beam_tools_build`,
-        MIX_QUIET: "1",
-    };
-    const { stdout } = await execFileAsync("mix", packerArgs, {
-        cwd: toolDir,
-        env,
-    });
-    return JSON.parse(stdout);
-}
-function hasCode(error, code) {
-    return (typeof error === "object" &&
-        error !== null &&
-        error.code === code);
-}
-function isMissingDepError(error) {
-    return hasCode(error, "missing_dep");
+    const distDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+    return resolve(distDir, "runtimes", variant);
 }
-function isUnsupportedAppsError(error) {
-    return hasCode(error, "unsupported_apps");
-}
-function isMissingExtraAppsError(error) {
-    return hasCode(error, "missing_extra_apps");
-}
-function toolchainOf(error) {
-    if (typeof error !== "object" || error === null) {
-        return undefined;
-    }
-    return error.toolchain;
-}
-function errorLines(error) {
-    if (isMissingDepError(error)) {
-        return [
-            `${error.app} depends on ${error.dep}, which isn't available.`,
-            `BEAM applications come from your project build and your active`,
-            `Erlang/Elixir installation; nothing is bundled with the package.`,
-            `Apps built by your project: ${error.available_apps.join(", ")}.`,
-        ];
-    }
-    if (isUnsupportedAppsError(error)) {
-        const apps = error.apps
-            .map(({ app, capability }) => `${app} (needs ${capability})`)
-            .join(", ");
-        return [
-            `These applications need native support the Wasm runtime wasn't built`,
-            `with: ${apps}.`,
-            `Drop them from your dependencies, or use a runtime built with it.`,
-        ];
-    }
-    if (isMissingExtraAppsError(error)) {
-        return [
-            `Extra apps not found: ${error.apps.join(", ")}.`,
-            `They have to come from your project build or your Erlang/Elixir install.`,
-        ];
-    }
-    return [`packaging failed: ${JSON.stringify(error)}`];
-}
-function formatPackError(error) {
-    const lines = errorLines(error);
-    const toolchain = toolchainOf(error);
-    if (toolchain !== undefined) {
-        lines.push(`Using ${toolchain.executable} (Erlang/OTP ${toolchain.otp}, Elixir ${toolchain.elixir}).`);
-    }
-    return lines.join("\n  ");
-}
-async function copy(source, target, { variants = ["uncompressed"] } = {}) {
-    const sources = typeof source === "string" ? [source] : source;
-    const targetIsDir = typeof source !== "string";
-    await Promise.all(sources.map(async (sourcePath) => {
-        const targetPath = targetIsDir
-            ? p `${target}/${basename(sourcePath)}`
-            : target;
-        await mkdir(dirname(targetPath), { recursive: true });
-        let content;
-        const read = () => (content ??= readFile(sourcePath));
-        await Promise.all(variants
-            .filter((variant) => Boolean(variant))
-            .map(async (variant) => {
-            switch (variant) {
-                case "uncompressed":
-                    await copyFile(sourcePath, targetPath);
-                    break;
-                case "gzip": {
-                    const input = await read();
-                    const buffer = await gzipAsync(input, { level: 9 });
-                    await writeFile(`${targetPath}.gz`, buffer);
-                    break;
-                }
-                case "brotli": {
-                    const Q = constants.BROTLI_PARAM_QUALITY;
-                    const opts = { params: { [Q]: 11 } };
-                    const input = await read();
-                    const buffer = await brotliCompressAsync(input, opts);
-                    await writeFile(`${targetPath}.br`, buffer);
-                    break;
-                }
-            }
-        }));
-    }));
-}
-function p(strings, ...values) {
-    return normalize(String.raw(strings, ...values));
-}
-async function withTmp(f) {
-    const dir = await mkdtemp(p `${tmpdir()}/popcorn-otp-`);
-    try {
-        return await f(dir);
-    }
-    finally {
-        await rm(dir, { recursive: true, force: true });
-    }
+function assert(ok, message) {
+    if (!ok)
+        throw new Error(`[popcorn-otp] ${message}`);
 }
 
-export { copyRuntime as c, popcorn as p, runtimeDirectory as r };
+export { popcorn as p, runtimeDirectory as r };

package/dist/plugins/vite.d.ts

@@ -1,5 +1,10 @@
 import type { Plugin } from "vite";
 import { type Options } from "./shared";
+/** Headers required by the threaded WebAssembly runtime. */
+export declare const crossOriginIsolationHeaders: {
+    "Cross-Origin-Opener-Policy": string;
+    "Cross-Origin-Embedder-Policy": string;
+};
 /**
  * Serves application assets during developmens.
  *
@@ -9,7 +14,7 @@ import { type Options } from "./shared";
  * import { popcorn } from "@swmansion/popcorn/vite";
  *
  * export default defineConfig({
- *   plugins: [popcorn({ rootDir: "../my_app", app: "my_app" })],
+ *   plugins: [popcorn({ rootDir: "../my_app" })],
  * });
  * ```
  *