ff9mapkit 1.0.0b4__tar.gz → 1.0.0b6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ff9mapkit
-Version: 1.0.0b4
+Version: 1.0.0b6
 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.0b6}/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.0b6"   # keep in lockstep with [project] version in pyproject.toml

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b6}/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.0b6}/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.0b6}/ff9mapkit/editor/jobs.py

@@ -80,6 +80,13 @@ def detect_deploy_target(repo_root):
     return mod, fid
 
 
+def has_deploy_tools(repo_root) -> bool:
+    """True if the deploy SCRIPTS (``tools/deploy_field.py`` etc.) are present -- i.e. this is a repo checkout,
+    not an installed wheel (the wheel ships no ``tools/``). The Workspace uses it to hide the dev-only deploy
+    paths (test-slot / campaign / journey / battle / reverts) for an installed copy."""
+    return (Path(repo_root) / "tools" / "deploy_field.py").is_file()
+
+
 def detect_deployed_fields(mod_folder):
     """``[(id, name), ...]`` of the FieldScene lines in the worktree mod folder's DictionaryPatch -- the
     fields whose encounter a battle-mint can repoint (the valid 'trigger field' choices)."""

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b6}/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.0b6}/ff9mapkit/workspace/builddoc.py

@@ -32,6 +32,10 @@ class BuildDoc(QWidget):
         self.pal = pal
         self.repo = Path(repo_root)
         self.kit = self.repo / "ff9mapkit"             # `-m ff9mapkit build` cwd (local pkg shadows)
+        self.kit_cwd = self.kit if self.kit.is_dir() else None   # None -> run_job falls back to KIT (always valid)
+        # A repo checkout has the deploy scripts at <repo>/tools/; an installed copy (pip/uv/.exe) does NOT,
+        # so the test-slot / campaign / journey DEPLOYS (+ the F6 loop) are unavailable there. `build` works either way.
+        self.has_tools = jobs.has_deploy_tools(self.repo)
         self._run = run
         self._problems = problems
         self.kind = "field"
@@ -102,7 +106,7 @@ class BuildDoc(QWidget):
         tid = self.worktree_id or 4003
         self.rb_test = QRadioButton(f"Test slot {tid} — quick + reversible; play via F6 → Warp"
                                     + ("  (or New Game → hut door)" if tid == 4003 else ""))
-        self.rb_test.setChecked(True)
+        self.rb_test.setChecked(self.has_tools)        # installed copy: no F6 dev engine -> default to Install to game
         self.rb_game = QRadioButton(f"Install to game (shipping mod folder): {self.game_mod}"
                                     if self.game_mod else "Install to game — (game install not found)")
         if not self.game_mod:
@@ -126,6 +130,10 @@ class BuildDoc(QWidget):
         self.dest.setWordWrap(True)
         self.dest.setStyleSheet(f"color:{self.pal['accent']};")
         gv.addWidget(self.dest)
+        if not self.has_tools:                         # installed: no test-slot/F6 -> default to Install to game / Build only
+            self.rb_test.setEnabled(False)
+            self.rb_test.setText(self.rb_test.text() + "   (dev repo only)")
+            (self.rb_game if self.game_mod else self.rb_other).setChecked(True)  # safe now: self.dest exists
         self.field_box = box
         return box
 
@@ -375,6 +383,21 @@ class BuildDoc(QWidget):
     def _info(self, title, text):
         QMessageBox.information(self, title, text)
 
+    def _require_tools(self, what):
+        """Installed (non-repo) copies don't ship the deploy SCRIPTS (tools/). Show a clear, actionable
+        message instead of a cryptic 'no such file' and return False; True when the repo tools are present."""
+        if self.has_tools:
+            return True
+        self._warn(
+            f"{what} needs the source repo",
+            f"'{what}' runs ff9mapkit's development deploy scripts (the repo's tools/), which aren't part of "
+            "an installed copy.\n\n"
+            "To get a custom field into your game from an installed ff9mapkit:\n"
+            "  - use  Build to -> 'Install to game'  (it writes the mod into your FF9 folder; Memoria detects\n"
+            "    it automatically), then reach it via a [[gateway]] from an early field or by wiring New Game.\n\n"
+            "(The test-slot + F6 loop and reversible campaign/journey deploys are a dev-repo workflow.)")
+        return False
+
     def _picked(self):
         f = self.path.text().strip().strip('"')
         if not f or not Path(f).is_file():
@@ -463,6 +486,8 @@ class BuildDoc(QWidget):
 
     def _go_field(self, field):
         if self.rb_test.isChecked():
+            if not self._require_tools("Deploy to test slot"):
+                return
             tid = self.worktree_id or 4003
             reach = ("New Game → walk to the hut door (or F6 → Warp)" if tid == 4003
                      else f"F6 → Warp to field {tid}")
@@ -477,20 +502,22 @@ class BuildDoc(QWidget):
             if self._confirm("Install to game",
                              f"Build this field into the game mod folder?\n\n{self.game_mod}\n\n"
                              "Writes the field at its real id (may overwrite a field with the same id)."):
