toiljs 0.0.15 → 0.0.19

package/src/io/FastSet.ts

@@ -4,12 +4,14 @@ import { type FastRecord, type IndexKey, type PropertyExtendedKey } from './Fast
  * The Set counterpart to {@link FastMap}: an insertion-ordered set backed by an array (for
  * iteration/ordering) plus a record index (for O(1) membership), with bigint-key support.
  *
- * Authored to match FastMap's design, the upstream package ships no `FastSet`.
+ * Authored to match FastMap's design, the upstream package ships no `FastSet`. Implements
+ * `Disposable`, so a `using` binding clears it on scope exit.
  */
 export class FastSet<T extends PropertyExtendedKey> implements Disposable {
     protected _values: T[] = [];
     protected _index: FastRecord<true> = {};
 
+    /** @param iterable - initial values, or another FastSet to copy. */
     constructor(iterable?: Iterable<T> | null | FastSet<T>) {
         if (iterable instanceof FastSet) {
             this.addAll(iterable);
@@ -20,10 +22,12 @@ export class FastSet<T extends PropertyExtendedKey> implements Disposable {
         }
     }
 
+    /** Number of values. */
     public get size(): number {
         return this._values.length;
     }
 
+    /** Adds `value` if not already present, and returns `this` for chaining. */
     public add(value: T): this {
         if (!this.has(value)) {
             this._values.push(value);
@@ -33,10 +37,12 @@ export class FastSet<T extends PropertyExtendedKey> implements Disposable {
         return this;
     }
 
+    /** Whether `value` is present (O(1)). */
     public has(value: T): boolean {
         return Object.prototype.hasOwnProperty.call(this._index, value as IndexKey);
     }
 
+    /** Returns the insertion index of `value`, or -1 if absent. */
     public indexOf(value: T): number {
         for (let i = 0; i < this._values.length; i++) {
             if (this._values[i] === value) {
@@ -47,6 +53,7 @@ export class FastSet<T extends PropertyExtendedKey> implements Disposable {
         return -1;
     }
 
+    /** Removes `value`; returns true if it was present. */
     public delete(value: T): boolean {
         if (!this.has(value)) {
             return false;
@@ -61,20 +68,24 @@ export class FastSet<T extends PropertyExtendedKey> implements Disposable {
         return true;
     }
 
+    /** Adds every value from `set`. */
     public addAll(set: FastSet<T>): void {
         for (const value of set.values()) {
             this.add(value);
         }
     }
 
+    /** Iterates the values in insertion order. */
     public *values(): IterableIterator<T> {
         yield* this._values;
     }
 
+    /** Iterates the values in insertion order (alias of {@link values}, for Map-like parity). */
     public *keys(): IterableIterator<T> {
         yield* this._values;
     }
 
+    /** Calls `callback(value, value, set)` for each value in insertion order. */
     public forEach(
         callback: (value: T, value2: T, set: FastSet<T>) => void,
         thisArg?: unknown,
@@ -84,15 +95,18 @@ export class FastSet<T extends PropertyExtendedKey> implements Disposable {
         }
     }
 
+    /** Removes all values. */
     public clear(): void {
         this._values = [];
         this._index = {};
     }
 
+    /** `Disposable` hook: clears the set (so `using s = new FastSet()` frees it on scope exit). */
     public [Symbol.dispose](): void {
         this.clear();
     }
 
+    /** Default iterator: the values in insertion order. */
     *[Symbol.iterator](): IterableIterator<T> {
         yield* this._values;
     }

package/src/io/codec.ts

@@ -0,0 +1,217 @@
+/**
+ * TypeScript side of the `@data` binary codec, byte-for-byte compatible with the
+ * ToilScript `DataWriter`/`DataReader` in `std/assembly/data.ts`.
+ *
+ * Little-endian by default (wasm `store`/`load` are little-endian, so the ToilScript
+ * side is near native and this matches it). Every multi-byte method takes an optional
+ * `be` flag to read/write big-endian instead, for interop with big-endian wire
+ * formats; the generated `@data` code never sets it, so the `@data` wire stays
+ * little-endian. Strings and byte blobs are a `u32` byte-length prefix followed by the
+ * bytes. `u128`/`i128` are two 64-bit limbs (low limb first in little-endian, high
+ * limb first in big-endian), `u256`/`i256` four. The reader never throws: a read past
+ * the end clears {@link DataReader.ok} and yields a zero/empty value.
+ */
+
+const MASK64 = 0xffffffffffffffffn;
+const utf8Encoder = new TextEncoder();
+const utf8Decoder = new TextDecoder();
+
+/**
+ * A growable little-endian (or big-endian, per the `be` flag) byte writer. Methods
+ * return `this` so writes chain. The backing buffer doubles as needed; call
+ * {@link toBytes} for an exact-length copy of what was written.
+ */
+export class DataWriter {
+    private buf: Uint8Array;
+    private view: DataView;
+    private off = 0;
+
+    /** @param capacity - initial buffer size in bytes (grows automatically). */
+    constructor(capacity = 64) {
+        this.buf = new Uint8Array(capacity > 0 ? capacity : 1);
+        this.view = new DataView(this.buf.buffer);
+    }
+
+    /**
+     * Ensures room for `extra` more bytes and returns the offset to write at. Grows
+     * (doubling) when needed, reassigning `buf`/`view`. Callers MUST read the returned
+     * offset into a local before touching `this.view`/`this.buf`, since a grow swaps
+     * them out from under a stale receiver.
+     */
+    private reserve(extra: number): number {
+        const need = this.off + extra;
+        if (need > this.buf.length) {
+            let n = this.buf.length;
+            while (n < need) n <<= 1;
+            const bigger = new Uint8Array(n);
+            bigger.set(this.buf.subarray(0, this.off));
+            this.buf = bigger;
+            this.view = new DataView(this.buf.buffer);
+        }
+        const at = this.off;
+        this.off += extra;
+        return at;
+    }
+
+    /** Writes an unsigned 8-bit byte (the low 8 bits of `v`). */
+    writeU8(v: number): this { const at = this.reserve(1); this.view.setUint8(at, v & 0xff); return this; }
+    /** Writes an unsigned 16-bit integer. @param be - big-endian if true (default little-endian). */
+    writeU16(v: number, be?: boolean): this { const at = this.reserve(2); this.view.setUint16(at, v & 0xffff, !be); return this; }
+    /** Writes an unsigned 32-bit integer. @param be - big-endian if true (default little-endian). */
+    writeU32(v: number, be?: boolean): this { const at = this.reserve(4); this.view.setUint32(at, v >>> 0, !be); return this; }
+    /** Writes an unsigned 64-bit integer (low 64 bits of `v`). @param be - big-endian if true. */
+    writeU64(v: bigint, be?: boolean): this { const at = this.reserve(8); this.view.setBigUint64(at, v & MASK64, !be); return this; }
+    /** Writes a signed 8-bit integer. */
+    writeI8(v: number): this { const at = this.reserve(1); this.view.setInt8(at, v); return this; }
+    /** Writes a signed 16-bit integer. @param be - big-endian if true (default little-endian). */
+    writeI16(v: number, be?: boolean): this { const at = this.reserve(2); this.view.setInt16(at, v, !be); return this; }
+    /** Writes a signed 32-bit integer. @param be - big-endian if true (default little-endian). */
+    writeI32(v: number, be?: boolean): this { const at = this.reserve(4); this.view.setInt32(at, v | 0, !be); return this; }
+    /** Writes a signed 64-bit integer. @param be - big-endian if true (default little-endian). */
+    writeI64(v: bigint, be?: boolean): this { const at = this.reserve(8); this.view.setBigInt64(at, BigInt.asIntN(64, v), !be); return this; }
+    /** Writes a 32-bit float. @param be - big-endian if true (default little-endian). */
+    writeF32(v: number, be?: boolean): this { const at = this.reserve(4); this.view.setFloat32(at, v, !be); return this; }
+    /** Writes a 64-bit float. @param be - big-endian if true (default little-endian). */
+    writeF64(v: number, be?: boolean): this { const at = this.reserve(8); this.view.setFloat64(at, v, !be); return this; }
+    /** Writes a boolean as one byte (1 or 0). */
+    writeBool(v: boolean): this { return this.writeU8(v ? 1 : 0); }
+
+    /** Writes the `count` 64-bit limbs of `u` (low limb first in LE, high limb first in BE). */
+    private writeLimbs(u: bigint, count: number, be: boolean): this {
+        if (be) {
+            for (let i = count - 1; i >= 0; i--) this.writeU64((u >> BigInt(i * 64)) & MASK64, true);
+        } else {
+            for (let i = 0; i < count; i++) this.writeU64((u >> BigInt(i * 64)) & MASK64, false);
+        }
+        return this;
+    }
+
+    /** Writes a `u32` length prefix followed by the raw bytes. @param be - endianness of the prefix. */
+    writeBytes(bytes: Uint8Array, be?: boolean): this {
+        this.writeU32(bytes.length, be);
+        if (bytes.length) {
+            const at = this.reserve(bytes.length);
+            this.buf.set(bytes, at);
+        }
+        return this;
+    }
+
+    /** Writes a `u32` byte-length prefix followed by the UTF-8 bytes. @param be - endianness of the prefix. */
+    writeString(value: string, be?: boolean): this {
+        const utf8 = utf8Encoder.encode(value);
+        this.writeU32(utf8.length, be);
+        if (utf8.length) {
+            const at = this.reserve(utf8.length);
+            this.buf.set(utf8, at);
+        }
+        return this;
+    }
+
+    /** Writes an unsigned 128-bit integer as two 64-bit limbs. @param be - big-endian if true. */
+    writeU128(v: bigint, be?: boolean): this { return this.writeLimbs(BigInt.asUintN(128, v), 2, !!be); }
+    /** Writes a signed 128-bit integer as two 64-bit limbs (two's complement). @param be - big-endian if true. */
+    writeI128(v: bigint, be?: boolean): this { return this.writeLimbs(BigInt.asUintN(128, v), 2, !!be); }
+    /** Writes an unsigned 256-bit integer as four 64-bit limbs. @param be - big-endian if true. */
+    writeU256(v: bigint, be?: boolean): this { return this.writeLimbs(BigInt.asUintN(256, v), 4, !!be); }
+    /** Writes a signed 256-bit integer as four 64-bit limbs (two's complement). @param be - big-endian if true. */
+    writeI256(v: bigint, be?: boolean): this { return this.writeLimbs(BigInt.asUintN(256, v), 4, !!be); }
+
+    /** Number of bytes written so far. */
+    length(): number { return this.off; }
+
+    /** A fresh copy of exactly the bytes written. */
+    toBytes(): Uint8Array { return this.buf.slice(0, this.off); }
+}
+
+/**
+ * Reads values written by {@link DataWriter}. Never throws: a read past the end
+ * clears {@link ok} and returns a zero/empty value, so a truncated or hostile buffer
+ * fails closed rather than crashing. Defaults to little-endian; pass `be` to match a
+ * big-endian writer.
+ */
+export class DataReader {
+    private buf: Uint8Array;
+    private view: DataView;
+    private off = 0;
+    /** Cleared to false if any read ran past the end of the buffer. */
+    ok = true;
+
+    /** @param bytes - the buffer to read from (its byteOffset/length are respected). */
+    constructor(bytes: Uint8Array) {
+        this.buf = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+
+    /** Returns true (and leaves `off` advanceable) if `n` more bytes are available; else clears `ok`. */
+    private has(n: number): boolean {
+        if (n < 0 || this.off + n > this.buf.length) {
+            this.ok = false;
+            return false;
+        }
+        return true;
+    }
+
+    /** Reads an unsigned 8-bit byte (0 past end). */
+    readU8(): number { if (!this.has(1)) return 0; const v = this.view.getUint8(this.off); this.off += 1; return v; }
+    /** Reads an unsigned 16-bit integer. @param be - big-endian if true (default little-endian). */
+    readU16(be?: boolean): number { if (!this.has(2)) return 0; const v = this.view.getUint16(this.off, !be); this.off += 2; return v; }
+    /** Reads an unsigned 32-bit integer. @param be - big-endian if true (default little-endian). */
+    readU32(be?: boolean): number { if (!this.has(4)) return 0; const v = this.view.getUint32(this.off, !be); this.off += 4; return v >>> 0; }
+    /** Reads an unsigned 64-bit integer. @param be - big-endian if true (default little-endian). */
+    readU64(be?: boolean): bigint { if (!this.has(8)) return 0n; const v = this.view.getBigUint64(this.off, !be); this.off += 8; return v; }
+    /** Reads a signed 8-bit integer (0 past end). */
+    readI8(): number { if (!this.has(1)) return 0; const v = this.view.getInt8(this.off); this.off += 1; return v; }
+    /** Reads a signed 16-bit integer. @param be - big-endian if true (default little-endian). */
+    readI16(be?: boolean): number { if (!this.has(2)) return 0; const v = this.view.getInt16(this.off, !be); this.off += 2; return v; }
+    /** Reads a signed 32-bit integer. @param be - big-endian if true (default little-endian). */
+    readI32(be?: boolean): number { if (!this.has(4)) return 0; const v = this.view.getInt32(this.off, !be); this.off += 4; return v; }
+    /** Reads a signed 64-bit integer. @param be - big-endian if true (default little-endian). */
+    readI64(be?: boolean): bigint { if (!this.has(8)) return 0n; const v = this.view.getBigInt64(this.off, !be); this.off += 8; return v; }
+    /** Reads a 32-bit float. @param be - big-endian if true (default little-endian). */
+    readF32(be?: boolean): number { if (!this.has(4)) return 0; const v = this.view.getFloat32(this.off, !be); this.off += 4; return v; }
+    /** Reads a 64-bit float. @param be - big-endian if true (default little-endian). */
+    readF64(be?: boolean): number { if (!this.has(8)) return 0; const v = this.view.getFloat64(this.off, !be); this.off += 8; return v; }
+    /** Reads a boolean (any non-zero byte is true). */
+    readBool(): boolean { return this.readU8() !== 0; }
+
+    /** Reads `count` 64-bit limbs and recombines them (low limb first in LE, high first in BE). */
+    private readLimbs(count: number, be: boolean): bigint {
+        let result = 0n;
+        if (be) {
+            for (let i = count - 1; i >= 0; i--) result |= this.readU64(true) << BigInt(i * 64);
+        } else {
+            for (let i = 0; i < count; i++) result |= this.readU64(false) << BigInt(i * 64);
+        }
+        return result;
+    }
+
+    /** Reads a `u32`-length-prefixed byte blob (empty past end). @param be - endianness of the prefix. */
+    readBytes(be?: boolean): Uint8Array {
+        const len = this.readU32(be);
+        if (!this.has(len)) return new Uint8Array(0);
+        const out = this.buf.slice(this.off, this.off + len);
+        this.off += len;
+        return out;
+    }
+
+    /** Reads a `u32`-byte-length-prefixed UTF-8 string (empty past end). @param be - endianness of the prefix. */
+    readString(be?: boolean): string {
+        const len = this.readU32(be);
+        if (!this.has(len)) return "";
+        const s = utf8Decoder.decode(this.buf.subarray(this.off, this.off + len));
+        this.off += len;
+        return s;
+    }
+
+    /** Reads an unsigned 128-bit integer. @param be - big-endian if true (default little-endian). */
+    readU128(be?: boolean): bigint { return this.readLimbs(2, !!be); }
+    /** Reads a signed 128-bit integer (two's complement). @param be - big-endian if true. */
+    readI128(be?: boolean): bigint { return BigInt.asIntN(128, this.readLimbs(2, !!be)); }
+    /** Reads an unsigned 256-bit integer. @param be - big-endian if true (default little-endian). */
+    readU256(be?: boolean): bigint { return this.readLimbs(4, !!be); }
+    /** Reads a signed 256-bit integer (two's complement). @param be - big-endian if true. */
+    readI256(be?: boolean): bigint { return BigInt.asIntN(256, this.readLimbs(4, !!be)); }
+
+    /** Bytes left to read. */
+    remaining(): number { return this.buf.length - this.off; }
+}

package/src/io/index.ts

@@ -1,11 +1,10 @@
-/**
- * toiljs IO, native binary serialization + fast collections, exposed to the client both as
- * `toiljs/io` imports and as ambient globals (see the generated `.toil/toil-env.d.ts`).
- */
-export { BinaryWriter } from './BinaryWriter.js';
-export { BinaryReader } from './BinaryReader.js';
-export { FastMap } from './FastMap.js';
-export { FastSet } from './FastSet.js';
-
-export type { PropertyExtendedKey, FastRecord, IndexKey } from './FastMap.js';
-export type { i8, i16, i32, i64, u8, u16, u32, u64, Selector, BufferLike } from './types.js';
+/**
+ * toiljs IO, native binary serialization + fast collections, exposed to the client both as
+ * `toiljs/io` imports and as ambient globals (see the generated `.toil/toil-env.d.ts`).
+ */
+export { FastMap } from './FastMap.js';
+export { FastSet } from './FastSet.js';
+export { DataWriter, DataReader } from './codec.js';
+
+export type { PropertyExtendedKey, FastRecord, IndexKey } from './FastMap.js';
+export type { i8, i16, i32, i64, u8, u16, u32, u64, Selector, BufferLike } from './types.js';

package/src/io/lengths.ts

@@ -1,14 +1,14 @@
-/** Byte widths for the fixed-size integer types written/read by the binary IO classes. */
-export const U8_BYTE_LENGTH = 1;
-export const U16_BYTE_LENGTH = 2;
-export const U32_BYTE_LENGTH = 4;
-export const U64_BYTE_LENGTH = 8;
-
-export const I8_BYTE_LENGTH = 1;
-export const I16_BYTE_LENGTH = 2;
-export const I32_BYTE_LENGTH = 4;
-export const I64_BYTE_LENGTH = 8;
-
-export const U128_BYTE_LENGTH = 16;
-export const I128_BYTE_LENGTH = 16;
-export const U256_BYTE_LENGTH = 32;
+/** Byte widths for the fixed-size integer types written/read by the binary IO classes. */
+export const U8_BYTE_LENGTH = 1;
+export const U16_BYTE_LENGTH = 2;
+export const U32_BYTE_LENGTH = 4;
+export const U64_BYTE_LENGTH = 8;
+
+export const I8_BYTE_LENGTH = 1;
+export const I16_BYTE_LENGTH = 2;
+export const I32_BYTE_LENGTH = 4;
+export const I64_BYTE_LENGTH = 8;
+
+export const U128_BYTE_LENGTH = 16;
+export const I128_BYTE_LENGTH = 16;
+export const U256_BYTE_LENGTH = 32;

package/src/io/types.ts

@@ -1,18 +1,19 @@
-/**
- * Branded numeric width aliases used by the binary IO classes. They are plain `number`/`bigint`
- * at runtime, the names document intent.
- */
-export type i8 = number;
-export type i16 = number;
-export type i32 = number;
-export type i64 = bigint;
-
-export type u8 = number;
-export type u16 = number;
-export type u32 = number;
-export type u64 = bigint;
-
-export type Selector = number;
-
-/** Anything that can back a {@link BinaryReader}. */
-export type BufferLike = Uint8Array;
+/**
+ * Branded numeric width aliases used by the binary IO classes. They are plain `number`/`bigint`
+ * at runtime, the names document intent.
+ */
+export type i8 = number;
+export type i16 = number;
+export type i32 = number;
+export type i64 = bigint;
+
+export type u8 = number;
+export type u16 = number;
+export type u32 = number;
+export type u64 = bigint;
+
+/** A method/route selector encoded as a `u32` on the wire. */
+export type Selector = number;
+
+/** Anything that can back a {@link DataReader}. */
+export type BufferLike = Uint8Array;

package/src/logger/index.ts

@@ -1,22 +1,22 @@
-/**
- * Minimal logger placeholder for toiljs. Swapped for the real implementation later.
- */
-
-export enum LogLevel {
-    Debug = 'debug',
-    Info = 'info',
-    Warn = 'warn',
-    Error = 'error',
-}
-
-export class Logger {
-    public constructor(private readonly scope: string = 'toil') {}
-
-    public log(level: LogLevel, message: string): void {
-        console.log(`[${this.scope}] ${level}: ${message}`);
-    }
-
-    public info(message: string): void {
-        this.log(LogLevel.Info, message);
-    }
-}
+/**
+ * Minimal logger placeholder for toiljs. Swapped for the real implementation later.
+ */
+
+export enum LogLevel {
+    Debug = 'debug',
+    Info = 'info',
+    Warn = 'warn',
+    Error = 'error',
+}
+
+export class Logger {
+    public constructor(private readonly scope: string = 'toil') {}
+
+    public log(level: LogLevel, message: string): void {
+        console.log(`[${this.scope}] ${level}: ${message}`);
+    }
+
+    public info(message: string): void {
+        this.log(LogLevel.Info, message);
+    }
+}

package/src/shared/index.ts

@@ -1,10 +1,10 @@
-/**
- * Shared primitives used across every toiljs target (client, compiler, cli, server tooling).
- * Placeholder, real shared types/utilities land here.
- */
-
-export const FRAMEWORK_NAME = 'toiljs';
-
-export interface ToilTarget {
-    readonly name: 'client' | 'compiler' | 'cli' | 'server';
-}
+/**
+ * Shared primitives used across every toiljs target (client, compiler, cli, server tooling).
+ * Placeholder, real shared types/utilities land here.
+ */
+
+export const FRAMEWORK_NAME = 'toiljs';
+
+export interface ToilTarget {
+    readonly name: 'client' | 'compiler' | 'cli' | 'server';
+}

package/std/client/index.d.ts

@@ -1,15 +1,15 @@
-/**
- * Ambient "native" types for the toiljs client framework.
- *
- * These are injected into the client target so users don't import them (a `declare global`
- * block discovered via tsconfig). Placeholder declarations; real framework globals land here.
- */
-
-declare global {
-    /** Global toil client handle, available without imports inside client code. */
-    const toil: {
-        readonly version: string;
-    };
-}
-
-export {};
+/**
+ * Ambient "native" types for the toiljs client framework.
+ *
+ * These are injected into the client target so users don't import them (a `declare global`
+ * block discovered via tsconfig). Placeholder declarations; real framework globals land here.
+ */
+
+declare global {
+    /** Global toil client handle, available without imports inside client code. */
+    const toil: {
+        readonly version: string;
+    };
+}
+
+export {};

package/std/client/package.json

@@ -1,3 +1,3 @@
-{
-    "types": "index.d.ts"
-}
+{
+    "types": "index.d.ts"
+}

package/test/assembly/example.spec.ts

@@ -1,7 +1,17 @@
-import { add } from '../../src/server';
-
-describe('server', () => {
-    it('adds two integers', () => {
-        expect<i32>(add(1, 2)).toBe(3);
-    });
-});
+import { Method, Response } from '../../server/runtime';
+
+describe('server runtime', () => {
+    it('numbers the HTTP methods per the wire contract', () => {
+        expect<i32>(<i32>Method.GET).toBe(0);
+        expect<i32>(<i32>Method.POST).toBe(1);
+        expect<i32>(<i32>Method.HEAD).toBe(5);
+    });
+
+    it('builds a 200 text response by default', () => {
+        expect<i32>(<i32>Response.text('hi').status).toBe(200);
+    });
+
+    it('defaults notFound() to 404', () => {
+        expect<i32>(<i32>Response.notFound().status).toBe(404);
+    });
+});

package/test/channel.test.ts

@@ -1,21 +1,21 @@
-import { describe, expect, it } from 'vitest';
-
-import { resolveChannelUrl } from '../src/client/channel/channel';
-
-describe('resolveChannelUrl', () => {
-    it('uses ws:// over http and the default /_toil path', () => {
-        expect(resolveChannelUrl(undefined, { protocol: 'http:', host: 'localhost:3000' })).toBe(
-            'ws://localhost:3000/_toil',
-        );
-    });
-
-    it('uses wss:// over https', () => {
-        expect(resolveChannelUrl('/_toil', { protocol: 'https:', host: 'app.example.com' })).toBe(
-            'wss://app.example.com/_toil',
-        );
-    });
-
-    it('normalizes a path without a leading slash', () => {
-        expect(resolveChannelUrl('live', { protocol: 'http:', host: 'h:1' })).toBe('ws://h:1/live');
-    });
-});
+import { describe, expect, it } from 'vitest';
+
+import { resolveChannelUrl } from '../src/client/channel/channel';
+
+describe('resolveChannelUrl', () => {
+    it('uses ws:// over http and the default /_toil path', () => {
+        expect(resolveChannelUrl(undefined, { protocol: 'http:', host: 'localhost:3000' })).toBe(
+            'ws://localhost:3000/_toil',
+        );
+    });
+
+    it('uses wss:// over https', () => {
+        expect(resolveChannelUrl('/_toil', { protocol: 'https:', host: 'app.example.com' })).toBe(
+            'wss://app.example.com/_toil',
+        );
+    });
+
+    it('normalizes a path without a leading slash', () => {
+        expect(resolveChannelUrl('live', { protocol: 'http:', host: 'h:1' })).toBe('ws://h:1/live');
+    });
+});

package/test/doctor.test.ts

@@ -7,8 +7,11 @@ import {
     checkMountSlots,
     checkNode,
     checkPeer,
+    checkPrettierPlugin,
     checkRelativeAssets,
+    checkRestDispatch,
     checkRootElement,
+    checkRpcWiring,
     checkSeoUrl,
     checkStyling,
     findRelativeAssets,
@@ -123,6 +126,68 @@ describe('config + environment checks', () => {
     });
 });
 
+describe('checkRpcWiring', () => {
+    const wired = {
+        buildServerWired: true,
+        tsconfigWired: true,
+        gitignoreWired: true,
+        toilscriptOk: true,
+    };
+
+    it('passes when fully wired', () => {
+        expect(checkRpcWiring(wired).status).toBe('pass');
+    });
+
+    it('warns and lists every missing piece', () => {
+        const c = checkRpcWiring({
+            buildServerWired: false,
+            tsconfigWired: false,
+            gitignoreWired: false,
+            toilscriptOk: false,
+        });
+        expect(c.status).toBe('warn');
+        expect(c.detail).toContain('toilscript');
+        expect(c.detail).toContain('--rpcModule');
+        expect(c.detail).toContain('tsconfig');
+        expect(c.detail).toContain('.gitignore');
+        expect(c.fix).toContain('--fix');
+    });
+
+    it('warns on a single missing piece', () => {
+        const c = checkRpcWiring({ ...wired, gitignoreWired: false });
+        expect(c.status).toBe('warn');
+        expect(c.detail).toContain('.gitignore');
+    });
+});
+
+describe('checkRestDispatch', () => {
+    it('passes when there are no @rest controllers', () => {
+        expect(checkRestDispatch({ hasControllers: false, dispatched: false }).status).toBe('pass');
+    });
+
+    it('passes when controllers are dispatched', () => {
+        expect(checkRestDispatch({ hasControllers: true, dispatched: true }).status).toBe('pass');
+    });
+
+    it('warns when controllers exist but nothing dispatches them', () => {
+        const c = checkRestDispatch({ hasControllers: true, dispatched: false });
+        expect(c.status).toBe('warn');
+        expect(c.detail).toContain('Rest.dispatch');
+        expect(c.fix).toContain('RestHandler');
+    });
+});
+
+describe('checkPrettierPlugin', () => {
+    it('passes when present', () => {
+        expect(checkPrettierPlugin(true).status).toBe('pass');
+    });
+    it('warns (not fails) when missing, pointing at --fix', () => {
+        const c = checkPrettierPlugin(false);
+        expect(c.status).toBe('warn');
+        expect(c.fix).toContain('--fix');
+    });
+});
+
 describe('summarize', () => {
     it('tallies pass/warn/fail across groups', () => {
         const groups: CheckGroup[] = [