@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/rendering/WebGPUv2.d.ts

@@ -0,0 +1,173 @@
+export interface WebGPUv2Features {
+    /** Timestamp queries for profiling */
+    timestampQuery: boolean;
+    /** Indirect multi-draw */
+    indirectFirstInstance: boolean;
+    /** Shader f16 support */
+    shaderF16: boolean;
+    /** Depth clip control */
+    depthClipControl: boolean;
+    /** RG11B10 storage textures */
+    rg11b10Storage: boolean;
+    /** BGRA read-write storage */
+    bgraStorage: boolean;
+    /** Float32 filterable textures */
+    float32Filterable: boolean;
+    /** Subgroups extension */
+    subgroups: boolean;
+    /** Max texture dimension */
+    maxTextureDimension: number;
+    /** Max bind groups */
+    maxBindGroups: number;
+    /** Max storage buffers per shader stage */
+    maxStorageBuffers: number;
+    /** Max compute workgroup size */
+    maxComputeWorkgroupSize: [number, number, number];
+}
+export declare function detectWebGPUv2Features(device: GPUDevice): Promise<WebGPUv2Features>;
+export interface BindlessTextureArray {
+    textureArray: GPUTexture;
+    sampler: GPUSampler;
+    bindGroup: GPUBindGroup;
+    layout: GPUBindGroupLayout;
+    capacity: number;
+    usedSlots: number;
+    slotMap: Map<string, number>;
+}
+export interface BindlessTextureConfig {
+    width: number;
+    height: number;
+    layers: number;
+    format: GPUTextureFormat;
+    mipLevelCount?: number;
+    sampleCount?: 1 | 4;
+}
+export declare function createBindlessTextureArray(device: GPUDevice, config: BindlessTextureConfig): BindlessTextureArray;
+export interface DrawIndirectCommand {
+    vertexCount: number;
+    instanceCount: number;
+    firstVertex: number;
+    firstInstance: number;
+}
+export interface DrawIndexedIndirectCommand {
+    indexCount: number;
+    instanceCount: number;
+    firstIndex: number;
+    baseVertex: number;
+    firstInstance: number;
+}
+export interface GPUDrivenRenderer {
+    /** Buffer for indirect draw commands */
+    drawBuffer: GPUBuffer;
+    /** Buffer for instance data */
+    instanceBuffer: GPUBuffer;
+    /** Buffer for visibility results (from culling) */
+    visibilityBuffer: GPUBuffer;
+    /** Compute pipeline for GPU culling */
+    cullPipeline: GPUComputePipeline;
+    /** Compute pipeline for compaction */
+    compactPipeline: GPUComputePipeline;
+    /** Max draw calls per frame */
+    maxDrawCalls: number;
+    /** Max instances total */
+    maxInstances: number;
+}
+export interface CullUniforms {
+    viewProjectionMatrix: Float32Array;
+    frustumPlanes: Float32Array;
+    cameraPosition: Float32Array;
+    lodDistances: Float32Array;
+}
+/** WGSL compute shader for frustum culling */
+export declare const GPU_CULL_SHADER = "\nstruct CullUniforms {\n  viewProj: mat4x4<f32>,\n  frustum0: vec4<f32>,\n  frustum1: vec4<f32>,\n  frustum2: vec4<f32>,\n  frustum3: vec4<f32>,\n  frustum4: vec4<f32>,\n  frustum5: vec4<f32>,\n  cameraPos: vec4<f32>,\n  lodDistances: vec4<f32>,\n}\n\nstruct InstanceData {\n  modelMatrix: mat4x4<f32>,\n  boundingSphere: vec4<f32>, // xyz = center, w = radius\n  lodLevel: u32,\n  meshIndex: u32,\n  materialIndex: u32,\n  flags: u32,\n}\n\nstruct DrawCommand {\n  vertexCount: u32,\n  instanceCount: atomic<u32>,\n  firstVertex: u32,\n  firstInstance: u32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CullUniforms;\n@group(0) @binding(1) var<storage, read> instances: array<InstanceData>;\n@group(0) @binding(2) var<storage, read_write> drawCommands: array<DrawCommand>;\n@group(0) @binding(3) var<storage, read_write> visibleInstances: array<u32>;\n@group(0) @binding(4) var<storage, read_write> visibilityCount: atomic<u32>;\n\nfn isInsideFrustum(sphere: vec4<f32>) -> bool {\n  let planes = array<vec4<f32>, 6>(\n    uniforms.frustum0, uniforms.frustum1, uniforms.frustum2,\n    uniforms.frustum3, uniforms.frustum4, uniforms.frustum5\n  );\n  \n  for (var i = 0u; i < 6u; i++) {\n    let dist = dot(planes[i].xyz, sphere.xyz) + planes[i].w;\n    if (dist < -sphere.w) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfn computeLOD(worldPos: vec3<f32>) -> u32 {\n  let dist = distance(worldPos, uniforms.cameraPos.xyz);\n  if (dist < uniforms.lodDistances.x) { return 0u; }\n  if (dist < uniforms.lodDistances.y) { return 1u; }\n  if (dist < uniforms.lodDistances.z) { return 2u; }\n  return 3u;\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let instanceIndex = gid.x;\n  if (instanceIndex >= arrayLength(&instances)) {\n    return;\n  }\n  \n  let instance = instances[instanceIndex];\n  \n  // Transform bounding sphere to world space\n  let worldCenter = (instance.modelMatrix * vec4<f32>(instance.boundingSphere.xyz, 1.0)).xyz;\n  let worldSphere = vec4<f32>(worldCenter, instance.boundingSphere.w);\n  \n  // Frustum cull\n  if (!isInsideFrustum(worldSphere)) {\n    return;\n  }\n  \n  // Compute LOD\n  let lod = computeLOD(worldCenter);\n  \n  // Add to visible instances\n  let slot = atomicAdd(&visibilityCount, 1u);\n  visibleInstances[slot] = instanceIndex;\n  \n  // Increment instance count for draw command\n  atomicAdd(&drawCommands[instance.meshIndex].instanceCount, 1u);\n}\n";
+export declare function createGPUDrivenRenderer(device: GPUDevice, maxDrawCalls: number, maxInstances: number): Promise<GPUDrivenRenderer>;
+export type ShadingRate = '1x1' | '1x2' | '2x1' | '2x2' | '2x4' | '4x2' | '4x4';
+export interface VRSConfig {
+    /** Enable VRS */
+    enabled: boolean;
+    /** Default shading rate */
+    defaultRate: ShadingRate;
+    /** Use velocity-based adaptive VRS */
+    velocityAdaptive: boolean;
+    /** Use luminance-based adaptive VRS */
+    luminanceAdaptive: boolean;
+    /** Edge detection for fine detail preservation */
+    edgePreservation: boolean;
+    /** Foveated regions (for VR) */
+    foveatedRegions?: FoveatedRegion[];
+}
+export interface FoveatedRegion {
+    centerX: number;
+    centerY: number;
+    innerRadius: number;
+    middleRadius: number;
+    outerRadius: number;
+    innerRate: ShadingRate;
+    middleRate: ShadingRate;
+    outerRate: ShadingRate;
+}
+export declare const DEFAULT_VRS_CONFIG: VRSConfig;
+/** WGSL shader for generating VRS rate image */
+export declare const VRS_RATE_SHADER = "\nstruct VRSParams {\n  enableVelocity: u32,\n  enableLuminance: u32,\n  enableEdge: u32,\n  defaultRate: u32,\n  screenSize: vec2<f32>,\n  foveaCenter: vec2<f32>,\n  foveaRadii: vec4<f32>, // inner, middle, outer, _\n}\n\n@group(0) @binding(0) var<uniform> params: VRSParams;\n@group(0) @binding(1) var velocityTex: texture_2d<f32>;\n@group(0) @binding(2) var depthTex: texture_2d<f32>;\n@group(0) @binding(3) var rateOutput: texture_storage_2d<r8uint, write>;\n\nfn velocityToRate(velocity: vec2<f32>) -> u32 {\n  let speed = length(velocity);\n  if (speed < 0.01) { return 0u; } // 1x1\n  if (speed < 0.05) { return 1u; } // 1x2\n  if (speed < 0.1) { return 3u; }  // 2x2\n  return 7u; // 4x4\n}\n\nfn foveaToRate(uv: vec2<f32>) -> u32 {\n  let dist = distance(uv, params.foveaCenter);\n  if (dist < params.foveaRadii.x) { return 0u; } // 1x1\n  if (dist < params.foveaRadii.y) { return 1u; } // 1x2\n  if (dist < params.foveaRadii.z) { return 3u; } // 2x2\n  return 7u; // 4x4\n}\n\n@compute @workgroup_size(8, 8)\nfn main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let screenPos = vec2<i32>(gid.xy);\n  let uv = vec2<f32>(gid.xy) / params.screenSize;\n  \n  var rate = params.defaultRate;\n  \n  // Foveated rendering (highest priority)\n  if (params.foveaRadii.w > 0.0) {\n    rate = max(rate, foveaToRate(uv));\n  }\n  \n  // Velocity-based\n  if (params.enableVelocity != 0u) {\n    let velocity = textureLoad(velocityTex, screenPos, 0).xy;\n    rate = max(rate, velocityToRate(velocity));\n  }\n  \n  textureStore(rateOutput, screenPos, vec4<u32>(rate, 0u, 0u, 0u));\n}\n";
+export interface RTAccelerationStructure {
+    /** BVH nodes buffer */
+    bvhBuffer: GPUBuffer;
+    /** Triangle data buffer */
+    triangleBuffer: GPUBuffer;
+    /** Instance transforms buffer */
+    instanceBuffer: GPUBuffer;
+    /** Compute pipeline for ray-BVH traversal */
+    traversalPipeline: GPUComputePipeline;
+    /** Total triangles */
+    triangleCount: number;
+    /** Total instances */
+    instanceCount: number;
+}
+export interface BVHNode {
+    boundsMin: [number, number, number];
+    boundsMax: [number, number, number];
+    leftChild: number;
+    rightChild: number;
+    firstTriangle: number;
+    triangleCount: number;
+}
+export interface RTConfig {
+    /** Max ray bounces */
+    maxBounces: number;
+    /** Samples per pixel */
+    samplesPerPixel: number;
+    /** Use importance sampling */
+    importanceSampling: boolean;
+    /** Enable soft shadows */
+    softShadows: boolean;
+    /** Enable ambient occlusion */
+    ambientOcclusion: boolean;
+    /** Enable global illumination */
+    globalIllumination: boolean;
+    /** Denoiser enabled */
+    denoiser: boolean;
+}
+export declare const DEFAULT_RT_CONFIG: RTConfig;
+/** BVH construction (SAH-based) */
+export declare function buildBVH(triangles: Float32Array, triangleCount: number): {
+    nodes: BVHNode[];
+    reorderedTriangles: Float32Array;
+};
+export interface TAAConfig {
+    /** Enable TAA */
+    enabled: boolean;
+    /** Jitter sample count (8 or 16) */
+    jitterSamples: 8 | 16;
+    /** Blend factor (0.9 = 90% history, 10% current) */
+    blendFactor: number;
+    /** Velocity rejection threshold */
+    velocityRejection: number;
+    /** Enable sharpening pass */
+    sharpen: boolean;
+    /** Sharpening strength */
+    sharpenStrength: number;
+}
+export declare const DEFAULT_TAA_CONFIG: TAAConfig;
+/** Halton sequence for jitter offsets */
+export declare function haltonSequence(index: number, base: number): number;
+export declare function generateJitterOffsets(sampleCount: 8 | 16): [number, number][];

