neon 3.0.0 → 3.1.1

package/dist/env.js

@@ -1,36 +1,30 @@
-export const isCi = () => {
-    return process.env.CI !== "false" && Boolean(process.env.CI);
+//#region src/env.ts
+const isCi = () => {
+	return process.env.CI !== "false" && Boolean(process.env.CI);
 };
-export const isDebug = () => {
-    return Boolean(process.env.DEBUG);
+const isDebug = () => {
+	return Boolean(process.env.DEBUG);
 };
-export const getGithubEnvVars = (env) => {
-    const vars = [
-        // github action info
-        "GITHUB_ACTION_PATH",
-        // source github repository
-        "GITHUB_REPOSITORY",
-        // environment info
-        "GITHUB_RUN_ID",
-        "GITHUB_RUN_NUMBER",
-        "GITHUB_SERVER_URL",
-        "GITHUB_WORKFLOW_REF",
-        "RUNNER_ARCH",
-        "RUNNER_ENVIRONMENT",
-        "RUNNER_OS",
-    ];
-    const map = new Map();
-    vars.forEach((v) => {
-        let value = env[v];
-        if (value === undefined || value === "") {
-            return;
-        }
-        if (v === "GITHUB_ACTION_PATH") {
-            value = value.includes("actions/")
-                ? value.replace(/^.*actions\/(.+)$/, "$1")
-                : value;
-        }
-        map.set(v, value);
-    });
-    return Object.fromEntries(map);
+const getGithubEnvVars = (env) => {
+	const vars = [
+		"GITHUB_ACTION_PATH",
+		"GITHUB_REPOSITORY",
+		"GITHUB_RUN_ID",
+		"GITHUB_RUN_NUMBER",
+		"GITHUB_SERVER_URL",
+		"GITHUB_WORKFLOW_REF",
+		"RUNNER_ARCH",
+		"RUNNER_ENVIRONMENT",
+		"RUNNER_OS"
+	];
+	const map = /* @__PURE__ */ new Map();
+	vars.forEach((v) => {
+		let value = env[v];
+		if (value === void 0 || value === "") return;
+		if (v === "GITHUB_ACTION_PATH") value = value.includes("actions/") ? value.replace(/^.*actions\/(.+)$/, "$1") : value;
+		map.set(v, value);
+	});
+	return Object.fromEntries(map);
 };
+//#endregion
+export { getGithubEnvVars, isCi, isDebug };

package/dist/env_file.js

@@ -1,159 +1,145 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+//#region src/env_file.ts
 /**
- * Default dotenv file `env pull` writes to: `.env` when one already exists in the working
- * directory (update where secrets already live), otherwise `.env.local` — matching the
- * `vercel env pull` convention. An explicit `--file` always wins over this.
- */
-export const resolveEnvFilePath = (cwd, file) => {
-    if (file)
-        return join(cwd, file);
-    if (existsSync(join(cwd, ".env")))
-        return join(cwd, ".env");
-    return join(cwd, ".env.local");
+* Default dotenv file `env pull` writes to: `.env` when one already exists in the working
+* directory (update where secrets already live), otherwise `.env.local` — matching the
+* `vercel env pull` convention. An explicit `--file` always wins over this.
+*/
+const resolveEnvFilePath = (cwd, file) => {
+	if (file) return join(cwd, file);
+	if (existsSync(join(cwd, ".env"))) return join(cwd, ".env");
+	return join(cwd, ".env.local");
 };
 /**
- * Merge `updates` into the dotenv content at `path`, preserving every other line
- * (comments, blank lines, unrelated keys) and the file's existing order. Keys present in
- * both are updated in place; keys only in `updates` are appended. A non-existent file is
- * treated as empty. When `managedKeys` is given, any owned key on disk that is absent from
- * `updates` is removed. Returns the keys written and the (managed) keys removed.
- */
-export const mergeEnvFile = (path, updates, options = {}) => {
-    const original = existsSync(path) ? readFileSync(path, "utf8") : "";
-    const { content, written, removed } = mergeEnvContent(original, updates, options);
-    writeFileSync(path, content);
-    return { written, removed };
+* Merge `updates` into the dotenv content at `path`, preserving every other line
+* (comments, blank lines, unrelated keys) and the file's existing order. Keys present in
+* both are updated in place; keys only in `updates` are appended. A non-existent file is
+* treated as empty. When `managedKeys` is given, any owned key on disk that is absent from
+* `updates` is removed. Returns the keys written and the (managed) keys removed.
+*/
+const mergeEnvFile = (path, updates, options = {}) => {
+	const original = existsSync(path) ? readFileSync(path, "utf8") : "";
+	const { content, written, removed } = mergeEnvContent(original, updates, options);
+	writeFileSync(path, content);
+	return {
+		written,
+		removed
+	};
 };
 /**
- * Pure core of {@link mergeEnvFile}: takes the current file content and the updates, and
- * returns the new content plus which keys were written / removed. Kept side-effect-free so
- * it can be unit-tested without touching the filesystem.
- */
-export const mergeEnvContent = (original, updates, options = {}) => {
-    const keys = Object.keys(updates);
-    // Owned keys the current pull did not produce: stale Neon-managed vars to prune. Anything
-    // not in `managedKeys` is always kept, so a user's own lines are never removed.
-    const stale = new Set([...(options.managedKeys ?? [])].filter((key) => !(key in updates)));
-    if (keys.length === 0 && stale.size === 0) {
-        return { content: original, written: [], removed: [] };
-    }
-    const remaining = new Set(keys);
-    const removed = [];
-    const lines = original === "" ? [] : original.split("\n");
-    // Walk the file: drop stale owned lines, update existing keys in place (so their position
-    // and any surrounding comments are preserved), and pass everything else through untouched.
-    const updatedLines = [];
-    for (const line of lines) {
-        const key = parseKey(line);
-        if (key !== null && stale.has(key)) {
-            removed.push(key);
-            continue;
-        }
-        if (key !== null && remaining.has(key)) {
-            remaining.delete(key);
-            updatedLines.push(formatLine(key, updates[key]));
-            continue;
-        }
-        updatedLines.push(line);
-    }
-    // Append keys that weren't already present, in the order they were given.
-    const appended = keys
-        .filter((key) => remaining.has(key))
-        .map((key) => formatLine(key, updates[key]));
-    const body = trimTrailingBlank(updatedLines);
-    const content = [...body, ...appended].join("\n");
-    return {
-        // A dotenv file ends with a trailing newline.
-        content: content === "" ? "" : `${content}\n`,
-        written: keys,
-        removed,
-    };
+* Pure core of {@link mergeEnvFile}: takes the current file content and the updates, and
+* returns the new content plus which keys were written / removed. Kept side-effect-free so
+* it can be unit-tested without touching the filesystem.
+*/
+const mergeEnvContent = (original, updates, options = {}) => {
+	const keys = Object.keys(updates);
+	const stale = new Set([...options.managedKeys ?? []].filter((key) => !(key in updates)));
+	if (keys.length === 0 && stale.size === 0) return {
+		content: original,
+		written: [],
+		removed: []
+	};
+	const remaining = new Set(keys);
+	const removed = [];
+	const lines = original === "" ? [] : original.split("\n");
+	const updatedLines = [];
+	for (const line of lines) {
+		const key = parseKey(line);
+		if (key !== null && stale.has(key)) {
+			removed.push(key);
+			continue;
+		}
+		if (key !== null && remaining.has(key)) {
+			remaining.delete(key);
+			updatedLines.push(formatLine(key, updates[key]));
+			continue;
+		}
+		updatedLines.push(line);
+	}
+	const appended = keys.filter((key) => remaining.has(key)).map((key) => formatLine(key, updates[key]));
+	const content = [...trimTrailingBlank(updatedLines), ...appended].join("\n");
+	return {
+		content: content === "" ? "" : `${content}\n`,
+		written: keys,
+		removed
+	};
 };
 /**
- * Read a dotenv file at `path` into a plain `{ KEY: value }` map. A non-existent file is an
- * error (callers pass an explicit `--env` path, so a typo should fail loudly rather than
- * silently load nothing). Quotes are stripped and `\"` / `\\` unescaped, matching the
- * quoting {@link mergeEnvFile} writes. Comments, blank lines, and non-assignment lines are
- * ignored.
- */
-export const readEnvFile = (path) => {
-    if (!existsSync(path)) {
-        throw new Error(`Env file not found: ${path}`);
-    }
-    const out = {};
-    for (const line of readFileSync(path, "utf8").split("\n")) {
-        const parsed = parseAssignment(line);
-        if (parsed)
-            out[parsed.key] = parsed.value;
-    }
-    return out;
+* Read a dotenv file at `path` into a plain `{ KEY: value }` map. A non-existent file is an
+* error (callers pass an explicit `--env` path, so a typo should fail loudly rather than
+* silently load nothing). Quotes are stripped and `\"` / `\\` unescaped, matching the
+* quoting {@link mergeEnvFile} writes. Comments, blank lines, and non-assignment lines are
+* ignored.
+*/
+const readEnvFile = (path) => {
+	if (!existsSync(path)) throw new Error(`Env file not found: ${path}`);
+	const out = {};
+	for (const line of readFileSync(path, "utf8").split("\n")) {
+		const parsed = parseAssignment(line);
+		if (parsed) out[parsed.key] = parsed.value;
+	}
+	return out;
 };
 /**
- * Load a dotenv file into `process.env` so values are available to anything read later
- * (e.g. a `neon.ts` whose function `env` values come from `process.env.X`). Existing
- * `process.env` entries are **not** overridden — an already-exported var wins over the
- * file, matching dotenv's default. Returns the keys that were applied.
- */
-export const loadEnvFileIntoProcess = (path) => {
-    const parsed = readEnvFile(path);
-    const applied = [];
-    for (const [key, value] of Object.entries(parsed)) {
-        if (process.env[key] === undefined) {
-            process.env[key] = value;
-            applied.push(key);
-        }
-    }
-    return applied;
+* Load a dotenv file into `process.env` so values are available to anything read later
+* (e.g. a `neon.ts` whose function `env` values come from `process.env.X`). Existing
+* `process.env` entries are **not** overridden — an already-exported var wins over the
+* file, matching dotenv's default. Returns the keys that were applied.
+*/
+const loadEnvFileIntoProcess = (path) => {
+	const parsed = readEnvFile(path);
+	const applied = [];
+	for (const [key, value] of Object.entries(parsed)) if (process.env[key] === void 0) {
+		process.env[key] = value;
+		applied.push(key);
+	}
+	return applied;
 };
 /**
- * Extract the variable name from a dotenv line, or `null` for comments / blank lines / any
- * line that isn't a `KEY=value` assignment. Tolerates a leading `export ` and surrounding
- * whitespace, matching common `.env` styles.
- */
+* Extract the variable name from a dotenv line, or `null` for comments / blank lines / any
+* line that isn't a `KEY=value` assignment. Tolerates a leading `export ` and surrounding
+* whitespace, matching common `.env` styles.
+*/
 const parseKey = (line) => {
-    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
-    return match ? match[1] : null;
+	const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
+	return match ? match[1] : null;
 };
 /**
- * Parse a `KEY=value` dotenv line into its key and unquoted value, or `null` for
- * comments / blank lines / non-assignments. Mirrors {@link formatLine}'s quoting.
- */
+* Parse a `KEY=value` dotenv line into its key and unquoted value, or `null` for
+* comments / blank lines / non-assignments. Mirrors {@link formatLine}'s quoting.
+*/
 const parseAssignment = (line) => {
-    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
-    const key = match?.[1];
-    const raw = match?.[2];
-    if (key === undefined || raw === undefined)
-        return null;
-    return { key, value: unquote(raw.trim()) };
+	const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+	const key = match?.[1];
+	const raw = match?.[2];
+	if (key === void 0 || raw === void 0) return null;
+	return {
+		key,
+		value: unquote(raw.trim())
+	};
 };
 /** Strip matching surrounding quotes and unescape `\"` / `\\` inside double quotes. */
 const unquote = (value) => {
-    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
-        return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-    }
-    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
-        return value.slice(1, -1);
-    }
-    return value;
+	if (value.length >= 2 && value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+	if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+	return value;
 };
 /**
- * Render a `KEY=value` line. The value is wrapped in double quotes when it contains
- * characters that would otherwise break parsing (spaces, `#`, quotes, `=`), with inner
- * quotes/backslashes escaped — Neon connection strings and URLs are safe either way, but
- * quoting defensively avoids surprises for tools that re-parse the file.
- */
+* Render a `KEY=value` line. The value is wrapped in double quotes when it contains
+* characters that would otherwise break parsing (spaces, `#`, quotes, `=`), with inner
+* quotes/backslashes escaped — Neon connection strings and URLs are safe either way, but
+* quoting defensively avoids surprises for tools that re-parse the file.
+*/
 const formatLine = (key, value) => {
-    const needsQuotes = /[\s#"'=]/.test(value);
-    if (!needsQuotes)
-        return `${key}=${value}`;
-    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-    return `${key}="${escaped}"`;
+	if (!/[\s#"'=]/.test(value)) return `${key}=${value}`;
+	return `${key}="${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
 };
 /** Drop trailing blank lines so we don't accumulate them across repeated merges. */
 const trimTrailingBlank = (lines) => {
-    const out = [...lines];
-    while (out.length > 0 && out[out.length - 1]?.trim() === "")
-        out.pop();
-    return out;
+	const out = [...lines];
+	while (out.length > 0 && out[out.length - 1]?.trim() === "") out.pop();
+	return out;
 };
+//#endregion
+export { loadEnvFileIntoProcess, mergeEnvContent, mergeEnvFile, readEnvFile, resolveEnvFilePath };

package/dist/env_services.js

@@ -1,51 +1,2 @@
-import { NEON_ENV_VAR_KEYS } from "./_shared/env-core/env.js";
-import { NEON_SERVICES } from "./neon_services.js";
-/**
- * The services `env pull --service` can select: every Neon service that produces branch env
- * vars. `functions` is the one left out — a function's env comes from the local `neon.ts`,
- * never from the branch, so there is nothing to pull.
- */
-export const ENV_PULL_SERVICES = NEON_SERVICES.filter((service) => service !== "functions");
-/** Why the services `env pull` leaves out are not selectable, for the refusal message. */
-export const ENV_PULL_UNAVAILABLE = {
-    functions: "a function's env comes from your neon.ts, not from the branch, so there is nothing to pull",
-};
-/** The OS-level env vars each service contributes to a pulled `.env`. */
-const SERVICE_ENV_KEYS = {
-    postgres: Object.values(NEON_ENV_VAR_KEYS.postgres),
-    auth: Object.values(NEON_ENV_VAR_KEYS.auth),
-    "data-api": Object.values(NEON_ENV_VAR_KEYS.dataApi),
-    "object-storage": Object.values(NEON_ENV_VAR_KEYS.storage),
-    "ai-gateway": Object.values(NEON_ENV_VAR_KEYS.aiGateway),
-    functions: [],
-};
-/**
- * The subset of {@link SERVICE_ENV_KEYS} a pull *owns*, and so may prune from the target file
- * when the branch no longer has it. Object storage is deliberately absent: it is emitted under
- * the third-party `AWS_*` names, which collide with credentials a user may set by hand, so
- * `env pull` only ever writes them.
- */
-const SERVICE_OWNED_ENV_KEYS = {
-    ...SERVICE_ENV_KEYS,
-    "object-storage": [],
-};
-/**
- * Branch identity. Not a service — every branch has a name — so a scoped pull refreshes it
- * alongside whatever services were selected.
- */
-export const BRANCH_ENV_KEY = NEON_ENV_VAR_KEYS.branch.name;
-/** Every env var the selected services contribute, plus branch identity. */
-export const envServiceKeys = (services) => {
-    const keys = new Set([BRANCH_ENV_KEY]);
-    for (const service of services) {
-        for (const key of SERVICE_ENV_KEYS[service])
-            keys.add(key);
-    }
-    return keys;
-};
-/**
- * The env vars a pull scoped to `services` may prune. Narrower than the unscoped set on
- * purpose: `env pull -s ai-gateway` says nothing about `DATABASE_URL`, so it must leave it
- * alone rather than treat its absence from this pull as "the branch no longer has it".
- */
-export const ownedEnvServiceKeys = (services) => services.flatMap((service) => SERVICE_OWNED_ENV_KEYS[service]);
+import { a as envKeysForSelection, c as ownedEnvServiceKeys, d as servicesForEnvKeys, i as ENV_PULL_UNAVAILABLE, l as parseEnvPullKeys, n as ENV_PULL_KEYS, o as envPullFlagValue, r as ENV_PULL_SERVICES, s as envServiceKeys, t as BRANCH_ENV_KEY, u as serviceForEnvKey } from "./_chunks/env_services-Tz9G4JeT.js";
+export { BRANCH_ENV_KEY, ENV_PULL_KEYS, ENV_PULL_SERVICES, ENV_PULL_UNAVAILABLE, envKeysForSelection, envPullFlagValue, envServiceKeys, ownedEnvServiceKeys, parseEnvPullKeys, serviceForEnvKey, servicesForEnvKeys };

package/dist/errors.js

@@ -1,80 +1,69 @@
+//#region src/errors.ts
 const ERROR_MATCHERS = [
-    [/^Unknown command: (.*)$/, "UNKNOWN_COMMAND"],
-    [/^Missing required argument: (.*)$/, "MISSING_ARGUMENT"],
-    [/^Failed to open web browser. (.*)$/, "AUTH_BROWSER_FAILED"],
+	[/^Unknown command: (.*)$/, "UNKNOWN_COMMAND"],
+	[/^Missing required argument: (.*)$/, "MISSING_ARGUMENT"],
+	[/^Failed to open web browser. (.*)$/, "AUTH_BROWSER_FAILED"]
 ];
-export const matchErrorCode = (message) => {
-    if (!message) {
-        return "UNKNOWN_ERROR";
-    }
-    for (const [matcher, code] of ERROR_MATCHERS) {
-        const match = message.match(matcher);
-        if (match) {
-            return code;
-        }
-    }
-    return "UNKNOWN_ERROR";
+const matchErrorCode = (message) => {
+	if (!message) return "UNKNOWN_ERROR";
+	for (const [matcher, code] of ERROR_MATCHERS) if (message.match(matcher)) return code;
+	return "UNKNOWN_ERROR";
 };
 /**
- * The single, human-readable line shown when the CLI couldn't reach the Neon API because
- * of a connection-level failure (DNS, refused/reset connection, offline). It replaces the
- * cryptic `fetch failed` / empty axios message a network blip otherwise surfaces (see
- * {@link isNetworkError}), pointing at the two things the user can actually check.
- */
-export const NETWORK_ERROR_MESSAGE = "Could not reach the Neon API. Please check your internet connection and try again. " +
-    "If your connection is fine and this keeps happening, check https://neonstatus.com for ongoing incidents.";
+* The single, human-readable line shown when the CLI couldn't reach the Neon API because
+* of a connection-level failure (DNS, refused/reset connection, offline). It replaces the
+* cryptic `fetch failed` / empty axios message a network blip otherwise surfaces (see
+* {@link isNetworkError}), pointing at the two things the user can actually check.
+*/
+const NETWORK_ERROR_MESSAGE = "Could not reach the Neon API. Please check your internet connection and try again. If your connection is fine and this keeps happening, check https://neonstatus.com for ongoing incidents.";
 /**
- * Node-level socket/DNS error codes that mean the request never reached the server — a
- * genuine connectivity problem rather than an API response we should surface. Deliberately
- * excludes `ECONNABORTED` (axios' timeout), which the CLI already reports as a timeout.
- */
-const NETWORK_ERROR_CODES = new Set([
-    "ECONNREFUSED",
-    "ECONNRESET",
-    "ETIMEDOUT",
-    "ENOTFOUND",
-    "EAI_AGAIN",
-    "EPIPE",
-    "EHOSTUNREACH",
-    "ENETUNREACH",
-    "EHOSTDOWN",
-    "ENETDOWN",
+* Node-level socket/DNS error codes that mean the request never reached the server — a
+* genuine connectivity problem rather than an API response we should surface. Deliberately
+* excludes `ECONNABORTED` (axios' timeout), which the CLI already reports as a timeout.
+*/
+const NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"ETIMEDOUT",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"EPIPE",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"EHOSTDOWN",
+	"ENETDOWN"
 ]);
 /**
- * Message fragments that mark a connection-level failure across our two transports: the
- * `@neon/sdk` / global `fetch` path (used by `env pull` / `config` / `deploy`, and `link`'s
- * bundled env pull) throws a bare `TypeError: fetch failed` / "Failed to fetch", while the
- * axios `api-client` path throws an `AxiosError` whose message is "Network Error".
- */
+* Message fragments that mark a connection-level failure across our two transports: the
+* `@neon/sdk` / global `fetch` path (used by `env pull` / `config` / `deploy`, and `link`'s
+* bundled env pull) throws a bare `TypeError: fetch failed` / "Failed to fetch", while the
+* axios `api-client` path throws an `AxiosError` whose message is "Network Error".
+*/
 const NETWORK_ERROR_MESSAGE_PATTERN = /fetch failed|failed to fetch|network error/i;
 const readErrorCode = (value) => {
-    if (value === null || typeof value !== "object")
-        return undefined;
-    const code = value.code;
-    return typeof code === "string" ? code : undefined;
+	if (value === null || typeof value !== "object") return void 0;
+	const code = value.code;
+	return typeof code === "string" ? code : void 0;
 };
 /**
- * Whether `err` is a connection-level failure (the network blip the user sees as a cryptic
- * `fetch failed`, or no message at all on the axios path) rather than an actual API response.
- *
- * A Node `fetch` failure is a bare `TypeError: fetch failed` whose underlying `cause` carries
- * the real socket `code` (e.g. `ECONNREFUSED`, `ENOTFOUND`, `EAI_AGAIN`), so we walk the
- * `cause` chain checking both the code and the message. This is what lets the CLI swap the
- * confusing default for {@link NETWORK_ERROR_MESSAGE}. It matches only failures where no
- * response was ever received, so it never masks a real 4xx/5xx the user needs to see.
- */
-export const isNetworkError = (err) => {
-    let current = err;
-    for (let depth = 0; depth < 6 && current !== null && current !== undefined; depth++) {
-        const code = readErrorCode(current);
-        if (code !== undefined && NETWORK_ERROR_CODES.has(code)) {
-            return true;
-        }
-        if (current instanceof Error &&
-            NETWORK_ERROR_MESSAGE_PATTERN.test(current.message)) {
-            return true;
-        }
-        current = current.cause;
-    }
-    return false;
+* Whether `err` is a connection-level failure (the network blip the user sees as a cryptic
+* `fetch failed`, or no message at all on the axios path) rather than an actual API response.
+*
+* A Node `fetch` failure is a bare `TypeError: fetch failed` whose underlying `cause` carries
+* the real socket `code` (e.g. `ECONNREFUSED`, `ENOTFOUND`, `EAI_AGAIN`), so we walk the
+* `cause` chain checking both the code and the message. This is what lets the CLI swap the
+* confusing default for {@link NETWORK_ERROR_MESSAGE}. It matches only failures where no
+* response was ever received, so it never masks a real 4xx/5xx the user needs to see.
+*/
+const isNetworkError = (err) => {
+	let current = err;
+	for (let depth = 0; depth < 6 && current !== null && current !== void 0; depth++) {
+		const code = readErrorCode(current);
+		if (code !== void 0 && NETWORK_ERROR_CODES.has(code)) return true;
+		if (current instanceof Error && NETWORK_ERROR_MESSAGE_PATTERN.test(current.message)) return true;
+		current = current.cause;
+	}
+	return false;
 };
+//#endregion
+export { NETWORK_ERROR_MESSAGE, isNetworkError, matchErrorCode };

package/dist/functions_api.js

@@ -1,48 +1,50 @@
-import { ContentType } from "./api.js";
+import "./api.js";
+//#region src/functions_api.ts
 const functionsPath = (projectId, branchId) => `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/functions`;
-export const listFunctions = async (apiClient, projectId, branchId, { cursor, limit } = {}) => {
-    const { data } = await apiClient.request({
-        path: functionsPath(projectId, branchId),
-        method: "GET",
-        query: { cursor, limit },
-        secure: true,
-        format: "json",
-    });
-    return { functions: data.functions ?? [], next: data.pagination?.next };
+const listFunctions = async (apiClient, projectId, branchId, { cursor, limit } = {}) => {
+	const { data } = await apiClient.request({
+		path: functionsPath(projectId, branchId),
+		method: "GET",
+		query: {
+			cursor,
+			limit
+		},
+		secure: true,
+		format: "json"
+	});
+	return {
+		functions: data.functions ?? [],
+		next: data.pagination?.next
+	};
 };
-export const getFunction = async (apiClient, projectId, branchId, slug) => {
-    const { data } = await apiClient.request({
-        path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}`,
-        method: "GET",
-        secure: true,
-        format: "json",
-    });
-    return data.function;
+const getFunction = async (apiClient, projectId, branchId, slug) => {
+	const { data } = await apiClient.request({
+		path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}`,
+		method: "GET",
+		secure: true,
+		format: "json"
+	});
+	return data.function;
 };
-export const deleteFunction = async (apiClient, projectId, branchId, slug) => {
-    await apiClient.request({
-        path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}`,
-        method: "DELETE",
-        secure: true,
-    });
+const deleteFunction = async (apiClient, projectId, branchId, slug) => {
+	await apiClient.request({
+		path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}`,
+		method: "DELETE",
+		secure: true
+	});
 };
-export const createDeployment = async (apiClient, projectId, branchId, slug, params) => {
-    const form = new FormData();
-    // TS 5.9 types `Uint8Array` as `Uint8Array<ArrayBufferLike>`, which is not
-    // assignable to `BlobPart` (it wants an `ArrayBuffer`-backed view, not a
-    // possibly-`SharedArrayBuffer` one). The bundle is always a plain
-    // `Uint8Array` over a regular `ArrayBuffer`, so the cast is safe.
-    form.append("zip", new Blob([params.zip]), "bundle.zip");
-    form.append("runtime", params.runtime);
-    if (params.environment)
-        form.append("environment", params.environment);
-    // The deploy POST returns an operation the CLI cannot poll; the body is
-    // ignored. We only need the request to succeed.
-    await apiClient.request({
-        path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}/deployments`,
-        method: "POST",
-        type: ContentType.FormData,
-        body: form,
-        secure: true,
-    });
+const createDeployment = async (apiClient, projectId, branchId, slug, params) => {
+	const form = new FormData();
+	form.append("zip", new Blob([params.zip]), "bundle.zip");
+	form.append("runtime", params.runtime);
+	if (params.environment) form.append("environment", params.environment);
+	await apiClient.request({
+		path: `${functionsPath(projectId, branchId)}/${encodeURIComponent(slug)}/deployments`,
+		method: "POST",
+		type: "multipart/form-data",
+		body: form,
+		secure: true
+	});
 };
+//#endregion
+export { createDeployment, deleteFunction, getFunction, listFunctions };