neon 8.4.5 → 8.5.0

package/README.md

@@ -316,23 +316,23 @@ neon realtime subscribe "SELECT id, title, completed FROM realtime_todos ORDER B
 
 The default terminal output is append-only. It identifies the selected project,
 branch, and database; prints the initial result once; reports connection-state
-changes; and then prints each published batch with its transaction IDs, a compact
+changes; and then prints each published change set with its transaction IDs, a compact
 `+insert ~update -delete` summary, and the affected rows. It does not take over the
-terminal or require keyboard navigation. Pass `--changes` to display the raw reset
-and batch events instead of the materialized view.
+terminal or require keyboard navigation. Pass `--changes` to display the raw `rows`
+and `changes` events instead of the materialized view.
 
 For scripts and agents, JSON output is a JSON Lines stream with one complete event
 per line. YAML output uses one document per event:
 
 ```bash
 neon realtime subscribe --changes --output json "SELECT * FROM realtime_todos" |
-  jq --unbuffered 'select(.type == "batch")'
+  jq --unbuffered 'select(.type == "changes")'
 
 neon realtime subscribe --output yaml "SELECT * FROM realtime_todos"
 ```
 
 Machine-readable output retains the event stream: without `--changes`, each event is
-a complete `snapshot`; with `--changes`, events are raw `reset` and `batch` objects.
+a complete `snapshot`; with `--changes`, events are raw `rows` and `changes` objects.
 Lifecycle labels and the target header are terminal-only.
 
 ## Configure autocompletion
@@ -967,7 +967,7 @@ On a TTY the command asks which agents and which skills, then installs. Detected
 
 `-y` skips those questions and installs the default skills into detected agents: project-folder markers such as `.cursor`, else the agent driving the CLI. `--agent` / `-a` names coding agents and skips the agent picker. `--skill` / `-s` names specific skills and skips the skill picker; it does not select agents. `--global -y` uses installed apps, else the host CLI agent. Without a TTY, pass `-y`, or `--skill <name>` (add `--agent <name>` to name agents). If `-y` finds no agent, it exits: pass `--agent <name>`, run from a supported agent, or omit `-y` in a terminal to pick.
 
-`--skill` names by source repo: `neondatabase/agent-skills` (`neon`, `neon-ai-gateway`, `neon-auth`, `neon-functions`, `neon-object-storage`, `neon-postgres`, `neon-postgres-branches`, `neon-postgres-egress-optimizer`); `neondatabase/neon-for-agent-platforms` (`neon-postgres-agent-platforms`).
+`--skill` names by source repo: `neondatabase/agent-skills` (`neon`, `neon-ai-gateway`, `neon-auth`, `neon-functions`, `neon-object-storage`, `neon-postgres`, `neon-postgres-branches`, `neon-postgres-egress-optimizer`, `neon-realtime`); `neondatabase/neon-for-agent-platforms` (`neon-postgres-agent-platforms`).
 
 Supported agents match `neon mcp`, minus agents that cannot install skills: `antigravity`, `cline`, `cline-cli`, `claude-code`, `claude-desktop`, `codex`, `cursor`, `gemini-cli`, `goose`, `github-copilot-cli`, `grok-build`, `opencode`, `vscode`, `windsurf`, `zed`. `mcporter` is a known MCP name that is then skipped. `neon skills --help` lists the same skill and agent values, and that `-y` leaves out `neon-postgres-agent-platforms`.
 
@@ -1019,7 +1019,7 @@ Default scope is `project`. `--global` is `user`. On macOS and Linux, Cursor and
 
 Supported agents with a plugins mapping: `claude-code`, `claude-desktop`, `codex`, `cursor`, `github-copilot-cli`, `grok-build`, `vscode`. `claude-desktop` installs as Claude Code; detecting both produces one install and lists both names in the table. `mcporter` is a known MCP name that is then skipped.
 
-The plugins CLI installs every plugin it finds in the Neon plugin package. Today that is `neon-postgres` from `neondatabase/agent-skills`. It includes the Neon MCP server (`https://mcp.neon.tech/mcp`) and these skills: `neon`, `neon-ai-gateway`, `neon-auth`, `neon-functions`, `neon-object-storage`, `neon-postgres`, `neon-postgres-branches`, `neon-postgres-egress-optimizer`. It does not include `neon-postgres-agent-platforms`.
+The plugins CLI installs every plugin it finds in the Neon plugin package. Today that is `neon-postgres` from `neondatabase/agent-skills`. It includes the Neon MCP server (`https://mcp.neon.tech/mcp`) and these skills: `neon`, `neon-ai-gateway`, `neon-auth`, `neon-functions`, `neon-object-storage`, `neon-postgres`, `neon-postgres-branches`, `neon-postgres-egress-optimizer`, `neon-realtime`. It does not include `neon-postgres-agent-platforms`.
 
 `neon plugins --help` lists the plugin, those contents, and the supported agent names.
 

