@inlang/sdk 0.11.0 → 0.13.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

@@ -0,0 +1,13 @@
+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.
+ *
+ * The paths are resolved from the `settingsFilePath` argument.
+ */
+export declare const createNodeishFsWithAbsolutePaths: (args: {
+    settingsFilePath: string;
+    nodeishFs: NodeishFilesystemSubset;
+}) => NodeishFilesystemSubset;
+//# sourceMappingURL=createNodeishFsWithAbsolutePaths.d.ts.map

package/dist/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -0,0 +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"}

package/dist/createNodeishFsWithAbsolutePaths.js

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

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

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

package/dist/createNodeishFsWithAbsolutePaths.test.js

@@ -0,0 +1,37 @@
+import { it, expect, vi } from "vitest";
+import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
+it("throws an error if settingsFilePath is not an absolute path", () => {
+    const relativePath = "relative/path";
+    expect(() => createNodeishFsWithAbsolutePaths({ settingsFilePath: relativePath, nodeishFs: {} })).toThrow();
+});
+it("intercepts paths correctly for readFile", async () => {
+    const settingsFilePath = `/Users/samuel/Documents/paraglide/example/project.inlang.json`;
+    const filePaths = [
+        ["file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+        ["./file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+        ["./folder/file.txt", `/Users/samuel/Documents/paraglide/example/folder/file.txt`],
+        ["../file.txt", `/Users/samuel/Documents/paraglide/file.txt`],
+        ["../folder/file.txt", `/Users/samuel/Documents/paraglide/folder/file.txt`],
+        ["../../file.txt", `/Users/samuel/Documents/file.txt`],
+        ["../../../file.txt", `/Users/samuel/file.txt`],
+    ];
+    const mockNodeishFs = {
+        readFile: vi.fn(),
+        readdir: vi.fn(),
+        mkdir: vi.fn(),
+        writeFile: vi.fn(),
+    };
+    const interceptedFs = createNodeishFsWithAbsolutePaths({
+        settingsFilePath,
+        nodeishFs: mockNodeishFs,
+    });
+    for (const [path, expectedPath] of filePaths) {
+        for (const fn of Object.keys(mockNodeishFs)) {
+            // @ts-expect-error
+            await interceptedFs[fn](path);
+            // @ts-expect-error
+            // expect the first argument to be the expectedPath
+            expect(mockNodeishFs[fn].mock.lastCall[0]).toBe(expectedPath);
+        }
+    }
+});

package/dist/errors.d.ts

@@ -1,4 +1,9 @@
 import type { ValueError } from "@sinclair/typebox/errors";
+export declare class LoadProjectInvalidArgument extends Error {
+    constructor(message: string, options: {
+        argument: string;
+    });
+}
 export declare class ProjectSettingsInvalidError extends Error {
     constructor(options: {
         errors: ValueError[];

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE;CAQ7C;AAED,qBAAa,kCAAmC,SAAQ,KAAK;gBAChD,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAOnE;AAED,qBAAa,gCAAiC,SAAQ,KAAK;gBAC9C,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAIpE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,qBAAa,0BAA2B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE;CAI1D;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE;CAQ7C;AAED,qBAAa,kCAAmC,SAAQ,KAAK;gBAChD,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAOnE;AAED,qBAAa,gCAAiC,SAAQ,KAAK;gBAC9C,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAIpE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD"}

package/dist/errors.js

@@ -1,3 +1,9 @@
+export class LoadProjectInvalidArgument extends Error {
+    constructor(message, options) {
+        super(`The argument "${options.argument}" of loadProject() is invalid: ${message}`);
+        this.name = "LoadProjectInvalidArgument";
+    }
+}
 export class ProjectSettingsInvalidError extends Error {
     constructor(options) {
         super(`The project settings are invalid:\n\n${options.errors

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;AAahF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAOjG;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CA4LxB,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;AAWjG;;;;;;;;;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,6 +1,6 @@
 import { resolveModules } from "./resolve-modules/index.js";
-import { TypeCompiler } from "@sinclair/typebox/compiler";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+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";
 import { debounce } from "throttle-debounce";
@@ -8,7 +8,8 @@ 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 } from "./resolve-modules/createNodeishFsWithAbsolutePaths.js";
+import { createNodeishFsWithAbsolutePaths, isAbsolutePath, } from "./createNodeishFsWithAbsolutePaths.js";
+import { normalizePath } from "@lix-js/fs";
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
 /**
  * Creates an inlang instance.
@@ -21,17 +22,25 @@ const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
  *
  */
 export const loadProject = async (args) => {
+    // -- validation --------------------------------------------------------
+    //! the only place where throwing is acceptable because the project
+    //! won't even be loaded. do not throw anywhere else. otherwise, apps
+    //! can't handle errors gracefully.
+    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();
-        // -- absolute path env -----------------------------------------------
         const nodeishFs = createNodeishFsWithAbsolutePaths({
+            settingsFilePath,
             nodeishFs: args.nodeishFs,
-            basePath: args.settingsFilePath.replace(/(.*?)[^/]*\..*$/, "$1"), // get directory of settings file
         });
         // -- 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
@@ -192,6 +201,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

@@ -1,9 +1,10 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect, vi } from "vitest";
 import { loadProject } from "./loadProject.js";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
+import { LoadProjectInvalidArgument, ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
 import { createNodeishMemoryFs } from "@lix-js/fs";
 import { createMessage } from "./test-utilities/createMessage.js";
+import { tryCatch } from "@inlang/result";
 // ------------------------------------------------------------------------------------------------
 const getValue = (subscribable) => {
     let value;
@@ -80,6 +81,16 @@ const _import = async (name) => ({
 });
 // ------------------------------------------------------------------------------------------------
 describe("initialization", () => {
+    it("should throw if settingsFilePath is not an absolute path", async () => {
+        const fs = createNodeishMemoryFs();
+        const result = await tryCatch(() => loadProject({
+            settingsFilePath: "relative/path",
+            nodeishFs: fs,
+            _import,
+        }));
+        expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
+        expect(result.data).toBeUndefined();
+    });
     describe("settings", () => {
         it("should return an error if settings file is not found", async () => {
             const fs = createNodeishMemoryFs();
@@ -225,6 +236,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 });
@@ -236,7 +264,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?
@@ -587,15 +615,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: () => [
@@ -611,7 +638,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.11.0",
+	"version": "0.13.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.test.ts

@@ -0,0 +1,47 @@
+import { it, expect, vi } from "vitest"
+import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
+import type { NodeishFilesystemSubset } from "./versionedInterfaces.js"
+
+it("throws an error if settingsFilePath is not an absolute path", () => {
+	const relativePath = "relative/path"
+
+	expect(() =>
+		createNodeishFsWithAbsolutePaths({ settingsFilePath: relativePath, nodeishFs: {} as any })
+	).toThrow()
+})
+
+it("intercepts paths correctly for readFile", async () => {
+	const settingsFilePath = `/Users/samuel/Documents/paraglide/example/project.inlang.json`
+
+	const filePaths = [
+		["file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+		["./file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+		["./folder/file.txt", `/Users/samuel/Documents/paraglide/example/folder/file.txt`],
+		["../file.txt", `/Users/samuel/Documents/paraglide/file.txt`],
+		["../folder/file.txt", `/Users/samuel/Documents/paraglide/folder/file.txt`],
+		["../../file.txt", `/Users/samuel/Documents/file.txt`],
+		["../../../file.txt", `/Users/samuel/file.txt`],
+	]
+
+	const mockNodeishFs = {
+		readFile: vi.fn(),
+		readdir: vi.fn(),
+		mkdir: vi.fn(),
+		writeFile: vi.fn(),
+	} satisfies Record<keyof NodeishFilesystemSubset, any>
+
+	const interceptedFs = createNodeishFsWithAbsolutePaths({
+		settingsFilePath,
+		nodeishFs: mockNodeishFs,
+	})
+
+	for (const [path, expectedPath] of filePaths) {
+		for (const fn of Object.keys(mockNodeishFs)) {
+			// @ts-expect-error
+			await interceptedFs[fn](path)
+			// @ts-expect-error
+			// expect the first argument to be the expectedPath
+			expect(mockNodeishFs[fn].mock.lastCall[0]).toBe(expectedPath)
+		}
+	}
+})

package/src/createNodeishFsWithAbsolutePaths.ts

@@ -0,0 +1,40 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin"
+import { normalizePath } from "@lix-js/fs"
+
+export const isAbsolutePath = (path: string) => /^[/\\]/.test(path)
+
+/**
+ * Wraps the nodeish filesystem subset with a function that intercepts paths
+ * and prepends the base path.
+ *
+ * The paths are resolved from the `settingsFilePath` argument.
+ */
+export const createNodeishFsWithAbsolutePaths = (args: {
+	settingsFilePath: string
+	nodeishFs: NodeishFilesystemSubset
+}): NodeishFilesystemSubset => {
+	if (!isAbsolutePath(args.settingsFilePath)) {
+		throw new Error("The argument `settingsFilePath` must be an absolute path.")
+	}
+
+	// get the base path of the settings file by
+	// removing the file name from the path
+	const basePath = args.settingsFilePath.split("/").slice(0, -1).join("/")
+
+	const makeAbsolute = (path: string) => {
+		if (isAbsolutePath(path)) {
+			return normalizePath(path)
+		}
+
+		return normalizePath(basePath + "/" + path)
+	}
+
+	return {
+		// @ts-expect-error
+		readFile: (path: string, options: { encoding: "utf-8" | "binary" }) =>
+			args.nodeishFs.readFile(makeAbsolute(path), options),
+		readdir: (path: string) => args.nodeishFs.readdir(makeAbsolute(path)),
+		mkdir: (path: string) => args.nodeishFs.mkdir(makeAbsolute(path)),
+		writeFile: (path: string, data: string) => args.nodeishFs.writeFile(makeAbsolute(path), data),
+	}
+}

package/src/errors.ts

@@ -1,5 +1,12 @@
 import type { ValueError } from "@sinclair/typebox/errors"
 
+export class LoadProjectInvalidArgument extends Error {
+	constructor(message: string, options: { argument: string }) {
+		super(`The argument "${options.argument}" of loadProject() is invalid: ${message}`)
+		this.name = "LoadProjectInvalidArgument"
+	}
+}
+
 export class ProjectSettingsInvalidError extends Error {
 	constructor(options: { errors: ValueError[] }) {
 		super(

package/src/loadProject.test.ts

@@ -5,12 +5,14 @@ import type { ProjectSettings, Plugin, MessageLintRule, Message } from "./versio
 import type { ImportFunction } from "./resolve-modules/index.js"
 import type { InlangModule } from "@inlang/module"
 import {
+	LoadProjectInvalidArgument,
 	ProjectSettingsFileJSONSyntaxError,
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
 } from "./errors.js"
 import { createNodeishMemoryFs } from "@lix-js/fs"
 import { createMessage } from "./test-utilities/createMessage.js"
+import { tryCatch } from "@inlang/result"
 
 // ------------------------------------------------------------------------------------------------
 
@@ -97,6 +99,20 @@ const _import: ImportFunction = async (name) =>
 // ------------------------------------------------------------------------------------------------
 
 describe("initialization", () => {
+	it("should throw if settingsFilePath is not an absolute path", async () => {
+		const fs = createNodeishMemoryFs()
+
+		const result = await tryCatch(() =>
+			loadProject({
+				settingsFilePath: "relative/path",
+				nodeishFs: fs,
+				_import,
+			})
+		)
+		expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument)
+		expect(result.data).toBeUndefined()
+	})
+
 	describe("settings", () => {
 		it("should return an error if settings file is not found", async () => {
 			const fs = createNodeishMemoryFs()
@@ -273,6 +289,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 })
@@ -286,7 +324,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()
 
@@ -685,18 +723,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: () => [
@@ -714,7 +751,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,13 +6,14 @@ 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,
 	ProjectSettingsInvalidError,
 	PluginLoadMessagesError,
 	PluginSaveMessagesError,
+	LoadProjectInvalidArgument,
 } from "./errors.js"
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js"
 import { createMessagesQuery } from "./createMessagesQuery.js"
@@ -21,7 +22,11 @@ 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 } from "./resolve-modules/createNodeishFsWithAbsolutePaths.js"
+import {
+	createNodeishFsWithAbsolutePaths,
+	isAbsolutePath,
+} from "./createNodeishFsWithAbsolutePaths.js"
+import { normalizePath } from "@lix-js/fs"
 
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
 
@@ -41,21 +46,32 @@ export const loadProject = async (args: {
 	_import?: ImportFunction
 	_capture?: (id: string, props: Record<string, unknown>) => void
 }): Promise<InlangProject> => {
-	return await createRoot(async () => {
-		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
+	// -- validation --------------------------------------------------------
+	//! the only place where throwing is acceptable because the project
+	//! won't even be loaded. do not throw anywhere else. otherwise, apps
+	//! can't handle errors gracefully.
+	if (!isAbsolutePath(args.settingsFilePath)) {
+		throw new LoadProjectInvalidArgument(
+			`Expected an absolute path but received "${args.settingsFilePath}".`,
+			{ argument: "settingsFilePath" }
+		)
+	}
 
-		// -- absolute path env -----------------------------------------------
+	const settingsFilePath = normalizePath(args.settingsFilePath)
 
+	// -- load project ------------------------------------------------------
+	return await createRoot(async () => {
+		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
 		const nodeishFs = createNodeishFsWithAbsolutePaths({
+			settingsFilePath,
 			nodeishFs: args.nodeishFs,
-			basePath: args.settingsFilePath.replace(/(.*?)[^/]*\..*$/, "$1"), // get directory of settings file
 		})
 
 		// -- 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
@@ -268,6 +284,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
 }
 
@@ -338,5 +372,3 @@ export function createSubscribable<T>(signal: () => T): Subscribable<T> {
 		},
 	})
 }
-
-

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
 	>
 }>

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.d.ts

@@ -1,6 +0,0 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin";
-export declare const createNodeishFsWithAbsolutePaths: (args: {
-    basePath: string;
-    nodeishFs: NodeishFilesystemSubset;
-}) => NodeishFilesystemSubset;
-//# sourceMappingURL=createNodeishFsWithAbsolutePaths.d.ts.map

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D,eAAO,MAAM,gCAAgC,SAAU;IACtD,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBAuBH,CAAA"}

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.js

@@ -1,20 +0,0 @@
-import { normalizePath } from "@lix-js/fs";
-export const createNodeishFsWithAbsolutePaths = (args) => {
-    const isAbsolutePath = (path) => /^[/\\]/.test(path);
-    if (!isAbsolutePath(args.basePath)) {
-        throw new Error("The argument `settingsFilePath` of `loadProject()` must be an absolute path.");
-    }
-    const intercept = (path) => {
-        if (isAbsolutePath(path)) {
-            return path;
-        }
-        return normalizePath(args.basePath + "/" + path);
-    };
-    return {
-        // @ts-expect-error
-        readFile: (path, options) => args.nodeishFs.readFile(intercept(path), options),
-        readdir: (path) => args.nodeishFs.readdir(intercept(path)),
-        mkdir: (path) => args.nodeishFs.mkdir(intercept(path)),
-        writeFile: (path, data) => args.nodeishFs.writeFile(intercept(path), data),
-    };
-};

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.test.d.ts.map

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

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.test.js

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
-describe("createNodeishFsWithAbsolutePaths", () => {
-    it("throws an error if basePath is not an absolute path", () => {
-        const invalidBasePath = "relative/path";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async () => Promise.resolve(new Uint8Array(0)),
-            readdir: async () => Promise.resolve([]),
-            mkdir: async () => Promise.resolve(""),
-            writeFile: async () => Promise.resolve(),
-        };
-        expect(() => createNodeishFsWithAbsolutePaths({ basePath: invalidBasePath, nodeishFs })).toThrowError("The argument `settingsFilePath` of `loadProject()` must be an absolute path.");
-    });
-    it("intercepts paths correctly for readFile", async () => {
-        const basePath = "/absolute/path";
-        const filePath = "file.txt";
-        const expectedPath = "/absolute/path/file.txt";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async (path) => {
-                expect(path).toBe(expectedPath);
-                return Promise.resolve(new Uint8Array(0));
-            },
-            readdir: async () => Promise.resolve([]),
-            mkdir: async () => Promise.resolve(""),
-            writeFile: async () => Promise.resolve(),
-        };
-        const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs });
-        await interceptedFs.readFile(filePath, { encoding: "utf-8" });
-    });
-    it("intercepts paths correctly for readdir", async () => {
-        const basePath = "/absolute/path";
-        const dirPath = "dir";
-        const expectedPath = "/absolute/path/dir";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async () => Promise.resolve(new Uint8Array(0)),
-            readdir: async (path) => {
-                expect(path).toBe(expectedPath);
-                return Promise.resolve([]);
-            },
-            mkdir: async () => Promise.resolve(""),
-            writeFile: async () => Promise.resolve(),
-        };
-        const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs });
-        await interceptedFs.readdir(dirPath);
-    });
-    it("intercepts paths correctly for mkdir", async () => {
-        const basePath = "/absolute/path";
-        const dirPath = "newDir";
-        const expectedPath = "/absolute/path/newDir";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async () => Promise.resolve(new Uint8Array(0)),
-            readdir: async () => Promise.resolve([]),
-            mkdir: async (path) => {
-                expect(path).toBe(expectedPath);
-                return Promise.resolve("");
-            },
-            writeFile: async () => Promise.resolve(),
-        };
-        const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs });
-        await interceptedFs.mkdir(dirPath);
-    });
-    it("intercepts paths correctly for writeFile", async () => {
-        const basePath = "/absolute/path";
-        const filePath = "file.txt";
-        const expectedPath = "/absolute/path/file.txt";
-        const data = "Hello, World!";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async () => Promise.resolve(new Uint8Array(0)),
-            readdir: async () => Promise.resolve([]),
-            mkdir: async () => Promise.resolve(""),
-            writeFile: async (path, content) => {
-                expect(path).toBe(expectedPath);
-                expect(content).toBe(data);
-                return Promise.resolve();
-            },
-        };
-        const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs });
-        await interceptedFs.writeFile(filePath, data);
-    });
-});

package/src/resolve-modules/createNodeishFsWithAbsolutePaths.test.ts

@@ -1,102 +0,0 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin"
-import { describe, it, expect } from "vitest"
-import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
-
-describe("createNodeishFsWithAbsolutePaths", () => {
-	it("throws an error if basePath is not an absolute path", () => {
-		const invalidBasePath = "relative/path"
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async () => Promise.resolve(new Uint8Array(0)),
-			readdir: async () => Promise.resolve([]),
-			mkdir: async () => Promise.resolve(""),
-			writeFile: async () => Promise.resolve(),
-		}
-
-		expect(() =>
-			createNodeishFsWithAbsolutePaths({ basePath: invalidBasePath, nodeishFs })
-		).toThrowError("The argument `settingsFilePath` of `loadProject()` must be an absolute path.")
-	})
-
-	it("intercepts paths correctly for readFile", async () => {
-		const basePath = "/absolute/path"
-		const filePath = "file.txt"
-		const expectedPath = "/absolute/path/file.txt"
-
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async (path) => {
-				expect(path).toBe(expectedPath)
-				return Promise.resolve(new Uint8Array(0))
-			},
-			readdir: async () => Promise.resolve([]),
-			mkdir: async () => Promise.resolve(""),
-			writeFile: async () => Promise.resolve(),
-		}
-
-		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
-		await interceptedFs.readFile(filePath, { encoding: "utf-8" })
-	})
-
-	it("intercepts paths correctly for readdir", async () => {
-		const basePath = "/absolute/path"
-		const dirPath = "dir"
-		const expectedPath = "/absolute/path/dir"
-
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async () => Promise.resolve(new Uint8Array(0)),
-			readdir: async (path) => {
-				expect(path).toBe(expectedPath)
-				return Promise.resolve([])
-			},
-			mkdir: async () => Promise.resolve(""),
-			writeFile: async () => Promise.resolve(),
-		}
-
-		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
-		await interceptedFs.readdir(dirPath)
-	})
-
-	it("intercepts paths correctly for mkdir", async () => {
-		const basePath = "/absolute/path"
-		const dirPath = "newDir"
-		const expectedPath = "/absolute/path/newDir"
-
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async () => Promise.resolve(new Uint8Array(0)),
-			readdir: async () => Promise.resolve([]),
-			mkdir: async (path) => {
-				expect(path).toBe(expectedPath)
-				return Promise.resolve("")
-			},
-			writeFile: async () => Promise.resolve(),
-		}
-
-		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
-		await interceptedFs.mkdir(dirPath)
-	})
-
-	it("intercepts paths correctly for writeFile", async () => {
-		const basePath = "/absolute/path"
-		const filePath = "file.txt"
-		const expectedPath = "/absolute/path/file.txt"
-		const data = "Hello, World!"
-
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async () => Promise.resolve(new Uint8Array(0)),
-			readdir: async () => Promise.resolve([]),
-			mkdir: async () => Promise.resolve(""),
-			writeFile: async (path, content) => {
-				expect(path).toBe(expectedPath)
-				expect(content).toBe(data)
-				return Promise.resolve()
-			},
-		}
-
-		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
-		await interceptedFs.writeFile(filePath, data)
-	})
-})

package/src/resolve-modules/createNodeishFsWithAbsolutePaths.ts

@@ -1,30 +0,0 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin"
-import { normalizePath } from "@lix-js/fs"
-
-export const createNodeishFsWithAbsolutePaths = (args: {
-	basePath: string
-	nodeishFs: NodeishFilesystemSubset
-}): NodeishFilesystemSubset => {
-	const isAbsolutePath = (path: string) => /^[/\\]/.test(path)
-
-	if (!isAbsolutePath(args.basePath)) {
-		throw new Error("The argument `settingsFilePath` of `loadProject()` must be an absolute path.")
-	}
-
-	const intercept = (path: string) => {
-		if (isAbsolutePath(path)) {
-			return path
-		}
-
-		return normalizePath(args.basePath + "/" + path)
-	}
-
-	return {
-		// @ts-expect-error
-		readFile: (path: string, options: { encoding: "utf-8" | "binary" }) =>
-			args.nodeishFs.readFile(intercept(path), options),
-		readdir: (path: string) => args.nodeishFs.readdir(intercept(path)),
-		mkdir: (path: string) => args.nodeishFs.mkdir(intercept(path)),
-		writeFile: (path: string, data: string) => args.nodeishFs.writeFile(intercept(path), data),
-	}
-}