wesl 0.6.0-pre10

package/dist/tools/packages/wesl/src/AbstractElems.d.ts

@@ -0,0 +1,322 @@
+import { Span } from '../../mini-parse/src';
+import { DeclIdent, RefIdent, SrcModule } from './Scope.ts';
+/**
+ * Structures to describe the 'interesting' parts of a WESL source file.
+ *
+ * The parts of the source that need to analyze further in the linker
+ * are pulled out into these structures.
+ *
+ * The parts that are uninteresting the the linker are recorded
+ * as 'TextElem' nodes, which are generally just copied to the output WGSL
+ * along with their containing element.
+ */
+export type AbstractElem = GrammarElem | SyntheticElem;
+export type GrammarElem = ContainerElem | TerminalElem;
+export type ContainerElem = AttributeElem | AliasElem | ConstAssertElem | ConstElem | UnknownExpressionElem | SimpleMemberRef | FnElem | TypedDeclElem | GlobalVarElem | LetElem | ModuleElem | OverrideElem | FnParamElem | StructElem | StructMemberElem | StuffElem | TypeRefElem | VarElem | StatementElem | SwitchClauseElem;
+/** Inspired by https://github.com/wgsl-tooling-wg/wesl-rs/blob/3b2434eac1b2ebda9eb8bfb25f43d8600d819872/crates/wgsl-parse/src/syntax.rs#L364 */
+export type ExpressionElem = Literal | TranslateTimeFeature | RefIdentElem | ParenthesizedExpression | ComponentExpression | ComponentMemberExpression | UnaryExpression | BinaryExpression | FunctionCallExpression;
+export type TerminalElem = DirectiveElem | DeclIdentElem | NameElem | RefIdentElem | TextElem | ImportElem;
+export type GlobalDeclarationElem = AliasElem | ConstElem | FnElem | GlobalVarElem | OverrideElem | StructElem;
+export type DeclarationElem = GlobalDeclarationElem | FnParamElem | VarElem;
+export type ElemWithAttributes = Extract<AbstractElem, HasAttributes>;
+export interface AbstractElemBase {
+    kind: AbstractElem["kind"];
+    start: number;
+    end: number;
+}
+export interface ElemWithContentsBase extends AbstractElemBase {
+    contents: AbstractElem[];
+}
+export interface HasAttributes {
+    attributes?: AttributeElem[];
+}
+/**
+ * a raw bit of text in WESL source that's typically copied to the linked WGSL.
+ * e.g. a keyword  like 'var'
+ * or a phrase we needn't analyze further like '@diagnostic(off,derivative_uniformity)'
+ */
+export interface TextElem extends AbstractElemBase {
+    kind: "text";
+    srcModule: SrcModule;
+}
+/** a name that doesn't need to be an Ident
+ * e.g.
+ * - a struct member name
+ * - a diagnostic rule name
+ * - an enable-extension name
+ * - an interpolation sampling name
+ */
+export interface NameElem extends AbstractElemBase {
+    kind: "name";
+    name: string;
+}
+/** an identifier that 'refers to' a declaration (aka a symbol reference) */
+export interface RefIdentElem extends AbstractElemBase {
+    kind: RefIdent["kind"];
+    ident: RefIdent;
+    srcModule: SrcModule;
+}
+/** a declaration identifier (aka a symbol declaration) */
+export interface DeclIdentElem extends AbstractElemBase {
+    kind: DeclIdent["kind"];
+    ident: DeclIdent;
+    srcModule: SrcModule;
+}
+/** Holds an import statement, and has a span */
+export interface ImportElem extends AbstractElemBase {
+    kind: "import";
+    imports: ImportStatement;
+}
+/**
+ * An import statement, which is tree shaped.
+ * `import foo::bar::{baz, cat as neko};
+ */
+export interface ImportStatement {
+    kind: "import-statement";
+    segments: ImportSegment[];
+    finalSegment: ImportCollection | ImportItem;
+}
+/**
+ * A collection of import trees.
+ * `{baz, cat as neko}`
+ */
+export interface ImportSegment {
+    kind: "import-segment";
+    name: string;
+}
+/**
+ * A primitive segment in an import statement.
+ * `foo`
+ */
+export interface ImportCollection {
+    kind: "import-collection";
+    subtrees: ImportStatement[];
+}
+/**
+ * A renamed item at the end of an import statement.
+ * `cat as neko`
+ */
+export interface ImportItem {
+    kind: "import-item";
+    name: string;
+    as?: string;
+}
+/** generated element, produced after parsing and binding */
+export interface SyntheticElem {
+    kind: "synthetic";
+    text: string;
+}
+/** a declaration identifer with a possible type */
+export interface TypedDeclElem extends ElemWithContentsBase {
+    kind: "typeDecl";
+    decl: DeclIdentElem;
+    typeRef?: TypeRefElem;
+}
+/** an alias statement */
+export interface AliasElem extends ElemWithContentsBase, HasAttributes {
+    kind: "alias";
+    name: DeclIdentElem;
+    typeRef: TypeRefElem;
+}
+/** an attribute like '@compute' or '@binding(0)' */
+export interface AttributeElem extends ElemWithContentsBase {
+    kind: "attribute";
+    attribute: Attribute;
+}
+export type Attribute = StandardAttribute | InterpolateAttribute | BuiltinAttribute | DiagnosticAttribute | IfAttribute;
+export interface StandardAttribute {
+    kind: "@attribute";
+    name: string;
+    params?: UnknownExpressionElem[];
+}
+export interface InterpolateAttribute {
+    kind: "@interpolate";
+    params: NameElem[];
+}
+export interface BuiltinAttribute {
+    kind: "@builtin";
+    param: NameElem;
+}
+export interface DiagnosticAttribute {
+    kind: "@diagnostic";
+    severity: NameElem;
+    rule: [NameElem, NameElem | null];
+}
+export interface IfAttribute {
+    kind: "@if";
+    param: TranslateTimeExpressionElem;
+}
+/** a const_assert statement */
+export interface ConstAssertElem extends ElemWithContentsBase, HasAttributes {
+    kind: "assert";
+}
+/** a const declaration */
+export interface ConstElem extends ElemWithContentsBase, HasAttributes {
+    kind: "const";
+    name: TypedDeclElem;
+}
+/** an expression w/o special handling, used inside attribute parameters */
+export interface UnknownExpressionElem extends ElemWithContentsBase {
+    kind: "expression";
+}
+/** an expression that can be safely evaluated at compile time */
+export interface TranslateTimeExpressionElem {
+    kind: "translate-time-expression";
+    expression: ExpressionElem;
+    span: Span;
+}
+/** A literal value in WESL source. A boolean or a number. */
+export interface Literal {
+    kind: "literal";
+    value: string;
+    span: Span;
+}
+/** `words`s inside `@if` */
+export interface TranslateTimeFeature {
+    kind: "translate-time-feature";
+    name: string;
+    span: Span;
+}
+/** (expr) */
+export interface ParenthesizedExpression {
+    kind: "parenthesized-expression";
+    expression: ExpressionElem;
+}
+/** `foo[expr]` */
+export interface ComponentExpression {
+    kind: "component-expression";
+    base: ExpressionElem;
+    access: ExpressionElem;
+}
+/** `foo.member` */
+export interface ComponentMemberExpression {
+    kind: "component-member-expression";
+    base: ExpressionElem;
+    access: NameElem;
+}
+/** `+foo` */
+export interface UnaryExpression {
+    kind: "unary-expression";
+    operator: UnaryOperator;
+    expression: ExpressionElem;
+}
+/** `foo + bar` */
+export interface BinaryExpression {
+    kind: "binary-expression";
+    operator: BinaryOperator;
+    left: ExpressionElem;
+    right: ExpressionElem;
+}
+/** `foo(arg, arg)` */
+export interface FunctionCallExpression {
+    kind: "call-expression";
+    function: RefIdentElem;
+    arguments: ExpressionElem[];
+}
+export interface UnaryOperator {
+    value: "!" | "&" | "*" | "-" | "~";
+    span: Span;
+}
+export interface BinaryOperator {
+    value: ("||" | "&&" | "+" | "-" | "*" | "/" | "%" | "==") | ("!=" | "<" | "<=" | ">" | ">=" | "|" | "&" | "^") | ("<<" | ">>");
+    span: Span;
+}
+export type DirectiveVariant = DiagnosticDirective | EnableDirective | RequiresDirective;
+export interface DirectiveElem extends AbstractElemBase, HasAttributes {
+    kind: "directive";
+    directive: DirectiveVariant;
+}
+export interface DiagnosticDirective {
+    kind: "diagnostic";
+    severity: NameElem;
+    rule: [NameElem, NameElem | null];
+}
+export interface EnableDirective {
+    kind: "enable";
+    extensions: NameElem[];
+}
+export interface RequiresDirective {
+    kind: "requires";
+    extensions: NameElem[];
+}
+/** a function declaration */
+export interface FnElem extends ElemWithContentsBase, HasAttributes {
+    kind: "fn";
+    name: DeclIdentElem;
+    params: FnParamElem[];
+    body: StatementElem;
+    returnAttributes?: AttributeElem[];
+    returnType?: TypeRefElem;
+}
+/** a global variable declaration (at the root level) */
+export interface GlobalVarElem extends ElemWithContentsBase, HasAttributes {
+    kind: "gvar";
+    name: TypedDeclElem;
+}
+/** an entire file */
+export interface ModuleElem extends ElemWithContentsBase {
+    kind: "module";
+}
+/** an override declaration */
+export interface OverrideElem extends ElemWithContentsBase, HasAttributes {
+    kind: "override";
+    name: TypedDeclElem;
+}
+/** a parameter in a function declaration */
+export interface FnParamElem extends ElemWithContentsBase, HasAttributes {
+    kind: "param";
+    name: TypedDeclElem;
+}
+/** simple references to structures, like myStruct.bar
+ * (used for transforming refs to binding structs) */
+export interface SimpleMemberRef extends ElemWithContentsBase {
+    kind: "memberRef";
+    name: RefIdentElem;
+    member: NameElem;
+    extraComponents?: StuffElem;
+}
+/** a struct declaration */
+export interface StructElem extends ElemWithContentsBase, HasAttributes {
+    kind: "struct";
+    name: DeclIdentElem;
+    members: StructMemberElem[];
+    bindingStruct?: true;
+}
+/** generic container of other elements */
+export interface StuffElem extends ElemWithContentsBase {
+    kind: "stuff";
+}
+/** a struct declaration that's been marked as a bindingStruct */
+export interface BindingStructElem extends StructElem {
+    bindingStruct: true;
+    entryFn?: FnElem;
+}
+/** a member of a struct declaration */
+export interface StructMemberElem extends ElemWithContentsBase, HasAttributes {
+    kind: "member";
+    name: NameElem;
+    typeRef: TypeRefElem;
+    mangledVarName?: string;
+}
+export type TypeTemplateParameter = TypeRefElem | UnknownExpressionElem;
+/** a reference to a type, like 'f32', or 'MyStruct', or 'ptr<storage, array<f32>, read_only>'   */
+export interface TypeRefElem extends ElemWithContentsBase {
+    kind: "type";
+    name: RefIdent;
+    templateParams?: TypeTemplateParameter[];
+}
+/** a variable declaration */
+export interface VarElem extends ElemWithContentsBase, HasAttributes {
+    kind: "var";
+    name: TypedDeclElem;
+}
+export interface LetElem extends ElemWithContentsBase, HasAttributes {
+    kind: "let";
+    name: TypedDeclElem;
+}
+export interface StatementElem extends ElemWithContentsBase, HasAttributes {
+    kind: "statement";
+}
+export interface SwitchClauseElem extends ElemWithContentsBase, HasAttributes {
+    kind: "switch-clause";
+}

