hoi4-agent-tools 3.2.0 → 3.4.0

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -241,8 +241,8 @@ function renderCorneredTile(element) {
     if (sprite?.supported !== true ||
         sprite.dataUri === undefined ||
         border === undefined ||
-        border.width <= 0 ||
-        border.height <= 0)
+        border.width < 0 ||
+        border.height < 0)
         return sprite === undefined ? '' : renderSpriteImage(sprite, rect);
     const sourceBorderX = Math.min(border.width, sprite.width / 2);
     const sourceBorderY = Math.min(border.height, sprite.height / 2);
@@ -299,11 +299,6 @@ function renderProgressbar(element) {
     const sprite = element.sprite;
     const secondary = element.secondarySprite;
     const ratio = Math.max(0, Math.min(1, element.progressRatio ?? 1));
-    const background = secondary === undefined ? '' : renderSpriteImage(secondary, rect);
-    if (sprite?.supported !== true || sprite.dataUri === undefined)
-        return background;
-    if (ratio <= 0)
-        return background;
     const horizontal = element.progressHorizontal !== false;
     const filled = horizontal
         ? { x: rect.x, y: rect.y, width: rect.width * ratio, height: rect.height }
@@ -313,15 +308,36 @@ function renderProgressbar(element) {
             width: rect.width,
             height: rect.height * ratio,
         };
-    const source = horizontal
-        ? { x: 0, y: 0, width: sprite.width * ratio, height: sprite.height }
-        : {
-            x: 0,
-            y: sprite.height * (1 - ratio),
-            width: sprite.width,
-            height: sprite.height * ratio,
+    const remainder = horizontal
+        ? { x: rect.x + filled.width, y: rect.y, width: rect.width - filled.width, height: rect.height }
+        : { x: rect.x, y: rect.y, width: rect.width, height: rect.height - filled.height };
+    // A threshold shader selects a texture once per pixel. Painting the filled region
+    // over a complete secondary layer would incorrectly blend both sources at partial alpha.
+    const layer = (texture, region, colour) => {
+        if (region.width <= 0 || region.height <= 0)
+            return '';
+        if (colour !== undefined)
+            return `<rect ${rectAttributes(region)} fill="${escapeXml(colour)}"/>`;
+        if (texture?.supported !== true ||
+            texture.dataUri === undefined ||
+            rect.width <= 0 ||
+            rect.height <= 0)
+            return '';
+        const source = {
+            x: ((region.x - rect.x) / rect.width) * texture.width,
+            y: ((region.y - rect.y) / rect.height) * texture.height,
+            width: (region.width / rect.width) * texture.width,
+            height: (region.height / rect.height) * texture.height,
         };
-    return `${background}${renderSpriteSlice(sprite, source, filled)}`;
+        return renderSpriteSlice(texture, source, region);
+    };
+    const content = `${layer(secondary, remainder, element.progressColours?.second)}${layer(sprite, filled, element.progressColours?.first)}`;
+    const filtering = element.progressShader?.textureFiltering;
+    if (filtering === undefined)
+        return content;
+    const shrinking = [sprite, secondary].some((texture) => texture !== undefined && (rect.width < texture.width || rect.height < texture.height));
+    const mode = filtering[shrinking ? 'minification' : 'magnification'];
+    return `<g image-rendering="${mode === 'nearest' ? 'optimizeSpeed' : 'optimizeQuality'}">${content}</g>`;
 }
 function renderMaskedShield(element) {
     const rect = element.unclippedRect;
@@ -351,8 +367,22 @@ function renderBaseElement(element, clipId, toolText) {
     const rect = element.unclippedRect;
     const clip = clipId === undefined ? '' : ` clip-path="url(#${clipId})"`;
     const content = [];
-    if (element.sprite?.supported === true && element.sprite.dataUri !== undefined) {
-        content.push(renderElementSprite(element));
+    if (element.spriteRenderMode === 'progressbar' && element.progressColours !== undefined) {
+        content.push(renderProgressbar(element));
+    }
+    else if (element.sprite?.supported === true && element.sprite.dataUri !== undefined) {
+        const sprite = renderElementSprite(element);
+        if (element.spriteShader === undefined)
+            content.push(sprite);
+        else {
+            const id = `gui-shader-${sha256Bytes(element.id).slice(0, 20)}`;
+            const matrix = element.spriteShader.colourMatrix
+                .map((coefficient) => Number(coefficient.toFixed(9)))
+                .join(' ');
+            const shrinking = rect.width < element.sprite.width || rect.height < element.sprite.height;
+            const sampling = element.spriteShader.textureFiltering[shrinking ? 'minification' : 'magnification'];
+            content.push(`<defs><filter id="${id}" filterUnits="userSpaceOnUse" ${rectAttributes(rect)} color-interpolation-filters="sRGB"><feColorMatrix type="matrix" values="${matrix}"/></filter></defs><g filter="url(#${id})" image-rendering="${sampling === 'nearest' ? 'optimizeSpeed' : 'optimizeQuality'}">${sprite}</g>`);
+        }
     }
     else if (element.sprite !== undefined) {
         content.push(`<rect ${rectAttributes(rect)} fill="#331f3f" stroke="#ff42d0" stroke-width="1"/><path d="M ${finite(rect.x)} ${finite(rect.y)} L ${finite(rect.x + rect.width)} ${finite(rect.y + rect.height)} M ${finite(rect.x + rect.width)} ${finite(rect.y)} L ${finite(rect.x)} ${finite(rect.y + rect.height)}" stroke="#ff42d0"/>`);

package/dist/hoi4_agent_tools/gui/scenario-conditions.js

@@ -1,6 +1,7 @@
 import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
 import { hasBlockingDiagnostics } from '../core/diagnostics.js';
 import { evaluateTriggerBlock } from '../core/condition-evaluator.js';
+import { scenarioFromGui } from '../core/scenario-model.js';
 import { resolveScopeContext, rootScopeContext } from '../core/scenario-state.js';
 import { assignments, firstScalar, parseClausewitz } from '../core/source/index.js';
 /** Keep declared scoped scalars out of exploratory value generation. */
@@ -30,29 +31,7 @@ function parsedCondition(expression) {
     };
 }
 export function guiConditionScenario(base, values = base.values) {
-    const state = { ...base.stateValues, ...base.variables, ...values };
-    for (const [key, value] of Object.entries(base.flags))
-        state[`flag.${key}`] = value;
-    const scopes = structuredClone(base.scopes ?? {});
-    for (const [key, value] of Object.entries(state)) {
-        const match = /^(ROOT|THIS|FROM(?:\.FROM)*|PREV)\.(.+)$/u.exec(key);
-        if (match === null)
-            continue;
-        if (match[1] === 'ROOT' || match[1] === 'THIS')
-            state[match[2]] ??= value;
-        else {
-            const scope = (scopes[match[1]] ??= { id: match[1], state: {} });
-            scope.state[match[2]] ??= value;
-        }
-    }
-    const actor = base.country?.tag ?? base.country?.countryTag ?? base.country?.GetTag;
-    return {
-        id: base.id,
-        state,
-        scopes,
-        closedFlags: false,
-        ...(typeof actor === 'string' ? { actor } : {}),
-    };
+    return scenarioFromGui(base, values);
 }
 export function evaluateGuiCondition(expression, scenario, subject, definitions = new ClausewitzEvaluationDefinitions(), scope = 'ROOT') {
     const context = resolveScopeContext(scenario, scope, rootScopeContext(scenario));

package/dist/hoi4_agent_tools/gui/shader.js

@@ -0,0 +1,515 @@
+// This is a bounded colour-expression interpreter, never a JavaScript/HLSL executor.
+// Unsupported sampling, geometry, branches and nonlinear colour operations stay explicit.
+export const GUI_SHADER_MAX_BYTES = 262_144;
+const maxTokens = 4_096;
+const maxTokenLength = 256;
+const maxDepth = 64;
+const maxStatements = 128;
+const maxCoefficient = 1_000_000;
+const constant = (value) => [0, 0, 0, 0, value];
+const isConstant = (value) => value.slice(0, 4).every((entry) => entry === 0);
+const identity = [
+    [1, 0, 0, 0, 0],
+    [0, 1, 0, 0, 0],
+    [0, 0, 1, 0, 0],
+    [0, 0, 0, 1, 0],
+];
+class UnsupportedShader extends Error {
+}
+function unsupported(reason) {
+    throw new UnsupportedShader(reason.length > 512 ? `${reason.slice(0, 509)}...` : reason);
+}
+function checked(value) {
+    if (value.length !== 5 ||
+        value.some((entry) => !Number.isFinite(entry) || Math.abs(entry) > maxCoefficient))
+        unsupported('Shader colour arithmetic exceeds its finite coefficient budget.');
+    return value;
+}
+function binary(left, right, operator) {
+    const width = Math.max(left.length, right.length);
+    if (![1, width].includes(left.length) || ![1, width].includes(right.length))
+        unsupported('Shader vector widths do not agree.');
+    return Array.from({ length: width }, (_, index) => {
+        const a = left[left.length === 1 ? 0 : index];
+        const b = right[right.length === 1 ? 0 : index];
+        if (operator === '+' || operator === '-')
+            return checked(a.map((entry, component) => entry + (operator === '+' ? 1 : -1) * b[component]));
+        if (operator === '*') {
+            if (isConstant(a))
+                return checked(b.map((entry) => entry * a[4]));
+            if (isConstant(b))
+                return checked(a.map((entry) => entry * b[4]));
+            unsupported('Multiplication of two sampled colour expressions is nonlinear.');
+        }
+        if (operator === '/' && isConstant(b) && b[4] !== 0)
+            return checked(a.map((entry) => entry / b[4]));
+        return unsupported('Shader division requires a finite nonzero constant divisor.');
+    });
+}
+function components(swizzle, width) {
+    const alphabet = /^[rgba]+$/u.test(swizzle) ? 'rgba' : 'xyzw';
+    const result = Array.from({ length: swizzle.length }, (_, index) => alphabet.indexOf(swizzle.charAt(index)));
+    if (result.length === 0 ||
+        result.length > 4 ||
+        result.some((index) => index < 0 || index >= width))
+        unsupported('Shader swizzle is outside its vector.');
+    return result;
+}
+function withoutComments(source) {
+    const stripped = source.replace(/\/\*[\s\S]*?\*\//gu, ' ').replace(/\/\/[^\r\n]*/gu, '');
+    if (stripped.includes('/*'))
+        unsupported('Shader has an unterminated comment.');
+    return stripped;
+}
+function inactiveFeatures(source) {
+    const stack = [];
+    let active = true;
+    const output = [];
+    for (const line of source.split(/\r?\n/u)) {
+        const directive = /^\s*[#@](\w+)(?:\s+([\s\S]*?))?\s*$/u.exec(line);
+        if (directive === null) {
+            if (active)
+                output.push(line);
+            continue;
+        }
+        const [, command, argument] = directive;
+        if (command === 'ifdef' || command === 'ifndef') {
+            if (!['ANIMATED', 'MASKING'].includes(argument ?? ''))
+                unsupported(`Shader feature ${argument ?? '(missing)'} has no supported binding.`);
+            if (stack.length >= maxDepth)
+                unsupported('Shader preprocessor nesting exceeds its budget.');
+            const condition = command === 'ifndef';
+            stack.push({ parent: active, condition, alternative: false });
+            active = active && condition;
+        }
+        else if (command === 'else' && argument === undefined) {
+            const branch = stack.at(-1);
+            if (branch === undefined || branch.alternative)
+                unsupported('Shader has an unmatched else.');
+            branch.alternative = true;
+            active = branch.parent && !branch.condition;
+        }
+        else if (command === 'endif' && argument === undefined) {
+            const branch = stack.pop();
+            if (branch === undefined)
+                unsupported('Shader has an unmatched endif.');
+            active = branch.parent;
+        }
+        else
+            unsupported(`Shader directive ${command ?? '(missing)'} is not supported.`);
+    }
+    if (stack.length !== 0)
+        unsupported('Shader has an unterminated conditional feature.');
+    return output.join('\n');
+}
+function tokenize(source) {
+    const tokens = [];
+    const pattern = /\s+|(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[fF]?|[A-Za-z_]\w*|[+*/-]=|[{}()[\],;.=+*/-]/guy;
+    let offset = 0;
+    while (offset < source.length) {
+        pattern.lastIndex = offset;
+        const token = pattern.exec(source)?.[0];
+        if (token === undefined)
+            unsupported('Shader contains unsupported expression syntax.');
+        offset += token.length;
+        if (token.trim().length === 0)
+            continue;
+        if (token.length > maxTokenLength)
+            unsupported('Shader token length exceeds its budget.');
+        tokens.push(token);
+        if (tokens.length > maxTokens)
+            unsupported('Shader token count exceeds its budget.');
+    }
+    return tokens;
+}
+class ColourInterpreter {
+    tokens;
+    inputName;
+    offset = 0;
+    depth = 0;
+    variables = new Map();
+    constructor(tokens, inputName, uniforms) {
+        this.tokens = tokens;
+        this.inputName = inputName;
+        this.variables.set('Color', (uniforms.colour ?? [1, 1, 1, 1]).map(constant));
+        this.variables.set('Time', [constant(uniforms.time)]);
+        this.variables.set('AnimationTime', [constant(uniforms.animationTime)]);
+    }
+    peek() {
+        return this.tokens[this.offset];
+    }
+    take() {
+        const token = this.tokens[this.offset++];
+        return token ?? unsupported('Shader expression ended unexpectedly.');
+    }
+    require(token) {
+        if (this.take() !== token)
+            unsupported(`Shader expected ${token}.`);
+    }
+    identifier() {
+        const token = this.take();
+        return /^[A-Za-z_]\w*$/u.test(token) ? token : unsupported('Shader expected an identifier.');
+    }
+    functionCall(name) {
+        this.require('(');
+        if (name === 'tex2D') {
+            this.require('MapTexture');
+            this.require(',');
+            this.require(this.inputName);
+            this.require('.');
+            this.require('vTexCoord');
+            this.require(')');
+            return identity;
+        }
+        const args = [];
+        if (this.peek() !== ')') {
+            for (;;) {
+                args.push(this.expression());
+                if (args.length > 4)
+                    unsupported('Shader call exceeds its argument budget.');
+                if (this.peek() !== ',')
+                    break;
+                this.take();
+            }
+        }
+        this.require(')');
+        const constructor = /^float([1-4])?$/u.exec(name);
+        if (constructor !== null) {
+            const width = Number(constructor[1] ?? 1);
+            const channels = args.flat();
+            if (channels.length === 1)
+                return Array.from({ length: width }, () => channels[0]);
+            if (channels.length !== width)
+                unsupported('Shader vector constructor has the wrong width.');
+            return channels;
+        }
+        if (name === 'dot' && args.length === 2 && args[0].length === args[1].length) {
+            const product = binary(args[0], args[1], '*');
+            return [product.reduce((sum, channel) => binary([sum], [channel], '+')[0], constant(0))];
+        }
+        if (name === 'lerp' && args.length === 3)
+            return binary(args[0], binary(binary(args[1], args[0], '-'), args[2], '*'), '+');
+        if (['saturate', 'abs'].includes(name) && args.length === 1)
+            return args[0].map((channel) => {
+                if (!isConstant(channel))
+                    unsupported(`${name} of sampled colour is nonlinear.`);
+                return constant(name === 'abs' ? Math.abs(channel[4]) : Math.max(0, Math.min(1, channel[4])));
+            });
+        if (['min', 'max', 'pow'].includes(name) &&
+            args.length === 2 &&
+            args.every((arg) => arg.length === 1 && isConstant(arg[0]))) {
+            const a = args[0][0][4];
+            const b = args[1][0][4];
+            return [
+                checked([
+                    0,
+                    0,
+                    0,
+                    0,
+                    name === 'min' ? Math.min(a, b) : name === 'max' ? Math.max(a, b) : Math.pow(a, b),
+                ]),
+            ];
+        }
+        return unsupported(`Shader call ${name} is not a supported affine colour operation.`);
+    }
+    primary() {
+        const token = this.take();
+        let value;
+        if (token === '(') {
+            value = this.expression();
+            this.require(')');
+        }
+        else if (token === '-' || token === '+') {
+            value = binary([constant(token === '-' ? -1 : 1)], this.expression(3), '*');
+        }
+        else if (/^(?:\d|\.)/u.test(token)) {
+            value = [checked([0, 0, 0, 0, Number(token.replace(/[fF]$/u, ''))])];
+        }
+        else if (this.peek() === '(') {
+            value = this.functionCall(token);
+        }
+        else {
+            value = this.variables.get(token) ?? unsupported(`Shader value ${token} is unresolved.`);
+        }
+        while (this.peek() === '.') {
+            this.take();
+            value = components(this.identifier(), value.length).map((index) => value[index]);
+        }
+        return value;
+    }
+    expression(minimumPrecedence = 0) {
+        this.depth += 1;
+        if (this.depth > maxDepth)
+            unsupported('Shader expression nesting exceeds its budget.');
+        try {
+            let value = this.primary();
+            for (;;) {
+                const operator = this.peek();
+                const precedence = operator === '+' || operator === '-' ? 1 : operator === '*' || operator === '/' ? 2 : -1;
+                if (precedence < minimumPrecedence)
+                    return value;
+                this.take();
+                value = binary(value, this.expression(precedence + 1), operator);
+            }
+        }
+        finally {
+            this.depth -= 1;
+        }
+    }
+    run() {
+        for (let statement = 0; statement < maxStatements; statement += 1) {
+            const first = this.identifier();
+            if (first === 'return') {
+                const value = this.expression();
+                this.require(';');
+                if (value.length !== 4 || this.offset !== this.tokens.length)
+                    unsupported('Shader must finish with one four-channel colour return.');
+                return value.flat();
+            }
+            const declaration = /^float([1-4])?$/u.exec(first);
+            const name = declaration === null ? first : this.identifier();
+            if (['Color', 'Time', 'AnimationTime'].includes(name))
+                unsupported('Shader cannot assign to a uniform.');
+            if (declaration !== null && this.variables.has(name))
+                unsupported('Shader redeclares a value.');
+            const existing = this.variables.get(name);
+            let swizzle;
+            if (this.peek() === '.') {
+                this.take();
+                swizzle = components(this.identifier(), existing?.length ?? 0);
+                if (new Set(swizzle).size !== swizzle.length)
+                    unsupported('Shader assignment repeats a swizzle component.');
+            }
+            const operator = this.take();
+            if (!['=', '+=', '-=', '*=', '/='].includes(operator))
+                unsupported('Shader statement is not an assignment.');
+            const width = declaration === null ? (swizzle?.length ?? existing?.length) : Number(declaration[1] ?? 1);
+            if (width === undefined)
+                unsupported(`Shader assignment to ${name} is undeclared.`);
+            let value = this.expression();
+            this.require(';');
+            if (value.length === 1)
+                value = Array.from({ length: width }, () => value[0]);
+            if (value.length !== width)
+                unsupported('Shader assignment changes vector width.');
+            if (operator !== '=') {
+                if (existing === undefined || declaration !== null)
+                    unsupported('Shader compound assignment has no prior value.');
+                value = binary(swizzle === undefined ? existing : swizzle.map((index) => existing[index]), value, operator[0]);
+            }
+            if (swizzle === undefined)
+                this.variables.set(name, value);
+            else {
+                const replaced = [...existing];
+                swizzle.forEach((index, component) => {
+                    replaced[index] = value[component];
+                });
+                this.variables.set(name, replaced);
+            }
+        }
+        return unsupported('Shader statement count exceeds its budget.');
+    }
+}
+function mainCodes(source) {
+    const codes = new Map();
+    for (const match of source.matchAll(/\bMainCode\s+(\w+)\s*\[\[([\s\S]*?)\]\]/gu)) {
+        if (codes.has(match[1]))
+            unsupported('Shader has duplicate named programs.');
+        codes.set(match[1], match[2]);
+    }
+    return codes;
+}
+function assertNativeVertex(source) {
+    const program = inactiveFeatures(source).replace(/\s+/gu, '');
+    const match = /^VS_OUTPUTmain\((?:const)?VS_INPUT(\w+)\)\{VS_OUTPUT(\w+);([\s\S]*)\}$/u.exec(program);
+    if (match === null)
+        unsupported('Shader vertex program is not the supported native sprite transform.');
+    const [, input, output, body] = match;
+    const prefix = `${output}.vPosition=mul(WorldViewProjectionMatrix,float4(${input}.vPosition.xyz,1));${output}.vTexCoord=${input}.vTexCoord;`;
+    const endings = ['', `${output}.vTexCoord+=Offset;`, `${output}.vTexCoord.x+=vXOffset;`];
+    if (!endings.some((offset) => body === `${prefix}${offset}return${output};`))
+        unsupported('Shader changes sprite geometry or texture coordinates beyond native atlas offsets.');
+}
+function fields(source) {
+    const result = new Map();
+    const remainder = source.replace(/\b(\w+)\s*=\s*(?:"([^"\r\n]*)"|([A-Za-z_][A-Za-z0-9_]*|[+-]?(?:\d+(?:\.\d*)?|\.\d+)))/gu, (_match, name, quoted, scalar) => {
+        if (result.has(name))
+            unsupported('Shader render state has a duplicate field.');
+        result.set(name, quoted ?? scalar);
+        return '';
+    });
+    if (remainder.trim().length > 0)
+        unsupported('Shader render state contains unsupported syntax.');
+    return result;
+}
+function textureFiltering(source) {
+    const samplers = [...source.matchAll(/\bMapTexture\s*=\s*\{([^{}]*)\}/gu)];
+    if (samplers.length !== 1)
+        unsupported('Shader must bind one primary MapTexture sampler.');
+    const sampler = fields(samplers[0][1]);
+    if (sampler.get('Index') !== '0' ||
+        sampler.get('AddressU') !== 'Clamp' ||
+        sampler.get('AddressV') !== 'Clamp' ||
+        sampler.get('MipFilter') !== 'None')
+        unsupported('Shader sampler requires primary texture slot zero, clamp addressing and no mip filtering.');
+    if ([...sampler.keys()].some((key) => ![
+        'Index',
+        'MagFilter',
+        'MinFilter',
+        'MipFilter',
+        'AddressU',
+        'AddressV',
+        'MipMapLodBias',
+    ].includes(key)))
+        unsupported('Shader sampler has unsupported fields.');
+    const mode = (key) => sampler.get(key) === 'Linear'
+        ? 'linear'
+        : sampler.get(key) === 'Point'
+            ? 'nearest'
+            : unsupported(`Shader ${key} is not a supported texture filter.`);
+    return { magnification: mode('MagFilter'), minification: mode('MinFilter') };
+}
+function assertStraightAlphaBlend(source) {
+    const blends = [...source.matchAll(/\bBlendState\s+\w+\s*\{([^{}]*)\}/gu)];
+    const blendFields = blends.length === 1 ? fields(blends[0][1]) : new Map();
+    if (blends.length !== 1 ||
+        blendFields.get('BlendEnable') !== 'yes' ||
+        blendFields.get('SourceBlend')?.toLowerCase() !== 'src_alpha' ||
+        blendFields.get('DestBlend')?.toLowerCase() !== 'inv_src_alpha' ||
+        (blendFields.has('AlphaTest') && blendFields.get('AlphaTest') !== 'no') ||
+        (blendFields.has('BlendOp') && blendFields.get('BlendOp')?.toLowerCase() !== 'add') ||
+        [...blendFields.keys()].some((key) => !['BlendEnable', 'SourceBlend', 'DestBlend', 'AlphaTest', 'BlendOp'].includes(key)))
+        unsupported('Shader does not use supported straight-alpha sprite blending.');
+}
+/** Recognize the native two-source threshold operation, never execute arbitrary shader code. */
+export function compileGuiProgressEffect(source, provenance, effect) {
+    try {
+        if (Buffer.byteLength(source, 'utf8') > GUI_SHADER_MAX_BYTES)
+            unsupported('Shader source exceeds its byte budget.');
+        const clean = withoutComments(source);
+        if (/^\s*[#@]/mu.test(clean) || /\bIncludes\s*=\s*\{\s*[^\s}]/u.test(clean))
+            unsupported('Progress shader has unbound includes or feature directives.');
+        const effects = [...clean.matchAll(/\bEffect\s+(\w+)\s*\{([^{}]*)\}/gu)].filter((match) => match[1] === effect);
+        if (effects.length !== 1)
+            unsupported(`Shader must define exactly one ${effect} effect.`);
+        const effectFields = fields(effects[0][2]);
+        const pixel = effectFields.get('PixelShader');
+        const vertex = effectFields.get('VertexShader');
+        if (effectFields.size !== 2 || pixel === undefined || vertex === undefined)
+            unsupported('Progress shader effect has unsupported render-state overrides.');
+        const programs = mainCodes(clean);
+        const vertexSource = programs.get(vertex)?.replace(/\s+/gu, '');
+        const vertexProgram = vertexSource === undefined
+            ? null
+            : /^VS_OUTPUTmain\((?:const)?VS_INPUT(\w+)\)\{VS_OUTPUT(\w+);([\s\S]*)\}$/u.exec(vertexSource);
+        if (vertexProgram === null)
+            unsupported('Progress vertex program is not a native transform.');
+        const [, input, output, body] = vertexProgram;
+        if (body !==
+            `${output}.vPosition=mul(WorldViewProjectionMatrix,${input}.vPosition);${output}.vTexCoord0=${input}.vTexCoord;${output}.vTexCoord0.y=-${output}.vTexCoord0.y;return${output};`)
+            unsupported('Progress shader changes native geometry or texture coordinates.');
+        const pixelSource = programs.get(pixel);
+        const program = pixelSource === undefined
+            ? null
+            : /^\s*float4\s+main\(\s*(?:const\s+)?VS_OUTPUT\s+(\w+)\s*\)\s*:\s*PDX_COLOR\s*\{([\s\S]*)\}\s*$/u.exec(pixelSource);
+        if (program === null)
+            unsupported('Progress shader pixel program is missing or unsupported.');
+        const variable = program[1];
+        const first = effect === 'Color' ? 'vFirstColor' : `tex2D(TextureOne,${variable}.vTexCoord0.xy)`;
+        const second = effect === 'Color' ? 'vSecondColor' : `tex2D(TextureTwo,${variable}.vTexCoord0.xy)`;
+        const pixelBody = program[2].replace(/\s+/gu, '');
+        if (pixelBody !== `if(${variable}.vTexCoord0.x<=CurrentState)return${first};elsereturn${second};`)
+            unsupported('Progress pixel program is not a supported two-source threshold operation.');
+        assertStraightAlphaBlend(clean);
+        let filtering;
+        if (effect === 'Texture') {
+            const modes = ['TextureOne', 'TextureTwo'].map((name, index) => {
+                const declarations = [
+                    ...clean.matchAll(new RegExp(`\\b${name}\\s*=\\s*\\{([^{}]*)\\}`, 'gu')),
+                ];
+                if (declarations.length !== 1)
+                    unsupported(`Progress shader must bind one ${name} sampler.`);
+                const sampler = fields(declarations[0][1]);
+                if (sampler.get('Index') !== String(index) ||
+                    sampler.get('MipFilter') !== 'None' ||
+                    sampler.get('AddressU') !== 'Wrap' ||
+                    sampler.get('AddressV') !== 'Wrap' ||
+                    [...sampler.keys()].some((key) => !['Index', 'MagFilter', 'MinFilter', 'MipFilter', 'AddressU', 'AddressV'].includes(key)))
+                    unsupported('Progress samplers require their declared slots, wrap addressing and no mip filtering.');
+                const mode = (key) => sampler.get(key) === 'Point'
+                    ? 'nearest'
+                    : sampler.get(key) === 'Linear'
+                        ? 'linear'
+                        : unsupported(`Unsupported progress ${key}.`);
+                return { magnification: mode('MagFilter'), minification: mode('MinFilter') };
+            });
+            if (modes[0].magnification !== modes[1].magnification ||
+                modes[0].minification !== modes[1].minification)
+                unsupported('Progress textures require matching filtering modes.');
+            filtering = modes[0];
+        }
+        return {
+            supported: true,
+            shader: {
+                sourcePath: provenance.path,
+                sourceHash: provenance.sha256,
+                effect,
+                entryPoint: pixel,
+                composition: 'threshold',
+                ...(filtering === undefined ? {} : { textureFiltering: filtering }),
+            },
+        };
+    }
+    catch (error) {
+        if (!(error instanceof UnsupportedShader))
+            throw error;
+        return { supported: false, reason: error.message };
+    }
+}
+export function compileGuiShaderEffect(source, provenance, effect, uniforms) {
+    try {
+        if (Buffer.byteLength(source, 'utf8') > GUI_SHADER_MAX_BYTES)
+            unsupported('Shader source exceeds its byte budget.');
+        if ([uniforms.time, uniforms.animationTime, ...(uniforms.colour ?? [])].some((value) => !Number.isFinite(value) || Math.abs(value) > maxCoefficient))
+            unsupported('Shader uniforms must be finite and within their coefficient budget.');
+        const clean = withoutComments(source);
+        if (/^\s*[#@](?:define|undef|include|if|elif|pragma)\b/mu.test(clean))
+            unsupported('Shader contains unbound preprocessor definitions or expressions.');
+        const effects = [...clean.matchAll(/\bEffect\s+(\w+)\s*\{([^{}]*)\}/gu)].filter((match) => match[1] === effect);
+        if (effects.length !== 1)
+            unsupported(`Shader must define exactly one ${effect} effect.`);
+        const effectFields = fields(effects[0][2]);
+        const pixel = effectFields.get('PixelShader');
+        const vertex = effectFields.get('VertexShader');
+        if (effectFields.size !== 2 || pixel === undefined || vertex === undefined)
+            unsupported('Shader effect has unsupported render-state overrides.');
+        const programs = mainCodes(clean);
+        const pixelSource = programs.get(pixel);
+        const vertexSource = programs.get(vertex);
+        if (pixelSource === undefined || vertexSource === undefined)
+            unsupported('Shader effect entry point is missing.');
+        assertNativeVertex(vertexSource);
+        assertStraightAlphaBlend(clean);
+        const program = /^\s*float4\s+main\(\s*(?:const\s+)?VS_OUTPUT\s+(\w+)\s*\)\s*:\s*PDX_COLOR\s*\{([^{}]*)\}\s*$/u.exec(inactiveFeatures(pixelSource));
+        if (program === null)
+            unsupported('Shader pixel program has unsupported control flow.');
+        const colourMatrix = new ColourInterpreter(tokenize(program[2]), program[1], uniforms).run();
+        const filtering = textureFiltering(clean);
+        return {
+            supported: true,
+            shader: {
+                sourcePath: provenance.path,
+                sourceHash: provenance.sha256,
+                effect,
+                entryPoint: pixel,
+                textureFiltering: filtering,
+                colourMatrix,
+            },
+        };
+    }
+    catch (error) {
+        if (!(error instanceof UnsupportedShader))
+            throw error;
+        return { supported: false, reason: error.message };
+    }
+}