neon 8.1.0 → 8.2.0

package/README.md

@@ -474,11 +474,11 @@ The resolved branch is then written (by name) to the same `.neon` file `link` us
 
 ```bash
 $ neon checkout main --project-id polished-snowflake-12345678
-INFO: Checked out branch br-main-branch-87654321 on project polished-snowflake-12345678. Updated /path/to/cwd/.neon.
+Checked out branch br-main-branch-87654321 on project polished-snowflake-12345678. Updated /path/to/cwd/.neon.
 
 $ neon checkout dev --create --project-id polished-snowflake-12345678
-INFO: Created branch dev (br-dev-branch-12345678).
-INFO: Checked out branch br-dev-branch-12345678 on project polished-snowflake-12345678. Updated /path/to/cwd/.neon.
+Created branch dev (br-dev-branch-12345678).
+Checked out branch br-dev-branch-12345678 on project polished-snowflake-12345678. Updated /path/to/cwd/.neon.
 
 $ cat .neon
 {
@@ -698,9 +698,9 @@ Each command prints what it changed and the next step:
 
 ```
 $ neon config add function sendemail
-INFO: Created functions/sendemail.ts.
-INFO: Updated neon.ts: added functions.sendemail.
-INFO: Next: `neon dev` to run it locally, `neon config apply` to deploy.
+Created functions/sendemail.ts.
+Updated neon.ts: added functions.sendemail.
+Next: `neon dev` to run it locally, `neon config apply` to deploy.
 ```
 
 - **Functions** take a slug of 1-20 lowercase letters and digits, the same rule `plan` enforces. The handler file is written first and an existing file is never overwritten, so pointing `--source` at code you already have works. A `.js` `neon.ts` gets a `.js` handler.
@@ -740,11 +740,18 @@ neon deploy
 
 The branch is chosen with `--branch <id|name>`; without it the project's default branch is used. The policy is the `neon.ts` in the project directory (next to `.neon`, or the current directory without one); pass `--config <path>` to point at another file.
 
-**Apply-only flags** (also available on `deploy`):
+**Confirmations** (also on `deploy`). Two things need a yes before `apply` changes anything: applying to a branch Neon marks as protected, and overriding settings the branch already has (compute, TTL, `protected`, Data API settings, custom-domain targets, and disabling an existing Data API). Adding services and deploying functions is not an override, so on an unprotected branch it never asks. In a terminal, `apply` shows the settings it would override and asks once, default No. Without a terminal (CI, agents, pipes) or with `-o json|yaml`, it exits 1 before changing anything and names the flag to pass:
 
-- `--update-existing` (`-y`, `--yes`) — auto-confirm overriding existing remote settings on the branch. Without it, drift on settings already present remotely (compute, TTL, `protected`) is reported as a **conflict** and `apply` makes no changes until you resolve it or pass this flag.
-- `--allow-protected` — auto-confirm applying to a branch Neon marks as protected. Without it, `apply` refuses to touch a protected branch.
-**Output**: `status` prints the project, branch, and reverse-engineered config. `plan` / `apply` render a **`git diff`-style report** (matching [`neon diff`](#diff)): service changes (Neon Auth, Data API, buckets, functions) list as green `+` additions, while **branch setting changes** (TTL, `protected`, compute) show grouped under a `~ <branch>` header, one sorted `field → value` line each. A bare `apply` that hits drift on settings already present remotely prints those as a sorted **before→after** diff (`current → desired`, old in red / new in green) and exits non-zero until you pass `--update-existing`. Pass `--output json` (or `--output yaml`) to emit the full machine-readable result (`PushResult`) instead, for piping into other tools or CI.
+- `--update-existing` — override settings that differ from `neon.ts`.
+- `--allow-protected` — apply to a protected branch.
+- `-y`, `--yes` — both.
+
+```bash
+neon deploy --env .env.prod --allow-protected   # production main is protected, no drift expected
+neon deploy -y                                   # protected branch and drift, no questions
+```
+
+**Output**: `status` prints the project, branch, and reverse-engineered config. `plan` / `apply` render a **`git diff`-style report** (matching [`neon diff`](#diff)): service changes (Neon Auth, Data API, buckets, functions) list as green `+` additions, while **branch setting changes** (TTL, `protected`, compute) show grouped under a `~ <branch>` header, one sorted `field → value` line each. When `apply` would override settings already present remotely, it prints them as a sorted **before→after** diff (`current → desired`, old in red / new in green) before asking or, without a terminal, before exiting non-zero. Pass `--output json` (or `--output yaml`) to emit the full machine-readable result (`PushResult`) instead, for piping into other tools or CI.
 
 **`config status --current-branch`** (alias `neon status --current-branch`) prints _only_ the branch pinned in the local `.neon` file — no network, no auth, no analytics — and exits non-zero when none is pinned. This behavior lets it safely drive a shell prompt. Example [starship](https://starship.rs) segment:
 
@@ -1342,7 +1349,7 @@ Project  proj-in-org
 
 napi_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 WARNING: Store this key now: it is not shown again.
-INFO: Limited to proj-in-org: it cannot create projects, mint API keys, or read any other project. It can still change and delete everything inside that project.
+Limited to proj-in-org: it cannot create projects, mint API keys, or read any other project. It can still change and delete everything inside that project.
 ```
 
 `--org-id` and `--project-id` are mutually exclusive. A project-scoped key *is* an organization key, and its organization is looked up from the project rather than chosen separately. With neither flag you get an account key.

