hoi4-agent-tools 3.0.8 → 3.0.9

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

@@ -0,0 +1,119 @@
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
+import { hasBlockingDiagnostics } from '../core/diagnostics.js';
+import { evaluateTriggerBlock } from '../core/condition-evaluator.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. */
+export function guiExplicitConditionValues(base) {
+    const values = { ...base.stateValues, ...base.variables, ...base.values };
+    for (const [key, value] of Object.entries(values)) {
+        if (key.includes('.'))
+            continue;
+        values[`ROOT.${key}`] ??= value;
+        values[`THIS.${key}`] ??= value;
+    }
+    for (const [scope, binding] of Object.entries(base.scopes ?? {})) {
+        for (const [key, value] of Object.entries(binding.state)) {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+                values[`${scope}.${key}`] ??= value;
+        }
+    }
+    return values;
+}
+function parsedCondition(expression) {
+    const text = expression.trim();
+    const document = parseClausewitz(Buffer.from(`condition = ${text.startsWith('{') ? text : `{ ${text} }`}`), 'scenario:condition');
+    const assignment = assignments(document.root, 'condition')[0];
+    return {
+        ...(assignment?.value.type === 'block' ? { block: assignment.value } : {}),
+        invalid: hasBlockingDiagnostics(document.diagnostics) || assignment?.value.type !== 'block',
+    };
+}
+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 } : {}),
+    };
+}
+export function evaluateGuiCondition(expression, scenario, subject, definitions = new ClausewitzEvaluationDefinitions(), scope = 'ROOT') {
+    const context = resolveScopeContext(scenario, scope, rootScopeContext(scenario));
+    const parsed = expression === undefined ? { invalid: false } : parsedCondition(expression);
+    if (parsed.invalid || context === undefined)
+        return {
+            state: 'unresolved',
+            unresolved: [
+                {
+                    code: 'GUI_CONDITION_UNRESOLVED',
+                    message: parsed.invalid
+                        ? 'Condition could not be parsed'
+                        : `Scenario does not declare scope ${scope}`,
+                    candidateId: subject.id,
+                },
+            ],
+        };
+    return evaluateTriggerBlock(parsed.block, scenario, subject, definitions, [], context);
+}
+/** Find operands structurally for exploratory previews, without asserting branch eligibility. */
+export function guiConditionVariables(expression, definitions) {
+    if (expression === undefined)
+        return [];
+    const parsed = parsedCondition(expression);
+    if (parsed.invalid || parsed.block === undefined)
+        return [];
+    const output = new Set();
+    const visit = (block, scope, stack) => {
+        const add = (key) => {
+            // Scoped operands need actual bindings; fabricated flat values can shadow ROOT/PREV.
+            if (scope === '' &&
+                key !== undefined &&
+                !key.includes('.') &&
+                !key.startsWith('@') &&
+                !key.startsWith('constant:') &&
+                !Number.isFinite(Number(key)))
+                output.add(key);
+        };
+        for (const assignment of assignments(block)) {
+            const key = assignment.key.value;
+            if (key === 'check_variable' && assignment.value.type === 'block') {
+                const short = assignments(assignment.value).find(({ key }) => !['var', 'value', 'compare', 'tooltip'].includes(key.value));
+                add(firstScalar(assignment.value, 'var')?.value ?? short?.key.value);
+                add(firstScalar(assignment.value, 'value')?.value ??
+                    (short?.value.type === 'scalar' ? short.value.value : undefined));
+            }
+            else if (assignment.value.type === 'block') {
+                const prefix = ['ROOT', 'THIS', 'FROM', 'PREV'].includes(key) ? `${key}.` : scope;
+                visit(assignment.value, prefix, stack);
+            }
+            else if (assignment.operator.text === '>' || assignment.operator.text === '<') {
+                add(key);
+                add(assignment.value.value);
+            }
+            else {
+                const helper = definitions.scriptedTriggers.get(key);
+                if (helper !== undefined && !stack.has(key))
+                    visit(helper.value, scope, new Set([...stack, key]));
+            }
+        }
+    };
+    visit(parsed.block, '', new Set());
+    return [...output].sort();
+}

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

@@ -1,4 +1,6 @@
 import { sha256Bytes } from '../core/canonical.js';
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
+import { evaluateGuiCondition, guiConditionScenario, guiConditionVariables, guiExplicitConditionValues, } from './scenario-conditions.js';
 import { parsePreviewScenario } from './scenario.js';
 const countryNames = ['Germany', 'France', 'Poland', 'Italy', 'Brazil', 'India', 'Canada'];
 const countryTags = ['GER', 'FRA', 'POL', 'ITA', 'BRA', 'RAJ', 'CAN'];
