@inlang/sdk 0.34.9 → 0.34.10

package/src/adapter/solidAdapter.test.ts

@@ -1,13 +1,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect } from "vitest"
 import type { ImportFunction } from "../resolve-modules/index.js"
-import {
-	createResource,
-	createSignal,
-	createEffect,
-	from,
-	createRoot,
-} from "../reactivity/solid.js"
+import { createEffect, from, createRoot } from "../reactivity/solid.js"
 import { solidAdapter } from "./solidAdapter.js"
 import { loadProject } from "../loadProject.js"
 import { mockRepo } from "@lix-js/client"
@@ -19,10 +13,6 @@ import type {
 	Text,
 } from "../versionedInterfaces.js"
 
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
 // ------------------------------------------------------------------------------------------------
 
 const config: ProjectSettings = {
@@ -170,8 +160,8 @@ describe("installed", () => {
 		// TODO: how can we await `setConfig` correctly
 		await new Promise((resolve) => setTimeout(resolve, 0))
 
-		expect(counterPlugins).toBe(2) // 2 times because effect creation + set
-		expect(counterLint).toBe(2) // 2 times because effect creation + set
+		expect(counterPlugins).toBe(3) // 3 times because effect creation + setSettings, setResolvedModules
+		expect(counterLint).toBe(3) // 3 times because effect creation + setSettings, setResolvedModules
 	})
 })
 
@@ -219,7 +209,7 @@ describe("messages", () => {
 			{ from }
 		)
 
-		let effectOnMessagesCounter = 0
+		let effectOnMessagesCounter = -1
 		createEffect(() => {
 			project.query.messages.getAll()
 			effectOnMessagesCounter += 1
@@ -232,7 +222,7 @@ describe("messages", () => {
 		// TODO: how can we await `setConfig` correctly
 		await new Promise((resolve) => setTimeout(resolve, 510))
 
-		expect(effectOnMessagesCounter).toBe(7) // 7 = initial effect, setSetting, loadMessage (2x - one per message), setResolvedPlugins, loadMessages (2x - one per message)
+		expect(effectOnMessagesCounter).toBe(3) // 3 = setSetting, loadMessage (2x - one per message)
 		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
 	})
 
@@ -363,6 +353,65 @@ describe("messages", () => {
 })
 
 describe("lint", () => {
+	it("should react to changes in config", async () => {
+		await createRoot(async () => {
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
+			const project = solidAdapter(
+				await loadProject({
+					projectPath: "/user/project.inlang",
+					repo,
+					_import: $import,
+				}),
+				{ from }
+			)
+
+			// set counter to -1 since creating effect will execute once
+			let counter = -1
+			createEffect(() => {
+				project.query.messageLintReports.getAll()
+				counter += 1
+			})
+
+			expect(counter).toBe(0)
+
+			// wait for all int reports beeing executed
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			// 1 because we batch the two lint rules
+			expect(counter).toBe(1)
+
+			const currentSettings = project.settings()!
+			const newConfig = { ...currentSettings, languageTags: ["en", "de"] }
+			project.setSettings(newConfig)
+
+			// set settings trigges synchronous -> +1
+			expect(counter).toBe(2)
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			// 4 = 2 + batched(1 (effect->settings) and  1 (effect->Resolved Plugin))
+			expect(counter).toBe(3)
+			expect(project.query.messageLintReports.getAll()).toEqual([])
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			const newConfig2 = { ...project.settings()!, languageTags: ["en", "de", "fr"] }
+			project.setSettings(newConfig2)
+
+			// set settings trigges synchronous -> +1
+			expect(counter).toBe(4)
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			// 5 -> 4 + 1 new lint report batch
+			expect(counter).toBe(5)
+			expect(project.query.messageLintReports.getAll()).toEqual([])
+		})
+	})
+
 	it.todo("should react to changes to packages")
 	it.todo("should react to changes to modules")
 
@@ -381,23 +430,16 @@ describe("lint", () => {
 				{ from }
 			)
 
-			const [messages, setMessages] = createSignal<readonly Message[]>()
-
-			let counter = 0
-
+			let counter = -1 // -1 to start counting after the initial effect
 			createEffect(() => {
-				setMessages(project.query.messages.getAll())
-			})
-
-			const [lintReports] = createResource(messages, async () => {
-				const reports = await project.query.messageLintReports.getAll()
+				project.query.messageLintReports.getAll()
 				counter += 1
-				return reports
 			})
+			expect(counter).toBe(0)
 
-			await sleep(10)
+			await new Promise((resolve) => setTimeout(resolve, 510))
+			// 1 -> lint rules are batched - we expect one signal on getAll
 			expect(counter).toBe(1)
-			expect(lintReports()).toStrictEqual([])
 
 			project.query.messages.update({
 				where: { id: "a" },
@@ -406,10 +448,11 @@ describe("lint", () => {
 					variants: [{ languageTag: "en", match: [], pattern: [{ type: "Text", value: "new" }] }],
 				},
 			})
+			await new Promise((resolve) => setTimeout(resolve, 510))
 
-			await sleep(10)
-			expect(counter).toBe(2)
-			expect(lintReports()).toStrictEqual([])
+			// 1 -> previous two messages + 0 - report results are the same - no effect
+			expect(counter).toBe(1)
+			expect(project.query.messageLintReports.getAll()).toEqual([])
 
 			project.query.messages.update({
 				where: { id: "a" },
@@ -419,9 +462,11 @@ describe("lint", () => {
 				},
 			})
 
-			await sleep(10)
-			expect(counter).toBe(3)
-			expect(lintReports()).toStrictEqual([])
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			// 2 -> the updated message does not update the lint rules - result is the same
+			expect(counter).toBe(1)
+			expect(project.query.messageLintReports.getAll()).toEqual([])
 		})
 	})
 })

package/src/adapter/solidAdapter.ts

@@ -39,7 +39,7 @@ export const solidAdapter = (
 			},
 			messageLintReports: {
 				get: project.query.messageLintReports.get,
-				getAll: project.query.messageLintReports.getAll,
+				getAll: convert(project.query.messageLintReports.getAll),
 			},
 		},
 	} satisfies InlangProjectWithSolidAdapter