package/dist/tools/packages/wesl/src/Assertions.d.ts

@@ -0,0 +1,27 @@
+/** checks whether a condition is true, otherwise throws */
+export declare function assertThat(condition: any, msg?: string): asserts condition;
+/** when debug testing is enabled, checks whether a condition is true, otherwise throws */
+export declare function assertThatDebug(condition: any, msg?: string): asserts condition;
+/** when debug testing is enabled throw an error */
+export declare function failDebug(msg?: string): void;
+/**
+ * Typescript will complain at compile time if it thinks this could be executed.
+ * Useful to validate that all cases are handled.
+ *
+ * Does nothing at runtime.
+ */
+export declare function assertUnreachableSilent(_value: never): void;
+/**
+ * Useful to validate that all cases are handled,
+ * TypeScript should complain if this statement could possibly be executed.
+ *
+ * If this is somehow executed at runtime, throw an exception.
+ */
+export declare function assertUnreachable(value: never): never;
+export interface ErrorWithDataOptions extends ErrorOptions {
+    data: any;
+}
+export declare class ErrorWithData extends Error {
+    data: any;
+    constructor(message?: string, options?: ErrorWithDataOptions);
+}

package/dist/tools/packages/wesl/src/BindIdents.d.ts

@@ -0,0 +1,70 @@
+import { AbstractElem } from './AbstractElems.ts';
+import { LinkRegistryParams, VirtualLibraryFn } from './Linker.ts';
+import { WeslAST } from './ParseWESL.ts';
+import { Conditions, DeclIdent, Scope, SrcModule } from './Scope.ts';
+/**
+  BindIdents pass
+
+  Goals:
+  - link references identifiers to their declaration identifiers.
+  - produce a list of declarations that are used (and need to be emitted in the link)
+  - create mangled names for global declarations (to avoid name conflicts)
+
+  BindIdents proceeds as a recursive tree walk of the scope tree, starting from the root module (e.g. main.wesl).
+  It traverses the scope tree depth first (and not the syntax tree).
+  - For each ref ident, search prior declarations in the current scope, then
+    up the scope tree to find a matching declaration
+  - If no local match is found, check for partial matches with import statements
+    - combine the ident with import statement to match a decl in an exporting module
+  - As global declaration identifies are found, also:
+     - mutate their mangled name to be globally unique.
+     - collect the declarations (they will be emitted)
+  
+  When iterating through the idents inside a scope, we maintain a parallel data structure of
+  'liveDecls', the declarations that are visible in the current scope at the currently
+  processed ident, along with a link to parent liveDecls for their current decl visibility.
+*/
+/** results returned from binding pass */
+export interface BindResults {
+    /** root level names (including names mangled due to conflict with earlier names) */
+    globalNames: Set<string>;
+    /** global declarations that were referenced (these will need to be emitted in the link) */
+    decls: DeclIdent[];
+    /** additional global statements to include in linked results
+     * (e.g. for adding module level const_assert statements) */
+    newStatements: EmittableElem[];
+}
+/** an element that can be directly emitted into the linked result */
+export interface EmittableElem {
+    srcModule: SrcModule;
+    elem: AbstractElem;
+}
+/** virtual package, generated by code generation function. */
+export interface VirtualLibrary {
+    /** function to generate the module */
+    fn: VirtualLibraryFn;
+    /** parsed AST for the module (constructed lazily) */
+    ast?: WeslAST;
+}
+/** key is virtual module name */
+export type VirtualLibrarySet = Record<string, VirtualLibrary>;
+export interface BindIdentsParams extends Pick<LinkRegistryParams, "registry" | "conditions" | "mangler"> {
+    rootAst: WeslAST;
+    virtuals?: VirtualLibrarySet;
+}
+/**
+ * Bind active reference idents to declaration Idents by mutating the refersTo: field
+ * Also in this pass, set the mangledName: field for all active global declaration idents.
+ *
+ * @param parsed
+ * @param conditions  only bind to/from idents that are valid with the current condition set
+ * @return any new declaration elements found (they will need to be emitted)
+ */
+export declare function bindIdents(params: BindIdentsParams): BindResults;
+/**
+ * @return the list of conditional valid declarations at the root level
+ * decls are either in the root scope or in a conditionally valid partial scope
+ */
+export declare function findValidRootDecls(rootScope: Scope, conditions: Conditions): DeclIdent[];
+/** @return true if this decl is at the root scope level of a module */
+export declare function isGlobal(declIdent: DeclIdent): boolean;

