# bins.v2.ps1 — установка выбранных программ из списка installers.json
#
# Чем отличается от bins.ps1:
#   * совместимость с Windows 7 и PowerShell 2.0..5.1: все возможности
#     (ConvertFrom-Json, Expand-Archive, Get-FileHash, Get-Package, Unblock-File,
#     ZipFile, TLS 1.2) определяются в рантайме и имеют запасной путь;
#   * докачка сделана безопасно: проверяется ответ 206 и Content-Range,
#     повторная отправка при смене файла на сервере начинается с нуля,
#     недокачанный файл больше не удаляется и не портится;
#   * "уже скачан" подтверждается маркером завершения и SHA-256, а не фактом
#     наличия файла с таким именем;
#   * коды возврата инсталляторов проверяются (msiexec 1603 — это ошибка,
#     а не "успешно установлена"); учитываются 3010 и 1641;
#   * папки распаковки защищены от выхода за пределы целевого каталога;
#   * единые точки логирования, паузы и обработки ошибок, есть -DryRun и -SelfTest.
#
# ШАПКА НАРОЧНО ОФОРМЛЕНА СТРОЧНЫМИ КОММЕНТАРИЯМИ, А НЕ БЛОКОМ <# #>:
#   при запуске вида "irm <url> | iex" служебные символы BOM попадают в начало
#   текста, и блочный комментарий перестаёт распознаваться — парсер начинает
#   читать его содержимое как код. Со строчными комментариями этого не происходит.
#
# ВАЖНО ПРО КОДИРОВКУ:
#   Файл обязан быть сохранён в UTF-8 С BOM. PowerShell 5.1 читает .ps1 без BOM
#   в системной ANSI-кодировке (windows-1251 на русской Windows), и тогда беда
#   не только в кракозябрах: часть байтов превращается в символы вида U+201A,
#   которые PowerShell считает кавычками, и файл вообще перестаёт разбираться.
#
# ЗАПУСК (правильный способ — файлом):
#   powershell.exe -NoProfile -ExecutionPolicy Bypass -File .\bins.v2.ps1
#   .\bins.v2.ps1 -JsonPath .\installers.json -DryRun      # офлайн-проверка списка
#   .\bins.v2.ps1 -SelfTest                                # проверка возможностей
#
# ЗАПУСК ОДНОЙ СТРОКОЙ (без ручного скачивания):
#   $f = "$env:TEMP\bins.v2.ps1"; iwr https://share.anykey54.ru/bins.v2.ps1 -OutFile $f
#   powershell -NoProfile -ExecutionPolicy Bypass -File $f
#   либо готовым загрузчиком — он чисто ASCII и потому переживает iex:
#   irm https://share.anykey54.ru/bins.boot.ps1 | iex
#
# ПОЧЕМУ НЕ "irm <url-этого-скрипта> | iex":
#   Invoke-RestMethod для text/plain без charset раскодирует ответ как Latin-1,
#   и служебные символы BOM в начале текста превращаются в мусор. Проверено:
#   мусор перед первым оператором ломает разбор всего файла — ошибки начинаются
#   со строки [CmdletBinding()], до кода дело не доходит. Кириллица при этом
#   тоже портится. Убрать BOM нельзя: без него PowerShell 5.1 читает .ps1
#   в системной ANSI-кодировке и файл не разбирается вообще (225 ошибок).
#   Поэтому скрипт нужно запускать файлом — bins.boot.ps1 делает это сам.
[CmdletBinding()]
param(
    # Откуда брать список установщиков.
    [string]$JsonUrl = 'https://share.anykey54.ru/list/installers.json',

    # Локальный файл вместо URL (офлайн-режим). Если указан — сеть не используется.
    [string]$JsonPath,

    # Куда складывать скачанное. По умолчанию — известная папка "Загрузки"\MyInstallers.
    [string]$DownloadFolder,

    # Файл журнала. По умолчанию — install_log.txt в папке загрузок.
    [string]$LogFile,

    [int]$Retries = 3,
    [int]$RetryDelaySeconds = 5,

    # Сколько ждать инсталлятор. 0 — ждать бесконечно.
    [int]$InstallerTimeoutMinutes = 30,

    # Размер журнала, после которого он уходит в install_log.1.txt.
    [int]$MaxLogSizeMB = 5,

    # Не опрашивать Get-Package (на Windows 10 это десятки секунд).
    [switch]$SkipPackageCheck,

    # Не определять, что уже установлено: считать всё неустановленным.
    [switch]$SkipInstalledCheck,

    # Не пропускать уже установленное: выбрать всё по умолчанию.
    [switch]$ForceReinstall,

    # Удалять скачанные установщики после успешной установки.
    [switch]$CleanupDownloads,

    # Скачивать заново, даже если файл подтверждён маркером завершения.
    [switch]$IgnoreCache,

    # Показывать в меню, почему программа считается установленной.
    [switch]$ShowDetectReason,

    # Ничего не скачивать и не запускать, только показать план.
    [switch]$DryRun,

    # Отбор без меню: номера записей (1,3,5), имена программ или слово all.
    # Нужен для запуска по расписанию и для автотестов.
    [string[]]$Select,

    # Не ждать ПРОБЕЛ в конце (для запуска по расписанию).
    [switch]$NoPause,

    # Проверить окружение и выйти.
    [switch]$SelfTest
)

Set-StrictMode -Version 1.0
$ErrorActionPreference = 'Stop'

# Проверка, что текст скрипта прочитан в правильной кодировке.
# Если файл провезли через "irm <url> | iex" без charset=utf-8, PowerShell
# раскодирует байты как Latin-1: русские строки становятся мусором, и понять
# вывод невозможно. Текст ниже намеренно набран латиницей — чтобы его можно
# было прочитать даже в этом случае. Строка-образец и класс символов портятся
# вместе, поэтому проверка ловит именно смену кодировки.
$encodingProbe = 'Проверка кодировки'
if ($encodingProbe -notmatch '^[А-Яа-яЁё ]+$') {
    Write-Host ''
    Write-Host 'ERROR: the script text was decoded with a wrong codepage.' -ForegroundColor Red
    Write-Host 'Do not run it as:  irm <url> | iex' -ForegroundColor Yellow
    Write-Host 'Invoke-RestMethod decodes text/plain without charset as Latin-1,' -ForegroundColor Yellow
    Write-Host 'so the Russian text (and the BOM) get corrupted.' -ForegroundColor Yellow
    Write-Host ''
    Write-Host 'Run it as a file instead:' -ForegroundColor Yellow
    Write-Host '  $f = "$env:TEMP\bins.v2.ps1"' -ForegroundColor Yellow
    Write-Host '  iwr https://share.anykey54.ru/bins.v2.ps1 -OutFile $f' -ForegroundColor Yellow
    Write-Host '  & $f' -ForegroundColor Yellow
    Write-Host ''
    Write-Host 'Server-side fix: serve the file as' -ForegroundColor Yellow
    Write-Host '  Content-Type: text/plain; charset=utf-8' -ForegroundColor Yellow
    exit 1
}

# ---------------------------------------------------------------------------
# Состояние скрипта. Все переменные объявлены заранее: включён StrictMode,
# обращение к неинициализированной переменной — ошибка.
# ---------------------------------------------------------------------------
$Script:Caps           = @{}
$Script:LogFile        = $null
$Script:LogWriter      = $null
$Script:MinFileLevel   = 10
$Script:MinConsoleLevel = 20
$Script:NoPause        = [bool]$NoPause
$Script:IsInteractive  = $false
$Script:UserAgent      = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
$Script:LogLevels      = @{ DEBUG = 10; INFO = 20; SUCCESS = 25; WARNING = 30; ERROR = 40 }

# ===========================================================================
# Возможности рантайма
# ===========================================================================

function Test-CommandAvailable {
    param([string]$Name)
    $command = Get-Command -Name $Name -ErrorAction SilentlyContinue
    return ($null -ne $command)
}

function Test-TypeAvailable {
    # Мало проверить наличие типа: сборку нужно ещё и загрузить, иначе её не
    # найдёт ни Type.GetType (ищет в mscorlib и вызывающей сборке), ни поиск
    # по имени. Проверка идёт через '-as [type]' по строке, без литерала типа:
    # литерал несуществующего типа — это ошибка разбора, а не $false.
    param(
        [string]$TypeName,
        [string]$AssemblyName
    )

    try {
        if ($AssemblyName) { Add-Type -AssemblyName $AssemblyName -ErrorAction Stop }
        return ($null -ne ($TypeName -as [type]))
    } catch {
        return $false
    }
}

function Initialize-Capabilities {
    $caps = @{}
    $caps['PSVersion']            = $PSVersionTable.PSVersion.ToString()
    $caps['HasConvertFromJson']   = (Test-CommandAvailable 'ConvertFrom-Json')
    $caps['HasGetFileHash']       = (Test-CommandAvailable 'Get-FileHash')
    $caps['HasExpandArchive']     = (Test-CommandAvailable 'Expand-Archive')
    $caps['HasGetPackage']        = (Test-CommandAvailable 'Get-Package')
    $caps['HasUnblockFile']       = (Test-CommandAvailable 'Unblock-File')
    $caps['HasZipFileApi']        = (Test-TypeAvailable -TypeName 'System.IO.Compression.ZipFile' -AssemblyName 'System.IO.Compression.FileSystem')
    $caps['HasZipPackageApi']     = (Test-TypeAvailable -TypeName 'System.IO.Packaging.ZipPackage' -AssemblyName 'WindowsBase')

    # JavaScriptSerializer из .NET 3.5 — быстрый запасной вариант для PowerShell 2.0.
    $caps['HasJavaScriptSerializer'] = (Test-TypeAvailable -TypeName 'System.Web.Script.Serialization.JavaScriptSerializer' -AssemblyName 'System.Web.Extensions')

    $tlsNames = @()
    try { $tlsNames = @([Enum]::GetNames([System.Net.SecurityProtocolType])) } catch { }
    $caps['HasTls12']             = ($tlsNames -contains 'Tls12')
    $caps['TlsNames']             = $tlsNames

    $caps['ShellApplication']     = $false
    try {
        $shellType = [Type]::GetTypeFromProgID('Shell.Application')
        $caps['ShellApplication'] = ($null -ne $shellType)
    } catch { }

    return $caps
}

function Initialize-Tls {
    $wanted = @()
    try {
        $names = @([Enum]::GetNames([System.Net.SecurityProtocolType]))
        foreach ($candidate in @('Tls', 'Tls11', 'Tls12')) {
            if ($names -contains $candidate) { $wanted += $candidate }
        }
    } catch { }

    if ($wanted.Count -eq 0) {
        Write-Log 'Не удалось определить поддерживаемые версии TLS.' 'WARNING'
        return
    }

    try {
        # Объединяем, а не заменяем: часть зеркал до сих пор умеет только TLS 1.0.
        $protocol = [Enum]::Parse([System.Net.SecurityProtocolType], ($wanted -join ', '))
        [System.Net.ServicePointManager]::SecurityProtocol = $protocol
        Write-Log ('TLS: включены ' + ($wanted -join ', ')) 'DEBUG'
    } catch {
        Write-Log ('Не удалось настроить TLS: ' + $_.Exception.Message) 'WARNING'
    }

    if (-not $Script:Caps['HasTls12']) {
        Write-Log 'В системе нет TLS 1.2 (.NET ниже 4.5 или Windows 7 без KB3140245). Часть сайтов может не открыться.' 'WARNING'
    }

    try {
        # Некоторые серверы отвечают на Expect: 100-continue с задержкой вплоть до таймаута.
        [System.Net.ServicePointManager]::Expect100Continue = $false
    } catch { }
}

function Initialize-ConsoleEncoding {
    try {
        $utf8 = New-Object System.Text.UTF8Encoding($false)
        [Console]::OutputEncoding = $utf8
        $global:OutputEncoding = $utf8
    } catch {
        # На урезанных консолях это может не сработать — не критично.
    }
}

# ===========================================================================
# Права администратора
# ===========================================================================

function Test-Administrator {
    try {
        $identity  = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $principal = New-Object System.Security.Principal.WindowsPrincipal($identity)
        return $principal.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    } catch {
        return $false
    }
}

# ===========================================================================
# Логирование
# ===========================================================================

function Get-LogLevelValue {
    param([string]$Level)
    if ($Script:LogLevels.ContainsKey($Level)) { return $Script:LogLevels[$Level] }
    return 20
}

