@swmansion/popcorn 0.3.3 → 0.4.0-next.2

package/dist/plugins/esbuild.d.ts

@@ -1,3 +1,11 @@
 import type { Plugin } from "esbuild";
-import { type PopcornPluginOptions } from "./shared";
-export declare function popcorn(options: PopcornPluginOptions): Plugin;
+import { type Options } from "./shared";
+/**
+ * Copies the worker, VM runtime, and `otp/` assets into the output directory after a successful esbuild build.
+ *
+ * Requires `format: "esm"` and either `outdir` or `outfile`.
+ * If the application bundle is elsewhere, set `PopcornOpts.workerUrl` to the copied `worker.mjs`.
+ *
+ * @see {@link Options} for application packaging and server requirements.
+ */
+export declare function popcorn(options: Options): Plugin;

package/dist/plugins/esbuild.mjs

@@ -1,54 +1,53 @@
-import { mkdir, copyFile } from 'fs/promises';
-import { dirname, resolve, basename, join } from 'path';
-import { fileURLToPath } from 'url';
+import { mkdir, cp, rm } from 'node:fs/promises';
+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';
 
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-// Plugin is at dist/plugins/esbuild.mjs, dist/ is one level up
-const popcornDistDir = resolve(__dirname$1, "..");
+/**
+ * Copies the worker, VM runtime, and `otp/` assets into the output directory after a successful esbuild build.
+ *
+ * Requires `format: "esm"` and either `outdir` or `outfile`.
+ * If the application bundle is elsewhere, set `PopcornOpts.workerUrl` to the copied `worker.mjs`.
+ *
+ * @see {@link Options} for application packaging and server requirements.
+ */
 function popcorn(options) {
-    const bundles = options.bundlePaths.map((p) => ({
-        name: basename(p),
-        dir: dirname(p),
-    }));
     let outputDir;
     return {
-        name: "popcorn",
+        name: "popcorn-otp",
         setup(build) {
             build.onStart(() => {
                 const opts = build.initialOptions;
-                const isEsm = opts.format === "esm";
-                const outdirFallback = opts.outfile !== undefined ? dirname(opts.outfile) : undefined;
-                const outdir = opts.outdir ?? outdirFallback;
-                if (!isEsm) {
-                    throw new Error("[popcorn] Popcorn works only with esm type builds.");
-                }
-                if (outdir === undefined) {
-                    throw new Error("[popcorn] outdir is not specified, cannot copy files");
-                }
-                outputDir = outdir;
+                const outdir = opts.outdir ??
+                    (opts.outfile === undefined ? undefined : dirname(opts.outfile));
+                assert(opts.format === "esm", "Popcorn OTP works only with esm builds.");
+                assert(outdir !== undefined, "outdir is not specified, cannot copy files");
+                outputDir = resolve(outdir);
             });
-            build.onEnd(async () => {
-                await mkdir(outputDir, { recursive: true });
+            build.onEnd(async (result) => {
+                if (result.errors.length > 0)
+                    return;
+                assert(outputDir !== undefined, "outdir was not resolved");
+                const outDir = outputDir;
+                const prepared = await popcorn$1(options);
                 try {
-                    await Promise.all([
-                        // Copy bundles to output directory
-                        ...bundles.map((b) => copy(b.name, { inDir: b.dir, outDir: outputDir })),
-                        // Copy popcorn runtime files to output directory
-                        // These need to be alongside the bundled code for import.meta.url to work
-                        copy("iframe.mjs", { inDir: popcornDistDir, outDir: outputDir }),
-                        copy("AtomVM.mjs", { inDir: popcornDistDir, outDir: outputDir }),
-                        copy("AtomVM.wasm", { inDir: popcornDistDir, outDir: outputDir }),
-                    ]);
+                    await mkdir(outDir, { recursive: true });
+                    await cp(prepared.dir, outDir, { recursive: true });
                 }
-                catch (err) {
-                    throw new Error("[popcorn] Failed to copy files", { cause: err });
+                finally {
+                    await rm(prepared.dir, { recursive: true, force: true });
                 }
             });
         },
     };
 }
-async function copy(name, { inDir, outDir }) {
-    return copyFile(join(inDir, name), join(outDir, name));
+function assert(ok, message) {
+    if (!ok) {
+        throw new Error(`[popcorn-otp] ${message}`);
+    }
 }
 
 export { popcorn };

package/dist/plugins/rollup.d.ts

@@ -1,3 +1,11 @@
 import type { Plugin } from "rollup";
-import { type PopcornPluginOptions } from "./shared";
-export declare function popcorn(options: PopcornPluginOptions): Plugin<unknown>;
+import { type Options } from "./shared";
+/**
+ * Copies the worker, VM runtime, and `otp/` assets into the output directory after Rollup writes the bundle.
+ *
+ * Requires `output.format: "es"` and either `output.dir` or `output.file`.
+ * If the application bundle is elsewhere, set `PopcornOpts.workerUrl` to the copied `worker.mjs`.
+ *
+ * @see {@link Options} for application packaging and server requirements.
+ */
+export declare function popcorn(options: Options): Plugin;

package/dist/plugins/rollup.mjs

@@ -1,35 +1,50 @@
-import { readFile } from 'fs/promises';
-import { dirname, resolve, basename } from 'path';
-import { fileURLToPath } from 'url';
+import { mkdir, cp, rm } from 'node:fs/promises';
+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';
 
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-// Plugin is at dist/plugins/rollup.mjs, dist/ is one level up
-const popcornDistDir = resolve(__dirname$1, "..");
+/**
+ * Copies the worker, VM runtime, and `otp/` assets into the output directory after Rollup writes the bundle.
+ *
+ * Requires `output.format: "es"` and either `output.dir` or `output.file`.
+ * If the application bundle is elsewhere, set `PopcornOpts.workerUrl` to the copied `worker.mjs`.
+ *
+ * @see {@link Options} for application packaging and server requirements.
+ */
 function popcorn(options) {
-    const bundles = options.bundlePaths.map((p) => ({
-        path: p,
-        name: basename(p),
-    }));
+    let outputDir;
     return {
-        name: "popcorn",
-        async generateBundle() {
-            // Emit bundles
-            for (const bundle of bundles) {
-                this.emitFile({
-                    type: "asset",
-                    fileName: resolve(popcornDistDir, bundle.name),
-                    source: await readFile(bundle.path),
-                });
+        name: "popcorn-otp",
+        renderStart(outputOptions) {
+            assert(outputOptions.format === "es", "Popcorn OTP works only with esm builds.");
+            let dir = outputOptions.dir;
+            if (dir === undefined && outputOptions.file !== undefined) {
+                dir = dirname(outputOptions.file);
             }
-            // Emit popcorn runtime files to output directory
-            // These need to be alongside the bundled code for import.meta.url to work
-            for (const name of ["iframe.mjs", "AtomVM.mjs", "AtomVM.wasm"]) {
-                const sourcePath = resolve(popcornDistDir, name);
-                const source = await readFile(sourcePath);
-                this.emitFile({ type: "asset", fileName: name, source });
+            assert(dir !== undefined, "output dir is not specified, cannot copy files");
+            outputDir = resolve(dir);
+        },
+        async writeBundle() {
+            assert(outputDir !== undefined, "output dir was not resolved");
+            const outDir = outputDir;
+            const prepared = await popcorn$1(options);
+            try {
+                await mkdir(outDir, { recursive: true });
+                await cp(prepared.dir, outDir, { recursive: true });
+            }
+            finally {
+                await rm(prepared.dir, { recursive: true, force: true });
             }
         },
     };
 }
+function assert(ok, message) {
+    if (!ok) {
+        throw new Error(`[popcorn-otp] ${message}`);
+    }
+}
 
 export { popcorn };

package/dist/plugins/shared.d.ts

@@ -1,7 +1,37 @@
-export declare const DIST_DIR = "node_modules/@swmansion/popcorn/dist";
-export type PopcornPluginOptions = {
+type RuntimeVariant = "core" | "crypto";
+/**
+ * Shared options for the Vite, Rollup, and esbuild plugins.
+ *
+ * The plugins invoke `mix popcorn.cook` in the project directory, which
+ * compiles the project before packaging it.
+ */
+export type Options = {
+    /** Runtime variant override. */
+    runtimeVariant?: RuntimeVariant;
+    /** Mix project directory. */
+    rootDir: string;
     /**
-     * Paths to .avm bundle files.
+     * OTP application to start after VM boot.
+     * Defaults to the current Mix application.
      */
-    bundlePaths: string[];
+    app?: string | null;
+    /** Additional applications to package with their dependencies. */
+    extraApps?: string[];
+    /** 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(options: Options): Promise<Prepared>;
+export declare function runtimeDirectory(variant: RuntimeVariant): string;
+export {};

package/dist/plugins/shared.mjs

@@ -0,0 +1,61 @@
+import { execFile } from 'node:child_process';
+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';
+
+const execFileAsync = promisify(execFile);
+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 {
+        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,
+            runtimeVariant: manifest.runtimeVariant,
+            notes: manifest.notes ?? [],
+        };
+    }
+    catch (error) {
+        await rm(dir, { recursive: true, force: true });
+        throw error;
+    }
+}
+function runtimeDirectory(variant) {
+    const distDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+    return resolve(distDir, "runtimes", variant);
+}
+function assert(ok, message) {
+    if (!ok)
+        throw new Error(`[popcorn-otp] ${message}`);
+}
+
+export { popcorn as p, runtimeDirectory as r };

package/dist/plugins/vite.d.ts

@@ -1,3 +1,23 @@
-import { type PopcornPluginOptions } from "./shared";
 import type { Plugin } from "vite";
-export declare function popcorn(options: PopcornPluginOptions): Plugin;
+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.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from "vite";
+ * import { popcorn } from "@swmansion/popcorn/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [popcorn({ rootDir: "../my_app" })],
+ * });
+ * ```
+ *
+ * @see {@link Options} for production server requirements.
+ */
+export declare function popcorn(options: Options): Plugin;

package/dist/plugins/vite.mjs

@@ -1,101 +1,224 @@
-import { readFile, stat } from 'fs/promises';
-import { dirname, resolve, basename } from 'path';
-import { fileURLToPath } from 'url';
+import { mkdir, cp, rm, readFile } from 'node:fs/promises';
+import { resolve, dirname, join, relative, isAbsolute } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { r as runtimeDirectory, p as popcorn$1 } from './shared.mjs';
+import 'node:child_process';
+import 'node:os';
+import 'node:util';
 
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-// Plugin is at dist/plugins/vite.mjs, dist/ is one level up
-const popcornDistDir = resolve(__dirname$1, "..");
+/** Headers required by the threaded WebAssembly runtime. */
+const crossOriginIsolationHeaders = {
+    "Cross-Origin-Opener-Policy": "same-origin",
+    "Cross-Origin-Embedder-Policy": "require-corp",
+};
+// Plugin is at dist/plugins/vite.mjs, dist/ is one level up.
+const distDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+/**
+ * Serves application assets during developmens.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from "vite";
+ * import { popcorn } from "@swmansion/popcorn/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [popcorn({ rootDir: "../my_app" })],
+ * });
+ * ```
+ *
+ * @see {@link Options} for production server requirements.
+ */
 function popcorn(options) {
-    const bundlePaths = options.bundlePaths;
-    const bundles = bundlePaths.map((p) => ({
-        path: p,
-        name: basename(p),
-        url: `/${basename(p)}`,
-    }));
-    let assetsDir;
+    const resolveRuntime = async (source, importer) => {
+        if (importer !== undefined &&
+            resolve(dirname(importer.split("?")[0]), source) ===
+                join(distDir, "beam.mjs")) {
+            const { runtimeVariant } = await ensurePrepared();
+            const runtimeDir = runtimeDirectory(runtimeVariant);
+            return join(runtimeDir, "beam.mjs");
+        }
+    };
+    let prepared;
+    let repacking;
+    let dirty = false;
+    let outDir;
+    let assetsDir = "assets";
+    // 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)
+            return Promise.resolve(prepared);
+        if (repacking === undefined) {
+            dirty = false;
+            repacking = popcorn$1(options)
+                .then(async (next) => {
+                if (prepared !== undefined) {
+                    await rm(prepared.dir, { recursive: true, force: true });
+                }
+                prepared = next;
+                return next;
+            })
+                .finally(() => {
+                repacking = undefined;
+            });
+        }
+        return repacking;
+    };
+    const cleanup = () => {
+        if (prepared !== undefined) {
+            rm(prepared.dir, { recursive: true, force: true });
+            prepared = undefined;
+        }
+    };
+    const serve = async (req, res, next) => {
+        const url = req.url;
+        if (url === undefined) {
+            next();
+            return;
+        }
+        const requestPath = decodeURIComponent(new URL(url, "http://localhost").pathname);
+        const requestRoot = [`/${assetsDir}/otp/`, `/@fs${distDir}/otp/`].find((root) => requestPath.startsWith(root));
+        if (requestRoot === undefined) {
+            next();
+            return;
+        }
+        let dir;
+        try {
+            ({ dir } = await ensurePrepared());
+        }
+        catch (error) {
+            next(error);
+            return;
+        }
+        const assetsRoot = join(dir, "otp");
+        const filePath = resolve(assetsRoot, requestPath.slice(requestRoot.length));
+        if (!isUnder(assetsRoot, filePath)) {
+            res.statusCode = 403;
+            res.end("Forbidden");
+            return;
+        }
+        try {
+            const compressible = isCompressible(filePath);
+            const encoding = compressible
+                ? selectEncoding(req.headers["accept-encoding"]?.toString())
+                : { name: null, suffix: "" };
+            if (compressible && encoding.name === null) {
+                res.statusCode = 406;
+                res.setHeader("Vary", "Accept-Encoding");
+                res.end("No supported content encoding");
+                return;
+            }
+            const content = await readFile(`${filePath}${encoding.suffix}`);
+            setContentType(res, filePath);
+            res.setHeader("Vary", "Accept-Encoding");
+            if (encoding.name !== null) {
+                res.setHeader("Content-Encoding", encoding.name);
+            }
+            res.end(content);
+        }
+        catch {
+            res.statusCode = 404;
+            res.end("Not found");
+        }
+    };
     return {
-        name: "popcorn",
+        name: "popcorn-otp",
+        enforce: "pre",
+        resolveId: resolveRuntime,
         config() {
             return {
-                // Exclude popcorn from prebundling so import.meta.url resolves correctly
-                optimizeDeps: {
-                    exclude: ["@swmansion/popcorn"],
+                // Exclude from prebundling so import.meta.url resolves correctly.
+                optimizeDeps: { exclude: ["@swmansion/popcorn"] },
+                worker: {
+                    format: "es",
+                    plugins: () => [
+                        {
+                            name: "popcorn-runtime",
+                            enforce: "pre",
+                            resolveId: resolveRuntime,
+                        },
+                    ],
                 },
             };
         },
-        async configResolved(config) {
-            const results = await Promise.allSettled(bundles.map((b) => stat(b.path)));
-            for (const [i, result] of results.entries()) {
-                if (result.status === "rejected") {
-                    this.error(`[popcorn] Bundle doesn't exist at '${bundles[i].path}'`);
-                }
-            }
-            config.server.fs.allow.push(popcornDistDir);
+        configResolved(config) {
+            config.server.fs.allow.push(distDir);
+            outDir = resolve(config.root, config.build.outDir);
             assetsDir = config.build.assetsDir;
         },
-        configureServer(server) {
-            server.middlewares.use(async (req, res, next) => {
-                setSharedArrayBufferHeaders(res);
-                for (const bundle of bundles) {
-                    const opts = { bundleUrl: bundle.url, bundlePath: bundle.path };
-                    const served = await serveAvmBundle(req, res, opts);
-                    if (served)
-                        return;
-                }
-                next();
+        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))
+                    dirty = true;
             });
+            server.middlewares.use(serve);
+            server.httpServer?.once("close", cleanup);
+            await ensurePrepared();
+            dirty = false;
         },
-        configurePreviewServer(server) {
-            server.middlewares.use(async (req, res, next) => {
-                setSharedArrayBufferHeaders(res);
-                for (const bundle of bundles) {
-                    const opts = { bundleUrl: bundle.url, bundlePath: bundle.path };
-                    const served = await serveAvmBundle(req, res, opts);
-                    if (served)
-                        return;
-                }
-                next();
-            });
+        async configurePreviewServer(server) {
+            server.httpServer?.prependListener("request", setIsolationHeaders);
+            server.middlewares.use(serve);
+            server.httpServer?.once("close", cleanup);
+            await ensurePrepared();
         },
-        async generateBundle() {
-            // Emit bundles to assets directory
-            for (const bundle of bundles) {
-                this.emitFile({
-                    type: "asset",
-                    fileName: `${assetsDir}/${bundle.name}`,
-                    source: await readFile(bundle.path),
-                });
+        async closeBundle() {
+            assert(outDir !== undefined, "outDir was not resolved");
+            const built = await ensurePrepared();
+            try {
+                const targetDir = join(outDir, assetsDir, "otp");
+                await mkdir(dirname(targetDir), { recursive: true });
+                await cp(join(built.dir, "otp"), targetDir, { recursive: true });
             }
-            // Emit AtomVM files to assets directory (same location as iframe.mjs)
-            // Vite treats iframe.mjs as a static asset and doesn't analyze its imports
-            for (const name of ["AtomVM.mjs", "AtomVM.wasm"]) {
-                this.emitFile({
-                    type: "asset",
-                    fileName: `${assetsDir}/${name}`,
-                    source: await readFile(resolve(popcornDistDir, name)),
-                });
+            finally {
+                await rm(built.dir, { recursive: true, force: true });
+                prepared = undefined;
             }
         },
     };
 }
-async function serveAvmBundle(req, res, { bundleUrl, bundlePath }) {
-    try {
-        if (req.url === bundleUrl) {
-            const content = await readFile(bundlePath);
-            res.setHeader("Content-Type", "application/octet-stream");
-            res.end(content);
-            return true;
-        }
-        return false;
+function isCompressible(path) {
+    return path.endsWith(".tar") || path.endsWith(".wasm");
+}
+function selectEncoding(header) {
+    if (header?.includes("br")) {
+        return { name: "br", suffix: ".br" };
     }
-    catch (err) {
-        console.error(`[popcorn] Failed to serve bundle:`, err);
-        throw err;
+    if (header?.includes("gzip"))
+        return { name: "gzip", suffix: ".gz" };
+    return { name: null, suffix: "" };
+}
+function isUnder(dir, file) {
+    const rel = relative(dir, file);
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function setIsolationHeaders(_req, res) {
+    for (const [key, value] of Object.entries(crossOriginIsolationHeaders)) {
+        res.setHeader(key, value);
+    }
+}
+function setContentType(res, path) {
+    if (path.endsWith(".mjs")) {
+        res.setHeader("Content-Type", "text/javascript");
+    }
+    else if (path.endsWith(".wasm")) {
+        res.setHeader("Content-Type", "application/wasm");
+    }
+    else if (path.endsWith(".json")) {
+        res.setHeader("Content-Type", "application/json");
+    }
+    else {
+        res.setHeader("Content-Type", "application/octet-stream");
     }
 }
-function setSharedArrayBufferHeaders(res) {
-    res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
-    res.setHeader("Cross-Origin-Embedder-Policy", "require-corp");
+function assert(ok, message) {
+    if (!ok) {
+        throw new Error(`[popcorn-otp] ${message}`);
+    }
 }
 
-export { popcorn };
+export { crossOriginIsolationHeaders, popcorn };