wesl 0.7.14 → 0.7.15

package/dist/index.d.ts

@@ -27,6 +27,85 @@ declare class ParseError extends Error {
   constructor(msg: string, span: Span);
 }
 //#endregion
+//#region src/Stream.d.ts
+/**
+ * Interface for a tokenizer. Returns a "next token", and can be reset to
+ * previously saved positions (checkpoints).
+ */
+interface Stream<T extends Token> {
+  /** Returns the current position */
+  checkpoint(): number;
+  /** Restores a position */
+  reset(position: number): void;
+  /**
+   * Returns the next token, or `null` if the end of the stream has been reached.
+   * Always leaves `checkpoint` right after the token.
+   */
+  nextToken(): T | null;
+  /** src text */
+  src: string;
+}
+/** A text token */
+interface Token {
+  kind: string;
+  text: string;
+  span: Span;
+}
+interface TypedToken<Kind extends string> extends Token {
+  kind: Kind;
+}
+//#endregion
+//#region src/parse/WeslStream.d.ts
+type WeslTokenKind = "word" | "keyword" | "number" | "symbol";
+type WeslToken<Kind extends WeslTokenKind = WeslTokenKind> = TypedToken<Kind>;
+/** A stream that produces WESL tokens, skipping over comments and white space */
+declare class WeslStream implements Stream<WeslToken> {
+  private stream;
+  /** New line */
+  private eolPattern;
+  private blockCommentPattern;
+  src: string;
+  constructor(src: string);
+  checkpoint(): number;
+  reset(position: number): void;
+  nextToken(): WeslToken | null;
+  /** Peek at the next token without consuming it */
+  peek(): WeslToken | null;
+  /** Consume token if text matches, otherwise leave position unchanged */
+  matchText(text: string): WeslToken | null;
+  /** Consume token if kind matches (and optionally text), otherwise leave position unchanged */
+  matchKind<K extends WeslTokenKind>(kind: K, text?: string): WeslToken<K> | null;
+  /** Consume token if predicate matches, otherwise leave position unchanged */
+  nextIf(predicate: (token: WeslToken) => boolean): WeslToken | null;
+  /** Match a sequence of tokens by text. Resets and returns null if any fails. */
+  matchSequence(...texts: string[]): WeslToken[] | null;
+  private skipToEol;
+  private skipBlockComment;
+  /**
+   * Only matches the `<` token if it is a template
+   * Precondition: An ident was parsed right before this.
+   * Runs the [template list discovery algorithm](https://www.w3.org/TR/WGSL/#template-list-discovery).
+   */
+  nextTemplateStartToken(): (WeslToken & {
+    kind: "symbol";
+  }) | null;
+  nextTemplateEndToken(): (WeslToken & {
+    kind: "symbol";
+  }) | null;
+  private isTemplateStart;
+  /**
+   * Call this after consuming an opening bracket.
+   * Skips until a closing bracket. This also consumes the closing bracket.
+   */
+  private skipBracketsTo;
+}
+//#endregion
+//#region src/parse/ParsingContext.d.ts
+interface ParseOptions {
+  /** Store expression AST nodes in statement contents (for tooling/validation). */
+  preserveExpressions?: boolean;
+}
+//#endregion
 //#region src/ParseWESL.d.ts
 /** Partial element being constructed during parsing. */
 type OpenElem<T extends ContainerElem = ContainerElem> = Pick<T, "kind" | "contents">;
@@ -77,7 +156,7 @@ declare class WeslParseError extends Error {
   });
 }
 /** Parse a WESL file. */
-declare function parseSrcModule(srcModule: SrcModule): WeslAST;
+declare function parseSrcModule(srcModule: SrcModule, options?: ParseOptions): WeslAST;
 /** @return flattened form of import tree for binding idents. */
 declare function flatImports(ast: BindingAST, conditions?: Conditions): FlatImport[];
 //#endregion