package/dist/types/rendering/index.d.ts

@@ -1,2 +1,3 @@
 export { Camera2D, type CameraShake } from './Camera2D';
 export { Renderer2D, RenderSystem, type RenderStats } from './Renderer2D';
+export { detectWebGPUv2Features, createBindlessTextureArray, createGPUDrivenRenderer, buildBVH, haltonSequence, generateJitterOffsets, GPU_CULL_SHADER, VRS_RATE_SHADER, DEFAULT_VRS_CONFIG, DEFAULT_RT_CONFIG, DEFAULT_TAA_CONFIG, type WebGPUv2Features, type BindlessTextureArray, type BindlessTextureConfig, type GPUDrivenRenderer, type CullUniforms, type VRSConfig, type FoveatedRegion, type ShadingRate, type RTAccelerationStructure, type BVHNode, type RTConfig, type TAAConfig, type DrawIndirectCommand, type DrawIndexedIndirectCommand, } from './WebGPUv2';

package/dist/types/scene/SceneManager.d.ts

@@ -1,5 +1,5 @@
-import type { EntityId, SceneData } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { EntityId, SceneData as _SceneData } from '../core/types';
 import { World, type ComponentMap } from '../ecs/World';
 export type TransitionType = 'none' | 'fade' | 'slide-left' | 'slide-right' | 'slide-up' | 'slide-down';
 export interface SceneTransition {
@@ -53,7 +53,7 @@ export declare class SceneManager {
         name?: string;
     }): EntityId;
     private instantiatePrefab;