package/dist/tools/packages/wesl/src/Conditions.d.ts

@@ -0,0 +1,6 @@
+import { ElemWithAttributes } from './AbstractElems.ts';
+import { Conditions, Scope } from './Scope.ts';
+/** @return true if the element is valid under current Conditions */
+export declare function elementValid(elem: ElemWithAttributes, conditions: Conditions): boolean;
+/** @return true if the scope is valid under current conditions */
+export declare function scopeValid(scope: Scope, conditions: Conditions): boolean;

package/dist/tools/packages/wesl/src/FlattenTreeImport.d.ts

@@ -0,0 +1,11 @@
+import { ImportStatement } from './AbstractElems';
+export interface FlatImport {
+    importPath: string[];
+    modulePath: string[];
+}
+/**
+ * Simplify importTree into a flattened map from import paths to module paths.
+ *
+ * @return map from import path (with 'as' renaming) to module Path
+ */
+export declare function flattenTreeImport(imp: ImportStatement): FlatImport[];

package/dist/tools/packages/wesl/src/LinkedWesl.d.ts

@@ -0,0 +1,50 @@
+import { SrcMap } from '../../mini-parse/src';
+import { WeslDevice } from './WeslDevice';
+/** Results of shader compilation. Has {@link WeslGPUCompilationMessage}
+ * which are aware of the WESL module that an error was thrown from. */
+export interface WeslGPUCompilationInfo extends GPUCompilationInfo {
+    messages: WeslGPUCompilationMessage[];
+}
+export interface WeslGPUCompilationMessage extends GPUCompilationMessage {
+    module: {
+        url: string;
+        text?: string;
+    };
+}
+/**
+ * A {@link GPUValidationError} with an inner error (for a stack trace).
+ * Can also point at a WESL source file.
+ */
+export interface ExtendedGPUValidationError extends GPUValidationError {
+    cause?: Error;
+    compilationInfo?: WeslGPUCompilationInfo;
+}
+/**
+ * Multiple WESL files that have been linked together to produce WGSL code.
+ *
+ * Call {@link LinkedWesl.createShaderModule} on a {@link WeslDevice}
+ * to make the error reporting aware of the WESL code.
+ */
+export declare class LinkedWesl {
+    sourceMap: SrcMap;
+    constructor(sourceMap: SrcMap);
+    /**
+     * Creates a {@link GPUShaderModule}.
+     * When errors occur, they will point at the original WESL source code.
+     *
+     * The compilation info {@link GPUShaderModule.getCompilationInfo}
+     * can be remapped with {@link mapGPUCompilationInfo}
+     * @param device GPUDevice. Preferably a {@link WeslDevice} for better error reporting.
+     * @param descriptor - Description of the {@link GPUShaderModule} to create.
+     */
+    createShaderModule(device: GPUDevice | WeslDevice, descriptor: Omit<GPUShaderModuleDescriptor, "code">): GPUShaderModule;
+    /**
+     * Use {@link LinkedWesl.createShaderModule} for a
+     * better error reporting experience.
+     */
+    get dest(): string;
+    /** Turns raw compilation info into compilation info
+     * that points at the WESL sources. */
+    mapGPUCompilationInfo(compilationInfo: GPUCompilationInfo): WeslGPUCompilationInfo;
+    private mapGPUCompilationMessage;
+}

