wgsl-edit 0.0.22 → 0.0.24

package/README.md

@@ -38,7 +38,7 @@ Multiple `<script>` tags create a multi-file editor with tabs.
 <wgsl-edit id="editor" theme="auto">
   <script type="text/wesl">/* shader code */</script>
 </wgsl-edit>
-<wgsl-play source="editor"></wgsl-play>
+<wgsl-play from="editor"></wgsl-play>
 ```
 
 The play component reads sources from the editor and live-previews the shader.
@@ -49,10 +49,6 @@ The play component reads sources from the editor and live-previews the shader.
 const editor = document.querySelector("wgsl-edit");
 
 editor.source = shaderCode;           // set active file content
-editor.sources = {                    // set all files
-  "package::main": mainCode,
-  "package::utils": utilsCode,
-};
 editor.addFile("helpers.wesl", code); // add a file
 editor.activeFile = "helpers.wesl";   // switch tabs
 
@@ -82,9 +78,8 @@ editor.project = {                    // load a full project
 ### Properties
 
 - `source: string` - Get/set active file content
-- `sources: Record<string, string>` - Get/set all files (keyed by module path)
 - `conditions: Record<string, boolean>` - Get/set conditions for conditional compilation (`@if`/`@elif`/`@else`)
-- `project: WeslProject` - Set full project (sources, conditions, packageName, etc.)
+- `project: WeslProject` - Get/set full project (weslSrc, conditions, constants, packageName, libs)
 - `activeFile: string` - Get/set active file name
 - `fileNames: string[]` - List all file names
 - `theme`, `tabs`, `lint`, `lineNumbers`, `readonly`, `shaderRoot`, `fetchLibs` - Mirror attributes
@@ -98,13 +93,13 @@ editor.project = {                    // load a full project
 
 ### Events
 
-- `change` - `{ source, sources, activeFile, conditions }` on edit or conditions change
+- `change` - `WeslProject` detail on edit or conditions change
 - `file-change` - `{ action, file }` on add/remove/rename
 
 ## Using with wesl-plugin
 
 For full project support (libraries, conditional compilation, constants),
-use [wesl-plugin](https://github.com/wgsl-tooling-wg/wesl-js/tree/main/tools/packages/wesl-plugin)
+use [wesl-plugin](https://github.com/wgsl-tooling-wg/wesl-js/tree/main/packages/wesl-plugin)
 to assemble shaders at build time and pass them to the editor via `project`.
 
 ```typescript

package/dist/GpuValidator-BZSULsmE.js

@@ -0,0 +1,48 @@
+//#region src/GpuValidator.ts
+/** Lazy-loaded GPU device singleton for shader validation. */
+let device = null;
+let initPromise = null;
+let warned = false;
+/** Get or initialize the shared GPU device, returning null if WebGPU is unavailable. */
+async function getDevice() {
+	if (device) return device;
+	if (initPromise) return initPromise;
+	if (typeof navigator === "undefined" || !navigator.gpu) {
+		if (!warned) console.warn("wgsl-edit: WebGPU unavailable, GPU lint disabled");
+		warned = true;
+		return null;
+	}
+	initPromise = (async () => {
+		try {
+			const adapter = await navigator.gpu.requestAdapter();
+			if (!adapter) {
+				console.warn("wgsl-edit: no GPU adapter, GPU lint disabled");
+				return null;
+			}
+			const dev = await adapter.requestDevice();
+			dev.lost.then(() => {
+				device = null;
+				initPromise = null;
+			});
+			device = dev;
+			return dev;
+		} catch (e) {
+			console.warn("wgsl-edit: GPU device request failed", e);
+			return null;
+		}
+	})();
+	return initPromise;
+}
+/** Validate WGSL code via WebGPU createShaderModule + getCompilationInfo. */
+async function validateWgsl(code) {
+	const dev = await getDevice();
+	if (!dev) return [];
+	return (await dev.createShaderModule({ code }).getCompilationInfo()).messages.filter((m) => m.type !== "info").map((m) => ({
+		offset: m.offset,
+		length: m.length,
+		message: m.message,
+		severity: m.type
+	}));
+}
+//#endregion
+export { validateWgsl };

package/dist/GpuValidator-D88-VTq9.js

