meltygui 0.1.2__py3-none-any.whl → 0.1.8__py3-none-any.whl

meltygui/__init__.py

@@ -22,6 +22,7 @@ from meltygui.core.styling.style import default_tint_accumulation
 from meltygui.core.styling.style import default_scalar_accumulation
 
 from meltygui.core.runtime.app import boot
+from meltygui.core.runtime.app import embedded_imports
 from meltygui.core.runtime.app import glfw_window
 from meltygui.core.runtime.app import run
 from meltygui.core.runtime.app import pressed
@@ -29,68 +30,31 @@ from meltygui.core.runtime.app import content_size
 from meltygui.core.runtime.app import mark
 from meltygui.core.runtime.app import persisted
 from meltygui.core.runtime.app import after_first_frame
+from meltygui.core.runtime.app import checkpoint
 
 if TYPE_CHECKING:   # IDE / type checkers only; never executed
+    import meltygui_imgui as imgui
+    from meltygui.core.rendering.gui_prototype import gui, os_window
     from meltygui.state.new_core_model import DrawState
-    from meltygui.view.text_view import draw_text
     from meltygui.model.tile_model import multi_instance
     from meltygui.view.chat_view import draw_claude_chat
-    from meltygui.view.texture_view import draw_texture
     from meltygui.core.rendering.render_dispatch import draw_any
-    from meltygui.view.control_view import draw_button
-    from meltygui.view.control_view import draw_str
-    from meltygui.view.control_view import draw_float
-    from meltygui.view.control_view import draw_int
-    from meltygui.view.control_view import draw_int_slider
-    from meltygui.view.control_view import draw_enum
-    from meltygui.view.dropdown_view import draw_dropdown
-    from meltygui.view.inspection_view import draw_view_func_selector
-    from meltygui.view.color_view import draw_color_picker
-    from meltygui.view.collection_view import draw_collection_as_tabs
-    from meltygui.view.layout_view import draw_columns
-    from meltygui.view.layout_view import draw_rows
     from meltygui.view.menu_view import draw_menu_bar
-    from meltygui.view.file_view import draw_file_selector
-    from meltygui.view.file_view import draw_fast_file_explorer
-    from meltygui.view.file_view import draw_shortcuts
     from meltygui.view.file_view import draw_breadcrumbs
-    from meltygui.core.files.file_core import draw_folder_files
-    from meltygui.view.terminal_view import draw_terminal
 