-    serializeScene(world: World, id: string, name: string): SceneData;
+    serializeScene(world: World, id: string, name: string): _SceneData;
     /** Deserialize a scene into a world. */
-    deserializeScene(world: World, data: SceneData): void;
+    deserializeScene(world: World, data: _SceneData): void;
 }

package/dist/types/scripting/GraphToAST.d.ts

@@ -1,4 +1,4 @@
-import type { ScriptGraph } from './NodeGraph';
+import type { ScriptGraph as _ScriptGraph } from './NodeGraph';
 import { NodeLibrary } from './NodeGraph';
 import type { ASTScript } from './ScriptAST';
 export interface ConvertOptions {
@@ -19,11 +19,11 @@ export declare class GraphToAST {
     /**
      * Convert a visual script graph to AST representation.
      */
-    convert(graph: ScriptGraph, options?: ConvertOptions): ASTScript;
+    convert(graph: _ScriptGraph, options?: ConvertOptions): ASTScript;
     /**
      * Convert multiple graphs into a single script module.
      */
-    convertMultiple(graphs: ScriptGraph[], moduleName: string, options?: ConvertOptions): ASTScript;
+    convertMultiple(graphs: _ScriptGraph[], moduleName: string, options?: ConvertOptions): ASTScript;
     private findEntryNodes;
     private entryTypeToMethodName;
     private convertVariables;
@@ -51,5 +51,5 @@ export declare class GraphToAST {
     private getFlowTargetNodes;
     private followFlowConnections;
 }
-export declare function convertGraphToAST(graph: ScriptGraph, library: NodeLibrary, options?: ConvertOptions): ASTScript;
+export declare function convertGraphToAST(graph: _ScriptGraph, library: NodeLibrary, options?: ConvertOptions): ASTScript;
 export default GraphToAST;

package/dist/types/scripting/NodeGraph.d.ts

@@ -1,5 +1,5 @@
-import type { EntityId, Vec2 } from '../core/types';
 import { EventBus } from '../core/EventBus';
+import type { EntityId, Vec2 } from '../core/types';
 export type PortDataType = 'flow' | 'boolean' | 'number' | 'string' | 'vec2' | 'color' | 'entity' | 'any';
 export type PortDirection = 'input' | 'output';
 export interface PortDef {

package/dist/types/scripting/ScriptAST.d.ts

@@ -1,8 +1,10 @@
-export type ASTDataType = 'void' | 'bool' | 'int' | 'float' | 'string' | 'vector2' | 'vector3' | 'color' | 'entity' | 'array' | 'dictionary' | 'any' | 'custom';
+export type ASTDataType = 'void' | 'bool' | 'int' | 'float' | 'string' | 'vector2' | 'vector3' | 'color' | 'entity' | 'array' | 'dictionary' | 'any' | 'custom' | 'null' | (string & {});
 export interface ASTTypeInfo {
     type: ASTDataType;
     /** For array/dictionary/custom types */
     genericArgs?: ASTTypeInfo[];
+    /** Alias for genericArgs (used by some exporters). */
+    genericTypes?: ASTTypeInfo[];
     /** Custom type name for 'custom' type */
     customName?: string;
     /** Whether the type is nullable */
@@ -19,6 +21,8 @@ export interface ASTNodeBase {
 export interface ASTLiteral extends ASTNodeBase {
     kind: 'literal';
     valueType: ASTDataType;
+    /** Alias for valueType (used by some exporters). */
+    literalType: ASTDataType;
     value: unknown;
 }
 export interface ASTIdentifier extends ASTNodeBase {
@@ -41,6 +45,8 @@ export interface ASTUnaryOp extends ASTNodeBase {
 export interface ASTCall extends ASTNodeBase {
     kind: 'call';
     callee: string;
+    /** Alias for callee (used by some exporters). */
+    functionName: string;
     args: ASTExpression[];
     /** Generic type arguments for the call */
     typeArgs?: ASTTypeInfo[];
@@ -48,24 +54,36 @@ export interface ASTCall extends ASTNodeBase {
 export interface ASTMethodCall extends ASTNodeBase {
     kind: 'methodCall';
     object: ASTExpression;
+    /** Alias for object (used by some exporters). */
+    target: ASTExpression;
     method: string;
+    /** Alias for method (used by some exporters). */
+    methodName: string;
     args: ASTExpression[];
 }
 export interface ASTPropertyAccess extends ASTNodeBase {
     kind: 'propertyAccess';
     object: ASTExpression;
+    /** Alias for object (used by some exporters). */
+    target: ASTExpression;
     property: string;
 }
 export interface ASTIndexAccess extends ASTNodeBase {
     kind: 'indexAccess';
     object: ASTExpression;
+    /** Alias for object (used by some exporters). */
+    target: ASTExpression;
     index: ASTExpression;
 }
 export interface ASTConditional extends ASTNodeBase {
     kind: 'conditional';
     condition: ASTExpression;
     ifTrue: ASTExpression;
+    /** Alias for ifTrue (used by some exporters). */
+    thenExpression: ASTExpression;
     ifFalse: ASTExpression;
+    /** Alias for ifFalse (used by some exporters). */
+    elseExpression: ASTExpression;
 }
 export interface ASTArrayLiteral extends ASTNodeBase {
     kind: 'arrayLiteral';
@@ -93,6 +111,8 @@ export interface ASTLambda extends ASTNodeBase {
 export interface ASTNew extends ASTNodeBase {
     kind: 'new';
     typeName: string;
+    /** Alias for typeName as ASTTypeInfo (used by some exporters). */
+    type: ASTTypeInfo;
     args: ASTExpression[];
 }
 export type ASTStatement = ASTVarDecl | ASTAssignment | ASTIf | ASTWhile | ASTFor | ASTForEach | ASTReturn | ASTBreak | ASTContinue | ASTExpressionStatement | ASTBlock | ASTSwitch | ASTTry | ASTYield | ASTAwait | ASTMatch | ASTSignalEmit;
@@ -100,6 +120,8 @@ export interface ASTVarDecl extends ASTNodeBase {
     kind: 'varDecl';
     name: string;
     varType?: ASTTypeInfo;
+    /** Alias for varType (used by some exporters). */
+    type: ASTTypeInfo;
     initializer?: ASTExpression;
     isConst?: boolean;
     /** Export for Godot @export, [SerializeField] for Unity */
@@ -115,7 +137,11 @@ export interface ASTIf extends ASTNodeBase {
     kind: 'if';
     condition: ASTExpression;
     thenBranch: ASTStatement[];
+    /** Alias for thenBranch (used by WasmCompiler). */
+    thenBody: ASTStatement[];
     elseBranch?: ASTStatement[];
+    /** Alias for elseBranch (used by WasmCompiler). */
+    elseBody?: ASTStatement[];
     elseIfs?: Array<{
         condition: ASTExpression;
         body: ASTStatement[];
@@ -136,6 +162,10 @@ export interface ASTFor extends ASTNodeBase {
 export interface ASTForEach extends ASTNodeBase {
     kind: 'forEach';
     variable: string;
+    /** Alias for variable (used by WasmCompiler). */
+    itemName: string;
+    /** Item type for typed for-each. */
+    itemType?: ASTTypeInfo;
     iterable: ASTExpression;
     body: ASTStatement[];
 }
@@ -169,11 +199,21 @@ export interface ASTSwitch extends ASTNodeBase {
 export interface ASTTry extends ASTNodeBase {
     kind: 'try';
     tryBlock: ASTStatement[];
+    /** Alias for tryBlock (used by WasmCompiler). */
+    tryBody: ASTStatement[];
     catchBlocks?: Array<{
         errorType?: string;
         errorVar?: string;
         body: ASTStatement[];
     }>;
+    /** Alias for catchBlocks (used by some exporters). */
+    catchBlock?: {
+        errorType?: string;
+        errorVar?: string;
+        body: ASTStatement[];
+    };
+    /** Alias for catchBlocks[0].errorVar (used by some exporters). */
+    catchVariable?: string;
     finallyBlock?: ASTStatement[];
 }
 export interface ASTYield extends ASTNodeBase {
@@ -201,6 +241,8 @@ export interface ASTSignalEmit extends ASTNodeBase {
 export interface ASTParameter {
     name: string;
     paramType: ASTTypeInfo;
+    /** Alias for paramType (used by some exporters). */
+    type: ASTTypeInfo;
     defaultValue?: ASTExpression;
     /** Variadic parameter (...args) */
     isVariadic?: boolean;
@@ -214,6 +256,8 @@ export interface ASTFunction extends ASTNodeBase {
     isAsync?: boolean;
     isStatic?: boolean;
     visibility?: 'public' | 'private' | 'protected' | 'internal';
+    /** Computed alias for visibility === 'private' (used by some exporters). */
+    isPrivate?: boolean;
     /** Virtual/override for inheritance */
     isVirtual?: boolean;
     isOverride?: boolean;
@@ -226,8 +270,14 @@ export interface ASTFunction extends ASTNodeBase {
 export interface ASTField {
     name: string;
     fieldType: ASTTypeInfo;
+    /** Alias for fieldType (used by some exporters). */
+    type: ASTTypeInfo;
     initializer?: ASTExpression;
     visibility?: 'public' | 'private' | 'protected' | 'internal';
+    /** Alias for visibility (used by WasmCompiler). */
+    accessModifier?: 'public' | 'private' | 'protected' | 'internal';
+    /** Computed alias for visibility === 'private' (used by some exporters). */
+    isPrivate?: boolean;
     isStatic?: boolean;
     isConst?: boolean;
     isReadonly?: boolean;

package/dist/types/scripting/VisualScripting2.d.ts

@@ -12,8 +12,8 @@
  * - Call stack visualization
  * - Live preview in editor
  */
-import type { EntityId, Vec2 } from '../core/types';
 import type { EventBus } from '../core/EventBus';
+import type { EntityId, Vec2 } from '../core/types';
 /** Extended data types for visual scripting */
 export type VSDataType = 'flow' | 'bool' | 'int' | 'float' | 'string' | 'vec2' | 'vec3' | 'color' | 'entity' | 'component' | 'asset' | 'array' | 'map' | 'struct' | 'object' | 'enum' | 'delegate' | 'wildcard';
 /** Type color mapping for visual identification */

package/dist/types/scripting/WasmCompiler.d.ts

@@ -0,0 +1,182 @@
+import type { ASTScript } from './ScriptAST';
+export type WasmValueType = 'i32' | 'i64' | 'f32' | 'f64' | 'v128' | 'funcref' | 'externref';
+export type WasmInstr = string;
+export interface WasmFuncType {
+    params: WasmValueType[];
+    results: WasmValueType[];
+}
+export interface WasmLocal {
+    name: string;
+    type: WasmValueType;
+}
+export interface WasmFunc {
+    name: string;
+    type: WasmFuncType;
+    locals: WasmLocal[];
+    body: WasmInstr[];
+    exported?: boolean;
+    importModule?: string;
+    importName?: string;
+}
+export interface WasmGlobal {
+    name: string;
+    type: WasmValueType;
+    mutable: boolean;
+    init: string;
+    exported?: boolean;
+}
+export interface WasmMemory {
+    name: string;
+    initial: number;
+    maximum?: number;
+    exported?: boolean;
+}
+export interface WasmTable {
+    name: string;
+    elementType: 'funcref' | 'externref';
+    initial: number;
+    maximum?: number;
+}
+export interface WasmModule {
+    funcs: WasmFunc[];
+    globals: WasmGlobal[];
+    memories: WasmMemory[];
+    tables: WasmTable[];
+    dataSegments: WasmDataSegment[];
+    types: Map<string, WasmFuncType>;
+    startFunc?: string;
+}
+export interface WasmDataSegment {
+    offset: number;
+    data: Uint8Array | string;
+}
+export interface WasmCompileConfig {
+    /** Module name for imports/exports */
+    moduleName: string;
+    /** Memory pages (64KB each) */
+    memoryPages: number;
+    /** Maximum memory pages */
+    maxMemoryPages?: number;
+    /** Enable debug info in output */
+    debug: boolean;
+    /** Use SIMD instructions when applicable */
+    useSIMD: boolean;
+    /** Enable multi-threading features */
+    useThreads: boolean;
+    /** Target runtime (affects imports) */
+    runtime: 'browser' | 'node' | 'standalone';
+    /** Host imports to expect */
+    hostImports: WasmHostImport[];
+    /** String encoding for data segments */
+    stringEncoding: 'utf8' | 'utf16';
+    /** Optimization level (0=none, 3=max) */
+    optimizationLevel: 0 | 1 | 2 | 3;
+}
+export interface WasmHostImport {
+    module: string;
+    name: string;
+    type: WasmFuncType;
+}
+export declare const defaultWasmConfig: WasmCompileConfig;
+export interface WasmCompileResult {
+    /** WebAssembly Text format output */
+    wat: string;
+    /** Compiled binary (null if compilation unavailable) */
+    wasm: Uint8Array | null;
+    /** Source map for debugging */
+    sourceMap?: WasmSourceMap;
+    /** Compilation errors */
+    errors: WasmCompileError[];
+    /** Compilation warnings */
+    warnings: WasmCompileWarning[];
+    /** Statistics */
+    stats: {
+        funcCount: number;
+        globalCount: number;
+        memoryBytes: number;
+        codeSize: number;
+        compileDuration: number;
+    };
+}
+export interface WasmSourceMap {
+    version: number;
+    sources: string[];
+    mappings: WasmMapping[];
+}
+export interface WasmMapping {
+    wasmOffset: number;
+    sourceFile: number;
+    sourceLine: number;
+    sourceColumn: number;
+}
+export interface WasmCompileError {
+    message: string;
+    nodeId?: string;
+    line?: number;
+}
+export interface WasmCompileWarning {
+    message: string;
+    nodeId?: string;
+    suggestion?: string;
+}
+/** Standard game engine host imports */
+export declare const STANDARD_HOST_IMPORTS: WasmHostImport[];
+export declare class WasmCompiler {
+    private config;
+    private module;
+    private errors;
+    private warnings;
+    private localScope;
+    private globalScope;
+    private funcScope;
+    private labelStack;
+    private nextLocalIndex;
+    private stringTable;
+    private stringDataOffset;
+    private currentFunc;
+    constructor(config?: Partial<WasmCompileConfig>);
+    compile(script: ASTScript): WasmCompileResult;
+    private reset;
+    private setupHostImports;
+    private compileClass;
+    private compileField;
+    private compileFunction;
+    private endsWithReturn;
+    private mapType;
+    private getDefaultValue;
+    private compileStatement;
+    private compileVarDecl;
+    private compileAssignment;
+    private compileIf;
+    private compileWhile;
+    private compileFor;
+    private compileForEach;
+    private compileReturn;
+    private compileExpressionStatement;
+    private compileBlock;
+    private compileSwitch;
+    private compileTry;
+    private compileExpression;
+    private compileLiteral;
+    private addStringToTable;
+    private compileIdentifier;
+    private compileBinaryOp;
+    private compileUnaryOp;
+    private compileCall;
+    private compileMethodCall;
+    private compilePropertyAccess;
+    private compileIndexAccess;
+    private compileConditional;
+    private compileArrayLiteral;
+    private compileCast;
+    private compileNew;
+    private generateWAT;
+    private generateFunctionWAT;
+    private encodeDataSegment;
+    private compileToBinary;
+    /** Create runtime JavaScript glue code for the WASM module */
+    generateRuntimeGlue(): string;
+}
+export declare function compileToWasm(script: ASTScript, config?: Partial<WasmCompileConfig>): WasmCompileResult;
+export declare function generateWasmRuntime(): string;
+export { WasmCompiler as default };

package/dist/types/scripting/exporters/CSharpExporter.d.ts

@@ -1,5 +1,5 @@
-import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTProperty, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTImport, ASTEnum } from '../ScriptAST';
 import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTProperty, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTImport, ASTEnum } from '../ScriptAST';
 export declare class CSharpExporter extends ImperativeLanguageExporter {
     readonly languageName = "csharp";
     readonly fileExtension = "cs";

package/dist/types/scripting/exporters/CppExporter.d.ts

@@ -0,0 +1,61 @@
+import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig, ExportResult } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum } from '../ScriptAST';
+export type CppTarget = 'sdl2' | 'sfml' | 'raylib' | 'generic';
+export declare class CppExporter extends ImperativeLanguageExporter {
+    readonly languageName = "cpp";
+    readonly fileExtension = "cpp";
+    readonly typeMapping: TypeMapping;
+    protected readonly statementTerminator = ";";
+    protected readonly breakKeyword = "break;";
+    protected readonly continueKeyword = "continue;";
+    private target;
+    constructor(config?: Partial<ExportConfig>);
+    export(script: import('../ScriptAST').ASTScript): ExportResult;
+    private generateHeader;
+    private generateHeaderIncludes;
+    private generateHelperStructs;
+    private generateClassHeader;
+    private generateEnumHeader;
+    private generateFieldDeclaration;
+    private generateMethodSignature;
+    protected generateScript(script: ASTScript): string;
+    private generateClassImplementation;
+    private generateClassMethodImpl;
+    protected generateClass(_cls: ASTClass, _builder: CodeBuilder): void;
+    protected generateEnum(_en: ASTEnum, _builder: CodeBuilder): void;
+    protected generateMethod(method: ASTFunction, builder: CodeBuilder): void;
+    protected generateField(_field: ASTField, _builder: CodeBuilder): void;
+    private getBaseClass;
+    private mapCppType;
+    private formatFieldName;
+    private isVirtualMethod;
+    private isOverrideMethod;
+    private convertMethodName;
+    private generateParamsDeclaration;
+    private getDefaultValue;
+    protected generateVarDecl(decl: ASTVarDecl, builder: CodeBuilder): void;
+    protected generateAssignment(assign: ASTAssignment, builder: CodeBuilder): void;
+    protected generateIf(stmt: ASTIf, builder: CodeBuilder): void;
+    protected generateWhile(stmt: ASTWhile, builder: CodeBuilder): void;
+    protected generateFor(stmt: ASTFor, builder: CodeBuilder): void;
+    private generateStatementInline;
+    protected generateForEach(stmt: ASTForEach, builder: CodeBuilder): void;
+    protected generateReturn(stmt: ASTReturn, builder: CodeBuilder): void;
+    protected generateSwitch(stmt: ASTSwitch, builder: CodeBuilder): void;
+    protected generateTry(stmt: ASTTry, builder: CodeBuilder): void;
+    protected generateLiteral(lit: ASTLiteral): string;
+    protected generateBinaryOp(op: ASTBinaryOp): string;
+    protected generateUnaryOp(op: ASTUnaryOp): string;
+    protected generateCall(call: ASTCall): string;
+    protected generateMethodCall(call: ASTMethodCall): string;
+    protected generatePropertyAccess(access: ASTPropertyAccess): string;
+    protected generateIndexAccess(access: ASTIndexAccess): string;
+    protected generateConditional(cond: ASTConditional): string;
+    protected generateArrayLiteral(arr: ASTArrayLiteral): string;
+    protected generateDictionaryLiteral(dict: ASTDictionaryLiteral): string;
+    protected generateCast(cast: ASTCast): string;
+    protected generateLambda(lambda: ASTLambda): string;
+    protected generateNew(newExpr: ASTNew): string;
+    private convertFunctionName;
+}
+export default CppExporter;

package/dist/types/scripting/exporters/GDScriptExporter.d.ts

@@ -1,5 +1,5 @@
-import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum, ASTSignalDef } from '../ScriptAST';
 import { ImperativeLanguageExporter, TypeMapping, CodeBuilder, ExportConfig } from '../LanguageExporter';
+import type { ASTScript, ASTClass, ASTFunction, ASTField, ASTVarDecl, ASTAssignment, ASTIf, ASTWhile, ASTFor, ASTForEach, ASTReturn, ASTSwitch, ASTTry, ASTLiteral, ASTBinaryOp, ASTUnaryOp, ASTCall, ASTMethodCall, ASTPropertyAccess, ASTIndexAccess, ASTConditional, ASTArrayLiteral, ASTDictionaryLiteral, ASTCast, ASTLambda, ASTNew, ASTEnum, ASTSignalDef } from '../ScriptAST';
 export declare class GDScriptExporter extends ImperativeLanguageExporter {
     readonly languageName = "gdscript";
     readonly fileExtension = "gd";