@@ -860,8 +939,19 @@ interface BindResults {
   decls: DeclIdent[];
   /** Additional global statements to emit (e.g., const_assert). */
   newStatements: EmittableElem[];
-  /** Unbound module paths (only if accumulateUnbound is true). */
-  unbound?: string[][];
+  /** Unbound identifiers with position info (only if accumulateUnbound is true). */
+  unbound?: UnboundRef[];
+}
+/** An unresolved reference with position info for error reporting. */
+interface UnboundRef {
+  /** Module path that couldn't be resolved (e.g., ["package", "foo", "bar"]). */
+  path: string[];
+  /** Source module containing this reference. */
+  srcModule: SrcModule;
+  /** Start offset in the source. */
+  start: number;
+  /** End offset in the source. */
+  end: number;
 }
 /** An element that can be directly emitted into the linked result. */
 interface EmittableElem {
@@ -905,7 +995,7 @@ interface BindContext {
   mangler: ManglerFn;
   virtuals?: VirtualLibrarySet;
   /** Unbound identifiers if accumulateUnbound is true. */
-  unbound?: string[][];
+  unbound?: UnboundRef[];
   /** Don't follow references from declarations (for library dependency detection). */
   dontFollowDecls?: boolean;
 }
@@ -941,6 +1031,8 @@ declare function identToString(ident?: Ident): string;
  *   (e.g., [['foo', 'bar', 'baz'], ['other', 'pkg']])
  */
 declare function findUnboundIdents(resolver: BatchModuleResolver): string[][];
+/** Find unbound references with full position info. */
+declare function findUnboundRefs(resolver: BatchModuleResolver): UnboundRef[];
 //#endregion
 //#region src/discovery/PackageNameUtils.d.ts
 /** Package name sanitization for WESL.
@@ -1029,78 +1121,20 @@ declare function normalize(path: string): string;
  * e.g. /foo/bar.wgsl => /foo/bar */
 declare function noSuffix(path: string): string;
 //#endregion
-//#region src/Stream.d.ts
-/**
- * Interface for a tokenizer. Returns a "next token", and can be reset to
- * previously saved positions (checkpoints).
- */
-interface Stream<T extends Token> {
-  /** Returns the current position */
-  checkpoint(): number;
-  /** Restores a position */
-  reset(position: number): void;
-  /**
-   * Returns the next token, or `null` if the end of the stream has been reached.
-   * Always leaves `checkpoint` right after the token.
-   */
-  nextToken(): T | null;
-  /** src text */
-  src: string;
-}
-/** A text token */
-interface Token {
-  kind: string;
-  text: string;
-  span: Span;
-}
-interface TypedToken<Kind extends string> extends Token {
-  kind: Kind;
-}
-//#endregion
-//#region src/parse/WeslStream.d.ts
-type WeslTokenKind = "word" | "keyword" | "number" | "symbol";
-type WeslToken<Kind extends WeslTokenKind = WeslTokenKind> = TypedToken<Kind>;
-/** A stream that produces WESL tokens, skipping over comments and white space */
-declare class WeslStream implements Stream<WeslToken> {
-  private stream;
-  /** New line */
-  private eolPattern;
-  private blockCommentPattern;
-  src: string;
-  constructor(src: string);
-  checkpoint(): number;
-  reset(position: number): void;
-  nextToken(): WeslToken | null;
-  /** Peek at the next token without consuming it */
-  peek(): WeslToken | null;
-  /** Consume token if text matches, otherwise leave position unchanged */
-  matchText(text: string): WeslToken | null;
-  /** Consume token if kind matches (and optionally text), otherwise leave position unchanged */
-  matchKind<K extends WeslTokenKind>(kind: K, text?: string): WeslToken<K> | null;
-  /** Consume token if predicate matches, otherwise leave position unchanged */
-  nextIf(predicate: (token: WeslToken) => boolean): WeslToken | null;
-  /** Match a sequence of tokens by text. Resets and returns null if any fails. */
-  matchSequence(...texts: string[]): WeslToken[] | null;
-  private skipToEol;
-  private skipBlockComment;
-  /**
-   * Only matches the `<` token if it is a template
-   * Precondition: An ident was parsed right before this.
-   * Runs the [template list discovery algorithm](https://www.w3.org/TR/WGSL/#template-list-discovery).
-   */
-  nextTemplateStartToken(): (WeslToken & {
-    kind: "symbol";
-  }) | null;
-  nextTemplateEndToken(): (WeslToken & {
-    kind: "symbol";
-  }) | null;
-  private isTemplateStart;
-  /**
-   * Call this after consuming an opening bracket.
-   * Skips until a closing bracket. This also consumes the closing bracket.
-   */
-  private skipBracketsTo;
-}
+//#region src/StandardTypes.d.ts
+declare const stdFns: string[];
+declare const sampledTextureTypes = "\n  texture_1d texture_2d texture_2d_array texture_3d \n  texture_cube texture_cube_array\n";
+declare const multisampledTextureTypes = "\n  texture_multisampled_2d texture_depth_multisampled_2d\n";
+declare const textureStorageTypes = "\n  texture_storage_1d texture_storage_2d texture_storage_2d_array \n  texture_storage_3d\n";
+declare const stdTypes: string[];
+/** https://www.w3.org/TR/WGSL/#predeclared-enumerants  */
+declare const stdEnumerants: string[];
+/** return true if the name is for a built in type (not a user struct) */
+declare function stdType(name: string): boolean;
+/** return true if the name is for a built in fn (not a user function) */
+declare function stdFn(name: string): boolean;
+/** return true if the name is for a built in enumerant */
+declare function stdEnumerant(name: string): boolean;
 //#endregion
 //#region src/TransformBindingStructs.d.ts
 declare function bindingStructsPlugin(): WeslJsPlugin;
@@ -1197,4 +1231,4 @@ declare function offsetToLineNumber(offset: number, text: string): [lineNum: num
  */
 declare function errorHighlight(source: string, span: Span): [string, string];
 //#endregion
-export { AbstractElem, AbstractElemBase, AliasElem, Attribute, AttributeElem, BatchModuleResolver, BinaryExpression, BinaryOperator, BindIdentsParams, BindResults, BindingAST, BindingStructElem, BlockStatement, BoundAndTransformed, BuiltinAttribute, BundleResolver, ComponentExpression, ComponentMemberExpression, CompositeResolver, ConditionalAttribute, Conditions, ConstAssertElem, ConstElem, ContainerElem, ContinuingElem, DeclIdent, DeclIdentElem, DeclarationElem, DiagnosticAttribute, DiagnosticDirective, DiagnosticRule, DirectiveElem, DirectiveVariant, ElemKindMap, ElemWithAttributes, ElemWithContentsBase, ElifAttribute, ElseAttribute, EmittableElem, EnableDirective, ExpressionElem, ExtendedGPUValidationError, FnElem, FnParamElem, FunctionCallExpression, GlobalDeclarationElem, GlobalVarElem, GrammarElem, HasAttributes, Ident, IfAttribute, ImportCollection, ImportElem, ImportItem, ImportSegment, ImportStatement, InterpolateAttribute, LetElem, LexicalScope, LinkConfig, LinkParams, LinkRegistryParams, LinkedWesl, LinkerTransform, Literal, LiveDecls, ManglerFn, ModuleElem, ModuleResolver, NameElem, OpenElem, OverrideElem, ParenthesizedExpression, ParseError, PartialScope, RecordResolver, RecordResolverOptions, RefIdent, RefIdentElem, RequiresDirective, Scope, SimpleMemberRef, Span, SrcMap, SrcMapBuilder, SrcMapEntry, SrcModule, SrcPosition, SrcWithPath, StableState, StandardAttribute, StatementElem, StructElem, StructMemberElem, StuffElem, SwitchClauseElem, SyntheticElem, TerminalElem, TextElem, TransformedAST, TranslateTimeExpressionElem, TypeRefElem, TypeTemplateParameter, TypedDeclElem, UnaryExpression, UnaryOperator, UnknownExpressionElem, VarElem, VirtualLibrary, VirtualLibraryFn, VirtualLibrarySet, WeslAST, WeslBundle, WeslDevice, WeslGPUCompilationInfo, WeslGPUCompilationMessage, WeslJsPlugin, WeslParseContext, WeslParseError, WeslParseState, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, emptyScope, errorHighlight, fileToModulePath, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };
+export { AbstractElem, AbstractElemBase, AliasElem, Attribute, AttributeElem, BatchModuleResolver, BinaryExpression, BinaryOperator, BindIdentsParams, BindResults, BindingAST, BindingStructElem, BlockStatement, BoundAndTransformed, BuiltinAttribute, BundleResolver, ComponentExpression, ComponentMemberExpression, CompositeResolver, ConditionalAttribute, Conditions, ConstAssertElem, ConstElem, ContainerElem, ContinuingElem, DeclIdent, DeclIdentElem, DeclarationElem, DiagnosticAttribute, DiagnosticDirective, DiagnosticRule, DirectiveElem, DirectiveVariant, ElemKindMap, ElemWithAttributes, ElemWithContentsBase, ElifAttribute, ElseAttribute, EmittableElem, EnableDirective, ExpressionElem, ExtendedGPUValidationError, FnElem, FnParamElem, FunctionCallExpression, GlobalDeclarationElem, GlobalVarElem, GrammarElem, HasAttributes, Ident, IfAttribute, ImportCollection, ImportElem, ImportItem, ImportSegment, ImportStatement, InterpolateAttribute, LetElem, LexicalScope, LinkConfig, LinkParams, LinkRegistryParams, LinkedWesl, LinkerTransform, Literal, LiveDecls, ManglerFn, ModuleElem, ModuleResolver, NameElem, OpenElem, OverrideElem, ParenthesizedExpression, ParseError, type ParseOptions, PartialScope, RecordResolver, RecordResolverOptions, RefIdent, RefIdentElem, RequiresDirective, Scope, SimpleMemberRef, Span, SrcMap, SrcMapBuilder, SrcMapEntry, SrcModule, SrcPosition, SrcWithPath, StableState, StandardAttribute, StatementElem, StructElem, StructMemberElem, StuffElem, SwitchClauseElem, SyntheticElem, TerminalElem, TextElem, TransformedAST, TranslateTimeExpressionElem, TypeRefElem, TypeTemplateParameter, TypedDeclElem, UnaryExpression, UnaryOperator, UnboundRef, UnknownExpressionElem, VarElem, VirtualLibrary, VirtualLibraryFn, VirtualLibrarySet, WeslAST, WeslBundle, WeslDevice, WeslGPUCompilationInfo, WeslGPUCompilationMessage, WeslJsPlugin, WeslParseContext, WeslParseError, WeslParseState, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, emptyScope, errorHighlight, fileToModulePath, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findUnboundRefs, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };

package/dist/index.js

@@ -46,9 +46,9 @@ function logInternalSrc(logFn, src, pos, ...msgs) {
 	logFn(carets(linePos, linePos2));
 }
 function carets(linePos, linePos2) {
-	const indent = " ".repeat(linePos);
+	const indent = " ".repeat(Math.max(0, linePos));
 	const numCarets = linePos2 ? linePos2 - linePos : 1;
-	return indent + "^".repeat(numCarets);
+	return indent + "^".repeat(Math.max(1, numCarets));
 }
 const startCache = /* @__PURE__ */ new Map();
 /** return the line in the src containing a given character position */
@@ -235,12 +235,12 @@ function offsetToLineNumber(offset, text) {
 */
 function errorHighlight(source, span) {
 	let lineStartOffset = source.lastIndexOf("\n", span[0]);
-	if (lineStartOffset === -1) lineStartOffset = 0;
+	lineStartOffset = lineStartOffset === -1 ? 0 : lineStartOffset + 1;
 	let lineEndOffset = source.indexOf("\n", span[0]);
 	if (lineEndOffset === -1) lineEndOffset = source.length;
 	const errorLength = span[1] - span[0];
 	const caretCount = Math.max(1, errorLength);
-	const linePos = span[0] - lineStartOffset;
+	const linePos = Math.max(0, span[0] - lineStartOffset);
 	return [source.slice(lineStartOffset, lineEndOffset), " ".repeat(linePos) + "^".repeat(caretCount)];
 }
 
@@ -1443,6 +1443,7 @@ function expectWord(stream, errorMsg) {
 function expectExpression(ctx, errorMsg = "Expected expression") {
 	const expr = parseExpression(ctx);
 	if (!expr) throwParseError(ctx.stream, errorMsg);
+	if (ctx.options.preserveExpressions) ctx.addElem(expr);
 	return expr;
 }
 /** Throw a ParseError at the current/next token position. */
@@ -2481,7 +2482,8 @@ function parseReturnStmt(ctx, startPos, attributes) {
 	const { stream } = ctx;
 	if (!stream.matchText("return")) return null;
 	beginElem(ctx, "statement", attributes);
-	parseExpression(ctx);
+	const expr = parseExpression(ctx);
+	if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
 	expect(stream, ";", "return statement");
 	return finishBlockStatement(startPos, ctx, attributes);
 }
@@ -2532,11 +2534,13 @@ function parsePhonyAssignment(ctx, startPos, attributes) {
 function parseExpressionStmt(ctx, startPos, attributes) {
 	const { stream } = ctx;
 	beginElem(ctx, "statement", attributes);
-	if (!parseExpression(ctx)) {
+	const expr = parseExpression(ctx);
+	if (!expr) {
 		finishContents(ctx, startPos, startPos);
 		stream.reset(startPos);
 		return null;
 	}
+	if (ctx.options.preserveExpressions) ctx.addElem(expr);
 	if (!parseIncDecOperator(stream)) parseAssignmentRhs(ctx);
 	expect(stream, ";", "expression");
 	return finishBlockStatement(startPos, ctx, attributes);
@@ -2569,7 +2573,8 @@ function parseForStatement(ctx, attributes) {
 	ctx.pushScope();
 	expect(stream, "(", "'for'");
 	parseForInit(ctx);
-	parseExpression(ctx);
+	const cond = parseExpression(ctx);
+	if (cond && ctx.options.preserveExpressions) ctx.addElem(cond);
 	expect(stream, ";", "for loop condition");
 	parseForUpdate(ctx);
 	expect(stream, ")", "for loop header");
@@ -2611,14 +2616,16 @@ function parseForInit(ctx) {
 	const varDecl = parseLocalVarDecl(ctx);
 	if (varDecl) ctx.addElem(varDecl);
 	else {
-		parseExpression(ctx);
+		const expr = parseExpression(ctx);
+		if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
 		expect(stream, ";", "for loop init");
 	}
 }
 /** Grammar: for_update : variable_updating_statement | func_call_statement
 *           variable_updating_statement : assignment_statement | increment_statement | decrement_statement */
 function parseForUpdate(ctx) {
-	parseExpression(ctx);
+	const expr = parseExpression(ctx);
+	if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
 	parseIncDecOperator(ctx.stream) || parseAssignmentRhs(ctx);
 }
 
@@ -3096,11 +3103,13 @@ var ParsingContext = class {
 	srcModule;
 	stream;
 	state;
-	constructor(stream, state) {
+	options;
+	constructor(stream, state, options) {
 		this.stream = stream;
 		this.state = state;
 		this.srcModule = state.stable.srcModule;
 		this.src = this.srcModule.src;
+		this.options = options ?? {};
 	}
 	position() {
 		return this.stream.checkpoint();
@@ -3509,8 +3518,8 @@ var WeslStream = class {
 //#endregion
 //#region src/parse/ParseWesl.ts
 /** Parse a WESL source module into an AST. */
-function parseWesl(srcModule) {
-	const { ctx, state } = createParseState(srcModule);
+function parseWesl(srcModule, options) {
+	const { ctx, state } = createParseState(srcModule, options);
 	try {
 		beginElem(ctx, "module");
 		parseModule(ctx);
@@ -3529,7 +3538,7 @@ function parseWesl(srcModule) {
 	}
 }
 /** Initialize parse state: token stream, root scope, and module element. */
-function createParseState(srcModule) {
+function createParseState(srcModule, options) {
 	const stream = new WeslStream(srcModule.src);
 	const rootScope = emptyScope(null);
 	const moduleElem = {
@@ -3551,7 +3560,7 @@ function createParseState(srcModule) {
 		}
 	};
 	return {
-		ctx: new ParsingContext(stream, state),
+		ctx: new ParsingContext(stream, state, options),
 		state
 	};
 }
@@ -3574,8 +3583,8 @@ var WeslParseError = class extends Error {
 	}
 };
 /** Parse a WESL file. */
-function parseSrcModule(srcModule) {
-	return parseWesl(srcModule);
+function parseSrcModule(srcModule, options) {
+	return parseWesl(srcModule, options);
 }
 /** @return flattened form of import tree for binding idents. */
 function flatImports(ast, conditions) {
@@ -3849,14 +3858,24 @@ function findQualifiedImport(refIdent, ctx) {
 	const identParts = refIdent.originalName.split("::");
 	const pathParts = matchingImport(identParts, flatImps) ?? qualifiedIdent(identParts);
 	if (!pathParts) {
-		if (unbound && !stdWgsl(refIdent.originalName)) unbound.push(identParts);
+		if (unbound && !stdWgsl(refIdent.originalName)) pushUnbound(unbound, identParts, refIdent);
 		return;
 	}
 	const result = findExport(pathParts, refIdent.ast.srcModule, ctx);
-	if (!result) if (unbound) unbound.push(pathParts);
+	if (!result) if (unbound) pushUnbound(unbound, pathParts, refIdent);
 	else failIdent(refIdent, `module not found for '${pathParts.join("::")}'`);
 	return result;
 }
+/** Add an unbound reference with position info. */
+function pushUnbound(unbound, path, refIdent) {
+	const { srcModule, start, end } = refIdent.refIdentElem;
+	unbound.push({
+		path,
+		srcModule,
+		start,
+		end
+	});
+}
 /** Find an import statement that matches a provided identifier. */
 function matchingImport(identParts, imports) {
 	const flat = imports.find((f) => f.importPath.at(-1) === identParts[0]);
@@ -3940,6 +3959,10 @@ function collectDecls(scope, found) {
 *   (e.g., [['foo', 'bar', 'baz'], ['other', 'pkg']])
 */
 function findUnboundIdents(resolver) {
+	return findUnboundRefs(resolver).map((ref) => ref.path);
+}
+/** Find unbound references with full position info. */
+function findUnboundRefs(resolver) {
 	const bindContext = {
 		resolver,
 		conditions: {},
@@ -4308,7 +4331,7 @@ var SrcMap = class SrcMap {
 		const newEntries = [prev];
 		for (let i = 1; i < this.entries.length; i++) {
 			const e = this.entries[i];
-			if (e.src.path === prev.src.path && e.src.text === prev.src.text && prev.destEnd === e.destStart && prev.srcEnd === e.srcStart) {
+			if (e.src.path === prev.src.path && e.src.text === prev.src.text && prev.destEnd === e.destStart && prev.srcEnd === e.srcStart && prev.srcEnd - prev.srcStart === prev.destEnd - prev.destStart) {
 				prev.destEnd = e.destEnd;
 				prev.srcEnd = e.srcEnd;
 			} else {
@@ -4937,4 +4960,4 @@ function makeWeslDevice(device) {
 }
 
 //#endregion
-export { BundleResolver, CompositeResolver, LinkedWesl, ParseError, RecordResolver, SrcMap, SrcMapBuilder, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, emptyScope, errorHighlight, fileToModulePath, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };
+export { BundleResolver, CompositeResolver, LinkedWesl, ParseError, RecordResolver, SrcMap, SrcMapBuilder, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, emptyScope, errorHighlight, fileToModulePath, filterMap, findMap, findRefsToBindingStructs, findUnboundIdents, findUnboundRefs, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, transformBindingReference, transformBindingStruct, underscoreMangle, validation, withLoggerAsync };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wesl",
-  "version": "0.7.14",
+  "version": "0.7.15",
   "type": "module",
   "files": [
     "dist",
@@ -27,7 +27,7 @@
     "wrangler": "^4.22.0"
   },
   "peerDependencies": {
-    "random_wgsl": "^0.6.63"
+    "random_wgsl": "^0.6.64"
   },
   "peerDependenciesMeta": {
     "random_wgsl": {

package/src/BindIdents.ts

@@ -70,8 +70,20 @@ export interface BindResults {
   /** Additional global statements to emit (e.g., const_assert). */
   newStatements: EmittableElem[];
 
-  /** Unbound module paths (only if accumulateUnbound is true). */
-  unbound?: string[][];
+  /** Unbound identifiers with position info (only if accumulateUnbound is true). */
+  unbound?: UnboundRef[];
+}
+
+/** An unresolved reference with position info for error reporting. */
+export interface UnboundRef {
+  /** Module path that couldn't be resolved (e.g., ["package", "foo", "bar"]). */
+  path: string[];
+  /** Source module containing this reference. */
+  srcModule: SrcModule;
+  /** Start offset in the source. */
+  start: number;
+  /** End offset in the source. */
+  end: number;
 }
 
 /** An element that can be directly emitted into the linked result. */
@@ -223,7 +235,7 @@ interface BindContext {
   virtuals?: VirtualLibrarySet;
 
   /** Unbound identifiers if accumulateUnbound is true. */
-  unbound?: string[][];
+  unbound?: UnboundRef[];
 
   /** Don't follow references from declarations (for library dependency detection). */
   dontFollowDecls?: boolean;
@@ -370,18 +382,30 @@ function findQualifiedImport(
     matchingImport(identParts, flatImps) ?? qualifiedIdent(identParts);
 
   if (!pathParts) {
-    if (unbound && !stdWgsl(refIdent.originalName)) unbound.push(identParts);
+    if (unbound && !stdWgsl(refIdent.originalName)) {
+      pushUnbound(unbound, identParts, refIdent);
+    }
     return undefined;
   }
 
   const result = findExport(pathParts, refIdent.ast.srcModule, ctx);
   if (!result) {
-    if (unbound) unbound.push(pathParts);
+    if (unbound) pushUnbound(unbound, pathParts, refIdent);
     else failIdent(refIdent, `module not found for '${pathParts.join("::")}'`);
   }
   return result;
 }
 
+/** Add an unbound reference with position info. */
+function pushUnbound(
+  unbound: UnboundRef[],
+  path: string[],
+  refIdent: RefIdent,
+): void {
+  const { srcModule, start, end } = refIdent.refIdentElem;
+  unbound.push({ path, srcModule, start, end });
+}
+
 /** Find an import statement that matches a provided identifier. */
 function matchingImport(
   identParts: string[],

package/src/Logging.ts

@@ -88,9 +88,9 @@ function logInternalSrc(
 }
 
 function carets(linePos: number, linePos2?: number): string {
-  const indent = " ".repeat(linePos);
+  const indent = " ".repeat(Math.max(0, linePos));
   const numCarets = linePos2 ? linePos2 - linePos : 1;
-  const caretStr = "^".repeat(numCarets);
+  const caretStr = "^".repeat(Math.max(1, numCarets));
   return indent + caretStr;
 }
 

package/src/ParseWESL.ts

@@ -9,10 +9,13 @@ import { filterValidElements } from "./Conditions.ts";
 import { type FlatImport, flattenTreeImport } from "./FlattenTreeImport.ts";
 import type { ParseError } from "./ParseError.ts";
 import { parseWesl } from "./parse/ParseWesl.ts";
+import type { ParseOptions } from "./parse/ParsingContext.ts";
 import type { Conditions, Scope, SrcModule } from "./Scope.ts";
 import type { Span } from "./Span.ts";
 import { errorHighlight, offsetToLineNumber } from "./Util.ts";
 
+export type { ParseOptions };
+
 /** Partial element being constructed during parsing. */
 export type OpenElem<T extends ContainerElem = ContainerElem> = Pick<
   T,
@@ -78,8 +81,11 @@ export class WeslParseError extends Error {
 }
 
 /** Parse a WESL file. */
-export function parseSrcModule(srcModule: SrcModule): WeslAST {
-  return parseWesl(srcModule);
+export function parseSrcModule(
+  srcModule: SrcModule,
+  options?: ParseOptions,
+): WeslAST {
+  return parseWesl(srcModule, options);
 }
 
 /** @return flattened form of import tree for binding idents. */

package/src/SrcMap.ts

@@ -50,7 +50,8 @@ export class SrcMap {
         e.src.path === prev.src.path &&
         e.src.text === prev.src.text &&
         prev.destEnd === e.destStart &&
-        prev.srcEnd === e.srcStart
+        prev.srcEnd === e.srcStart &&
+        prev.srcEnd - prev.srcStart === prev.destEnd - prev.destStart
       ) {
         // combine adjacent range entries into one
         prev.destEnd = e.destEnd;

package/src/Util.ts

@@ -175,9 +175,7 @@ export function offsetToLineNumber(
  */
 export function errorHighlight(source: string, span: Span): [string, string] {
   let lineStartOffset = source.lastIndexOf("\n", span[0]);
-  if (lineStartOffset === -1) {
-    lineStartOffset = 0;
-  }
+  lineStartOffset = lineStartOffset === -1 ? 0 : lineStartOffset + 1;
   let lineEndOffset = source.indexOf("\n", span[0]);
   if (lineEndOffset === -1) {
     lineEndOffset = source.length;
@@ -186,7 +184,7 @@ export function errorHighlight(source: string, span: Span): [string, string] {
   // LATER Handle multiline spans
   const errorLength = span[1] - span[0];
   const caretCount = Math.max(1, errorLength);
-  const linePos = span[0] - lineStartOffset;
+  const linePos = Math.max(0, span[0] - lineStartOffset);
   return [
     source.slice(lineStartOffset, lineEndOffset),
     " ".repeat(linePos) + "^".repeat(caretCount),

package/src/discovery/FindUnboundIdents.ts

@@ -3,6 +3,7 @@ import {
   bindIdentsRecursive,
   type EmittableElem,
   findValidRootDecls,
+  type UnboundRef,
 } from "../BindIdents.ts";
 import { type LiveDecls, makeLiveDecls } from "../LiveDeclarations.ts";
 import { minimalMangle } from "../Mangler.ts";
@@ -21,6 +22,11 @@ import { filterMap } from "../Util.ts";
  *   (e.g., [['foo', 'bar', 'baz'], ['other', 'pkg']])
  */
 export function findUnboundIdents(resolver: BatchModuleResolver): string[][] {
+  return findUnboundRefs(resolver).map(ref => ref.path);
+}
+
+/** Find unbound references with full position info. */
+export function findUnboundRefs(resolver: BatchModuleResolver): UnboundRef[] {
   const bindContext = {
     resolver,
     conditions: {},
@@ -29,7 +35,7 @@ export function findUnboundIdents(resolver: BatchModuleResolver): string[][] {
     globalNames: new Set<string>(),
     globalStatements: new Map<AbstractElem, EmittableElem>(),
     mangler: minimalMangle,
-    unbound: [] as string[][],
+    unbound: [] as UnboundRef[],
     dontFollowDecls: true,
   };
 

package/src/index.ts

@@ -18,6 +18,7 @@ export { WeslStream } from "./parse/WeslStream.ts";
 export * from "./Scope.ts";
 export * from "./Span.ts";
 export * from "./SrcMap.ts";
+export * from "./StandardTypes.ts";
 export * from "./TransformBindingStructs.ts";
 export * from "./Util.ts";
 export * from "./WeslBundle.ts";

package/src/parse/ParseLoop.ts

@@ -33,7 +33,8 @@ export function parseForStatement(
   expect(stream, "(", "'for'");
 
   parseForInit(ctx);
-  parseExpression(ctx); // returns null if empty condition
+  const cond = parseExpression(ctx); // returns null if empty condition
+  if (cond && ctx.options.preserveExpressions) ctx.addElem(cond);
   expect(stream, ";", "for loop condition");
   parseForUpdate(ctx);
   expect(stream, ")", "for loop header");
@@ -99,7 +100,8 @@ function parseForInit(ctx: ParsingContext): void {
     ctx.addElem(varDecl);
     // parseLocalVarDecl already consumed the ';'
   } else {
-    parseExpression(ctx); // returns null for empty case
+    const expr = parseExpression(ctx); // returns null for empty case
+    if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
     expect(stream, ";", "for loop init");
   }
 }
@@ -107,6 +109,7 @@ function parseForInit(ctx: ParsingContext): void {
 /** Grammar: for_update : variable_updating_statement | func_call_statement
  *           variable_updating_statement : assignment_statement | increment_statement | decrement_statement */
 function parseForUpdate(ctx: ParsingContext): void {
-  parseExpression(ctx);
+  const expr = parseExpression(ctx);
+  if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
   parseIncDecOperator(ctx.stream) || parseAssignmentRhs(ctx);
 }

package/src/parse/ParseSimpleStatement.ts

@@ -57,7 +57,8 @@ function parseReturnStmt(
   const { stream } = ctx;
   if (!stream.matchText("return")) return null;
   beginElem(ctx, "statement", attributes);
-  parseExpression(ctx);
+  const expr = parseExpression(ctx);
+  if (expr && ctx.options.preserveExpressions) ctx.addElem(expr);
   expect(stream, ";", "return statement");
   return finishBlockStatement(startPos, ctx, attributes);
 }
@@ -138,6 +139,7 @@ function parseExpressionStmt(
     stream.reset(startPos);
     return null;
   }
+  if (ctx.options.preserveExpressions) ctx.addElem(expr);
 
   if (!parseIncDecOperator(stream)) parseAssignmentRhs(ctx);
   expect(stream, ";", "expression");

package/src/parse/ParseUtil.ts

@@ -54,6 +54,7 @@ export function expectExpression(
 ): ExpressionElem {
   const expr = parseExpression(ctx);
   if (!expr) throwParseError(ctx.stream, errorMsg);
+  if (ctx.options.preserveExpressions) ctx.addElem(expr);
   return expr;
 }
 

package/src/parse/ParseWesl.ts

@@ -6,12 +6,15 @@ import type { SrcModule } from "../Scope.ts";
 import { emptyScope } from "../Scope.ts";
 import { beginElem, finishContents } from "./ContentsHelpers.ts";
 import { parseModule } from "./ParseModule.ts";
-import { ParsingContext } from "./ParsingContext.ts";
+import { type ParseOptions, ParsingContext } from "./ParsingContext.ts";
 import { WeslStream } from "./WeslStream.ts";
 
 /** Parse a WESL source module into an AST. */
-export function parseWesl(srcModule: SrcModule): WeslAST {
-  const { ctx, state } = createParseState(srcModule);
+export function parseWesl(
+  srcModule: SrcModule,
+  options?: ParseOptions,
+): WeslAST {
+  const { ctx, state } = createParseState(srcModule, options);
   try {
     beginElem(ctx, "module");
     parseModule(ctx);
@@ -30,7 +33,10 @@ export function parseWesl(srcModule: SrcModule): WeslAST {
 }
 
 /** Initialize parse state: token stream, root scope, and module element. */
-function createParseState(srcModule: SrcModule): {
+function createParseState(
+  srcModule: SrcModule,
+  options?: ParseOptions,
+): {
   ctx: ParsingContext;
   state: WeslParseState;
 } {
@@ -46,6 +52,6 @@ function createParseState(srcModule: SrcModule): {
     context: { scope: rootScope, openElems: [] },
     stable: { srcModule, moduleElem, rootScope, imports: [] },
   };
-  const ctx = new ParsingContext(stream, state);
+  const ctx = new ParsingContext(stream, state, options);
   return { ctx, state };
 }

package/src/parse/ParsingContext.ts

@@ -11,18 +11,30 @@ import {
 } from "../Scope.ts";
 import type { WeslStream } from "./WeslStream.ts";
 
+export interface ParseOptions {
+  /** Store expression AST nodes in statement contents (for tooling/validation). */
+  // LATER we'll always store expressions in the AST, (but this partial support is for wgsl-edit validation)
+  preserveExpressions?: boolean;
+}
+
 /** Context for parsers to build AST and manage scopes. */
 export class ParsingContext {
   src: string;
   srcModule: SrcModule;
   stream: WeslStream;
   state: WeslParseState;
+  options: ParseOptions;
 
-  constructor(stream: WeslStream, state: WeslParseState) {
+  constructor(
+    stream: WeslStream,
+    state: WeslParseState,
+    options?: ParseOptions,
+  ) {
     this.stream = stream;
     this.state = state;
     this.srcModule = state.stable.srcModule;
     this.src = this.srcModule.src;
+    this.options = options ?? {};
   }
 
   position(): number {

package/src/test/BindWESLV2.test.ts

@@ -79,8 +79,9 @@ test("collect unbound references", async () => {
   const bindResult = bindIdents({ resolver, rootAst, accumulateUnbound: true });
 
   const expected = ["pkg1::bar::baz", "pkg2::foo"];
-  const expectedArrays = expected.map(s => s.split("::")).sort();
-  expect(bindResult.unbound?.sort()).deep.equal(expectedArrays);
+  const expectedPaths = expected.map(s => s.split("::")).sort();
+  const unboundPaths = bindResult.unbound?.map(ref => ref.path).sort();
+  expect(unboundPaths).deep.equal(expectedPaths);
 });
 
 test("publicDecl finds valid conditional declaration", () => {

package/src/test/ParseErrorV2.test.ts

@@ -18,9 +18,8 @@ test("parse invalid if", () => {
   }`;
   expect(() => parseTest(src)).toThrowErrorMatchingInlineSnapshot(`
     [Error: ./test.wesl:3:13 error: Invalid token 🐈
-
       if(1<1) { 🐈‍⬛ } else {  }
-                 ^^]
+                ^^]
   `);
 });
 

package/src/test/SrcMap.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "vitest";
+import { SrcMap, type SrcMapEntry, type SrcWithPath } from "../SrcMap.ts";
+
+const src: SrcWithPath = {
+  text: "let x = lygia::math::consts::PI;\n  let x = 7;",
+  path: "test.wesl",
+};
+
+function makeMap(entries: SrcMapEntry[]): SrcMap {
+  const dest: SrcWithPath = { text: "PI;\n  let x = 7;" };
+  return new SrcMap(dest, entries);
+}
+
+test("compact does not merge entries with different src/dest lengths", () => {
+  // Entry A: src "lygia::math::consts::PI" (25 chars) -> dest "PI" (2 chars)
+  // Entry B: src ";\n  let x = 7;" (14 chars) -> dest ";\n  let x = 7;" (14 chars)
+  const entries: SrcMapEntry[] = [
+    { src, srcStart: 8, srcEnd: 33, destStart: 0, destEnd: 2 },
+    { src, srcStart: 33, srcEnd: 47, destStart: 2, destEnd: 16 },
+  ];
+  const map = makeMap(entries);
+  map.compact();
+  expect(map.entries).toHaveLength(2);
+});
+
+test("compact merges adjacent entries with equal src/dest lengths", () => {
+  const entries: SrcMapEntry[] = [
+    { src, srcStart: 0, srcEnd: 5, destStart: 0, destEnd: 5 },
+    { src, srcStart: 5, srcEnd: 10, destStart: 5, destEnd: 10 },
+  ];
+  const map = makeMap(entries);
+  map.compact();
+  expect(map.entries).toHaveLength(1);
+  expect(map.entries[0]).toMatchObject({
+    srcStart: 0,
+    srcEnd: 10,
+    destStart: 0,
+    destEnd: 10,
+  });
+});
+
+test("destToSrc returns correct position after compact with mixed-length entries", () => {
+  // dest: "PI;\n  let x = 7;"
+  //        ^^ entry A (2 chars dest, 25 chars src)
+  //          ^^^^^^^^^^^^^^ entry B (14 chars dest, 14 chars src)
+  const entries: SrcMapEntry[] = [
+    { src, srcStart: 8, srcEnd: 33, destStart: 0, destEnd: 2 },
+    { src, srcStart: 33, srcEnd: 47, destStart: 2, destEnd: 16 },
+  ];
+  const map = makeMap(entries);
+  map.compact();
+
+  // "x" in "let x = 7" is at dest offset 10 (inside entry B)
+  const result = map.destToSrc(10);
+  expect(result.position).toBe(41); // srcStart 33 + (10 - 2) = 41
+});
+
+test("destToSrc for unmapped position falls back to dest identity", () => {
+  const entries: SrcMapEntry[] = [
+    { src, srcStart: 0, srcEnd: 3, destStart: 0, destEnd: 3 },
+    { src, srcStart: 10, srcEnd: 13, destStart: 10, destEnd: 13 },
+  ];
+  const map = makeMap(entries);
+
+  // position 5 is in the gap between entries
+  const result = map.destToSrc(5);
+  expect(result.src).toBe(map.dest);
+  expect(result.position).toBe(5);
+});