ff9mapkit 1.0.0b4__tar.gz → 1.0.0b5__tar.gz

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ff9mapkit
-Version: 1.0.0b4
+Version: 1.0.0b5
 Summary: Author novel custom field maps for Final Fantasy IX (Memoria engine) from a declarative TOML project file.
 Author: GameJawnsInc
 License-Expression: MIT

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/ff9mapkit/__init__.py

@@ -15,4 +15,4 @@ Public surface is organized as:
   ff9mapkit.battle    — the battle.toml -> custom battle-background (BBG) builder (fork/edit/build a 3D battle map)
 """
 
-__version__ = "1.0.0b4"   # keep in lockstep with [project] version in pyproject.toml
+__version__ = "1.0.0b5"   # keep in lockstep with [project] version in pyproject.toml

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/ff9mapkit/build.py

@@ -1839,6 +1839,16 @@ def lint_logic(project: FieldProject) -> list[str]:
             for ln in _text.overflow_lines(t, wrap):
                 out.append(f"{who} has a word too wide to fit one line ({ln!r}) -- it will overflow; "
                            f"shorten it or raise [dialogue] wrap.")
+    # DEPRECATION: `[cutscene] ate = true` is the OLD, unfaithful forced-ATE model -- a grey banner held over
+    # THIS in-place cutscene. A real grey ATE WARPS you to a dedicated scene and back (verified vs 6 real grey
+    # ATEs; see project-ff9-ate-system). Steer to the faithful trigger; the held-banner still builds (not an error).
+    _cs = raw.get("cutscene")
+    if isinstance(_cs, dict) and _cs.get("ate"):
+        out.append("[cutscene] ate = true is the OLD held-banner ATE styling (a grey banner over this in-place "
+                   "cutscene) -- NOT how a real grey ATE works (it WARPS you to a scene, plays it, and warps you "
+                   "back). For a faithful forced ATE use `[[gateway]] ate = true` (the warp-in trigger: banner "
+                   "warning + centered title window, then the warp) + a plain [cutscene] + exit_warp on the "
+                   "destination field. This held-banner flavor still builds, but it isn't faithful.")
 
     # reference-data sanity (Info Hub): an [[npc]] model id / animation id the engine won't recognise.
     # A model NAME is handled by validate() (fatal); here we WARN on a raw id outside the known tables
@@ -3183,9 +3193,10 @@ _UID_HOTFIX_DONORS = frozenset((900, 2803))
 
 
 def _verbatim_donor_id(project: FieldProject):
-    """Best-effort donor field id of a verbatim fork (for engine-hotfix warnings). ``import --verbatim``
-    records it as ``[verbatim_eb] donor``; ``None`` when an older fork's toml lacks it (the warn is then
-    skipped -- only fields 900/2803 are affected, so a missing hint just means no warn)."""
+    """Best-effort donor field id of ANY fork (verbatim OR native/synth), for engine-hotfix warnings AND the
+    deploy-time ForkDonorPatch `<forkId> <donorId>` mapping. The import records it as ``[verbatim_eb] donor``
+    (verbatim) or ``[field] source_field`` (native/synth); ``borrow_field`` is the BG-borrow form. ``None``
+    when an older fork's toml lacks it (the warn/emit is then skipped -- pre-record forks need a hand-added line)."""
     for blk, key in (("verbatim_eb", "donor"), ("field", "source_field"), ("field", "borrow_field")):
         v = (project.raw.get(blk) or {}).get(key)
         if isinstance(v, bool):

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/ff9mapkit/config.py

@@ -46,6 +46,15 @@ _COMMON_STEAM_PATHS = (
     r"D:\SteamLibrary\steamapps\common\FINAL FANTASY IX",
 )
 
+# FF9 store identifiers -- used to read the per-game install path from the Windows registry (the SAME keys
+# Memoria's patcher reads, so we resolve exactly the folder it patches -- correct even on a secondary drive
+# / custom Steam library). Steam + GOG are the same Unity port with an identical on-disk layout; the
+# Microsoft Store / Xbox Game Pass build is a different, non-Unity, DRM-locked package Memoria can't patch,
+# so the detector never targets it.  Refs: Albeoris/Memoria Memoria.Patcher/GameInfo/.
+_STEAM_APPID = "377840"
+_GOG_GAMEID = "1375008492"
+_FF9_DIRNAME = "FINAL FANTASY IX"
+
 
 class ConfigError(RuntimeError):
     """Raised when a required path cannot be resolved or does not exist."""
