neon 8.11.1 → 8.11.2

package/dist/commands/config.js

@@ -1,1113 +1 @@
-import { t as __exportAll } from "../_chunks/rolldown-runtime-8H4AJuhK.js";
-import { isCi, isInteractiveTerminal } from "../env.js";
-import { log } from "../log.js";
-import { getApiClient } from "../api.js";
-import { contextBranch, ensureDirectoryGitignored, readContextFile } from "../context.js";
-import { getCliName } from "../utils/cli_name.js";
-import { NEON_SERVICES, NEON_SERVICE_LABELS, deprecatedServiceMessage, servicesFlagValue, servicesOption } from "../neon_services.js";
-import { FUNCTION_FILENAME, FUNCTION_SLUG, FUNCTION_TEMPLATE, REQUIRED_PACKAGES, parseConfigInitServices, renderFunctionSource, renderNeonConfig, renderNeonConfigFromView } from "../config_template.js";
-import { TYPESCRIPT_EXTENSION, asRelativeModulePath, editNeonConfig } from "../config_edit.js";
-import { toNeonConfigView } from "../config_format.js";
-import { declaredNeonServices } from "../config_services.js";
-import { loadProjectConfig, neonConfigFilename, projectConfigPath, projectDir } from "../project.js";
-import { loadEnvFileIntoProcess } from "../env_file.js";
-import { formatInstallCommand, installArgs, resolvePackageManager, runCommand } from "../utils/package_manager.js";
-import { writer } from "../writer.js";
-import { fillSingleProject, resolveBranchRef } from "../utils/enrichers.js";
-import { assertAiGatewayProvisionable, warnAiGateway } from "../utils/ai_gateway_notice.js";
-import { announceTargetBranch } from "../utils/branch_notice.js";
-import { renderAppliedChanges, renderBranchSettingConflicts, renderCustomDomainFollowup } from "../utils/config_diff.js";
-import { bundleEntry } from "../utils/esbuild.js";
-import { FUNCTION_SLUG_PATTERN, deriveFunctionSlug } from "../utils/function_slug.js";
-import { readGitContext } from "../utils/git.js";
-import { resolveHookEnv, runDeployAfterHook, runDeployBeforeHook } from "../utils/hooks.js";
-import { pickServicesInteractively } from "../utils/service_picker.js";
-import { zipBundle } from "../utils/zip.js";
-import { autoPullEnvAfterPin } from "./env.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-import chalk from "chalk";
-import { defineConfig, packagesToStage, previewGaWarningForConfig, resolveConfig } from "@neon/config";
-import { PushAbortedError, PushConflictError, apply, assertZipWithinLimits, bundleAsIs, createBranch, describeNativeFinding, enforceLimits, findUndeclaredNativePackages, inspect, isPartialBranchCreateError, plan, resolveEsbuildEntry, traceNativePackages, zipFunctionBundle } from "@neon/config-runtime";
-//#region src/commands/config.ts
-var config_exports = /* @__PURE__ */ __exportAll({
-	ConfigInstallFailed: () => ConfigInstallFailed,
-	addCmd: () => addCmd,
-	applyCmd: () => applyCmd,
-	applyFlags: () => applyFlags,
-	applyPolicyOnCreate: () => applyPolicyOnCreate,
-	builder: () => builder,
-	command: () => command,
-	createBranchFromPolicyOnCheckout: () => createBranchFromPolicyOnCheckout,
-	describe: () => describe,
-	ensureConfigPackages: () => ensureConfigPackages,
-	envFlag: () => envFlag,
-	envPullFlag: () => envPullFlag,
-	handler: () => handler,
-	initCmd: () => initCmd,
-	installCommandFrom: () => installCommandFrom,
-	missingDependencies: () => missingDependencies,
-	planCmd: () => planCmd,
-	status: () => status
-});
-const neonctlBundler = async (fn) => {
-	if (typeof fn.bundler === "function") return zipFunctionBundle(fn.slug, await fn.bundler(fn));
-	if (fn.bundler === "none") return zipFunctionBundle(fn.slug, await bundleAsIs(fn));
-	const entry = await resolveEsbuildEntry(fn.source);
-	const externalPackages = fn.externalPackages ?? [];
-	const { files, metafile, warnings } = await bundleEntry(entry, { externalPackages: externalPackages.map((pkg) => pkg.name) });
-	for (const warning of warnings) log.warning(warning);
-	for (const finding of findUndeclaredNativePackages({
-		metafile,
-		declared: externalPackages.map((pkg) => pkg.name),
-		projectDir: dirname(entry)
-	})) log.warning(describeNativeFinding(fn.slug, finding));
-	const staged = packagesToStage(externalPackages);
-	if (staged.length === 0) return zipBundle(files);
-	const traced = await traceNativePackages({
-		slug: fn.slug,
-		packages: staged,
-		projectDir: dirname(entry)
-	});
-	for (const warning of traced.warnings) log.warning(warning);
-	const entries = {
-		...files,
-		...traced.entries
-	};
-	enforceLimits(fn.slug, entries);
-	const zip = zipBundle(entries);
-	assertZipWithinLimits(fn.slug, zip, entries);
-	return zip;
-};
-const reasonAllowsUpdateExisting = (reason) => reason.includes("Pass `updateExisting: true`");
-const INSPECT_FIELDS = [
-	"project",
-	"branch",
-	"config"
-];
-const envFlag = { env: {
-	describe: "Path to a .env file to load into the environment before evaluating neon.ts so Function env values resolve from it. Existing env vars are not overridden. Function env values that read process.env must be set in this file or the environment.",
-	type: "string"
-} };
-/** Apply-only flags, exported so `deploy` can reuse the exact same surface. */
-const applyFlags = {
-	"update-existing": {
-		describe: "Override branch settings that differ from neon.ts without asking",
-		type: "boolean",
-		default: false
-	},
-	"allow-protected": {
-		describe: "Apply to a branch marked protected on Neon without asking",
-		type: "boolean",
-		default: false
-	},
-	yes: {
-		alias: "y",
-		describe: "Answer yes to every confirmation: --update-existing and --allow-protected",
-		type: "boolean",
-		default: false
-	}
-};
-/**
-* `--env-pull` for `config apply` / `deploy` (shared so both expose the identical surface).
-* After a successful apply, the branch's Neon env vars are written to a local `.env` — the
-* same bundled convenience as `link` / `checkout`. On by default; `--no-env-pull` opts out.
-*/
-const envPullFlag = { "env-pull": {
-	describe: "Pull the branch's Neon env vars (DATABASE_URL, …) into a local .env after a successful apply. On by default; use --no-env-pull to skip (e.g. when injecting env at runtime with `neon-env run` / `neon dev`).",
-	type: "boolean",
-	default: true
-} };
-/** package.json fields a dependency can be declared in. */
-const DEPENDENCY_FIELDS = [
-	"dependencies",
-	"devDependencies",
-	"peerDependencies",
-	"optionalDependencies"
-];
-var ConfigInstallFailed = class extends Error {
-	constructor(command) {
-		super("Could not install the Neon dependencies.");
-		this.name = "ConfigInstallFailed";
-		this.command = command;
-	}
-};
-const isRecord = (value) => typeof value === "object" && value !== null;
-/**
-* The {@link REQUIRED_PACKAGES} not already declared in the project's package.json
-* (any dependency field). A missing or malformed package.json means none are
-* declared, so all are reported missing.
-*/
-const missingDependencies = (cwd) => {
-	const declared = /* @__PURE__ */ new Set();
-	const pkgPath = join(cwd, "package.json");
-	if (existsSync(pkgPath)) {
-		let parsed;
-		try {
-			parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
-		} catch {
-			parsed = void 0;
-		}
-		if (isRecord(parsed)) for (const field of DEPENDENCY_FIELDS) {
-			const deps = parsed[field];
-			if (isRecord(deps)) for (const name of Object.keys(deps)) declared.add(name);
-		}
-	}
-	return REQUIRED_PACKAGES.filter((pkg) => !declared.has(pkg));
-};
-/**
-* Which services the scaffolded policy declares. `--services` always wins so a script or an
-* agent gets the same result without a TTY; an injected picker is next (tests); the real
-* picker only runs on an interactive terminal outside CI. Everything else scaffolds the
-* starter policy, which is what `config init` has always written.
-*/
-const resolveServices = async (props) => {
-	if (props.services !== void 0) return parseConfigInitServices(props.services, (used, canonical) => log.warning(deprecatedServiceMessage(used, canonical)));
-	if (props.pickServices) return props.pickServices();
-	if (isCi() || !process.stdout.isTTY) return [];
-	return pickServicesInteractively();
-};
-/**
-* Write the hello-world handler the scaffolded `functions` entry points at. An
-* existing `hello.ts` is left alone: the declared function keeps pointing at it, which is the
-* better outcome than overwriting a file the user wrote.
-*/
-const scaffoldFunction = (cwd) => {
-	const path = join(cwd, FUNCTION_FILENAME);
-	if (existsSync(path)) {
-		log.info("Found an existing %s — leaving it untouched; the %s function points at it.", FUNCTION_FILENAME, FUNCTION_SLUG);
-		return;
-	}
-	writeFileSync(path, FUNCTION_TEMPLATE);
-	log.info("Created %s — the source of the %s function.", FUNCTION_FILENAME, FUNCTION_SLUG);
-};
-/**
-* Read a branch's live state and render it as a `neon.ts`. The read goes through the same
-* {@link liveConfigView} as `config status`, so a seeded policy declares exactly what
-* `config status --config-json` reports — including what it cannot report (see
-* {@link renderNeonConfigFromView}).
-*/
-const seedFromBranch = async (props) => {
-	const { apiClient, projectId } = props;
-	if (!apiClient || !projectId) throw new Error("--from-branch needs a project. Pass --project-id, or run `neon link` to pin one in .neon.");
-	const ref = await resolveBranchRef({
-		apiClient,
-		projectId,
-		...props.branch !== void 0 ? { branch: props.branch } : {}
-	});
-	if (ref.usedDefault) log.info("No branch pinned or passed — seeding from the project's default branch %s.", ref.branchName);
-	const { live, view } = await liveConfigView({
-		projectId,
-		branchId: ref.branchId,
-		...props.apiKey ? { apiKey: props.apiKey } : {},
-		...props.apiHost ? { apiHost: props.apiHost } : {},
-		...props.runtimeApi ? { runtimeApi: props.runtimeApi } : {}
-	});
-	return {
-		...renderNeonConfigFromView(view, live.branch.name),
-		branchName: live.branch.name
-	};
-};
-/** The install command to print, prefixed with a `cd` when the project is not the cwd. */
-const installCommandFrom = (dir, pm, missing, options) => {
-	const command = formatInstallCommand(pm, [...missing], options);
-	const rel = relative(process.cwd(), dir);
-	if (rel === "") return command;
-	const target = rel.length <= dir.length ? rel : dir;
-	return `cd ${shellQuote(target)} && ${command}`;
-};
-/** Install the config packages the project is missing, or say how to. */
-const ensureConfigPackages = async (cwd, props) => {
-	const run = props.run ?? runCommand;
-	const missing = missingDependencies(cwd);
-	if (missing.length === 0) {
-		if (!props.silent) log.info("%s are already installed.", REQUIRED_PACKAGES.join(" and "));
-		return;
-	}
-	const pm = props.packageManager ?? resolvePackageManager(cwd);
-	const args = installArgs(pm, missing);
-	const installHint = installCommandFrom(cwd, pm, missing);
-	if (props.install === false) {
-		if (!props.silent) log.info("Install the Neon config packages to use neon.ts: %s", installHint);
-		return;
-	}
-	const pkgPath = join(cwd, "package.json");
-	if (!existsSync(pkgPath)) {
-		writeFileSync(pkgPath, "{}\n");
-		if (!props.silent) log.info("Created package.json.");
-	}
-	ensureDirectoryGitignored(join(cwd, "node_modules"));
-	if (!props.silent) log.info("Installing %s with %s…", missing.join(", "), pm);
-	if (!await run(pm, args, cwd)) {
-		if (props.requireInstall) throw new ConfigInstallFailed(installHint);
-		log.warning("Could not install the config packages automatically. Run by hand: %s", installHint);
-	}
-};
-/**
-* Scaffold a `neon.ts` policy and make sure the Neon config packages are
-* installed, so a project can go straight to `neon config plan` / `apply`.
-* Local-only unless `--from-branch` is set (see {@link isConfigInit}).
-*/
-const initCmd = async (props) => {
-	const cwd = props.cwd ?? projectDir(props.contextFile ? { contextFile: props.contextFile } : {});
-	const existing = neonConfigFilename(cwd);
-	if (existing) {
-		if (!props.silent) {
-			log.info("Found an existing %s — leaving it untouched.", existing);
-			if (props.services !== void 0) log.warning("--services was ignored. To declare services in the existing %s, use `%s config add`.", existing, getCliName());
-		}
-	} else if (props.fromBranch) {
-		const { source, seeded, branchName } = await seedFromBranch(props);
-		writeFileSync(join(cwd, "neon.ts"), source);
-		if (!props.silent) {
-			if (seeded) log.info("Created neon.ts from the live state of %s.", branchName);
-			else log.info("%s declares no services and no branch settings — created neon.ts with the starter policy instead.", branchName);
-		}
-	} else {
-		const services = await resolveServices(props);
-		writeFileSync(join(cwd, "neon.ts"), renderNeonConfig(services));
-		if (!props.silent) {
-			if (services.length === 0) log.info("Created neon.ts with a starter policy.");
-			else {
-				const declared = services.map((service) => service === "realtime" ? "Realtime" : service);
-				log.info("Created neon.ts declaring %s.", declared.join(", "));
-			}
-		}
-		if (services.includes("functions")) scaffoldFunction(cwd);
-	}
-	await ensureConfigPackages(cwd, props);
-	if (!props.silent) log.info("Next: edit neon.ts, then run `neon config plan` to preview and `neon config apply`.");
-};
-const SCRIPT_EXTENSION = /\.(?:ts|mts|cts|js|mjs|cjs)$/;
-const shellQuote = (value) => /^[\w@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
-/**
-* `explicitConfig` is the `--config` the user passed. The commands suggested afterwards must
-* carry it, or they would act on the project directory's `neon.ts` instead.
-*/
-const planAdd = (target, configPath, explicitConfig) => {
-	const language = TYPESCRIPT_EXTENSION.test(configPath) ? "ts" : "js";
-	const cli = getCliName();
-	const flag = explicitConfig ? ` --config ${shellQuote(explicitConfig)}` : "";
-	const provision = `Next: \`${cli} config plan${flag}\` to preview, \`${cli} config apply${flag}\` to provision.`;
-	switch (target.kind) {
-		case "realtime": {
-			const realtime = target.allowedOrigins === void 0 ? true : { allowedOrigins: target.allowedOrigins };
-			defineConfig({ preview: { realtime } });
-			return {
-				edit: {
-					kind: "realtime",
-					enabled: true,
-					...target.allowedOrigins !== void 0 ? { allowedOrigins: target.allowedOrigins } : {}
-				},
-				next: provision
-			};
-		}
-		case "service": return {
-			edit: {
-				kind: "service",
-				service: target.service
-			},
-			next: provision
-		};
-		case "bucket":
-			if (target.name.length < 1 || target.name.length > 255) throw new Error("A bucket name must be 1-255 characters.");
-			if (target.name === "__proto__") throw new Error("\"__proto__\" cannot be used as a bucket name.");
-			return {
-				edit: {
-					kind: "bucket",
-					name: target.name,
-					access: target.access ?? "private"
-				},
-				next: provision
-			};
-		case "function": {
-			if (!FUNCTION_SLUG_PATTERN.test(target.slug)) {
-				const suggestion = deriveFunctionSlug(target.slug);
-				throw new Error(`"${target.slug}" is not a valid function slug: use 1-20 lowercase letters and digits, no hyphens.` + (suggestion ? ` Try "${suggestion}".` : ""));
-			}
-			if (target.source !== void 0 && !SCRIPT_EXTENSION.test(target.source)) throw new Error(`--source must be a .ts or .js file, got "${target.source}". Declare a directory source in neon.ts by hand.`);
-			const source = asRelativeModulePath(target.source ?? `functions/${target.slug}.${language}`);
-			return {
-				edit: {
-					kind: "function",
-					slug: target.slug,
-					name: target.name ?? target.slug,
-					source
-				},
-				sourceFile: resolve(dirname(configPath), source),
-				next: explicitConfig ? `Next: \`${cli} config apply${flag}\` to deploy.` : `Next: \`${cli} dev\` to run it locally, \`${cli} config apply\` to deploy.`
-			};
-		}
-	}
-};
-/**
-* Declare a service, feature, function, or bucket in the project's `neon.ts` with a text edit that
-* leaves the rest of the file alone, creating the file (and installing the config packages)
-* when the project has none. Local only, like `config init`.
-*/
-const addCmd = async (props) => {
-	const cwd = props.cwd ?? process.cwd();
-	const location = {
-		cwd,
-		...props.contextFile ? { contextFile: props.contextFile } : {}
-	};
-	let existing;
-	if (props.config) {
-		existing = resolve(cwd, props.config);
-		if (!existsSync(existing)) throw new Error(`--config ${props.config} does not exist.`);
-	} else existing = projectConfigPath(location);
-	const configPath = existing ?? join(projectDir(location), "neon.ts");
-	const shown = (path) => relative(cwd, path) || path;
-	const plan = planAdd(props.target, configPath, props.config);
-	const { source, changes } = editNeonConfig(existing ? readFileSync(existing, "utf8") : renderNeonConfig([]), plan.edit);
-	if (changes.length === 0) {
-		if (props.target.kind === "service" || props.target.kind === "realtime") {
-			log.info("%s already has the requested configuration; nothing to change.", shown(configPath));
-			return;
-		}
-		throw new Error(`${shown(configPath)} already declares ${props.target.kind} "${props.target.kind === "function" ? props.target.slug : props.target.name}". Edit it there, or pick another name.`);
-	}
-	if (plan.sourceFile) {
-		if (existsSync(plan.sourceFile)) log.info("Found an existing %s — leaving it untouched.", shown(plan.sourceFile));
-		else {
-			mkdirSync(dirname(plan.sourceFile), { recursive: true });
-			const slug = props.target.kind === "function" ? props.target.slug : "";
-			writeFileSync(plan.sourceFile, renderFunctionSource(slug, TYPESCRIPT_EXTENSION.test(plan.sourceFile) ? "ts" : "js"));
-			log.info("Created %s.", shown(plan.sourceFile));
-		}
-	}
-	writeFileSync(configPath, source);
-	log.info("%s %s: %s.", existing ? "Updated" : "Created", shown(configPath), changes.join(", "));
-	if (!existing) await ensureConfigPackages(dirname(configPath), props);
-	log.info("%s", plan.next);
-};
-/**
-* Options every `config add` sub-command takes. `--project-id` and `--branch` are inherited
-* from `config` but mean nothing to a command that never leaves the working tree, so they are
-* hidden from its help.
-*/
-const addSharedOptions = (yargs) => yargs.strict().options({
-	"project-id": { hidden: true },
-	branch: { hidden: true },
-	config: {
-		describe: "Path to the neon.ts to edit (defaults to the neon.ts next to .neon, or in cwd without one; created there when missing)",
-		type: "string"
-	},
-	install: {
-		describe: "Install @neon/config and @neon/env when creating neon.ts. On by default; use --no-install to just print the command.",
-		type: "boolean",
-		default: true
-	}
-});
-/** The `config add` props for a sub-command's parsed flags. */
-const addProps = (args, target) => ({
-	target,
-	install: args.install,
-	...args.config !== void 0 ? { config: args.config } : {},
-	...args.contextFile !== void 0 ? { contextFile: args.contextFile } : {}
-});
-const command = "config";
-const describe = "Manage a branch with a neon.ts policy";
-const builder = (argv) => argv.usage("$0 config <sub-command> [options]").options({
-	"project-id": {
-		describe: "Project ID",
-		type: "string"
-	},
-	branch: {
-		describe: "Branch ID or name",
-		type: "string"
-	}
-}).middleware(fillSingleProject).command("status", "Show the branch's live Neon state", (yargs) => yargs.options({
-	"config-json": {
-		describe: "Print only the branch's live config as neon.ts-shaped JSON (services + branch tuning + preview), to stdout. Useful for scripting or copying into a neon.ts.",
-		type: "boolean",
-		default: false
-	},
-	"current-branch": {
-		describe: "Print only the linked branch name from the local .neon file (no network). Exits non-zero when no branch is pinned.",
-		type: "boolean",
-		default: false
-	}
-}), (args) => status(args)).command("plan", "Show what `config apply` would change (dry run)", (yargs) => yargs.options({
-	config: {
-		describe: "Path to a neon.ts policy (defaults to the neon.ts next to .neon, or in cwd without one)",
-		type: "string"
-	},
-	...envFlag
-}), (args) => planCmd(args)).command("apply", "Apply a neon.ts policy to the branch", (yargs) => yargs.options({
-	config: {
-		describe: "Path to a neon.ts policy (defaults to the neon.ts next to .neon, or in cwd without one)",
-		type: "string"
-	},
-	...envFlag,
-	...applyFlags,
-	...envPullFlag
-}), (args) => applyCmd(args)).command("add", "Add a service, function, or bucket to neon.ts (creates it if missing)", (yargs) => yargs.command("auth", "Enable Neon Auth (auth: true)", addSharedOptions, (args) => addCmd(addProps(args, {
-	kind: "service",
-	service: "auth"
-}))).command("data-api", "Enable the Data API (dataApi: true) and Neon Auth, which the default provider requires", addSharedOptions, (args) => addCmd(addProps(args, {
-	kind: "service",
-	service: "data-api"
-}))).command("ai-gateway", "Enable the AI Gateway (aiGateway: true)", addSharedOptions, (args) => addCmd(addProps(args, {
-	kind: "service",
-	service: "ai-gateway"
-}))).command("realtime", "Enable Realtime (preview.realtime: true)", (yargs) => addSharedOptions(yargs).option("allowed-origin", {
-	describe: "Allowed browser origin (repeatable). \"*\" allows every origin",
-	type: "array",
-	string: true
-}), (args) => addCmd(addProps(args, {
-	kind: "realtime",
-	...args.allowedOrigin !== void 0 ? { allowedOrigins: args.allowedOrigin } : {}
-}))).command("function <slug>", "Declare a Neon Function and create its handler file", (yargs) => addSharedOptions(yargs).example("$0 config add function sendemail", "Creates functions/sendemail.ts and declares it").example("$0 config add function sendemail --source src/send.ts", "Declares an existing handler").positional("slug", {
-	describe: "Function slug: 1-20 lowercase letters and digits",
-	type: "string",
-	demandOption: true
-}).options({
-	name: {
-		describe: "Display name. Defaults to the slug",
-		type: "string"
-	},
-	source: {
-		describe: "Handler file, relative to neon.ts. Defaults to functions/<slug>.ts. Created when missing, left alone when it exists",
-		type: "string"
-	}
-}), (args) => addCmd(addProps(args, {
-	kind: "function",
-	slug: args.slug,
-	...args.name !== void 0 ? { name: args.name } : {},
-	...args.source !== void 0 ? { source: args.source } : {}
-}))).command("bucket <name>", "Declare an Object Storage bucket", (yargs) => addSharedOptions(yargs).example("$0 config add bucket assets --access public_read", "Declares a bucket that allows anonymous reads").positional("name", {
-	describe: "Bucket name",
-	type: "string",
-	demandOption: true
-}).options({ access: {
-	describe: "Anonymous access: private requires credentials, public_read allows anonymous reads",
-	type: "string",
-	choices: ["private", "public_read"],
-	default: "private"
-} }), (args) => addCmd(addProps(args, {
-	kind: "bucket",
-	name: args.name,
-	access: args.access
-})))).command("init", "Scaffold a neon.ts policy and install the Neon config packages", (yargs) => yargs.strict().options({
-	install: {
-		describe: "Install @neon/config and @neon/env if they're missing. On by default; use --no-install to just print the command.",
-		type: "boolean",
-		default: true
-	},
-	services: servicesOption({
-		key: "services",
-		allowed: NEON_SERVICES,
-		describe: "Services the scaffolded neon.ts declares",
-		also: "postgres alone writes the starter policy; every branch has Postgres. Omitted: pick interactively on a terminal, starter policy in CI or without a TTY."
-	}),
-	"from-branch": {
-		describe: "Seed neon.ts from a branch's live Neon state instead of asking. Uses the branch pinned in .neon, or --branch <name|id>, or the project's default branch. The only mode of `config init` that calls the Neon API.",
-		type: "boolean",
-		conflicts: "services"
-	}
-}), (args) => initCmd({
-	...args,
-	services: servicesFlagValue(args.services)
-}));
-const handler = (args) => {
-	return args;
-};
-/**
-* A branch's live state, plus that state projected into the `neon.ts`-shaped
-* {@link NeonConfigView}. Shared by `config status` and `config init --from-branch` so both
-* read the branch through one path: what `status --config-json` prints is exactly what
-* `init --from-branch` writes.
-*
-* The pulled `config` carries the branch's tuning inside a closure that JSON can't render, so
-* it is resolved against the live branch target first.
-*/
-const liveConfigView = async (opts) => {
-	const live = await inspect({
-		projectId: opts.projectId,
-		branchId: opts.branchId,
-		...opts.apiKey ? { apiKey: opts.apiKey } : {},
-		...opts.apiHost ? { apiHost: opts.apiHost } : {},
-		...opts.runtimeApi ? { api: opts.runtimeApi } : {}
-	});
-	const resolved = resolveConfig(live.config, {
-		name: live.branch.name,
-		id: live.branch.id,
-		exists: true,
-		isDefault: live.branch.isDefault,
-		isProtected: live.branch.protected,
-		...live.branch.parent ? { parentId: live.branch.parent } : {},
-		...live.branch.expiresAt ? { expiresAt: live.branch.expiresAt } : {}
-	});
-	return {
-		live,
-		view: toNeonConfigView(resolved, live.preview)
-	};
-};
-const loadEnvFileIfGiven = (env) => {
-	if (!env) return;
-	const applied = loadEnvFileIntoProcess(env);
-	log.debug("Loaded %d var(s) from %s into the environment: %s", applied.length, env, applied.join(", "));
-};
-const loadConfig = async (props) => {
-	loadEnvFileIfGiven(props.env);
-	const { config } = await loadProjectConfig({
-		contextFile: props.contextFile,
-		...props.config ? { path: props.config } : {}
-	});
-	return config;
-};
-const status = async (props) => {
-	if (props.currentBranch) {
-		const branch = contextBranch(readContextFile(props.contextFile));
-		if (branch) process.stdout.write(`${branch}\n`);
-		else {
-			log.info(`No branch pinned. Run \`${getCliName()} checkout <branch>\` to pin a branch and pull its env vars.`);
-			process.exitCode = 1;
-		}
-		return;
-	}
-	const branch = await resolveBranchRef(props);
-	if (!props.configJson) announceTargetBranch(props, branch, "Inspecting branch");
-	const { live, view: configView } = await liveConfigView({
-		projectId: props.projectId,
-		branchId: branch.branchId,
-		...props.apiKey ? { apiKey: props.apiKey } : {},
-		...props.apiHost ? { apiHost: props.apiHost } : {},
-		...props.runtimeApi ? { runtimeApi: props.runtimeApi } : {}
-	});
-	if (props.configJson) {
-		process.stdout.write(`${JSON.stringify(configView, null, 2)}\n`);
-		return;
-	}
-	if (props.output !== "table") {
-		writer(props).end({
-			project: live.project,
-			branch: live.branch,
-			config: configView
-		}, { fields: INSPECT_FIELDS });
-		return;
-	}
-	writeStatusTables(props, live, configView);
-};
-const STATUS_FIELDS = [
-	"project",
-	"region",
-	"postgres_version",
-	"organization",
-	"branch",
-	"parent",
-	"default",
-	"protected",
-	"expires_at",
-	"auth",
-	"data_api",
-	"compute",
-	"scale_to_zero",
-	"ttl"
-];
-const formatComputeUnits = (settings) => {
-	const min = settings?.autoscalingLimitMinCu;
-	const max = settings?.autoscalingLimitMaxCu;
-	if (min === void 0 && max === void 0) return void 0;
-	if (min === void 0) return `max ${max} CU`;
-	if (max === void 0) return `min ${min} CU`;
-	return min === max ? `${min} CU` : `${min}-${max} CU`;
-};
-/** Human `status`: one summary block, then a table per reported resource kind. */
-const writeStatusTables = (props, live, view) => {
-	const compute = view.branch?.postgres?.computeSettings;
-	const suspend = compute?.suspendTimeout;
-	const out = writer(props);
-	out.write({
-		project: `${live.project.name} (${live.project.id})`,
-		region: live.project.region,
-		postgres_version: live.project.pgVersion,
-		organization: live.project.orgId,
-		branch: `${live.branch.name} (${live.branch.id})`,
-		parent: live.branch.parent,
-		default: live.branch.isDefault ? "yes" : "no",
-		protected: live.branch.protected ? "yes" : "no",
-		expires_at: live.branch.expiresAt,
-		auth: view.auth ? "enabled" : void 0,
-		data_api: view.dataApi ? "enabled" : void 0,
-		compute: formatComputeUnits(compute),
-		scale_to_zero: suspend === void 0 ? void 0 : suspend === false ? "off" : String(suspend),
-		ttl: view.branch?.ttl
-	}, {
-		fields: STATUS_FIELDS,
-		humanTitle: "Status"
-	});
-	const functions = Object.entries(view.preview?.functions ?? {}).map(([slug, fn]) => ({
-		slug,
-		name: fn.name
-	}));
-	if (functions.length > 0) out.write(functions, {
-		fields: ["slug", "name"],
-		humanTitle: "Functions"
-	});
-	const buckets = Object.entries(view.preview?.buckets ?? {}).map(([name, bucket]) => ({
-		name,
-		access: bucket.access
-	}));
-	if (buckets.length > 0) out.write(buckets, {
-		fields: ["name", "access"],
-		humanTitle: "Buckets"
-	});
-	const credentials = (view.preview?.credentials ?? []).map((credential) => ({
-		id: credential.id,
-		name: credential.name,
-		scopes: credential.scopes.join(", "),
-		last_used_at: credential.lastUsedAt
-	}));
-	if (credentials.length > 0) out.write(credentials, {
-		fields: [
-			"id",
-			"name",
-			"scopes",
-			"last_used_at"
-		],
-		humanTitle: "Credentials"
-	});
-	out.end();
-};
-const planCmd = async (props) => {
-	const config = await loadConfig(props);
-	const branch = await resolveBranchRef(props);
-	announceTargetBranch(props, branch, "Planning against branch");
-	const branchId = branch.branchId;
-	const result = await plan(config, {
-		projectId: props.projectId,
-		branchId,
-		...props.apiKey ? { apiKey: props.apiKey } : {},
-		...props.apiHost ? { apiHost: props.apiHost } : {},
-		...props.runtimeApi ? { api: props.runtimeApi } : {}
-	});
-	const services = utilizedServices(config);
-	reportPushResult(props, result, "plan", services);
-	if (result.conflicts.some((conflict) => conflict.field === "customDomain" && !reasonAllowsUpdateExisting(conflict.reason))) process.exitCode = 1;
-	if (services.includes("AI Gateway")) await warnAiGateway({
-		apiClient: props.apiClient,
-		projectId: props.projectId,
-		branchId
-	});
-};
-const warnDeprecatedPreview = (config, target) => {
-	const message = previewGaWarningForConfig(config, target);
-	if (message) log.warning("%s", message);
-};
-const warningTargetFromResolved = (branch) => ({
-	name: branch.branchName,
-	id: branch.branchId,
-	exists: true,
-	...branch.isDefault !== void 0 ? { isDefault: branch.isDefault } : {},
-	...branch.isProtected !== void 0 ? { isProtected: branch.isProtected } : {},
-	...branch.parentId ? { parentId: branch.parentId } : {},
-	...branch.expiresAt ? { expiresAt: branch.expiresAt } : {}
-});
-const warningTargetForExistingBranch = async (props) => {
-	if (props.runtimeApi) {
-		const branch = (await props.runtimeApi.listBranches(props.projectId)).find((listed) => listed.id === props.branchId);
-		if (branch) return {
-			name: branch.name,
-			id: branch.id,
-			exists: true,
-			isDefault: branch.isDefault,
-			isProtected: branch.protected,
-			...branch.parentId ? { parentId: branch.parentId } : {},
-			...branch.expiresAt ? { expiresAt: branch.expiresAt } : {}
-		};
-	}
-	if (props.apiKey) {
-		const { data } = await getApiClient({
-			apiKey: props.apiKey,
-			...props.apiHost ? { apiHost: props.apiHost } : {}
-		}).listProjectBranches({ projectId: props.projectId });
-		const found = data.branches.find((listed) => listed.id === props.branchId);
-		if (found) return {
-			name: found.name ?? props.branchName ?? props.branchId,
-			id: found.id,
-			exists: true,
-			isDefault: found.default === true,
-			isProtected: found.protected === true,
-			...found.parent_id ? { parentId: found.parent_id } : {},
-			...found.expires_at ? { expiresAt: found.expires_at } : {}
-		};
-	}
-	return {
-		name: props.branchName ?? props.branchId,
-		id: props.branchId,
-		exists: true,
-		isDefault: false
-	};
-};
-const warnDeprecatedPreviewOnCreate = async (config, props) => {
-	try {
-		const listed = await warningTargetForExistingBranch(props);
-		warnDeprecatedPreview(config, {
-			...listed,
-			exists: false
-		});
-	} catch {
-		warnDeprecatedPreview(config, {
-			name: props.branchName,
-			id: props.branchId,
-			exists: false,
-			isDefault: false
-		});
-	}
-};
-const applyCmd = async (props) => {
-	const config = await loadConfig(props);
-	const branch = await resolveBranchRef(props);
-	announceTargetBranch(props, branch, "Applying to branch");
-	warnDeprecatedPreview(config, warningTargetFromResolved(branch));
-	const branchId = branch.branchId;
-	if (utilizedServices(config).includes("AI Gateway")) await assertAiGatewayProvisionable({
-		apiClient: props.apiClient,
-		projectId: props.projectId
-	});
-	const cwd = process.cwd();
-	const git = readGitContext(cwd);
-	const event = { type: "neon-deploy" };
-	const hooks = config.experimental?.hooks;
-	const hookBranch = {
-		projectId: props.projectId,
-		id: branch.branchId,
-		name: branch.branchName,
-		created: false,
-		isDefault: branch.isDefault ?? false,
-		isProtected: branch.isProtected ?? false,
-		...branch.parentId ? { parentId: branch.parentId } : {},
-		...branch.expiresAt ? { expiresAt: branch.expiresAt } : {}
-	};
-	let result;
-	let declined = false;
-	try {
-		result = await apply(config, {
-			projectId: props.projectId,
-			branchId,
-			...props.apiKey ? { apiKey: props.apiKey } : {},
-			...props.apiHost ? { apiHost: props.apiHost } : {},
-			...props.runtimeApi ? { api: props.runtimeApi } : {},
-			...props.updateExisting || props.yes ? { updateExisting: true } : {},
-			...props.allowProtected || props.yes ? { allowProtectedBranch: true } : {},
-			confirm: async (context) => {
-				if (context.overrides.length > 0) reportConflicts(props, context.overrides);
-				if (!canPromptForApply(props)) return false;
-				const proceed = await askToApply(context);
-				declined = !proceed;
-				return proceed;
-			},
-			beforeMutations: () => runDeployBeforeHook({
-				hooks,
-				branch: hookBranch,
-				git,
-				event,
-				cwd
-			}),
-			bundleFunction: neonctlBundler
-		});
-	} catch (err) {
-		if (err instanceof PushAbortedError) throw new Error(declined ? `Aborted: nothing was applied to branch "${err.branchName}".` : abortedApplyMessage(err));
-		if (err instanceof PushConflictError) {
-			reportConflicts(props, err.conflicts);
-			throw new Error("The policy conflicts with remote state. --update-existing will not resolve every conflict shown above.");
-		}
-		throw err;
-	}
-	reportPushResult(props, result, "apply", utilizedServices(config));
-	await autoPullEnvAfterPin({
-		...props,
-		envPull: props.envPull !== false
-	}, branch);
-	if (hooks?.deploy?.after) {
-		const env = await resolveHookEnv(config, {
-			projectId: props.projectId,
-			branch: branchId,
-			...props.apiKey ? { apiKey: props.apiKey } : {},
-			...props.apiHost ? { apiHost: props.apiHost } : {},
-			...props.runtimeApi ? { api: props.runtimeApi } : {}
-		});
-		if (env) await runDeployAfterHook({
-			hooks,
-			branch: hookBranch,
-			env,
-			result,
-			git,
-			event,
-			cwd
-		});
-	}
-};
-/**
-* Human-readable list of the services a `neon.ts` policy utilizes on the branch, shown under
-* the plan/apply table. Postgres is always present (every branch has it); the rest are listed
-* only when the policy declares them. This deliberately surfaces services that produce **no**
-* plan step — notably the AI Gateway, which is always available and only needs a scoped branch
-* credential (not a provisioning step) — so adding `aiGateway` to a neon.ts isn't
-* mistaken for being silently dropped. Service enablement is static top-level config (it never
-* lives in the per-branch closure), so reading it straight off `config` is accurate.
-*/
-const utilizedServices = (config) => [NEON_SERVICE_LABELS.postgres, ...declaredNeonServices(config).map((service) => NEON_SERVICE_LABELS[service])];
-/**
-* Render a {@link PushResult}. JSON/YAML output emits the raw result (plus a `services`
-* summary) verbatim so it can be piped; the human-readable path renders the actual changes
-* (dropping noops) and any blocking conflicts as a `git diff`-style report, or a "nothing to
-* do" line when both are empty — and always closes with the list of services the policy
-* utilizes so a service that produces no plan step (Postgres, or the credential-gated AI
-* Gateway) isn't mistaken for being missing from the plan above.
-*
-* The diff is asymmetric on purpose (see the CLI's `neon diff`): **service** changes are
-* additions with no "before", so they list as `+`/`~` lines; **branch setting** changes have
-* a natural before→after, so conflicts render as a sorted `current → desired` diff. Planned
-* branch updates (under `--update-existing`) carry only the new value, so they render
-* desired-only for now (the previous value isn't threaded through the runtime yet).
-*/
-const reportPushResult = (props, result, mode, services) => {
-	if (props.output === "json" || props.output === "yaml") {
-		writer(props).end({
-			...result,
-			services
-		}, { fields: [] });
-		return;
-	}
-	const appliedChanges = result.applied.filter((change) => change.action !== "noop");
-	const functionUrlBySlug = /* @__PURE__ */ new Map();
-	for (const change of appliedChanges) {
-		const slug = change.details?.slug;
-		const invocationUrl = change.details?.invocationUrl;
-		if (typeof slug === "string" && typeof invocationUrl === "string") functionUrlBySlug.set(slug, invocationUrl);
-	}
-	const color = props.color !== false;
-	const out = writer(props);
-	const noChanges = appliedChanges.length === 0 && result.conflicts.length === 0;
-	const appliedText = renderAppliedChanges(appliedChanges, mode === "plan" ? "Planned changes" : "Applied changes", { color });
-	if (appliedText) out.text(`${appliedText}\n`);
-	if (result.conflicts.length > 0) {
-		const conflictText = renderBranchSettingConflicts(result.conflicts, { color });
-		if (conflictText) out.text(`\n${conflictText}\n`);
-		for (const conflict of result.conflicts) if (!reasonAllowsUpdateExisting(conflict.reason)) out.text(`  ! ${conflict.field}: ${conflict.reason}\n`);
-	}
-	const followup = renderCustomDomainFollowup(result, { color });
-	if (followup) out.text(`\n${followup}\n`);
-	if (functionUrlBySlug.size > 0) {
-		const heading = mode === "plan" ? "Function URLs (after apply)" : "Function URLs";
-		out.text(`\n${isCi() ? heading : chalk.bold(heading)}\n`);
-		for (const [slug, invocationUrl] of functionUrlBySlug) out.text(`  • ${slug}: ${invocationUrl}\n`);
-	}
-	if (noChanges) log.info(`No changes — branch ${result.branchName} already matches the policy.`);
-	out.text(`\nUtilized services: ${services.join(", ")}\n`);
-};
-/** A prompt needs both ends of a terminal, and would corrupt `-o json|yaml` on stdout. */
-const canPromptForApply = (props) => isInteractiveTerminal() && props.output !== "json" && props.output !== "yaml";
-const askToApply = async (context) => {
-	const branch = JSON.stringify(context.branchName);
-	const message = context.protectedBranch && context.overrideUpdates ? `Branch ${branch} is protected, and this overrides the settings shown above. Apply anyway?` : context.protectedBranch ? `Branch ${branch} is protected. Apply to it anyway?` : `Override the settings shown above on branch ${branch}?`;
-	const { default: prompts } = await import("prompts");
-	const { proceed } = await prompts({
-		type: "confirm",
-		name: "proceed",
-		message,
-		initial: false
-	});
-	return proceed === true;
-};
-/** Without a terminal there is no one to ask, so name the flags that answer the question. */
-const abortedApplyMessage = (err) => {
-	const branch = JSON.stringify(err.branchName);
-	const isProtected = err.reasons.includes("protected-branch");
-	const overrides = err.reasons.includes("override-updates");
-	if (isProtected && overrides) return `Branch ${branch} is protected and its settings differ from the policy. Re-run with -y (or --allow-protected --update-existing) to apply the changes shown above.`;
-	if (isProtected) return `Branch ${branch} is protected. Re-run with --allow-protected (or -y) to apply to it.`;
-	return "Branch settings conflict with the policy. Re-run with --update-existing (or -y) to apply the changes shown above.";
-};
-/**
-* Render the branch-setting {@link ConflictReport}s a bare `apply` refused to override (drift
-* without `--update-existing`) as the git-style before→after diff. JSON/YAML output emits the
-* structured conflicts so it can be piped; the human path prints the sorted diff followed by
-* any conflict whose fix is *not* `--update-existing` (e.g. an immutable "no endpoint" case),
-* so nothing the library's error message carried is lost.
-*/
-const reportConflicts = (props, conflicts) => {
-	if (props.output === "json" || props.output === "yaml") {
-		writer(props).end({ conflicts }, { fields: [] });
-		return;
-	}
-	const out = writer(props);
-	const text = renderBranchSettingConflicts([...conflicts], { color: props.color !== false });
-	if (text) out.text(`${text}\n`);
-	for (const conflict of conflicts) if (!reasonAllowsUpdateExisting(conflict.reason)) out.text(`  ! ${conflict.field}: ${conflict.reason}\n`);
-};
-/**
-* Block provisioning the AI Gateway on a Free plan from the `checkout` policy paths, which
-* carry raw credentials (`apiKey`/`apiHost`) rather than the CLI's api client. Builds a client
-* from them and defers to {@link assertAiGatewayProvisionable}. Skipped when a `runtimeApi` is
-* injected (tests) or no `apiKey` is available; the interactive commands always have a key.
-*/
-const assertAiGatewayProvisionableFromCreds = async (props) => {
-	if (props.runtimeApi || !props.apiKey) return;
-	if (!utilizedServices(props.config).includes("AI Gateway")) return;
-	const apiClient = getApiClient({
-		apiKey: props.apiKey,
-		...props.apiHost ? { apiHost: props.apiHost } : {}
-	});
-	await assertAiGatewayProvisionable({
-		apiClient,
-		projectId: props.projectId
-	});
-};
-/**
-* Apply a `neon.ts` policy to a **freshly created** branch (used by `neonctl checkout`
-* when it creates a branch). No-op when there is no `neon.ts` on the path from cwd up to
-* the repo root — checkout still succeeds, it just has no policy to apply.
-*
-* The branch was just created by us, so we apply non-interactively (`updateExisting` /
-* `allowProtectedBranch`) — there is no pre-existing state a user would be surprised to
-* see overridden. Functions are bundled with neonctl's own esbuild helper.
-*/
-const applyPolicyOnCreate = async (props) => {
-	loadEnvFileIfGiven(props.env);
-	let config;
-	try {
-		({config} = await loadProjectConfig({
-			...props.cwd ? { cwd: props.cwd } : {},
-			...props.contextFile ? { contextFile: props.contextFile } : {}
-		}));
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		if (/Could not find a Neon config file/i.test(message)) return;
-		throw err;
-	}
-	try {
-		warnDeprecatedPreview(config, await warningTargetForExistingBranch({
-			projectId: props.projectId,
-			branchId: props.branchId,
-			...props.branchName ? { branchName: props.branchName } : {},
-			...props.apiKey ? { apiKey: props.apiKey } : {},
-			...props.apiHost ? { apiHost: props.apiHost } : {},
-			...props.runtimeApi ? { runtimeApi: props.runtimeApi } : {}
-		}));
-	} catch {
-		warnDeprecatedPreview(config);
-	}
-	await assertAiGatewayProvisionableFromCreds({
-		projectId: props.projectId,
-		...props.apiKey ? { apiKey: props.apiKey } : {},
-		...props.apiHost ? { apiHost: props.apiHost } : {},
-		...props.runtimeApi ? { runtimeApi: props.runtimeApi } : {},
-		config
-	});
-	log.info("Applying neon.ts policy to the new branch…");
-	const result = await apply(config, {
-		projectId: props.projectId,
-		branchId: props.branchId,
-		...props.apiKey ? { apiKey: props.apiKey } : {},
-		...props.apiHost ? { apiHost: props.apiHost } : {},
-		...props.runtimeApi ? { api: props.runtimeApi } : {},
-		updateExisting: true,
-		allowProtectedBranch: true,
-		bundleFunction: neonctlBundler
-	});
-	logPolicyResult(result, { color: props.color !== false });
-};
-/**
-* Report what applying a `neon.ts` policy changed, using the same `field → value` diff
-* `deploy` prints (see {@link renderAppliedChanges}) rather than a bare list of change
-* identifiers — the identifier alone repeats the branch name once per change and never says
-* *what* was applied, which is the only interesting part on a freshly created branch.
-*/
-const logPolicyResult = (result, opts) => {
-	const changes = result.applied.filter((c) => c.action !== "noop");
-	if (changes.length === 0 && result.conflicts.length === 0) {
-		log.info("neon.ts applied — no changes were needed.");
-		const followup = renderCustomDomainFollowup(result, opts);
-		if (followup) log.info("%s", followup);
-		return;
-	}
-	if (changes.length > 0) log.info("%s", renderAppliedChanges(changes, `neon.ts applied — ${changes.length} change${changes.length === 1 ? "" : "s"}:`, opts));
-	if (result.conflicts.length > 0) {
-		const conflictText = renderBranchSettingConflicts(result.conflicts, opts);
-		if (conflictText) log.info("%s", conflictText);
-		for (const conflict of result.conflicts) if (!reasonAllowsUpdateExisting(conflict.reason)) log.info("  ! %s: %s", conflict.field, conflict.reason);
-	}
-	const followup = renderCustomDomainFollowup(result, opts);
-	if (followup) log.info("%s", followup);
-};
-/**
-* Create a branch **from** the local `neon.ts` policy. Returns `null` when there is no
-* `neon.ts` on the path from cwd up to the repo root, so `neonctl checkout` can fall back to a
-* bare branch create.
-*
-* Unlike a bare create followed by {@link applyPolicyOnCreate}, this evaluates the policy for
-* the **new** branch (`exists: false`): the runtime branches from the policy's `parent` and
-* brings the branch up with its declared TTL / compute settings / services. That's what makes
-* a policy keyed on `!branch.exists` (the common "only configure new branches" shape) take
-* effect on the very first `checkout` — a bare create + `apply` always saw `exists: true` and
-* skipped that block.
-*
-* A branch that was created but whose policy failed to apply is reported through
-* `policyFailure` rather than thrown: the branch is real, so `checkout` still needs to pin it
-* (see the handler) instead of leaving it stranded behind an unchanged `.neon`.
-*/
-const createBranchFromPolicyOnCheckout = async (props) => {
-	loadEnvFileIfGiven(props.env);
-	let config;
-	try {
-		({config} = await loadProjectConfig({
-			...props.cwd ? { cwd: props.cwd } : {},
-			...props.contextFile ? { contextFile: props.contextFile } : {}
-		}));
-	} 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;
-	}
-	await assertAiGatewayProvisionableFromCreds({
-		projectId: props.projectId,
-		...props.apiKey ? { apiKey: props.apiKey } : {},
-		...props.apiHost ? { apiHost: props.apiHost } : {},
-		...props.runtimeApi ? { runtimeApi: props.runtimeApi } : {},
-		config
-	});
-	try {
-		const { branchId, branchName, result } = await createBranch(config, {
-			projectId: props.projectId,
-			branchName: props.branchName,
-			...props.apiKey ? { apiKey: props.apiKey } : {},
-			...props.apiHost ? { apiHost: props.apiHost } : {},
-			...props.runtimeApi ? { api: props.runtimeApi } : {},
-			bundleFunction: neonctlBundler
-		});
-		log.info("Created branch %s (%s) from neon.ts policy.", branchName, branchId);
-		logPolicyResult(result, { color: props.color !== false });
-		await warnDeprecatedPreviewOnCreate(config, {
-			projectId: props.projectId,
-			branchId,
-			branchName,
-			...props.apiKey ? { apiKey: props.apiKey } : {},
-			...props.apiHost ? { apiHost: props.apiHost } : {},
-			...props.runtimeApi ? { runtimeApi: props.runtimeApi } : {}
-		});
-		return { branchId };
-	} catch (err) {
-		if (isPartialBranchCreateError(err)) {
-			log.info("Created branch %s (%s) from neon.ts policy.", err.branchName, err.branchId);
-			await warnDeprecatedPreviewOnCreate(config, {
-				projectId: props.projectId,
-				branchId: err.branchId,
-				branchName: err.branchName,
-				...props.apiKey ? { apiKey: props.apiKey } : {},
-				...props.apiHost ? { apiHost: props.apiHost } : {},
-				...props.runtimeApi ? { runtimeApi: props.runtimeApi } : {}
-			});
-			return {
-				branchId: err.branchId,
-				policyFailure: err.reason
-			};
-		}
-		throw err;
-	}
-};
-//#endregion
-export { ConfigInstallFailed, addCmd, applyCmd, applyFlags, applyPolicyOnCreate, builder, command, createBranchFromPolicyOnCheckout, describe, ensureConfigPackages, envFlag, envPullFlag, handler, initCmd, installCommandFrom, missingDependencies, planCmd, status, config_exports as t };
+export { t as ConfigInstallFailed, n as addCmd, r as applyCmd, i as applyFlags, a as applyPolicyOnCreate, o as builder, s as command, l as createBranchFromPolicyOnCheckout, u as describe, d as ensureConfigPackages, f as envFlag, p as envPullFlag, m as handler, h as initCmd, g as installCommandFrom, _ as missingDependencies, v as planCmd, y as status } from "../_chunks/config-BH_qRHiG.js";