package/dist/commands/api_keys.js

@@ -242,7 +242,7 @@ const withdraw = async (props, orgId, keyId) => {
 		const { data } = orgId ? await props.apiClient.revokeOrgApiKey(orgId, keyId) : await props.apiClient.revokeApiKey(keyId);
 		return data.revoked === true && data.id === keyId;
 	} catch (err) {
-		log.error("Failed to revoke API key %d: %s", keyId, err instanceof Error ? err.message : String(err));
+		log.warning("Failed to revoke API key %d: %s", keyId, err instanceof Error ? err.message : String(err));
 		return false;
 	}
 };

package/dist/commands/auth.js

@@ -451,7 +451,7 @@ const ensureAuth = async (props) => {
 	}
 	if (props._[0] === "me") {
 		const state = loaded === null ? "has no stored credential" : "holds a session that has expired";
-		process.stderr.write(`Not signed in: profile "${selection.profile}" ${state}. Run \`${getCliName()} login --profile ${selection.profile}\` to sign in, or use an API key with --api-key or NEON_API_KEY.\n`);
+		log.info(`Not signed in: profile "${selection.profile}" ${state}. Run \`${getCliName()} login --profile ${selection.profile}\` to sign in, or use an API key with --api-key or NEON_API_KEY.`);
 		process.exitCode = 1;
 		return;
 	}

package/dist/commands/checkout.js