function Write-Log {
    param(
        [string]$Message,
        [string]$Level = 'INFO',
        [switch]$NoConsole
    )

    $entry = '[' + (Get-Date).ToString('yyyy-MM-dd HH:mm:ss') + '] [' + $Level + '] ' + $Message

    if ($null -ne $Script:LogWriter -and (Get-LogLevelValue $Level) -ge $Script:MinFileLevel) {
        try { $Script:LogWriter.WriteLine($entry) } catch { }
    }

    if (-not $NoConsole -and (Get-LogLevelValue $Level) -ge $Script:MinConsoleLevel) {
        switch ($Level) {
            'ERROR'   { Write-Host $entry -ForegroundColor Red }
            'WARNING' { Write-Host $entry -ForegroundColor Yellow }
            'SUCCESS' { Write-Host $entry -ForegroundColor Green }
            'DEBUG'   { Write-Host $entry -ForegroundColor DarkGray }
            default   { Write-Host $entry }
        }
    }
}

function Initialize-LogFile {
    param(
        [string]$Path,
        [int]$MaxSizeMB = 5,
        [int]$MinFileLevel = 10
    )

    $Script:MinFileLevel = $MinFileLevel

    $directory = Split-Path -Path $Path -Parent
    if ($directory -and -not (Test-Path -LiteralPath $directory)) {
        New-Item -Path $directory -ItemType Directory -Force | Out-Null
    }

    # Ротация: журнал копится между запусками, поэтому ограничиваем его размер.
    if ($MaxSizeMB -gt 0 -and (Test-Path -LiteralPath $Path)) {
        $size = (Get-Item -LiteralPath $Path).Length
        if ($size -gt ($MaxSizeMB * 1MB)) {
            $archive = Join-Path $directory `
                ([System.IO.Path]::GetFileNameWithoutExtension($Path) + '.1' + [System.IO.Path]::GetExtension($Path))
            if (Test-Path -LiteralPath $archive) {
                Remove-Item -LiteralPath $archive -Force -ErrorAction SilentlyContinue
            }
            Move-Item -LiteralPath $Path -Destination $archive -Force -ErrorAction SilentlyContinue
        }
    }

    $encoding = New-Object System.Text.UTF8Encoding($false)
    $Script:LogWriter = New-Object System.IO.StreamWriter -ArgumentList @($Path, $true, $encoding)
    $Script:LogWriter.AutoFlush = $true
    $Script:LogFile = $Path
}

function Close-LogFile {
    if ($null -ne $Script:LogWriter) {
        try {
            $Script:LogWriter.Flush()
            $Script:LogWriter.Close()
        } catch { }
        $Script:LogWriter = $null
    }
}

# ===========================================================================
# Пауза и завершение
# ===========================================================================

function Wait-ForKey {
    param([string]$Message = 'Нажмите ПРОБЕЛ, чтобы закрыть...')

    if ($Script:NoPause -or -not $Script:IsInteractive) { return }

    Write-Host ''
    Write-Host $Message -NoNewline
    try {
        do {
            $key = $Host.UI.RawUI.ReadKey('NoEcho,IncludeKeyDown')
        } while ($key.VirtualKeyCode -ne 32)
    } catch {
        # Ввод перенаправлен или хост без RawUI — ждём Enter.
        try { $null = Read-Host } catch { }
    }
    Write-Host ''
}

function Stop-Script {
    param(
        [int]$ExitCode = 0,
        [string]$Message = $null,
        [string]$Level = 'INFO'
    )

    if ($Message) { Write-Log $Message $Level }
    if ($ExitCode -ne 0) { Wait-ForKey }
    Close-LogFile
    exit $ExitCode
}

# ===========================================================================
# Работа со значениями
# ===========================================================================

function Get-Value {
    # Достаёт значение из хэш-таблицы (запасной JSON-парсер) или из объекта
    # (ConvertFrom-Json). Отсутствующее поле даёт $Default, а не ошибку.
    param(
        $Object,
        [string]$Name,
        $Default = $null
    )

    if ($null -eq $Object) { return $Default }

    if ($Object -is [System.Collections.IDictionary]) {
        if ($Object.Contains($Name)) {
            $value = $Object[$Name]
            if ($null -ne $value) { return $value }
        }
        return $Default
    }

    $property = $Object.PSObject.Properties[$Name]
    if ($null -ne $property -and $null -ne $property.Value) { return $property.Value }
    return $Default
}

function Get-FirstValue {
    # Первое непустое значение из списка имён полей — терпимость к разным схемам.
    param(
        $Object,
        [string[]]$Names,
        $Default = $null
    )

    foreach ($name in $Names) {
        $value = Get-Value -Object $Object -Name $name
        if ($null -ne $value) {
            if ($value -is [string] -and $value.Trim().Length -eq 0) { continue }
            return $value
        }
    }
    return $Default
}

function Get-ObjectFieldNames {
    param($Object)
    if ($null -eq $Object) { return @() }
    if ($Object -is [System.Collections.IDictionary]) {
        $names = @()
        foreach ($key in $Object.Keys) { $names += [string]$key }
        return $names
    }
    $names = @()
    foreach ($property in $Object.PSObject.Properties) { $names += $property.Name }
    return $names
}

function Format-FileSize {
    param([double]$Bytes)
    if ($Bytes -ge 1GB) { return ('{0:N2} GB' -f ($Bytes / 1GB)) }
    if ($Bytes -ge 1MB) { return ('{0:N1} MB' -f ($Bytes / 1MB)) }
    if ($Bytes -ge 1KB) { return ('{0:N0} KB' -f ($Bytes / 1KB)) }
    return ('{0:N0} B' -f $Bytes)
}

function Get-ClampedPercent {
    param([double]$Value)
    if ($Value -lt 0) { return 0 }
    if ($Value -gt 100) { return 100 }
    return [int][Math]::Round($Value)
}

# ===========================================================================
# Файловые утилиты
# ===========================================================================

function Read-TextFileAuto {
    # Читает текст в UTF-8/UTF-16 с BOM, а без BOM — сначала пробует строгий
    # UTF-8 и только потом системную ANSI. Так же ведёт себя редактор.
    param([string]$Path)

    $bytes = [System.IO.File]::ReadAllBytes($Path)

    if ($bytes.Length -ge 3 -and $bytes[0] -eq 0xEF -and $bytes[1] -eq 0xBB -and $bytes[2] -eq 0xBF) {
        return [System.Text.Encoding]::UTF8.GetString($bytes, 3, $bytes.Length - 3)
    }
    if ($bytes.Length -ge 2 -and $bytes[0] -eq 0xFF -and $bytes[1] -eq 0xFE) {
        return [System.Text.Encoding]::Unicode.GetString($bytes, 2, $bytes.Length - 2)
    }
    if ($bytes.Length -ge 2 -and $bytes[0] -eq 0xFE -and $bytes[1] -eq 0xFF) {
        return [System.Text.Encoding]::BigEndianUnicode.GetString($bytes, 2, $bytes.Length - 2)
    }

    try {
        $strict = New-Object System.Text.UTF8Encoding($false, $true)
        return $strict.GetString($bytes)
    } catch {
        return [System.Text.Encoding]::Default.GetString($bytes)
    }
}

function Get-FileHashCompat {
    param([string]$Path)

    if ($Script:Caps['HasGetFileHash']) {
        $result = Get-FileHash -LiteralPath $Path -Algorithm SHA256
        return $result.Hash.ToLowerInvariant()
    }

    $sha    = $null
    $stream = $null
    try {
        $sha    = [System.Security.Cryptography.SHA256]::Create()
        $stream = [System.IO.File]::Open($Path, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::Read)
        $bytes  = $sha.ComputeHash($stream)
        $builder = New-Object System.Text.StringBuilder
        foreach ($byte in $bytes) { [void]$builder.Append($byte.ToString('x2')) }
        return $builder.ToString()
    } finally {
        if ($null -ne $stream) { $stream.Close() }
        if ($null -ne $sha) { $sha.Clear() }
    }
}

function Unblock-FileCompat {
    # Снимает метку "файл из интернета", иначе установщик получит MOTW.
    param([string]$Path)

    if ($Script:Caps['HasUnblockFile']) {
        try { Unblock-File -LiteralPath $Path -ErrorAction SilentlyContinue } catch { }
        return
    }
    try { Remove-Item -LiteralPath ($Path + ':Zone.Identifier') -Force -ErrorAction SilentlyContinue } catch { }
}

function Get-DownloadsFolder {
    # На Win7 папка "Загрузки" локализована, поэтому спрашиваем оболочку,
    # а к англоязычному пути откатываемся только если COM недоступен.
    try {
        $shell  = New-Object -ComObject Shell.Application
        $folder = $shell.NameSpace('shell:Downloads')
        if ($null -ne $folder -and $folder.Self.Path) {
            return [string]$folder.Self.Path
        }
    } catch { }

    $profilePath = [Environment]::GetFolderPath('UserProfile')
    return (Join-Path $profilePath 'Downloads')
}

# ===========================================================================
# JSON
#
# Разбор JSON в три слоя, от быстрого к универсальному:
#   1. ConvertFrom-Json        — PowerShell 3.0+
#   2. JavaScriptSerializer    — .NET 3.5+ (обычно есть даже на Windows 7)
#   3. собственный парсер      — работает всегда, включая PowerShell 2.0
# ===========================================================================

$Script:JsonText   = ''
$Script:JsonChars  = $null
$Script:JsonPos    = 0
$Script:JsonLength = 0

function JsonSkipWhitespace {
    while ($Script:JsonPos -lt $Script:JsonLength) {
        $ch = $Script:JsonChars[$Script:JsonPos]
        if ($ch -eq ' ' -or $ch -eq "`t" -or $ch -eq "`r" -or $ch -eq "`n") {
            $Script:JsonPos++
        } else {
            break
        }
    }
}

function JsonReadString {
    # Вызывается, когда текущий символ — открывающая кавычка.
    $Script:JsonPos++
    $builder = New-Object System.Text.StringBuilder
    while ($Script:JsonPos -lt $Script:JsonLength) {
        $ch = $Script:JsonChars[$Script:JsonPos]
        $Script:JsonPos++
        if ($ch -eq '"') { return $builder.ToString() }
        if ($ch -ne '\') {
            [void]$builder.Append($ch)
            continue
        }
        if ($Script:JsonPos -ge $Script:JsonLength) { break }
        $esc = $Script:JsonChars[$Script:JsonPos]
        $Script:JsonPos++
        switch ($esc) {
            '"'     { [void]$builder.Append('"') }
            '\'     { [void]$builder.Append('\') }
            '/'     { [void]$builder.Append('/') }
            'b'     { [void]$builder.Append([char]8) }
            'f'     { [void]$builder.Append([char]12) }
            'n'     { [void]$builder.Append([char]10) }
            'r'     { [void]$builder.Append([char]13) }
            't'     { [void]$builder.Append([char]9) }
            'u'     {
                if ($Script:JsonPos + 4 -gt $Script:JsonLength) { throw 'Обрыв escape-последовательности \u в JSON.' }
                $hex = $Script:JsonText.Substring($Script:JsonPos, 4)
                $Script:JsonPos += 4
                [void]$builder.Append([char][Convert]::ToInt32($hex, 16))
            }
            default { [void]$builder.Append($esc) }
        }
    }
    throw 'Незакрытая строка в JSON.'
}

function JsonReadNumber {
    $start = $Script:JsonPos
    while ($Script:JsonPos -lt $Script:JsonLength) {
        $ch = $Script:JsonChars[$Script:JsonPos]
        if (($ch -ge '0' -and $ch -le '9') -or $ch -eq '-' -or $ch -eq '+' -or $ch -eq '.' -or $ch -eq 'e' -or $ch -eq 'E') {
            $Script:JsonPos++
        } else {
            break
        }
    }
    $raw = $Script:JsonText.Substring($start, $Script:JsonPos - $start)
    if ($raw.Length -eq 0) { throw ('Ожидалось значение в позиции ' + $start + '.') }

    $intValue = 0
    if ($raw -notmatch '[.eE]') {
        if ([int]::TryParse($raw, [ref]$intValue)) { return $intValue }
    }
    return [double]::Parse($raw, [System.Globalization.CultureInfo]::InvariantCulture)
}

function JsonReadObject {
    $Script:JsonPos++   # {
    $table = @{}
    JsonSkipWhitespace

    if ($Script:JsonPos -lt $Script:JsonLength -and $Script:JsonChars[$Script:JsonPos] -eq '}') {
        $Script:JsonPos++
        return $table
    }

    while ($true) {
        JsonSkipWhitespace
        if ($Script:JsonPos -ge $Script:JsonLength) { throw 'Незакрытый объект JSON.' }
        if ($Script:JsonChars[$Script:JsonPos] -ne '"') { throw ('Ожидалось имя поля в позиции ' + $Script:JsonPos + '.') }

        $key = JsonReadString
        JsonSkipWhitespace

        if ($Script:JsonPos -ge $Script:JsonLength -or $Script:JsonChars[$Script:JsonPos] -ne ':') {
            throw ('Ожидалось ":" после поля "' + $key + '".')
        }
        $Script:JsonPos++
        $table[$key] = JsonReadValue

        JsonSkipWhitespace
        if ($Script:JsonPos -ge $Script:JsonLength) { throw 'Незакрытый объект JSON.' }
        $ch = $Script:JsonChars[$Script:JsonPos]
        $Script:JsonPos++
        if ($ch -eq '}') { break }
        if ($ch -ne ',') { throw ('Ожидалась "," или "}" в позиции ' + ($Script:JsonPos - 1) + '.') }
    }
    return $table
}

