@ts-edge/wasm 1.100.0-1

package/build/wasm_exec.js

@@ -0,0 +1,575 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+"use strict";
+
+(() => {
+	const enosys = () => {
+		const err = new Error("not implemented");
+		err.code = "ENOSYS";
+		return err;
+	};
+
+	if (!globalThis.fs) {
+		let outputBuf = "";
+		globalThis.fs = {
+			constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1, O_DIRECTORY: -1 }, // unused
+			writeSync(fd, buf) {
+				outputBuf += decoder.decode(buf);
+				const nl = outputBuf.lastIndexOf("\n");
+				if (nl != -1) {
+					console.log(outputBuf.substring(0, nl));
+					outputBuf = outputBuf.substring(nl + 1);
+				}
+				return buf.length;
+			},
+			write(fd, buf, offset, length, position, callback) {
+				if (offset !== 0 || length !== buf.length || position !== null) {
+					callback(enosys());
+					return;
+				}
+				const n = this.writeSync(fd, buf);
+				callback(null, n);
+			},
+			chmod(path, mode, callback) { callback(enosys()); },
+			chown(path, uid, gid, callback) { callback(enosys()); },
+			close(fd, callback) { callback(enosys()); },
+			fchmod(fd, mode, callback) { callback(enosys()); },
+			fchown(fd, uid, gid, callback) { callback(enosys()); },
+			fstat(fd, callback) { callback(enosys()); },
+			fsync(fd, callback) { callback(null); },
+			ftruncate(fd, length, callback) { callback(enosys()); },
+			lchown(path, uid, gid, callback) { callback(enosys()); },
+			link(path, link, callback) { callback(enosys()); },
+			lstat(path, callback) { callback(enosys()); },
+			mkdir(path, perm, callback) { callback(enosys()); },
+			open(path, flags, mode, callback) { callback(enosys()); },
+			read(fd, buffer, offset, length, position, callback) { callback(enosys()); },
+			readdir(path, callback) { callback(enosys()); },
+			readlink(path, callback) { callback(enosys()); },
+			rename(from, to, callback) { callback(enosys()); },
+			rmdir(path, callback) { callback(enosys()); },
+			stat(path, callback) { callback(enosys()); },
+			symlink(path, link, callback) { callback(enosys()); },
+			truncate(path, length, callback) { callback(enosys()); },
+			unlink(path, callback) { callback(enosys()); },
+			utimes(path, atime, mtime, callback) { callback(enosys()); },
+		};
+	}
+
+	if (!globalThis.process) {
+		globalThis.process = {
+			getuid() { return -1; },
+			getgid() { return -1; },
+			geteuid() { return -1; },
+			getegid() { return -1; },
+			getgroups() { throw enosys(); },
+			pid: -1,
+			ppid: -1,
+			umask() { throw enosys(); },
+			cwd() { throw enosys(); },
+			chdir() { throw enosys(); },
+		}
+	}
+
+	if (!globalThis.path) {
+		globalThis.path = {
+			resolve(...pathSegments) {
+				return pathSegments.join("/");
+			}
+		}
+	}
+
+	if (!globalThis.crypto) {
+		throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
+	}
+
+	if (!globalThis.performance) {
+		throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
+	}
+
+	if (!globalThis.TextEncoder) {
+		throw new Error("globalThis.TextEncoder is not available, polyfill required");
+	}
+
+	if (!globalThis.TextDecoder) {
+		throw new Error("globalThis.TextDecoder is not available, polyfill required");
+	}
+
+	const encoder = new TextEncoder("utf-8");
+	const decoder = new TextDecoder("utf-8");
+
+	globalThis.Go = class {
+		constructor() {
+			this.argv = ["js"];
+			this.env = {};
+			this.exit = (code) => {
+				if (code !== 0) {
+					console.warn("exit code:", code);
+				}
+			};
+			this._exitPromise = new Promise((resolve) => {
+				this._resolveExitPromise = resolve;
+			});
+			this._pendingEvent = null;
+			this._scheduledTimeouts = new Map();
+			this._nextCallbackTimeoutID = 1;
+
+			const setInt64 = (addr, v) => {
+				this.mem.setUint32(addr + 0, v, true);
+				this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
+			}
+
+			const setInt32 = (addr, v) => {
+				this.mem.setUint32(addr + 0, v, true);
+			}
+
+			const getInt64 = (addr) => {
+				const low = this.mem.getUint32(addr + 0, true);
+				const high = this.mem.getInt32(addr + 4, true);
+				return low + high * 4294967296;
+			}
+
+			const loadValue = (addr) => {
+				const f = this.mem.getFloat64(addr, true);
+				if (f === 0) {
+					return undefined;
+				}
+				if (!isNaN(f)) {
+					return f;
+				}
+
+				const id = this.mem.getUint32(addr, true);
+				return this._values[id];
+			}
+
+			const storeValue = (addr, v) => {
+				const nanHead = 0x7FF80000;
+
+				if (typeof v === "number" && v !== 0) {
+					if (isNaN(v)) {
+						this.mem.setUint32(addr + 4, nanHead, true);
+						this.mem.setUint32(addr, 0, true);
+						return;
+					}
+					this.mem.setFloat64(addr, v, true);
+					return;
+				}
+
+				if (v === undefined) {
+					this.mem.setFloat64(addr, 0, true);
+					return;
+				}
+
+				let id = this._ids.get(v);
+				if (id === undefined) {
+					id = this._idPool.pop();
+					if (id === undefined) {
+						id = this._values.length;
+					}
+					this._values[id] = v;
+					this._goRefCounts[id] = 0;
+					this._ids.set(v, id);
+				}
+				this._goRefCounts[id]++;
+				let typeFlag = 0;
+				switch (typeof v) {
+					case "object":
+						if (v !== null) {
+							typeFlag = 1;
+						}
+						break;
+					case "string":
+						typeFlag = 2;
+						break;
+					case "symbol":
+						typeFlag = 3;
+						break;
+					case "function":
+						typeFlag = 4;
+						break;
+				}
+				this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
+				this.mem.setUint32(addr, id, true);
+			}
+
+			const loadSlice = (addr) => {
+				const array = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				return new Uint8Array(this._inst.exports.mem.buffer, array, len);
+			}
+
+			const loadSliceOfValues = (addr) => {
+				const array = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				const a = new Array(len);
+				for (let i = 0; i < len; i++) {
+					a[i] = loadValue(array + i * 8);
+				}
+				return a;
+			}
+
+			const loadString = (addr) => {
+				const saddr = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
+			}
+
+			const testCallExport = (a, b) => {
+				this._inst.exports.testExport0();
+				return this._inst.exports.testExport(a, b);
+			}
+
+			const timeOrigin = Date.now() - performance.now();
+			this.importObject = {
+				_gotest: {
+					add: (a, b) => a + b,
+					callExport: testCallExport,
+				},
+				gojs: {
+					// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
+					// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
+					// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
+					// This changes the SP, thus we have to update the SP used by the imported function.
+
+					// func wasmExit(code int32)
+					"runtime.wasmExit": (sp) => {
+						sp >>>= 0;
+						const code = this.mem.getInt32(sp + 8, true);
+						this.exited = true;
+						delete this._inst;
+						delete this._values;
+						delete this._goRefCounts;
+						delete this._ids;
+						delete this._idPool;
+						this.exit(code);
+					},
+
+					// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
+					"runtime.wasmWrite": (sp) => {
+						sp >>>= 0;
+						const fd = getInt64(sp + 8);
+						const p = getInt64(sp + 16);
+						const n = this.mem.getInt32(sp + 24, true);
+						fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
+					},
+
+					// func resetMemoryDataView()
+					"runtime.resetMemoryDataView": (sp) => {
+						sp >>>= 0;
+						this.mem = new DataView(this._inst.exports.mem.buffer);
+					},
+
+					// func nanotime1() int64
+					"runtime.nanotime1": (sp) => {
+						sp >>>= 0;
+						setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
+					},
+
+					// func walltime() (sec int64, nsec int32)
+					"runtime.walltime": (sp) => {
+						sp >>>= 0;
+						const msec = (new Date).getTime();
+						setInt64(sp + 8, msec / 1000);
+						this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
+					},
+
+					// func scheduleTimeoutEvent(delay int64) int32
+					"runtime.scheduleTimeoutEvent": (sp) => {
+						sp >>>= 0;
+						const id = this._nextCallbackTimeoutID;
+						this._nextCallbackTimeoutID++;
+						this._scheduledTimeouts.set(id, setTimeout(
+							() => {
+								this._resume();
+								while (this._scheduledTimeouts.has(id)) {
+									// for some reason Go failed to register the timeout event, log and try again
+									// (temporary workaround for https://github.com/golang/go/issues/28975)
+									console.warn("scheduleTimeoutEvent: missed timeout event");
+									this._resume();
+								}
+							},
+							getInt64(sp + 8),
+						));
+						this.mem.setInt32(sp + 16, id, true);
+					},
+
+					// func clearTimeoutEvent(id int32)
+					"runtime.clearTimeoutEvent": (sp) => {
+						sp >>>= 0;
+						const id = this.mem.getInt32(sp + 8, true);
+						clearTimeout(this._scheduledTimeouts.get(id));
+						this._scheduledTimeouts.delete(id);
+					},
+
+					// func getRandomData(r []byte)
+					"runtime.getRandomData": (sp) => {
+						sp >>>= 0;
+						crypto.getRandomValues(loadSlice(sp + 8));
+					},
+
+					// func finalizeRef(v ref)
+					"syscall/js.finalizeRef": (sp) => {
+						sp >>>= 0;
+						const id = this.mem.getUint32(sp + 8, true);
+						this._goRefCounts[id]--;
+						if (this._goRefCounts[id] === 0) {
+							const v = this._values[id];
+							this._values[id] = null;
+							this._ids.delete(v);
+							this._idPool.push(id);
+						}
+					},
+
+					// func stringVal(value string) ref
+					"syscall/js.stringVal": (sp) => {
+						sp >>>= 0;
+						storeValue(sp + 24, loadString(sp + 8));
+					},
+
+					// func valueGet(v ref, p string) ref
+					"syscall/js.valueGet": (sp) => {
+						sp >>>= 0;
+						const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
+						sp = this._inst.exports.getsp() >>> 0; // see comment above
+						storeValue(sp + 32, result);
+					},
+
+					// func valueSet(v ref, p string, x ref)
+					"syscall/js.valueSet": (sp) => {
+						sp >>>= 0;
+						Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
+					},
+
+					// func valueDelete(v ref, p string)
+					"syscall/js.valueDelete": (sp) => {
+						sp >>>= 0;
+						Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
+					},
+
+					// func valueIndex(v ref, i int) ref
+					"syscall/js.valueIndex": (sp) => {
+						sp >>>= 0;
+						storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
+					},
+
+					// valueSetIndex(v ref, i int, x ref)
+					"syscall/js.valueSetIndex": (sp) => {
+						sp >>>= 0;
+						Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
+					},
+
+					// func valueCall(v ref, m string, args []ref) (ref, bool)
+					"syscall/js.valueCall": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const m = Reflect.get(v, loadString(sp + 16));
+							const args = loadSliceOfValues(sp + 32);
+							const result = Reflect.apply(m, v, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 56, result);
+							this.mem.setUint8(sp + 64, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 56, err);
+							this.mem.setUint8(sp + 64, 0);
+						}
+					},
+
+					// func valueInvoke(v ref, args []ref) (ref, bool)
+					"syscall/js.valueInvoke": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const args = loadSliceOfValues(sp + 16);
+							const result = Reflect.apply(v, undefined, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, result);
+							this.mem.setUint8(sp + 48, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, err);
+							this.mem.setUint8(sp + 48, 0);
+						}
+					},
+
+					// func valueNew(v ref, args []ref) (ref, bool)
+					"syscall/js.valueNew": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const args = loadSliceOfValues(sp + 16);
+							const result = Reflect.construct(v, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, result);
+							this.mem.setUint8(sp + 48, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, err);
+							this.mem.setUint8(sp + 48, 0);
+						}
+					},
+
+					// func valueLength(v ref) int
+					"syscall/js.valueLength": (sp) => {
+						sp >>>= 0;
+						setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
+					},
+
+					// valuePrepareString(v ref) (ref, int)
+					"syscall/js.valuePrepareString": (sp) => {
+						sp >>>= 0;
+						const str = encoder.encode(String(loadValue(sp + 8)));
+						storeValue(sp + 16, str);
+						setInt64(sp + 24, str.length);
+					},
+
+					// valueLoadString(v ref, b []byte)
+					"syscall/js.valueLoadString": (sp) => {
+						sp >>>= 0;
+						const str = loadValue(sp + 8);
+						loadSlice(sp + 16).set(str);
+					},
+
+					// func valueInstanceOf(v ref, t ref) bool
+					"syscall/js.valueInstanceOf": (sp) => {
+						sp >>>= 0;
+						this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0);
+					},
+
+					// func copyBytesToGo(dst []byte, src ref) (int, bool)
+					"syscall/js.copyBytesToGo": (sp) => {
+						sp >>>= 0;
+						const dst = loadSlice(sp + 8);
+						const src = loadValue(sp + 32);
+						if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
+							this.mem.setUint8(sp + 48, 0);
+							return;
+						}
+						const toCopy = src.subarray(0, dst.length);
+						dst.set(toCopy);
+						setInt64(sp + 40, toCopy.length);
+						this.mem.setUint8(sp + 48, 1);
+					},
+
+					// func copyBytesToJS(dst ref, src []byte) (int, bool)
+					"syscall/js.copyBytesToJS": (sp) => {
+						sp >>>= 0;
+						const dst = loadValue(sp + 8);
+						const src = loadSlice(sp + 16);
+						if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
+							this.mem.setUint8(sp + 48, 0);
+							return;
+						}
+						const toCopy = src.subarray(0, dst.length);
+						dst.set(toCopy);
+						setInt64(sp + 40, toCopy.length);
+						this.mem.setUint8(sp + 48, 1);
+					},
+
+					"debug": (value) => {
+						console.log(value);
+					},
+				}
+			};
+		}
+
+		async run(instance) {
+			if (!(instance instanceof WebAssembly.Instance)) {
+				throw new Error("Go.run: WebAssembly.Instance expected");
+			}
+			this._inst = instance;
+			this.mem = new DataView(this._inst.exports.mem.buffer);
+			this._values = [ // JS values that Go currently has references to, indexed by reference id
+				NaN,
+				0,
+				null,
+				true,
+				false,
+				globalThis,
+				this,
+			];
+			this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
+			this._ids = new Map([ // mapping from JS values to reference ids
+				[0, 1],
+				[null, 2],
+				[true, 3],
+				[false, 4],
+				[globalThis, 5],
+				[this, 6],
+			]);
+			this._idPool = [];   // unused ids that have been garbage collected
+			this.exited = false; // whether the Go program has exited
+
+			// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
+			let offset = 4096;
+
+			const strPtr = (str) => {
+				const ptr = offset;
+				const bytes = encoder.encode(str + "\0");
+				new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
+				offset += bytes.length;
+				if (offset % 8 !== 0) {
+					offset += 8 - (offset % 8);
+				}
+				return ptr;
+			};
+
+			const argc = this.argv.length;
+
+			const argvPtrs = [];
+			this.argv.forEach((arg) => {
+				argvPtrs.push(strPtr(arg));
+			});
+			argvPtrs.push(0);
+
+			const keys = Object.keys(this.env).sort();
+			keys.forEach((key) => {
+				argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
+			});
+			argvPtrs.push(0);
+
+			const argv = offset;
+			argvPtrs.forEach((ptr) => {
+				this.mem.setUint32(offset, ptr, true);
+				this.mem.setUint32(offset + 4, 0, true);
+				offset += 8;
+			});
+
+			// The linker guarantees global data starts from at least wasmMinDataAddr.
+			// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
+			const wasmMinDataAddr = 4096 + 8192;
+			if (offset >= wasmMinDataAddr) {
+				throw new Error("total length of command line and environment variables exceeds limit");
+			}
+
+			this._inst.exports.run(argc, argv);
+			if (this.exited) {
+				this._resolveExitPromise();
+			}
+			await this._exitPromise;
+		}
+
+		_resume() {
+			if (this.exited) {
+				throw new Error("Go program has already exited");
+			}
+			this._inst.exports.resume();
+			if (this.exited) {
+				this._resolveExitPromise();
+			}
+		}
+
+		_makeFuncWrapper(id) {
+			const go = this;
+			return function () {
+				const event = { id: id, this: this, args: arguments };
+				go._pendingEvent = event;
+				go._resume();
+				return event.result;
+			};
+		}
+	}
+})();

