fix: enhance WIT validation and binding generation with source path support

- Updated `generateBindingsFromWasm` to accept an optional source path for improved context during binding generation.
- Modified `validateWitSyntaxDetailedFromWasm` to include source path for detailed validation.
- Introduced recursive file collection for WIT files in `wasmUtils.ts` to support local imports.
- Added tests for local import resolution and validation scenarios.
- Updated WIT interface definitions to reflect new parameters for validation and binding functions.
- Bumped dependencies in `Cargo.lock` and `Cargo.toml` for compatibility with new features.

Fixes Packages split across multiple files fail
Fixes #121

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

package-lock.json

@@ -75,30 +75,41 @@
     },
     "dependencies": {},
     "devDependencies": {
-        "@bytecodealliance/jco": "1.17.1",
+        "@bytecodealliance/jco": "1.17.5",
         "@eslint/css": "1.0.0",
         "@eslint/js": "10.0.1",
         "@types/node": "25.5.0",
         "@types/vscode": "1.99.0",
-        "@typescript-eslint/parser": "8.57.1",
-        "@vitest/coverage-v8": "4.1.0",
-        "@vitest/ui": "4.1.0",
+        "@typescript-eslint/parser": "8.57.2",
+        "@vitest/coverage-v8": "4.1.1",
+        "@vitest/ui": "4.1.1",
         "@vscode/vsce": "3.7.1",
         "esbuild": "0.27.4",
         "esbuild-node-externals": "1.20.1",
-        "eslint": "10.0.3",
+        "eslint": "10.1.0",
         "eslint-plugin-prettier": "5.5.5",
         "globals": "17.4.0",
         "npm-run-all": "4.1.5",
-        "ovsx": "0.10.9",
+        "ovsx": "0.10.10",
         "prettier": "3.8.1",
         "rimraf": "6.1.3",
-        "typescript": "5.9.3",
-        "typescript-eslint": "8.57.1",
-        "vitest": "4.1.0",
+        "typescript": "6.0.2",
+        "typescript-eslint": "8.57.2",
+        "vitest": "4.1.1",
         "vscode-tmgrammar-test": "0.1.3",
         "wit-bindgen-wasm": "file:wit-bindgen-wasm/pkg"
     },