package/dist/tools/packages/wesl/src/Linker.d.ts

@@ -0,0 +1,87 @@
+import { SrcMap } from '../../mini-parse/src';
+import { AbstractElem } from './AbstractElems.ts';
+import { EmittableElem } from './BindIdents.ts';
+import { LinkedWesl } from './LinkedWesl.ts';
+import { ManglerFn } from './Mangler.ts';
+import { ParsedRegistry } from './ParsedRegistry.ts';
+import { WeslAST } from './ParseWESL.ts';
+import { Conditions, DeclIdent } from './Scope.ts';
+import { WeslBundle } from './WeslBundle.ts';
+type LinkerTransform = (boundAST: TransformedAST) => TransformedAST;
+export interface WeslJsPlugin {
+    transform?: LinkerTransform;
+}
+export interface TransformedAST extends Pick<WeslAST, "srcModule" | "moduleElem"> {
+    globalNames: Set<string>;
+    notableElems: Record<string, AbstractElem[]>;
+}
+export interface LinkConfig {
+    plugins?: WeslJsPlugin[];
+}
+export interface LinkParams {
+    /** record of file paths and wesl text for modules.
+     *   key is module path or file path
+     *     `package::foo::bar`, or './foo/bar.wesl', or './foo/bar'
+     *   value is wesl src
+     *
+     *
+     * Only accepts unix-style, relative filesystem paths that are valid WGSL identifiers
+     * - Unix-style: Slashes as separators.
+     * - Valid WGSL identifiers: No backslashes, no `..`, or other non-identifier symbols.
+     * - Relative paths: They have to be relative to the wesl root.
+     */
+    weslSrc: Record<string, string>;
+    /** name of root wesl module
+     *    for an app, the root module normally contains the '@compute', '@vertex' or '@fragment' entry points
+     *    for a library, the root module defines the public api fo the library
+     *  can be specified as file path (./main.wesl), a module path (package::main), or just a module name (main)
+     */
+    rootModuleName?: string;
+    /** For debug logging. Will be prepended to file paths. */
+    debugWeslRoot?: string;
+    /** runtime conditions for conditional compiling with @if and friends */
+    conditions?: Conditions;
+    /** libraries available for the link */
+    libs?: WeslBundle[];
+    /** generate wesl from code at runtime */
+    virtualLibs?: Record<string, VirtualLibraryFn>;
+    /** plugins and other configuration to use while linking */
+    config?: LinkConfig;
+    /** Host (ts/js) provided wgsl constants.
+     * Users can import the values from wesl code via the `constants' virtual library:
+     *  `import constants::num_lights;` */
+    constants?: Record<string, string | number>;
+    /** function to construct globally unique wgsl identifiers */
+    mangler?: ManglerFn;
+}
+/** Generate a virtual WESL module based on a set of conditions. */
+export type VirtualLibraryFn = (conditions: Conditions) => string;
+/**
+ * Link a set of WESL source modules (typically the text from .wesl files) into a single WGSL string.
+ * Linking starts with a specified 'root' source module, and recursively incorporates code
+ * referenced from other modules (in local files or libraries).
+ *
+ * Unreferenced (dead) code outside the root module is not included in the output WGSL.
+ * Additionally the caller can specify conditions for to control conditional compilation.
+ * Only code that is valid with the current conditions is included in the output.
+ */
+export declare function link(params: LinkParams): Promise<LinkedWesl>;
+export interface LinkRegistryParams extends Pick<LinkParams, "rootModuleName" | "conditions" | "virtualLibs" | "config" | "constants" | "mangler"> {
+    registry: ParsedRegistry;
+}
+/** Link wesl from a registry of already parsed modules.
+ *
+ * This entry point is intended for users who want to link multiple times
+ * from the same sources. (e.g. linking with different conditions
+ * each time, or perhaps to produce multiple wgsl shaders
+ * that share some sources.)
+ */
+export declare function linkRegistry(params: LinkRegistryParams): SrcMap;
+export interface BoundAndTransformed {
+    transformedAst: TransformedAST;
+    newDecls: DeclIdent[];
+    newStatements: EmittableElem[];
+}
+/** bind identifers and apply any transform plugins */
+export declare function bindAndTransform(params: LinkRegistryParams): BoundAndTransformed;
+export {};

