neon 2.47.0 → 3.1.0

package/dist/utils/ai_gateway_notice.js

@@ -1,180 +1,149 @@
 import { log } from "../log.js";
+//#region src/utils/ai_gateway_notice.ts
 /**
- * Friendly guidance shown when a branch enables the AI Gateway (`preview.aiGateway`).
- *
- * The gateway is credential-gated, not provisioned: enabling it always mints a working
- * branch credential, so `apply` / `checkout` / `env pull` succeed regardless of plan. The
- * two things that *do* gate the gateway happen at serving time and are invisible in the
- * provisioning result, so we surface them as a courtesy notice instead:
- *
- *  - **Free plan** — credentials provision, but the gateway does not *serve* model requests.
- *    The account needs to upgrade to a paid plan.
- *  - **Reduced model set** — on a paid plan, an account still ramping up on the beta gets a
- *    trimmed model catalog (flagship models are listed but `enabled: false` on `/v1/models`).
- *    They can request access to more models.
- *
- * This is deliberately phrased for the user: it never mentions account "verification" or any
- * other internal gating mechanism.
- */
+* Friendly guidance shown when a branch enables the AI Gateway (`preview.aiGateway`).
+*
+* The gateway is credential-gated, not provisioned: enabling it always mints a working
+* branch credential, so `apply` / `checkout` / `env pull` succeed regardless of plan. The
+* two things that *do* gate the gateway happen at serving time and are invisible in the
+* provisioning result, so we surface them as a courtesy notice instead:
+*
+*  - **Free plan** — credentials provision, but the gateway does not *serve* model requests.
+*    The account needs to upgrade to a paid plan.
+*  - **Reduced model set** — on a paid plan, an account still ramping up on the beta gets a
+*    trimmed model catalog (flagship models are listed but `enabled: false` on `/v1/models`).
+*    They can request access to more models.
+*
+* This is deliberately phrased for the user: it never mentions account "verification" or any
+* other internal gating mechanism.
+*/
 /**
- * `BillingSubscriptionType` values that mean the account is on a Free plan (the gateway
- * won't serve requests). Everything else — `launch`, `scale`, `business`, the `*_v3`
- * variants, marketplace plans — is treated as paid.
- */
-const FREE_SUBSCRIPTION_TYPES = new Set(["free_v2", "free_v3"]);
+* `BillingSubscriptionType` values that mean the account is on a Free plan (the gateway
+* won't serve requests). Everything else — `launch`, `scale`, `business`, the `*_v3`
+* variants, marketplace plans — is treated as paid.
+*/
+const FREE_SUBSCRIPTION_TYPES = /* @__PURE__ */ new Set(["free_v2", "free_v3"]);
 /**
- * The Neon Console billing page to upgrade a Free-plan account so the gateway can serve. It's
- * org-scoped when the project belongs to an org; projects on a personal account (which is
- * where Free plans usually live) have no org id, so we fall back to the account-level page.
- */
-export const aiGatewayUpgradeUrl = (orgId) => orgId
-    ? `https://console.neon.tech/app/${orgId}/billing`
-    : "https://console.neon.tech/app/billing";
+* The Neon Console billing page to upgrade a Free-plan account so the gateway can serve. It's
+* org-scoped when the project belongs to an org; projects on a personal account (which is
+* where Free plans usually live) have no org id, so we fall back to the account-level page.
+*/
+const aiGatewayUpgradeUrl = (orgId) => orgId ? `https://console.neon.tech/app/${orgId}/billing` : "https://console.neon.tech/app/billing";
 /**
- * The branch's AI Gateway page in the Neon Console — where a paid user with a reduced model
- * set requests access to more models. It's branch-scoped, so it's built from the linked
- * project and branch ids.
- */
-export const aiGatewayModelsUrl = (projectId, branchId) => `https://console.neon.tech/app/projects/${projectId}/branches/${branchId}/ai-gateway`;
-export const isFreePlan = (subscriptionType) => subscriptionType !== undefined &&
-    FREE_SUBSCRIPTION_TYPES.has(subscriptionType);
+* The branch's AI Gateway page in the Neon Console — where a paid user with a reduced model
+* set requests access to more models. It's branch-scoped, so it's built from the linked
+* project and branch ids.
+*/
+const aiGatewayModelsUrl = (projectId, branchId) => `https://console.neon.tech/app/projects/${projectId}/branches/${branchId}/ai-gateway`;
+const isFreePlan = (subscriptionType) => subscriptionType !== void 0 && FREE_SUBSCRIPTION_TYPES.has(subscriptionType);
 /**
- * Whether the model catalog includes at least one flagship model enabled. Flagship models
- * (Anthropic Opus, OpenAI Codex / `*-pro`) are the first to be held back for an account still
- * ramping up on the beta, so their total absence from a non-empty enabled set is the signal
- * that the account has a reduced model set. Matched by id substring so it survives model
- * version bumps (e.g. `claude-opus-4-8`).
- */
-export const hasFlagshipModels = (modelIds) => modelIds.some((id) => id.includes("opus") || id.includes("codex") || id.endsWith("-pro"));
+* Whether the model catalog includes at least one flagship model enabled. Flagship models
+* (Anthropic Opus, OpenAI Codex / `*-pro`) are the first to be held back for an account still
+* ramping up on the beta, so their total absence from a non-empty enabled set is the signal
+* that the account has a reduced model set. Matched by id substring so it survives model
+* version bumps (e.g. `claude-opus-4-8`).
+*/
+const hasFlagshipModels = (modelIds) => modelIds.some((id) => id.includes("opus") || id.includes("codex") || id.endsWith("-pro"));
 /**
- * The message shown when a `neon.ts` that enables the AI Gateway is applied on a Free plan.
- * Provisioning is refused up front (see {@link assertAiGatewayProvisionable}) because the
- * gateway won't serve model requests until the account is on a paid plan. `upgradeUrl` is the
- * org-scoped Console billing page (see {@link aiGatewayUpgradeUrl}).
- */
-export const freePlanBlockMessage = (upgradeUrl) => "This neon.ts enables the AI Gateway, which isn't available on the Free plan — the " +
-    "gateway won't serve model requests. Upgrade to a paid plan and re-run, or remove " +
-    `\`preview.aiGateway\` from neon.ts. Upgrade here: ${upgradeUrl}`;
+* The message shown when a `neon.ts` that enables the AI Gateway is applied on a Free plan.
+* Provisioning is refused up front (see {@link assertAiGatewayProvisionable}) because the
+* gateway won't serve model requests until the account is on a paid plan. `upgradeUrl` is the
+* org-scoped Console billing page (see {@link aiGatewayUpgradeUrl}).
+*/
+const freePlanBlockMessage = (upgradeUrl) => `This neon.ts enables the AI Gateway, which isn't available on the Free plan — the gateway won't serve model requests. Upgrade to a paid plan and re-run, or remove \`preview.aiGateway\` from neon.ts. Upgrade here: ${upgradeUrl}`;
 /**
- * Build the AI Gateway courtesy notice for an account's plan and (optionally) its live model
- * catalog, or `null` when nothing needs saying.
- *
- * `modelIds` is `undefined` when the catalog wasn't probed (e.g. a dry-run `plan`, or a probe
- * that failed); in that case only the plan-based (Free) notice can be produced — never a
- * false "reduced models" warning. `upgradeUrl` is the org-scoped Console billing page
- * (Free notice); `moreModelsUrl` is the branch's Console AI Gateway page
- * (see {@link aiGatewayModelsUrl}), shown when the catalog is reduced.
- */
-export const buildAiGatewayNotice = ({ subscriptionType, modelIds, upgradeUrl, moreModelsUrl, }) => {
-    if (isFreePlan(subscriptionType)) {
-        return {
-            level: "warning",
-            message: "AI Gateway is enabled, but the gateway does not serve model requests on the " +
-                `Free plan. Upgrade to a paid plan to start making requests: ${upgradeUrl}`,
-        };
-    }
-    if (modelIds !== undefined &&
-        modelIds.length > 0 &&
-        !hasFlagshipModels(modelIds)) {
-        return {
-            level: "warning",
-            message: "AI Gateway is in public beta and not every model is enabled for your account " +
-                "yet, so some models are missing from the catalog. Request access to more " +
-                `models here: ${moreModelsUrl}`,
-        };
-    }
-    return null;
+* Build the AI Gateway courtesy notice for an account's plan and (optionally) its live model
+* catalog, or `null` when nothing needs saying.
+*
+* `modelIds` is `undefined` when the catalog wasn't probed (e.g. a dry-run `plan`, or a probe
+* that failed); in that case only the plan-based (Free) notice can be produced — never a
+* false "reduced models" warning. `upgradeUrl` is the org-scoped Console billing page
+* (Free notice); `moreModelsUrl` is the branch's Console AI Gateway page
+* (see {@link aiGatewayModelsUrl}), shown when the catalog is reduced.
+*/
+const buildAiGatewayNotice = ({ subscriptionType, modelIds, upgradeUrl, moreModelsUrl }) => {
+	if (isFreePlan(subscriptionType)) return {
+		level: "warning",
+		message: `AI Gateway is enabled, but the gateway does not serve model requests on the Free plan. Upgrade to a paid plan to start making requests: ${upgradeUrl}`
+	};
+	if (modelIds !== void 0 && modelIds.length > 0 && !hasFlagshipModels(modelIds)) return {
+		level: "warning",
+		message: `AI Gateway is in public beta and not every model is enabled for your account yet, so some models are missing from the catalog. Request access to more models here: ${moreModelsUrl}`
+	};
+	return null;
 };
 const isRecord = (value) => typeof value === "object" && value !== null;
 /**
- * Pull the `id`s of enabled models out of an OpenAI-compatible
- * `{ object: "list", data: [{ id, enabled, ... }] }` body. The gateway lists every model in
- * the catalog but marks ones the account can't serve yet with `enabled: false`; only the
- * enabled set is used to detect a reduced catalog.
- */
-export const extractEnabledModelIds = (body) => {
-    if (!isRecord(body) || !Array.isArray(body.data))
-        return null;
-    const ids = [];
-    for (const entry of body.data) {
-        if (isRecord(entry) &&
-            typeof entry.id === "string" &&
-            entry.enabled === true) {
-            ids.push(entry.id);
-        }
-    }
-    return ids;
+* Pull the `id`s of enabled models out of an OpenAI-compatible
+* `{ object: "list", data: [{ id, enabled, ... }] }` body. The gateway lists every model in
+* the catalog but marks ones the account can't serve yet with `enabled: false`; only the
+* enabled set is used to detect a reduced catalog.
+*/
+const extractEnabledModelIds = (body) => {
+	if (!isRecord(body) || !Array.isArray(body.data)) return null;
+	const ids = [];
+	for (const entry of body.data) if (isRecord(entry) && typeof entry.id === "string" && entry.enabled === true) ids.push(entry.id);
+	return ids;
 };
 /**
- * `GET {baseUrl}/v1/models` → the enabled model ids, or `null` if the catalog can't be read
- * (network / HTTP / parse failure). Returning `null` keeps the notice silent rather than
- * risking a false "reduced models" warning. `/v1/models` is served only on the unified
- * dialect (the `/openai/v1` Responses dialect returns 404).
- */
-export const fetchGatewayModelIds = async (baseUrl, token) => {
-    try {
-        const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/v1/models`, {
-            headers: { Authorization: `Bearer ${token}` },
-        });
-        if (!res.ok)
-            return null;
-        return extractEnabledModelIds(await res.json());
-    }
-    catch {
-        return null;
-    }
+* `GET {baseUrl}/v1/models` → the enabled model ids, or `null` if the catalog can't be read
+* (network / HTTP / parse failure). Returning `null` keeps the notice silent rather than
+* risking a false "reduced models" warning. `/v1/models` is served only on the unified
+* dialect (the `/openai/v1` Responses dialect returns 404).
+*/
+const fetchGatewayModelIds = async (baseUrl, token) => {
+	try {
+		const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/v1/models`, { headers: { Authorization: `Bearer ${token}` } });
+		if (!res.ok) return null;
+		return extractEnabledModelIds(await res.json());
+	} catch {
+		return null;
+	}
 };
 /**
- * Refuse to provision the AI Gateway on a Free plan. Called before the `neon.ts` lifecycle
- * commands provision a branch (`config apply` / `deploy`, `checkout`), so a Free-plan user
- * gets a clear "upgrade first" error instead of a credential that can't serve requests.
- *
- * Best-effort on the plan lookup: if the plan can't be determined (network / API failure) we
- * do NOT block, so a transient error never wrongly refuses a paid user's deploy. Only a
- * positively-identified Free plan throws.
- */
-export const assertAiGatewayProvisionable = async (params) => {
-    let subscriptionType;
-    let orgId;
-    try {
-        const { data } = await params.apiClient.getProject(params.projectId);
-        subscriptionType = data.project.owner?.subscription_type;
-        orgId = data.project.org_id ?? undefined;
-    }
-    catch {
-        return; // Can't determine the plan — don't block.
-    }
-    if (isFreePlan(subscriptionType)) {
-        throw new Error(freePlanBlockMessage(aiGatewayUpgradeUrl(orgId)));
-    }
+* Refuse to provision the AI Gateway on a Free plan. Called before the `neon.ts` lifecycle
+* commands provision a branch (`config apply` / `deploy`, `checkout`), so a Free-plan user
+* gets a clear "upgrade first" error instead of a credential that can't serve requests.
+*
+* Best-effort on the plan lookup: if the plan can't be determined (network / API failure) we
+* do NOT block, so a transient error never wrongly refuses a paid user's deploy. Only a
+* positively-identified Free plan throws.
+*/
+const assertAiGatewayProvisionable = async (params) => {
+	let subscriptionType;
+	let orgId;
+	try {
+		const { data } = await params.apiClient.getProject(params.projectId);
+		subscriptionType = data.project.owner?.subscription_type;
+		orgId = data.project.org_id ?? void 0;
+	} catch {
+		return;
+	}
+	if (isFreePlan(subscriptionType)) throw new Error(freePlanBlockMessage(aiGatewayUpgradeUrl(orgId)));
 };
 /**
- * Resolve the account's plan (and, when gateway credentials are on hand, its live model
- * catalog) and print the AI Gateway courtesy notice — used by the `neon.ts` lifecycle and
- * `env pull` whenever a branch has the gateway enabled.
- *
- * Pass `gateway` (base URL + token) to enable the reduced-model-set check; omit it (e.g. a
- * dry-run `plan`) to get only the Free-plan notice. This is best-effort: any failure while
- * fetching the plan or catalog is swallowed so it can never break the underlying command.
- */
-export const warnAiGateway = async (params) => {
-    try {
-        const { data } = await params.apiClient.getProject(params.projectId);
-        const subscriptionType = data.project.owner?.subscription_type;
-        const orgId = data.project.org_id ?? undefined;
-        const modelIds = params.gateway
-            ? ((await fetchGatewayModelIds(params.gateway.baseUrl, params.gateway.token)) ?? undefined)
-            : undefined;
-        const notice = buildAiGatewayNotice({
-            subscriptionType,
-            modelIds,
-            upgradeUrl: aiGatewayUpgradeUrl(orgId),
-            moreModelsUrl: aiGatewayModelsUrl(params.projectId, params.branchId),
-        });
-        if (notice)
-            log.warning(notice.message);
-    }
-    catch {
-        // A courtesy notice must never break the command that triggered it.
-    }
+* Resolve the account's plan (and, when gateway credentials are on hand, its live model
+* catalog) and print the AI Gateway courtesy notice — used by the `neon.ts` lifecycle and
+* `env pull` whenever a branch has the gateway enabled.
+*
+* Pass `gateway` (base URL + token) to enable the reduced-model-set check; omit it (e.g. a
+* dry-run `plan`) to get only the Free-plan notice. This is best-effort: any failure while
+* fetching the plan or catalog is swallowed so it can never break the underlying command.
+*/
+const warnAiGateway = async (params) => {
+	try {
+		const { data } = await params.apiClient.getProject(params.projectId);
+		const subscriptionType = data.project.owner?.subscription_type;
+		const orgId = data.project.org_id ?? void 0;
+		const modelIds = params.gateway ? await fetchGatewayModelIds(params.gateway.baseUrl, params.gateway.token) ?? void 0 : void 0;
+		const notice = buildAiGatewayNotice({
+			subscriptionType,
+			modelIds,
+			upgradeUrl: aiGatewayUpgradeUrl(orgId),
+			moreModelsUrl: aiGatewayModelsUrl(params.projectId, params.branchId)
+		});
+		if (notice) log.warning(notice.message);
+	} catch {}
 };
+//#endregion
+export { aiGatewayModelsUrl, aiGatewayUpgradeUrl, assertAiGatewayProvisionable, buildAiGatewayNotice, extractEnabledModelIds, fetchGatewayModelIds, freePlanBlockMessage, hasFlagshipModels, isFreePlan, warnAiGateway };

package/dist/utils/api_enums.js

@@ -1,33 +1,26 @@
-// Runtime enum-like constants for Neon API string unions.
-//
-// `@neondatabase/api-client` generated TypeScript `enum`s (real runtime objects)
-// for fields like the compute endpoint type. `@neon/sdk` instead models these as
-// plain string-literal union *types*, which have no runtime value — so code that
-// read `EndpointType.ReadWrite` or `Object.values(EndpointType)` no longer works.
-//
-// These `as const` objects restore that runtime surface, and each is paired with
-// a same-named type whose union is identical to the corresponding `@neon/sdk`
-// type, so values stay assignable in both directions.
-export const EndpointType = {
-    ReadOnly: "read_only",
-    ReadWrite: "read_write",
+//#region src/utils/api_enums.ts
+const EndpointType = {
+	ReadOnly: "read_only",
+	ReadWrite: "read_write"
 };
-export const NeonAuthOauthProviderId = {
-    Google: "google",
-    Github: "github",
-    Microsoft: "microsoft",
-    Vercel: "vercel",
+const NeonAuthOauthProviderId = {
+	Google: "google",
+	Github: "github",
+	Microsoft: "microsoft",
+	Vercel: "vercel"
 };
-export const NeonAuthOauthProviderType = {
-    Standard: "standard",
-    Shared: "shared",
+const NeonAuthOauthProviderType = {
+	Standard: "standard",
+	Shared: "shared"
 };
-export const NeonAuthSupportedAuthProvider = {
-    Mock: "mock",
-    Stack: "stack",
-    BetterAuth: "better_auth",
+const NeonAuthSupportedAuthProvider = {
+	Mock: "mock",
+	Stack: "stack",
+	BetterAuth: "better_auth"
 };
-export const NeonAuthEmailVerificationMethod = {
-    Link: "link",
-    Otp: "otp",
+const NeonAuthEmailVerificationMethod = {
+	Link: "link",
+	Otp: "otp"
 };
+//#endregion
+export { EndpointType, NeonAuthEmailVerificationMethod, NeonAuthOauthProviderId, NeonAuthOauthProviderType, NeonAuthSupportedAuthProvider };

package/dist/utils/auth.js

@@ -1,5 +1,11 @@
-export const extendTokenSet = (tokenSet) => {
-    const exp = new Date();
-    exp.setSeconds(exp.getSeconds() + (tokenSet.expires_in ?? 0));
-    return { ...tokenSet, expires_at: exp.getTime() };
+//#region src/utils/auth.ts
+const extendTokenSet = (tokenSet) => {
+	const exp = /* @__PURE__ */ new Date();
+	exp.setSeconds(exp.getSeconds() + (tokenSet.expires_in ?? 0));
+	return {
+		...tokenSet,
+		expires_at: exp.getTime()
+	};
 };
+//#endregion
+export { extendTokenSet };

package/dist/utils/branch_notice.js

@@ -1,22 +1,23 @@
-import chalk from "chalk";
 import { log } from "../log.js";
+import chalk from "chalk";
+//#region src/utils/branch_notice.ts
 /**
- * Print a one-line "this command is targeting <branch>" notice to **stderr** so
- * the user can sanity-check they're acting on the branch they think they are —
- * before a `status` / `plan` / `apply` / `env pull` does its work. This is the
- * cheap guardrail that catches "I planned against the wrong branch" / "I pulled
- * env from the wrong branch" before it bites.
- *
- * - Skipped for machine-readable output (`--output json|yaml`) so it never has
- *   to be reasoned about by a script; it's stderr-only regardless, keeping
- *   `--output table` stdout clean for piping too.
- * - `verb` is the leading phrase, e.g. `'Planning against branch'` →
- *   `→ Planning against branch main (br-…)`.
- */
-export const announceTargetBranch = (props, branch, verb) => {
-    if (props.output === "json" || props.output === "yaml") {
-        return;
-    }
-    const suffix = branch.usedDefault ? chalk.dim(" · project default") : "";
-    log.info("%s %s %s %s%s", chalk.dim("→"), verb, chalk.cyan.bold(branch.branchName), chalk.dim(`(${branch.branchId})`), suffix);
+* Print a one-line "this command is targeting <branch>" notice to **stderr** so
+* the user can sanity-check they're acting on the branch they think they are —
+* before a `status` / `plan` / `apply` / `env pull` does its work. This is the
+* cheap guardrail that catches "I planned against the wrong branch" / "I pulled
+* env from the wrong branch" before it bites.
+*
+* - Skipped for machine-readable output (`--output json|yaml`) so it never has
+*   to be reasoned about by a script; it's stderr-only regardless, keeping
+*   `--output table` stdout clean for piping too.
+* - `verb` is the leading phrase, e.g. `'Planning against branch'` →
+*   `→ Planning against branch main (br-…)`.
+*/
+const announceTargetBranch = (props, branch, verb) => {
+	if (props.output === "json" || props.output === "yaml") return;
+	const suffix = branch.usedDefault ? chalk.dim(" · project default") : "";
+	log.info("%s %s %s %s%s", chalk.dim("→"), verb, chalk.cyan.bold(branch.branchName), chalk.dim(`(${branch.branchId})`), suffix);
 };
+//#endregion
+export { announceTargetBranch };

package/dist/utils/branch_picker.js

@@ -1,103 +1,97 @@
-import prompts from "prompts";
-import { retryOnLock } from "../api.js";
 import { isCi } from "../env.js";
 import { log } from "../log.js";
+import { retryOnLock } from "../api.js";
 import { EndpointType } from "./api_enums.js";
+import prompts from "prompts";
+//#region src/utils/branch_picker.ts
 /** Sentinel `value` for the "create a new branch" choice (no branch id can collide). */
 const CREATE_BRANCH_CHOICE = Symbol("create-branch");
 /**
- * Render a branch's display name with the same word labels as `neonctl branch list`
- * (`[default]`, `[protected]`) instead of symbols, so the picker reads clearly.
- */
+* Render a branch's display name with the same word labels as `neonctl branch list`
+* (`[default]`, `[protected]`) instead of symbols, so the picker reads clearly.
+*/
 const branchLabel = (branch) => {
-    const labels = [];
-    if (branch.default) {
-        labels.push("[default]");
-    }
-    if (branch.protected) {
-        labels.push("[protected]");
-    }
-    labels.push(branch.name);
-    return labels.join(" ");
+	const labels = [];
+	if (branch.default) labels.push("[default]");
+	if (branch.protected) labels.push("[protected]");
+	labels.push(branch.name);
+	return labels.join(" ");
 };
 /**
- * Prompt the user to pick a branch from `branches`, with a "＋ Create a new branch…" option
- * pinned to the top (mirroring the project/org pickers). The default selection is the
- * project's default branch (the create option sits at index 0, so the default index is
- * offset by one).
- *
- * Throws `opts.nonInteractiveMessage` when there is no TTY (or in CI): the caller knows the
- * right guidance for its command, so the message is supplied rather than hard-coded here.
- */
-export const pickBranchInteractively = async (branches, opts) => {
-    if (isCi() || !process.stdout.isTTY) {
-        throw new Error(opts.nonInteractiveMessage);
-    }
-    const defaultBranchIndex = branches.findIndex((b) => b.default);
-    const initial = defaultBranchIndex >= 0 ? defaultBranchIndex + 1 : 0;
-    const { choice } = await prompts({
-        type: "select",
-        name: "choice",
-        message: opts.message,
-        choices: [
-            { title: "＋ Create a new branch…", value: CREATE_BRANCH_CHOICE },
-            ...branches.map((b) => ({
-                title: `${branchLabel(b)} (${b.id})`,
-                value: b.id,
-            })),
-        ],
-        initial,
-    });
-    if (choice === undefined) {
-        throw new Error("Aborted: no branch selected.");
-    }
-    if (choice === CREATE_BRANCH_CHOICE) {
-        return { kind: "create", name: await promptNewBranchName(branches) };
-    }
-    return { kind: "existing", branchId: choice };
+* Prompt the user to pick a branch from `branches`, with a "＋ Create a new branch…" option
+* pinned to the top (mirroring the project/org pickers). The default selection is the
+* project's default branch (the create option sits at index 0, so the default index is
+* offset by one).
+*
+* Throws `opts.nonInteractiveMessage` when there is no TTY (or in CI): the caller knows the
+* right guidance for its command, so the message is supplied rather than hard-coded here.
+*/
+const pickBranchInteractively = async (branches, opts) => {
+	if (isCi() || !process.stdout.isTTY) throw new Error(opts.nonInteractiveMessage);
+	const defaultBranchIndex = branches.findIndex((b) => b.default);
+	const initial = defaultBranchIndex >= 0 ? defaultBranchIndex + 1 : 0;
+	const { choice } = await prompts({
+		type: "select",
+		name: "choice",
+		message: opts.message,
+		choices: [{
+			title: "＋ Create a new branch…",
+			value: CREATE_BRANCH_CHOICE
+		}, ...branches.map((b) => ({
+			title: `${branchLabel(b)} (${b.id})`,
+			value: b.id
+		}))],
+		initial
+	});
+	if (choice === void 0) throw new Error("Aborted: no branch selected.");
+	if (choice === CREATE_BRANCH_CHOICE) return {
+		kind: "create",
+		name: await promptNewBranchName(branches)
+	};
+	return {
+		kind: "existing",
+		branchId: choice
+	};
 };
 /**
- * Prompt for a new branch name, rejecting empty input and names already taken on the
- * project (so we never silently select a different, pre-existing branch).
- */
-export const promptNewBranchName = async (branches) => {
-    const existing = new Set(branches.map((b) => b.name));
-    const { name } = await prompts({
-        type: "text",
-        name: "name",
-        message: "New branch name:",
-        validate: (value) => {
-            const trimmed = value.trim();
-            if (trimmed === "")
-                return "Branch name cannot be empty.";
-            if (existing.has(trimmed))
-                return `A branch named "${trimmed}" already exists.`;
-            return true;
-        },
-    });
-    const trimmed = typeof name === "string" ? name.trim() : "";
-    if (trimmed === "") {
-        throw new Error("Aborted: no branch name provided.");
-    }
-    return trimmed;
+* Prompt for a new branch name, rejecting empty input and names already taken on the
+* project (so we never silently select a different, pre-existing branch).
+*/
+const promptNewBranchName = async (branches) => {
+	const existing = new Set(branches.map((b) => b.name));
+	const { name } = await prompts({
+		type: "text",
+		name: "name",
+		message: "New branch name:",
+		validate: (value) => {
+			const trimmed = value.trim();
+			if (trimmed === "") return "Branch name cannot be empty.";
+			if (existing.has(trimmed)) return `A branch named "${trimmed}" already exists.`;
+			return true;
+		}
+	});
+	const trimmed = typeof name === "string" ? name.trim() : "";
+	if (trimmed === "") throw new Error("Aborted: no branch name provided.");
+	return trimmed;
 };
 /**
- * Create a branch with the same defaults as `neonctl branch create --name <name>`:
- * branched from the project's default branch with a read-write compute endpoint. Returns
- * the new branch id.
- */
-export const createBranch = async (apiClient, projectId, name, branches) => {
-    const defaultBranch = branches.find((b) => b.default);
-    if (!defaultBranch) {
-        throw new Error("No default branch found");
-    }
-    const { data } = await retryOnLock(() => apiClient.createProjectBranch(projectId, {
-        branch: { name, parent_id: defaultBranch.id },
-        endpoints: [{ type: EndpointType.ReadWrite }],
-    }));
-    if (defaultBranch.protected) {
-        log.warning("The parent branch is protected; a unique role password has been generated for the new branch.");
-    }
-    log.info("Created branch %s (%s).", data.branch.name, data.branch.id);
-    return data.branch.id;
+* Create a branch with the same defaults as `neonctl branch create --name <name>`:
+* branched from the project's default branch with a read-write compute endpoint. Returns
+* the new branch id.
+*/
+const createBranch = async (apiClient, projectId, name, branches) => {
+	const defaultBranch = branches.find((b) => b.default);
+	if (!defaultBranch) throw new Error("No default branch found");
+	const { data } = await retryOnLock(() => apiClient.createProjectBranch(projectId, {
+		branch: {
+			name,
+			parent_id: defaultBranch.id
+		},
+		endpoints: [{ type: EndpointType.ReadWrite }]
+	}));
+	if (defaultBranch.protected) log.warning("The parent branch is protected; a unique role password has been generated for the new branch.");
+	log.info("Created branch %s (%s).", data.branch.name, data.branch.id);
+	return data.branch.id;
 };
+//#endregion
+export { createBranch, pickBranchInteractively, promptNewBranchName };