@inlang/sdk 0.12.0 → 0.14.0

package/dist/adapter/solidAdapter.test.js

@@ -88,7 +88,7 @@ describe("config", () => {
         const newConfig = { ...project.settings(), languageTags: ["en", "de"] };
         project.setSettings(newConfig);
         // TODO: how can we await `setConfig` correctly
-        await new Promise((resolve) => setTimeout(resolve, 0));
+        await new Promise((resolve) => setTimeout(resolve, 510));
         expect(counter).toBe(2); // 2 times because effect creation + set
         expect(project.settings()).toStrictEqual(newConfig);
     });
@@ -162,11 +162,11 @@ describe("messages", () => {
             counter += 1;
         });
         expect(Object.values(project.query.messages.getAll()).length).toBe(2);
-        project.setSettings({ ...project.settings(), languageTags: [] });
+        project.setSettings({ ...project.settings(), languageTags: ["en"] });
         // TODO: how can we await `setConfig` correctly
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(counter).toBe(2); // 2 times because effect creation + set
-        expect(Object.values(project.query.messages.getAll()).length).toBe(0);
+        await new Promise((resolve) => setTimeout(resolve, 510));
+        expect(counter).toBe(1); // 2 times because effect creation + set
+        expect(Object.values(project.query.messages.getAll()).length).toBe(2);
     });
     it("should react to changes in messages", async () => {
         const fs = createNodeishMemoryFs();

package/dist/createNodeishFsWithAbsolutePaths.d.ts

@@ -1,5 +1,4 @@
 import type { NodeishFilesystemSubset } from "@inlang/plugin";
-export declare const isAbsolutePath: (path: string) => boolean;
 /**
  * Wraps the nodeish filesystem subset with a function that intercepts paths
  * and prepends the base path.

package/dist/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D,eAAO,MAAM,cAAc,SAAU,MAAM,YAAwB,CAAA;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,SAAU;IACtD,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBAyBH,CAAA"}
+{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAI7D;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,SAAU;IACtD,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBAyBH,CAAA"}

package/dist/createNodeishFsWithAbsolutePaths.js

@@ -1,5 +1,5 @@
 import { normalizePath } from "@lix-js/fs";
-export const isAbsolutePath = (path) => /^[/\\]/.test(path);
+import { isAbsolutePath } from "./isAbsolutePath.js";
 /**
  * Wraps the nodeish filesystem subset with a function that intercepts paths
  * and prepends the base path.
@@ -8,16 +8,16 @@ export const isAbsolutePath = (path) => /^[/\\]/.test(path);
  */
 export const createNodeishFsWithAbsolutePaths = (args) => {
     if (!isAbsolutePath(args.settingsFilePath)) {
-        throw new Error("The argument `settingsFilePath` must be an absolute path.");
+        throw new Error(`Expected an absolute path but received "${args.settingsFilePath}".`);
     }
     // get the base path of the settings file by
     // removing the file name from the path
-    const bathPath = args.settingsFilePath.split("/").slice(0, -1).join("/");
+    const basePath = normalizePath(args.settingsFilePath).split("/").slice(0, -1).join("/");
     const makeAbsolute = (path) => {
         if (isAbsolutePath(path)) {
-            return path;
+            return normalizePath(path);
         }
-        return normalizePath(bathPath + "/" + path);
+        return normalizePath(basePath + "/" + path);
     };
     return {
         // @ts-expect-error

package/dist/isAbsolutePath.d.ts

@@ -0,0 +1,2 @@
+export declare const isAbsolutePath: (path: string) => boolean;
+//# sourceMappingURL=isAbsolutePath.d.ts.map

package/dist/isAbsolutePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAbsolutePath.d.ts","sourceRoot":"","sources":["../src/isAbsolutePath.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,SAAU,MAAM,YAI1C,CAAA"}

package/dist/isAbsolutePath.js

@@ -0,0 +1,4 @@
+export const isAbsolutePath = (path) => {
+    const matchPosixAndWindowsAbsolutePaths = /^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/;
+    return matchPosixAndWindowsAbsolutePaths.test(path);
+};

package/dist/isAbsolutePath.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isAbsolutePath.test.d.ts.map

package/dist/isAbsolutePath.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAbsolutePath.test.d.ts","sourceRoot":"","sources":["../src/isAbsolutePath.test.ts"],"names":[],"mappings":""}

package/dist/isAbsolutePath.test.js

@@ -0,0 +1,20 @@
+import { assert, describe, it } from "vitest";
+import { isAbsolutePath } from "./isAbsolutePath.js";
+describe("isAbsolutePath", () => {
+    it("should correctly identify Unix absolute paths", () => {
+        assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"));
+        assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"));
+        assert.isFalse(isAbsolutePath("relative/path/to/file.txt"));
+    });
+    it("should correctly identify Windows absolute paths", () => {
+        assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"));
+        assert.isTrue(isAbsolutePath("C:/Users/user/project/project.inlang.json"));
+        assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"));
+    });
+    it("should handle edge cases", () => {
+        assert.isFalse(isAbsolutePath("")); // Empty path should return false
+        assert.isFalse(isAbsolutePath("relative/path/../file.txt")); // Relative path with ".." should return false
+        assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"));
+        assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"));
+    });
+});

package/dist/loadProject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAchF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAUjG;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAkMxB,CAAA;AAqGD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}
+{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAchF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AASjG;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAuMxB,CAAA;AAuHD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -1,5 +1,5 @@
 import { resolveModules } from "./resolve-modules/index.js";
-import { TypeCompiler } from "@sinclair/typebox/compiler";
+import { TypeCompiler, ValueErrorType } from "@sinclair/typebox/compiler";
 import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, LoadProjectInvalidArgument, } from "./errors.js";
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js";
 import { createMessagesQuery } from "./createMessagesQuery.js";
@@ -8,7 +8,9 @@ import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.j
 import { ProjectSettings, Message } from "./versionedInterfaces.js";
 import { tryCatch } from "@inlang/result";
 import { migrateIfOutdated } from "@inlang/project-settings/migration";
-import { createNodeishFsWithAbsolutePaths, isAbsolutePath, } from "./createNodeishFsWithAbsolutePaths.js";
+import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
+import { normalizePath } from "@lix-js/fs";
+import { isAbsolutePath } from "./isAbsolutePath.js";
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
 /**
  * Creates an inlang instance.
@@ -28,14 +30,18 @@ export const loadProject = async (args) => {
     if (!isAbsolutePath(args.settingsFilePath)) {
         throw new LoadProjectInvalidArgument(`Expected an absolute path but received "${args.settingsFilePath}".`, { argument: "settingsFilePath" });
     }
+    const settingsFilePath = normalizePath(args.settingsFilePath);
     // -- load project ------------------------------------------------------
     return await createRoot(async () => {
         const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
-        const nodeishFs = createNodeishFsWithAbsolutePaths(args);
+        const nodeishFs = createNodeishFsWithAbsolutePaths({
+            settingsFilePath,
+            nodeishFs: args.nodeishFs,
+        });
         // -- settings ------------------------------------------------------------
         const [settings, _setSettings] = createSignal();
         createEffect(() => {
-            loadSettings({ settingsFilePath: args.settingsFilePath, nodeishFs })
+            loadSettings({ settingsFilePath, nodeishFs })
                 .then((settings) => {
                 setSettings(settings);
                 // rename settings to get a convenient access to the data in Posthog
@@ -196,6 +202,20 @@ const parseSettings = (settings) => {
             });
         }
     }
+    const { sourceLanguageTag, languageTags } = settings;
+    if (!languageTags.includes(sourceLanguageTag)) {
+        throw new ProjectSettingsInvalidError({
+            errors: [
+                {
+                    message: `The sourceLanguageTag "${sourceLanguageTag}" is not included in the languageTags "${languageTags.join('", "')}". Please add it to the languageTags.`,
+                    type: ValueErrorType.String,
+                    schema: ProjectSettings,
+                    value: sourceLanguageTag,
+                    path: "sourceLanguageTag",
+                },
+            ],
+        });
+    }
     return withMigration;
 };
 const _writeSettingsToDisk = async (args) => {

package/dist/loadProject.test.js

@@ -91,6 +91,18 @@ describe("initialization", () => {
         expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
         expect(result.data).toBeUndefined();
     });
+    it("should resolve from a windows path", async () => {
+        const fs = createNodeishMemoryFs();
+        fs.mkdir("C:\\Users\\user\\project", { recursive: true });
+        fs.writeFile("C:\\Users\\user\\project\\project.inlang.json", JSON.stringify(settings));
+        const result = await tryCatch(() => loadProject({
+            settingsFilePath: "C:\\Users\\user\\project\\project.inlang.json",
+            nodeishFs: fs,
+            _import,
+        }));
+        expect(result.error).toBeUndefined();
+        expect(result.data).toBeDefined();
+    });
     describe("settings", () => {
         it("should return an error if settings file is not found", async () => {
             const fs = createNodeishMemoryFs();
@@ -236,6 +248,23 @@ describe("functionality", () => {
             expect(result.data).toBeUndefined();
             expect(result.error).toBeInstanceOf(ProjectSettingsInvalidError);
         });
+        it("should throw an error if sourceLanguageTag is not in languageTags", async () => {
+            const fs = await createNodeishMemoryFs();
+            await fs.mkdir("/user/project", { recursive: true });
+            const settings = {
+                sourceLanguageTag: "en",
+                languageTags: ["de"],
+                modules: [],
+            };
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "/user/project/project.inlang.json",
+                nodeishFs: fs,
+                _import,
+            });
+            expect(project.errors()).toHaveLength(1);
+            expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsInvalidError);
+        });
         it("should write settings to disk", async () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project", { recursive: true });
@@ -247,7 +276,7 @@ describe("functionality", () => {
             });
             const before = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" });
             expect(before).toBeDefined();
-            const result = project.setSettings({ ...settings, languageTags: [] });
+            const result = project.setSettings({ ...settings, languageTags: ["en"] });
             expect(result.data).toBeUndefined();
             expect(result.error).toBeUndefined();
             // TODO: how to wait for fs.writeFile to finish?
@@ -598,15 +627,14 @@ describe("functionality", () => {
                 sourceLanguageTag: "en",
                 languageTags: ["en", "de"],
                 modules: ["plugin.js"],
-                "plugin.project.json": {
+                "plugin.placeholder.name": {
                     pathPattern: "./resources/{languageTag}.json",
                 },
             };
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
-                id: "plugin.project.json",
+                id: "plugin.placeholder.name",
                 description: "Mock plugin description",
                 displayName: "Mock Plugin",
                 loadMessages: () => [
@@ -622,7 +650,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                settingsFilePath: "/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });

package/dist/resolve-modules/plugins/errors.d.ts

@@ -5,11 +5,6 @@ export declare class PluginHasInvalidIdError extends Error {
         id: Plugin["id"];
     });
 }
-export declare class PluginUsesReservedNamespaceError extends Error {
-    constructor(options: {
-        id: Plugin["id"];
-    });
-}
 export declare class PluginHasInvalidSchemaError extends Error {
     constructor(options: {
         id: Plugin["id"];

package/dist/resolve-modules/plugins/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;KAAE;CAMzC;AAED,qBAAa,gCAAiC,SAAQ,KAAK;gBAC9C,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;KAAE;CAIzC;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QAAC,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE;CAQ/D;AAED,qBAAa,6CAA8C,SAAQ,KAAK;gBAC3D,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;KAAE;CAMzC;AAED,qBAAa,6CAA8C,SAAQ,KAAK;gBAC3D,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;KAAE;CAMzC;AAED,qBAAa,mCAAoC,SAAQ,KAAK;gBACjD,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QAAC,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIvE;AAED,qBAAa,0CAA2C,SAAQ,KAAK;;CAOpE"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;KAAE;CAMzC;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QAAC,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE;CAQ/D;AAED,qBAAa,6CAA8C,SAAQ,KAAK;gBAC3D,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;KAAE;CAMzC;AAED,qBAAa,6CAA8C,SAAQ,KAAK;gBAC3D,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;KAAE;CAMzC;AAED,qBAAa,mCAAoC,SAAQ,KAAK;gBACjD,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QAAC,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIvE;AAED,qBAAa,0CAA2C,SAAQ,KAAK;;CAOpE"}

package/dist/resolve-modules/plugins/errors.js

@@ -4,12 +4,6 @@ export class PluginHasInvalidIdError extends Error {
         this.name = "PluginHasInvalidIdError";
     }
 }
-export class PluginUsesReservedNamespaceError extends Error {
-    constructor(options) {
-        super(`Plugin ${options.id} uses reserved namespace 'inlang'.`);
-        this.name = "PluginUsesReservedNamespaceError";
-    }
-}
 export class PluginHasInvalidSchemaError extends Error {
     constructor(options) {
         super(`Plugin "${options.id}" has an invalid schema:\n\n${options.errors

package/dist/resolve-modules/plugins/resolvePlugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolvePlugins.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/resolvePlugins.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAuBxD,eAAO,MAAM,cAAc,EAAE,sBAqH5B,CAAA"}
+{"version":3,"file":"resolvePlugins.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/resolvePlugins.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAiBxD,eAAO,MAAM,cAAc,EAAE,sBA4G5B,CAAA"}

package/dist/resolve-modules/plugins/resolvePlugins.js

@@ -1,13 +1,8 @@
 import { Plugin } from "@inlang/plugin";
-import { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginsDoNotProvideLoadOrSaveMessagesError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, PluginUsesReservedNamespaceError, } from "./errors.js";
+import { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginsDoNotProvideLoadOrSaveMessagesError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, } from "./errors.js";
 import { deepmerge } from "deepmerge-ts";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
 import { tryCatch } from "@inlang/result";
-const whitelistedPlugins = [
-    "plugin.inlang.json",
-    "plugin.inlang.i18next",
-    "plugin.inlang.paraglideJs",
-];
 // @ts-ignore - type mismatch error
 const PluginCompiler = TypeCompiler.Compile(Plugin);
 export const resolvePlugins = async (args) => {
@@ -29,12 +24,6 @@ export const resolvePlugins = async (args) => {
         if (hasInvalidId) {
             result.errors.push(new PluginHasInvalidIdError({ id: plugin.id }));
         }
-        // -- USES RESERVED NAMESPACE --
-        if (plugin.id.includes("inlang") && !whitelistedPlugins.includes(plugin.id)) {
-            result.errors.push(new PluginUsesReservedNamespaceError({
-                id: plugin.id,
-            }));
-        }
         // -- USES INVALID SCHEMA --
         if (errors.length > 0) {
             result.errors.push(new PluginHasInvalidSchemaError({

package/dist/resolve-modules/plugins/resolvePlugins.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, expect, it } from "vitest";
 import { resolvePlugins } from "./resolvePlugins.js";
-import { PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginUsesReservedNamespaceError, PluginReturnedInvalidCustomApiError, PluginHasInvalidSchemaError, PluginsDoNotProvideLoadOrSaveMessagesError, } from "./errors.js";
+import { PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginReturnedInvalidCustomApiError, PluginHasInvalidSchemaError, PluginsDoNotProvideLoadOrSaveMessagesError, } from "./errors.js";
 it("should return an error if a plugin uses an invalid id", async () => {
     const mockPlugin = {
         // @ts-expect-error - invalid id
@@ -37,20 +37,6 @@ it("should return an error if a plugin uses APIs that are not available", async
     });
     expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidSchemaError);
 });
-it("should not initialize a plugin that uses the 'inlang' namespace except for inlang whitelisted plugins", async () => {
-    const mockPlugin = {
-        id: "plugin.inlang.notWhitelisted",
-        description: { en: "My plugin description" },
-        displayName: { en: "My plugin" },
-        loadMessages: () => undefined,
-    };
-    const resolved = await resolvePlugins({
-        plugins: [mockPlugin],
-        settings: {},
-        nodeishFs: {},
-    });
-    expect(resolved.errors[0]).toBeInstanceOf(PluginUsesReservedNamespaceError);
-});
 it("should expose the project settings including the plugin settings", async () => {
     const settings = {
         sourceLanguageTag: "en",

package/dist/resolve-modules/plugins/types.d.ts

@@ -1,5 +1,5 @@
 import type { NodeishFilesystem } from "@lix-js/fs";
-import type { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, PluginUsesReservedNamespaceError, PluginsDoNotProvideLoadOrSaveMessagesError } from "./errors.js";
+import type { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, PluginsDoNotProvideLoadOrSaveMessagesError } from "./errors.js";
 import type { Message } from "@inlang/message";
 import type { CustomApiInlangIdeExtension, Plugin } from "@inlang/plugin";
 import type { ProjectSettings } from "@inlang/project-settings";
@@ -18,7 +18,7 @@ export type ResolvePluginsFunction = (args: {
     nodeishFs: NodeishFilesystemSubset;
 }) => Promise<{
     data: ResolvedPluginApi;
-    errors: Array<PluginReturnedInvalidCustomApiError | PluginLoadMessagesFunctionAlreadyDefinedError | PluginSaveMessagesFunctionAlreadyDefinedError | PluginHasInvalidIdError | PluginHasInvalidSchemaError | PluginUsesReservedNamespaceError | PluginsDoNotProvideLoadOrSaveMessagesError>;
+    errors: Array<PluginReturnedInvalidCustomApiError | PluginLoadMessagesFunctionAlreadyDefinedError | PluginSaveMessagesFunctionAlreadyDefinedError | PluginHasInvalidIdError | PluginHasInvalidSchemaError | PluginsDoNotProvideLoadOrSaveMessagesError>;
 }>;
 /**
  * The API after resolving the plugins.

package/dist/resolve-modules/plugins/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,KAAK,EACX,mCAAmC,EACnC,6CAA6C,EAC7C,6CAA6C,EAC7C,uBAAuB,EACvB,2BAA2B,EAC3B,gCAAgC,EAChC,0CAA0C,EAC1C,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACzC,iBAAiB,EACjB,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAC9C,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE;IAC3C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAK,OAAO,CAAC;IACb,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,EAAE,KAAK,CACV,mCAAmC,GACnC,6CAA6C,GAC7C,6CAA6C,GAC7C,uBAAuB,GACvB,2BAA2B,GAC3B,gCAAgC,GAChC,0CAA0C,CAC5C,CAAA;CACD,CAAC,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,eAAe,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAA;IACrF,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,eAAe,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAChG;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,EAAE,MAAM,CAAC,OAAO,MAAM,IAAI,MAAM,EAAE,GAAG,WAAW,MAAM,IAAI,MAAM,EAAE,EAAE,OAAO,CAAC,GAAG;QACvF,yBAAyB,CAAC,EAAE,2BAA2B,CAAA;KACvD,CAAA;CACD,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,KAAK,EACX,mCAAmC,EACnC,6CAA6C,EAC7C,6CAA6C,EAC7C,uBAAuB,EACvB,2BAA2B,EAC3B,0CAA0C,EAC1C,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACzC,iBAAiB,EACjB,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAC9C,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE;IAC3C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAK,OAAO,CAAC;IACb,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,EAAE,KAAK,CACV,mCAAmC,GACnC,6CAA6C,GAC7C,6CAA6C,GAC7C,uBAAuB,GACvB,2BAA2B,GAC3B,0CAA0C,CAC5C,CAAA;CACD,CAAC,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,eAAe,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAA;IACrF,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,eAAe,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAChG;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,EAAE,MAAM,CAAC,OAAO,MAAM,IAAI,MAAM,EAAE,GAAG,WAAW,MAAM,IAAI,MAAM,EAAE,EAAE,OAAO,CAAC,GAAG;QACvF,yBAAyB,CAAC,EAAE,2BAA2B,CAAA;KACvD,CAAA;CACD,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@inlang/sdk",
 	"type": "module",
-	"version": "0.12.0",
+	"version": "0.14.0",
 	"license": "Apache-2.0",
 	"publishConfig": {
 		"access": "public"
@@ -38,7 +38,7 @@
 		"@inlang/project-settings": "*",
 		"@inlang/result": "*",
 		"@lix-js/fs": "*",
-		"@sinclair/typebox": "^0.31.0",
+		"@sinclair/typebox": "^0.31.17",
 		"deepmerge-ts": "^5.1.0",
 		"solid-js": "1.6.12",
 		"throttle-debounce": "5.0.0",

package/src/adapter/solidAdapter.test.ts

@@ -109,8 +109,10 @@ describe("config", () => {
 		const newConfig = { ...project.settings()!, languageTags: ["en", "de"] }
 
 		project.setSettings(newConfig)
+
 		// TODO: how can we await `setConfig` correctly
-		await new Promise((resolve) => setTimeout(resolve, 0))
+		await new Promise((resolve) => setTimeout(resolve, 510))
+
 		expect(counter).toBe(2) // 2 times because effect creation + set
 		expect(project.settings()).toStrictEqual(newConfig)
 	})
@@ -202,13 +204,13 @@ describe("messages", () => {
 
 		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
 
-		project.setSettings({ ...project.settings()!, languageTags: [] })
+		project.setSettings({ ...project.settings()!, languageTags: ["en"] })
 
 		// TODO: how can we await `setConfig` correctly
-		await new Promise((resolve) => setTimeout(resolve, 0))
+		await new Promise((resolve) => setTimeout(resolve, 510))
 
-		expect(counter).toBe(2) // 2 times because effect creation + set
-		expect(Object.values(project.query.messages.getAll()).length).toBe(0)
+		expect(counter).toBe(1) // 2 times because effect creation + set
+		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
 	})
 
 	it("should react to changes in messages", async () => {

package/src/createNodeishFsWithAbsolutePaths.ts

@@ -1,7 +1,6 @@
 import type { NodeishFilesystemSubset } from "@inlang/plugin"
 import { normalizePath } from "@lix-js/fs"
-
-export const isAbsolutePath = (path: string) => /^[/\\]/.test(path)
+import { isAbsolutePath } from "./isAbsolutePath.js"
 
 /**
  * Wraps the nodeish filesystem subset with a function that intercepts paths
@@ -14,19 +13,19 @@ export const createNodeishFsWithAbsolutePaths = (args: {
 	nodeishFs: NodeishFilesystemSubset
 }): NodeishFilesystemSubset => {
 	if (!isAbsolutePath(args.settingsFilePath)) {
-		throw new Error("The argument `settingsFilePath` must be an absolute path.")
+		throw new Error(`Expected an absolute path but received "${args.settingsFilePath}".`)
 	}
 
 	// get the base path of the settings file by
 	// removing the file name from the path
-	const bathPath = args.settingsFilePath.split("/").slice(0, -1).join("/")
+	const basePath = normalizePath(args.settingsFilePath).split("/").slice(0, -1).join("/")
 
 	const makeAbsolute = (path: string) => {
 		if (isAbsolutePath(path)) {
-			return path
+			return normalizePath(path)
 		}
 
-		return normalizePath(bathPath + "/" + path)
+		return normalizePath(basePath + "/" + path)
 	}
 
 	return {

package/src/isAbsolutePath.test.ts

@@ -0,0 +1,23 @@
+import { assert, describe, it } from "vitest"
+import { isAbsolutePath } from "./isAbsolutePath.js"
+
+describe("isAbsolutePath", () => {
+	it("should correctly identify Unix absolute paths", () => {
+		assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"))
+		assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"))
+		assert.isFalse(isAbsolutePath("relative/path/to/file.txt"))
+	})
+
+	it("should correctly identify Windows absolute paths", () => {
+		assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"))
+		assert.isTrue(isAbsolutePath("C:/Users/user/project/project.inlang.json"))
+		assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"))
+	})
+
+	it("should handle edge cases", () => {
+		assert.isFalse(isAbsolutePath("")) // Empty path should return false
+		assert.isFalse(isAbsolutePath("relative/path/../file.txt")) // Relative path with ".." should return false
+		assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"))
+		assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"))
+	})
+})

package/src/isAbsolutePath.ts

@@ -0,0 +1,5 @@
+export const isAbsolutePath = (path: string) => {
+	const matchPosixAndWindowsAbsolutePaths =
+		/^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/
+	return matchPosixAndWindowsAbsolutePaths.test(path)
+}

package/src/loadProject.test.ts

@@ -113,6 +113,23 @@ describe("initialization", () => {
 		expect(result.data).toBeUndefined()
 	})
 
+	it("should resolve from a windows path", async () => {
+		const fs = createNodeishMemoryFs()
+		fs.mkdir("C:\\Users\\user\\project", { recursive: true })
+		fs.writeFile("C:\\Users\\user\\project\\project.inlang.json", JSON.stringify(settings))
+
+		const result = await tryCatch(() =>
+			loadProject({
+				settingsFilePath: "C:\\Users\\user\\project\\project.inlang.json",
+				nodeishFs: fs,
+				_import,
+			})
+		)
+
+		expect(result.error).toBeUndefined()
+		expect(result.data).toBeDefined()
+	})
+
 	describe("settings", () => {
 		it("should return an error if settings file is not found", async () => {
 			const fs = createNodeishMemoryFs()
@@ -289,6 +306,28 @@ describe("functionality", () => {
 			expect(result.error).toBeInstanceOf(ProjectSettingsInvalidError)
 		})
 
+		it("should throw an error if sourceLanguageTag is not in languageTags", async () => {
+			const fs = await createNodeishMemoryFs()
+			await fs.mkdir("/user/project", { recursive: true })
+
+			const settings: ProjectSettings = {
+				sourceLanguageTag: "en",
+				languageTags: ["de"],
+				modules: [],
+			}
+
+			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+
+			const project = await loadProject({
+				settingsFilePath: "/user/project/project.inlang.json",
+				nodeishFs: fs,
+				_import,
+			})
+
+			expect(project.errors()).toHaveLength(1)
+			expect(project.errors()![0]).toBeInstanceOf(ProjectSettingsInvalidError)
+		})
+
 		it("should write settings to disk", async () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project", { recursive: true })
@@ -302,7 +341,7 @@ describe("functionality", () => {
 			const before = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" })
 			expect(before).toBeDefined()
 
-			const result = project.setSettings({ ...settings, languageTags: [] })
+			const result = project.setSettings({ ...settings, languageTags: ["en"] })
 			expect(result.data).toBeUndefined()
 			expect(result.error).toBeUndefined()
 
@@ -701,18 +740,17 @@ describe("functionality", () => {
 				sourceLanguageTag: "en",
 				languageTags: ["en", "de"],
 				modules: ["plugin.js"],
-				"plugin.project.json": {
+				"plugin.placeholder.name": {
 					pathPattern: "./resources/{languageTag}.json",
 				},
 			}
 
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.writeFile("./project.inlang.json", JSON.stringify(settings))
 
 			const mockSaveFn = vi.fn()
 
 			const _mockPlugin: Plugin = {
-				id: "plugin.project.json",
+				id: "plugin.placeholder.name",
 				description: "Mock plugin description",
 				displayName: "Mock Plugin",
 				loadMessages: () => [
@@ -730,7 +768,7 @@ describe("functionality", () => {
 			}
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				settingsFilePath: "/project.inlang.json",
 				nodeishFs: fs,
 				_import,
 			})

package/src/loadProject.ts

@@ -6,7 +6,7 @@ import type {
 	Subscribable,
 } from "./api.js"
 import { type ImportFunction, resolveModules } from "./resolve-modules/index.js"
-import { TypeCompiler } from "@sinclair/typebox/compiler"
+import { TypeCompiler, ValueErrorType } from "@sinclair/typebox/compiler"
 import {
 	ProjectSettingsFileJSONSyntaxError,
 	ProjectSettingsFileNotFoundError,
@@ -22,10 +22,9 @@ import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.j
 import { ProjectSettings, Message, type NodeishFilesystemSubset } from "./versionedInterfaces.js"
 import { tryCatch, type Result } from "@inlang/result"
 import { migrateIfOutdated } from "@inlang/project-settings/migration"
-import {
-	createNodeishFsWithAbsolutePaths,
-	isAbsolutePath,
-} from "./createNodeishFsWithAbsolutePaths.js"
+import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
+import { normalizePath } from "@lix-js/fs"
+import { isAbsolutePath } from "./isAbsolutePath.js"
 
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
 
@@ -56,16 +55,21 @@ export const loadProject = async (args: {
 		)
 	}
 
+	const settingsFilePath = normalizePath(args.settingsFilePath)
+
 	// -- load project ------------------------------------------------------
 	return await createRoot(async () => {
 		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
-		const nodeishFs = createNodeishFsWithAbsolutePaths(args)
+		const nodeishFs = createNodeishFsWithAbsolutePaths({
+			settingsFilePath,
+			nodeishFs: args.nodeishFs,
+		})
 
 		// -- settings ------------------------------------------------------------
 
 		const [settings, _setSettings] = createSignal<ProjectSettings>()
 		createEffect(() => {
-			loadSettings({ settingsFilePath: args.settingsFilePath, nodeishFs })
+			loadSettings({ settingsFilePath, nodeishFs })
 				.then((settings) => {
 					setSettings(settings)
 					// rename settings to get a convenient access to the data in Posthog
@@ -278,6 +282,24 @@ const parseSettings = (settings: unknown) => {
 			})
 		}
 	}
+
+	const { sourceLanguageTag, languageTags } = settings as ProjectSettings
+	if (!languageTags.includes(sourceLanguageTag)) {
+		throw new ProjectSettingsInvalidError({
+			errors: [
+				{
+					message: `The sourceLanguageTag "${sourceLanguageTag}" is not included in the languageTags "${languageTags.join(
+						'", "'
+					)}". Please add it to the languageTags.`,
+					type: ValueErrorType.String,
+					schema: ProjectSettings,
+					value: sourceLanguageTag,
+					path: "sourceLanguageTag",
+				},
+			],
+		})
+	}
+
 	return withMigration
 }
 

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

@@ -10,13 +10,6 @@ export class PluginHasInvalidIdError extends Error {
 	}
 }
 
-export class PluginUsesReservedNamespaceError extends Error {
-	constructor(options: { id: Plugin["id"] }) {
-		super(`Plugin ${options.id} uses reserved namespace 'inlang'.`)
-		this.name = "PluginUsesReservedNamespaceError"
-	}
-}
-
 export class PluginHasInvalidSchemaError extends Error {
 	constructor(options: { id: Plugin["id"]; errors: ValueError[] }) {
 		super(

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

@@ -5,7 +5,6 @@ import {
 	PluginLoadMessagesFunctionAlreadyDefinedError,
 	PluginSaveMessagesFunctionAlreadyDefinedError,
 	PluginHasInvalidIdError,
-	PluginUsesReservedNamespaceError,
 	PluginReturnedInvalidCustomApiError,
 	PluginHasInvalidSchemaError,
 	PluginsDoNotProvideLoadOrSaveMessagesError,
@@ -54,23 +53,6 @@ it("should return an error if a plugin uses APIs that are not available", async
 	expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidSchemaError)
 })
 
-it("should not initialize a plugin that uses the 'inlang' namespace except for inlang whitelisted plugins", async () => {
-	const mockPlugin: Plugin = {
-		id: "plugin.inlang.notWhitelisted",
-		description: { en: "My plugin description" },
-		displayName: { en: "My plugin" },
-		loadMessages: () => undefined as any,
-	}
-
-	const resolved = await resolvePlugins({
-		plugins: [mockPlugin],
-		settings: {} as any,
-		nodeishFs: {} as any,
-	})
-
-	expect(resolved.errors[0]).toBeInstanceOf(PluginUsesReservedNamespaceError)
-})
-
 it("should expose the project settings including the plugin settings", async () => {
 	const settings: ProjectSettings = {
 		sourceLanguageTag: "en",

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

@@ -8,17 +8,11 @@ import {
 	PluginsDoNotProvideLoadOrSaveMessagesError,
 	PluginHasInvalidIdError,
 	PluginHasInvalidSchemaError,
-	PluginUsesReservedNamespaceError,
 } from "./errors.js"
 import { deepmerge } from "deepmerge-ts"
 import { TypeCompiler } from "@sinclair/typebox/compiler"
 import { tryCatch } from "@inlang/result"
 
-const whitelistedPlugins = [
-	"plugin.inlang.json",
-	"plugin.inlang.i18next",
-	"plugin.inlang.paraglideJs",
-]
 // @ts-ignore - type mismatch error
 const PluginCompiler = TypeCompiler.Compile(Plugin)
 
@@ -45,15 +39,6 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 			result.errors.push(new PluginHasInvalidIdError({ id: plugin.id }))
 		}
 
-		// -- USES RESERVED NAMESPACE --
-		if (plugin.id.includes("inlang") && !whitelistedPlugins.includes(plugin.id)) {
-			result.errors.push(
-				new PluginUsesReservedNamespaceError({
-					id: plugin.id,
-				})
-			)
-		}
-
 		// -- USES INVALID SCHEMA --
 		if (errors.length > 0) {
 			result.errors.push(

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

@@ -5,7 +5,6 @@ import type {
 	PluginSaveMessagesFunctionAlreadyDefinedError,
 	PluginHasInvalidIdError,
 	PluginHasInvalidSchemaError,
-	PluginUsesReservedNamespaceError,
 	PluginsDoNotProvideLoadOrSaveMessagesError,
 } from "./errors.js"
 import type { Message } from "@inlang/message"
@@ -37,7 +36,6 @@ export type ResolvePluginsFunction = (args: {
 		| PluginSaveMessagesFunctionAlreadyDefinedError
 		| PluginHasInvalidIdError
 		| PluginHasInvalidSchemaError
-		| PluginUsesReservedNamespaceError
 		| PluginsDoNotProvideLoadOrSaveMessagesError
 	>
 }>