package/dist/tools/packages/wesl/src/LinkerUtil.d.ts

@@ -0,0 +1,3 @@
+import { AbstractElem, DeclIdentElem, RefIdentElem } from './AbstractElems.ts';
+export declare function visitAst(elem: AbstractElem, visitor: (elem: AbstractElem) => void): void;
+export declare function identElemLog(identElem: DeclIdentElem | RefIdentElem, ...messages: any[]): void;

package/dist/tools/packages/wesl/src/LiveDeclarations.d.ts

@@ -0,0 +1,12 @@
+import { DeclIdent } from './Scope.ts';
+/** decls currently visible in this scope */
+export interface LiveDecls {
+    /** decls currently visible in this scope */
+    decls: Map<string, DeclIdent>;
+    /** live decls in the parent scope. null for the modue root scope */
+    parent?: LiveDecls | null;
+}
+/** create a LiveDecls */
+export declare function makeLiveDecls(parent?: LiveDecls | null): LiveDecls;
+/** debug routine for logging LiveDecls */
+export declare function liveDeclsToString(liveDecls: LiveDecls): string;

package/dist/tools/packages/wesl/src/LowerAndEmit.d.ts

@@ -0,0 +1,31 @@
+import { SrcMapBuilder } from '../../mini-parse/src';
+import { AbstractElem, ContainerElem, DeclIdentElem, ExpressionElem, FnElem, NameElem, RefIdentElem, StructElem, SyntheticElem, TextElem } from './AbstractElems.ts';
+import { Conditions, DeclIdent, Ident } from './Scope.ts';
+/** passed to the emitters */
+interface EmitContext {
+    srcBuilder: SrcMapBuilder;
+    conditions: Conditions;
+    extracting: boolean;
+}
+/** traverse the AST, starting from root elements, emitting wgsl for each */
+export declare function lowerAndEmit(srcBuilder: SrcMapBuilder, rootElems: AbstractElem[], conditions: Conditions, extracting?: boolean): void;
+export declare function lowerAndEmitElem(e: AbstractElem, ctx: EmitContext): void;
+export declare function emitText(e: TextElem, ctx: EmitContext): void;
+export declare function emitName(e: NameElem, ctx: EmitContext): void;
+/** emit function explicitly so we can control commas between conditional parameters */
+export declare function emitFn(e: FnElem, ctx: EmitContext): void;
+/** emit structs explicitly so we can control commas between conditional members */
+export declare function emitStruct(e: StructElem, ctx: EmitContext): void;
+export declare function emitSynthetic(e: SyntheticElem, ctx: EmitContext): void;
+export declare function emitContents(elem: ContainerElem, ctx: EmitContext): void;
+export declare function emitRefIdent(e: RefIdentElem, ctx: EmitContext): void;
+export declare function emitDeclIdent(e: DeclIdentElem, ctx: EmitContext): void;
+export declare function diagnosticControlToString(severity: NameElem, rule: [NameElem, NameElem | null]): string;
+export declare function expressionToString(elem: ExpressionElem): string;
+/** trace through refersTo links in reference Idents until we find the declaration
+ * expects that bindIdents has filled in all refersTo: links
+ */
+export declare function findDecl(ident: Ident): DeclIdent;
+/** check if the element is visible with the current current conditional compilation settings */
+export declare function conditionsValid(elem: AbstractElem, conditions: Conditions): true | false | undefined;
+export {};