function JsonReadArray {
    $Script:JsonPos++   # [
    $items = @()
    JsonSkipWhitespace

    if ($Script:JsonPos -lt $Script:JsonLength -and $Script:JsonChars[$Script:JsonPos] -eq ']') {
        $Script:JsonPos++
        return $items
    }

    while ($true) {
        # Запятая перед значением сохраняет вложенные массивы: без неё
        # PowerShell "разворачивает" массив внутрь внешнего.
        $items += ,(JsonReadValue)
        JsonSkipWhitespace
        if ($Script:JsonPos -ge $Script:JsonLength) { throw 'Незакрытый массив JSON.' }
        $ch = $Script:JsonChars[$Script:JsonPos]
        $Script:JsonPos++
        if ($ch -eq ']') { break }
        if ($ch -ne ',') { throw ('Ожидалась "," или "]" в позиции ' + ($Script:JsonPos - 1) + '.') }
    }
    return $items
}

function JsonReadValue {
    JsonSkipWhitespace
    if ($Script:JsonPos -ge $Script:JsonLength) { throw 'Неожиданный конец JSON.' }

    $ch = $Script:JsonChars[$Script:JsonPos]
    switch ($ch) {
        '{' { return (JsonReadObject) }
        '[' { return (JsonReadArray) }
        '"' { return (JsonReadString) }
        't' {
            if ($Script:JsonText.Substring($Script:JsonPos, 4) -ne 'true') { throw ('Ожидалось true в позиции ' + $Script:JsonPos + '.') }
            $Script:JsonPos += 4
            return $true
        }
        'f' {
            if ($Script:JsonText.Substring($Script:JsonPos, 5) -ne 'false') { throw ('Ожидалось false в позиции ' + $Script:JsonPos + '.') }
            $Script:JsonPos += 5
            return $false
        }
        'n' {
            if ($Script:JsonText.Substring($Script:JsonPos, 4) -ne 'null') { throw ('Ожидалось null в позиции ' + $Script:JsonPos + '.') }
            $Script:JsonPos += 4
            return $null
        }
        default { return (JsonReadNumber) }
    }
}

function ConvertFrom-JsonFallback {
    param([string]$Text)

    if ($null -eq $Text) { throw 'Пустой JSON.' }
    $Script:JsonText   = $Text
    $Script:JsonChars  = $Text.ToCharArray()
    $Script:JsonPos    = 0
    $Script:JsonLength = $Text.Length

    if ($Script:JsonLength -gt 0 -and [int]$Text[0] -eq 0xFEFF) { $Script:JsonPos = 1 }

    $value = JsonReadValue
    JsonSkipWhitespace
    if ($Script:JsonPos -lt $Script:JsonLength) {
        throw ('Лишние данные после JSON, позиция ' + $Script:JsonPos + '.')
    }
    return $value
}

function ConvertFrom-JsonCompat {
    param(
        [string]$Text,
        [switch]$ForceFallback
    )

    if (-not $ForceFallback) {
        if ($Script:Caps['HasConvertFromJson']) {
            return ($Text | ConvertFrom-Json)
        }
        if ($Script:Caps['HasJavaScriptSerializer']) {
            try {
                $serializer = New-Object System.Web.Script.Serialization.JavaScriptSerializer
                return $serializer.DeserializeObject($Text)
            } catch {
                Write-Log ('JavaScriptSerializer не справился, разбираем встроенным парсером: ' + $_.Exception.Message) 'DEBUG'
            }
        }
    }
    return (ConvertFrom-JsonFallback -Text $Text)
}

# ===========================================================================
# Список установщиков
# ===========================================================================

function ConvertTo-InstallerList {
    # Приводит разобранный JSON к единому виду. Поля читаются по нескольким
    # возможным именам, поэтому список можно расширять, не ломая скрипт.
    param($Data)

    if ($null -eq $Data) { throw 'Список установщиков пуст.' }

    # Если список завёрнут в объект-контейнер, разворачиваем его.
    if ($Data -is [System.Collections.IDictionary] -or $Data -is [System.Management.Automation.PSCustomObject]) {
        foreach ($wrapper in @('installers', 'programs', 'items', 'list', 'apps')) {
            $candidate = Get-Value -Object $Data -Name $wrapper
            if ($null -eq $candidate -or $candidate -is [string]) { continue }
            Write-Log ('Список программ найден в поле "' + $wrapper + '".') 'DEBUG'
            $Data = $candidate
            break
        }
    }

    $result = @()
    $index  = 0

    foreach ($item in @($Data)) {
        $index++
        $name = [string](Get-FirstValue -Object $item -Names @('name', 'title', 'displayName') -Default '')

        if ($name.Trim().Length -eq 0) {
            Write-Log ('Запись №' + $index + ' пропущена: нет поля name. Найдены поля: ' + ((Get-ObjectFieldNames -Object $item) -join ', ')) 'WARNING'
            continue
        }

        $urls = @()
        foreach ($candidate in @(Get-FirstValue -Object $item -Names @('urls', 'url') -Default @())) {
            if ($null -ne $candidate -and ([string]$candidate).Trim().Length -gt 0) {
                $urls += ([string]$candidate).Trim()
            }
        }
        if ($urls.Count -eq 0) {
            Write-Log ($name + ': пропущена, нет ни одной ссылки (urls/url).') 'WARNING'
            continue
        }

        $hash = [string](Get-FirstValue -Object $item -Names @('sha256', 'hash', 'checksum') -Default '')
        $hash = ($hash.Trim().ToLowerInvariant() -replace '[^0-9a-f]', '')
        if ($hash.Length -ne 64) { $hash = '' }

        $result += New-Object PSObject -Property @{
            Name        = $name.Trim()
            Urls        = $urls
            Arguments   = [string](Get-FirstValue -Object $item -Names @('arguments', 'args', 'installArguments', 'silentArgs') -Default '')
            PostExtract = [string](Get-FirstValue -Object $item -Names @('postExtract', 'postExtractFile', 'runAfterExtract') -Default '')
            Detect      = @(Get-FirstValue -Object $item -Names @('detect', 'detectNames', 'alreadyInstalled') -Default @())
            Sha256      = $hash
            Category    = [string](Get-FirstValue -Object $item -Names @('category', 'group') -Default '')
            ExtractTo   = [string](Get-FirstValue -Object $item -Names @('extractTo', 'targetFolder') -Default '')
            FileName    = [string](Get-FirstValue -Object $item -Names @('fileName', 'file') -Default '')
            Fields      = @(Get-ObjectFieldNames -Object $item)
        }
    }

    return $result
}

function Get-InstallerList {
    param(
        [string]$Url,
        [string]$Path,
        [int]$Retries = 3,
        [int]$RetryDelaySeconds = 5
    )

    if ($Path) {
        if (-not (Test-Path -LiteralPath $Path)) { throw ('Файл списка не найден: ' + $Path) }
        Write-Log ('Читаем список из файла: ' + $Path)
        $text = Read-TextFileAuto -Path $Path
    } else {
        Write-Log ('Загружаем список: ' + $Url)
        $text = Get-TextFromUrl -Url $Url -Retries $Retries -RetryDelaySeconds $RetryDelaySeconds
    }

    if ($null -eq $text -or $text.Trim().Length -eq 0) { throw 'Получен пустой список установщиков.' }

    $data       = ConvertFrom-JsonCompat -Text $text
    $installers = @(ConvertTo-InstallerList -Data $data)

    if ($installers.Count -eq 0) { throw 'В списке нет ни одной пригодной записи.' }

    # Полезно при подгонке скрипта под новый список: видно, какие поля вообще есть.
    $allFields = @()
    foreach ($installer in $installers) {
        foreach ($field in $installer.Fields) {
            if ($allFields -notcontains $field) { $allFields += $field }
        }
    }
    Write-Log ('Поля в списке: ' + (($allFields | Sort-Object) -join ', ') + ' (записей: ' + $installers.Count + ')') 'DEBUG'

    return $installers
}

# ===========================================================================
# Сеть
#
# Используется HttpWebRequest, а не HttpClient: он есть начиная с .NET 2.0,
# то есть работает и на "голой" Windows 7 без .NET 4.5.
# ===========================================================================

function Get-WebResponseSafe {
    # GetResponse() бросает WebException на любом ответе вне 2xx, поэтому статус
    # приходится доставать из исключения.
    param($Request)

    $result = @{ Response = $null; StatusCode = 0; StatusText = ''; Error = $null }

    try {
        $response     = $Request.GetResponse()
        $httpResponse = [System.Net.HttpWebResponse]$response
        $result['Response']   = $response
        $result['StatusCode'] = [int]$httpResponse.StatusCode
        $result['StatusText'] = [string]$httpResponse.StatusDescription
    } catch [System.Net.WebException] {
        $webError = $_.Exception
        if ($null -ne $webError.Response) {
            $httpResponse = [System.Net.HttpWebResponse]$webError.Response
            $result['Response']   = $httpResponse
            $result['StatusCode'] = [int]$httpResponse.StatusCode
            $result['StatusText'] = [string]$httpResponse.StatusDescription
        } else {
            $result['Error'] = $webError.Message
        }
    }

    return $result
}

function New-DownloadRequest {
    param(
        [string]$Url,
        [long]$From = 0,
        [string]$IfRange = $null,
        [switch]$AllowCompression
    )

    $request = [System.Net.HttpWebRequest]::Create($Url)
    $request.Method = 'GET'
    $request.AllowAutoRedirect = $true
    $request.MaximumAutomaticRedirections = 10
    $request.UserAgent = $Script:UserAgent
    $request.Accept = '*/*'
    $request.KeepAlive = $true
    $request.Timeout = 60000            # соединение и получение заголовков
    $request.ReadWriteTimeout = 300000  # таймаут на одно чтение из потока

    if ($AllowCompression) {
        $request.AutomaticDecompression = [System.Net.DecompressionMethods]::GZip -bor [System.Net.DecompressionMethods]::Deflate
    }

    # Для установщиков сжатие не запрашиваем сознательно: при сжатом ответе
    # смещения в Range относятся к сжатому потоку, и докачка склеит мусор.
    if ($From -gt 0) {
        if ($From -gt [int]::MaxValue) {
            throw 'Файл больше 2 ГБ: докачка не поддерживается.'
        }
        $request.AddRange([int]$From)
        if ($IfRange) { $request.Headers['If-Range'] = $IfRange }
    }

    return $request
}

function Get-TextFromUrl {
    param(
        [string]$Url,
        [int]$Retries = 3,
        [int]$RetryDelaySeconds = 5
    )

    $attempt   = 0
    $lastError = 'неизвестная ошибка'

    while ($attempt -lt $Retries) {
        $attempt++
        $response = $null
        try {
            $request = New-DownloadRequest -Url $Url -AllowCompression
            $request.Accept = 'application/json, text/plain, */*'
            $request.Timeout = 30000
            $request.ReadWriteTimeout = 60000

            $answer   = Get-WebResponseSafe -Request $request
            $response = $answer['Response']

            if ($null -eq $response) { throw ('Сетевая ошибка: ' + $answer['Error']) }

            $status = $answer['StatusCode']
            if ($status -ne 200) {
                throw ('HTTP ' + $status + ' ' + $answer['StatusText'])
            }

            $stream = $response.GetResponseStream()
            $reader = New-Object System.IO.StreamReader -ArgumentList @($stream, [System.Text.Encoding]::UTF8, $true)
            try {
                return $reader.ReadToEnd()
            } finally {
                $reader.Close()
            }
        } catch {
            $lastError = $_.Exception.Message
            Write-Log ('Попытка ' + $attempt + ' из ' + $Retries + ' не удалась: ' + $lastError) 'WARNING'
            if ($attempt -lt $Retries) { Start-Sleep -Seconds $RetryDelaySeconds }
        } finally {
            if ($null -ne $response) { try { ([System.Net.HttpWebResponse]$response).Close() } catch { } }
        }
    }

    throw ('Не удалось получить ' + $Url + ' за ' + $Retries + ' попыток. Последняя ошибка: ' + $lastError)
}

