hadars 0.4.1 → 0.4.2

package/src/utils/rspack.ts

@@ -1,467 +0,0 @@
-import rspack from "@rspack/core";
-import type { Configuration, RuleSetLoaderWithOptions, RuleSetRule } from "@rspack/core";
-import ReactRefreshPlugin from '@rspack/plugin-react-refresh';
-import path from 'node:path';
-import type { SwcPluginList } from '../types/hadars';
-import { fileURLToPath } from "node:url";
-import pathMod from "node:path";
-import { existsSync } from "node:fs";
-
-const __dirname = process.cwd();
-const packageDir = pathMod.dirname(fileURLToPath(import.meta.url));
-const clientScriptPath = pathMod.resolve(packageDir, 'template.html');
-
-// When running from compiled dist/cli.js the loader is pre-built as loader.cjs.
-// The .cjs extension forces CommonJS regardless of the package "type": "module".
-// When running from source (bun/tsx) it falls back to loader.ts.
-const loaderPath = existsSync(pathMod.resolve(packageDir, 'loader.cjs'))
-    ? pathMod.resolve(packageDir, 'loader.cjs')
-    : pathMod.resolve(packageDir, 'loader.ts');
-
-const getConfigBase = (mode: "development" | "production", isServerBuild = false): Omit<Configuration, "entry" | "output" | "plugins"> => {
-    const isDev = mode === 'development';
-    return {
-        experiments: {
-            css: true,
-            outputModule: true,
-        },
-        resolve: {
-            modules: [
-                path.resolve(__dirname, 'node_modules'),
-                // 'node_modules' (relative) enables the standard upward-traversal
-                // resolution so rspack can find transitive deps (e.g. webpack-dev-server)
-                // that live in a parent node_modules when running from a sub-project.
-                'node_modules',
-            ],
-            tsConfig: path.resolve(__dirname, 'tsconfig.json'),
-            extensions: ['.tsx', '.ts', '.js', '.jsx'],
-        },
-        module: {
-            rules: [
-                {
-                    test: /\.css$/,
-                    use: [{ loader: "builtin:lightningcss-loader" }],
-                    type: "css",
-                },
-                {
-                    test: /\.svg$/i,
-                    issuer: /\.[jt]sx?$/,
-                    use: ['@svgr/webpack'],
-                },
-                {
-                    test: /\.m?jsx?$/,
-                    resolve: {
-                        fullySpecified: false,
-                    },
-                    exclude: [loaderPath],
-                    use: [
-                        // Transforms loadModule('./path') based on build target.
-                        // Runs before swc-loader (loaders execute right-to-left).
-                        {
-                            loader: loaderPath,
-                            options: { server: isServerBuild },
-                        },
-                        {
-                            loader: 'builtin:swc-loader',
-                            options: {
-                                jsc: {
-                                    parser: {
-                                        syntax: 'ecmascript',
-                                        jsx: true,
-                                    },
-                                    transform: {
-                                        react: {
-                                            runtime: "automatic",
-                                            development: isDev,
-                                            refresh: isDev && !isServerBuild,
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    type: 'javascript/auto',
-                },
-                {
-                    test: /\.tsx?$/,
-                    resolve: {
-                        fullySpecified: false,
-                    },
-                    exclude: [loaderPath],
-                    use: [
-                        {
-                            loader: loaderPath,
-                            options: { server: isServerBuild },
-                        },
-                        {
-                            loader: 'builtin:swc-loader',
-                            options: {
-                                jsc: {
-                                    parser: {
-                                        syntax: 'typescript',
-                                        tsx: true,
-                                    },
-                                    transform: {
-                                        react: {
-                                            runtime: "automatic",
-                                            development: isDev,
-                                            refresh: isDev && !isServerBuild,
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    type: 'javascript/auto',
-                },
-            ],
-        },
-    }
-}
-
-type EntryOutput = Configuration["output"];
-
-interface EntryOptions {
-    target: Configuration["target"],
-    output: EntryOutput,
-    mode: "development" | "production",
-    // optional swc plugins to pass to swc-loader
-    swcPlugins?: SwcPluginList,
-    // optional path to a custom HTML template (resolved relative to cwd)
-    htmlTemplate?: string,
-    // optional compile-time defines (e.g. { 'process.env.NODE_ENV': '"development"' })
-    define?: Record<string, string>;
-    base?: string;
-    // optional rspack optimization overrides (production client builds only)
-    optimization?: Record<string, unknown>;
-    // additional module rules appended after the built-in rules
-    moduleRules?: Record<string, any>[];
-    // additional rspack/webpack-compatible plugins (applied after built-in plugins)
-    plugins?: Array<{ apply(compiler: any): void }>;
-    // PostCSS plugins to pass to postcss-loader (replaces the default builtin:lightningcss-loader).
-    // Use this when you need PostCSS transforms such as Tailwind CSS v4 (@tailwindcss/postcss).
-    postcssPlugins?: any[];
-    // force React runtime mode independently of build mode (client only)
-    reactMode?: 'development' | 'production';
-}
-
-const buildCompilerConfig = (
-    entry: string,
-    opts: EntryOptions,
-    includeHotPlugin: boolean,
-): Configuration => {
-    const { base } = opts;
-    const isDev = opts.mode === 'development';
-    const isServerBuild = Boolean(
-        (opts.output && typeof opts.output === 'object' && (opts.output.library || String(opts.output.filename || '').includes('ssr')))
-    );
-    const Config = getConfigBase(opts.mode, isServerBuild);
-
-    // shallow-clone base config to avoid mutating shared Config while preserving RegExp and plugin instances
-    const localConfig: any = {
-        ...Config,
-        module: {
-            ...Config.module,
-            rules: (Config.module && Array.isArray(Config.module.rules) ? Config.module.rules : []).map((r: any) => {
-                // shallow copy each rule and its 'use' array/entries so we can mutate safely
-                const nr: any = { ...r };
-                if (r && Array.isArray(r.use)) {
-                    nr.use = r.use.map((u: any) => ({ ...(typeof u === 'object' ? u : { loader: u }) }));
-                }
-                return nr;
-            }),
-        },
-    };
-
-    // if swc plugins are provided, inject them into swc-loader options for js/jsx and ts/tsx rules
-    if (opts.swcPlugins && Array.isArray(opts.swcPlugins) && opts.swcPlugins.length > 0) {
-        const rules = localConfig.module && localConfig.module.rules;
-        if (Array.isArray(rules)) {
-            for (const rule of rules) {
-                const ruleUse = rule as RuleSetRule;
-                if (ruleUse.use && Array.isArray(ruleUse.use)) {
-                    for (const entry of ruleUse.use ) {
-                        const useEntry = entry as RuleSetLoaderWithOptions;
-                        if (useEntry && useEntry.loader && typeof useEntry.loader === 'string' && useEntry.loader.includes('swc-loader')) {
-                            const options = ( useEntry.options || {} ) as  Record<string, any>;
-                            useEntry.options = options;
-                            useEntry.options.jsc = useEntry.options.jsc || {};
-                            useEntry.options.jsc.experimental = useEntry.options.jsc.experimental || {};
-                            // ensure plugins run before other transforms (important for Relay plugin)
-                            useEntry.options.jsc.experimental.runPluginFirst = true;
-                            // existing plugins may be present under jsc.experimental.plugins; merge them with provided ones
-                            const existingPlugins = Array.isArray(useEntry.options.jsc.experimental.plugins) ? useEntry.options.jsc.experimental.plugins : [];
-                            const incomingPlugins = Array.isArray(opts.swcPlugins) ? opts.swcPlugins : [];
-                            // simple dedupe by plugin name (first element of tuple) to avoid duplicates
-                            const seen = new Set<string>();
-                            const merged: any[] = [];
-                            for (const p of existingPlugins.concat(incomingPlugins)) {
-                                // plugin can be [name, options] or string; normalize
-                                const name = Array.isArray(p) && p.length > 0 ? String(p[0]) : String(p);
-                                if (!seen.has(name)) {
-                                    seen.add(name);
-                                    merged.push(p);
-                                }
-                            }
-                            useEntry.options.jsc.experimental.plugins = merged;
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // If postcssPlugins are provided, swap the default lightningcss-loader CSS rule
-    // for postcss-loader with the given plugins.
-    if (opts.postcssPlugins && opts.postcssPlugins.length > 0) {
-        const rules: any[] = localConfig.module?.rules ?? [];
-        for (const rule of rules) {
-            if (rule?.test instanceof RegExp && rule.test.source === '\\.css$') {
-                rule.use = [{
-                    loader: 'postcss-loader',
-                    options: { postcssOptions: { plugins: opts.postcssPlugins } },
-                }];
-                break;
-            }
-        }
-    }
-
-    if (opts.moduleRules && opts.moduleRules.length > 0) {
-        localConfig.module.rules.push(...opts.moduleRules);
-    }
-
-    // slim-react: the SSR-only React-compatible renderer bundled with hadars.
-    // On server builds we replace the real React with slim-react so that hooks
-    // get safe SSR stubs, context works, and renderToStream / Suspense are
-    // natively supported.  The client build is untouched and uses real React.
-    const slimReactIndex = pathMod.resolve(packageDir, 'slim-react', 'index.js');
-    const slimReactJsx   = pathMod.resolve(packageDir, 'slim-react', 'jsx-runtime.js');
-
-    const resolveAliases: Record<string, string> | undefined = isServerBuild ? {
-        // Route all React imports to slim-react for SSR.
-        react:                slimReactIndex,
-        'react/jsx-runtime':  slimReactJsx,
-        'react/jsx-dev-runtime': slimReactJsx,
-        // @emotion/* is bundled (not external) so that its `react` imports are
-        // resolved through the alias above to slim-react. If left external,
-        // emotion loads real React from node_modules and calls
-        // ReactSharedInternals.H.useContext which requires React's dispatcher.
-    } : undefined;
-
-    const externals = isServerBuild ? [
-        // Node.js built-ins — must not be bundled; resolved by the runtime.
-        'node:fs', 'node:path', 'node:os', 'node:stream', 'node:util',
-        // @emotion/server is only used outside component rendering (CSS extraction)
-        // and does not call React hooks, so it is safe to leave as external.
-        '@emotion/server',
-    ] : undefined;
-
-    // reactMode lets the caller force React's dev/prod runtime independently of
-    // the webpack build mode. Only applies to the client bundle (SSR uses slim-react).
-    // 'development' → process.env.NODE_ENV = "development" + JSX dev transform.
-    const effectiveReactDev = isServerBuild
-        ? false  // slim-react doesn't use NODE_ENV
-        : opts.reactMode === 'development' ? true
-        : opts.reactMode === 'production'  ? false
-        : isDev;                           // default: follow build mode
-
-    if (!isServerBuild && opts.reactMode !== undefined) {
-        // Override the SWC JSX development flag for all js/ts rules already built
-        const rules = localConfig.module?.rules ?? [];
-        for (const rule of rules) {
-            if (!rule?.use || !Array.isArray(rule.use)) continue;
-            for (const entry of rule.use) {
-                if (entry?.loader?.includes('swc-loader')) {
-                    entry.options = entry.options ?? {};
-                    entry.options.jsc = entry.options.jsc ?? {};
-                    entry.options.jsc.transform = entry.options.jsc.transform ?? {};
-                    entry.options.jsc.transform.react = entry.options.jsc.transform.react ?? {};
-                    entry.options.jsc.transform.react.development = effectiveReactDev;
-                    entry.options.jsc.transform.react.refresh = effectiveReactDev && isDev;
-                }
-            }
-        }
-    }
-
-    const extraPlugins: any[] = [];
-
-    const defineValues: Record<string, string> = { ...(opts.define ?? {}) };
-    // When reactMode overrides the React runtime we must also set process.env.NODE_ENV
-    // so React picks its dev/prod bundle, independently of the rspack build mode.
-    if (!isServerBuild && opts.reactMode !== undefined) {
-        defineValues['process.env.NODE_ENV'] = JSON.stringify(opts.reactMode);
-    }
-    if (Object.keys(defineValues).length > 0) {
-        const DefinePlugin = (rspack as any).DefinePlugin || (rspack as any).plugins?.DefinePlugin;
-        if (DefinePlugin) {
-            extraPlugins.push(new DefinePlugin(defineValues));
-        }
-    }
-
-    const resolveConfig: any = {
-        extensions: ['.tsx', '.ts', '.js', '.jsx'],
-        alias: resolveAliases,
-        // for server builds prefer the package "main"/"module" fields and avoid "browser" so we don't pick browser-specific entrypoints
-        mainFields: isServerBuild ? ['main', 'module'] : ['browser', 'module', 'main'],
-        // for server builds exclude the "browser" condition so packages with package.json
-        // "exports" conditions (e.g. @emotion/*) resolve their Node/CJS entry, not the browser build
-        ...(isServerBuild ? { conditionNames: ['node', 'require', 'default'] } : {}),
-    };
-
-    // Production client builds get vendor splitting and deterministic module IDs.
-    // User-supplied optimization is merged on top so it can extend or override defaults.
-    // Dev and SSR builds skip this — splitChunks slows HMR, SSR uses externals instead.
-    const optimization: any = (!isServerBuild && !isDev) ? {
-        moduleIds: 'deterministic',
-        splitChunks: {
-            chunks: 'all',
-            cacheGroups: {
-                react: {
-                    test: /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/,
-                    name: 'vendor-react',
-                    chunks: 'all' as const,
-                    priority: 20,
-                },
-            },
-        },
-        ...(opts.optimization ?? {}),
-    } : (opts.optimization ? { ...opts.optimization } : undefined);
-
-    return {
-        entry,
-        output: {
-            ...opts.output,
-            clean: false,
-        },
-        mode: opts.mode,
-        // Persist transformed modules to disk — subsequent starts only recompile
-        // changed files, making repeat dev starts significantly faster.
-        cache: true,
-        externals,
-        // externalsPresets.node externalises ALL Node.js built-ins (bare names
-        // and the node: prefix) for both static and dynamic imports.  This
-        // complements the explicit `externals` array: the preset handles the
-        // node: URI scheme that rspack cannot resolve as a file, while the
-        // array keeps '@emotion/server' as an explicit external.
-        ...(isServerBuild ? { externalsPresets: { node: true } } : {}),
-        ...(optimization !== undefined ? { optimization } : {}),
-        plugins: [
-            !isServerBuild && new rspack.HtmlRspackPlugin({
-                publicPath: base || '/',
-                template: opts.htmlTemplate
-                    ? pathMod.resolve(process.cwd(), opts.htmlTemplate)
-                    : clientScriptPath,
-                scriptLoading: 'module',
-                filename: 'out.html',
-                inject: 'head',
-                minify: opts.mode === 'production',
-            }),
-            !isServerBuild && {
-                apply(compiler: any) {
-                    compiler.hooks.emit.tapAsync('HadarsAsyncModuleScript', (compilation: any, cb: () => void) => {
-                        const asset = compilation.assets['out.html'];
-                        if (asset) {
-                            const html: string = asset.source();
-                            const updated = html.replace(
-                                /(<script\b[^>]*\btype="module"[^>]*)(>)/g,
-                                (match, before: string, end: string) =>
-                                    before.includes('async') ? match : `${before} async${end}`,
-                            );
-                            compilation.assets['out.html'] = {
-                                source: () => updated,
-                                size:   () => Buffer.byteLength(updated),
-                            };
-                        }
-                        cb();
-                    });
-                },
-            },
-            isDev && !isServerBuild && new ReactRefreshPlugin(),
-            includeHotPlugin && isDev && !isServerBuild && new rspack.HotModuleReplacementPlugin(),
-            ...extraPlugins,
-            ...(opts.plugins ?? []),
-        ],
-        ...localConfig,
-        // Merge base resolve (modules, tsConfig, extensions) with per-build resolve
-        // (alias, mainFields). The spread order matters: resolveConfig wins for keys
-        // it defines, localConfig.resolve wins for keys it defines exclusively.
-        resolve: {
-            ...localConfig.resolve,
-            ...resolveConfig,
-        },
-        // HMR is not implemented for module chunk format, so disable outputModule
-        // for client builds. SSR builds still need it for dynamic import() of exports.
-        experiments: {
-            ...(localConfig.experiments || {}),
-            outputModule: isServerBuild,
-        },
-        // Prevent rspack from watching its own build output — without this the
-        // SSR watcher writing .hadars/index.ssr.js triggers the client compiler
-        // and vice versa, causing an infinite rebuild loop.
-        watchOptions: {
-            ignored: ['**/node_modules/**', '**/.hadars/**', '/tmp/**'],
-        },
-    };
-};
-
-/**
- * Creates a configured rspack compiler for the client bundle without running it.
- * Intended for use with RspackDevServer for proper HMR support.
- * HotModuleReplacementPlugin is intentionally omitted — RspackDevServer adds it automatically.
- */
-export const createClientCompiler = (entry: string, opts: EntryOptions) => {
-    return rspack(buildCompilerConfig(entry, opts, false));
-};
-
-export const compileEntry = async (entry: string, opts: EntryOptions & { watch?: boolean, onChange?: (stats:any)=>void }) => {
-    const compiler = rspack(buildCompilerConfig(entry, opts, true));
-
-    // If watch mode is requested, start watching and invoke onChange for each rebuild.
-    // The returned promise resolves once the first build completes so callers can
-    // await initial build completion before starting their own server.
-    if (opts.watch) {
-        await new Promise((resolve, reject) => {
-            let first = true;
-            // Pass ignored patterns directly — compiler.watch(watchOptions) replaces
-            // the config-level watchOptions, so we must repeat them here.
-            compiler.watch({ ignored: ['**/node_modules/**', '**/.hadars/**', '/tmp/**'] }, (err: any, stats: any) => {
-                if (err) {
-                    if (first) { first = false; reject(err); }
-                    else { console.error('rspack watch error', err); }
-                    return;
-                }
-
-                console.log(stats?.toString({ colors: true }));
-
-                if (first) {
-                    first = false;
-                    resolve(stats);
-                } else {
-                    try {
-                        opts.onChange && opts.onChange(stats);
-                    } catch (e) {
-                        console.error('onChange handler error', e);
-                    }
-                }
-            });
-        });
-        return;
-    }
-
-    // non-watch: do a single run and resolve when complete
-    await new Promise((resolve, reject) => {
-        compiler.run((err: any, stats: any) => {
-            if (err) {
-                reject(err);
-                return;
-            }
-
-            console.log(stats?.toString({
-                colors: true,
-                preset: 'minimal',
-            }));
-
-            resolve(stats);
-        });
-    });
-}

package/src/utils/runtime.ts

@@ -1,19 +0,0 @@
-/** True when running inside Bun. */
-export const isBun = typeof (globalThis as any).Bun !== 'undefined';
-
-/** True when running inside Deno. */
-export const isDeno = typeof (globalThis as any).Deno !== 'undefined';
-
-/** True when running inside Node.js (not Bun, not Deno). */
-export const isNode = !isBun && !isDeno;
-
-/** Returns a human-readable runtime identifier. */
-export const getRuntimeName = (): 'bun' | 'deno' | 'node' =>
-    isBun ? 'bun' : isDeno ? 'deno' : 'node';
-
-/** Returns a version string for the current runtime, e.g. "Bun 1.1.0". */
-export const getRuntimeVersion = (): string => {
-    if (isBun) return `Bun ${(globalThis as any).Bun.version}`;
-    if (isDeno) return `Deno ${(globalThis as any).Deno.version.deno}`;
-    return `Node.js ${process.version}`;
-};

package/src/utils/serve.ts

@@ -1,155 +0,0 @@
-import { isBun, isDeno } from './runtime';
-
-/**
- * Minimal server context passed to every fetch handler invocation.
- * On Bun, `upgrade` performs a real WebSocket upgrade.
- * On all other runtimes it is a no-op that always returns false.
- */
-export interface ServerContext {
-    upgrade(req: Request): boolean;
-}
-
-type FetchHandler = (
-    req: Request,
-    ctx: ServerContext,
-) => Promise<Response | undefined> | Response | undefined;
-
-/** Converts a Node.js Readable stream to a Web ReadableStream<Uint8Array>. */
-function nodeReadableToWebStream(readable: NodeJS.ReadableStream): ReadableStream<Uint8Array> {
-    const enc = new TextEncoder();
-    return new ReadableStream<Uint8Array>({
-        start(controller) {
-            readable.on('data', (chunk: Buffer | string) => {
-                controller.enqueue(
-                    typeof chunk === 'string'
-                        ? enc.encode(chunk)
-                        : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength),
-                );
-            });
-            readable.on('end', () => controller.close());
-            readable.on('error', (err) => controller.error(err));
-        },
-        cancel() {
-            (readable as any).destroy?.();
-        },
-    });
-}
-
-const noopCtx: ServerContext = { upgrade: () => false };
-
-/**
- * Starts an HTTP server on the given port using the best available runtime API:
- * - **Bun**:    `Bun.serve()` — full WebSocket support via the `websocket` option
- * - **Deno**:   `Deno.serve()`
- * - **Node.js**: `node:http` `createServer()` with a Web-Fetch bridge
- *
- * The `fetchHandler` may return `undefined` to signal that the response was
- * handled out-of-band (e.g. a Bun WebSocket upgrade).
- */
-function withRequestLogging(handler: FetchHandler): FetchHandler {
-    return async (req, ctx) => {
-        const start = performance.now();
-        const res = await handler(req, ctx);
-        const ms = Math.round(performance.now() - start);
-        const status = res?.status ?? 404;
-        const path = new URL(req.url).pathname;
-        console.log(`[hadars] ${req.method} ${path} ${status} ${ms}ms`);
-        return res;
-    };
-}
-
-
-export async function serve(
-    port: number,
-    fetchHandler: FetchHandler,
-    /** Bun WebSocketHandler — ignored on Deno and Node.js. */
-    websocket?: unknown,
-): Promise<void> {
-    fetchHandler = withRequestLogging(fetchHandler);
-
-    // ── Bun ────────────────────────────────────────────────────────────────
-    if (isBun) {
-        (globalThis as any).Bun.serve({
-            port,
-            websocket,
-            async fetch(req: Request, server: any) {
-                const ctx: ServerContext = { upgrade: (r) => server.upgrade(r) };
-                // Returning undefined from a Bun fetch handler means the
-                // request was handled as a WebSocket upgrade.
-                return (await fetchHandler(req, ctx)) ?? undefined;
-            },
-        });
-        return;
-    }
-
-    // ── Deno ───────────────────────────────────────────────────────────────
-    // Deno 2.x changed the signature to options-first. Use the single-object
-    // form { port, handler } which is stable across Deno 1.x and 2.x.
-    if (isDeno) {
-        (globalThis as any).Deno.serve({
-            port,
-            handler: async (req: Request) => {
-                const res = await fetchHandler(req, noopCtx);
-                return res ?? new Response('Not Found', { status: 404 });
-            },
-        });
-        return;
-    }
-
-    // ── Node.js ────────────────────────────────────────────────────────────
-    const { createServer } = await import('node:http');
-
-    const server = createServer(async (nodeReq, nodeRes) => {
-        try {
-            // Collect body for non-GET/HEAD requests
-            const chunks: Buffer[] = [];
-            if (!['GET', 'HEAD'].includes(nodeReq.method ?? 'GET')) {
-                for await (const chunk of nodeReq) {
-                    chunks.push(chunk as Buffer);
-                }
-            }
-            const body = chunks.length > 0 ? Buffer.concat(chunks) : undefined;
-
-            const url = `http://localhost:${port}${nodeReq.url ?? '/'}`;
-            const reqInit: RequestInit & { duplex?: string } = {
-                method: nodeReq.method ?? 'GET',
-                headers: new Headers(nodeReq.headers as Record<string, string>),
-            };
-            if (body) {
-                reqInit.body = body;
-                reqInit.duplex = 'half';
-            }
-            const req = new Request(url, reqInit);
-
-            const res = await fetchHandler(req, noopCtx);
-            const response = res ?? new Response('Not Found', { status: 404 });
-
-            const headers: Record<string, string> = {};
-            response.headers.forEach((v, k) => { headers[k] = v; });
-            nodeRes.writeHead(response.status, headers);
-
-            if (response.body) {
-                const reader = response.body.getReader();
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) break;
-                    await new Promise<void>((resolve, reject) =>
-                        nodeRes.write(value, (err) => (err ? reject(err) : resolve())),
-                    );
-                }
-            }
-        } catch (err) {
-            console.error('[hadars] request error', err);
-            if (!nodeRes.headersSent) nodeRes.writeHead(500);
-        } finally {
-            nodeRes.end();
-        }
-    });
-
-    await new Promise<void>((resolve, reject) => {
-        server.listen(port, () => resolve());
-        server.once('error', reject);
-    });
-}
-
-export { nodeReadableToWebStream };