package/dist/abi.d.ts

@@ -0,0 +1,61 @@
+/** A tailnet peer snapshot as marshalled by the Go side. */
+export interface Peer {
+    name: string;
+    addrs: string[];
+    online: boolean;
+}
+/** A running server handle returned by serve()/listen(). */
+export interface Server {
+    close(): void;
+}
+/**
+ * A streamed HTTP body crossing the ABI: read() resolves the next chunk and
+ * null at end-of-stream; cancel() abandons the stream early.
+ */
+export interface BodyReaderABI {
+    read(): Promise<Uint8Array | null | undefined>;
+    cancel(): void;
+}
+/** The response to NodeABI.fetch. Resolves once headers arrive; the body
+ * streams on demand. */
+export interface RawResponse {
+    status: number;
+    statusText: string;
+    headers: [string, string][];
+    body: BodyReaderABI;
+}
+/** An inbound HTTP request delivered to a NodeABI.serve handler. */
+export interface RawRequest {
+    method: string;
+    url: string;
+    host: string;
+    headers: [string, string][];
+    remoteAddr: string;
+    body: BodyReaderABI;
+}
+/** A serve handler's response: headers as pairs or a plain object, body
+ * buffered or as a pull reader (streamed to the peer with per-chunk flush). */
+export interface RawServeResponse {
+    status?: number;
+    headers?: [string, string][] | Record<string, string>;
+    body?: Uint8Array | string | BodyReaderABI;
+}
+/** A raw TCP connection / UDP flow as exposed by dial()/listen(). */
+export interface SocketABI {
+    remoteAddr: string;
+    write(data: Uint8Array): void;
+    close(): void;
+    attach(onData: (chunk: Uint8Array) => void, onClose: () => void, onError: (msg: string) => void): void;
+}
+/** The object returned by globalThis.__tsedgeNewNode(config). */
+export interface NodeABI {
+    start(onEvent: (type: string, data: unknown) => void): void;
+    stop(): Promise<void>;
+    up(): Promise<void>;
+    down(): Promise<void>;
+    fetch(req: unknown): Promise<RawResponse>;
+    dial(proto: string, addr: string): Promise<SocketABI>;
+    serve(port: number, handler: (req: RawRequest) => Promise<RawServeResponse>): Promise<Server>;
+    listen(proto: string, port: number, onConnection: (sock: SocketABI) => void): Promise<Server>;
+    getPeers(): Peer[];
+}

