@carbonenginejs/runtime-resource 0.10.0 → 0.11.1

package/dist/formats/webgpu/core/ir/inferValueTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inferValueTypes.js","sources":["../../../../../../src/formats/webgpu/core/ir/inferValueTypes.js"],"sourcesContent":["const COMPONENTS = [ \"x\", \"y\", \"z\", \"w\" ];\nconst COMPONENT_INDEX = new Map(COMPONENTS.map((component, index) => [ component, index ]));\n\nexport const SCALAR_TYPES = Object.freeze([\n    \"unknown\", \"float32\", \"int32\", \"uint32\", \"bool\", \"bitpattern32\"\n]);\n\nconst FLOAT_OPS = new Set([\n    \"add\", \"deriv_rtx\", \"deriv_rty\", \"deriv_rtx_coarse\", \"deriv_rtx_fine\",\n    \"deriv_rty_coarse\", \"deriv_rty_fine\", \"div\", \"dp2\", \"dp3\", \"dp4\",\n    \"exp\", \"frc\", \"log\", \"mad\", \"max\", \"min\", \"mul\", \"rcp\", \"round_ne\",\n    \"round_ni\", \"round_pi\", \"round_z\", \"rsq\", \"sqrt\", \"sincos\"\n]);\nconst FLOAT_COMPARE = new Set([ \"eq\", \"ge\", \"lt\", \"ne\" ]);\nconst INT_OPS = new Set([ \"iadd\", \"imad\", \"imax\", \"imin\", \"imul\", \"ineg\", \"ishl\", \"ishr\" ]);\nconst INT_COMPARE = new Set([ \"ieq\", \"ige\", \"ilt\", \"ine\" ]);\nconst UINT_OPS = new Set([\n    \"countbits\", \"firstbit_hi\", \"firstbit_lo\", \"firstbit_shi\", \"uaddc\",\n    \"ubfe\", \"udiv\", \"umad\", \"umax\", \"umin\", \"umul\", \"ushr\", \"usubb\"\n]);\nconst UINT_COMPARE = new Set([ \"uge\", \"ult\" ]);\nconst BITWISE_OPS = new Set([ \"and\", \"not\", \"or\", \"xor\" ]);\nconst CONTROL_MASK_OPS = new Set([ \"breakc\", \"continuec\", \"discard\", \"if\", \"retc\", \"switch\" ]);\nconst SAMPLE_OPS = new Set([\n    \"sample\", \"sample_b\", \"sample_c\", \"sample_c_lz\", \"sample_d\", \"sample_l\"\n]);\n\nfunction bindingResultType(program, instruction, operandTypeName, resourceKind)\n{\n    const resource = instruction.operands.find((operand) => operand.typeName === operandTypeName);\n    const reference = resource?.resourceReference;\n    const binding = program.bindings.find((entry) => entry.resourceKind === resourceKind\n        && (reference?.rangeId !== null && reference?.rangeId !== undefined\n            ? entry.range.rangeId === reference.rangeId\n            : entry.registerIndex === resource?.registerIndex));\n    const mapped = (binding?.returnType?.returnTypeNames || []).map((type) => ({\n        unorm: \"float32\",\n        snorm: \"float32\",\n        float: \"float32\",\n        sint: \"int32\",\n        uint: \"uint32\"\n    })[type] || \"unknown\");\n    const concrete = mapped.filter((type) => type !== \"unknown\");\n    if (!concrete.length) return null;\n    return new Set(concrete).size === 1 ? concrete[0] : \"bitpattern32\";\n}\n\nfunction sampleResultType(program, instruction)\n{\n    return bindingResultType(program, instruction, \"resource\", \"sampled-resource\");\n}\n\nfunction ruleFor(opcodeName, program, instruction)\n{\n    if (FLOAT_OPS.has(opcodeName)) return { name: \"float-arithmetic\", destination: \"float32\", sources: \"float32\" };\n    if (FLOAT_COMPARE.has(opcodeName)) return { name: \"float-comparison-mask\", destination: \"uint32\", sources: \"float32\" };\n    if (INT_OPS.has(opcodeName)) return { name: \"signed-integer\", destination: \"int32\", sources: \"int32\" };\n    if (INT_COMPARE.has(opcodeName)) return { name: \"signed-comparison-mask\", destination: \"uint32\", sources: \"int32\" };\n    if (UINT_OPS.has(opcodeName)) return { name: \"unsigned-integer\", destination: \"uint32\", sources: \"uint32\" };\n    if (UINT_COMPARE.has(opcodeName)) return { name: \"unsigned-comparison-mask\", destination: \"uint32\", sources: \"uint32\" };\n    if (BITWISE_OPS.has(opcodeName)) return { name: \"bitwise\", destination: \"uint32\", sources: \"uint32\" };\n    if (CONTROL_MASK_OPS.has(opcodeName)) return { name: \"control-mask\", destination: null, sourceByOperand: { 0: \"uint32\" }, conditionProjection: \"nonzero\" };\n    if (SAMPLE_OPS.has(opcodeName))\n    {\n        const sourceByOperand = { 1: \"float32\" };\n        if ([ \"sample_b\", \"sample_c\", \"sample_l\" ].includes(opcodeName)) sourceByOperand[4] = \"float32\";\n        if (opcodeName === \"sample_d\") Object.assign(sourceByOperand, { 4: \"float32\", 5: \"float32\" });\n        return { name: \"sample-resource\", destination: sampleResultType(program, instruction), sourceByOperand };\n    }\n    if (opcodeName === \"resinfo\")\n    {\n        return {\n            name: \"resource-info\",\n            destination: instruction?.resinfoReturnTypeName === \"uint\" ? \"uint32\" : \"float32\"\n        };\n    }\n    if (opcodeName === \"f16tof32\") return { name: \"half-unpack\", destination: \"float32\", sourceByOperand: { 1: \"uint32\" } };\n    if (opcodeName === \"f32tof16\") return { name: \"half-pack\", destination: \"uint32\", sourceByOperand: { 1: \"float32\" } };\n    if (opcodeName === \"ld\")\n    {\n        return {\n            name: \"texture-load\",\n            destination: sampleResultType(program, instruction),\n            sourceByOperand: { 1: \"uint32\" }\n        };\n    }\n    if (opcodeName === \"atomic_iadd\")\n    {\n        return {\n            name: \"atomic-add\",\n            destination: null,\n            sourceByOperand: { 1: \"uint32\", 2: \"uint32\" }\n        };\n    }\n    if (opcodeName === \"store_uav_typed\")\n    {\n        return {\n            name: \"typed-uav-store\",\n            destination: null,\n            sourceByOperand: {\n                1: \"uint32\",\n                2: bindingResultType(program, instruction, \"uav\", \"storage-resource\")\n            }\n        };\n    }\n    if (opcodeName === \"ld_structured\")\n    {\n        return {\n            name: \"structured-load\",\n            destination: null,\n            sourceByOperand: { 1: \"uint32\", 2: \"uint32\" }\n        };\n    }\n    if (opcodeName === \"store_structured\")\n    {\n        return {\n            name: \"structured-store\",\n            destination: null,\n            sourceByOperand: { 1: \"uint32\", 2: \"uint32\" }\n        };\n    }\n    const conversions = {\n        ftoi: [ \"int32\", \"float32\" ],\n        ftou: [ \"uint32\", \"float32\" ],\n        itof: [ \"float32\", \"int32\" ],\n        utof: [ \"float32\", \"uint32\" ]\n    };\n    if (conversions[opcodeName])\n    {\n        const [ destination, source ] = conversions[opcodeName];\n        return { name: \"numeric-conversion\", destination, sourceByOperand: { 1: source }, conversion: { from: source, to: destination } };\n    }\n    if (opcodeName === \"mov\") return { name: \"move\", destination: null, equalitySources: [ 1 ] };\n    if (opcodeName === \"movc\") return { name: \"conditional-move\", destination: null, sourceByOperand: { 1: \"uint32\" }, equalitySources: [ 2, 3 ] };\n    return { name: \"untyped\", destination: null };\n}\n\nfunction nodeKey(ref)\n{\n    return `${ref.valueId}.${ref.component}`;\n}\n\nfunction valueComponents(value)\n{\n    return Array.from(value.writeMask || \"\");\n}\n\nfunction signatureType(program, register, component)\n{\n    if ([ \"output_depth\", \"output_depth_greater_equal\", \"output_depth_less_equal\" ].includes(register)) return \"float32\";\n    const match = /^(input|output)\\[(\\d+)/.exec(register);\n    if (!match) return null;\n    const elements = program.signatures?.[match[1]] || [];\n    const componentBit = 1 << COMPONENT_INDEX.get(component);\n    const element = elements.find((entry) => entry.registerIndex === Number(match[2]) && (entry.mask & componentBit));\n    return element && SCALAR_TYPES.includes(element.componentTypeName) ? element.componentTypeName : null;\n}\n\nfunction correspondingRef(refs, index)\n{\n    if (!refs.length) return null;\n    return refs.length === 1 ? refs[0] : refs[index % refs.length];\n}\n\n/**\n * Infers component storage types from opcode domains, signatures, moves, and\n * SSA merges. Conflicting typeless-register uses become `bitpattern32` and\n * receive explicit per-use reinterpret records.\n *\n * @param {object} program Mutable shader IR under construction.\n * @returns {object} The same program.\n */\nexport function inferValueTypes(program)\n{\n    const parent = new Map();\n    const constraints = new Map();\n\n    const ensure = (ref) =>\n    {\n        const key = nodeKey(ref);\n        if (!parent.has(key))\n        {\n            parent.set(key, key);\n            constraints.set(key, new Set());\n        }\n        return key;\n    };\n    const find = (key) =>\n    {\n        let current = key;\n        while (parent.get(current) !== current) current = parent.get(current);\n        while (parent.get(key) !== key)\n        {\n            const next = parent.get(key);\n            parent.set(key, current);\n            key = next;\n        }\n        return current;\n    };\n    const union = (leftRef, rightRef) =>\n    {\n        const left = find(ensure(leftRef));\n        const right = find(ensure(rightRef));\n        if (left === right) return;\n        const [ root, child ] = left.localeCompare(right) <= 0 ? [ left, right ] : [ right, left ];\n        parent.set(child, root);\n        for (const type of constraints.get(child)) constraints.get(root).add(type);\n    };\n    const constrain = (ref, type) =>\n    {\n        if (!type) return;\n        constraints.get(find(ensure(ref))).add(type);\n    };\n\n    for (const value of program.values)\n    {\n        for (const component of valueComponents(value)) ensure({ valueId: value.id, component });\n        if (value.origin === \"control-flow-merge\")\n        {\n            const mergeRef = { valueId: value.id, component: value.writeMask };\n            for (const incoming of value.incoming) union(mergeRef, incoming);\n        }\n    }\n\n    for (const instruction of program.instructions)\n    {\n        const rule = ruleFor(instruction.opcodeName, program, instruction);\n        const writes = instruction.dataflow.writes;\n        for (const sourceOperandIndex of rule.equalitySources || [])\n        {\n            const read = instruction.dataflow.reads.find((entry) => entry.operandIndex === sourceOperandIndex && entry.kind !== \"index-read\");\n            if (!read) continue;\n            for (const write of writes)\n            {\n                Array.from(write.mask).forEach((component, index) =>\n                {\n                    const sourceRef = correspondingRef(read.refs, index);\n                    if (sourceRef) union({ valueId: write.valueId, component }, sourceRef);\n                });\n            }\n        }\n    }\n\n    for (const value of program.values)\n    {\n        for (const component of valueComponents(value))\n        {\n            const type = signatureType(program, value.register, component);\n            if (type) constrain({ valueId: value.id, component }, type);\n        }\n    }\n    for (const instruction of program.instructions)\n    {\n        const rule = ruleFor(instruction.opcodeName, program, instruction);\n        if (rule.destination)\n        {\n            for (const write of instruction.dataflow.writes)\n            {\n                for (const component of write.mask) constrain({ valueId: write.valueId, component }, rule.destination);\n            }\n        }\n        for (const read of instruction.dataflow.reads)\n        {\n            if (read.kind === \"index-read\") continue;\n            const expected = rule.sourceByOperand?.[read.operandIndex] ?? rule.sources ?? null;\n            for (const ref of read.refs) constrain(ref, expected);\n        }\n    }\n\n    // A live value (read by an instruction or feeding a phi) whose type is\n    // otherwise unconstrained — e.g. an immediate `0` that only ever flows\n    // through moves and never reaches a typed use — defaults to raw bitpattern32\n    // bits so it can be emitted. This covers EVERY lane of a live value, not\n    // just the read lane: an emitted multi-lane value needs a type for its dead\n    // lanes too (the vector constructor references all of them). Because moves\n    // union source and destination, the default propagates consistently across\n    // the whole move chain and any phi it feeds. Genuinely dead writes are never\n    // read, keep no constraint (stay `unknown`), and are dropped by the lowerers.\n    const liveValueIds = new Set();\n    for (const instruction of program.instructions)\n    {\n        for (const read of instruction.dataflow.reads)\n        {\n            if (read.kind === \"index-read\") continue;\n            for (const ref of read.refs) liveValueIds.add(ref.valueId);\n        }\n    }\n    for (const value of program.values)\n    {\n        for (const incoming of value.incoming || []) liveValueIds.add(incoming.valueId);\n    }\n    for (const value of program.values)\n    {\n        if (!liveValueIds.has(value.id)) continue;\n        for (const component of valueComponents(value))\n        {\n            const ref = { valueId: value.id, component };\n            if (!constraints.get(find(ensure(ref))).size) constrain(ref, \"bitpattern32\");\n        }\n    }\n\n    const typeForRef = (ref) =>\n    {\n        const types = Array.from(constraints.get(find(ensure(ref))));\n        if (types.length === 0) return \"unknown\";\n        return types.length === 1 ? types[0] : \"bitpattern32\";\n    };\n\n    for (const value of program.values)\n    {\n        value.componentTypes = {};\n        for (const component of valueComponents(value))\n        {\n            value.componentTypes[component] = typeForRef({ valueId: value.id, component });\n        }\n    }\n\n    for (const instruction of program.instructions)\n    {\n        const rule = ruleFor(instruction.opcodeName, program, instruction);\n        const writes = instruction.dataflow.writes;\n        const destinationTypes = writes.flatMap((write) => Array.from(write.mask)\n            .map((component) => program.values.find((value) => value.id === write.valueId)?.componentTypes[component]))\n            .filter(Boolean);\n        const moveType = destinationTypes.length && new Set(destinationTypes).size === 1 ? destinationTypes[0] : null;\n        const operandTypes = instruction.operands.map((operand, operandIndex) =>\n        {\n            let expectedType = rule.sourceByOperand?.[operandIndex] ?? null;\n            if (!expectedType && rule.sources && operandIndex > 0) expectedType = rule.sources;\n            if (!expectedType && (rule.equalitySources || []).includes(operandIndex)) expectedType = moveType;\n            if (instruction.dataflow.writes.some((write) => write.operandIndex === operandIndex)) expectedType = rule.destination ?? moveType;\n            return {\n                operandIndex,\n                role: instruction.dataflow.writes.some((write) => write.operandIndex === operandIndex) ? \"destination\" : \"source\",\n                expectedType: expectedType || \"unknown\",\n                modifier: operand.modifierName || \"none\",\n                minPrecision: operand.minPrecisionName || \"default\",\n                immediate: operand.typeName === \"immediate32\"\n                    ? operand.immediateValues.map((value, component) => ({ component: COMPONENTS[component], uint32: value.uint32, float32: value.float32 }))\n                    : null\n            };\n        });\n        const bitcasts = [];\n        for (const read of instruction.dataflow.reads)\n        {\n            if (read.kind === \"index-read\") continue;\n            let expected = rule.sourceByOperand?.[read.operandIndex] ?? rule.sources ?? null;\n            if (!expected && (rule.equalitySources || []).includes(read.operandIndex)) expected = moveType;\n            if (!expected || expected === \"unknown\") continue;\n            read.refs.forEach((ref, componentIndex) =>\n            {\n                const storage = typeForRef(ref);\n                if (storage !== expected && storage !== \"unknown\")\n                {\n                    bitcasts.push({ kind: \"read-bitcast\", operandIndex: read.operandIndex, componentIndex, valueId: ref.valueId, component: ref.component, from: storage, to: expected });\n                }\n            });\n        }\n        for (const write of writes)\n        {\n            if (!rule.destination) continue;\n            Array.from(write.mask).forEach((component) =>\n            {\n                const storage = typeForRef({ valueId: write.valueId, component });\n                if (storage !== rule.destination && storage !== \"unknown\")\n                {\n                    bitcasts.push({ kind: \"result-bitcast\", operandIndex: write.operandIndex, valueId: write.valueId, component, from: rule.destination, to: storage });\n                }\n            });\n        }\n        for (const operand of operandTypes)\n        {\n            if (!operand.immediate || ![ \"float32\", \"int32\" ].includes(operand.expectedType)) continue;\n            for (const immediate of operand.immediate)\n            {\n                bitcasts.push({ kind: \"immediate-bitcast\", operandIndex: operand.operandIndex, component: immediate.component, from: \"uint32\", to: operand.expectedType, uint32: immediate.uint32 });\n            }\n        }\n        instruction.typeInfo = {\n            kind: \"instruction-types\",\n            rule: rule.name,\n            resultType: rule.destination ?? moveType ?? \"unknown\",\n            conversion: rule.conversion || null,\n            conditionProjection: rule.conditionProjection || null,\n            operandTypes,\n            bitcasts\n        };\n    }\n\n    program.typeSystem = {\n        kind: \"scalar-type-system\",\n        scalarTypes: SCALAR_TYPES.slice(),\n        comparisonResult: \"uint32-mask\",\n        conditionProjection: \"nonzero\",\n        registerStorage: \"component-granular\"\n    };\n    return program;\n}\n"],"names":["COMPONENTS","COMPONENT_INDEX","Map","map","component","index","SCALAR_TYPES","Object","freeze","FLOAT_OPS","Set","FLOAT_COMPARE","INT_OPS","INT_COMPARE","UINT_OPS","UINT_COMPARE","BITWISE_OPS","CONTROL_MASK_OPS","SAMPLE_OPS","bindingResultType","program","instruction","operandTypeName","resourceKind","resource","operands","find","operand","typeName","reference","resourceReference","binding","bindings","entry","rangeId","undefined","range","registerIndex","mapped","returnType","returnTypeNames","type","unorm","snorm","float","sint","uint","concrete","filter","length","size","sampleResultType","ruleFor","opcodeName","has","name","destination","sources","sourceByOperand","conditionProjection","includes","assign","resinfoReturnTypeName","conversions","ftoi","ftou","itof","utof","source","conversion","from","to","equalitySources","nodeKey","ref","valueId","valueComponents","value","Array","writeMask","signatureType","register","match","exec","elements","signatures","componentBit","get","element","Number","mask","componentTypeName","correspondingRef","refs","inferValueTypes","parent","constraints","ensure","key","set","current","next","union","leftRef","rightRef","left","right","root","child","localeCompare","add","constrain","values","id","origin","mergeRef","incoming","instructions","rule","writes","dataflow","sourceOperandIndex","read","reads","operandIndex","kind","write","forEach","sourceRef","expected","liveValueIds","typeForRef","types","componentTypes","destinationTypes","flatMap","Boolean","moveType","operandTypes","expectedType","some","role","modifier","modifierName","minPrecision","minPrecisionName","immediate","immediateValues","uint32","float32","bitcasts","componentIndex","storage","push","typeInfo","resultType","typeSystem","scalarTypes","slice","comparisonResult","registerStorage"],"mappings":"AAAA,MAAMA,UAAU,GAAG,CAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAE;AACzC,MAAMC,eAAe,GAAG,IAAIC,GAAG,CAACF,UAAU,CAACG,GAAG,CAAC,CAACC,SAAS,EAAEC,KAAK,KAAK,CAAED,SAAS,EAAEC,KAAK,CAAE,CAAC,CAAC;AAEpF,MAAMC,YAAY,GAAGC,MAAM,CAACC,MAAM,CAAC,CACtC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,CAClE;AAED,MAAMC,SAAS,GAAG,IAAIC,GAAG,CAAC,CACtB,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,kBAAkB,EAAE,gBAAgB,EACrE,kBAAkB,EAAE,gBAAgB,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAChE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAClE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAC7D,CAAC;AACF,MAAMC,aAAa,GAAG,IAAID,GAAG,CAAC,CAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAE,CAAC;AACzD,MAAME,OAAO,GAAG,IAAIF,GAAG,CAAC,CAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAE,CAAC;AAC3F,MAAMG,WAAW,GAAG,IAAIH,GAAG,CAAC,CAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAE,CAAC;AAC3D,MAAMI,QAAQ,GAAG,IAAIJ,GAAG,CAAC,CACrB,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,OAAO,EAClE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAClE,CAAC;AACF,MAAMK,YAAY,GAAG,IAAIL,GAAG,CAAC,CAAE,KAAK,EAAE,KAAK,CAAE,CAAC;AAC9C,MAAMM,WAAW,GAAG,IAAIN,GAAG,CAAC,CAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAE,CAAC;AAC1D,MAAMO,gBAAgB,GAAG,IAAIP,GAAG,CAAC,CAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAE,CAAC;AAC9F,MAAMQ,UAAU,GAAG,IAAIR,GAAG,CAAC,CACvB,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,CAC1E,CAAC;AAEF,SAASS,iBAAiBA,CAACC,OAAO,EAAEC,WAAW,EAAEC,eAAe,EAAEC,YAAY,EAC9E;AACI,EAAA,MAAMC,QAAQ,GAAGH,WAAW,CAACI,QAAQ,CAACC,IAAI,CAAEC,OAAO,IAAKA,OAAO,CAACC,QAAQ,KAAKN,eAAe,CAAC;AAC7F,EAAA,MAAMO,SAAS,GAAGL,QAAQ,EAAEM,iBAAiB;EAC7C,MAAMC,OAAO,GAAGX,OAAO,CAACY,QAAQ,CAACN,IAAI,CAAEO,KAAK,IAAKA,KAAK,CAACV,YAAY,KAAKA,YAAY,KAC5EM,SAAS,EAAEK,OAAO,KAAK,IAAI,IAAIL,SAAS,EAAEK,OAAO,KAAKC,SAAS,GAC7DF,KAAK,CAACG,KAAK,CAACF,OAAO,KAAKL,SAAS,CAACK,OAAO,GACzCD,KAAK,CAACI,aAAa,KAAKb,QAAQ,EAAEa,aAAa,CAAC,CAAC;AAC3D,EAAA,MAAMC,MAAM,GAAG,CAACP,OAAO,EAAEQ,UAAU,EAAEC,eAAe,IAAI,EAAE,EAAErC,GAAG,CAAEsC,IAAI,IAAK,CAAC;AACvEC,IAAAA,KAAK,EAAE,SAAS;AAChBC,IAAAA,KAAK,EAAE,SAAS;AAChBC,IAAAA,KAAK,EAAE,SAAS;AAChBC,IAAAA,IAAI,EAAE,OAAO;AACbC,IAAAA,IAAI,EAAE;AACV,GAAC,EAAEL,IAAI,CAAC,IAAI,SAAS,CAAC;EACtB,MAAMM,QAAQ,GAAGT,MAAM,CAACU,MAAM,CAAEP,IAAI,IAAKA,IAAI,KAAK,SAAS,CAAC;AAC5D,EAAA,IAAI,CAACM,QAAQ,CAACE,MAAM,EAAE,OAAO,IAAI;AACjC,EAAA,OAAO,IAAIvC,GAAG,CAACqC,QAAQ,CAAC,CAACG,IAAI,KAAK,CAAC,GAAGH,QAAQ,CAAC,CAAC,CAAC,GAAG,cAAc;AACtE;AAEA,SAASI,gBAAgBA,CAAC/B,OAAO,EAAEC,WAAW,EAC9C;EACI,OAAOF,iBAAiB,CAACC,OAAO,EAAEC,WAAW,EAAE,UAAU,EAAE,kBAAkB,CAAC;AAClF;AAEA,SAAS+B,OAAOA,CAACC,UAAU,EAAEjC,OAAO,EAAEC,WAAW,EACjD;AACI,EAAA,IAAIZ,SAAS,CAAC6C,GAAG,CAACD,UAAU,CAAC,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,kBAAkB;AAAEC,IAAAA,WAAW,EAAE,SAAS;AAAEC,IAAAA,OAAO,EAAE;GAAW;AAC9G,EAAA,IAAI9C,aAAa,CAAC2C,GAAG,CAACD,UAAU,CAAC,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,uBAAuB;AAAEC,IAAAA,WAAW,EAAE,QAAQ;AAAEC,IAAAA,OAAO,EAAE;GAAW;AACtH,EAAA,IAAI7C,OAAO,CAAC0C,GAAG,CAACD,UAAU,CAAC,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,gBAAgB;AAAEC,IAAAA,WAAW,EAAE,OAAO;AAAEC,IAAAA,OAAO,EAAE;GAAS;AACtG,EAAA,IAAI5C,WAAW,CAACyC,GAAG,CAACD,UAAU,CAAC,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,wBAAwB;AAAEC,IAAAA,WAAW,EAAE,QAAQ;AAAEC,IAAAA,OAAO,EAAE;GAAS;AACnH,EAAA,IAAI3C,QAAQ,CAACwC,GAAG,CAACD,UAAU,CAAC,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,kBAAkB;AAAEC,IAAAA,WAAW,EAAE,QAAQ;AAAEC,IAAAA,OAAO,EAAE;GAAU;AAC3G,EAAA,IAAI1C,YAAY,CAACuC,GAAG,CAACD,UAAU,CAAC,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,0BAA0B;AAAEC,IAAAA,WAAW,EAAE,QAAQ;AAAEC,IAAAA,OAAO,EAAE;GAAU;AACvH,EAAA,IAAIzC,WAAW,CAACsC,GAAG,CAACD,UAAU,CAAC,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,SAAS;AAAEC,IAAAA,WAAW,EAAE,QAAQ;AAAEC,IAAAA,OAAO,EAAE;GAAU;AACrG,EAAA,IAAIxC,gBAAgB,CAACqC,GAAG,CAACD,UAAU,CAAC,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,cAAc;AAAEC,IAAAA,WAAW,EAAE,IAAI;AAAEE,IAAAA,eAAe,EAAE;AAAE,MAAA,CAAC,EAAE;KAAU;AAAEC,IAAAA,mBAAmB,EAAE;GAAW;AAC1J,EAAA,IAAIzC,UAAU,CAACoC,GAAG,CAACD,UAAU,CAAC,EAC9B;AACI,IAAA,MAAMK,eAAe,GAAG;AAAE,MAAA,CAAC,EAAE;KAAW;AACxC,IAAA,IAAI,CAAE,UAAU,EAAE,UAAU,EAAE,UAAU,CAAE,CAACE,QAAQ,CAACP,UAAU,CAAC,EAAEK,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS;IAC/F,IAAIL,UAAU,KAAK,UAAU,EAAE9C,MAAM,CAACsD,MAAM,CAACH,eAAe,EAAE;AAAE,MAAA,CAAC,EAAE,SAAS;AAAE,MAAA,CAAC,EAAE;AAAU,KAAC,CAAC;IAC7F,OAAO;AAAEH,MAAAA,IAAI,EAAE,iBAAiB;AAAEC,MAAAA,WAAW,EAAEL,gBAAgB,CAAC/B,OAAO,EAAEC,WAAW,CAAC;AAAEqC,MAAAA;KAAiB;AAC5G,EAAA;EACA,IAAIL,UAAU,KAAK,SAAS,EAC5B;IACI,OAAO;AACHE,MAAAA,IAAI,EAAE,eAAe;MACrBC,WAAW,EAAEnC,WAAW,EAAEyC,qBAAqB,KAAK,MAAM,GAAG,QAAQ,GAAG;KAC3E;AACL,EAAA;AACA,EAAA,IAAIT,UAAU,KAAK,UAAU,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,aAAa;AAAEC,IAAAA,WAAW,EAAE,SAAS;AAAEE,IAAAA,eAAe,EAAE;AAAE,MAAA,CAAC,EAAE;AAAS;GAAG;AACvH,EAAA,IAAIL,UAAU,KAAK,UAAU,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,WAAW;AAAEC,IAAAA,WAAW,EAAE,QAAQ;AAAEE,IAAAA,eAAe,EAAE;AAAE,MAAA,CAAC,EAAE;AAAU;GAAG;EACrH,IAAIL,UAAU,KAAK,IAAI,EACvB;IACI,OAAO;AACHE,MAAAA,IAAI,EAAE,cAAc;AACpBC,MAAAA,WAAW,EAAEL,gBAAgB,CAAC/B,OAAO,EAAEC,WAAW,CAAC;AACnDqC,MAAAA,eAAe,EAAE;AAAE,QAAA,CAAC,EAAE;AAAS;KAClC;AACL,EAAA;EACA,IAAIL,UAAU,KAAK,aAAa,EAChC;IACI,OAAO;AACHE,MAAAA,IAAI,EAAE,YAAY;AAClBC,MAAAA,WAAW,EAAE,IAAI;AACjBE,MAAAA,eAAe,EAAE;AAAE,QAAA,CAAC,EAAE,QAAQ;AAAE,QAAA,CAAC,EAAE;AAAS;KAC/C;AACL,EAAA;EACA,IAAIL,UAAU,KAAK,iBAAiB,EACpC;IACI,OAAO;AACHE,MAAAA,IAAI,EAAE,iBAAiB;AACvBC,MAAAA,WAAW,EAAE,IAAI;AACjBE,MAAAA,eAAe,EAAE;AACb,QAAA,CAAC,EAAE,QAAQ;QACX,CAAC,EAAEvC,iBAAiB,CAACC,OAAO,EAAEC,WAAW,EAAE,KAAK,EAAE,kBAAkB;AACxE;KACH;AACL,EAAA;EACA,IAAIgC,UAAU,KAAK,eAAe,EAClC;IACI,OAAO;AACHE,MAAAA,IAAI,EAAE,iBAAiB;AACvBC,MAAAA,WAAW,EAAE,IAAI;AACjBE,MAAAA,eAAe,EAAE;AAAE,QAAA,CAAC,EAAE,QAAQ;AAAE,QAAA,CAAC,EAAE;AAAS;KAC/C;AACL,EAAA;EACA,IAAIL,UAAU,KAAK,kBAAkB,EACrC;IACI,OAAO;AACHE,MAAAA,IAAI,EAAE,kBAAkB;AACxBC,MAAAA,WAAW,EAAE,IAAI;AACjBE,MAAAA,eAAe,EAAE;AAAE,QAAA,CAAC,EAAE,QAAQ;AAAE,QAAA,CAAC,EAAE;AAAS;KAC/C;AACL,EAAA;AACA,EAAA,MAAMK,WAAW,GAAG;AAChBC,IAAAA,IAAI,EAAE,CAAE,OAAO,EAAE,SAAS,CAAE;AAC5BC,IAAAA,IAAI,EAAE,CAAE,QAAQ,EAAE,SAAS,CAAE;AAC7BC,IAAAA,IAAI,EAAE,CAAE,SAAS,EAAE,OAAO,CAAE;AAC5BC,IAAAA,IAAI,EAAE,CAAE,SAAS,EAAE,QAAQ;GAC9B;AACD,EAAA,IAAIJ,WAAW,CAACV,UAAU,CAAC,EAC3B;IACI,MAAM,CAAEG,WAAW,EAAEY,MAAM,CAAE,GAAGL,WAAW,CAACV,UAAU,CAAC;IACvD,OAAO;AAAEE,MAAAA,IAAI,EAAE,oBAAoB;MAAEC,WAAW;AAAEE,MAAAA,eAAe,EAAE;AAAE,QAAA,CAAC,EAAEU;OAAQ;AAAEC,MAAAA,UAAU,EAAE;AAAEC,QAAAA,IAAI,EAAEF,MAAM;AAAEG,QAAAA,EAAE,EAAEf;AAAY;KAAG;AACrI,EAAA;AACA,EAAA,IAAIH,UAAU,KAAK,KAAK,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,MAAM;AAAEC,IAAAA,WAAW,EAAE,IAAI;IAAEgB,eAAe,EAAE,CAAE,CAAC;GAAI;AAC5F,EAAA,IAAInB,UAAU,KAAK,MAAM,EAAE,OAAO;AAAEE,IAAAA,IAAI,EAAE,kBAAkB;AAAEC,IAAAA,WAAW,EAAE,IAAI;AAAEE,IAAAA,eAAe,EAAE;AAAE,MAAA,CAAC,EAAE;KAAU;AAAEc,IAAAA,eAAe,EAAE,CAAE,CAAC,EAAE,CAAC;GAAI;EAC9I,OAAO;AAAEjB,IAAAA,IAAI,EAAE,SAAS;AAAEC,IAAAA,WAAW,EAAE;GAAM;AACjD;AAEA,SAASiB,OAAOA,CAACC,GAAG,EACpB;EACI,OAAO,CAAA,EAAGA,GAAG,CAACC,OAAO,IAAID,GAAG,CAACtE,SAAS,CAAA,CAAE;AAC5C;AAEA,SAASwE,eAAeA,CAACC,KAAK,EAC9B;EACI,OAAOC,KAAK,CAACR,IAAI,CAACO,KAAK,CAACE,SAAS,IAAI,EAAE,CAAC;AAC5C;AAEA,SAASC,aAAaA,CAAC5D,OAAO,EAAE6D,QAAQ,EAAE7E,SAAS,EACnD;AACI,EAAA,IAAI,CAAE,cAAc,EAAE,4BAA4B,EAAE,yBAAyB,CAAE,CAACwD,QAAQ,CAACqB,QAAQ,CAAC,EAAE,OAAO,SAAS;AACpH,EAAA,MAAMC,KAAK,GAAG,wBAAwB,CAACC,IAAI,CAACF,QAAQ,CAAC;AACrD,EAAA,IAAI,CAACC,KAAK,EAAE,OAAO,IAAI;AACvB,EAAA,MAAME,QAAQ,GAAGhE,OAAO,CAACiE,UAAU,GAAGH,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;EACrD,MAAMI,YAAY,GAAG,CAAC,IAAIrF,eAAe,CAACsF,GAAG,CAACnF,SAAS,CAAC;EACxD,MAAMoF,OAAO,GAAGJ,QAAQ,CAAC1D,IAAI,CAAEO,KAAK,IAAKA,KAAK,CAACI,aAAa,KAAKoD,MAAM,CAACP,KAAK,CAAC,CAAC,CAAC,CAAC,IAAKjD,KAAK,CAACyD,IAAI,GAAGJ,YAAa,CAAC;AACjH,EAAA,OAAOE,OAAO,IAAIlF,YAAY,CAACsD,QAAQ,CAAC4B,OAAO,CAACG,iBAAiB,CAAC,GAAGH,OAAO,CAACG,iBAAiB,GAAG,IAAI;AACzG;AAEA,SAASC,gBAAgBA,CAACC,IAAI,EAAExF,KAAK,EACrC;AACI,EAAA,IAAI,CAACwF,IAAI,CAAC5C,MAAM,EAAE,OAAO,IAAI;AAC7B,EAAA,OAAO4C,IAAI,CAAC5C,MAAM,KAAK,CAAC,GAAG4C,IAAI,CAAC,CAAC,CAAC,GAAGA,IAAI,CAACxF,KAAK,GAAGwF,IAAI,CAAC5C,MAAM,CAAC;AAClE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS6C,eAAeA,CAAC1E,OAAO,EACvC;AACI,EAAA,MAAM2E,MAAM,GAAG,IAAI7F,GAAG,EAAE;AACxB,EAAA,MAAM8F,WAAW,GAAG,IAAI9F,GAAG,EAAE;EAE7B,MAAM+F,MAAM,GAAIvB,GAAG,IACnB;AACI,IAAA,MAAMwB,GAAG,GAAGzB,OAAO,CAACC,GAAG,CAAC;AACxB,IAAA,IAAI,CAACqB,MAAM,CAACzC,GAAG,CAAC4C,GAAG,CAAC,EACpB;AACIH,MAAAA,MAAM,CAACI,GAAG,CAACD,GAAG,EAAEA,GAAG,CAAC;MACpBF,WAAW,CAACG,GAAG,CAACD,GAAG,EAAE,IAAIxF,GAAG,EAAE,CAAC;AACnC,IAAA;AACA,IAAA,OAAOwF,GAAG;EACd,CAAC;EACD,MAAMxE,IAAI,GAAIwE,GAAG,IACjB;IACI,IAAIE,OAAO,GAAGF,GAAG;AACjB,IAAA,OAAOH,MAAM,CAACR,GAAG,CAACa,OAAO,CAAC,KAAKA,OAAO,EAAEA,OAAO,GAAGL,MAAM,CAACR,GAAG,CAACa,OAAO,CAAC;IACrE,OAAOL,MAAM,CAACR,GAAG,CAACW,GAAG,CAAC,KAAKA,GAAG,EAC9B;AACI,MAAA,MAAMG,IAAI,GAAGN,MAAM,CAACR,GAAG,CAACW,GAAG,CAAC;AAC5BH,MAAAA,MAAM,CAACI,GAAG,CAACD,GAAG,EAAEE,OAAO,CAAC;AACxBF,MAAAA,GAAG,GAAGG,IAAI;AACd,IAAA;AACA,IAAA,OAAOD,OAAO;EAClB,CAAC;AACD,EAAA,MAAME,KAAK,GAAGA,CAACC,OAAO,EAAEC,QAAQ,KAChC;IACI,MAAMC,IAAI,GAAG/E,IAAI,CAACuE,MAAM,CAACM,OAAO,CAAC,CAAC;IAClC,MAAMG,KAAK,GAAGhF,IAAI,CAACuE,MAAM,CAACO,QAAQ,CAAC,CAAC;IACpC,IAAIC,IAAI,KAAKC,KAAK,EAAE;IACpB,MAAM,CAAEC,IAAI,EAAEC,KAAK,CAAE,GAAGH,IAAI,CAACI,aAAa,CAACH,KAAK,CAAC,IAAI,CAAC,GAAG,CAAED,IAAI,EAAEC,KAAK,CAAE,GAAG,CAAEA,KAAK,EAAED,IAAI,CAAE;AAC1FV,IAAAA,MAAM,CAACI,GAAG,CAACS,KAAK,EAAED,IAAI,CAAC;IACvB,KAAK,MAAMlE,IAAI,IAAIuD,WAAW,CAACT,GAAG,CAACqB,KAAK,CAAC,EAAEZ,WAAW,CAACT,GAAG,CAACoB,IAAI,CAAC,CAACG,GAAG,CAACrE,IAAI,CAAC;EAC9E,CAAC;AACD,EAAA,MAAMsE,SAAS,GAAGA,CAACrC,GAAG,EAAEjC,IAAI,KAC5B;IACI,IAAI,CAACA,IAAI,EAAE;AACXuD,IAAAA,WAAW,CAACT,GAAG,CAAC7D,IAAI,CAACuE,MAAM,CAACvB,GAAG,CAAC,CAAC,CAAC,CAACoC,GAAG,CAACrE,IAAI,CAAC;EAChD,CAAC;AAED,EAAA,KAAK,MAAMoC,KAAK,IAAIzD,OAAO,CAAC4F,MAAM,EAClC;IACI,KAAK,MAAM5G,SAAS,IAAIwE,eAAe,CAACC,KAAK,CAAC,EAAEoB,MAAM,CAAC;MAAEtB,OAAO,EAAEE,KAAK,CAACoC,EAAE;AAAE7G,MAAAA;AAAU,KAAC,CAAC;AACxF,IAAA,IAAIyE,KAAK,CAACqC,MAAM,KAAK,oBAAoB,EACzC;AACI,MAAA,MAAMC,QAAQ,GAAG;QAAExC,OAAO,EAAEE,KAAK,CAACoC,EAAE;QAAE7G,SAAS,EAAEyE,KAAK,CAACE;OAAW;AAClE,MAAA,KAAK,MAAMqC,QAAQ,IAAIvC,KAAK,CAACuC,QAAQ,EAAEd,KAAK,CAACa,QAAQ,EAAEC,QAAQ,CAAC;AACpE,IAAA;AACJ,EAAA;AAEA,EAAA,KAAK,MAAM/F,WAAW,IAAID,OAAO,CAACiG,YAAY,EAC9C;IACI,MAAMC,IAAI,GAAGlE,OAAO,CAAC/B,WAAW,CAACgC,UAAU,EAAEjC,OAAO,EAAEC,WAAW,CAAC;AAClE,IAAA,MAAMkG,MAAM,GAAGlG,WAAW,CAACmG,QAAQ,CAACD,MAAM;IAC1C,KAAK,MAAME,kBAAkB,IAAIH,IAAI,CAAC9C,eAAe,IAAI,EAAE,EAC3D;MACI,MAAMkD,IAAI,GAAGrG,WAAW,CAACmG,QAAQ,CAACG,KAAK,CAACjG,IAAI,CAAEO,KAAK,IAAKA,KAAK,CAAC2F,YAAY,KAAKH,kBAAkB,IAAIxF,KAAK,CAAC4F,IAAI,KAAK,YAAY,CAAC;MACjI,IAAI,CAACH,IAAI,EAAE;AACX,MAAA,KAAK,MAAMI,KAAK,IAAIP,MAAM,EAC1B;AACIzC,QAAAA,KAAK,CAACR,IAAI,CAACwD,KAAK,CAACpC,IAAI,CAAC,CAACqC,OAAO,CAAC,CAAC3H,SAAS,EAAEC,KAAK,KAChD;UACI,MAAM2H,SAAS,GAAGpC,gBAAgB,CAAC8B,IAAI,CAAC7B,IAAI,EAAExF,KAAK,CAAC;UACpD,IAAI2H,SAAS,EAAE1B,KAAK,CAAC;YAAE3B,OAAO,EAAEmD,KAAK,CAACnD,OAAO;AAAEvE,YAAAA;WAAW,EAAE4H,SAAS,CAAC;AAC1E,QAAA,CAAC,CAAC;AACN,MAAA;AACJ,IAAA;AACJ,EAAA;AAEA,EAAA,KAAK,MAAMnD,KAAK,IAAIzD,OAAO,CAAC4F,MAAM,EAClC;AACI,IAAA,KAAK,MAAM5G,SAAS,IAAIwE,eAAe,CAACC,KAAK,CAAC,EAC9C;MACI,MAAMpC,IAAI,GAAGuC,aAAa,CAAC5D,OAAO,EAAEyD,KAAK,CAACI,QAAQ,EAAE7E,SAAS,CAAC;MAC9D,IAAIqC,IAAI,EAAEsE,SAAS,CAAC;QAAEpC,OAAO,EAAEE,KAAK,CAACoC,EAAE;AAAE7G,QAAAA;OAAW,EAAEqC,IAAI,CAAC;AAC/D,IAAA;AACJ,EAAA;AACA,EAAA,KAAK,MAAMpB,WAAW,IAAID,OAAO,CAACiG,YAAY,EAC9C;IACI,MAAMC,IAAI,GAAGlE,OAAO,CAAC/B,WAAW,CAACgC,UAAU,EAAEjC,OAAO,EAAEC,WAAW,CAAC;IAClE,IAAIiG,IAAI,CAAC9D,WAAW,EACpB;MACI,KAAK,MAAMsE,KAAK,IAAIzG,WAAW,CAACmG,QAAQ,CAACD,MAAM,EAC/C;QACI,KAAK,MAAMnH,SAAS,IAAI0H,KAAK,CAACpC,IAAI,EAAEqB,SAAS,CAAC;UAAEpC,OAAO,EAAEmD,KAAK,CAACnD,OAAO;AAAEvE,UAAAA;AAAU,SAAC,EAAEkH,IAAI,CAAC9D,WAAW,CAAC;AAC1G,MAAA;AACJ,IAAA;IACA,KAAK,MAAMkE,IAAI,IAAIrG,WAAW,CAACmG,QAAQ,CAACG,KAAK,EAC7C;AACI,MAAA,IAAID,IAAI,CAACG,IAAI,KAAK,YAAY,EAAE;AAChC,MAAA,MAAMI,QAAQ,GAAGX,IAAI,CAAC5D,eAAe,GAAGgE,IAAI,CAACE,YAAY,CAAC,IAAIN,IAAI,CAAC7D,OAAO,IAAI,IAAI;AAClF,MAAA,KAAK,MAAMiB,GAAG,IAAIgD,IAAI,CAAC7B,IAAI,EAAEkB,SAAS,CAACrC,GAAG,EAAEuD,QAAQ,CAAC;AACzD,IAAA;AACJ,EAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAA,MAAMC,YAAY,GAAG,IAAIxH,GAAG,EAAE;AAC9B,EAAA,KAAK,MAAMW,WAAW,IAAID,OAAO,CAACiG,YAAY,EAC9C;IACI,KAAK,MAAMK,IAAI,IAAIrG,WAAW,CAACmG,QAAQ,CAACG,KAAK,EAC7C;AACI,MAAA,IAAID,IAAI,CAACG,IAAI,KAAK,YAAY,EAAE;AAChC,MAAA,KAAK,MAAMnD,GAAG,IAAIgD,IAAI,CAAC7B,IAAI,EAAEqC,YAAY,CAACpB,GAAG,CAACpC,GAAG,CAACC,OAAO,CAAC;AAC9D,IAAA;AACJ,EAAA;AACA,EAAA,KAAK,MAAME,KAAK,IAAIzD,OAAO,CAAC4F,MAAM,EAClC;AACI,IAAA,KAAK,MAAMI,QAAQ,IAAIvC,KAAK,CAACuC,QAAQ,IAAI,EAAE,EAAEc,YAAY,CAACpB,GAAG,CAACM,QAAQ,CAACzC,OAAO,CAAC;AACnF,EAAA;AACA,EAAA,KAAK,MAAME,KAAK,IAAIzD,OAAO,CAAC4F,MAAM,EAClC;IACI,IAAI,CAACkB,YAAY,CAAC5E,GAAG,CAACuB,KAAK,CAACoC,EAAE,CAAC,EAAE;AACjC,IAAA,KAAK,MAAM7G,SAAS,IAAIwE,eAAe,CAACC,KAAK,CAAC,EAC9C;AACI,MAAA,MAAMH,GAAG,GAAG;QAAEC,OAAO,EAAEE,KAAK,CAACoC,EAAE;AAAE7G,QAAAA;OAAW;MAC5C,IAAI,CAAC4F,WAAW,CAACT,GAAG,CAAC7D,IAAI,CAACuE,MAAM,CAACvB,GAAG,CAAC,CAAC,CAAC,CAACxB,IAAI,EAAE6D,SAAS,CAACrC,GAAG,EAAE,cAAc,CAAC;AAChF,IAAA;AACJ,EAAA;EAEA,MAAMyD,UAAU,GAAIzD,GAAG,IACvB;AACI,IAAA,MAAM0D,KAAK,GAAGtD,KAAK,CAACR,IAAI,CAAC0B,WAAW,CAACT,GAAG,CAAC7D,IAAI,CAACuE,MAAM,CAACvB,GAAG,CAAC,CAAC,CAAC,CAAC;AAC5D,IAAA,IAAI0D,KAAK,CAACnF,MAAM,KAAK,CAAC,EAAE,OAAO,SAAS;IACxC,OAAOmF,KAAK,CAACnF,MAAM,KAAK,CAAC,GAAGmF,KAAK,CAAC,CAAC,CAAC,GAAG,cAAc;EACzD,CAAC;AAED,EAAA,KAAK,MAAMvD,KAAK,IAAIzD,OAAO,CAAC4F,MAAM,EAClC;AACInC,IAAAA,KAAK,CAACwD,cAAc,GAAG,EAAE;AACzB,IAAA,KAAK,MAAMjI,SAAS,IAAIwE,eAAe,CAACC,KAAK,CAAC,EAC9C;AACIA,MAAAA,KAAK,CAACwD,cAAc,CAACjI,SAAS,CAAC,GAAG+H,UAAU,CAAC;QAAExD,OAAO,EAAEE,KAAK,CAACoC,EAAE;AAAE7G,QAAAA;AAAU,OAAC,CAAC;AAClF,IAAA;AACJ,EAAA;AAEA,EAAA,KAAK,MAAMiB,WAAW,IAAID,OAAO,CAACiG,YAAY,EAC9C;IACI,MAAMC,IAAI,GAAGlE,OAAO,CAAC/B,WAAW,CAACgC,UAAU,EAAEjC,OAAO,EAAEC,WAAW,CAAC;AAClE,IAAA,MAAMkG,MAAM,GAAGlG,WAAW,CAACmG,QAAQ,CAACD,MAAM;IAC1C,MAAMe,gBAAgB,GAAGf,MAAM,CAACgB,OAAO,CAAET,KAAK,IAAKhD,KAAK,CAACR,IAAI,CAACwD,KAAK,CAACpC,IAAI,CAAC,CACpEvF,GAAG,CAAEC,SAAS,IAAKgB,OAAO,CAAC4F,MAAM,CAACtF,IAAI,CAAEmD,KAAK,IAAKA,KAAK,CAACoC,EAAE,KAAKa,KAAK,CAACnD,OAAO,CAAC,EAAE0D,cAAc,CAACjI,SAAS,CAAC,CAAC,CAAC,CAC1G4C,MAAM,CAACwF,OAAO,CAAC;IACpB,MAAMC,QAAQ,GAAGH,gBAAgB,CAACrF,MAAM,IAAI,IAAIvC,GAAG,CAAC4H,gBAAgB,CAAC,CAACpF,IAAI,KAAK,CAAC,GAAGoF,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI;AAC7G,IAAA,MAAMI,YAAY,GAAGrH,WAAW,CAACI,QAAQ,CAACtB,GAAG,CAAC,CAACwB,OAAO,EAAEiG,YAAY,KACpE;MACI,IAAIe,YAAY,GAAGrB,IAAI,CAAC5D,eAAe,GAAGkE,YAAY,CAAC,IAAI,IAAI;AAC/D,MAAA,IAAI,CAACe,YAAY,IAAIrB,IAAI,CAAC7D,OAAO,IAAImE,YAAY,GAAG,CAAC,EAAEe,YAAY,GAAGrB,IAAI,CAAC7D,OAAO;AAClF,MAAA,IAAI,CAACkF,YAAY,IAAI,CAACrB,IAAI,CAAC9C,eAAe,IAAI,EAAE,EAAEZ,QAAQ,CAACgE,YAAY,CAAC,EAAEe,YAAY,GAAGF,QAAQ;MACjG,IAAIpH,WAAW,CAACmG,QAAQ,CAACD,MAAM,CAACqB,IAAI,CAAEd,KAAK,IAAKA,KAAK,CAACF,YAAY,KAAKA,YAAY,CAAC,EAAEe,YAAY,GAAGrB,IAAI,CAAC9D,WAAW,IAAIiF,QAAQ;MACjI,OAAO;QACHb,YAAY;QACZiB,IAAI,EAAExH,WAAW,CAACmG,QAAQ,CAACD,MAAM,CAACqB,IAAI,CAAEd,KAAK,IAAKA,KAAK,CAACF,YAAY,KAAKA,YAAY,CAAC,GAAG,aAAa,GAAG,QAAQ;QACjHe,YAAY,EAAEA,YAAY,IAAI,SAAS;AACvCG,QAAAA,QAAQ,EAAEnH,OAAO,CAACoH,YAAY,IAAI,MAAM;AACxCC,QAAAA,YAAY,EAAErH,OAAO,CAACsH,gBAAgB,IAAI,SAAS;AACnDC,QAAAA,SAAS,EAAEvH,OAAO,CAACC,QAAQ,KAAK,aAAa,GACvCD,OAAO,CAACwH,eAAe,CAAChJ,GAAG,CAAC,CAAC0E,KAAK,EAAEzE,SAAS,MAAM;AAAEA,UAAAA,SAAS,EAAEJ,UAAU,CAACI,SAAS,CAAC;UAAEgJ,MAAM,EAAEvE,KAAK,CAACuE,MAAM;UAAEC,OAAO,EAAExE,KAAK,CAACwE;SAAS,CAAC,CAAC,GACvI;OACT;AACL,IAAA,CAAC,CAAC;IACF,MAAMC,QAAQ,GAAG,EAAE;IACnB,KAAK,MAAM5B,IAAI,IAAIrG,WAAW,CAACmG,QAAQ,CAACG,KAAK,EAC7C;AACI,MAAA,IAAID,IAAI,CAACG,IAAI,KAAK,YAAY,EAAE;AAChC,MAAA,IAAII,QAAQ,GAAGX,IAAI,CAAC5D,eAAe,GAAGgE,IAAI,CAACE,YAAY,CAAC,IAAIN,IAAI,CAAC7D,OAAO,IAAI,IAAI;AAChF,MAAA,IAAI,CAACwE,QAAQ,IAAI,CAACX,IAAI,CAAC9C,eAAe,IAAI,EAAE,EAAEZ,QAAQ,CAAC8D,IAAI,CAACE,YAAY,CAAC,EAAEK,QAAQ,GAAGQ,QAAQ;AAC9F,MAAA,IAAI,CAACR,QAAQ,IAAIA,QAAQ,KAAK,SAAS,EAAE;MACzCP,IAAI,CAAC7B,IAAI,CAACkC,OAAO,CAAC,CAACrD,GAAG,EAAE6E,cAAc,KACtC;AACI,QAAA,MAAMC,OAAO,GAAGrB,UAAU,CAACzD,GAAG,CAAC;AAC/B,QAAA,IAAI8E,OAAO,KAAKvB,QAAQ,IAAIuB,OAAO,KAAK,SAAS,EACjD;UACIF,QAAQ,CAACG,IAAI,CAAC;AAAE5B,YAAAA,IAAI,EAAE,cAAc;YAAED,YAAY,EAAEF,IAAI,CAACE,YAAY;YAAE2B,cAAc;YAAE5E,OAAO,EAAED,GAAG,CAACC,OAAO;YAAEvE,SAAS,EAAEsE,GAAG,CAACtE,SAAS;AAAEkE,YAAAA,IAAI,EAAEkF,OAAO;AAAEjF,YAAAA,EAAE,EAAE0D;AAAS,WAAC,CAAC;AACzK,QAAA;AACJ,MAAA,CAAC,CAAC;AACN,IAAA;AACA,IAAA,KAAK,MAAMH,KAAK,IAAIP,MAAM,EAC1B;AACI,MAAA,IAAI,CAACD,IAAI,CAAC9D,WAAW,EAAE;MACvBsB,KAAK,CAACR,IAAI,CAACwD,KAAK,CAACpC,IAAI,CAAC,CAACqC,OAAO,CAAE3H,SAAS,IACzC;QACI,MAAMoJ,OAAO,GAAGrB,UAAU,CAAC;UAAExD,OAAO,EAAEmD,KAAK,CAACnD,OAAO;AAAEvE,UAAAA;AAAU,SAAC,CAAC;QACjE,IAAIoJ,OAAO,KAAKlC,IAAI,CAAC9D,WAAW,IAAIgG,OAAO,KAAK,SAAS,EACzD;UACIF,QAAQ,CAACG,IAAI,CAAC;AAAE5B,YAAAA,IAAI,EAAE,gBAAgB;YAAED,YAAY,EAAEE,KAAK,CAACF,YAAY;YAAEjD,OAAO,EAAEmD,KAAK,CAACnD,OAAO;YAAEvE,SAAS;YAAEkE,IAAI,EAAEgD,IAAI,CAAC9D,WAAW;AAAEe,YAAAA,EAAE,EAAEiF;AAAQ,WAAC,CAAC;AACvJ,QAAA;AACJ,MAAA,CAAC,CAAC;AACN,IAAA;AACA,IAAA,KAAK,MAAM7H,OAAO,IAAI+G,YAAY,EAClC;AACI,MAAA,IAAI,CAAC/G,OAAO,CAACuH,SAAS,IAAI,CAAC,CAAE,SAAS,EAAE,OAAO,CAAE,CAACtF,QAAQ,CAACjC,OAAO,CAACgH,YAAY,CAAC,EAAE;AAClF,MAAA,KAAK,MAAMO,SAAS,IAAIvH,OAAO,CAACuH,SAAS,EACzC;QACII,QAAQ,CAACG,IAAI,CAAC;AAAE5B,UAAAA,IAAI,EAAE,mBAAmB;UAAED,YAAY,EAAEjG,OAAO,CAACiG,YAAY;UAAExH,SAAS,EAAE8I,SAAS,CAAC9I,SAAS;AAAEkE,UAAAA,IAAI,EAAE,QAAQ;UAAEC,EAAE,EAAE5C,OAAO,CAACgH,YAAY;UAAES,MAAM,EAAEF,SAAS,CAACE;AAAO,SAAC,CAAC;AACxL,MAAA;AACJ,IAAA;IACA/H,WAAW,CAACqI,QAAQ,GAAG;AACnB7B,MAAAA,IAAI,EAAE,mBAAmB;MACzBP,IAAI,EAAEA,IAAI,CAAC/D,IAAI;AACfoG,MAAAA,UAAU,EAAErC,IAAI,CAAC9D,WAAW,IAAIiF,QAAQ,IAAI,SAAS;AACrDpE,MAAAA,UAAU,EAAEiD,IAAI,CAACjD,UAAU,IAAI,IAAI;AACnCV,MAAAA,mBAAmB,EAAE2D,IAAI,CAAC3D,mBAAmB,IAAI,IAAI;MACrD+E,YAAY;AACZY,MAAAA;KACH;AACL,EAAA;EAEAlI,OAAO,CAACwI,UAAU,GAAG;AACjB/B,IAAAA,IAAI,EAAE,oBAAoB;AAC1BgC,IAAAA,WAAW,EAAEvJ,YAAY,CAACwJ,KAAK,EAAE;AACjCC,IAAAA,gBAAgB,EAAE,aAAa;AAC/BpG,IAAAA,mBAAmB,EAAE,SAAS;AAC9BqG,IAAAA,eAAe,EAAE;GACpB;AACD,EAAA,OAAO5I,OAAO;AAClB;;;;"}

