@inlang/sdk 0.35.9 → 0.36.0

package/dist/createNewProject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNewProject.d.ts","sourceRoot":"","sources":["../src/createNewProject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAI1D;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,eAAe,EAAE,eAAe,CAAA;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhB"}
+{"version":3,"file":"createNewProject.d.ts","sourceRoot":"","sources":["../src/createNewProject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAI1D;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,eAAe,EAAE,eAAe,CAAA;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAehB"}

package/dist/createNewProject.js

@@ -11,7 +11,11 @@ export async function createNewProject(args) {
     if (await pathExists(args.projectPath, nodeishFs)) {
         throw new Error(`projectPath already exists, received "${args.projectPath}"`);
     }
-    await nodeishFs.mkdir(args.projectPath, { recursive: true });
     const settingsText = JSON.stringify(args.projectSettings ?? defaultProjectSettings, undefined, 2);
-    await nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText);
+    await nodeishFs.mkdir(args.projectPath, { recursive: true });
+    await Promise.all([
+        nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText),
+        nodeishFs.writeFile(`${args.projectPath}/.gitignore`, "cache"),
+        nodeishFs.mkdir(`${args.projectPath}/cache/modules`, { recursive: true }),
+    ]);
 }

package/dist/createNewProject.test.js

@@ -70,14 +70,14 @@ describe("createNewProject", () => {
         const projectPath = "/test/project.inlang";
         await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings });
         const project = await loadProject({ projectPath, repo });
-        expect(project.errors().length).toBe(0);
+        expect(project.errors()).toEqual([]);
     });
     it("should create messages inside the project directory", async () => {
         const repo = await mockRepo();
         const projectPath = "/test/project.inlang";
         await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings });
         const project = await loadProject({ projectPath, repo });
