mcpywrap 0.4.3__tar.gz → 0.4.4__tar.gz

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 更新记录
 
+## 0.4.4
+
+- 修复 Windows 与 macOS 之间同步 Git 依赖时的源码校验失败：获取源码时禁用宿主 Git 的换行、编码与过滤转换，统一保留固定提交中的文件字节。
+- `mcpy sync` 按固定提交直接重新计算 lock 摘要，不改变依赖版本，不再创建锁备份或执行专门迁移；未被修改的旧安装副本自动重建，缓存损坏与手动修改仍会报错。
+- Git 项目依赖和旧代码库使用独立的新源码缓存，首次同步重新获取固定提交，后续可离线复用。补充跨 Git 配置、旧 Windows 缓存、二进制文件与重复同步稳定性的回归测试。
+- Windows 启动时增加原生 HUD 布局日志识别，避免 Python 启动日志异常导致世界就绪状态无法确认。
+- 修复 Mod 模板窗口关闭后未释放对象、在新版 PySide6 下退出进程时可能崩溃的问题。
+
 ## 0.4.3
 
 - macOS 新增无认证服务器连接，复用 `mcpy connect` 与项目 `[tool.mcpywrap.server]` 的 `run` 入口、cppconfig、日志、偏好和退出机制，不装配本地 Mod 或创建本地世界实例。