# ===========================================================================
# Загрузка файлов
#
# Рядом с файлом лежит маркер <файл>.resume. Он нужен для двух вещей:
#   * отличить полностью скачанный файл от обрывка с тем же именем;
#   * помнить ETag/Last-Modified, чтобы докачка не склеила две версии файла.
# ===========================================================================

function Get-ResumeMarkerPath {
    param([string]$Path)
    return ($Path + '.resume')
}

function Read-ResumeMarker {
    param([string]$Path)

    $result     = @{}
    $markerPath = Get-ResumeMarkerPath -Path $Path
    if (-not (Test-Path -LiteralPath $markerPath)) { return $result }

    try {
        foreach ($line in [System.IO.File]::ReadAllLines($markerPath)) {
            if ($line -match '^\s*([A-Za-z]+)\s*=\s*(.*)$') {
                $result[$Matches[1]] = $Matches[2]
            }
        }
    } catch {
        Write-Log ('Не удалось прочитать маркер загрузки: ' + $_.Exception.Message) 'DEBUG'
    }
    return $result
}

function Write-ResumeMarker {
    param([string]$Path, $Data)

    $lines = @()
    foreach ($key in @('Url', 'ETag', 'LastModified', 'TotalLength', 'Sha256', 'Complete')) {
        $value = ''
        if ($Data.ContainsKey($key)) { $value = [string]$Data[$key] }
        $lines += ($key + '=' + $value)
    }

    try {
        $encoding = New-Object System.Text.UTF8Encoding($false)
        [System.IO.File]::WriteAllLines((Get-ResumeMarkerPath -Path $Path), [string[]]$lines, $encoding)
    } catch {
        Write-Log ('Не удалось сохранить маркер загрузки: ' + $_.Exception.Message) 'DEBUG'
    }
}

function Get-FileWithResume {
    param(
        [string]$Url,
        [string]$Destination,
        [string]$ExpectedHash = $null,
        [int]$Retries = 3,
        [int]$RetryDelaySeconds = 5,
        [string]$Label = '',
        [switch]$IgnoreCache
    )

    if (-not $Label) { $Label = Split-Path -Path $Destination -Leaf }
    $activity = 'Скачивание: ' + $Label
    $marker   = Read-ResumeMarker -Path $Destination

    # -IgnoreCache означает "начать заново", а не "докачать остаток":
    # иначе уже полный файл просто подтвердился бы ответом 206 на пустой Range.
    if ($IgnoreCache -and (Test-Path -LiteralPath $Destination)) {
        Write-Log ($Label + ': -IgnoreCache, удаляем ранее скачанный файл и начинаем заново.') 'DEBUG'
        Remove-Item -LiteralPath $Destination -Force -ErrorAction SilentlyContinue
        Remove-Item -LiteralPath (Get-ResumeMarkerPath -Path $Destination) -Force -ErrorAction SilentlyContinue
        $marker = @{}
    }

    # --- Шаг 1: файл уже скачан и это подтверждено маркером ---
    if (-not $IgnoreCache -and (Test-Path -LiteralPath $Destination) -and $marker['Complete'] -eq '1' -and $marker['Url'] -eq $Url) {
        $size         = (Get-Item -LiteralPath $Destination).Length
        $expectedSize = -1
        if ([string]$marker['TotalLength'] -match '^\d+$') { $expectedSize = [long]$marker['TotalLength'] }

        if ($expectedSize -ne $size) {
            Write-Log ($Label + ': размер файла (' + $size + ') не совпадает с записанным (' + $expectedSize + '), перекачиваем.') 'WARNING'
        } elseif ($ExpectedHash) {
            $actualHash = Get-FileHashCompat -Path $Destination
            if ($actualHash -eq $ExpectedHash) {
                Write-Log ($Label + ': уже скачан, SHA-256 совпал, пропускаем загрузку.') 'DEBUG'
                return @{ Status = 'cached'; Path = $Destination; Length = $size; Sha256 = $actualHash }
            }
            Write-Log ($Label + ': SHA-256 не совпал (' + $actualHash + '), файл перекачивается.') 'WARNING'
        } else {
            Write-Log ($Label + ': уже скачан (' + (Format-FileSize $size) + '), пропускаем загрузку.') 'DEBUG'
            return @{ Status = 'cached'; Path = $Destination; Length = $size; Sha256 = '' }
        }

        Remove-Item -LiteralPath $Destination -Force -ErrorAction SilentlyContinue
        Remove-Item -LiteralPath (Get-ResumeMarkerPath -Path $Destination) -Force -ErrorAction SilentlyContinue
        $marker = @{}
    }

    $attempt   = 0
    $lastError = 'неизвестная ошибка'
    $fatal     = $false

    while ($attempt -lt $Retries) {
        $attempt++
        $response   = $null
        $stream     = $null
        $fileStream = $null

        try {
            $existing = 0L
            if (Test-Path -LiteralPath $Destination) { $existing = (Get-Item -LiteralPath $Destination).Length }

            if ($existing -gt [int]::MaxValue) {
                Write-Log ($Label + ': локальный файл больше 2 ГБ, начинаем загрузку заново.') 'WARNING'
                Remove-Item -LiteralPath $Destination -Force -ErrorAction SilentlyContinue
                $existing = 0
                $marker   = @{}
            }

            $ifRange = $null
            if ($existing -gt 0 -and $marker['Url'] -eq $Url) {
                if ($marker['ETag']) { $ifRange = [string]$marker['ETag'] }
                elseif ($marker['LastModified']) { $ifRange = [string]$marker['LastModified'] }
            }

            $request  = New-DownloadRequest -Url $Url -From $existing -IfRange $ifRange
            $answer   = Get-WebResponseSafe -Request $request
            $response = $answer['Response']

            if ($null -eq $response) { throw ('Сетевая ошибка: ' + $answer['Error']) }

            $status = $answer['StatusCode']

            if ($status -eq 416) {
                # Огрызок длиннее файла на сервере — файл там заменили.
                Write-Log ($Label + ': локальный огрызок длиннее файла на сервере, начинаем заново.') 'WARNING'
                Remove-Item -LiteralPath $Destination -Force -ErrorAction SilentlyContinue
                Remove-Item -LiteralPath (Get-ResumeMarkerPath -Path $Destination) -Force -ErrorAction SilentlyContinue
                $marker = @{}
                continue
            }

            if ($status -eq 401 -or $status -eq 403 -or $status -eq 404) {
                $fatal = $true
                throw ('HTTP ' + $status + ' ' + $answer['StatusText'] + ' — ' + $Url)
            }
            if ($status -ne 200 -and $status -ne 206) {
                throw ('HTTP ' + $status + ' ' + $answer['StatusText'])
            }

            $httpResponse = [System.Net.HttpWebResponse]$response

            # --- Шаг 2: решаем, дописывать или начинать заново ---
            $append = $false
            $total  = -1L

            if ($status -eq 206 -and $existing -gt 0) {
                $append       = $true
                $contentRange = [string]$httpResponse.Headers['Content-Range']
                if ($contentRange -and $contentRange -match '/(\d+)\s*$') { $total = [long]$Matches[1] }
                if ($total -le 0 -and $httpResponse.ContentLength -ge 0) {
                    $total = $existing + [long]$httpResponse.ContentLength
                }
                Write-Log ($Label + ': продолжаем загрузку с ' + (Format-FileSize $existing) + '.') 'DEBUG'
            } else {
                if ($existing -gt 0) {
                    # Ключевая проверка: сервер проигнорировал Range и отдал файл
                    # целиком. Дописать его к огрызку означало бы испортить файл.
                    Write-Log ($Label + ': сервер ответил 200 вместо 206 (докачка не поддерживается), качаем заново.') 'WARNING'
                }
                $append   = $false
                $existing = 0
                if ($httpResponse.ContentLength -ge 0) { $total = [long]$httpResponse.ContentLength }
            }

            # Запоминаем ETag до начала записи: если загрузка оборвётся,
            # продолжение будет запрошено именно для этой версии файла.
            $marker = @{
                Url          = $Url
                ETag         = [string]$httpResponse.Headers['ETag']
                LastModified = [string]$httpResponse.Headers['Last-Modified']
                TotalLength  = $total
                Complete     = '0'
            }
            Write-ResumeMarker -Path $Destination -Data $marker

            # --- Шаг 3: копируем поток ---
            $directory = Split-Path -Path $Destination -Parent
            if ($directory -and -not (Test-Path -LiteralPath $directory)) {
                New-Item -Path $directory -ItemType Directory -Force | Out-Null
            }

            $stream   = $httpResponse.GetResponseStream()
            $fileMode = [System.IO.FileMode]::Create
            if ($append) { $fileMode = [System.IO.FileMode]::Append }
            $fileStream = [System.IO.File]::Open($Destination, $fileMode, [System.IO.FileAccess]::Write, [System.IO.FileShare]::None)

            $buffer     = New-Object byte[] 65536
            $written    = $existing
            $stopwatch  = [System.Diagnostics.Stopwatch]::StartNew()
            $lastUpdate = -200

            while ($true) {
                $read = $stream.Read($buffer, 0, $buffer.Length)
                if ($read -le 0) { break }
                $fileStream.Write($buffer, 0, $read)
                $written += $read

                if ($stopwatch.ElapsedMilliseconds -ge ($lastUpdate + 200)) {
                    $lastUpdate = $stopwatch.ElapsedMilliseconds
                    $seconds    = $stopwatch.ElapsedMilliseconds / 1000.0
                    $speed      = 0
                    if ($seconds -gt 0) { $speed = ($written - $existing) / $seconds }

                    if ($total -gt 0) {
                        Write-Progress -Activity $activity `
                            -Status ((Format-FileSize $written) + ' из ' + (Format-FileSize $total) + ' (' + (Format-FileSize $speed) + '/с)') `
                            -PercentComplete (Get-ClampedPercent (($written / $total) * 100))
                    } else {
                        Write-Progress -Activity $activity -Status ((Format-FileSize $written) + ' скачано')
                    }
                }
            }

            $fileStream.Flush()
            $fileStream.Close(); $fileStream = $null
            $stream.Close();     $stream     = $null
            $httpResponse.Close(); $response = $null
            Write-Progress -Activity $activity -Completed

            # --- Шаг 4: проверки ---
            $finalLength = (Get-Item -LiteralPath $Destination).Length
            if ($total -gt 0 -and $finalLength -ne $total) {
                throw ('Файл недокачан: ' + $finalLength + ' из ' + $total + ' байт.')
            }

            $actualHash = ''
            if ($ExpectedHash) {
                $actualHash = Get-FileHashCompat -Path $Destination
                if ($actualHash -ne $ExpectedHash) {
                    Remove-Item -LiteralPath $Destination -Force -ErrorAction SilentlyContinue
                    Remove-Item -LiteralPath (Get-ResumeMarkerPath -Path $Destination) -Force -ErrorAction SilentlyContinue
                    $fatal = $true
                    throw ('SHA-256 не совпал: ожидался ' + $ExpectedHash + ', получен ' + $actualHash + '. Файл удалён.')
                }
            }

            $marker = @{
                Url          = $Url
                ETag         = [string]$marker['ETag']
                LastModified = [string]$marker['LastModified']
                TotalLength  = $finalLength
                Sha256       = $actualHash
                Complete     = '1'
            }
            Write-ResumeMarker -Path $Destination -Data $marker

            $resultStatus = 'downloaded'
            if ($append) { $resultStatus = 'resumed' }

            return @{ Status = $resultStatus; Path = $Destination; Length = $finalLength; Sha256 = $actualHash }
        } catch {
            $lastError = $_.Exception.Message
            if ($fatal) {
                Write-Progress -Activity $activity -Completed
                throw $lastError
            }
            Write-Log ($Label + ': попытка ' + $attempt + ' из ' + $Retries + ' не удалась — ' + $lastError) 'WARNING'
            if ($attempt -lt $Retries) {
                $delay = $RetryDelaySeconds * $attempt
                Write-Log ('Повтор через ' + $delay + ' с. Недокачанный файл сохранён для продолжения.') 'DEBUG'
                Start-Sleep -Seconds $delay
            }
        } finally {
            if ($null -ne $fileStream) { try { $fileStream.Close() } catch { } }
            if ($null -ne $stream)     { try { $stream.Close() }     catch { } }
            if ($null -ne $response)   { try { ([System.Net.HttpWebResponse]$response).Close() } catch { } }
        }
    }

    Write-Progress -Activity $activity -Completed
    throw ($Label + ': не удалось скачать за ' + $Retries + ' попыток. Последняя ошибка: ' + $lastError)
}

# ===========================================================================
# Определение того, что уже установлено
#
# Раньше на каждый установщик и на каждое слово его имени заново перебирался
# весь реестр — это O(установщики × слова × записи) и минуты работы.
# Теперь реестр читается один раз и склеивается в одну строку, а поиск идёт
# предкомпилированными регулярными выражениями по границам слов.
# ===========================================================================