-        expect(project.errors().length).toBe(0);
+        expect(project.errors()).toEqual([]);
         const testMessage = createMessage("test", { en: "test message" });
         project.query.messages.create({ data: testMessage });
         const messages = project.query.messages.getAll();

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export { listProjects } from "./listProjects.js";
 export { solidAdapter, type InlangProjectWithSolidAdapter } from "./adapter/solidAdapter.js";
 export { createMessagesQuery } from "./createMessagesQuery.js";
 export { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+export { ModuleError, ModuleHasNoExportsError, ModuleImportError, ModuleExportIsInvalidError, ModuleSettingsAreInvalidError, } from "./resolve-modules/errors.js";
 export { randomHumanId } from "./storage/human-id/human-readable-id.js";
 export { normalizeMessage } from "./storage/helper.js";
 export * from "./messages/variant.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,YAAY,GACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,KAAK,6BAA6B,EAAE,MAAM,2BAA2B,CAAA;AAC5F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EACN,kCAAkC,EAClC,gCAAgC,EAChC,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,GACvB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAA;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACtD,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,YAAY,GACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,KAAK,6BAA6B,EAAE,MAAM,2BAA2B,CAAA;AAC5F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EACN,kCAAkC,EAClC,gCAAgC,EAChC,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,GACvB,MAAM,aAAa,CAAA;AACpB,OAAO,EACN,WAAW,EACX,uBAAuB,EACvB,iBAAiB,EACjB,0BAA0B,EAC1B,6BAA6B,GAC7B,MAAM,6BAA6B,CAAA;AAEpC,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAA;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACtD,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -11,6 +11,7 @@ export { listProjects } from "./listProjects.js";
 export { solidAdapter } from "./adapter/solidAdapter.js";
 export { createMessagesQuery } from "./createMessagesQuery.js";
 export { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+export { ModuleError, ModuleHasNoExportsError, ModuleImportError, ModuleExportIsInvalidError, ModuleSettingsAreInvalidError, } from "./resolve-modules/errors.js";
 export { randomHumanId } from "./storage/human-id/human-readable-id.js";
 export { normalizeMessage } from "./storage/helper.js";
 export * from "./messages/variant.js";

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,EAGZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAkBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAgBhD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAyQzB;AA+GD,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,EAGZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAsBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAchD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CA+QzB;AA+GD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -10,8 +10,10 @@ import { migrateIfOutdated } from "@inlang/project-settings/migration";
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
 import { normalizePath } from "@lix-js/fs";
 import { assertValidProjectPath } from "./validateProjectPath.js";
+// Migrations
 import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js";
 import { maybeCreateFirstProjectId } from "./migrations/maybeCreateFirstProjectId.js";
+import { maybeAddModuleCache } from "./migrations/maybeAddModuleCache.js";
 import { capture } from "./telemetry/capture.js";
 import { identifyProject } from "./telemetry/groupIdentify.js";
 import { stubMessagesQuery, stubMessageLintReportsQuery } from "./v2/stubQueryApi.js";
@@ -42,6 +44,7 @@ export async function loadProject(args) {
     // -- migratations ------------------------------------------------
     await maybeMigrateToDirectory({ nodeishFs, projectPath });
     await maybeCreateFirstProjectId({ projectPath, repo: args.repo });
+    await maybeAddModuleCache({ projectPath, repo: args.repo });
     // -- load project ------------------------------------------------------
     return await createRoot(async () => {
         // TODO remove tryCatch after https://github.com/opral/monorepo/issues/2013
@@ -103,7 +106,12 @@ export async function loadProject(args) {
             const _settings = settings();
             if (!_settings)
                 return;
-            resolveModules({ settings: _settings, nodeishFs, _import: args._import })
+            resolveModules({
+                settings: _settings,
+                nodeishFs,
+                _import: args._import,
+                projectPath,
+            })
                 .then((resolvedModules) => {
                 setResolvedModules(resolvedModules);
             })

package/dist/migrations/maybeAddModuleCache.d.ts

@@ -0,0 +1,6 @@
+import type { Repository } from "@lix-js/client";
+export declare function maybeAddModuleCache(args: {
+    projectPath: string;
+    repo?: Repository;
+}): Promise<void>;
+//# sourceMappingURL=maybeAddModuleCache.d.ts.map

package/dist/migrations/maybeAddModuleCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybeAddModuleCache.d.ts","sourceRoot":"","sources":["../../src/migrations/maybeAddModuleCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAKhD,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC/C,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,UAAU,CAAA;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BhB"}

package/dist/migrations/maybeAddModuleCache.js

@@ -0,0 +1,44 @@
+const EXPECTED_IGNORES = ["cache"];
+export async function maybeAddModuleCache(args) {
+    if (args.repo === undefined)
+        return;
+    const projectExists = await directoryExists(args.projectPath, args.repo.nodeishFs);
+    if (!projectExists)
+        return;
+    const gitignorePath = args.projectPath + "/.gitignore";
+    const moduleCache = args.projectPath + "/cache/modules/";
+    const gitignoreExists = await fileExists(gitignorePath, args.repo.nodeishFs);
+    const moduleCacheExists = await directoryExists(moduleCache, args.repo.nodeishFs);
+    if (gitignoreExists) {
+        // non-destructively add any missing ignores
+        const gitignore = await args.repo.nodeishFs.readFile(gitignorePath, { encoding: "utf-8" });
+        const missingIgnores = EXPECTED_IGNORES.filter((ignore) => !gitignore.includes(ignore));
+        if (missingIgnores.length > 0) {
+            await args.repo.nodeishFs.appendFile(gitignorePath, "\n" + missingIgnores.join("\n"));
+        }
+    }
+    else {
+        await args.repo.nodeishFs.writeFile(gitignorePath, EXPECTED_IGNORES.join("\n"));
+    }
+    if (!moduleCacheExists) {
+        await args.repo.nodeishFs.mkdir(moduleCache, { recursive: true });
+    }
+}
+async function fileExists(path, nodeishFs) {
+    try {
+        const stat = await nodeishFs.stat(path);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryExists(path, nodeishFs) {
+    try {
+        const stat = await nodeishFs.stat(path);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin";
+/**
+ * Implements a "Network-First" caching strategy.
+ */
+export declare function withCache(moduleLoader: (uri: string) => Promise<string>, projectPath: string, nodeishFs: Pick<NodeishFilesystemSubset, "readFile" | "writeFile">): (uri: string) => Promise<string>;
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAuC7D;;GAEG;AACH,wBAAgB,SAAS,CACxB,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,EAC9C,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,IAAI,CAAC,uBAAuB,EAAE,UAAU,GAAG,WAAW,CAAC,GAChE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAelC"}

package/dist/resolve-modules/cache.js

@@ -0,0 +1,40 @@
+import { tryCatch } from "@inlang/result";
+function escape(url) {
+    // collect the bytes of the UTF-8 representation
+    const bytes = new TextEncoder().encode(url);
+    // 64-bit FNV1a hash to make the file-names shorter
+    // https://en.wikipedia.org/wiki/FNV-1a
+    const hash = bytes.reduce((hash, byte) => BigInt.asUintN(64, (hash ^ BigInt(byte)) * 1099511628211n), 14695981039346656037n);
+    return hash.toString(36);
+}
+async function readModuleFromCache(moduleURI, projectPath, readFile) {
+    const moduleHash = escape(moduleURI);
+    const filePath = projectPath + `/cache/modules/${moduleHash}`;
+    return await tryCatch(async () => await readFile(filePath, { encoding: "utf-8" }));
+}
+async function writeModuleToCache(moduleURI, moduleContent, projectPath, writeFile) {
+    const moduleHash = escape(moduleURI);
+    const filePath = projectPath + `/cache/modules/${moduleHash}`;
+    await writeFile(filePath, moduleContent);
+}
+/**
+ * Implements a "Network-First" caching strategy.
+ */
+export function withCache(moduleLoader, projectPath, nodeishFs) {
+    return async (uri) => {
+        const cachePromise = readModuleFromCache(uri, projectPath, nodeishFs.readFile);
+        const networkResult = await tryCatch(async () => await moduleLoader(uri));
+        if (networkResult.error) {
+            const cacheResult = await cachePromise;
+            if (!cacheResult.error)
+                return cacheResult.data;
+            else
+                throw networkResult.error;
+        }
+        else {
+            const moduleAsText = networkResult.data;
+            await writeModuleToCache(uri, moduleAsText, projectPath, nodeishFs.writeFile);
+            return moduleAsText;
+        }
+    };
+}

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

@@ -15,15 +15,5 @@ export type ImportFunction = (uri: string) => Promise<any>;
  *   const $import = createImport({ readFile: fs.readFile, fetch });
  *   const module = await _import('./some-module.js');
  */
-export declare function createImport(args: {
-    /** the fs from which the file can be read */
-    readFile: NodeishFilesystemSubset["readFile"];
-}): (uri: string) => ReturnType<typeof $import>;
-declare function $import(uri: string, options: {
-    /**
-     * Required to import from a local path.
-     */
-    readFile: NodeishFilesystemSubset["readFile"];
-}): Promise<any>;
-export {};
+export declare function createImport(projectPath: string, nodeishFs: Pick<NodeishFilesystemSubset, "readFile" | "writeFile">): (uri: string) => Promise<any>;
 //# sourceMappingURL=import.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/import.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IAClC,6CAA6C;IAC7C,QAAQ,EAAE,uBAAuB,CAAC,UAAU,CAAC,CAAA;CAC7C,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,OAAO,CAAC,CAG9C;AAED,iBAAe,OAAO,CACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;IACR;;OAEG;IACH,QAAQ,EAAE,uBAAuB,CAAC,UAAU,CAAC,CAAA;CAC7C,GACC,OAAO,CAAC,GAAG,CAAC,CAyBd"}
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/import.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAK7D;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC3B,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,IAAI,CAAC,uBAAuB,EAAE,UAAU,GAAG,WAAW,CAAC,SAErD,MAAM,kBACnB"}

package/dist/resolve-modules/import.js

@@ -1,5 +1,7 @@
 import dedent from "dedent";
 import { ModuleImportError } from "./errors.js";
+import { withCache } from "./cache.js";
+import { tryCatch } from "@inlang/result";
 /**
  * Creates the import function.
  *
@@ -9,20 +11,13 @@ import { ModuleImportError } from "./errors.js";
  *   const $import = createImport({ readFile: fs.readFile, fetch });
  *   const module = await _import('./some-module.js');
  */
-export function createImport(args) {
-    // resembles a native import api
-    return (uri) => $import(uri, args);
+export function createImport(projectPath, nodeishFs) {
+    return (uri) => $import(uri, projectPath, nodeishFs);
 }
-async function $import(uri, options) {
-    let moduleAsText;
-    if (uri.startsWith("http")) {
-        moduleAsText = await (await fetch(uri)).text();
-    }
-    else {
-        moduleAsText = await options.readFile(uri, {
-            encoding: "utf-8",
-        });
-    }
+async function $import(uri, projectPath, nodeishFs) {
+    const moduleAsText = uri.startsWith("http")
+        ? await withCache(readModuleFromCDN, projectPath, nodeishFs)(uri)
+        : await readModulefromDisk(uri, nodeishFs.readFile);
     const moduleWithMimeType = "data:application/javascript," + encodeURIComponent(moduleAsText);
     try {
         return await import(/* @vite-ignore */ moduleWithMimeType);
@@ -30,11 +25,78 @@ async function $import(uri, options) {
     catch (error) {
         if (error instanceof SyntaxError && uri.includes("jsdelivr")) {
             error.message += dedent `\n\n
-Are you sure that the file exists on JSDelivr?
+				Are you sure that the file exists on JSDelivr?
 
-The error indicates that the imported file does not exist on JSDelivr. For non-existent files, JSDelivr returns a 404 text that JS cannot parse as a module and throws a SyntaxError.
-			`;
+				The error indicates that the imported file does not exist on JSDelivr. For non-existent files, JSDelivr returns a 404 text that JS cannot parse as a module and throws a SyntaxError.`;
         }
         throw new ModuleImportError({ module: uri, cause: error });
     }
 }
+/**
+ * Tries to read the module from disk
+ * @throws {ModuleImportError}
+ */
+async function readModulefromDisk(uri, readFile) {
+    try {
+        return await readFile(uri, { encoding: "utf-8" });
+    }
+    catch (error) {
+        throw new ModuleImportError({ module: uri, cause: error });
+    }
+}
+/**
+ * Reads a module from a CDN.
+ * Tries to read local cache first.
+ *
+ * @param uri A valid URL
+ * @throws {ModuleImportError}
+ */
+async function readModuleFromCDN(uri) {
+    if (!isValidUrl(uri))
+        throw new ModuleImportError({ module: uri, cause: new Error("Malformed URL") });
+    const result = await tryCatch(async () => await fetch(uri));
+    if (result.error) {
+        throw new ModuleImportError({
+            module: uri,
+            cause: result.error,
+        });
+    }
+    const response = result.data;
+    if (!response.ok) {
+        throw new ModuleImportError({
+            module: uri,
+            cause: new Error(`Failed to fetch module. HTTP status: ${response.status}, Message: ${response.statusText}`),
+        });
+    }
+    const JS_CONTENT_TYPES = [
+        "application/javascript",
+        "text/javascript",
+        "application/x-javascript",
+        "text/x-javascript",
+    ];
+    // if there is no content-type header, assume it's a JavaScript module & hope for the best
+    const contentType = response.headers.get("content-type")?.toLowerCase();
+    if (contentType && !JS_CONTENT_TYPES.some((knownType) => contentType.includes(knownType))) {
+        throw new ModuleImportError({
+            module: uri,
+            cause: new Error(`Server responded with ${contentType} insetad of a JavaScript module`),
+        });
+    }
+    return await response.text();
+}
+function isValidUrl(url) {
+    // This dance is necessary to both support a fallback in case URL.canParse
+    // is not present (like in vitest), and also appease typescript
+    const URLConstructor = URL;
+    if ("canParse" in URL) {
+        return URL.canParse(url);
+    }
+    try {
+        new URLConstructor(url);
+        return true;
+    }
+    catch (e) {
+        console.warn(`Invalid URL: ${url}`);
+        return false;
+    }
+}

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

@@ -4,6 +4,7 @@ import { describe, expect, it } from "vitest";
 import { createImport } from "./import.js";
 describe("$import", async () => {
     const fs = createNodeishMemoryFs();
+    await fs.mkdir("./project.inlang/cache/modules", { recursive: true });
     await fs.writeFile("./mock-module.js", `
 		export function hello() {
 			return "hello";
@@ -16,7 +17,8 @@ describe("$import", async () => {
 			return "world";
 		}
 		`);
-    const _import = createImport({
+    const _import = createImport("/project.inlang", {
+        writeFile: fs.writeFile,
         readFile: fs.readFile,
     });
     it("should import a module from a local path", async () => {

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

@@ -1 +1 @@
-{"version":3,"file":"resolveModules.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/resolveModules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAoBvD,eAAO,MAAM,cAAc,EAAE,qBAiG5B,CAAA"}
+{"version":3,"file":"resolveModules.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/resolveModules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAoBvD,eAAO,MAAM,cAAc,EAAE,qBA4F5B,CAAA"}

package/dist/resolve-modules/resolveModules.js

@@ -8,30 +8,27 @@ import { TypeCompiler } from "@sinclair/typebox/compiler";
 import { validatedModuleSettings } from "./validatedModuleSettings.js";
 const ModuleCompiler = TypeCompiler.Compile(InlangModule);
 export const resolveModules = async (args) => {
-    const _import = args._import ?? createImport({ readFile: args.nodeishFs.readFile });
-    const moduleErrors = [];
+    const _import = args._import ?? createImport(args.projectPath, args.nodeishFs);
     const allPlugins = [];
     const allMessageLintRules = [];
     const meta = [];
-    for (const module of args.settings.modules) {
-        /**
-         * -------------- BEGIN SETUP --------------
-         */
+    const moduleErrors = [];
+    async function resolveModule(module) {
         const importedModule = await tryCatch(() => _import(module));
-        // -- IMPORT MODULE --
+        // -- FAILED TO IMPORT --
         if (importedModule.error) {
             moduleErrors.push(new ModuleImportError({
                 module: module,
                 cause: importedModule.error,
             }));
-            continue;
+            return;
         }
         // -- MODULE DOES NOT EXPORT ANYTHING --
         if (importedModule.data?.default === undefined) {
             moduleErrors.push(new ModuleHasNoExportsError({
                 module: module,
             }));
-            continue;
+            return;
         }
         // -- CHECK IF MODULE IS SYNTACTIALLY VALID
         const isValidModule = ModuleCompiler.Check(importedModule.data);
@@ -41,7 +38,7 @@ export const resolveModules = async (args) => {
                 module: module,
                 errors,
             }));
-            continue;
+            return;
         }
         // -- VALIDATE MODULE SETTINGS
         const result = validatedModuleSettings({
@@ -50,7 +47,7 @@ export const resolveModules = async (args) => {
         });
         if (result !== "isValid") {
             moduleErrors.push(new ModuleSettingsAreInvalidError({ module: module, errors: result }));
-            continue;
+            return;
         }
         meta.push({
             module: module,
@@ -66,6 +63,7 @@ export const resolveModules = async (args) => {
             moduleErrors.push(new ModuleError(`Unimplemented module type ${importedModule.data.default.id}.The module has not been installed.`, { module: module }));
         }
     }
+    await Promise.all(args.settings.modules.map(resolveModule));
     const resolvedPlugins = await resolvePlugins({
         plugins: allPlugins,
         settings: args.settings,

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

@@ -9,6 +9,7 @@ it("should return an error if a plugin cannot be imported", async () => {
         modules: ["https://myplugin.com/index.js"],
     };
     const resolved = await resolveModules({
+        projectPath: "/project.inlang",
         settings,
         nodeishFs: {},
         _import: () => {
@@ -58,7 +59,12 @@ it("should resolve plugins and message lint rules successfully", async () => {
         }
     };
     // Call the function
-    const resolved = await resolveModules({ settings, _import, nodeishFs: {} });
+    const resolved = await resolveModules({
+        projectPath: "/project.inlang",
+        settings,
+        _import,
+        nodeishFs: {},
+    });
     // Assert results
     expect(resolved.errors).toHaveLength(0);
     // Check for the meta data of the plugin
@@ -81,7 +87,12 @@ it("should return an error if a module cannot be imported", async () => {
         });
     };
     // Call the function
-    const resolved = await resolveModules({ settings, _import, nodeishFs: {} });
+    const resolved = await resolveModules({
+        projectPath: "/project.inlang",
+        settings,
+        _import,
+        nodeishFs: {},
+    });
     // Assert results
     expect(resolved.errors[0]).toBeInstanceOf(ModuleImportError);
 });
@@ -93,7 +104,12 @@ it("should return an error if a module does not export anything", async () => {
     };
     const _import = async () => ({});
     // Call the function
-    const resolved = await resolveModules({ settings, _import, nodeishFs: {} });
+    const resolved = await resolveModules({
+        projectPath: "/project.inlang",
+        settings,
+        _import,
+        nodeishFs: {},
+    });
     // Assert results
     expect(resolved.errors[0]).toBeInstanceOf(ModuleHasNoExportsError);
 });
@@ -110,7 +126,12 @@ it("should return an error if a module exports an invalid plugin or lint rule",
             description: { en: "Mock plugin description" },
         },
     });
-    const resolved = await resolveModules({ settings, _import, nodeishFs: {} });
+    const resolved = await resolveModules({
+        projectPath: "/project.inlang",
+        settings,
+        _import,
+        nodeishFs: {},
+    });
     expect(resolved.errors[0]).toBeInstanceOf(ModuleExportIsInvalidError);
 });
 it("should handle other unhandled errors during plugin resolution", async () => {
@@ -124,7 +145,12 @@ it("should handle other unhandled errors during plugin resolution", async () =>
         throw new Error(errorMessage);
     };
     // Call the function
-    const resolved = await resolveModules({ settings, _import, nodeishFs: {} });
+    const resolved = await resolveModules({
+        projectPath: "/project.inlang",
+        settings,
+        _import,
+        nodeishFs: {},
+    });
     // Assert results
     expect(resolved.errors[0]).toBeInstanceOf(ModuleError);
 });
@@ -148,7 +174,12 @@ it("should return an error if a moduleSettings are invalid", async () => {
         },
     });
     // Call the function
-    const resolved = await resolveModules({ settings, _import, nodeishFs: {} });
+    const resolved = await resolveModules({
+        projectPath: "/project.inlang",
+        settings,
+        _import,
+        nodeishFs: {},
+    });
     // Assert results
     expect(resolved.errors[0]).toBeInstanceOf(ModuleSettingsAreInvalidError);
 });

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

@@ -11,6 +11,7 @@ import type { resolveMessageLintRules } from "./message-lint-rules/resolveMessag
  * Pass a custom `_import` function to override the default import function.
  */
 export type ResolveModuleFunction = (args: {
+    projectPath: string;
     settings: ProjectSettings;
     nodeishFs: NodeishFilesystemSubset;
     _import?: ImportFunction;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EACX,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAA;AAE9F;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE;IAC1C,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,uBAAuB,CAAA;IAClC,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,KAAK,OAAO,CAAC;IACb;;;;;;;;OAQG;IACH,IAAI,EAAE,KAAK,CAAC;QACX;;;;WAIG;QACH,MAAM,EAAE,MAAM,CAAA;QACd;;WAEG;QACH,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC,CAAA;KACxC,CAAC,CAAA;IACF;;OAEG;IACH,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB;;OAEG;IACH,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;IACxC;;OAEG;IACH,iBAAiB,EAAE,iBAAiB,CAAA;IACpC;;;;;;;;OAQG;IACH,MAAM,EAAE,KAAK,CACV,uBAAuB,GACvB,iBAAiB,GACjB,OAAO,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAC7D,OAAO,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CACvE,CAAA;CACD,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EACX,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iDAAiD,CAAA;AAE9F;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE;IAC1C,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,uBAAuB,CAAA;IAClC,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,KAAK,OAAO,CAAC;IACb;;;;;;;;OAQG;IACH,IAAI,EAAE,KAAK,CAAC;QACX;;;;WAIG;QACH,MAAM,EAAE,MAAM,CAAA;QACd;;WAEG;QACH,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC,CAAA;KACxC,CAAC,CAAA;IACF;;OAEG;IACH,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB;;OAEG;IACH,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;IACxC;;OAEG;IACH,iBAAiB,EAAE,iBAAiB,CAAA;IACpC;;;;;;;;OAQG;IACH,MAAM,EAAE,KAAK,CACV,uBAAuB,GACvB,iBAAiB,GACjB,OAAO,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAC7D,OAAO,CAAC,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CACvE,CAAA;CACD,CAAC,CAAA"}

package/dist/v2/mocks/plural/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../../src/v2/mocks/plural/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,eAAO,MAAM,YAAY,EAAE,aA2I1B,CAAA"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../../src/v2/mocks/plural/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,eAAO,MAAM,YAAY,EAAE,aAiK1B,CAAA"}

package/dist/v2/mocks/plural/bundle.js

@@ -18,6 +18,28 @@ export const pluralBundle = {
                         },
                     },
                 },
+                {
+                    type: "input",
+                    name: "count",
+                    value: {
+                        type: "expression",
+                        arg: {
+                            type: "variable",
+                            name: "count",
+                        },
+                    },
+                },
+                {
+                    type: "input",
+                    name: "projectCount",
+                    value: {
+                        type: "expression",
+                        arg: {
+                            type: "variable",
+                            name: "projectCount",
+                        },
+                    },
+                },
             ],
             selectors: [
                 {

package/dist/v2/mocks/plural/bundle.test.js

@@ -8,7 +8,7 @@ describe("mock plural messageBundle", () => {
         const messageBundle = pluralBundle;
         expect(Value.Check(MessageBundle, messageBundle)).toBe(true);
         expect(pluralBundle.messages.length).toBe(2);
-        expect(pluralBundle.messages[0].declarations.length).toBe(1);
+        expect(pluralBundle.messages[0].declarations.length).toBe(3);
         expect(pluralBundle.messages[0].selectors.length).toBe(1);
         expect(pluralBundle.messages[0].variants.length).toBe(3);
     });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.35.9",
+  "version": "0.36.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -35,10 +35,10 @@
     "solid-js": "1.6.12",
     "throttle-debounce": "^5.0.0",
     "@inlang/json-types": "1.1.0",
-    "@inlang/message": "2.1.0",
+    "@inlang/language-tag": "1.5.1",
     "@inlang/message-lint-rule": "1.4.7",
     "@inlang/plugin": "2.4.13",
-    "@inlang/language-tag": "1.5.1",
+    "@inlang/message": "2.1.0",
     "@inlang/module": "1.2.13",
     "@inlang/project-settings": "2.4.2",
     "@inlang/result": "1.1.0",

package/src/createNewProject.test.ts

@@ -80,7 +80,7 @@ describe("createNewProject", () => {
 		await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
 
 		const project = await loadProject({ projectPath, repo })
-		expect(project.errors().length).toBe(0)
+		expect(project.errors()).toEqual([])
 	})
 
 	it("should create messages inside the project directory", async () => {
@@ -88,7 +88,7 @@ describe("createNewProject", () => {
 		const projectPath = "/test/project.inlang"
 		await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
 		const project = await loadProject({ projectPath, repo })
-		expect(project.errors().length).toBe(0)
+		expect(project.errors()).toEqual([])
 
 		const testMessage = createMessage("test", { en: "test message" })
 		project.query.messages.create({ data: testMessage })

package/src/createNewProject.ts

@@ -18,9 +18,12 @@ export async function createNewProject(args: {
 	if (await pathExists(args.projectPath, nodeishFs)) {
 		throw new Error(`projectPath already exists, received "${args.projectPath}"`)
 	}
-	await nodeishFs.mkdir(args.projectPath, { recursive: true })
-
 	const settingsText = JSON.stringify(args.projectSettings ?? defaultProjectSettings, undefined, 2)
 
-	await nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText)
+	await nodeishFs.mkdir(args.projectPath, { recursive: true })
+	await Promise.all([
+		nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText),
+		nodeishFs.writeFile(`${args.projectPath}/.gitignore`, "cache"),
+		nodeishFs.mkdir(`${args.projectPath}/cache/modules`, { recursive: true }),
+	])
 }

package/src/index.ts

@@ -25,6 +25,13 @@ export {
 	PluginLoadMessagesError,
 	PluginSaveMessagesError,
 } from "./errors.js"
+export {
+	ModuleError,
+	ModuleHasNoExportsError,
+	ModuleImportError,
+	ModuleExportIsInvalidError,
+	ModuleSettingsAreInvalidError,
+} from "./resolve-modules/errors.js"
 
 export { randomHumanId } from "./storage/human-id/human-readable-id.js"
 export { normalizeMessage } from "./storage/helper.js"

package/src/loadProject.ts

@@ -23,12 +23,14 @@ import { migrateIfOutdated } from "@inlang/project-settings/migration"
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
 import { normalizePath } from "@lix-js/fs"
 import { assertValidProjectPath } from "./validateProjectPath.js"
+
+// Migrations
 import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js"
+import { maybeCreateFirstProjectId } from "./migrations/maybeCreateFirstProjectId.js"
+import { maybeAddModuleCache } from "./migrations/maybeAddModuleCache.js"
 
 import type { Repository } from "@lix-js/client"
 
-import { maybeCreateFirstProjectId } from "./migrations/maybeCreateFirstProjectId.js"
-
 import { capture } from "./telemetry/capture.js"
 import { identifyProject } from "./telemetry/groupIdentify.js"
 
@@ -74,6 +76,7 @@ export async function loadProject(args: {
 
 	await maybeMigrateToDirectory({ nodeishFs, projectPath })
 	await maybeCreateFirstProjectId({ projectPath, repo: args.repo })
+	await maybeAddModuleCache({ projectPath, repo: args.repo })
 
 	// -- load project ------------------------------------------------------
 
@@ -155,7 +158,12 @@ export async function loadProject(args: {
 			const _settings = settings()
 			if (!_settings) return
 
-			resolveModules({ settings: _settings, nodeishFs, _import: args._import })
+			resolveModules({
+				settings: _settings,
+				nodeishFs,
+				_import: args._import,
+				projectPath,
+			})
 				.then((resolvedModules) => {
 					setResolvedModules(resolvedModules)
 				})

package/src/migrations/maybeAddModuleCache.ts

@@ -0,0 +1,53 @@
+import type { Repository } from "@lix-js/client"
+import type { NodeishFilesystem } from "@lix-js/fs"
+
+const EXPECTED_IGNORES = ["cache"]
+
+export async function maybeAddModuleCache(args: {
+	projectPath: string
+	repo?: Repository
+}): Promise<void> {
+	if (args.repo === undefined) return
+
+	const projectExists = await directoryExists(args.projectPath, args.repo.nodeishFs)
+	if (!projectExists) return
+
+	const gitignorePath = args.projectPath + "/.gitignore"
+	const moduleCache = args.projectPath + "/cache/modules/"
+
+	const gitignoreExists = await fileExists(gitignorePath, args.repo.nodeishFs)
+	const moduleCacheExists = await directoryExists(moduleCache, args.repo.nodeishFs)
+
+	if (gitignoreExists) {
+		// non-destructively add any missing ignores
+		const gitignore = await args.repo.nodeishFs.readFile(gitignorePath, { encoding: "utf-8" })
+		const missingIgnores = EXPECTED_IGNORES.filter((ignore) => !gitignore.includes(ignore))
+		if (missingIgnores.length > 0) {
+			await args.repo.nodeishFs.appendFile(gitignorePath, "\n" + missingIgnores.join("\n"))
+		}
+	} else {
+		await args.repo.nodeishFs.writeFile(gitignorePath, EXPECTED_IGNORES.join("\n"))
+	}
+
+	if (!moduleCacheExists) {
+		await args.repo.nodeishFs.mkdir(moduleCache, { recursive: true })
+	}
+}
+
+async function fileExists(path: string, nodeishFs: NodeishFilesystem): Promise<boolean> {
+	try {
+		const stat = await nodeishFs.stat(path)
+		return stat.isFile()
+	} catch {
+		return false
+	}
+}
+
+async function directoryExists(path: string, nodeishFs: NodeishFilesystem): Promise<boolean> {
+	try {
+		const stat = await nodeishFs.stat(path)
+		return stat.isDirectory()
+	} catch {
+		return false
+	}
+}

package/src/resolve-modules/cache.ts

@@ -0,0 +1,62 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin"
+import { type Result, tryCatch } from "@inlang/result"
+
+function escape(url: string) {
+	// collect the bytes of the UTF-8 representation
+	const bytes = new TextEncoder().encode(url)
+
+	// 64-bit FNV1a hash to make the file-names shorter
+	// https://en.wikipedia.org/wiki/FNV-1a
+	const hash = bytes.reduce(
+		(hash, byte) => BigInt.asUintN(64, (hash ^ BigInt(byte)) * 1_099_511_628_211n),
+		14_695_981_039_346_656_037n
+	)
+
+	return hash.toString(36)
+}
+
+async function readModuleFromCache(
+	moduleURI: string,
+	projectPath: string,
+	readFile: NodeishFilesystemSubset["readFile"]
+): Promise<Result<string, Error>> {
+	const moduleHash = escape(moduleURI)
+	const filePath = projectPath + `/cache/modules/${moduleHash}`
+
+	return await tryCatch(async () => await readFile(filePath, { encoding: "utf-8" }))
+}
+
+async function writeModuleToCache(
+	moduleURI: string,
+	moduleContent: string,
+	projectPath: string,
+	writeFile: NodeishFilesystemSubset["writeFile"]
+): Promise<void> {
+	const moduleHash = escape(moduleURI)
+	const filePath = projectPath + `/cache/modules/${moduleHash}`
+	await writeFile(filePath, moduleContent)
+}
+
+/**
+ * Implements a "Network-First" caching strategy.
+ */
+export function withCache(
+	moduleLoader: (uri: string) => Promise<string>,
+	projectPath: string,
+	nodeishFs: Pick<NodeishFilesystemSubset, "readFile" | "writeFile">
+): (uri: string) => Promise<string> {
+	return async (uri: string) => {
+		const cachePromise = readModuleFromCache(uri, projectPath, nodeishFs.readFile)
+		const networkResult = await tryCatch(async () => await moduleLoader(uri))
+
+		if (networkResult.error) {
+			const cacheResult = await cachePromise
+			if (!cacheResult.error) return cacheResult.data
+			else throw networkResult.error
+		} else {
+			const moduleAsText = networkResult.data
+			await writeModuleToCache(uri, moduleAsText, projectPath, nodeishFs.writeFile)
+			return moduleAsText
+		}
+	}
+}

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

@@ -6,6 +6,9 @@ import { createImport } from "./import.js"
 
 describe("$import", async () => {
 	const fs = createNodeishMemoryFs()
+
+	await fs.mkdir("./project.inlang/cache/modules", { recursive: true })
+
 	await fs.writeFile(
 		"./mock-module.js",
 		`
@@ -26,7 +29,8 @@ describe("$import", async () => {
 		`
 	)
 
-	const _import = createImport({
+	const _import = createImport("/project.inlang", {
+		writeFile: fs.writeFile,
 		readFile: fs.readFile,
 	})
 

package/src/resolve-modules/import.ts

@@ -1,6 +1,8 @@
 import dedent from "dedent"
 import type { NodeishFilesystemSubset } from "@inlang/plugin"
 import { ModuleImportError } from "./errors.js"
+import { withCache } from "./cache.js"
+import { tryCatch } from "@inlang/result"
 
 /**
  * Importing ES modules either from a local path, or from a url.
@@ -19,32 +21,21 @@ export type ImportFunction = (uri: string) => Promise<any>
  *   const $import = createImport({ readFile: fs.readFile, fetch });
  *   const module = await _import('./some-module.js');
  */
-export function createImport(args: {
-	/** the fs from which the file can be read */
-	readFile: NodeishFilesystemSubset["readFile"]
-}): (uri: string) => ReturnType<typeof $import> {
-	// resembles a native import api
-	return (uri: string) => $import(uri, args)
+export function createImport(
+	projectPath: string,
+	nodeishFs: Pick<NodeishFilesystemSubset, "readFile" | "writeFile">
+) {
+	return (uri: string) => $import(uri, projectPath, nodeishFs)
 }
 
 async function $import(
 	uri: string,
-	options: {
-		/**
-		 * Required to import from a local path.
-		 */
-		readFile: NodeishFilesystemSubset["readFile"]
-	}
+	projectPath: string,
+	nodeishFs: Pick<NodeishFilesystemSubset, "readFile" | "writeFile">
 ): Promise<any> {
-	let moduleAsText: string
-
-	if (uri.startsWith("http")) {
-		moduleAsText = await (await fetch(uri)).text()
-	} else {
-		moduleAsText = await options.readFile(uri, {
-			encoding: "utf-8",
-		})
-	}
+	const moduleAsText = uri.startsWith("http")
+		? await withCache(readModuleFromCDN, projectPath, nodeishFs)(uri)
+		: await readModulefromDisk(uri, nodeishFs.readFile)
 
 	const moduleWithMimeType = "data:application/javascript," + encodeURIComponent(moduleAsText)
 
@@ -53,11 +44,90 @@ async function $import(
 	} catch (error) {
 		if (error instanceof SyntaxError && uri.includes("jsdelivr")) {
 			error.message += dedent`\n\n
-Are you sure that the file exists on JSDelivr?
+				Are you sure that the file exists on JSDelivr?
 
-The error indicates that the imported file does not exist on JSDelivr. For non-existent files, JSDelivr returns a 404 text that JS cannot parse as a module and throws a SyntaxError.
-			`
+				The error indicates that the imported file does not exist on JSDelivr. For non-existent files, JSDelivr returns a 404 text that JS cannot parse as a module and throws a SyntaxError.`
 		}
 		throw new ModuleImportError({ module: uri, cause: error as Error })
 	}
 }
+
+/**
+ * Tries to read the module from disk
+ * @throws {ModuleImportError}
+ */
+async function readModulefromDisk(
+	uri: string,
+	readFile: NodeishFilesystemSubset["readFile"]
+): Promise<string> {
+	try {
+		return await readFile(uri, { encoding: "utf-8" })
+	} catch (error) {
+		throw new ModuleImportError({ module: uri, cause: error as Error })
+	}
+}
+
+/**
+ * Reads a module from a CDN.
+ * Tries to read local cache first.
+ *
+ * @param uri A valid URL
+ * @throws {ModuleImportError}
+ */
+async function readModuleFromCDN(uri: string): Promise<string> {
+	if (!isValidUrl(uri))
+		throw new ModuleImportError({ module: uri, cause: new Error("Malformed URL") })
+
+	const result = await tryCatch(async () => await fetch(uri))
+	if (result.error) {
+		throw new ModuleImportError({
+			module: uri,
+			cause: result.error,
+		})
+	}
+
+	const response = result.data
+	if (!response.ok) {
+		throw new ModuleImportError({
+			module: uri,
+			cause: new Error(
+				`Failed to fetch module. HTTP status: ${response.status}, Message: ${response.statusText}`
+			),
+		})
+	}
+
+	const JS_CONTENT_TYPES = [
+		"application/javascript",
+		"text/javascript",
+		"application/x-javascript",
+		"text/x-javascript",
+	]
+
+	// if there is no content-type header, assume it's a JavaScript module & hope for the best
+	const contentType = response.headers.get("content-type")?.toLowerCase()
+	if (contentType && !JS_CONTENT_TYPES.some((knownType) => contentType.includes(knownType))) {
+		throw new ModuleImportError({
+			module: uri,
+			cause: new Error(`Server responded with ${contentType} insetad of a JavaScript module`),
+		})
+	}
+
+	return await response.text()
+}
+
+function isValidUrl(url: string) {
+	// This dance is necessary to both support a fallback in case URL.canParse
+	// is not present (like in vitest), and also appease typescript
+	const URLConstructor = URL
+	if ("canParse" in URL) {
+		return URL.canParse(url)
+	}
+
+	try {
+		new URLConstructor(url)
+		return true
+	} catch (e) {
+		console.warn(`Invalid URL: ${url}`)
+		return false
+	}
+}

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

@@ -22,6 +22,7 @@ it("should return an error if a plugin cannot be imported", async () => {
 	}
 
 	const resolved = await resolveModules({
+		projectPath: "/project.inlang",
 		settings,
 		nodeishFs: {} as any,
 		_import: () => {
@@ -78,7 +79,12 @@ it("should resolve plugins and message lint rules successfully", async () => {
 	}
 
 	// Call the function
-	const resolved = await resolveModules({ settings, _import, nodeishFs: {} as any })
+	const resolved = await resolveModules({
+		projectPath: "/project.inlang",
+		settings,
+		_import,
+		nodeishFs: {} as any,
+	})
 
 	// Assert results
 	expect(resolved.errors).toHaveLength(0)
@@ -105,7 +111,12 @@ it("should return an error if a module cannot be imported", async () => {
 	}
 
 	// Call the function
-	const resolved = await resolveModules({ settings, _import, nodeishFs: {} as any })
+	const resolved = await resolveModules({
+		projectPath: "/project.inlang",
+		settings,
+		_import,
+		nodeishFs: {} as any,
+	})
 
 	// Assert results
 	expect(resolved.errors[0]).toBeInstanceOf(ModuleImportError)
@@ -121,7 +132,12 @@ it("should return an error if a module does not export anything", async () => {
 	const _import = async () => ({})
 
 	// Call the function
-	const resolved = await resolveModules({ settings, _import, nodeishFs: {} as any })
+	const resolved = await resolveModules({
+		projectPath: "/project.inlang",
+		settings,
+		_import,
+		nodeishFs: {} as any,
+	})
 
 	// Assert results
 	expect(resolved.errors[0]).toBeInstanceOf(ModuleHasNoExportsError)
@@ -142,7 +158,12 @@ it("should return an error if a module exports an invalid plugin or lint rule",
 			},
 		} satisfies InlangModule)
 
-	const resolved = await resolveModules({ settings, _import, nodeishFs: {} as any })
+	const resolved = await resolveModules({
+		projectPath: "/project.inlang",
+		settings,
+		_import,
+		nodeishFs: {} as any,
+	})
 	expect(resolved.errors[0]).toBeInstanceOf(ModuleExportIsInvalidError)
 })
 
@@ -159,7 +180,12 @@ it("should handle other unhandled errors during plugin resolution", async () =>
 	}
 
 	// Call the function
-	const resolved = await resolveModules({ settings, _import, nodeishFs: {} as any })
+	const resolved = await resolveModules({
+		projectPath: "/project.inlang",
+		settings,
+		_import,
+		nodeishFs: {} as any,
+	})
 
 	// Assert results
 	expect(resolved.errors[0]).toBeInstanceOf(ModuleError)
@@ -186,7 +212,12 @@ it("should return an error if a moduleSettings are invalid", async () => {
 	})
 
 	// Call the function
-	const resolved = await resolveModules({ settings, _import, nodeishFs: {} as any })
+	const resolved = await resolveModules({
+		projectPath: "/project.inlang",
+		settings,
+		_import,
+		nodeishFs: {} as any,
+	})
 
 	// Assert results
 	expect(resolved.errors[0]).toBeInstanceOf(ModuleSettingsAreInvalidError)

package/src/resolve-modules/resolveModules.ts

@@ -9,32 +9,27 @@ import {
 } from "./errors.js"
 import { tryCatch } from "@inlang/result"
 import { resolveMessageLintRules } from "./message-lint-rules/resolveMessageLintRules.js"
-import type { Plugin } from "@inlang/plugin"
 import { createImport } from "./import.js"
-import type { MessageLintRule } from "@inlang/message-lint-rule"
 import { resolvePlugins } from "./plugins/resolvePlugins.js"
 import { TypeCompiler } from "@sinclair/typebox/compiler"
 import { validatedModuleSettings } from "./validatedModuleSettings.js"
+import type { Plugin } from "@inlang/plugin"
+import type { MessageLintRule } from "@inlang/message-lint-rule"
 
 const ModuleCompiler = TypeCompiler.Compile(InlangModule)
 
 export const resolveModules: ResolveModuleFunction = async (args) => {
-	const _import = args._import ?? createImport({ readFile: args.nodeishFs.readFile })
-	const moduleErrors: Array<ModuleError> = []
+	const _import = args._import ?? createImport(args.projectPath, args.nodeishFs)
 
 	const allPlugins: Array<Plugin> = []
 	const allMessageLintRules: Array<MessageLintRule> = []
-
 	const meta: Awaited<ReturnType<ResolveModuleFunction>>["meta"] = []
+	const moduleErrors: Array<ModuleError> = []
 
-	for (const module of args.settings.modules) {
-		/**
-		 * -------------- BEGIN SETUP --------------
-		 */
-
+	async function resolveModule(module: string) {
 		const importedModule = await tryCatch<InlangModule>(() => _import(module))
-		// -- IMPORT MODULE --
 
+		// -- FAILED TO IMPORT --
 		if (importedModule.error) {
 			moduleErrors.push(
 				new ModuleImportError({
@@ -42,22 +37,20 @@ export const resolveModules: ResolveModuleFunction = async (args) => {
 					cause: importedModule.error as Error,
 				})
 			)
-			continue
+			return
 		}
 
 		// -- MODULE DOES NOT EXPORT ANYTHING --
-
 		if (importedModule.data?.default === undefined) {
 			moduleErrors.push(
 				new ModuleHasNoExportsError({
 					module: module,
 				})
 			)
-			continue
+			return
 		}
 
 		// -- CHECK IF MODULE IS SYNTACTIALLY VALID
-
 		const isValidModule = ModuleCompiler.Check(importedModule.data)
 		if (isValidModule === false) {
 			const errors = [...ModuleCompiler.Errors(importedModule.data)]
@@ -68,7 +61,7 @@ export const resolveModules: ResolveModuleFunction = async (args) => {
 				})
 			)
 
-			continue
+			return
 		}
 
 		// -- VALIDATE MODULE SETTINGS
@@ -79,7 +72,7 @@ export const resolveModules: ResolveModuleFunction = async (args) => {
 		})
 		if (result !== "isValid") {
 			moduleErrors.push(new ModuleSettingsAreInvalidError({ module: module, errors: result }))
-			continue
+			return
 		}
 
 		meta.push({
@@ -100,6 +93,8 @@ export const resolveModules: ResolveModuleFunction = async (args) => {
 			)
 		}
 	}
+
+	await Promise.all(args.settings.modules.map(resolveModule))
 	const resolvedPlugins = await resolvePlugins({
 		plugins: allPlugins,
 		settings: args.settings,

package/src/resolve-modules/types.ts

@@ -16,6 +16,7 @@ import type { resolveMessageLintRules } from "./message-lint-rules/resolveMessag
  * Pass a custom `_import` function to override the default import function.
  */
 export type ResolveModuleFunction = (args: {
+	projectPath: string
 	settings: ProjectSettings
 	nodeishFs: NodeishFilesystemSubset
 	_import?: ImportFunction

package/src/v2/mocks/plural/bundle.test.ts

@@ -11,7 +11,7 @@ describe("mock plural messageBundle", () => {
 		expect(Value.Check(MessageBundle, messageBundle)).toBe(true)
 
 		expect(pluralBundle.messages.length).toBe(2)
-		expect(pluralBundle.messages[0]!.declarations.length).toBe(1)
+		expect(pluralBundle.messages[0]!.declarations.length).toBe(3)
 		expect(pluralBundle.messages[0]!.selectors.length).toBe(1)
 		expect(pluralBundle.messages[0]!.variants.length).toBe(3)
 	})

package/src/v2/mocks/plural/bundle.ts

@@ -20,6 +20,28 @@ export const pluralBundle: MessageBundle = {
 						},
 					},
 				},
+				{
+					type: "input",
+					name: "count",
+					value: {
+						type: "expression",
+						arg: {
+							type: "variable",
+							name: "count",
+						},
+					},
+				},
+				{
+					type: "input",
+					name: "projectCount",
+					value: {
+						type: "expression",
+						arg: {
+							type: "variable",
+							name: "projectCount",
+						},
+					},
+				},
 			],
 			selectors: [
 				{