{mcpywrap-0.4.3/mcpywrap.egg-info → mcpywrap-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpywrap
-Version: 0.4.3
+Version: 0.4.4
 Summary: A wrapper for Minecraft China Edition Addons management
 Author-email: boybook <boybook@easecation.net>
 License-Expression: MIT

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/docs/git-dependencies.md

@@ -76,11 +76,11 @@ Python的project.dependencies继续表示工具Python依赖，不变成游戏代
 
 两端提交并使用同一份 `mcpy-git.lock.json`，无需维护平台分支。锁定的是 Git 提交、源码和依赖关系；本机安装目录位于 `.mcpy/`，不提交到 Git。当前依赖都是游戏源码，没有需要分别锁定的 Windows/macOS 原生包。
 
-v2 锁使用相同的大小写敏感路径排序；源码由 Git archive 提取，保留仓库内的原始字节，工具生成的文件统一使用 LF。切换操作系统不会改变依赖摘要。新机器或克隆项目后运行一次 `mcpy sync`，随后正常 `mcpy run`。
+v2 锁使用相同的大小写敏感路径排序；源码由 Git archive 提取，禁用宿主 Git 的换行、编码、ident 和 filter 转换及全局 attributes，保留提交中的文件字节（包括二进制和原本的 CRLF）。工具生成的文件统一使用 LF。新机器或克隆项目后运行一次 `mcpy sync`，随后正常 `mcpy run`。
 
-普通 `mcpy sync` 会验证旧 v1 锁的源码，再自动更新跨平台格式，不再需要迁移参数。旧锁备份于 `.mcpy/lock-backups/`；需要重建的旧平台安装副本保留于 `.mcpy/registration-backups/`。提交新锁后，团队两端应使用支持 v2 的新版 mcpy。旧源码校验失败、或已安装文件出现无法解释的修改时仍会报错，不自动丢弃用户修改。
+`mcpy sync` 依据声明中固定的完整 Git 提交重新计算源码和安装内容摘要，直接写回锁文件；不更新依赖版本、不创建备份或执行专门的锁迁移。旧 v1/v2 锁都可通过一次 sync 刷新。新快照使用独立的 `git-archive-v2` 缓存，首次同步会重新获取固定提交，之后可离线复用；旧缓存不参与新摘要计算。已安装副本与旧锁一致时可重建，手动改动或缓存损坏仍会报错。`build/package/run` 继续严格验证锁文件，不隐式重算。
 
-终端只显示同步进度、结果和必要操作；`mcpy sync --json` 保留备份位置、完整摘要等诊断信息，供脚本和 AI 使用。`--migrate-windows-lock` 暂留作旧脚本兼容参数。
+终端只显示同步进度、结果和必要操作；`mcpy sync --json` 返回结构化结果。`--migrate-windows-lock` 和 JSON 中始终为空的 `git_lock_migrations` 仅保留旧脚本兼容。团队各设备应使用包含此修复的版本，并提交 sync 更新后的锁文件。
 
 ## 验证范围
 

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """mcpywrap - 我的世界中国版 Addon 开发依赖、构建与游戏测试工具。"""
 
-__version__ = '0.4.3'
+__version__ = '0.4.4'

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/code_libraries.py

@@ -64,9 +64,6 @@ def prepare_sync(root, config=None):
     for entry in entries:
         key = identity(entry)
         installed = cache / key
-        if installed.is_dir() and key in expected and expected[key] in (digest(installed), windows_checkout_digest(installed, crlf=False)):
-            lock['libraries'].append({'declaration': entry, 'sha256': digest(installed)})
-            continue
         # 临时仓库不检出文件、不运行依赖代码、hooks 或安装脚本。
         with tempfile.TemporaryDirectory(prefix='fetch-', dir=cache) as temporary:
             temp = Path(temporary)
@@ -83,12 +80,19 @@ def prepare_sync(root, config=None):
                     (content / ('MCPY_UPSTREAM_' + file.name)).write_bytes(file.read_bytes())
             validate_game_files(root, [content])
             value = digest(content)
-            if key in expected and expected[key] not in (value, windows_checkout_digest(content, crlf=False)):
-                raise DependencyError('固定提交的代码库内容与锁文件摘要不符')
             if installed.exists():
-                # 回退到旧提交：用重新获取的内容验证旧缓存，而不是逐文件覆盖。
+                # Rebuild unchanged old installations from canonical source.
                 if digest(installed) != value:
-                    raise DependencyError(f'代码库缓存已损坏，请移走后重新 sync: {installed}')
+                    if key not in expected or expected[key] not in (
+                            digest(installed), windows_checkout_digest(installed, crlf=False)):
+                        raise DependencyError(f'代码库缓存已损坏，请移走后重新 sync: {installed}')
+                    old = temp / 'old'
+                    os.replace(installed, old)
+                    try:
+                        os.replace(content, installed)
+                    except BaseException:
+                        os.replace(old, installed)
+                        raise
             else:
                 os.replace(content, installed)
             lock['libraries'].append({'declaration': entry, 'sha256': value})

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/commands/sync_cmd.py

@@ -19,8 +19,6 @@ def sync_cmd(install, migrate_windows_lock=False):
     result = sync_project(project_dir(), install, migrate_windows_lock=migrate_windows_lock)
     if json_output():
         return result
-    if result['git_lock_migrations']:
-        click.echo('已更新跨平台依赖记录，旧文件已备份。')
     count = result['git_projects'] + result['code_libraries']
     click.secho('完成 · %d 个源码依赖已就绪 · %.1fs' % (count, time.monotonic()-started), fg='green')
     if install:
@@ -38,7 +36,6 @@ def sync_project(path, install=False, migrate_windows_lock=False):
         from ..builders.dependency_manager import DependencyManager
         visited, active = set(), set()
         git_count = 0
-        migrations = []
         def sync_sources(directory):
             nonlocal git_count
             key = canonical_path(directory)
@@ -57,8 +54,7 @@ def sync_project(path, install=False, migrate_windows_lock=False):
                     if target and 'mcpywrap' in read_project(target).get('tool', {}):
                         sync_sources(target)
             if git_declarations(directory, source_config) or Path(directory, GIT_LOCK_FILE).exists():
-                git_count += sync_projects(directory, source_config, migrate_windows_lock=migrate_windows_lock,
-                                           migration_report=migrations)
+                git_count += sync_projects(directory, source_config)
             active.remove(key)
             visited.add(key)
         sync_sources(path)
@@ -78,4 +74,4 @@ def sync_project(path, install=False, migrate_windows_lock=False):
             if proc.returncode:
                 raise click.ClickException(proc.stderr or proc.stdout or '项目安装失败')
     return {'project': str(path), 'installed': install, 'code_libraries': library_count,
-            'git_projects': git_count, 'git_lock_migrations': migrations}
+            'git_projects': git_count, 'git_lock_migrations': []}

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/engines/windows.py