package/dist/formats/webgpu/core/ir/lowerDxbcToIr.js

@@ -0,0 +1,494 @@
+import { CjsDxbcFormat } from '../../../dxbc/CjsDxbcFormat.js';
+import { analyzeRegisterValues, operandRoles } from './analyzeRegisterValues.js';
+import { buildControlFlow } from './buildControlFlow.js';
+import { resolveRegisterFlow } from './resolveRegisterFlow.js';
+import { inferValueTypes, SCALAR_TYPES } from './inferValueTypes.js';
+
+const SHADER_IR_FORMAT = "CJS_SHADER_IR";
+const SHADER_IR_VERSION = 1;
+const PRECISE_MASK = /^x?y?z?w?$/u;
+const BINDING_KINDS = Object.freeze({
+  dcl_constant_buffer: "uniform-buffer",
+  dcl_sampler: "sampler",
+  dcl_resource: "sampled-resource",
+  dcl_resource_raw: "sampled-resource",
+  dcl_resource_structured: "sampled-resource",
+  dcl_unordered_access_view_typed: "storage-resource",
+  dcl_unordered_access_view_raw: "storage-resource",
+  dcl_unordered_access_view_structured: "storage-resource"
+});
+const BLOCK_BEFORE = new Set(["loop", "else", "endif", "endloop", "case", "default", "endswitch"]);
+const BLOCK_AFTER = new Set(["if", "loop", "switch", "break", "breakc", "continue", "continuec", "ret", "retc", "discard", "else", "endif", "endloop", "case", "default", "endswitch"]);
+function clonePlain(value) {
+  if (value === null || value === undefined) return value ?? null;
+  if (ArrayBuffer.isView(value)) return Array.from(value);
+  if (Array.isArray(value)) return value.map(clonePlain);
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) out[key] = clonePlain(entry);
+    return out;
+  }
+  return value;
+}
+function readDecoded(input, options) {
+  if (input instanceof Uint8Array || input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+    const raw = CjsDxbcFormat.read(input, {
+      emit: CjsDxbcFormat.OUTPUT_RAW,
+      source: options.source || "memory",
+      decodeInstructions: true
+    });
+    return {
+      program: raw.program,
+      instructions: raw.decoder?.instructions || [],
+      signatures: {
+        input: raw.inputSignature?.elements || [],
+        output: raw.outputSignature?.elements || [],
+        patch: raw.patchSignature?.elements || []
+      }
+    };
+  }
+  if (input?.program && input?.decoder) {
+    return {
+      program: input.program,
+      instructions: input.decoder.instructions || [],
+      signatures: {
+        input: input.inputSignature?.elements || input.signatures?.input || [],
+        output: input.outputSignature?.elements || input.signatures?.output || [],
+        patch: input.patchSignature?.elements || input.signatures?.patch || []
+      }
+    };
+  }
+  if (input?.program && Array.isArray(input.instructions)) {
+    return {
+      program: input.program,
+      instructions: input.instructions,
+      signatures: input.signatures || {}
+    };
+  }
+  throw new TypeError("CjsWebgpuFormat.BuildShaderIr: expected DXBC bytes or decoded program/instructions");
+}
+function normalizedRange(declaration) {
+  if (declaration.bindingRange) return clonePlain(declaration.bindingRange);
+  const registerIndex = declaration.registerIndex ?? null;
+  return {
+    bindingModel: "sm5.0-register",
+    rangeId: null,
+    lowerBound: registerIndex,
+    upperBound: registerIndex,
+    unbounded: false,
+    registerCount: registerIndex === null ? 0 : 1,
+    registerSpace: 0
+  };
+}
+function buildBinding(instruction) {
+  const resourceKind = BINDING_KINDS[instruction.opcodeName];
+  if (!resourceKind) return null;
+  const declaration = instruction.declaration || {};
+  const range = normalizedRange(declaration);
+  return {
+    kind: "binding",
+    id: `${resourceKind}:space${range.registerSpace}:range${range.rangeId ?? range.lowerBound}`,
+    resourceKind,
+    operandType: instruction.operands?.[0]?.typeName || null,
+    declarationOffset: instruction.offset,
+    registerIndex: declaration.registerIndex ?? range.lowerBound,
+    range,
+    accessPattern: declaration.accessPattern || null,
+    resourceDimension: declaration.resourceDimensionName || null,
+    structureStride: declaration.structureStride ?? null,
+    returnType: clonePlain(declaration.returnType || null)
+  };
+}
+function controlKind(opcodeName) {
+  if (["if", "else", "endif"].includes(opcodeName)) return "selection";
+  if (["loop", "endloop", "break", "breakc", "continue", "continuec"].includes(opcodeName)) return "loop";
+  if (["switch", "case", "default", "endswitch"].includes(opcodeName)) return "switch";
+  if (["ret", "retc", "discard", "abort"].includes(opcodeName)) return "termination";
+  return null;
+}
+const COMPONENT_ORDER = ["x", "y", "z", "w"];
+const FLOAT_VIEW = new DataView(new ArrayBuffer(4));
+function immediateRecord(value) {
+  const bits = (value?.uint32 ?? 0) >>> 0;
+  FLOAT_VIEW.setUint32(0, bits);
+  return {
+    uint32: bits,
+    float32: FLOAT_VIEW.getFloat32(0)
+  };
+}
+
+/**
+ * Recognizes indexable temps that are immutable constant tables: every write
+ * is a straight-line pre-control-flow `mov x#[slot].mask, l(...)` immediate,
+ * and at least one access uses relative addressing. Such registers lower to a
+ * module-scope WGSL `const` array (the same shape as the DXBC icb), so their
+ * dynamic reads never need mutable-register SSA. Any relative indexable-temp
+ * usage that does not fit this shape fails closed here with a diagnostic.
+ *
+ * @param {object[]} declarationInstructions Decoded declaration instructions.
+ * @param {object[]} executable Decoded executable instructions.
+ * @returns {{tables: object[]|null, removed: Set<number>|null}} Tables and initializer indices.
+ */
+function extractConstTables(declarationInstructions, executable) {
+  const declared = new Map();
+  const duplicateDeclarations = new Set();
+  for (const declaration of declarationInstructions) {
+    if (declaration.opcodeName !== "dcl_indexable_temp") continue;
+    const data = declaration.declaration || {};
+    if (declared.has(data.registerIndex)) duplicateDeclarations.add(data.registerIndex);
+    declared.set(data.registerIndex, {
+      slotCount: data.registerCount,
+      componentCount: data.componentCount
+    });
+  }
+  const touched = new Map();
+  const entryFor = registerIndex => {
+    let entry = touched.get(registerIndex);
+    if (!entry) {
+      entry = {
+        writes: [],
+        hasRelative: false,
+        invalid: null
+      };
+      touched.set(registerIndex, entry);
+    }
+    return entry;
+  };
+  const invalidate = (entry, reason) => {
+    if (!entry.invalid) entry.invalid = reason;
+  };
+  let firstControl = executable.findIndex(instruction => controlKind(instruction.opcodeName) !== null);
+  if (firstControl < 0) firstControl = executable.length;
+  executable.forEach((instruction, instructionIndex) => {
+    operandRoles(instruction).forEach(({
+      operand,
+      role
+    }, operandIndex) => {
+      if (operand.typeName !== "indexable_temp") return;
+      const indices = operand.indices || [];
+      const registerIndex = indices[0]?.values?.[0];
+      const entry = entryFor(registerIndex);
+      if (indices.length !== 2 || indices[0]?.relative || indices[0]?.values?.length !== 1 || !Number.isInteger(registerIndex) || registerIndex < 0 || operand.registerIndex !== registerIndex) {
+        return invalidate(entry, "requires one consistent fixed register identity and [register][slot] addressing");
+      }
+      if (indices[1]?.relative) entry.hasRelative = true;
+      if (role === "source") {
+        const lanes = operand.selected ? [operand.selected] : operand.swizzle ? Array.from(new Set(operand.swizzle)) : COMPONENT_ORDER.slice();
+        entry.reads = entry.reads || [];
+        entry.reads.push({
+          instructionIndex,
+          lanes
+        });
+        return;
+      }
+
+      // Destination use: only straight-line immediate table initializers
+      // are representable; anything else is a mutable indexable temp.
+      const source = instruction.operands?.[1];
+      const slot = indices[1]?.values?.[0];
+      if (instruction.opcodeName !== "mov" || instruction.saturate) {
+        return invalidate(entry, "is only writable by non-saturating mov initializers");
+      }
+      if (instructionIndex >= firstControl) {
+        return invalidate(entry, "initializers must precede all control flow");
+      }
+      if (indices[1]?.relative || indices[1]?.values?.length !== 1 || !Number.isInteger(slot) || slot < 0) {
+        return invalidate(entry, "initializers require an immediate slot index");
+      }
+      if (source?.typeName !== "immediate32" || (source.modifierName || "none") !== "none" || ![1, 4].includes(source.immediateValues?.length ?? 0)) {
+        return invalidate(entry, "initializers require immediate32 sources");
+      }
+      if ((operand.modifierName || "none") !== "none" || (operand.minPrecisionName || "default") !== "default" || (source.minPrecisionName || "default") !== "default" || instruction.extensions?.length) {
+        return invalidate(entry, "initializers require canonical default-precision mov operands");
+      }
+      if (!operand.mask || operand.swizzle || operand.selected || source.mask || source.swizzle && source.selected || source.selected && !COMPONENT_ORDER.includes(source.selected) || source.swizzle && (source.swizzle.length !== 4 || Array.from(source.swizzle).some(lane => !COMPONENT_ORDER.includes(lane)))) {
+        return invalidate(entry, "initializers require canonical destination and source component selection");
+      }
+      const valuesByLane = {};
+      for (const lane of operand.mask) {
+        const destinationLane = COMPONENT_ORDER.indexOf(lane);
+        const sourceLane = source.selected || source.swizzle?.[destinationLane] || lane;
+        const sourceLaneIndex = COMPONENT_ORDER.indexOf(sourceLane);
+        const value = source.immediateValues.length === 1 ? source.immediateValues[0] : source.immediateValues[sourceLaneIndex];
+        if (!value) {
+          return invalidate(entry, "an initializer selects an unavailable immediate lane");
+        }
+        valuesByLane[lane] = value;
+      }
+      entry.writes.push({
+        instructionIndex,
+        slot,
+        mask: operand.mask,
+        valuesByLane
+      });
+    });
+  });
+  const tables = [];
+  const removed = new Set();
+  for (const [registerIndex, entry] of touched) {
+    if (!entry.hasRelative) continue;
+    const declaration = declared.get(registerIndex);
+    const describe = reason => new Error(`Shader IR indexable temp x${registerIndex} relative addressing is not supported: ${reason}`);
+    if (entry.invalid) throw describe(entry.invalid);
+    if (duplicateDeclarations.has(registerIndex)) throw describe("it has duplicate declarations");
+    if (!declaration || !Number.isInteger(declaration.slotCount) || declaration.slotCount < 1) {
+      throw describe("it has no usable declaration");
+    }
+    if (!Number.isInteger(declaration.componentCount) || declaration.componentCount < 1 || declaration.componentCount > 4) {
+      throw describe("it has an invalid component count");
+    }
+    const lastWrite = Math.max(...entry.writes.map(write => write.instructionIndex));
+    const firstRead = Math.min(...(entry.reads || []).map(read => read.instructionIndex));
+    if (lastWrite >= firstRead) {
+      throw describe("all initializers must precede every read");
+    }
+    const laneMask = entry.writes[0]?.mask;
+    if (Array.from(laneMask || "").some(lane => COMPONENT_ORDER.indexOf(lane) >= declaration.componentCount)) {
+      throw describe("an initializer writes outside the declared component range");
+    }
+    const rows = Array.from({
+      length: declaration.slotCount
+    }, () => COMPONENT_ORDER.map(() => null));
+    for (const write of entry.writes) {
+      if (write.mask !== laneMask) throw describe("initializers must share one write mask");
+      if (write.slot < 0 || write.slot >= declaration.slotCount) {
+        throw describe("an initializer writes outside the declared range");
+      }
+      for (const lane of write.mask) {
+        const laneIndex = COMPONENT_ORDER.indexOf(lane);
+        if (rows[write.slot][laneIndex] !== null) throw describe("a slot lane is written twice");
+        rows[write.slot][laneIndex] = immediateRecord(write.valuesByLane[lane]);
+      }
+      removed.add(write.instructionIndex);
+    }
+    for (const [slot, row] of rows.entries()) {
+      for (const lane of laneMask || "") {
+        if (row[COMPONENT_ORDER.indexOf(lane)] === null) {
+          throw describe(`slot ${slot} is never fully written`);
+        }
+      }
+    }
+    for (const read of entry.reads || []) {
+      if (read.lanes.some(lane => !(laneMask || "").includes(lane))) {
+        throw describe("a read selects lanes the table never writes");
+      }
+    }
+    tables.push(Object.freeze({
+      kind: "const-table",
+      registerIndex,
+      symbol: `xt${registerIndex}`,
+      slotCount: declaration.slotCount,
+      laneMask: laneMask || "",
+      rows: rows.map(row => row.map(value => value ?? {
+        uint32: 0,
+        float32: 0
+      }))
+    }));
+  }
+  return tables.length ? {
+    tables,
+    removed
+  } : {
+    tables: null,
+    removed: null
+  };
+}
+function buildInstruction(instruction, index) {
+  return {
+    kind: "instruction",
+    index,
+    dxbcOffset: instruction.offset,
+    opcode: instruction.opcode,
+    opcodeName: instruction.opcodeName,
+    controlKind: controlKind(instruction.opcodeName),
+    testBoolean: instruction.testBoolean || null,
+    saturate: !!instruction.saturate,
+    preciseMask: instruction.preciseMask || "",
+    ...(instruction.opcodeName === "resinfo" ? {
+      resinfoReturnTypeName: instruction.resinfoReturnTypeName || "float"
+    } : {}),
+    ...(instruction.opcodeName === "sync" ? {
+      syncFlags: Number.isInteger(instruction.syncFlags) ? instruction.syncFlags : null,
+      syncFlagNames: Array.isArray(instruction.syncFlagNames) ? clonePlain(instruction.syncFlagNames) : null
+    } : {}),
+    ...(instruction.extensions?.length ? {
+      extensions: clonePlain(instruction.extensions)
+    } : {}),
+    ...(instruction.tailTokens?.length ? {
+      tailTokens: clonePlain(instruction.tailTokens)
+    } : {}),
+    operands: clonePlain(instruction.operands || [])
+  };
+}
+function buildBlocks(instructions) {
+  if (instructions.length === 0) return [];
+  const leaders = new Set([0]);
+  for (let index = 0; index < instructions.length; index += 1) {
+    if (BLOCK_BEFORE.has(instructions[index].opcodeName)) leaders.add(index);
+    if (BLOCK_AFTER.has(instructions[index].opcodeName) && index + 1 < instructions.length) leaders.add(index + 1);
+  }
+  const starts = Array.from(leaders).sort((a, b) => a - b);
+  return starts.map((start, blockIndex) => {
+    const end = (starts[blockIndex + 1] ?? instructions.length) - 1;
+    const last = instructions[end];
+    return {
+      kind: "basic-block",
+      id: `block${blockIndex}`,
+      index: blockIndex,
+      startInstruction: start,
+      endInstruction: end,
+      startDxbcOffset: instructions[start].dxbcOffset,
+      endDxbcOffset: last.dxbcOffset,
+      instructionIndices: Array.from({
+        length: end - start + 1
+      }, (_, offset) => start + offset),
+      terminator: last.controlKind ? last.opcodeName : null
+    };
+  });
+}
+function validateProgram(program) {
+  if (!program.stage || !Number.isInteger(program.shaderModel.major)) {
+    throw new Error("Invalid shader IR program identity");
+  }
+  for (let index = 1; index < program.instructions.length; index += 1) {
+    if (program.instructions[index].dxbcOffset <= program.instructions[index - 1].dxbcOffset) {
+      throw new Error("Shader IR instruction offsets must be strictly increasing");
+    }
+  }
+  const covered = program.blocks.flatMap(block => block.instructionIndices);
+  if (covered.length !== program.instructions.length || covered.some((value, index) => value !== index)) {
+    throw new Error("Shader IR basic blocks must cover every executable instruction exactly once");
+  }
+  const blockIds = new Set(program.blocks.map(block => block.id));
+  for (const block of program.blocks) {
+    if (block.successors.some(edge => !blockIds.has(edge.blockId))) {
+      throw new Error("Shader IR control-flow edge references an unknown block");
+    }
+    for (const edge of block.successors) {
+      const successor = program.blocks.find(entry => entry.id === edge.blockId);
+      if (!successor.predecessors.some(entry => entry.blockId === block.id && entry.kind === edge.kind)) {
+        throw new Error("Shader IR control-flow successor/predecessor edges must be symmetric");
+      }
+    }
+  }
+  const bindingIds = new Set();
+  for (const binding of program.bindings) {
+    if (bindingIds.has(binding.id)) throw new Error(`Duplicate shader IR binding ${binding.id}`);
+    bindingIds.add(binding.id);
+  }
+  const valueIds = new Set(program.values.map(value => value.id));
+  const valuesById = new Map(program.values.map(value => [value.id, value]));
+  if (valueIds.size !== program.values.length) throw new Error("Shader IR register value ids must be unique");
+  for (const block of program.blocks) {
+    if (block.inputValueIds.some(id => !valueIds.has(id))) {
+      throw new Error("Shader IR block input references an unknown value");
+    }
+    if (block.outputValues.some(output => !valueIds.has(output.ref.valueId))) {
+      throw new Error("Shader IR block output references an unknown value");
+    }
+    if (block.mergeSite?.valueIds?.some(id => !valueIds.has(id) || valuesById.get(id).origin !== "control-flow-merge" || valuesById.get(id).blockId !== block.id)) {
+      throw new Error("Shader IR merge site references an invalid merge value");
+    }
+  }
+  for (const instruction of program.instructions) {
+    if (!instruction.dataflow) throw new Error("Shader IR instruction is missing register dataflow");
+    const refs = [...instruction.dataflow.reads.flatMap(read => read.refs), ...instruction.dataflow.writes.flatMap(write => [{
+      valueId: write.valueId
+    }, ...Object.values(write.previous || {}), ...Object.values(write.result || {})])];
+    if (refs.some(ref => !valueIds.has(ref.valueId))) {
+      throw new Error("Shader IR register dataflow references an unknown value");
+    }
+  }
+  for (const value of program.values) {
+    if (value.origin === "block-input") throw new Error("Shader IR contains an unresolved block input");
+    if (value.origin === "control-flow-merge") {
+      if (value.incoming.length < 2) throw new Error("Shader IR merge value must have at least two incoming values");
+      if (value.incoming.some(incoming => !valueIds.has(incoming.valueId))) {
+        throw new Error("Shader IR merge value references an unknown incoming value");
+      }
+      if (value.incoming.some(incoming => incoming.component !== value.writeMask || valuesById.get(incoming.valueId).register !== value.register)) {
+        throw new Error("Shader IR merge value has an incompatible incoming register component");
+      }
+    }
+    if (!value.componentTypes || Object.values(value.componentTypes).some(type => !SCALAR_TYPES.includes(type))) {
+      throw new Error("Shader IR register value has an invalid component type");
+    }
+  }
+  for (const instruction of program.instructions) {
+    if (!instruction.typeInfo) throw new Error("Shader IR instruction is missing type information");
+    if (typeof instruction.preciseMask !== "string" || !PRECISE_MASK.test(instruction.preciseMask)) {
+      throw new Error(`Shader IR instruction ${instruction.index} has an invalid precise component mask`);
+    }
+    if (instruction.typeInfo.bitcasts.some(bitcast => !SCALAR_TYPES.includes(bitcast.from) || !SCALAR_TYPES.includes(bitcast.to))) {
+      throw new Error("Shader IR instruction has an invalid bitcast type");
+    }
+  }
+}
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const entry of Object.values(value)) deepFreeze(entry);
+  return Object.freeze(value);
+}
+
+/**
+ * Lowers decoded DXBC framing into the stable front-end shader IR.
+ * Type inference and SSA value reconstruction are later passes.
+ *
+ * @param {Uint8Array|ArrayBuffer|ArrayBufferView|object} input DXBC bytes or decoded result.
+ * @param {object} [options] IR provenance options.
+ * @returns {object} Frozen, validated shader IR program.
+ */
+function lowerDxbcToIr(input, options = {}) {
+  const decoded = readDecoded(input, options);
+  if (!decoded.program) throw new Error("DXBC input has no shader program");
+  const declarationInstructions = decoded.instructions.filter(instruction => instruction.isDeclaration);
+  let executable = decoded.instructions.filter(instruction => !instruction.isDeclaration);
+  const constTableExtraction = extractConstTables(declarationInstructions, executable);
+  if (constTableExtraction.removed) {
+    executable = executable.filter((_, index) => !constTableExtraction.removed.has(index));
+  }
+  const instructions = executable.map(buildInstruction);
+  const icbInstruction = declarationInstructions.find(instruction => instruction.customData?.immediateConstantBuffer);
+  const immediateConstantBuffer = icbInstruction ? clonePlain(icbInstruction.customData.immediateConstantBuffer) : null;
+  const program = {
+    kind: "shader-program",
+    format: SHADER_IR_FORMAT,
+    formatVersion: SHADER_IR_VERSION,
+    source: options.source || decoded.program.source || "memory",
+    stage: decoded.program.programTypeName,
+    programType: decoded.program.programType,
+    shaderModel: {
+      major: decoded.program.majorVersion,
+      minor: decoded.program.minorVersion
+    },
+    signatures: {
+      input: clonePlain(decoded.signatures?.input || []),
+      output: clonePlain(decoded.signatures?.output || []),
+      patch: clonePlain(decoded.signatures?.patch || [])
+    },
+    declarations: declarationInstructions.map(instruction => ({
+      kind: "declaration",
+      dxbcOffset: instruction.offset,
+      opcodeName: instruction.opcodeName,
+      data: clonePlain(instruction.declaration),
+      operands: clonePlain(instruction.operands || []),
+      ...(instruction.tailTokens?.length ? {
+        tailTokens: clonePlain(instruction.tailTokens)
+      } : {})
+    })),
+    bindings: declarationInstructions.map(buildBinding).filter(Boolean),
+    immediateConstantBuffer,
+    constTables: constTableExtraction.tables,
+    instructions,
+    blocks: buildBlocks(instructions)
+  };
+  buildControlFlow(program);
+  analyzeRegisterValues(program);
+  resolveRegisterFlow(program);
+  inferValueTypes(program);
+  validateProgram(program);
+  return deepFreeze(program);
+}
+
+export { SHADER_IR_FORMAT, SHADER_IR_VERSION, lowerDxbcToIr };
+//# sourceMappingURL=lowerDxbcToIr.js.map