function Get-InstallerTokens {
    # Значимые слова имени программы. Служебные слова отбрасываются: иначе
    # "Microsoft" или "Setup" в имени дают ложное "уже установлена".
    param([string]$Name)

    $stopWords = @(
        'microsoft', 'windows', 'setup', 'install', 'installer', 'runtime', 'update', 'updates',
        'x64', 'x86', 'bit', 'the', 'and', 'for', 'with', 'from', 'plus', 'edition', 'version',
        'free', 'standard', 'portable'
    )

    $tokens = @()
    foreach ($word in ($Name -split '[^0-9A-Za-zА-Яа-яЁё\.\+]+')) {
        $token = $word.Trim().TrimEnd('.').ToLowerInvariant()
        if ($token.Length -lt 3) { continue }
        if ($stopWords -contains $token) { continue }
        if ($tokens -notcontains $token) { $tokens += $token }
    }
    return $tokens
}

function New-TokenPattern {
    param([string]$Token, $Cache)

    if (-not $Cache.ContainsKey($Token)) {
        # Границы — только буквы, без цифр: иначе "hwinfo" не найдётся
        # в "HWiNFO64", а таких имён в Windows большинство.
        $pattern = '(?<![a-zа-яё])' + [regex]::Escape($Token) + '(?![a-zа-яё])'
        $Cache[$Token] = New-Object System.Text.RegularExpressions.Regex($pattern)
    }
    return $Cache[$Token]
}

function Get-InstalledIndex {
    param([switch]$SkipPackageCheck)

    $registryBuilder = New-Object System.Text.StringBuilder
    $programsBuilder = New-Object System.Text.StringBuilder
    $packagesBuilder = New-Object System.Text.StringBuilder
    $processBuilder  = New-Object System.Text.StringBuilder
    $exactNames      = @{}
    $counts          = @{ Registry = 0; Programs = 0; Packages = 0; Processes = 0 }

    $stopwatch = [System.Diagnostics.Stopwatch]::StartNew()

    # --- Реестр: единственный надёжный источник ---
    $registryPaths = @(
        'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*',
        'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*',
        'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*'
    )
    foreach ($path in $registryPaths) {
        try {
            foreach ($item in @(Get-ItemProperty -Path $path -ErrorAction SilentlyContinue)) {
                $displayName = [string](Get-Value -Object $item -Name 'DisplayName' -Default '')
                if ($displayName.Trim().Length -eq 0) { continue }

                $counts['Registry']++
                $lower = $displayName.ToLowerInvariant()
                [void]$registryBuilder.Append($lower).Append("`n")
                if (-not $exactNames.ContainsKey($lower)) { $exactNames[$lower] = 'реестр' }

                $version = [string](Get-Value -Object $item -Name 'DisplayVersion' -Default '')
                if ($version.Trim().Length -gt 0) {
                    [void]$registryBuilder.Append($lower).Append(' ').Append($version.ToLowerInvariant()).Append("`n")
                }

                # Папка установки добавляет улики там, где DisplayName не совпадает
                # с именем из списка (локализованные названия, "64" в конце и т.п.).
                $installLocation = [string](Get-Value -Object $item -Name 'InstallLocation' -Default '')
                if ($installLocation.Trim().Length -gt 0) {
                    [void]$registryBuilder.Append($installLocation.ToLowerInvariant()).Append("`n")
                }
            }
        } catch {
            Write-Log ('Не удалось прочитать раздел реестра ' + $path + ': ' + $_.Exception.Message) 'DEBUG'
        }
    }

    # --- Program Files ---
    $programRoots = @()
    if ($env:ProgramFiles) { $programRoots += $env:ProgramFiles }
    $programFilesX86 = [Environment]::GetEnvironmentVariable('ProgramFiles(x86)')
    if ($programFilesX86) { $programRoots += $programFilesX86 }

    foreach ($root in $programRoots) {
        if (-not (Test-Path -LiteralPath $root)) { continue }
        try {
            foreach ($directory in @(Get-ChildItem -LiteralPath $root -ErrorAction SilentlyContinue)) {
                if (-not $directory.PSIsContainer) { continue }
                $counts['Programs']++
                $lower = $directory.Name.ToLowerInvariant()
                [void]$programsBuilder.Append($lower).Append("`n")
                if (-not $exactNames.ContainsKey($lower)) { $exactNames[$lower] = 'Program Files' }
            }
        } catch {
            Write-Log ('Не удалось прочитать ' + $root + ': ' + $_.Exception.Message) 'DEBUG'
        }
    }

    # --- Get-Package (медленно, поэтому отключаемо) ---
    if (-not $SkipPackageCheck -and $Script:Caps['HasGetPackage']) {
        $packageWatch = [System.Diagnostics.Stopwatch]::StartNew()
        try {
            foreach ($package in @(Get-Package -ErrorAction Stop)) {
                $packageName = [string](Get-Value -Object $package -Name 'Name' -Default '')
                if ($packageName.Trim().Length -eq 0) { continue }
                $counts['Packages']++
                [void]$packagesBuilder.Append($packageName.ToLowerInvariant()).Append("`n")
            }
            Write-Log ('Get-Package: ' + $counts['Packages'] + ' записей за ' + $packageWatch.ElapsedMilliseconds + ' мс.') 'DEBUG'
        } catch {
            Write-Log ('Get-Package недоступен: ' + $_.Exception.Message) 'DEBUG'
        }
    }

    # --- Процессы: самый слабый источник, оставлен на случай портативных программ ---
    try {
        foreach ($process in @(Get-Process -ErrorAction SilentlyContinue)) {
            $processName = [string]$process.ProcessName
            if ($processName.Trim().Length -eq 0) { continue }
            $counts['Processes']++
            [void]$processBuilder.Append($processName.ToLowerInvariant()).Append("`n")
        }
    } catch { }

    Write-Log ('Источники: реестр ' + $counts['Registry'] + ', Program Files ' + $counts['Programs'] +
               ', Get-Package ' + $counts['Packages'] + ', процессов ' + $counts['Processes'] +
               '. Всего ' + $stopwatch.ElapsedMilliseconds + ' мс.')

    return @{
        RegistryBlob  = $registryBuilder.ToString()
        ProgramsBlob  = $programsBuilder.ToString()
        PackagesBlob  = $packagesBuilder.ToString()
        ProcessesBlob = $processBuilder.ToString()
        ExactNames    = $exactNames
    }
}

function Test-InstallerInstalled {
    param(
        $Installer,
        $Index,
        $PatternCache
    )

    $lower = ([string]$Installer.Name).ToLowerInvariant()

    # 1. Имя точно совпало с записью об удалении программы.
    if ($Index.ExactNames.ContainsKey($lower)) {
        return @{ Installed = $true; Reason = ('точное совпадение: ' + $Index.ExactNames[$lower]) }
    }

    # 2. Явные правила из списка имеют приоритет над догадками.
    foreach ($rule in @($Installer.Detect)) {
        if ($null -eq $rule) { continue }
        $text = ([string]$rule).Trim().ToLowerInvariant()
        if ($text.Length -eq 0) { continue }
        if ($lower -eq $text) { return @{ Installed = $true; Reason = ('правило из списка: ' + $text) } }
        if ($Index.RegistryBlob.IndexOf($text, [System.StringComparison]::Ordinal) -ge 0) {
            return @{ Installed = $true; Reason = ('правило из списка: ' + $text) }
        }
        if ($Index.ProgramsBlob.IndexOf($text, [System.StringComparison]::Ordinal) -ge 0) {
            return @{ Installed = $true; Reason = ('правило из списка: ' + $text) }
        }
    }

    # 3. Все значимые слова имени должны встречаться целиком.
    $tokens = @(Get-InstallerTokens -Name ([string]$Installer.Name))
    if ($tokens.Count -eq 0) { $tokens = @($lower) }

    $sources = @(
        @{ Key = 'RegistryBlob';  Title = 'реестр' },
        @{ Key = 'ProgramsBlob';  Title = 'Program Files' },
        @{ Key = 'PackagesBlob';  Title = 'Get-Package' },
        @{ Key = 'ProcessesBlob'; Title = 'запущенный процесс' }
    )

    foreach ($source in $sources) {
        $blob = [string]$Index[$source['Key']]
        if ($blob.Length -eq 0) { continue }

        $allFound = $true
        foreach ($token in $tokens) {
            $regex = New-TokenPattern -Token $token -Cache $PatternCache
            if (-not $regex.IsMatch($blob)) { $allFound = $false; break }
        }
        if ($allFound) {
            return @{ Installed = $true; Reason = ('слова [' + ($tokens -join ', ') + '] найдены: ' + $source['Title']) }
        }
    }

    return @{ Installed = $false; Reason = '' }
}

# ===========================================================================
# Меню
# ===========================================================================