@@ -13,28 +13,34 @@ class WindowsBackend(GameBackend):
     def debug_channel(self, data, write_log):
         from ..mcstudio.runtime_debug import SafaiaChannel
         self._world_ready = data.get('mode') != 'local'
-        self._log_offset, self._log_pending = 0, b''
+        self._ready_log_cursors = {}
         if data.get('mode') == 'local': data['world_ready'] = False
         return SafaiaChannel(write_log, ready=lambda: self._world_ready)
 
     def refresh(self, data, channel):
         if self._world_ready: return False
         from pathlib import Path
-        path = Path(data['log_path'])
-        try:
-            with path.open('rb') as stream:
-                stream.seek(self._log_offset)
-                chunk = stream.read(65536)
-                self._log_offset = stream.tell()
-        except FileNotFoundError:
-            return False
-        text = self._log_pending + chunk
-        # This engine log is emitted after client/server Python system creation.
-        if b'OnHandlePushScreen hud_screen' in text:
-            self._world_ready = data['world_ready'] = True
-            self._log_pending = b''
-            return True
-        self._log_pending = text[-64:]
+        import re
+        for name in ('log_path', 'engine_log_path'):
+            if not data.get(name): continue
+            path = Path(data[name])
+            offset, pending = self._ready_log_cursors.get(name, (0, b''))
+            try:
+                with path.open('rb') as stream:
+                    stream.seek(offset)
+                    chunk = stream.read(65536)
+                    offset = stream.tell()
+            except FileNotFoundError:
+                continue
+            text = pending + chunk
+            # Both markers require a created gameplay HUD. The native layout
+            # marker also works if the Python launch logging handler raises.
+            hud = (b'OnHandlePushScreen hud_screen' in text if name == 'log_path' else
+                   re.search(rb"\bINFO GUI [^\r\n]*\] Layout main thread: [^\r\n]*controls completed [^\r\n]*for screen 'hud\.hud_screen'\.", text))
+            self._ready_log_cursors[name] = (offset, text[-1024:])
+            if hud:
+                self._world_ready = data['world_ready'] = True
+                return True
         return False
 
     def reload_restriction(self, data, kind):

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/git_cache.py

@@ -89,7 +89,9 @@ def fetch_snapshot(url, ref):
         raise DependencyError('无效Git引用')
     origin = hashlib.sha256(url.encode('utf-8')).hexdigest()
     base = cache_root()
-    snapshots = base / 'git' / origin
+    # Old archives may contain bytes converted by the host's Git settings.
+    # Keep them separate so even a verified old cache cannot reintroduce CRLF.
+    snapshots = base / 'git-archive-v2' / origin
     snapshots.mkdir(parents=True, exist_ok=True)
     with _source_lock(base / 'locks' / (origin + '.lock')):
         if re.fullmatch('[0-9a-f]{40}', ref) and (snapshots / ref).exists():
@@ -99,6 +101,11 @@ def fetch_snapshot(url, ref):
             repo, package = stage / 'repo', stage / 'snapshot'
             content = package / 'content'
             _git('init', '--bare', repo)
+            # Archive applies checkout conversions too. Preserve blob bytes,
+            # including binary/intentional CRLF files, on every host.
+            (repo / 'info').mkdir(exist_ok=True)
+            (repo / 'info' / 'attributes').write_bytes(
+                b'* -text -eol -filter -ident -working-tree-encoding\n')
             _git('-C', repo, 'fetch', '--depth=1', '--no-tags', url, ref)
             commit = _git('-C', repo, 'rev-parse', 'FETCH_HEAD^{commit}').decode().strip()
             if not re.fullmatch('[0-9a-f]{40}', commit) or (re.fullmatch('[0-9a-f]{40}', ref) and commit != ref):

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/git_projects.py

