@effect/tsgo 0.0.12 → 0.0.14

package/bin/effect-tsgo.js

@@ -45596,7 +45596,7 @@ const cursorMove = (column, row = 0) => {
 	return command;
 };
 /** @internal */
-const eraseLines = (rows) => {
+const eraseLines$1 = (rows) => {
 	let command = "";
 	for (let i = 0; i < rows; i++) command += `${ESC}2K` + (i < rows - 1 ? `${ESC}1A` : "");
 	if (rows > 0) command += `${ESC}G`;
@@ -45787,7 +45787,7 @@ const runWithInput = (prompt, terminal, input) => suspend(() => {
 });
 const runLoop = /* @__PURE__ */ fnUntraced(function* (loop, terminal, input) {
 	let state = isEffect(loop.initialState) ? yield* loop.initialState : loop.initialState;
-	let action = Action.NextFrame({ state });
+	let action = Action$1.NextFrame({ state });
 	while (true) {
 		const msg = yield* loop.render(state, action);
 		yield* orDie(terminal.display(msg));
@@ -45808,24 +45808,24 @@ const runLoop = /* @__PURE__ */ fnUntraced(function* (loop, terminal, input) {
 		}
 	}
 }, (effect, _, terminal) => ensuring(effect, orDie(terminal.display(cursorShow))));
-const Action = /* @__PURE__ */ taggedEnum();
+const Action$1 = /* @__PURE__ */ taggedEnum();
 /**
 * Clears all lines taken up by the specified `text`.
 */
-const eraseText = (text, columns) => {
+const eraseText$1 = (text, columns) => {
 	if (columns === 0) return eraseLine + cursorTo(0);
 	let rows = 0;
 	const lines = text.split(NEWLINE_REGEXP);
 	for (const line of lines) rows += 1 + Math.floor(Math.max(line.length - 1, 0) / columns);
-	return eraseLines(rows);
+	return eraseLines$1(rows);
 };
 const lines = (prompt, columns) => {
 	const lines = prompt.split(NEWLINE_REGEXP);
 	return columns === 0 ? lines.length : pipe(map$7(lines, (line) => Math.ceil(line.length / columns)), reduce(0, (left, right) => left + right));
 };
 const clearOutputWithError = (outputText, columns, errorText) => {
-	if (errorText !== void 0 && errorText.length > 0) return cursorDown(lines(errorText, columns)) + eraseText(`\n${errorText}`, columns) + eraseText(outputText, columns);
-	return eraseText(outputText, columns);
+	if (errorText !== void 0 && errorText.length > 0) return cursorDown(lines(errorText, columns)) + eraseText$1(`\n${errorText}`, columns) + eraseText$1(outputText, columns);
+	return eraseText$1(outputText, columns);
 };
 const renderBeep = beep;
 const NEWLINE_REGEXP = /\r?\n/;
@@ -45833,7 +45833,7 @@ const handleConfirmClear = (options) => {
 	return fnUntraced(function* (state, _) {
 		const columns = yield* (yield* Terminal).columns;
 		const figures = yield* platformFigures;
-		return eraseText(renderConfirmOutput(state.value ? options.placeholder.defaultConfirm : options.placeholder.defaultDeny, "?", figures.pointerSmall, options, { plain: true }), columns) + (eraseLine + cursorLeft);
+		return eraseText$1(renderConfirmOutput(state.value ? options.placeholder.defaultConfirm : options.placeholder.defaultDeny, "?", figures.pointerSmall, options, { plain: true }), columns) + (eraseLine + cursorLeft);
 	});
 };
 const renderConfirmOutput = (confirm, leadingSymbol, trailingSymbol, options, renderOptions) => renderPrompt(confirm, options.message, leadingSymbol, trailingSymbol, renderOptions);
@@ -45853,7 +45853,7 @@ const renderConfirmSubmission = /* @__PURE__ */ fnUntraced(function* (value, opt
 });
 const handleConfirmRender = (options) => {
 	return (_, action) => {
-		return Action.$match(action, {
+		return Action$1.$match(action, {
 			Beep: () => succeed(renderBeep),
 			NextFrame: ({ state }) => renderConfirmNextFrame(state, options),
 			Submit: ({ value }) => renderConfirmSubmission(value, options)
@@ -45864,10 +45864,10 @@ const TRUE_VALUE_REGEXP = /^y|t$/;
 const FALSE_VALUE_REGEXP = /^n|f$/;
 const handleConfirmProcess = (input, defaultValue) => {
 	const value = input.input ?? "";
-	if (input.key.name === "enter" || input.key.name === "return") return succeed(Action.Submit({ value: defaultValue }));
-	if (TRUE_VALUE_REGEXP.test(value.toLowerCase())) return succeed(Action.Submit({ value: true }));
-	if (FALSE_VALUE_REGEXP.test(value.toLowerCase())) return succeed(Action.Submit({ value: false }));
-	return succeed(Action.Beep());
+	if (input.key.name === "enter" || input.key.name === "return") return succeed(Action$1.Submit({ value: defaultValue }));
+	if (TRUE_VALUE_REGEXP.test(value.toLowerCase())) return succeed(Action$1.Submit({ value: true }));
+	if (FALSE_VALUE_REGEXP.test(value.toLowerCase())) return succeed(Action$1.Submit({ value: false }));
+	return succeed(Action$1.Beep());
 };
 const renderPrompt = (confirm, message, leadingSymbol, trailingSymbol, options) => {
 	const prefix = leadingSymbol + " ";
@@ -45903,7 +45903,7 @@ const renderMultiSelectChoices = (state, options, figures, renderOptions) => {
 	const inverseSelectionText = options?.inverseSelection ?? "Inverse Selection";
 	const metaOptions = [{ title: selectAllText }, { title: inverseSelectionText }];
 	const allChoices = [...metaOptions, ...choices];
-	const toDisplay = entriesToDisplay(state.index, allChoices.length, options.maxPerPage);
+	const toDisplay = entriesToDisplay$1(state.index, allChoices.length, options.maxPerPage);
 	const documents = [];
 	for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
 		const choice = allChoices[index];
@@ -45939,14 +45939,14 @@ const renderMultiSelectSubmission = /* @__PURE__ */ fnUntraced(function* (state,
 });
 const processMultiSelectCursorUp = (state, totalChoices) => {
 	const newIndex = state.index === 0 ? totalChoices - 1 : state.index - 1;
-	return succeed(Action.NextFrame({ state: {
+	return succeed(Action$1.NextFrame({ state: {
 		...state,
 		index: newIndex
 	} }));
 };
 const processMultiSelectCursorDown = (state, totalChoices) => {
 	const newIndex = (state.index + 1) % totalChoices;
-	return succeed(Action.NextFrame({ state: {
+	return succeed(Action$1.NextFrame({ state: {
 		...state,
 		index: newIndex
 	} }));
@@ -45962,7 +45962,7 @@ const processSpace = (state, options) => {
 		if (selectedIndices.has(choiceIndex)) selectedIndices.delete(choiceIndex);
 		else selectedIndices.add(choiceIndex);
 	}
-	return succeed(Action.NextFrame({ state: {
+	return succeed(Action$1.NextFrame({ state: {
 		...state,
 		selectedIndices
 	} }));
@@ -45995,24 +45995,24 @@ const handleMultiSelectProcess = (options) => {
 			case "enter":
 			case "return": {
 				const selectedCount = state.selectedIndices.size;
-				if (options.min !== void 0 && selectedCount < options.min) return succeed(Action.NextFrame({ state: {
+				if (options.min !== void 0 && selectedCount < options.min) return succeed(Action$1.NextFrame({ state: {
 					...state,
 					error: `At least ${options.min} are required`
 				} }));
-				if (options.max !== void 0 && selectedCount > options.max) return succeed(Action.NextFrame({ state: {
+				if (options.max !== void 0 && selectedCount > options.max) return succeed(Action$1.NextFrame({ state: {
 					...state,
 					error: `At most ${options.max} choices are allowed`
 				} }));
 				const selectedValues = Array.from(state.selectedIndices).sort(Order$3).map((index) => options.choices[index].value);
-				return succeed(Action.Submit({ value: selectedValues }));
+				return succeed(Action$1.Submit({ value: selectedValues }));
 			}
-			default: return succeed(Action.Beep());
+			default: return succeed(Action$1.Beep());
 		}
 	};
 };
 const handleMultiSelectRender = (options) => {
 	return (state, action) => {
-		return Action.$match(action, {
+		return Action$1.$match(action, {
 			Beep: () => succeed(renderBeep),
 			NextFrame: ({ state }) => renderMultiSelectNextFrame(state, options),
 			Submit: () => renderMultiSelectSubmission(state, options)
@@ -46039,7 +46039,7 @@ const renderChoiceTitle = (choice, isSelected, renderOptions) => {
 };
 const renderSelectChoices = (state, options, figures, renderOptions) => {
 	const choices = options.choices;
-	const toDisplay = entriesToDisplay(state, choices.length, options.maxPerPage);
+	const toDisplay = entriesToDisplay$1(state, choices.length, options.maxPerPage);
 	const documents = [];
 	for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
 		const choice = choices[index];
@@ -46063,19 +46063,19 @@ const renderSelectSubmission = /* @__PURE__ */ fnUntraced(function* (state, opti
 	return renderSelectOutput(annotate(figures.tick, green$1), annotate(figures.ellipsis, blackBright), options) + " " + annotate(selected, white) + "\n";
 });
 const processSelectCursorUp = (state, choices) => {
-	if (state === 0) return succeed(Action.NextFrame({ state: choices.length - 1 }));
-	return succeed(Action.NextFrame({ state: state - 1 }));
+	if (state === 0) return succeed(Action$1.NextFrame({ state: choices.length - 1 }));
+	return succeed(Action$1.NextFrame({ state: state - 1 }));
 };
 const processSelectCursorDown = (state, choices) => {
-	if (state === choices.length - 1) return succeed(Action.NextFrame({ state: 0 }));
-	return succeed(Action.NextFrame({ state: state + 1 }));
+	if (state === choices.length - 1) return succeed(Action$1.NextFrame({ state: 0 }));
+	return succeed(Action$1.NextFrame({ state: state + 1 }));
 };
 const processSelectNext = (state, choices) => {
-	return succeed(Action.NextFrame({ state: (state + 1) % choices.length }));
+	return succeed(Action$1.NextFrame({ state: (state + 1) % choices.length }));
 };
 const handleSelectRender = (options) => {
 	return (state, action) => {
-		return Action.$match(action, {
+		return Action$1.$match(action, {
 			Beep: () => succeed(renderBeep),
 			NextFrame: ({ state }) => renderSelectNextFrame(state, options),
 			Submit: () => renderSelectSubmission(state, options)
@@ -46086,7 +46086,7 @@ const handleSelectClear = (options) => fnUntraced(function* (state, _) {
 	const columns = yield* (yield* Terminal).columns;
 	const figures = yield* platformFigures;
 	const clearPrompt = eraseLine + cursorLeft;
-	return eraseText(`${renderSelectOutput("?", figures.pointerSmall, options, { plain: true })}\n${renderSelectChoices(state, options, figures, { plain: true })}`, columns) + clearPrompt;
+	return eraseText$1(`${renderSelectOutput("?", figures.pointerSmall, options, { plain: true })}\n${renderSelectChoices(state, options, figures, { plain: true })}`, columns) + clearPrompt;
 });
 const handleSelectProcess = (options) => {
 	return (input, state) => {
@@ -46099,10 +46099,10 @@ const handleSelectProcess = (options) => {
 			case "enter":
 			case "return": {
 				const selected = options.choices[state];
-				if (selected.disabled) return succeed(Action.Beep());
-				return succeed(Action.Submit({ value: selected.value }));
+				if (selected.disabled) return succeed(Action$1.Beep());
+				return succeed(Action$1.Submit({ value: selected.value }));
 			}
-			default: return succeed(Action.Beep());
+			default: return succeed(Action$1.Beep());
 		}
 	};
 };
@@ -46157,12 +46157,12 @@ const renderTextSubmission = /* @__PURE__ */ fnUntraced(function* (state, option
 	return renderTextOutput(state, annotate(figures.tick, green$1), annotate(figures.ellipsis, blackBright), options, void 0, true) + "\n";
 });
 const processTextBackspace = (state) => {
-	if (state.cursor <= 0) return succeed(Action.Beep());
+	if (state.cursor <= 0) return succeed(Action$1.Beep());
 	const beforeCursor = state.value.slice(0, state.cursor - 1);
 	const afterCursor = state.value.slice(state.cursor);
 	const cursor = state.cursor - 1;
 	const value = `${beforeCursor}${afterCursor}`;
-	return succeed(Action.NextFrame({ state: {
+	return succeed(Action$1.NextFrame({ state: {
 		...state,
 		cursor,
 		value,
@@ -46170,28 +46170,28 @@ const processTextBackspace = (state) => {
 	} }));
 };
 const processTextCursorLeft = (state) => {
-	if (state.cursor <= 0) return succeed(Action.Beep());
+	if (state.cursor <= 0) return succeed(Action$1.Beep());
 	const cursor = state.cursor - 1;
-	return succeed(Action.NextFrame({ state: {
+	return succeed(Action$1.NextFrame({ state: {
 		...state,
 		cursor,
 		error: void 0
 	} }));
 };
 const processTextCursorRight = (state) => {
-	if (state.cursor >= state.value.length) return succeed(Action.Beep());
+	if (state.cursor >= state.value.length) return succeed(Action$1.Beep());
 	const cursor = Math.min(state.cursor + 1, state.value.length);
-	return succeed(Action.NextFrame({ state: {
+	return succeed(Action$1.NextFrame({ state: {
 		...state,
 		cursor,
 		error: void 0
 	} }));
 };
 const processTab = (state, options) => {
-	if (state.value === options.default) return succeed(Action.Beep());
+	if (state.value === options.default) return succeed(Action$1.Beep());
 	const value = getValue(state, options);
 	const cursor = value.length;
-	return succeed(Action.NextFrame({ state: {
+	return succeed(Action$1.NextFrame({ state: {
 		...state,
 		value,
 		cursor,
@@ -46201,7 +46201,7 @@ const processTab = (state, options) => {
 const defaultTextProcessor = (input, state) => {
 	const value = `${state.value.slice(0, state.cursor)}${input}${state.value.slice(state.cursor)}`;
 	const cursor = state.cursor + input.length;
-	return succeed(Action.NextFrame({ state: {
+	return succeed(Action$1.NextFrame({ state: {
 		...state,
 		cursor,
 		value,
@@ -46210,7 +46210,7 @@ const defaultTextProcessor = (input, state) => {
 };
 const handleTextRender = (options) => {
 	return (state, action) => {
-		return Action.$match(action, {
+		return Action$1.$match(action, {
 			Beep: () => succeed(renderBeep),
 			NextFrame: ({ state }) => renderTextNextFrame(state, options),
 			Submit: () => renderTextSubmission(state, options)
@@ -46227,12 +46227,12 @@ const handleTextProcess = (options) => {
 			case "return": {
 				const value = getValue(state, options);
 				return match$1(options.validate(value), {
-					onFailure: (error) => Action.NextFrame({ state: {
+					onFailure: (error) => Action$1.NextFrame({ state: {
 						...state,
 						value,
 						error
 					} }),
-					onSuccess: (value) => Action.Submit({ value })
+					onSuccess: (value) => Action$1.Submit({ value })
 				});
 			}
 			case "tab": return processTab(state, options);
@@ -46262,7 +46262,7 @@ const basePrompt = (options, type) => {
 		clear: handleTextClear(opts)
 	});
 };
-const entriesToDisplay = (cursor, total, maxVisible) => {
+const entriesToDisplay$1 = (cursor, total, maxVisible) => {
 	const max = maxVisible === void 0 ? total : maxVisible;
 	let startIndex = Math.min(total - max, cursor - Math.floor(max / 2));
 	if (startIndex < 0) startIndex = 0;
@@ -195732,7 +195732,7 @@ var FileReadError = class extends TaggedError("FileReadError") {
 //#endregion
 //#region package.json
 var name = "@effect/tsgo";
-var version = "0.0.12";
+var version = "0.0.14";
 
 //#endregion
 //#region src/setup/consts.ts
@@ -195813,16 +195813,28 @@ const assessTsConfig = (input) => {
 	const sourceFile = import_typescript.parseJsonText(input.fileName, input.text);
 	const parsed = import_typescript.convertToObject(sourceFile, []);
 	const hasPlugins = parsed.compilerOptions?.plugins !== void 0;
-	const hasLspPlugin = (parsed.compilerOptions?.plugins ?? []).some((plugin) => plugin.name === LSP_PLUGIN_NAME);
+	const plugins = parsed.compilerOptions?.plugins ?? [];
+	const hasLspPlugin = plugins.some((plugin) => plugin.name === LSP_PLUGIN_NAME);
+	const currentDiagnosticSeverities = getCurrentDiagnosticSeverities(plugins);
 	return {
 		path: input.fileName,
 		sourceFile,
 		parsed,
 		text: input.text,
 		hasPlugins,
-		hasLspPlugin
+		hasLspPlugin,
+		currentDiagnosticSeverities
 	};
 };
+function getCurrentDiagnosticSeverities(plugins) {
+	const lspPlugin = plugins.find((plugin) => plugin.name === LSP_PLUGIN_NAME);
+	if (!lspPlugin || typeof lspPlugin !== "object" || lspPlugin === null) return none$3();
+	const diagnosticSeverity = lspPlugin.diagnosticSeverity;
+	if (!diagnosticSeverity || typeof diagnosticSeverity !== "object" || Array.isArray(diagnosticSeverity)) return none$3();
+	const result = {};
+	for (const [key, value] of Object.entries(diagnosticSeverity)) if (value === "off" || value === "suggestion" || value === "message" || value === "warning" || value === "error") result[key] = value;
+	return Object.keys(result).length > 0 ? some(result) : none$3();
+}
 /**
 * Assess VSCode settings from input
 */
@@ -195906,6 +195918,15 @@ function insertNodeAtEndOfList(tracker, sourceFile, nodeArray, newNode) {
 		tracker.insertNodeAt(sourceFile, lastElement.end, newNode, { prefix: ",\n" });
 	}
 }
+function createDiagnosticSeverityObject(severities) {
+	const entries = Object.entries(severities).sort(([a], [b]) => a.localeCompare(b));
+	return import_typescript.factory.createObjectLiteralExpression(entries.map(([name, severity]) => import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral(name), import_typescript.factory.createStringLiteral(severity))), true);
+}
+function createLspPluginObject(target) {
+	const properties = [import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("name"), import_typescript.factory.createStringLiteral(LSP_PLUGIN_NAME))];
+	if (isSome(target.diagnosticSeverities)) properties.push(import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("diagnosticSeverity"), createDiagnosticSeverityObject(target.diagnosticSeverities.value)));
+	return import_typescript.factory.createObjectLiteralExpression(properties, true);
+}
 /**
 * Create a minimal LanguageServiceHost for use with ChangeTracker
 */
@@ -196091,22 +196112,38 @@ const computeTsConfigChanges = (current, target, lspVersion) => {
 				descriptions.push("Update $schema in tsconfig");
 				tracker.replaceNode(current.sourceFile, schemaProperty.initializer, schemaPropertyAssignment.initializer);
 			}
-			const pluginObject = import_typescript.factory.createObjectLiteralExpression([import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("name"), import_typescript.factory.createStringLiteral(LSP_PLUGIN_NAME))], false);
+			const pluginObject = createLspPluginObject(target);
 			if (!pluginsProperty) {
 				descriptions.push(`Add plugins array with ${LSP_PLUGIN_NAME} plugin`);
 				const newPluginsProp = import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("plugins"), import_typescript.factory.createArrayLiteralExpression([pluginObject], true));
 				insertNodeAtEndOfList(tracker, current.sourceFile, compilerOptions.properties, newPluginsProp);
 			} else if (import_typescript.isArrayLiteralExpression(pluginsProperty.initializer)) {
 				const pluginsArray = pluginsProperty.initializer;
-				if (!pluginsArray.elements.find((element) => {
+				const lspPluginElement = pluginsArray.elements.find((element) => {
 					if (import_typescript.isObjectLiteralExpression(element)) {
 						const nameProperty = findPropertyInObject(element, "name");
 						if (nameProperty && import_typescript.isStringLiteral(nameProperty.initializer)) return nameProperty.initializer.text === LSP_PLUGIN_NAME;
 					}
 					return false;
-				})) {
+				});
+				if (!lspPluginElement) {
 					descriptions.push(`Add ${LSP_PLUGIN_NAME} plugin to existing plugins array`);
 					insertNodeAtEndOfList(tracker, current.sourceFile, pluginsArray.elements, pluginObject);
+				} else if (import_typescript.isObjectLiteralExpression(lspPluginElement)) {
+					const diagnosticSeverityProperty = findPropertyInObject(lspPluginElement, "diagnosticSeverity");
+					if (isSome(target.diagnosticSeverities)) {
+						const newDiagnosticSeverityValue = createDiagnosticSeverityObject(target.diagnosticSeverities.value);
+						if (!diagnosticSeverityProperty) {
+							descriptions.push(`Add diagnosticSeverity to ${LSP_PLUGIN_NAME} plugin`);
+							insertNodeAtEndOfList(tracker, current.sourceFile, lspPluginElement.properties, import_typescript.factory.createPropertyAssignment(import_typescript.factory.createStringLiteral("diagnosticSeverity"), newDiagnosticSeverityValue));
+						} else if (import_typescript.isPropertyAssignment(diagnosticSeverityProperty)) {
+							descriptions.push(`Update diagnosticSeverity in ${LSP_PLUGIN_NAME} plugin`);
+							tracker.replaceNode(current.sourceFile, diagnosticSeverityProperty.initializer, newDiagnosticSeverityValue);
+						}
+					} else if (diagnosticSeverityProperty) {
+						descriptions.push(`Remove diagnosticSeverity from ${LSP_PLUGIN_NAME} plugin`);
+						deleteNodeFromList(tracker, current.sourceFile, lspPluginElement.properties, diagnosticSeverityProperty);
+					}
 				}
 			}
 		}
@@ -196383,6 +196420,529 @@ const renderCodeActions = (result, assessmentState) => gen(function* () {
 	}
 });
 
+//#endregion
+//#region src/rules.json
+var rules_default = [
+	{
+		"name": "anyUnknownInErrorContext",
+		"description": "Detects 'any' or 'unknown' types in Effect error or requirements channels",
+		"defaultSeverity": "off",
+		"codes": [377030]
+	},
+	{
+		"name": "catchAllToMapError",
+		"description": "Suggests using Effect.mapError instead of Effect.catch + Effect.fail",
+		"defaultSeverity": "suggestion",
+		"codes": [377010]
+	},
+	{
+		"name": "catchUnfailableEffect",
+		"description": "Warns when using error handling on Effects that never fail",
+		"defaultSeverity": "suggestion",
+		"codes": [377009]
+	},
+	{
+		"name": "classSelfMismatch",
+		"description": "Ensures Self type parameter matches the class name in Service/Tag/Schema classes",
+		"defaultSeverity": "error",
+		"codes": [377046]
+	},
+	{
+		"name": "deterministicKeys",
+		"description": "Enforces deterministic naming for service/tag/error identifiers based on class names",
+		"defaultSeverity": "off",
+		"codes": [377049]
+	},
+	{
+		"name": "duplicatePackage",
+		"description": "Warns when multiple versions of an Effect-related package are detected in the program",
+		"defaultSeverity": "warning",
+		"codes": [377051]
+	},
+	{
+		"name": "effectFnIife",
+		"description": "Effect.fn or Effect.fnUntraced is called as an IIFE; use Effect.gen instead",
+		"defaultSeverity": "warning",
+		"codes": [377011]
+	},
+	{
+		"name": "effectFnOpportunity",
+		"description": "Suggests using Effect.fn for functions that return an Effect",
+		"defaultSeverity": "suggestion",
+		"codes": [377047]
+	},
+	{
+		"name": "effectGenUsesAdapter",
+		"description": "Warns when using the deprecated adapter parameter in Effect.gen",
+		"defaultSeverity": "warning",
+		"codes": [377027]
+	},
+	{
+		"name": "effectInFailure",
+		"description": "Warns when an Effect is used inside an Effect failure channel",
+		"defaultSeverity": "warning",
+		"codes": [377054]
+	},
+	{
+		"name": "effectInVoidSuccess",
+		"description": "Detects nested Effects in void success channels that may cause unexecuted effects",
+		"defaultSeverity": "warning",
+		"codes": [377020]
+	},
+	{
+		"name": "effectMapVoid",
+		"description": "Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})",
+		"defaultSeverity": "suggestion",
+		"codes": [377018]
+	},
+	{
+		"name": "effectSucceedWithVoid",
+		"description": "Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
+		"defaultSeverity": "suggestion",
+		"codes": [377016]
+	},
+	{
+		"name": "extendsNativeError",
+		"description": "Warns when a class directly extends the native Error class",
+		"defaultSeverity": "off",
+		"codes": [377055]
+	},
+	{
+		"name": "floatingEffect",
+		"description": "Detects Effect values that are neither yielded nor assigned",
+		"defaultSeverity": "error",
+		"codes": [377001, 377058]
+	},
+	{
+		"name": "genericEffectServices",
+		"description": "Prevents services with type parameters that cannot be discriminated at runtime",
+		"defaultSeverity": "warning",
+		"codes": [377043]
+	},
+	{
+		"name": "globalErrorInEffectCatch",
+		"description": "Warns when catch callbacks return global Error type instead of typed errors",
+		"defaultSeverity": "warning",
+		"codes": [377022]
+	},
+	{
+		"name": "globalErrorInEffectFailure",
+		"description": "Warns when the global Error type is used in an Effect failure channel",
+		"defaultSeverity": "warning",
+		"codes": [377023]
+	},
+	{
+		"name": "instanceOfSchema",
+		"description": "Suggests using Schema.is instead of instanceof for Effect Schema types",
+		"defaultSeverity": "off",
+		"codes": [377042]
+	},
+	{
+		"name": "layerMergeAllWithDependencies",
+		"description": "Detects interdependencies in Layer.mergeAll calls where one layer provides a service that another layer requires",
+		"defaultSeverity": "warning",
+		"codes": [377035]
+	},
+	{
+		"name": "leakingRequirements",
+		"description": "Detects implementation services leaked in service methods",
+		"defaultSeverity": "suggestion",
+		"codes": [377041]
+	},
+	{
+		"name": "missedPipeableOpportunity",
+		"description": "Suggests using .pipe() for nested function calls",
+		"defaultSeverity": "off",
+		"codes": [377050]
+	},
+	{
+		"name": "missingEffectContext",
+		"description": "Detects Effect values with unhandled context requirements",
+		"defaultSeverity": "error",
+		"codes": [377004]
+	},
+	{
+		"name": "missingEffectError",
+		"description": "Detects Effect values with unhandled error types",
+		"defaultSeverity": "error",
+		"codes": [377003]
+	},
+	{
+		"name": "missingEffectServiceDependency",
+		"description": "Checks that Effect.Service dependencies satisfy all required layer inputs",
+		"defaultSeverity": "off",
+		"codes": [377039, 377040]
+	},
+	{
+		"name": "missingLayerContext",
+		"description": "Detects Layer values with unhandled context requirements",
+		"defaultSeverity": "error",
+		"codes": [377034]
+	},
+	{
+		"name": "missingReturnYieldStar",
+		"description": "Suggests using return yield* for Effects that never succeed",
+		"defaultSeverity": "error",
+		"codes": [377006]
+	},
+	{
+		"name": "missingStarInYieldEffectGen",
+		"description": "Detects bare yield (without *) inside Effect generator scopes",
+		"defaultSeverity": "error",
+		"codes": [377007, 377008]
+	},
+	{
+		"name": "multipleEffectProvide",
+		"description": "Warns against chaining Effect.provide calls which can cause service lifecycle issues",
+		"defaultSeverity": "warning",
+		"codes": [377033]
+	},
+	{
+		"name": "nodeBuiltinImport",
+		"description": "Warns when importing Node.js built-in modules that have Effect-native counterparts",
+		"defaultSeverity": "off",
+		"codes": [377057]
+	},
+	{
+		"name": "nonObjectEffectServiceType",
+		"description": "Ensures Effect.Service types are objects, not primitives",
+		"defaultSeverity": "error",
+		"codes": [377048]
+	},
+	{
+		"name": "outdatedApi",
+		"description": "Detects usage of APIs that have been removed or renamed in Effect v4",
+		"defaultSeverity": "warning",
+		"codes": [377052, 377053]
+	},
+	{
+		"name": "overriddenSchemaConstructor",
+		"description": "Prevents overriding constructors in Schema classes which breaks decoding behavior",
+		"defaultSeverity": "error",
+		"codes": [377044]
+	},
+	{
+		"name": "preferSchemaOverJson",
+		"description": "Suggests using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify",
+		"defaultSeverity": "suggestion",
+		"codes": [377026]
+	},
+	{
+		"name": "redundantSchemaTagIdentifier",
+		"description": "Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest",
+		"defaultSeverity": "suggestion",
+		"codes": [377045]
+	},
+	{
+		"name": "returnEffectInGen",
+		"description": "Warns when returning an Effect in a generator causes nested Effect<Effect<...>>",
+		"defaultSeverity": "suggestion",
+		"codes": [377014]
+	},
+	{
+		"name": "runEffectInsideEffect",
+		"description": "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
+		"defaultSeverity": "suggestion",
+		"codes": [377024, 377025]
+	},
+	{
+		"name": "schemaStructWithTag",
+		"description": "Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field",
+		"defaultSeverity": "suggestion",
+		"codes": [377036]
+	},
+	{
+		"name": "schemaSyncInEffect",
+		"description": "Suggests using Effect-based Schema methods instead of sync methods inside Effect generators",
+		"defaultSeverity": "suggestion",
+		"codes": [377037]
+	},
+	{
+		"name": "schemaUnionOfLiterals",
+		"description": "Suggests combining multiple Schema.Literal calls in Schema.Union into a single Schema.Literal",
+		"defaultSeverity": "off",
+		"codes": [377038]
+	},
+	{
+		"name": "scopeInLayerEffect",
+		"description": "Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements",
+		"defaultSeverity": "warning",
+		"codes": [377031]
+	},
+	{
+		"name": "serviceNotAsClass",
+		"description": "Warns when ServiceMap.Service is used as a variable instead of a class declaration",
+		"defaultSeverity": "off",
+		"codes": [377056]
+	},
+	{
+		"name": "strictBooleanExpressions",
+		"description": "Enforces boolean types in conditional expressions for type safety",
+		"defaultSeverity": "off",
+		"codes": [377029]
+	},
+	{
+		"name": "strictEffectProvide",
+		"description": "Warns when using Effect.provide with layers outside of application entry points",
+		"defaultSeverity": "off",
+		"codes": [377032]
+	},
+	{
+		"name": "tryCatchInEffectGen",
+		"description": "Discourages try/catch in Effect generators in favor of Effect error handling",
+		"defaultSeverity": "suggestion",
+		"codes": [377012]
+	},
+	{
+		"name": "unknownInEffectCatch",
+		"description": "Warns when catch callbacks return unknown instead of typed errors",
+		"defaultSeverity": "warning",
+		"codes": [377021]
+	},
+	{
+		"name": "unnecessaryEffectGen",
+		"description": "Suggests removing Effect.gen when it contains only a single return statement",
+		"defaultSeverity": "suggestion",
+		"codes": [377017]
+	},
+	{
+		"name": "unnecessaryFailYieldableError",
+		"description": "Suggests yielding yieldable errors directly instead of wrapping with Effect.fail",
+		"defaultSeverity": "suggestion",
+		"codes": [377019]
+	},
+	{
+		"name": "unnecessaryPipe",
+		"description": "Removes pipe calls with no arguments",
+		"defaultSeverity": "suggestion",
+		"codes": [377013]
+	},
+	{
+		"name": "unnecessaryPipeChain",
+		"description": "Simplifies chained pipe calls into a single pipe call",
+		"defaultSeverity": "suggestion",
+		"codes": [377015]
+	}
+];
+
+//#endregion
+//#region src/setup/rule-info.ts
+function getAllRules() {
+	return rules_default;
+}
+function cycleSeverity(current, direction) {
+	const order = [
+		"off",
+		"suggestion",
+		"message",
+		"warning",
+		"error"
+	];
+	const currentIndex = order.indexOf(current);
+	if (direction === "right") return order[(currentIndex + 1) % order.length];
+	return order[(currentIndex - 1 + order.length) % order.length];
+}
+const shortNames = {
+	off: "off",
+	suggestion: "sugg",
+	message: "info",
+	warning: "warn",
+	error: "err"
+};
+const MAX_SEVERITY_LENGTH = Object.values(shortNames).reduce((max, name) => Math.max(max, name.length), 0);
+function getSeverityShortName(severity) {
+	return shortNames[severity] ?? "???";
+}
+
+//#endregion
+//#region src/ansi.ts
+const RESET = "\x1B[0m";
+const BOLD = "\x1B[0;1m";
+const DIM = "\x1B[0;90m";
+const GREEN = "\x1B[0;32m";
+const WHITE = "\x1B[0;37m";
+const CYAN_BRIGHT = "\x1B[0;96m";
+const BG_BLACK_BRIGHT = "\x1B[0;100m";
+const BG_RED = "\x1B[41m";
+const BG_YELLOW = "\x1B[43m";
+const BG_BLUE = "\x1B[0;44m";
+const BG_CYAN = "\x1B[0;46m";
+const ansi = (text, code) => `${code}${text}${RESET}`;
+const ERASE_LINE = "\x1B[2K";
+const CURSOR_LEFT = "\r";
+const CURSOR_HIDE = "\x1B[?25l";
+const CURSOR_TO_0 = "\x1B[G";
+const BEEP = "\x07";
+
+//#endregion
+//#region src/setup/rule-prompt.ts
+function eraseLines(count) {
+	let result = "";
+	for (let i = 0; i < count; i++) {
+		if (i > 0) result += "\x1B[1A";
+		result += ERASE_LINE;
+	}
+	if (count > 0) result += CURSOR_LEFT;
+	return result;
+}
+const Action = taggedEnum();
+const NEWLINE_REGEX = /\r?\n/;
+function eraseText(text, columns) {
+	if (columns === 0) return ERASE_LINE + CURSOR_TO_0;
+	let rows = 0;
+	const lines = text.split(/\r?\n/);
+	for (const line of lines) rows += 1 + Math.floor(Math.max(line.length - 1, 0) / columns);
+	return eraseLines(rows);
+}
+function entriesToDisplay(cursor, total, maxVisible) {
+	const max = maxVisible === void 0 ? total : maxVisible;
+	let startIndex = Math.min(total - max, cursor - Math.floor(max / 2));
+	if (startIndex < 0) startIndex = 0;
+	const endIndex = Math.min(startIndex + max, total);
+	return {
+		startIndex,
+		endIndex
+	};
+}
+const figuresValue = {
+	arrowUp: "↑",
+	arrowDown: "↓",
+	tick: "✔",
+	pointerSmall: "›"
+};
+function getSeverityStyle(severity) {
+	return {
+		off: WHITE + BG_BLACK_BRIGHT,
+		suggestion: WHITE + BG_CYAN,
+		message: WHITE + BG_BLUE,
+		warning: WHITE + BG_YELLOW,
+		error: WHITE + BG_RED
+	}[severity];
+}
+function renderOutput(leadingSymbol, trailingSymbol, options) {
+	const annotateLine = (line) => ansi(line, BOLD);
+	const prefix = leadingSymbol + " ";
+	return match$6(options.message.split(NEWLINE_REGEX), {
+		onEmpty: () => `${prefix}${trailingSymbol}`,
+		onNonEmpty: (promptLines) => {
+			return `${prefix}${map$7(promptLines, (line) => annotateLine(line)).join("\n  ")} ${trailingSymbol} `;
+		}
+	});
+}
+function renderRules(state, options, figs, columns) {
+	const toDisplay = entriesToDisplay(state.index, options.rules.length, options.maxPerPage);
+	const documents = [];
+	for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
+		const rule = options.rules[index];
+		const isHighlighted = state.index === index;
+		const currentSeverity = state.severities[rule.name] ?? rule.defaultSeverity;
+		const hasChanged = currentSeverity !== rule.defaultSeverity;
+		let prefix = " ";
+		if (index === toDisplay.startIndex && toDisplay.startIndex > 0) prefix = figs.arrowUp;
+		else if (index === toDisplay.endIndex - 1 && toDisplay.endIndex < options.rules.length) prefix = figs.arrowDown;
+		const severityStr = ansi(` ${getSeverityShortName(currentSeverity).padEnd(MAX_SEVERITY_LENGTH, " ")} `, getSeverityStyle(currentSeverity));
+		const nameText = hasChanged ? `${rule.name}*` : rule.name;
+		const nameStr = isHighlighted ? ansi(nameText, CYAN_BRIGHT) : nameText;
+		const mainLine = `${prefix} ${severityStr} ${nameStr}`;
+		if (isHighlighted && rule.description) {
+			const indentWidth = 2 + (MAX_SEVERITY_LENGTH + 2) + 1;
+			const indent = " ".repeat(indentWidth);
+			const availableWidth = columns - indentWidth;
+			const truncatedDescription = availableWidth > 0 && rule.description.length > availableWidth ? rule.description.substring(0, availableWidth - 1) + "…" : rule.description;
+			documents.push(mainLine + "\n" + ansi(indent + truncatedDescription, DIM));
+		} else documents.push(mainLine);
+	}
+	return documents.join("\n");
+}
+function renderNextFrame(state, options) {
+	return gen(function* () {
+		const rulesStr = renderRules(state, options, figuresValue, yield* (yield* Terminal).columns);
+		const promptMsg = renderOutput(ansi("?", CYAN_BRIGHT), figuresValue.pointerSmall, options);
+		const helpText = ansi("Use ↑/↓ to navigate, ←/→ to change severity, Enter to finish", DIM);
+		return CURSOR_HIDE + promptMsg + "\n" + helpText + "\n" + rulesStr;
+	});
+}
+function renderSubmission(state, options) {
+	return gen(function* () {
+		const changedCount = Object.entries(state.severities).filter(([name, severity]) => {
+			const rule = options.rules.find((current) => current.name === name);
+			return rule && severity !== rule.defaultSeverity;
+		}).length;
+		const result = ansi(`${changedCount} rule${changedCount === 1 ? "" : "s"} configured`, WHITE);
+		return renderOutput(ansi(figuresValue.tick, GREEN), "", options) + " " + result + "\n";
+	});
+}
+function processCursorUp(state, totalCount) {
+	const newIndex = state.index === 0 ? totalCount - 1 : state.index - 1;
+	return succeed(Action.NextFrame({ state: {
+		...state,
+		index: newIndex
+	} }));
+}
+function processCursorDown(state, totalCount) {
+	const newIndex = (state.index + 1) % totalCount;
+	return succeed(Action.NextFrame({ state: {
+		...state,
+		index: newIndex
+	} }));
+}
+function processSeverityChange(state, options, direction) {
+	const rule = options.rules[state.index];
+	const newSeverity = cycleSeverity(state.severities[rule.name] ?? rule.defaultSeverity, direction);
+	return succeed(Action.NextFrame({ state: {
+		...state,
+		severities: {
+			...state.severities,
+			[rule.name]: newSeverity
+		}
+	} }));
+}
+function handleProcess(options) {
+	return (input, state) => {
+		const totalCount = options.rules.length;
+		switch (input.key.name) {
+			case "k":
+			case "up": return processCursorUp(state, totalCount);
+			case "j":
+			case "down": return processCursorDown(state, totalCount);
+			case "left": return processSeverityChange(state, options, "left");
+			case "right": return processSeverityChange(state, options, "right");
+			case "enter":
+			case "return": return succeed(Action.Submit({ value: state.severities }));
+			default: return succeed(Action.Beep());
+		}
+	};
+}
+function handleClear(options) {
+	return gen(function* () {
+		const columns = yield* (yield* Terminal).columns;
+		const visibleCount = Math.min(options.rules.length, options.maxPerPage);
+		return eraseText("\n".repeat(visibleCount + 2) + options.message, columns) + ERASE_LINE + CURSOR_LEFT;
+	});
+}
+function handleRender(options) {
+	return (state, action) => Action.$match(action, {
+		Beep: () => succeed(BEEP),
+		NextFrame: ({ state }) => renderNextFrame(state, options),
+		Submit: () => renderSubmission(state, options)
+	});
+}
+function createRulePrompt(rules, initialSeverities) {
+	const options = {
+		message: "Configure Rule Severities",
+		rules,
+		maxPerPage: 10
+	};
+	return custom({
+		index: 0,
+		severities: initialSeverities
+	}, {
+		render: handleRender(options),
+		process: handleProcess(options),
+		clear: () => handleClear(options)
+	});
+}
+
 //#endregion
 //#region src/setup/target-prompt.ts
 /**
@@ -196420,10 +196980,26 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 			lspVersion: none$3(),
 			prepareScript: false
 		},
-		tsconfig: { plugin: false },
+		tsconfig: {
+			plugin: false,
+			diagnosticSeverities: none$3()
+		},
 		vscodeSettings: none$3(),
 		editors: []
 	};
+	const diagnosticSeverities = (yield* select({
+		message: "Would you like to customize the diagnostic severities?",
+		choices: [{
+			title: "Yes",
+			description: "Review the available rules and adjust their severities",
+			value: true,
+			selected: true
+		}, {
+			title: "No",
+			description: "Keep the default severities shipped by @effect/tsgo",
+			value: false
+		}]
+	})) ? some(yield* createRulePrompt(getAllRules(), getOrElse$1(assessment.tsconfig.currentDiagnosticSeverities, () => ({})))) : none$3();
 	const hasVscodeSettings = isSome(assessment.vscodeSettings);
 	const editors = yield* multiSelect({
 		message: "Which editors do you use?",
@@ -196443,7 +197019,10 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 			}
 		]
 	});
-	const vscodeSettings = editors.includes("vscode") ? some({ settings: { "typescript.native-preview.tsdk": "node_modules/@typescript/native-preview" } }) : none$3();
+	const vscodeSettings = editors.includes("vscode") ? some({ settings: {
+		"typescript.native-preview.tsdk": "node_modules/@typescript/native-preview",
+		"typescript.experimental.useTsgo": true
+	} }) : none$3();
 	return {
 		packageJson: {
 			lspVersion: some({
@@ -196452,7 +197031,10 @@ const gatherTargetState = (assessment, context) => gen(function* () {
 			}),
 			prepareScript: true
 		},
-		tsconfig: { plugin: true },
+		tsconfig: {
+			plugin: true,
+			diagnosticSeverities
+		},
 		vscodeSettings,
 		editors
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/tsgo",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Effect Language Service for TypeScript-Go — Effect-specific diagnostics and hover features.",
   "license": "MIT",
   "repository": {
@@ -21,13 +21,13 @@
     "bin/"
   ],
   "optionalDependencies": {
-    "@effect/tsgo-win32-x64": "0.0.12",
-    "@effect/tsgo-win32-arm64": "0.0.12",
-    "@effect/tsgo-linux-x64": "0.0.12",
-    "@effect/tsgo-linux-arm64": "0.0.12",
-    "@effect/tsgo-linux-arm": "0.0.12",
-    "@effect/tsgo-darwin-x64": "0.0.12",
-    "@effect/tsgo-darwin-arm64": "0.0.12"
+    "@effect/tsgo-win32-x64": "0.0.14",
+    "@effect/tsgo-win32-arm64": "0.0.14",
+    "@effect/tsgo-linux-x64": "0.0.14",
+    "@effect/tsgo-linux-arm64": "0.0.14",
+    "@effect/tsgo-linux-arm": "0.0.14",
+    "@effect/tsgo-darwin-x64": "0.0.14",
+    "@effect/tsgo-darwin-arm64": "0.0.14"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-beta.11",