@@ -0,0 +1,48 @@
+//#region src/GpuValidator.ts
+/** Lazy-loaded GPU device singleton for shader validation. */
+let device = null;
+let initPromise = null;
+let warned = false;
+/** Get or initialize the shared GPU device, returning null if WebGPU is unavailable. */
+async function getDevice() {
+	if (device) return device;
+	if (initPromise) return initPromise;
+	if (typeof navigator === "undefined" || !navigator.gpu) {
+		if (!warned) console.warn("wgsl-edit: WebGPU unavailable, GPU lint disabled");
+		warned = true;
+		return null;
+	}
+	initPromise = (async () => {
+		try {
+			const adapter = await navigator.gpu.requestAdapter();
+			if (!adapter) {
+				console.warn("wgsl-edit: no GPU adapter, GPU lint disabled");
+				return null;
+			}
+			const dev = await adapter.requestDevice();
+			dev.lost.then(() => {
+				device = null;
+				initPromise = null;
+			});
+			device = dev;
+			return dev;
+		} catch (e) {
+			console.warn("wgsl-edit: GPU device request failed", e);
+			return null;
+		}
+	})();
+	return initPromise;
+}
+/** Validate WGSL code via WebGPU createShaderModule + getCompilationInfo. */
+async function validateWgsl(code) {
+	const dev = await getDevice();
+	if (!dev) return [];
+	return (await dev.createShaderModule({ code }).getCompilationInfo()).messages.filter((m) => m.type !== "info").map((m) => ({
+		offset: m.offset,
+		length: m.length,
+		message: m.message,
+		severity: m.type
+	}));
+}
+//#endregion
+export { validateWgsl };

package/dist/Language.d.ts

@@ -21,10 +21,14 @@ interface WeslLintConfig {
   fetchLibs?: (packageNames: string[]) => Promise<WeslBundle[]>;
   /** Package names to ignore when checking unbound externals (e.g. virtual modules). */
   ignorePackages?: () => string[];
+  /** GPU validation of linked WGSL. Called after WESL lint passes with no errors. */
+  gpuValidate?: () => Promise<Diagnostic[]>;
 }
 declare const weslLanguage: LRLanguage;
 declare function wesl(): LanguageSupport;
 /** Create a linter that validates WESL using the canonical parser. */
 declare function createWeslLinter(config: WeslLintConfig): _codemirror_state0.Extension;
+/** Lint once, fetch missing externals if needed, re-lint with new libs. @internal */
+declare function lintAndFetch(config: WeslLintConfig): Promise<Diagnostic[]>;
 //#endregion
-export { WeslLintConfig, createWeslLinter, wesl, weslLanguage };
+export { WeslLintConfig, createWeslLinter, lintAndFetch, wesl, weslLanguage };

package/dist/Language.js

@@ -2,7 +2,6 @@ import { LRLanguage, LanguageSupport } from "@codemirror/language";
 import { linter } from "@codemirror/lint";
 import { parser, weslHighlighting } from "lezer-wesl";
 import { BundleResolver, CompositeResolver, RecordResolver, WeslParseError, bindIdents } from "wesl";