@@ -108,11 +108,10 @@ def prepare_graph(root, config=None, migrate_windows_lock=False):
     root = Path(root).resolve()
     config = read_project(root) if config is None else config
     roots = declarations(root, config)
-    expected, legacy = {}, False
+    expected = {}
     if (root / LOCK_FILE).exists():
         try:
             prior = json.loads((root / LOCK_FILE).read_text('utf-8'))
-            legacy = prior['version'] == 1
             expected = {record['id']: record for record in prior['nodes']}
         except (ValueError, KeyError, TypeError) as exc:
             raise DependencyError('无法读取依赖锁文件 mcpy-git.lock.json。\n请从版本控制恢复该文件后运行 mcpy sync。') from exc
@@ -120,7 +119,7 @@ def prepare_graph(root, config=None, migrate_windows_lock=False):
             raise DependencyError('此项目需要较新版本的 mcpy，请先升级 mcpywrap。')
     registered = long_path(root / '.mcpy/git-projects')
     registered.mkdir(parents=True, exist_ok=True)
-    nodes, active, migrations = {}, [], []
+    nodes, active = {}, []
     def visit(entry, supplied_source=None):
         source, commit = supplied_source or fetch_source(root, entry['git'], entry['rev'])
         project, payload, project_config, kind, target = _layout(source, entry)
@@ -138,11 +137,8 @@ def prepare_graph(root, config=None, migrate_windows_lock=False):
         active.append(key)
         source_hash = digest(source)
         previous = expected.get(key)
-        migrating = legacy and previous is not None
-        if previous and previous['source_sha256'] != source_hash:
-            if not migrating or previous['source_sha256'] not in (
-                    windows_checkout_digest(source), windows_checkout_digest(source, crlf=False)):
-                raise DependencyError(f"依赖 {entry['name']} 的源码校验失败。\n请保留 mcpy-git.lock.json，并重新获取该依赖的固定版本。")
+        # sync derives checksums from the pinned commit's verified snapshot.
+        # Old host-dependent checksums are outputs, not version constraints.
         children = []
         for child in declarations(project, project_config):
             children.append(visit(child))
@@ -197,65 +193,39 @@ def prepare_graph(root, config=None, migrate_windows_lock=False):
             from .dependencies import validate_game_files
             validate_game_files(stage, addon_directories(stage).values())
             content_hash = digest(stage)
-            if previous and previous['sha256'] != content_hash and not migrating:
-                raise DependencyError(f"依赖 {entry['name']} 的安装内容与锁文件不一致。\n请确认团队使用相同版本的 mcpywrap；不要删除锁文件。")
             final = registered / key
             if final.exists():
                 if digest(final) != content_hash:
-                    # Old generated files may contain Windows line endings. Only
-                    # replace a verified old registration; preserve it for recovery.
-                    if not migrating or previous['sha256'] not in (
+                    # Only replace an unchanged installation of the old lock.
+                    if not previous or previous['sha256'] not in (
                             digest(final), windows_checkout_digest(final, crlf=False)):
                         raise DependencyError(f"依赖 {entry['name']} 的本地文件已修改。\n请将 {final} 移到项目外备份，再运行 mcpy sync。")
-                    backups = root/'.mcpy/registration-backups'
-                    backups.mkdir(parents=True, exist_ok=True)
-                    backup = Path(tempfile.mkdtemp(prefix=key[:12]+'-', dir=backups))/'project'
-                    os.replace(final, backup)
+                    old = Path(temporary) / 'old'
+                    os.replace(final, old)
                     try:
                         os.replace(stage, final)
                     except BaseException:
-                        os.replace(backup, final)
+                        os.replace(old, final)
                         raise
             else:
                 os.replace(stage, final)
         record = {'id': key, 'source': identity, 'source_sha256': source_hash, 'sha256': content_hash,
                   'kind': kind, 'target': target, 'children': list(dict.fromkeys(children))}
-        if migrating:
-            migrations.append({'node': key, 'name': entry['name'], 'git': entry['git'], 'rev': commit,
-                               'old_source_sha256': previous['source_sha256'], 'source_sha256': source_hash,
-                               'old_registered_sha256': previous['sha256'], 'registered_sha256': content_hash})
         nodes[key] = record
         active.pop()
         return key
     root_ids = [visit(entry) for entry in roots]
-    lock = {'version': 2, 'declarations': roots, 'roots': root_ids, 'nodes': list(nodes.values())}
-    if migrations:
-        lock['_lock_migrations'] = migrations
-    return lock
+    return {'version': 2, 'declarations': roots, 'roots': root_ids, 'nodes': list(nodes.values())}
 
 
 def write_lock(root, lock):
-    data = dict(lock)
-    migrations = data.pop('_lock_migrations', [])
-    report = []
-    if migrations and (Path(root)/LOCK_FILE).exists():
-        old = (Path(root)/LOCK_FILE).read_bytes()
-        backup = Path(root)/'.mcpy/lock-backups'/(hashlib.sha256(old).hexdigest()+'.json')
-        backup.parent.mkdir(parents=True, exist_ok=True)
-        if backup.exists() and backup.read_bytes() != old:
-            raise DependencyError('无法备份旧依赖记录，原锁文件未修改。')
-        backup.write_bytes(old)
-        report.append({'project': str(root), 'backup': str(backup), 'nodes': migrations})
-    _write_json(Path(root) / LOCK_FILE, data)
-    return report
+    _write_json(Path(root) / LOCK_FILE, lock)
 
 
 def sync_projects(root, config=None, migrate_windows_lock=False, migration_report=None):
-    # Kept for older callers; recognized legacy locks now migrate automatically.
-    lock = prepare_graph(root, config, migrate_windows_lock=migrate_windows_lock)
-    report = write_lock(root, lock)
-    if migration_report is not None:
-        migration_report.extend(report)
+    # Legacy arguments are retained for callers; sync simply recalculates the lock.
+    lock = prepare_graph(root, config)
+    write_lock(root, lock)
     return len(lock['nodes'])
 
 

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/mcstudio/bridge_payload/manifest.json

@@ -11,9 +11,9 @@
     "Loader.c": "f2f1f781ce82fc30c62a6ce22bb048d3b023f6ff500e6ec8228da28b4dbf1b4a"
   },
   "files": {
-    "Injector.exe": "376bbefafdab254e413e6a6d9cb1b880e1e94fd259bae55c8a882e17a383892e",
-    "Loader.dll": "a4f4da0a3d65dfd94802ac2dd30e5edea81d34659df451c961de15e44a87f6ac",
-    "McpyMcsAuth.dll": "c5f105f2e8bd821aa8a0bc1435cc42bac2ca690343a63f8c773eb593971a5ffb",
+    "Injector.exe": "aa185d69f11e138df90f446c239d075ef6ab4e5c5e0457981a6c09f52e04b7b9",
+    "Loader.dll": "03956417da34f569dd6e794076f2252ff05cb286fd1a8dc6ce966dc78911330e",
+    "McpyMcsAuth.dll": "b1270f169319e8acebca7d49be966d54c769590d708157c3984e33f9a943c1d7",
     "publisher.cer": "e5aa2ac39df40804ed8b08fe8e43c4a2b8923f0d02a360708486b2db5b6303d7"
   }
 }

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/mcstudio/window_capture/manifest.json