+    "overrides": {
+        "typescript-eslint": {
+            "typescript": "$typescript"
+        },
+        "@typescript-eslint/eslint-plugin": {
+            "typescript": "$typescript"
+        },
+        "@typescript-eslint/parser": {
+            "typescript": "$typescript"
+        }
+    },
     "contributes": {
         "colors": [
             {

package.json

@@ -596,7 +596,12 @@ export function activate(context: vscode.ExtensionContext) {
 
                 const outputPath = outputUri[0].fsPath;
 
-                const bindingFiles = await generateBindingsFromWasm(witContent, language);
+                const bindingFiles = await generateBindingsFromWasm(
+                    witContent,
+                    language,
+                    undefined,
+                    diagDoc?.uri.fsPath ?? targetUri.fsPath
+                );
 
                 const fileEntries = Object.entries(bindingFiles);
                 const errorFile = fileEntries.find(([filename]) => filename === "error.txt");

src/extension.ts

@@ -34,7 +34,7 @@ export class WitSyntaxValidator {
     public async validate(path: string, content: string): Promise<ReturnType<typeof extractErrorInfo> | null> {
         try {
             // Use the enhanced WASM-based WIT validation with detailed error reporting
-            const validationResult = await validateWitSyntaxDetailedFromWasm(content);
+            const validationResult = await validateWitSyntaxDetailedFromWasm(content, path);
 
             if (validationResult.valid) {
                 return null;

src/validator.ts

@@ -1,10 +1,93 @@
+import { readdir, readFile } from "node:fs/promises";
+import type { Dirent } from "node:fs";
+import path from "node:path";
+
 /**
  * Cached reference to the witValidator interface from the WASM component module.
  * The jco-transpiled module self-initializes via top-level await,
  * so the module is ready to use once the dynamic import resolves.
  */
 let witValidatorApi: typeof import("wit-bindgen-wasm").witValidator | null = null;
 
+interface PreparedSourceContext {
+    sourcePath?: string;
+    sourceFilesJson?: string;
+}
+
+function normalizeSourcePath(sourcePath?: string): string | undefined {
+    const trimmedPath = sourcePath?.trim();
+    if (!trimmedPath) {
+        return undefined;
+    }
+
+    return path.resolve(trimmedPath);
+}
+
+function isErrnoException(error: unknown): error is NodeJS.ErrnoException {
+    return error instanceof Error && "code" in error;
+}
+
+async function readDirectoryEntries(directoryPath: string): Promise<Array<Dirent<string>>> {
+    try {
+        return await readdir(directoryPath, { encoding: "utf8", withFileTypes: true });
+    } catch (error: unknown) {
+        if (isErrnoException(error) && error.code === "ENOENT") {
+            return [];
+        }
+
+        throw error;
+    }
+}
+
+async function collectWitFilesRecursively(directoryPath: string, sourceFiles: Record<string, string>): Promise<void> {
+    for (const entry of await readDirectoryEntries(directoryPath)) {
+        const entryPath = path.join(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+            await collectWitFilesRecursively(entryPath, sourceFiles);
+            continue;
+        }
+
+        if (entry.isFile() && entry.name.toLowerCase().endsWith(".wit")) {
+            sourceFiles[entryPath] = await readFile(entryPath, "utf8");
+        }
+    }
+}
+
+async function collectWitContext(sourceDirectory: string): Promise<Record<string, string>> {
+    const sourceFiles: Record<string, string> = {};
+
+    for (const entry of await readDirectoryEntries(sourceDirectory)) {
+        const entryPath = path.join(sourceDirectory, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "deps") {
+                await collectWitFilesRecursively(entryPath, sourceFiles);
+            }
+            continue;
+        }
+
+        if (entry.isFile() && entry.name.toLowerCase().endsWith(".wit")) {
+            sourceFiles[entryPath] = await readFile(entryPath, "utf8");
+        }
+    }
+
+    return sourceFiles;
+}
+
+async function prepareSourceContext(content: string, sourcePath?: string): Promise<PreparedSourceContext> {
+    const normalizedSourcePath = normalizeSourcePath(sourcePath);
+    if (!normalizedSourcePath) {
+        return {};
+    }
+
+    const sourceFiles = await collectWitContext(path.dirname(normalizedSourcePath));
+    sourceFiles[normalizedSourcePath] = content;
+
+    return {
+        sourcePath: normalizedSourcePath,
+        sourceFilesJson: JSON.stringify(sourceFiles),
+    };
+}
+
 /**
  * Initialize the WASM module by dynamically importing it.
  * The jco-transpiled component handles WASM loading internally.
@@ -68,9 +151,10 @@ export async function isWitFileExtensionFromWasm(filename: string): Promise<bool
  * @param content - The WIT content to validate
  * @returns Promise that resolves to true if the syntax is valid
  */
-export async function validateWitSyntaxFromWasm(content: string): Promise<boolean> {
+export async function validateWitSyntaxFromWasm(content: string, sourcePath?: string): Promise<boolean> {
     const api = await getApi();
-    return api.validateWitSyntax(content);
+    const preparedSource = await prepareSourceContext(content, sourcePath);
+    return api.validateWitSyntax(content, preparedSource.sourcePath, preparedSource.sourceFilesJson);
 }
 
 /**
@@ -122,11 +206,19 @@ export async function extractInterfacesFromWasm(content: string): Promise<string
 export async function generateBindingsFromWasm(
     content: string,
     language: string,
-    worldName?: string
+    worldName?: string,
+    sourcePath?: string
 ): Promise<Record<string, string>> {
     const api = await getApi();
-    const jsonResult = api.generateBindings(content, language, worldName);
-    return JSON.parse(jsonResult);
+    const preparedSource = await prepareSourceContext(content, sourcePath);
+    const jsonResult = api.generateBindings(
+        content,
+        language,
+        worldName,
+        preparedSource.sourcePath,
+        preparedSource.sourceFilesJson
+    );
+    return JSON.parse(jsonResult) as Record<string, string>;
 }
 
 /**
@@ -143,8 +235,16 @@ export interface WitValidationResult {
  * @param content - The WIT content to validate
  * @returns Promise that resolves to detailed validation results
  */
-export async function validateWitSyntaxDetailedFromWasm(content: string): Promise<WitValidationResult> {
+export async function validateWitSyntaxDetailedFromWasm(
+    content: string,
+    sourcePath?: string
+): Promise<WitValidationResult> {
     const api = await getApi();
-    const resultJson = api.validateWitSyntaxDetailed(content);
-    return JSON.parse(resultJson);
+    const preparedSource = await prepareSourceContext(content, sourcePath);
+    const resultJson = api.validateWitSyntaxDetailed(
+        content,
+        preparedSource.sourcePath,
+        preparedSource.sourceFilesJson
+    );
+    return JSON.parse(resultJson) as WitValidationResult;
 }

src/wasmUtils.ts

@@ -28,7 +28,7 @@ describe("Bindings Generation for All Languages", () => {
 
     supportedLanguages.forEach(({ lang, extension, expectedContent, minLength }) => {
         it(`should generate actual code stubs for ${lang}`, () => {
-            const resultJson = witValidator.generateBindings(TEST_WIT, lang, undefined);
+            const resultJson = witValidator.generateBindings(TEST_WIT, lang, undefined, undefined, undefined);
             const result = JSON.parse(resultJson);
 
             // Verify files were generated
@@ -66,7 +66,7 @@ describe("Bindings Generation for All Languages", () => {
         });
 
         it(`should not generate only README files for ${lang}`, () => {
-            const resultJson = witValidator.generateBindings(TEST_WIT, lang, undefined);
+            const resultJson = witValidator.generateBindings(TEST_WIT, lang, undefined, undefined, undefined);
             const result = JSON.parse(resultJson);
 
             // Verify that not all files are README files
@@ -90,7 +90,7 @@ describe("Bindings Generation for All Languages", () => {
         const results: Record<string, Record<string, string>> = {};
 
         for (const { lang } of supportedLanguages) {
-            const resultJson = witValidator.generateBindings(TEST_WIT, lang, undefined);
+            const resultJson = witValidator.generateBindings(TEST_WIT, lang, undefined, undefined, undefined);
             results[lang] = JSON.parse(resultJson);
         }
 
@@ -149,7 +149,7 @@ world app {
 `;
 
         for (const { lang, extension } of supportedLanguages) {
-            const resultJson = witValidator.generateBindings(complexWit, lang, undefined);
+            const resultJson = witValidator.generateBindings(complexWit, lang, undefined, undefined, undefined);
             const result = JSON.parse(resultJson);
 
             expect(Object.keys(result).length).toBeGreaterThan(0);

tests/bindings-generation.test.ts

@@ -0,0 +1,11 @@
+package local:demo;
+
+world my-world {
+  import host;
+
+  export another-interface;
+}
+
+interface host {
+  // ...
+}

tests/grammar/issue-121/wit/a.wit

@@ -0,0 +1,3 @@
+interface another-interface {
+  // ...
+}

tests/grammar/issue-121/wit/b.wit

@@ -0,0 +1,82 @@
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { generateBindingsFromWasm, validateWitSyntaxDetailedFromWasm } from "../src/wasmUtils.js";
+
+describe("local import resolution", () => {
+    const tempDirectories: string[] = [];
+
+    afterEach(async () => {
+        await Promise.all(tempDirectories.map((directory) => rm(directory, { recursive: true, force: true })));
+        tempDirectories.length = 0;
+    });
+
+    async function createIssue121Fixture(): Promise<{ content: string; sourcePath: string }> {
+        const fixtureRoot = await mkdtemp(path.join(os.tmpdir(), "wit-idl-imports-"));
+        tempDirectories.push(fixtureRoot);
+
+        const witDirectory = path.join(fixtureRoot, "wit");
+        await mkdir(witDirectory, { recursive: true });
+
+        const sourcePath = path.join(witDirectory, "a.wit");
+        await writeFile(
+            sourcePath,
+            `package local:demo;
+
+world my-world {
+    import host;
+
+    export another-interface;
+}
+
+interface host {
+    ping: func();
+}
+`,
+            "utf8"
+        );
+        await writeFile(
+            path.join(witDirectory, "b.wit"),
+            `interface another-interface {
+    pong: func();
+}
+`,
+            "utf8"
+        );
+
+        return {
+            content: await readFile(sourcePath, "utf8"),
+            sourcePath,
+        };
+    }
+
+    it("validates WIT with sibling imports when given a source path", async () => {
+        const fixture = await createIssue121Fixture();
+
+        const result = await validateWitSyntaxDetailedFromWasm(fixture.content, fixture.sourcePath);
+
+        expect(result).toEqual({ valid: true });
+    });
+
+    it("uses unsaved editor content while still resolving sibling imports", async () => {
+        const fixture = await createIssue121Fixture();
+        const invalidContent = `${fixture.content}\nthis is not valid wit\n`;
+
+        const result = await validateWitSyntaxDetailedFromWasm(invalidContent, fixture.sourcePath);
+
+        expect(result.valid).toBe(false);
+        expect(result.error).toContain(fixture.sourcePath);
+    });
+
+    it("generates bindings from in-memory content while resolving sibling imports", async () => {
+        const fixture = await createIssue121Fixture();
+        const updatedContent = fixture.content.replace("world my-world", "world staged-world");
+
+        const files = await generateBindingsFromWasm(updatedContent, "rust", "staged-world", fixture.sourcePath);
+
+        expect(files["error.txt"]).toBeUndefined();
+        expect(Object.keys(files).some((filename) => filename.endsWith(".rs"))).toBe(true);
+    });
+});