{"version":3,"sources":["~lib/rt/common.ts","src/wasm/assembly/index.ts","src/wasm/assembly/memory.ts","src/wasm/assembly/type-registry.ts","src/wasm/assembly/signature-table.ts","src/wasm/assembly/cache.ts","src/wasm/assembly/dispatch.ts"],"names":[],"mappings":"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","sourceRoot":"./dispatch","sourcesContent":["// Alignment guarantees\n\n// @ts-ignore: decorator\n@inline export const AL_BITS: u32 = 4; // 16 bytes to fit up to v128\n// @ts-ignore: decorator\n@inline export const AL_SIZE: usize = 1 << AL_BITS;\n// @ts-ignore: decorator\n@inline export const AL_MASK: usize = AL_SIZE - 1;\n\n// Extra debugging\n\n// @ts-ignore: decorator\n@inline export const DEBUG = true;\n// @ts-ignore: decorator\n@inline export const TRACE = false;\n// @ts-ignore: decorator\n@inline export const RTRACE = isDefined(ASC_RTRACE);\n// @ts-ignore: decorator\n@inline export const PROFILE = isDefined(ASC_PROFILE);\n\n// Memory manager\n\n// ╒════════════ Memory manager block layout (32-bit) ═════════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ MM info │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class BLOCK {\n /** Memory manager info. */\n mmInfo: usize;\n}\n\n/** Overhead of a memory manager block. */\n// @ts-ignore: decorator\n@inline export const BLOCK_OVERHEAD: usize = offsetof();\n\n/** Maximum size of a memory manager block's payload. */\n// @ts-ignore: decorator\n@inline export const BLOCK_MAXSIZE: usize = (1 << 30) - BLOCK_OVERHEAD;\n\n// Garbage collector\n\n// ╒══════════ Garbage collector object layout (32-bit) ═══════════╕\n// 3 2 1\n// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits\n// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤\n// │ Memory manager block │ -20\n// ╞═══════════════════════════════════════════════════════════════╡\n// │ GC info │ -16\n// ├───────────────────────────────────────────────────────────────┤\n// │ GC info │ -12\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT id │ -8\n// ├───────────────────────────────────────────────────────────────┤\n// │ RT size │ -4\n// ╞>ptr═══════════════════════════════════════════════════════════╡\n// │ ... │\n@unmanaged export class OBJECT extends BLOCK {\n /** Garbage collector info. */\n gcInfo: u32;\n /** Garbage collector info. */\n gcInfo2: u32;\n /** Runtime class id. */\n rtId: u32;\n /** Runtime object size. */\n rtSize: u32;\n}\n\n/** Overhead of a garbage collector object. Excludes memory manager block overhead. */\n// @ts-ignore: decorator\n@inline export const OBJECT_OVERHEAD: usize = (offsetof() - BLOCK_OVERHEAD + AL_MASK) & ~AL_MASK;\n\n/** Maximum size of a garbage collector object's payload. */\n// @ts-ignore: decorator\n@inline export const OBJECT_MAXSIZE: usize = BLOCK_MAXSIZE - OBJECT_OVERHEAD;\n\n/** Total of memory manager and garbage collector overhead. */\n// @ts-ignore: decorator\n@inline export const TOTAL_OVERHEAD: usize = BLOCK_OVERHEAD + OBJECT_OVERHEAD;\n","/**\r\n * AssemblyScript Entry Point for typed-function WASM dispatch\r\n *\r\n * Exports all WASM functions for use by the JavaScript bridge.\r\n */\r\n\r\n// Export version for verification\r\nexport const WASM_VERSION: u32 = 1;\r\n\r\n// Export memory management\r\nexport {\r\n TYPE_REGISTRY_OFFSET,\r\n SIGNATURE_TABLE_OFFSET,\r\n DISPATCH_CACHE_OFFSET,\r\n MAX_TYPES,\r\n MAX_SIGNATURES,\r\n MAX_PARAMS,\r\n CACHE_SLOTS,\r\n getTypeCount,\r\n setTypeCount,\r\n getSignatureCount,\r\n setSignatureCount,\r\n clearMemory,\r\n} from './memory';\r\n\r\n// Export type registry functions\r\nexport {\r\n TYPE_NUMBER,\r\n TYPE_STRING,\r\n TYPE_BOOLEAN,\r\n TYPE_FUNCTION,\r\n TYPE_ARRAY,\r\n TYPE_DATE,\r\n TYPE_REGEXP,\r\n TYPE_OBJECT,\r\n TYPE_NULL,\r\n TYPE_UNDEFINED,\r\n TYPE_ANY,\r\n registerType,\r\n getTypeMask,\r\n getTypeId,\r\n typeMatches,\r\n combineMasks,\r\n getBuiltinMask,\r\n initBuiltinTypes,\r\n} from './type-registry';\r\n\r\n// Export signature table functions\r\nexport {\r\n addSignature,\r\n setParamMask,\r\n getFnIndex,\r\n getParamCount,\r\n getParamMask,\r\n matchSignature,\r\n matchSignature0,\r\n matchSignature1,\r\n matchSignature2,\r\n} from './signature-table';\r\n\r\n// Export dispatch functions\r\nexport {\r\n NO_MATCH,\r\n dispatchFind,\r\n dispatchFind0,\r\n dispatchFind1,\r\n dispatchFind2,\r\n dispatchFindNoCache,\r\n hasSignatureForArgCount,\r\n} from './dispatch';\r\n\r\n// Export cache functions\r\nexport {\r\n cacheLookup,\r\n cacheStore,\r\n clearCache,\r\n invalidateCache,\r\n getCacheStats,\r\n} from './cache';\r\n","/**\r\n * AssemblyScript Memory Layout for typed-function WASM dispatch\r\n *\r\n * Memory is organized in fixed regions to enable efficient dispatch.\r\n * All offsets are in bytes.\r\n */\r\n\r\n// === Memory Region Offsets ===\r\n\r\n/** Start of type registry region (stores type IDs and masks) */\r\nexport const TYPE_REGISTRY_OFFSET: u32 = 0;\r\n\r\n/** Maximum number of types supported */\r\nexport const MAX_TYPES: u32 = 256;\r\n\r\n/** Size of each type entry (4 bytes for ID, 4 bytes for mask) */\r\nexport const TYPE_ENTRY_SIZE: u32 = 8;\r\n\r\n/** Total size of type registry region */\r\nexport const TYPE_REGISTRY_SIZE: u32 = MAX_TYPES * TYPE_ENTRY_SIZE;\r\n\r\n/** Start of signature table region */\r\nexport const SIGNATURE_TABLE_OFFSET: u32 = TYPE_REGISTRY_OFFSET + TYPE_REGISTRY_SIZE;\r\n\r\n/** Maximum number of signatures supported */\r\nexport const MAX_SIGNATURES: u32 = 1024;\r\n\r\n/** Size of each signature entry:\r\n * - 4 bytes: function index\r\n * - 4 bytes: param count\r\n * - 32 bytes: param masks (8 params * 4 bytes each)\r\n */\r\nexport const SIGNATURE_ENTRY_SIZE: u32 = 40;\r\n\r\n/** Maximum parameters per signature for WASM dispatch */\r\nexport const MAX_PARAMS: u32 = 8;\r\n\r\n/** Total size of signature table region */\r\nexport const SIGNATURE_TABLE_SIZE: u32 = MAX_SIGNATURES * SIGNATURE_ENTRY_SIZE;\r\n\r\n/** Start of dispatch cache region */\r\nexport const DISPATCH_CACHE_OFFSET: u32 = SIGNATURE_TABLE_OFFSET + SIGNATURE_TABLE_SIZE;\r\n\r\n/** Number of cache slots (power of 2 for fast modulo) */\r\nexport const CACHE_SLOTS: u32 = 256;\r\n\r\n/** Size of each cache entry:\r\n * - 4 bytes: hash key\r\n * - 4 bytes: function index result\r\n * - 32 bytes: param masks (for validation)\r\n */\r\nexport const CACHE_ENTRY_SIZE: u32 = 40;\r\n\r\n/** Total size of dispatch cache region */\r\nexport const DISPATCH_CACHE_SIZE: u32 = CACHE_SLOTS * CACHE_ENTRY_SIZE;\r\n\r\n/** Start of scratch/temp region */\r\nexport const SCRATCH_OFFSET: u32 = DISPATCH_CACHE_OFFSET + DISPATCH_CACHE_SIZE;\r\n\r\n/** Size of scratch region for temporary computations */\r\nexport const SCRATCH_SIZE: u32 = 1024;\r\n\r\n/** Total memory layout size */\r\nexport const TOTAL_MEMORY_SIZE: u32 = SCRATCH_OFFSET + SCRATCH_SIZE;\r\n\r\n// === Counters ===\r\n\r\n/** Current number of registered types */\r\nlet typeCount: u32 = 0;\r\n\r\n/** Current number of registered signatures */\r\nlet signatureCount: u32 = 0;\r\n\r\n// === Memory Access Helpers ===\r\n\r\n/**\r\n * Get the offset for a type entry by index\r\n */\r\nexport function getTypeOffset(index: u32): u32 {\r\n return TYPE_REGISTRY_OFFSET + index * TYPE_ENTRY_SIZE;\r\n}\r\n\r\n/**\r\n * Get the offset for a signature entry by index\r\n */\r\nexport function getSignatureOffset(index: u32): u32 {\r\n return SIGNATURE_TABLE_OFFSET + index * SIGNATURE_ENTRY_SIZE;\r\n}\r\n\r\n/**\r\n * Get the offset for a cache entry by slot\r\n */\r\nexport function getCacheOffset(slot: u32): u32 {\r\n return DISPATCH_CACHE_OFFSET + slot * CACHE_ENTRY_SIZE;\r\n}\r\n\r\n/**\r\n * Get current type count\r\n */\r\nexport function getTypeCount(): u32 {\r\n return typeCount;\r\n}\r\n\r\n/**\r\n * Set type count\r\n */\r\nexport function setTypeCount(count: u32): void {\r\n typeCount = count;\r\n}\r\n\r\n/**\r\n * Get current signature count\r\n */\r\nexport function getSignatureCount(): u32 {\r\n return signatureCount;\r\n}\r\n\r\n/**\r\n * Set signature count\r\n */\r\nexport function setSignatureCount(count: u32): void {\r\n signatureCount = count;\r\n}\r\n\r\n/**\r\n * Clear all memory regions (reset state)\r\n */\r\nexport function clearMemory(): void {\r\n typeCount = 0;\r\n signatureCount = 0;\r\n\r\n // Clear type registry\r\n for (let i: u32 = 0; i < TYPE_REGISTRY_SIZE; i += 4) {\r\n store(TYPE_REGISTRY_OFFSET + i, 0);\r\n }\r\n\r\n // Clear signature table\r\n for (let i: u32 = 0; i < SIGNATURE_TABLE_SIZE; i += 4) {\r\n store(SIGNATURE_TABLE_OFFSET + i, 0);\r\n }\r\n\r\n // Clear cache\r\n for (let i: u32 = 0; i < DISPATCH_CACHE_SIZE; i += 4) {\r\n store(DISPATCH_CACHE_OFFSET + i, 0);\r\n }\r\n}\r\n","/**\r\n * AssemblyScript Type ID Registry for typed-function WASM dispatch\r\n *\r\n * Stores type IDs and their corresponding bit masks for fast\r\n * type matching during dispatch.\r\n */\r\n\r\nimport {\r\n TYPE_REGISTRY_OFFSET,\r\n TYPE_ENTRY_SIZE,\r\n MAX_TYPES,\r\n getTypeOffset,\r\n getTypeCount,\r\n setTypeCount,\r\n} from './memory';\r\n\r\n// === Built-in Type IDs ===\r\n// These match the bit positions in the JS TypeRegistry\r\n\r\n/** Type ID for number */\r\nexport const TYPE_NUMBER: u32 = 0;\r\n\r\n/** Type ID for string */\r\nexport const TYPE_STRING: u32 = 1;\r\n\r\n/** Type ID for boolean */\r\nexport const TYPE_BOOLEAN: u32 = 2;\r\n\r\n/** Type ID for Function */\r\nexport const TYPE_FUNCTION: u32 = 3;\r\n\r\n/** Type ID for Array */\r\nexport const TYPE_ARRAY: u32 = 4;\r\n\r\n/** Type ID for Date */\r\nexport const TYPE_DATE: u32 = 5;\r\n\r\n/** Type ID for RegExp */\r\nexport const TYPE_REGEXP: u32 = 6;\r\n\r\n/** Type ID for Object */\r\nexport const TYPE_OBJECT: u32 = 7;\r\n\r\n/** Type ID for null */\r\nexport const TYPE_NULL: u32 = 8;\r\n\r\n/** Type ID for undefined */\r\nexport const TYPE_UNDEFINED: u32 = 9;\r\n\r\n/** Type ID for any (matches all) */\r\nexport const TYPE_ANY: u32 = 0xFFFFFFFF;\r\n\r\n/**\r\n * Register a type with its bit mask\r\n *\r\n * @param typeId - The type's unique ID\r\n * @param typeMask - The type's bit mask (1 << typeId for single types)\r\n * @returns The index where the type was stored\r\n */\r\nexport function registerType(typeId: u32, typeMask: u32): u32 {\r\n const count = getTypeCount();\r\n if (count >= MAX_TYPES) {\r\n return 0xFFFFFFFF; // Error: too many types\r\n }\r\n\r\n const offset = getTypeOffset(count);\r\n\r\n // Store type ID at offset\r\n store(offset, typeId);\r\n\r\n // Store type mask at offset + 4\r\n store(offset + 4, typeMask);\r\n\r\n setTypeCount(count + 1);\r\n return count;\r\n}\r\n\r\n/**\r\n * Get the type mask for a registered type\r\n *\r\n * @param index - The type index\r\n * @returns The type's bit mask\r\n */\r\nexport function getTypeMask(index: u32): u32 {\r\n if (index >= getTypeCount()) {\r\n return 0;\r\n }\r\n\r\n const offset = getTypeOffset(index);\r\n return load(offset + 4);\r\n}\r\n\r\n/**\r\n * Get the type ID for a registered type\r\n *\r\n * @param index - The type index\r\n * @returns The type's ID\r\n */\r\nexport function getTypeId(index: u32): u32 {\r\n if (index >= getTypeCount()) {\r\n return 0xFFFFFFFF;\r\n }\r\n\r\n const offset = getTypeOffset(index);\r\n return load(offset);\r\n}\r\n\r\n/**\r\n * Check if a value's type mask matches an expected type mask\r\n *\r\n * @param valueMask - The mask representing the value's type\r\n * @param expectedMask - The mask representing expected types\r\n * @returns true if the value matches any expected type\r\n */\r\nexport function typeMatches(valueMask: u32, expectedMask: u32): bool {\r\n // ANY type matches everything\r\n if (expectedMask === TYPE_ANY) {\r\n return true;\r\n }\r\n\r\n // Check if value's type bit is set in expected mask\r\n return (valueMask & expectedMask) !== 0;\r\n}\r\n\r\n/**\r\n * Create a combined mask from multiple type masks\r\n *\r\n * @param masks - Array of individual type masks\r\n * @returns Combined mask (OR of all input masks)\r\n */\r\nexport function combineMasks(mask1: u32, mask2: u32): u32 {\r\n return mask1 | mask2;\r\n}\r\n\r\n/**\r\n * Get the bit mask for a built-in type ID\r\n *\r\n * @param typeId - The built-in type ID\r\n * @returns The corresponding bit mask\r\n */\r\nexport function getBuiltinMask(typeId: u32): u32 {\r\n if (typeId >= 32) {\r\n return 0; // Only support 32 built-in types\r\n }\r\n return 1 << typeId;\r\n}\r\n\r\n/**\r\n * Find a type by its ID\r\n *\r\n * @param typeId - The type ID to find\r\n * @returns The index of the type, or 0xFFFFFFFF if not found\r\n */\r\nexport function findTypeByIdLoop(typeId: u32): u32 {\r\n const count = getTypeCount();\r\n\r\n for (let i: u32 = 0; i < count; i++) {\r\n if (getTypeId(i) === typeId) {\r\n return i;\r\n }\r\n }\r\n\r\n return 0xFFFFFFFF;\r\n}\r\n\r\n/**\r\n * Initialize built-in types\r\n * Call this once at startup\r\n */\r\nexport function initBuiltinTypes(): void {\r\n registerType(TYPE_NUMBER, 1 << TYPE_NUMBER);\r\n registerType(TYPE_STRING, 1 << TYPE_STRING);\r\n registerType(TYPE_BOOLEAN, 1 << TYPE_BOOLEAN);\r\n registerType(TYPE_FUNCTION, 1 << TYPE_FUNCTION);\r\n registerType(TYPE_ARRAY, 1 << TYPE_ARRAY);\r\n registerType(TYPE_DATE, 1 << TYPE_DATE);\r\n registerType(TYPE_REGEXP, 1 << TYPE_REGEXP);\r\n registerType(TYPE_OBJECT, 1 << TYPE_OBJECT);\r\n registerType(TYPE_NULL, 1 << TYPE_NULL);\r\n registerType(TYPE_UNDEFINED, 1 << TYPE_UNDEFINED);\r\n}\r\n","/**\r\n * AssemblyScript Signature Table for typed-function WASM dispatch\r\n *\r\n * Stores signature metadata for fast matching during dispatch.\r\n * Each signature entry contains:\r\n * - Function index (to return to JS)\r\n * - Parameter count\r\n * - Parameter type masks (up to 8 params)\r\n */\r\n\r\nimport {\r\n SIGNATURE_TABLE_OFFSET,\r\n SIGNATURE_ENTRY_SIZE,\r\n MAX_SIGNATURES,\r\n MAX_PARAMS,\r\n getSignatureOffset,\r\n getSignatureCount,\r\n setSignatureCount,\r\n} from './memory';\r\n\r\n// === Signature Entry Layout ===\r\n// Offset 0: function index (u32)\r\n// Offset 4: param count (u32)\r\n// Offset 8-39: param masks (8 * u32)\r\n\r\n/** Offset of function index within signature entry */\r\nconst FN_INDEX_OFFSET: u32 = 0;\r\n\r\n/** Offset of param count within signature entry */\r\nconst PARAM_COUNT_OFFSET: u32 = 4;\r\n\r\n/** Offset of first param mask within signature entry */\r\nconst PARAM_MASKS_OFFSET: u32 = 8;\r\n\r\n/**\r\n * Add a new signature to the table\r\n *\r\n * @param fnIndex - Index of the function in the JS function table\r\n * @param paramCount - Number of parameters\r\n * @param paramMasks - Array of type masks for each parameter (as a pointer)\r\n * @returns The signature index, or 0xFFFFFFFF on error\r\n */\r\nexport function addSignature(fnIndex: u32, paramCount: u32): u32 {\r\n const count = getSignatureCount();\r\n if (count >= MAX_SIGNATURES) {\r\n return 0xFFFFFFFF; // Error: too many signatures\r\n }\r\n\r\n if (paramCount > MAX_PARAMS) {\r\n return 0xFFFFFFFF; // Error: too many params\r\n }\r\n\r\n const offset = getSignatureOffset(count);\r\n\r\n // Store function index\r\n store(offset + FN_INDEX_OFFSET, fnIndex);\r\n\r\n // Store param count\r\n store(offset + PARAM_COUNT_OFFSET, paramCount);\r\n\r\n // Initialize param masks to 0 (will be set separately)\r\n for (let i: u32 = 0; i < MAX_PARAMS; i++) {\r\n store(offset + PARAM_MASKS_OFFSET + i * 4, 0);\r\n }\r\n\r\n setSignatureCount(count + 1);\r\n return count;\r\n}\r\n\r\n/**\r\n * Set a parameter mask for a signature\r\n *\r\n * @param sigIndex - The signature index\r\n * @param paramIndex - The parameter index (0-7)\r\n * @param mask - The type mask for this parameter\r\n */\r\nexport function setParamMask(sigIndex: u32, paramIndex: u32, mask: u32): void {\r\n if (sigIndex >= getSignatureCount() || paramIndex >= MAX_PARAMS) {\r\n return;\r\n }\r\n\r\n const offset = getSignatureOffset(sigIndex);\r\n store(offset + PARAM_MASKS_OFFSET + paramIndex * 4, mask);\r\n}\r\n\r\n/**\r\n * Get the function index for a signature\r\n *\r\n * @param sigIndex - The signature index\r\n * @returns The function index\r\n */\r\nexport function getFnIndex(sigIndex: u32): u32 {\r\n if (sigIndex >= getSignatureCount()) {\r\n return 0xFFFFFFFF;\r\n }\r\n\r\n const offset = getSignatureOffset(sigIndex);\r\n return load(offset + FN_INDEX_OFFSET);\r\n}\r\n\r\n/**\r\n * Get the parameter count for a signature\r\n *\r\n * @param sigIndex - The signature index\r\n * @returns The number of parameters\r\n */\r\nexport function getParamCount(sigIndex: u32): u32 {\r\n if (sigIndex >= getSignatureCount()) {\r\n return 0;\r\n }\r\n\r\n const offset = getSignatureOffset(sigIndex);\r\n return load(offset + PARAM_COUNT_OFFSET);\r\n}\r\n\r\n/**\r\n * Get a parameter mask for a signature\r\n *\r\n * @param sigIndex - The signature index\r\n * @param paramIndex - The parameter index\r\n * @returns The type mask for this parameter\r\n */\r\nexport function getParamMask(sigIndex: u32, paramIndex: u32): u32 {\r\n if (sigIndex >= getSignatureCount() || paramIndex >= MAX_PARAMS) {\r\n return 0;\r\n }\r\n\r\n const offset = getSignatureOffset(sigIndex);\r\n return load(offset + PARAM_MASKS_OFFSET + paramIndex * 4);\r\n}\r\n\r\n/**\r\n * Check if argument masks match a signature\r\n *\r\n * @param sigIndex - The signature index\r\n * @param argCount - Number of arguments provided\r\n * @param arg0Mask - Type mask for argument 0\r\n * @param arg1Mask - Type mask for argument 1\r\n * @param arg2Mask - Type mask for argument 2 (optional)\r\n * @param arg3Mask - Type mask for argument 3 (optional)\r\n * @returns true if all arguments match\r\n */\r\nexport function matchSignature(\r\n sigIndex: u32,\r\n argCount: u32,\r\n arg0Mask: u32,\r\n arg1Mask: u32,\r\n arg2Mask: u32,\r\n arg3Mask: u32\r\n): bool {\r\n const paramCount = getParamCount(sigIndex);\r\n\r\n // Argument count must match (exact match for now, rest params handled in JS)\r\n if (argCount !== paramCount) {\r\n return false;\r\n }\r\n\r\n const offset = getSignatureOffset(sigIndex);\r\n\r\n // Check each argument against the corresponding parameter mask\r\n if (paramCount >= 1) {\r\n const mask0 = load(offset + PARAM_MASKS_OFFSET);\r\n if (mask0 !== 0xFFFFFFFF && (arg0Mask & mask0) === 0) {\r\n return false;\r\n }\r\n }\r\n\r\n if (paramCount >= 2) {\r\n const mask1 = load(offset + PARAM_MASKS_OFFSET + 4);\r\n if (mask1 !== 0xFFFFFFFF && (arg1Mask & mask1) === 0) {\r\n return false;\r\n }\r\n }\r\n\r\n if (paramCount >= 3) {\r\n const mask2 = load(offset + PARAM_MASKS_OFFSET + 8);\r\n if (mask2 !== 0xFFFFFFFF && (arg2Mask & mask2) === 0) {\r\n return false;\r\n }\r\n }\r\n\r\n if (paramCount >= 4) {\r\n const mask3 = load(offset + PARAM_MASKS_OFFSET + 12);\r\n if (mask3 !== 0xFFFFFFFF && (arg3Mask & mask3) === 0) {\r\n return false;\r\n }\r\n }\r\n\r\n return true;\r\n}\r\n\r\n/**\r\n * Optimized match for 0-parameter signatures\r\n */\r\nexport function matchSignature0(sigIndex: u32, argCount: u32): bool {\r\n return argCount === 0 && getParamCount(sigIndex) === 0;\r\n}\r\n\r\n/**\r\n * Optimized match for 1-parameter signatures\r\n */\r\nexport function matchSignature1(sigIndex: u32, argCount: u32, arg0Mask: u32): bool {\r\n if (argCount !== 1 || getParamCount(sigIndex) !== 1) {\r\n return false;\r\n }\r\n\r\n const offset = getSignatureOffset(sigIndex);\r\n const mask0 = load(offset + PARAM_MASKS_OFFSET);\r\n\r\n return mask0 === 0xFFFFFFFF || (arg0Mask & mask0) !== 0;\r\n}\r\n\r\n/**\r\n * Optimized match for 2-parameter signatures\r\n */\r\nexport function matchSignature2(\r\n sigIndex: u32,\r\n argCount: u32,\r\n arg0Mask: u32,\r\n arg1Mask: u32\r\n): bool {\r\n if (argCount !== 2 || getParamCount(sigIndex) !== 2) {\r\n return false;\r\n }\r\n\r\n const offset = getSignatureOffset(sigIndex);\r\n const mask0 = load(offset + PARAM_MASKS_OFFSET);\r\n const mask1 = load(offset + PARAM_MASKS_OFFSET + 4);\r\n\r\n if (mask0 !== 0xFFFFFFFF && (arg0Mask & mask0) === 0) {\r\n return false;\r\n }\r\n\r\n if (mask1 !== 0xFFFFFFFF && (arg1Mask & mask1) === 0) {\r\n return false;\r\n }\r\n\r\n return true;\r\n}\r\n","/**\r\n * AssemblyScript Dispatch Cache for typed-function WASM dispatch\r\n *\r\n * LRU-style cache with FNV-1a hash for repeated argument patterns.\r\n * Significantly speeds up repeated calls with same argument types.\r\n */\r\n\r\nimport {\r\n DISPATCH_CACHE_OFFSET,\r\n CACHE_SLOTS,\r\n CACHE_ENTRY_SIZE,\r\n getCacheOffset,\r\n} from './memory';\r\n\r\n/** Sentinel value indicating no match found */\r\nconst NO_MATCH: u32 = 0xFFFFFFFF;\r\n\r\n// === Cache Entry Layout ===\r\n// Offset 0: hash key (u32)\r\n// Offset 4: function index result (u32)\r\n// Offset 8: argCount (u32)\r\n// Offset 12: arg0Mask (u32)\r\n// Offset 16: arg1Mask (u32)\r\n// Offset 20: arg2Mask (u32)\r\n// Offset 24: arg3Mask (u32)\r\n// Offset 28: valid flag (u32, 1 = valid, 0 = invalid)\r\n\r\nconst HASH_OFFSET: u32 = 0;\r\nconst RESULT_OFFSET: u32 = 4;\r\nconst ARG_COUNT_OFFSET: u32 = 8;\r\nconst ARG0_OFFSET: u32 = 12;\r\nconst ARG1_OFFSET: u32 = 16;\r\nconst ARG2_OFFSET: u32 = 20;\r\nconst ARG3_OFFSET: u32 = 24;\r\nconst VALID_OFFSET: u32 = 28;\r\n\r\n/** FNV-1a offset basis */\r\nconst FNV_OFFSET_BASIS: u32 = 2166136261;\r\n\r\n/** FNV-1a prime */\r\nconst FNV_PRIME: u32 = 16777619;\r\n\r\n/**\r\n * Compute FNV-1a hash for argument masks\r\n *\r\n * @param argCount - Number of arguments\r\n * @param arg0Mask - Type mask for argument 0\r\n * @param arg1Mask - Type mask for argument 1\r\n * @param arg2Mask - Type mask for argument 2\r\n * @param arg3Mask - Type mask for argument 3\r\n * @returns 32-bit hash value\r\n */\r\nfunction computeHash(\r\n argCount: u32,\r\n arg0Mask: u32,\r\n arg1Mask: u32,\r\n arg2Mask: u32,\r\n arg3Mask: u32\r\n): u32 {\r\n let hash = FNV_OFFSET_BASIS;\r\n\r\n // Hash argCount\r\n hash ^= argCount & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n\r\n // Hash arg0Mask bytes\r\n hash ^= arg0Mask & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg0Mask >> 8) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg0Mask >> 16) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg0Mask >> 24) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n\r\n // Hash arg1Mask bytes\r\n hash ^= arg1Mask & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg1Mask >> 8) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg1Mask >> 16) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg1Mask >> 24) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n\r\n // Hash arg2Mask bytes\r\n hash ^= arg2Mask & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg2Mask >> 8) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg2Mask >> 16) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg2Mask >> 24) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n\r\n // Hash arg3Mask bytes\r\n hash ^= arg3Mask & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg3Mask >> 8) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg3Mask >> 16) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n hash ^= (arg3Mask >> 24) & 0xFF;\r\n hash = hash * FNV_PRIME;\r\n\r\n return hash;\r\n}\r\n\r\n/**\r\n * Get cache slot from hash (using power-of-2 modulo)\r\n */\r\nfunction getSlot(hash: u32): u32 {\r\n return hash & (CACHE_SLOTS - 1);\r\n}\r\n\r\n/**\r\n * Look up a cached dispatch result\r\n *\r\n * @param argCount - Number of arguments\r\n * @param arg0Mask - Type mask for argument 0\r\n * @param arg1Mask - Type mask for argument 1\r\n * @param arg2Mask - Type mask for argument 2\r\n * @param arg3Mask - Type mask for argument 3\r\n * @returns Cached function index, or NO_MATCH if not found\r\n */\r\nexport function cacheLookup(\r\n argCount: u32,\r\n arg0Mask: u32,\r\n arg1Mask: u32,\r\n arg2Mask: u32,\r\n arg3Mask: u32\r\n): u32 {\r\n const hash = computeHash(argCount, arg0Mask, arg1Mask, arg2Mask, arg3Mask);\r\n const slot = getSlot(hash);\r\n const offset = getCacheOffset(slot);\r\n\r\n // Check if slot is valid\r\n const valid = load(offset + VALID_OFFSET);\r\n if (valid !== 1) {\r\n return NO_MATCH;\r\n }\r\n\r\n // Check if hash matches\r\n const storedHash = load(offset + HASH_OFFSET);\r\n if (storedHash !== hash) {\r\n return NO_MATCH;\r\n }\r\n\r\n // Verify all arguments match (to handle hash collisions)\r\n if (load(offset + ARG_COUNT_OFFSET) !== argCount) {\r\n return NO_MATCH;\r\n }\r\n if (load(offset + ARG0_OFFSET) !== arg0Mask) {\r\n return NO_MATCH;\r\n }\r\n if (load(offset + ARG1_OFFSET) !== arg1Mask) {\r\n return NO_MATCH;\r\n }\r\n if (load(offset + ARG2_OFFSET) !== arg2Mask) {\r\n return NO_MATCH;\r\n }\r\n if (load(offset + ARG3_OFFSET) !== arg3Mask) {\r\n return NO_MATCH;\r\n }\r\n\r\n // Return cached result\r\n return load(offset + RESULT_OFFSET);\r\n}\r\n\r\n/**\r\n * Store a dispatch result in the cache\r\n *\r\n * @param argCount - Number of arguments\r\n * @param arg0Mask - Type mask for argument 0\r\n * @param arg1Mask - Type mask for argument 1\r\n * @param arg2Mask - Type mask for argument 2\r\n * @param arg3Mask - Type mask for argument 3\r\n * @param fnIndex - The function index result\r\n */\r\nexport function cacheStore(\r\n argCount: u32,\r\n arg0Mask: u32,\r\n arg1Mask: u32,\r\n arg2Mask: u32,\r\n arg3Mask: u32,\r\n fnIndex: u32\r\n): void {\r\n const hash = computeHash(argCount, arg0Mask, arg1Mask, arg2Mask, arg3Mask);\r\n const slot = getSlot(hash);\r\n const offset = getCacheOffset(slot);\r\n\r\n // Store all values\r\n store(offset + HASH_OFFSET, hash);\r\n store(offset + RESULT_OFFSET, fnIndex);\r\n store(offset + ARG_COUNT_OFFSET, argCount);\r\n store(offset + ARG0_OFFSET, arg0Mask);\r\n store(offset + ARG1_OFFSET, arg1Mask);\r\n store(offset + ARG2_OFFSET, arg2Mask);\r\n store(offset + ARG3_OFFSET, arg3Mask);\r\n store(offset + VALID_OFFSET, 1);\r\n}\r\n\r\n/**\r\n * Clear the entire cache\r\n */\r\nexport function clearCache(): void {\r\n for (let i: u32 = 0; i < CACHE_SLOTS; i++) {\r\n const offset = getCacheOffset(i);\r\n store(offset + VALID_OFFSET, 0);\r\n }\r\n}\r\n\r\n/**\r\n * Invalidate a specific cache entry\r\n */\r\nexport function invalidateCache(\r\n argCount: u32,\r\n arg0Mask: u32,\r\n arg1Mask: u32,\r\n arg2Mask: u32,\r\n arg3Mask: u32\r\n): void {\r\n const hash = computeHash(argCount, arg0Mask, arg1Mask, arg2Mask, arg3Mask);\r\n const slot = getSlot(hash);\r\n const offset = getCacheOffset(slot);\r\n store(offset + VALID_OFFSET, 0);\r\n}\r\n\r\n/**\r\n * Get cache statistics (for debugging)\r\n * Returns number of valid entries\r\n */\r\nexport function getCacheStats(): u32 {\r\n let validCount: u32 = 0;\r\n\r\n for (let i: u32 = 0; i < CACHE_SLOTS; i++) {\r\n const offset = getCacheOffset(i);\r\n if (load(offset + VALID_OFFSET) === 1) {\r\n validCount++;\r\n }\r\n }\r\n\r\n return validCount;\r\n}\r\n","/**\r\n * AssemblyScript Dispatch Loop for typed-function WASM dispatch\r\n *\r\n * Core hot-path dispatch with bit-mask matching.\r\n * Returns the function index for matching signature.\r\n */\r\n\r\nimport { getSignatureCount } from './memory';\r\nimport {\r\n getFnIndex,\r\n getParamCount,\r\n getParamMask,\r\n matchSignature0,\r\n matchSignature1,\r\n matchSignature2,\r\n matchSignature,\r\n} from './signature-table';\r\nimport { cacheLookup, cacheStore } from './cache';\r\n\r\n/** Sentinel value indicating no match found */\r\nexport const NO_MATCH: u32 = 0xFFFFFFFF;\r\n\r\n/**\r\n * Find matching signature for given argument type masks\r\n *\r\n * This is the core dispatch function. It iterates through all signatures\r\n * and returns the function index of the first match.\r\n *\r\n * @param argCount - Number of arguments\r\n * @param arg0Mask - Type mask for argument 0\r\n * @param arg1Mask - Type mask for argument 1\r\n * @param arg2Mask - Type mask for argument 2\r\n * @param arg3Mask - Type mask for argument 3\r\n * @returns Function index of matching signature, or NO_MATCH\r\n */\r\nexport function dispatchFind(\r\n argCount: u32,\r\n arg0Mask: u32,\r\n arg1Mask: u32,\r\n arg2Mask: u32,\r\n arg3Mask: u32\r\n): u32 {\r\n // Try cache first\r\n const cached = cacheLookup(argCount, arg0Mask, arg1Mask, arg2Mask, arg3Mask);\r\n if (cached !== NO_MATCH) {\r\n return cached;\r\n }\r\n\r\n const sigCount = getSignatureCount();\r\n\r\n // Iterate through all signatures\r\n for (let i: u32 = 0; i < sigCount; i++) {\r\n if (matchSignature(i, argCount, arg0Mask, arg1Mask, arg2Mask, arg3Mask)) {\r\n const fnIndex = getFnIndex(i);\r\n // Store in cache for future lookups\r\n cacheStore(argCount, arg0Mask, arg1Mask, arg2Mask, arg3Mask, fnIndex);\r\n return fnIndex;\r\n }\r\n }\r\n\r\n return NO_MATCH;\r\n}\r\n\r\n/**\r\n * Optimized dispatch for 0-argument calls\r\n */\r\nexport function dispatchFind0(): u32 {\r\n // Try cache first\r\n const cached = cacheLookup(0, 0, 0, 0, 0);\r\n if (cached !== NO_MATCH) {\r\n return cached;\r\n }\r\n\r\n const sigCount = getSignatureCount();\r\n\r\n for (let i: u32 = 0; i < sigCount; i++) {\r\n if (matchSignature0(i, 0)) {\r\n const fnIndex = getFnIndex(i);\r\n cacheStore(0, 0, 0, 0, 0, fnIndex);\r\n return fnIndex;\r\n }\r\n }\r\n\r\n return NO_MATCH;\r\n}\r\n\r\n/**\r\n * Optimized dispatch for 1-argument calls\r\n *\r\n * @param arg0Mask - Type mask for the single argument\r\n */\r\nexport function dispatchFind1(arg0Mask: u32): u32 {\r\n // Try cache first\r\n const cached = cacheLookup(1, arg0Mask, 0, 0, 0);\r\n if (cached !== NO_MATCH) {\r\n return cached;\r\n }\r\n\r\n const sigCount = getSignatureCount();\r\n\r\n for (let i: u32 = 0; i < sigCount; i++) {\r\n if (matchSignature1(i, 1, arg0Mask)) {\r\n const fnIndex = getFnIndex(i);\r\n cacheStore(1, arg0Mask, 0, 0, 0, fnIndex);\r\n return fnIndex;\r\n }\r\n }\r\n\r\n return NO_MATCH;\r\n}\r\n\r\n/**\r\n * Optimized dispatch for 2-argument calls\r\n *\r\n * @param arg0Mask - Type mask for argument 0\r\n * @param arg1Mask - Type mask for argument 1\r\n */\r\nexport function dispatchFind2(arg0Mask: u32, arg1Mask: u32): u32 {\r\n // Try cache first\r\n const cached = cacheLookup(2, arg0Mask, arg1Mask, 0, 0);\r\n if (cached !== NO_MATCH) {\r\n return cached;\r\n }\r\n\r\n const sigCount = getSignatureCount();\r\n\r\n for (let i: u32 = 0; i < sigCount; i++) {\r\n if (matchSignature2(i, 2, arg0Mask, arg1Mask)) {\r\n const fnIndex = getFnIndex(i);\r\n cacheStore(2, arg0Mask, arg1Mask, 0, 0, fnIndex);\r\n return fnIndex;\r\n }\r\n }\r\n\r\n return NO_MATCH;\r\n}\r\n\r\n/**\r\n * Dispatch without caching (for one-off calls or testing)\r\n */\r\nexport function dispatchFindNoCache(\r\n argCount: u32,\r\n arg0Mask: u32,\r\n arg1Mask: u32,\r\n arg2Mask: u32,\r\n arg3Mask: u32\r\n): u32 {\r\n const sigCount = getSignatureCount();\r\n\r\n for (let i: u32 = 0; i < sigCount; i++) {\r\n if (matchSignature(i, argCount, arg0Mask, arg1Mask, arg2Mask, arg3Mask)) {\r\n return getFnIndex(i);\r\n }\r\n }\r\n\r\n return NO_MATCH;\r\n}\r\n\r\n/**\r\n * Check if any signature exists that could match given argument count\r\n *\r\n * @param argCount - Number of arguments\r\n * @returns true if at least one signature has matching param count\r\n */\r\nexport function hasSignatureForArgCount(argCount: u32): bool {\r\n const sigCount = getSignatureCount();\r\n\r\n for (let i: u32 = 0; i < sigCount; i++) {\r\n if (getParamCount(i) === argCount) {\r\n return true;\r\n }\r\n }\r\n\r\n return false;\r\n}\r\n"]}