@thetally/httptree 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./router.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./router.js";

package/dist/router.d.ts

@@ -0,0 +1,129 @@
+import http from "http";
+import { type WebSocket } from "ws";
+type Flat<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Params<Path extends string> = ParamsInner<Path>;
+type ParamsInner<S extends string> = S extends `[[...${infer P}]]/${infer Rest}` ? {
+    [K in P]?: string[];
+} : S extends `[[...${infer P}]]/` ? {
+    [K in P]?: string[];
+} : S extends `[[...${infer P}]]` ? {
+    [K in P]?: string[];
+} : S extends `[...${infer P}]/${infer Rest}` ? {
+    [K in P]: string[];
+} : S extends `[...${infer P}]/` ? {
+    [K in P]: string[];
+} : S extends `[...${infer P}]` ? {
+    [K in P]: string[];
+} : S extends `[[${infer P}]]/${infer Rest}` ? {
+    [K in P]?: string;
+} & ParamsInner<Rest> : S extends `[[${infer P}]]/` ? {
+    [K in P]?: string;
+} : S extends `[[${infer P}]]` ? {
+    [K in P]?: string;
+} : S extends `[${infer P}]/${infer Rest}` ? {
+    [K in P]: string;
+} & ParamsInner<Rest> : S extends `[${infer P}]/` ? {
+    [K in P]: string;
+} : S extends `[${infer P}]` ? {
+    [K in P]: string;
+} : S extends `${infer _Segment}/${infer Rest}` ? ParamsInner<Rest> : {};
+type Middleware = (req: http.IncomingMessage & {
+    params: Record<string, string | undefined>;
+}, res: http.ServerResponse, next: (err?: Error) => void) => void | Promise<void>;
+type PatternInfo = {
+    regex: RegExp;
+    params: string[];
+    score: number;
+};
+type HandlerReturn = TreeResponse | string | Buffer | void | Promise<TreeResponse | string | Buffer | void>;
+type Handler<P extends Record<string, any>> = (req: http.IncomingMessage & {
+    params: Flat<P>;
+}, res: http.ServerResponse) => HandlerReturn;
+type WSHandler<P extends Record<string, any> = Record<string, any>> = (ws: WebSocket, req: http.IncomingMessage & {
+    params: Flat<P>;
+}) => void | Promise<void>;
+export type UpgradeHandler = (req: http.IncomingMessage, socket: any, head: Buffer) => boolean | void;
+type Precheck = (req: http.IncomingMessage, res: http.ServerResponse) => boolean | Promise<boolean>;
+type Route = {
+    method: string;
+    info: PatternInfo;
+    handler: Handler<any>;
+    prechecks: Precheck[];
+};
+type WSRoute = {
+    info: PatternInfo;
+    handler: WSHandler;
+    prechecks: Precheck[];
+};
+declare class Router<P extends Record<string, string | undefined> = {}> {
+    protected base: string;
+    protected routes: Route[];
+    protected wsRoutes: WSRoute[];
+    protected inheritedChecks: Precheck[];
+    protected root: Router<any>;
+    protected errorHandlers: Map<string, (err: any, req: http.IncomingMessage, res: http.ServerResponse) => void>;
+    constructor(base?: string, root?: Router<any>, inheritedChecks?: Precheck[]);
+    handleError(type: "NotFound" | "InternalError" | "*", handler: (err: any, req: http.IncomingMessage, res: http.ServerResponse) => void): this;
+    branch<Path extends string>(path: Path, check?: Precheck): Router<P & Params<Path>>;
+    get<Path extends string>(path: Path, h: Handler<Flat<P & Params<Path>>>): this;
+    post<Path extends string>(path: Path, h: Handler<Flat<P & Params<Path>>>): this;
+    put<Path extends string>(path: Path, h: Handler<Flat<P & Params<Path>>>): this;
+    delete<Path extends string>(path: Path, h: Handler<Flat<P & Params<Path>>>): this;
+    all<Path extends string>(path: Path, h: Handler<Flat<P & Params<Path>>>): this;
+    ws<Path extends string>(path: Path, h: WSHandler<Flat<P & Params<Path>>>): this;
+    handle: (req: http.IncomingMessage & {
+        params: Record<string, string | string[] | undefined>;
+    }, res: http.ServerResponse, next: (err?: Error) => void) => Promise<void>;
+    handleWS: (ws: WebSocket, req: http.IncomingMessage) => Promise<void>;
+    protected add(method: string, path: string, handler: Handler<any>): this;
+}
+export declare class BaseRouter extends Router {
+    #private;
+    handleError(type: string, handler: (err: any, req: http.IncomingMessage, res: http.ServerResponse) => void): this;
+    listen(port: number, cb?: () => void): Promise<void> | import('http').Server;
+    stop(): Promise<void>;
+    use(fn: Middleware, priority?: number): void;
+    useUpgrade(fn: UpgradeHandler, priority?: number): void;
+}
+export declare function root(base?: string): BaseRouter;
+export declare const responseSymbol: unique symbol;
+export interface TreeResponse {
+    [responseSymbol]: true;
+    body: string | Buffer;
+    status: number;
+    headers: Record<string, string>;
+}
+export declare function json(data: unknown, opts?: {
+    status?: number;
+    headers?: Record<string, string>;
+}): TreeResponse;
+export declare function text(body: string, opts?: {
+    status?: number;
+    headers?: Record<string, string>;
+}): TreeResponse;
+export declare function redirect(location: string, status?: 301 | 302 | 303 | 307 | 308): never;
+declare function _error(status: number, body?: string | object, headers?: Record<string, string>): never;
+declare const error: typeof _error & {
+    badRequest: (body?: string | object, headers?: Record<string, string>) => never;
+    unauthorized: (body?: string | object, headers?: Record<string, string>) => never;
+    forbidden: (body?: string | object, headers?: Record<string, string>) => never;
+    notFound: (body?: string | object, headers?: Record<string, string>) => never;
+    conflict: (body?: string | object, headers?: Record<string, string>) => never;
+    unprocessableEntity: (body?: string | object, headers?: Record<string, string>) => never;
+    tooManyRequests: (body?: string | object, headers?: Record<string, string>) => never;
+    internalServerError: (body?: string | object, headers?: Record<string, string>) => never;
+    badGateway: (body?: string | object, headers?: Record<string, string>) => never;
+    serviceUnavailable: (body?: string | object, headers?: Record<string, string>) => never;
+};
+export { error };
+export declare function raw(body: Buffer, opts?: {
+    status?: number;
+    headers?: Record<string, string>;
+}): TreeResponse;
+export declare function file(body: Buffer, filename: string, contentType?: string): TreeResponse;
+export declare function html(body: string, opts?: {
+    status?: number;
+    headers?: Record<string, string>;
+}): TreeResponse;