@@ -1,5 +1,5 @@
 {
-  "executable_sha256": "81642e2d7c9c5097cd86b139f41f75a6f3ca12cb5b2bddbc0427cb2aee92bb64",
+  "executable_sha256": "4f4f8b0a8eae4b8d409ae90e222886623c4b53ed66525d8267ffaadc1db65442",
   "source_sha256": "0c0b2a02bfecea68b824a486ac1d88cde6bd9fc8ee8e4c9a6939870bd8e710d1",
   "sources": {
     "video_capture.h": "8daee1b8c1c8273bc8d19d39f0559f82c30d7ff900894bcc2cc197d3881532d7",

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/minecraft/template/mod_template.py

@@ -144,6 +144,8 @@ def open_ui_crate_mod(behavior_pack_path, run_event_loop=True):
     
     # 主窗口
     window = QWidget()
+    # Closed embedded editors must release their signal closures before Qt exits.
+    window.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
     window.setWindowTitle("Minecraft Mod 创建工具")
     window.setMinimumWidth(900)  # 增加窗口宽度以适应目录树
     window.setMinimumHeight(600)  # 设置窗口最小高度

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/mcpywrap/source_files.py

@@ -68,7 +68,10 @@ def _git(*args):
             return value[4:]
         return value
     try:
-        result = subprocess.run(['git', '-c', 'core.hooksPath=', '-c', 'core.longpaths=true', *map(argument, args)],
+        result = subprocess.run(['git', '-c', 'core.hooksPath=', '-c', 'core.longpaths=true',
+                                 '-c', 'core.autocrlf=false', '-c', 'core.eol=lf',
+                                 '-c', 'core.attributesFile=' + os.devnull, *map(argument, args)],
+                                env=dict(os.environ, GIT_ATTR_NOSYSTEM='1'),
                                 capture_output=True, timeout=180)
     except (OSError, subprocess.TimeoutExpired) as exc:
         raise DependencyError(f'无法获取代码库: {exc}') from exc

{mcpywrap-0.4.3 → mcpywrap-0.4.4/mcpywrap.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpywrap
-Version: 0.4.3
+Version: 0.4.4
 Summary: A wrapper for Minecraft China Edition Addons management
 Author-email: boybook <boybook@easecation.net>
 License-Expression: MIT

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcpywrap"
-version = "0.4.3"
+version = "0.4.4"
 description = "A wrapper for Minecraft China Edition Addons management"
 readme = "README.md"
 authors = [{name = "boybook", email = "boybook@easecation.net"}]

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/skills/mcpywrap/SKILL.md

@@ -63,7 +63,7 @@ description: 使用 mcpywrap 管理《我的世界》中国版 Addon/地图、
 `--project` 必须是调用端路径且目录已存在；纯连接不需要 init。远程实际会话保存在 Windows 的 serve 数据目录。
 远程结果中的 `project/image` 是调用端路径；`remote_project/executable/log_path/engine_log_path` 是 Windows 信息。读取远程日志用 logs，不在 macOS 打开 Windows 路径。
 
-Windows/macOS 共用依赖锁；克隆后用 `sync --json` 恢复，旧平台格式自动验证和备份。向用户说明依赖名称与下一步命令，完整迁移信息保留在 JSON 中。
+Windows/macOS 共用依赖锁；克隆后用 `sync --json` 恢复。sync 按固定 Git 提交重新计算跨平台摘要并写回锁，不改变依赖版本，也不创建备份或要求迁移。两端 CLI 都应包含此修复；首次使用新的源码缓存需联网获取固定提交。
 
 ## 项目工作流
 

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/skills/mcpywrap/references/project-dependencies.md

@@ -116,7 +116,8 @@ export.path相对该项目描述。没有export时工具可识别符合既有目
 | 新克隆缺少缓存 | 执行sync，保留现有锁定提交 |
 | 布局无法识别 | 查上游export/目录，再传明确subdir、kind、target；不猜安装位置 |
 | 目标已有手工框架或另一依赖 | 核对归属并制定明确迁移；不直接覆盖或删业务目录 |
-| 源码摘要不符 | 定位具体缓存条目，保留锁的预期内容；不删锁或清空全部缓存来掩盖差异 |
+| 旧平台锁摘要不符 | 更新两端 CLI 后运行 sync，按固定提交直接重算锁；不必删除锁或更改依赖版本 |
+| 共享源码缓存损坏 | 定位具体缓存条目并重新获取；不清空全部缓存，不把手动改动写入锁 |
 | 获取来源失败 | 保留失败信息及现有声明，不静默换镜像、更新版本或转为pip安装 |
 | 构建成功但游戏导入失败 | 检查产物路径、入口、端侧与游戏日志；不是工具Python缺包的充分证据 |
 

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/tests/test_code_libraries.py

@@ -87,6 +87,26 @@ class CodeLibraries(unittest.TestCase):
         self.build()
         self.assertFalse((self.out / 'behavior_pack/MyMod/Library').exists())
 
+    def test_windows_lock_and_installation_are_recalculated_from_pinned_source(self):
+        from mcpywrap.source_files import digest
+        sync_libraries(self.main)
+        path = self.main / LOCK_FILE
+        canonical = path.read_bytes()
+        installed = resolve_libraries(self.main)[0]['source']
+        for file in installed.rglob('*'):
+            if file.is_file():
+                file.write_bytes(file.read_bytes().replace(b'\r\n', b'\n').replace(b'\n', b'\r\n'))
+        lock = json.loads(canonical)
+        lock['libraries'][0]['sha256'] = digest(installed)
+        self.assertNotEqual(lock['libraries'][0]['sha256'], json.loads(canonical)['libraries'][0]['sha256'])
+        path.write_text(json.dumps(lock))
+        clone = self.root / 'clone'
+        shutil.copytree(self.main, clone, ignore=shutil.ignore_patterns('.mcpy'))
+        for project in (self.main, clone):
+            sync_libraries(project)
+            resolve_libraries(project)
+            self.assertEqual((project / LOCK_FILE).read_bytes(), canonical)
+
     def test_tamper_failed_fetch_and_handwritten_conflicts_preserve_output(self):
         sync_libraries(self.main)
         self.build()

{mcpywrap-0.4.3 → mcpywrap-0.4.4}/tests/test_engine_backends.py

@@ -18,6 +18,28 @@ from mcpywrap.engines.windows import WindowsBackend
 
 
 class BackendTests(unittest.TestCase):
+    def test_windows_native_hud_layout_when_python_launch_log_is_missing(self):
+        backend=WindowsBackend()
+        game=self.root/'game.log';engine=self.root/'engine.log'
+        data={'mode':'local','log_path':str(game),'engine_log_path':str(engine)}
+        channel=backend.debug_channel(data,lambda text:None);self.addCleanup(channel.close)
+        game.write_bytes(b'UI registered\n')
+        engine.write_bytes(b"[INFO GUI 1 2] Destroyed 'world_loading_progress_screen'\n[INFO GUI 1 2] Layout main thread: Full re-layout of 364 controls completed in 3ms for screen 'pause.pause_screen'.\n")
+        self.assertFalse(backend.refresh(data,channel));self.assertFalse(channel.ready())
+        marker=b"[2026-10-10 16:54:45:664 INFO GUI 90568 80348] Layout main thread: Full re-layout of 364 controls completed in 3.714000ms for screen 'hud.hud_screen'."
+        with engine.open('ab') as stream:stream.write(marker[:120])
+        self.assertFalse(backend.refresh(data,channel))
+        with engine.open('ab') as stream:stream.write(marker[120:]+b'\n')
+        self.assertTrue(backend.refresh(data,channel));self.assertTrue(data['world_ready']);self.assertTrue(channel.ready())
+        self.assertFalse(backend.refresh(data,channel))
+
+    def test_windows_native_hud_requires_engine_log_not_arbitrary_python_text(self):
+        backend=WindowsBackend();game=self.root/'game.log'
+        data={'mode':'local','log_path':str(game),'engine_log_path':str(self.root/'missing.log')}
+        channel=backend.debug_channel(data,lambda text:None);self.addCleanup(channel.close)
+        game.write_bytes(b"[INFO GUI 1 2] Layout main thread: 10 controls completed for screen 'hud.hud_screen'.\n")
+        self.assertFalse(backend.refresh(data,channel));self.assertFalse(channel.ready())
+
     def test_windows_world_readiness_waits_for_client_system_initialization(self):
         backend = WindowsBackend()
         path = self.root/'game.log'