@u84u/gl 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1723 @@
+import { S as SourceResolver } from './resolver-Fn4_IKEu.js';
+export { M as MemorySourceResolver, a as SourceModule } from './resolver-Fn4_IKEu.js';
+
+type TokenKind = "Fn" | "Struct" | "Return" | "If" | "Else" | "True" | "False" | "Let" | "Mut" | "Binding" | "Uniform" | "Import" | "Ident" | "Int" | "Float" | "String" | "Char" | "Color" | "LParen" | "RParen" | "LBrace" | "RBrace" | "LBracket" | "RBracket" | "Comma" | "Dot" | "Colon" | "Semicolon" | "Question" | "Assign" | "PlusEq" | "MinusEq" | "StarEq" | "SlashEq" | "PercentEq" | "AmpEq" | "PipeEq" | "CaretEq" | "LtLtEq" | "GtGtEq" | "Plus" | "Minus" | "Star" | "Slash" | "Percent" | "PlusPlus" | "MinusMinus" | "Eq" | "Neq" | "Lt" | "Gt" | "Lte" | "Gte" | "LtLt" | "GtGt" | "Spaceship" | "Range" | "And" | "Or" | "Not" | "Amp" | "Pipe" | "Caret" | "Tilde" | "NullCoalescing" | "Arrow" | "In" | "Opaque" | "Self" | "Ref" | "Deref" | "EOF" | "Illegal" | "While" | "For" | "Do" | "Loop" | "Break" | "Continue" | "Match" | "Panic" | "Unreachable" | "Discard" | "Kill" | "Enum" | "Impl" | "Trait" | "Type";
+interface Token {
+    kind: TokenKind;
+    lexeme: string;
+    line: number;
+    column: number;
+}
+declare function tokenize(source: string): Token[];
+
+type ScalarTypeName = "i8" | "u8" | "i16" | "u16" | "i32" | "u32" | "i64" | "u64" | "f16" | "f32" | "f64" | "bf16" | "bool";
+type ShaderStage = "vertex" | "fragment" | "compute";
+type ShaderTarget = "wgsl" | "glsl-es-300" | "glsl-450" | "glsl" | (string & {});
+type ResourceKind = "uniformBuffer" | "storageBuffer" | "sampledTexture" | "storageTexture" | "sampler";
+interface BackendCapabilities {
+    readonly id: string;
+    readonly version: string;
+    readonly shaderStages: ReadonlySet<ShaderStage>;
+    readonly scalarTypes: ReadonlySet<ScalarTypeName>;
+    readonly resourceKinds: ReadonlySet<ResourceKind>;
+    readonly supportsStorageBuffers: boolean;
+    readonly supportsCompute: boolean;
+    readonly supportsF16: boolean;
+    readonly supportsF64: boolean;
+    readonly supportsI64: boolean;
+}
+declare const WGSL_CAPABILITIES: BackendCapabilities;
+declare const GLSL_ES_300_CAPABILITIES: BackendCapabilities;
+declare const GLSL_450_CAPABILITIES: BackendCapabilities;
+declare function capabilitiesFor(target: ShaderTarget): BackendCapabilities;
+declare function scalarIsSupported(capabilities: BackendCapabilities, name: ScalarTypeName): boolean;
+
+type Span = {
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+};
+type LiteralKind = "int" | "float" | "bool" | "char" | "color";
+interface LiteralValueMap {
+    "int": number;
+    "float": number;
+    "bool": boolean;
+    "char": string;
+    "color": string;
+}
+interface LiteralBase<K extends LiteralKind> {
+    kind: "Literal";
+    literalKind: K;
+    value: LiteralValueMap[K];
+    span: Span;
+}
+type Literal = LiteralBase<LiteralKind>;
+type PatternKind = "wildcard" | "binding" | "literal" | "struct" | "tuple" | "array" | "ref" | "deref";
+interface PatternBase<K extends PatternKind> {
+    kind: K;
+    span: Span;
+}
+interface WildcardPattern extends PatternBase<"wildcard"> {
+}
+interface BindingPattern extends PatternBase<"binding"> {
+    binding: string;
+}
+interface LiteralPattern extends PatternBase<"literal"> {
+    value: number | string | boolean;
+}
+interface StructPattern extends PatternBase<"struct"> {
+    subPatterns: Pattern[];
+}
+interface TuplePattern extends PatternBase<"tuple"> {
+    subPatterns: Pattern[];
+}
+interface ArrayPattern extends PatternBase<"array"> {
+    subPatterns: Pattern[];
+}
+interface RefPattern extends PatternBase<"ref"> {
+    subPatterns: Pattern[];
+}
+interface DerefPattern extends PatternBase<"deref"> {
+    subPatterns: Pattern[];
+}
+type Pattern = WildcardPattern | BindingPattern | LiteralPattern | StructPattern | TuplePattern | ArrayPattern | RefPattern | DerefPattern;
+type Type = {
+    kind: "abstractInt";
+} | {
+    kind: "abstractFloat";
+} | {
+    kind: "scalar";
+    name: "i8" | "u8" | "i16" | "u16" | "i32" | "u32" | "i64" | "u64" | "f16" | "f32" | "f64" | "bf16" | "bool";
+} | {
+    kind: "vector";
+    element: "i8" | "u8" | "i16" | "u16" | "i32" | "u32" | "i64" | "u64" | "f16" | "f32" | "f64" | "bf16" | "bool";
+    size: 2 | 3 | 4;
+} | {
+    kind: "matrix";
+    element: "i8" | "u8" | "i16" | "u16" | "i32" | "u32" | "i64" | "u64" | "f16" | "f32" | "f64" | "bf16" | "bool";
+    rows: 2 | 3 | 4;
+    columns: 2 | 3 | 4;
+} | {
+    kind: "quaternion";
+} | {
+    kind: "struct";
+    name: string;
+} | {
+    kind: "enum";
+    name: string;
+} | {
+    kind: "sampler";
+    name: "sampler2D" | "sampler3D" | "samplerCube" | "sampler2DArray" | "samplerCubeArray" | "sampler2DShadow" | "samplerCubeShadow" | "samplerBuffer";
+} | {
+    kind: "array";
+    element: Type;
+    size: number;
+} | {
+    kind: "tuple";
+    elements: Type[];
+} | {
+    kind: "option";
+    element: Type;
+} | {
+    kind: "result";
+    ok: Type;
+    err: Type;
+} | {
+    kind: "alias";
+    name: string;
+} | {
+    kind: "opaque";
+    name: string;
+} | {
+    kind: "anonymousStruct";
+    fields: Field[];
+} | {
+    kind: "union";
+    members: Type[];
+};
+interface Field {
+    name: string;
+    type: Type;
+}
+interface Param {
+    name: string;
+    type: Type;
+}
+interface StructDecl {
+    kind: "StructDecl";
+    name: string;
+    fields: Field[];
+    span: Span;
+}
+interface EnumDecl {
+    kind: "EnumDecl";
+    name: string;
+    variants: {
+        name: string;
+        type: Type | null;
+        span?: Span;
+    }[];
+    span: Span;
+}
+interface ImplBlock {
+    kind: "ImplBlock";
+    trait: string | null;
+    type: Type;
+    methods: FnDecl[];
+    span: Span;
+}
+interface TraitDecl {
+    kind: "TraitDecl";
+    name: string;
+    bounds: string[];
+    methods: {
+        name: string;
+        params: Param[];
+        returnType: Type;
+    }[];
+    span: Span;
+}
+interface TypeAlias {
+    kind: "TypeAlias";
+    name: string;
+    type: Type;
+    span: Span;
+}
+interface NewtypeDecl {
+    kind: "NewtypeDecl";
+    name: string;
+    innerType: Type;
+    span: Span;
+}
+interface OpaqueDecl {
+    kind: "OpaqueDecl";
+    name: string;
+    span: Span;
+}
+interface FnDecl {
+    kind: "FnDecl";
+    name: string;
+    params: Param[];
+    returnType: Type;
+    body: Block;
+    stage?: ShaderStage;
+    span: Span;
+}
+interface VarDecl {
+    kind: "VarDecl";
+    name: string;
+    type: Type;
+    initializer: Expression | null;
+    mutable: boolean;
+    span: Span;
+}
+interface ReturnStmt {
+    kind: "ReturnStmt";
+    value: Expression | null;
+    span: Span;
+}
+interface ExpressionStmt {
+    kind: "ExpressionStmt";
+    expression: Expression;
+    span: Span;
+}
+interface Block {
+    kind: "Block";
+    statements: Statement[];
+    span: Span;
+}
+interface IfStmt {
+    kind: "IfStmt";
+    condition: Expression;
+    thenBranch: Block;
+    elseBranch: Block | null;
+    span: Span;
+}
+interface WhileStmt {
+    kind: "WhileStmt";
+    condition: Expression;
+    body: Block;
+    span: Span;
+}
+interface ForStmt {
+    kind: "ForStmt";
+    init: VarDecl | ExpressionStmt | null;
+    condition: Expression | null;
+    increment: Expression | null;
+    range: {
+        variable: string;
+        start: Expression;
+        end: Expression;
+        inclusive: boolean;
+        span?: Span;
+    } | null;
+    body: Block;
+    span: Span;
+}
+interface DoWhileStmt {
+    kind: "DoWhileStmt";
+    body: Block;
+    condition: Expression;
+    span: Span;
+}
+interface LoopStmt {
+    kind: "LoopStmt";
+    body: Block;
+    label: string | null;
+    span: Span;
+}
+interface BreakStmt {
+    kind: "BreakStmt";
+    label: string | null;
+    span: Span;
+}
+interface ContinueStmt {
+    kind: "ContinueStmt";
+    label: string | null;
+    span: Span;
+}
+interface MatchArm {
+    pattern: Pattern;
+    guard: Expression | null;
+    body: Block;
+    span: Span;
+}
+interface MatchExpr {
+    kind: "MatchExpr";
+    subject: Expression;
+    arms: MatchArm[];
+    span: Span;
+}
+interface PanicStmt {
+    kind: "PanicStmt";
+    message: Expression | null;
+    span: Span;
+}
+interface UnreachableStmt {
+    kind: "UnreachableStmt";
+    span: Span;
+}
+interface DiscardStmt {
+    kind: "DiscardStmt";
+    span: Span;
+}
+interface BindingDecl {
+    kind: "BindingDecl";
+    binding: number;
+    name: string;
+    type: Type;
+    span: Span;
+}
+interface ImportDecl {
+    kind: "ImportDecl";
+    path: string;
+    span: Span;
+}
+interface Identifier {
+    kind: "Identifier";
+    name: string;
+    span: Span;
+}
+interface BinaryExpr {
+    kind: "BinaryExpr";
+    left: Expression;
+    operator: string;
+    right: Expression;
+    span: Span;
+}
+interface UnaryExpr {
+    kind: "UnaryExpr";
+    operator: string;
+    operand: Expression;
+    span: Span;
+}
+interface CallExpr {
+    kind: "CallExpr";
+    callee: Expression;
+    args: Expression[];
+    span: Span;
+}
+interface MemberExpr {
+    kind: "MemberExpr";
+    object: Expression;
+    property: string;
+    span: Span;
+}
+interface SwizzleExpr {
+    kind: "SwizzleExpr";
+    object: Expression;
+    components: string[];
+    span: Span;
+}
+interface IndexExpr {
+    kind: "IndexExpr";
+    object: Expression;
+    index: Expression;
+    span: Span;
+}
+interface StructLiteral {
+    kind: "StructLiteral";
+    typeName: string;
+    fields: {
+        name: string | null;
+        value: Expression;
+    }[];
+    span: Span;
+}
+interface ArrayLiteral {
+    kind: "ArrayLiteral";
+    elements: Expression[];
+    span: Span;
+}
+interface CompoundAssignExpr {
+    kind: "CompoundAssignExpr";
+    operator: "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=";
+    target: Expression;
+    value: Expression;
+    span: Span;
+}
+interface UpdateExpr {
+    kind: "UpdateExpr";
+    operator: "++" | "--";
+    operand: Expression;
+    prefix: boolean;
+    span: Span;
+}
+interface ConditionalExpr {
+    kind: "ConditionalExpr";
+    test: Expression;
+    consequent: Expression;
+    alternate: Expression;
+    span: Span;
+}
+interface NullCoalescingExpr {
+    kind: "NullCoalescingExpr";
+    left: Expression;
+    right: Expression;
+    span: Span;
+}
+interface BlockExpr {
+    kind: "BlockExpr";
+    block: Block;
+    span: Span;
+}
+type Statement = StructDecl | EnumDecl | ImplBlock | TraitDecl | TypeAlias | NewtypeDecl | OpaqueDecl | FnDecl | VarDecl | ReturnStmt | ExpressionStmt | Block | IfStmt | WhileStmt | ForStmt | DoWhileStmt | LoopStmt | BreakStmt | ContinueStmt | PanicStmt | UnreachableStmt | DiscardStmt | BindingDecl | ImportDecl;
+type Expression = Identifier | Literal | BinaryExpr | UnaryExpr | CallExpr | MemberExpr | SwizzleExpr | IndexExpr | StructLiteral | ArrayLiteral | CompoundAssignExpr | UpdateExpr | ConditionalExpr | NullCoalescingExpr | MatchExpr | BlockExpr;
+interface Program {
+    kind: "Program";
+    statements: Statement[];
+    span: Span;
+}
+
+declare function parse(tokens: Token[]): Program;
+
+type DiagnosticSeverity = "error" | "warning" | "info" | "hint";
+interface Diagnostic {
+    file: string;
+    code?: string;
+    severity?: DiagnosticSeverity;
+    message: string;
+    span: Span;
+    related?: Diagnostic[];
+    help?: string;
+}
+/**
+ * Type-checks a parsed program and returns diagnostics.
+ *
+ * @param program - The parsed Program AST to type-check.
+ * @param file - The source file name (used in diagnostic messages).
+ * @returns An object containing the collected diagnostics.
+ */
+declare function typeCheck(program: Program, file: string, provenance?: Map<Statement, string>): {
+    diagnostics: Diagnostic[];
+};
+
+type IRScalarName = "i8" | "u8" | "i16" | "u16" | "i32" | "u32" | "i64" | "u64" | "f16" | "f32" | "f64" | "bf16" | "bool" | "abstractInt" | "abstractFloat";
+type IRStage = "vertex" | "fragment" | "compute";
+type IRResourceKind = "uniformBuffer" | "storageBuffer" | "sampledTexture" | "storageTexture" | "sampler";
+/**
+ * Source location used for diagnostics after lowering/raising.
+ */
+type IRSpan = {
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+};
+type IRType = IRScalar | IRVector | IRMatrix | IRArray | IRStructRef | IREnumRef | IRQuaternion | IRSampler | IRAlias | IROpaque | IRAnonymousStruct | IRUnion | IROption | IRResult | IRTuple;
+interface IRScalar {
+    kind: "scalar";
+    name: IRScalarName;
+    span?: IRSpan;
+}
+interface IRVector {
+    kind: "vector";
+    element: IRScalarName;
+    size: 2 | 3 | 4;
+    span?: IRSpan;
+}
+interface IRMatrix {
+    kind: "matrix";
+    element: IRScalarName;
+    rows: 2 | 3 | 4;
+    columns: 2 | 3 | 4;
+    span?: IRSpan;
+}
+interface IRArray {
+    kind: "array";
+    element: IRType;
+    size: number;
+    span?: IRSpan;
+}
+interface IRStructRef {
+    kind: "struct";
+    name: string;
+    span?: IRSpan;
+}
+interface IREnumRef {
+    kind: "enum";
+    name: string;
+    span?: IRSpan;
+}
+interface IRQuaternion {
+    kind: "quaternion";
+    span?: IRSpan;
+}
+interface IRSampler {
+    kind: "sampler";
+    name: string;
+    span?: IRSpan;
+}
+interface IRAlias {
+    kind: "alias";
+    name: string;
+    span?: IRSpan;
+}
+interface IROpaque {
+    kind: "opaque";
+    name: string;
+    span?: IRSpan;
+}
+interface IRAnonymousStruct {
+    kind: "anonymousStruct";
+    fields: IRField[];
+    span?: IRSpan;
+}
+interface IRUnion {
+    kind: "union";
+    members: IRType[];
+    span?: IRSpan;
+}
+interface IROption {
+    kind: "option";
+    element: IRType;
+    span?: IRSpan;
+}
+interface IRResult {
+    kind: "result";
+    ok: IRType;
+    err: IRType;
+    span?: IRSpan;
+}
+interface IRTuple {
+    kind: "tuple";
+    elements: IRType[];
+    span?: IRSpan;
+}
+interface IRField {
+    name: string;
+    type: IRType;
+    span?: IRSpan;
+}
+type IRParam = IRField;
+type IRLiteralKind = "int" | "float" | "bool" | "char" | "color";
+type IRExpression = IRLiteral | IRIdentifier | IRBinary | IRUnary | IRCall | IRMember | IRSwizzle | IRIndex | IRStructLiteral | IRArrayLiteral | IRCompoundAssign | IRUpdate | IRConditional | IRNullCoalescing | IRMatch | IRBlockExpr;
+interface IRLiteral {
+    kind: "literal";
+    literalKind: IRLiteralKind;
+    value: string | number | boolean;
+    span?: IRSpan;
+}
+interface IRIdentifier {
+    kind: "identifier";
+    name: string;
+    span?: IRSpan;
+}
+interface IRBinary {
+    kind: "binary";
+    operator: string;
+    left: IRExpression;
+    right: IRExpression;
+    span?: IRSpan;
+}
+interface IRUnary {
+    kind: "unary";
+    operator: string;
+    operand: IRExpression;
+    span?: IRSpan;
+}
+interface IRCall {
+    kind: "call";
+    callee: IRExpression;
+    args: IRExpression[];
+    span?: IRSpan;
+}
+interface IRMember {
+    kind: "member";
+    object: IRExpression;
+    property: string;
+    span?: IRSpan;
+}
+interface IRSwizzle {
+    kind: "swizzle";
+    object: IRExpression;
+    components: string[];
+    span?: IRSpan;
+}
+interface IRIndex {
+    kind: "index";
+    object: IRExpression;
+    index: IRExpression;
+    span?: IRSpan;
+}
+interface IRStructLiteral {
+    kind: "structLiteral";
+    typeName: string;
+    fields: {
+        name: string | null;
+        value: IRExpression;
+    }[];
+    span?: IRSpan;
+}
+interface IRArrayLiteral {
+    kind: "arrayLiteral";
+    elements: IRExpression[];
+    span?: IRSpan;
+}
+interface IRCompoundAssign {
+    kind: "compoundAssign";
+    operator: string;
+    target: IRExpression;
+    value: IRExpression;
+    span?: IRSpan;
+}
+interface IRUpdate {
+    kind: "update";
+    operator: "++" | "--";
+    operand: IRExpression;
+    prefix: boolean;
+    span?: IRSpan;
+}
+interface IRConditional {
+    kind: "conditional";
+    test: IRExpression;
+    consequent: IRExpression;
+    alternate: IRExpression;
+    span?: IRSpan;
+}
+interface IRNullCoalescing {
+    kind: "nullCoalescing";
+    left: IRExpression;
+    right: IRExpression;
+    span?: IRSpan;
+}
+interface IRMatch {
+    kind: "match";
+    subject: IRExpression;
+    arms: IRMatchArm[];
+    span?: IRSpan;
+}
+interface IRMatchArm {
+    pattern: IRPattern;
+    guard: IRExpression | null;
+    body: IRBlock;
+    span?: IRSpan;
+}
+type IRPattern = IRLiteralPattern | IRBindingPattern | IRWildcardPattern;
+interface IRLiteralPattern {
+    kind: "literal";
+    value: string | number | boolean;
+    span?: IRSpan;
+}
+interface IRBindingPattern {
+    kind: "binding";
+    binding: string;
+    span?: IRSpan;
+}
+interface IRWildcardPattern {
+    kind: "wildcard";
+    span?: IRSpan;
+}
+interface IRBlockExpr {
+    kind: "blockExpr";
+    block: IRBlock;
+    span?: IRSpan;
+}
+type IRStatement = IRVarDecl | IRReturn | IRExpressionStmt | IRBlock | IRIf | IRWhile | IRFor | IRDoWhile | IRLoop | IRBreak | IRContinue | IRDiscard | IRPanic | IRUnreachable;
+interface IRVarDecl {
+    kind: "varDecl";
+    name: string;
+    type: IRType;
+    initializer: IRExpression | null;
+    mutable: boolean;
+    span?: IRSpan;
+}
+interface IRReturn {
+    kind: "return";
+    value: IRExpression | null;
+    span?: IRSpan;
+}
+interface IRExpressionStmt {
+    kind: "expressionStmt";
+    expression: IRExpression;
+    span?: IRSpan;
+}
+interface IRBlock {
+    kind: "block";
+    statements: IRModuleItem[];
+    span?: IRSpan;
+}
+interface IRIf {
+    kind: "if";
+    condition: IRExpression;
+    thenBranch: IRBlock;
+    elseBranch: IRBlock | null;
+    span?: IRSpan;
+}
+interface IRWhile {
+    kind: "while";
+    condition: IRExpression;
+    body: IRBlock;
+    span?: IRSpan;
+}
+interface IRFor {
+    kind: "for";
+    init: IRVarDecl | IRExpressionStmt | null;
+    condition: IRExpression | null;
+    increment: IRExpression | null;
+    range: IRForRange | null;
+    body: IRBlock;
+    span?: IRSpan;
+}
+interface IRForRange {
+    variable: string;
+    start: IRExpression;
+    end: IRExpression;
+    inclusive: boolean;
+    span?: IRSpan;
+}
+interface IRDoWhile {
+    kind: "doWhile";
+    body: IRBlock;
+    condition: IRExpression;
+    span?: IRSpan;
+}
+interface IRLoop {
+    kind: "loop";
+    body: IRBlock;
+    label: string | null;
+    span?: IRSpan;
+}
+interface IRBreak {
+    kind: "break";
+    label: string | null;
+    span?: IRSpan;
+}
+interface IRContinue {
+    kind: "continue";
+    label: string | null;
+    span?: IRSpan;
+}
+interface IRDiscard {
+    kind: "discard";
+    span?: IRSpan;
+}
+interface IRPanic {
+    kind: "panic";
+    message: IRExpression | null;
+    span?: IRSpan;
+}
+interface IRUnreachable {
+    kind: "unreachable";
+    span?: IRSpan;
+}
+interface IRStructDecl {
+    kind: "struct";
+    name: string;
+    fields: IRField[];
+    span?: IRSpan;
+}
+interface IRBindingDecl {
+    kind: "binding";
+    binding: number;
+    name: string;
+    type: IRType;
+    span?: IRSpan;
+}
+interface IREnumDecl {
+    kind: "enum";
+    name: string;
+    variants: {
+        name: string;
+        type: IRType | null;
+        span?: IRSpan;
+    }[];
+    span?: IRSpan;
+}
+interface IRFnDecl {
+    kind: "fn";
+    name: string;
+    stage: IRStage;
+    params: IRParam[];
+    returnType: IRType;
+    body: IRBlock;
+    span?: IRSpan;
+}
+interface IRTypeAlias {
+    kind: "typeAlias";
+    name: string;
+    type: IRType;
+    span?: IRSpan;
+}
+interface IRNewtypeDecl {
+    kind: "newtype";
+    name: string;
+    innerType: IRType;
+    span?: IRSpan;
+}
+interface IROpaqueDecl {
+    kind: "opaqueDecl";
+    name: string;
+    span?: IRSpan;
+}
+interface IRTraitDecl {
+    kind: "trait";
+    name: string;
+    bounds: string[];
+    methods: {
+        name: string;
+        params: IRParam[];
+        returnType: IRType;
+    }[];
+    span?: IRSpan;
+}
+interface IRImplBlock {
+    kind: "implBlock";
+    trait: string | null;
+    type: IRType;
+    methods: IRFnDecl[];
+    span?: IRSpan;
+}
+interface IREntryPoint {
+    stage: IRStage;
+    name: string;
+    fn: IRFnDecl;
+}
+interface IRSourceFile {
+    id: string;
+    displayName?: string;
+}
+interface IRSourceAttribution {
+    /** Canonical identity of the source module that declared this item. */
+    sourceFile?: string;
+}
+type IRModuleItem = (IRStructDecl | IREnumDecl | IRFnDecl | IRBindingDecl | IRTypeAlias | IRNewtypeDecl | IROpaqueDecl | IRTraitDecl | IRImplBlock | IRStatement) & IRSourceAttribution;
+interface IRModule {
+    items: IRModuleItem[];
+    functions: IRFnDecl[];
+    structs: IRStructDecl[];
+    enums: IREnumDecl[];
+    bindings: IRBindingDecl[];
+    typeAliases: IRTypeAlias[];
+    newtypes: IRNewtypeDecl[];
+    opaques: IROpaqueDecl[];
+    traits: IRTraitDecl[];
+    impls: IRImplBlock[];
+    entryPoints: IREntryPoint[];
+    sourceFiles: IRSourceFile[];
+    sourceId: string;
+    span?: IRSpan;
+}
+
+interface CodegenOptions {
+    /** Formatting style: "compact" or "pretty". Defaults to "pretty". */
+    format?: "compact" | "pretty";
+}
+interface ShaderArtifact {
+    stage: ShaderStage;
+    entryPoint: string;
+    code: string;
+    sourceMap?: ShaderSourceMap;
+    reflection: ShaderReflection;
+}
+interface ShaderSourceMap {
+    mappings: string;
+    sources: string[];
+    names: string[];
+}
+interface ShaderReflection {
+    entryPoints: ShaderEntryPointReflection[];
+    resources: ShaderResourceReflection[];
+    uniforms: ShaderUniformReflection[];
+}
+interface ShaderEntryPointReflection {
+    name: string;
+    stage: ShaderStage;
+    inputs: ShaderInterfaceVariable[];
+    outputs: ShaderInterfaceVariable[];
+}
+interface ShaderInterfaceVariable {
+    name: string;
+    type: string;
+    location?: number;
+    builtin?: string;
+}
+interface ShaderResourceReflection {
+    name: string;
+    kind: string;
+    binding: number;
+    set: number;
+    stageVisibility: ShaderStage[];
+}
+interface ShaderUniformReflection {
+    name: string;
+    type: string;
+    offset: number;
+    size: number;
+}
+interface BackendOutput {
+    target: ShaderTarget;
+    shaders: ShaderArtifact[];
+    diagnostics: Diagnostic[];
+}
+/**
+ * Contract for a shader code-generation backend. Each backend converts the
+ * lowered IR (raised to AST for compatibility) into target-specific shader
+ * source code, validates target capabilities, and reports structured
+ * diagnostics for unsupported constructs.
+ */
+interface ShaderCodegenBackend {
+    readonly id: string;
+    readonly version: string;
+    readonly capabilities: BackendCapabilities;
+    validate(module: IRModule, file: string): Diagnostic[];
+    generate(module: IRModule, file: string, options?: CodegenOptions): BackendOutput;
+}
+/**
+ * Global backend registry. Backends register themselves here; consumers look
+ * them up by target ID. Prevents duplicate registrations.
+ */
+declare class BackendRegistry {
+    private backends;
+    register(backend: ShaderCodegenBackend): void;
+    /** Replace an existing backend for a target. */
+    replace(backend: ShaderCodegenBackend): void;
+    get(id: string): ShaderCodegenBackend | undefined;
+    has(id: string): boolean;
+    ids(): string[];
+}
+declare function createDefaultBackendRegistry(): BackendRegistry;
+declare const defaultRegistry: BackendRegistry;
+declare function getBackend(id: ShaderTarget): ShaderCodegenBackend | undefined;
+
+/**
+ * Backward-compatible wrapper: lowers a Program AST to IR and delegates to
+ * the IR-based generator.
+ */
+declare function generateGLSL(program: Program, target?: "glsl-450" | "glsl-es-300"): string;
+
+declare function generateWGSL(program: Program): string;
+
+/**
+ * Creates a source span for AST nodes.
+ *
+ * @param line - The line number (1-based).
+ * @param column - The column number (1-based).
+ * @returns A span object.
+ */
+declare function span(line?: number, column?: number): {
+    line: number;
+    column: number;
+};
+/**
+ * Builds a scalar type node.
+ *
+ * @param name - The scalar type name (e.g. "f32", "i32", "bool").
+ * @returns The scalar Type node.
+ */
+declare function scalarType(name: Extract<Type, {
+    kind: "scalar";
+}>["name"]): Type;
+/**
+ * Builds an i8 scalar type.
+ * @returns The i8 Type node.
+ */
+declare function i8(): Type;
+/**
+ * Builds a u8 scalar type.
+ * @returns The u8 Type node.
+ */
+declare function u8(): Type;
+/**
+ * Builds an i16 scalar type.
+ * @returns The i16 Type node.
+ */
+declare function i16(): Type;
+/**
+ * Builds a u16 scalar type.
+ * @returns The u16 Type node.
+ */
+declare function u16(): Type;
+/**
+ * Builds an i32 scalar type.
+ * @returns The i32 Type node.
+ */
+declare function i32(): Type;
+/**
+ * Builds a u32 scalar type.
+ * @returns The u32 Type node.
+ */
+declare function u32(): Type;
+/**
+ * Builds an i64 scalar type.
+ * @returns The i64 Type node.
+ */
+declare function i64(): Type;
+/**
+ * Builds a u64 scalar type.
+ * @returns The u64 Type node.
+ */
+declare function u64(): Type;
+/**
+ * Builds an f16 scalar type.
+ * @returns The f16 Type node.
+ */
+declare function f16(): Type;
+/**
+ * Builds an f32 scalar type.
+ * @returns The f32 Type node.
+ */
+declare function f32(): Type;
+/**
+ * Builds an f64 scalar type.
+ * @returns The f64 Type node.
+ */
+declare function f64(): Type;
+/**
+ * Builds a bf16 scalar type.
+ * @returns The bf16 Type node.
+ */
+declare function bf16(): Type;
+/**
+ * Builds a bool scalar type.
+ * @returns The bool Type node.
+ */
+declare function boolType(): Type;
+/**
+ * Builds a vector type node.
+ *
+ * @param element - The element type name (e.g. "f32", "i32").
+ * @param size - The vector size (2, 3, or 4).
+ * @returns The vector Type node.
+ */
+declare function vectorType(element: string, size: 2 | 3 | 4): Type;
+/**
+ * Builds a vec2 type.
+ * @param element - The element type name (default "f32").
+ * @returns The vec2 Type node.
+ */
+declare function vec2(element?: string): Type;
+/**
+ * Builds a vec3 type.
+ * @param element - The element type name (default "f32").
+ * @returns The vec3 Type node.
+ */
+declare function vec3(element?: string): Type;
+/**
+ * Builds a vec4 type.
+ * @param element - The element type name (default "f32").
+ * @returns The vec4 Type node.
+ */
+declare function vec4(element?: string): Type;
+/**
+ * Builds an ivec2 type.
+ * @returns The ivec2 Type node.
+ */
+declare function ivec2(): Type;
+/**
+ * Builds an ivec3 type.
+ * @returns The ivec3 Type node.
+ */
+declare function ivec3(): Type;
+/**
+ * Builds an ivec4 type.
+ * @returns The ivec4 Type node.
+ */
+declare function ivec4(): Type;
+/**
+ * Builds a uvec2 type.
+ * @returns The uvec2 Type node.
+ */
+declare function uvec2(): Type;
+/**
+ * Builds a uvec3 type.
+ * @returns The uvec3 Type node.
+ */
+declare function uvec3(): Type;
+/**
+ * Builds a uvec4 type.
+ * @returns The uvec4 Type node.
+ */
+declare function uvec4(): Type;
+/**
+ * Builds a bvec2 type.
+ * @returns The bvec2 Type node.
+ */
+declare function bvec2(): Type;
+/**
+ * Builds a bvec3 type.
+ * @returns The bvec3 Type node.
+ */
+declare function bvec3(): Type;
+/**
+ * Builds a bvec4 type.
+ * @returns The bvec4 Type node.
+ */
+declare function bvec4(): Type;
+/**
+ * Builds a dvec2 type.
+ * @returns The dvec2 Type node.
+ */
+declare function dvec2(): Type;
+/**
+ * Builds a dvec3 type.
+ * @returns The dvec3 Type node.
+ */
+declare function dvec3(): Type;
+/**
+ * Builds a dvec4 type.
+ * @returns The dvec4 Type node.
+ */
+declare function dvec4(): Type;
+/**
+ * Builds a matrix type node.
+ *
+ * @param element - The element type name.
+ * @param rows - The number of rows (2, 3, or 4).
+ * @param columns - The number of columns (2, 3, or 4).
+ * @returns The matrix Type node.
+ */
+declare function matrixType(element: string, rows: 2 | 3 | 4, columns: 2 | 3 | 4): Type;
+/**
+ * Builds a mat2 type.
+ * @returns The mat2 Type node.
+ */
+declare function mat2(): Type;
+/**
+ * Builds a mat3 type.
+ * @returns The mat3 Type node.
+ */
+declare function mat3(): Type;
+/**
+ * Builds a mat4 type.
+ * @returns The mat4 Type node.
+ */
+declare function mat4(): Type;
+/**
+ * Builds a mat2x3 type.
+ * @returns The mat2x3 Type node.
+ */
+declare function mat2x3(): Type;
+/**
+ * Builds a mat3x2 type.
+ * @returns The mat3x2 Type node.
+ */
+declare function mat3x2(): Type;
+/**
+ * Builds a dmat3 type.
+ * @returns The dmat3 Type node.
+ */
+declare function dmat3(): Type;
+/**
+ * Builds a quaternion type node.
+ * @returns The quaternion Type node.
+ */
+declare function quatType(): Type;
+/**
+ * Builds a struct type reference.
+ *
+ * @param name - The struct name.
+ * @returns The struct Type node.
+ */
+declare function structType(name: string): Type;
+/**
+ * Builds an enum type reference.
+ *
+ * @param name - The enum name.
+ * @returns The enum Type node.
+ */
+declare function enumType(name: string): Type;
+/**
+ * Builds a sampler type node.
+ *
+ * @param name - The sampler type name (e.g. "sampler2D").
+ * @returns The sampler Type node.
+ */
+declare function samplerType(name: Extract<Type, {
+    kind: "sampler";
+}>["name"]): Type;
+/**
+ * Builds a sampler2D type.
+ * @returns The sampler2D Type node.
+ */
+declare function sampler2D(): Type;
+/**
+ * Builds a sampler3D type.
+ * @returns The sampler3D Type node.
+ */
+declare function sampler3D(): Type;
+/**
+ * Builds a samplerCube type.
+ * @returns The samplerCube Type node.
+ */
+declare function samplerCube(): Type;
+/**
+ * Builds an array type node.
+ *
+ * @param element - The element Type.
+ * @param size - The array size.
+ * @returns The array Type node.
+ */
+declare function arrayType(element: Type, size: number): Type;
+/**
+ * Builds a tuple type node.
+ *
+ * @param elements - The element Types.
+ * @returns The tuple Type node.
+ */
+declare function tupleType(elements: Type[]): Type;
+/**
+ * Builds an option type node.
+ *
+ * @param element - The element Type.
+ * @returns The option Type node.
+ */
+declare function optionType(element: Type): Type;
+/**
+ * Builds a result type node.
+ *
+ * @param ok - The ok Type.
+ * @param err - The err Type.
+ * @returns The result Type node.
+ */
+declare function resultType(ok: Type, err: Type): Type;
+/**
+ * Builds an alias type reference.
+ *
+ * @param name - The alias name.
+ * @returns The alias Type node.
+ */
+declare function aliasType(name: string): Type;
+/**
+ * Builds an opaque type reference.
+ *
+ * @param name - The opaque type name.
+ * @returns The opaque Type node.
+ */
+declare function opaqueType(name: string): Type;
+/**
+ * Builds an anonymous struct type node.
+ *
+ * @param fields - The struct fields.
+ * @returns The anonymous struct Type node.
+ */
+declare function anonymousStructType(fields: Field[]): Type;
+/**
+ * Builds a union type node.
+ *
+ * @param members - The member Types.
+ * @returns The union Type node.
+ */
+declare function unionType(members: Type[]): Type;
+/**
+ * Builds a struct field.
+ *
+ * @param name - The field name.
+ * @param type - The field Type.
+ * @returns The Field node.
+ */
+declare function field(name: string, type: Type): Field;
+/**
+ * Builds a function parameter.
+ *
+ * @param name - The parameter name.
+ * @param type - The parameter Type.
+ * @returns The Param node.
+ */
+declare function param(name: string, type: Type): Param;
+/**
+ * Builds a struct declaration.
+ *
+ * @param name - The struct name.
+ * @param fields - The struct fields.
+ * @returns The StructDecl node.
+ */
+declare function structDecl(name: string, fields: Field[]): StructDecl;
+/**
+ * Builds an enum declaration.
+ *
+ * @param name - The enum name.
+ * @param variants - The enum variants (name + optional type).
+ * @returns The EnumDecl node.
+ */
+declare function enumDecl(name: string, variants: {
+    name: string;
+    type: Type | null;
+    span?: Span;
+}[]): EnumDecl;
+/**
+ * Builds a function declaration.
+ *
+ * @param name - The function name.
+ * @param params - The function parameters.
+ * @param returnType - The return Type.
+ * @param body - The function body block.
+ * @returns The FnDecl node.
+ */
+declare function fnDecl(name: string, params: Param[], returnType: Type, body: Block, stage?: ShaderStage): FnDecl;
+/**
+ * Builds a binding declaration (@binding).
+ *
+ * @param binding - The binding slot number.
+ * @param name - The binding name.
+ * @param type - The binding Type.
+ * @returns The BindingDecl node.
+ */
+declare function bindingDecl(binding: number, name: string, type: Type): BindingDecl;
+/**
+ * Builds an import declaration.
+ *
+ * @param path - The import path.
+ * @returns The ImportDecl node.
+ */
+declare function importDecl(path: string): ImportDecl;
+/**
+ * Builds a variable declaration.
+ *
+ * @param name - The variable name.
+ * @param type - The variable Type.
+ * @param initializer - The initializer expression, or null.
+ * @param mutable - Whether the variable is mutable (var vs let).
+ * @returns The VarDecl node.
+ */
+declare function varDecl(name: string, type: Type, initializer?: Expression | null, mutable?: boolean): VarDecl;
+/**
+ * Builds a return statement.
+ *
+ * @param value - The return value expression, or null.
+ * @returns The ReturnStmt node.
+ */
+declare function returnStmt(value?: Expression | null): ReturnStmt;
+/**
+ * Builds an expression statement.
+ *
+ * @param expression - The expression to evaluate.
+ * @returns The ExpressionStmt node.
+ */
+declare function expressionStmt(expression: Expression): ExpressionStmt;
+/**
+ * Builds a block statement.
+ *
+ * @param statements - The statements inside the block.
+ * @returns The Block node.
+ */
+declare function block(statements: Statement[]): Block;
+/**
+ * Builds an if-else statement.
+ *
+ * @param condition - The condition expression.
+ * @param thenBranch - The then-branch block.
+ * @param elseBranch - The optional else-branch block.
+ * @returns The IfStmt node.
+ */
+declare function ifStmt(condition: Expression, thenBranch: Block, elseBranch?: Block | null): IfStmt;
+/**
+ * Builds a while loop statement.
+ *
+ * @param condition - The loop condition expression.
+ * @param body - The loop body block.
+ * @returns The WhileStmt node.
+ */
+declare function whileStmt(condition: Expression, body: Block): WhileStmt;
+/**
+ * Builds a C-style for loop statement.
+ *
+ * @param init - The initializer (VarDecl, ExpressionStmt, or null).
+ * @param condition - The loop condition, or null.
+ * @param increment - The increment expression, or null.
+ * @param body - The loop body block.
+ * @returns The ForStmt node.
+ */
+declare function forStmt(init: VarDecl | ExpressionStmt | null, condition: Expression | null, increment: Expression | null, body: Block): ForStmt;
+/**
+ * Builds a range-based for loop statement (e.g. `for x in 0..3`).
+ *
+ * @param variable - The loop variable name.
+ * @param start - The range start expression.
+ * @param end - The range end expression.
+ * @param inclusive - Whether the range is inclusive (`..=`).
+ * @param body - The loop body block.
+ * @returns The ForStmt node.
+ */
+declare function rangeForStmt(variable: string, start: Expression, end: Expression, inclusive: boolean, body: Block): ForStmt;
+/**
+ * Builds a do-while loop statement.
+ *
+ * @param body - The loop body block.
+ * @param condition - The exit condition expression.
+ * @returns The DoWhileStmt node.
+ */
+declare function doWhileStmt(body: Block, condition: Expression): DoWhileStmt;
+/**
+ * Builds a loop statement (infinite loop, lowered to `for (;;)`).
+ *
+ * @param body - The loop body block.
+ * @returns The LoopStmt node.
+ */
+declare function loopStmt(body: Block): LoopStmt;
+/**
+ * Builds a break statement.
+ * @returns The BreakStmt node.
+ */
+declare function breakStmt(): BreakStmt;
+/**
+ * Builds a continue statement.
+ * @returns The ContinueStmt node.
+ */
+declare function continueStmt(): ContinueStmt;
+/**
+ * Builds a discard statement.
+ * @returns The DiscardStmt node.
+ */
+declare function discardStmt(): DiscardStmt;
+/**
+ * Builds a panic statement.
+ *
+ * @param message - The optional panic message expression.
+ * @returns The PanicStmt node.
+ */
+declare function panicStmt(message?: Expression | null): PanicStmt;
+/**
+ * Builds an unreachable statement.
+ * @returns The UnreachableStmt node.
+ */
+declare function unreachableStmt(): UnreachableStmt;
+/**
+ * Builds an identifier expression.
+ *
+ * @param name - The identifier name.
+ * @returns The Identifier expression node.
+ */
+declare function ident(name: string): Identifier;
+/**
+ * Builds an integer literal expression.
+ *
+ * @param value - The integer value.
+ * @returns The Literal expression node with literalKind "int".
+ */
+declare function int(value: number): LiteralBase<"int">;
+/**
+ * Builds a float literal expression.
+ *
+ * @param value - The float value.
+ * @returns The Literal expression node with literalKind "float".
+ */
+declare function float(value: number): LiteralBase<"float">;
+/**
+ * Builds a boolean literal expression.
+ *
+ * @param value - The boolean value.
+ * @returns The Literal expression node with literalKind "bool".
+ */
+declare function boolLiteral(value: boolean): LiteralBase<"bool">;
+/**
+ * Builds a binary expression.
+ *
+ * @param left - The left operand.
+ * @param operator - The binary operator.
+ * @param right - The right operand.
+ * @returns The BinaryExpr expression node.
+ */
+declare function binary(left: Expression, operator: string, right: Expression): BinaryExpr;
+/**
+ * Builds a unary expression.
+ *
+ * @param operator - The unary operator.
+ * @param operand - The operand expression.
+ * @returns The UnaryExpr expression node.
+ */
+declare function unary(operator: string, operand: Expression): UnaryExpr;
+/**
+ * Builds a function call expression.
+ *
+ * @param callee - The callee expression.
+ * @param args - The call arguments (default empty).
+ * @returns The CallExpr expression node.
+ */
+declare function call(callee: Expression, args?: Expression[]): CallExpr;
+/**
+ * Builds a member access expression.
+ *
+ * @param object - The object expression.
+ * @param property - The property name.
+ * @returns The MemberExpr expression node.
+ */
+declare function member(object: Expression, property: string): MemberExpr;
+/**
+ * Builds a swizzle expression.
+ *
+ * @param object - The object expression.
+ * @param components - The swizzle components (e.g. ["r", "g", "b"]).
+ * @returns The SwizzleExpr expression node.
+ */
+declare function swizzle(object: Expression, components: string[]): SwizzleExpr;
+/**
+ * Builds an index expression.
+ *
+ * @param object - The object expression.
+ * @param indexExpr - The index expression.
+ * @returns The IndexExpr expression node.
+ */
+declare function index(object: Expression, indexExpr: Expression): IndexExpr;
+/**
+ * Builds a struct literal expression.
+ *
+ * @param typeName - The struct type name.
+ * @param fields - The field name/value pairs (name may be null for spread).
+ * @returns The StructLiteral expression node.
+ */
+declare function structLiteral(typeName: string, fields: {
+    name: string | null;
+    value: Expression;
+}[]): StructLiteral;
+/**
+ * Builds an array literal expression.
+ *
+ * @param elements - The array elements (default empty).
+ * @returns The ArrayLiteral expression node.
+ */
+declare function arrayLiteral(elements?: Expression[]): ArrayLiteral;
+/**
+ * Builds a compound assignment expression (e.g. `x += 2`).
+ *
+ * @param target - The target expression.
+ * @param operator - The compound assignment operator.
+ * @param value - The value expression.
+ * @returns The CompoundAssignExpr expression node.
+ */
+declare function compoundAssign(target: Expression, operator: "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=", value: Expression): CompoundAssignExpr;
+/**
+ * Builds an increment/decrement expression (e.g. `++x` or `x--`).
+ *
+ * @param operator - The update operator ("++" or "--").
+ * @param operand - The operand expression.
+ * @param prefix - Whether the operator is prefix (default false).
+ * @returns The UpdateExpr expression node.
+ */
+declare function update(operator: "++" | "--", operand: Expression, prefix?: boolean): UpdateExpr;
+/**
+ * Builds a ternary conditional expression (e.g. `b ? 1.0 : 2.0`).
+ *
+ * @param test - The test expression.
+ * @param consequent - The consequent expression.
+ * @param alternate - The alternate expression.
+ * @returns The ConditionalExpr expression node.
+ */
+declare function conditional(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpr;
+/**
+ * Builds a null coalescing expression (e.g. `x ?? 2`).
+ *
+ * @param left - The left expression.
+ * @param right - The right expression.
+ * @returns The NullCoalescingExpr expression node.
+ */
+declare function nullCoalescing(left: Expression, right: Expression): NullCoalescingExpr;
+/**
+ * Builds a match expression.
+ *
+ * @param subject - The subject expression.
+ * @param arms - The match arms.
+ * @returns The MatchExpr expression node.
+ */
+declare function match(subject: Expression, arms: MatchArm[]): MatchExpr;
+/**
+ * Builds a block expression.
+ *
+ * @param block - The block statement.
+ * @returns The BlockExpr expression node.
+ */
+declare function blockExpr(block: Block): BlockExpr;
+/**
+ * Builds a literal match pattern.
+ *
+ * @param value - The literal value.
+ * @returns The LiteralPattern node.
+ */
+declare function literalPattern(value: number | string | boolean): LiteralPattern;
+/**
+ * Builds a binding match pattern.
+ *
+ * @param name - The binding name.
+ * @returns The BindingPattern node.
+ */
+declare function bindingPattern(name: string): BindingPattern;
+/**
+ * Builds a wildcard match pattern.
+ * @returns The WildcardPattern node.
+ */
+declare function wildcardPattern(): WildcardPattern;
+/**
+ * Builds a match arm.
+ *
+ * @param pattern - The match pattern.
+ * @param body - The arm body block.
+ * @param guard - The optional guard expression.
+ * @returns The MatchArm node.
+ */
+declare function arm(pattern: Pattern, body: Block, guard?: Expression | null): MatchArm;
+/**
+ * Builds a type alias declaration.
+ *
+ * @param name - The alias name.
+ * @param type - The aliased Type.
+ * @returns The TypeAlias node.
+ */
+declare function typeAlias(name: string, type: Type): TypeAlias;
+/**
+ * Builds a newtype declaration.
+ *
+ * @param name - The newtype name.
+ * @param innerType - The inner Type.
+ * @returns The NewtypeDecl node.
+ */
+declare function newtypeDecl(name: string, innerType: Type): NewtypeDecl;
+/**
+ * Builds an opaque type declaration.
+ *
+ * @param name - The opaque type name.
+ * @returns The OpaqueDecl node.
+ */
+declare function opaqueDecl(name: string): OpaqueDecl;
+/**
+ * Builds a trait declaration.
+ *
+ * @param name - The trait name.
+ * @param bounds - The trait bounds.
+ * @param methods - The trait method signatures.
+ * @returns The TraitDecl node.
+ */
+declare function traitDecl(name: string, bounds: string[], methods: {
+    name: string;
+    params: Param[];
+    returnType: Type;
+}[]): TraitDecl;
+/**
+ * Builds an impl block declaration.
+ *
+ * @param trait - The trait name, or null for inherent impl.
+ * @param type - The target Type.
+ * @param methods - The impl method declarations.
+ * @returns The ImplBlock node.
+ */
+declare function implBlock(trait: string | null, type: Type, methods: FnDecl[]): ImplBlock;
+/**
+ * Builds a Program node.
+ *
+ * @param statements - The top-level statements.
+ * @returns The Program node.
+ */
+declare function program(statements: Statement[]): Program;
+/**
+ * Builds a `fn main(): vec4` entry point.
+ *
+ * @param body - The main function body block.
+ * @returns The FnDecl node for main.
+ */
+declare function mainFn(body: Block): FnDecl;
+/**
+ * Builds a `fn main(): vec4` entry point from a list of statements.
+ *
+ * @param statements - The statements inside main's body.
+ * @returns The FnDecl node for main.
+ */
+declare function mainVec4(statements: Statement[]): FnDecl;
+
+/**
+ * Options for compiling a gl source file or AST.
+ */
+interface CompileOptions {
+    target: string;
+    file?: string;
+    /** Source text to parse and compile (mutually exclusive with `ast`). */
+    source?: string;
+    /** Pre-built AST to type-check and codegen (mutually exclusive with `source`). */
+    ast?: Program;
+    /** Source resolver for import resolution. Required when source contains imports. */
+    resolver?: SourceResolver;
+    /** Stable, canonical identity for the main source (used in diagnostics + module graph). */
+    sourceId?: string;
+    /** Optional backend registry (defaults to the shared default registry). */
+    registry?: BackendRegistry;
+    /** Provenance map from statement to source file (used for imported diagnostics). */
+    provenance?: Map<Statement, string>;
+}
+interface CompileSyncOptions extends CompileOptions {
+    target: string;
+}
+interface CompileAsyncOptions extends CompileOptions {
+    target: string;
+    resolver: SourceResolver;
+}
+/**
+ * Result of compiling a gl source file or AST.
+ */
+interface CompileResult {
+    code: string | null;
+    shaders: ShaderArtifact[];
+    ast: Program;
+    diagnostics: Diagnostic[];
+    target: string;
+}
+/**
+ * Compiles a pre-built Program AST or single-file source (no imports) to the target language.
+ *
+ * This is the synchronous entry point. Source containing imports requires
+ * `compileAsync` with an injected `SourceResolver`.
+ *
+ * @param options - Compilation options (target, file, and either `source` or `ast`).
+ * @returns CompileResult indexed by the target.
+ */
+declare function compileSync(options: CompileSyncOptions): CompileResult;
+/**
+ * Compiles a gl source file or pre-built AST to the target language with async
+ * module resolution. Resolves imports through the injected `SourceResolver`.
+ *
+ * @param options - Compilation options (target, resolver, and either `source` or `ast`).
+ * @returns CompileResult indexed by the target.
+ */
+declare function compileAsync(options: CompileAsyncOptions): Promise<CompileResult>;
+/**
+ * Compiles a gl source file or pre-built AST to the target language.
+ *
+ * When `source` is given without imports, compiles synchronously. When `source`
+ * contains imports, returns a diagnostic directing the caller to `compileAsync`.
+ * When `ast` is given, skips parsing and import resolution.
+ *
+ * @deprecated Use `compileSync` or `compileAsync` explicitly.
+ * @param options - Compilation options (target, file, and either `source` or `ast`).
+ * @returns CompileResult indexed by the target.
+ */
+declare function compile(options: CompileOptions): CompileResult;
+
+export { type BackendCapabilities, type BackendOutput, BackendRegistry, type CodegenOptions, type CompileAsyncOptions, type CompileOptions, type CompileResult, type CompileSyncOptions, type Diagnostic, GLSL_450_CAPABILITIES, GLSL_ES_300_CAPABILITIES, type IRAlias, type IRAnonymousStruct, type IRArray, type IRArrayLiteral, type IRBinary, type IRBindingDecl, type IRBindingPattern, type IRBlock, type IRBlockExpr, type IRBreak, type IRCall, type IRCompoundAssign, type IRConditional, type IRContinue, type IRDiscard, type IRDoWhile, type IREntryPoint, type IREnumDecl, type IREnumRef, type IRExpression, type IRExpressionStmt, type IRField, type IRFnDecl, type IRFor, type IRForRange, type IRIdentifier, type IRIf, type IRImplBlock, type IRIndex, type IRLiteral, type IRLiteralKind, type IRLiteralPattern, type IRLoop, type IRMatch, type IRMatchArm, type IRMatrix, type IRMember, type IRModule, type IRModuleItem, type IRNewtypeDecl, type IRNullCoalescing, type IROpaque, type IROpaqueDecl, type IROption, type IRPanic, type IRParam, type IRPattern, type IRQuaternion, type IRResourceKind, type IRResult, type IRReturn, type IRSampler, type IRScalar, type IRScalarName, type IRSourceAttribution, type IRSourceFile, type IRSpan, type IRStage, type IRStatement, type IRStructDecl, type IRStructLiteral, type IRStructRef, type IRSwizzle, type IRTraitDecl, type IRTuple, type IRType, type IRTypeAlias, type IRUnary, type IRUnion, type IRUnreachable, type IRUpdate, type IRVarDecl, type IRVector, type IRWhile, type IRWildcardPattern, type ResourceKind, type ScalarTypeName, type ShaderArtifact, type ShaderCodegenBackend, type ShaderEntryPointReflection, type ShaderInterfaceVariable, type ShaderReflection, type ShaderResourceReflection, type ShaderSourceMap, type ShaderStage, type ShaderTarget, type ShaderUniformReflection, SourceResolver, WGSL_CAPABILITIES, aliasType, anonymousStructType, arm, arrayLiteral, arrayType, bf16, binary, bindingDecl, bindingPattern, block, blockExpr, boolLiteral, boolType, breakStmt, bvec2, bvec3, bvec4, call, capabilitiesFor, compile, compileAsync, compileSync, compoundAssign, conditional, continueStmt, createDefaultBackendRegistry, defaultRegistry, discardStmt, dmat3, doWhileStmt, dvec2, dvec3, dvec4, enumDecl, enumType, expressionStmt, f16, f32, f64, field, float, fnDecl, forStmt, generateGLSL, generateWGSL, getBackend, i16, i32, i64, i8, ident, ifStmt, implBlock, importDecl, index, int, ivec2, ivec3, ivec4, literalPattern, loopStmt, mainFn, mainVec4, mat2, mat2x3, mat3, mat3x2, mat4, match, matrixType, member, newtypeDecl, nullCoalescing, opaqueDecl, opaqueType, optionType, panicStmt, param, parse, program, quatType, rangeForStmt, resultType, returnStmt, sampler2D, sampler3D, samplerCube, samplerType, scalarIsSupported, scalarType, span, structDecl, structLiteral, structType, swizzle, tokenize, traitDecl, tupleType, typeAlias, typeCheck, u16, u32, u64, u8, unary, unionType, unreachableStmt, update, uvec2, uvec3, uvec4, varDecl, vec2, vec3, vec4, vectorType, whileStmt, wildcardPattern };