bedrockplus 0.1.0b1__py3-none-win_amd64.whl

bedrockplus/__init__.py

@@ -0,0 +1,99 @@
+"""Public, typed BedrockPlus Python plugin API."""
+
+__version__ = "0.1.0b1"
+
+from .api import EventCallback, Plugin, PluginHost, TaskCallback
+from .commands import (
+    CommandArgument,
+    CommandArgumentType,
+    CommandCallback,
+    CommandInvocation,
+    CommandOverload,
+    CommandResult,
+    CommandReturn,
+    CommandSourceKind,
+    CommandValue,
+)
+from .events import (
+    BlockBreakEvent,
+    BlockPlaceEvent,
+    CancellableEvent,
+    Event,
+    EventName,
+    EventPriority,
+    PlayerChatEvent,
+    PlayerCommandEvent,
+    PlayerJoinEvent,
+    PlayerJumpEvent,
+    PlayerKickEvent,
+    PlayerLoginEvent,
+    PlayerMoveEvent,
+    PlayerQuitEvent,
+    ServerCommandEvent,
+    ServerListPingEvent,
+    ServerTickEvent,
+)
+from .objects import (
+    Block,
+    ConnectionInfo,
+    Entity,
+    GameMode,
+    ItemStack,
+    Level,
+    Location,
+    Player,
+    Server,
+    SocketAddress,
+    Vector2,
+    Vector3,
+    World,
+)
+from .system import System
+
+__all__ = [
+    "__version__",
+    "BlockBreakEvent",
+    "Block",
+    "BlockPlaceEvent",
+    "CancellableEvent",
+    "CommandArgument",
+    "CommandArgumentType",
+    "CommandCallback",
+    "CommandInvocation",
+    "CommandOverload",
+    "CommandResult",
+    "CommandReturn",
+    "CommandSourceKind",
+    "CommandValue",
+    "ConnectionInfo",
+    "Entity",
+    "GameMode",
+    "Event",
+    "EventCallback",
+    "EventName",
+    "EventPriority",
+    "PlayerChatEvent",
+    "PlayerCommandEvent",
+    "PlayerJoinEvent",
+    "PlayerJumpEvent",
+    "PlayerKickEvent",
+    "PlayerLoginEvent",
+    "PlayerMoveEvent",
+    "PlayerQuitEvent",
+    "Player",
+    "ItemStack",
+    "Level",
+    "Location",
+    "Plugin",
+    "PluginHost",
+    "ServerCommandEvent",
+    "ServerListPingEvent",
+    "ServerTickEvent",
+    "Server",
+    "SocketAddress",
+    "TaskCallback",
+    "System",
+    "Vector2",
+    "Vector3",
+    "World",
+]

bedrockplus/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+
+raise SystemExit(main())

bedrockplus/_assets/Initialize-BedrockPlusServer.ps1

