lowlander 0.2.0

package/tests/fake-warpsocket.ts

@@ -0,0 +1,452 @@
+/**
+ * In-process fake implementation of warpsocket for testing.
+ * 
+ * Provides the full warpsocket API (send, subscribe, virtual sockets, KV store)
+ * backed by in-memory data structures. Message delivery uses setTimeout(fn, 0)
+ * so it integrates with Aberdeen's fakedom passTime().
+ */
+import * as pathMod from 'node:path';
+
+import type { WorkerInterface } from 'warpsocket';
+let workerModule: WorkerInterface;
+
+interface VirtualSocket {
+    targetSocketId: number;
+    userPrefix?: Uint8Array;
+}
+
+interface FakeClientSocket {
+    socketId: number;
+    onmessage?: ((event: {data: ArrayBuffer}) => void) | null;
+    onopen?: (() => void) | null;
+    onclose?: (() => void) | null;
+    onerror?: ((error: any) => void) | null;
+    readyState: number;
+    binaryType: string;
+    send(data: Uint8Array | ArrayBuffer): void;
+    close(): void;
+}
+
+type ChannelDebug = { channel: Uint8Array, subscribers: { [socketId: number]: number } };
+type SocketDebug = { ip: string, workerId: number } | { targetSocketId: number, userPrefix?: Uint8Array };
+type WorkerDebug = { hasTextHandler: boolean, hasBinaryHandler: boolean, hasCloseHandler: boolean, hasOpenHandler: boolean };
+type KVDebug = { key: Uint8Array, value: Uint8Array };
+
+let nextSocketId = 1;
+let nextVirtualSocketId = 100000; // High range to avoid collisions
+let virtualSockets = new Map<number, VirtualSocket>();
+let channels = new Map<string, Map<number, number>>(); // channelKey -> socketId -> refCount
+let channelBytes = new Map<string, Uint8Array>(); // channelKey -> original channel name bytes
+let kv = new Map<string, Uint8Array>();
+let kvKeyBytes = new Map<string, Uint8Array>(); // keyStr -> original key bytes
+let clientSockets = new Map<number, FakeClientSocket>();
+
+/** Convert any accepted type to Uint8Array */
+function toBytes(input: Uint8Array | ArrayBuffer | string): Uint8Array {
+    if (input instanceof Uint8Array) return input;
+    if (input instanceof ArrayBuffer) return new Uint8Array(input);
+    return new TextEncoder().encode(input);
+}
+
+function keyStr(key: Uint8Array | ArrayBuffer | string): string {
+    if (typeof key === 'string') return key;
+    const bytes = key instanceof Uint8Array ? key : new Uint8Array(key);
+    return Array.from(bytes).join(',');
+}
+
+function channelKey(name: Uint8Array | ArrayBuffer | string): string {
+    return 'ch:' + keyStr(name);
+}
+
+export function send(target: number | number[] | Uint8Array | ArrayBuffer | string | (number | Uint8Array | ArrayBuffer | string)[], data: Uint8Array | ArrayBuffer | string): number {
+    const buf = toBytes(data);
+
+    if (typeof target === 'number') {
+        return sendToSocket(target, buf);
+    } else if (typeof target === 'string' || target instanceof Uint8Array || target instanceof ArrayBuffer) {
+        return sendToChannel(target, buf);
+    } else if (Array.isArray(target)) {
+        let count = 0;
+        for (const item of target) {
+            if (typeof item === 'number') {
+                count += sendToSocket(item, buf);
+            } else {
+                count += sendToChannel(item, buf);
+            }
+        }
+        return count;
+    }
+    return 0;
+}
+
+function sendToSocket(id: number, data: Uint8Array): number {
+    const vs = virtualSockets.get(id);
+    if (vs) {
+        let finalData: Uint8Array;
+        if (vs.userPrefix) {
+            finalData = new Uint8Array(vs.userPrefix.length + data.length);
+            finalData.set(vs.userPrefix, 0);
+            finalData.set(data, vs.userPrefix.length);
+        } else {
+            finalData = data;
+        }
+        return sendToSocket(vs.targetSocketId, finalData);
+    }
+
+    const client = clientSockets.get(id);
+    if (!client || client.readyState !== 1) return 0;
+    
+    const copy = new Uint8Array(data).slice();
+    setTimeout(() => {
+        if (client.readyState === 1 && client.onmessage) {
+            client.onmessage({data: copy.buffer});
+        }
+    }, 0);
+    return 1;
+}
+
+function sendToChannel(channelName: Uint8Array | ArrayBuffer | string, data: Uint8Array): number {
+    const key = channelKey(channelName);
+    const subscribers = channels.get(key);
+    if (!subscribers) return 0;
+    let count = 0;
+    for (const vsId of subscribers.keys()) {
+        count += sendToSocket(vsId, data);
+    }
+    return count;
+}
+
+/** 
+* Subscribes one or more WebSocket connections to a channel, or copies subscriptions from one channel to another.
+* Multiple subscriptions to the same channel by the same connection are reference-counted.
+* 
+* @param socketIdOrChannelName - Can be:
+*   - A single socket ID (number): applies delta to that socket's subscription
+*   - An array of socket IDs (number[]): applies delta to all sockets' subscriptions
+*   - A channel name (Buffer/ArrayBuffer/string): applies delta to all subscribers of this source channel
+*   - An array mixing socket IDs and channel names: applies delta to sockets and source channel subscribers
+* @param channelName - The target channel name (Buffer, ArrayBuffer, or string).
+* @param delta - Optional. The amount to change the subscription count by (default: 1). 
+*   Positive values add subscriptions, negative values remove them. When the count reaches zero, the subscription is removed.
+* @returns An array of socket IDs that were affected by the operation:
+*   - For positive delta: socket IDs that became newly subscribed (reference count went from 0 to positive)
+*   - For negative delta: socket IDs that became completely unsubscribed (reference count reached 0)
+*/
+export function subscribe(target: number | number[] | Uint8Array | ArrayBuffer | string | (number | Uint8Array | ArrayBuffer | string)[], channelName: Uint8Array | ArrayBuffer | string, delta: number = 1): number[] {
+    const key = channelKey(channelName);
+    let subscribers = channels.get(key);
+    if (!subscribers) {
+        channels.set(key, subscribers = new Map());
+        channelBytes.set(key, toBytes(channelName));
+    }
+
+    // Resolve targets to socket IDs
+    let socketIds: number[];
+    if (typeof target === 'number') {
+        socketIds = [target];
+    } else if (Array.isArray(target)) {
+        socketIds = [];
+        for (const item of target) {
+            if (typeof item === 'number') {
+                socketIds.push(item);
+            } else {
+                // Channel name — gather its subscribers
+                const srcSubs = channels.get(channelKey(item));
+                if (srcSubs) for (const sid of srcSubs.keys()) socketIds.push(sid);
+            }
+        }
+    } else {
+        // target is a channel name (Uint8Array | ArrayBuffer | string)
+        const srcSubs = channels.get(channelKey(target));
+        socketIds = srcSubs ? [...srcSubs.keys()] : [];
+    }
+
+    const changed: number[] = [];
+    for (const sid of socketIds) {
+        const current = subscribers.get(sid) || 0;
+        const next = current + delta;
+        if (delta > 0) {
+            subscribers.set(sid, next);
+            if (current === 0) changed.push(sid);
+        } else {
+            if (next <= 0) {
+                subscribers.delete(sid);
+                if (current > 0) changed.push(sid);
+            } else {
+                subscribers.set(sid, next);
+            }
+        }
+    }
+    if (!subscribers.size) {
+        channels.delete(key);
+        channelBytes.delete(key);
+    }
+    return changed;
+}
+
+/**
+ * Exactly the same as `subscribe`, only with a negative delta (defaulting to 1, which means a single unsubscribe, or a subscribe with delta -1).
+ */
+export function unsubscribe(socketIdOrChannelName: number | number[] | Uint8Array | ArrayBuffer | string | (number | Uint8Array | ArrayBuffer | string)[], channelName: Uint8Array | ArrayBuffer | string, delta: number = 1): number[] {
+    return subscribe(socketIdOrChannelName, channelName, -delta);
+}
+
+/** 
+* **DEPRECATED:** Use subscribe(fromChannelName, toChannelName) instead.
+* 
+* Copies all subscribers from one channel to another channel. Uses reference counting - if a subscriber 
+* is already subscribed to the destination channel, their reference count will be incremented instead 
+* of creating duplicate subscriptions.
+* @param fromChannelName - The source channel name (Buffer, ArrayBuffer, or string).
+* @param toChannelName - The destination channel name (Buffer, ArrayBuffer, or string).
+* @returns An array of socket IDs that were newly added to the destination channel. Sockets that were 
+*   already subscribed (and had their reference count incremented) are not included.
+*/
+export function copySubscriptions(fromChannelName: Uint8Array | ArrayBuffer | string, toChannelName: Uint8Array | ArrayBuffer | string): number[] {
+    return subscribe(fromChannelName, toChannelName);
+}
+ 
+export function hasSubscriptions(channelName: Uint8Array | ArrayBuffer | string): boolean {
+    const key = channelKey(channelName);
+    const subscribers = channels.get(key);
+    return !!subscribers && subscribers.size > 0;
+}
+
+export function createVirtualSocket(socketId: number, userPrefix?: Uint8Array | ArrayBuffer | string): number {
+    const vsId = nextVirtualSocketId++;
+    virtualSockets.set(vsId, {
+        targetSocketId: socketId,
+        userPrefix: userPrefix != null ? toBytes(userPrefix) : undefined,
+    });
+    return vsId;
+}
+
+export function deleteVirtualSocket(virtualSocketId: number, expectedTargetSocketId?: number): boolean {
+    const vs = virtualSockets.get(virtualSocketId);
+    if (!vs) return false;
+    if (expectedTargetSocketId !== undefined && vs.targetSocketId !== expectedTargetSocketId) return false;
+    virtualSockets.delete(virtualSocketId);
+    // Unsubscribe from all channels
+    for (const [key, subscribers] of channels) {
+        subscribers.delete(virtualSocketId);
+        if (!subscribers.size) {
+            channels.delete(key);
+            channelBytes.delete(key);
+        }
+    }
+    return true;
+}
+
+export function getKey(key: Uint8Array | ArrayBuffer | string): Uint8Array | undefined {
+    return kv.get(keyStr(key));
+}
+
+export function setKey(key: Uint8Array | ArrayBuffer | string, value?: Uint8Array | ArrayBuffer | string): Uint8Array | undefined {
+    const k = keyStr(key);
+    const prev = kv.get(k);
+    if (value == null) {
+        kv.delete(k);
+        kvKeyBytes.delete(k);
+    } else {
+        kv.set(k, toBytes(value));
+        if (!kvKeyBytes.has(k)) kvKeyBytes.set(k, toBytes(key));
+    }
+    return prev;
+}
+
+export function setKeyIf(key: Uint8Array | ArrayBuffer | string, newValue?: Uint8Array | ArrayBuffer | string, checkValue?: Uint8Array | ArrayBuffer | string): boolean {
+    const k = keyStr(key);
+    const current = kv.get(k);
+    const checkBytes = checkValue != null ? toBytes(checkValue) : undefined;
+    // Compare: both undefined, or byte-equal
+    const matches = (current === undefined && checkBytes === undefined) || (
+        current !== undefined && checkBytes !== undefined &&
+        current.length === checkBytes.length &&
+        current.every((v, i) => v === checkBytes[i])
+    );
+    if (!matches) return false;
+    if (newValue == null) {
+        kv.delete(k);
+        kvKeyBytes.delete(k);
+    } else {
+        kv.set(k, toBytes(newValue));
+        if (!kvKeyBytes.has(k)) kvKeyBytes.set(k, toBytes(key));
+    }
+    return true;
+}
+
+export function getDebugState(mode: "channels"): ChannelDebug[];
+export function getDebugState(mode: "channels", channelName: Uint8Array | ArrayBuffer | string): ChannelDebug | undefined;
+export function getDebugState(mode: "channels", filterSocketId: number): ChannelDebug[];
+export function getDebugState(mode: "sockets"): Record<number, SocketDebug>;
+export function getDebugState(mode: "sockets", socketId: number): SocketDebug | undefined;
+export function getDebugState(mode: "workers"): Record<number, WorkerDebug>;
+export function getDebugState(mode: "workers", workerId: number): WorkerDebug | undefined;
+export function getDebugState(mode: "kv"): KVDebug[];
+export function getDebugState(mode: string, singleKey?: any): any {
+    if (mode === 'channels') {
+        if (singleKey !== undefined) {
+            if (typeof singleKey === 'number') {
+                // Filter: all channels this socket is subscribed to
+                const result: ChannelDebug[] = [];
+                for (const [key, subscribers] of channels) {
+                    if (subscribers.has(singleKey)) {
+                        const subs: { [id: number]: number } = {};
+                        for (const [sid, count] of subscribers) subs[sid] = count;
+                        result.push({ channel: channelBytes.get(key)!, subscribers: subs });
+                    }
+                }
+                return result;
+            } else {
+                // Lookup single channel by name
+                const key = channelKey(singleKey);
+                const subscribers = channels.get(key);
+                if (!subscribers) return undefined;
+                const subs: { [id: number]: number } = {};
+                for (const [sid, count] of subscribers) subs[sid] = count;
+                return { channel: channelBytes.get(key)!, subscribers: subs } as ChannelDebug;
+            }
+        }
+        const result: ChannelDebug[] = [];
+        for (const [key, subscribers] of channels) {
+            const subs: { [id: number]: number } = {};
+            for (const [sid, count] of subscribers) subs[sid] = count;
+            result.push({ channel: channelBytes.get(key)!, subscribers: subs });
+        }
+        return result;
+    }
+    if (mode === 'sockets') {
+        if (typeof singleKey === 'number') {
+            const vs = virtualSockets.get(singleKey);
+            if (vs) {
+                const debug: any = { targetSocketId: vs.targetSocketId };
+                if (vs.userPrefix) debug.userPrefix = vs.userPrefix;
+                return debug as SocketDebug;
+            }
+            const cs = clientSockets.get(singleKey);
+            if (cs) return { ip: '127.0.0.1', workerId: 0 } as SocketDebug;
+            return undefined;
+        }
+        const result: Record<number, SocketDebug> = {};
+        for (const [id] of clientSockets) {
+            result[id] = { ip: '127.0.0.1', workerId: 0 };
+        }
+        for (const [id, vs] of virtualSockets) {
+            const debug: any = { targetSocketId: vs.targetSocketId };
+            if (vs.userPrefix) debug.userPrefix = vs.userPrefix;
+            result[id] = debug;
+        }
+        return result;
+    }
+    if (mode === 'workers') {
+        const info: WorkerDebug = {
+            hasTextHandler: !!workerModule?.handleTextMessage,
+            hasBinaryHandler: !!workerModule?.handleBinaryMessage,
+            hasCloseHandler: !!workerModule?.handleClose,
+            hasOpenHandler: !!workerModule?.handleOpen,
+        };
+        if (typeof singleKey === 'number') return singleKey === 0 ? info : undefined;
+        return { 0: info } as Record<number, WorkerDebug>;
+    }
+    if (mode === 'kv') {
+        const result: KVDebug[] = [];
+        for (const [k, v] of kv) {
+            result.push({ key: kvKeyBytes.get(k) || toBytes(k), value: v });
+        }
+        return result;
+    }
+    return {};
+}
+
+/** Create a fake client-side WebSocket that's wired to this in-process server. */
+export function createClientSocket(): WebSocket {
+    const socketId = nextSocketId++;
+
+    // Serialize message processing per socket (like real warpsocket)
+    let messageQueue: Promise<void> = Promise.resolve();
+
+    const socket: FakeClientSocket = {
+        socketId,
+        onmessage: null,
+        onopen: null,
+        onclose: null,
+        onerror: null,
+        readyState: 0, // CONNECTING
+        binaryType: 'arraybuffer',
+
+        send(data: Uint8Array | ArrayBuffer) {
+            const buf = data instanceof Uint8Array ? data : new Uint8Array(data);
+            // Queue message processing to ensure sequential handling
+            messageQueue = messageQueue.then(() => new Promise<void>(resolve => {
+                setTimeout(async () => {
+                    try {
+                        await workerModule.handleBinaryMessage?.(buf, socketId);
+                    } catch (e) {
+                        console.error('FakeWarpSocket: handleBinaryMessage error', e);
+                    }
+                    resolve();
+                }, 0);
+            }));
+        },
+
+        close() {
+            if (socket.readyState >= 2) return;
+            socket.readyState = 2; // CLOSING
+            clientSockets.delete(socketId);
+            setTimeout(() => {
+                socket.readyState = 3; // CLOSED
+                workerModule.handleClose?.(socketId);
+                socket.onclose?.();
+            }, 0);
+        },
+    };
+
+    clientSockets.set(socketId, socket);
+
+    // Open asynchronously
+    setTimeout(() => {
+        socket.readyState = 1; // OPEN
+        workerModule.handleOpen?.(socketId, '127.0.0.1', {"user-agent": "FakeWarpSocket"});
+        socket.onopen?.();
+    }, 0);
+
+    return socket as any;
+}
+
+/** Reset all state (for between tests). */
+export function reset() {
+    for (const client of clientSockets.values()) {
+        client.readyState = 3;
+    }
+    clientSockets.clear();
+    virtualSockets.clear();
+    channels.clear();
+    channelBytes.clear();
+    kv.clear();
+    kvKeyBytes.clear();
+    nextSocketId = 1;
+    nextVirtualSocketId = 100000;
+}
+
+/**
+ * Initializes the fake warpsocket. Ignores `threads` and `bind`.
+ */
+
+export async function start(options: {
+    bind: string | string[];
+    workerPath?: string;
+    threads?: number;
+    workerArg?: any;
+}): Promise<void> {
+    if (!options || !options.bind || !options.workerPath) {
+        throw new Error('options.bind and options.workerPath are required');
+    }
+
+    if (!pathMod.isAbsolute(options.workerPath)) {
+        options.workerPath = pathMod.resolve(process.cwd(), options.workerPath);
+    }
+
+    workerModule = await import(options.workerPath);
+    await workerModule.handleStart?.(options.workerArg);
+}
+

