@inlang/sdk 0.35.5 → 0.35.6

package/src/loadProject.ts

@@ -4,6 +4,8 @@ import type {
 	InstalledMessageLintRule,
 	InstalledPlugin,
 	Subscribable,
+	MessageQueryApi,
+	MessageLintReportsQueryApi,
 } from "./api.js"
 import { type ImportFunction, resolveModules } from "./resolve-modules/index.js"
 import { TypeCompiler, ValueErrorType } from "@sinclair/typebox/compiler"
@@ -30,6 +32,10 @@ import { maybeCreateFirstProjectId } from "./migrations/maybeCreateFirstProjectI
 import { capture } from "./telemetry/capture.js"
 import { identifyProject } from "./telemetry/groupIdentify.js"
 
+import { stubMessagesQuery, stubMessageLintReportsQuery } from "./v2/stubQueryApi.js"
+import type { StoreApi } from "./persistence/storeApi.js"
+import { openStore } from "./persistence/store.js"
+
 import _debug from "debug"
 const debug = _debug("sdk:loadProject")
 
@@ -80,9 +86,16 @@ export async function loadProject(args: {
 		)
 
 		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
+		const [loadedSettings, markSettingsAsLoaded, markSettingsAsFailed] = createAwaitable()
 		// -- settings ------------------------------------------------------------
 
 		const [settings, _setSettings] = createSignal<ProjectSettings>()
+		let v2Persistence = false
+		let locales: string[] = []
+
+		// This effect currently has no signals
+		// TODO: replace createEffect with await loadSettings
+		// https://github.com/opral/inlang-message-sdk/issues/77
 		createEffect(() => {
 			// TODO:
 			// if (projectId) {
@@ -92,12 +105,17 @@ export async function loadProject(args: {
 			// }
 
 			loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs })
-				.then((settings) => setSettings(settings))
+				.then((settings) => {
+					setSettings(settings)
+					markSettingsAsLoaded()
+				})
 				.catch((err) => {
 					markInitAsFailed(err)
+					markSettingsAsFailed(err)
 				})
 		})
 		// TODO: create FS watcher and update settings on change
+		// https://github.com/opral/inlang-message-sdk/issues/35
 
 		const writeSettingsToDisk = skipFirst((settings: ProjectSettings) =>
 			_writeSettingsToDisk({ nodeishFs, settings, projectPath })
@@ -106,11 +124,8 @@ export async function loadProject(args: {
 		const setSettings = (settings: ProjectSettings): Result<void, ProjectSettingsInvalidError> => {
 			try {
 				const validatedSettings = parseSettings(settings)
-				if (validatedSettings.experimental?.persistence) {
-					settings["plugin.sdk.persistence"] = {
-						pathPattern: projectPath + "/messages.json",
-					}
-				}
+				v2Persistence = !!validatedSettings.experimental?.persistence
+				locales = validatedSettings.languageTags
 
 				batch(() => {
 					// reset the resolved modules first - since they are no longer valid at that point
@@ -147,40 +162,11 @@ export async function loadProject(args: {
 				.catch((err) => markInitAsFailed(err))
 		})
 
-		// -- messages ----------------------------------------------------------
+		// -- installed items ----------------------------------------------------
 
 		let settingsValue: ProjectSettings
-		createEffect(() => (settingsValue = settings()!)) // workaround to not run effects twice (e.g. settings change + modules change) (I'm sure there exists a solid way of doing this, but I haven't found it yet)
-
-		const [loadMessagesViaPluginError, setLoadMessagesViaPluginError] = createSignal<
-			Error | undefined
-		>()
-
-		const [saveMessagesViaPluginError, setSaveMessagesViaPluginError] = createSignal<
-			Error | undefined
-		>()
-
-		const messagesQuery = createMessagesQuery({
-			projectPath,
-			nodeishFs,
-			settings,
-			resolvedModules,
-			onInitialMessageLoadResult: (e) => {
-				if (e) {
-					markInitAsFailed(e)
-				} else {
-					markInitAsComplete()
-				}
-			},
-			onLoadMessageResult: (e) => {
-				setLoadMessagesViaPluginError(e)
-			},
-			onSaveMessageResult: (e) => {
-				setSaveMessagesViaPluginError(e)
-			},
-		})
-
-		// -- installed items ----------------------------------------------------
+		// workaround to not run effects twice (e.g. settings change + modules change) (I'm sure there exists a solid way of doing this, but I haven't found it yet)
+		createEffect(() => (settingsValue = settings()!))
 
 		const installedMessageLintRules = () => {
 			if (!resolvedModules()) return []
@@ -213,17 +199,69 @@ export async function loadProject(args: {
 			})) satisfies Array<InstalledPlugin>
 		}
 
+		// -- messages ----------------------------------------------------------
+
+		const [loadMessagesViaPluginError, setLoadMessagesViaPluginError] = createSignal<
+			Error | undefined
+		>()
+
+		const [saveMessagesViaPluginError, setSaveMessagesViaPluginError] = createSignal<
+			Error | undefined
+		>()
+
+		let messagesQuery: MessageQueryApi
+		let lintReportsQuery: MessageLintReportsQueryApi
+		let store: StoreApi | undefined
+
+		// wait for seetings to load v2Persistence flag
+		// .catch avoids throwing here if the awaitable is rejected
+		// error is recorded via markInitAsFailed so no need to capture it again
+		await loadedSettings.catch(() => {})
+
+		if (v2Persistence) {
+			messagesQuery = stubMessagesQuery
+			lintReportsQuery = stubMessageLintReportsQuery
+			try {
+				store = await openStore({ projectPath, nodeishFs, locales })
+				markInitAsComplete()
+			} catch (e) {
+				markInitAsFailed(e)
+			}
+		} else {
+			messagesQuery = createMessagesQuery({
+				projectPath,
+				nodeishFs,
+				settings,
+				resolvedModules,
+				onInitialMessageLoadResult: (e) => {
+					if (e) {
+						markInitAsFailed(e)
+					} else {
+						markInitAsComplete()
+					}
+				},
+				onLoadMessageResult: (e) => {
+					setLoadMessagesViaPluginError(e)
+				},
+				onSaveMessageResult: (e) => {
+					setSaveMessagesViaPluginError(e)
+				},
+			})
+
+			lintReportsQuery = createMessageLintReportsQuery(
+				messagesQuery,
+				settings as () => ProjectSettings,
+				installedMessageLintRules,
+				resolvedModules
+			)
+
+			store = undefined
+		}
+
 		// -- app ---------------------------------------------------------------
 
 		const initializeError: Error | undefined = await initialized.catch((error) => error)
 
-		const lintReportsQuery = createMessageLintReportsQuery(
-			messagesQuery,
-			settings as () => ProjectSettings,
-			installedMessageLintRules,
-			resolvedModules
-		)
-
 		/**
 		 * Utility to escape reactive tracking and avoid multiple calls to
 		 * the capture event.
@@ -250,6 +288,8 @@ export async function loadProject(args: {
 					settings: settings(),
 					installedPluginIds: installedPlugins().map((p) => p.id),
 					installedMessageLintRuleIds: installedMessageLintRules().map((r) => r.id),
+					// TODO: fix for v2Persistence
+					// https://github.com/opral/inlang-message-sdk/issues/78
 					numberOfMessages: messagesQuery.includedMessageIds().length,
 				},
 			})
@@ -276,6 +316,7 @@ export async function loadProject(args: {
 				messages: messagesQuery,
 				messageLintReports: lintReportsQuery,
 			},
+			store,
 		} satisfies InlangProject
 	})
 }

package/src/persistence/batchedIO.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, vi } from "vitest"
+import { sleep } from "../test-utilities/sleep.js"
+import { batchedIO } from "./batchedIO.js"
+
+let locked = false
+
+const instrumentAquireLockStart = vi.fn()
+
+async function mockAquireLock() {
+	instrumentAquireLockStart()
+	let pollCount = 0
+	while (locked && pollCount++ < 100) {
+		await sleep(10)
+	}
+	if (locked) {
+		throw new Error("Timeout acquiring lock")
+	}
+	await sleep(10)
+	locked = true
+	return 69
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function mockReleaseLock(_: number) {
+	sleep(10)
+	locked = false
+}
+
+const instrumentSaveStart = vi.fn()
+const instrumentSaveEnd = vi.fn()
+
+async function mockSave() {
+	instrumentSaveStart()
+	await sleep(50)
+	instrumentSaveEnd()
+}
+
+describe("batchedIO", () => {
+	it("queues 2 requests while waiting for lock and pushes 2 more to the next batch", async () => {
+		const save = batchedIO(mockAquireLock, mockReleaseLock, mockSave)
+		const p1 = save("1")
+		const p2 = save("2")
+		await sleep(5)
+		expect(instrumentAquireLockStart).toHaveBeenCalledTimes(1)
+		expect(instrumentSaveStart).not.toHaveBeenCalled()
+		await sleep(10)
+		expect(instrumentSaveStart).toHaveBeenCalled()
+		expect(instrumentSaveEnd).not.toHaveBeenCalled()
+		const p3 = save("3")
+		const p4 = save("4")
+		expect(instrumentAquireLockStart).toHaveBeenCalledTimes(2)
+		expect(locked).toBe(true)
+		await sleep(50)
+		expect(instrumentSaveEnd).toHaveBeenCalled()
+		expect(await p1).toBe("1")
+		expect(await p2).toBe("2")
+		expect(instrumentSaveStart).toHaveBeenCalledTimes(1)
+		expect(await p3).toBe("3")
+		expect(await p4).toBe("4")
+		expect(instrumentAquireLockStart).toHaveBeenCalledTimes(2)
+		expect(instrumentSaveStart).toHaveBeenCalledTimes(2)
+	})
+})

package/src/persistence/batchedIO.ts

@@ -0,0 +1,64 @@
+import _debug from "debug"
+const debug = _debug("sdk:batchedIO")
+
+/**
+ * State machine to convert async save() into batched async save()
+ * states = idle -> acquiring -> saving -> idle
+ * idle = nothing queued, ready to acquire lock.
+ * aquiring = waiting to acquire a lock: requests go into the queue.
+ * saving = lock is acquired, save has begun: new requests go into the next batch.
+ * The next batch should not acquire the lock while current save is in progress.
+ * Queued requests are only resolved when the save completes.
+ */
+export function batchedIO(
+	acquireLock: () => Promise<number>,
+	releaseLock: (lock: number) => Promise<void>,
+	save: () => Promise<void>
+): (id: string) => Promise<string> {
+	// 3-state machine
+	let state: "idle" | "acquiring" | "saving" = "idle"
+
+	// Hold requests while acquiring, resolve after saving
+	// TODO: rejectQueued if save throws (maybe?)
+	// https://github.com/opral/inlang-message-sdk/issues/79
+	type Queued = {
+		id: string
+		resolve: (value: string) => void
+		reject: (reason: any) => void
+	}
+	const queue: Queued[] = []
+
+	// initialize nextBatch lazily, reset after saving
+	let nextBatch: ((id: string) => Promise<string>) | undefined = undefined
+
+	// batched save function
+	return async (id: string) => {
+		if (state === "idle") {
+			state = "acquiring"
+			const lock = await acquireLock()
+			state = "saving"
+			await save()
+			await releaseLock(lock)
+			resolveQueued()
+			nextBatch = undefined
+			state = "idle"
+			return id
+		} else if (state === "acquiring") {
+			return new Promise<string>((resolve, reject) => {
+				queue.push({ id, resolve, reject })
+			})
+		} else {
+			// state === "saving"
+			nextBatch = nextBatch ?? batchedIO(acquireLock, releaseLock, save)
+			return await nextBatch(id)
+		}
+	}
+
+	function resolveQueued() {
+		debug("batched", queue.length + 1)
+		for (const { id, resolve } of queue) {
+			resolve(id)
+		}
+		queue.length = 0
+	}
+}

package/src/persistence/filelock/acquireFileLock.ts

@@ -21,16 +21,19 @@ export async function acquireFileLock(
 	try {
 		debug(lockOrigin + " tries to acquire a lockfile Retry Nr.: " + tryCount)
 		await fs.mkdir(lockDirPath)
-		const stats = await fs.stat(lockDirPath)
+		// NOTE: fs.stat does not need to be atomic since mkdir would crash atomically - if we are here its save to consider the lock held by this process
+		const stats = await fs.stat(lockDirPath) 
 		debug(lockOrigin + " acquired a lockfile Retry Nr.: " + tryCount)
+
 		return stats.mtimeMs
 	} catch (error: any) {
 		if (error.code !== "EEXIST") {
-			// we only expect the error that the file exists already (locked by other process)
+		// NOTE in case we have an EEXIST - this is an expected error: the folder existed - another process already acquired the lock. Rethrow all other errors
 			throw error
 		}
 	}
 
+	// land here if the lockDirPath already exists => lock is held by other process
 	let currentLockTime: number
 
 	try {

package/src/persistence/filelock/releaseLock.ts

@@ -11,8 +11,9 @@ export async function releaseLock(
 	debug(lockOrigin + " releasing the lock ")
 	try {
 		const stats = await fs.stat(lockDirPath)
+		// I believe this check associates the lock with the aquirer
 		if (stats.mtimeMs === lockTime) {
-			// this can be corrupt as welll since the last getStat and the current a modification could have occured :-/
+		// NOTE: since we have to use a timeout for stale detection (uTimes is not exposed via mermoryfs) the check for the locktime is not sufficient and can fail in rare cases when another process accuires a lock that was identifiert as tale between call to fs.state and rmDir
 			await fs.rmdir(lockDirPath)
 		}
 	} catch (statError: any) {

package/src/persistence/store.test.ts

@@ -0,0 +1,102 @@
+import { test, expect } from "vitest"
+import { createNodeishMemoryFs } from "../test-utilities/index.js"
+import type { MessageBundle } from "../v2/types.js"
+import { createMessageBundle, createMessage, injectJSONNewlines, addSlots } from "../v2/helper.js"
+import { openStore, readJSON, writeJSON } from "./store.js"
+
+const locales = ["en", "de"]
+
+const mockMessages: MessageBundle[] = [
+	createMessageBundle({
+		id: "first_message",
+		messages: [
+			createMessage({
+				locale: "en",
+				text: "If this fails I will be sad",
+			}),
+		],
+	}),
+	createMessageBundle({
+		id: "second_message",
+		messages: [
+			createMessage({ locale: "en", text: "Let's see if this works" }),
+			createMessage({ locale: "de", text: "Mal sehen ob das funktioniert" }),
+		],
+	}),
+]
+
+test("roundtrip readJSON/writeJSON", async () => {
+	const nodeishFs = createNodeishMemoryFs()
+	const projectPath = "/test/project.inlang"
+	const filePath = projectPath + "/messages.json"
+	const persistedMessages = injectJSONNewlines(
+		JSON.stringify(mockMessages.map((bundle) => addSlots(bundle, locales)))
+	)
+
+	await nodeishFs.mkdir(projectPath, { recursive: true })
+	await nodeishFs.writeFile(filePath, persistedMessages)
+
+	const firstMessageLoad = await readJSON({
+		filePath,
+		nodeishFs: nodeishFs,
+	})
+
+	expect(firstMessageLoad).toStrictEqual(mockMessages)
+
+	await writeJSON({
+		filePath,
+		nodeishFs,
+		messages: firstMessageLoad,
+		locales,
+	})
+
+	const afterRoundtrip = await nodeishFs.readFile(filePath, { encoding: "utf-8" })
+
+	expect(afterRoundtrip).toStrictEqual(persistedMessages)
+
+	const messagesAfterRoundtrip = await readJSON({
+		filePath,
+		nodeishFs,
+	})
+
+	expect(messagesAfterRoundtrip).toStrictEqual(firstMessageLoad)
+})
+
+test("openStore does minimal CRUD on messageBundles", async () => {
+	const nodeishFs = createNodeishMemoryFs()
+	const projectPath = "/test/project.inlang"
+	const filePath = projectPath + "/messages.json"
+	const persistedMessages = JSON.stringify(mockMessages)
+
+	await nodeishFs.mkdir(projectPath, { recursive: true })
+	await nodeishFs.writeFile(filePath, persistedMessages)
+
+	const store = await openStore({ projectPath, nodeishFs, locales })
+
+	const messages = await store.messageBundles.getAll()
+	expect(messages).toStrictEqual(mockMessages)
+
+	const firstMessageBundle = await store.messageBundles.get({ id: "first_message" })
+	expect(firstMessageBundle).toStrictEqual(mockMessages[0])
+
+	const modifedMessageBundle = structuredClone(firstMessageBundle) as MessageBundle
+	const newMessage = createMessage({ locale: "de", text: "Wenn dies schiefläuft, bin ich sauer" })
+	modifedMessageBundle.messages.push(newMessage)
+	await store.messageBundles.set({ data: modifedMessageBundle })
+
+	const setMessageBundle = await store.messageBundles.get({ id: "first_message" })
+	expect(setMessageBundle).toStrictEqual(modifedMessageBundle)
+
+	// no need to sleep here
+	// with batchedIO, the set should await until the write is done
+	const messagesAfterRoundtrip = await readJSON({
+		filePath,
+		nodeishFs,
+	})
+	const expected = [setMessageBundle, ...mockMessages.slice(1)]
+	expect(messagesAfterRoundtrip).toStrictEqual(expected)
+
+	await store.messageBundles.delete({ id: "first_message" })
+	const messagesAfterDelete = await store.messageBundles.getAll()
+	expect(messagesAfterDelete).toStrictEqual(mockMessages.slice(1))
+})

package/src/persistence/store.ts

@@ -0,0 +1,119 @@
+import type { MessageBundle } from "../v2/types.js"
+import { addSlots, removeSlots, injectJSONNewlines } from "../v2/helper.js"
+import { getDirname, type NodeishFilesystem } from "@lix-js/fs"
+import { acquireFileLock } from "./filelock/acquireFileLock.js"
+import { releaseLock } from "./filelock/releaseLock.js"
+import { batchedIO } from "./batchedIO.js"
+import type { StoreApi } from "./storeApi.js"
+
+import _debug from "debug"
+const debug = _debug("sdk:store")
+
+export async function openStore(args: {
+	projectPath: string
+	nodeishFs: NodeishFilesystem
+	locales: string[]
+}): Promise<StoreApi> {
+	const nodeishFs = args.nodeishFs
+	const filePath = args.projectPath + "/messages.json"
+	const lockDirPath = args.projectPath + "/messagelock"
+
+	// the index holds the in-memory state
+	// TODO: reload when file changes on disk
+	// https://github.com/opral/inlang-message-sdk/issues/80
+	let index = await load()
+
+	const batchedSave = batchedIO(acquireSaveLock, releaseSaveLock, save)
+
+	return {
+		messageBundles: {
+			reload: async () => {
+				index.clear()
+				index = await load()
+			},
+			get: async (args: { id: string }) => {
+				return index.get(args.id)
+			},
+			set: async (args: { data: MessageBundle }) => {
+				index.set(args.data.id, args.data)
+				await batchedSave(args.data.id)
+			},
+			delete: async (args: { id: string }) => {
+				index.delete(args.id)
+				await batchedSave(args.id)
+			},
+			getAll: async () => {
+				return [...index.values()]
+			},
+		},
+	}
+
+	// load and save messages from file system atomically
+	// using a lock file to prevent partial reads and writes
+	async function load() {
+		const lockTime = await acquireFileLock(nodeishFs, lockDirPath, "load")
+		const messages = await readJSON({ filePath, nodeishFs: nodeishFs })
+		const index = new Map<string, MessageBundle>(messages.map((message) => [message.id, message]))
+		await releaseLock(nodeishFs, lockDirPath, "load", lockTime)
+		return index
+	}
+	async function acquireSaveLock() {
+		return await acquireFileLock(nodeishFs, lockDirPath, "save")
+	}
+	async function releaseSaveLock(lock: number) {
+		return await releaseLock(nodeishFs, lockDirPath, "save", lock)
+	}
+	async function save() {
+		await writeJSON({
+			filePath,
+			nodeishFs: nodeishFs,
+			messages: [...index.values()],
+			locales: args.locales,
+		})
+	}
+}
+
+export async function readJSON(args: { filePath: string; nodeishFs: NodeishFilesystem }) {
+	let result: MessageBundle[] = []
+
+	debug("loadAll", args.filePath)
+	try {
+		const file = await args.nodeishFs.readFile(args.filePath, { encoding: "utf-8" })
+		result = JSON.parse(file)
+	} catch (error) {
+		if ((error as any)?.code !== "ENOENT") {
+			debug("loadMessages", error)
+			throw error
+		}
+	}
+	return result.map(removeSlots)
+}
+
+export async function writeJSON(args: {
+	filePath: string
+	nodeishFs: NodeishFilesystem
+	messages: MessageBundle[]
+	locales: string[]
+}) {
+	debug("saveall", args.filePath)
+	try {
+		await createDirectoryIfNotExits(getDirname(args.filePath), args.nodeishFs)
+		const output = injectJSONNewlines(
+			JSON.stringify(args.messages.map((bundle) => addSlots(bundle, args.locales)))
+		)
+		await args.nodeishFs.writeFile(args.filePath, output)
+	} catch (error) {
+		debug("saveMessages", error)
+		throw error
+	}
+}
+
+async function createDirectoryIfNotExits(path: string, nodeishFs: NodeishFilesystem) {
+	try {
+		await nodeishFs.mkdir(path, { recursive: true })
+	} catch (error: any) {
+		if (error.code !== "EEXIST") {
+			throw error
+		}
+	}
+}

package/src/persistence/storeApi.ts

@@ -0,0 +1,19 @@
+import type * as V2 from "../v2/types.js"
+
+/**
+ * WIP async V2 store interface
+ * E.g. `await project.store.messageBundles.get({ id: "..." })`
+ **/
+export type StoreApi = {
+	messageBundles: Store<V2.MessageBundle>
+}
+
+export interface Store<T> {
+	// TODO: remove reload when fs.watch can trigger auto-invalidation
+	reload: () => Promise<void>
+
+	get: (args: { id: string }) => Promise<T | undefined>
+	set: (args: { data: T }) => Promise<void>
+	delete: (args: { id: string }) => Promise<void>
+	getAll: () => Promise<T[]>
+}

package/src/reactivity/solid.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect } from "vitest"
+import { sleep, delay } from "../test-utilities/sleep.js"
 import {
 	createRoot,
 	createSignal,
@@ -9,14 +10,6 @@ import {
 } from "./solid.js"
 import { ReactiveMap } from "./map.js"
 
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-function delay(v: unknown, ms: number) {
-	return new Promise((resolve) => setTimeout(() => resolve(v), ms))
-}
-
 describe("vitest", () => {
 	it("waits for the result of an async function", async () => {
 		const rval = await delay(42, 1)

package/src/resolve-modules/plugins/resolvePlugins.ts

@@ -1,10 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import type { ResolvePluginsFunction } from "./types.js"
 import { Plugin } from "@inlang/plugin"
-import {
-	loadMessages as sdkLoadMessages,
-	saveMessages as sdkSaveMessages,
-} from "../../persistence/plugin.js"
 import {
 	PluginReturnedInvalidCustomApiError,
 	PluginLoadMessagesFunctionAlreadyDefinedError,
@@ -121,15 +117,10 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 
 	// --- LOADMESSAGE / SAVEMESSAGE NOT DEFINED ---
 
-	if (experimentalPersistence) {
-		debug("Override load/save for experimental persistence")
-		// @ts-ignore - type mismatch error
-		result.data.loadMessages = sdkLoadMessages
-		// @ts-ignore - type mismatch error
-		result.data.saveMessages = sdkSaveMessages
-	} else if (
-		typeof result.data.loadMessages !== "function" ||
-		typeof result.data.saveMessages !== "function"
+	if (
+		!experimentalPersistence &&
+		(typeof result.data.loadMessages !== "function" ||
+			typeof result.data.saveMessages !== "function")
 	) {
 		result.errors.push(new PluginsDoNotProvideLoadOrSaveMessagesError())
 	}

package/src/test-utilities/sleep.ts

@@ -0,0 +1,11 @@
+export function sleep(ms: number) {
+	return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export function delay(v: unknown, ms: number) {
+	return new Promise((resolve) => setTimeout(() => resolve(v), ms))
+}
+
+export function fail(ms: number) {
+	return new Promise((resolve, reject) => setTimeout(() => reject(new Error("fail")), ms))
+}

package/src/v2/{createMessageBundle.test.ts → helper.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest"
-import { createMessageBundle, createMessage } from "./createMessageBundle.js"
+import { createMessageBundle, createMessage } from "./helper.js"
 import { MessageBundle } from "./types.js"
 import { Value } from "@sinclair/typebox/value"