@@ -0,0 +1,395 @@
+[CmdletBinding()]
+param(
+    [string]$DestinationRoot = (Get-Location).Path,
+    [string]$BdsVersion = '',
+    [switch]$Yes,
+    [switch]$ListVersions,
+    [string]$ManifestPath = (Join-Path $PSScriptRoot 'compatibility\bds\supported-versions.json'),
+    [string]$ArchivePath = ''
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+function Set-HiddenDirectory {
+    param([Parameter(Mandatory)][string]$Path)
+
+    $item = Get-Item -LiteralPath $Path -Force
+    $item.Attributes = $item.Attributes -bor [IO.FileAttributes]::Hidden
+}
+
+function Get-Sha256 {
+    param([Parameter(Mandatory)][string]$Path)
+
+    $stream = [IO.File]::OpenRead($Path)
+    $hasher = [Security.Cryptography.SHA256]::Create()
+    try {
+        return ([BitConverter]::ToString($hasher.ComputeHash($stream))).Replace('-', '').ToLowerInvariant()
+    } finally {
+        $hasher.Dispose()
+        $stream.Dispose()
+    }
+}
+
+function Invoke-BdsDownload {
+    param(
+        [Parameter(Mandatory)][string]$Uri,
+        [Parameter(Mandatory)][string]$Destination,
+        [Parameter(Mandatory)][string]$Version
+    )
+
+    Add-Type -AssemblyName System.Net.Http
+    $client = [Net.Http.HttpClient]::new()
+    $response = $null
+    $input = $null
+    $output = $null
+    try {
+        $response = $client.GetAsync(
+            $Uri,
+            [Net.Http.HttpCompletionOption]::ResponseHeadersRead
+        ).GetAwaiter().GetResult()
+        $response.EnsureSuccessStatusCode()
+        $total = $response.Content.Headers.ContentLength
+        $input = $response.Content.ReadAsStreamAsync().GetAwaiter().GetResult()
+        $output = [IO.File]::Open($Destination, [IO.FileMode]::CreateNew, [IO.FileAccess]::Write, [IO.FileShare]::None)
+        $buffer = [byte[]]::new(1024 * 1024)
+        [long]$received = 0
+        while (($count = $input.Read($buffer, 0, $buffer.Length)) -gt 0) {
+            $output.Write($buffer, 0, $count)
+            $received += $count
+            if ($total -and $total -gt 0) {
+                $percent = [Math]::Min(100, [int](($received * 100) / $total))
+                Write-Progress -Activity "Downloading BDS $Version" -Status "$percent% ($([Math]::Round($received / 1MB, 1)) / $([Math]::Round($total / 1MB, 1)) MiB)" -PercentComplete $percent
+            } else {
+                Write-Progress -Activity "Downloading BDS $Version" -Status "$([Math]::Round($received / 1MB, 1)) MiB received" -PercentComplete 0
+            }
+        }
+    } finally {
+        Write-Progress -Activity "Downloading BDS $Version" -Completed
+        if ($output) { $output.Dispose() }
+        if ($input) { $input.Dispose() }
+        if ($response) { $response.Dispose() }
+        $client.Dispose()
+    }
+}
+
+function Expand-BdsArchive {
+    param(
+        [Parameter(Mandatory)][string]$Path,
+        [Parameter(Mandatory)][string]$Destination,
+        [Parameter(Mandatory)][string]$Version
+    )
+
+    Add-Type -AssemblyName System.IO.Compression.FileSystem
+    $archive = [IO.Compression.ZipFile]::OpenRead($Path)
+    try {
+        $total = $archive.Entries.Count
+        for ($index = 0; $index -lt $total; $index++) {
+            $entry = $archive.Entries[$index]
+            $target = [IO.Path]::GetFullPath((Join-Path $Destination $entry.FullName.Replace('/', '\')))
+            if ([string]::IsNullOrEmpty($entry.Name)) {
+                New-Item -ItemType Directory -Force -Path $target | Out-Null
+            } else {
+                $parent = Split-Path -Parent $target
+                if (-not (Test-Path -LiteralPath $parent -PathType Container)) {
+                    New-Item -ItemType Directory -Force -Path $parent | Out-Null
+                }
+                [IO.Compression.ZipFileExtensions]::ExtractToFile($entry, $target, $false)
+            }
+            $percent = [int]((($index + 1) * 100) / [Math]::Max(1, $total))
+            Write-Progress -Activity "Installing BDS $Version" -Status "$percent% ($($index + 1) of $total files)" -PercentComplete $percent
+        }
+    } finally {
+        Write-Progress -Activity "Installing BDS $Version" -Completed
+        $archive.Dispose()
+    }
+}
+
+function Assert-SafeArchive {
+    param(
+        [Parameter(Mandatory)][string]$Path,
+        [Parameter(Mandatory)][string]$ExtractionRoot
+    )
+
+    Add-Type -AssemblyName System.IO.Compression.FileSystem
+    $root = [IO.Path]::GetFullPath($ExtractionRoot).TrimEnd('\') + '\'
+    $archive = [IO.Compression.ZipFile]::OpenRead($Path)
+    try {
+        if ($archive.Entries.Count -eq 0 -or $archive.Entries.Count -gt 20000) {
+            throw 'The BDS archive has an invalid number of entries.'
+        }
+        foreach ($entry in $archive.Entries) {
+            $name = $entry.FullName.Replace('/', '\')
+            if ([string]::IsNullOrWhiteSpace($name) -or
+                [IO.Path]::IsPathRooted($name) -or
+                $name.Contains(':') -or
+                $name.Contains([char]0)) {
+                throw "The BDS archive contains an unsafe path: $name"
+            }
+            $segments = @($name.Split('\') | Where-Object { $_ -ne '' })
+            if ($segments.Count -eq 0 -or $segments -contains '.' -or $segments -contains '..') {
+                throw "The BDS archive contains an unsafe path: $name"
+            }
+            $target = [IO.Path]::GetFullPath((Join-Path $ExtractionRoot $name))
+            if (-not $target.StartsWith($root, [StringComparison]::OrdinalIgnoreCase)) {
+                throw "The BDS archive path escapes its staging directory: $name"
+            }
+            $unixType = (($entry.ExternalAttributes -shr 16) -band 0xF000)
+            if ($unixType -eq 0xA000) {
+                throw "The BDS archive contains a symbolic link: $name"
+            }
+        }
+    } finally {
+        $archive.Dispose()
+    }
+}
+
+function Set-ServerProperties {
+    param([Parameter(Mandatory)][string]$Path)
+
+    $properties = [IO.File]::ReadAllText($Path)
+    foreach ($setting in @(
+        @('server-name', 'BedrockPlus'),
+        @('level-name', 'BedrockPlus')
+    )) {
+        $key = $setting[0]
+        $value = $setting[1]
+        $pattern = "(?m)^$([Text.RegularExpressions.Regex]::Escape($key))=.*$"
+        if ($properties -match $pattern) {
+            $properties = [Text.RegularExpressions.Regex]::Replace(
+                $properties,
+                $pattern,
+                "$key=$value"
+            )
+        } else {
+            $properties = $properties.TrimEnd("`r", "`n") + "`r`n$key=$value`r`n"
+        }
+    }
+    [IO.File]::WriteAllText($Path, $properties, [Text.UTF8Encoding]::new($false))
+}
+
+function Write-BedrockPlusSettings {
+    param([Parameter(Mandatory)][string]$Path)
+
+    $settings = @'
+; BedrockPlus settings. server.properties remains owned by vanilla BDS.
+[general]
+channel=stable
+auto-update=true
+
+; These switches apply equally to the console and human-readable .log files.
+; Full structured metadata is always retained in the parallel .jsonl log.
+[logging]
+prefix-timestamp=true
+timestamp-pattern=[{hour}:{minute}:{second}.{millisecond}]
+prefix-level=true
+prefix-source=true
+fields=false
+'@
+    [IO.File]::WriteAllText($Path, $settings.TrimStart() + "`r`n", [Text.UTF8Encoding]::new($false))
+}
+
+if (-not (Test-Path -LiteralPath $ManifestPath -PathType Leaf)) {
+    throw "Supported-version manifest was not found: $ManifestPath"
+}
+$manifest = Get-Content -LiteralPath $ManifestPath -Raw | ConvertFrom-Json
+if ($manifest.format_version -ne 1 -or -not $manifest.versions) {
+    throw 'The supported-version manifest is invalid.'
+}
+
+if ($ListVersions) {
+    foreach ($entry in $manifest.versions) {
+        $default = if ($entry.version -eq $manifest.default_version) { ' (default)' } else { '' }
+        Write-Output "$($entry.version) [$($entry.channel), $($entry.platform)]$default"
+    }
+    exit 0
+}
+
+if ([string]::IsNullOrWhiteSpace($BdsVersion)) {
+    if (-not $Yes) {
+        Write-Host 'BDS versions supported by this BedrockPlus build:'
+        foreach ($entry in $manifest.versions) {
+            $default = if ($entry.version -eq $manifest.default_version) { ' (default)' } else { '' }
+            Write-Host "  $($entry.version) [$($entry.channel)]$default"
+        }
+        if (@($manifest.versions).Count -gt 1) {
+            $answer = Read-Host "Select BDS version [$($manifest.default_version)]"
+            if (-not [string]::IsNullOrWhiteSpace($answer)) {
+                $BdsVersion = $answer.Trim()
+            }
+        }
+    }
+    if ([string]::IsNullOrWhiteSpace($BdsVersion)) {
+        $BdsVersion = [string]$manifest.default_version
+    }
+}
+$matches = @($manifest.versions | Where-Object { $_.version -eq $BdsVersion })
+if ($matches.Count -ne 1) {
+    $supported = @($manifest.versions | ForEach-Object { $_.version }) -join ', '
+    throw "BDS $BdsVersion is not supported by this BedrockPlus build. Supported: $supported"
+}
+$selected = $matches[0]
+if ($selected.platform -ne 'windows-x64' -or
+    $selected.download_url -notmatch '^https://www\.minecraft\.net/' -or
+    $selected.archive_sha256 -notmatch '^[0-9a-fA-F]{64}$') {
+    throw 'The selected BDS manifest entry is invalid or uses an unapproved download host.'
+}
+
+$DestinationRoot = [IO.Path]::GetFullPath($DestinationRoot).TrimEnd('\')
+if ($DestinationRoot -split '[\\/]' -contains 'referenceOnly') {
+    throw 'A BedrockPlus server cannot be initialized inside referenceOnly.'
+}
+$downloadsRoot = Join-Path $DestinationRoot 'Downloads'
+$archiveName = "bedrock-server-$($selected.version).zip"
+$cachedArchive = Join-Path $downloadsRoot $archiveName
+if (Test-Path -LiteralPath $DestinationRoot) {
+    if (-not (Test-Path -LiteralPath $DestinationRoot -PathType Container)) {
+        throw "DestinationRoot is not a directory: $DestinationRoot"
+    }
+    $existingItems = @(Get-ChildItem -LiteralPath $DestinationRoot -Force)
+    $unexpectedItems = @($existingItems | Where-Object { $_.Name -cne 'Downloads' })
+    if ($unexpectedItems.Count -ne 0) {
+        throw "DestinationRoot must be empty except for the managed Downloads cache; no files were changed: $DestinationRoot"
+    }
+    if ($existingItems.Count -eq 1) {
+        $downloadsItem = $existingItems[0]
+        if (-not $downloadsItem.PSIsContainer -or
+            ($downloadsItem.Attributes -band [IO.FileAttributes]::ReparsePoint)) {
+            throw "The Downloads cache must be a normal local directory: $downloadsRoot"
+        }
+        foreach ($item in Get-ChildItem -LiteralPath $downloadsRoot -Force) {
+            if ($item.PSIsContainer -or
+                ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -or
+                $item.Name -notmatch '^bedrock-server-[0-9A-Za-z.+-]+\.zip$') {
+                throw "The Downloads cache contains an unmanaged entry; no files were changed: $($item.FullName)"
+            }
+        }
+    }
+} else {
+    New-Item -ItemType Directory -Path $DestinationRoot | Out-Null
+}
+
+if (-not $Yes) {
+    Write-Host "BedrockPlus supports BDS $($selected.version) ($($selected.channel))."
+    Write-Host 'The official BDS archive will be downloaded from minecraft.net.'
+    Write-Host 'By continuing, you confirm that you accept the applicable Minecraft server terms.'
+    $answer = Read-Host "Install it into '$DestinationRoot'? [Y/n]"
+    if (-not [string]::IsNullOrWhiteSpace($answer) -and
+        $answer -notin @('y', 'Y', 'yes', 'YES', 'Yes')) {
+        Write-Host 'Initialization cancelled; no server files were installed.'
+        exit 2
+    }
+}
+
+$temporaryRoot = Join-Path ([IO.Path]::GetTempPath()) ("bedrockplus-init-" + [Guid]::NewGuid().ToString('N'))
+$download = Join-Path $temporaryRoot $archiveName
+$staging = Join-Path $temporaryRoot 'extracted'
+$installedPaths = [Collections.Generic.List[string]]::new()
+New-Item -ItemType Directory -Path $temporaryRoot, $staging | Out-Null
+
+try {
+    if ([string]::IsNullOrWhiteSpace($ArchivePath)) {
+        $useCachedArchive = $false
+        if (Test-Path -LiteralPath $cachedArchive -PathType Leaf) {
+            $cachedHash = Get-Sha256 -Path $cachedArchive
+            $expectedHash = ([string]$selected.archive_sha256).ToLowerInvariant()
+            if ($cachedHash -eq $expectedHash) {
+                Write-Host "Using verified cached BDS $($selected.version) from Downloads."
+                Copy-Item -LiteralPath $cachedArchive -Destination $download
+                $useCachedArchive = $true
+            } else {
+                Write-Warning "The cached BDS $($selected.version) archive failed verification and will be replaced."
+            }
+        }
+        if (-not $useCachedArchive) {
+            Write-Host "Downloading official BDS $($selected.version)..."
+            Invoke-BdsDownload -Uri $selected.download_url -Destination $download -Version $selected.version
+        }
+    } else {
+        Copy-Item -LiteralPath ([IO.Path]::GetFullPath($ArchivePath)) -Destination $download
+    }
+
+    $actualHash = Get-Sha256 -Path $download
+    $expectedHash = ([string]$selected.archive_sha256).ToLowerInvariant()
+    if ($actualHash -ne $expectedHash) {
+        throw "BDS archive verification failed. Expected $expectedHash but received $actualHash."
+    }
+
+    Assert-SafeArchive -Path $download -ExtractionRoot $staging
+    Expand-BdsArchive -Path $download -Destination $staging -Version $selected.version
+
+    $serverExecutable = Join-Path $staging 'bedrock_server.exe'
+    $serverProperties = Join-Path $staging 'server.properties'
+    if (-not (Test-Path -LiteralPath $serverExecutable -PathType Leaf) -or
+        -not (Test-Path -LiteralPath $serverProperties -PathType Leaf)) {
+        throw 'The verified archive does not contain a complete Windows BDS layout.'
+    }
+
+    Set-ServerProperties -Path $serverProperties
+    Write-BedrockPlusSettings -Path (Join-Path $staging 'BedrockPlus.ini')
+    [IO.File]::WriteAllText(
+        (Join-Path $staging 'allowlist.json'),
+        "[]`r`n",
+        [Text.UTF8Encoding]::new($false)
+    )
+    [IO.File]::WriteAllText(
+        (Join-Path $staging 'permissions.json'),
+        "[]`r`n",
+        [Text.UTF8Encoding]::new($false)
+    )
+    New-Item -ItemType Directory -Force -Path `
+        (Join-Path $staging 'plugins'), `
+        (Join-Path $staging 'logs'), `
+        (Join-Path $staging 'Downloads'), `
+        (Join-Path $staging '.bedrockplus'), `
+        (Join-Path $staging '.bedrockplus\plugin-data') | Out-Null
+    Move-Item -LiteralPath $download -Destination (Join-Path $staging "Downloads\$archiveName")
+
+    [ordered]@{
+        product = 'BedrockPlus'
+        format_version = 1
+        bds_version = [string]$selected.version
+        bds_channel = [string]$selected.channel
+        created_by = 'Turkmen'
+        created_at_utc = [DateTime]::UtcNow.ToString('o')
+    } | ConvertTo-Json | Set-Content -LiteralPath `
+        (Join-Path $staging 'bedrockplus.instance.json') -Encoding UTF8
+
+    $installItems = @(Get-ChildItem -LiteralPath $staging -Force)
+    for ($index = 0; $index -lt $installItems.Count; $index++) {
+        $item = $installItems[$index]
+        if ($item.Name -ceq 'Downloads' -and
+            (Test-Path -LiteralPath $downloadsRoot -PathType Container)) {
+            foreach ($archiveItem in Get-ChildItem -LiteralPath $item.FullName -Force) {
+                Move-Item -LiteralPath $archiveItem.FullName -Destination $downloadsRoot -Force
+            }
+            Remove-Item -LiteralPath $item.FullName -Force
+        } else {
+            Move-Item -LiteralPath $item.FullName -Destination $DestinationRoot
+            $installedPaths.Add((Join-Path $DestinationRoot $item.Name))
+        }
+        $percent = [int]((($index + 1) * 100) / [Math]::Max(1, $installItems.Count))
+        Write-Progress -Activity 'Finalizing BedrockPlus server' -Status "$percent%" -PercentComplete $percent
+    }
+    Write-Progress -Activity 'Finalizing BedrockPlus server' -Completed
+    Set-HiddenDirectory -Path (Join-Path $DestinationRoot '.bedrockplus')
+} catch {
+    # Remove only entries successfully moved by this initializer. A file created
+    # concurrently by the operator is never included in this rollback list.
+    foreach ($path in $installedPaths) {
+        Remove-Item -LiteralPath $path -Recurse -Force -ErrorAction SilentlyContinue
+    }
+    throw
+} finally {
+    $tempBase = [IO.Path]::GetFullPath([IO.Path]::GetTempPath()).TrimEnd('\') + '\'
+    $resolvedTemporary = [IO.Path]::GetFullPath($temporaryRoot)
+    if ($resolvedTemporary.StartsWith($tempBase, [StringComparison]::OrdinalIgnoreCase) -and
+        (Split-Path $resolvedTemporary -Leaf).StartsWith('bedrockplus-init-', [StringComparison]::Ordinal)) {
+        Remove-Item -LiteralPath $resolvedTemporary -Recurse -Force -ErrorAction SilentlyContinue
+    }
+}
+
+Write-Host "Created BedrockPlus server: $DestinationRoot"
+Write-Host "BDS version: $($selected.version)"
+Write-Host "BDS archive: $(Join-Path $DestinationRoot "Downloads\$archiveName")"
+Write-Host "Plugin inbox: $(Join-Path $DestinationRoot 'plugins')"

bedrockplus/_assets/LICENSE.txt

@@ -0,0 +1,87 @@
+BEDROCKPLUS PROPRIETARY SOFTWARE LICENSE AGREEMENT
+
+Version 1.0 — 8 October 2026
+
+Copyright (c) 2026 Turkmen. All rights reserved.
+
+This agreement applies to the BedrockPlus server software, launcher, runtime,
+software development kits, headers, examples, documentation, and accompanying
+files (collectively, the "Software"). By installing, copying, or using the
+Software, you agree to these terms.
+
+1. Permitted use
+
+You may install and run unmodified copies of the Software to operate Minecraft:
+Bedrock Edition dedicated servers, including personal and commercial servers.
+You may create, compile, package, and distribute plugins that use the public
+BedrockPlus Python API, C++ SDK headers, or documented plugin ABI. Plugins you
+create remain yours.
+
+2. Redistribution
+
+You may not redistribute the BedrockPlus runtime, launcher, binaries, SDK,
+documentation, or modified copies of them without prior written permission from
+the copyright holder. Instead, direct users to the official BedrockPlus
+distribution channels. This restriction does not prevent redistribution of
+your own plugins or inclusion of the minimum public SDK declarations required
+inside their source code.
+
+3. Restrictions
+
+Except where applicable law expressly permits it, you may not modify, reverse
+engineer, decompile, disassemble, bypass access controls in, sublicense, sell,
+rent, or create derivative works of the closed-source BedrockPlus runtime. You
+may not use the BedrockPlus name or marks to imply endorsement of an unofficial
+distribution.
+
+4. Third-party software and services
+
+Third-party components remain governed by their own license terms, reproduced
+in THIRD_PARTY_NOTICES.md and the accompanying license files. Minecraft and the
+Bedrock Dedicated Server are products of Microsoft and Mojang. BedrockPlus is
+not affiliated with, endorsed by, or sponsored by Microsoft or Mojang. The
+official Bedrock Dedicated Server is downloaded separately and is not licensed
+under this agreement.
+
+5. Server and player data
+
+BedrockPlus processes server and player data locally to provide its documented
+server and plugin features. Server operators are responsible for configuring
+their plugins, protecting logs and stored data, informing players where legally
+required, and complying with applicable privacy and data-protection law.
+
+6. Updates and compatibility
+
+Pre-release versions may change without notice and may support only the exact
+operating-system, Python, and Bedrock Dedicated Server versions stated in their
+release notes. No compatibility, update, or continued-availability commitment
+is made.
+
+7. Disclaimer of warranty
+
+THE SOFTWARE IS PROVIDED "AS IS" AND "AS AVAILABLE", WITHOUT WARRANTIES OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF MERCHANTABILITY, FITNESS FOR
+A PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT. USE PRE-RELEASE SOFTWARE
+ONLY AFTER BACKING UP WORLDS AND SERVER DATA.
+
+8. Limitation of liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE COPYRIGHT HOLDER WILL NOT BE LIABLE
+FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES, OR
+FOR LOSS OF DATA, WORLDS, PROFITS, REVENUE, OR SERVER AVAILABILITY, ARISING FROM
+THE SOFTWARE OR ITS USE.
+
+9. Termination
+
+Your rights under this agreement terminate automatically if you materially
+breach it. On termination, you must stop using and delete your copies of the
+Software, except for backups that applicable law requires you to retain.
+
+10. Contact and separate permission
+
+Requests for redistribution, commercial licensing beyond these terms, security
+reports, or other permissions must be sent through the official BedrockPlus
+website or project contact channel.
+
+If any provision is unenforceable, the remaining provisions continue in effect.
+This agreement does not limit rights that cannot legally be waived.

bedrockplus/_assets/README.md

@@ -0,0 +1,85 @@
+# BedrockPlus Windows x64 pre-release
+
+BedrockPlus is a BDS-native server and plugin platform created by Turkmen. This
+package supports the exact BDS version recorded in `release-manifest.json` and
+contains the BedrockPlus console launcher, runtime, Python and C++ plugin host,
+plugin packaging tools, server initializer, documentation, and required legal
+notices.
+
+The package does **not** contain Minecraft Bedrock Dedicated Server, worlds,
+plugins, private source code, debug symbols, signing keys, build directories,
+or private development files. BDS is downloaded from the official source only
+after the operator accepts the applicable Minecraft server terms.
+
+This is a pre-release. Back up worlds before testing and use only the listed BDS
+version. Python plugins require 64-bit CPython 3.13, which is also the supported
+Python version for installing the BedrockPlus command package.
+
+## Installed commands
+
+After installing the public Python wheel, open Command Prompt in any directory:
+
+```text
+bedrockplus
+bedrockplus init
+bedrockplus start
+bedrockplus doctor
+bedrockplus list-versions
+bedrockplus plugin python init "My Plugin"
+bedrockplus plugin pack
+```
+
+Running `bedrockplus` in a fresh directory offers to install the supported BDS
+version with Yes as the default. The verified official archive is retained in
+the server-root `Downloads` directory. A matching archive already stored there
+is verified and reused without another download.
+
+## Release contents
+
+The archive is assembled from an explicit allowlist and contains only:
+
+- release BedrockPlus executables and DLLs;
+- the command, initializer, launcher, and plugin packaging scripts;
+- supported-version and compatibility data;
+- this guide and third-party notices;
+- a generated payload manifest and SHA-256 checksum list.
+
+`release-manifest.json` records every distributed payload with its role, exact
+byte size, and SHA-256. `SHA256SUMS` covers the payload and manifest. The outer
+ZIP has a separate SHA-256 file. Do not use a package whose verification fails.
+
+## Manual ZIP usage
+
+The Python wheel is the recommended installation. For manual testing:
+
+1. Install 64-bit CPython 3.13.
+2. Extract this release to a new local directory.
+3. Open Command Prompt in the directory where the server should be created.
+4. Run the release's `bin\bedrockplus.ps1` through PowerShell.
+5. Confirm the official BDS installation and start the server.
+
+Keep `bedrock_server.exe`, `server.properties`, `BedrockPlus.ini`, `plugins`,
+`Downloads`, `worlds`, and `logs` together in one server directory. BedrockPlus
+keeps private runtime state and installed plugin contents below the hidden
+`.bedrockplus` directory.
+
+## Publisher build and validation
+
+Use Visual Studio 2022 and the locked project-local environment:
+
+```powershell
+. .\toolchain\enter-dev-shell.ps1
+pwsh -NoProfile -File .\toolchain\package-release.ps1
+```
+
+The packaging task builds Release configuration, runs the complete test suite,
+creates the allowlisted ZIP and checksum, extracts it into an isolated staging
+directory, and verifies its exact contents. Artifacts are written below:
+
+```text
+out/build/windows-vs2022-release/packages/
+```
+
+The public Python wheel is built separately from the verified runtime package.
+Only the wheel is uploaded to PyPI; do not upload the source distribution or
+the private repository.