beam.com 0.1.0-rc.1 → 0.1.0-rc.2

package/README.md

@@ -20,10 +20,10 @@ With `beam.com` you can:
 - **Use Elixir and its tools** from one file: `mix.com`, `iex.com`,
   `elixir.com`. A Phoenix app with SQLite and `phx.gen.auth` runs from
   its source, with no C compiler.
-- **Deploy to Cloudflare Workers, Deno Deploy or a web page**:
-  `beam.com INPUT -o DIR --target wasm32` makes one directory that runs
-  the same program on all three, with a second runtime: ERTS compiled to
-  WebAssembly.
+- **Run the same file on Cloudflare Workers, Deno Deploy or a web page**:
+  the `app.com` of `beam.com INPUT -o app.com` also runs there, with a
+  second runtime: ERTS compiled to WebAssembly, in the npm package
+  `beam.com`.
 
 The file has the compiler, `crypto` and `ssl` (with OpenSSL), SQLite, and
 a WebAssembly runtime (WAMR). It is about 50 MB.
@@ -118,15 +118,6 @@ cd hello && ../mix.com deps.get && ../mix.com ecto.migrate
 ../iex.com -S mix phx.server                     # http://localhost:4000
 ```
 
-Make Cloudflare Workers of a program. The same directory runs on Deno:
-
-```sh
-beam.com examples/worker -o worker --target wasm32
-cd worker
-npx workerd serve worker.capnp                   # test on this computer (Workers)
-deno serve -A deno.js                            # or on Deno
-```
-
 One file runs natively and in the WebAssembly runtime. Each executable of
 `-o` also has its edge part, of 40 to 180 KB (`--no-edge` leaves it out).
 A release directory of `mix release` is an input too:
@@ -134,13 +125,72 @@ A release directory of `mix release` is an input too:
 ```sh
 beam.com _build/prod/rel/my_app -o my_app.com     # a Phoenix app
 PHX_SERVER=true ./my_app.com                     # natively
-cd worker && BEAM_APP=../my_app.com deno serve -A deno.js   # the same file on Deno
 ```
 
-The npm package `beam.com` has the runtime for Node.js, and `npx
-beam.com` (see [npm](#npm)).
+The npm package `beam.com` runs the same file on Cloudflare Workers, on
+Deno Deploy, in a web page and in Node.js. See [Deploy to the
+edge](#deploy-to-the-edge).
+
+## Deploy to the edge
+
+A project deploys its `app.com` to Cloudflare Workers and to Deno Deploy
+at each git push, with four small files and the npm package `beam.com`.
+The files do not change from one app to another:
+
+| File | What |
+|---|---|
+| `package.json` | The dev dependencies `beam.com` and `wrangler`, the script `build` (it makes `app.com` with `npx beam.com`), and the script `deploy` (`wrangler deploy`). |
+| `worker.js` | The entry, the same on both hosts. |
+| `wrangler.jsonc` | The name of the Worker, the Data rule for `*.com`, and for a stateful app the Durable Object. |
+| `deno.json` | The `deploy` key of Deno Deploy: `npm install`, `npm run build`, and the entrypoint `worker.js`. |
+
+The entry:
+
+```js
+import app from './app.com' with { type: 'bytes' };
+import { serve } from 'beam.com';
+export { Beam } from 'beam.com';   // stateful only
+
+const beam = serve(app);
+
+export default {
+  fetch(request, env, ctx) {
+    return beam.fetch(request, env, ctx);
+  },
+};
+```
+
+With the Durable Object `Beam` and its binding, the app is stateful: one
+VM serves all the requests, its timers run between requests, and its
+SQLite storage keeps the database. With no binding, it is stateless:
+each isolate runs its own VM. A Phoenix app needs no secret and no
+variable: the VM makes `SECRET_KEY_BASE` one time and keeps it, and
+`PHX_HOST` is the host of the first request.
+
+Test on this computer:
+
+```sh
+npm install && npm run build
+npx wrangler dev                 # Cloudflare Workers, in workerd
+npx deno serve -A worker.js      # Deno
+```
+
+[`examples/phoenix_demo`](examples/phoenix_demo) (stateful) and
+[`examples/worker`](examples/worker) (stateless) are such projects, with
+one-click buttons for both hosts. Copy one to start. See "Deploy at each
+git push" in [`docs/WORKERS.md`](docs/WORKERS.md).
+
+The program does not change. Its HTTP server (Bandit or Cowboy) listens
+with `gen_tcp`, and all of OTP is there. Outgoing HTTP goes through
+`fetch()` of the host, and other TCP through `connect()`. Give the build
+`--cacerts FILE` for HTTPS: the runtime has no root certificates of its
+own.
 
-See "One file, natively and at the edge" in [`docs/WORKERS.md`](docs/WORKERS.md).
+A Worker makes a snapshot of its booted VM at its first boot, and the
+next isolates restore it. For the shortest cold start, the build can
+also make one, and a stateless Worker then restores its VM before the
+first request: see "The snapshot of the build" in
+[`docs/WORKERS.md`](docs/WORKERS.md).
 
 ## Publish on GitHub Pages
 
@@ -166,14 +216,14 @@ jobs:
 ```
 
 Then turn on Pages one time: Settings, Pages, Source "GitHub Actions". The