@@ -257,70 +259,46 @@ function generatedNumberForKey(key, options, random, inferred = {}) {
 function setIfMissing(target, key, value) {
     target[key] ??= value;
 }
-function scriptedLocalisationValue(graph, token, language, random, kind, values) {
+function scriptedLocalisationValue(graph, token, language, kind, values, base, definitions, results) {
     const shortToken = token.slice(token.lastIndexOf('.') + 1);
-    const definitions = graph.scriptedLocalisation.filter(({ name }) => name === token || name === shortToken);
-    if (definitions.length === 0)
+    const definition = graph.scriptedLocalisation
+        .filter(({ name }) => name === token || name === shortToken)
+        .at(-1);
+    if (definition === undefined)
         return undefined;
-    const sprites = new Set(graph.sprites.map(({ name }) => name.toLocaleLowerCase('en-US')));
-    const choices = definitions.flatMap(({ choices }) => choices);
-    const eligible = choices.filter(({ localisationKey }) => kind === 'image'
-        ? sprites.has(localisationKey.toLocaleLowerCase('en-US'))
-        : localisationText(graph, language, localisationKey) !== undefined);
-    if (eligible.length === 0)
-        return undefined;
-    const evaluated = eligible.map((choice) => ({
-        choice,
-        result: evaluateSimpleTrigger(choice.triggerExpression, values),
-    }));
-    const matched = evaluated.find(({ result }) => result === true)?.choice;
-    const firstThreshold = evaluated
-        .map(({ choice }) => simpleThreshold(choice.triggerExpression))
-        .find((threshold) => threshold !== undefined && typeof values[threshold.variable] === 'number');
-    const unknownExists = evaluated.some(({ result }) => result === undefined);
-    const ranked = matched === undefined && unknownExists && firstThreshold !== undefined
-        ? eligible[Math.min(eligible.length - 1, Math.max(0, Math.round((1 - Math.max(0, Math.min(100, Number(values[firstThreshold.variable]))) / 100) *
-            (eligible.length - 1))))]
-        : undefined;
-    const fallback = evaluated.find(({ result }) => result === 'fallback')?.choice;
-    const selected = matched ?? ranked ?? fallback ?? random.pick(eligible);
-    if (kind === 'image')
-        return selected.localisationKey;
-    return localisationText(graph, language, selected.localisationKey);
-}
-function simpleThreshold(triggerExpression) {
-    if (triggerExpression === undefined)
-        return undefined;
-    const direct = /([A-Za-z_][A-Za-z0-9_.:^]*)\s*([<>])\s*(-?(?:\d+\.?\d*|\.\d+))/u.exec(triggerExpression);
-    if (direct !== null)
-        return {
-            variable: direct[1],
-            operator: direct[2],
-            threshold: Number(direct[3]),
-        };
-    const variable = /\bvar\s*=\s*([A-Za-z_][A-Za-z0-9_.:^]*)/u.exec(triggerExpression)?.[1];
-    const threshold = /\bvalue\s*=\s*(-?(?:\d+\.?\d*|\.\d+))/u.exec(triggerExpression)?.[1];
-    const compare = /\bcompare\s*=\s*(greater_than|less_than)/u.exec(triggerExpression)?.[1];
-    if (variable === undefined || threshold === undefined || compare === undefined)
-        return undefined;
-    return {
-        variable,
-        operator: compare === 'greater_than' ? '>' : '<',
-        threshold: Number(threshold),
+    const scenario = guiConditionScenario(base, values);
+    const subject = {
+        id: token,
+        provenance: [
+            {
+                path: definition.sourcePath,
+                rootKind: 'source',
+                loadOrder: 0,
+                sourceHash: graph.sourceHashes[definition.sourcePath] ?? '',
+                ...(definition.location === undefined ? {} : { location: definition.location }),
+            },
+        ],
     };
-}
-function evaluateSimpleTrigger(triggerExpression, values) {
-    if (triggerExpression === undefined || /\balways\s*=\s*yes\b/u.test(triggerExpression))
-        return 'fallback';
-    if (/\balways\s*=\s*no\b/u.test(triggerExpression))
-        return false;
-    const threshold = simpleThreshold(triggerExpression);
-    if (threshold === undefined)
-        return undefined;
-    const value = values[threshold.variable];
-    if (typeof value !== 'number')
-        return undefined;
-    return threshold.operator === '>' ? value > threshold.threshold : value < threshold.threshold;
+    const prefix = token.includes('.') ? token.slice(0, token.lastIndexOf('.')) : 'ROOT';
+    for (const choice of definition.choices) {
+        const result = evaluateGuiCondition(choice.triggerExpression, scenario, subject, definitions, prefix);
+        results.push({
+            token,
+            sourcePath: definition.sourcePath,
+            state: result.state,
+            localisationKey: choice.localisationKey,
+            unresolved: result.unresolved.map(({ message }) => message),
+        });
+        // An earlier unknown branch may be selected by the game; a later fallback cannot prove it false.
+        if (result.state === 'unresolved')
+            return undefined;
+        if (result.state === 'false')
+            continue;
+        return kind === 'image'
+            ? choice.localisationKey
+            : localisationText(graph, language, choice.localisationKey);
+    }
+    return undefined;
 }
 function materializeDynamicText(template, values) {
     const valueFor = (key) => {
@@ -481,7 +459,7 @@ function generatedRows(count, random, options) {
         };
     });
 }
-export function generateGuiPreviewScenarios(graph, windowName, base, options) {
+export function generateGuiPreviewScenarios(graph, windowName, base, options, definitions = new ClausewitzEvaluationDefinitions()) {
     if (!options.enabled)
         return [];
     const scripted = relatedScriptedGuis(graph, windowName);
@@ -519,9 +497,8 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         if (![...relevantDynamicTokens].some((token) => token === definition.name || token.endsWith(`.${definition.name}`)))
             continue;
         for (const choice of definition.choices) {
-            const threshold = simpleThreshold(choice.triggerExpression);
-            if (threshold !== undefined)
-                tokens.numeric.add(threshold.variable);
+            for (const variable of guiConditionVariables(choice.triggerExpression, definitions))
+                tokens.numeric.add(variable);
         }
     }
     const progressRanges = new Map();
@@ -545,7 +522,10 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
     const sourceSeed = options.seed === 'auto' ? `${windowName}:${base.id}:${hashSourceGraph(graph)}` : options.seed;
     return Array.from({ length: options.count }, (_unused, scenarioIndex) => {
         const random = new ScenarioRandom(`${sourceSeed}:${scenarioIndex}`);
-        const values = { ...base.values };
+        const explicitValues = guiExplicitConditionValues(base);
+        const values = { ...explicitValues };
+        const conditionResults = [];
+        const scriptedTokens = new Set([...tokens.textual].filter((token) => graph.scriptedLocalisation.some(({ name }) => name === token || token.endsWith(`.${name}`))));
         const lists = Object.fromEntries(Object.entries(base.lists).map(([key, rows]) => [key, rows.map((row) => ({ ...row }))]));
         const visibility = generatedVisibility(graph, scripted, options, random, base.visibility);
         const elementStates = { ...base.elementStates };
@@ -571,7 +551,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
                 setIfMissing(values, startValueToken, value);
         }
         for (const key of tokens.numeric) {
-            if (!key.endsWith('_bar') || base.values[key] !== undefined)
+            if (!key.endsWith('_bar') || explicitValues[key] !== undefined)
                 continue;
             const sourceKey = key.slice(0, -'_bar'.length);
             const sourceValue = values[sourceKey];
@@ -579,7 +559,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
                 values[key] = sourceValue;
         }
         for (const { value: valueKey, limit: limitKey } of numericConstraints.relationships) {
-            if (base.values[valueKey] !== undefined)
+            if (explicitValues[valueKey] !== undefined)
                 continue;
             const value = values[valueKey];
             const limit = values[limitKey];
@@ -589,22 +569,27 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
             values[valueKey] = Math.max(minimum, Math.min(value, limit));
         }
         for (const key of tokens.textual)
-            setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
+            if (!scriptedTokens.has(key))
+                setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
         const scriptedTextTemplates = new Map();
         for (const key of tokens.textual) {
-            const scriptedValue = scriptedLocalisationValue(graph, key, base.language, random, 'text', values);
-            if (scriptedValue !== undefined && base.values[key] === undefined)
+            if (explicitValues[key] !== undefined)
+                continue;
+            const scriptedValue = scriptedLocalisationValue(graph, key, base.language, 'text', values, base, definitions, conditionResults);
+            if (scriptedValue !== undefined)
                 scriptedTextTemplates.set(key, scriptedValue);
         }
         for (let pass = 0; pass < 3; pass += 1)
             for (const [key, template] of scriptedTextTemplates)
                 values[key] = materializeDynamicText(template, values);
         for (const key of imageTokens) {
+            if (explicitValues[key] !== undefined)
+                continue;
             if (/(?:^|\.)GetFlag$/u.test(key)) {
                 setIfMissing(values, key, generatedCountryTag);
                 continue;
             }
-            const sprite = scriptedLocalisationValue(graph, key, base.language, random, 'image', values);
+            const sprite = scriptedLocalisationValue(graph, key, base.language, 'image', values, base, definitions, conditionResults);
             if (sprite !== undefined)
                 setIfMissing(values, key, sprite);
         }
@@ -625,7 +610,8 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         return parsePreviewScenario({
             ...base,
             id: `${base.id}-${options.idPrefix}-${scenarioIndex + 1}`,
-            description: `Generated source-aware scenario ${scenarioIndex + 1} (seed ${sourceSeed})`,
+            description: `Generated exploratory preview ${scenarioIndex + 1} (seed ${sourceSeed}; not verified campaign state)`,
+            conditionResults,
             values,
             country: [...imageTokens].some((key) => /(?:^|\.)GetFlag$/u.test(key))
                 ? {

package/dist/hoi4_agent_tools/gui/scenario.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ConditionScopeBindingSchema, ConditionResultSchema } from '../core/condition-schema.js';
 import { renderDimensionViolation, RENDER_MAX_DIMENSION } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
 import { GUI_SCENARIO_MAX_KEYS, GUI_SCENARIO_MAX_LIST_KEYS, GUI_SCENARIO_MAX_ROWS, GUI_SCENARIO_MAX_STRING_CHARACTERS, } from './limits.js';
@@ -120,6 +121,8 @@ const GuiPreviewScenarioBodySchema = z
     visibleTimeSeconds: z.number().min(0).max(86_400).optional(),
     country: objectSchema.optional(),
     stateValues: objectSchema.optional(),
+    scopes: z.record(z.string().max(256), ConditionScopeBindingSchema).optional(),
+    conditionResults: z.array(ConditionResultSchema).max(10_000).optional(),
     variables: z.record(z.string(), z.number()).default({}),
     flags: z.record(z.string(), z.boolean()).default({}),
     lists: z.record(z.string(), z.array(objectSchema).max(10_000)).default({}),

package/dist/hoi4_agent_tools/gui/studio.js

@@ -6,6 +6,7 @@ import { compareCodeUnits, canonicalJson, deterministicId, hashCanonical, sha256
 import { DiagnosticCollector } from '../core/diagnostic-collector.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { CoreEngine } from '../core/engine.js';
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
 import { assertRenderDimensions, RenderBudget, RENDER_MAX_PIXELS } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
 import { WorkspaceScanner } from '../core/scanner.js';
@@ -25,6 +26,8 @@ import { buildGuiSourceGraph } from './source-graph.js';
 import { assertGuiSourcePatchesSafe } from './source-patch.js';
 import { validateGuiScene, validateResolutionDrift, validateStateMatrix } from './validators.js';
 const staticGuiDefinitionPatterns = [
+    'common/scripted_triggers/**/*.txt',
+    'common/script_constants/**/*.txt',
     'common/scripted_localisation/**/*.txt',
     'common/decisions/**/*.txt',
     'common/decision_categories/**/*.txt',
@@ -814,7 +817,7 @@ export class ScriptedGuiStudio {
         const scanned = await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [placeholderScenario.language, ...explicitRelatedScenarios.map(({ language }) => language)], scenarioSpriteNames([placeholderScenario, ...explicitRelatedScenarios], generatedOptions?.textSamples));
         const generatedScenarios = generatedOptions === undefined
             ? []
-            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions);
+            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions, ClausewitzEvaluationDefinitions.build(scanned));
         const scenario = generatedScenarios[0] ?? placeholderScenario;
         const relatedScenarios = [
             ...(generatedOptions?.preservePlaceholder === true && generatedScenarios.length > 0
@@ -893,7 +896,7 @@ export class ScriptedGuiStudio {
         ], generatedOptions?.textSamples));
         const generatedScenarios = generatedOptions === undefined
             ? []
-            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions);
+            : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions, ClausewitzEvaluationDefinitions.build(scanned));
         const scenario = generatedScenarios[0] ?? placeholderScenario;
         const relatedScenarios = [
             ...(generatedOptions?.preservePlaceholder === true && generatedScenarios.length > 0

package/dist/hoi4_agent_tools/probability/scenario-state.js

@@ -1,98 +1,5 @@
-function caseInsensitiveEntry(record, key) {
-    if (record === undefined)
-        return undefined;
-    if (Object.hasOwn(record, key))
-        return record[key];
-    const normalized = key.toLowerCase();
-    const found = Object.entries(record).find(([candidate]) => candidate.toLowerCase() === normalized);
-    return found?.[1];
-}
-export function rootScopeContext(scenario) {
-    return {
-        expression: 'ROOT',
-        binding: {
-            id: scenario.actor ?? 'ROOT',
-            ...(scenario.actor === undefined ? {} : { actor: scenario.actor }),
-            state: scenario.state,
-            ...(scenario.flags === undefined ? {} : { flags: scenario.flags }),
-            ...(scenario.eventTargets === undefined ? {} : { eventTargets: scenario.eventTargets }),
-        },
-    };
-}
-function explicitScope(scenario, expression, parent) {
-    const binding = caseInsensitiveEntry(scenario.scopes, expression);
-    return binding === undefined ? undefined : { expression, binding, parent };
-}
-export function resolveScopeContext(scenario, expression, current) {
-    const upper = expression.toUpperCase();
-    if (upper === 'ROOT')
-        return rootScopeContext(scenario);
-    if (upper === 'THIS')
-        return current;
-    if (upper === 'PREV')
-        return current.parent ?? rootScopeContext(scenario);
-    const chained = current.expression === 'ROOT' || current.expression === 'THIS'
-        ? expression
-        : `${current.expression}.${expression}`;
-    const chainedBinding = explicitScope(scenario, chained, current);
-    if (chainedBinding !== undefined)
-        return chainedBinding;
-    const direct = explicitScope(scenario, expression, current);
-    if (direct !== undefined)
-        return direct;
-    const targetMatch = /^(?:event_target|scope):(.+)$/iu.exec(expression);
-    const targetId = targetMatch === null
-        ? undefined
-        : (caseInsensitiveEntry(current.binding.eventTargets, targetMatch[1]) ??
-            caseInsensitiveEntry(scenario.eventTargets, targetMatch[1]));
-    if (targetId !== undefined) {
-        const declaredBinding = Object.values(scenario.scopes ?? {}).find((binding) => binding.id === targetId || binding.actor === targetId);
-        return {
-            expression,
-            binding: declaredBinding ?? { id: targetId, actor: targetId, state: {} },
-            parent: current,
-        };
-    }
-    return undefined;
-}
-export function scopeStateValue(scenario, key, current) {
-    if (Object.hasOwn(current.binding.state, key))
-        return current.binding.state[key];
-    if (Object.hasOwn(current.binding.state, `trigger.${key}`))
-        return current.binding.state[`trigger.${key}`];
-    if (current.expression !== 'ROOT')
-        return undefined;
-    if (Object.hasOwn(scenario.state, key))
-        return scenario.state[key];
-    if (Object.hasOwn(scenario.state, `trigger.${key}`))
-        return scenario.state[`trigger.${key}`];
-    return undefined;
-}
-export function rootStateValue(scenario, key) {
-    if (Object.hasOwn(scenario.state, key))
-        return scenario.state[key];
-    if (Object.hasOwn(scenario.state, `trigger.${key}`))
-        return scenario.state[`trigger.${key}`];
-    return undefined;
-}
-export function scopeIdentity(current) {
-    return current.binding.actor ?? current.binding.id;
-}
-export function scopedExpressionValue(scenario, expression) {
-    const scopes = Object.entries(scenario.scopes ?? {}).sort(([left], [right]) => right.length - left.length);
-    for (const [scope, binding] of scopes) {
-        for (const prefix of [`${scope}.`, `scope.${scope}.`, `scopes.${scope}.`]) {
-            if (!expression.toLowerCase().startsWith(prefix.toLowerCase()))
-                continue;
-            const key = expression.slice(prefix.length).replace(/^state\./u, '');
-            if (Object.hasOwn(binding.state, key))
-                return binding.state[key];
-            if (Object.hasOwn(binding.state, `variable.${key}`))
-                return binding.state[`variable.${key}`];
-        }
-    }
-    return undefined;
-}
+import { rootStateValue, scopedExpressionValue } from '../core/scenario-state.js';
+export { rootScopeContext, resolveScopeContext, scopeStateValue, rootStateValue, scopeIdentity, scopedExpressionValue, } from '../core/scenario-state.js';
 function updateScopeState(scenario, path, value) {
     const scopes = Object.entries(scenario.scopes ?? {}).sort(([left], [right]) => right.length - left.length);
     for (const [scope, binding] of scopes) {