@@ -80,34 +89,129 @@ def save_game_path(game_path: str | os.PathLike) -> Path:
     return USER_CONFIG
 
 
+def _is_ff9_root(p: Path) -> bool:
+    """True if ``p`` is a real, MODDABLE FF9 install (Steam or GOG -- same layout). Keys off Memoria's own
+    sentinel (``FF9_Launcher.exe``) plus ``StreamingAssets`` and the managed-DLL tree -- which also rejects
+    the un-moddable Microsoft Store build (no launcher / no Managed dir) and stale empty folders."""
+    try:
+        return ((p / "FF9_Launcher.exe").is_file()
+                and (p / "StreamingAssets").is_dir()
+                and ((p / "x64" / "FF9_Data" / "Managed").is_dir()
+                     or (p / "x86" / "FF9_Data" / "Managed").is_dir()))
+    except OSError:
+        return False
+
+
+def _reg_str(hive, subkey: str, value: str) -> str | None:
+    """Read one registry string value, trying the 64-bit THEN 32-bit view (FF9's keys live under
+    ``WOW6432Node`` on 64-bit Windows). Windows-only; returns None elsewhere or if the key/value is absent."""
+    if os.name != "nt":
+        return None
+    import winreg  # noqa: PLC0415 - Windows-only, lazy
+    for view in (winreg.KEY_WOW64_64KEY, winreg.KEY_WOW64_32KEY):
+        try:
+            with winreg.OpenKeyEx(hive, subkey, 0, winreg.KEY_READ | view) as key:
+                data, _ = winreg.QueryValueEx(key, value)
+                if data:
+                    return str(data)
+        except OSError:
+            continue
+    return None
+
+
+def _registry_candidates() -> list[Path]:
+    """FF9 roots from the per-game Steam + GOG registry keys (the exact keys Memoria reads). These point at
+    the ACTUAL install dir, so they find FF9 even on a secondary drive or a custom-named Steam library."""
+    if os.name != "nt":
+        return []
+    import winreg  # noqa: PLC0415
+    out: list[Path] = []
+    steam = _reg_str(winreg.HKEY_LOCAL_MACHINE,
+                     rf"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Steam App {_STEAM_APPID}",
+                     "InstallLocation")
+    if steam:
+        out.append(Path(steam))
+    gog = _reg_str(winreg.HKEY_LOCAL_MACHINE, rf"SOFTWARE\GOG.com\Games\{_GOG_GAMEID}", "path")
+    if gog:
+        out.append(Path(gog))
+    return out
+
+
+def _parse_vdf_library_paths(text: str) -> list[str]:
+    """Library-folder paths from a Steam ``libraryfolders.vdf`` -- handles both the old ``"1" "<path>"`` and
+    the new ``"path" "<path>"`` schemas (and ignores the new schema's ``"apps"`` appid->buildid map). The
+    file doubles its backslashes, so they're unescaped here."""
+    keyed = re.findall(r'"path"\s+"([^"]+)"', text) if '"path"' in text \
+        else re.findall(r'"\d+"\s+"([^"]+)"', text)
+    return [p.replace("\\\\", "\\") for p in keyed]
+
+
+def _steam_library_candidates() -> list[Path]:
+    """FF9 under every Steam library (a fallback when the per-game Uninstall key is missing): locate Steam
+    via the registry, parse ``libraryfolders.vdf``, and join ``steamapps/common/FINAL FANTASY IX``."""
+    if os.name != "nt":
+        return []
+    import winreg  # noqa: PLC0415
+    steam = (_reg_str(winreg.HKEY_CURRENT_USER, r"Software\Valve\Steam", "SteamPath")
+             or _reg_str(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\WOW6432Node\Valve\Steam", "InstallPath"))
+    if not steam:
+        return []
+    steam_dir = Path(steam)
+    out: list[Path] = [steam_dir / "steamapps" / "common" / _FF9_DIRNAME]
+    for vdf in (steam_dir / "steamapps" / "libraryfolders.vdf", steam_dir / "config" / "libraryfolders.vdf"):
+        try:
+            text = vdf.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        for lib in _parse_vdf_library_paths(text):
+            out.append(Path(lib) / "steamapps" / "common" / _FF9_DIRNAME)
+    return out
+
+
+def _fallback_candidates() -> list[Path]:
+    """Last-resort default install folders (Steam + GOG) if registry/library lookups don't resolve."""
+    gog = [Path(b) / _FF9_DIRNAME for b in
+           (r"C:\GOG Games", r"D:\GOG Games", r"C:\Program Files (x86)\GOG Galaxy\Games")]
+    return [Path(p) for p in _COMMON_STEAM_PATHS] + gog
+
+
 def find_game_path(explicit: str | os.PathLike | None = None) -> Path:
     """Resolve the Final Fantasy IX install folder.
 
-    Order: explicit arg > $FF9_GAME_PATH > ~/.ff9mapkit.toml(game_path) > common Steam dirs.
-    Raises ConfigError with actionable guidance if none of them point at a real folder.
+    Order: explicit arg > ``$FF9_GAME_PATH`` > ``~/.ff9mapkit.toml`` (``game_path``) > auto-detect. The
+    auto-detector mirrors Memoria's: the per-game Steam + GOG registry keys, then a Steam-library scan, then
+    the common default folders. Explicit/env/config paths are trusted if they exist; auto-detected ones are
+    validated as a real, moddable FF9 install (which also skips the un-moddable Microsoft Store build).
+    Raises ConfigError with actionable guidance if nothing resolves.
     """
-    candidates: list[Path] = []
-    if explicit:
-        candidates.append(Path(explicit))
-    env = os.environ.get("FF9_GAME_PATH")
-    if env:
-        candidates.append(Path(env))
-    cfg = _read_user_config().get("game_path")
-    if cfg:
-        candidates.append(Path(cfg))
-    candidates.extend(Path(p) for p in _COMMON_STEAM_PATHS)
-
-    for c in candidates:
+    # 1) user-specified -- trusted on existence
+    for c in (Path(p) for p in (explicit, os.environ.get("FF9_GAME_PATH"),
+                                _read_user_config().get("game_path")) if p):
         if c.is_dir():
             return c.resolve()
 
+    # 2) auto-detect Steam + GOG, validated as a real install; de-dupe by resolved path
+    seen: set[Path] = set()
+    for c in _registry_candidates() + _steam_library_candidates() + _fallback_candidates():
+        try:
+            rc = c.resolve()
+        except OSError:
+            continue
+        if rc in seen:
+            continue
+        seen.add(rc)
+        if _is_ff9_root(c):
+            return rc
+
     raise ConfigError(
-        "Could not locate the Final Fantasy IX install folder.\n"
+        "Could not locate the Final Fantasy IX install folder (checked Steam + GOG via the registry,\n"
+        "the Steam libraries, and the common install paths).\n"
         "Set it one of these ways:\n"
         "  - pass --game \"<path>\" on the command line\n"
         "  - export FF9_GAME_PATH=\"<path>\"\n"
         f"  - add  game_path = \"<path>\"  to {USER_CONFIG}\n"
-        "The folder should contain FF9_Launcher.exe and a StreamingAssets directory."
+        "The folder should contain FF9_Launcher.exe and a StreamingAssets directory.\n"
+        "(The Microsoft Store / Xbox Game Pass version is not moddable -- use the Steam or GOG release.)"
     )
 
 

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/ff9mapkit/extract.py

@@ -1829,6 +1829,16 @@ def write_native_project(field: str, out_dir, *, name: str | None = None, field_
     wb = meta["walkmesh_bounds"]
     x, z = meta["player_start"]
     scroll = "[camera.scroll]\nenabled = true\n" if meta["scrolling"] else ""
+    # The donor's REAL field id (FBG -> id): a fork MIRRORS this field's geometry, so deploy auto-emits the
+    # ForkDonorPatch `<forkId> <donorId>` -> the engine's name-keyed fidelity (s31 occlusion z-offset,
+    # FieldLocationName) resolves for the custom id. Recorded as `[verbatim_eb] donor` (verbatim) OR
+    # `[field] source_field` (native/synth) -- both read by build._verbatim_donor_id + emitted by deploy_field.
+    from .dialogue import _resolve_field_id as _rfi
+    try:
+        _src_fid = _rfi(field)
+    except (FileNotFoundError, ValueError):
+        _src_fid = None
+    source_field_line = ""
     if verbatim:
         # VERBATIM .eb fork (docs/FORK_FIDELITY.md, the entry-0 carry): ship the donor's WHOLE event script;
         # the build runs the real logic instead of synthesizing. No declarative content (it's all in the .eb).
@@ -1845,11 +1855,7 @@ def write_native_project(field: str, out_dir, *, name: str | None = None, field_
         # Donor battle BGM: a verbatim fork carries the real Battle()/BattleEx() ops, but its custom id misses
         # the engine's (fldMapNo, scene) song lookup -> the boss/special theme is lost. Auto-emit [[battle_bgm]]
         # for the donor's scripted battle scenes whose song is non-zero (build -> a scene-keyed Music: line).
-        from .dialogue import _resolve_field_id
-        try:
-            _donor_fid = _resolve_field_id(field)
-        except (FileNotFoundError, ValueError):
-            _donor_fid = None
+        _donor_fid = _src_fid
         bgm_pairs = _donor_battle_bgm_pairs(donor_eb, _donor_fid, game)
         bgm_blocks = _render_battle_bgm_blocks(bgm_pairs)
         # retarget the Field() exits: import-chain pre-fills a LIVE table (doors warp into the chain's own
@@ -1894,6 +1900,9 @@ def write_native_project(field: str, out_dir, *, name: str | None = None, field_
             field, game, out_dir=out, name=name, id_remap=id_remap, live_seams=live_seams,
             graft_player_funcs=graft_player_funcs, carry_text=carry_text, graft_savepoint=graft_savepoint)
         meta["imported_content"] = content_summary
+        if _src_fid is not None and _src_fid != field_id:        # record the donor -> deploy auto-emits ForkDonorPatch
+            source_field_line = (f"source_field = {_src_fid}   # the real field this NATIVE fork mirrors; deploy "
+                                 f"emits ForkDonorPatch so name-keyed fidelity (occlusion/location) resolves\n")
         control_line = (f"control_direction = {control_dir}   # imported WASD-vs-camera tuning\n"
                         if control_dir is not None else "")
         content_tail = (
@@ -1913,6 +1922,7 @@ def write_native_project(field: str, out_dir, *, name: str | None = None, field_
         f'name = "{name}"\n'
         f"area = {safe_area}\n"
         f"text_block = {text_block}\n"
+        f"{source_field_line}"
         f"{_walkmesh_hotfix_line(field)}"
         f"{_area_title_hide_lines(meta, verbatim=verbatim)}"
         f'bgs = "scene.bgs.bytes"   # NATIVE scene (per-tile depth) -> seamless render, NO .bgx / no tile seams\n'

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/ff9mapkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ff9mapkit
-Version: 1.0.0b4
+Version: 1.0.0b5
 Summary: Author novel custom field maps for Final Fantasy IX (Memoria engine) from a declarative TOML project file.
 Author: GameJawnsInc
 License-Expression: MIT

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ff9mapkit"
-version = "1.0.0b4"
+version = "1.0.0b5"
 description = "Author novel custom field maps for Final Fantasy IX (Memoria engine) from a declarative TOML project file."
 readme = "README.md"
 requires-python = ">=3.11"          # tomllib is stdlib from 3.11

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/tests/test_ate.py

@@ -369,3 +369,20 @@ def _w(tmp_path, toml):
     p = tmp_path / "ok.field.toml"
     p.write_text(toml, encoding="utf-8")
     return p
+
+
+def test_legacy_cutscene_ate_is_deprecated(tmp_path):
+    """`[cutscene] ate = true` (the OLD held-banner model) now lint-warns toward the faithful `[[gateway]] ate`
+    warp-in trigger -- it still builds (a warning, not an error)."""
+    from ff9mapkit.build import FieldProject, lint_logic, validate
+    base = ('[field]\nid = 4003\nname = "D"\narea = 11\ntext_block = 1073\n\n'
+            '[camera]\npitch = 45\nfov = 42.2\n\n'
+            '[walkmesh]\nquad = [[-200,-200],[200,-200],[200,200],[-200,200]]\n\n'
+            '[player]\nspawn = [0, 0]\n\n')
+    p = tmp_path / "d.field.toml"
+    p.write_text(base + '[cutscene]\nate = true\nsteps = [ { say = "An ATE." } ]\n', encoding="utf-8")
+    proj = FieldProject.load(p)
+    assert any("held-banner" in w and "[[gateway]] ate" in w for w in lint_logic(proj))
+    assert validate(proj) == []                                # deprecated, but still valid (warning, not error)
+    p.write_text(base + '[cutscene]\nsteps = [ { say = "Hi." } ]\n', encoding="utf-8")   # no ate -> no warning
+    assert not any("held-banner" in w for w in lint_logic(FieldProject.load(p)))

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/tests/test_setup.py

@@ -132,3 +132,44 @@ def test_install_engine_refuses_without_memoria(tmp_path):
 def test_bundle_missing_dll_raises(tmp_path):
     with pytest.raises(ValueError):
         memoria.bundle_dll_members(_make_bundle(tmp_path, complete=False))
+
+
+# ---- game-install detection (Steam + GOG; rejects MS Store) ----------------------------------------
+def _make_ff9_root(tmp_path, *, launcher=True, streaming=True, managed=True):
+    root = tmp_path / "FINAL FANTASY IX"
+    root.mkdir(parents=True, exist_ok=True)
+    if launcher:
+        (root / "FF9_Launcher.exe").write_bytes(b"")
+    if streaming:
+        (root / "StreamingAssets").mkdir(exist_ok=True)
+    if managed:
+        (root / "x64" / "FF9_Data" / "Managed").mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def test_is_ff9_root_accepts_real_layout(tmp_path):
+    assert config._is_ff9_root(_make_ff9_root(tmp_path)) is True
+
+
+def test_is_ff9_root_rejects_incomplete(tmp_path):
+    assert config._is_ff9_root(_make_ff9_root(tmp_path / "a", launcher=False)) is False   # MS Store-like
+    assert config._is_ff9_root(_make_ff9_root(tmp_path / "b", streaming=False)) is False
+    assert config._is_ff9_root(_make_ff9_root(tmp_path / "c", managed=False)) is False
+    assert config._is_ff9_root(tmp_path / "nope") is False
+
+
+def test_parse_vdf_new_schema():
+    text = (
+        '"libraryfolders"\n{\n'
+        '    "0"\n    {\n'
+        '        "path"    "C:\\\\Program Files (x86)\\\\Steam"\n'
+        '        "apps" { "377840" "12345678" }\n'      # appid->buildid must NOT be read as a library
+        '    }\n'
+        '    "1"\n    {\n        "path"    "E:\\\\SteamLibrary"\n    }\n}\n'
+    )
+    assert config._parse_vdf_library_paths(text) == [r"C:\Program Files (x86)\Steam", r"E:\SteamLibrary"]
+
+
+def test_parse_vdf_old_schema():
+    text = '"LibraryFolders"\n{\n    "1"   "E:\\\\Games\\\\Steam"\n    "2"   "F:\\\\Steam"\n}\n'
+    assert config._parse_vdf_library_paths(text) == [r"E:\Games\Steam", r"F:\Steam"]

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b5}/tests/test_verbatim.py

@@ -90,6 +90,21 @@ def test_remap_fields_patches_destinations():
     assert _vb.remap_fields(eb, {}) == eb
 
 
+def test_fork_donor_id_reads_native_source_field():
+    """deploy_field auto-emits ForkDonorPatch for NATIVE/SYNTH forks too: build._verbatim_donor_id resolves the
+    donor from `[field] source_field` (the native import's record), not only `[verbatim_eb] donor`."""
+    from ff9mapkit.build import _verbatim_donor_id
+
+    class _P:
+        def __init__(self, raw):
+            self.raw = raw
+
+    assert _verbatim_donor_id(_P({"field": {"source_field": 351}})) == 351   # native fork
+    assert _verbatim_donor_id(_P({"verbatim_eb": {"donor": 1860}})) == 1860  # verbatim fork (unchanged)
+    assert _verbatim_donor_id(_P({"field": {"borrow_field": 100}})) == 100   # BG-borrow form
+    assert _verbatim_donor_id(_P({"field": {}})) is None                     # a non-fork synth field -> no emit
+
+
 def _game_ready():
     try:
         import UnityPy  # noqa: F401,PLC0415
@@ -136,6 +151,22 @@ def test_import_verbatim_ships_the_whole_donor_eb(tmp_path):
     assert 4100 in _fields(shipped) and exits[0] not in _fields(shipped)
 
 
+@pytest.mark.skipif(not _game_ready(), reason="needs the FF9 install + UnityPy")
+def test_native_import_records_donor_for_forkdonorpatch(tmp_path):
+    # A NATIVE (non-verbatim) import now records `[field] source_field = <donor real id>`, so deploy_field can
+    # auto-emit ForkDonorPatch (name-keyed occlusion/location fidelity) -- no more hand-written `<fork> <donor>`.
+    from ff9mapkit import extract
+    from ff9mapkit.build import FieldProject, _verbatim_donor_id
+    from ff9mapkit.dialogue import _resolve_field_id
+    fbg = "fbg_n06_vgdl_map101_dl_inn_0"
+    donor = _resolve_field_id(fbg)
+    _m, toml = extract.write_native_project(fbg, tmp_path, name="DV")    # native scene, NOT verbatim
+    proj = FieldProject.load(toml)
+    assert "verbatim_eb" not in proj.raw                                 # it's a native fork
+    assert proj.raw["field"].get("source_field") == donor               # donor recorded in [field]
+    assert _verbatim_donor_id(proj) == donor                            # -> deploy_field emits ForkDonorPatch
+
+
 @pytest.mark.skipif(not _game_ready(), reason="needs the FF9 install + UnityPy")
 def test_build_field_verbatim_with_logic_edit_end_to_end(tmp_path):
     # REGRESSION: a FULL build of a verbatim fork must run build_field's per-language loop (which reads
@@ -374,6 +405,34 @@ def test_build_field_verbatim_player_walk_end_to_end(tmp_path):
         assert (2, 250, 20) in calls                                # conductor RunScriptSync(2, player=250, 20)
 
 
+@pytest.mark.skipif(not _game_ready(), reason="needs the FF9 install + UnityPy")
+def test_build_field_verbatim_conductor_exit_warp_end_to_end(tmp_path):
+    # A conductor on a verbatim fork with `exit_warp`: the below-band director ENDS with a fade + Field(target)
+    # (the warp-back) instead of EnableMove -- the player is warped out after the scene (the same lever the
+    # forced-ATE scene uses to return the player). exit_warp sits OUTSIDE the once-gate so it always fires.
+    from ff9mapkit import build, extract
+    from ff9mapkit.eb import EbScript
+    from ff9mapkit.content import object as _object
+    _meta, toml = extract.write_native_project("fbg_n06_vgdl_map101_dl_inn_0", tmp_path, name="DV", verbatim=True)
+    donor = EbScript.from_bytes(extract.extract_event_script("fbg_n06_vgdl_map101_dl_inn_0"))
+    project = build.FieldProject.load(toml)
+    project.raw["npc"] = [{"name": "lefty", "preset": "vivi", "pos": [100, 200], "dialogue": "."}]
+    project.raw["cutscene"] = {"once": True, "actor": ["lefty"], "exit_warp": 1153,
+                               "steps": [{"actor": "lefty", "say": "The scene ends -- and out you go."}]}
+    assert build.validate(project) == []
+    out = tmp_path / "mod"
+    build.build_mod([project], out, mod_name="FF9CustomMap")         # must not raise
+    band_lo = donor.entry_count - _object.PARTY_BAND_SIZE            # lefty=band_lo, conductor=band_lo+1
+    ebs = [p for p in out.rglob("*.eb.bytes")]
+    assert ebs
+    for p in ebs:
+        s = EbScript.from_bytes(p.read_bytes())
+        cond = s.entry(band_lo + 1).func_by_tag(0)
+        ops = [i.op for i in s.instrs(cond)]
+        assert 1153 in [i.imm(0) for i in s.instrs(cond) if i.op == 0x2B]   # ends with Field(exit_warp) -- the warp-back
+        assert 0x2E not in ops                                      # NO EnableMove (the destination restores control)
+
+
 @pytest.mark.skipif(not _game_ready(), reason="needs the FF9 install + UnityPy")
 def test_build_field_verbatim_with_readable_prop_end_to_end(tmp_path):
     # A readable [[prop]] (dialogue=) ADDED to a verbatim fork: the below-band prop object is NON-bare -- it