@prisma/orm-toolchain 0.16.0

package/dist/exports-B_xhKZmC.mjs

@@ -0,0 +1,1436 @@
+import { n as findNearestConfigPathForFile, r as loadConfig } from "./exports-Dl2aGAk7.mjs";
+import { CliStructuredError } from "@prisma/orm-framework/errors/control";
+import { join } from "pathe";
+import { createControlStack } from "@prisma/orm-framework/components/control";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { format } from "@prisma/orm-framework/psl-parser/format";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { CompletionItemKind, DiagnosticSeverity, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FoldingRangeKind, InsertTextFormat, RegistrationRequest, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments } from "vscode-languageserver";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { ArrayLiteralAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectLiteralExprAst, StringLiteralExprAst, TypesBlockAst, any, filterChildren, findChildToken, parse, skipTriviaToken } from "@prisma/orm-framework/psl-parser/syntax";
+import { isAuthoringPslBlockDescriptor } from "@prisma/orm-framework/components/authoring";
+import { buildSymbolTable, findBlockDescriptor } from "@prisma/orm-framework/psl-parser";
+import { hasPslInterpreter } from "@prisma/orm-framework/psl-parser/interpret";
+import { ProposedFeatures, createConnection } from "vscode-languageserver/node";
+//#region ../../../1-framework/3-tooling/language-server/dist/exports/index.mjs
+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
+	}));
+}
+const documentStartRange = {
+	start: {
+		line: 0,
+		character: 0
+	},
+	end: {
+		line: 0,
+		character: 1
+	}
+};
+function mapInterpreterDiagnostics(diagnostics, sourceFile) {
+	return diagnostics.map((diagnostic) => ({
+		range: diagnostic.span === void 0 ? documentStartRange : pslSpanToRange(diagnostic.span, sourceFile),
+		message: diagnostic.message,
+		code: diagnostic.code,
+		severity: ParseDiagnosticSeverity.Error
+	}));
+}
+function pslSpanToRange(span, sourceFile) {
+	return {
+		start: sourceFile.positionAt(span.start.offset),
+		end: sourceFile.positionAt(span.end.offset)
+	};
+}
+const UNSUPPORTED = { kind: "unsupported" };
+function classifyPslCompletionContext(input) {
+	const root = input.document.syntax;
+	const offset = input.sourceFile.offsetAt(input.position);
+	const at = root.tokenAtOffset(offset);
+	if (at.leftBiased()?.kind === "Comment") return UNSUPPORTED;
+	const edit = cursorIdentifier(at, offset);
+	const preceding = precedingToken(at, edit);
+	const precedingNode = preceding?.parent;
+	const replacementStartOffset = edit?.offset ?? offset;
+	const declarationKeywordContext = classifyDeclarationKeyword({
+		node: precedingNode,
+		offset,
+		replacementStartOffset
+	});
+	if (declarationKeywordContext !== void 0) return declarationKeywordContext;
+	const genericBlockContext = classifyGenericBlockParameter({
+		offset,
+		at,
+		precedingToken: preceding,
+		replacementStartOffset
+	});
+	if (genericBlockContext !== void 0) return genericBlockContext;
+	const field = fieldForTypeSlot(precedingNode);
+	if (field === void 0) return UNSUPPORTED;
+	if (field.syntax.findAncestor(any(ModelDeclarationAst.cast, CompositeTypeDeclarationAst.cast)) === void 0) return UNSUPPORTED;
+	return classifyModelFieldType({
+		field,
+		offset,
+		replacementStartOffset,
+		precedingToken: preceding
+	});
+}
+/**
+* Locates the field whose type position the cursor occupies. The preceding token
+* climbs to the field whether the cursor sits inside a present type (the type
+* identifier's predecessor still belongs to the field) or in the empty type slot
+* of a typeless field (whose trailing trivia lives in the enclosing block, so
+* the nearest significant token to the left is the field's own name).
+*/
+function fieldForTypeSlot(precedingNode) {
+	return precedingNode?.findAncestor(FieldDeclarationAst.cast);
+}
+function classifyModelFieldType(input) {
+	const fieldName = input.field.name();
+	if (fieldName === void 0) return UNSUPPORTED;
+	const fieldNameText = fieldName.name();
+	if (fieldNameText === void 0) return UNSUPPORTED;
+	if (fieldName.syntax.isInside(input.offset)) return UNSUPPORTED;
+	const typeAnnotation = input.field.typeAnnotation();
+	if (typeAnnotation === void 0) {
+		if (input.precedingToken !== void 0 && fieldName.syntax.isInside(input.precedingToken.offset)) return {
+			kind: "modelType",
+			offset: input.offset,
+			fieldName: fieldNameText,
+			replacementStartOffset: input.offset
+		};
+		return UNSUPPORTED;
+	}
+	if (typeAnnotation.syntax.isOutside(input.offset)) return UNSUPPORTED;
+	if (typeAnnotation.argList()?.syntax.isInside(input.offset)) return UNSUPPORTED;
+	const name = typeAnnotation.name();
+	if (name === void 0) return UNSUPPORTED;
+	if (name.syntax.isOutside(input.offset)) return UNSUPPORTED;
+	if (name.isOverQualified()) return UNSUPPORTED;
+	return classifyTypePosition(name, input.offset, fieldNameText, input.replacementStartOffset);
+}
+/**
+* Builds the type-completion context for a qualified name. Roles are read
+* straight off the separator-positional accessors: a populated namespace
+* segment is a `.`-qualified name, a populated space segment is a `:`-qualified
+* name, and the absence of both is a bare model type.
+*
+* Behaviour change: a `:`-qualified name with no `.` (e.g. `supabase:`,
+* `supabase:U`) is a `spaceMember` position rather than falling through to bare
+* model-type completions. A malformed leading-separator name (`:User`, `.User`)
+* carries no populated segment and resolves to `modelType` rather than
+* `unsupported`.
+*/
+function classifyTypePosition(name, offset, fieldName, replacementStartOffset) {
+	const namespace = name.namespace()?.name();
+	if (namespace !== void 0 && namespace.length > 0) {
+		const namespaceSpace = name.space()?.name();
+		return {
+			kind: "namespaceMember",
+			offset,
+			fieldName,
+			replacementStartOffset,
+			namespace,
+			...namespaceSpace !== void 0 && namespaceSpace.length > 0 ? { space: namespaceSpace } : {}
+		};
+	}
+	const space = name.space()?.name();
+	if (space !== void 0 && space.length > 0) return {
+		kind: "spaceMember",
+		offset,
+		fieldName,
+		replacementStartOffset,
+		space
+	};
+	return {
+		kind: "modelType",
+		offset,
+		fieldName,
+		replacementStartOffset
+	};
+}
+const declarationCast = any(ModelDeclarationAst.cast, CompositeTypeDeclarationAst.cast, TypesBlockAst.cast, GenericBlockDeclarationAst.cast, NamespaceDeclarationAst.cast);
+function classifyDeclarationKeyword(input) {
+	const precedingDeclaration = input.node?.findAncestor(declarationCast);
+	const namespace = input.node?.findAncestor(NamespaceDeclarationAst.cast);
+	const inNamespaceBody = blockBodyContainsOffset(namespace, input.offset);
+	if (precedingDeclaration !== void 0 && !canCompleteDeclaration(precedingDeclaration, input.offset, inNamespaceBody)) return;
+	return {
+		kind: "declarationKeyword",
+		offset: input.offset,
+		scope: inNamespaceBody ? "namespace" : "document",
+		replacementStartOffset: input.replacementStartOffset
+	};
+}
+/**
+* Whether a new declaration can begin at the cursor, given the nearest enclosing
+* declaration. Allowed when that declaration is still nascent (only its keyword
+* typed, no name or body yet), when it is a namespace whose body holds further
+* declarations, or when the cursor sits past its closing `}`.
+*/
+function canCompleteDeclaration(precedingDeclaration, offset, inNamespaceBody) {
+	if (precedingDeclaration.lbrace() === void 0 && (precedingDeclaration instanceof TypesBlockAst || precedingDeclaration.name() === void 0)) return true;
+	if (precedingDeclaration instanceof NamespaceDeclarationAst && inNamespaceBody) return true;
+	const rbrace = precedingDeclaration.rbrace();
+	return rbrace !== void 0 && offset >= rbrace.endOffset;
+}
+function blockBodyContainsOffset(block, offset) {
+	if (block === void 0) return false;
+	const lbrace = block.lbrace();
+	if (lbrace === void 0) return false;
+	const bodyStart = lbrace.endOffset;
+	const bodyEnd = block.rbrace()?.offset ?? block.syntax.endOffset;
+	return offset >= bodyStart && offset <= bodyEnd;
+}
+function classifyGenericBlockParameter(input) {
+	const node = input.at.leftBiased()?.parent;
+	const block = node?.findAncestor(GenericBlockDeclarationAst.cast);
+	if (block === void 0) return;
+	if (hasUnsupportedAncestor(node)) return UNSUPPORTED;
+	if (!blockBodyContainsOffset(block, input.offset)) return UNSUPPORTED;
+	if ((node?.findAncestor(FieldDeclarationAst.cast))?.syntax.isInside(input.offset)) return UNSUPPORTED;
+	const keyword = block.keyword()?.text;
+	if (keyword === void 0 || keyword.length === 0) return UNSUPPORTED;
+	if (input.precedingToken?.kind === "Equals") return {
+		kind: "genericBlockValue",
+		offset: input.offset,
+		blockKeyword: keyword,
+		replacementStartOffset: input.replacementStartOffset
+	};
+	const activePair = activeKeyValuePair(node, input.offset);
+	if (activePair !== void 0 && isAfterEquals(activePair, input.offset)) return UNSUPPORTED;
+	return {
+		kind: "genericBlockKey",
+		offset: input.offset,
+		blockKeyword: keyword,
+		replacementStartOffset: input.replacementStartOffset,
+		block
+	};
+}
+function activeKeyValuePair(node, offset) {
+	const pair = node?.findAncestor(KeyValuePairAst.cast);
+	if (pair === void 0 || pair.syntax.isOutside(offset)) return;
+	return pair;
+}
+function isAfterEquals(pair, offset) {
+	const equals = pair.equals();
+	return equals !== void 0 && offset > equals.offset;
+}
+function hasUnsupportedAncestor(node) {
+	return node?.findAncestor(any(AttributeArgListAst.cast, FieldAttributeAst.cast, ModelAttributeAst.cast)) !== void 0;
+}
+/** The significant token preceding the cursor — the in-progress edit identifier
+*  is skipped, so the result is the token the classifier anchors on. */
+function precedingToken(at, edit) {
+	const start = edit !== void 0 ? edit.prevToken : at.leftBiased();
+	return start === void 0 ? void 0 : skipTriviaToken(start, "prev");
+}
+/** The identifier token the cursor is editing, if any. */
+function cursorIdentifier(at, offset) {
+	const right = at.rightBiased();
+	if (right?.kind === "Ident" && offset < right.endOffset) return right;
+	const left = at.leftBiased();
+	if (left?.kind === "Ident" && left.endOffset === offset) return left;
+}
+/**
+* Presentation-level classification of a `types {}` binding: a
+* non-constructor binding whose base is a configured scalar type refines that
+* scalar (rendered as a default-library type); everything else reads as a
+* plain alias. The authoritative scalar-or-not pronouncement lives in the
+* interpreter's named-type resolution — this mirrors it for display only.
+*/
+function refinesScalarType(symbol, scalarTypes) {
+	return !symbol.isConstructor && symbol.baseType !== void 0 && scalarTypes.includes(symbol.baseType);
+}
+const categoryOrder = {
+	configuredScalar: 0,
+	topLevelModel: 1,
+	topLevelCompositeType: 2,
+	scalar: 3,
+	typeAlias: 4,
+	namespace: 5,
+	namespaceModel: 6,
+	namespaceCompositeType: 7
+};
+const declarationKeywordCategoryOrder = {
+	native: 0,
+	genericBlock: 1
+};
+const nameSnippetPlaceholder = "${1:Name}";
+const documentNativeDeclarationKeywords = [
+	nativeDeclarationKeyword("model", "model ", `model ${nameSnippetPlaceholder} {\n  $0\n}`),
+	nativeDeclarationKeyword("type", "type ", `type ${nameSnippetPlaceholder} {\n  $0\n}`),
+	nativeDeclarationKeyword("types", "types ", "types {\n  $0\n}"),
+	nativeDeclarationKeyword("namespace", "namespace ", `namespace \${1:name} {\n  $0\n}`)
+];
+const namespaceNativeDeclarationKeywords = [nativeDeclarationKeyword("model", "model ", `model ${nameSnippetPlaceholder} {\n  $0\n}`), nativeDeclarationKeyword("type", "type ", `type ${nameSnippetPlaceholder} {\n  $0\n}`)];
+function providePslCompletionItems(input) {
+	const { context } = input;
+	switch (context.kind) {
+		case "unsupported": return [];
+		case "spaceMember": return [];
+		case "genericBlockValue": return [];
+		case "declarationKeyword": return provideDeclarationKeywordCompletionItems(context, input.sourceFile, input.candidates, input.clientSupportsSnippets);
+		case "genericBlockKey": return provideGenericBlockKeyCompletionItems(context, input.sourceFile, input.candidates);
+		case "modelType": return provideModelTypeCompletionItems(context, input.sourceFile, input.candidates);
+		case "namespaceMember": return provideNamespaceMemberCompletionItems(context, input.sourceFile, input.candidates);
+	}
+}
+function provideDeclarationKeywordCompletionItems(context, sourceFile, source, clientSupportsSnippets) {
+	const replacementRange = {
+		start: sourceFile.positionAt(context.replacementStartOffset),
+		end: sourceFile.positionAt(context.offset)
+	};
+	return declarationKeywordCandidates(context.scope, source).map((candidate) => ({
+		label: candidate.label,
+		kind: candidate.kind,
+		detail: candidate.detail,
+		sortText: declarationKeywordSortText(candidate),
+		filterText: candidate.label,
+		...clientSupportsSnippets ? { insertTextFormat: InsertTextFormat.Snippet } : {},
+		textEdit: {
+			range: replacementRange,
+			newText: clientSupportsSnippets ? candidate.snippetText : candidate.insertText
+		}
+	}));
+}
+function declarationKeywordCandidates(scope, source) {
+	return [...scope === "namespace" ? namespaceNativeDeclarationKeywords : documentNativeDeclarationKeywords, ...genericBlockDeclarationKeywordCandidates(source.pslBlockDescriptors)];
+}
+function nativeDeclarationKeyword(label, insertText, snippetText) {
+	return {
+		category: "native",
+		label,
+		insertText,
+		snippetText,
+		detail: "PSL declaration keyword",
+		kind: CompletionItemKind.Keyword
+	};
+}
+function genericBlockDeclarationKeywordCandidates(descriptors) {
+	return descriptorBlockKeywords(descriptors).map((keyword) => ({
+		category: "genericBlock",
+		label: keyword,
+		insertText: `${keyword} `,
+		snippetText: `${keyword} ${nameSnippetPlaceholder} {\n  $0\n}`,
+		detail: "Generic block keyword",
+		kind: CompletionItemKind.Keyword
+	}));
+}
+function descriptorBlockKeywords(descriptors) {
+	const keywords = [];
+	collectDescriptorBlockKeywords(descriptors, keywords);
+	return sortedUnique(keywords);
+}
+function collectDescriptorBlockKeywords(descriptors, keywords) {
+	for (const value of Object.values(descriptors)) {
+		if (isAuthoringPslBlockDescriptor(value)) {
+			keywords.push(value.keyword);
+			continue;
+		}
+		collectDescriptorBlockKeywords(value, keywords);
+	}
+}
+function declarationKeywordSortText(candidate) {
+	return `${declarationKeywordCategoryOrder[candidate.category]}:${candidate.label}`;
+}
+function provideGenericBlockKeyCompletionItems(context, sourceFile, source) {
+	const descriptor = findBlockDescriptor(source.pslBlockDescriptors, context.blockKeyword);
+	if (descriptor === void 0) return [];
+	const existing = existingGenericBlockParameterNames(context.block, context.offset);
+	const replacementRange = {
+		start: sourceFile.positionAt(context.replacementStartOffset),
+		end: sourceFile.positionAt(context.offset)
+	};
+	return Object.keys(descriptor.parameters).filter((parameterName) => !existing.has(parameterName)).map((parameterName, index) => ({
+		label: parameterName,
+		kind: CompletionItemKind.Property,
+		detail: "Generic block parameter",
+		sortText: genericBlockParameterSortText(index, parameterName),
+		filterText: parameterName,
+		textEdit: {
+			range: replacementRange,
+			newText: parameterName
+		}
+	}));
+}
+function existingGenericBlockParameterNames(block, cursorOffset) {
+	const names = /* @__PURE__ */ new Set();
+	for (const entry of block.entries()) {
+		if (!entry.syntax.isOutside(cursorOffset)) continue;
+		const name = entry.key()?.name();
+		if (name !== void 0) names.add(name);
+	}
+	return names;
+}
+function provideModelTypeCompletionItems(context, sourceFile, source) {
+	return modelTypeCompletionItems(context, sourceFile, [
+		...configuredScalarCandidates(source.scalarTypes),
+		...topLevelSymbolCandidates(source.symbolTable, source.scalarTypes),
+		...allNamespaceCandidates(source.symbolTable)
+	]);
+}
+function provideNamespaceMemberCompletionItems(context, sourceFile, source) {
+	if (context.space !== void 0) return [];
+	return modelTypeCompletionItems(context, sourceFile, namespaceCandidates(source.symbolTable.topLevel.namespaces[context.namespace]));
+}
+function modelTypeCompletionItems(context, sourceFile, candidates) {
+	const replacementRange = {
+		start: sourceFile.positionAt(context.replacementStartOffset),
+		end: sourceFile.positionAt(context.offset)
+	};
+	return candidates.map((candidate) => ({
+		label: candidate.label,
+		kind: candidate.kind,
+		detail: candidate.detail,
+		sortText: sortText(candidate),
+		filterText: candidate.filterText,
+		textEdit: {
+			range: replacementRange,
+			newText: candidate.insertText
+		}
+	}));
+}
+function configuredScalarCandidates(scalarTypes) {
+	return sortedUnique(scalarTypes).map((name) => ({
+		category: "configuredScalar",
+		label: name,
+		insertText: name,
+		filterText: name,
+		detail: "Configured scalar type",
+		kind: CompletionItemKind.Keyword
+	}));
+}
+function topLevelSymbolCandidates(symbolTable, scalarTypes) {
+	const { topLevel } = symbolTable;
+	const namedTypes = Object.values(topLevel.namedTypes);
+	const scalarRefinementNames = namedTypes.filter((symbol) => refinesScalarType(symbol, scalarTypes)).map((symbol) => symbol.name).sort(compareNames);
+	const aliasNames = namedTypes.filter((symbol) => !refinesScalarType(symbol, scalarTypes)).map((symbol) => symbol.name).sort(compareNames);
+	return [
+		...symbolCandidates(recordNames(topLevel.models), "topLevelModel", "Model", CompletionItemKind.Class),
+		...symbolCandidates(recordNames(topLevel.compositeTypes), "topLevelCompositeType", "Composite type", CompletionItemKind.Struct),
+		...symbolCandidates(scalarRefinementNames, "scalar", "Scalar type", CompletionItemKind.Unit),
+		...symbolCandidates(aliasNames, "typeAlias", "Type alias", CompletionItemKind.Reference)
+	];
+}
+function allNamespaceCandidates(symbolTable) {
+	return Object.values(symbolTable.topLevel.namespaces).sort((left, right) => compareNames(left.name, right.name)).map(namespaceQualifierCandidate);
+}
+function namespaceCandidates(namespace) {
+	if (namespace === void 0) return [];
+	return [...symbolCandidates(recordNames(namespace.models), "namespaceModel", `Model in namespace ${namespace.name}`, CompletionItemKind.Class), ...symbolCandidates(recordNames(namespace.compositeTypes), "namespaceCompositeType", `Composite type in namespace ${namespace.name}`, CompletionItemKind.Struct)];
+}
+function namespaceQualifierCandidate(namespace) {
+	return {
+		category: "namespace",
+		label: namespace.name,
+		insertText: namespace.name,
+		filterText: namespace.name,
+		detail: "Namespace",
+		kind: CompletionItemKind.Module
+	};
+}
+function symbolCandidates(names, category, detail, kind) {
+	return names.map((name) => ({
+		category,
+		label: name,
+		insertText: name,
+		filterText: name,
+		detail,
+		kind
+	}));
+}
+function recordNames(record) {
+	return Object.values(record).map((symbol) => symbol.name).sort(compareNames);
+}
+function sortedUnique(names) {
+	return [...new Set(names)].sort(compareNames);
+}
+function sortText(candidate) {
+	return `${categoryOrder[candidate.category]}:${candidate.label}`;
+}
+function genericBlockParameterSortText(index, label) {
+	return `${index.toString().padStart(4, "0")}:${label}`;
+}
+function compareNames(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+function hasPslInputs(config) {
+	const source = config.contract?.source;
+	return source?.format === "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),
+		uris: () => uris
+	};
+}
+const CONFIG_FILENAME = "prisma-next.config.ts";
+const emptyPipelineInputs = {
+	scalarTypes: [],
+	pslBlockDescriptors: {}
+};
+async function resolveConfigInputs(configPath) {
+	const config = await loadConfig(configPath);
+	const inputs = resolveSchemaInputs(config);
+	if (!hasPslInputs(config)) return {
+		inputs,
+		controlStack: emptyPipelineInputs,
+		...config.formatter === void 0 ? {} : { formatter: config.formatter }
+	};
+	const stack = createControlStack(config);
+	const interpretation = resolveInterpretation(config, stack, inputs);
+	return {
+		inputs,
+		controlStack: pipelineInputsFromStack(stack),
+		...config.formatter === void 0 ? {} : { formatter: config.formatter },
+		...interpretation === void 0 ? {} : { interpretation }
+	};
+}
+function pipelineInputsFromStack(stack) {
+	return {
+		scalarTypes: [...stack.scalarTypes],
+		pslBlockDescriptors: stack.authoringContributions.pslBlockDescriptors
+	};
+}
+function resolveInterpretation(config, stack, inputs) {
+	const source = config.contract?.source;
+	if (source === void 0 || !hasPslInterpreter(source)) return;
+	return {
+		source,
+		context: {
+			composedExtensions: stack.extensions.map((p) => p.id),
+			composedExtensionContracts: stack.extensionContracts,
+			authoringContributions: stack.authoringContributions,
+			codecLookup: stack.codecLookup,
+			controlMutationDefaults: stack.controlMutationDefaults,
+			resolvedInputs: [...inputs.uris()],
+			capabilities: stack.capabilities
+		}
+	};
+}
+/**
+* Computes folding ranges for block declarations in a PSL document.
+*
+* Block types that produce folding ranges:
+* - model (e.g., `model User { ... }`)
+* - composite type (e.g., `type Address { ... }`)
+* - namespace (e.g., `namespace billing { ... }`)
+* - generic blocks (generator, datasource, extension blocks)
+* - types block (e.g., `types { ... }`)
+*
+* The range spans from the line containing `{` to the line containing `}`.
+*/
+function computeFoldingRanges(document, sourceFile) {
+	const ranges = [];
+	collectFoldingRanges(document, sourceFile, ranges);
+	return ranges;
+}
+function collectFoldingRanges(document, sourceFile, ranges) {
+	for (const declaration of document.declarations()) {
+		addFoldingRange(declaration, sourceFile, ranges);
+		const namespace = NamespaceDeclarationAst.cast(declaration.syntax);
+		if (namespace !== void 0) for (const nested of namespace.declarations()) addFoldingRange(nested, sourceFile, ranges);
+	}
+}
+function addFoldingRange(declaration, sourceFile, ranges) {
+	const lbrace = declaration.lbrace();
+	const rbrace = declaration.rbrace();
+	if (lbrace === void 0 || rbrace === void 0) return;
+	const startLine = sourceFile.positionAt(lbrace.offset).line;
+	const endLine = sourceFile.positionAt(rbrace.offset).line;
+	ranges.push({
+		startLine,
+		endLine,
+		kind: FoldingRangeKind.Region
+	});
+}
+/**
+* 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,
+		pslBlockDescriptors: inputs.pslBlockDescriptors
+	});
+	return {
+		document,
+		sourceFile,
+		symbolTable,
+		diagnostics: mapParseDiagnostics([...parseDiagnostics, ...symbolTableDiagnostics])
+	};
+}
+/**
+* `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
+	};
+}
+function createProjectArtifacts(options) {
+	const { inputs, controlStack, getText, interpretation } = options;
+	const documents = /* @__PURE__ */ new Map();
+	let symbolTable;
+	function createInterpretSlot(uri, computed) {
+		if (interpretation === void 0) return () => [];
+		let memo;
+		return () => {
+			if (memo === void 0) {
+				const result = interpretation.source.interpret({
+					document: computed.document,
+					sourceFile: computed.sourceFile,
+					symbolTable: computed.symbolTable,
+					sourceId: uri
+				}, interpretation.context);
+				memo = mapInterpreterDiagnostics(result.ok ? [] : result.failure.diagnostics, computed.sourceFile);
+			}
+			return memo;
+		};
+	}
+	function drop(uri) {
+		if (documents.delete(uri)) symbolTable = void 0;
+	}
+	function readDocument(uri) {
+		const existing = documents.get(uri);
+		if (existing !== void 0) return existing;
+		const text = getText(uri);
+		if (text === void 0) return;
+		const computed = computeDocumentDiagnostics(uri, text, inputs, controlStack);
+		if (computed === null) return;
+		const artifacts = {
+			document: computed.document,
+			sourceFile: computed.sourceFile,
+			diagnostics: computed.diagnostics,
+			interpretDiagnostics: createInterpretSlot(uri, computed)
+		};
+		documents.set(uri, artifacts);
+		symbolTable = computed.symbolTable;
+		return artifacts;
+	}
+	return {
+		document: readDocument,
+		symbolTable: () => {
+			if (symbolTable !== void 0) return symbolTable;
+			for (const uri of inputs.uris()) {
+				const artifacts = readDocument(uri);
+				if (artifacts === void 0) continue;
+				symbolTable ??= buildSymbolTable({
+					document: artifacts.document,
+					sourceFile: artifacts.sourceFile,
+					pslBlockDescriptors: controlStack.pslBlockDescriptors
+				}).table;
+				return symbolTable;
+			}
+			throw new InternalError("invariant violated: project has no open configured input — the server must drop such projects");
+		},
+		documentChanged: drop,
+		documentClosed: drop
+	};
+}
+const semanticTokenTypes = [
+	SemanticTokenTypes.keyword,
+	SemanticTokenTypes.namespace,
+	SemanticTokenTypes.class,
+	SemanticTokenTypes.struct,
+	SemanticTokenTypes.type,
+	SemanticTokenTypes.property,
+	SemanticTokenTypes.decorator,
+	SemanticTokenTypes.string,
+	SemanticTokenTypes.number,
+	SemanticTokenTypes.comment
+];
+const semanticTokenModifiers = [SemanticTokenModifiers.declaration, SemanticTokenModifiers.defaultLibrary];
+const semanticTokenModifierIndexes = {
+	declaration: 0,
+	defaultLibrary: 1
+};
+const semanticTokenModifierBits = {
+	declaration: 1 << semanticTokenModifierIndexes.declaration,
+	defaultLibrary: 1 << semanticTokenModifierIndexes.defaultLibrary
+};
+const semanticTokensLegend = {
+	tokenTypes: [...semanticTokenTypes],
+	tokenModifiers: [...semanticTokenModifiers]
+};
+function buildSemanticTokens(source, range) {
+	const builder = new SemanticTokensBuilder(source.sourceFile, range);
+	for (const token of collectSemanticTokenEvents(source)) builder.add(token);
+	return builder.build();
+}
+function collectSemanticTokenEvents(source) {
+	const comments = collectCommentTokens(source.document);
+	const tokens = [];
+	collectDeclarations(source, tokens);
+	return mergeSourceOrderedTokens(comments, tokens);
+}
+var SemanticTokensBuilder = class {
+	#data = [];
+	#sourceFile;
+	#rangeOffsets;
+	#previousLine = 0;
+	#previousCharacter = 0;
+	#first = true;
+	constructor(sourceFile, range) {
+		this.#sourceFile = sourceFile;
+		if (range !== void 0) {
+			const startOffset = sourceFile.offsetAt(range.start);
+			const endOffset = sourceFile.offsetAt(range.end);
+			this.#rangeOffsets = {
+				lower: Math.min(startOffset, endOffset),
+				upper: Math.max(startOffset, endOffset)
+			};
+		}
+	}
+	add(token) {
+		if (!this.#intersectsRange(token.startOffset, token.endOffset)) return;
+		if (token.splitMultiline) {
+			this.#addMultilineSplitToken(token);
+			return;
+		}
+		this.#encode(token.startOffset, token.endOffset, token.tokenTypeIndex, token.modifierBitset);
+	}
+	build() {
+		return { data: this.#data };
+	}
+	#intersectsRange(startOffset, endOffset) {
+		const rangeOffsets = this.#rangeOffsets;
+		return rangeOffsets === void 0 || startOffset < rangeOffsets.upper && endOffset > rangeOffsets.lower;
+	}
+	#addMultilineSplitToken(token) {
+		const start = this.#sourceFile.positionAt(token.startOffset);
+		const end = this.#sourceFile.positionAt(token.endOffset);
+		if (start.line === end.line) {
+			this.#encode(token.startOffset, token.endOffset, token.tokenTypeIndex, token.modifierBitset);
+			return;
+		}
+		for (let line = start.line; line <= end.line; line++) {
+			const startOffset = line === start.line ? token.startOffset : this.#sourceFile.lineStartOffset(line);
+			const endOffset = line === end.line ? token.endOffset : this.#sourceFile.lineEndOffset(line);
+			if (endOffset > startOffset && this.#intersectsRange(startOffset, endOffset)) this.#encode(startOffset, endOffset, token.tokenTypeIndex, token.modifierBitset);
+		}
+	}
+	#encode(startOffset, endOffset, tokenTypeIndex, modifierBitset) {
+		const start = this.#sourceFile.positionAt(startOffset);
+		const deltaLine = this.#first ? start.line : start.line - this.#previousLine;
+		const deltaStart = this.#first || deltaLine !== 0 ? start.character : start.character - this.#previousCharacter;
+		this.#data.push(deltaLine, deltaStart, endOffset - startOffset, tokenTypeIndex, modifierBitset);
+		this.#previousLine = start.line;
+		this.#previousCharacter = start.character;
+		this.#first = false;
+	}
+};
+function collectCommentTokens(document) {
+	const tokens = [];
+	for (const token of document.syntax.tokens()) if (token.kind === "Comment") tokens.push(pendingTokenForToken(token, "comment"));
+	return tokens;
+}
+function collectDeclarations(source, tokens) {
+	for (const declaration of source.document.declarations()) collectDeclaration(declaration, source, tokens, void 0);
+}
+function collectDeclaration(declaration, source, tokens, namespace) {
+	if (declaration instanceof ModelDeclarationAst) {
+		addToken(declaration.keyword(), "keyword", tokens);
+		addIdentifier(declaration.name(), "class", tokens, semanticTokenModifierBits.declaration);
+		collectBlockMembers(declaration.members(), source, tokens, namespace);
+		return;
+	}
+	if (declaration instanceof CompositeTypeDeclarationAst) {
+		addToken(declaration.keyword(), "keyword", tokens);
+		addIdentifier(declaration.name(), "struct", tokens, semanticTokenModifierBits.declaration);
+		collectBlockMembers(declaration.members(), source, tokens, namespace);
+		return;
+	}
+	if (declaration instanceof NamespaceDeclarationAst) {
+		addToken(declaration.keyword(), "keyword", tokens);
+		addIdentifier(declaration.name(), "namespace", tokens, semanticTokenModifierBits.declaration);
+		const nestedNamespace = declaration.name()?.name();
+		for (const nested of declaration.declarations()) collectDeclaration(nested, source, tokens, nestedNamespace);
+		return;
+	}
+	if (declaration instanceof TypesBlockAst) {
+		addToken(declaration.keyword(), "keyword", tokens);
+		for (const namedType of declaration.declarations()) collectNamedTypeDeclaration(namedType, source, tokens, namespace);
+		return;
+	}
+	addToken(declaration.keyword(), "keyword", tokens);
+	addIdentifier(declaration.name(), "type", tokens, semanticTokenModifierBits.declaration);
+	collectGenericBlockMembers(declaration.members(), source, tokens, namespace);
+}
+function collectNamedTypeDeclaration(declaration, source, tokens, namespace) {
+	addIdentifier(declaration.name(), "type", tokens, semanticTokenModifierBits.declaration);
+	collectTypeAnnotation(declaration.typeAnnotation(), source, tokens, namespace);
+	collectAttributes(declaration.attributes(), source, tokens, namespace);
+}
+function collectGenericBlockMembers(members, source, tokens, namespace) {
+	for (const member of members) {
+		if ("key" in member) {
+			addIdentifier(member.key(), "property", tokens);
+			collectExpression(member.value(), source, tokens, namespace);
+			continue;
+		}
+		collectAttribute(member, source, tokens, namespace);
+	}
+}
+function collectBlockMembers(members, source, tokens, namespace) {
+	for (const member of members) {
+		if (member instanceof FieldDeclarationAst) {
+			collectField(member, source, tokens, namespace);
+			continue;
+		}
+		collectAttribute(member, source, tokens, namespace);
+	}
+}
+function collectField(field, source, tokens, namespace) {
+	addIdentifier(field.name(), "property", tokens, semanticTokenModifierBits.declaration);
+	collectTypeAnnotation(field.typeAnnotation(), source, tokens, namespace);
+	collectAttributes(field.attributes(), source, tokens, namespace);
+}
+function collectTypeAnnotation(annotation, source, tokens, namespace) {
+	if (annotation === void 0) return;
+	collectTypeReference(annotation.name(), source, tokens, namespace);
+	collectAttributeArgList(annotation.argList(), source, tokens, namespace);
+}
+function collectAttributes(attributes, source, tokens, namespace) {
+	for (const attribute of attributes) collectAttribute(attribute, source, tokens, namespace);
+}
+function collectAttribute(attribute, source, tokens, namespace) {
+	const marker = findChildToken(attribute.syntax, "At") ?? findChildToken(attribute.syntax, "DoubleAt");
+	collectDecoratorName(attribute.name(), marker, tokens);
+	collectAttributeArgList(attribute.argList(), source, tokens, namespace);
+}
+function collectDecoratorName(name, marker, tokens) {
+	if (name === void 0) return;
+	const segments = identifierSegments(name);
+	for (const [index, segment] of segments.entries()) tokens.push(rangeForDecoratorIdentifier(segment.identifier, index === 0 ? marker : void 0));
+}
+function collectAttributeArgList(argList, source, tokens, namespace) {
+	if (argList === void 0) return;
+	for (const arg of argList.args()) collectAttributeArg(arg, source, tokens, namespace);
+}
+function collectAttributeArg(arg, source, tokens, namespace) {
+	const name = arg.name();
+	addIdentifier(name, "property", tokens);
+	collectExpression(arg.value(), source, tokens, namespace, expressionContextForAttributeArg(name));
+}
+function collectExpression(expression, source, tokens, namespace, context = {}) {
+	if (expression === void 0) return;
+	if (expression instanceof StringLiteralExprAst) {
+		addToken(expression.token(), "string", tokens);
+		return;
+	}
+	if (expression instanceof NumberLiteralExprAst) {
+		addToken(expression.token(), "number", tokens);
+		return;
+	}
+	if (expression instanceof BooleanLiteralExprAst) {
+		addToken(expression.token(), "keyword", tokens);
+		return;
+	}
+	if (expression instanceof FunctionCallAst) {
+		collectTypeReference(expression.name(), source, tokens, namespace);
+		for (const arg of expression.args()) collectAttributeArg(arg, source, tokens, namespace);
+		return;
+	}
+	if (expression instanceof ArrayLiteralAst) {
+		for (const element of expression.elements()) collectExpression(element, source, tokens, namespace, context);
+		return;
+	}
+	if (expression instanceof ObjectLiteralExprAst) {
+		for (const field of expression.fields()) {
+			addIdentifier(field.key(), "property", tokens);
+			collectExpression(field.value(), source, tokens, namespace);
+		}
+		return;
+	}
+	collectIdentifierExpression(expression, source, tokens, namespace, context);
+}
+function collectIdentifierExpression(identifier, source, tokens, namespace, context) {
+	const text = identifier.name();
+	if (text === void 0) return;
+	const bareIdentifierTokenType = context.bareIdentifierTokenType;
+	if (bareIdentifierTokenType !== void 0) {
+		tokens.push(rangeForIdentifier(identifier, bareIdentifierTokenType));
+		return;
+	}
+	const classification = classifyTypeReference([text], source, namespace);
+	tokens.push(rangeForIdentifier(identifier, classification.tokenType, classification.modifierBitset));
+}
+function expressionContextForAttributeArg(name) {
+	const argName = name?.name();
+	return argName === "fields" || argName === "references" ? { bareIdentifierTokenType: "property" } : {};
+}
+function collectTypeReference(name, source, tokens, namespace) {
+	if (name === void 0) return;
+	const segments = identifierSegments(name);
+	if (segments.length === 0) return;
+	const path = segments.map((segment) => segment.text);
+	for (const segment of segments.slice(0, -1)) if (isKnownNamespace(segment.text, source.symbolTable)) tokens.push(rangeForIdentifier(segment.identifier, "namespace"));
+	const finalSegment = segments[segments.length - 1];
+	if (finalSegment === void 0) return;
+	const classification = classifyTypeReference(path, source, namespace);
+	tokens.push(rangeForIdentifier(finalSegment.identifier, classification.tokenType, classification.modifierBitset));
+}
+function classifyTypeReference(path, source, namespace) {
+	const name = path[path.length - 1];
+	if (name === void 0) return { tokenType: "type" };
+	const table = source.symbolTable;
+	const namespaceName = path.length > 1 ? path[path.length - 2] : namespace;
+	const namespaceScope = namespaceName !== void 0 ? table.topLevel.namespaces[namespaceName] : void 0;
+	if (namespaceScope !== void 0) {
+		if (Object.hasOwn(namespaceScope.models, name)) return { tokenType: "class" };
+		if (Object.hasOwn(namespaceScope.compositeTypes, name)) return { tokenType: "struct" };
+		if (Object.hasOwn(namespaceScope.blocks, name)) return { tokenType: "type" };
+	}
+	if (Object.hasOwn(table.topLevel.models, name)) return { tokenType: "class" };
+	if (Object.hasOwn(table.topLevel.compositeTypes, name)) return { tokenType: "struct" };
+	const namedType = table.topLevel.namedTypes[name];
+	if (namedType !== void 0) return refinesScalarType(namedType, source.scalarTypes) ? {
+		tokenType: "type",
+		modifierBitset: semanticTokenModifierBits.defaultLibrary
+	} : { tokenType: "type" };
+	if (Object.hasOwn(table.topLevel.blocks, name)) return { tokenType: "type" };
+	if (source.scalarTypes.includes(name)) return {
+		tokenType: "type",
+		modifierBitset: semanticTokenModifierBits.defaultLibrary
+	};
+	return { tokenType: "type" };
+}
+function isKnownNamespace(name, table) {
+	return Object.hasOwn(table.topLevel.namespaces, name);
+}
+function identifierSegments(name) {
+	const segments = [];
+	for (const identifier of filterChildren(name.syntax, IdentifierAst.cast)) {
+		const text = identifier.name();
+		if (text !== void 0) segments.push({
+			identifier,
+			text
+		});
+	}
+	return segments;
+}
+function addIdentifier(identifier, tokenType, tokens, modifierBitset = 0) {
+	if (identifier === void 0) return;
+	tokens.push(rangeForIdentifier(identifier, tokenType, modifierBitset));
+}
+function addToken(token, tokenType, tokens, modifierBitset = 0) {
+	if (token === void 0) return;
+	tokens.push(pendingTokenForToken(token, tokenType, modifierBitset));
+}
+function rangeForIdentifier(identifier, tokenType, modifierBitset = 0) {
+	const token = identifier.token();
+	if (token === void 0) return createPendingSemanticToken(identifier.syntax.offset, identifier.syntax.offset, tokenType, modifierBitset);
+	return pendingTokenForToken(token, tokenType, modifierBitset);
+}
+function rangeForDecoratorIdentifier(identifier, marker) {
+	const range = rangeForIdentifier(identifier, "decorator");
+	if (marker === void 0 || marker.offset >= range.startOffset) return range;
+	return createPendingSemanticToken(marker.offset, range.endOffset, "decorator", range.modifierBitset);
+}
+function pendingTokenForToken(token, tokenType, modifierBitset = 0) {
+	return createPendingSemanticToken(token.offset, token.offset + token.text.length, tokenType, modifierBitset);
+}
+function mergeSourceOrderedTokens(left, right) {
+	const result = [];
+	let leftIndex = 0;
+	let rightIndex = 0;
+	while (leftIndex < left.length || rightIndex < right.length) {
+		const leftToken = left[leftIndex];
+		const rightToken = right[rightIndex];
+		if (leftToken !== void 0 && (rightToken === void 0 || leftToken.startOffset <= rightToken.startOffset)) {
+			result.push(leftToken);
+			leftIndex++;
+		} else if (rightToken !== void 0) {
+			result.push(rightToken);
+			rightIndex++;
+		}
+	}
+	return result;
+}
+function createPendingSemanticToken(startOffset, endOffset, tokenType, modifierBitset = 0) {
+	return {
+		startOffset,
+		endOffset,
+		tokenTypeIndex: tokenTypeIndex(tokenType),
+		modifierBitset,
+		splitMultiline: tokenType === "string" || tokenType === "comment"
+	};
+}
+function tokenTypeIndex(tokenType) {
+	return semanticTokenTypes.indexOf(tokenType);
+}
+/** The project a new load of this config could fall back to. */
+function lastGoodProject(entry) {
+	if (entry === void 0 || entry.status === "failed") return;
+	return entry.status === "loaded" ? entry.project : entry.lastGood;
+}
+const CONFIG_LOAD_FAILED_CODE = "PRISMA_NEXT_CONFIG_LOAD_FAILED";
+const semanticTokenSourceLimit = 1e5;
+function createServer(connection) {
+	const documents = new TextDocuments(TextDocument);
+	const managedProjects = /* @__PURE__ */ new Map();
+	const documentConfigPaths = /* @__PURE__ */ new Map();
+	let rootPath = process.cwd();
+	let watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
+	let clientCapabilities = noClientCapabilities;
+	let disposed = false;
+	function sendDiagnostics(params) {
+		if (disposed) return;
+		connection.sendDiagnostics(params);
+	}
+	function logWarn(message) {
+		if (disposed) return;
+		connection.console.warn(message);
+	}
+	async function publish(uri) {
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) return;
+		if (documents.get(uri) === void 0) {
+			documentConfigPaths.delete(uri);
+			return;
+		}
+		const artifacts = project.artifacts.document(uri);
+		if (artifacts === void 0) {
+			sendDiagnostics({
+				uri,
+				diagnostics: []
+			});
+			return;
+		}
+		sendDiagnostics({
+			uri,
+			diagnostics: combinedDiagnostics(artifacts)
+		});
+	}
+	function combinedDiagnostics(artifacts) {
+		return toDiagnostics([...artifacts.diagnostics, ...artifacts.interpretDiagnostics()]);
+	}
+	/**
+	* Project-scoped so a future multi-input symbol table can attach
+	* `relatedDocuments` for cross-file effects.
+	*/
+	function buildDocumentDiagnosticReport(project, uri) {
+		const artifacts = project.artifacts.document(uri);
+		return {
+			kind: DocumentDiagnosticReportKind.Full,
+			items: artifacts === void 0 ? [] : combinedDiagnostics(artifacts)
+		};
+	}
+	async function resolveProjectForDocument(uri) {
+		const project = await projectForNearestConfig(uri);
+		if (project === void 0 || project.inputs.includes(uri)) return project;
+		documentConfigPaths.delete(uri);
+		dropProjectWithoutManagedDocuments(project.configPath);
+	}
+	async function projectForNearestConfig(uri) {
+		const knownConfigPath = documentConfigPaths.get(uri);
+		if (knownConfigPath !== void 0) return resolveProjectIfLoadable(knownConfigPath);
+		const filePath = filePathFromUri(uri);
+		if (filePath === void 0) return;
+		let configPath;
+		try {
+			configPath = await findNearestConfigPathForFile(filePath);
+		} catch {
+			return;
+		}
+		if (configPath === void 0) return;
+		documentConfigPaths.set(uri, configPath);
+		return resolveProjectIfLoadable(configPath);
+	}
+	async function resolveProjectIfLoadable(configPath) {
+		try {
+			return await resolveProject(configPath);
+		} catch {
+			return;
+		}
+	}
+	async function resolveProject(configPath) {
+		const entry = managedProjects.get(configPath);
+		if (entry === void 0 || entry.status === "failed") return startProjectLoad(configPath);
+		return entry.status === "loaded" ? entry.project : entry.load;
+	}
+	function refreshProject(configPath) {
+		return startProjectLoad(configPath);
+	}
+	function startProjectLoad(configPath) {
+		const existing = managedProjects.get(configPath);
+		const previousLoad = existing?.status === "loading" ? existing.load : void 0;
+		const lastGood = lastGoodProject(existing);
+		const load = (previousLoad ?? Promise.resolve(void 0)).catch(() => void 0).then(() => loadProject(configPath)).then((project) => {
+			if (isCurrentLoad(configPath, load)) {
+				if (hasManagedDocuments(configPath)) managedProjects.set(configPath, {
+					status: "loaded",
+					project
+				});
+				else managedProjects.delete(configPath);
+				clearConfigFailure(configPath);
+			}
+			return project;
+		}, (error) => {
+			if (isCurrentLoad(configPath, load)) if (!hasManagedDocuments(configPath)) {
+				managedProjects.delete(configPath);
+				clearConfigFailure(configPath);
+			} else {
+				publishConfigFailure(configPath, error);
+				if (lastGood !== void 0) {
+					managedProjects.set(configPath, {
+						status: "loaded",
+						project: lastGood
+					});
+					return lastGood;
+				}
+				managedProjects.set(configPath, { status: "failed" });
+				unmanageDocuments(configPath);
+			}
+			throw error;
+		});
+		managedProjects.set(configPath, {
+			status: "loading",
+			load,
+			lastGood
+		});
+		return load;
+	}
+	function publishConfigFailure(configPath, error) {
+		sendDiagnostics({
+			uri: pathToFileURL(configPath).toString(),
+			diagnostics: [{
+				range: {
+					start: {
+						line: 0,
+						character: 0
+					},
+					end: {
+						line: 0,
+						character: 1
+					}
+				},
+				message: configFailureMessage(error),
+				code: CONFIG_LOAD_FAILED_CODE,
+				severity: DiagnosticSeverity.Error,
+				source: "prisma-next"
+			}]
+		});
+	}
+	function configFailureMessage(error) {
+		if (CliStructuredError.is(error)) return error.why ?? error.message;
+		return error instanceof Error ? error.message : String(error);
+	}
+	function clearConfigFailure(configPath) {
+		sendDiagnostics({
+			uri: pathToFileURL(configPath).toString(),
+			diagnostics: []
+		});
+	}
+	function isCurrentLoad(configPath, load) {
+		const entry = managedProjects.get(configPath);
+		return entry?.status === "loading" && entry.load === load;
+	}
+	async function loadProject(configPath) {
+		const resolution = await resolveConfigInputs(configPath);
+		const artifacts = createProjectArtifacts({
+			inputs: resolution.inputs,
+			controlStack: resolution.controlStack,
+			getText: (uri) => documents.get(uri)?.getText(),
+			...resolution.interpretation === void 0 ? {} : { interpretation: resolution.interpretation }
+		});
+		return {
+			configPath,
+			inputs: resolution.inputs,
+			controlStack: resolution.controlStack,
+			artifacts,
+			...resolution.formatter === void 0 ? {} : { formatter: resolution.formatter },
+			...resolution.interpretation === void 0 ? {} : { interpretation: resolution.interpretation }
+		};
+	}
+	function unmanageDocuments(configPath) {
+		for (const document of documents.all()) if (documentConfigPaths.get(document.uri) === configPath) documentConfigPaths.delete(document.uri);
+	}
+	async function republishOpenDocumentsForConfig(configPath) {
+		for (const document of documents.all()) {
+			if (documentConfigPaths.get(document.uri) === configPath) {
+				if (await resolveProjectForDocument(document.uri) === void 0) {
+					sendDiagnostics({
+						uri: document.uri,
+						diagnostics: []
+					});
+					continue;
+				}
+				await publish(document.uri);
+				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);
+			}
+		}
+	}
+	function publishSafely(uri) {
+		publish(uri).catch((error) => {
+			if (disposed) return;
+			try {
+				connection.console.error(error instanceof Error ? error.message : String(error));
+			} catch {}
+		});
+	}
+	async function formatDocument(uri) {
+		const document = documents.get(uri);
+		if (document === void 0) return [];
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) 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
+		}];
+	}
+	async function semanticTokensForDocument(uri, range) {
+		const document = documents.get(uri);
+		if (document === void 0) return emptySemanticTokens();
+		if (document.getText().length > semanticTokenSourceLimit) return emptySemanticTokens();
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) return emptySemanticTokens();
+		const artifacts = project.artifacts.document(uri);
+		if (artifacts === void 0) return emptySemanticTokens();
+		return buildSemanticTokens({
+			document: artifacts.document,
+			sourceFile: artifacts.sourceFile,
+			symbolTable: project.artifacts.symbolTable(),
+			scalarTypes: project.controlStack.scalarTypes
+		}, range);
+	}
+	async function completeDocument(uri, position) {
+		if (documents.get(uri) === void 0) return [];
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) return [];
+		const artifacts = project.artifacts.document(uri);
+		if (artifacts === void 0) return [];
+		try {
+			return [...providePslCompletionItems({
+				context: classifyPslCompletionContext({
+					document: artifacts.document,
+					sourceFile: artifacts.sourceFile,
+					position
+				}),
+				sourceFile: artifacts.sourceFile,
+				candidates: {
+					scalarTypes: project.controlStack.scalarTypes,
+					pslBlockDescriptors: project.controlStack.pslBlockDescriptors,
+					symbolTable: project.artifacts.symbolTable()
+				},
+				clientSupportsSnippets: clientCapabilities.completionSnippets
+			})];
+		} catch {
+			return [];
+		}
+	}
+	connection.onInitialize(async (params) => {
+		rootPath = resolveRootPath(params);
+		watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
+		clientCapabilities = resolveClientCapabilities(params);
+		return { capabilities: {
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			documentFormattingProvider: true,
+			foldingRangeProvider: true,
+			semanticTokensProvider: {
+				legend: semanticTokensLegend,
+				full: true,
+				range: true
+			},
+			completionProvider: { triggerCharacters: ["."] },
+			...clientCapabilities.pullDiagnostics ? { diagnosticProvider: {
+				interFileDependencies: false,
+				workspaceDiagnostics: false
+			} } : {}
+		} };
+	});
+	connection.onInitialized(() => {
+		if (clientCapabilities.watchedFilesRegistration) connection.sendRequest(RegistrationRequest.type, { registrations: [{
+			id: "prisma-8-config-watcher",
+			method: DidChangeWatchedFilesNotification.type.method,
+			registerOptions: { watchers: [{ globPattern: watchedConfigGlob }] }
+		}] }).catch(() => void 0);
+		else logWarn("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) {
+			if (managedProjects.has(configPath)) try {
+				await refreshProject(configPath);
+			} catch {
+				continue;
+			}
+			if (!clientCapabilities.pullDiagnostics) await republishOpenDocumentsForConfig(configPath);
+		}
+		if (clientCapabilities.pullDiagnostics && clientCapabilities.diagnosticsRefresh && changedConfigPaths.size > 0 && !disposed) connection.languages.diagnostics.refresh().catch(() => void 0);
+	});
+	connection.onDocumentFormatting((params) => formatDocument(params.textDocument.uri));
+	connection.onCompletion((params) => completeDocument(params.textDocument.uri, params.position));
+	connection.languages.semanticTokens.on((params) => semanticTokensForDocument(params.textDocument.uri));
+	connection.languages.semanticTokens.onRange((params) => semanticTokensForDocument(params.textDocument.uri, params.range));
+	connection.languages.diagnostics.on(async (params) => {
+		const project = await resolveProjectForDocument(params.textDocument.uri);
+		if (project === void 0) return {
+			kind: DocumentDiagnosticReportKind.Full,
+			items: []
+		};
+		return buildDocumentDiagnosticReport(project, params.textDocument.uri);
+	});
+	connection.onFoldingRanges(async (params) => {
+		const project = await resolveProjectForDocument(params.textDocument.uri);
+		if (project === void 0) return [];
+		const artifacts = project.artifacts.document(params.textDocument.uri);
+		if (artifacts === void 0) return [];
+		return computeFoldingRanges(artifacts.document, artifacts.sourceFile);
+	});
+	documents.onDidOpen((event) => {
+		artifactsForDocument(event.document.uri)?.documentChanged(event.document.uri);
+		if (clientCapabilities.pullDiagnostics) return;
+		publishSafely(event.document.uri);
+	});
+	documents.onDidChangeContent((event) => {
+		artifactsForDocument(event.document.uri)?.documentChanged(event.document.uri);
+		if (clientCapabilities.pullDiagnostics) return;
+		publishSafely(event.document.uri);
+	});
+	documents.onDidClose((event) => {
+		const uri = event.document.uri;
+		const configPath = documentConfigPaths.get(uri);
+		artifactsForDocument(uri)?.documentClosed(uri);
+		documentConfigPaths.delete(uri);
+		if (configPath !== void 0) dropProjectWithoutManagedDocuments(configPath);
+		if (!clientCapabilities.pullDiagnostics) sendDiagnostics({
+			uri,
+			diagnostics: []
+		});
+	});
+	documents.listen(connection);
+	connection.listen();
+	function artifactsForDocument(uri) {
+		const configPath = documentConfigPaths.get(uri);
+		if (configPath === void 0) return;
+		const entry = managedProjects.get(configPath);
+		return entry?.status === "loaded" ? entry.project.artifacts : void 0;
+	}
+	function hasManagedDocuments(configPath) {
+		for (const managedConfigPath of documentConfigPaths.values()) if (managedConfigPath === configPath) return true;
+		return false;
+	}
+	function dropProjectWithoutManagedDocuments(configPath) {
+		if (hasManagedDocuments(configPath)) return;
+		const entry = managedProjects.get(configPath);
+		if (entry === void 0 || entry.status === "loading") return;
+		managedProjects.delete(configPath);
+		clearConfigFailure(configPath);
+	}
+	return {
+		dispose: () => {
+			disposed = true;
+			connection.dispose();
+		},
+		getDocumentAst: (uri) => artifactsForDocument(uri)?.document(uri),
+		getProjectSymbolTable: (uri) => artifactsForDocument(uri)?.symbolTable()
+	};
+}
+function emptySemanticTokens() {
+	return { data: [] };
+}
+function toDiagnostics(computed) {
+	return computed.map((diagnostic) => ({
+		range: diagnostic.range,
+		message: diagnostic.message,
+		code: diagnostic.code,
+		severity: toLspSeverity(diagnostic.severity),
+		source: "prisma-next"
+	}));
+}
+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;
+	}
+}
+const noClientCapabilities = {
+	watchedFilesRegistration: false,
+	completionSnippets: false,
+	pullDiagnostics: false,
+	diagnosticsRefresh: false
+};
+function resolveClientCapabilities(params) {
+	return {
+		watchedFilesRegistration: params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true,
+		completionSnippets: params.capabilities.textDocument?.completion?.completionItem?.snippetSupport === true,
+		pullDiagnostics: params.capabilities.textDocument?.diagnostic !== void 0,
+		diagnosticsRefresh: params.capabilities.workspace?.diagnostics?.refreshSupport === true
+	};
+}
+function resolveRootPath(params) {
+	const workspaceFolder = params.workspaceFolders?.[0];
+	if (workspaceFolder !== void 0) return fileURLToPath(workspaceFolder.uri);
+	if (params.rootUri) return fileURLToPath(params.rootUri);
+	if (params.rootPath) return params.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;
+}
+function startServer() {
+	return createServer(createConnection(ProposedFeatures.all));
+}
+//#endregion
+export { startServer };
+
+//# sourceMappingURL=exports-B_xhKZmC.mjs.map