package/dist/_chunks/{env-4WGRW2nw.js → env-BNm69Qh8.js}

@@ -4,8 +4,8 @@ import { declaredNeonServices } from "../config_services.js";
 import { loadProjectConfig } from "../project.js";
 import { a as defaultAiGatewayCredential, c as fetchEnvKeysState, d as isLiveCredential, h as toEntries, i as credentialName, l as functionBaseUrlKey, m as resolveBranchPolicy, n as createApiFromOptions, o as defaultStorageCredential, p as policyEnvKeys, r as credentialEnvKeys, t as NEON_ENV_VAR_KEYS, u as isFunctionBaseUrlKey } from "./env-BpP3Dqpe.js";
 import { ENV_PULL_SERVICES, envKeysForSelection, serviceForEnvKey, servicesForEnvKeys } from "../env_services.js";
-import { StagingOnlyError, assertPolicyAvailable, assertRealtimeAvailable, stagingFeaturesEnabled } from "../utils/staging.js";
 import { formatInstallCommand, resolvePackageManager } from "../utils/package_manager.js";
+import { StagingOnlyError } from "../utils/staging.js";
 import { ErrorCode, PlatformError, createNeonApiFromOptions, isPlatformError } from "@neon/config";
 import { credentialScopesSatisfied } from "@neon/config/v1";
 import { plan, pullConfig } from "@neon/config-runtime";