package/src/api.ts

@@ -82,9 +82,9 @@ export type Subscribable<Value> = {
 }
 
 export type MessageQueryDelegate = {
-	onMessageCreate: (messageId: string, message: Message) => void
-	onMessageUpdate: (messageId: string, message: Message) => void
-	onMessageDelete: (messageId: string) => void
+	onMessageCreate: (messageId: string, message: Message, messages: Message[]) => void
+	onMessageUpdate: (messageId: string, message: Message, messages: Message[]) => void
+	onMessageDelete: (messageId: string, messages: Message[]) => void
 	onLoaded: (messages: Message[]) => void
 	onCleanup: () => void
 }
@@ -109,12 +109,19 @@ export type MessageQueryApi = {
 	update: (args: { where: { id: Message["id"] }; data: Partial<Message> }) => boolean
 	upsert: (args: { where: { id: Message["id"] }; data: Message }) => void
 	delete: (args: { where: { id: Message["id"] } }) => boolean
-	setDelegate: (delegate: MessageQueryDelegate) => void
+	setDelegate: (delegate: MessageQueryDelegate | undefined, callOnLoad: boolean) => void
 }
 
 export type MessageLintReportsQueryApi = {
-	getAll: () => Promise<MessageLintReport[]>
-	get: (args: {
+	getAll: Subscribable<MessageLintReport[]> & {
+		settled: () => Promise<MessageLintReport[]>
+	}
+	get: ((args: {
 		where: { messageId: MessageLintReport["messageId"] }
-	}) => Promise<Readonly<MessageLintReport[]>>
+	}) => Readonly<MessageLintReport[]>) & {
+		subscribe: (
+			args: { where: { messageId: MessageLintReport["messageId"] } },
+			callback: (MessageLintRules: Readonly<MessageLintReport[]>) => void
+		) => void
+	}
 }

package/src/createMessageLintReportsQuery.ts

@@ -10,13 +10,13 @@ import type { resolveModules } from "./resolve-modules/index.js"
 import type { MessageLintReport, Message } from "./versionedInterfaces.js"
 import { lintSingleMessage } from "./lint/index.js"
 