package/dist/router.js

@@ -0,0 +1,574 @@
+import http from "http";
+import url from "url";
+import { createRequire } from "module";
+const debug = (...args) => {
+    if (typeof process !== "undefined")
+        if (process.env?.HTTPTREE_DEBUG) {
+            console.log("[httptree]", ...args);
+        }
+};
+const _require = (typeof require !== "undefined")
+    ? require
+    : createRequire(import.meta.url);
+let WebSocketServer;
+function getWebSocketServer() {
+    if (WebSocketServer)
+        return WebSocketServer;
+    try {
+        const mod = _require("ws");
+        WebSocketServer = mod.WebSocketServer;
+        return WebSocketServer;
+    }
+    catch {
+        return undefined;
+    }
+}
+const middlewares = [];
+let _regIdx = 0;
+function use(fn, priority = 0) {
+    debug(`Registering middleware with priority=${priority}, idx=${_regIdx}`);
+    middlewares.push({ fn, priority, idx: _regIdx++ });
+}
+function runMiddlewares(req, res, done) {
+    const reqWithParams = req;
+    if (!reqWithParams.params)
+        reqWithParams.params = {};
+    const list = [...middlewares].sort((a, b) => b.priority - a.priority || a.idx - b.idx);
+    let idx = 0;
+    function next(err) {
+        if (err)
+            return done(err);
+        const entry = list[idx++];
+        if (!entry)
+            return done();
+        debug(`Running middleware idx=${entry.idx}, priority=${entry.priority}`);
+        try {
+            const ret = entry.fn(reqWithParams, res, next);
+            if (ret && typeof ret.then === "function") {
+                ret.catch((e) => next(e instanceof Error ? e : new Error(String(e))));
+            }
+        }
+        catch (e) {
+            next(e instanceof Error ? e : new Error(String(e)));
+        }
+    }
+    next();
+}
+const upgradeHandlers = [];
+let _upgradeIdx = 0;
+function useUpgrade(fn, priority = 0) {
+    upgradeHandlers.push({ fn, priority, idx: _upgradeIdx++ });
+}
+function escapeRE(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compilePattern(path) {
+    if (!path.startsWith("/"))
+        path = "/" + path;
+    if (path !== "/" && path.endsWith("/"))
+        path = path.slice(0, -1);
+    const parts = path.split("/").slice(1).filter(Boolean);
+    const params = [];
+    let re = "^";
+    let score = 0;
+    for (const seg of parts) {
+        if (seg.startsWith("[...") && seg.endsWith("]")) {
+            params.push("..." + seg.slice(4, -1));
+            re += "(?:/(.*))?";
+            break;
+        }
+        if (seg.startsWith("[[") && seg.endsWith("]]")) {
+            params.push(seg.slice(2, -2));
+            re += "(?:/([^/]+))?";
+            score += 1;
+            continue;
+        }
+        if (seg.startsWith("[") && seg.endsWith("]")) {
+            params.push(seg.slice(1, -1));
+            re += "/([^/]+)";
+            score += 1;
+            continue;
+        }
+        re += "/" + escapeRE(seg);
+        score += 10;
+    }
+    if (parts.length === 0)
+        re += "/?";
+    re += "/?$";
+    return { regex: new RegExp(re), params, score };
+}
+function finishResponse(res, result) {
+    if (res.writableEnded)
+        return;
+    if (!result) {
+        res.statusCode = 204;
+        res.end();
+        return;
+    }
+    if (result[responseSymbol]) {
+        const r = result;
+        res.statusCode = r.status;
+        for (const [k, v] of Object.entries(r.headers || {})) {
+            try {
+                res.setHeader(k, v);
+            }
+            catch { }
+        }
+        res.end(r.body);
+        return;
+    }
+    if (typeof result === "string" || Buffer.isBuffer(result)) {
+        res.statusCode = 200;
+        res.end(result);
+        return;
+    }
+    res.statusCode = 204;
+    res.end();
+}
+class Router {
+    base;
+    routes;
+    wsRoutes;
+    inheritedChecks;
+    root;
+    errorHandlers;
+    constructor(base = "/", root, inheritedChecks = []) {
+        this.base = normalize(base);
+        this.root = root ?? this;
+        this.routes = root ? root.routes : [];
+        this.wsRoutes = root ? root.wsRoutes : [];
+        this.inheritedChecks = inheritedChecks;
+        this.errorHandlers = new Map();
+        this.parent = undefined;
+        if (!root) {
+            this.branches = [];
+            use(this.handle);
+        }
+    }
+    handleError(type, handler) {
+        debug(`Registering error handler for type '${type}' on base '${this.base}'`);
+        this.errorHandlers.set(type, handler);
+        return this;
+    }
+    branch(path, check) {
+        let full = join(this.base, path);
+        debug(`Creating branch: parent base='${this.base}', requested path='${path}', full before normalization='${full}'`);
+        const normalizedFull = normalize(full);
+        debug(`Normalized full path for branch: '${normalizedFull}'`);
+        const checks = [...this.inheritedChecks];
+        if (check)
+            checks.push(check);
+        const branch = new Router(normalizedFull, this.root, checks);
+        branch.parent = this;
+        if (!this.branches)
+            this.branches = [];
+        this.branches.push(branch);
+        debug(`Created branch with base '${branch.base}' under parent base '${this.base}'`);
+        return branch;
+    }
+    get(path, h) {
+        debug(`Registering GET route: base='${this.base}', path='${path}'`);
+        return this.add("GET", path, h);
+    }
+    post(path, h) {
+        debug(`Registering POST route: base='${this.base}', path='${path}'`);
+        return this.add("POST", path, h);
+    }
+    put(path, h) {
+        debug(`Registering PUT route: base='${this.base}', path='${path}'`);
+        return this.add("PUT", path, h);
+    }
+    delete(path, h) {
+        debug(`Registering DELETE route: base='${this.base}', path='${path}'`);
+        return this.add("DELETE", path, h);
+    }
+    all(path, h) {
+        debug(`Registering ALL route: base='${this.base}', path='${path}'`);
+        return this.add("*", path, h);
+    }
+    ws(path, h) {
+        debug(`Registering WS route: base='${this.base}', path='${path}'`);
+        const WSSCtor = getWebSocketServer();
+        if (!WSSCtor) {
+            throw new Error("WebSocket support requires the 'ws' package. Please install it first.");
+        }
+        const full = join(this.base, path);
+        const info = compilePattern(full);
+        this.wsRoutes.push({
+            info,
+            handler: h,
+            prechecks: [...this.inheritedChecks],
+        });
+        this.wsRoutes.sort((a, b) => b.info.score - a.info.score);
+        return this;
+    }
+    handle = async (req, res, next) => {
+        const pathname = url.parse(req.url || "/").pathname || "/";
+        const method = (req.method || "GET").toUpperCase();
+        debug(`Handling request: method='${method}', path='${pathname}'`);
+        let matchedRoute = null;
+        for (const r of this.routes) {
+            if (r.method !== "*" && r.method !== method)
+                continue;
+            const m = r.info.regex.exec(pathname);
+            if (!m)
+                continue;
+            debug(`Route matched: method='${r.method}', regex='${r.info.regex}', params=[${r.info.params.join(", ")}]`);
+            matchedRoute = r;
+            const params = {};
+            r.info.params.forEach((p, i) => {
+                debug(`Extracting param '${p}' from segment '${m[i + 1]}'`);
+                if (p.startsWith("...")) {
+                    const val = m[i + 1] ? decodeURIComponent(m[i + 1]) : undefined;
+                    params[p.replace(/^\.\.\./, "")] = val !== undefined ? val.split("/").filter(Boolean) : [];
+                }
+                else {
+                    params[p] = m[i + 1] ? decodeURIComponent(m[i + 1]) : undefined;
+                }
+            });
+            for (const chk of r.prechecks) {
+                debug(`Running precheck for route: method='${r.method}', path regex='${r.info.regex}'`);
+                const ok = await chk(req, res);
+                if (!ok) {
+                    debug(`Precheck failed for route: method='${r.method}', path regex='${r.info.regex}'`);
+                    res.statusCode = 403;
+                    res.end("Forbidden");
+                    return;
+                }
+            }
+            try {
+                req.params = params;
+                debug(`Invoking handler for route: method='${r.method}', path regex='${r.info.regex}'`);
+                const result = await r.handler(req, res);
+                if (result && typeof result === "object" && result[responseSymbol]) {
+                    finishResponse(res, result);
+                    return;
+                }
+                if (!res.writableEnded) {
+                    res.end();
+                }
+                return;
+            }
+            catch (e) {
+                if (e && typeof e === "object" && e[responseSymbol]) {
+                    finishResponse(res, e);
+                    return;
+                }
+                let errType = (e && typeof e === "object" && e.name) || (e && typeof e === "object" && e.constructor && e.constructor.name) || typeof e;
+                let lastError = e;
+                let current = this;
+                if (process.env.HTTPTREE_DEBUG) {
+                    debug(`Error thrown: type='${errType}' on base='${this.base}'`);
+                }
+                while (current) {
+                    const handler = current.errorHandlers.get(String(errType)) || current.errorHandlers.get("*");
+                    if (handler) {
+                        if (process.env.HTTPTREE_DEBUG) {
+                            debug(`Using error handler for type='${errType}' on base='${current.base}'`);
+                        }
+                        try {
+                            handler(lastError, req, res);
+                        }
+                        catch (err) {
+                            lastError = err;
+                            if (process.env.HTTPTREE_DEBUG) {
+                                debug(`Handler on base='${current.base}' threw, trying parent`);
+                            }
+                            current = current.parent;
+                            continue;
+                        }
+                        return;
+                    }
+                    else if (process.env.HTTPTREE_DEBUG) {
+                        debug(`No handler for type='${errType}' on base='${current.base}', moving to parent`);
+                    }
+                    current = current.parent;
+                }
+                if (!res.writableEnded) {
+                    res.statusCode = 500;
+                    res.end("Internal Server Error");
+                }
+                if (lastError &&
+                    ((typeof lastError !== "object" || !('suppressLog' in lastError)) &&
+                        !(lastError && typeof lastError === "object" && lastError.name === "NotFound"))) {
+                    console.error("Uncaught handler error:", lastError);
+                }
+                return;
+            }
+        }
+        if (!res.writableEnded) {
+            debug(`No route matched for method='${method}', path='${pathname}'. Resolving most specific branch.`);
+            let mostSpecific = this;
+            let current = this;
+            if (process.env.HTTPTREE_DEBUG) {
+                debug(`NotFound: resolving most specific branch for path='${pathname}'`);
+            }
+            while (true) {
+                let found = false;
+                if (current.branches) {
+                    let bestBranch = null;
+                    let bestLen = -1;
+                    for (const branch of current.branches) {
+                        if (pathname.startsWith(branch.base) && branch.base.length > bestLen) {
+                            bestBranch = branch;
+                            bestLen = branch.base.length;
+                        }
+                    }
+                    if (bestBranch) {
+                        if (process.env.HTTPTREE_DEBUG) {
+                            debug(`Path '${pathname}' matches branch base='${bestBranch.base}'`);
+                        }
+                        mostSpecific = bestBranch;
+                        current = bestBranch;
+                        found = true;
+                    }
+                }
+                if (!found)
+                    break;
+            }
+            let errType = "NotFound";
+            let lastError = Object.assign(new Error("Not Found"), { name: "NotFound" });
+            current = mostSpecific;
+            while (current) {
+                const handler = current.errorHandlers.get(errType) || current.errorHandlers.get("*");
+                if (handler) {
+                    if (process.env.HTTPTREE_DEBUG) {
+                        debug(`Using NotFound handler on base='${current.base}' for path='${pathname}'`);
+                    }
+                    try {
+                        handler(lastError, req, res);
+                    }
+                    catch (err) {
+                        lastError = err;
+                        if (process.env.HTTPTREE_DEBUG) {
+                            debug(`NotFound handler on base='${current.base}' threw, trying parent`);
+                        }
+                        current = current.parent;
+                        continue;
+                    }
+                    return;
+                }
+                else if (process.env.HTTPTREE_DEBUG) {
+                    debug(`No NotFound handler on base='${current.base}', moving to parent`);
+                }
+                current = current.parent;
+            }
+            if (!res.writableEnded) {
+                res.statusCode = 404;
+                res.end("Not Found");
+            }
+            if (lastError && (typeof lastError !== "object" || !('suppressLog' in lastError))) {
+                console.error("Uncaught handler error:", lastError);
+            }
+        }
+    };
+    handleWS = async (ws, req) => {
+        const pathname = url.parse(req.url || "/").pathname || "/";
+        for (const r of this.wsRoutes) {
+            const m = r.info.regex.exec(pathname);
+            if (!m)
+                continue;
+            const params = {};
+            r.info.params.forEach((p, i) => {
+                params[p] = m[i + 1] ? decodeURIComponent(m[i + 1]) : undefined;
+            });
+            // ensure req.params is available for prechecks and handler
+            const reqWithParams = req;
+            reqWithParams.params = params;
+            for (const chk of r.prechecks) {
+                const ok = await chk(reqWithParams, {});
+                if (!ok) {
+                    ws.close(1008, "Forbidden");
+                    return;
+                }
+            }
+            await r.handler(ws, reqWithParams);
+            return;
+        }
+        ws.close(1002, "No WS route");
+    };
+    add(method, path, handler) {
+        const full = join(this.base, path);
+        const info = compilePattern(full);
+        debug(`Adding route: method='${method}', full path='${full}', regex='${info.regex}', params=[${info.params.join(", ")}]`);
+        this.routes.push({
+            method,
+            info,
+            handler,
+            prechecks: [...this.inheritedChecks],
+        });
+        this.routes.sort((a, b) => b.info.score - a.info.score ||
+            b.info.regex.source.length - a.info.regex.source.length);
+        return this;
+    }
+}
+export class BaseRouter extends Router {
+    #server;
+    handleError(type, handler) {
+        super.handleError(type, handler);
+        return this;
+    }
+    listen(port, cb) {
+        const server = http.createServer((req, res) => {
+            runMiddlewares(req, res, (err) => {
+                if (err) {
+                    res.statusCode = 500;
+                    res.end("Internal Error");
+                }
+            });
+        });
+        this.#server = server;
+        const WSSCtor = getWebSocketServer();
+        if (WSSCtor) {
+            const wss = new WSSCtor({ noServer: true });
+            useUpgrade((req, socket, head) => {
+                // only accept websocket upgrades
+                if (req.headers.upgrade !== "websocket")
+                    return false;
+                wss.handleUpgrade(req, socket, head, (ws) => {
+                    this.handleWS(ws, req);
+                });
+                return true;
+            });
+        }
+        server.on("upgrade", (req, socket, head) => {
+            const list = [...upgradeHandlers].sort((a, b) => b.priority - a.priority || a.idx - b.idx);
+            for (const h of list) {
+                try {
+                    const handled = h.fn(req, socket, head);
+                    if (handled)
+                        return;
+                }
+                catch (e) {
+                    socket.destroy();
+                    return;
+                }
+            }
+            // nothing handled it
+            socket.destroy();
+        });
+        if (cb) {
+            server.listen(port, cb);
+            return server;
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                server.listen(port, () => resolve());
+                server.on('error', reject);
+            });
+        }
+    }
+    stop() {
+        return new Promise((resolve, reject) => {
+            if (this.#server) {
+                this.#server.close((err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+                this.#server = undefined;
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    use(fn, priority = 0) {
+        use(fn, priority);
+    }
+    useUpgrade(fn, priority = 0) {
+        useUpgrade(fn, priority);
+    }
+}
+function normalize(p) {
+    if (!p.startsWith("/"))
+        p = "/" + p;
+    p = p.replace(/\/+/g, "/");
+    if (p !== "/" && p.endsWith("/"))
+        p = p.slice(0, -1);
+    return p;
+}
+function join(a, b) {
+    if (a !== "/" && a.endsWith("/"))
+        a = a.slice(0, -1);
+    b = b.replace(/^\/+/, "");
+    if (!b)
+        return a;
+    return a + "/" + b;
+}
+export function root(base = "/") {
+    return new BaseRouter(base);
+}
+export const responseSymbol = Symbol("httptree.response");
+function createResponse(body, status = 200, headers = {}) {
+    return {
+        [responseSymbol]: true,
+        body,
+        status,
+        headers,
+    };
+}
+export function json(data, opts = {}) {
+    return createResponse(JSON.stringify(data), opts.status ?? 200, {
+        "Content-Type": "application/json; charset=utf-8",
+        ...opts.headers,
+    });
+}
+export function text(body, opts = {}) {
+    return createResponse(body, opts.status ?? 200, {
+        "Content-Type": "text/plain; charset=utf-8",
+        ...opts.headers,
+    });
+}
+export function redirect(location, status = 302) {
+    throw {
+        [responseSymbol]: true,
+        body: "",
+        status,
+        headers: {
+            Location: location,
+        },
+    };
+}
+function _error(status, body = http.STATUS_CODES[status] ?? "Error", headers = {}) {
+    const isJSON = typeof body === "object";
+    throw {
+        [responseSymbol]: true,
+        body: isJSON ? JSON.stringify(body) : String(body),
+        status,
+        headers: {
+            "Content-Type": isJSON
+                ? "application/json; charset=utf-8"
+                : "text/plain; charset=utf-8",
+            ...headers,
+        },
+    };
+}
+const error = _error;
+error.badRequest = (body = "Bad Request", headers = {}) => _error(400, body, headers);
+error.unauthorized = (body = "Unauthorized", headers = {}) => _error(401, body, headers);
+error.forbidden = (body = "Forbidden", headers = {}) => _error(403, body, headers);
+error.notFound = (body = "Not Found", headers = {}) => _error(404, body, headers);
+error.conflict = (body = "Conflict", headers = {}) => _error(409, body, headers);
+error.unprocessableEntity = (body = "Unprocessable Entity", headers = {}) => _error(422, body, headers);
+error.tooManyRequests = (body = "Too Many Requests", headers = {}) => _error(429, body, headers);
+error.internalServerError = (body = "Internal Server Error", headers = {}) => _error(500, body, headers);
+error.badGateway = (body = "Bad Gateway", headers = {}) => _error(502, body, headers);
+error.serviceUnavailable = (body = "Service Unavailable", headers = {}) => _error(503, body, headers);
+export { error };
+export function raw(body, opts = {}) {
+    return createResponse(body, opts.status ?? 200, opts.headers ?? {});
+}
+export function file(body, filename, contentType = "application/octet-stream") {
+    return createResponse(body, 200, {
+        "Content-Type": contentType,
+        "Content-Disposition": `attachment; filename="${filename}"`,
+    });
+}
+export function html(body, opts = {}) {
+    return createResponse(body, opts.status ?? 200, {
+        "Content-Type": "text/html; charset=utf-8",
+        ...opts.headers,
+    });
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "@thetally/httptree",
+    "version": "0.1.0",
+    "description": "A TypeScript library for creating and managing HTTP request trees.",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "lint": "eslint src --ext .ts",
+        "test": "node dist/test/test.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": ""
+    },
+    "keywords": [
+        "http",
+        "tree",
+        "typescript"
+    ],
+    "author": "",
+    "type": "module",
+    "license": "MIT",
+    "files": [
+        "dist/**/*",
+        "!dist/test/**/*"
+    ],
+    "devDependencies": {
+        "@types/node": "^25.2.3",
+        "@types/ws": "^8.18.1",
+        "eslint": "^8.0.0",
+        "typescript": "^5.0.0",
+        "ws": "^8.19.0"
+    },
+    "peerDependencies": {
+        "ws": "^8.0.0"
+    },
+    "peerDependenciesMeta": {
+        "ws": {
+            "optional": true
+        }
+    }
+}