@@ -223,7 +223,7 @@ const resolveBranchId = async (props, projectId, hookCtx) => {
 	if (props.create) return createCheckoutBranch(props, projectId, ref, branches, hookCtx);
 	const missingName = notFoundMessage(ref, branches, { suggestCreate: true });
 	if (isCi() || !process.stdout.isTTY) throw new Error(missingName);
-	log.error(missingName);
+	log.info(missingName);
 	const { create } = await prompts({
 		type: "confirm",
 		name: "create",
@@ -310,7 +310,7 @@ const resolveProjectId = async (props) => {
 	if (autoDetected) return autoDetected;
 	const missingProjectMessage = `Could not determine which Neon project to check out a branch from. Provide one via the --project-id flag or a .neon file (created by \`${getCliName()} link\` / \`${getCliName()} set-context\`).`;
 	if (isCi() || !process.stdout.isTTY) throw new Error(missingProjectMessage);
-	log.error(missingProjectMessage);
+	log.info(missingProjectMessage);
 	const { runLink } = await prompts({
 		type: "confirm",
 		name: "runLink",

package/dist/commands/config.js

@@ -27,7 +27,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import chalk from "chalk";
 import { packagesToStage, previewGaWarningForConfig, resolveConfig } from "@neon/config";
-import { PushConflictError, apply, assertZipWithinLimits, bundleAsIs, createBranch, describeNativeFinding, enforceLimits, findUndeclaredNativePackages, inspect, isPartialBranchCreateError, plan, resolveEsbuildEntry, traceNativePackages, zipFunctionBundle } from "@neon/config-runtime";
+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,
@@ -88,13 +88,18 @@ const envFlag = { env: {
 /** Apply-only flags, exported so `deploy` can reuse the exact same surface. */
 const applyFlags = {
 	"update-existing": {
-		alias: ["y", "yes"],
-		describe: "Auto-confirm overriding existing remote settings on the branch",
+		describe: "Override branch settings that differ from neon.ts without asking",
 		type: "boolean",
 		default: false
 	},
 	"allow-protected": {
-		describe: "Auto-confirm applying to a branch marked protected on Neon",
+		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
 	}
@@ -754,14 +759,8 @@ const applyCmd = async (props) => {
 		...branch.parentId ? { parentId: branch.parentId } : {},
 		...branch.expiresAt ? { expiresAt: branch.expiresAt } : {}
 	};
-	await runDeployBeforeHook({
-		hooks,
-		branch: hookBranch,
-		git,
-		event,
-		cwd
-	});
 	let result;
+	let declined = false;
 	try {
 		result = await apply(config, {
 			projectId: props.projectId,
@@ -769,15 +768,29 @@ const applyCmd = async (props) => {
 			...props.apiKey ? { apiKey: props.apiKey } : {},
 			...props.apiHost ? { apiHost: props.apiHost } : {},
 			...props.runtimeApi ? { api: props.runtimeApi } : {},
-			...props.updateExisting ? { updateExisting: true } : {},
-			...props.allowProtected ? { allowProtectedBranch: true } : {},
+			...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);
-			const overrideable = err.conflicts.every((c) => reasonAllowsUpdateExisting(c.reason));
-			throw new Error(overrideable ? "Branch settings conflict with the policy. Re-run with --update-existing to apply the changes shown above." : "The policy conflicts with remote state. --update-existing will not resolve every conflict shown above.");
+			throw new Error("The policy conflicts with remote state. --update-existing will not resolve every conflict shown above.");
 		}
 		throw err;
 	}
@@ -864,6 +877,29 @@ const reportPushResult = (props, result, mode, services) => {
 	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) => !isCi() && Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && 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

package/dist/commands/dev.js

@@ -4,11 +4,11 @@ import { isClaimableEnvTarget } from "../claimable/state.js";
 import { getCliName } from "../utils/cli_name.js";
 import { readEnvFile, resolveEnvFilePath } from "../env_file.js";
 import { l as functionBaseUrlKey } from "../_chunks/env-HYNFtxu5.js";
+import { branchIdResolve } from "../utils/enrichers.js";
+import { bundleEntry } from "../utils/esbuild.js";
 import { a as resolveDevEnv } from "../_chunks/env-BWqJqBDJ.js";
 import { findConfigFunctionBySource, resolveFunctionsFromConfig } from "../dev/functions.js";
 import { resolveWatchInputs } from "../dev/inputs.js";
-import { branchIdResolve } from "../utils/enrichers.js";
-import { bundleEntry } from "../utils/esbuild.js";
 import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -550,7 +550,7 @@ const reconcileOnce = async (running, replan, ops) => {
 	try {
 		desired = await replan(nextSearchBase(running), keepPortsFromRunning(running));
 	} catch (err) {
-		log.info(chalk.red("neon.ts change ignored: ") + (err instanceof Error ? err.message : String(err)) + chalk.dim(" (fix it and save again)"));
+		log.warning("neon.ts change ignored: " + (err instanceof Error ? err.message : String(err)) + chalk.dim(" (fix it and save again)"));
 		return;
 	}
 	if (ops.isShuttingDown()) return;

package/dist/commands/env.js

@@ -7,10 +7,10 @@ import { deprecatedServiceMessage, parseServices, servicesFlagValue, servicesOpt
 import { mergeEnvFile, readEnvFile, resolveEnvFilePath } from "../env_file.js";
 import { t as NEON_ENV_VAR_KEYS, u as isFunctionBaseUrlKey } from "../_chunks/env-HYNFtxu5.js";
 import { ENV_PULL_KEY_HELP, ENV_PULL_SERVICES, envKeysForSelection, envPullFlagValue, ownedEnvServiceKeys, parseEnvPullKeys } from "../env_services.js";
-import { i as dropClaimableUnsupported, o as resolveNeonEnvVars } from "../_chunks/env-BWqJqBDJ.js";
 import { fillSingleProject, resolveBranchRef } from "../utils/enrichers.js";
 import { warnAiGateway } from "../utils/ai_gateway_notice.js";
 import { announceTargetBranch } from "../utils/branch_notice.js";
+import { i as dropClaimableUnsupported, o as resolveNeonEnvVars } from "../_chunks/env-BWqJqBDJ.js";
 import { formatPulledEnv } from "./env_output.js";
 import { existsSync } from "node:fs";
 import chalk from "chalk";

package/dist/commands/git.js

@@ -110,7 +110,7 @@ const uninstall = (_props) => {
 			log.info("Removed the neon git post-checkout hook. Git → Neon sync is off.");
 			break;
 		case "foreign":
-			log.warning("Left the existing `post-checkout` hook in place (not managed by neon). Git → Neon sync flag cleared.");
+			log.info("Left the existing `post-checkout` hook in place (not managed by neon). Git → Neon sync flag cleared.");
 			break;
 		case "absent": log.info("No neon git hook was installed. Git → Neon sync flag cleared.");
 	}
@@ -295,7 +295,7 @@ const cleanup = async (props) => {
 	const orphanNeonNames = new Set(orphaned.map(([, neonBranch]) => neonBranch));
 	const branches = (await props.apiClient.listProjectBranches({ projectId: props.projectId })).data.branches;
 	const { toDelete, skipped } = partitionBranchesToPrune(branches, orphanNeonNames);
-	for (const { name, reason } of skipped) log.warning("Keeping Neon branch %s (%s) — never auto-deleted.", name, reason);
+	for (const { name, reason } of skipped) log.info("Keeping Neon branch %s (%s) — never auto-deleted.", name, reason);
 	if (toDelete.length === 0) {
 		log.info("No orphaned Neon branches to delete.");
 		return;

package/dist/commands/profile.js

@@ -466,7 +466,10 @@ const createByMinting = async (props) => {
 		});
 		warnAboutReach(scope);
 	} finally {
-		if (minted !== void 0 && !keyIsReachable) log.info(await withdrawKey(session, mintedScope, minted.id) ? `Revoked the key that was minted but not stored (id ${minted.id}).` : `Minted key ${minted.id} could be neither stored nor revoked, and may still be live. Remove it with: neon api-keys revoke ${minted.id}${mintedScope.orgId ? ` --org-id ${mintedScope.orgId}` : ""}`);
+		if (minted !== void 0 && !keyIsReachable) {
+			if (await withdrawKey(session, mintedScope, minted.id)) log.info(`Revoked the key that was minted but not stored (id ${minted.id}).`);
+			else log.warning(`Minted key ${minted.id} could be neither stored nor revoked, and may still be live. Remove it with: neon api-keys revoke ${minted.id}${mintedScope.orgId ? ` --org-id ${mintedScope.orgId}` : ""}`);
+		}
 		const revoked = await revokeToken(oauthProps, tokenSet);
 		log.info(revoked ? "Signed the browser session back out, so nothing but the key remains." : "Could not sign the browser session back out; it will expire on its own.");
 	}
@@ -604,7 +607,8 @@ const remove = async (props) => {
 				apiKey: stored.apiKey,
 				apiHost: props.apiHost
 			});
-			log.info(await withdrawKey(client, scope, keyId) ? `Revoked the API key (id ${keyId})` : `Could not revoke the API key (id ${keyId}) — it may still be live. Remove it with: neon api-keys revoke ${keyId}${scope.orgId ? ` --org-id ${scope.orgId}` : ""}`);
+			if (await withdrawKey(client, scope, keyId)) log.info(`Revoked the API key (id ${keyId})`);
+			else log.warning(`Could not revoke the API key (id ${keyId}) — it may still be live. Remove it with: neon api-keys revoke ${keyId}${scope.orgId ? ` --org-id ${scope.orgId}` : ""}`);
 		}
 	} else if (stored !== null) {
 		const revoked = await revokeTokenSet(stored.tokens, props);

package/dist/log.js

@@ -9,7 +9,7 @@ const log = {
 		process.stderr.write(`WARNING: ${format(...args)}\n`);
 	},
 	info: (...args) => {
-		process.stderr.write(`INFO: ${format(...args)}\n`);
+		process.stderr.write(`${format(...args)}\n`);
 	},
 	error: (...args) => {
 		process.stderr.write(`ERROR: ${format(...args)}\n`);

package/dist/mcp/mint.js

@@ -14,7 +14,7 @@ const withdraw = async (client, keyId, orgId) => {
 		const { data } = orgId ? await client.revokeOrgApiKey(orgId, keyId) : await client.revokeApiKey(keyId);
 		return data.revoked === true && data.id === keyId;
 	} catch (err) {
-		log.error("Failed to revoke API key %d: %s", keyId, err instanceof Error ? err.message : String(err));
+		log.warning("Failed to revoke API key %d: %s", keyId, err instanceof Error ? err.message : String(err));
 		return false;
 	}
 };

package/dist/retire_credential.js

@@ -57,7 +57,8 @@ const retirePreviousCredential = async (props, name, existing, replacementKey) =
 			apiKey: existing.apiKey,
 			apiHost: props.apiHost
 		});
-		log.info(await withdrawKey(client, existing.scope, existing.keyId) ? `Revoked the key it replaces (id ${existing.keyId})` : `Could not revoke the key it replaces (id ${existing.keyId}); it may still be live. Remove it with: neon api-keys revoke ${existing.keyId}`);
+		if (await withdrawKey(client, existing.scope, existing.keyId)) log.info(`Revoked the key it replaces (id ${existing.keyId})`);
+		else log.warning(`Could not revoke the key it replaces (id ${existing.keyId}); it may still be live. Remove it with: neon api-keys revoke ${existing.keyId}`);
 		return;
 	}
 	const revoked = await revokeTokenSet(existing.tokens, props);
@@ -70,7 +71,7 @@ const withdrawKey = async (client, scope, keyId) => {
 		const { data } = scope.orgId ? await client.revokeOrgApiKey(scope.orgId, keyId) : await client.revokeApiKey(keyId);
 		return data.revoked === true && data.id === keyId;
 	} catch (err) {
-		log.error("Failed to revoke API key %d: %s", keyId, err instanceof Error ? err.message : String(err));
+		log.warning("Failed to revoke API key %d: %s", keyId, err instanceof Error ? err.message : String(err));
 		return false;
 	}
 };

package/dist/utils/config_diff.js

@@ -130,7 +130,6 @@ const renderAppliedChanges = (changes, title, opts) => {
 	lines.push(...renderBranchGroups(byBranch, paint));
 	return lines.join("\n");
 };
-const isOverrideableConflict = (conflict) => conflict.reason.includes("Pass `updateExisting: true`");
 const CUSTOM_DOMAIN_REASON = /^custom domain "([^"]+)"/;
 const labeledConflictField = (conflict) => {
 	if (conflict.field !== "customDomain") return conflict.field;
@@ -145,8 +144,7 @@ const renderBranchSettingConflicts = (conflicts, opts) => {
 		const existing = byBranch.get(conflict.identifier) ?? [];
 		byBranch.set(conflict.identifier, [...existing, ...expandField(labeledConflictField(conflict), conflict.current, conflict.desired)]);
 	}
-	const heading = conflicts.every(isOverrideableConflict) ? "Branch settings differ (re-run with --update-existing to apply)" : "Branch settings differ";
-	return [paint.title(heading), ...renderBranchGroups(byBranch, paint)].join("\n");
+	return [paint.title("Branch settings differ"), ...renderBranchGroups(byBranch, paint)].join("\n");
 };
 const renderCustomDomainFollowup = (result, opts) => {
 	const paint = palette(opts.color);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neon",
-  "version": "8.1.0",
+  "version": "8.2.0",
   "description": "CLI tool for Neon, the cloud backend primitives built around Lakebase Postgres",
   "keywords": [
     "neon",
@@ -64,9 +64,9 @@
     "yaml": "^2.9.0",
     "yargs": "17.7.2",
     "yoctocolors": "^2.1.2",
-    "@neon/config": "1.8.5",
-    "@neon/config-runtime": "1.7.7",
-    "@neon/sdk": "7.0.1"
+    "@neon/config-runtime": "1.8.0",
+    "@neon/sdk": "7.0.1",
+    "@neon/config": "1.8.6"
   },
   "optionalDependencies": {
     "@napi-rs/keyring": "1.3.0",
@@ -101,8 +101,8 @@
     "vitest": "^3.0.9",
     "@neon-internals/cli-core": "0.0.0",
     "@neon/e2e-harness": "0.0.0",
-    "@neon/functions": "0.11.0",
-    "@neon-internals/env-core": "0.0.28"
+    "@neon-internals/env-core": "0.0.29",
+    "@neon/functions": "0.11.0"
   },
   "publishConfig": {
     "access": "public",