@@ -414,8 +414,7 @@ const resolveNeonEnvVars = async (ctx) => {
 		const pulled = await pullConfig({
 			projectId: ctx.projectId,
 			branchId: ctx.branchId,
-			...apiOptions(ctx),
-			realtime: stagingFeaturesEnabled(ctx.apiHost)
+			...apiOptions(ctx)
 		});
 		const resolvedBranch = {
 			id: pulled.branch.id,
@@ -513,7 +512,6 @@ const resolveSelectedServices = async (ctx, directServices, envKeys) => {
 	const impliedServices = servicesForEnvKeys(envKeys);
 	const services = ENV_PULL_SERVICES.filter((service) => directServices.includes(service) || impliedServices.includes(service));
 	const selectedKeys = envKeysForSelection(directServices, envKeys);
-	if (services.includes("realtime")) assertRealtimeAvailable(ctx.apiHost);
 	const api = apiFor(ctx);
 	const has = (service) => services.includes(service);
 	const checkAiGateway = has("ai-gateway") && !selectedKeys.includes(NEON_ENV_VAR_KEYS.aiGateway.apiKey);
@@ -758,7 +756,6 @@ const loadNeonConfig = async (ctx) => {
 			...ctx.config ? { path: ctx.config } : {},
 			...ctx.omitUnsetFunctionEnv ? { unsetFunctionEnv: "omit" } : {}
 		});
-		assertPolicyAvailable(config, ctx.apiHost);
 		return config;
 	} catch (err) {
 		const message = err instanceof Error ? err.message : String(err);

package/dist/commands/config.js

@@ -11,7 +11,6 @@ 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 { assertPolicyAvailable, assertRealtimeAvailable, listedServices, stagingFeaturesEnabled, stagingFeaturesEnabledForArgv } from "../utils/staging.js";
 import { formatInstallCommand, installArgs, resolvePackageManager, runCommand } from "../utils/package_manager.js";
 import { writer } from "../writer.js";
 import { fillSingleProject, resolveBranchRef } from "../utils/enrichers.js";
@@ -159,11 +158,7 @@ const missingDependencies = (cwd) => {
 * starter policy, which is what `config init` has always written.
 */
 const resolveServices = async (props) => {
-	if (props.services !== void 0) {
-		const services = parseConfigInitServices(props.services, (used, canonical) => log.warning(deprecatedServiceMessage(used, canonical)));
-		if (services.includes("realtime")) assertRealtimeAvailable(props.apiHost);
-		return services;
-	}
+	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();
@@ -456,22 +451,14 @@ const builder = (argv) => argv.usage("$0 config <sub-command> [options]").option
 }))).command("ai-gateway", "Enable the AI Gateway (aiGateway: true)", addSharedOptions, (args) => addCmd(addProps(args, {
 	kind: "service",
 	service: "ai-gateway"
-}))).command({
-	command: "realtime",
-	describe: stagingFeaturesEnabledForArgv() ? "Enable Realtime (preview.realtime: true)" : false,
-	builder: (yargs) => addSharedOptions(yargs).option("allowed-origin", {
-		describe: "Allowed browser origin (repeatable). \"*\" allows every origin",
-		type: "array",
-		string: true
-	}),
-	handler: (args) => {
-		assertRealtimeAvailable();
-		return 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", {
+}))).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
@@ -510,7 +497,7 @@ const builder = (argv) => argv.usage("$0 config <sub-command> [options]").option
 	},
 	services: servicesOption({
 		key: "services",
-		allowed: listedServices(NEON_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."
 	}),
@@ -541,8 +528,7 @@ const liveConfigView = async (opts) => {
 		branchId: opts.branchId,
 		...opts.apiKey ? { apiKey: opts.apiKey } : {},
 		...opts.apiHost ? { apiHost: opts.apiHost } : {},
-		...opts.runtimeApi ? { api: opts.runtimeApi } : {},
-		realtime: stagingFeaturesEnabled(opts.apiHost)
+		...opts.runtimeApi ? { api: opts.runtimeApi } : {}
 	});
 	const resolved = resolveConfig(live.config, {
 		name: live.branch.name,
@@ -569,7 +555,6 @@ const loadConfig = async (props) => {
 		contextFile: props.contextFile,
 		...props.config ? { path: props.config } : {}
 	});
-	assertPolicyAvailable(config, props.apiHost);
 	return config;
 };
 const status = async (props) => {
@@ -994,7 +979,6 @@ const applyPolicyOnCreate = async (props) => {
 		if (/Could not find a Neon config file/i.test(message)) return;
 		throw err;
 	}
-	assertPolicyAvailable(config, props.apiHost);
 	try {
 		warnDeprecatedPreview(config, await warningTargetForExistingBranch({
 			projectId: props.projectId,
@@ -1079,7 +1063,6 @@ const createBranchFromPolicyOnCheckout = async (props) => {
 		if (/Could not find a Neon config file/i.test(message)) return null;
 		throw err;
 	}
-	assertPolicyAvailable(config, props.apiHost);
 	await assertAiGatewayProvisionableFromCreds({
 		projectId: props.projectId,
 		...props.apiKey ? { apiKey: props.apiKey } : {},

package/dist/commands/dev.js

@@ -6,7 +6,7 @@ import { readEnvFile, resolveEnvFilePath } from "../env_file.js";
 import { l as functionBaseUrlKey } from "../_chunks/env-BpP3Dqpe.js";
 import { branchIdResolve } from "../utils/enrichers.js";
 import { bundleEntry } from "../utils/esbuild.js";
-import { a as resolveDevEnv } from "../_chunks/env-4WGRW2nw.js";
+import { a as resolveDevEnv } from "../_chunks/env-BNm69Qh8.js";
 import { findConfigFunctionBySource, resolveFunctionsFromConfig } from "../dev/functions.js";
 import { resolveWatchInputs } from "../dev/inputs.js";
 import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";

package/dist/commands/env.js

@@ -7,10 +7,9 @@ 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-BpP3Dqpe.js";
 import { ENV_PULL_KEY_HELP, ENV_PULL_SERVICES, envKeysForSelection, envPullFlagValue, ownedEnvServiceKeys, parseEnvPullKeys } from "../env_services.js";
-import { listedServices } from "../utils/staging.js";
 import { fillSingleProject, resolveBranchRef } from "../utils/enrichers.js";
 import { warnAiGateway } from "../utils/ai_gateway_notice.js";
-import { i as dropClaimableUnsupported, o as resolveNeonEnvVars } from "../_chunks/env-4WGRW2nw.js";
+import { i as dropClaimableUnsupported, o as resolveNeonEnvVars } from "../_chunks/env-BNm69Qh8.js";
 import { formatPulledEnv, pulledBranch } from "./env_output.js";
 import { existsSync } from "node:fs";
 import chalk from "chalk";
@@ -48,7 +47,7 @@ const builder = (argv) => argv.usage("$0 env <sub-command> [options]").options({
 	},
 	service: servicesOption({
 		key: "service",
-		allowed: listedServices(ENV_PULL_SERVICES),
+		allowed: ENV_PULL_SERVICES,
 		describe: "Pull only these services' variables",
 		also: "Overrides neon.ts, and prunes only within the services you name. Combines with --env as a union."
 	}),

package/dist/commands/init.js

@@ -2,7 +2,6 @@ import { t as __exportAll } from "../_chunks/rolldown-runtime-8H4AJuhK.js";
 import { getCliName } from "../utils/cli_name.js";
 import { helpCsv, helpEpilogue } from "../utils/help_text.js";
 import { NEON_SERVICES, servicesOption } from "../neon_services.js";
-import { listedServices } from "../utils/staging.js";
 import { coerceAgentFlag } from "../utils/agent_flag.js";
 import { initPluginAgents, initSkillsMcpAgents } from "../init/plan.js";
 import { listSkillIds } from "../skills/catalog.js";
@@ -52,7 +51,7 @@ const builder = (yargs) => yargs.usage("$0 init [options]").option("context-file
 	describe: "Create neon.ts after linking. Use --no-config to skip. Omitted in Custom: you will be asked"
 }).option("services", servicesOption({
 	key: "services",
-	allowed: listedServices(NEON_SERVICES),
+	allowed: NEON_SERVICES,
 	describe: "Services to declare in neon.ts",
 	also: "postgres alone writes the starter policy; every branch has Postgres. Implies creating neon.ts. Cannot be combined with --no-config."
 })).option("org-id", {

package/dist/commands/manifest.js

@@ -1,5 +1,4 @@
 import { getCliName } from "../utils/cli_name.js";
-import { REALTIME_COMING_SOON } from "../utils/staging.js";
 import { Parser } from "yargs/helpers";
 //#region src/commands/manifest.ts
 /**
@@ -190,8 +189,7 @@ const commandManifest = [
 	{
 		command: "realtime",
 		describe: "Manage Neon Realtime for a branch",
-		load: () => import("./realtime.js"),
-		stagingOnly: REALTIME_COMING_SOON
+		load: () => import("./realtime.js")
 	},
 	{
 		command: "functions",

package/dist/commands/subscribe.js

@@ -1,16 +1,16 @@
 import { writer } from "../writer.js";
 import { branchIdFromProps } from "../utils/enrichers.js";
-import { o as resolveNeonEnvVars } from "../_chunks/env-4WGRW2nw.js";
+import { o as resolveNeonEnvVars } from "../_chunks/env-BNm69Qh8.js";
 import YAML from "yaml";
 //#region src/commands/subscribe.ts
 const builder = (argv) => argv.usage("$0 realtime subscribe \"<query>\" [options]").positional("query", {
 	describe: "SELECT query to subscribe to",
 	type: "string"
 }).options({ changes: {
-	describe: "Show raw resets and transaction batches",
+	describe: "Show raw rows and changes events",
 	type: "boolean",
 	default: false
-} }).example("$0 realtime subscribe \"SELECT * FROM items\"", "Print the initial result followed by a readable transaction log").example("$0 realtime subscribe --changes \"SELECT * FROM items\"", "Print raw reset and delta events").epilogue("The subscription runs until interrupted. Terminal output is an append-only snapshot and transaction log; JSON output is newline-delimited; YAML output uses one document per event.").strict();
+} }).example("$0 realtime subscribe \"SELECT * FROM items\"", "Print the initial result followed by a readable transaction log").example("$0 realtime subscribe --changes \"SELECT * FROM items\"", "Print raw rows and changes events").epilogue("The subscription runs until interrupted. Terminal output is an append-only snapshot and transaction log; JSON output is newline-delimited; YAML output uses one document per event.").strict();
 const handler = async (args) => {
 	const props = args;
 	const controller = new AbortController();
@@ -140,16 +140,16 @@ const createRenderer = (props, context, now) => {
 			return;
 		}
 		out.write("\n");
-		if (event.type === "reset" && !props.changes) {
-			const label = hasBaseline ? "Reset" : "Initial snapshot";
+		if (event.type === "rows" && !props.changes) {
+			const label = hasBaseline ? "Rows" : "Initial snapshot";
 			hasBaseline = true;
 			rowsById.clear();
 			for (const { rowId, row } of event.rows) rowsById.set(rowId, row);
 			renderMaterializedRows(out, event.rows.map(({ row }) => row), `${timestamp(now)} ${label}`);
 			return;
 		}
-		if (event.type === "batch" && !props.changes) {
-			renderHumanBatch(out, event, rowsById, now);
+		if (event.type === "changes" && !props.changes) {
+			renderHumanChanges(out, event, rowsById, now);
 			return;
 		}
 		renderTableEvent(out, event, now);
@@ -160,12 +160,12 @@ const renderTableEvent = (out, event, now) => {
 		renderMaterializedRows(out, event.rows, `${timestamp(now)} Snapshot`);
 		return;
 	}
-	if (event.type === "reset") {
+	if (event.type === "rows") {
 		const rows = event.rows.map(({ rowId, row }) => ({
 			row_id: rowId,
 			row
 		}));
-		renderRows(out, rows, ["row_id", "row"], `${timestamp(now)} Reset · ${rowCount(rows.length)}`, "Reset contains no rows.");
+		renderRows(out, rows, ["row_id", "row"], `${timestamp(now)} Rows · ${rowCount(rows.length)}`, "Rows event contains no rows.");
 		return;
 	}
 	const rows = event.changes.map((change) => ({
@@ -177,7 +177,7 @@ const renderTableEvent = (out, event, now) => {
 		"type",
 		"row_id",
 		"row"
-	], `${timestamp(now)} ${transactionLabel(event.txids)} · ${rawChangeSummary(event.changes)}`, "Batch contains no row changes.");
+	], `${timestamp(now)} ${transactionLabel(event.txids)} · ${rawChangeSummary(event.changes)}`, "Changes event contains no row changes.");
 };
 const renderHumanHeader = (out, context, rawChanges) => {
 	const target = {
@@ -205,18 +205,18 @@ const renderMaterializedRows = (out, rows, title) => {
 	const humanTitle = `${title} · ${rowCount(rows.length)}`;
 	renderRows(out, rows, rowFields(rows), humanTitle, "Query returned no rows.");
 };
-const renderHumanBatch = (out, event, rowsById, now) => {
+const renderHumanChanges = (out, event, rowsById, now) => {
 	const changes = classifyChanges(event.changes, rowsById);
 	const inserted = changes.filter((change) => change.operation === "+ insert");
 	const updated = changes.filter((change) => change.operation === "~ update");
 	const deleted = changes.filter((change) => change.operation === "- delete");
-	const rowFieldsInBatch = rowFields(changes.flatMap((change) => change.row ? [change.row] : []));
-	const operationField = uniqueOperationField(rowFieldsInBatch);
+	const rowFieldsInChanges = rowFields(changes.flatMap((change) => change.row ? [change.row] : []));
+	const operationField = uniqueOperationField(rowFieldsInChanges);
 	const rows = changes.map((change) => ({
 		...change.row ?? {},
 		[operationField]: change.operation
 	}));
-	renderRows(out, rows, [operationField, ...rowFieldsInBatch], `${timestamp(now)} ${transactionLabel(event.txids)} · +${inserted.length} ~${updated.length} -${deleted.length}`, "Transaction contains no row changes.");
+	renderRows(out, rows, [operationField, ...rowFieldsInChanges], `${timestamp(now)} ${transactionLabel(event.txids)} · +${inserted.length} ~${updated.length} -${deleted.length}`, "Transaction contains no row changes.");
 };
 const renderRows = (out, rows, fields, title, emptyMessage) => {
 	writer({
@@ -292,11 +292,11 @@ const consumeSnapshots = async (subscription, render, signal) => consumeSubscrip
 }))], render, signal);
 const consumeChanges = async (subscription, render, signal) => consumeSubscription(subscription, (fail) => [subscription.onUpdate((update) => {
 	if (update.type === "rows") attempt(fail, () => render({
-		type: "reset",
+		type: "rows",
 		rows: update.rows
 	}));
 	else attempt(fail, () => render({
-		type: "batch",
+		type: "changes",
 		txids: update.batch.txids,
 		changes: update.changes
 	}));

package/dist/credential_io.js

@@ -1,2 +1 @@
-import { t as storeFor } from "./_chunks/credential_io-ByNuojoE.js";
-export { storeFor };
+export { t as storeFor } from "./_chunks/credential_io-ByNuojoE.js";

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/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/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";
@@ -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 } : {},

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 };