+import { ReactiveMap } from "./reactivity/map.js"
+import { createMemo, onCleanup, untrack, batch } from "./reactivity/solid.js"
+import { createSubscribable } from "./loadProject.js"
+
 import _debug from "debug"
 const debug = _debug("sdk:lintReports")
 
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
 /**
  * Creates a non-reactive async query API for lint reports.
  * e.g. used in editor/.../Listheader.tsx
@@ -30,81 +30,196 @@ export function createMessageLintReportsQuery(
 	installedMessageLintRules: () => Array<InstalledMessageLintRule>,
 	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined
 ): InlangProject["query"]["messageLintReports"] {
-	const index = new Map<MessageLintReport["messageId"], MessageLintReport[]>()
-
-	const modules = resolvedModules()
-
-	const rulesArray = modules?.messageLintRules
-	const messageLintRuleLevels = Object.fromEntries(
-		installedMessageLintRules().map((rule) => [rule.id, rule.level])
-	)
-	const settingsObject = () => {
-		return {
-			...settings(),
-			messageLintRuleLevels,
-		}
-	}
+	// @ts-expect-error Reactive map seems to have a problem with Type aliases here
+	const index = new ReactiveMap<MessageLintReport["messageId"], MessageLintReport[]>()
+
+	debug("resetting settledReports")
+	let settledReports = Promise.resolve()
+
+	let currentBatchEnd: undefined | (() => Promise<void>) = undefined
+
+	const updatedReports: { [messageId: string]: MessageLintReport[] } = {}
+
+	// triggered whenever settings or resolved modules changes
+	createMemo(() => {
+		// we clear the index independent from the change for
+		index.clear()
+
+		onCleanup(() => {
+			messagesQuery.setDelegate(undefined, false)
+		})
 
-	const lintMessage = (message: Message, messages: Message[]) => {
-		if (!rulesArray) {
-			return
+		// settings is a signal - effect will be called whenever settings changes
+		const _settings = settings()
+		if (!_settings) return
+
+		const _resolvedModules = resolvedModules()
+		if (!_resolvedModules) return
+
+		// resolvedModules is a signal - effect will be called whenever resolvedModules changes
+		const rulesArray = _resolvedModules.messageLintRules
+
+		const messageLintRuleLevels = Object.fromEntries(
+			installedMessageLintRules().map((rule) => [rule.id, rule.level])
+		)
+		const settingsObject = () => {
+			return {
+				...settings(),
+				messageLintRuleLevels,
+			}
 		}
 
-		// TODO unhandled promise rejection (as before the refactor) but won't tackle this in this pr
-		lintSingleMessage({
-			rules: rulesArray,
-			settings: settingsObject(),
-			messages: messages,
-			message: message,
-		}).then((report) => {
-			if (report.errors.length === 0 && index.get(message.id) !== report.data) {
-				debug("lintSingleMessage", message.id, report.data.length)
-				index.set(message.id, report.data)
+		const sheduleLintMessage = (message: Message, messages: Message[]) => {
+			debug("shedule Lint for message:", message.id)
+
+			const updateOutstandingReportsOnLast = async () => {
+				if (currentBatchEnd !== updateOutstandingReportsOnLast) {
+					debug("skip triggering reactivy", message.id)
+					return
+				}
+				debug("finished queue - trigger reactivity", message.id)
+
+				batch(() => {
+					for (const [id, reports] of Object.entries(updatedReports)) {
+						const currentReports = index.get(id)
+						// we only update the report if it differs from the known one - to not trigger reactivity
+						if (!reportsEqual(currentReports, reports)) {
+							debug("lint reports for message: ", id, " now n:", reports.length)
+							index.set(id, reports)
+						}
+					}
+				})
 			}
+
+			currentBatchEnd = updateOutstandingReportsOnLast
+
+			const scheduledLint = lintSingleMessage({
+				rules: rulesArray,
+				settings: settingsObject(),
+				messages: messages,
+				message: message,
+			}).then((reportsResult) => {
+				if (reportsResult.errors.length === 0) {
+					debug("lint reports for message: ", message.id, "n:", reportsResult.data.length)
+					updatedReports[message.id] = reportsResult.data
+				}
+
+				return updateOutstandingReportsOnLast()
+			})
+			settledReports = settledReports.then(() => scheduledLint)
+		}
+
+		// setup delegate of message query
+		const messageQueryChangeDelegate: MessageQueryDelegate = {
+			onCleanup: () => {
+				// NOTE: we could cancel all running lint rules - but results get overritten anyway
+				index.clear()
+			},
+			onLoaded: (messages: Message[]) => {
+				// for (const message of messages) {
+				// 	lintMessage(message, messages)
+				// }
+				debug("sheduluing Lint for all messages - on load")
+				batch(() => {
+					debug("sheduluing Lint for all messages - subsquencial call?")
+					for (const message of messages) {
+						// NOTE: this potentually creates thousands of promisses we could create a promise that batches linting
+						// NOTE: this produces a lot of signals - we could batch the
+						sheduleLintMessage(message, messages)
+					}
+				})
+			},
+			onMessageCreate: (messageId: string, message: Message, messages: Message[]) => {
+				// NOTE: unhandled promise rejection (as before the refactor) but won't tackle this in this pr
+				// TODO MESDK-105 reevaluate all lint's instead of those for the messsage that where created
+				debug("shedule Lint for message - onMessageCreate", message.id)
+				sheduleLintMessage(message, messages)
+			},
+			onMessageUpdate: (messageId: string, message: Message, messages: Message[]) => {
+				// NOTE: unhandled promise rejection (as before the refactor) but won't tackle this in this pr
+				// TODO MESDK-105 reevaluate all lint's instead of those for the messsage that changed
+				debug("shedule Lint for message - onMessageUpdate", message.id)
+				sheduleLintMessage(message, messages)
+			},
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO MESDK-105 we gonna need the mesage Property for evaluation
+			onMessageDelete: (messageId: string, _messages: Message[]) => {
+				index.delete(messageId)
+			},
+		}
+
+		untrack(() => {
+			messagesQuery.setDelegate(messageQueryChangeDelegate, true)
 		})
+	})
+
+	const get = (args: Parameters<MessageLintReportsQueryApi["get"]>[0]) => {
+		debug("get", args.where.messageId)
+		return structuredClone(index.get(args.where.messageId))
 	}
 
-	const messages = messagesQuery.getAll() as Message[]
-	// load report for all messages once
-	for (const message of messages) {
-		// NOTE: this potentually creates thousands of promisses we could create a promise that batches linting
-		lintMessage(message, messages)
+	const getAll = () => {
+		const flatValues = [...index.values()].flat()
+		debug("getAll", flatValues.length)
+		return structuredClone(flatValues.length === 0 ? [] : flatValues) as MessageLintReport[]
 	}
 
-	const messageQueryChangeDelegate: MessageQueryDelegate = {
-		onCleanup: () => {
-			// NOTE: we could cancel all running lint rules - but results get overritten anyway
-			index.clear()
-		},
-		onLoaded: (messages: Message[]) => {
-			for (const message of messages) {
-				lintMessage(message, messages)
-			}
-		},
-		onMessageCreate: (messageId: string, message: Message) => {
-			lintMessage(message, messages)
-		},
-		onMessageUpdate: (messageId: string, message: Message) => {
-			lintMessage(message, messages)
-		},
-		onMessageDelete: (messageId: string) => {
-			index.delete(messageId)
-		},
+	return {
+		getAll: Object.assign(createSubscribable(getAll), {
+			settled: async () => {
+				await settledReports
+				return getAll()
+			},
+		}),
+		get: Object.assign(get, {
+			subscribe: (
+				args: Parameters<MessageLintReportsQueryApi["get"]["subscribe"]>[0],
+				callback: Parameters<MessageLintReportsQueryApi["get"]["subscribe"]>[1]
+			) => createSubscribable(() => get(args)).subscribe(callback),
+		}) as any,
 	}
+}
 
-	messagesQuery.setDelegate(messageQueryChangeDelegate)
+function reportsEqual(
+	reportsA: MessageLintReport[] | undefined,
+	reportsB: MessageLintReport[] | undefined
+) {
+	if (reportsA === undefined && reportsB === undefined) {
+		return true
+	} else if (reportsA === undefined || reportsB === undefined) {
+		return false
+	}
 
-	return {
-		getAll: async () => {
-			await sleep(0) // evaluate on next tick to allow for out-of-order effects
-			const flatValues = [...index.values()].flat()
-			debug("getAll", flatValues.length)
-			return structuredClone(flatValues.length === 0 ? [] : flatValues)
-		},
-		get: async (args: Parameters<MessageLintReportsQueryApi["get"]>[0]) => {
-			await sleep(0) // evaluate on next tick to allow for out-of-order effects
-			debug("get", args.where.messageId)
-			return structuredClone(index.get(args.where.messageId) ?? [])
-		},
+	if (reportsA.length !== reportsB.length) {
+		return false
+	}
+
+	for (const [i, element] of reportsA.entries()) {
+		if (element?.languageTag !== reportsB[i]?.languageTag) {
+			return false
+		}
+
+		if (element?.level !== reportsB[i]?.level) {
+			return false
+		}
+
+		if (element?.ruleId !== reportsB[i]?.ruleId) {
+			return false
+		}
+
+		if (typeof element?.body !== typeof reportsB[i]?.body) {
+			return false
+		}
+
+		if (typeof element?.body === "string") {
+			if (reportsB[i]?.body !== reportsB[i]?.body) {
+				return false
+			}
+		} else {
+			// NOTE: this was the fastest way to check if both bodies are equal - we can optimize that later if needed
+			if (JSON.stringify(element?.body) !== JSON.stringify(element?.body)) {
+				return false
+			}
+		}
 	}
+	return true
 }

package/src/createMessagesQuery.ts

@@ -1,13 +1,12 @@
 import type { Message } from "@inlang/message"
 import { ReactiveMap } from "./reactivity/map.js"
-import { createEffect } from "./reactivity/solid.js"
+import { createEffect, onCleanup } from "./reactivity/solid.js"
 import { createSubscribable } from "./loadProject.js"
 import type { InlangProject, MessageQueryApi, MessageQueryDelegate } from "./api.js"
 import type { ResolvedPluginApi } from "./resolve-modules/plugins/types.js"
 import type { resolveModules } from "./resolve-modules/resolveModules.js"
 import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js"
 import type { NodeishFilesystem } from "@lix-js/fs"
-import { onCleanup } from "solid-js"
 import { stringifyMessage } from "./storage/helper.js"
 import { acquireFileLock } from "./persistence/filelock/acquireFileLock.js"
 import _debug from "debug"
@@ -62,14 +61,18 @@ export function createMessagesQuery({
 }: createMessagesQueryParameters): InlangProject["query"]["messages"] {
 	// @ts-expect-error
 	const index = new ReactiveMap<string, Message>()
+	let loaded = false
 
 	// filepath for the lock folder
 	const messageLockDirPath = projectPath + "/messagelock"
 
 	let delegate: MessageQueryDelegate | undefined = undefined
 
-	const setDelegate = (newDelegate: MessageQueryDelegate) => {
+	const setDelegate = (newDelegate: MessageQueryDelegate | undefined, onLoad: boolean) => {
 		delegate = newDelegate
+		if (newDelegate && loaded && onLoad) {
+			newDelegate.onLoaded([...index.values()] as Message[])
+		}
 	}
 
 	// Map default alias to message
@@ -94,6 +97,7 @@ export function createMessagesQuery({
 		// we clear the index independent from the change for
 		index.clear()
 		defaultAliasIndex.clear()
+		loaded = false
 
 		// Load messages -> use settings to subscribe to signals from the settings
 		const _settings = settings()
@@ -143,7 +147,7 @@ export function createMessagesQuery({
 			messageLockDirPath,
 			messageStates,
 			index,
-			delegate,
+			undefined /* delegate - we don't pass it here since we will call onLoaded instead */,
 			_settings, // NOTE we bang here - we don't expect the settings to become null during the livetime of a project
 			resolvedPluginApi
 		)