package/tests/helloworld.test.ts

@@ -0,0 +1,151 @@
+import { expect, test, beforeAll, afterEach, beforeEach } from "bun:test";
+import { passTime, assertBody, reset as resetAberdeen } from "aberdeen/test-helpers";
+import * as E from "edinburgh";
+import { start } from "lowlander/server";
+import { Connection } from "lowlander/client";
+import type * as API from "../examples/helloworld/server/api.js";
+import A from "aberdeen";
+import * as fakeWarpSocket from "./fake-warpsocket.js";
+
+beforeAll(async () => {
+    E.init('.edinburgh_test');
+    E.setMaxRetryCount(100);
+    await start(
+        new URL('../examples/helloworld/server/api.ts', import.meta.url).pathname,
+        { injectWarpSocket: fakeWarpSocket },
+    );
+});
+
+beforeEach(async () => {
+    await connect().api.resetTestData(true).promise;
+});
+
+afterEach(async () => {
+    fakeWarpSocket.reset();
+    A.unmountAll();
+    await resetAberdeen();
+});
+
+function connect() {
+    return new Connection<typeof API>(fakeWarpSocket.createClientSocket);
+}
+
+test('simple RPC: add', async () => {
+    const c = connect();
+    const sum = c.api.add(2, 3);
+    await passTime();
+    expect(sum.value).toBe(5);
+});
+
+test('authenticate returns ServerProxy', async () => {
+    const c = connect();
+    const auth = c.api.authenticate('Frank');
+    await passTime(1100);
+    expect(auth.value).toBe('secret');
+});
+
+test('authenticate with unknown user throws', async () => {
+    const c = connect();
+    const auth = c.api.authenticate('Nobody');
+    auth.promise.catch(() => {}); // prevent unhandled rejection
+    await passTime(1100);
+    expect(auth.error).toBeDefined();
+    expect(auth.error.message).toBe('User not found');
+});
+
+test('ServerProxy: getBio', async () => {
+    const c = connect();
+    const auth = c.api.authenticate('Frank');
+    const bio = auth.serverProxy.getBio();
+    await passTime(1100);
+    expect(bio.value).toContain('Frank is 45 years old');
+});
+
+test('ServerProxy: toggleFriend', async () => {
+    const c = connect();
+    const auth = c.api.authenticate('Frank');
+    const result = auth.serverProxy.toggleFriend('Alice');
+    await passTime(1100);
+    expect(typeof result.value).toBe('boolean');
+});
+
+test('model streaming: streamModel', async () => {
+    const c = connect();
+    const model = c.api.streamModel();
+    await passTime();
+    expect(model.value).toBeDefined();
+    expect(model.value!.name).toBe('Test');
+    expect(model.value!.owner).toBeDefined();
+    expect(model.value!.owner.name).toBe('Frank');
+});
+
+test('two clients see same RPC result', async () => {
+    const c1 = connect();
+    const c2 = connect();
+    const sum1 = c1.api.add(10, 20);
+    const sum2 = c2.api.add(10, 20);
+    await passTime();
+    expect(sum1.value).toBe(30);
+    expect(sum2.value).toBe(30);
+});
+
+test('online status', async () => {
+    const c = connect();
+    expect(c.isOnline()).toBe(false);
+    await passTime();
+    expect(c.isOnline()).toBe(true);
+});
+
+test('render RPC result in DOM', async () => {
+    const c = connect();
+    const sum = c.api.add(7, 8);
+    A(() => {
+        if (sum.value !== undefined) A('span#' + sum.value);
+    });
+    assertBody('');
+    await passTime();
+    expect(sum.value).toBe(15);
+    await passTime();
+    assertBody('span{"15"}');
+});
+
+test('two connections render in same DOM', async () => {
+    const c1 = connect();
+    const c2 = connect();
+    const s1 = c1.api.add(1, 2);
+    const s2 = c2.api.add(3, 4);
+    A('div', () => {
+        A(() => {
+            if (s1.value !== undefined) A('span.c1#' + s1.value);
+        });
+        A(() => {
+            if (s2.value !== undefined) A('span.c2#' + s2.value);
+        });
+    });
+    await passTime();
+    assertBody('div{span.c1{"3"} span.c2{"7"}}');
+});
+
+test('4 connections stream, mutate, and converge', async () => {
+    const conns = Array.from({length: 4}, () => connect());
+    const models = conns.map(c => c.api.streamModel());
+    A('div', () => {
+        for (const [i, m] of models.entries()) {
+            A(() => {
+                if (m.value) A(`span.c${i}#` + m.value.owner.age);
+            });
+        }
+    });
+    await passTime();
+    conns[0].api.setOwnerAge(100);
+    await passTime();
+    // All 4 connections increment simultaneously, racing through retries
+    await Promise.all(conns.map((c, i) => c.api.incrOwnerAge(i + 1).promise));
+    // Await UI update
+    await passTime();
+    // All 4 should converge; total increment = 1+2+3+4 = 10, so age = 110
+    assertBody('div{span.c0{"110"} span.c1{"110"} span.c2{"110"} span.c3{"110"}}');
+    // Restore original age
+    conns[0].api.setOwnerAge(45);
+    await passTime();
+});