package/dist/abi.js

@@ -0,0 +1,4 @@
+// Copyright (c) 2026 Sam Jean
+// SPDX-License-Identifier: BSD-3-Clause
+export {};
+//# sourceMappingURL=abi.js.map

package/dist/abi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.js","sourceRoot":"","sources":["../src/abi.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAC9B,wCAAwC"}

package/dist/emitter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A minimal typed event emitter — just enough for TailscaleNode and
+ * TailnetSocket, with no Node.js EventEmitter dependency so the package stays
+ * runtime-portable (Workers, browsers, Node).
+ */
+export declare class TypedEmitter<Events extends Record<string, (...args: any[]) => void>> {
+    #private;
+    on<K extends keyof Events>(event: K, cb: Events[K]): void;
+    off<K extends keyof Events>(event: K, cb: Events[K]): void;
+    protected emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): void;
+    protected listenerCount(event: keyof Events): number;
+}

package/dist/emitter.js

@@ -0,0 +1,30 @@
+// Copyright (c) 2026 Sam Jean
+// SPDX-License-Identifier: BSD-3-Clause
+/**
+ * A minimal typed event emitter — just enough for TailscaleNode and
+ * TailnetSocket, with no Node.js EventEmitter dependency so the package stays
+ * runtime-portable (Workers, browsers, Node).
+ */
+export class TypedEmitter {
+    #listeners = new Map();
+    on(event, cb) {
+        let set = this.#listeners.get(event);
+        if (!set)
+            this.#listeners.set(event, (set = new Set()));
+        set.add(cb);
+    }
+    off(event, cb) {
+        this.#listeners.get(event)?.delete(cb);
+    }
+    emit(event, ...args) {
+        const set = this.#listeners.get(event);
+        if (!set)
+            return;
+        for (const cb of set)
+            cb(...args);
+    }
+    listenerCount(event) {
+        return this.#listeners.get(event)?.size ?? 0;
+    }
+}
+//# sourceMappingURL=emitter.js.map

