JIT executor Phase 3: SwiftUI session-lifecycle integration + hot-reload

.github/workflows/cache-warm.yml

@@ -96,3 +96,32 @@ jobs:
         run: |
           swift build
           swift build --package-path examples/spm
+
+  warm-jit-cache:
+    name: Warm jit-llvm cache
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Select Xcode
+        run: sudo xcode-select -s /Applications/Xcode_26.3.app
+
+      - name: Install cmake and ninja
+        run: brew install cmake ninja
+
+      - name: Cache JIT LLVM build
+        uses: actions/cache@v4
+        with:
+          path: |
+            third_party/llvm-build
+            third_party/llvm-build-rt
+            third_party/llvm-project
+          key: jit-llvm-${{ runner.os }}-${{ hashFiles('scripts/build-jit-llvm.sh') }}
+
+      - name: Build JIT LLVM (skips on cache hit)
+        run: |
+          if [ -f third_party/llvm-build-rt/lib/darwin/liborc_rt_osx.a ]; then
+            echo "JIT LLVM already cached; nothing to build."
+          else
+            scripts/build-jit-llvm.sh
+          fi

.github/workflows/ci.yml

@@ -268,3 +268,71 @@ jobs:
           xcrun simctl list devices booted 2>/dev/null || true
           echo "--- orphan simctl/previewsmcp procs ---"
           ps -o pid,command -ax | grep -E "(simctl|previewsmcp)" | grep -v grep || true
+
+  jit-tests:
+    needs: changes
+    if: needs.changes.outputs.src == 'true'
+    runs-on: macos-15
+    # 90m absorbs a cache-miss libLLVM build from source (only on a
+    # build-jit-llvm.sh change / first run); the cache-warm.yml warm-jit-cache
+    # job keeps the cache warm so the normal path just restores and tests.
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Select Xcode
+        run: sudo xcode-select -s /Applications/Xcode_26.3.app
+
+      - name: Disable Spotlight
+        # Non-fatal: mdutil can exit 1 when a volume is mid-transition
+        # (kMDConfigSearchLevelTransitioning); it is only a build-speed hint.
+        run: sudo mdutil -a -i off || true
+
+      - name: Install cmake and ninja
+        run: brew install cmake ninja
+
+      - name: Cache JIT LLVM build
+        uses: actions/cache@v4
+        with:
+          path: |
+            third_party/llvm-build
+            third_party/llvm-build-rt
+            third_party/llvm-project
+          key: jit-llvm-${{ runner.os }}-${{ hashFiles('scripts/build-jit-llvm.sh') }}
+
+      - name: Cache SPM build
+        uses: actions/cache@v4
+        with:
+          path: |
+            .build
+            examples/spm/.build
+          key: spm-${{ runner.os }}-jit-${{ hashFiles('Package.resolved') }}
+          restore-keys: |
+            spm-${{ runner.os }}-jit-
+            spm-${{ runner.os }}-
+
+      - name: Build JIT LLVM if cache missed
+        run: |
+          if [ -f third_party/llvm-build-rt/lib/darwin/liborc_rt_osx.a ]; then
+            echo "JIT LLVM restored from cache."
+          else
+            echo "JIT LLVM cache miss; building from source (slow)."
+            scripts/build-jit-llvm.sh
+          fi
+
+      - name: Build
+        run: |
+          swift build
+          swift build --package-path examples/spm
+
+      - name: JIT tests
+        # The suite builds PreviewAgent and renders real previews in spawned
+        # agents; 20m covers the cold test-target + agent compile plus runs.
+        # --no-parallel: the JIT layer (shared in-process LLJIT + LLVM ORC) is
+        # not safe under Swift Testing's default parallel execution; concurrent
+        # compile/link/teardown trips LLVM assertions (assertions are on in our
+        # build) and SIGABRTs intermittently. Serial is stable.
+        timeout-minutes: 20
+        env:
+          NSUnbufferedIO: "YES"
+        run: swift test --filter "PreviewsJITLinkTests" --no-parallel

Package.swift

@@ -11,6 +11,12 @@ let jitEnabled =
     FileManager.default.fileExists(atPath: llvmBuild)
     && FileManager.default.fileExists(atPath: orcRuntimeArchive)
 
