neon 8.4.5 → 8.6.0

package/dist/dev/env.js

@@ -1,2 +1 @@
-import { a as resolveDevEnv, i as dropClaimableUnsupported, n as MissingBranchContextError, o as resolveNeonEnvVars, r as ServiceNotOnBranchError, t as DevEnvMismatchError } from "../_chunks/env-4WGRW2nw.js";
-export { DevEnvMismatchError, MissingBranchContextError, ServiceNotOnBranchError, dropClaimableUnsupported, resolveDevEnv, resolveNeonEnvVars };
+export { t as DevEnvMismatchError, n as MissingBranchContextError, r as ServiceNotOnBranchError, i as dropClaimableUnsupported, a as resolveDevEnv, o as resolveNeonEnvVars } from "../_chunks/env-BNm69Qh8.js";

package/dist/dev/runtime.js

@@ -121,6 +121,14 @@ const portSelectionFromEnv = (env) => {
 		mode: "explicit",
 		port: parsePort(explicit, "NEON_DEV_PORT")
 	};
+	const searchBase = env.NEON_DEV_PORT_BASE;
+	if (searchBase !== void 0 && searchBase !== "") {
+		const from = Number(searchBase);
+		return {
+			mode: "search",
+			from: Number.isInteger(from) ? from : DEFAULT_SEARCH_BASE
+		};
+	}
 	const injected = env.PORT;
 	if (injected !== void 0 && injected !== "") return {
 		mode: "explicit",

package/dist/env_file.js

@@ -15,6 +15,14 @@ const resolveEnvFilePath = (location, file) => {
 	return join(dir, ".env.local");
 };
 /**
+* The dotenv files `neon dev` loads by default, in load order: the project directory's
+* `.env`, then `.env.local`, whose values override it. Missing files are skipped.
+*/
+const defaultDevEnvFiles = (location) => {
+	const dir = projectDir(location);
+	return [join(dir, ".env"), join(dir, ".env.local")].filter((path) => existsSync(path));
+};
+/**
 * Merge `updates` into the dotenv content at `path`, preserving every other line
 * (comments, blank lines, unrelated keys) and the file's existing order. Keys present in
 * both are updated in place; keys only in `updates` are appended. A non-existent file is
@@ -145,4 +153,4 @@ const trimTrailingBlank = (lines) => {
 	return out;
 };
 //#endregion
-export { loadEnvFileIntoProcess, mergeEnvContent, mergeEnvFile, readEnvFile, resolveEnvFilePath };
+export { defaultDevEnvFiles, loadEnvFileIntoProcess, mergeEnvContent, mergeEnvFile, readEnvFile, resolveEnvFilePath };

package/dist/index.js

@@ -12,13 +12,13 @@ import { getCliName } from "./utils/cli_name.js";
 import { ensureAuth } from "./commands/auth.js";
 import { recoverFrom401 } from "./auth_recovery.js";
 import { UsageError, failOnUsageError, isBareParentCommand, showHelp, showUsageErrorHelp } from "./help.js";
-import { stagingFeaturesEnabledForArgv } from "./utils/staging.js";
 import { lazyCommands, preloadCommand } from "./commands/manifest.js";
 import { rewriteUnknownAgentArg } from "./init/plan.js";
 import { recoverFromSSO } from "./sso_recovery.js";
 import { notifyIfUpdateAvailable } from "./update_notifier.js";
 import { fillInArgs, resolveApiKeyFromEnv } from "./utils/middlewares.js";
 import { collapseRepeatedFlags, declaredOptions } from "./utils/repeated_flags.js";
+import { stagingFeaturesEnabledForArgv } from "./utils/staging.js";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 //#region src/index.ts

package/dist/init/auth.js

@@ -61,10 +61,7 @@ const runAuthenticatedMcp = async (options) => {
 const pullInitEnv = async (props) => {
 	const authenticated = authContext(props, ["env", "pull"]);
 	await ensureAuth(authenticated);
-	const opts = {
-		announce: true,
-		implyAiGateway: true
-	};
+	const opts = { announce: true };
 	try {
 		return await pull(authenticated, opts);
 	} catch (error) {

package/dist/init/choices.js

@@ -1,3 +1,5 @@
+import { FUNCTION_SLUG } from "../config_template.js";
+import { l as functionBaseUrlKey } from "../_chunks/env-BpP3Dqpe.js";
 //#region src/init/choices.ts
 const INIT_CONFIG_SERVICES_CONFLICT = "--no-config cannot be combined with --services.";
 const resolveInitConfigChoice = (input) => {
@@ -21,11 +23,23 @@ const configPlanFromResolution = (resolution, accepted) => {
 	if (resolution.kind === "skip") return { kind: "skip" };
 	return resolution;
 };
-const shouldRefreshEnvAfterNewConfig = (input) => input.wroteNewFile && typeof input.projectId === "string" && input.projectId.length > 0 && typeof input.branch === "string" && input.branch.length > 0;
-const shouldPullEnvAfterInitConfig = (input) => !input.extraServices && !input.alreadyPulled && shouldRefreshEnvAfterNewConfig({
-	wroteNewFile: input.wroteNewFile,
-	...input.projectId !== void 0 ? { projectId: input.projectId } : {},
-	...input.branch !== void 0 ? { branch: input.branch } : {}
-});
+/**
+* A neon.ts policy pull fails while the branch lacks a declared service. These two need
+* no `deploy`: the AI Gateway exists on every branch, and function URLs derive from the
+* branch host.
+*/
+const DEPLOY_FREE_SERVICES = /* @__PURE__ */ new Set(["ai-gateway", "functions"]);
+const needsDeploy = (declared) => declared.some((service) => !DEPLOY_FREE_SERVICES.has(service));
+const initEnvPullAfterConfig = (input) => {
+	if (!input.projectId || !input.branch) return { kind: "skip" };
+	if (!input.linkDeferredPull && !input.wroteNewFile) return { kind: "skip" };
+	if (input.claimable && input.declared.length > 0) return { kind: "skip" };
+	if (!needsDeploy(input.declared)) return { kind: "policy" };
+	return {
+		kind: "services",
+		services: input.declared.includes("ai-gateway") ? ["postgres", "ai-gateway"] : ["postgres"],
+		envKeys: input.declared.includes("functions") ? [functionBaseUrlKey(FUNCTION_SLUG)] : []
+	};
+};
 //#endregion
-export { INIT_CONFIG_SERVICES_CONFLICT, configPlanFromResolution, resolveInitConfigChoice, shouldPullEnvAfterInitConfig, shouldRefreshEnvAfterNewConfig };
+export { INIT_CONFIG_SERVICES_CONFLICT, configPlanFromResolution, initEnvPullAfterConfig, resolveInitConfigChoice };

package/dist/init/copy.js

@@ -99,16 +99,22 @@ const offlinePinNext = (input) => [
 	...input.envPull !== void 0 ? ["Then pull the branch's environment variables:", input.envPull] : []
 ];
 const skippedLinkNext = () => ["To connect this directory to a Neon project:", `${getCliName()} link`];
-const extraServicesNext = () => [
-	"Review neon.ts and confirm the linked project and branch before deploying.",
+const extraServicesNext = (input) => [
 	"Preview the changes:",
 	`${getCliName()} config plan`,
 	"",
-	"Deploy when the changes and target are correct:",
+	"Deploy when the changes and target are correct. Deploy also pulls the branch's environment variables:",
 	`${getCliName()} deploy`,
 	"",
-	"Refresh local environment variables after deployment:",
-	`${getCliName()} env pull`
+	"Optional, once deployed:",
+	...input.functions ? [
+		"Run Neon Functions locally:",
+		`${getCliName()} dev`,
+		""
+	] : [],
+	"Work on a development branch created from neon.ts:",
+	`${getCliName()} checkout dev --create`,
+	...input.skills ? ["", "Set up the services declared in neon.ts with your coding agent. The Neon agent skills cover best practices for each one."] : []
 ];
 const existingConfigNext = () => ["The existing Neon config was preserved. Refresh environment variables when its declared services are available:", `${getCliName()} env pull`];
 const claimableNext = (expiresAt) => [
@@ -128,10 +134,18 @@ const claimableThenServicesNext = (expiresAt) => [
 	"Refresh local environment variables:",
 	`${getCliName()} env pull`
 ];
-const installFailedNext = (command) => ({
+const installFailedNext = (command, envPull) => ({
 	heading: HEADING_FAILED,
 	body: "Could not install the Neon dependencies.",
-	next: ["Install the dependencies, then run neon init again:", command]
+	next: [
+		"Install the dependencies, then run neon init again:",
+		command,
+		...envPull ? [
+			"",
+			"Then pull the branch's environment variables:",
+			`${getCliName()} env pull`
+		] : []
+	]
 });
 const MCP_API_KEY_NEEDS_AUTH = "API-key MCP setup needs a Neon credential to mint the key. Sign in with `neon login` or pass a personal API key.";
 /** `mcp` is the `neon mcp` invocation without an auth flag. */

package/dist/init/run.js

@@ -9,7 +9,6 @@ import { getCliName } from "../utils/cli_name.js";
 import { servicesFlagValue } from "../neon_services.js";
 import { CONFIG_INIT_SERVICES, parseConfigInitServices } from "../config_template.js";
 import { hasNeonConfigFile, neonConfigFilename } from "../project.js";
-import { assertRealtimeAvailable } from "../utils/staging.js";
 import { getAgentDisplayName } from "../mcp/agents.js";
 import { mcpInstallableAgents } from "../mcp/targets.js";
 import { missingPluginsCommands, pluginsInstallableAgents } from "../plugins/targets.js";
@@ -27,7 +26,7 @@ import { InitCancelled, raceSigint, restoreCursor } from "./cancelled.js";
 import { pickAgentSetupInteractively, pickInitAgentsInteractively, pickInitConfigInteractively, pickInitMcpAuthInteractively, pickInitMcpConfigLocationInteractively, pickInitModeInteractively, pickInitPackageManagerInteractively, pickInitProjectSetupInteractively, pickInitServicesInteractively, pickInitSkillsInteractively } from "./wizard.js";
 import { runToolingSteps } from "./tooling.js";
 import { create } from "../commands/claim.js";
-import { INIT_CONFIG_SERVICES_CONFLICT, configPlanFromResolution, resolveInitConfigChoice, shouldPullEnvAfterInitConfig } from "./choices.js";
+import { INIT_CONFIG_SERVICES_CONFLICT, configPlanFromResolution, initEnvPullAfterConfig, resolveInitConfigChoice } from "./choices.js";
 import { detectInitEnvironment } from "./detect.js";
 import { createInitFunnel, emitInitStart, finishInitFunnel, initStartProperties } from "./funnel.js";
 import { assertAgentSetupFlags, hasInitMcpFlags, inferInitAgentSetup, resolveInitMode } from "./mode.js";
@@ -184,7 +183,7 @@ const runInit = async (props) => {
 	};
 	const servicesFlag = servicesFlagValue(props.services);
 	if (props.config === false && servicesFlag !== void 0) throw new Error(INIT_CONFIG_SERVICES_CONFLICT);
-	if (servicesFlag !== void 0 && parseConfigInitServices(servicesFlag).includes("realtime")) assertRealtimeAvailable(props.apiHost);
+	if (servicesFlag !== void 0) parseConfigInitServices(servicesFlag);
 	const linkInputs = {
 		...props.orgId ? { orgId: props.orgId } : {},
 		...props.projectId ? { projectId: props.projectId } : {},
@@ -370,7 +369,6 @@ const runInit = async (props) => {
 		});
 		if (toolingSteps.length > 0) await runTooling(toolingSteps, earlyTooling);
 		let projectSetup = "skip";
-		let linkedNow = false;
 		let claimExpiresAt;
 		const noLink = props.link === false;
 		const linkByDefault = detection.authenticated || hasExplicitLinkInputs && !yes;
@@ -395,6 +393,7 @@ const runInit = async (props) => {
 			funnel.link = "skipped";
 		} else if (props.pickProjectSetup !== void 0 || detection.interactive) projectSetup = await (props.pickProjectSetup ?? pickInitProjectSetupInteractively)();
 		else throw new Error(NON_TTY_LINK_NEEDS_AUTH);
+		const deferLinkPull = !existingConfig && props.config !== false;
 		const linkProps = {
 			apiClient: props.apiClient,
 			apiKey: props.apiKey,
@@ -405,6 +404,7 @@ const runInit = async (props) => {
 			clear: false,
 			checks: true,
 			envPull: true,
+			deferEnvPull: deferLinkPull,
 			config: false,
 			cwd,
 			...linkInputs,
@@ -426,13 +426,11 @@ const runInit = async (props) => {
 				apiKey: props.apiKey,
 				...props.profile !== void 0 ? { profile: props.profile } : {}
 			});
-			linkedNow = true;
 			funnel.link = "claimable";
 			claimExpiresAt = readLinkedClaimableCredentials(configDir, readContextFile(contextFile))?.expiresAt;
 		} else if (projectSetup === "link") {
 			printInitProgress(detection.authenticated ? PROGRESS.link : PROGRESS.auth);
 			await (props.linkProject ?? runAuthenticatedLink)(linkProps);
-			linkedNow = true;
 			funnel.link = "linked";
 		}
 		const pinnedOffline = funnel.link === "skipped" && !noLink && linkInputs.orgId !== void 0 && linkInputs.projectId !== void 0 && linkInputs.branch !== void 0 && linkInputs.projectName === void 0 && linkInputs.regionId === void 0;
@@ -442,7 +440,6 @@ const runInit = async (props) => {
 				checks: false,
 				envPull: false
 			});
-			linkedNow = true;
 			funnel.link = "linked";
 		}
 		if (delayMcp && tooling.setup !== "skip" && props.mcpProjectScoped === true && funnel.link === "skipped" && !noLink) mcpState.deferredPin = linkInputs.projectId !== void 0 ? quoteFlagValue(linkInputs.projectId) : "<project-id>";
@@ -502,11 +499,13 @@ const runInit = async (props) => {
 		};
 		let wroteNewFile = false;
 		let extraServices = false;
+		let declared = [];
 		let selectedServices = null;
+		const linkDeferredPull = deferLinkPull && projectSetup === "link" && funnel.link === "linked";
 		if (configPlan.kind === "write") {
 			const planned = existingConfig ? void 0 : configPlan.services ?? ["postgres"];
 			if (planned !== void 0) {
-				const declared = parseConfigInitServices(planned);
+				declared = parseConfigInitServices(planned);
 				extraServices = declared.length > 0;
 				selectedServices = expandTelemetryServices(declared);
 				funnel.services = selectedServices;
@@ -529,7 +528,7 @@ const runInit = async (props) => {
 				});
 			} catch (error) {
 				if (error instanceof ConfigInstallFailed) {
-					const failed = installFailedNext(error.command);
+					const failed = installFailedNext(error.command, linkDeferredPull);
 					printInitDone(formatInitDone({
 						heading: failed.heading,
 						body: failed.body,
@@ -547,14 +546,15 @@ const runInit = async (props) => {
 		const context = readContextFile(contextFile);
 		const branch = contextBranch(context);
 		const linked = isLinked(contextFile);
-		const alreadyPulled = linkedNow && funnel.link === "linked" && !pinnedOffline;
-		if (funnel.link !== "skipped" && !pinnedOffline && shouldPullEnvAfterInitConfig({
+		const envPullPlan = funnel.link === "skipped" || pinnedOffline ? { kind: "skip" } : initEnvPullAfterConfig({
+			linkDeferredPull,
 			wroteNewFile,
-			extraServices,
-			alreadyPulled,
+			declared,
+			claimable: funnel.link === "claimable",
 			...typeof context.projectId === "string" ? { projectId: context.projectId } : {},
 			...branch !== void 0 ? { branch } : {}
-		})) try {
+		});
+		if (envPullPlan.kind !== "skip") try {
 			if (typeof context.projectId !== "string" || typeof branch !== "string") throw new Error("Env pull requires a linked project and branch.");
 			printInitProgress(PROGRESS.env);
 			await raceSigint((props.envPull ?? pullInitEnv)({
@@ -562,7 +562,11 @@ const runInit = async (props) => {
 				output: props.output,
 				cwd,
 				projectId: context.projectId,
-				branch
+				branch,
+				...envPullPlan.kind === "services" ? {
+					services: envPullPlan.services,
+					envKeys: envPullPlan.envKeys
+				} : {}
 			}));
 		} catch (error) {
 			if (error instanceof InitCancelled) throw error;
@@ -618,7 +622,10 @@ const runInit = async (props) => {
 			next.push(...claimableNext(claimExpiresAt));
 		} else if (pendingServices) {
 			if (next.length > 0) next.push("");
-			next.push(...extraServicesNext());
+			next.push(...extraServicesNext({
+				skills: installsSkills(reportedTooling()),
+				functions: declared.includes("functions")
+			}));
 		} else if (pendingExisting) {
 			if (next.length > 0) next.push("");
 			next.push(...existingConfigNext());
@@ -699,6 +706,8 @@ const withoutMcp = (tooling) => {
 	};
 	return tooling;
 };
+/** The Neon plugin bundles the skills. */
+const installsSkills = (tooling) => tooling.setup === "skills-mcp" ? tooling.skillsAgents.length > 0 : tooling.setup !== "skip";
 const agentsFromTooling = (tooling) => {
 	switch (tooling.setup) {
 		case "skip": return [];

package/dist/plugins/run.js

@@ -12,7 +12,8 @@ const PLUGIN_SKILLS = [
 	"neon-object-storage",
 	"neon-postgres",
 	"neon-postgres-branches",
-	"neon-postgres-egress-optimizer"
+	"neon-postgres-egress-optimizer",
+	"neon-realtime"
 ];
 const PLUGINS_CLI_TIMEOUT_MS = 12e4;
 const pluginsChildEnv = (base = process.env) => {

package/dist/psql/command/cmd_io.js

@@ -1,2 +1 @@
-import { A as cmdPrint, C as cmdGdesc, D as cmdInclude, E as cmdGx, F as registerIoCommands, M as cmdWrite, N as formatWatchTimestamp, O as cmdIncludeRel, P as getQueryFout, S as cmdG, T as cmdGset, b as WATCH_TEST_CONTROLLER, j as cmdWatch, k as cmdOut, w as cmdGexec, x as clearPipelineGateErrors, y as DEFAULT_WATCH_INTERVAL } from "../../_chunks/cmd_pipeline-CEk93dGN.js";
-export { DEFAULT_WATCH_INTERVAL, WATCH_TEST_CONTROLLER, clearPipelineGateErrors, cmdG, cmdGdesc, cmdGexec, cmdGset, cmdGx, cmdInclude, cmdIncludeRel, cmdOut, cmdPrint, cmdWatch, cmdWrite, formatWatchTimestamp, getQueryFout, registerIoCommands };
+export { y as DEFAULT_WATCH_INTERVAL, b as WATCH_TEST_CONTROLLER, x as clearPipelineGateErrors, S as cmdG, C as cmdGdesc, w as cmdGexec, T as cmdGset, E as cmdGx, D as cmdInclude, O as cmdIncludeRel, k as cmdOut, A as cmdPrint, j as cmdWatch, M as cmdWrite, N as formatWatchTimestamp, P as getQueryFout, F as registerIoCommands } from "../../_chunks/cmd_pipeline-CEk93dGN.js";

package/dist/psql/command/cmd_pipeline.js

@@ -1,2 +1 @@
-import { C as cmdGdesc, _ as stagedNamedBindPresent, a as cmdFlush, c as cmdParse, d as cmdSyncPipeline, f as consumeBindState, g as registerPipelineCommands, h as lookupPrepared, i as cmdEndPipeline, l as cmdSendPipeline, m as getPipelineState, n as cmdBindNamed, o as cmdFlushRequest, p as dropPrepared, r as cmdClosePrepared, s as cmdGetResults, t as cmdBind, u as cmdStartPipeline, v as stashPrepared } from "../../_chunks/cmd_pipeline-CEk93dGN.js";
-export { cmdBind, cmdBindNamed, cmdClosePrepared, cmdEndPipeline, cmdFlush, cmdFlushRequest, cmdGdesc, cmdGetResults, cmdParse, cmdSendPipeline, cmdStartPipeline, cmdSyncPipeline, consumeBindState, dropPrepared, getPipelineState, lookupPrepared, registerPipelineCommands, stagedNamedBindPresent, stashPrepared };
+export { t as cmdBind, n as cmdBindNamed, r as cmdClosePrepared, i as cmdEndPipeline, a as cmdFlush, o as cmdFlushRequest, C as cmdGdesc, s as cmdGetResults, c as cmdParse, l as cmdSendPipeline, u as cmdStartPipeline, d as cmdSyncPipeline, f as consumeBindState, p as dropPrepared, m as getPipelineState, h as lookupPrepared, g as registerPipelineCommands, _ as stagedNamedBindPresent, v as stashPrepared } from "../../_chunks/cmd_pipeline-CEk93dGN.js";

package/dist/psql/core/common.js

@@ -1,2 +1 @@
-import { B as psqlExec, G as writeQueryError, H as renderResultSet, I as __testing, L as captureLastError, R as executeAndPrint, U as sendQuery, V as refreshErrorVars, W as stripLeadingCommentsAndWS, z as pickOut } from "../../_chunks/cmd_pipeline-CEk93dGN.js";
-export { __testing, captureLastError, executeAndPrint, pickOut, psqlExec, refreshErrorVars, renderResultSet, sendQuery, stripLeadingCommentsAndWS, writeQueryError };
+export { I as __testing, L as captureLastError, R as executeAndPrint, z as pickOut, B as psqlExec, V as refreshErrorVars, H as renderResultSet, U as sendQuery, W as stripLeadingCommentsAndWS, G as writeQueryError } from "../../_chunks/cmd_pipeline-CEk93dGN.js";

package/dist/psql/core/startup.js

@@ -1,2 +1 @@
-import { f as CLIENT_VERSION, h as parseStartupArgs, m as formatParseError, p as applyStartupArgs } from "../../_chunks/psql-BNljLda2.js";
-export { CLIENT_VERSION, applyStartupArgs, formatParseError, parseStartupArgs };
+export { f as CLIENT_VERSION, p as applyStartupArgs, m as formatParseError, h as parseStartupArgs } from "../../_chunks/psql-BNljLda2.js";

package/dist/psql/index.js

@@ -1,2 +1 @@
-import { a as mergeConnectOptions, c as parseConnectionUriService, d as serviceEntryToConnectOptions, i as looksLikeConnectionString, l as parseConninfo, n as envConnectionDefaults, o as parseConnectionUri, r as libpqConnectionDefaults, s as parseConnectionUriPartial, t as defaultClientCertDefaults, u as runPsql } from "../_chunks/psql-BNljLda2.js";
-export { defaultClientCertDefaults, envConnectionDefaults, libpqConnectionDefaults, looksLikeConnectionString, mergeConnectOptions, parseConnectionUri, parseConnectionUriPartial, parseConnectionUriService, parseConninfo, runPsql, serviceEntryToConnectOptions };
+export { t as defaultClientCertDefaults, n as envConnectionDefaults, r as libpqConnectionDefaults, i as looksLikeConnectionString, a as mergeConnectOptions, o as parseConnectionUri, s as parseConnectionUriPartial, c as parseConnectionUriService, l as parseConninfo, u as runPsql, d as serviceEntryToConnectOptions } from "../_chunks/psql-BNljLda2.js";

package/dist/psql/types/index.js

@@ -1,8 +1,7 @@
-import { initialScanState, isContinueStatus } from "./scanner.js";
+export { initialScanState, isContinueStatus } from "./scanner.js";
 import "./backslash.js";
 import "./connection.js";
 import "./printer.js";
 import "./repl.js";
 import "./settings.js";
 import "./variables.js";
-export { initialScanState, isContinueStatus };

package/dist/skills/catalog.js

@@ -43,6 +43,11 @@ const NEON_SKILL_CATALOG = [
 		source: AGENT_SKILLS_SOURCE,
 		defaultSelected: true
 	},
+	{
+		skill: "neon-realtime",
+		source: AGENT_SKILLS_SOURCE,
+		defaultSelected: true
+	},
 	{
 		skill: "neon-postgres-agent-platforms",
 		source: PLATFORMS_SKILLS_SOURCE,

package/dist/utils/hooks.js

@@ -1,7 +1,6 @@
 import { log } from "../log.js";
 import { loadProjectConfig } from "../project.js";
 import { s as fetchEnvKeys } from "../_chunks/env-BpP3Dqpe.js";
-import { assertPolicyAvailable } from "./staging.js";
 import { runHook } from "@neon/config-runtime";
 //#region src/utils/hooks.ts
 /**
@@ -150,7 +149,6 @@ const runAfter = async (label, run) => {
 * postgres only, since nothing else is declared enabled).
 */
 const resolveHookEnv = async (config, options) => {
-	assertPolicyAvailable(config, options.apiHost);
 	try {
 		const resolved = await fetchEnvKeys(config, options, null);
 		return shapeHookEnv(resolved);

package/dist/utils/staging.js

@@ -7,7 +7,6 @@ import { Parser, hideBin } from "yargs/helpers";
 * hidden from help and fail with a "coming soon" message.
 */
 const STAGING_API_HOST = "https://console-stage.neon.build/api/v2";
-const REALTIME_COMING_SOON = `Neon Realtime is coming soon! For now it only works on Neon's staging API: set NEON_API_HOST=${STAGING_API_HOST} or pass --api-host.`;
 /** `NEON_STAGING_API_HOST` lets the CLI's tests treat their local mock API as staging. */
 const stagingHostname = () => new URL(process.env.NEON_STAGING_API_HOST ?? "https://console-stage.neon.build/api/v2").hostname;
 const isStagingApiHost = (apiHost) => apiHost !== void 0 && URL.canParse(apiHost) && new URL(apiHost).hostname === stagingHostname();
@@ -26,8 +25,6 @@ const stagingFeaturesEnabledForArgv = (args = hideBin(process.argv)) => {
 };
 /** `apiHost` is a command's resolved host; without one, the host this process was invoked with. */
 const stagingFeaturesEnabled = (apiHost) => apiHost === void 0 ? stagingFeaturesEnabledForArgv() : isStagingApiHost(apiHost);
-/** Service names to list in help: Realtime only on staging. */
-const listedServices = (services) => stagingFeaturesEnabledForArgv() ? services : services.filter((service) => service !== "realtime");
 /** A hard stop: callers that degrade other failures to warnings let this one through. */
 var StagingOnlyError = class extends Error {
 	constructor(..._args) {
@@ -35,15 +32,5 @@ var StagingOnlyError = class extends Error {
 		this.name = "StagingOnlyError";
 	}
 };
-const assertRealtimeAvailable = (apiHost) => {
-	if (!stagingFeaturesEnabled(apiHost)) throw new StagingOnlyError(REALTIME_COMING_SOON);
-};
-/**
-* A `neon.ts` with any `preview.realtime` value reads the Realtime API, which production
-* does not serve. `false` reads it too, to disable Realtime on the branch.
-*/
-const assertPolicyAvailable = (config, apiHost) => {
-	if (config.preview?.realtime !== void 0) assertRealtimeAvailable(apiHost);
-};
 //#endregion
-export { REALTIME_COMING_SOON, STAGING_API_HOST, StagingOnlyError, assertPolicyAvailable, assertRealtimeAvailable, isStagingApiHost, listedServices, stagingFeaturesEnabled, stagingFeaturesEnabledForArgv };
+export { STAGING_API_HOST, StagingOnlyError, isStagingApiHost, stagingFeaturesEnabled, stagingFeaturesEnabledForArgv };

package/{LICENSE → dist/vendor/postgres-meta/LICENSE}

@@ -1,4 +1,3 @@
-
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/

package/dist/vendor/postgres-meta/constants.js

@@ -0,0 +1,14 @@
+//#region src/vendor/postgres-meta/constants.ts
+const GENERATE_TYPES_DEFAULT_SCHEMA = process.env.PG_META_GENERATE_TYPES_DEFAULT_SCHEMA || "public";
+const VALID_UNNAMED_FUNCTION_ARG_TYPES = /* @__PURE__ */ new Set([
+	114,
+	3802,
+	25
+]);
+const VALID_FUNCTION_ARGS_MODE = /* @__PURE__ */ new Set([
+	"in",
+	"inout",
+	"variadic"
+]);
+//#endregion
+export { GENERATE_TYPES_DEFAULT_SCHEMA, VALID_FUNCTION_ARGS_MODE, VALID_UNNAMED_FUNCTION_ARG_TYPES };

package/dist/vendor/postgres-meta/lib/PostgresMeta.js

@@ -0,0 +1,49 @@
+import PostgresMetaColumnPrivileges from "./PostgresMetaColumnPrivileges.js";
+import PostgresMetaTables from "./PostgresMetaTables.js";
+import PostgresMetaColumns from "./PostgresMetaColumns.js";
+import PostgresMetaConfig from "./PostgresMetaConfig.js";
+import PostgresMetaExtensions from "./PostgresMetaExtensions.js";
+import PostgresMetaForeignTables from "./PostgresMetaForeignTables.js";
+import PostgresMetaFunctions from "./PostgresMetaFunctions.js";
+import PostgresMetaIndexes from "./PostgresMetaIndexes.js";
+import PostgresMetaMaterializedViews from "./PostgresMetaMaterializedViews.js";
+import PostgresMetaPolicies from "./PostgresMetaPolicies.js";
+import PostgresMetaPublications from "./PostgresMetaPublications.js";
+import PostgresMetaRelationships from "./PostgresMetaRelationships.js";
+import PostgresMetaRoles from "./PostgresMetaRoles.js";
+import PostgresMetaSchemas from "./PostgresMetaSchemas.js";
+import PostgresMetaTablePrivileges from "./PostgresMetaTablePrivileges.js";
+import PostgresMetaTriggers from "./PostgresMetaTriggers.js";
+import PostgresMetaTypes from "./PostgresMetaTypes.js";
+import PostgresMetaVersion from "./PostgresMetaVersion.js";
+import PostgresMetaViews from "./PostgresMetaViews.js";
+import { init } from "./db.js";
+//#region src/vendor/postgres-meta/lib/PostgresMeta.ts
+var PostgresMeta = class {
+	constructor(config) {
+		const { query, end } = init(config);
+		this.query = query;
+		this.end = end;
+		this.columnPrivileges = new PostgresMetaColumnPrivileges(this.query);
+		this.columns = new PostgresMetaColumns(this.query);
+		this.config = new PostgresMetaConfig(this.query);
+		this.extensions = new PostgresMetaExtensions(this.query);
+		this.foreignTables = new PostgresMetaForeignTables(this.query);
+		this.functions = new PostgresMetaFunctions(this.query);
+		this.indexes = new PostgresMetaIndexes(this.query);
+		this.materializedViews = new PostgresMetaMaterializedViews(this.query);
+		this.policies = new PostgresMetaPolicies(this.query);
+		this.publications = new PostgresMetaPublications(this.query);
+		this.relationships = new PostgresMetaRelationships(this.query);
+		this.roles = new PostgresMetaRoles(this.query);
+		this.schemas = new PostgresMetaSchemas(this.query);
+		this.tablePrivileges = new PostgresMetaTablePrivileges(this.query);
+		this.tables = new PostgresMetaTables(this.query);
+		this.triggers = new PostgresMetaTriggers(this.query);
+		this.types = new PostgresMetaTypes(this.query);
+		this.version = new PostgresMetaVersion(this.query);
+		this.views = new PostgresMetaViews(this.query);
+	}
+};
+//#endregion
+export { PostgresMeta as default };

package/dist/vendor/postgres-meta/lib/PostgresMetaColumnPrivileges.js

@@ -0,0 +1,85 @@
+import { DEFAULT_SYSTEM_SCHEMAS } from "./constants.js";
+import { filterByList, filterByValue } from "./helpers.js";
+import { COLUMN_PRIVILEGES_SQL } from "./sql/column_privileges.sql.js";
+import { ident, literal } from "pg-format";
+//#region src/vendor/postgres-meta/lib/PostgresMetaColumnPrivileges.ts
+var PostgresMetaColumnPrivileges = class {
+	constructor(query) {
+		this.query = query;
+	}
+	async list({ includeSystemSchemas = false, includedSchemas, excludedSchemas, limit, offset } = {}) {
+		const schemaFilter = filterByList(includedSchemas, excludedSchemas, !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : void 0);
+		const sql = COLUMN_PRIVILEGES_SQL({
+			schemaFilter,
+			limit,
+			offset
+		});
+		return await this.query(sql);
+	}
+	async grant(grants) {
+		let sql = `
+do $$
+declare
+  col record;
+begin
+${grants.map(({ privilege_type, column_id, grantee, is_grantable }) => {
+			const [relationId, columnNumber] = column_id.split(".");
+			return `
+select *
+from pg_attribute a
+where a.attrelid = ${literal(relationId)}
+  and a.attnum = ${literal(columnNumber)}
+into col;
+execute format(
+  'grant ${privilege_type} (%I) on %s to ${grantee.toLowerCase() === "public" ? "public" : ident(grantee)} ${is_grantable ? "with grant option" : ""}',
+  col.attname,
+  col.attrelid::regclass
+);`;
+		}).join("\n")}
+end $$;
+`;
+		const { data, error } = await this.query(sql);
+		if (error) return {
+			data,
+			error
+		};
+		const columnIds = [...new Set(grants.map(({ column_id }) => column_id))];
+		const columnIdsFilter = filterByValue(columnIds);
+		sql = COLUMN_PRIVILEGES_SQL({ columnIdsFilter });
+		return await this.query(sql);
+	}
+	async revoke(revokes) {
+		let sql = `
+do $$
+declare
+  col record;
+begin
+${revokes.map(({ privilege_type, column_id, grantee }) => {
+			const [relationId, columnNumber] = column_id.split(".");
+			return `
+select *
+from pg_attribute a
+where a.attrelid = ${literal(relationId)}
+  and a.attnum = ${literal(columnNumber)}
+into col;
+execute format(
+  'revoke ${privilege_type} (%I) on %s from ${grantee.toLowerCase() === "public" ? "public" : ident(grantee)}',
+  col.attname,
+  col.attrelid::regclass
+);`;
+		}).join("\n")}
+end $$;
+`;
+		const { data, error } = await this.query(sql);
+		if (error) return {
+			data,
+			error
+		};
+		const columnIds = [...new Set(revokes.map(({ column_id }) => column_id))];
+		const columnIdsFilter = filterByValue(columnIds);
+		sql = COLUMN_PRIVILEGES_SQL({ columnIdsFilter });
+		return await this.query(sql);
+	}
+};
+//#endregion
+export { PostgresMetaColumnPrivileges as default };