@kodycodes/cli 1.23.1 → 1.24.0

package/dist/package-app-dev.js

@@ -1,18 +1,31 @@
 /**
  * Long-running `kody dev` app server: bundles `kody.app.entry` the same way
- * local-bundle/publish does for esbuild, serves via workerd, strips the mount
- * at the Node proxy, and rebuilds on file changes.
+ * local-bundle/publish does for esbuild, serves via workerd behind a Node
+ * proxy that strips the mount, and rebuilds on file changes.
+ *
+ * Each successful rebuild starts a new workerd "generation" and only swaps the
+ * proxy over once it is listening; the previous generation drains in-flight
+ * requests and is then stopped. Requests that arrive mid-rebuild wait for it,
+ * so a save is never answered by a 503 or a stale bundle.
  */
-import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
-import { watch } from 'node:fs';
+import { rmSync } from 'node:fs';
 import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { createServer, request as httpRequest, } from 'node:http';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 import { assertTokenSafeApiUrl, callCapabilityProxy, } from './capability-proxy.js';
 import { apiTokenEnvVar } from './defaults.js';
-import { bundleLocalUserModule } from './local-bundle.js';
+import { createDevBundler } from './dev/dev-bundler.js';
+import { parseWorkerdStdoutLine } from './dev/dev-events.js';
+import { devErrorHeader, devRequestIdHeader } from './dev/dev-protocol.js';
+import { createDevWatcher } from './dev/dev-watcher.js';
+import { sendDevError } from './dev/error-page.js';
+import { createLiveReloadHub, injectLiveReloadScript, liveReloadClientPath, liveReloadClientSource, liveReloadEventsPath, liveReloadScriptTag, shouldInjectLiveReload, } from './dev/live-reload.js';
+import { devWorkDirPrefix, startProcessReaper, sweepStaleDevDirs, } from './dev/process-reaper.js';
+import { createStackMapper } from './dev/stack-trace.js';
+import { cleanWorkerdStderrLine, startWorkerd, } from './dev/workerd-process.js';
+import { BundleError, formatBundleDiagnostic } from './local-bundle.js';
 import { localExecuteGatewayFetchShimModuleName, resolveLocalPackageGraph, writePackageModuleFiles, } from './local-package-graph.js';
 import { createRuntimeFlatAliasSource, createWorkerdConfig, localWorkerModuleNames, } from './local-runtime-source.js';
 import { buildLocalPackageContext } from './local-package-run.js';
