@prisma-next/language-server 0.14.0-dev.17

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2026] [Prisma Data, Inc]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,50 @@
+# @prisma-next/language-server
+
+> **Internal package.** This package is an implementation detail of [`prisma-next`](https://www.npmjs.com/package/prisma-next)
+> and is published only to support its runtime. Its API is unstable and may change
+> without notice. Do not depend on this package directly; install `prisma-next` instead.
+
+The Prisma Next language server. It speaks the Language Server Protocol over stdio and supports PSL parse diagnostics plus whole-document PSL formatting for the schema inputs declared in a project's `prisma-next.config.ts`. It is launched by the `prisma-next lsp` subcommand, so the editor features come from the project's own `@prisma-next` version (version-matched by construction).
+
+## Scope
+
+Supported capabilities are intentionally narrow: parse diagnostics and whole-document formatting for configured PSL inputs. Formatting is only available for documents listed in `contract.source.inputs`, uses `@prisma-next/psl-parser/format`, and applies formatter options from the project's Prisma config `formatter` block. Hover, completion, navigation, range formatting, on-type formatting, and editor-extension work are out of scope. A server process can manage multiple projects under the workspace root, keyed by the config file each open document belongs to.
+
+## How it works
+
+1. **`initialize`** — resolves the workspace root from the client's `rootUri` and registers config-file watching when the client supports it. Configs are loaded when matching documents open or when watched config files change. If a config cannot be loaded, the server does not manage that project.
+2. **Document sync** — text-document sync is **incremental**
+   (`TextDocumentSyncKind.Incremental`); the `TextDocuments` manager applies
+   incremental edits, and the server re-parses the full current buffer on each
+   change.
+3. **Diagnostics** — on `didOpen` / `didChange` of a document whose URI is a configured PSL input, the server runs `@prisma-next/psl-parser`'s `parse()` (the CST path) and `buildSymbolTable()`, then publishes the merged, mapped diagnostics via `textDocument/publishDiagnostics`. A clean document publishes an empty array (clearing markers). Documents that are not configured inputs publish nothing.
+4. **Formatting** — on `textDocument/formatting`, the server formats the current in-memory document text with `@prisma-next/psl-parser/format` when the document is a configured PSL input. It returns one whole-document edit when the formatted text differs, and returns no edits for missing or closed documents, unconfigured documents, already canonical text, malformed PSL, or invalid formatter options.
+5. **Preserved artifacts** — each project keeps the parse artifacts it produces:
+   the AST per open document (keyed by URI) and one symbol table per project,
+   rebuilt from the open configured input on each edit and dropped when the
+   document closes. They are exposed through `getDocumentAst` /
+   `getProjectSymbolTable` so future features (completion, semantic tokens) read
+   real stages instead of re-parsing. Filling the project table from several
+   inputs — and reading unopened inputs from disk — is deferred cross-file work.
+
+## Module layout
+
+- `diagnostic-mapping.ts` — pure `ParseDiagnostic[] → LspDiagnostic[]` mapping.
+  Free of any `vscode-languageserver` import; it returns plain shape objects
+  (ranges pass through unchanged) so it stays reusable. The connection layer
+  adapts the numeric severity to the LSP enum.
+- `schema-inputs.ts` — resolves the schema-input set (`SchemaInputSet`) from a
+  config and answers URI membership.
+- `config-resolution.ts` — wraps `loadConfig` and resolves schema inputs, formatter options, and control-stack inputs for a config. A standalone async function so it can be re-run on a config change without rewiring the server.
+- `document-diagnostics.ts` — `computeDocumentDiagnostics(uri, text, inputs, controlStack)`, the pure seam that parses, builds the symbol table, and returns the diagnostics plus the parse artifacts.
+- `project-artifacts.ts` — `createProjectArtifacts()`, the per-project store that
+  preserves the per-URI ASTs and the single project symbol table across edits.
+- `server.ts` — `createServer(connection)` wires diagnostics and whole-document formatting handlers onto an injected connection.
+- `start-server.ts` — `startServer()` creates a stdio connection and starts the server. This is what the CLI delegates to.
+
+## Package Location
+
+- **Domain**: framework (target-agnostic)
+- **Layer**: tooling
+- **Plane**: migration
+- **Path**: `packages/1-framework/3-tooling/language-server`

package/dist/exports/index.d.mts

@@ -0,0 +1,41 @@
+import { Connection } from "vscode-languageserver";
+import { SymbolTable } from "@prisma-next/psl-parser";
+import { DocumentAst, ParseDiagnostic, Range, SourceFile } from "@prisma-next/psl-parser/syntax";
+//#region src/diagnostic-mapping.d.ts
+declare const ParseDiagnosticSeverity: {
+  readonly Error: 1;
+  readonly Warning: 2;
+  readonly Information: 3;
+  readonly Hint: 4;
+};
+interface LspDiagnostic {
+  readonly range: Range;
+  readonly message: string;
+  readonly code: string;
+  readonly severity: number;
+}
+declare function mapParseDiagnostics(diagnostics: readonly ParseDiagnostic[]): readonly LspDiagnostic[];
+//#endregion
+//#region src/project-artifacts.d.ts
+interface CachedDocument {
+  readonly document: DocumentAst;
+  readonly sourceFile: SourceFile;
+}
+//#endregion
+//#region src/server.d.ts
+interface LanguageServer {
+  dispose(): void;
+  /**
+   * Exposed for future features (completion, semantic tokens); nothing consumes
+   * them yet.
+   */
+  getDocumentAst(uri: string): CachedDocument | undefined;
+  getProjectSymbolTable(uri: string): SymbolTable | undefined;
+}
+declare function createServer(connection: Connection): LanguageServer;
+//#endregion
+//#region src/start-server.d.ts
+declare function startServer(): LanguageServer;
+//#endregion
+export { type LanguageServer, type LspDiagnostic, ParseDiagnosticSeverity, createServer, mapParseDiagnostics, startServer };
+//# sourceMappingURL=index.d.mts.map

package/dist/exports/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/diagnostic-mapping.ts","../../src/project-artifacts.ts","../../src/server.ts","../../src/start-server.ts"],"mappings":";;;;cAEa,uBAAA;EAAA;;;;;UAOI,aAAA;EAAA,SACN,KAAA,EAAO,KAAK;EAAA,SACZ,OAAA;EAAA,SACA,IAAA;EAAA,SACA,QAAA;AAAA;AAAA,iBAGK,mBAAA,CACd,WAAA,WAAsB,eAAA,cACZ,aAAa;;;UCXR,cAAA;EAAA,SACN,QAAA,EAAU,WAAA;EAAA,SACV,UAAA,EAAY,UAAU;AAAA;;;UCmBhB,cAAA;EACf,OAAA;;AF3BF;;;EEgCE,cAAA,CAAe,GAAA,WAAc,cAAA;EAC7B,qBAAA,CAAsB,GAAA,WAAc,WAAW;AAAA;AAAA,iBAejC,YAAA,CAAa,UAAA,EAAY,UAAA,GAAa,cAAc;;;iBC/CpD,WAAA,IAAe,cAAc"}

package/dist/exports/index.mjs

@@ -0,0 +1,380 @@
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { findNearestConfigPathForFile, loadConfig } from "@prisma-next/config-loader";
+import { format } from "@prisma-next/psl-parser/format";
+import { DiagnosticSeverity, DidChangeWatchedFilesNotification, RegistrationRequest, TextDocumentSyncKind, TextDocuments } from "vscode-languageserver";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { createControlStack } from "@prisma-next/framework-components/control";
+import { buildSymbolTable } from "@prisma-next/psl-parser";
+import { parse } from "@prisma-next/psl-parser/syntax";
+import { ProposedFeatures, createConnection } from "vscode-languageserver/node";
+//#region src/diagnostic-mapping.ts
+const ParseDiagnosticSeverity = {
+	Error: 1,
+	Warning: 2,
+	Information: 3,
+	Hint: 4
+};
+function mapParseDiagnostics(diagnostics) {
+	return diagnostics.map((diagnostic) => ({
+		range: diagnostic.range,
+		message: diagnostic.message,
+		code: diagnostic.code,
+		severity: ParseDiagnosticSeverity.Error
+	}));
+}
+//#endregion
+//#region src/schema-inputs.ts
+function hasPslInputs(config) {
+	const source = config.contract?.source;
+	return source?.sourceFormat === "psl" && source.inputs !== void 0;
+}
+function resolveSchemaInputs(config) {
+	const inputs = hasPslInputs(config) ? config.contract?.source.inputs : void 0;
+	const uris = new Set(inputs?.map((input) => pathToFileURL(input).toString()));
+	return { includes: (uri) => uris.has(uri) };
+}
+//#endregion
+//#region src/config-resolution.ts
+const CONFIG_FILENAME = "prisma-next.config.ts";
+const emptyPipelineInputs = {
+	scalarTypes: [],
+	pslBlockDescriptors: {}
+};
+async function resolveConfigInputs(configPath) {
+	const config = await loadConfig(configPath);
+	const inputs = resolveSchemaInputs(config);
+	const controlStack = resolveControlStackInputs(config) ?? emptyPipelineInputs;
+	return config.formatter === void 0 ? {
+		inputs,
+		controlStack
+	} : {
+		inputs,
+		formatter: config.formatter,
+		controlStack
+	};
+}
+function resolveControlStackInputs(config) {
+	if (!hasPslInputs(config)) return;
+	const stack = createControlStack(config);
+	return {
+		scalarTypes: [...stack.scalarTypeDescriptors.keys()],
+		pslBlockDescriptors: stack.authoringContributions.pslBlockDescriptors
+	};
+}
+//#endregion
+//#region src/pipeline.ts
+/**
+* Composes the stages exactly as the contract-psl provider does, so the editor
+* and the build agree: `parse` then `buildSymbolTable`, parse diagnostics ahead
+* of symbol-table diagnostics. Never throws on malformed input — `parse`
+* recovers and `buildSymbolTable` is documented not to throw.
+*/
+function runPipeline(text, inputs) {
+	const { document, sourceFile, diagnostics: parseDiagnostics } = parse(text);
+	const { table: symbolTable, diagnostics: symbolTableDiagnostics } = buildSymbolTable({
+		document,
+		sourceFile,
+		scalarTypes: inputs.scalarTypes,
+		pslBlockDescriptors: inputs.pslBlockDescriptors
+	});
+	return {
+		document,
+		sourceFile,
+		symbolTable,
+		diagnostics: mapParseDiagnostics([...parseDiagnostics, ...symbolTableDiagnostics])
+	};
+}
+//#endregion
+//#region src/document-diagnostics.ts
+/**
+* `null` (not a configured input) is distinct from a `DocumentDiagnostics` whose
+* `diagnostics` are `[]` (an input that parsed clean): the caller treats both as
+* "publish no diagnostics", but only the latter is a document we own and keep
+* diagnosing.
+*/
+function computeDocumentDiagnostics(uri, text, inputs, controlStack) {
+	if (!inputs.includes(uri)) return null;
+	const { document, sourceFile, symbolTable, diagnostics } = runPipeline(text, controlStack);
+	return {
+		diagnostics,
+		document,
+		sourceFile,
+		symbolTable
+	};
+}
+//#endregion
+//#region src/project-artifacts.ts
+function createProjectArtifacts() {
+	const documents = /* @__PURE__ */ new Map();
+	let symbolTable;
+	return {
+		getDocument: (uri) => documents.get(uri),
+		getSymbolTable: () => symbolTable,
+		update: (uri, text, inputs, controlStack) => {
+			const computed = computeDocumentDiagnostics(uri, text, inputs, controlStack);
+			if (computed === null) {
+				if (documents.delete(uri)) symbolTable = void 0;
+				return null;
+			}
+			documents.set(uri, {
+				document: computed.document,
+				sourceFile: computed.sourceFile
+			});
+			symbolTable = computed.symbolTable;
+			return computed.diagnostics;
+		},
+		remove: (uri) => {
+			if (documents.delete(uri)) symbolTable = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/server.ts
+function createServer(connection) {
+	const documents = new TextDocuments(TextDocument);
+	const projects = /* @__PURE__ */ new Map();
+	const projectLoads = /* @__PURE__ */ new Map();
+	const documentConfigPaths = /* @__PURE__ */ new Map();
+	let rootPath = process.cwd();
+	let watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
+	let supportsWatchedFilesRegistration = false;
+	async function publish(uri, text) {
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) return;
+		const currentDocument = documents.get(uri);
+		if (currentDocument === void 0) {
+			documentConfigPaths.delete(uri);
+			return;
+		}
+		if (currentDocument.getText() !== text) return;
+		const computed = project.artifacts.update(uri, text, project.inputs, project.controlStack);
+		if (computed === null) {
+			connection.sendDiagnostics({
+				uri,
+				diagnostics: []
+			});
+			return;
+		}
+		const diagnostics = computed.map((diagnostic) => ({
+			range: diagnostic.range,
+			message: diagnostic.message,
+			code: diagnostic.code,
+			severity: toLspSeverity(diagnostic.severity),
+			source: "prisma-next"
+		}));
+		connection.sendDiagnostics({
+			uri,
+			diagnostics
+		});
+	}
+	async function resolveProjectForDocument(uri) {
+		const knownConfigPath = documentConfigPaths.get(uri);
+		if (knownConfigPath !== void 0) return resolveProject(knownConfigPath);
+		const filePath = filePathFromUri(uri);
+		if (filePath === void 0) return;
+		const configPath = await findNearestConfigPathForFile(filePath);
+		if (configPath === void 0) return;
+		documentConfigPaths.set(uri, configPath);
+		const project = await resolveProjectIfLoadable(configPath);
+		if (project === void 0) documentConfigPaths.delete(uri);
+		return project;
+	}
+	async function resolveProjectIfLoadable(configPath) {
+		try {
+			return await resolveProject(configPath);
+		} catch {
+			stopManagingProject(configPath);
+			return;
+		}
+	}
+	async function resolveProject(configPath) {
+		const existing = projects.get(configPath);
+		if (existing !== void 0) return existing;
+		const existingLoad = projectLoads.get(configPath);
+		if (existingLoad !== void 0) return existingLoad;
+		return queueProjectLoad(configPath);
+	}
+	function refreshProject(configPath) {
+		return queueProjectLoad(configPath);
+	}
+	function queueProjectLoad(configPath) {
+		const load = (projectLoads.get(configPath) ?? Promise.resolve()).catch(() => void 0).then(() => loadProject(configPath)).finally(() => {
+			if (projectLoads.get(configPath) === load) projectLoads.delete(configPath);
+		});
+		projectLoads.set(configPath, load);
+		return load;
+	}
+	async function loadProject(configPath) {
+		const resolution = await resolveConfigInputs(configPath);
+		const artifacts = projects.get(configPath)?.artifacts ?? createProjectArtifacts();
+		const project = resolution.formatter === void 0 ? {
+			configPath,
+			inputs: resolution.inputs,
+			controlStack: resolution.controlStack,
+			artifacts
+		} : {
+			configPath,
+			inputs: resolution.inputs,
+			formatter: resolution.formatter,
+			controlStack: resolution.controlStack,
+			artifacts
+		};
+		projects.set(configPath, project);
+		return project;
+	}
+	function stopManagingProject(configPath) {
+		const hadProject = projects.delete(configPath);
+		for (const document of documents.all()) if (documentConfigPaths.get(document.uri) === configPath) {
+			documentConfigPaths.delete(document.uri);
+			if (hadProject) connection.sendDiagnostics({
+				uri: document.uri,
+				diagnostics: []
+			});
+		}
+	}
+	async function republishOpenDocumentsForConfig(configPath) {
+		for (const document of documents.all()) {
+			if (documentConfigPaths.get(document.uri) === configPath) {
+				await publish(document.uri, document.getText());
+				continue;
+			}
+			const filePath = filePathFromUri(document.uri);
+			if (filePath === void 0) continue;
+			if (await findNearestConfigPathForFile(filePath) === configPath) {
+				documentConfigPaths.set(document.uri, configPath);
+				await publish(document.uri, document.getText());
+			}
+		}
+	}
+	function publishSafely(uri, text) {
+		publish(uri, text).catch((error) => {
+			connection.console.error(error instanceof Error ? error.message : String(error));
+		});
+	}
+	async function formatDocument(uri) {
+		const document = documents.get(uri);
+		if (document === void 0) return [];
+		let project;
+		try {
+			project = await resolveProjectForDocument(uri);
+		} catch {
+			return [];
+		}
+		if (project === void 0 || !project.inputs.includes(uri)) return [];
+		const source = document.getText();
+		let formatted;
+		try {
+			formatted = format(source, project.formatter);
+		} catch {
+			return [];
+		}
+		if (formatted === source) return [];
+		return [{
+			range: {
+				start: {
+					line: 0,
+					character: 0
+				},
+				end: document.positionAt(source.length)
+			},
+			newText: formatted
+		}];
+	}
+	connection.onInitialize(async (params) => {
+		rootPath = resolveRootPath(params.rootUri, params.rootPath);
+		watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
+		supportsWatchedFilesRegistration = clientSupportsWatchedFilesRegistration(params);
+		return { capabilities: {
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			documentFormattingProvider: true
+		} };
+	});
+	connection.onInitialized(() => {
+		if (supportsWatchedFilesRegistration) connection.sendRequest(RegistrationRequest.type, { registrations: [{
+			id: "prisma-next-config-watcher",
+			method: DidChangeWatchedFilesNotification.type.method,
+			registerOptions: { watchers: [{ globPattern: watchedConfigGlob }] }
+		}] }).catch(() => void 0);
+		else connection.console.warn("Client does not support dynamic file-watcher registration; Prisma Next config changes will not be picked up without a restart.");
+	});
+	connection.onDidChangeWatchedFiles(async (params) => {
+		const changedConfigPaths = configPathsFromWatchedChanges(params.changes.map((change) => filePathFromUri(change.uri)));
+		for (const configPath of changedConfigPaths) {
+			try {
+				await refreshProject(configPath);
+			} catch {
+				stopManagingProject(configPath);
+				continue;
+			}
+			await republishOpenDocumentsForConfig(configPath);
+		}
+	});
+	connection.onDocumentFormatting((params) => formatDocument(params.textDocument.uri));
+	documents.onDidOpen((event) => {
+		publishSafely(event.document.uri, event.document.getText());
+	});
+	documents.onDidChangeContent((event) => {
+		publishSafely(event.document.uri, event.document.getText());
+	});
+	documents.onDidClose((event) => {
+		const uri = event.document.uri;
+		const configPath = documentConfigPaths.get(uri);
+		if (configPath !== void 0) projects.get(configPath)?.artifacts.remove(uri);
+		documentConfigPaths.delete(uri);
+		connection.sendDiagnostics({
+			uri,
+			diagnostics: []
+		});
+	});
+	documents.listen(connection);
+	connection.listen();
+	function artifactsForDocument(uri) {
+		const configPath = documentConfigPaths.get(uri);
+		return configPath === void 0 ? void 0 : projects.get(configPath)?.artifacts;
+	}
+	return {
+		dispose: () => {
+			connection.dispose();
+		},
+		getDocumentAst: (uri) => artifactsForDocument(uri)?.getDocument(uri),
+		getProjectSymbolTable: (uri) => artifactsForDocument(uri)?.getSymbolTable()
+	};
+}
+function toLspSeverity(severity) {
+	switch (severity) {
+		case ParseDiagnosticSeverity.Warning: return DiagnosticSeverity.Warning;
+		case ParseDiagnosticSeverity.Information: return DiagnosticSeverity.Information;
+		case ParseDiagnosticSeverity.Hint: return DiagnosticSeverity.Hint;
+		default: return DiagnosticSeverity.Error;
+	}
+}
+function clientSupportsWatchedFilesRegistration(params) {
+	return params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true;
+}
+function resolveRootPath(rootUri, rootPath) {
+	if (rootUri) return fileURLToPath(rootUri);
+	if (rootPath) return rootPath;
+	return process.cwd();
+}
+function filePathFromUri(uri) {
+	try {
+		return fileURLToPath(uri);
+	} catch {
+		return;
+	}
+}
+function configPathsFromWatchedChanges(paths) {
+	const configPaths = /* @__PURE__ */ new Set();
+	for (const path of paths) if (path?.endsWith("prisma-next.config.ts")) configPaths.add(path);
+	return configPaths;
+}
+//#endregion
+//#region src/start-server.ts
+function startServer() {
+	return createServer(createConnection(ProposedFeatures.all));
+}
+//#endregion
+export { ParseDiagnosticSeverity, createServer, mapParseDiagnostics, startServer };
+
+//# sourceMappingURL=index.mjs.map