From e5d6be41233fba5f91948e11b4201dc01c0442ec Mon Sep 17 00:00:00 2001 From: gsxdsm Date: Wed, 22 Jul 2026 23:41:48 -0700 Subject: [PATCH] Fix Windows embedded PostgreSQL 0xC0000142 crashes (issue #2411) (#2418) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary Two-part fix for #2411 — Windows embedded PostgreSQL backends dying with exception `0xC0000142` and taking the whole dashboard down. ### 1. Crash hardening + recovery (FN-8522) - Child-only native `PATH` hardening so forked backends can always resolve their runtime DLLs. - Non-blocking `.pgrunner` log monitoring (shared read), eliminating the self-inflicted ~30s `sharing violation` retry window at boot. - Detection of the ordered 0xC0000142 shutdown sequence with a single automatic restart of owned clusters on their resolved port, plus operator diagnostics. ### 2. Platform-aware `max_connections` default (follow-up from [operator report](https://github.com/Runfusion/Fusion/issues/2411#issuecomment-5054900702)) On Windows every PostgreSQL connection is a separate process; the embedded cluster's unconfigured `max_connections=500` cap lets backend spawn bursts exhaust the non-interactive desktop heap, which kills forked backends with exactly `0xC0000142`. The reporter confirmed stability after lowering the cap. - `embeddedPostgresMaxConnections` is now schema-unset so the server can distinguish "operator never set it" from an explicit choice (`getSettings()` merges schema defaults, which previously pinned 500 unconditionally and made the runtime fallback dead code). - New `resolveEmbeddedMaxConnections()` resolves the unset default platform-aware: **150 on win32, 500 elsewhere**. Explicit settings are honored on every platform, clamped to [32, 2000] as before. - Settings UI renders the cap empty ("auto") with platform-aware help copy across all six locales. - Fixed a latent reset bug this exposed: global "Reset this menu" wrote `undefined` for undefined-default keys, which JSON serialization drops — the stored value silently survived reset. Now uses null-as-delete. ## Testing - New unit tests for `resolveEmbeddedMaxConnections` (platform defaults, clamping, non-integer handling). - Updated settings-defaults, default-descriptions, and SettingsModal tests; embedded lifecycle + recovery coverage from FN-8522. - `@fusion/core` builds clean; changesets included for both parts. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Fable 5 --- ...-windows-embedded-pg-connection-default.md | 7 +++ .../src/__test-utils__/pg-test-harness.ts | 31 +++++++++++-- .../postgres/embedded-lifecycle.test.ts | 43 +++++++++++++++++++ .../src/__tests__/settings-defaults.test.ts | 10 ++++- .../core/src/postgres/embedded-lifecycle.ts | 31 +++++++++++++ packages/core/src/postgres/startup-factory.ts | 16 +++++-- packages/core/src/settings-schema.ts | 16 +++++-- .../app/components/SettingsModal.tsx | 9 +++- .../__tests__/SettingsModal.general.test.tsx | 10 ++++- .../sections/DatabaseBackupsSection.tsx | 7 +-- .../settings-default-descriptions.test.tsx | 4 +- packages/i18n/locales/en/app.json | 5 ++- packages/i18n/locales/es/app.json | 5 ++- packages/i18n/locales/fr/app.json | 5 ++- packages/i18n/locales/ko/app.json | 5 ++- packages/i18n/locales/zh-CN/app.json | 5 ++- packages/i18n/locales/zh-TW/app.json | 5 ++- 17 files changed, 181 insertions(+), 33 deletions(-) create mode 100644 .changeset/fn-windows-embedded-pg-connection-default.md diff --git a/.changeset/fn-windows-embedded-pg-connection-default.md b/.changeset/fn-windows-embedded-pg-connection-default.md new file mode 100644 index 0000000000..75cf8f52ad --- /dev/null +++ b/.changeset/fn-windows-embedded-pg-connection-default.md @@ -0,0 +1,7 @@ +--- +"@runfusion/fusion": patch +--- + +summary: Lower the embedded PostgreSQL default connection cap to 150 on Windows to prevent 0xC0000142 backend crashes. +category: fix +dev: Issue #2411 — embeddedPostgresMaxConnections is now schema-unset; resolveEmbeddedMaxConnections picks win32 150 / else 500, explicit settings still clamp to [32, 2000]. diff --git a/packages/core/src/__test-utils__/pg-test-harness.ts b/packages/core/src/__test-utils__/pg-test-harness.ts index 3d61c266d7..affd881f1a 100644 --- a/packages/core/src/__test-utils__/pg-test-harness.ts +++ b/packages/core/src/__test-utils__/pg-test-harness.ts @@ -516,10 +516,33 @@ function ensureGoldenTemplate(): Promise { // the lock. A sibling fork blocks on pg_advisory_lock until the winner has // fully built the golden template and recorded its ready marker. await withMaintenanceSql(async (client) => { - // Ensure the readiness marker table exists before any read/write of it. - await client.unsafe( - `CREATE TABLE IF NOT EXISTS ${GOLDEN_MARKER_QUALIFIED} (name text PRIMARY KEY, created_at timestamptz NOT NULL DEFAULT now())`, - ); + /* + FNXC:PgTestTemplateDb 2026-07-22-23:45: + Ensure the readiness marker table exists before any read/write of it. + `CREATE TABLE IF NOT EXISTS` is NOT concurrency-safe in PostgreSQL: two + sessions that both observe "not exists" race to insert the table's + composite-type row, and the loser aborts with `duplicate key value + violates unique constraint "pg_type_typname_nsp_index"`. On a fresh CI + cluster the gate's vitest forks all reach this line together on first + contact, which turned the merge gate red repo-wide (first seen + 2026-07-23 01:25 UTC); long-lived local clusters already have the table, + so the race never reproduces locally. Serialize the one-time DDL under + its own advisory lock (this session already uses session-level advisory + locks for the golden build below), and additionally swallow the two + benign "lost the race" errors — duplicate_table (42P07) and the pg_type + unique violation (23505) — since either one proves a sibling created it. + */ + await client`SELECT pg_advisory_lock(hashtext('fusion_golden_marker_table_ddl'))`; + try { + await client.unsafe( + `CREATE TABLE IF NOT EXISTS ${GOLDEN_MARKER_QUALIFIED} (name text PRIMARY KEY, created_at timestamptz NOT NULL DEFAULT now())`, + ); + } catch (error) { + const code = (error as { code?: string }).code; + if (code !== "42P07" && code !== "23505") throw error; + } finally { + await client`SELECT pg_advisory_unlock(hashtext('fusion_golden_marker_table_ddl'))`; + } // Sweep templates orphaned by crashed/finished processes and drop marker // rows whose golden database no longer exists. const rows = await client<{ datname: string }[]>` diff --git a/packages/core/src/__tests__/postgres/embedded-lifecycle.test.ts b/packages/core/src/__tests__/postgres/embedded-lifecycle.test.ts index 56a8391aa6..1922ca9a1c 100644 --- a/packages/core/src/__tests__/postgres/embedded-lifecycle.test.ts +++ b/packages/core/src/__tests__/postgres/embedded-lifecycle.test.ts @@ -35,6 +35,9 @@ import { DEFAULT_START_TIMEOUT_MS, DEFAULT_EMBEDDED_POSTGRES_FLAGS, defaultEmbeddedPostgresFlagsFor, + resolveEmbeddedMaxConnections, + DEFAULT_EMBEDDED_MAX_CONNECTIONS, + DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32, isDataDirInitialized, isWindowsElevatedAdmin, normalizeMacosEmbeddedPostgresDylibSymlinks, @@ -1461,6 +1464,46 @@ describe("embedded-lifecycle: shared-memory-safe postgres flags", () => { }); }); +describe("embedded-lifecycle: platform-aware max_connections default (issue #2411)", () => { + /* + * FNXC:PostgresEmbedded 2026-07-22-23:55: + * Issue #2411: on Windows each connection is a separate postgres.exe process; a + * max_connections=500 cap exhausts the non-interactive desktop heap during + * backend spawn bursts and forked backends die with 0xC0000142, taking the + * cluster (and dashboard) down. The reporter confirmed stability after lowering + * the cap. The UNSET default must therefore be lower on win32 (150) than + * elsewhere (500), while an explicit operator setting is honored on every + * platform, clamped to [32, 2000]. + */ + it.each([ + ["win32", DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32], + ["darwin", DEFAULT_EMBEDDED_MAX_CONNECTIONS], + ["linux", DEFAULT_EMBEDDED_MAX_CONNECTIONS], + ] as const)("unset resolves the platform default on %s", (platform, expected) => { + expect(resolveEmbeddedMaxConnections(undefined, platform)).toBe(expected); + }); + + it("keeps the win32 default materially below the general default", () => { + expect(DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32).toBeLessThan(DEFAULT_EMBEDDED_MAX_CONNECTIONS); + expect(DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32).toBeLessThanOrEqual(150); + }); + + it.each(["win32", "darwin", "linux"] as const)( + "an explicit operator setting is honored and clamped to [32, 2000] on %s", + (platform) => { + expect(resolveEmbeddedMaxConnections(100, platform)).toBe(100); + expect(resolveEmbeddedMaxConnections(500, platform)).toBe(500); + expect(resolveEmbeddedMaxConnections(5, platform)).toBe(32); + expect(resolveEmbeddedMaxConnections(9_999, platform)).toBe(2_000); + }, + ); + + it("treats non-integer configured values as unset", () => { + expect(resolveEmbeddedMaxConnections(Number.NaN, "win32")).toBe(DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32); + expect(resolveEmbeddedMaxConnections(250.5, "linux")).toBe(DEFAULT_EMBEDDED_MAX_CONNECTIONS); + }); +}); + describe("embedded-lifecycle: signal re-raise (P1 #23)", () => { it("boundShutdown re-raises real signals via process.kill (unit, no process)", async () => { // Verify the signal re-raise logic without a real cluster: construct a diff --git a/packages/core/src/__tests__/settings-defaults.test.ts b/packages/core/src/__tests__/settings-defaults.test.ts index b055b6ad2e..876fa6ea7d 100644 --- a/packages/core/src/__tests__/settings-defaults.test.ts +++ b/packages/core/src/__tests__/settings-defaults.test.ts @@ -36,8 +36,14 @@ describe("settings defaults invariants", () => { expect(isGlobalOnlySettingsKey("localNetworkDiscoveryEnabled")).toBe(true); }); - it("keeps the embedded PostgreSQL connection cap global and high by default", () => { - expect(DEFAULT_GLOBAL_SETTINGS.embeddedPostgresMaxConnections).toBe(500); + it("keeps the embedded PostgreSQL connection cap global and schema-unset so the server resolves a platform-aware default", () => { + /* + FNXC:PostgresEmbedded 2026-07-22-23:55: + Issue #2411: the schema default must stay undefined. getSettings() merges + DEFAULT_GLOBAL_SETTINGS, so a concrete value here would look operator-set and + defeat resolveEmbeddedMaxConnections' win32-lowered default (150 vs 500). + */ + expect(DEFAULT_GLOBAL_SETTINGS.embeddedPostgresMaxConnections).toBeUndefined(); expect(GLOBAL_SETTINGS_KEYS).toContain("embeddedPostgresMaxConnections"); expect(PROJECT_SETTINGS_KEYS).not.toContain("embeddedPostgresMaxConnections"); }); diff --git a/packages/core/src/postgres/embedded-lifecycle.ts b/packages/core/src/postgres/embedded-lifecycle.ts index 50ecdbf90a..74a0074d70 100644 --- a/packages/core/src/postgres/embedded-lifecycle.ts +++ b/packages/core/src/postgres/embedded-lifecycle.ts @@ -683,6 +683,37 @@ export function defaultEmbeddedPostgresFlagsFor(platform: NodeJS.Platform): read export const DEFAULT_EMBEDDED_POSTGRES_FLAGS = defaultEmbeddedPostgresFlagsFor(process.platform); +/* + * FNXC:PostgresEmbedded 2026-07-22-23:55: + * Issue #2411 (operator-confirmed on 0.73.0-beta.2): on Windows every PostgreSQL + * connection is a separate postgres.exe process, and standing up backends against a + * max_connections=500 cap exhausts the non-interactive desktop heap during connection + * bursts. A forked backend then dies in DLL/session init with exception 0xC0000142, + * the postmaster terminates all other backends, and the whole embedded cluster — and + * with it the dashboard — goes down. The reporter measured stability at a cap of 100 + * after repeated crashes at 500. Default the cap platform-aware: 150 on win32 (well + * above Fusion's own pool usage of ~3 connections per connection set), 500 elsewhere. + * An operator-configured embeddedPostgresMaxConnections is always honored, clamped to + * [32, 2000] on every platform — the lower win32 number is only the unset default. + * This complements, not replaces, the FN-8522 child PATH hardening and single-restart + * recovery for the same 0xC0000142 signature. + */ +export const DEFAULT_EMBEDDED_MAX_CONNECTIONS = 500; +export const DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32 = 150; +export const EMBEDDED_MAX_CONNECTIONS_MIN = 32; +export const EMBEDDED_MAX_CONNECTIONS_MAX = 2_000; + +/** Resolve the effective embedded-cluster max_connections from the optional operator setting. */ +export function resolveEmbeddedMaxConnections( + configured: number | undefined, + platform: NodeJS.Platform = process.platform, +): number { + if (typeof configured === "number" && Number.isInteger(configured)) { + return Math.min(EMBEDDED_MAX_CONNECTIONS_MAX, Math.max(EMBEDDED_MAX_CONNECTIONS_MIN, configured)); + } + return platform === "win32" ? DEFAULT_EMBEDDED_MAX_CONNECTIONS_WIN32 : DEFAULT_EMBEDDED_MAX_CONNECTIONS; +} + /* FNXC:PostgresEmbedded 2026-07-18-00:20: GitHub issue #2286: initdb without --encoding inherits the OS locale's diff --git a/packages/core/src/postgres/startup-factory.ts b/packages/core/src/postgres/startup-factory.ts index 91118fcf93..b0323e286c 100644 --- a/packages/core/src/postgres/startup-factory.ts +++ b/packages/core/src/postgres/startup-factory.ts @@ -397,7 +397,7 @@ async function bootSchemaBackendOnce( let resolvedBackend = backend; let embeddedDataDir: string | null = null; if (backend.mode === "embedded") { - const { EmbeddedPostgresLifecycle, defaultEmbeddedDataDir, DEFAULT_EMBEDDED_DATABASE } = + const { EmbeddedPostgresLifecycle, defaultEmbeddedDataDir, DEFAULT_EMBEDDED_DATABASE, resolveEmbeddedMaxConnections } = await import("./embedded-lifecycle.js"); const { GlobalSettingsStore } = await import("../global-settings.js"); // Tests that boot an embedded backend intentionally do not have an @@ -406,9 +406,17 @@ async function bootSchemaBackendOnce( const configuredMaxConnections = process.env.VITEST === "true" && !options.globalSettingsDir ? undefined : (await new GlobalSettingsStore(options.globalSettingsDir).getSettings()).embeddedPostgresMaxConnections; - const maxConnections = Number.isInteger(configuredMaxConnections) - ? Math.min(2_000, Math.max(32, configuredMaxConnections!)) - : 500; + /* + FNXC:PostgresEmbedded 2026-07-22-23:55: + Issue #2411: the unset default is platform-aware (win32 150, else 500) because + Windows backends are separate processes and a 500-connection cap exhausts the + desktop heap under load, killing forked backends with 0xC0000142 and taking the + dashboard down. embeddedPostgresMaxConnections is deliberately undefined in + DEFAULT_GLOBAL_SETTINGS so this server-side resolution can see "operator never + set it" — a concrete schema default would be merged in by getSettings() and + mask the platform choice. + */ + const maxConnections = resolveEmbeddedMaxConnections(configuredMaxConnections); const dataDir = resolve(options.embeddedDataDir ?? defaultEmbeddedDataDir()); embeddedDataDir = dataDir; log.log(`startup-factory: starting embedded PostgreSQL (data dir ${dataDir})`); diff --git a/packages/core/src/settings-schema.ts b/packages/core/src/settings-schema.ts index 3b8a0e6d97..da0635f649 100644 --- a/packages/core/src/settings-schema.ts +++ b/packages/core/src/settings-schema.ts @@ -72,10 +72,18 @@ type ProjectSettingsSchema = Omit = {}; for (const key of activeSectionResetEntry.keys) { - patch[key] = (DEFAULT_GLOBAL_SETTINGS as Record)[key]; + /* + FNXC:SettingsReset 2026-07-22-23:55: + Issue #2411: global keys whose canonical default is undefined (e.g. + embeddedPostgresMaxConnections, resolved platform-aware server-side) + must reset via null-as-delete. A literal undefined is dropped by JSON + serialization, so the stored value would silently survive the reset. + */ + patch[key] = (DEFAULT_GLOBAL_SETTINGS as Record)[key] ?? null; } await updateGlobalSettings(patch); } else { diff --git a/packages/dashboard/app/components/__tests__/SettingsModal.general.test.tsx b/packages/dashboard/app/components/__tests__/SettingsModal.general.test.tsx index 7e17015975..f693fd9b42 100644 --- a/packages/dashboard/app/components/__tests__/SettingsModal.general.test.tsx +++ b/packages/dashboard/app/components/__tests__/SettingsModal.general.test.tsx @@ -1441,9 +1441,15 @@ describe("SettingsModal", () => { renderModal({ initialSection: "backups-global" }); await waitForSettingsModalReady(); - expect(screen.getByLabelText("Embedded PostgreSQL connection cap")).toHaveValue(500); + /* + FNXC:PostgresEmbedded 2026-07-22-23:55: + Issue #2411: the cap is schema-unset so the server can resolve a platform-aware + default (win32 150, else 500). The input therefore renders empty ("auto"), not 500. + */ + expect(screen.getByLabelText("Embedded PostgreSQL connection cap")).toHaveValue(null); + expect(screen.getByLabelText("Embedded PostgreSQL connection cap")).toHaveAttribute("placeholder", "auto"); expect(screen.getByTestId("settings-help-embeddedPostgresMaxConnections")).toBeInTheDocument(); - expect(screen.getByText("Maximum server connections for Fusion's embedded PostgreSQL. Applies after restarting Fusion. Range: 32–2,000. Default: 500. External PostgreSQL uses its provider's connection limit.").closest(".settings-help-bubble")).toBeTruthy(); + expect(screen.getByText("Maximum server connections for Fusion's embedded PostgreSQL. Applies after restarting Fusion. Range: 32–2,000. Unset by default — Fusion picks 500, or 150 on Windows where each connection is a separate process and higher caps can crash backends. External PostgreSQL uses its provider's connection limit.").closest(".settings-help-bubble")).toBeTruthy(); }); it("saves ephemeral agent toggle in project settings payload", async () => { diff --git a/packages/dashboard/app/components/settings/sections/DatabaseBackupsSection.tsx b/packages/dashboard/app/components/settings/sections/DatabaseBackupsSection.tsx index 1c1c52aa0b..1c9bad8001 100644 --- a/packages/dashboard/app/components/settings/sections/DatabaseBackupsSection.tsx +++ b/packages/dashboard/app/components/settings/sections/DatabaseBackupsSection.tsx @@ -50,13 +50,14 @@ export function DatabaseBackupsSection({ form, setForm, backupInfo, backupLoadin descriptor={{ key: "embeddedPostgresMaxConnections", label: t("settings.database.embeddedConnectionCap", "Embedded PostgreSQL connection cap"), - help: t("settings.database.embeddedConnectionCapHelp", "Maximum server connections for Fusion's embedded PostgreSQL. Applies after restarting Fusion. Range: 32–2,000. Default: 500. External PostgreSQL uses its provider's connection limit."), + help: t("settings.database.embeddedConnectionCapHelp", "Maximum server connections for Fusion's embedded PostgreSQL. Applies after restarting Fusion. Range: 32–2,000. Unset by default — Fusion picks 500, or 150 on Windows where each connection is a separate process and higher caps can crash backends. External PostgreSQL uses its provider's connection limit."), scope: "global", min: 32, max: 2000, + placeholder: t("settings.database.embeddedConnectionCapPlaceholder", "auto"), }} - value={form.embeddedPostgresMaxConnections ?? 500} - onChange={(v) => setForm((f) => ({ ...f, embeddedPostgresMaxConnections: v ?? 500 }))} + value={form.embeddedPostgresMaxConnections ?? null} + onChange={(v) => setForm((f) => ({ ...f, embeddedPostgresMaxConnections: v ?? undefined }))} error={form.embeddedPostgresMaxConnections !== undefined && (form.embeddedPostgresMaxConnections < 32 || form.embeddedPostgresMaxConnections > 2000) ? t("settings.database.embeddedConnectionCapError", "Enter a value between 32 and 2,000.") : undefined} diff --git a/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx b/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx index 82829a8f1a..7380b44d4e 100644 --- a/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx +++ b/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx @@ -167,7 +167,9 @@ const SETTING_DESCRIPTION_KEYS: Record = { /* FNXC:SettingsDefaults 2026-07-17-13:55: FN-8335 restores FN-7505 default-value parity for the surfaced embeddedPostgresMaxConnections - control. The English locale description is the canonical rendered SettingsHelpTip copy and states Default: 500. + control. Issue #2411 made the schema default undefined (server resolves win32 150 / else 500), + so the canonical English copy now uses unset phrasing ("Unset by default — Fusion picks …") + and must not make a concrete "Default:" colon claim. */ embeddedPostgresMaxConnections: "database.embeddedConnectionCapHelp", // MemorySection diff --git a/packages/i18n/locales/en/app.json b/packages/i18n/locales/en/app.json index e6a25e2689..422cc19348 100644 --- a/packages/i18n/locales/en/app.json +++ b/packages/i18n/locales/en/app.json @@ -6854,10 +6854,11 @@ "allProjectResetSuccess": "All project settings reset to defaults" }, "database": { - "embeddedConnectionCapHelp": "Maximum server connections for Fusion's embedded PostgreSQL. Applies after restarting Fusion. Range: 32–2,000. Default: 500. External PostgreSQL uses its provider's connection limit.", + "embeddedConnectionCapHelp": "Maximum server connections for Fusion's embedded PostgreSQL. Applies after restarting Fusion. Range: 32–2,000. Unset by default — Fusion picks 500, or 150 on Windows where each connection is a separate process and higher caps can crash backends. External PostgreSQL uses its provider's connection limit.", "embeddedConnectionCap": "Embedded PostgreSQL connection cap", "embeddedConnectionCapError": "Enter a value between 32 and 2,000.", - "advanced": "Advanced database settings" + "advanced": "Advanced database settings", + "embeddedConnectionCapPlaceholder": "auto" }, "configVersions": { "title": "Configuration versions", diff --git a/packages/i18n/locales/es/app.json b/packages/i18n/locales/es/app.json index 1562cf34d7..7cacbd6f15 100644 --- a/packages/i18n/locales/es/app.json +++ b/packages/i18n/locales/es/app.json @@ -6839,10 +6839,11 @@ "allProjectResetSuccess": "" }, "database": { - "embeddedConnectionCapHelp": "Máximo de conexiones de servidor para el PostgreSQL integrado de Fusion. Se aplica al reiniciar Fusion. Rango: 32–2.000. Predeterminado: 500. PostgreSQL externo usa el límite de su proveedor.", + "embeddedConnectionCapHelp": "Máximo de conexiones de servidor para el PostgreSQL integrado de Fusion. Se aplica al reiniciar Fusion. Rango: 32–2.000. Sin valor establecido por defecto: Fusion elige 500, o 150 en Windows, donde cada conexión es un proceso independiente y límites más altos pueden bloquear los procesos backend. PostgreSQL externo usa el límite de su proveedor.", "embeddedConnectionCap": "Límite de conexiones de PostgreSQL integrado", "embeddedConnectionCapError": "Introduce un valor entre 32 y 2.000.", - "advanced": "Ajustes avanzados de base de datos" + "advanced": "Ajustes avanzados de base de datos", + "embeddedConnectionCapPlaceholder": "auto" }, "configVersions": { "title": "Versiones de configuración", diff --git a/packages/i18n/locales/fr/app.json b/packages/i18n/locales/fr/app.json index d2d75b2da2..b3940a5f0a 100644 --- a/packages/i18n/locales/fr/app.json +++ b/packages/i18n/locales/fr/app.json @@ -6839,10 +6839,11 @@ "allProjectResetSuccess": "" }, "database": { - "embeddedConnectionCapHelp": "Nombre maximal de connexions serveur pour le PostgreSQL embarqué de Fusion. Appliqué après redémarrage de Fusion. Plage : 32–2 000. Par défaut : 500. PostgreSQL externe utilise la limite de son fournisseur.", + "embeddedConnectionCapHelp": "Nombre maximal de connexions serveur pour le PostgreSQL embarqué de Fusion. Appliqué après redémarrage de Fusion. Plage : 32–2 000. Non défini par défaut — Fusion choisit 500, ou 150 sous Windows où chaque connexion est un processus séparé et des plafonds plus élevés peuvent faire planter les backends. PostgreSQL externe utilise la limite de son fournisseur.", "embeddedConnectionCap": "Plafond de connexions PostgreSQL embarqué", "embeddedConnectionCapError": "Saisissez une valeur entre 32 et 2 000.", - "advanced": "Paramètres de base de données avancés" + "advanced": "Paramètres de base de données avancés", + "embeddedConnectionCapPlaceholder": "auto" }, "configVersions": { "title": "Versions de configuration", diff --git a/packages/i18n/locales/ko/app.json b/packages/i18n/locales/ko/app.json index 63ccd80f87..5107fc79b1 100644 --- a/packages/i18n/locales/ko/app.json +++ b/packages/i18n/locales/ko/app.json @@ -6839,10 +6839,11 @@ "allProjectResetSuccess": "" }, "database": { - "embeddedConnectionCapHelp": "Fusion 내장 PostgreSQL의 최대 서버 연결 수. Fusion 재시작 후 적용. 범위: 32–2,000. 기본값: 500. 외부 PostgreSQL은 제공자 연결 한도를 사용합니다.", + "embeddedConnectionCapHelp": "Fusion 내장 PostgreSQL의 최대 서버 연결 수. Fusion 재시작 후 적용. 범위: 32–2,000. 기본적으로 미설정 — Fusion이 500을 선택하며, 각 연결이 별도 프로세스인 Windows에서는 150을 사용합니다(높은 한도는 백엔드 충돌을 유발할 수 있음). 외부 PostgreSQL은 제공자 연결 한도를 사용합니다.", "embeddedConnectionCap": "내장 PostgreSQL 연결 상한", "embeddedConnectionCapError": "32에서 2,000 사이의 값을 입력하세요.", - "advanced": "고급 데이터베이스 설정" + "advanced": "고급 데이터베이스 설정", + "embeddedConnectionCapPlaceholder": "자동" }, "configVersions": { "title": "구성 버전", diff --git a/packages/i18n/locales/zh-CN/app.json b/packages/i18n/locales/zh-CN/app.json index a882fe0735..89215031a3 100644 --- a/packages/i18n/locales/zh-CN/app.json +++ b/packages/i18n/locales/zh-CN/app.json @@ -6839,10 +6839,11 @@ "description": "" }, "database": { - "embeddedConnectionCapHelp": "Fusion 嵌入式 PostgreSQL 的最大服务器连接数。重启 Fusion 后生效。范围：32–2,000。默认：500。外部 PostgreSQL 使用其提供方的连接限制。", + "embeddedConnectionCapHelp": "Fusion 嵌入式 PostgreSQL 的最大服务器连接数。重启 Fusion 后生效。范围：32–2,000。默认未设置 — Fusion 选择 500；在 Windows 上为 150，因为每个连接都是一个独立进程，更高的上限可能导致后端崩溃。外部 PostgreSQL 使用其提供方的连接限制。", "embeddedConnectionCap": "嵌入式 PostgreSQL 连接上限", "embeddedConnectionCapError": "请输入 32 到 2,000 之间的值。", - "advanced": "高级数据库设置" + "advanced": "高级数据库设置", + "embeddedConnectionCapPlaceholder": "自动" }, "configVersions": { "title": "配置版本", diff --git a/packages/i18n/locales/zh-TW/app.json b/packages/i18n/locales/zh-TW/app.json index 438dd051aa..0734a6ac2c 100644 --- a/packages/i18n/locales/zh-TW/app.json +++ b/packages/i18n/locales/zh-TW/app.json @@ -6839,10 +6839,11 @@ "allProjectResetSuccess": "" }, "database": { - "embeddedConnectionCapHelp": "Fusion 內嵌 PostgreSQL 的最大伺服器連線數。重新啟動 Fusion 後生效。範圍：32–2,000。預設：500。外部 PostgreSQL 使用其提供者的連線限制。", + "embeddedConnectionCapHelp": "Fusion 內嵌 PostgreSQL 的最大伺服器連線數。重新啟動 Fusion 後生效。範圍：32–2,000。預設未設定 — Fusion 選擇 500；在 Windows 上為 150，因為每個連線都是一個獨立程序，更高的上限可能導致後端當機。外部 PostgreSQL 使用其提供者的連線限制。", "embeddedConnectionCap": "內嵌 PostgreSQL 連線上限", "embeddedConnectionCapError": "請輸入 32 到 2,000 之間的值。", - "advanced": "進階資料庫設定" + "advanced": "進階資料庫設定", + "embeddedConnectionCapPlaceholder": "自動" }, "configVersions": { "title": "設定版本",