@@ -22,7 +35,11 @@ import { createPackageAppEntrySource, createPackageLocalRuntimeModuleSource, run
 import { resolvePackagePath } from './package-manifest.js';
 import { redact } from './redact.js';
 import { ensureWorkerdBinary } from './workerd-binary.js';
-const workerdStartTimeoutMs = 30_000;
+const defaultDebounceMs = 120;
+/** Longest a request waits for an in-progress rebuild before the old build answers. */
+const rebuildGateMs = 10_000;
+/** Longest a retired generation may keep draining in-flight requests. */
+const drainTimeoutMs = 10_000;
 export async function startPackageAppDev(options) {
     if (!options.manifest.app?.entry) {
         throw new Error('This package has no kody.app.entry. Add `"kody": { "app": { "entry": "./app/router.ts" } }` or use `kody dev job|webhook|emit|check`.');
@@ -30,8 +47,16 @@ export async function startPackageAppDev(options) {
     assertTokenSafeApiUrl(options.apiUrl);
     const host = options.host ?? '127.0.0.1';
     const appBasePath = normalizeBasePath(options.appBasePath ?? '');
+    const root = options.manifest.root;
     const runSecret = randomBytes(32).toString('hex');
-    const workDir = await mkdtemp(join(tmpdir(), 'kody-dev-'));
+    const emit = (event) => options.onEvent?.(event);
+    const liveReload = options.liveReload ?? options.watch !== false;
+    const errorPageTail = liveReload
+        ? `<script>globalThis.__kodyDevErrorPage = true</script>${liveReloadScriptTag}`
+        : '';
+    void sweepStaleDevDirs().catch(() => { });
+    const workDir = await mkdtemp(join(tmpdir(), devWorkDirPrefix));
+    const reaper = await startProcessReaper({ workDir });
     const workerdPath = options.workerdPath ??
         (await ensureWorkerdBinary({
             onDownload: (url) => options.onStatus?.(`Downloading workerd from ${url}…`),
@@ -42,15 +67,40 @@ export async function startPackageAppDev(options) {
         fetchFn: options.fetchFn,
         ...(options.org ? { org: options.org } : {}),
     };
-    let bridge;
-    let child;
-    let workerdPort;
-    let reloadTimer;
+    const generations = new Set();
+    let active;
+    let buildFailure = null;
+    let generationCounter = 0;
+    let requestCounter = 0;
     let closed = false;
-    /** Last workerd stderr chunk(s) — surfaced when the app returns HTTP 5xx. */
-    let lastWorkerdStderr = '';
+    let buildLoop = null;
+    let rebuildAgain = false;
+    const changedFiles = new Set();
+    const liveReloadHub = createLiveReloadHub({
+        state: () => ({
+            buildId: active?.id ?? null,
+            error: buildFailure ? buildErrorView(buildFailure) : null,
+        }),
+    });
+    let markStarted = () => { };
+    const started = new Promise((resolve) => {
+        markStarted = resolve;
+    });
+    const killAllSync = () => {
+        for (const generation of generations) {
+            try {
+                process.kill(generation.workerd.pid, 'SIGKILL');
+            }
+            catch { }
+        }
+        try {
+            rmSync(workDir, { recursive: true, force: true });
+        }
+        catch { }
+    };
+    process.once('exit', killAllSync);
     const proxy = createServer((req, res) => {
-        void proxyRequest(req, res);
+        void handleRequest(req, res);
     });
     await new Promise((resolve, reject) => {
         proxy.once('error', reject);
@@ -66,12 +116,12 @@ export async function startPackageAppDev(options) {
     });
     const mockFetchGateway = await resolveMockFetchGateway({
         target: options.target,
-        packageRoot: options.manifest.root,
+        packageRoot: root,
         passthroughHosts: options.passthroughHosts,
         allowPrivateNetwork: options.allowPrivateNetwork,
         onStatus: options.onStatus,
     });
-    bridge = await startBridge({
+    const bridge = await startBridge({
         runSecret,
         forward: async (call, signal) => {
             const mocked = tryHandleMockGatewayFetchCall({
@@ -90,14 +140,80 @@ export async function startPackageAppDev(options) {
         },
     });
     const entryPath = resolvePackagePath(options.manifest, options.manifest.app.entry);
-    async function rebuildAndServe() {
-        options.onStatus?.(`Bundling ${entryPath}…`);
-        const code = await bundleLocalUserModule(entryPath);
+    const bundler = createDevBundler({ entryPath, root });
+    const workerdEnv = { ...process.env, [runSecretEnvVar]: runSecret };
+    delete workerdEnv[apiTokenEnvVar];
+    function requestBuild(paths) {
+        for (const path of paths)
+            changedFiles.add(path);
+        if (buildLoop) {
+            rebuildAgain = true;
+            return buildLoop;
+        }
+        buildLoop = (async () => {
+            do {
+                rebuildAgain = false;
+                const files = [...changedFiles];
+                changedFiles.clear();
+                await buildOnce(files);
+            } while (rebuildAgain && !closed);
+        })().finally(() => {
+            buildLoop = null;
+        });
+        return buildLoop;
+    }
+    async function buildOnce(files) {
+        const started = performance.now();
+        emit({ type: 'rebuild_start', files: files.map((file) => relative(root, file) || file) });
+        let bundle;
+        try {
+            bundle = await bundler.build();
+            watcher?.track([...bundle.inputs, options.manifest.packageJsonPath]);
+            if (active && !buildFailure && bundle.code === active.code) {
+                emit({
+                    type: 'rebuild_ok',
+                    ms: elapsed(started),
+                    buildId: active.id,
+                    restarted: false,
+                });
+                return;
+            }
+            const generation = await startGeneration(bundle);
+            if (closed) {
+                await stopGeneration(generation);
+                return;
+            }
+            const previous = active;
+            active = generation;
+            buildFailure = null;
+            if (previous)
+                retireGeneration(previous);
+            emit({ type: 'rebuild_ok', ms: elapsed(started), buildId: generation.id, restarted: true });
+            liveReloadHub.broadcast({ event: 'reload', data: { buildId: generation.id } });
+        }
+        catch (error) {
+            buildFailure = toBuildFailure(error);
+            const [first] = buildFailure.diagnostics;
+            emit({
+                type: 'build_error',
+                ms: elapsed(started),
+                message: buildFailure.message,
+                file: first?.file ?? null,
+                line: first?.line ?? null,
+                col: first?.col ?? null,
+                diagnostics: buildFailure.diagnostics,
+            });
+            liveReloadHub.broadcast({ event: 'build_error', data: buildErrorView(buildFailure) });
+        }
+    }
+    async function startGeneration(bundle) {
+        const id = ++generationCounter;
+        const dir = join(workDir, `g${id}`);
         await writeWorkerFiles({
-            workDir,
-            code,
+            workDir: dir,
+            code: bundle.code,
             packageContext,
-            packageRoot: options.manifest.root,
+            packageRoot: root,
             mockStorage: options.target === 'mock',
             bridgePort: bridge.port,
             allowPrivateNetwork: options.allowPrivateNetwork,
@@ -109,112 +225,299 @@ export async function startPackageAppDev(options) {
             mockFetchGateway,
             onStatus: options.onStatus,
         });
-        await restartWorkerd();
-    }
-    async function restartWorkerd() {
-        if (child) {
-            child.kill('SIGKILL');
-            child = undefined;
-            workerdPort = undefined;
+        let trackedPid;
+        let workerd;
+        try {
+            workerd = await startWorkerd({
+                workerdPath,
+                configPath: join(dir, 'config.capnp'),
+                cwd: dir,
+                env: workerdEnv,
+                onSpawn: (pid) => {
+                    trackedPid = pid;
+                    reaper.track(pid);
+                },
+                onStdoutLine: (line) => emit(parseWorkerdStdoutLine(line)),
+                onStderrLine: (line) => {
+                    const cleaned = cleanWorkerdStderrLine(line);
+                    if (cleaned === null)
+                        return;
+                    emit({
+                        type: 'log',
+                        source: 'workerd',
+                        level: 'error',
+                        message: redact(cleaned),
+                        request: null,
+                    });
+                },
+            });
         }
-        const env = { ...process.env, [runSecretEnvVar]: runSecret };
-        delete env[apiTokenEnvVar];
-        const configPath = join(workDir, 'config.capnp');
-        lastWorkerdStderr = '';
-        child = spawn(workerdPath, ['serve', configPath, '--control-fd=3'], {
-            cwd: workDir,
-            env,
-            stdio: ['ignore', 'pipe', 'pipe', 'pipe'],
-        });
-        child.stderr?.on('data', (chunk) => {
-            lastWorkerdStderr += chunk.toString('utf8');
-            if (lastWorkerdStderr.length > 32_000) {
-                lastWorkerdStderr = lastWorkerdStderr.slice(-24_000);
-            }
+        catch (error) {
+            // onSpawn tracks before listen; a failed start never reaches the
+            // exited/untrack path, so drop the pid here before pid reuse.
+            if (trackedPid !== undefined)
+                reaper.untrack(trackedPid);
+            await rm(dir, { recursive: true, force: true }).catch(() => { });
+            throw error;
+        }
+        const generation = {
+            id,
+            dir,
+            workerd,
+            code: bundle.code,
+            mapStack: createStackMapper({
+                sourceMap: bundle.sourceMap,
+                userModule: localWorkerModuleNames.user,
+            }),
+            inflight: 0,
+            retired: false,
+            stopped: false,
+        };
+        generations.add(generation);
+        void workerd.exited.then((detail) => {
+            reaper.untrack(workerd.pid);
+            if (closed || generation.retired || active !== generation)
+                return;
+            active = undefined;
+            buildFailure = {
+                message: `workerd stopped unexpectedly (${detail}). Save a file to restart it.`,
+                diagnostics: [],
+            };
+            options.onError?.(buildFailure.message);
         });
-        const workerd = watchWorkerd(child);
-        const started = await workerd.listening;
-        if ('exitDetail' in started) {
-            throw new Error(`workerd failed to start${started.exitDetail}`);
+        return generation;
+    }
+    function retireGeneration(generation) {
+        generation.retired = true;
+        if (generation.inflight === 0) {
+            void stopGeneration(generation);
+            return;
         }
-        workerdPort = started.port;
-        options.onStatus?.(`App ready at ${hostedUrl}${appBasePath || '/'}`);
+        setTimeout(() => void stopGeneration(generation), drainTimeoutMs).unref();
+    }
+    async function stopGeneration(generation) {
+        if (generation.stopped)
+            return;
+        generation.stopped = true;
+        generation.retired = true;
+        await generation.workerd.kill();
+        reaper.untrack(generation.workerd.pid);
+        generations.delete(generation);
+        await rm(generation.dir, { recursive: true, force: true });
     }
-    async function proxyRequest(req, res) {
+    async function waitForBuild() {
+        const pending = buildLoop ?? (active || buildFailure ? null : started);
+        if (!pending)
+            return;
+        await Promise.race([
+            pending.catch(() => { }),
+            new Promise((resolve) => setTimeout(resolve, rebuildGateMs).unref()),
+        ]);
+    }
+    function handleDevRoute(req, res) {
+        const pathname = stripMount(new URL(req.url ?? '/', hostedUrl).pathname, appBasePath);
+        if (!liveReload)
+            return false;
+        if (pathname === liveReloadEventsPath) {
+            liveReloadHub.handleEvents(req, res);
+            return true;
+        }
+        if (pathname === liveReloadClientPath) {
+            res.writeHead(200, {
+                'content-type': 'text/javascript; charset=utf-8',
+                'cache-control': 'no-store',
+            });
+            res.end(liveReloadClientSource);
+            return true;
+        }
+        return false;
+    }
+    async function handleRequest(req, res) {
         try {
-            if (!workerdPort) {
-                res.writeHead(503, { 'content-type': 'text/plain' });
-                res.end('Dev server is still starting.');
+            if (handleDevRoute(req, res))
+                return;
+            await waitForBuild();
+            if (buildFailure) {
+                sendDevError(req, res, 500, buildErrorView(buildFailure), {
+                    htmlTail: errorPageTail,
+                });
                 return;
             }
-            const incomingUrl = new URL(req.url ?? '/', hostedUrl);
-            const restPath = stripMount(incomingUrl.pathname, appBasePath);
-            const forwardUrl = new URL(restPath + incomingUrl.search, `http://127.0.0.1:${workerdPort}`);
-            const chunks = [];
-            for await (const chunk of req) {
-                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            const generation = active;
+            if (!generation) {
+                res.writeHead(503, { 'content-type': 'text/plain; charset=utf-8' });
+                res.end(closed ? 'kody dev is shutting down.\n' : 'kody dev is still starting.\n');
+                return;
+            }
+            generation.inflight += 1;
+            try {
+                await forwardRequest(generation, req, res);
+            }
+            finally {
+                generation.inflight -= 1;
+                if (generation.retired && generation.inflight === 0) {
+                    void stopGeneration(generation);
+                }
             }
-            const body = Buffer.concat(chunks);
-            const headers = {
-                ...req.headers,
-                host: `127.0.0.1:${workerdPort}`,
-                [runSecretHeader]: runSecret,
-            };
-            delete headers['content-length'];
-            await new Promise((resolve, reject) => {
-                const upstream = httpRequest(forwardUrl, { method: req.method, headers }, (upstreamRes) => {
-                    const status = upstreamRes.statusCode ?? 502;
-                    const chunks = [];
-                    upstreamRes.on('data', (chunk) => {
-                        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                    });
-                    upstreamRes.on('end', () => {
-                        const responseBody = Buffer.concat(chunks);
-                        if (status >= 500) {
-                            const preview = redact(responseBody.toString('utf8').slice(0, 2000));
-                            const workerdLogs = redact(lastWorkerdStderr.trim());
-                            options.onError?.(`App handler HTTP ${status}${workerdLogs ? `\nworkerd stderr:\n${workerdLogs}` : ''}${preview ? `\nbody:\n${preview}` : ''}`);
-                        }
-                        if (!res.headersSent) {
-                            res.writeHead(status, upstreamRes.headers);
-                        }
-                        res.end(responseBody);
-                        resolve();
-                    });
-                    upstreamRes.on('error', reject);
-                });
-                upstream.on('error', reject);
-                if (body.length > 0)
-                    upstream.write(body);
-                upstream.end();
-            });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            const workerdLogs = redact(lastWorkerdStderr.trim());
-            options.onError?.(workerdLogs ? `${message}\nworkerd stderr:\n${workerdLogs}` : message);
+            options.onError?.(`Dev proxy error: ${message}`);
             if (!res.headersSent) {
-                res.writeHead(502, { 'content-type': 'text/plain' });
-                res.end(`Dev proxy error: ${message}`);
+                res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' });
+                res.end(`Dev proxy error: ${message}\n`);
             }
+            else if (!res.writableEnded) {
+                res.destroy();
+            }
+        }
+    }
+    function forwardRequest(generation, req, res) {
+        const incomingUrl = new URL(req.url ?? '/', hostedUrl);
+        const restPath = stripMount(incomingUrl.pathname, appBasePath);
+        const forwardUrl = new URL(restPath + incomingUrl.search, `http://127.0.0.1:${generation.workerd.port}`);
+        const tag = {
+            id: String(++requestCounter),
+            method: req.method ?? 'GET',
+            path: restPath + incomingUrl.search,
+        };
+        const headers = {
+            ...req.headers,
+            host: `127.0.0.1:${generation.workerd.port}`,
+            [runSecretHeader]: runSecret,
+            [devRequestIdHeader]: tag.id,
+        };
+        return new Promise((resolve, reject) => {
+            const upstream = httpRequest(forwardUrl, { method: req.method, headers }, (upstreamRes) => {
+                if (upstreamRes.headers[devErrorHeader]) {
+                    void readStream(upstreamRes)
+                        .then((raw) => {
+                        respondWithRuntimeError(generation, req, res, tag, raw);
+                        resolve();
+                    })
+                        .catch(reject);
+                    return;
+                }
+                const status = upstreamRes.statusCode ?? 502;
+                if (status >= 500) {
+                    emit({
+                        type: 'log',
+                        source: 'app',
+                        level: 'warn',
+                        message: `responded HTTP ${status}`,
+                        request: tag,
+                    });
+                }
+                if (liveReload &&
+                    shouldInjectLiveReload({
+                        method: req.method,
+                        status,
+                        headers: upstreamRes.headers,
+                    })) {
+                    void readStream(upstreamRes)
+                        .then((html) => {
+                        const body = Buffer.from(injectLiveReloadScript(html), 'utf8');
+                        const headers = { ...upstreamRes.headers };
+                        delete headers['transfer-encoding'];
+                        headers['content-length'] = String(body.length);
+                        res.writeHead(status, headers);
+                        res.end(body);
+                        resolve();
+                    })
+                        .catch(reject);
+                    return;
+                }
+                res.writeHead(status, upstreamRes.headers);
+                upstreamRes.pipe(res);
+                upstreamRes.on('end', () => resolve());
+                upstreamRes.on('error', reject);
+            });
+            upstream.on('error', reject);
+            res.on('close', () => {
+                if (!res.writableFinished)
+                    upstream.destroy();
+                resolve();
+            });
+            req.pipe(upstream);
+        });
+    }
+    function respondWithRuntimeError(generation, req, res, tag, raw) {
+        let message = 'Uncaught error';
+        let stack = '';
+        try {
+            const parsed = JSON.parse(raw);
+            message = `${parsed.name ?? 'Error'}: ${parsed.message ?? ''}`;
+            stack = parsed.stack ?? message;
+        }
+        catch {
+            stack = raw;
         }
+        const mapped = redact(generation.mapStack(stack));
+        emit({ type: 'runtime_error', message: redact(message), stack: mapped, request: tag });
+        const view = {
+            kind: 'runtime',
+            title: redact(message),
+            detail: mapped,
+            request: `${tag.method} ${tag.path}`,
+        };
+        liveReloadHub.broadcast({ event: 'runtime_error', data: view });
+        sendDevError(req, res, 500, view, { htmlTail: errorPageTail });
     }
-    await rebuildAndServe();
     const watcher = options.watch === false
         ? null
-        : watch(options.manifest.root, { recursive: true }, (_event, filename) => {
-            if (closed)
-                return;
-            if (filename && shouldIgnoreWatchPath(filename))
-                return;
-            clearTimeout(reloadTimer);
-            reloadTimer = setTimeout(() => {
-                void rebuildAndServe().catch((error) => {
-                    const message = error instanceof Error ? error.message : String(error);
-                    options.onError?.(message);
-                });
-            }, 120);
+        : (() => {
+            let timer;
+            const pending = new Set();
+            return createDevWatcher({
+                root,
+                onChange: (path) => {
+                    if (closed)
+                        return;
+                    pending.add(path);
+                    clearTimeout(timer);
+                    timer = setTimeout(() => {
+                        const paths = [...pending];
+                        pending.clear();
+                        void requestBuild(paths);
+                    }, options.debounceMs ?? defaultDebounceMs);
+                },
+            });
+        })();
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        process.off('exit', killAllSync);
+        await watcher?.close();
+        await buildLoop?.catch(() => { });
+        await bundler.dispose();
+        await Promise.all([...generations].map((generation) => stopGeneration(generation)));
+        reaper.close();
+        await bridge.close();
+        liveReloadHub.close();
+        proxy.closeAllConnections();
+        await new Promise((resolve) => {
+            proxy.close(() => resolve());
         });
+        await rm(workDir, { recursive: true, force: true });
+    };
+    try {
+        await Promise.all([requestBuild([]), watcher?.ready]);
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+    finally {
+        markStarted();
+    }
+    if (options.watch === false && buildFailure) {
+        const message = buildFailure.message;
+        await close();
+        throw new Error(message);
+    }
+    if (active)
+        options.onStatus?.(`App ready at ${hostedUrl}${appBasePath || '/'}`);
     const fetchPath = async (path, init = {}) => {
         const url = new URL(joinUrlPath(appBasePath, path), hostedUrl);
         const response = await fetch(url, {
@@ -236,28 +539,40 @@ export async function startPackageAppDev(options) {
         appBasePath,
         packageContext,
         fetchPath,
-        close: async () => {
-            closed = true;
-            clearTimeout(reloadTimer);
-            watcher?.close();
-            const stopping = child;
-            if (stopping) {
-                const exited = new Promise((resolve) => {
-                    stopping.once('exit', () => resolve());
-                    stopping.once('error', () => resolve());
-                });
-                stopping.kill('SIGKILL');
-                await Promise.race([exited, new Promise((r) => setTimeout(r, 1000))]);
-                child = undefined;
-            }
-            await bridge?.close();
-            await new Promise((resolve) => {
-                proxy.close(() => resolve());
-            });
-            await rm(workDir, { recursive: true, force: true });
-        },
+        close,
     };
 }
+function elapsed(started) {
+    return Math.round(performance.now() - started);
+}
+function toBuildFailure(error) {
+    if (error instanceof BundleError) {
+        return { message: error.message, diagnostics: error.diagnostics };
+    }
+    return {
+        message: redact(error instanceof Error ? error.message : String(error)),
+        diagnostics: [],
+    };
+}
+function buildErrorView(failure) {
+    const [first] = failure.diagnostics;
+    return {
+        kind: 'build',
+        title: first
+            ? `${first.file ?? 'bundle'}${first.line !== null ? `:${first.line}:${first.col}` : ''} ${first.message}`
+            : (failure.message.split('\n')[0] ?? 'Build failed'),
+        detail: failure.diagnostics.length > 0
+            ? failure.diagnostics.map(formatBundleDiagnostic).join('\n\n')
+            : failure.message,
+    };
+}
+async function readStream(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
 async function writeWorkerFiles(input) {
     await mkdir(input.workDir, { recursive: true });
     const packageGraph = await resolveLocalPackageGraph({
@@ -320,67 +635,6 @@ function joinUrlPath(base, path) {
         return rest;
     return `${base}${rest === '/' ? '' : rest}` || base;
 }
-function shouldIgnoreWatchPath(filename) {
-    return (filename.includes('node_modules') ||
-        filename.includes('.git') ||
-        filename.endsWith('.map') ||
-        filename.startsWith('.'));
-}
-function watchWorkerd(child) {
-    let stderrText = '';
-    child.stderr?.on('data', (chunk) => {
-        stderrText += chunk.toString('utf8');
-    });
-    child.stdout?.resume();
-    const stderr = () => {
-        const trimmed = redact(stderrText.trim());
-        return trimmed ? `\n${trimmed}` : '';
-    };
-    const exited = new Promise((resolve) => {
-        child.once('exit', (code, signal) => {
-            resolve(` (workerd exit ${signal ?? code})${stderr()}`);
-        });
-    });
-    const listening = new Promise((resolve, reject) => {
-        const control = child.stdio[3];
-        let buffered = '';
-        const timer = setTimeout(() => {
-            reject(new Error(`workerd did not start within ${workerdStartTimeoutMs / 1000}s.${stderr()}`));
-        }, workerdStartTimeoutMs);
-        control?.on('data', (chunk) => {
-            buffered += chunk.toString('utf8');
-            for (const line of buffered.split('\n')) {
-                const port = parseListenPort(line);
-                if (port !== null) {
-                    clearTimeout(timer);
-                    resolve({ port });
-                }
-            }
-        });
-        child.once('error', (error) => {
-            clearTimeout(timer);
-            reject(new Error(`Could not start workerd: ${error.message}`));
-        });
-        void exited.then((exitDetail) => {
-            clearTimeout(timer);
-            resolve({ exitDetail });
-        });
-    });
-    return { listening, exited, stderr };
-}
-function parseListenPort(line) {
-    if (!line.trim())
-        return null;
-    try {
-        const event = JSON.parse(line);
-        return event.event === 'listen' && event.socket === 'http' && typeof event.port === 'number'
-            ? event.port
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
 async function startBridge(input) {
     const inFlight = new AbortController();
     const server = createServer(async (request, response) => {