toiljs 0.0.73 → 0.0.75

package/src/devserver/stream/index.ts

@@ -81,10 +81,10 @@ export type StreamMessageOutcome =
     | { readonly kind: 'reply'; readonly frames: Buffer[] }
     | { readonly kind: 'reject'; readonly code: number };
 
-/** A `@connect` outcome: the guest accepted (the box is usable) or rejected with a `0x02xx` code. */
+/** A `@connect` outcome: accepted/rejected plus any immediate frames staged during the hook. */
 export type StreamConnectOutcome =
-    | { readonly kind: 'accept' }
-    | { readonly kind: 'reject'; readonly code: number };
+    | { readonly kind: 'accept'; readonly initialEgress: Buffer[] }
+    | { readonly kind: 'reject'; readonly code: number; readonly initialEgress: Buffer[] };
 
 export class DevStreamBox {
     private constructor(
@@ -132,17 +132,16 @@ export class DevStreamBox {
 
     /**
      * Fire `@connect`: write the connect-info block (stream id + transport + authority + path) into the
-     * guest's info region, dispatch `EVENT_CONNECT`, and decode the `StreamOutbound` accept/reject. On
-     * accept, clear any `@connect`-staged egress (initial-egress is deferred, like the edge) so it does
-     * not contaminate the first `@message` reply. A box without the bridge runs `@connect` context-free
+     * guest's info region, dispatch `EVENT_CONNECT`, decode the `StreamOutbound` accept/reject, and
+     * drain any staged egress as initial frames. A box without the bridge runs `@connect` context-free
      * (the write is a no-op) and always accepts unless it returns a negative code.
      */
     onConnect(streamId: bigint, authority: string, path: string): StreamConnectOutcome {
         this.writeConnectInfo(streamId, authority, path);
         const rc = this.dispatch(EVENT_CONNECT, streamId);
-        if (rc < 0n) return { kind: 'reject', code: decodeRejectCode(rc) };
-        this.resetEgressRing();
-        return { kind: 'accept' };
+        const initialEgress = this.egressDrain();
+        if (rc < 0n) return { kind: 'reject', code: decodeRejectCode(rc), initialEgress };
+        return { kind: 'accept', initialEgress };
     }
 
     /** Fire `@close` (graceful close). */
@@ -241,16 +240,6 @@ export class DevStreamBox {
         if (pathLen > 0) memU8.set(pathBytes.subarray(0, pathLen), base + SI_BODY + authLen);
     }
 
-    /** Zero the egress ring cursors, discarding any staged frames. Safe between dispatches (the guest,
-     *  the sole egress producer, is idle). */
-    private resetEgressRing(): void {
-        const rings = this.rings;
-        if (!rings) return;
-        const dv = new DataView(this.exports.memory.buffer);
-        dv.setUint32(rings.egressOff + RC_WRITE, 0, true);
-        dv.setUint32(rings.egressOff + RC_READ, 0, true);
-    }
-
     /** Host (producer) writes ONE inbound RingFrame into the ingress ring with the drained-reset
      *  (host owns write_cursor; reset read_cursor only when the guest has drained). */
     private ingressWrite(inbound: Buffer): void {

package/src/devserver/stream/manager.ts

@@ -32,8 +32,8 @@ export const STREAM_HOOK_TRAPPED = 0x0200;
 
 /** The outcome of an upgrade accept attempt (mirrors the edge `StreamUpgradeOutcome`). */
 export type StreamUpgradeOutcome =
-    | { readonly kind: 'accepted'; readonly streamId: bigint }
-    | { readonly kind: 'rejected'; readonly code: number };
+    | { readonly kind: 'accepted'; readonly streamId: bigint; readonly initialEgress: Buffer[] }
+    | { readonly kind: 'rejected'; readonly code: number; readonly initialEgress: Buffer[] };
 
 /** The outcome of driving one inbound frame (mirrors the edge `StreamDatagramOutcome`). */
 export type StreamDispatchResult =
@@ -69,30 +69,34 @@ export class StreamDevHost {
      * Accept (or reject) an upgrade for `authority` + `path`, mirroring `StreamWorker::accept_upgrade`:
      * (re)load the artifact on mtime change, instantiate a resident box, fire `@connect` WITH the
      * connect context, and HONOR the guest's accept/reject. Returns the host-assigned stream id on
-     * accept, or a `0x02xx` reject code. Fails closed (no connection registered, box dropped) on a
-     * missing/unreadable artifact (`0x0208`), a `@connect` reject (the guest's code), or a load/connect
-     * trap (`0x0200`). Throws only on a duplicate `connId`.
+     * accept, plus any initial egress staged by `@connect`, or a `0x02xx` reject code. Fails closed
+     * (no connection registered, box dropped) on a missing/unreadable artifact (`0x0208`), a
+     * `@connect` reject (the guest's code), or a load/connect trap (`0x0200`). Throws only on a
+     * duplicate `connId`.
      */
     acceptUpgrade(connId: string, authority: string, path: string): StreamUpgradeOutcome {
-        if (this.conns.has(connId)) throw new Error(`stream connection '${connId}' is already open`);
+        if (this.conns.has(connId))
+            throw new Error(`stream connection '${connId}' is already open`);
         this.refresh();
-        if (!this.bytes) return { kind: 'rejected', code: STREAM_REJECTED };
+        if (!this.bytes) return { kind: 'rejected', code: STREAM_REJECTED, initialEgress: [] };
         let box: DevStreamBox;
         try {
             box = DevStreamBox.load(this.bytes);
         } catch {
-            return { kind: 'rejected', code: STREAM_REJECTED };
+            return { kind: 'rejected', code: STREAM_REJECTED, initialEgress: [] };
         }
         const streamId = this.allocStreamId();
         let outcome;
         try {
             outcome = box.onConnect(streamId, authority, path);
         } catch {
-            return { kind: 'rejected', code: STREAM_HOOK_TRAPPED }; // @connect trapped
+            return { kind: 'rejected', code: STREAM_HOOK_TRAPPED, initialEgress: [] }; // @connect trapped
+        }
+        if (outcome.kind === 'reject') {
+            return { kind: 'rejected', code: outcome.code, initialEgress: outcome.initialEgress };
         }
-        if (outcome.kind === 'reject') return { kind: 'rejected', code: outcome.code };
         this.conns.set(connId, { box, streamId });
-        return { kind: 'accepted', streamId };
+        return { kind: 'accepted', streamId, initialEgress: outcome.initialEgress };
     }
 
     /**

package/src/devserver/stream/ws.ts

@@ -45,10 +45,12 @@ export class StreamWsSession {
     onOpen(): boolean {
         const up = this.host.acceptUpgrade(this.connId, this.authority, this.path);
         if (up.kind === 'rejected') {
+            for (const frame of up.initialEgress) this.transport.send(frame);
             this.transport.close(up.code);
             return false;
         }
         this.open = true;
+        for (const frame of up.initialEgress) this.transport.send(frame);
         return true;
     }
 

package/test/assembly/aspect-shim.ts

@@ -0,0 +1,33 @@
+// A minimal in-AssemblyScript test shim for this directory's assembly specs.
+// `describe`/`it` run their bodies inline; `expect(x).toBe(y)` / `.toStrictEqual(y)` assert
+// `x == y` (value-equality, which covers the bool / i32 / string the specs compare). A failed
+// assertion aborts with the current test name; the vitest runner (../assembly.test.ts) compiles
+// each spec with toilscript, runs `_start`, and surfaces the abort as a test failure.
+
+let currentTest: string = '';
+
+export function describe(_name: string, fn: () => void): void {
+    fn();
+}
+
+export function it(name: string, fn: () => void): void {
+    currentTest = name;
+    fn();
+}
+
+export class Expectation<T> {
+    private actual: T;
+    constructor(actual: T) {
+        this.actual = actual;
+    }
+    toBe(expected: T): void {
+        assert(this.actual == expected, currentTest);
+    }
+    toStrictEqual(expected: T): void {
+        assert(this.actual == expected, currentTest);
+    }
+}
+
+export function expect<T>(actual: T): Expectation<T> {
+    return new Expectation<T>(actual);
+}

package/test/assembly/cookie.spec.ts

@@ -5,6 +5,7 @@
 // as-pect compiler does not ship. `SecureCookies`
 // is exercised end-to-end against the real toilscript-compiled wasm in
 // `test/devserver.test.ts`.
+import { describe, it, expect } from './aspect-shim';
 import { Method, Request, Header } from '../../server/runtime/request';
 import { Response } from '../../server/runtime/response';
 import { Cookie, SameSite, CookieEncoding } from '../../server/runtime/http/cookie';

package/test/assembly/example.spec.ts

@@ -1,6 +1,7 @@
 // Imports the specific modules rather than the runtime index: the index
 // re-exports `SecureCookies`, which depends on the toilscript crypto std the
 // as-pect compiler does not ship (see test/assembly/cookie.spec.ts).
+import { describe, it, expect } from './aspect-shim';
 import { Method } from '../../server/runtime/request';
 import { Response } from '../../server/runtime/response';
 

package/test/assembly/ssr.spec.ts

@@ -3,6 +3,7 @@
 // (escaping + buffer building + linear-memory encode), so they run under
 // as-pect; the full `render` export is exercised via the example wasm in
 // test/devserver.test.ts.
+import { describe, it, expect } from './aspect-shim';
 import { escapeHtml, escapeJsonForScript } from '../../server/runtime/ssr/escape';
 import { HASH_LEN, HtmlBuilder, SlotKind, SlotValues } from '../../server/runtime/ssr/slots';
 import { encodeValues } from '../../server/runtime/ssr/encode';

package/test/assembly.test.ts

@@ -0,0 +1,59 @@
+// Runs the AssemblyScript specs in test/assembly/*.spec.ts by compiling each with toilscript and
+// executing its `_start` (which runs the describe/it bodies + the shim's asserts). A failed assert
+// aborts; this runner surfaces it as a vitest failure. Runs them via toilscript, no external runner.
+import { describe, it } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const TOILSCRIPT_BIN = join(here, '..', 'node_modules', 'toilscript', 'bin', 'toilscript.js');
+const SPECS = ['example', 'cookie', 'ssr'] as const;
+
+function liftString(ptr: number, mem: WebAssembly.Memory): string {
+    if (!ptr) return '(no message)';
+    const u32 = new Uint32Array(mem.buffer);
+    const len = (u32[(ptr - 4) >>> 2] >>> 1) >>> 0;
+    const u16 = new Uint16Array(mem.buffer);
+    let s = '';
+    const start = ptr >>> 1;
+    for (let i = 0; i < len; i++) s += String.fromCharCode(u16[start + i]);
+    return s;
+}
+
+describe('assembly specs (toilscript-compiled)', () => {
+    for (const spec of SPECS) {
+        it(`${spec}.spec.ts passes`, async () => {
+            const tmp = mkdtempSync(join(tmpdir(), 'toiljs-asm-'));
+            try {
+                const src = join(here, 'assembly', `${spec}.spec.ts`);
+                const out = join(tmp, `${spec}.wasm`);
+                const r = spawnSync(
+                    'node',
+                    [TOILSCRIPT_BIN, src, '-o', out, '--exportStart', '_start', '--runtime', 'stub'],
+                    { encoding: 'utf8' },
+                );
+                if (r.status !== 0) {
+                    throw new Error(`toilscript compile ${spec}.spec.ts failed:\n${r.stderr}${r.stdout}`);
+                }
+                const wasm = readFileSync(out);
+                const holder: { mem: WebAssembly.Memory | null } = { mem: null };
+                const { instance } = await WebAssembly.instantiate(wasm, {
+                    env: {
+                        abort(msg: number, _file: number, line: number): void {
+                            const m = holder.mem ? liftString(msg >>> 0, holder.mem) : '';
+                            throw new Error(`${spec}.spec.ts assertion failed: "${m}" (line ${line})`);
+                        },
+                        seed: () => 0,
+                    },
+                });
+                holder.mem = instance.exports.memory as WebAssembly.Memory;
+                (instance.exports._start as () => void)();
+            } finally {
+                rmSync(tmp, { recursive: true, force: true });
+            }
+        });
+    }
+});

package/test/dom/Link.test.tsx

@@ -31,6 +31,26 @@ describe('Link', () => {
         expect(window.location.pathname).toBe('/');
     });
 
+    it('ignores a click when href is missing (data-driven href to a page that does not exist)', () => {
+        // A runtime-undefined href (e.g. `routeMap[missingKey]`) used to throw on `href.startsWith`
+        // inside the click handler. React reports a handler throw as an uncaught *window* error (what
+        // the dev overlay surfaces), not a synchronous throw, so assert no such error fires. The anchor
+        // is inert now: the click is left to the browser, the page stays put.
+        const errors: string[] = [];
+        const onError = (e: ErrorEvent): void => {
+            errors.push(e.message || String(e.error));
+        };
+        window.addEventListener('error', onError);
+        try {
+            const { getByText } = render(<Link href={undefined as unknown as string as never}>x</Link>);
+            fireEvent.click(getByText('x'));
+        } finally {
+            window.removeEventListener('error', onError);
+        }
+        expect(errors).toEqual([]);
+        expect(window.location.pathname).toBe('/');
+    });
+
     it('forwards anchor attributes (rel, target)', () => {
         const { getByText } = render(
             <Link

package/test/fixtures/stream-gate.ts

@@ -1,24 +1,28 @@
 // Dev @connect-bridge fixture: a `@stream('gate')` whose `@connect(c: StreamInbound): StreamOutbound`
 // reads the host-written connect context (the path) and REJECTS "/blocked" with 0x0211, ACCEPTING any
-// other path; a "/greet" path stages an egress frame DURING @connect (the host must clear it so it does
-// not contaminate the first @message reply). A @message echoes. Mirrors toil-backend's connect_src.ts;
+// other path; a "/greet" path stages an egress frame DURING @connect (the host returns it as initial
+// egress and drains the ring so it does not contaminate the first @message reply). A @message echoes. Mirrors toil-backend's connect_src.ts;
 // exercises the whole @connect bridge (stream_info block -> StreamInbound.path() -> accept/reject).
 
 @stream('gate')
 class Gate {
-  @connect onConnect(c: StreamInbound): StreamOutbound {
-    if (c.path() == "/blocked") return StreamOutbound.reject(0x0211);
-    if (c.path() == "/greet") {
-      const g = new Uint8Array(3);
-      g[0] = 0x47; g[1] = 0x48; g[2] = 0x49; // "GHI"
-      StreamOutbound.reply(g);
-      return StreamOutbound.accept();
+    @connect onConnect(c: StreamInbound): StreamOutbound {
+        if (c.path() == '/blocked') return StreamOutbound.reject(0x0211);
+        if (c.path() == '/greet') {
+            const g = new Uint8Array(3);
+            g[0] = 0x47;
+            g[1] = 0x48;
+            g[2] = 0x49; // "GHI"
+            StreamOutbound.reply(g);
+            return StreamOutbound.accept();
+        }
+        return StreamOutbound.accept();
+    }
+    @message reply(p: StreamPacket): StreamOutbound {
+        return StreamOutbound.reply(p.bytes());
     }
-    return StreamOutbound.accept();
-  }
-  @message reply(p: StreamPacket): StreamOutbound {
-    return StreamOutbound.reply(p.bytes());
-  }
 }
 
-export function probe(): i32 { return 1; }
+export function probe(): i32 {
+    return 1;
+}

package/test/stream-emulation.test.ts

@@ -30,8 +30,10 @@ import {
 import { StreamWsSession, type StreamWsTransport } from '../src/devserver/stream/ws.js';
 
 const here = dirname(fileURLToPath(import.meta.url));
-// The LOCAL toilscript build (the @message + @connect bridge codegen); the published dep predates it.
-const LOCAL_TOILSCRIPT_BIN = join(here, '..', '..', 'toilscript', 'bin', 'toilscript.js');
+// The toilscript build with the @message + @connect bridge codegen (it ships in the dep now).
+// Resolved from node_modules so this works both locally (the symlinked repo) and in CI (the npm
+// dep), not from a sibling checkout that CI does not have.
+const LOCAL_TOILSCRIPT_BIN = join(here, '..', 'node_modules', 'toilscript', 'bin', 'toilscript.js');
 
 let tmp: string;
 let ECHO_PATH: string;
@@ -50,7 +52,9 @@ function compile(srcName: string): { path: string; wasm: Buffer } {
         { encoding: 'utf8' },
     );
     if (r.status !== 0) {
-        throw new Error(`toilscript compile ${srcName} failed (${String(r.status)}):\n${r.stderr}${r.stdout}`);
+        throw new Error(
+            `toilscript compile ${srcName} failed (${String(r.status)}):\n${r.stderr}${r.stdout}`,
+        );
     }
     return { path: out, wasm: readFileSync(out) };
 }
@@ -140,10 +144,17 @@ describe('dev stream box: the @connect info-block bridge', () => {
     it('reads the connect path and rejects /blocked while accepting others', () => {
         const box = DevStreamBox.load(GATE);
         expect(box.hasConnectBridge).toBe(true);
-        expect(box.onConnect(id, 'acme.toil', '/blocked')).toEqual({ kind: 'reject', code: 0x0211 });
+        expect(box.onConnect(id, 'acme.toil', '/blocked')).toEqual({
+            kind: 'reject',
+            code: 0x0211,
+            initialEgress: [],
+        });
 
         const ok = DevStreamBox.load(GATE);
-        expect(ok.onConnect(id, 'acme.toil', '/room/42')).toEqual({ kind: 'accept' });
+        expect(ok.onConnect(id, 'acme.toil', '/room/42')).toEqual({
+            kind: 'accept',
+            initialEgress: [],
+        });
         // An accepted connection is usable: its @message echoes.
         expect(ok.onMessage(id, Buffer.from('hi'))).toEqual({
             kind: 'reply',
@@ -151,11 +162,14 @@ describe('dev stream box: the @connect info-block bridge', () => {
         });
     });
 
-    it('clears @connect-staged egress so the first @message reply is clean', () => {
+    it('returns @connect-staged egress and keeps the first @message reply clean', () => {
         const box = DevStreamBox.load(GATE);
-        // /greet stages "GHI" during @connect; the host clears it on accept.
-        expect(box.onConnect(id, 'acme.toil', '/greet')).toEqual({ kind: 'accept' });
-        // The first @message must see ONLY its own reply, never the stale "GHI".
+        // /greet stages "GHI" during @connect; the host returns it as initial egress.
+        expect(box.onConnect(id, 'acme.toil', '/greet')).toEqual({
+            kind: 'accept',
+            initialEgress: [Buffer.from('GHI')],
+        });
+        // The first @message must see ONLY its own reply, never the drained initial "GHI".
         expect(box.onMessage(id, Buffer.from('hi'))).toEqual({
             kind: 'reply',
             frames: [Buffer.from('hi')],
@@ -185,6 +199,7 @@ describe('dev stream session driver (StreamDevHost)', () => {
         expect(host.acceptUpgrade('c1', 'acme.toil', '/blocked')).toEqual({
             kind: 'rejected',
             code: 0x0211,
+            initialEgress: [],
         });
         expect(host.activeConnections).toBe(0);
         expect(host.acceptUpgrade('c2', 'acme.toil', '/ok').kind).toBe('accepted');
@@ -211,6 +226,18 @@ describe('dev stream session driver (StreamDevHost)', () => {
         host.acceptUpgrade('c1', 'acme.toil', '/');
         expect(() => host.acceptUpgrade('c1', 'acme.toil', '/')).toThrow();
     });
+
+    it('returns initial egress from @connect while keeping dispatch clean', () => {
+        const host = new StreamDevHost(GATE_PATH);
+        expect(host.acceptUpgrade('c1', 'acme.toil', '/greet')).toMatchObject({
+            kind: 'accepted',
+            initialEgress: [Buffer.from('GHI')],
+        });
+        expect(host.dispatch('c1', Buffer.from('hi'))).toEqual({
+            kind: 'reply',
+            frames: [Buffer.from('hi')],
+        });
+    });
 });
 
 describe('dev stream WS session adapter (StreamWsSession)', () => {
@@ -237,6 +264,20 @@ describe('dev stream WS session adapter (StreamWsSession)', () => {
         expect(host.activeConnections).toBe(0);
     });
 
+    it('sends @connect initial egress on open', () => {
+        const host = new StreamDevHost(GATE_PATH);
+        const { sent, closed, t } = makeTransport();
+        const s = new StreamWsSession(host, 'ws1', 'acme.toil', '/greet', t);
+        expect(s.onOpen()).toBe(true);
+        expect(s.isOpen).toBe(true);
+        expect(sent).toEqual([Buffer.from('GHI')]);
+        expect(closed).toEqual([]);
+        s.onMessage(Buffer.from('hi'));
+        expect(sent).toEqual([Buffer.from('GHI'), Buffer.from('hi')]);
+        s.onClose();
+        expect(host.activeConnections).toBe(0);
+    });
+
     it('closes the socket with the code on a guest reject, then fires @close on socket close', () => {
         const host = new StreamDevHost(ECHO_PATH);
         const { closed, t } = makeTransport();
@@ -310,7 +351,12 @@ describe('dev stream router (doc 08 4.1/4.2)', () => {
         expect(router.matchRoute('/not-a-stream')).toBeNull(); // -> proxied to Vite
 
         const ws = new MockWs();
-        const ctx: StreamUpgradeContext = { kind: 'stream', route, url: route, authority: 'acme.toil' };
+        const ctx: StreamUpgradeContext = {
+            kind: 'stream',
+            route,
+            url: route,
+            authority: 'acme.toil',
+        };
         router.onUpgrade(ws, ctx);
         expect(router.activeConnections).toBe(1);
         ws.emitMessage(Buffer.from('hi'));

package/vitest.config.ts

@@ -10,7 +10,8 @@ export default defineConfig({
         // docs.ts) before the suite, so a fresh checkout can test without a build.
         globalSetup: ['./test/global-setup.ts'],
         include: ['test/**/*.test.ts', 'test/**/*.test.tsx', 'test/**/*.spec.ts'],
-        // test/assembly holds toilscript specs run by as-pect, not vitest.
+        // test/assembly/*.spec.ts are AssemblyScript specs, compiled + run via toilscript by
+        // test/assembly.test.ts (not executed by vitest directly).
         exclude: [...configDefaults.exclude, 'test/assembly/**'],
         coverage: {
             provider: 'v8',

package/as-pect.asconfig.json

@@ -1,34 +0,0 @@
-{
-    "targets": {
-        "coverage": {
-            "lib": [
-                "./node_modules/@btc-vision/as-covers-assembly/index.ts"
-            ],
-            "transform": [
-                "@btc-vision/as-covers-transform",
-                "@btc-vision/as-pect-transform"
-            ]
-        },
-        "noCoverage": {
-            "transform": [
-                "@btc-vision/as-pect-transform"
-            ]
-        }
-    },
-    "options": {
-        "outFile": "output.wasm",
-        "textFile": "output.wat",
-        "debug": true,
-        "bindings": "raw",
-        "exportStart": "_start",
-        "exportMemory": true,
-        "exportRuntime": true,
-        "exportTable": true,
-        "use": [
-            "RTRACE=1"
-        ]
-    },
-    "entries": [
-        "./node_modules/@btc-vision/as-pect-assembly/assembly/index.ts"
-    ]
-}

package/as-pect.config.js

@@ -1,71 +0,0 @@
-function __liftString(pointer, memory) {
-    if (!pointer) return null;
-    const end = (pointer + new Uint32Array(memory.buffer)[(pointer - 4) >>> 2]) >>> 1,
-        memoryU16 = new Uint16Array(memory.buffer);
-    let start = pointer >>> 1,
-        string = '';
-    while (end - start > 1024) {
-        const a = memoryU16.subarray(start, (start += 1024));
-        string += String.fromCharCode(...a);
-    }
-    return string + String.fromCharCode(...memoryU16.subarray(start, end));
-}
-
-function log(text, memory) {
-    text = __liftString(text >>> 0, memory);
-    console.log(`CONTRACT LOG: ${text}`);
-}
-
-export default {
-    /**
-     * A set of globs passed to the glob package that qualify typescript files for testing.
-     */
-    entries: ['test/assembly/**/*.spec.ts'],
-
-    /**
-     * A set of globs passed to the glob package that quality files to be added to each test.
-     */
-    include: ['test/assembly/**/*.include.ts'],
-
-    /**
-     * A set of regexp that will disclude source files from testing.
-     */
-    disclude: [/node_modules/],
-
-    /**
-     * Add your required toilscript imports here.
-     */
-    async instantiate(memory, createImports, instantiate, binary) {
-        let memory2;
-        const resp = instantiate(
-            binary,
-            createImports({
-                env: {
-                    memory,
-                    'console.log': (data) => {
-                        log(data, memory2);
-                    },
-                },
-            }),
-        );
-
-        const { exports } = await resp;
-        memory2 = exports.memory || memory;
-
-        return resp;
-    },
-
-    /**
-     * Enable code coverage. `securecookies.ts` is excluded: it depends on the
-     * toilscript crypto std (`crypto` / `data` / `bindings/webcrypto`), which the
-     * as-pect compiler does not ship, so it cannot
-     * compile here. It is covered end-to-end against the real wasm in
-     * `test/devserver.test.ts`.
-     */
-    coverage: ['server/**/*.ts', 'server/*.ts', '!server/runtime/http/securecookies.ts'],
-
-    /**
-     * Specify if the binary wasm file should be written to the file system.
-     */
-    outputBinary: false,
-};