@@ -154,6 +158,7 @@ export function createMessagesQuery({
 			.then(() => {
 				onInitialMessageLoadResult()
 				delegate?.onLoaded([...index.values()])
+				loaded = true
 			})
 	})
 
@@ -203,7 +208,7 @@ export function createMessagesQuery({
 			}
 
 			messageStates.messageDirtyFlags[data.id] = true
-			delegate?.onMessageCreate(data.id, index.get(data.id))
+			delegate?.onMessageCreate(data.id, index.get(data.id), [...index.values()])
 			scheduleSave()
 			return true
 		},
@@ -230,7 +235,7 @@ export function createMessagesQuery({
 			if (message === undefined) return false
 			index.set(where.id, { ...message, ...data })
 			messageStates.messageDirtyFlags[where.id] = true
-			delegate?.onMessageCreate(where.id, index.get(data.id))
+			delegate?.onMessageUpdate(where.id, index.get(data.id), [...index.values()])
 			scheduleSave()
 			return true
 		},
@@ -242,11 +247,11 @@ export function createMessagesQuery({
 					defaultAliasIndex.set(data.alias.default, data)
 				}
 				messageStates.messageDirtyFlags[where.id] = true
-				delegate?.onMessageCreate(data.id, index.get(data.id))
+				delegate?.onMessageCreate(data.id, index.get(data.id), [...index.values()])
 			} else {
 				index.set(where.id, { ...message, ...data })
 				messageStates.messageDirtyFlags[where.id] = true
-				delegate?.onMessageUpdate(data.id, index.get(data.id))
+				delegate?.onMessageUpdate(data.id, index.get(data.id), [...index.values()])
 			}
 			scheduleSave()
 			return true
@@ -259,7 +264,7 @@ export function createMessagesQuery({
 			}
 			index.delete(where.id)
 			messageStates.messageDirtyFlags[where.id] = true
-			delegate?.onMessageDelete(where.id)
+			delegate?.onMessageDelete(where.id, [...index.values()])
 			scheduleSave()
 			return true
 		},
@@ -323,6 +328,8 @@ async function loadMessagesViaPlugin(
 
 		let loadedMessageCount = 0
 
+		const deletedMessages = new Set(messages.keys())
+
 		for (const loadedMessage of loadedMessages) {
 			const loadedMessageClone = structuredClone(loadedMessage)
 
@@ -338,6 +345,8 @@ async function loadMessagesViaPlugin(
 				// - this could be the case if one edits the aliase manualy
 				throw new Error("more than one message with the same id or alias found ")
 			} else if (currentMessages.length === 1) {
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length has checked beforhand
+				deletedMessages.delete(currentMessages[0]!.id)
 				// update message in place - leave message id and alias untouched
 				loadedMessageClone.alias = {} as any
 
@@ -364,7 +373,7 @@ async function loadMessagesViaPlugin(
 				messages.set(loadedMessageClone.id, loadedMessageClone)
 				// NOTE could use hash instead of the whole object JSON to save memory...
 				messageState.messageLoadHash[loadedMessageClone.id] = importedEnecoded
-				delegate?.onMessageUpdate(loadedMessageClone.id, loadedMessageClone)
+				delegate?.onMessageUpdate(loadedMessageClone.id, loadedMessageClone, [...messages.values()])
 				loadedMessageCount++
 			} else {
 				// message with the given alias does not exist so far
@@ -392,7 +401,7 @@ async function loadMessagesViaPlugin(
 				// we don't have to check - done before hand if (messages.has(loadedMessageClone.id)) return false
 				messages.set(loadedMessageClone.id, loadedMessageClone)
 				messageState.messageLoadHash[loadedMessageClone.id] = importedEnecoded
-				delegate?.onMessageUpdate(loadedMessageClone.id, loadedMessageClone)
+				delegate?.onMessageUpdate(loadedMessageClone.id, loadedMessageClone, [...messages.values()])
 				loadedMessageCount++
 			}
 			if (loadedMessageCount > maxMessagesPerTick) {
@@ -403,6 +412,18 @@ async function loadMessagesViaPlugin(
 				loadedMessageCount = 0
 			}
 		}
+
+		loadedMessageCount = 0
+		for (const deletedMessageId of deletedMessages) {
+			messages.delete(deletedMessageId)
+			delegate?.onMessageDelete(deletedMessageId, [...messages.values()])
+			loadedMessageCount++
+			if (loadedMessageCount > maxMessagesPerTick) {
+				await sleep(0)
+				loadedMessageCount = 0
+			}
+		}
+
 		await releaseLock(fs as NodeishFilesystem, lockDirPath, "loadMessage", lockTime)
 		lockTime = undefined
 

package/src/createNodeishFsWithWatcher.ts

@@ -20,7 +20,7 @@ export const createNodeishFsWithWatcher = (args: {
 			ac.abort()
 		}
 		// release references
-		abortControllers = [];
+		abortControllers = []
 	}
 
 	const makeWatcher = (path: string) => {

package/src/lint/message/lintSingleMessage.ts

@@ -50,5 +50,8 @@ export const lintSingleMessage = async (args: {
 
 	await Promise.all(promises)
 
-	return { data: reports, errors }
+	// we sort the reports by rule id to allow us to easyly compare both
+	const sortedReports = reports.sort((r1, r2) => r1.ruleId.localeCompare(r2.ruleId))
+
+	return { data: sortedReports, errors }
 }