package/dist/tools/packages/wesl/src/Mangler.d.ts

@@ -0,0 +1,39 @@
+import { DeclIdent, SrcModule } from './Scope.ts';
+/**
+ * A function for constructing a unique identifier name for a global declaration.
+ * Global names must be unique in the linked wgsl.
+ *
+ * Three manglers are currently available:
+ * . minimalMangle preserves original source names where possible
+ * . underscoreMangle constructs long but predictable names for every declaration
+ * . lengthPrefixMangle constructs long but predictable names for every declaration
+ */
+export type ManglerFn = (
+/** global declaration that needs a name */
+decl: DeclIdent, 
+/** module that contains the declaration */
+srcModule: SrcModule, 
+/** name at use site (possibly import as renamed from declaration) */
+proposedName: string, 
+/** current set of mangled root level names for the linked result (read only) */
+globalNames: Set<string>) => string;
+/**
+ * Construct a globally unique name based on the declaration
+ * module path separated by underscores.
+ * Corresponds to "Underscore-count mangling" from [NameMangling.md](https://github.com/wgsl-tooling-wg/wesl-spec/blob/main/NameMangling.md)
+ */
+export declare function underscoreMangle(decl: DeclIdent, srcModule: SrcModule): string;
+/**
+ * Construct a globally unique name based on the declaration
+ */
+export declare function lengthPrefixMangle(decl: DeclIdent, srcModule: SrcModule): string;
+/**
+ * ManglerFn to construct a globally unique name
+ * using the requested name plus a uniquing number suffix if necessary
+ */
+export declare function minimalMangle(_d: DeclIdent, _s: SrcModule, proposedName: string, globalNames: Set<string>): string;
+/**
+ * Construct a globally unique name by using the requested name if possible
+ * and appending a number suffix necessary
+ */
+export declare function minimallyMangledName(proposedName: string, globalNames: Set<string>): string;