-`GITHUB_TOKEN` cannot do this step. Until the first release (`v0.1.0`),
-use `@main` in place of `@v0.1.0`: the workflow then uses the `edge`
-build of `beam.com`.
+`GITHUB_TOKEN` cannot do this step. Until the release `v0.1.0`, use the
+release candidate `@v0.1.0-rc.2` in place of `@v0.1.0`. With `@main`, the
+workflow uses the `edge` build of `beam.com`.
 
 The workflow ([`pages-app.yml`](.github/workflows/pages-app.yml)) builds
-the app with `beam.com --target wasm32`, and publishes the static site
-`DIR/page/`. A Mix project with Phoenix becomes a release first
-(`mix.com release`). Its inputs:
+the app with `beam.com INPUT -o DIR --page`, and publishes the static site
+`DIR`: the native file `app.com` and the page that runs it. A Mix project
+with Phoenix becomes a release first (`mix.com release`). Its inputs:
 
 | Input | Default | What |
 |---|---|---|
@@ -201,8 +251,8 @@ NIFs of the WebAssembly runtime. The limits:
   site closes, the data goes, and the next visit starts from the snapshot
   of the boot.
 - No outgoing TCP: a connection of Erlang gets `econnrefused`.
-- The first visit downloads `beam.wasm` (about 6.5 MB) and `release.bin`
-  (3.5 to 14 MB for a Phoenix app).
+- The first visit downloads `beam.wasm` (about 6.5 MB) and the parts of
+  `app.com` that the release needs (about 13 MB for a Phoenix app).
 - The browser needs JSPI: Chrome and Edge 137 or later, or Firefox 153
   or later.
 
@@ -230,6 +280,13 @@ release, and checks its SHA-256 against the value that the package
 holds. Then the file stays in the cache (`~/.cache/beam.com/npm/`). A
 host that only uses the runtime never downloads it.
 
+Each GitHub release from 0.1.0-rc.2 also holds the package, the same
+file as on npm. npm installs it with no registry:
+
+```sh
+npm install https://github.com/sntran/BEAM.com/releases/download/v0.1.0-rc.2/beam.com-0.1.0-rc.2.tgz
+```
+
 - `BEAM_COM`: the path of a `beam.com` to use. Then nothing is
   downloaded.
 - `BEAM_COM_DOWNLOAD`: the URL of a directory with the file `beam.com`,
@@ -268,34 +325,9 @@ The other modules of the package:
 | `beam.com/worker` | The runtime (`worker.js` of Cloudflare Workers). |
 | `beam.com/beam.wasm` | The VM: ERTS built for WebAssembly. |
 