+// Composition-root wiring for the JIT structural-reload path. Only the executable
+// references the gated PreviewsJITLink, behind one `#if PREVIEWSMCP_JIT`; the daemon
+// logic depends solely on the JIT-free `StructuralReloader` protocol in PreviewsCore.
+let jitCLIDependencies: [Target.Dependency] = jitEnabled ? ["PreviewsJITLink"] : []
+let jitCLISwiftSettings: [SwiftSetting] = jitEnabled ? [.define("PREVIEWSMCP_JIT")] : []
+
 var targets: [Target] = [
     .target(
         name: "SimulatorBridge",
@@ -53,7 +59,8 @@ var targets: [Target] = [
             "PreviewsEngine",
             .product(name: "ArgumentParser", package: "swift-argument-parser"),
             .product(name: "MCP", package: "swift-sdk"),
-        ],
+        ] + jitCLIDependencies,
+        swiftSettings: jitCLISwiftSettings,
         plugins: [.plugin(name: "GenerateVersion")]
     ),
     .executableTarget(
@@ -117,7 +124,7 @@ if jitEnabled {
     targets += [
         .target(
             name: "PreviewsJITLink",
-            dependencies: ["PreviewsJITLinkCxx"],
+            dependencies: ["PreviewsJITLinkCxx", "PreviewsCore"],
             plugins: [.plugin(name: "BundleOrcRuntime")]
         ),
         .target(

Sources/PreviewAgent/main.cpp

@@ -1,4 +1,6 @@
+#include "llvm/ExecutionEngine/Orc/Shared/AllocationActions.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
+#include "llvm/ExecutionEngine/Orc/Shared/MemoryFlags.h"
 #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
 #include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/ExecutorSharedMemoryMapperService.h"
@@ -8,11 +10,18 @@
 #include "llvm/ExecutionEngine/Orc/TargetProcess/SimpleExecutorMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/SimpleRemoteEPCServer.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/Memory.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <cstdlib>
+#include <cstring>
+#include <dispatch/dispatch.h>
 #include <dlfcn.h>
+#include <map>
+#include <mutex>
 #include <string>
+#include <thread>
+#include <vector>
 
 using namespace llvm;
 using namespace llvm::orc;
@@ -62,6 +71,110 @@ CWrapperFunctionResult previewsmcp_register_types(const char *ArgData,
       .release();
 }
 
+struct MainThreadCall {
+  int32_t (*Fn)();
+  int32_t Result;
+};
+
+void invokeOnMain(void *Ctx) {
+  auto *Call = static_cast<MainThreadCall *>(Ctx);
+  Call->Result = Call->Fn();
+}
+
+CWrapperFunctionResult previewsmcp_run_on_main(const char *ArgData,
+                                               size_t ArgSize) {
+  return WrapperFunction<int32_t(SPSExecutorAddr)>::handle(
+             ArgData, ArgSize,
+             [](llvm::orc::ExecutorAddr FnAddr) -> int32_t {
+               MainThreadCall Call{FnAddr.toPtr<int32_t (*)()>(), 0};
+               dispatch_sync_f(dispatch_get_main_queue(), &Call, invokeOnMain);
+               return Call.Result;
+             })
+      .release();
+}
+
+std::mutex AnonMapperMutex;
+std::map<void *, size_t> AnonReservations;
+
+CWrapperFunctionResult previewsmcp_anon_reserve(const char *ArgData,
+                                                size_t ArgSize) {
+  return WrapperFunction<SPSExpected<SPSExecutorAddr>(uint64_t)>::handle(
+             ArgData, ArgSize,
+             [](uint64_t Size) -> Expected<llvm::orc::ExecutorAddr> {
+               std::error_code EC;
+               auto MB = sys::Memory::allocateMappedMemory(
+                   Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE,
+                   EC);
+               if (EC)
+                 return errorCodeToError(EC);
+               std::lock_guard<std::mutex> Lock(AnonMapperMutex);
+               AnonReservations[MB.base()] = Size;
+               return llvm::orc::ExecutorAddr::fromPtr(MB.base());
+             })
+      .release();
+}
+
+CWrapperFunctionResult previewsmcp_anon_initialize(const char *ArgData,
+                                                   size_t ArgSize) {
+  using namespace llvm::orc::tpctypes;
+  return WrapperFunction<SPSExpected<SPSExecutorAddr>(SPSFinalizeRequest)>::
+      handle(ArgData, ArgSize,
+             [](FinalizeRequest FR) -> Expected<llvm::orc::ExecutorAddr> {
+               llvm::orc::ExecutorAddr Base(~0ULL);
+               for (auto &Seg : FR.Segments)
+                 Base = std::min(Base, Seg.Addr);
+               for (auto &Seg : FR.Segments) {
+                 char *Mem = Seg.Addr.toPtr<char *>();
+                 if (!Seg.Content.empty())
+                   memcpy(Mem, Seg.Content.data(), Seg.Content.size());
+                 memset(Mem + Seg.Content.size(), 0,
+                        Seg.Size - Seg.Content.size());
+                 sys::MemoryBlock MB(Mem, Seg.Size);
+                 if (auto EC = sys::Memory::protectMappedMemory(
+                         MB, toSysMemoryProtectionFlags(Seg.RAG.Prot)))
+                   return errorCodeToError(EC);
+                 if ((Seg.RAG.Prot & MemProt::Exec) == MemProt::Exec)
+                   sys::Memory::InvalidateInstructionCache(Mem, Seg.Size);
+               }
+               auto Dealloc = runFinalizeActions(FR.Actions);
+               if (!Dealloc)
+                 return Dealloc.takeError();
+               return Base;
+             })
+          .release();
+}
+
+CWrapperFunctionResult previewsmcp_anon_deinitialize(const char *ArgData,
+                                                     size_t ArgSize) {
+  return WrapperFunction<SPSError(SPSSequence<SPSExecutorAddr>)>::handle(
+             ArgData, ArgSize,
+             [](std::vector<llvm::orc::ExecutorAddr>) -> Error {
+               return Error::success();
+             })
+      .release();
+}
+
+CWrapperFunctionResult previewsmcp_anon_release(const char *ArgData,
+                                                size_t ArgSize) {
+  return WrapperFunction<SPSError(SPSSequence<SPSExecutorAddr>)>::handle(
+             ArgData, ArgSize,
+             [](std::vector<llvm::orc::ExecutorAddr> Bases) -> Error {
+               Error Err = Error::success();
+               std::lock_guard<std::mutex> Lock(AnonMapperMutex);
+               for (auto B : Bases) {
+                 auto I = AnonReservations.find(B.toPtr<void *>());
+                 if (I == AnonReservations.end())
+                   continue;
+                 sys::MemoryBlock MB(I->first, I->second);
+                 if (auto EC = sys::Memory::releaseMappedMemory(MB))
+                   Err = joinErrors(std::move(Err), errorCodeToError(EC));
+                 AnonReservations.erase(I);
+               }
+               return Err;
+             })
+      .release();
+}
+
 CWrapperFunctionResult previewsmcp_write_pointers(const char *ArgData,
                                                   size_t ArgSize) {
   using namespace llvm::orc::tpctypes;
@@ -83,13 +196,14 @@ static void printErrorAndExit(Twine ErrMsg) {
 }
 
 int main(int argc, char *argv[]) {
-  ExitOnError ExitOnErr;
-  ExitOnErr.setBanner(std::string(argv[0]) + ": ");
-
   dlopen("/usr/lib/swift/libswiftCore.dylib", RTLD_NOW | RTLD_GLOBAL);
   dlopen("/usr/lib/swift/libswift_Concurrency.dylib", RTLD_NOW | RTLD_GLOBAL);
   dlopen("/usr/lib/swift/libswiftFoundation.dylib", RTLD_NOW | RTLD_GLOBAL);
   dlopen("/usr/lib/swift/libswiftDispatch.dylib", RTLD_NOW | RTLD_GLOBAL);
+  dlopen("/System/Library/Frameworks/AppKit.framework/AppKit",
+         RTLD_NOW | RTLD_GLOBAL);
+  dlopen("/System/Library/Frameworks/SwiftUI.framework/SwiftUI",
+         RTLD_NOW | RTLD_GLOBAL);
 
   if (argc != 2)
     printErrorAndExit("expected exactly one argument");
@@ -107,31 +221,59 @@ int main(int argc, char *argv[]) {
   if (OutFDStr.getAsInteger(10, OutFD))
     printErrorAndExit(OutFDStr + " is not a valid file descriptor");
 
-  auto Server =
-      ExitOnErr(SimpleRemoteEPCServer::Create<FDSimpleRemoteEPCTransport>(
-          [](SimpleRemoteEPCServer::Setup &S) -> Error {
-            S.setDispatcher(
-                std::make_unique<SimpleRemoteEPCServer::ThreadDispatcher>());
-            S.bootstrapSymbols() =
-                SimpleRemoteEPCServer::defaultBootstrapSymbols();
-            S.bootstrapSymbols()["__previewsmcp_register_conformances"] =
-                llvm::orc::ExecutorAddr::fromPtr(
-                    &previewsmcp_register_conformances);
-            S.bootstrapSymbols()["__previewsmcp_register_types"] =
-                llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_register_types);
-            S.bootstrapSymbols()["__previewsmcp_write_pointers"] =
-                llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_write_pointers);
-            S.services().push_back(
-                std::make_unique<rt_bootstrap::SimpleExecutorDylibManager>());
-            S.services().push_back(
-                std::make_unique<rt_bootstrap::SimpleExecutorMemoryManager>());
-            S.services().push_back(
-                std::make_unique<
-                    rt_bootstrap::ExecutorSharedMemoryMapperService>());
-            return Error::success();
-          },
-          InFD, OutFD));
-
-  ExitOnErr(Server->waitForDisconnect());
-  return 0;
+  std::thread ServerThread([InFD, OutFD] {
+    ExitOnError ExitOnErr;
+    ExitOnErr.setBanner("PreviewAgent: ");
+    auto Server = ExitOnErr(SimpleRemoteEPCServer::Create<
+                            FDSimpleRemoteEPCTransport>(
+        [](SimpleRemoteEPCServer::Setup &S) -> Error {
+          S.setDispatcher(
+              std::make_unique<SimpleRemoteEPCServer::ThreadDispatcher>());
+          S.bootstrapSymbols() =
+              SimpleRemoteEPCServer::defaultBootstrapSymbols();
+          S.bootstrapSymbols()["__previewsmcp_register_conformances"] =
+              llvm::orc::ExecutorAddr::fromPtr(
+                  &previewsmcp_register_conformances);
+          S.bootstrapSymbols()["__previewsmcp_register_types"] =
+              llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_register_types);
+          S.bootstrapSymbols()["__previewsmcp_write_pointers"] =
+              llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_write_pointers);
+          S.bootstrapSymbols()["__previewsmcp_run_on_main"] =
+              llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_run_on_main);
+          S.bootstrapSymbols()["__previewsmcp_anon_reserve"] =
+              llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_anon_reserve);
+          S.bootstrapSymbols()["__previewsmcp_anon_initialize"] =
+              llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_anon_initialize);
+          S.bootstrapSymbols()["__previewsmcp_anon_deinitialize"] =
+              llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_anon_deinitialize);
+          S.bootstrapSymbols()["__previewsmcp_anon_release"] =
+              llvm::orc::ExecutorAddr::fromPtr(&previewsmcp_anon_release);
+          S.services().push_back(
+              std::make_unique<rt_bootstrap::SimpleExecutorDylibManager>());
+          S.services().push_back(
+              std::make_unique<rt_bootstrap::SimpleExecutorMemoryManager>());
+          S.services().push_back(
+              std::make_unique<
+                  rt_bootstrap::ExecutorSharedMemoryMapperService>());
+          return Error::success();
+        },
+        InFD, OutFD));
+    ExitOnErr(Server->waitForDisconnect());
+    std::_Exit(0);
+  });
+  ServerThread.detach();
+
+  if (auto *Load = reinterpret_cast<bool (*)()>(
+          dlsym(RTLD_DEFAULT, "NSApplicationLoad")))
+    Load();
+
+  auto *RunInMode =
+      reinterpret_cast<int (*)(const void *, double, unsigned char)>(
+          dlsym(RTLD_DEFAULT, "CFRunLoopRunInMode"));
+  auto *DefaultMode = reinterpret_cast<const void *const *>(
+      dlsym(RTLD_DEFAULT, "kCFRunLoopDefaultMode"));
+  if (!RunInMode || !DefaultMode)
+    printErrorAndExit("CoreFoundation run loop symbols not found");
+  while (true)
+    RunInMode(*DefaultMode, 0.25, false);
 }

Sources/PreviewsCLI/Handlers/PreviewStartHandler.swift

@@ -299,7 +299,7 @@ private func handleIOSPreviewStart(
     let sessionID = session.id
     let allPaths = [fileURL.path] + (buildContext?.sourceFiles?.map(\.path) ?? [])
     let iosState = ctx.iosState
-    let watcher = try? FileWatcher(paths: allPaths) {
+    let watcher = try? FileWatcher(paths: allPaths) { _ in
         Task {
             Log.info("MCP: iOS file change detected, reloading session \(sessionID)...")
             do {