neon 3.0.0 → 3.1.0

package/dist/dev/functions.js

@@ -1,77 +1,63 @@
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
-import { loadConfigFromFile, resolveConfig, } from "@neon/config";
+import { loadConfigFromFile, resolveConfig } from "@neon/config";
+//#region src/dev/functions.ts
 /**
- * Load `neon.ts` (if any) and resolve the list of functions it declares into
- * {@link PlannedFunction}s for `neon dev` to serve. Returns `null` when there is no
- * `neon.ts` on the path from `cwd` up to the repo root — the caller turns that into a
- * "no --source and no neon.ts" error.
- *
- * `branchName` is used only to evaluate a policy that switches on `branch.name`; the
- * function list is otherwise branch-independent, so a placeholder is fine when unknown.
- */
-export const resolveFunctionsFromConfig = async (cwd, branchName) => {
-    const loaded = await loadNeonConfig(cwd);
-    if (!loaded)
-        return null;
-    const { config, configDir, configPath } = loaded;
-    const resolved = resolveConfig(config, {
-        name: branchName ?? "local",
-        exists: branchName !== undefined,
-    });
-    const functions = resolved.preview?.functions ?? [];
-    const planned = functions.map((fn) => {
-        const source = isAbsolute(fn.source)
-            ? fn.source
-            : resolve(configDir, fn.source);
-        if (!existsSync(source)) {
-            throw new Error(`Function "${fn.slug}" points at a source that does not exist: ${source} ` +
-                `(from neon.ts "${fn.source}"). Fix the source path and re-run.`);
-        }
-        return {
-            slug: fn.slug,
-            name: fn.name,
-            source,
-            ...(devPort(fn.dev) !== undefined
-                ? { port: devPort(fn.dev) }
-                : {}),
-            env: { ...fn.env },
-            // Names only: locally every entry is simply left unbundled, and `includeFiles`
-            // governs the deployed archive, which `neon dev` does not build.
-            ...(fn.externalPackages
-                ? {
-                    externalPackages: fn.externalPackages.map((pkg) => pkg.name),
-                }
-                : {}),
-        };
-    });
-    return { configPath, functions: planned };
+* Load `neon.ts` (if any) and resolve the list of functions it declares into
+* {@link PlannedFunction}s for `neon dev` to serve. Returns `null` when there is no
+* `neon.ts` on the path from `cwd` up to the repo root — the caller turns that into a
+* "no --source and no neon.ts" error.
+*
+* `branchName` is used only to evaluate a policy that switches on `branch.name`; the
+* function list is otherwise branch-independent, so a placeholder is fine when unknown.
+*/
+const resolveFunctionsFromConfig = async (cwd, branchName) => {
+	const loaded = await loadNeonConfig(cwd);
+	if (!loaded) return null;
+	const { config, configDir, configPath } = loaded;
+	return {
+		configPath,
+		functions: (resolveConfig(config, {
+			name: branchName ?? "local",
+			exists: branchName !== void 0
+		}).preview?.functions ?? []).map((fn) => {
+			const source = isAbsolute(fn.source) ? fn.source : resolve(configDir, fn.source);
+			if (!existsSync(source)) throw new Error(`Function "${fn.slug}" points at a source that does not exist: ${source} (from neon.ts "${fn.source}"). Fix the source path and re-run.`);
+			return {
+				slug: fn.slug,
+				name: fn.name,
+				source,
+				...devPort(fn.dev) !== void 0 ? { port: devPort(fn.dev) } : {},
+				env: { ...fn.env },
+				...fn.externalPackages ? { externalPackages: fn.externalPackages.map((pkg) => pkg.name) } : {}
+			};
+		})
+	};
 };
 /**
- * Read the `port` off a {@link FunctionDevConfig}. `undefined` when no `dev.port` is set
- * (the supervisor then searches for a free port).
- */
+* Read the `port` off a {@link FunctionDevConfig}. `undefined` when no `dev.port` is set
+* (the supervisor then searches for a free port).
+*/
 const devPort = (dev) => dev?.port;
 /**
- * Load a `neon.ts` policy if one exists, returning the loaded config, the resolved path to
- * the config file (used by the dev server to watch it), and the directory it lives in (used
- * to resolve each function's relative `source`). Returns `null` when no config file is
- * found; surfaces real load errors (e.g. a syntax error).
- */
+* Load a `neon.ts` policy if one exists, returning the loaded config, the resolved path to
+* the config file (used by the dev server to watch it), and the directory it lives in (used
+* to resolve each function's relative `source`). Returns `null` when no config file is
+* found; surfaces real load errors (e.g. a syntax error).
+*/
 const loadNeonConfig = async (cwd) => {
-    try {
-        const { config, resolvedPath } = await loadConfigFromFile({ cwd });
-        return {
-            config,
-            configDir: dirname(resolvedPath),
-            configPath: resolvedPath,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (/Could not find a Neon config file/i.test(message)) {
-            return null;
-        }
-        throw err;
-    }
+	try {
+		const { config, resolvedPath } = await loadConfigFromFile({ cwd });
+		return {
+			config,
+			configDir: dirname(resolvedPath),
+			configPath: resolvedPath
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (/Could not find a Neon config file/i.test(message)) return null;
+		throw err;
+	}
 };
+//#endregion
+export { resolveFunctionsFromConfig };

package/dist/dev/inputs.js

@@ -1,63 +1,51 @@
 import { resolve } from "node:path";
+//#region src/dev/inputs.ts
 const defaultDeps = {
-    isPackaged: () => process.pkg !== undefined,
-    loadEsbuild: (name) => import(name),
+	isPackaged: () => process.pkg !== void 0,
+	loadEsbuild: (name) => import(name)
 };
 /**
- * Resolve the exact set of files esbuild reads to produce the bundle for
- * `source` — the entry plus every local module it imports (npm deps are left
- * external, so they never appear). These are the files the dev watcher should
- * watch, so a single edit triggers exactly one rebuild.
- *
- * Returns absolute paths, or `null` when the precise set cannot be computed —
- * either inside the packaged binary (which cannot import esbuild as a module;
- * it shells out to a binary that has no JSON-metafile equivalent here) or on a
- * platform where the esbuild module won't load. Callers fall back to a coarser
- * watch in that case.
- *
- * This performs a metafile-only pass (`write:false`, `metafile:true`) so it
- * never emits output; the actual bundle bytes still come from `bundleEntry`.
- */
-export const resolveWatchInputs = async (source, deps = defaultDeps) => {
-    if (deps.isPackaged())
-        return null;
-    // esbuild is resolved by a COMPUTED specifier, never the literal string
-    // 'esbuild', for the same reason as src/utils/esbuild.ts: rollup and
-    // @yao-pkg/pkg statically scan for literal import()/require() and would pull
-    // esbuild's native Go binary into the bundle/snapshot. Keep it invisible.
-    const name = ["es", "build"].join("");
-    let esbuild;
-    try {
-        esbuild = await deps.loadEsbuild(name);
-    }
-    catch {
-        return null;
-    }
-    let metafile;
-    try {
-        // Mirrors bundleEntry's flags so the resolved input graph matches the real
-        // bundle. metafile:true + write:false makes this a pure analysis pass.
-        const result = await esbuild.build({
-            entryPoints: [source],
-            bundle: true,
-            write: false,
-            metafile: true,
-            format: "esm",
-            platform: "node",
-            packages: "external",
-            logLevel: "silent",
-        });
-        metafile = result.metafile;
-    }
-    catch {
-        // A bundle error here is non-fatal for watching: bundleEntry surfaces the
-        // real diagnostic. Fall back to the coarser watch so edits still rebuild.
-        return null;
-    }
-    const inputs = metafile?.inputs;
-    if (!inputs)
-        return null;
-    // metafile input keys are paths relative to esbuild's cwd; resolve to absolute
-    // so they compare cleanly against chokidar's watched paths.
-    return Object.keys(inputs).map((p) => resolve(process.cwd(), p));
+* Resolve the exact set of files esbuild reads to produce the bundle for
+* `source` — the entry plus every local module it imports (npm deps are left
+* external, so they never appear). These are the files the dev watcher should
+* watch, so a single edit triggers exactly one rebuild.
+*
+* Returns absolute paths, or `null` when the precise set cannot be computed —
+* either inside the packaged binary (which cannot import esbuild as a module;
+* it shells out to a binary that has no JSON-metafile equivalent here) or on a
+* platform where the esbuild module won't load. Callers fall back to a coarser
+* watch in that case.
+*
+* This performs a metafile-only pass (`write:false`, `metafile:true`) so it
+* never emits output; the actual bundle bytes still come from `bundleEntry`.
+*/
+const resolveWatchInputs = async (source, deps = defaultDeps) => {
+	if (deps.isPackaged()) return null;
+	const name = ["es", "build"].join("");
+	let esbuild;
+	try {
+		esbuild = await deps.loadEsbuild(name);
+	} catch {
+		return null;
+	}
+	let metafile;
+	try {
+		metafile = (await esbuild.build({
+			entryPoints: [source],
+			bundle: true,
+			write: false,
+			metafile: true,
+			format: "esm",
+			platform: "node",
+			packages: "external",
+			logLevel: "silent"
+		})).metafile;
+	} catch {
+		return null;
+	}
+	const inputs = metafile?.inputs;
+	if (!inputs) return null;
+	return Object.keys(inputs).map((p) => resolve(process.cwd(), p));
 };
+//#endregion
+export { resolveWatchInputs };

package/dist/dev/runtime.js

@@ -1,190 +1,161 @@
-import { createServer } from "node:http";
+import { createUpgradeListener, installWebSocketBridge } from "./websocket.js";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { createServer } from "node:http";
 import { getRequestListener } from "@hono/node-server";
-import { createUpgradeListener, installWebSocketBridge, } from "./websocket.js";
+//#region src/dev/runtime.ts
 const isFunction = (value) => typeof value === "function";
-const hasFetchMethod = (value) => typeof value === "object" &&
-    value !== null &&
-    "fetch" in value &&
-    typeof value.fetch === "function";
+const hasFetchMethod = (value) => typeof value === "object" && value !== null && "fetch" in value && typeof value.fetch === "function";
 /**
- * Resolve the user's exported handler to a single fetch callback.
- *
- * Resolution order (first match wins):
- *   1. `export default { fetch }`      — Workers / Neon Functions style
- *   2. `export default function (req)` — bare (async) default function
- */
-export const resolveFetchHandler = (mod) => {
-    const defaultExport = mod.default;
-    if (hasFetchMethod(defaultExport)) {
-        const target = defaultExport;
-        return (req) => target.fetch(req);
-    }
-    if (isFunction(defaultExport)) {
-        return defaultExport;
-    }
-    throw new Error("No request handler found in the source module. Export one of:\n" +
-        "  export default { fetch(req) { /* ... */ } }\n" +
-        "  export default function (req) { /* ... */ }");
+* Resolve the user's exported handler to a single fetch callback.
+*
+* Resolution order (first match wins):
+*   1. `export default { fetch }`      — Workers / Neon Functions style
+*   2. `export default function (req)` — bare (async) default function
+*/
+const resolveFetchHandler = (mod) => {
+	const defaultExport = mod.default;
+	if (hasFetchMethod(defaultExport)) {
+		const target = defaultExport;
+		return (req) => target.fetch(req);
+	}
+	if (isFunction(defaultExport)) return defaultExport;
+	throw new Error("No request handler found in the source module. Export one of:\n  export default { fetch(req) { /* ... */ } }\n  export default function (req) { /* ... */ }");
 };
-const hasUpgradeMethod = (value) => typeof value === "object" &&
-    value !== null &&
-    "upgrade" in value &&
-    typeof value.upgrade === "function";
+const hasUpgradeMethod = (value) => typeof value === "object" && value !== null && "upgrade" in value && typeof value.upgrade === "function";
 /**
- * Resolve the user's optional WebSocket entrypoint: a named `export function upgrade`,
- * or an `upgrade` method on the default export. `undefined` when the module has
- * neither, which is the common case — a function without one either uses
- * `upgradeWebSocket()` inside `fetch` or serves no WebSockets at all.
- *
- * Resolution order matches the deployed runtime exactly (named export first, then the
- * default-export method), so a module that resolves one way locally cannot resolve the
- * other way once deployed.
- */
-export const resolveUpgradeHandler = (mod) => {
-    if (typeof mod.upgrade === "function")
-        return mod.upgrade;
-    const defaultExport = mod.default;
-    if (hasUpgradeMethod(defaultExport)) {
-        const target = defaultExport;
-        return (req, socket, head) => target.upgrade(req, socket, head);
-    }
-    return undefined;
+* Resolve the user's optional WebSocket entrypoint: a named `export function upgrade`,
+* or an `upgrade` method on the default export. `undefined` when the module has
+* neither, which is the common case — a function without one either uses
+* `upgradeWebSocket()` inside `fetch` or serves no WebSockets at all.
+*
+* Resolution order matches the deployed runtime exactly (named export first, then the
+* default-export method), so a module that resolves one way locally cannot resolve the
+* other way once deployed.
+*/
+const resolveUpgradeHandler = (mod) => {
+	if (typeof mod.upgrade === "function") return mod.upgrade;
+	const defaultExport = mod.default;
+	if (hasUpgradeMethod(defaultExport)) {
+		const target = defaultExport;
+		return (req, socket, head) => target.upgrade(req, socket, head);
+	}
 };
 /**
- * Wrap a fetch handler so user errors become a 500 response (with the message
- * in the body during dev) instead of crashing the child process.
- */
-export const withErrorBoundary = (handler) => {
-    return async (req) => {
-        try {
-            return await handler(req);
-        }
-        catch (err) {
-            const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
-            process.stderr.write(`Request handler threw an error:\n${message}\n`);
-            return new Response(`Internal Server Error\n\n${message}`, {
-                status: 500,
-                headers: { "content-type": "text/plain; charset=utf-8" },
-            });
-        }
-    };
+* Wrap a fetch handler so user errors become a 500 response (with the message
+* in the body during dev) instead of crashing the child process.
+*/
+const withErrorBoundary = (handler) => {
+	return async (req) => {
+		try {
+			return await handler(req);
+		} catch (err) {
+			const message = err instanceof Error ? err.stack ?? err.message : String(err);
+			process.stderr.write(`Request handler threw an error:\n${message}\n`);
+			return new Response(`Internal Server Error\n\n${message}`, {
+				status: 500,
+				headers: { "content-type": "text/plain; charset=utf-8" }
+			});
+		}
+	};
 };
-const isAddressInUse = (err) => typeof err === "object" &&
-    err !== null &&
-    err.code === "EADDRINUSE";
+const isAddressInUse = (err) => typeof err === "object" && err !== null && err.code === "EADDRINUSE";
 const DEFAULT_SEARCH_BASE = 8787;
 const MAX_SEARCH_STEPS = 100;
 const bindPort = async (server, selection, hostname) => {
-    if (selection.mode === "explicit") {
-        return listen(server, selection.port, hostname);
-    }
-    for (let step = 0; step < MAX_SEARCH_STEPS; step++) {
-        try {
-            return await listen(server, selection.from + step, hostname);
-        }
-        catch (err) {
-            if (!isAddressInUse(err))
-                throw err;
-        }
-    }
-    throw new Error(`Could not find a free port in ${selection.from}-${selection.from + MAX_SEARCH_STEPS - 1}`);
+	if (selection.mode === "explicit") return listen(server, selection.port, hostname);
+	for (let step = 0; step < MAX_SEARCH_STEPS; step++) try {
+		return await listen(server, selection.from + step, hostname);
+	} catch (err) {
+		if (!isAddressInUse(err)) throw err;
+	}
+	throw new Error(`Could not find a free port in ${selection.from}-${selection.from + MAX_SEARCH_STEPS - 1}`);
 };
 const listen = (server, port, hostname) => new Promise((resolveListen, rejectListen) => {
-    const onError = (err) => {
-        server.off("listening", onListening);
-        rejectListen(err);
-    };
-    const onListening = () => {
-        server.off("error", onError);
-        resolveListen(server.address().port);
-    };
-    server.once("error", onError);
-    server.once("listening", onListening);
-    server.listen(port, hostname);
+	const onError = (err) => {
+		server.off("listening", onListening);
+		rejectListen(err);
+	};
+	const onListening = () => {
+		server.off("error", onError);
+		resolveListen(server.address().port);
+	};
+	server.once("error", onError);
+	server.once("listening", onListening);
+	server.listen(port, hostname);
 });
 /**
- * Load the (already-bundled) user module, build the listener, and start an HTTP
- * server. Announces the bound port on stdout as `neon-dev:ready <port>` so the
- * parent can render the URL. Resolves with the bound port.
- */
-export const startRuntime = async ({ source, port, hostname, }) => {
-    const absoluteSource = resolve(process.cwd(), source);
-    const mod = (await import(pathToFileURL(absoluteSource).href));
-    const fetchHandler = resolveFetchHandler(mod);
-    const handler = withErrorBoundary(fetchHandler);
-    // Publish the bridge `upgradeWebSocket()` reads before the user module can serve a
-    // request, so the helper resolves locally exactly as it does when deployed.
-    installWebSocketBridge();
-    const listener = getRequestListener(handler, { hostname });
-    const server = createServer((incoming, outgoing) => {
-        void listener(incoming, outgoing);
-    });
-    // Node emits 'upgrade' rather than 'request' for a WebSocket handshake. Without
-    // this listener Node hands the handshake to the ordinary request handler, which
-    // answers 200 on a connection the client expects to be a 101 — so a function's
-    // WebSocket code silently never ran under `neon dev`.
-    //
-    // The upgrade path takes the RAW handler, not the error-boundary-wrapped one. The
-    // boundary turns a throw into a 500 Response, which on this path is
-    // indistinguishable from a handler that deliberately declined the upgrade — so a
-    // crashing handler would answer 501 ("no WebSocket support") instead of surfacing
-    // the error. The upgrade listener has its own equivalent boundary, and reports a
-    // throw as the 502 the deployed runtime returns.
-    server.on("upgrade", createUpgradeListener({
-        fetch: fetchHandler,
-        upgrade: resolveUpgradeHandler(mod),
-    }));
-    const boundPort = await bindPort(server, port, hostname);
-    process.stdout.write(`neon-dev:ready ${boundPort}\n`);
-    return boundPort;
+* Load the (already-bundled) user module, build the listener, and start an HTTP
+* server. Announces the bound port on stdout as `neon-dev:ready <port>` so the
+* parent can render the URL. Resolves with the bound port.
+*/
+const startRuntime = async ({ source, port, hostname }) => {
+	const absoluteSource = resolve(process.cwd(), source);
+	const mod = await import(pathToFileURL(absoluteSource).href);
+	const fetchHandler = resolveFetchHandler(mod);
+	const handler = withErrorBoundary(fetchHandler);
+	installWebSocketBridge();
+	const listener = getRequestListener(handler, { hostname });
+	const server = createServer((incoming, outgoing) => {
+		listener(incoming, outgoing);
+	});
+	server.on("upgrade", createUpgradeListener({
+		fetch: fetchHandler,
+		upgrade: resolveUpgradeHandler(mod)
+	}));
+	const boundPort = await bindPort(server, port, hostname);
+	process.stdout.write(`neon-dev:ready ${boundPort}\n`);
+	return boundPort;
 };
 /**
- * Build a {@link PortSelection} from the environment. Precedence:
- *   1. `NEON_DEV_PORT` -> explicit bind (crash if taken). Set by `neon dev` from an
- *      explicit `--port` / `dev.port`.
- *   2. `PORT`          -> explicit bind. A bare `PORT=3000 neon dev` sets this, so the
- *      runtime binds the port chosen for it.
- *   3. otherwise        -> search upward from `NEON_DEV_PORT_BASE` (or the default base).
- */
-export const portSelectionFromEnv = (env) => {
-    const explicit = env.NEON_DEV_PORT;
-    if (explicit !== undefined && explicit !== "") {
-        return { mode: "explicit", port: parsePort(explicit, "NEON_DEV_PORT") };
-    }
-    const injected = env.PORT;
-    if (injected !== undefined && injected !== "") {
-        return { mode: "explicit", port: parsePort(injected, "PORT") };
-    }
-    const base = Number(env.NEON_DEV_PORT_BASE ?? DEFAULT_SEARCH_BASE);
-    return {
-        mode: "search",
-        from: Number.isInteger(base) ? base : DEFAULT_SEARCH_BASE,
-    };
+* Build a {@link PortSelection} from the environment. Precedence:
+*   1. `NEON_DEV_PORT` -> explicit bind (crash if taken). Set by `neon dev` from an
+*      explicit `--port` / `dev.port`.
+*   2. `PORT`          -> explicit bind. A bare `PORT=3000 neon dev` sets this, so the
+*      runtime binds the port chosen for it.
+*   3. otherwise        -> search upward from `NEON_DEV_PORT_BASE` (or the default base).
+*/
+const portSelectionFromEnv = (env) => {
+	const explicit = env.NEON_DEV_PORT;
+	if (explicit !== void 0 && explicit !== "") return {
+		mode: "explicit",
+		port: parsePort(explicit, "NEON_DEV_PORT")
+	};
+	const injected = env.PORT;
+	if (injected !== void 0 && injected !== "") return {
+		mode: "explicit",
+		port: parsePort(injected, "PORT")
+	};
+	const base = Number(env.NEON_DEV_PORT_BASE ?? DEFAULT_SEARCH_BASE);
+	return {
+		mode: "search",
+		from: Number.isInteger(base) ? base : DEFAULT_SEARCH_BASE
+	};
 };
 const parsePort = (value, varName) => {
-    const port = Number(value);
-    if (!Number.isInteger(port) || port < 0 || port > 65535) {
-        throw new Error(`Invalid ${varName}: "${value}"`);
-    }
-    return port;
+	const port = Number(value);
+	if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`Invalid ${varName}: "${value}"`);
+	return port;
 };
 const isDirectExecution = () => {
-    const entry = process.argv[1];
-    if (!entry)
-        return false;
-    return import.meta.url === pathToFileURL(entry).href;
+	const entry = process.argv[1];
+	if (!entry) return false;
+	return import.meta.url === pathToFileURL(entry).href;
 };
 if (isDirectExecution()) {
-    const source = process.env.NEON_DEV_SOURCE ?? process.argv[2];
-    if (!source) {
-        process.stderr.write("neon-dev runtime: missing source path\n");
-        process.exit(1);
-    }
-    startRuntime({ source, port: portSelectionFromEnv(process.env) }).catch((err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`neon-dev runtime failed to start: ${msg}\n`);
-        process.exit(1);
-    });
+	const source = process.env.NEON_DEV_SOURCE ?? process.argv[2];
+	if (!source) {
+		process.stderr.write("neon-dev runtime: missing source path\n");
+		process.exit(1);
+	}
+	startRuntime({
+		source,
+		port: portSelectionFromEnv(process.env)
+	}).catch((err) => {
+		const msg = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`neon-dev runtime failed to start: ${msg}\n`);
+		process.exit(1);
+	});
 }
+//#endregion
+export { portSelectionFromEnv, resolveFetchHandler, resolveUpgradeHandler, startRuntime, withErrorBoundary };