function Show-Menu {
    param(
        $Installers,
        [int[]]$Visible,
        $Selected,
        $Installed,
        [string]$Filter = ''
    )

    Clear-Host

    $disk = $Script:Disk
    Write-Host ('Диск:     ' + $disk['Name'] + ':\')
    Write-Host ('Объём:    {0:N2} GB' -f $disk['TotalGB'])
    Write-Host ('Свободно: {0:N2} GB' -f $disk['FreeGB'])
    Write-Host ('Занято:   {0:N2} GB' -f $disk['UsedGB'])
    Write-Host ''
    Write-Host 'Определение установленного приблизительное: проверяйте отметки вручную.'
    if ($Filter) { Write-Host ('Фильтр: "' + $Filter + '"') -ForegroundColor Cyan }
    Write-Host "Выберите программы: 'a' — всё, 'n' — снять, 'i' — инвертировать,"
    Write-Host "'f текст' — фильтр, 'c' — сбросить фильтр, 'r' — перепроверить,"
    Write-Host "'s' — начать установку, 'q' — выход, '?' — справка."
    Write-Host ''

    if ($Visible.Count -eq 0) {
        Write-Host 'Ничего не найдено по фильтру.' -ForegroundColor Yellow
        return
    }

    for ($position = 0; $position -lt $Visible.Count; $position++) {
        $index = $Visible[$position]
        $flag  = '[ ]'
        if ($Selected[$index]) { $flag = '[X]' }

        $status = ''
        if ($Installed[$index]['Installed']) {
            $status = ' (уже установлена)'
            if ($Script:ShowDetectReason -and $Installed[$index]['Reason']) {
                $status = ' (уже установлена: ' + $Installed[$index]['Reason'] + ')'
            }
        }

        Write-Host (('{0,3}) {1} {2}{3}' -f ($position + 1), $flag, $Installers[$index].Name, $status))
    }
}

function Get-VisibleIndexes {
    param(
        $Installers,
        [string]$Filter
    )

    $visible = @()
    for ($index = 0; $index -lt $Installers.Count; $index++) {
        if (-not $Filter) { $visible += $index; continue }
        if (([string]$Installers[$index].Name).ToLowerInvariant().Contains($Filter.ToLowerInvariant())) {
            $visible += $index
        }
    }
    return $visible
}

function Select-InstallerByNumber {
    param(
        $Installers,
        [int[]]$Visible,
        $Selected,
        [int]$Number
    )

    if ($Number -lt 1 -or $Number -gt $Visible.Count) {
        Write-Host 'Нет такого номера.' -ForegroundColor Yellow
        return $false
    }
    $index = $Visible[$Number - 1]
    $Selected[$index] = -not $Selected[$index]
    return $true
}

# ===========================================================================
# Установка
# ===========================================================================

function Get-SafeFileName {
    param(
        [string]$Name,
        [string]$Fallback = 'installer'
    )

    if (-not $Name) { return $Fallback }

    $invalid = [System.IO.Path]::GetInvalidFileNameChars()
    $builder = New-Object System.Text.StringBuilder
    foreach ($ch in $Name.ToCharArray()) {
        if ($invalid -contains $ch) { [void]$builder.Append('_') } else { [void]$builder.Append($ch) }
    }

    $safe = $builder.ToString().Trim().TrimEnd('.')
    if ($safe.Length -eq 0) { return $Fallback }
    return $safe
}

function Get-DownloadFileName {
    # Имя файла берётся из ссылки, но с префиксом-названием программы: у разных
    # установщиков в ссылке часто стоит одно и то же "setup.exe"/"installer.exe",
    # и в общей папке они затирали бы друг друга.
    param(
        $Installer,
        [string]$Url
    )

    $installerName = Get-SafeFileName -Name ([string]$Installer.Name)

    if ($Installer.FileName) {
        $explicit = Get-SafeFileName -Name ([string]$Installer.FileName)
        if ([System.IO.Path]::GetExtension($explicit)) { return ($installerName + '__' + $explicit) }
    }

    $fromUrl   = ''
    $extension = ''
    try {
        $uri       = New-Object System.Uri($Url)
        $fromUrl   = [System.Uri]::UnescapeDataString([System.IO.Path]::GetFileName($uri.AbsolutePath))
        $extension = [System.IO.Path]::GetExtension($fromUrl).ToLowerInvariant()
    } catch { }

    # Доверяем только расширениям, с которыми скрипт умеет работать.
    # "get.php?id=15" — это скрипт раздачи, а не имя файла: сохранив его как
    # .php, мы отправили бы установщик в ветку "неизвестный тип".
    $supported = @('.exe', '.msi', '.zip')
    if ($fromUrl.Length -gt 0 -and ($supported -contains $extension)) {
        return ($installerName + '__' + (Get-SafeFileName -Name $fromUrl))
    }

    # Расширения нет — тип определим по содержимому уже после загрузки.
    return ($installerName + '__download.bin')
}

function Get-InstallerKind {
    # Расширение решает не всё: имя может быть без него, а внутри окажется MSI.
    param([string]$Path)

    $extension = [System.IO.Path]::GetExtension($Path).ToLowerInvariant()
    switch ($extension) {
        '.msi' { return 'msi' }
        '.zip' { return 'zip' }
        '.exe' { return 'exe' }
    }

    try {
        $stream = [System.IO.File]::Open($Path, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::Read)
        try {
            $header = New-Object byte[] 8
            $read   = $stream.Read($header, 0, 8)
        } finally {
            $stream.Close()
        }

        if ($read -ge 4) {
            if ($header[0] -eq 0xD0 -and $header[1] -eq 0xCF -and $header[2] -eq 0x11 -and $header[3] -eq 0xE0) { return 'msi' }
            if ($header[0] -eq 0x50 -and $header[1] -eq 0x4B -and $header[2] -eq 0x03 -and $header[3] -eq 0x04) { return 'zip' }
            if ($header[0] -eq 0x4D -and $header[1] -eq 0x5A) { return 'exe' }
            if ($header[0] -eq 0x37 -and $header[1] -eq 0x7A -and $header[2] -eq 0xBC -and $header[3] -eq 0xAF) { return '7z' }
            if ($header[0] -eq 0x52 -and $header[1] -eq 0x61 -and $header[2] -eq 0x72 -and $header[3] -eq 0x21) { return 'rar' }
        }
    } catch {
        Write-Log ('Не удалось определить тип файла ' + $Path + ': ' + $_.Exception.Message) 'DEBUG'
    }

    return 'unknown'
}

function Test-ZipEntriesSafe {
    # Защита от Zip Slip: запись вида "..\..\Windows\System32\evil.dll" не должна
    # оказаться за пределами папки распаковки.
    param([string]$Path)

    if ($Script:Caps['HasZipFileApi']) {
        Add-Type -AssemblyName System.IO.Compression.FileSystem -ErrorAction SilentlyContinue
        $archive = [System.IO.Compression.ZipFile]::OpenRead($Path)
        try {
            foreach ($entry in $archive.Entries) {
                $name = [string]$entry.FullName
                if ($name -match '(^|[\\/])\.\.([\\/]|$)') {
                    return @{ Safe = $false; Reason = ('в архиве путь с "..": ' + $name) }
                }
            }
        } finally {
            $archive.Dispose()
        }
        return @{ Safe = $true; Reason = '' }
    }

    if ($Script:Caps['HasZipPackageApi']) {
        Add-Type -AssemblyName WindowsBase -ErrorAction SilentlyContinue
        $package = [System.IO.Packaging.ZipPackage]::Open($Path, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read)
        try {
            foreach ($part in $package.GetParts()) {
                $name = [System.Uri]::UnescapeDataString($part.Uri.ToString())
                if ($name -match '(^|[\\/])\.\.([\\/]|$)') {
                    return @{ Safe = $false; Reason = ('в архиве путь с "..": ' + $name) }
                }
            }
        } finally {
            $package.Close()
        }
        return @{ Safe = $true; Reason = '' }
    }

    return @{ Safe = $null; Reason = 'нет API для проверки содержимого архива' }
}

function Expand-ArchiveCompat {
    param(
        [string]$Path,
        [string]$Destination
    )

    $check = Test-ZipEntriesSafe -Path $Path
    if ($check['Safe'] -eq $false) { throw ('Архив отклонён: ' + $check['Reason']) }
    if ($null -eq $check['Safe']) { Write-Log ('Проверить архив не удалось (' + $check['Reason'] + '), распаковываем как есть.') 'WARNING' }

    if (-not (Test-Path -LiteralPath $Destination)) {
        New-Item -Path $Destination -ItemType Directory -Force | Out-Null
    }

    if ($Script:Caps['HasZipFileApi']) {
        Add-Type -AssemblyName System.IO.Compression.FileSystem -ErrorAction SilentlyContinue
        $destinationFull = [System.IO.Path]::GetFullPath($Destination)
        if (-not $destinationFull.EndsWith([string][System.IO.Path]::DirectorySeparatorChar)) {
            $destinationFull += [System.IO.Path]::DirectorySeparatorChar
        }

        $archive = [System.IO.Compression.ZipFile]::OpenRead($Path)
        try {
            foreach ($entry in $archive.Entries) {
                $target = [System.IO.Path]::GetFullPath([System.IO.Path]::Combine($destinationFull, $entry.FullName))
                if (-not $target.StartsWith($destinationFull, [System.StringComparison]::OrdinalIgnoreCase)) {
                    throw ('Запись архива выходит за пределы папки распаковки: ' + $entry.FullName)
                }

                if ($entry.Name.Length -eq 0) {
                    if (-not (Test-Path -LiteralPath $target)) { New-Item -Path $target -ItemType Directory -Force | Out-Null }
                    continue
                }

                $parent = [System.IO.Path]::GetDirectoryName($target)
                if ($parent -and -not (Test-Path -LiteralPath $parent)) { New-Item -Path $parent -ItemType Directory -Force | Out-Null }
                [System.IO.Compression.ZipFileExtensions]::ExtractToFile($entry, $target, $true)
            }
        } finally {
            $archive.Dispose()
        }
        return $true
    }

    if ($Script:Caps['HasExpandArchive']) {
        Expand-Archive -LiteralPath $Path -DestinationPath $Destination -Force
        return $true
    }

    if ($Script:Caps['ShellApplication']) {
        # Асинхронный COM-путь: ждём, пока оболочка закончит распаковку.
        $shell  = New-Object -ComObject Shell.Application
        $source = $shell.NameSpace($Path)
        if ($null -eq $source) { throw ('Оболочка не смогла открыть архив: ' + $Path) }

        $items = $source.Items()
        $expected = $items.Count
        $shell.NameSpace($Destination).CopyHere($items, 1556)   # без диалогов, "да для всех"

        $watch = [System.Diagnostics.Stopwatch]::StartNew()
        while ($watch.Elapsed.TotalSeconds -lt 120) {
            if ($shell.NameSpace($Destination).Items().Count -ge $expected) { return $true }
            Start-Sleep -Milliseconds 500
        }
        Write-Log 'Распаковка через оболочку не подтвердилась за 120 с.' 'WARNING'
        return $true
    }

    throw 'В системе нет ни одного доступного способа распаковать ZIP.'
}

function Get-InstallerExitCodeMeaning {
    param([int]$ExitCode)

    $meanings = @{
        0    = @{ Success = $true;  Text = 'успешно' }
        1641 = @{ Success = $true;  Text = 'успешно, инициирована перезагрузка' }
        3010 = @{ Success = $true;  Text = 'успешно, требуется перезагрузка' }
        1602 = @{ Success = $false; Text = 'установка отменена пользователем' }
        1603 = @{ Success = $false; Text = 'фатальная ошибка установщика' }
        1605 = @{ Success = $false; Text = 'продукт не установлен' }
        1618 = @{ Success = $false; Text = 'другая установка уже выполняется' }
        1619 = @{ Success = $false; Text = 'не удалось открыть пакет установки' }
        1620 = @{ Success = $false; Text = 'пакет установки повреждён или неверного формата' }
        1625 = @{ Success = $false; Text = 'установка запрещена системной политикой' }
        1633 = @{ Success = $false; Text = 'платформа не поддерживается' }
        1638 = @{ Success = $false; Text = 'уже установлена другая версия' }
        1639 = @{ Success = $false; Text = 'неверный аргумент командной строки' }
    }

    if ($meanings.ContainsKey($ExitCode)) { return $meanings[$ExitCode] }
    return @{ Success = ($ExitCode -eq 0); Text = ('код возврата ' + $ExitCode) }
}

function Invoke-InstallerProcess {
    param(
        [string]$FilePath,
        [string]$Arguments = '',
        [int]$TimeoutMinutes = 30,
        [switch]$DryRun,
        [string]$Label = ''
    )

    if ($DryRun) {
        Write-Log ('[DryRun] запуск: "' + $FilePath + '" ' + $Arguments)
        return @{ Success = $true; ExitCode = 0; Message = 'пропущено (-DryRun)' }
    }

    Write-Log ('Запуск: "' + $FilePath + '" ' + $Arguments)

    $process = $null
    try {
        if ($Arguments.Trim().Length -gt 0) {
            $process = Start-Process -FilePath $FilePath -ArgumentList $Arguments -PassThru -NoNewWindow
        } else {
            $process = Start-Process -FilePath $FilePath -PassThru -NoNewWindow
        }
    } catch {
        return @{ Success = $false; ExitCode = -1; Message = ('не удалось запустить процесс: ' + $_.Exception.Message) }
    }

    if ($null -eq $process) {
        return @{ Success = $false; ExitCode = -1; Message = 'процесс не был создан' }
    }

    if ($TimeoutMinutes -gt 0) {
        $timeoutMs = $TimeoutMinutes * 60000
        if ($timeoutMs -gt [int]::MaxValue) { $timeoutMs = [int]::MaxValue }
        if (-not $process.WaitForExit([int]$timeoutMs)) {
            return @{ Success = $false; ExitCode = -1; Message = ('не завершился за ' + $TimeoutMinutes + ' мин, процесс оставлен работать') }
        }
    } else {
        $process.WaitForExit()
    }

    # Start-Process не даёт код возврата сам по себе: без -PassThru успех
    # объявлялся бы всегда, включая msiexec 1603.
    $exitCode = $process.ExitCode
    $meaning  = Get-InstallerExitCodeMeaning -ExitCode $exitCode
    return @{ Success = $meaning['Success']; ExitCode = $exitCode; Message = $meaning['Text'] }
}

function Install-Program {
    param(
        $Installer,
        [string]$Path,
        [string]$ExtractRoot,
        [int]$TimeoutMinutes = 30,
        [switch]$DryRun
    )

    $arguments = [string]$Installer.Arguments
    $kind      = Get-InstallerKind -Path $Path

    Write-Log ($Installer.Name + ': тип "' + $kind + '", ключи: "' + $arguments + '"') 'DEBUG'

    switch ($kind) {
        'msi' {
            $msiArguments = '/i "' + $Path + '"'
            if ($arguments.Trim().Length -gt 0) {
                $msiArguments += ' ' + $arguments
            } else {
                Write-Log ($Installer.Name + ': для MSI не заданы ключи, будет показан интерфейс установки.') 'DEBUG'
            }
            return (Invoke-InstallerProcess -FilePath 'msiexec.exe' -Arguments $msiArguments -TimeoutMinutes $TimeoutMinutes -DryRun:$DryRun -Label $Installer.Name)
        }

        'zip' {
            $folderName = Get-SafeFileName -Name ([string]$Installer.Name)
            if ($Installer.ExtractTo) { $folderName = Get-SafeFileName -Name ([string]$Installer.ExtractTo) }
            $extractPath = Join-Path $ExtractRoot $folderName

            if ($DryRun) {
                Write-Log ('[DryRun] распаковка "' + $Path + '" в "' + $extractPath + '"')
            } else {
                Write-Log ($Installer.Name + ': распаковка в ' + $extractPath)
                [void](Expand-ArchiveCompat -Path $Path -Destination $extractPath)
            }

            if (-not $Installer.PostExtract) {
                if (-not $DryRun) { Write-Log ($Installer.Name + ': архив распакован, файл для запуска не указан (postExtract).') 'DEBUG' }
                return @{ Success = $true; ExitCode = 0; Message = 'распаковано' }
            }

            $executable = [System.IO.Path]::GetFullPath((Join-Path $extractPath ([string]$Installer.PostExtract)))
            $rootFull   = [System.IO.Path]::GetFullPath($extractPath)
            if (-not $rootFull.EndsWith([string][System.IO.Path]::DirectorySeparatorChar)) {
                $rootFull += [System.IO.Path]::DirectorySeparatorChar
            }
            if (-not $executable.StartsWith($rootFull, [System.StringComparison]::OrdinalIgnoreCase)) {
                return @{ Success = $false; ExitCode = -1; Message = 'postExtract указывает за пределы папки распаковки' }
            }
            if (-not $DryRun -and -not (Test-Path -LiteralPath $executable)) {
                return @{ Success = $false; ExitCode = -1; Message = ('файл postExtract не найден: ' + $executable) }
            }

            return (Invoke-InstallerProcess -FilePath $executable -Arguments $arguments -TimeoutMinutes $TimeoutMinutes -DryRun:$DryRun -Label $Installer.Name)
        }

        'exe' {
            return (Invoke-InstallerProcess -FilePath $Path -Arguments $arguments -TimeoutMinutes $TimeoutMinutes -DryRun:$DryRun -Label $Installer.Name)
        }

        '7z' {
            return @{ Success = $false; ExitCode = -1; Message = 'формат 7z не поддерживается: распакуйте вручную или замените ссылку на .zip/.exe' }
        }

        'rar' {
            return @{ Success = $false; ExitCode = -1; Message = 'формат rar не поддерживается: распакуйте вручную или замените ссылку на .zip/.exe' }
        }

        default {
            Write-Log ($Installer.Name + ': тип файла не распознан, пробуем запустить напрямую.') 'WARNING'
            return (Invoke-InstallerProcess -FilePath $Path -Arguments $arguments -TimeoutMinutes $TimeoutMinutes -DryRun:$DryRun -Label $Installer.Name)
        }
    }
}

# ===========================================================================
# Самопроверка
# ===========================================================================

function Test-SelfTestCase {
    param(
        [string]$Title,
        [bool]$Condition,
        [string]$Detail = ''
    )

    if ($Condition) {
        Write-Host ('  [OK]    ' + $Title) -ForegroundColor Green
    } else {
        Write-Host ('  [ОШИБКА] ' + $Title + ' ' + $Detail) -ForegroundColor Red
        $Script:SelfTestFailures++
    }
}

function Invoke-SelfTest {
    $Script:SelfTestFailures = 0

    Write-Host ''
    Write-Host '=== Окружение ===' -ForegroundColor Cyan
    foreach ($key in @($Script:Caps.Keys | Sort-Object)) {
        $value = $Script:Caps[$key]
        if ($value -is [array]) { $value = ($value -join ', ') }
        Write-Host ('  ' + ([string]$key).PadRight(26) + ' = ' + $value)
    }
    Write-Host ('  ' + 'Administrator'.PadRight(26) + ' = ' + (Test-Administrator))

    Write-Host ''
    Write-Host '=== Разбор JSON ===' -ForegroundColor Cyan

    $sample = '{"installers":[{"name":"Тестовая программа","urls":["http://example.org/a.exe"],' +
              '"arguments":"/S","sha256":"' + ('a' * 64) + '","detect":["Тест"],"nested":[[1,2],[3]]}]}'

    try {
        $parsed = ConvertFrom-JsonCompat -Text $sample -ForceFallback
        $list   = @(ConvertTo-InstallerList -Data $parsed)
        Test-SelfTestCase 'встроенный парсер: одна запись' ($list.Count -eq 1) ('получено ' + $list.Count)
        if ($list.Count -eq 1) {
            Test-SelfTestCase 'встроенный парсер: имя' ($list[0].Name -eq 'Тестовая программа') $list[0].Name
            Test-SelfTestCase 'встроенный парсер: ссылка' ($list[0].Urls.Count -eq 1)
            Test-SelfTestCase 'встроенный парсер: sha256' ($list[0].Sha256.Length -eq 64)
            Test-SelfTestCase 'встроенный парсер: detect' ($list[0].Detect.Count -eq 1)
        }
    } catch {
        Test-SelfTestCase 'встроенный парсер' $false $_.Exception.Message
    }

    if ($Script:Caps['HasConvertFromJson']) {
        try {
            $nativeList = @(ConvertTo-InstallerList -Data (ConvertFrom-JsonCompat -Text $sample))
            Test-SelfTestCase 'ConvertFrom-Json: одна запись' ($nativeList.Count -eq 1)
            if ($nativeList.Count -eq 1) {
                Test-SelfTestCase 'ConvertFrom-Json: имя' ($nativeList[0].Name -eq 'Тестовая программа') $nativeList[0].Name
                Test-SelfTestCase 'ConvertFrom-Json: ссылка' ($nativeList[0].Urls.Count -eq 1)
            }
        } catch {
            Test-SelfTestCase 'ConvertFrom-Json' $false $_.Exception.Message
        }
    }

    try {
        $wrapped = @(ConvertTo-InstallerList -Data (ConvertFrom-JsonCompat -Text '{"programs":[{"name":"Одиночная","url":"http://example.org/b.msi"}]}'))
        Test-SelfTestCase 'обёртка programs + одиночный url' ($wrapped.Count -eq 1 -and $wrapped[0].Urls.Count -eq 1)
    } catch {
        Test-SelfTestCase 'обёртка programs + одиночный url' $false $_.Exception.Message
    }

    try {
        $single = @(ConvertTo-InstallerList -Data (ConvertFrom-JsonCompat -Text '{"name":"Один объект","urls":["http://example.org/c.exe"]}'))
        Test-SelfTestCase 'одиночный объект вместо массива' ($single.Count -eq 1)
    } catch {
        Test-SelfTestCase 'одиночный объект вместо массива' $false $_.Exception.Message
    }

    Write-Host ''
    Write-Host '=== SHA-256 ===' -ForegroundColor Cyan

    $tempFile = [System.IO.Path]::GetTempFileName()
    try {
        [System.IO.File]::WriteAllBytes($tempFile, [System.Text.Encoding]::ASCII.GetBytes('abc'))
        $reference = 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'

        $savedCapability = $Script:Caps['HasGetFileHash']
        try {
            $Script:Caps['HasGetFileHash'] = $false
            $netHash = Get-FileHashCompat -Path $tempFile
        } finally {
            $Script:Caps['HasGetFileHash'] = $savedCapability
        }
        Test-SelfTestCase 'SHA-256 через .NET' ($netHash -eq $reference) $netHash

        if ($Script:Caps['HasGetFileHash']) {
            Test-SelfTestCase 'SHA-256 через Get-FileHash' ((Get-FileHashCompat -Path $tempFile) -eq $reference)
        }
    } finally {
        Remove-Item -LiteralPath $tempFile -Force -ErrorAction SilentlyContinue
    }

    Write-Host ''
    Write-Host '=== Определение типа файла ===' -ForegroundColor Cyan

    $tempKind = [System.IO.Path]::GetTempFileName()
    try {
        [System.IO.File]::WriteAllBytes($tempKind, [byte[]](0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1))
        Test-SelfTestCase 'MSI по сигнатуре' ((Get-InstallerKind -Path $tempKind) -eq 'msi')

        [System.IO.File]::WriteAllBytes($tempKind, [byte[]](0x50, 0x4B, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00))
        Test-SelfTestCase 'ZIP по сигнатуре' ((Get-InstallerKind -Path $tempKind) -eq 'zip')

        [System.IO.File]::WriteAllBytes($tempKind, [byte[]](0x4D, 0x5A, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00))
        Test-SelfTestCase 'EXE по сигнатуре' ((Get-InstallerKind -Path $tempKind) -eq 'exe')

        [System.IO.File]::WriteAllBytes($tempKind, [byte[]](0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C, 0x00, 0x00))
        Test-SelfTestCase '7z по сигнатуре' ((Get-InstallerKind -Path $tempKind) -eq '7z')

        [System.IO.File]::WriteAllBytes($tempKind, [byte[]](0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00, 0x00))
        Test-SelfTestCase 'rar по сигнатуре' ((Get-InstallerKind -Path $tempKind) -eq 'rar')
    } finally {
        Remove-Item -LiteralPath $tempKind -Force -ErrorAction SilentlyContinue
    }

    Write-Host ''
    Write-Host '=== Поиск установленного ===' -ForegroundColor Cyan

    $fakeIndex = @{
        RegistryBlob  = "`nvisual studio`ngoogle chrome`n"
        ProgramsBlob  = ''
        PackagesBlob  = ''
        ProcessesBlob = ''
        ExactNames    = @{ 'google chrome' = 'реестр' }
    }
    $cache = @{}

    $exact = Test-InstallerInstalled -Installer (New-Object PSObject -Property @{ Name = 'Google Chrome'; Detect = @() }) -Index $fakeIndex -PatternCache $cache
    Test-SelfTestCase 'точное совпадение имени' ($exact['Installed'])

    $partial = Test-InstallerInstalled -Installer (New-Object PSObject -Property @{ Name = 'Visual Studio'; Detect = @() }) -Index $fakeIndex -PatternCache $cache
    Test-SelfTestCase 'совпадение по всем словам' ($partial['Installed'])

    $extra = Test-InstallerInstalled -Installer (New-Object PSObject -Property @{ Name = 'Visual Studio Code'; Detect = @() }) -Index $fakeIndex -PatternCache $cache
    Test-SelfTestCase 'лишнее слово не считается установкой' (-not $extra['Installed'])

    $unrelated = Test-InstallerInstalled -Installer (New-Object PSObject -Property @{ Name = '7-Zip'; Detect = @() }) -Index $fakeIndex -PatternCache $cache
    Test-SelfTestCase 'отсутствующая программа не найдена' (-not $unrelated['Installed'])

    $suffixedIndex = @{
        RegistryBlob  = "`nhwinfo64 v8.46`n"
        ProgramsBlob  = ''
        PackagesBlob  = ''
        ProcessesBlob = ''
        ExactNames    = @{}
    }
    $suffixed = Test-InstallerInstalled -Installer (New-Object PSObject -Property @{ Name = 'HWInfo'; Detect = @() }) -Index $suffixedIndex -PatternCache $cache
    Test-SelfTestCase 'HWInfo находит HWiNFO64' ($suffixed['Installed'])

    $chromiumIndex = @{
        RegistryBlob  = "`nchromium`n"
        ProgramsBlob  = ''
        PackagesBlob  = ''
        ProcessesBlob = ''
        ExactNames    = @{}
    }
    $chromium = Test-InstallerInstalled -Installer (New-Object PSObject -Property @{ Name = 'Chrome'; Detect = @() }) -Index $chromiumIndex -PatternCache $cache
    Test-SelfTestCase 'Chrome НЕ путается с Chromium' (-not $chromium['Installed'])

    Write-Host ''
    Write-Host '=== Имена файлов ===' -ForegroundColor Cyan

    $zipInstaller = New-Object PSObject -Property @{ Name = '7-Zip'; FileName = ''; Urls = @() }
    $name1 = Get-DownloadFileName -Installer $zipInstaller -Url 'https://example.org/download/7z2408-x64.exe'
    Test-SelfTestCase 'имя из ссылки' ($name1 -eq '7-Zip__7z2408-x64.exe') $name1

    $name2 = Get-DownloadFileName -Installer $zipInstaller -Url 'https://example.org/get.php?id=15'
    Test-SelfTestCase 'ссылка без расширения' ($name2 -eq '7-Zip__download.bin') $name2

    $badInstaller = New-Object PSObject -Property @{ Name = 'Программа: тест/1'; FileName = ''; Urls = @() }
    $name3 = Get-DownloadFileName -Installer $badInstaller -Url 'https://example.org/setup.exe'
    Test-SelfTestCase 'недопустимые символы заменены' ($name3 -notmatch '[:/]') $name3

    Write-Host ''
    Write-Host '=== Прочее ===' -ForegroundColor Cyan
    Test-SelfTestCase 'Get-ClampedPercent(150) = 100' ((Get-ClampedPercent 150) -eq 100)
    Test-SelfTestCase 'Get-ClampedPercent(-5) = 0' ((Get-ClampedPercent -5) -eq 0)
    Test-SelfTestCase 'Get-InstallerTokens отбрасывает служебные слова' (((Get-InstallerTokens -Name 'Microsoft Visual C++ 2015 Redistributable (x64)') -notcontains 'microsoft'))

    Write-Host ''
    if ($Script:SelfTestFailures -eq 0) {
        Write-Host 'Все проверки пройдены.' -ForegroundColor Green
    } else {
        Write-Host ('Провалено проверок: ' + $Script:SelfTestFailures) -ForegroundColor Red
    }
    return $Script:SelfTestFailures
}

# ===========================================================================
# Запуск
# ===========================================================================

Initialize-ConsoleEncoding
$Script:Caps          = Initialize-Capabilities
$Script:IsInteractive = ([Environment]::UserInteractive -and $Host.Name -eq 'ConsoleHost')
$Script:ShowDetectReason = [bool]$ShowDetectReason

# --- Пути ---
if (-not $DownloadFolder) {
    $DownloadFolder = Join-Path (Get-DownloadsFolder) 'MyInstallers'
}
$DownloadFolder = [System.IO.Path]::GetFullPath($DownloadFolder)

if (-not (Test-Path -LiteralPath $DownloadFolder)) {
    try {
        New-Item -Path $DownloadFolder -ItemType Directory -Force | Out-Null
    } catch {
        Write-Host ('Не удалось создать папку загрузок ' + $DownloadFolder + ': ' + $_.Exception.Message) -ForegroundColor Red
        exit 1
    }
}

if (-not $LogFile) { $LogFile = Join-Path $DownloadFolder 'install_log.txt' }
Initialize-LogFile -Path $LogFile -MaxSizeMB $MaxLogSizeMB

Write-Log '### Запуск bins.v2.ps1 ###'
Write-Log ('PowerShell ' + $Script:Caps['PSVersion'] + '; режим: ' + $(
    if ($DryRun) { 'проверка без установки' } else { 'установка' })) 'DEBUG'

if ($SelfTest) {
    $failures = Invoke-SelfTest
    Wait-ForKey
    Close-LogFile
    if ($failures -gt 0) { exit 1 }
    exit 0
}

# --- Права администратора ---
# В режиме -DryRun ничего не скачивается в систему и не запускается, поэтому
# права не нужны: можно просто посмотреть план.
if (-not (Test-Administrator)) {
    if ($DryRun) {
        Write-Log 'Права администратора не требуются: выбран режим -DryRun.' 'WARNING'
    } else {
        Write-Log 'Нужны права администратора: запустите скрипт от имени администратора.' 'ERROR'
        Stop-Script 1
    }
}

Initialize-Tls

# --- Информация о диске ---
$driveLetter = 'C'
if ($env:SystemDrive) { $driveLetter = $env:SystemDrive.TrimEnd(':') }
try {
    $drive = Get-PSDrive -Name $driveLetter -ErrorAction Stop
    $Script:Disk = @{
        Name    = $driveLetter
        TotalGB = (($drive.Used + $drive.Free) / 1GB)
        FreeGB  = ($drive.Free / 1GB)
        UsedGB  = ($drive.Used / 1GB)
    }
} catch {
    $Script:Disk = @{ Name = $driveLetter; TotalGB = 0; FreeGB = 0; UsedGB = 0 }
}

# --- Список установщиков ---
try {
    $installers = @(Get-InstallerList -Url $JsonUrl -Path $JsonPath -Retries $Retries -RetryDelaySeconds $RetryDelaySeconds)
} catch {
    Write-Log ('Не удалось получить список установщиков: ' + $_.Exception.Message) 'ERROR'
    Stop-Script 1
}
Write-Log ('В списке ' + $installers.Count + ' программ.') 'SUCCESS'

# --- Что уже установлено ---
$installed    = @{}
$patternCache = @{}

if ($SkipInstalledCheck) {
    Write-Log 'Проверка установленного отключена (-SkipInstalledCheck).' 'WARNING'
    for ($i = 0; $i -lt $installers.Count; $i++) {
        $installed[$i] = @{ Installed = $false; Reason = 'проверка отключена' }
    }
} else {
    $index = Get-InstalledIndex -SkipPackageCheck:$SkipPackageCheck
    for ($i = 0; $i -lt $installers.Count; $i++) {
        $installed[$i] = Test-InstallerInstalled -Installer $installers[$i] -Index $index -PatternCache $patternCache
        if ($installed[$i]['Installed']) {
            Write-Log ($installers[$i].Name + ': уже установлена — ' + $installed[$i]['Reason']) 'DEBUG'
        }
    }
}

$selected = @{}
for ($i = 0; $i -lt $installers.Count; $i++) {
    if ($ForceReinstall) { $selected[$i] = $true }
    else { $selected[$i] = -not $installed[$i]['Installed'] }
}

# --- Меню ---
$filter   = ''
$visible  = @(Get-VisibleIndexes -Installers $installers -Filter $filter)
$showMenu = $true

# Отбор без меню: -Select all | номера | имена программ.
if ($Select -and $Select.Count -gt 0) {
    for ($i = 0; $i -lt $installers.Count; $i++) { $selected[$i] = $false }

    foreach ($item in $Select) {
        $token = ([string]$item).Trim()
        if ($token.Length -eq 0) { continue }

        if ($token.ToLowerInvariant() -eq 'all') {
            for ($i = 0; $i -lt $installers.Count; $i++) { $selected[$i] = $true }
            continue
        }

        $number = 0
        if ([int]::TryParse($token, [ref]$number) -and $number -ge 1 -and $number -le $installers.Count) {
            $selected[$number - 1] = $true
            continue
        }

        $matched = $false
        for ($i = 0; $i -lt $installers.Count; $i++) {
            if (([string]$installers[$i].Name).ToLowerInvariant() -eq $token.ToLowerInvariant()) {
                $selected[$i] = $true
                $matched = $true
            }
        }
        if (-not $matched) { Write-Log ('-Select: не найден ни номер, ни программа "' + $token + '".') 'WARNING' }
    }

    Write-Log ('Отбор без меню: отмечено ' + @($selected.Values | Where-Object { $_ }).Count + ' программ.') 'INFO'
    $showMenu = $false
}

while ($showMenu) {
    Show-Menu -Installers $installers -Visible $visible -Selected $selected -Installed $installed -Filter $filter

    $answer = Read-Host "Ваш выбор (номер, 'a', 'n', 'i', 'f', 'c', 'r', 's', 'q', '?')"
    if ($null -eq $answer) { $answer = '' }
    $answer = $answer.Trim().ToLowerInvariant()

    if ($answer.Length -eq 0) { continue }
    elseif ($answer -eq 'q') {
        Write-Log 'Выход по запросу пользователя.'
        Close-LogFile
        exit 0
    }
    elseif ($answer -eq 's') { $showMenu = $false }
    elseif ($answer -eq 'a') {
        foreach ($index in $visible) { if (-not $installed[$index]['Installed']) { $selected[$index] = $true } }
    }
    elseif ($answer -eq 'n') {
        foreach ($index in $visible) { $selected[$index] = $false }
    }
    elseif ($answer -eq 'i') {
        foreach ($index in $visible) { $selected[$index] = -not $selected[$index] }
    }
    elseif ($answer -eq 'c') {
        $filter  = ''
        $visible = @(Get-VisibleIndexes -Installers $installers -Filter $filter)
    }
    elseif ($answer -match '^f\s*(.*)$') {
        $filter  = $Matches[1].Trim()
        $visible = @(Get-VisibleIndexes -Installers $installers -Filter $filter)
    }
    elseif ($answer -eq 'r') {
        Write-Host 'Перепроверяем установленное...' -ForegroundColor Cyan
        $index        = Get-InstalledIndex -SkipPackageCheck:$SkipPackageCheck
        $patternCache = @{}
        for ($i = 0; $i -lt $installers.Count; $i++) {
            $installed[$i] = Test-InstallerInstalled -Installer $installers[$i] -Index $index -PatternCache $patternCache
            $selected[$i]  = -not $installed[$i]['Installed']
        }
        Write-Log 'Повторная проверка выполнена.'
        Wait-ForKey 'Нажмите ПРОБЕЛ, чтобы продолжить...'
    }
    elseif ($answer -eq '?') {
        Write-Host ''
        Write-Host '  Номер      — переключить отметку программы'
        Write-Host '  a / n / i  — выбрать всё / снять всё / инвертировать (в пределах фильтра)'
        Write-Host '  f текст    — оставить только программы, в имени которых есть текст'
        Write-Host '  c          — сбросить фильтр'
        Write-Host '  r          — заново определить, что уже установлено'
        Write-Host '  s          — начать установку отмеченного'
        Write-Host '  q          — выход'
        Wait-ForKey 'Нажмите ПРОБЕЛ, чтобы продолжить...'
    }
    elseif ($answer -match '^\d+$') {
        $number = 0
        if ([int]::TryParse($answer, [ref]$number)) {
            [void](Select-InstallerByNumber -Installers $installers -Visible $visible -Selected $selected -Number $number)
        }
    }
    else {
        Write-Host 'Не понял команду. Нажмите "?" для справки.' -ForegroundColor Yellow
        Start-Sleep -Milliseconds 700
    }
}

# --- Установка ---
$plan = @()
for ($i = 0; $i -lt $installers.Count; $i++) {
    if ($selected[$i]) { $plan += $i }
}

if ($plan.Count -eq 0) {
    Write-Log 'Ничего не отмечено, работа завершена.' 'WARNING'
    Wait-ForKey
    Close-LogFile
    exit 0
}

$report = @{ Downloaded = @(); Installed = @(); Failed = @() }
Write-Log ('К установке: ' + $plan.Count + ' программ.') 'INFO'

$position = 0
foreach ($index in $plan) {
    $position++
    $installer = $installers[$index]

    Write-Progress -Activity 'Установка программ' `
        -Status ($position.ToString() + ' из ' + $plan.Count + ': ' + $installer.Name) `
        -PercentComplete (Get-ClampedPercent ((($position - 1) / $plan.Count) * 100))

    Write-Log ('=== ' + $installer.Name + ' (' + $position + ' из ' + $plan.Count + ') ===')

    $done      = $false
    $lastError = 'нет ни одной рабочей ссылки'

    foreach ($url in @($installer.Urls)) {
        try {
            $fileName     = Get-DownloadFileName -Installer $installer -Url $url
            $downloadPath = Join-Path $DownloadFolder $fileName

            $download = Get-FileWithResume -Url $url -Destination $downloadPath `
                -ExpectedHash $installer.Sha256 -Retries $Retries -RetryDelaySeconds $RetryDelaySeconds `
                -Label ($installer.Name + ' / ' + $fileName) -IgnoreCache:$IgnoreCache

            if ($download['Status'] -eq 'cached') {
                Write-Log ($installer.Name + ': файл уже загружен ранее (' + (Format-FileSize $download['Length']) + ').') 'DEBUG'
            } else {
                Write-Log ($installer.Name + ': скачано ' + (Format-FileSize $download['Length']) + ' (' + $download['Status'] + ').') 'SUCCESS'
                $report.Downloaded += $installer.Name
            }

            if (-not $DryRun) { Unblock-FileCompat -Path $downloadPath }

            $outcome = Install-Program -Installer $installer -Path $downloadPath -ExtractRoot $DownloadFolder `
                -TimeoutMinutes $InstallerTimeoutMinutes -DryRun:$DryRun

            if ($outcome['Success']) {
                Write-Log ($installer.Name + ': ' + $outcome['Message']) 'SUCCESS'
                $report.Installed += $installer.Name
                $done = $true

                if ($CleanupDownloads -and -not $DryRun) {
                    Remove-Item -LiteralPath $downloadPath -Force -ErrorAction SilentlyContinue
                    Remove-Item -LiteralPath (Get-ResumeMarkerPath -Path $downloadPath) -Force -ErrorAction SilentlyContinue
                }
                break
            }

            $lastError = $outcome['Message']
            Write-Log ($installer.Name + ': ' + $lastError + ' (ссылка ' + $url + ')') 'WARNING'
        } catch {
            $lastError = $_.Exception.Message
            Write-Log ($installer.Name + ': ссылка ' + $url + ' не сработала — ' + $lastError) 'WARNING'
        }
    }

    if (-not $done) {
        $report.Failed += $installer.Name
        Write-Log ($installer.Name + ': не установлена. ' + $lastError) 'ERROR'
    }
}

Write-Progress -Activity 'Установка программ' -Completed

# --- Итог ---
Write-Host ''
Write-Log '=== Итог ==='

$installedList = @($report.Installed | Select-Object -Unique)
$failedList    = @($report.Failed    | Select-Object -Unique)
$downloadedList = @($report.Downloaded | Select-Object -Unique)

if ($installedList.Count -gt 0) { Write-Log ('Установлено (' + $installedList.Count + '): ' + ($installedList -join ', ')) 'SUCCESS' }
if ($downloadedList.Count -gt 0) { Write-Log ('Скачано (' + $downloadedList.Count + '): ' + ($downloadedList -join ', ')) 'INFO' }
if ($failedList.Count -gt 0) { Write-Log ('Ошибки (' + $failedList.Count + '): ' + ($failedList -join ', ')) 'ERROR' }
if ($failedList.Count -eq 0 -and $installedList.Count -gt 0) { Write-Log 'Все отмеченные программы обработаны.' 'SUCCESS' }

Write-Log ('Файлы: ' + $DownloadFolder)
Write-Log ('Журнал: ' + $LogFile)

Wait-ForKey
Close-LogFile

if ($failedList.Count -gt 0) { exit 1 }
exit 0