-
 //#region src/Language.ts
 const weslLanguage = LRLanguage.define({
 	name: "wesl",
@@ -22,15 +21,33 @@ function wesl() {
 function createWeslLinter(config) {
 	return linter(async () => lintAndFetch(config), { delay: 300 });
 }
-/** Lint once, fetch missing externals if needed, re-lint with new libs. */
+/** Lint once, fetch missing externals if needed, re-lint with new libs. @internal */
 async function lintAndFetch(config) {
 	const libs = config.getLibs?.() ?? [];
 	const ignored = new Set(config.ignorePackages?.() ?? []);
-	const { diagnostics, externals } = lintPass(config, libs, ignored);
-	if (!config.fetchLibs || !externals.length) return diagnostics;
-	const newLibs = await config.fetchLibs(externals);
-	if (!newLibs.length) return diagnostics;
-	return lintPass(config, [...libs, ...newLibs], ignored).diagnostics;
+	let result = lintPass(config, libs, ignored);
+	let { diagnostics, externals, weslErrorCount } = result;
+	if (config.fetchLibs && externals.length) {
+		const newLibs = await config.fetchLibs(externals);
+		if (newLibs.length) {
+			result = lintPass(config, [...libs, ...newLibs], ignored);
+			({diagnostics, weslErrorCount} = result);
+		}
+	}
+	if (weslErrorCount === 0 && config.gpuValidate) try {
+		const gpuDiags = await config.gpuValidate();
+		diagnostics.push(...gpuDiags);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : "unknown error";
+		diagnostics.push({
+			from: 0,
+			to: 0,
+			severity: "warning",
+			message: `GPU validation skipped: ${msg}`,
+			source: "WebGPU"
+		});
+	}
+	return diagnostics;
 }
 /** Parse, bind, collect diagnostics and discover missing externals. */
 function lintPass(config, libs, ignored) {
@@ -38,82 +55,71 @@ function lintPass(config, libs, ignored) {
 	const rootModule = config.rootModule();
 	const diagnostics = [];
 	let externals = [];
+	let weslErrorCount = 0;
 	try {
 		const resolver = buildResolver(sources, libs, config.packageName?.());
 		const rootAst = resolver.resolveModule(rootModule);
 		if (rootAst) {
-			const result = runBind(config, resolver, rootAst);
-			diagnostics.push(...unboundDiagnostics(result, rootModule, ignored));
+			const result = bindIdents({
+				resolver,
+				rootAst,
+				conditions: config.conditions?.(),
+				accumulateUnbound: true
+			});
+			const unbound = unboundDiagnostics(result, rootModule, ignored);
+			diagnostics.push(...unbound);
+			weslErrorCount = unbound.length;
 			externals = findMissingPackages(rootAst, result, resolver, ignored, libs);
 		}
 	} catch (e) {
 		const diag = errorToDiagnostic(e);
-		if (diag) diagnostics.push(diag);
+		if (diag) {
+			diagnostics.push(diag);
+			weslErrorCount++;
+		}
 	}
 	diagnostics.push(...config.getExternalDiagnostics?.() ?? []);
 	return {
 		diagnostics,
-		externals
+		externals,
+		weslErrorCount
 	};
 }
-/** Build a resolver from sources and optional libs. */
 function buildResolver(sources, libs, packageName) {
 	const record = new RecordResolver(sources, { packageName });
 	if (libs.length === 0) return record;
 	return new CompositeResolver([record, ...libs.map((b) => new BundleResolver(b))]);
 }
-/** Parse and bind identifiers starting from a root module. */
-function runBind(config, resolver, rootAst) {
-	return bindIdents({
-		resolver,
-		rootAst,
-		conditions: config.conditions?.(),
-		accumulateUnbound: true
-	});
-}
 /** Convert unbound refs to diagnostics, skipping ignored packages. */
 function unboundDiagnostics(result, rootModule, ignored) {
-	const diagnostics = [];
-	for (const ref of result.unbound ?? []) {
-		if (ref.srcModule.modulePath !== rootModule) continue;
-		if (ref.path.length > 1 && ignored.has(ref.path[0])) continue;
-		diagnostics.push(unboundToDiagnostic(ref));
-	}
-	return diagnostics;
+	return (result.unbound ?? []).filter((ref) => ref.srcModule.modulePath === rootModule && !(ref.path.length > 1 && ignored.has(ref.path[0]))).map(unboundToDiagnostic);
 }
-/** Convert a WESL error to a CodeMirror diagnostic. */
 function errorToDiagnostic(e) {
-	if (e instanceof WeslParseError) {
-		const [from, to] = e.span;
-		return {
-			from,
-			to,
-			severity: "error",
-			message: e.cause?.message ?? e.message
-		};
-	}
+	if (!(e instanceof WeslParseError)) return void 0;
+	const [from, to] = e.span;
+	return {
+		from,
+		to,
+		severity: "error",
+		message: e.cause?.message ?? e.message
+	};
 }
 /** Find external package names not yet loaded, from unresolved imports and unbound refs. */
 function findMissingPackages(rootAst, result, resolver, ignored, libs) {
 	const loaded = new Set(libs.map((b) => b.name));
-	const pkgs = [];
-	for (const imp of rootAst.imports) {
+	const skip = (r) => !isExternalRoot(r) || ignored.has(r) || loaded.has(r);
+	const fromImports = rootAst.imports.filter((imp) => {
 		const root = imp.segments[0]?.name;
-		if (!root || !isExternalRoot(root) || ignored.has(root) || loaded.has(root)) continue;
+		if (!root || skip(root)) return false;
 		const modPath = imp.segments.map((s) => s.name).join("::");
-		if (!resolver.resolveModule(modPath)) pkgs.push(root);
-	}
-	for (const ref of result.unbound ?? []) {
-		const root = ref.path[0];
-		if (ref.path.length > 1 && isExternalRoot(root) && !ignored.has(root) && !loaded.has(root)) pkgs.push(root);
-	}
-	return [...new Set(pkgs)];
+		return !resolver.resolveModule(modPath);
+	}).map((imp) => imp.segments[0].name);
+	const fromUnbound = (result.unbound ?? []).filter((ref) => ref.path.length > 1 && !skip(ref.path[0])).map((ref) => ref.path[0]);
+	return [...new Set([...fromImports, ...fromUnbound])];
 }
-/** @return true if root is an external package name (not package/super). */
 function isExternalRoot(root) {
 	return root !== "package" && root !== "super";
 }
-/** Convert an unbound reference to a CodeMirror diagnostic. */
 function unboundToDiagnostic(ref) {
 	return {
 		from: ref.start,
@@ -122,6 +128,5 @@ function unboundToDiagnostic(ref) {
 		message: `unresolved identifier '${ref.path.join("::")}'`
 	};
 }
-
 //#endregion
-export { createWeslLinter, wesl, weslLanguage };
+export { createWeslLinter, lintAndFetch, wesl, weslLanguage };