-                self._stream(jobs.build_argv(field, str(self.game_mod)), cwd=self.kit,
+                self._stream(jobs.build_argv(field, str(self.game_mod)), cwd=self.kit_cwd,
                              subject="Install to game", ok_headline=f"Built into {self.game_mod}")
         else:
             out = self.other.text().strip()
             if not out:
                 return self._warn("No folder", "Pick an output folder.")
-            self._stream(jobs.build_argv(field, out), cwd=self.kit, subject="Build",
+            self._stream(jobs.build_argv(field, out), cwd=self.kit_cwd, subject="Build",
                          ok_headline=f"Built into {out}")
 
     def _go_campaign(self, path):
         if self.rb_camp_build.isChecked():
-            self._stream(jobs.build_campaign_argv(path), cwd=self.kit, subject="Build campaign",
+            self._stream(jobs.build_campaign_argv(path), cwd=self.kit_cwd, subject="Build campaign",
                          ok_headline=f"Built campaign {self.plan.name}")
             return
+        if not self._require_tools("Deploy campaign"):
+            return
         wire = self.wire_newgame.isChecked()
         route = ("It also wires New Game to enter the chain (experimental)." if wire
                  else "Reach each screen in-game via F6 → Warp.")
@@ -505,6 +532,8 @@ class BuildDoc(QWidget):
                          ok_next=f"Relaunch once (new DictionaryPatch), then F6 → Warp → {entry} to walk the chain.")
 
     def _go_journey(self, path):
+        if not self._require_tools("Deploy journey"):
+            return
         if self.rb_jour_preview.isChecked():           # dry-run: print the playbook, no game writes -> no confirm
             self._stream(jobs.deploy_journey_argv(self.repo, path), cwd=self.repo,
                          subject="Journey deploy playbook (dry-run)",
@@ -550,6 +579,8 @@ class BuildDoc(QWidget):
                          ok_next=stackmsg)
 
     def _go_battle(self, battle):
+        if not self._require_tools("Deploy battle map"):
+            return
         trig = self.trigger.text().strip()
         if trig and not trig.isdigit():
             return self._warn("Bad trigger field", "Trigger field must be a field id number (or blank).")
@@ -566,6 +597,8 @@ class BuildDoc(QWidget):
 
     # ------------------------------------------------------------------ New Game entry (hub-less)
     def on_set_newgame(self):
+        if not self._require_tools("Set New Game entry"):
+            return
         fid = self.newgame_id.text().strip()
         if not fid.isdigit():
             return self._warn("Bad field id", "Enter the numeric field id New Game should land on "
@@ -580,6 +613,8 @@ class BuildDoc(QWidget):
                          ok_next="Relaunch the game, then New Game. Undo with 'Revert New Game'.")
 
     def on_revert_newgame(self):
+        if not self._require_tools("Revert New Game"):
+            return
         argv = jobs.revert_newgame_argv(self.repo)            # most-recent New-Game revert (from-stock OR retarget)
         if argv is None or not Path(argv[-1]).exists():
             return self._info("Nothing to revert", "No New-Game change to undo yet.")
@@ -590,6 +625,8 @@ class BuildDoc(QWidget):
 
     # ------------------------------------------------------------------ Revert
     def on_revert(self):
+        if not self._require_tools("Revert"):
+            return
         if self.kind == "battle":
             argv, what = jobs.revert_battle_argv(self.repo), "battle"
         elif self.kind == "campaign":

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b6}/ff9mapkit/workspace/importdoc.py

@@ -30,6 +30,10 @@ class ImportDoc(QWidget):
         super().__init__()
         self.pal = pal
         self.kit = Path(kit_root)                      # `-m ff9mapkit` cwd (this worktree's package)
+        # Default output base: the repo parent for a checkout; an installed copy's package dir is inside a
+        # venv, so write forked projects to a discoverable user folder instead (not buried in site-packages).
+        self.proj_base = (self.kit.parent if (self.kit / "pyproject.toml").is_file()
+                          else Path.home() / "Dream World IX")
         self._run = run
         self._on_forked = on_forked                    # called with the output DIR on a clean fork -> shell opens it
         # The tab body SCROLLS: this view stacks five tall group boxes, so a short window would otherwise
@@ -152,7 +156,7 @@ class ImportDoc(QWidget):
 
         out = QHBoxLayout()
         out.addWidget(QLabel("Write to:"))
-        self.out = QLineEdit(str(self.kit.parent / "imported"))
+        self.out = QLineEdit(str(self.proj_base / "imported"))
         browse = QPushButton("Browse…")
         browse.clicked.connect(self.browse_out)
         out.addWidget(self.out, 1)
@@ -269,7 +273,7 @@ class ImportDoc(QWidget):
         v.addWidget(swap_hint)
         out = QHBoxLayout()
         out.addWidget(QLabel("Write campaign to:"))
-        self.rg_out = QLineEdit(str(self.kit.parent / "campaign"))
+        self.rg_out = QLineEdit(str(self.proj_base / "campaign"))
         rbrowse = QPushButton("Browse…")
         rbrowse.clicked.connect(self.browse_region_out)
         out.addWidget(self.rg_out, 1)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ff9mapkit
-Version: 1.0.0b4
+Version: 1.0.0b6
 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.0b6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ff9mapkit"
-version = "1.0.0b4"
+version = "1.0.0b6"
 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.0b6}/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.0b6}/tests/test_setup.py

@@ -132,3 +132,53 @@ 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"]
+
+
+# ---- installed vs repo: the GUI deploy-tools gate (PySide6-free; the Qt shell is covered by --smoke) ----
+def test_has_deploy_tools(tmp_path):
+    from ff9mapkit.editor import jobs
+    assert jobs.has_deploy_tools(tmp_path) is False              # installed-like: no tools/ in the wheel
+    (tmp_path / "tools").mkdir()
+    (tmp_path / "tools" / "deploy_field.py").write_text("", encoding="utf-8")
+    assert jobs.has_deploy_tools(tmp_path) is True               # repo checkout

{ff9mapkit-1.0.0b4 → ff9mapkit-1.0.0b6}/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