-_NCV = 'meltygui.core.rendering.render_dispatch'
-_VIEWS = {
+# Non-render helpers keep explicit locations; @render_func views are discovered.
+_LAZY_EXPORTS = {
+    'columns': ('meltygui.core.rendering.gui_layout_prototype', 'columns'),
+    'rows': ('meltygui.core.rendering.gui_layout_prototype', 'rows'),
+    'gui': ('meltygui.core.rendering.gui_prototype', 'gui'),
+    'os_window': ('meltygui.core.rendering.gui_prototype', 'os_window'),
     'DrawState': ('meltygui.state.new_core_model', 'DrawState'),
-    'draw_voxels': ('meltygui.view.voxel_view', 'draw_voxels'),
-    'draw_voxels_opengl': ('meltygui.view.voxel_view', 'draw_voxels_opengl'),
-    'draw_voxels_cuda': ('meltygui.view.voxel_view', 'draw_voxels_cuda'),
-    'draw_tensor_slices': ('meltygui.view.tensor_view', 'draw_tensor_slices'),
-    'draw_tensor_error': ('meltygui.view.tensor_view', 'draw_tensor_error'),
-    'draw_line_graph': ('meltygui.view.graph_view', 'draw_line_graph'),
     'render_func': ('meltygui.core.core_render', 'render_func'),
     'multi_instance': ('meltygui.model.tile_model', 'multi_instance'),
     'draw_claude_chat': ('meltygui.view.chat_view', 'draw_claude_chat'),
-    'draw_text': ('meltygui.view.text_view', 'draw_text'),
-    'draw_texture': ('meltygui.view.texture_view', 'draw_texture'),
-    'draw_any': (_NCV, 'draw_any'),
-    'draw_button': ('meltygui.view.control_view', 'draw_button'),
-    'draw_str': ('meltygui.view.control_view', 'draw_str'),
-    'draw_float': ('meltygui.view.control_view', 'draw_float'),
-    'draw_int': ('meltygui.view.control_view', 'draw_int'),
-    'draw_int_slider': ('meltygui.view.control_view', 'draw_int_slider'),
-    'draw_enum': ('meltygui.view.control_view', 'draw_enum'),
-    'draw_dropdown': ('meltygui.view.dropdown_view', 'draw_dropdown'),
-    'draw_view_func_selector': ('meltygui.view.inspection_view', 'draw_view_func_selector'),
-    'draw_color_picker': ('meltygui.view.color_view', 'draw_color_picker'),
-    'draw_collection_as_tabs': ('meltygui.view.collection_view', 'draw_collection_as_tabs'),
-    'draw_columns': ('meltygui.view.layout_view', 'draw_columns'),
-    'draw_rows': ('meltygui.view.layout_view', 'draw_rows'),
+    'draw_any': ('meltygui.core.rendering.render_dispatch', 'draw_any'),
     'draw_menu_bar': ('meltygui.view.menu_view', 'draw_menu_bar'),
-    'draw_file_selector': ('meltygui.view.file_view', 'draw_file_selector'),
-    'draw_fast_file_explorer': ('meltygui.view.file_view', 'draw_fast_file_explorer'),
-    'draw_shortcuts': ('meltygui.view.file_view', 'draw_shortcuts'),
     'draw_breadcrumbs': ('meltygui.view.file_view', 'draw_breadcrumbs'),
-    'draw_folder_files': ('meltygui.core.files.file_core', 'draw_folder_files'),
-    'draw_terminal': ('meltygui.view.terminal_view', 'draw_terminal'),
 }
 
 
@@ -104,7 +68,13 @@ def __getattr__(name):
     if name == 'window_api':
         import meltygui.core.windowing.window_api as window_api
         return window_api
-    spec = _VIEWS.get(name)
+    if name == '__all__':
+        value = list(dict.fromkeys([*_PUBLIC_NAMES, *_LAZY_EXPORTS, *_render_exports()]))
+        globals()[name] = value
+        return value
+    spec = _LAZY_EXPORTS.get(name)
+    if spec is None:
+        spec = _render_exports().get(name)
     if spec is None:
         raise AttributeError(name)
     import importlib
@@ -115,6 +85,17 @@ def __getattr__(name):
     return value
 
 
-__all__ = ['Style', 'boot', 'glfw_window', 'run', 'pressed', 'content_size', 'mark', 'persisted', 'after_first_frame',
-           'toggles', 'window_api', 'imgui',
-           *_VIEWS]
+_PUBLIC_NAMES = [
+    'Style', 'boot', 'embedded_imports', 'glfw_window', 'run', 'pressed',
+    'content_size', 'mark', 'persisted', 'after_first_frame', 'checkpoint',
+    'toggles', 'window_api', 'imgui',
+]
+
+
+def _render_exports():
+    from meltygui.core.runtime.public_exports import render_exports
+    return render_exports()
+
+
+def __dir__():
+    return sorted(set(globals()) | set(_PUBLIC_NAMES) | set(_LAZY_EXPORTS) | set(_render_exports()))

meltygui/accounts/internet_accounts.py

@@ -353,7 +353,7 @@ class AnthropicKind(AccountKind):
         source = self._source(account)
         if source is None:
             return ("needs_login", "not signed in")
-        return ("ready", f"{source} · verified" if account.get("_validated") else source)
+        return ("ready", f"{source}  verified" if account.get("_validated") else source)
 
     # -- Claude plan usage (through Claude Code's login) ----------------------
     # The plan's rate-limit windows (session, weekly all-models, weekly
@@ -662,7 +662,7 @@ class AnthropicKind(AccountKind):
             same_day = fetched[:3] == time.localtime()[:3]
             stamp = "as of " + time.strftime("%H:%M:%S" if same_day else "%m-%d %H:%M", fetched)
             if account.get("_usage_loading"):
-                stamp += " · refreshing…"
+                stamp += "  refreshing…"
             out.append(("stamp", stamp))
         return out
 
@@ -690,13 +690,13 @@ class AnthropicKind(AccountKind):
             client.models.list(limit=1)
             client.close()
             account["_validated"] = True
-            account["_status"] = ("ready", f"{source} · verified")
+            account["_status"] = ("ready", f"{source}  verified")
         except ImportError:
             account["_status"] = ("error", "anthropic package not installed")
         except Exception as error:
             account["_validated"] = False
             message = getattr(error, "message", None) or str(error)
-            account["_status"] = ("error", f"{source} · {message[:90]}")
+            account["_status"] = ("error", f"{source}  {message[:90]}")
         accounts_changed()
 
     # -- browser sign-in ---------------------------------------------------
@@ -880,7 +880,7 @@ class CodexKind(AccountKind):
             return ("needs_login", "not signed in")
         if identity.get("type") != "chatgpt":
             return ("warning", "ChatGPT sign-in required for plan usage")
-        return ("ready", " · ".join(filter(None, (
+        return ("ready", "  ".join(filter(None, (
             identity.get("email") or "ChatGPT", identity.get("planType")))))
 
     def probe(self, account):
@@ -1025,7 +1025,7 @@ class CodexKind(AccountKind):
             if fetched:
                 stamp = "as of " + time.strftime("%m-%d %H:%M:%S", time.localtime(fetched))
                 if account.get("_usage_loading"):
-                    stamp += " · refreshing…"
+                    stamp += "  refreshing…"
                 out.append(("stamp", stamp))
         out.append(("note", "Shared with Codex desktop / CLI" if account["id"] == "codex"
                     else "Separate Codex account"))
@@ -1136,7 +1136,7 @@ class OllamaKind(AccountKind):
                 models = ollama.list_models(client)
         except Exception as error:
             account["_models"] = []
-            return ("error", f"{host} · {str(error)[:60]}")
+            return ("error", f"{host}  {str(error)[:60]}")
         account["_models"] = models
         try:
             account["_gpus"] = ollama.gpu_inventory()   # best-effort GPU names for the device menu
@@ -1148,10 +1148,10 @@ class OllamaKind(AccountKind):
                            for key in ("coder", "codellama", "starcoder", "codestral", "deepseek-coder"))]
         text = f"{len(models)} models"
         if loaded:
-            text += f" · {len(loaded)} loaded on " + ", ".join(
+            text += f"  {len(loaded)} loaded on " + ", ".join(
                 sorted({model['where'] or '?' for model in loaded}))
         if not fim_like:
-            text += " · no FIM model (pull qwen2.5-coder)"
+            text += "  no FIM model (pull qwen2.5-coder)"
         return ("ready", text)
 
     def actions(self, account):

meltygui/chat/chat_interface.py

@@ -387,7 +387,7 @@ def source_initials(label):
 def source_label(account_id, kind, accounts):
     """A tab's text: the provider, plus the account when the kind has several."""
     if len(accounts.of_kind(kind.name)) > 1:
-        return f'{kind.chat_label} · {accounts[account_id]["label"]}'
+        return f'{kind.chat_label}  {accounts[account_id]["label"]}'
     return kind.chat_label
 
 
@@ -530,10 +530,10 @@ def _draw_image(ref, x, y, max_width, box_height, caption_height, tint, *, name=
             rendered_size = (image_state.width, image_state.height)
             width, height = rendered_size
     elif entry is not None and entry.status == "failed":
-        caption = (caption + " · " if caption else "") + "could not decode: " + str(entry.error)
+        caption = (caption + "  " if caption else "") + "could not decode: " + str(entry.error)
     else:
         draw_list.add_rect_filled(x, y, x + width, y + height, _color(tint, 0.12), rounding=Melty.px(6))
-        caption = (caption + " · " if caption else "") + "decoding…"
+        caption = (caption + "  " if caption else "") + "decoding…"
     _title(caption or ref.label, x, y + height, max_width, caption_height, tint, brightness=0.7, ellipsis=True)
     return rendered_size
 
@@ -560,10 +560,10 @@ def transcript_entries(messages, state, key):
         if len(entries) == 1:
             preview = _message_preview(entries[0][1])
             if preview:
-                summary += " · " + preview
+                summary += "  " + preview
         failures = sum(_message_failed(message) for _, message in entries)
         if failures:
-            summary += f" · {failures} failed"
+            summary += f"  {failures} failed"
         group = Message("actionGroup", details={"label": summary})
         yield identifier, group
         if getattr(state, "action_groups", {}).get(key + ":" + identifier, False):

meltygui/chat/images.py

@@ -224,4 +224,4 @@ def image_label(ref, entry=None):
         parts.append("%d×%d" % entry.size)
         if entry.hdr:
             parts.append(f"HDR, peak {entry.peak_nits:.0f} nits")
-    return " · ".join(parts)
+    return "  ".join(parts)

meltygui/chat/main.py

@@ -30,6 +30,7 @@ The service must remain alive; rebooting or killing the service stops its work.
 import os
 import pathlib
 import socket
+import sys
 import threading
 
 import meltygui
@@ -169,12 +170,16 @@ def main(argv=None):
         parser.error(f'not a directory: {project}')
     state = dict(new_project=str(project) if project else None,
                  default_project=str(pathlib.Path.cwd()))
-    instance = os.environ.get('MELTY_CLAUDE_INSTANCE')
-    socket_path = (pathlib.Path(os.environ.get('XDG_RUNTIME_DIR') or '/tmp')
-                   / f"{APP_ID}-{os.getuid()}{('-' + instance) if instance else ''}.sock")
-    if hand_over_to_running_instance(socket_path):
-        return 0
-    close_instance = serve_instance(socket_path)
+    close_instance = None
+    # iOS owns the app lifecycle; the desktop activation socket under /tmp
+    # is outside the app sandbox and must not be created there.
+    if sys.platform != 'ios':
+        instance = os.environ.get('MELTY_CLAUDE_INSTANCE')
+        socket_path = (pathlib.Path(os.environ.get('XDG_RUNTIME_DIR') or '/tmp')
+                       / f"{APP_ID}-{os.getuid()}{('-' + instance) if instance else ''}.sock")
+        if hand_over_to_running_instance(socket_path):
+            return 0
+        close_instance = serve_instance(socket_path)
     try:
         # Window registration and runtime state belong to this invocation.
         @glfw_window(name='Claude Code', width=1180, height=820, app_id=APP_ID,
@@ -196,7 +201,8 @@ def main(argv=None):
         meltygui.run()
     finally:
         try:
-            close_instance()
+            if close_instance is not None:
+                close_instance()
         finally:
             disconnect_chats()
     return 0

meltygui/code/chain_converters.py

@@ -1320,7 +1320,7 @@ def focus(input_value, path=(), default=None, kind=None, draw_state=None, unique
     else:
         target = None
     base = kind or str(draw_state.name)
-    label = f"{base} · {target}" if target else base
+    label = f"{base}  {target}" if target else base
 
     imgui.same_line()
     imgui.text(label)

meltygui/code/codec_registry.py

@@ -17,7 +17,8 @@ def file_icon_for_path(path):
     # File browsers also work before any editor has initialized the codecs.
     from meltygui.code import new_codecs
 
-    codec = extension_to_codec.get(Path(path).suffix.lower())
+    from meltygui.model.file_location_model import file_path
+    codec = extension_to_codec.get(file_path(path).suffix.lower())
     return codec.icon_for_path(path) if codec is not None else None
 
 
@@ -36,5 +37,6 @@ def file_badge_for_path(path):
     from pathlib import Path
     from meltygui.code import new_codecs
 
-    codec = extension_to_codec.get(Path(path).suffix.lower())
+    from meltygui.model.file_location_model import file_path
+    codec = extension_to_codec.get(file_path(path).suffix.lower())
     return codec.badge_for_path(path) if codec is not None else None

meltygui/code/embedded_jedi.py

@@ -0,0 +1,47 @@
+"""Jedi introspection inside a running app, without process-global path swaps.
+
+Jedi's usual same-process helpers temporarily replace sys.path. Its analysis
+worker then races imports on the render thread and application workers. Source
+lookups can pass their search path directly; compiled modules must use the
+embedded application's actual environment.
+"""
+import importlib
+import sys
+import warnings
+
+from jedi.api.environment import InterpreterEnvironment
+from jedi.inference.compiled import access
+from jedi.inference.compiled.subprocess import InferenceStateSameProcess, functions
+
+
+class EmbeddedProcess(InferenceStateSameProcess):
+    def get_module_info(self, sys_path=None, full_name=None, **kwargs):
+        if kwargs.get('path') is None and sys_path is not None:
+            kwargs['path'] = sys_path
+            # Jedi's namespace-package result normally gets this from a global
+            # lookup. Passing an explicit root path must retain that name.
+            full_name = full_name or kwargs['string']
+        try:
+            return functions._find_module(full_name=full_name, **kwargs)
+        except ImportError:
+            return None, None
+
+    def load_module(self, dotted_name, sys_path):
+        # Project-specific Python sources are resolved statically above. Native
+        # introspection uses this interpreter's modules, never another venv's
+        # binaries or a temporary replacement of the application's sys.path.
+        try:
+            module = importlib.import_module(dotted_name)
+        except Exception:
+            warnings.warn(f'Module {dotted_name} is not importable in the embedded app.',
+                          stacklevel=2)
+            return None
+        return access.create_access_path(self._inference_state_weakref(), module)
+
+
+class EmbeddedEnvironment(InterpreterEnvironment):
+    def get_inference_state_subprocess(self, inference_state):
+        return EmbeddedProcess(inference_state)
+
+    def get_sys_path(self):
+        return list(sys.path)

meltygui/code/fileref.py

@@ -66,6 +66,9 @@ def add_editable_root(path) -> Path | None:
     or the PROJECT ROOT of a file `path` (see project_root_of). Idempotent;
     a library install (site-packages, a venv) is never registered. Returns
     the root registered, or None when refused."""
+    from meltygui.model.file_location_model import is_remote
+    if is_remote(path):
+        return None
     try:
         p = Path(path).expanduser().resolve()
     except (OSError, ValueError):
@@ -122,7 +125,7 @@ def is_editable_source(source_file) -> bool:
     except (OSError, ValueError):
         return False
     ok = True
-    if {"site-packages", "dist-packages"} & set(p.parts):
+    if _ios_bundle_source(p) or {"site-packages", "dist-packages"} & set(p.parts):
         ok = False
     else:
         ok = any(p.is_relative_to(root) for root in _EDITABLE_ROOTS)
@@ -136,6 +139,12 @@ _LIBRARY_PARTS = frozenset({"site-packages", "dist-packages", "venv", ".venv",
                             "node_modules"})
 
 
+def _ios_bundle_source(path: Path) -> bool:
+    # Signed iOS bundles can report writable POSIX modes/access(), while the
+    # sandbox rejects writes. This includes app source registered as a project.
+    return sys.platform == "ios" and any(part.endswith(".app") for part in path.parts)
+
+
 def writable_file_refusal(path) -> str | None:
     """Why the PLAIN-FILE codecs (TextFileCodec and friends) will not edit
     `path` — a short human reason — or None when they will.
@@ -150,10 +159,16 @@ def writable_file_refusal(path) -> str | None:
     gate exists to prevent. (It used to require $HOME instead of write
     permission, and a refused file showed as a tab that never loaded.)
     A path that does not exist yet is judged by its directory."""
+    from meltygui.model.file_location_model import file_path, is_remote
+    if is_remote(path):
+        hit = _LIBRARY_PARTS & set(file_path(path).parts)
+        return f'inside a library install ({sorted(hit)[0]}/)' if hit else None
     try:
         p = Path(path).resolve()
     except (OSError, ValueError) as e:
         return f"path cannot be resolved ({e})"
+    if _ios_bundle_source(p):
+        return "inside a read-only iOS app bundle"
     hit = _LIBRARY_PARTS & set(p.parts)
     if hit:
         return f"inside a library install ({sorted(hit)[0]}/)"
@@ -198,7 +213,8 @@ class Address:
     end = None
 
     def __init__(self, path, start=None, end=None, source=None, watcher_ds=None):
-        self.path = Path(path).resolve()
+        from meltygui.model.file_location_model import file_path
+        self.path = file_path(path).resolve()
         self.start = start
         self.end = end
         self.source = source

meltygui/code/libcst_conversion.py

@@ -558,11 +558,12 @@ _xref_cache: dict[_Path, tuple[float, dict[str, list[UsageRef]]]] = {}
 
 DISABLE_JEDI = False
 
-# ── Jedi subprocess pool ──────────────────────────────────────
-# Runs jedi in a child process so CPU-intensive parso parsing
-# doesn't hold the main process GIL.
+# ── Jedi workers ──────────────────────────────────────────────
+# Desktop analysis runs in child processes to avoid the render thread's GIL.
+# iOS uses one thread in the embedded interpreter: processes are unavailable,
+# and concurrent Jedi jobs must not race its shared parser/inference caches.
 
-from concurrent.futures import ProcessPoolExecutor as _PPE
+from concurrent.futures import Executor as _Executor
 from concurrent.futures import Future as _Future
 
 # Two pools, same forkserver context. "index" (4 workers) runs the heavy
@@ -572,7 +573,7 @@ from concurrent.futures import Future as _Future
 # every interactive job lands on the SAME worker process, so parso's per-process
 # parse cache stays warm for the file being edited (~10-30ms per completion vs
 # ~1s re-parsing cold on whichever index worker happened to be idle).
-_jedi_pools: dict[str, _PPE] = {}
+_jedi_pools: dict[str, _Executor] = {}
 _jedi_pool_lock = threading.Lock()
 _jedi_mp_ctx = None
 
@@ -595,6 +596,8 @@ def _get_jedi_mp_ctx():
     COW-share that ~0.4 GB base instead of each re-importing it. Built once and cached:
     the server persists across restarts, so rebuilt pools fork from the same clean base."""
     global _jedi_mp_ctx
+    if sys.platform == 'ios':
+        raise RuntimeError('iOS Jedi analysis uses the embedded interpreter, not multiprocessing')
     if _jedi_mp_ctx is None:
         import multiprocessing as _mp
         if "forkserver" in _mp.get_all_start_methods():
@@ -611,7 +614,15 @@ def _get_jedi_mp_ctx():
     return _jedi_mp_ctx
 
 
-def _get_jedi_pool(kind: str = "index") -> _PPE:
+def _get_jedi_pool(kind: str = "index") -> _Executor:
+    if sys.platform == 'ios':
+        from concurrent.futures import ThreadPoolExecutor
+        with _jedi_pool_lock:
+            pool = _jedi_pools.get('ios')
+            if pool is None or pool._shutdown:
+                pool = ThreadPoolExecutor(max_workers=1, thread_name_prefix='melty-jedi-ios')
+                _jedi_pools['ios'] = pool
+            return pool
     # A studio restart-in-place ends the session, which fires concurrent.futures'
     # atexit (_python_exit) even though THIS process keeps running. That sets the
     # module-level _global_shutdown flag and kills the worker processes, so EVERY
@@ -619,14 +630,15 @@ def _get_jedi_pool(kind: str = "index") -> _PPE:
     # silently disabling jedi + every off-GIL task. Clear that stale signal (the
     # process is not actually exiting) and rebuild BOTH pools.
     import concurrent.futures.process as _cfp
+    from concurrent.futures import ProcessPoolExecutor
     with _jedi_pool_lock:
         if getattr(_cfp, "_global_shutdown", False):
             _cfp._global_shutdown = False
             _jedi_pools.clear()
         pool = _jedi_pools.get(kind)
         if pool is None or getattr(pool, "_shutdown_thread", False):
-            pool = _PPE(max_workers=1 if kind == "ac" else 4,
-                        mp_context=_get_jedi_mp_ctx())
+            pool = ProcessPoolExecutor(max_workers=1 if kind == "ac" else 4,
+                                       mp_context=_get_jedi_mp_ctx())
             _jedi_pools[kind] = pool
         return pool
 
@@ -647,6 +659,10 @@ def _submit_interactive(worker, *args) -> _Future:
     forkserver — which preloads this module, >1s of imports — so pool get +
     submit happen on a short-lived daemon thread and the pool future's result is
     mirrored into the returned Future (same done()/add_done_callback contract)."""
+    if sys.platform == 'ios':
+        # Thread startup does not import/spawn a second interpreter. Returning
+        # its own Future also preserves cancellation of queued device work.
+        return _get_jedi_pool('ac').submit(worker, *args)
     out = _Future()
 
     def _bg():
@@ -679,7 +695,7 @@ def _jedi_project(file_path=None):
     held = _jedi_projects.get(project.key)
     if held is None:
         held = _jedi_projects[project.key] = jedi.Project(
-            path=project.root, environment_path=project.environment,
+            path=project.root, environment_path=None if sys.platform == 'ios' else project.environment,
             added_sys_path=list(project.source_paths))
     return held
 
@@ -688,7 +704,15 @@ def _jedi_script(file_path, code=None):
     """jedi.Script on the file’s owning project. `code` (in-memory source) overrides
     the on-disk file so unsaved edits are analyzed; path still drives resolution."""
     import jedi
-    return jedi.Script(code=code, path=str(file_path), project=_jedi_project(file_path))
+    kwargs = {}
+    if sys.platform == 'ios':
+        # Threading alone is insufficient: Script's default Environment probes
+        # an executable and runs compiled-module introspection in a subprocess.
+        # Keep lookups inside bundled CPython without replacing sys.path while
+        # the app's rendering/decoder threads are importing their own modules.
+        from meltygui.code.embedded_jedi import EmbeddedEnvironment
+        kwargs['environment'] = EmbeddedEnvironment()
+    return jedi.Script(code=code, path=str(file_path), project=_jedi_project(file_path), **kwargs)
 
 
 def shutdown_jedi_pool():
@@ -696,8 +720,8 @@ def shutdown_jedi_pool():
         pools = list(_jedi_pools.values())
         _jedi_pools.clear()
     for pool in pools:
-        # Kill worker processes first because shutdown(cancel_futures=True) only
-        # cancels pending futures, not ones already running in a subprocess.
+        # Desktop workers can be killed. An iOS job already executing in a
+        # thread must finish; shutdown cancels its queued requests only.
         for pid, proc in list(getattr(pool, '_processes', {}).items()):
             try:
                 proc.kill()
@@ -809,7 +833,11 @@ def _completion_namespace():
     if _completion_ns_cache is None:
         import importlib
         ns = {}
-        for alias, mod in _COMPLETION_MODULES.items():
+        modules = _COMPLETION_MODULES
+        if sys.platform == 'ios':
+            modules = dict(modules, imgui='meltygui_imgui',
+                           glfw='meltygui.core.windowing.window_api')
+        for alias, mod in modules.items():
             try:
                 ns[alias] = importlib.import_module(mod)
             except Exception:
@@ -827,8 +855,7 @@ def _jedi_complete_worker(code: str, line: int, col: int, path: str = None):
     module/class/function/instance/param/keyword/statement/property/path)."""
     import jedi
     try:
-        kw = {"path": path, "project": _jedi_project(path)} if path else {}
-        script = (jedi.Script(code, **kw) if path else
+        script = (_jedi_script(path, code) if path else
                   jedi.Interpreter(code, [_completion_namespace()]))
         comps = script.complete(line, col)
     except Exception:
@@ -904,8 +931,7 @@ def _jedi_signatures_worker(code: str, line: int, col: int, path: str = None):
     'x', 'y=0', '*args')."""
     import jedi
     try:
-        kw = {"path": path, "project": _jedi_project(path)} if path else {}
-        script = (jedi.Script(code, **kw) if path else
+        script = (_jedi_script(path, code) if path else
                   jedi.Interpreter(code, [_completion_namespace()]))
         sigs = script.get_signatures(line, col)
     except Exception:
@@ -3704,7 +3730,7 @@ _FRAME_STAMP_STALE_S = 2.0    # a frame stamp this old = frame aborted mid-draw
 
 def _park_while_frame(max_park_s=_FRAME_PARK_MAX_S):
     """Sleep a background thread while the render thread is INSIDE a frame
-    (Melty._frame_draw_start set at frame start, cleared at post_frame end).
+    (Melty._frame_draw_start set by the surface, restored in its finally).
 
     Why: post_frame's capture pass is hundreds of ctypes GL calls, each
     releasing and re-acquiring the GIL. Under a CPU-bound background
@@ -3725,9 +3751,13 @@ def _park_while_frame(max_park_s=_FRAME_PARK_MAX_S):
     cur = threading.current_thread()
     if cur is threading.main_thread():
         return 0.0
-    import meltygui.core.graphics.gl_state as gl_state
-    glt = getattr(gl_state, "_gl_thread", None)  # read, don't claim
-    if glt is None or cur is glt:
+    from meltygui.core.windowing import glfw_utils
+    render_id = glfw_utils._render_thread_id
+    # Native Metal hosts have a render thread but no GL-state owner. Read an
+    # existing GL module only for the studio's older dedicated render loop.
+    gl_state = sys.modules.get("meltygui.core.graphics.gl_state")
+    glt = getattr(gl_state, "_gl_thread", None)
+    if cur.ident == render_id or cur is glt or (render_id is None and glt is None):
         return 0.0
     t0 = time.monotonic()
     if t0 - fs >= _FRAME_STAMP_STALE_S:
@@ -3783,9 +3813,14 @@ def _yield_to_ui():
     cur = threading.current_thread()
     if cur is threading.main_thread():
         return
-    import meltygui.core.graphics.gl_state as gl_state
-    glt = getattr(gl_state, "_gl_thread", None)  # read, don't claim (is_current_thread claims)
-    if glt is None or cur is glt:
+    # Native Metal has a registered render thread but no OpenGL thread. Use
+    # the same ownership check as _park_while_frame so its workers also defer
+    # between frames while a gesture or momentum animation remains active.
+    from meltygui.core.windowing import glfw_utils
+    render_id = glfw_utils._render_thread_id
+    gl_state = sys.modules.get("meltygui.core.graphics.gl_state")
+    glt = getattr(gl_state, "_gl_thread", None)
+    if cur.ident == render_id or cur is glt or (render_id is None and glt is None):
         return
     _t0 = time.monotonic()
     while Toggles.yield_to_ui:
@@ -9721,4 +9756,4 @@ def shutdown_symbol_index_daemon():
 #         try:
 #             SymbolIndexCache.rebuild()
 #         except Exception:
-#             pass
+#             pass