package/tsconfig.client.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "outDir": "./build",
+    "rootDir": ".",
+    "paths": {
+      "lowlander/client": ["./client/client.ts"],
+      "lowlander/server": ["./server/server.ts"]
+    }
+  },
+  "include": ["client/**/*.ts", "examples/**/client/**/*.ts"],
+  "exclude": ["node_modules", "build", "tests"],
+  "references": [
+    {"path": "./tsconfig.server.json"}
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "experimentalDecorators": true,
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "sourceMap": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "references": [
+    { "path": "./tsconfig.server.json" },
+    { "path": "./tsconfig.client.json" },
+    { "path": "./tsconfig.test.json" }
+  ],
+  "files": [],
+  "exclude": ["node_modules", "build"]
+}

package/tsconfig.server.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "lib": ["ES2020", "ESNext.WeakRef"],
+    "types": ["bun"],
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./build",
+    "rootDir": ".",
+    "paths": {
+      "lowlander/server": ["./server/server.ts"]
+    }
+  },
+  "include": ["server/**/*.ts", "examples/**/server/**/*.ts", "tests/fake-warpsocket.ts"],
+  "exclude": ["node_modules", "build", "tests"]
+}

package/tsconfig.test.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "types": ["bun"],
+    "noEmit": true,
+    "paths": {
+      "lowlander/server": ["./server/server.ts"],
+      "lowlander/client": ["./client/client.ts"]
+    }
+  },
+  "include": ["tests/**/*.ts"]
+}