-The same `app.com` runs on Cloudflare Workers, on Deno Deploy and in a
-web page, with the runtime of the package. One entry runs on both hosts:
-
-```js
-import app from './app.com' with { type: 'bytes' };
-import { serve } from 'beam.com';
-export { Beam } from 'beam.com';   // stateful only
-
-const beam = serve(app);
-
-export default {
-  fetch(request, env, ctx) {
-    return beam.fetch(request, env, ctx);
-  },
-};
-```
-
-With the Durable Object `Beam` and its binding, the app is stateful: one
-VM serves all the requests, its timers run between requests, and its
-SQLite storage keeps the database. With no binding, it is stateless:
-each isolate runs its own VM. A project deploys at each git push: the
-build step of the host makes `app.com` (`npx beam.com`), and the host
-runs it. A Phoenix app needs no secret and no variable: the VM
-makes `SECRET_KEY_BASE` one time and keeps it, and `PHX_HOST` is the
-host of the first request. [`examples/phoenix_demo`](examples/phoenix_demo)
-(stateful) and [`examples/worker`](examples/worker) (stateless) are such
-projects, with one-click buttons for both hosts. See "Deploy at
-each git push" in [`docs/WORKERS.md`](docs/WORKERS.md).
+The same `app.com` runs on Cloudflare Workers and Deno Deploy with
+`serve(app)` (see [Deploy to the edge](#deploy-to-the-edge)), and in a
+web page with `main.js` of the package.
 
 The release job of CI makes the generated part of the package
 (`runtime/`, with `scripts/npm.sh`) and publishes it with each tag `v*`.
@@ -313,7 +345,7 @@ the Erlang shell in your browser is at
 |---|---|
 | [`docs/PROGRAMS.md`](docs/PROGRAMS.md) | Run and build programs: the inputs, Hex packages, command line programs, native files (`--target`), distributed Erlang, a release in the zip, debugging. |
 | [`docs/ELIXIR.md`](docs/ELIXIR.md) | Elixir programs, the tools (`mix`, `iex`, `elixir`), Phoenix from source, the file watcher. |
-| [`docs/WORKERS.md`](docs/WORKERS.md) | Cloudflare Workers, Deno Deploy and web pages (`--target wasm32`): Durable Objects, Ecto SQLite, snapshots, tenants, limits. |
+| [`docs/WORKERS.md`](docs/WORKERS.md) | Cloudflare Workers, Deno Deploy and web pages: `app.com` with the npm package, Durable Objects, Ecto SQLite, HTTP through `fetch()`, snapshots, tenants, static sites (`--page`), and limits. |
 | [`docs/NOTEBOOKS.md`](docs/NOTEBOOKS.md) | The documentation as notebooks that run in your browser: a tour of beam.com, the WebAssembly VM, the anatomy of the file, WebAssembly programs, hosts and storage, networking, and building programs. |
 | [`docs/LIBRARIES.md`](docs/LIBRARIES.md) | Crypto and TLS, SQLite, and WebAssembly in Erlang code. |
 | [`docs/SANDBOX.md`](docs/SANDBOX.md) | `--allow-read`, `--allow-write`, `--allow-net`, `--allow-run`: a program that gives up what it does not need. |

package/js/beam.com.mjs

@@ -1,11 +1,55 @@
 #!/usr/bin/env node
 // npx beam.com ARGS: beam.com of the version of this package, with ARGS
 // (download.mjs). For example: npx beam.com app.erl -o app.com
+//
+// npx beam.com --snapshot APP.com [-o FILE] [--full] [--warm PATH]...
+// [--env NAME=VALUE]...: the snapshot of the build of APP.com for
+// serve(app, { snapshot }) of a Worker (snapshot() of node.mjs), in FILE
+// (default APP.snapshot). It runs here, with no download of beam.com.
 import { spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { constants } from 'node:os';
 import { command, ensure } from './download.mjs';
 
+if (process.argv[2] === '--snapshot') {
+  try {
+    await snapshotCommand(process.argv.slice(3));
+    process.exit(0);
+  } catch (e) {
+    console.error(`beam.com: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+async function snapshotCommand(args) {
+  const opts = { env: {}, warm: [], kind: 'boot-point' };
+  let app = null, out = null;
+  while (args.length) {
+    const a = args.shift();
+    const value = () => {
+      if (!args.length) throw new Error(`${a} needs a value`);
+      return args.shift();
+    };
+    if (a === '-o') out = value();
+    else if (a === '--full') opts.kind = 'full';
+    else if (a === '--warm') opts.warm.push(value());
+    else if (a === '--env') {
+      const v = value(), at = v.indexOf('=');
+      if (at < 1) throw new Error(`--env ${v}: not NAME=VALUE`);
+      opts.env[v.slice(0, at)] = v.slice(at + 1);
+    } else if (!a.startsWith('-') && !app) app = a;
+    else throw new Error(`--snapshot: unknown argument ${a}`);
+  }
+  if (!app) throw new Error('usage: npx beam.com --snapshot APP.com [-o FILE] [--full] [--warm PATH]... [--env NAME=VALUE]...');
+  if (opts.warm.length && opts.kind !== 'full') throw new Error('--warm is for a full snapshot (--full)');
+  out ??= app.replace(/\.com$/, '') + '.snapshot';
+  const { snapshot } = await import('./node.mjs');
+  const t0 = performance.now();
+  const bytes = await snapshot(app, opts);
+  writeFileSync(out, bytes);
+  console.error(`beam.com: wrote ${out} (${(bytes.length / 1048576).toFixed(1)} MB, ${opts.kind}, in ${Math.round(performance.now() - t0)} ms)`);
+}
+
 let release = null;
 try {
   release = JSON.parse(readFileSync(new URL('../runtime/release.json', import.meta.url), 'utf8'));

package/js/node.mjs

@@ -47,8 +47,9 @@ export function release(app) {
   return readApp(app, appRelease);
 }
 
-// The release of app with get (appRelease, or appFiles: no copy).
-async function readApp(app, get) {
+// The release of app with get (appRelease, or appFiles: no copy), and the
+// options of get.
+async function readApp(app, get, options = {}) {
   const file = await fs.open(app);
   try {
     const { size } = await file.stat();
@@ -57,7 +58,7 @@ async function readApp(app, get) {
       const { bytesRead } = await file.read(b, 0, n, at);
       return b.subarray(0, bytesRead);
     };
-    return await get(read, size, { runtime: runtimeId });
+    return await get(read, size, { ...options, runtime: runtimeId });
   } finally {
     await file.close();
   }
@@ -66,10 +67,60 @@ async function readApp(app, get) {
 // The VM of an app.com, when it is ready. env: the variables of the VM.
 // There is no cache for snapshots in Node.js, so BEAM_SNAPSHOT is "off".
 // The VM keeps its state between requests (plain: false), as in Deno.
-export async function boot(app, { env = {} } = {}) {
-  const bin = await readApp(app, appFiles);
+// statics: false keeps the static files of a Phoenix app in the VM, as
+// serve(app) of a Worker does.
+export async function boot(app, { env = {}, statics = true } = {}) {
+  const bin = await readApp(app, appFiles, { statics });
   const { Vm } = await import(new URL('worker.js', runtimeUrl).href);
   const vm = new Vm({ BEAM_SNAPSHOT: 'off', ...env }, { release: bin, plain: false });
   await vm.ready;
   return vm;
 }
+
+// A snapshot of the build of an app.com, for serve(app, { snapshot }) of a
+// Worker (npx beam.com --snapshot). kind:
+// - 'boot-point' (the default): the VM loaded the modules of its boot, and
+//   the program did not start. It holds no variable of the app: each VM
+//   starts the program with the variables of its host.
+// - 'full': the VM after its boot and the warm-up requests (warm, paths).
+//   It holds the variables of env and the state of the program. A Phoenix
+//   app must give SECRET_KEY_BASE and PHX_HOST, and an app with Ecto
+//   SQLite cannot use it (its boot changes the database).
+// Gives the bytes of the snapshot.
+export async function snapshot(app, { env = {}, warm = [], kind = 'boot-point' } = {}) {
+  if (kind !== 'boot-point' && kind !== 'full') throw new Error(`the kind of snapshot is boot-point or full, not ${kind}`);
+  const bin = await readApp(app, appFiles);
+  const { Vm, releaseMeta } = await import(new URL('worker.js', runtimeUrl).href);
+  const meta = releaseMeta(bin);
+  if (kind === 'full') {
+    if (meta.sql) throw new Error(`${app}: the app has Ecto SQLite: use a snapshot at the boot point`);
+    const missing = ['SECRET_KEY_BASE', 'PHX_HOST'].filter((k) => meta.env?.PHX_SERVER === 'true' && !env[k]);
+    if (missing.length) throw new Error(`${app}: a full snapshot of a Phoenix app needs ${missing.join(' and ')}`);
+  }
+  const vm = new Vm({ BEAM_SNAPSHOT: 'off', ...env }, { release: bin, plain: false, capture: kind });
+  let bytes;
+  if (kind === 'boot-point') {
+    // wasm_host says "ready", and then it stops at the boot point. A boot
+    // that fails rejects ready.
+    let timer;
+    const late = new Promise((resolve, reject) => {
+      timer = setTimeout(() => reject(new Error(`${app}: the VM did not stop at the boot point in 120 s`)), 120000);
+    });
+    try {
+      bytes = await Promise.race([vm.captured, vm.ready.then(() => vm.captured), late]);
+    } finally {
+      clearTimeout(timer);
+    }
+  } else {
+    await vm.ready;
+    await vm.listening(Number(env.PORT ?? meta.env?.PORT ?? 4000));
+    for (const path of warm) {
+      const r = await vm.fetch(new Request(new URL(path, 'http://localhost')));
+      await r.arrayBuffer();
+      if (r.status >= 500) throw new Error(`${app}: the warm-up request ${path} gave ${r.status}`);
+    }
+    bytes = await vm.snapshot(false);
+  }
+  if (!(bytes instanceof Uint8Array)) throw new Error(`${app}: no snapshot (${bytes}): the VM was not quiet`);
+  return bytes;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beam.com",
-  "version": "0.1.0-rc.1",
+  "version": "0.1.0-rc.2",
   "description": "Erlang/OTP and Elixir in one executable file: npx beam.com, and the WebAssembly runtime for a native app.com",
   "license": "Apache-2.0",
   "repository": {

package/runtime/app-com.js

@@ -111,7 +111,8 @@ function gzipOf(raw, e) {
 }
 
 // The data of the entry e, in span (the bytes of the file from offset base).
-async function entryData(span, base, e) {
+// unzip: the inflate of a deflated entry.
+async function entryData(span, base, e, unzip = inflate) {
   const h = e.offset - base;
   if (h < 0 || h + 30 > span.length || u32(span, h) !== LOCAL) fail(`${e.name}: no local header`);
   const start = h + 30 + u16(span, h + 26) + u16(span, h + 28);
@@ -120,7 +121,7 @@ async function entryData(span, base, e) {
   if (e.method === DEFLATED && e.name.endsWith('.beam')) return gzipOf(raw, e);
   let d;
   if (e.method === STORED) d = raw;
-  else if (e.method === DEFLATED) d = await inflate(raw);
+  else if (e.method === DEFLATED) d = await unzip(raw);
   else fail(`${e.name}: the compression method ${e.method} is not supported`);
   if (d.length !== e.size || crc32(d) !== e.crc) fail(`${e.name}: the CRC-32 does not match`);
   return d;
@@ -134,7 +135,10 @@ export async function appRelease(read, size, options = {}) {
   return pack(meta, files);
 }
 
-export async function appFiles(read, size, { runtime, statics: split = true } = {}) {
+// options.inflate: the inflate of a deflated entry, (raw) => bytes. The
+// default uses DecompressionStream, which the global scope of a Worker
+// cannot use (cloudflare/release.js gives inflateRawSync of node:zlib).
+export async function appFiles(read, size, { runtime, statics: split = true, inflate: unzip = inflate } = {}) {
   const { entries, cdAt } = await zipEntries(read, size);
   const want = entries.filter((e) => inRelease(e.name) && !e.name.endsWith('/'));
   const json = want.find((e) => e.name === `${EDGE}.release.json`);
@@ -143,7 +147,7 @@ export async function appFiles(read, size, { runtime, statics: split = true } =
   const lo = Math.min(...want.map((e) => e.offset));
   const span = await read(lo, cdAt - lo);
   if (span.length !== cdAt - lo) fail('a short read of the release');
-  const meta = await entryData(span, lo, json);
+  const meta = await entryData(span, lo, json, unzip);
   const release = JSON.parse(text.decode(meta));
   if (runtime && release.runtime !== runtime) {
     fail(`it was built for the runtime ${String(release.runtime).slice(0, 12)}, and this runtime is ${runtime.slice(0, 12)}: `
@@ -164,9 +168,9 @@ export async function appFiles(read, size, { runtime, statics: split = true } =
       statics.set(e.name.slice(prefix.length - 1), staticEntry(span, lo, e));
       continue;
     }
-    files.set(e.name, await entryData(span, lo, e));
+    files.set(e.name, await entryData(span, lo, e, unzip));
   }
-  for (const e of want) if (e.name.startsWith(EDGE) && e !== json) files.set(e.name.slice(EDGE.length), await entryData(span, lo, e));
+  for (const e of want) if (e.name.startsWith(EDGE) && e !== json) files.set(e.name.slice(EDGE.length), await entryData(span, lo, e, unzip));
   const list = [...files];
   return {
     meta, files: list, statics,

package/runtime/browser.js

@@ -11,7 +11,7 @@
 // Then:
 //
 //   import { start } from './browser.js';
-//   const beam = await start({ release: './release/release.bin' });
+//   const beam = await start({ app: './app.com' });
 //   const response = await beam.fetch('/path');   // a Response of the app
 //   const socket = await beam.socket('/ws');      // a WebSocket of the app
 //
@@ -127,7 +127,10 @@ async function urlReader(url) {
 // Boots the release of the URL release, or of the native app.com of the URL
 // app (its edge part, see app-com.js: for this runtime only), with the
 // environment env (the "vars" of a Worker). BEAM_HOST is "browser".
-export async function start({ release = './release.bin', app = null, env = {} } = {}) {
+// statics: false keeps the static files of the app in the VM. Else the VM
+// does not have them (appFiles): use false for an app that serves
+// priv/static at a path other than "/" (Plug.Static with at:).
+export async function start({ release = './release.bin', app = null, env = {}, statics = true } = {}) {
   if (typeof WebAssembly.Suspending !== 'function') {
     throw new Error('this browser has no JSPI (WebAssembly.Suspending)');
   }
@@ -137,10 +140,10 @@ export async function start({ release = './release.bin', app = null, env = {} }
   if (app) {
     const [{ appFiles }, { default: runtime }] = await Promise.all([import('./app-com.js'), import('./runtime-id.js')]);
     const { read, size } = await urlReader(new URL(app, where).href);
-    const bytes = await appFiles(read, size, { runtime });
-    vm = new Vm({ BEAM_HOST: 'browser', ...env }, { plain: false, release: bytes });
+    const bytes = await appFiles(read, size, { runtime, statics });
+    vm = new Vm({ BEAM_HOST: 'browser', ...env }, { plain: false, release: bytes, scheme: false });
   } else {
-    vm = new Vm({ BEAM_HOST: 'browser', ...env, RELEASE_URL: new URL(release, where).href }, { plain: false });
+    vm = new Vm({ BEAM_HOST: 'browser', ...env, RELEASE_URL: new URL(release, where).href }, { plain: false, scheme: false });
   }
   await vm.ready;
   const origin = new URL('http://localhost');

package/runtime/cloudflare/index.js

@@ -24,8 +24,10 @@
 //
 // wrangler.jsonc gives app.com to the Worker as a Data module:
 //   "rules": [{ "type": "Data", "globs": ["**/*.com"], "fallthrough": true }]
+import { env as globalEnv } from 'cloudflare:workers';
 import { release, use } from './release.js';
-import plain, { staticResponse } from './worker.js';
+import { useSnapshot } from './snapshot.js';
+import plain, { snapshotHeader, staticResponse, Vm } from './worker.js';
 import front from './durable.js';
 
 export { Beam } from './durable.js';
@@ -49,8 +51,41 @@ export { Beam } from './durable.js';
 //   scheduled(controller, env, ctx) {
 //     return beam.scheduled(controller, env, ctx);
 //   },
-export function serve(app, { binding = 'BEAM', name, nifs = null } = {}) {
-  use(app, nifs);
+//
+// options.statics: true (the default) serves the static files of a
+// Phoenix app (priv/static of the application of the release) at the root
+// of the site, before the VM: the VM does not get them. An app that serves
+// them at another path (Plug.Static with at:) gives false: then the VM
+// keeps them and serves them.
+//
+// options.snapshot: the snapshot of the build of app.com (npx beam.com
+// --snapshot app.com, imported as a Data module, as app.com):
+// - a full one (--full): each new VM restores it in place of a boot. A
+//   stateless Worker restores its VM in the global scope, before the
+//   first request;
+// - one at the boot point: a new VM restores it only when the store of
+//   snapshots has none (the first VM of a deploy), and then the VM makes
+//   its snapshot for the store, as with no snapshot of the build.
+// The entry waits for the VM of the global scope:
+//
+//   import snapshot from './app.snapshot';
+//   const beam = serve(app, { snapshot });
+//   await beam.ready;
+//
+// With the var BEAM_WARM (a path, as "/"), the global scope also sends one
+// GET request of that path to the VM of a full snapshot (see global.js).
+export function serve(app, { binding = 'BEAM', name, nifs = null, snapshot = null, statics: split = true } = {}) {
+  use(app, nifs, split);
+  useSnapshot(snapshot);
+  // The VM of a stateless Worker, restored from a full snapshot in the
+  // global scope.
+  let vm = null;
+  const full = !!snapshot && !snapshotHeader(snapshot).boot_point;
+  const ready = full && !globalEnv[binding] ? (async () => {
+    vm = new Vm(globalEnv, { release: await release(), snapshot });
+    await vm.ready;
+    if (globalEnv.BEAM_WARM) await vm.warm(globalEnv.BEAM_WARM);
+  })() : Promise.resolve();
   // The env of the front: the binding as BEAM, the name of the object, and
   // the static files of app.com (the front serves them, with no request
   // to the object).
@@ -62,8 +97,10 @@ export function serve(app, { binding = 'BEAM', name, nifs = null } = {}) {
     ...env, BEAM: env[binding], BEAM_OBJECT: name ?? env.BEAM_OBJECT, BEAM_STATICS: statics,
   });
   return {
+    ready,
     fetch(request, env, ctx) {
       const objects = env[binding];
+      if (!objects && vm) return vm.fetch(request, ctx);
       if (!objects) return plain.fetch(request, env, ctx);
       if (typeof name === 'function') return objects.getByName(name(request)).fetch(request);
       return front.fetch(request, frontEnv(env), ctx);

package/runtime/cloudflare/release.js

@@ -8,17 +8,26 @@
 // The file must come from the beam.com of the version of this package:
 // app-com.js refuses a file for another runtime. worker.js reads the
 // release at the first request of an isolate, not in the global scope.
+import { inflateRawSync } from 'node:zlib';
 import { appFiles, bytesReader } from '../app-com.js';
 import runtime from '../runtime-id.js';
 
+// The global scope of a Worker cannot use DecompressionStream (a VM that
+// serve(app, { snapshot }) restores there reads the release first).
+const inflate = async (raw) => new Uint8Array(inflateRawSync(raw));
+
 let app = null;
 let modules = null;
+let split = true;
 
 // nifModules: the NIF libraries in WebAssembly of app.com, compiled by
-// Wrangler (nifs.js of "beam.com --nif-modules"), or null.
-export function use(bytes, nifModules = null) {
+// Wrangler (nifs.js of "beam.com --nif-modules"), or null. statics: false
+// keeps the static files of a Phoenix app in the release of the VM (see
+// serve(app) of index.js).
+export function use(bytes, nifModules = null, statics = true) {
   app = bytes;
   modules = nifModules;
+  split = statics;
 }
 
 // For worker.js: the path of each NIF library in /app, and its module.
@@ -36,7 +45,7 @@ export function release() {
   }
   if (!files) {
     const { read, size } = bytesReader(app);
-    files = appFiles(read, size, { runtime });
+    files = appFiles(read, size, { runtime, inflate, statics: split });
   }
   return files;
 }

package/runtime/cloudflare/snapshot.js

@@ -1,3 +1,11 @@
-// No snapshot of the build in a Worker that runs an app.com: the Worker
-// makes its own snapshot (the Cache API, or the R2 bucket SNAPSHOTS).
-export default null;
+// The snapshot of the build of the app.com of the project (npx beam.com
+// --snapshot), when the entry gives it to serve(app, { snapshot }): each
+// new VM restores it in place of a boot. With none, the Worker makes its
+// own snapshot (the Cache API, or the R2 bucket SNAPSHOTS).
+let bytes = null;
+
+export function useSnapshot(snapshot) {
+  bytes = snapshot;
+}
+
+export { bytes as default };