package/dist/emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAC9B,wCAAwC;AAExC;;;;GAIG;AACH,MAAM,OAAO,YAAY;IACvB,UAAU,GAAG,IAAI,GAAG,EAA2C,CAAC;IAEhE,EAAE,CAAyB,KAAQ,EAAE,EAAa;QAChD,IAAI,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,GAAG;YAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,GAAG,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC;QACxD,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACd,CAAC;IAED,GAAG,CAAyB,KAAQ,EAAE,EAAa;QACjD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IACzC,CAAC;IAES,IAAI,CAAyB,KAAQ,EAAE,GAAG,IAA2B;QAC7E,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,CAAC,GAAG;YAAE,OAAO;QACjB,KAAK,MAAM,EAAE,IAAI,GAAG;YAAG,EAAgC,CAAC,GAAG,IAAI,CAAC,CAAC;IACnE,CAAC;IAES,aAAa,CAAC,KAAmB;QACzC,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC;IAC/C,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+import type { NodeABI, Peer, Server, SocketABI } from "./abi";
+import { TypedEmitter } from "./emitter";
+export type { BodyReaderABI, NodeABI, Peer, RawRequest, RawResponse, RawServeResponse, Server, SocketABI, } from "./abi";
+export type NodeState = "NoState" | "NeedsLogin" | "NeedsMachineAuth" | "InUseOtherUser" | "Starting" | "Running" | "Stopped";
+export interface NodeConfig {
+    /**
+     * The compiled node module. In Cloudflare Workers pass a WebAssembly.Module
+     * (e.g. `import wasm from "@ts-edge/wasm/node.wasm"`); workerd forbids
+     * compiling from bytes. In browsers a BufferSource also works.
+     */
+    wasm: WebAssembly.Module | BufferSource;
+    /** An ephemeral, reusable Tailscale auth key. */
+    authKey: string;
+    hostname?: string;
+    controlURL?: string;
+}
+export interface FetchInit {
+    method?: string;
+    headers?: Record<string, string> | Headers | [string, string][];
+    body?: Uint8Array | string | ReadableStream<Uint8Array>;
+}
+/**
+ * A fetch-style handler for TailscaleNode.serve(): pass a Hono (or any
+ * `(Request) => Response` framework) app's `fetch` directly. The second
+ * argument carries tailnet connection info; frameworks that accept an "env"
+ * second parameter (Hono) surface it there.
+ */
+export type ServeHandler = (req: Request, info: {
+    remoteAddr: string;
+}) => Response | Promise<Response>;
+type NodeEvents = {
+    state: (state: NodeState) => void;
+    netmap: (addrs: readonly string[]) => void;
+    /** Fires whenever the peer set changes — including instant online/offline
+     * flips pushed by the control plane. */
+    peers: (peers: readonly Peer[]) => void;
+    error: (err: Error) => void;
+};
+/** Create (but do not yet start) an ephemeral Tailscale node. */
+export declare function createNode(config: NodeConfig): Promise<TailscaleNode>;
+export declare class TailscaleNode extends TypedEmitter<NodeEvents> {
+    #private;
+    constructor(abi: NodeABI);
+    get state(): NodeState;
+    get addrs(): readonly string[];
+    get ipv4(): string | undefined;
+    /** A snapshot of the current tailnet peers. */
+    getPeers(): Peer[];
+    /** Begin ephemeral login. Resolves once login has been kicked off. */
+    start(): Promise<void>;
+    waitUntilRunning({ timeoutMs }?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    /** Bring the node back online after down() — `tailscale up`. The node stays
+     * registered with control across down/up, so no fresh login is needed. */
+    up(): Promise<void>;
+    /** Take the node offline without logging out — `tailscale down`. State
+     * becomes Stopped; peers see the node go offline. */
+    down(): Promise<void>;
+    /**
+     * HTTP request over the tailnet, returning a standard web Response. The
+     * response resolves as soon as headers arrive; its body streams on demand.
+     * A ReadableStream body is sent as a streaming (chunked) upload.
+     */
+    fetch(url: string, init?: FetchInit): Promise<Response>;
+    /** Raw connection to a tailnet host:port. Defaults to TCP; pass
+     * `{ proto: "udp" }` for UDP. */
+    dial(addr: string, opts?: {
+        proto?: "tcp" | "udp";
+    }): Promise<TailnetSocket>;
+    /**
+     * Serve a fetch-style handler (`(Request) => Response`) on a tailnet TCP
+     * port — pass a Hono app's `fetch` directly:
+     *
+     *     await tailNode.serve({ port: 80 }, app.fetch);
+     *
+     * Request and response bodies stream; every response chunk is flushed to
+     * the peer as it is written, so SSE and long-lived responses work.
+     */
+    serve(opts: {
+        port: number;
+    }, handler: ServeHandler): Promise<Server>;
+    /** Accept raw connections on a tailnet port. Defaults to TCP; pass
+     * `{ proto: "udp" }` for UDP. */
+    listen(opts: {
+        port: number;
+        proto?: "tcp" | "udp";
+    }, onConnection: (socket: TailnetSocket) => void): Promise<Server>;
+}
+type SocketEvents = {
+    data: (chunk: Uint8Array) => void;
+    close: () => void;
+    error: (err: Error) => void;
+};
+export declare class TailnetSocket extends TypedEmitter<SocketEvents> {
+    #private;
+    readonly remoteAddr: string;
+    constructor(sock: SocketABI);
+    on<K extends keyof SocketEvents>(event: K, cb: SocketEvents[K]): void;
+    write(data: Uint8Array | string): void;
+    close(): void;
+}

package/dist/index.js

@@ -0,0 +1,268 @@
+// Copyright (c) 2026 Sam Jean
+// SPDX-License-Identifier: BSD-3-Clause
+import { TypedEmitter } from "./emitter";
+import { waitFor } from "./wait";
+// ── loader ──────────────────────────────────────────────────────────────────
+let goRuntimeStarted = false;
+async function ensureGoRuntime(wasm) {
+    const g = globalThis;
+    if (typeof g.__tsedgeNewNode === "function")
+        return;
+    if (typeof Go !== "function" && typeof g.Go !== "function") {
+        throw new Error('globalThis.Go is missing — import "@ts-edge/wasm/wasm_exec.js" before createNode()');
+    }
+    if (goRuntimeStarted) {
+        await waitForGoRuntime(g);
+        return;
+    }
+    goRuntimeStarted = true;
+    const go = new Go();
+    let instance;
+    if (wasm instanceof WebAssembly.Module) {
+        instance = await WebAssembly.instantiate(wasm, go.importObject);
+    }
+    else {
+        ({ instance } = await WebAssembly.instantiate(wasm, go.importObject));
+    }
+    // go.run resolves when the Go program exits — which happens when the last
+    // node is stopped. Reset the loader state so the next createNode() boots a
+    // fresh runtime instead of calling into the dead one.
+    const reset = () => {
+        goRuntimeStarted = false;
+        delete g.__tsedgeNewNode;
+    };
+    void go.run(instance).then(reset, (err) => {
+        console.error("Go runtime exited:", err);
+        reset();
+    });
+    await waitForGoRuntime(g);
+}
+function waitForGoRuntime(g) {
+    return waitFor(() => typeof g.__tsedgeNewNode === "function", "the Go runtime to start", {
+        timeoutMs: 5000,
+        intervalMs: 5,
+    });
+}
+/** Create (but do not yet start) an ephemeral Tailscale node. */
+export async function createNode(config) {
+    await ensureGoRuntime(config.wasm);
+    const newNode = globalThis
+        .__tsedgeNewNode;
+    const abi = newNode({
+        authKey: config.authKey,
+        hostname: config.hostname,
+        controlURL: config.controlURL,
+    });
+    return new TailscaleNode(abi);
+}
+// ── node ────────────────────────────────────────────────────────────────────
+export class TailscaleNode extends TypedEmitter {
+    #abi;
+    #state = "NoState";
+    #addrs = [];
+    #runningWaiters = [];
+    constructor(abi) {
+        super();
+        this.#abi = abi;
+    }
+    get state() {
+        return this.#state;
+    }
+    get addrs() {
+        return this.#addrs;
+    }
+    get ipv4() {
+        return this.#addrs.find((a) => a.includes("."));
+    }
+    /** A snapshot of the current tailnet peers. */
+    getPeers() {
+        return this.#abi.getPeers();
+    }
+    /** Begin ephemeral login. Resolves once login has been kicked off. */
+    async start() {
+        this.#abi.start((type, data) => {
+            if (type === "state") {
+                this.#state = data;
+                this.emit("state", this.#state);
+                if (this.#state === "Running") {
+                    const waiters = this.#runningWaiters;
+                    this.#runningWaiters = [];
+                    for (const w of waiters)
+                        w();
+                }
+            }
+            else if (type === "netmap") {
+                this.#addrs = data;
+                this.emit("netmap", this.#addrs);
+            }
+            else if (type === "peers") {
+                this.emit("peers", data);
+            }
+            else if (type === "error") {
+                this.emit("error", new Error(String(data)));
+            }
+        });
+    }
+    waitUntilRunning({ timeoutMs = 60_000 } = {}) {
+        if (this.#state === "Running")
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(`node not Running after ${timeoutMs}ms (state=${this.#state})`)), timeoutMs);
+            this.#runningWaiters.push(() => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        await this.#abi.stop();
+    }
+    /** Bring the node back online after down() — `tailscale up`. The node stays
+     * registered with control across down/up, so no fresh login is needed. */
+    async up() {
+        await this.#abi.up();
+    }
+    /** Take the node offline without logging out — `tailscale down`. State
+     * becomes Stopped; peers see the node go offline. */
+    async down() {
+        await this.#abi.down();
+    }
+    /**
+     * HTTP request over the tailnet, returning a standard web Response. The
+     * response resolves as soon as headers arrive; its body streams on demand.
+     * A ReadableStream body is sent as a streaming (chunked) upload.
+     */
+    async fetch(url, init = {}) {
+        const raw = await this.#abi.fetch({
+            url,
+            method: init.method,
+            headers: headerPairs(init.headers),
+            body: init.body instanceof ReadableStream ? streamToReader(init.body) : init.body,
+        });
+        // Response forbids bodies on null-body statuses and HEAD responses.
+        const nullBody = (init.method ?? "GET").toUpperCase() === "HEAD" ||
+            [204, 205, 304].includes(raw.status);
+        if (nullBody)
+            raw.body.cancel();
+        return new Response(nullBody ? null : readerToStream(raw.body), {
+            status: raw.status,
+            statusText: raw.statusText,
+            headers: raw.headers,
+        });
+    }
+    /** Raw connection to a tailnet host:port. Defaults to TCP; pass
+     * `{ proto: "udp" }` for UDP. */
+    async dial(addr, opts = {}) {
+        return new TailnetSocket(await this.#abi.dial(opts.proto ?? "tcp", addr));
+    }
+    /**
+     * Serve a fetch-style handler (`(Request) => Response`) on a tailnet TCP
+     * port — pass a Hono app's `fetch` directly:
+     *
+     *     await tailNode.serve({ port: 80 }, app.fetch);
+     *
+     * Request and response bodies stream; every response chunk is flushed to
+     * the peer as it is written, so SSE and long-lived responses work.
+     */
+    async serve(opts, handler) {
+        return this.#abi.serve(opts.port, async (raw) => {
+            // GET/HEAD must not carry a body (Request forbids it); drop the reader.
+            const hasBody = raw.method !== "GET" && raw.method !== "HEAD";
+            if (!hasBody)
+                raw.body.cancel();
+            const url = /^https?:\/\//.test(raw.url)
+                ? raw.url
+                : `http://${raw.host || "tailnet"}${raw.url}`;
+            const req = new Request(url, {
+                method: raw.method,
+                headers: raw.headers,
+                body: hasBody ? readerToStream(raw.body) : undefined,
+                // Required (per spec) whenever a Request body is a stream.
+                duplex: "half",
+            });
+            const res = await handler(req, { remoteAddr: raw.remoteAddr });
+            return {
+                status: res.status,
+                // Pairs preserve repeated names (Set-Cookie); Headers iteration
+                // yields set-cookie uncombined.
+                headers: [...res.headers],
+                body: res.body ? streamToReader(res.body) : undefined,
+            };
+        });
+    }
+    /** Accept raw connections on a tailnet port. Defaults to TCP; pass
+     * `{ proto: "udp" }` for UDP. */
+    async listen(opts, onConnection) {
+        return this.#abi.listen(opts.proto ?? "tcp", opts.port, (sock) => onConnection(new TailnetSocket(sock)));
+    }
+}
+export class TailnetSocket extends TypedEmitter {
+    remoteAddr;
+    #sock;
+    // Chunks that arrive before an on("data") listener is attached (e.g. the first
+    // UDP datagram, which is ready the instant the flow is created) are buffered
+    // and flushed when the first data listener registers.
+    #early = [];
+    constructor(sock) {
+        super();
+        this.#sock = sock;
+        this.remoteAddr = sock.remoteAddr;
+        sock.attach((chunk) => {
+            if (this.listenerCount("data") === 0)
+                this.#early.push(chunk);
+            else
+                this.emit("data", chunk);
+        }, () => this.emit("close"), (msg) => this.emit("error", new Error(msg)));
+    }
+    on(event, cb) {
+        super.on(event, cb);
+        if (event === "data" && this.#early.length > 0) {
+            const pending = this.#early;
+            this.#early = [];
+            for (const chunk of pending)
+                cb(chunk);
+        }
+    }
+    write(data) {
+        this.#sock.write(typeof data === "string" ? new TextEncoder().encode(data) : data);
+    }
+    close() {
+        this.#sock.close();
+    }
+}
+// ── body stream bridging ────────────────────────────────────────────────────
+/** Wrap an ABI pull-reader as a web ReadableStream. */
+function readerToStream(r) {
+    return new ReadableStream({
+        async pull(controller) {
+            const chunk = await r.read();
+            if (chunk == null)
+                controller.close();
+            else
+                controller.enqueue(chunk);
+        },
+        cancel() {
+            r.cancel();
+        },
+    });
+}
+/** Expose a web ReadableStream as an ABI pull-reader. */
+function streamToReader(s) {
+    const reader = s.getReader();
+    return {
+        async read() {
+            const { done, value } = await reader.read();
+            return done || value === undefined ? null : value;
+        },
+        cancel() {
+            void reader.cancel().catch(() => { });
+        },
+    };
+}
+// ── header normalization ────────────────────────────────────────────────────
+function headerPairs(h) {
+    // Headers accepts all three shapes and applies native fetch() semantics
+    // (lowercased names, duplicates combined — except set-cookie).
+    return h ? [...new Headers(h)] : [];
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/wait.d.ts

@@ -0,0 +1,5 @@
+/** Poll until pred() is true; rejects naming `what` after timeoutMs. */
+export declare function waitFor(pred: () => boolean, what: string, { timeoutMs, intervalMs }?: {
+    timeoutMs?: number;
+    intervalMs?: number;
+}): Promise<void>;

package/dist/wait.js

@@ -0,0 +1,13 @@
+// Copyright (c) 2026 Sam Jean
+// SPDX-License-Identifier: BSD-3-Clause
+/** Poll until pred() is true; rejects naming `what` after timeoutMs. */
+export async function waitFor(pred, what, { timeoutMs = 15_000, intervalMs = 20 } = {}) {
+    const start = Date.now();
+    while (!pred()) {
+        if (Date.now() - start > timeoutMs) {
+            throw new Error(`timeout waiting for ${what}`);
+        }
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+}
+//# sourceMappingURL=wait.js.map

package/dist/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.js","sourceRoot":"","sources":["../src/wait.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAC9B,wCAAwC;AAExC,wEAAwE;AACxE,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,IAAmB,EACnB,IAAY,EACZ,EAAE,SAAS,GAAG,MAAM,EAAE,UAAU,GAAG,EAAE,KAAkD,EAAE;IAEzF,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACzB,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;QACf,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,SAAS,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,EAAE,CAAC,CAAC;QACjD,CAAC;QACD,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;IACtD,CAAC;AACH,CAAC"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@ts-edge/wasm",
+  "version": "1.100.0-1",
+  "type": "module",
+  "description": "WASM ephemeral Tailscale node (Go js/wasm) with a typed JS/TS loader.",
+  "license": "BSD-3-Clause",
+  "author": "Sam Jean",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jseun/ts-edge.git",
+    "directory": "packages/wasm"
+  },
+  "keywords": [
+    "tailscale",
+    "wasm",
+    "tailnet",
+    "cloudflare-workers",
+    "wireguard"
+  ],
+  "sideEffects": [
+    "./build/wasm_exec.js"
+  ],
+  "files": [
+    "dist",
+    "build/node.wasm",
+    "build/wasm_exec.js"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node.wasm": "./build/node.wasm",
+    "./wasm_exec.js": "./build/wasm_exec.js"
+  },
+  "scripts": {
+    "build:wasm": "./scripts/build-wasm.sh",
+    "build:ts": "tsc -p tsconfig.json",
+    "build": "pnpm build:ts",
+    "prepare": "pnpm build:ts",
+    "prepack": "pnpm build:wasm && pnpm build:ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json && tsc -p test/workerd/tsconfig.json",
+    "test": "vitest run --project unit",
+    "test:unit": "vitest run --project unit",
+    "test:functional": "vitest run --project functional",
+    "test:workerd": "pnpm build:ts && vitest run --project workerd",
+    "test:go": "./scripts/test-go.sh"
+  },
+  "devDependencies": {
+    "@cloudflare/vitest-pool-workers": "^0.18.0",
+    "@cloudflare/workers-types": "^4.20260702.1",
+    "@types/node": "^22.0.0",
+    "hono": "^4.12.28",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  }
+}