diff --git a/docs/preloading.md b/docs/preloading.md
new file mode 100644
index 00000000..a8734046
--- /dev/null
+++ b/docs/preloading.md
@@ -0,0 +1,328 @@
+# Preloading System
+
+## Overview
+
+The preloading system in GutenbergKit pre-fetches WordPress REST API responses before the editor loads, eliminating network latency during editor initialization. By injecting cached API responses directly into the JavaScript runtime, the Gutenberg editor can almost always initialize instantly without waiting for network requests.
+
+## Architecture
+
+The preloading system consists of several interconnected components:
+
+```
++---------------------------------------------------------------------+
+|                         EditorService                               |
+|  (Orchestrates dependency fetching and caching)                     |
++----------------------------------+----------------------------------+
+                                   |
+                +------------------+------------------+
+                |                  |                  |
+                v                  v                  v
+   +--------------------+ +--------------+ +--------------------+
+   | RESTAPIRepository  | |EditorPreload | |EditorAssetLibrary  |
+   | (API caching)      | |    List      | | (JS/CSS bundles)   |
+   +---------+----------+ +------+-------+ +--------------------+
+             |                   |
+             v                   v
+   +--------------------+ +-------------------------------------+
+   |  EditorURLCache    | |           GBKitGlobal               |
+   | (Disk caching)     | | (Serialized to window.GBKit)        |
+   +---------+----------+ +------------------+------------------+
+             |                               |
+             v                               v
+   +--------------------+        +-----------------------------+
+   |EditorCachePolicy   |        |   JavaScript Preloading     |
+   | (TTL management)   |        |       Middleware            |
+   +--------------------+        +-----------------------------+
+```
+
+## Key Components
+
+### EditorService
+
+The `EditorService` actor coordinates fetching all editor dependencies concurrently:
+
+**Swift**
+```swift
+let service = EditorService(configuration: config)
+let dependencies = try await service.prepare { progress in
+    print("Loading: \(progress.fractionCompleted * 100)%")
+}
+```
+
+**Kotlin**
+```kotlin
+// TBD
+```
+
+The `prepare` method fetches these resources in parallel:
+- Editor settings (theme styles, block settings)
+- Asset bundles (JavaScript and CSS files)
+- Preload list (API responses for editor initialization)
+
+### EditorPreloadList
+
+The `EditorPreloadList` struct contains pre-fetched API responses that are serialized to JSON and injected into the editor's JavaScript runtime:
+
+| Property | API Endpoint | Description |
+|----------|--------------|-------------|
+| `postData` | `/wp/v2/posts/{id}?context=edit` | The post being edited (existing posts only) |
+| `postTypeData` | `/wp/v2/types/{type}?context=edit` | Schema for the current post type |
+| `postTypesData` | `/wp/v2/types?context=view` | All available post types |
+| `activeThemeData` | `/wp/v2/themes?context=edit&status=active` | Active theme information |
+| `settingsOptionsData` | `OPTIONS /wp/v2/settings` | Site settings schema |
+
+### EditorURLCache
+
+The `EditorURLCache` provides disk-based caching for API responses, keyed by URL and HTTP method. It supports three cache policies via `EditorCachePolicy`:
+
+| Policy | Behavior |
+|--------|----------|
+| `.ignore` | Never use cached responses (force fresh data) |
+| `.maxAge(TimeInterval)` | Use cached responses younger than the specified age |
+| `.always` | Always use cached responses regardless of age |
+
+Example:
+
+**Swift**
+```swift
+// Cache responses for up to 1 hour
+let service = EditorService(
+    configuration: config,
+    cachePolicy: .maxAge(3600)
+)
+```
+
+**Kotlin**
+```kotlin
+// TBD
+```
+
+### RESTAPIRepository
+
+The `RESTAPIRepository` handles fetching and caching individual API responses. It follows a read-through caching pattern:
+
+1. Check cache for existing response
+2. If cache hit and valid per policy, return cached data
+3. If cache miss or expired, fetch from network
+4. Store response in cache
+5. Return response
+
+## Data Flow
+
+### 1. Preparation Phase (Native)
+
+When `EditorService.prepare()` is called:
+
+```
+EditorService.prepare()
+    |-- prepareEditorSettings()      -> EditorSettings
+    |-- prepareAssetBundle()         -> EditorAssetBundle
+    +-- preparePreloadList()
+        |-- prepareActiveTheme()     -> EditorURLResponse
+        |-- prepareSettingsOptions() -> EditorURLResponse
+        |-- preparePost(type:)       -> EditorURLResponse
+        |-- preparePostTypes()       -> EditorURLResponse
+        +-- preparePost(id:)         -> EditorURLResponse (if editing existing post)
+```
+
+### 2. Serialization Phase (Native)
+
+The `EditorPreloadList` is converted to JSON via `build()`:
+
+```json
+{
+  "/wp/v2/types/post?context=edit": {
+    "body": { "slug": "post", "supports": { ... } },
+    "headers": { "Link": "<...>; rel=\"https://api.w.org/\"" }
+  },
+  "/wp/v2/types?context=view": {
+    "body": { "post": { ... }, "page": { ... } },
+    "headers": {}
+  },
+  "/wp/v2/themes?context=edit&status=active": {
+    "body": [ ... ],
+    "headers": {}
+  },
+  "OPTIONS": {
+    "/wp/v2/settings": {
+      "body": { ... },
+      "headers": {}
+    }
+  }
+}
+```
+
+### 3. Injection Phase (Native to Web)
+
+The `GBKitGlobal` struct packages all configuration and preload data, then injects it into the WebView as `window.GBKit`:
+
+```javascript
+window.GBKit = {
+  siteURL: "https://example.com",
+  siteApiRoot: "https://example.com/wp-json",
+  authHeader: "Bearer ...",
+  preloadData: { /* serialized EditorPreloadList */ },
+  editorSettings: { /* theme styles, colors, etc. */ },
+  // ... other configuration
+};
+```
+
+### 4. Consumption Phase (JavaScript)
+
+The `@wordpress/api-fetch` package includes a preloading middleware that intercepts API requests:
+
+```javascript
+// In src/utils/api-fetch.js
+export function configureApiFetch() {
+  const { preloadData } = getGBKit();
+
+  apiFetch.use(
+    apiFetch.createPreloadingMiddleware(preloadData ?? defaultPreloadData)
+  );
+}
+```
+
+When Gutenberg makes an API request:
+
+1. The preloading middleware checks if the request path exists in `preloadData`
+2. If found, the cached response is returned immediately (no network request)
+3. If not found, the request proceeds to the network
+4. The preload entry is consumed (one-time use) to ensure fresh data on subsequent requests
+
+## Header Filtering
+
+Only certain headers are preserved in preload responses to match WordPress core's behavior:
+
+- `Accept` - Content type negotiation
+- `Link` - REST API discovery and pagination
+
+This filtering is performed by `EditorURLResponse.asPreloadResponse()`.
+
+## Cache Management
+
+### Automatic Cleanup
+
+`EditorService` automatically cleans up old asset bundles once per day:
+
+**Swift**
+```swift
+try await onceEvery(.seconds(86_400)) {
+    try await self.cleanup()
+}
+```
+
+**Kotlin**
+```kotlin
+//tbd
+```
+
+### Manual Cache Control
+
+**Swift**
+```swift
+// Clear unused resources (keeps most recent)
+try await service.cleanup()
+
+// Clear all resources (requires re-download)
+try await service.purge()
+```
+
+**Kotlin**
+```kotlin
+//tbd
+```
+
+## Offline Mode
+
+When `EditorConfiguration.isOfflineModeEnabled` is `true`, the preloading system returns empty dependencies:
+
+```swift
+if self.configuration.isOfflineModeEnabled {
+    return EditorDependencies(
+        editorSettings: .undefined,
+        assetBundle: .empty,
+        preloadList: nil
+    )
+}
+```
+
+Offline mode doesn't refer to reguar site that are offline – it's for when you're using GutenbergKit separately from a WordPress
+site (for instance, the bundled editor in the demo app, or you just want an editor without the WP integration).
+
+The JavaScript side falls back to `defaultPreloadData` which contains minimal type definitions to allow basic editor functionality.
+
+## Progress Reporting
+
+The preloading system reports its progress to give the user high-quality feedback about the loading process - if the user loads the
+editor without `EditorDependencies` present, the editor will display a loading screen with a progress bar. If the user provides `EditorDependencies`
+that contain everything the editor needs, the progress bar will never be displayed.
+
+## EditorDependencies
+
+`EditorDependencies` contains all pre-fetched resources needed to initialize the editor instantly.
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `editorSettings` | `EditorSettings` | Theme styles, colors, typography, block settings |
+| `assetBundle` | `EditorAssetBundle` | Cached JavaScript/CSS for plugins/themes |
+| `preloadList` | `EditorPreloadList?` | Pre-fetched API responses |
+
+### Obtaining Dependencies
+
+```swift
+let service = EditorService(configuration: configuration)
+let dependencies = try await service.prepare { progress in
+    loadingView.progress = progress.fractionCompleted
+}
+```
+
+### EditorViewController Loading Flows
+
+`EditorViewController` supports two loading flows based on whether dependencies are provided:
+
+#### Flow 1: Dependencies Provided (Recommended)
+
+```swift
+let editor = EditorViewController(
+    configuration: configuration,
+    dependencies: dependencies  // Loads immediately
+)
+```
+
+The editor skips the progress UI and loads the WebView immediately.
+
+#### Flow 2: No Dependencies (Fallback)
+
+```swift
+let editor = EditorViewController(
+    configuration: configuration
+    // No dependencies - fetches automatically
+)
+```
+
+The editor displays a progress bar while fetching, then loads once complete.
+
+### Best Practice: Prepare Early
+
+Fetch dependencies before the user needs the editor:
+
+```swift
+class PostListViewController: UIViewController {
+    private var editorDependencies: EditorDependencies?
+    private let editorService: EditorService
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        Task {
+            self.editorDependencies = try? await editorService.prepare { _ in }
+        }
+    }
+
+    func editPost(_ post: Post) {
+        let editor = EditorViewController(
+            configuration: EditorConfiguration(post: post),
+            dependencies: editorDependencies
+        )
+        navigationController?.pushViewController(editor, animated: true)
+    }
+}
diff --git a/ios/Demo-iOS/Gutenberg.xcodeproj/project.pbxproj b/ios/Demo-iOS/Gutenberg.xcodeproj/project.pbxproj
index c9268e1d..283bfb48 100644
--- a/ios/Demo-iOS/Gutenberg.xcodeproj/project.pbxproj
+++ b/ios/Demo-iOS/Gutenberg.xcodeproj/project.pbxproj
@@ -122,6 +122,7 @@
 			buildRules = (
 			);
 			dependencies = (
+				245D6BE42EDFCD640076D741 /* PBXTargetDependency */,
 			);
 			fileSystemSynchronizedGroups = (
 				2468525B2EAAC62B00ED1F09 /* Views */,
@@ -197,6 +198,13 @@
 		};
 /* End PBXSourcesBuildPhase section */
 
+/* Begin PBXTargetDependency section */
+		245D6BE42EDFCD640076D741 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			productRef = 245D6BE32EDFCD640076D741 /* GutenbergKit */;
+		};
+/* End PBXTargetDependency section */
+
 /* Begin XCBuildConfiguration section */
 		0C4F59972BEFF4980028BD96 /* Debug */ = {
 			isa = XCBuildConfiguration;
@@ -431,6 +439,10 @@
 			isa = XCSwiftPackageProductDependency;
 			productName = GutenbergKit;
 		};
+		245D6BE32EDFCD640076D741 /* GutenbergKit */ = {
+			isa = XCSwiftPackageProductDependency;
+			productName = GutenbergKit;
+		};
 /* End XCSwiftPackageProductDependency section */
 	};
 	rootObject = 0C4F59832BEFF4970028BD96 /* Project object */;
diff --git a/ios/Demo-iOS/Gutenberg.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved b/ios/Demo-iOS/Gutenberg.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
index 0ea20e7d..909f39e3 100644
--- a/ios/Demo-iOS/Gutenberg.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
+++ b/ios/Demo-iOS/Gutenberg.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
@@ -1,4 +1,5 @@
 {
+  "originHash" : "2aee256c0b38622aa9bb903b83d446aa51554bf7f6d1f43aca6d447f82d2a906",
   "pins" : [
     {
       "identity" : "svgview",
@@ -28,5 +29,5 @@
       }
     }
   ],
-  "version" : 2
+  "version" : 3
 }
diff --git a/ios/Demo-iOS/Sources/ConfigurationItem.swift b/ios/Demo-iOS/Sources/ConfigurationItem.swift
index a29c4157..bfe6d87b 100644
--- a/ios/Demo-iOS/Sources/ConfigurationItem.swift
+++ b/ios/Demo-iOS/Sources/ConfigurationItem.swift
@@ -1,7 +1,8 @@
 import Foundation
+import GutenbergKit
 
 /// Represents a configuration item for the editor
-enum ConfigurationItem: Codable, Identifiable, Equatable {
+enum ConfigurationItem: Codable, Identifiable, Equatable, Hashable {
     case bundledEditor
     case editorConfiguration(ConfiguredEditor)
 
@@ -24,8 +25,13 @@ enum ConfigurationItem: Codable, Identifiable, Equatable {
     }
 }
 
+struct RunnableEditor: Equatable, Hashable {
+    let configuration: EditorConfiguration
+    let dependencies: EditorDependencies?
+}
+
 /// Configuration for an editor with site integration
-struct ConfiguredEditor: Codable, Identifiable, Equatable {
+struct ConfiguredEditor: Codable, Identifiable, Equatable, Hashable {
     let id: String
     let name: String
     let siteUrl: String
diff --git a/ios/Demo-iOS/Sources/GutenbergApp.swift b/ios/Demo-iOS/Sources/GutenbergApp.swift
index 8b4f9ecf..82f5e02e 100644
--- a/ios/Demo-iOS/Sources/GutenbergApp.swift
+++ b/ios/Demo-iOS/Sources/GutenbergApp.swift
@@ -2,8 +2,42 @@ import SwiftUI
 import OSLog
 import GutenbergKit
 
+final class Navigation: ObservableObject {
+    @Published var path = NavigationPath()
+
+    @Published var hasEditor: Bool = false
+
+    @Published var editor: RunnableEditor?
+
+    func push(_ path: any Hashable) {
+        self.path.append(path)
+    }
+
+    func present(_ editor: RunnableEditor) {
+        self.hasEditor = true
+        self.editor = editor
+    }
+}
+
+extension EnvironmentValues {
+    private struct NavigationKey: EnvironmentKey {
+        static let defaultValue = Navigation()
+    }
+
+    var navigation: Navigation {
+        get { self[NavigationKey.self] }
+        set { self[NavigationKey.self] = newValue }
+    }
+}
+
 @main
 struct GutenbergApp: App {
+    @StateObject
+    private var navigation = Navigation()
+
+    private let configurationStorage = ConfigurationStorage()
+    private let authenticationManager = AuthenticationManager()
+
     init() {
         // Configure logger for GutenbergKit
         EditorLogger.shared = OSLogEditorLogger()
@@ -12,12 +46,24 @@ struct GutenbergApp: App {
 
     var body: some Scene {
         WindowGroup {
-            NavigationStack {
+            NavigationStack(path: $navigation.path) {
                 AppRootView()
+                .navigationDestination(for: ConfigurationItem.self) { item in
+                    SitePreparationView(site: item)
+                }
+                .fullScreenCover(isPresented: $navigation.hasEditor) {
+                    let editor = navigation.editor!
+
+                    NavigationStack {
+                        EditorView(configuration: editor.configuration, dependencies: editor.dependencies)
+                    }
+                }
+
             }
         }
-        .environmentObject(ConfigurationStorage())
-        .environmentObject(AuthenticationManager())
+        .environment(\.navigation, navigation)
+        .environmentObject(configurationStorage)
+        .environmentObject(authenticationManager)
     }
 }
 
diff --git a/ios/Demo-iOS/Sources/Views/AppRootView.swift b/ios/Demo-iOS/Sources/Views/AppRootView.swift
index 49c9e6a6..f42e38c7 100644
--- a/ios/Demo-iOS/Sources/Views/AppRootView.swift
+++ b/ios/Demo-iOS/Sources/Views/AppRootView.swift
@@ -11,7 +11,6 @@ struct AppRootView: View {
     @EnvironmentObject
     private var authenticationManager: AuthenticationManager
 
-    @State private var selectedConfiguration: ConfigurationItem?
     @State private var configurations: [ConfigurationItem] = [.bundledEditor]
     @State private var siteUrlInput = ""
 
@@ -23,7 +22,7 @@ struct AppRootView: View {
     @AppStorage("isNativeInserterEnabled") private var isNativeInserterEnabled = false
 
     var body: some View {
-        EditorList(isNativeInserterEnabled: $isNativeInserterEnabled, selectedConfiguration: $selectedConfiguration)
+        EditorList()
         .alert(isPresented: $hasError, error: error, actions: {
             Button {
                 self.hasError = false
@@ -35,79 +34,12 @@ struct AppRootView: View {
                 }
             }.buttonStyle(.borderedProminent)
         })
-        .fullScreenCover(item: $selectedConfiguration) { config in
-            editor
-        }
-        .onChange(of: self.selectedConfiguration) { oldValue, newValue in
-            switch newValue {
-            case .bundledEditor:
-                let config = createBundledConfiguration()
-                activeEditorConfiguration = config
-            case .editorConfiguration(let config):
-                self.loadEditorConfiguration(for: config)
-            case .none:
-                self.activeEditorConfiguration = nil
-            }
-        }
-    }
-
-    @ViewBuilder
-    var editor: some View {
-        NavigationView {
-            if let activeEditorConfiguration {
-                EditorView(configuration: activeEditorConfiguration)
-            } else {
-                ProgressView("Preparing Editor")
-            }
-        }
-    }
-
-    private func loadEditorConfiguration(for config: ConfiguredEditor) {
-        Task {
-            do {
-                let client = WordPressAPI(
-                    urlSession: .shared,
-                    apiRootUrl: try ParsedUrl.parse(input: config.siteApiRoot),
-                    authentication: .authorizationHeader(token: config.authHeader)
-                )
-
-                let apiRoot = try await client.apiRoot.get().data
-
-                let canUsePlugins = apiRoot.hasRoute(route: "/wpcom/v2/editor-assets")
-                let canUseEditorStyles = apiRoot.hasRoute(route: "/wp-block-editor/v1/settings")
-
-                self.activeEditorConfiguration = EditorConfigurationBuilder()
-                    .setShouldUseThemeStyles(canUseEditorStyles)
-                    .setShouldUsePlugins(canUsePlugins)
-                    .setSiteUrl(config.siteUrl)
-                    .setSiteApiRoot(config.siteApiRoot)
-                    .setAuthHeader(config.authHeader)
-                    .setNativeInserterEnabled(isNativeInserterEnabled)
-                    .setLogLevel(.debug)
-                    .setEnableNetworkLogging(true)
-                    .build()
-            } catch {
-                self.hasError = true
-                self.error = AppError(errorDescription: error.localizedDescription)
-            }
-        }
     }
 
     private func deleteConfiguration(_ config: ConfigurationItem) {
         configurations.removeAll { $0.id == config.id }
         configurationStorage.saveConfigurations(configurations)
     }
-
-    private func createBundledConfiguration() -> EditorConfiguration {
-        EditorConfigurationBuilder()
-            .setShouldUsePlugins(false)
-            .setSiteUrl("")
-            .setSiteApiRoot("")
-            .setAuthHeader("")
-            .setNativeInserterEnabled(isNativeInserterEnabled)
-            .setEnableNetworkLogging(true)
-            .build()
-    }
 }
 
 struct AppError: LocalizedError {
diff --git a/ios/Demo-iOS/Sources/Views/EditorList.swift b/ios/Demo-iOS/Sources/Views/EditorList.swift
index 4f616121..d747335c 100644
--- a/ios/Demo-iOS/Sources/Views/EditorList.swift
+++ b/ios/Demo-iOS/Sources/Views/EditorList.swift
@@ -7,17 +7,15 @@ struct EditorList: View {
 
     @State private var showAddDialog = false
     @State private var showDebugSettings = false
-    @Binding var isNativeInserterEnabled: Bool
-
-    @Binding var selectedConfiguration: ConfigurationItem?
 
     @State var configurationToDelete: ConfigurationItem?
 
     var body: some View {
         List {
             Section {
-                Button("Default Editor") {
-                    selectedConfiguration = .bundledEditor
+                NavigationLink("Default Editor") {
+                    SitePreparationView(site: .bundledEditor)
+
                 }
             } header: {
                 if ProcessInfo.processInfo.environment["GUTENBERG_EDITOR_URL"] != nil
@@ -47,10 +45,6 @@ struct EditorList: View {
             } footer: {
                 Text("Editors with site configuration; enabling media uploads, plugin support, etc.")
             }
-
-            Section("Feature Configuration") {
-                Toggle("Native Inserter", isOn: $isNativeInserterEnabled)
-            }
         }
         .alert(
             "Delete Editor Configuration?",
@@ -105,9 +99,7 @@ struct EditorList: View {
             if case .editorConfiguration = $0 { return true }
             return false
         }) { config in
-            Button(config.displayName) {
-                self.selectedConfiguration = config
-            }
+            NavigationLink(config.displayName, value: config)
             .swipeActions(edge: .trailing) {
                 Button(role: .destructive) {
                     configurationToDelete = config
diff --git a/ios/Demo-iOS/Sources/Views/EditorView.swift b/ios/Demo-iOS/Sources/Views/EditorView.swift
index 07701aeb..b8a0361d 100644
--- a/ios/Demo-iOS/Sources/Views/EditorView.swift
+++ b/ios/Demo-iOS/Sources/Views/EditorView.swift
@@ -3,17 +3,23 @@ import GutenbergKit
 
 struct EditorView: View {
     private let configuration: EditorConfiguration
+    private let dependencies: EditorDependencies?
 
-    @State private var viewModel = EditorViewModel()
+    @StateObject private var viewModel = EditorViewModel()
 
-    @Environment(\.dismiss) private var dismiss
+    @Environment(\.dismiss) var dismiss
 
-    init(configuration: EditorConfiguration) {
+    init(configuration: EditorConfiguration, dependencies: EditorDependencies? = nil) {
         self.configuration = configuration
+        self.dependencies = dependencies
     }
 
     var body: some View {
-        _EditorView(configuration: configuration, viewModel: viewModel)
+        _EditorView(
+            configuration: configuration,
+            dependencies: dependencies,
+            viewModel: viewModel
+        )
             .toolbar { toolbar }
     }
 
@@ -21,13 +27,11 @@ struct EditorView: View {
     private var toolbar: some ToolbarContent {
         ToolbarItem(placement: .topBarLeading) {
             Button {
-                dismiss()
+                self.dismiss()
             } label: {
                 Image(systemName: "xmark")
             }
-            .disabled(viewModel.isModalDialogOpen)
         }
-
         ToolbarItemGroup(placement: .topBarTrailing) {
             Group {
                 Button {
@@ -90,13 +94,16 @@ struct EditorView: View {
 
 private struct _EditorView: UIViewControllerRepresentable {
     private let configuration: EditorConfiguration
+    private let dependencies: EditorDependencies?
     private let viewModel: EditorViewModel
 
     init(
         configuration: EditorConfiguration,
+        dependencies: EditorDependencies? = nil,
         viewModel: EditorViewModel
     ) {
         self.configuration = configuration
+        self.dependencies = dependencies
         self.viewModel = viewModel
     }
 
@@ -105,10 +112,9 @@ private struct _EditorView: UIViewControllerRepresentable {
     }
 
     func makeUIViewController(context: Context) -> EditorViewController {
-        let viewController = EditorViewController(configuration: configuration)
+        let viewController = EditorViewController(configuration: configuration, dependencies: dependencies)
         viewController.delegate = context.coordinator
         viewController.webView.isInspectable = true
-        viewController.startEditorSetup()
 
         viewModel.perform = { [weak viewController] in
             switch $0 {
@@ -210,8 +216,7 @@ private struct _EditorView: UIViewControllerRepresentable {
     }
 }
 
-@Observable
-private final class EditorViewModel {
+private final class EditorViewModel: ObservableObject {
     var isModalDialogOpen = false
     var hasUndo = false
     var hasRedo = false
@@ -227,6 +232,18 @@ private final class EditorViewModel {
 
 #Preview {
     NavigationStack {
-        EditorView(configuration: .default)
+        EditorView(configuration: .bundled)
     }
 }
+
+extension EditorConfiguration {
+    static let bundled = EditorConfigurationBuilder(
+        postType: "post",
+        siteURL: URL(string: "https://example.com")!,
+        siteApiRoot: URL(string: "https://example.com/wp-json")!
+    )
+    .setShouldUsePlugins(false)
+    .setAuthHeader("")
+    .setIsOfflineModeEnabled(true)
+    .build()
+}
diff --git a/ios/Demo-iOS/Sources/Views/SitePreparationView.swift b/ios/Demo-iOS/Sources/Views/SitePreparationView.swift
new file mode 100644
index 00000000..aeb6e0f6
--- /dev/null
+++ b/ios/Demo-iOS/Sources/Views/SitePreparationView.swift
@@ -0,0 +1,334 @@
+import SwiftUI
+import WordPressAPI
+import GutenbergKit
+
+struct SitePreparationView: View {
+
+    @Environment(\.navigation)
+    private var navigation
+
+    @State
+    private var viewModel: SitePreparationViewModel
+
+    init(site: ConfigurationItem) {
+        self.viewModel = SitePreparationViewModel(configurationItem: site)
+    }
+
+    var body: some View {
+        Group {
+            if let configuration = self.viewModel.editorConfiguration {
+                loadedView(configuration: configuration)
+            } else {
+                ProgressView("Loading Site Configuration")
+            }
+        }
+        .toolbar {
+            ToolbarItem(placement: .confirmationAction) {
+                if self.viewModel.editorConfiguration != nil {
+                    Button("Start") {
+                        self.viewModel.buildAndLoadConfiguration(navigation: navigation)
+                    }
+                    .buttonStyle(.borderedProminent)
+                }
+            }
+        }
+        .navigationTitle("Editor Configuration")
+        .onAppear {
+            self.viewModel.startLoading()
+        }
+    }
+
+    func loadedView(configuration: EditorConfiguration) -> some View {
+        Form {
+
+            if viewModel.editorDependencies != nil {
+                Text("Editor Dependencies Loaded – the editor should load instantly")
+            } else {
+                Text("Editor Dependencies Missing – the editor will need to load them when it starts")
+            }
+
+            Section("Feature Configuration") {
+                Toggle("Enable Native Inserter", isOn: $viewModel.enableNativeInserter)
+                Toggle("Enable Network Logging", isOn: $viewModel.enableNetworkLogging)
+
+                // TODO: Loading this from the server would allow us to validate Custom Post Type support
+                Picker("Post Type", selection: $viewModel.postType) {
+                    Text("Post").tag("post")
+                    Text("Page").tag("page")
+                }
+            }
+
+            if let editorConfiguration = viewModel.editorConfiguration {
+                Section("Editor Configuration Details") {
+                    KeyValueRow(key: "Site URL", value: editorConfiguration.siteURL.absoluteString)
+                    KeyValueRow(key: "API Root", value: editorConfiguration.siteApiRoot.absoluteString)
+                    KeyValueRow(key: "Supports Block Assets", value: editorConfiguration.shouldUsePlugins)
+                    KeyValueRow(key: "Supports Theme Styles", value: editorConfiguration.shouldUseThemeStyles)
+                }
+            }
+
+            self.preloadSection
+
+            if let error = viewModel.error {
+                Section("Error") {
+                    Text(error.localizedDescription)
+                }
+            }
+        }
+    }
+
+    var preloadSection: some View {
+        Section {
+            Button("Prepare Editor") {
+                withAnimation {
+                    self.viewModel.prepareEditor()
+                }
+            }.disabled(self.viewModel.disableButtons)
+
+            Button("Prepare Editor Ignoring Cache") {
+                withAnimation {
+                    self.viewModel.prepareEditorFromScratch()
+                }
+            }.disabled(self.viewModel.disableButtons)
+
+            Button("Clear Preload Cache") {
+                withAnimation {
+                    self.viewModel.resetEditorCaches()
+                }
+            }.disabled(self.viewModel.disableButtons)
+        } header: {
+            Text("Local Caches")
+        } footer: {
+            if let progress = self.viewModel.loadingProgress {
+                ProgressView(value: progress.fractionCompleted)
+            }
+        }.task {
+            await self.viewModel.countAssetBundles()
+        }
+    }
+}
+
+@Observable
+class SitePreparationViewModel {
+
+    var enableNativeInserter: Bool = true
+
+    var enableNetworkLogging: Bool = false
+
+    var postType: String = "post"
+
+    var cacheBundleCount: Int?
+
+    var isPreparing: Bool = false
+
+    var isPrepared: Bool = false
+
+    var error: Error?
+
+    var configurationItem: ConfigurationItem
+
+    var editorConfiguration: EditorConfiguration?
+
+    var disableButtons: Bool = false
+
+    var loadingProgress: EditorProgress?
+
+    var editorDependencies: EditorDependencies?
+
+    private var taskHandle: Task<Void, Never>?
+
+    init(configurationItem: ConfigurationItem) {
+        self.configurationItem = configurationItem
+    }
+
+    @MainActor
+    func startLoading() {
+        self.taskHandle = Task {
+            do {
+                switch configurationItem {
+                case .bundledEditor:
+                    self.editorConfiguration = .bundled
+                case .editorConfiguration(let siteDetails):
+                    let newConfiguration = try await self.loadConfiguration(for: siteDetails)
+                    self.editorConfiguration = newConfiguration
+                }
+            } catch {
+                self.error = error
+            }
+        }
+    }
+
+    /// Prepares the editor by caching all resources and preparing an `EditorDependencies` object to inject into the editor.
+    /// Once this method is run, the editor should load instantly.
+    @MainActor
+    func prepareEditor() {
+        guard let configuration = self.editorConfiguration else {
+            preconditionFailure("Unable to prepare editor without editor configuration – the UI should prevent this")
+        }
+
+        let cacheInterval: TimeInterval = 86_400  // Cache for one day
+        self.prepareEditor(with: EditorService(configuration: configuration, cachePolicy: .maxAge(cacheInterval)))
+    }
+
+    /// Prepares the editor by caching all resources and preparing an `EditorDependencies` object to inject into the editor.
+    /// Once this method is run, the editor should load instantly.
+    @MainActor
+    func prepareEditorFromScratch() {
+        guard let configuration = self.editorConfiguration else {
+            preconditionFailure("Unable to prepare editor without editor configuration – the UI should prevent this")
+        }
+
+        self.prepareEditor(with: EditorService(configuration: configuration, cachePolicy: .ignore))
+    }
+
+    private func prepareEditor(with editorService: EditorService) {
+        self.taskHandle = Task {
+            self.disableButtons = true
+            defer {
+                self.loadingProgress = nil
+                self.disableButtons = false
+            }
+
+            do {
+                self.editorDependencies = try await editorService.prepare { @MainActor progress in
+                    self.loadingProgress = progress
+                }
+
+                await self.countAssetBundles()
+
+            } catch {
+                self.error = error
+            }
+        }
+
+    }
+
+    /// Clears all local editor data, forcing the loading functions to run the next time the editor starts up. This is useful for testing the built-in
+    /// editor loading code.
+    func resetEditorCaches() {
+        guard let configuration = self.editorConfiguration else {
+            preconditionFailure("Unable to prepare editor without editor configuration – the UI should prevent this")
+        }
+
+        self.taskHandle = Task {
+            do {
+                self.disableButtons = true
+                defer { self.disableButtons = false }
+
+                self.editorDependencies = nil
+
+                let editorService = EditorService(configuration: configuration)
+                try await editorService.purge()
+
+                await self.countAssetBundles()
+            } catch {
+                self.error = error
+            }
+        }
+    }
+
+    func countAssetBundles() async {
+        do {
+            guard let editorConfiguration else {
+                self.cacheBundleCount = 0
+                return
+            }
+
+            let editorService = EditorService(configuration: editorConfiguration)
+            self.cacheBundleCount = try await editorService.fetchAssetBundleCount()
+        } catch {
+            self.error = error
+        }
+    }
+
+    @MainActor
+    private func loadConfiguration(for config: ConfiguredEditor) async throws -> EditorConfiguration {
+        let parsedApiRoot = try ParsedUrl.parse(input: config.siteApiRoot)
+        let client = WordPressAPI(
+            urlSession: .shared,
+            apiRootUrl: parsedApiRoot,
+            authentication: .authorizationHeader(token: config.authHeader)
+        )
+
+        let apiRoot = try await client.apiRoot.get().data
+
+        let canUsePlugins = apiRoot.hasRoute(route: "/wpcom/v2/editor-assets")
+        let canUseEditorStyles = apiRoot.hasRoute(route: "/wp-block-editor/v1/settings")
+
+        return EditorConfigurationBuilder(
+            postType: "post",
+            siteURL: URL(string: apiRoot.siteUrlString())!,
+            siteApiRoot: parsedApiRoot.asURL()
+        )
+        .setShouldUseThemeStyles(canUseEditorStyles)
+        .setShouldUsePlugins(canUsePlugins)
+        .setAuthHeader(config.authHeader)
+        .setLogLevel(.debug)
+        .build()
+    }
+
+    private func buildConfiguration() -> EditorConfiguration {
+        guard let editorConfiguration = self.editorConfiguration else {
+            preconditionFailure("Cannot build configuration as it is not loaded yet")
+        }
+
+        return editorConfiguration.toBuilder()
+            .setEnableNetworkLogging(self.enableNetworkLogging)
+            .setNativeInserterEnabled(self.enableNativeInserter)
+            .setPostType(self.postType)
+            .build()
+    }
+
+    func buildAndLoadConfiguration(navigation: Navigation) {
+        let editor = RunnableEditor(
+            configuration: buildConfiguration(),
+            dependencies: self.editorDependencies
+        )
+
+        navigation.present(editor)
+    }
+}
+
+struct KeyValueRow: View {
+
+    enum Value {
+        case string(String)
+        case bool(Bool)
+    }
+
+    let key: String
+    let value: Value
+
+    init(key: String, value: String) {
+        self.key = key
+        self.value = .string(value)
+    }
+
+    init(key: String, value: Bool) {
+        self.key = key
+        self.value = .bool(value)
+    }
+
+    var body: some View {
+        switch self.value {
+        case .string(let string):
+            VStack(alignment: .leading) {
+                Text(key).font(.caption2).foregroundStyle(Color.secondary)
+                Text(string)
+            }
+        case .bool(let bool):
+            HStack {
+                Text(key)
+                Spacer()
+                Image(systemName: bool ? "checkmark.circle" : "xmark.circle")
+                    .foregroundStyle(bool ? Color.green : Color.red)
+            }
+        }
+    }
+}
+
+#Preview("Bundled Editor") {
+    NavigationStack {
+        SitePreparationView(site: .bundledEditor)
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Constants.swift b/ios/Sources/GutenbergKit/Sources/Constants.swift
new file mode 100644
index 00000000..aabd0c32
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Constants.swift
@@ -0,0 +1,15 @@
+import Foundation
+
+public struct Constants {
+
+    public struct EditorAssetLibrary {
+        public static let urlScheme = "gbk-cache-https"
+    }
+
+    public struct API {
+        public static let editorSettingsPath = "/wp-block-editor/v1/settings"
+        public static let activeThemePath = "/wp/v2/themes?context=edit&status=active"
+        public static let siteSettingsPath = "/wp/v2/settings"
+        public static let postTypesPath = "/wp/v2/types?context=view"
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/EditorConfiguration.swift b/ios/Sources/GutenbergKit/Sources/EditorConfiguration.swift
deleted file mode 100644
index 93694e46..00000000
--- a/ios/Sources/GutenbergKit/Sources/EditorConfiguration.swift
+++ /dev/null
@@ -1,376 +0,0 @@
-import Foundation
-
-public struct EditorConfiguration: Sendable {
-    /// Initial title for populating the editor
-    public let title: String
-    /// Initial content for populating the editor
-    public let content: String
-
-    /// ID of the post being edited
-    public let postID: Int?
-    /// Type of the post being edited
-    public let postType: String?
-    /// Toggles application of theme styles
-    public let shouldUseThemeStyles: Bool
-    /// Toggles loading plugin-provided editor assets
-    public let shouldUsePlugins: Bool
-    /// Toggles visibility of the title field
-    public let shouldHideTitle: Bool
-    /// Root URL for the site
-    public let siteURL: String
-    /// Root URL for the site API
-    public let siteApiRoot: String
-    /// Namespaces for the site API
-    public let siteApiNamespace: [String]
-    /// Paths excluded from API namespacing
-    public let namespaceExcludedPaths: [String]
-    /// Authorization header
-    public let authHeader: String
-    /// Raw block editor settings from the WordPress REST API
-    public let editorSettings: String
-    /// Locale used for translations
-    public let locale: String
-    /// Enables the native inserter UI in the editor
-    public let isNativeInserterEnabled: Bool
-    /// Endpoint for loading editor settings
-    public let editorSettingsEndpoint: URL?
-    /// Endpoint for loading editor assets, used when enabling `shouldUsePlugins`
-    public let editorAssetsEndpoint: URL?
-    /// Logs emitted at or above this level will be printed to the debug console
-    public let logLevel: EditorLogLevel
-    /// Enables logging of all network requests/responses to the native host
-    public let enableNetworkLogging: Bool
-
-    /// Deliberately non-public – consumers should use `EditorConfigurationBuilder` to construct a configuration
-    init(
-        title: String,
-        content: String,
-        postID: Int?,
-        postType: String?,
-        shouldUseThemeStyles: Bool,
-        shouldUsePlugins: Bool,
-        shouldHideTitle: Bool,
-        siteURL: String,
-        siteApiRoot: String,
-        siteApiNamespace: [String],
-        namespaceExcludedPaths: [String],
-        authHeader: String,
-        editorSettings: String,
-        locale: String,
-        isNativeInserterEnabled: Bool,
-        editorSettingsEndpoint: URL?,
-        editorAssetsEndpoint: URL?,
-        logLevel: EditorLogLevel,
-        enableNetworkLogging: Bool = false
-    ) {
-        self.title = title
-        self.content = content
-        self.postID = postID
-        self.postType = postType
-        self.shouldUseThemeStyles = shouldUseThemeStyles
-        self.shouldUsePlugins = shouldUsePlugins
-        self.shouldHideTitle = shouldHideTitle
-        self.siteURL = siteURL
-        self.siteApiRoot = siteApiRoot
-        self.siteApiNamespace = siteApiNamespace
-        self.namespaceExcludedPaths = namespaceExcludedPaths
-        self.authHeader = authHeader
-        self.editorSettings = editorSettings
-        self.locale = locale
-        self.isNativeInserterEnabled = isNativeInserterEnabled
-        self.editorSettingsEndpoint = editorSettingsEndpoint
-        self.editorAssetsEndpoint = editorAssetsEndpoint
-        self.logLevel = logLevel
-        self.enableNetworkLogging = enableNetworkLogging
-    }
-
-    public func toBuilder() -> EditorConfigurationBuilder {
-        return EditorConfigurationBuilder(
-            title: title,
-            content: content,
-            postID: postID,
-            postType: postType,
-            shouldUseThemeStyles: shouldUseThemeStyles,
-            shouldUsePlugins: shouldUsePlugins,
-            shouldHideTitle: shouldHideTitle,
-            siteURL: siteURL,
-            siteApiRoot: siteApiRoot,
-            siteApiNamespace: siteApiNamespace,
-            namespaceExcludedPaths: namespaceExcludedPaths,
-            authHeader: authHeader,
-            editorSettings: editorSettings,
-            locale: locale,
-            isNativeInserterEnabled: isNativeInserterEnabled,
-            editorSettingsEndpoint: editorSettingsEndpoint,
-            editorAssetsEndpoint: editorAssetsEndpoint,
-            logLevel: logLevel,
-            enableNetworkLogging: enableNetworkLogging
-        )
-    }
-
-    var escapedTitle: String {
-        title.addingPercentEncoding(withAllowedCharacters: .alphanumerics)!
-    }
-
-    var escapedContent: String {
-        content.addingPercentEncoding(withAllowedCharacters: .alphanumerics)!
-    }
-
-    public static let `default` = EditorConfigurationBuilder().build()
-}
-
-public struct EditorConfigurationBuilder {
-    private var title: String
-    private var content: String
-    private var postID: Int?
-    private var postType: String?
-    private var shouldUseThemeStyles: Bool
-    private var shouldUsePlugins: Bool
-    private var shouldHideTitle: Bool
-    private var siteURL: String
-    private var siteApiRoot: String
-    private var siteApiNamespace: [String]
-    private var namespaceExcludedPaths: [String]
-    private var authHeader: String
-    private var editorSettings: String
-    private var locale: String
-    private var isNativeInserterEnabled: Bool
-    private var editorSettingsEndpoint: URL?
-    private var editorAssetsEndpoint: URL?
-    private var logLevel: EditorLogLevel
-    private var enableNetworkLogging: Bool
-
-    public init(
-        title: String = "",
-        content: String = "",
-        postID: Int? = nil,
-        postType: String? = nil,
-        shouldUseThemeStyles: Bool = false,
-        shouldUsePlugins: Bool = false,
-        shouldHideTitle: Bool = false,
-        siteURL: String = "",
-        siteApiRoot: String = "",
-        siteApiNamespace: [String] = [],
-        namespaceExcludedPaths: [String] = [],
-        authHeader: String = "",
-        editorSettings: String = "undefined",
-        locale: String = "en",
-        isNativeInserterEnabled: Bool = false,
-        editorSettingsEndpoint: URL? = nil,
-        editorAssetsEndpoint: URL? = nil,
-        logLevel: EditorLogLevel = .error,
-        enableNetworkLogging: Bool = false
-    ){
-        self.title = title
-        self.content = content
-        self.postID = postID
-        self.postType = postType
-        self.shouldUseThemeStyles = shouldUseThemeStyles
-        self.shouldUsePlugins = shouldUsePlugins
-        self.shouldHideTitle = shouldHideTitle
-        self.siteURL = siteURL
-        self.siteApiRoot = siteApiRoot
-        self.siteApiNamespace = siteApiNamespace
-        self.namespaceExcludedPaths = namespaceExcludedPaths
-        self.authHeader = authHeader
-        self.editorSettings = editorSettings
-        self.locale = locale
-        self.isNativeInserterEnabled = isNativeInserterEnabled
-        self.editorSettingsEndpoint = editorSettingsEndpoint
-        self.editorAssetsEndpoint = editorAssetsEndpoint
-        self.logLevel = logLevel
-        self.enableNetworkLogging = enableNetworkLogging
-    }
-
-    public func setTitle(_ title: String) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.title = title
-        return copy
-    }
-
-    public func setContent(_ content: String) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.content = content
-        return copy
-    }
-
-    public func setPostID(_ postID: Int?) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.postID = postID
-        return copy
-    }
-
-    public func setPostType(_ postType: String?) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.postType = postType
-        return copy
-    }
-
-    public func setShouldUseThemeStyles(_ shouldUseThemeStyles: Bool) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.shouldUseThemeStyles = shouldUseThemeStyles
-        return copy
-    }
-
-    public func setShouldUsePlugins(_ shouldUsePlugins: Bool) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.shouldUsePlugins = shouldUsePlugins
-        return copy
-    }
-
-    public func setShouldHideTitle(_ shouldHideTitle: Bool) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.shouldHideTitle = shouldHideTitle
-        return copy
-    }
-
-    public func setSiteUrl(_ siteUrl: String) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.siteURL = siteUrl
-        return copy
-    }
-
-    public func setSiteApiRoot(_ siteApiRoot: String) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.siteApiRoot = siteApiRoot
-        return copy
-    }
-
-    public func setSiteApiNamespace(_ siteApiNamespace: [String]) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.siteApiNamespace = siteApiNamespace
-        return copy
-    }
-
-    public func setNamespaceExcludedPaths(_ namespaceExcludedPaths: [String]) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.namespaceExcludedPaths = namespaceExcludedPaths
-        return copy
-    }
-
-    public func setAuthHeader(_ authHeader: String) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.authHeader = authHeader
-        return copy
-    }
-
-    public func setEditorSettings(_ editorSettings: String) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.editorSettings = editorSettings
-        return copy
-    }
-
-    public func setLocale(_ locale: String) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.locale = locale
-        return copy
-    }
-
-    public func setNativeInserterEnabled(_ isNativeInserterEnabled: Bool = true) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.isNativeInserterEnabled = isNativeInserterEnabled
-        return copy
-    }
-
-    public func setEditorSettingsEndpoint(_ editorSettingsEndpoint: URL?) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.editorSettingsEndpoint = editorSettingsEndpoint
-        return copy
-    }
-
-    public func setEditorAssetsEndpoint(_ editorAssetsEndpoint: URL?) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.editorAssetsEndpoint = editorAssetsEndpoint
-        return copy
-    }
-
-    public func setLogLevel(_ logLevel: EditorLogLevel) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.logLevel = logLevel
-        return copy
-    }
-
-    public func setEnableNetworkLogging(_ enableNetworkLogging: Bool) -> EditorConfigurationBuilder {
-        var copy = self
-        copy.enableNetworkLogging = enableNetworkLogging
-        return copy
-    }
-
-    /// Simplify conditionally applying a configuration change
-    ///
-    /// Sample Code:
-    /// ```swift
-    ///  // Before
-    ///  let configurationBuilder = EditorConfigurationBuilder()
-    ///  if let postID = post.id {
-    ///     configurationBuilder = configurationBuilder.setPostID(postID)
-    ///  }
-    ///
-    ///  // After
-    ///  let configurationBuilder = EditorConfigurationBuilder()
-    ///     .apply(post.id, { $0.setPostID($1) } )
-    /// ```
-    public func apply<T>(_ value: T?, _ closure: (EditorConfigurationBuilder, T) -> EditorConfigurationBuilder) -> Self {
-        guard let value else {
-            return self
-        }
-
-        return closure(self, value)
-    }
-
-    public func build() -> EditorConfiguration {
-        EditorConfiguration(
-            title: title,
-            content: content,
-            postID: postID,
-            postType: postType,
-            shouldUseThemeStyles: shouldUseThemeStyles,
-            shouldUsePlugins: shouldUsePlugins,
-            shouldHideTitle: shouldHideTitle,
-            siteURL: siteURL,
-            siteApiRoot: siteApiRoot,
-            siteApiNamespace: siteApiNamespace,
-            namespaceExcludedPaths: namespaceExcludedPaths,
-            authHeader: authHeader,
-            editorSettings: editorSettings,
-            locale: locale,
-            isNativeInserterEnabled: isNativeInserterEnabled,
-            editorSettingsEndpoint: editorSettingsEndpoint,
-            editorAssetsEndpoint: editorAssetsEndpoint,
-            logLevel: logLevel,
-            enableNetworkLogging: enableNetworkLogging
-        )
-    }
-}
-
-public typealias EditorSettings = [String: Encodable]
-
-// MARK: - EditorConfiguration Extensions
-
-extension EditorConfiguration {
-    /// Extracts CSS styles from the editor settings JSON string
-    func extractThemeStyles() -> String? {
-        guard editorSettings != "undefined",
-              let data = editorSettings.data(using: .utf8),
-              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
-              let styles = json["styles"] as? [[String: Any]] else {
-            return nil
-        }
-
-        // Concatenate all CSS from the styles array
-        let cssArray = styles.compactMap { $0["css"] as? String }
-        return cssArray.isEmpty ? nil : cssArray.joined(separator: "\n")
-    }
-}
-
-// String escaping extension
-private extension String {
-    var escaped: String {
-        return self.replacingOccurrences(of: "\"", with: "\\\"")
-            .replacingOccurrences(of: "\n", with: "\\n")
-            .replacingOccurrences(of: "\r", with: "\\r")
-            .replacingOccurrences(of: "\t", with: "\\t")
-            .replacingOccurrences(of: "\u{8}", with: "\\b")
-            .replacingOccurrences(of: "\u{12}", with: "\\f")
-    }
-}
diff --git a/ios/Sources/GutenbergKit/Sources/EditorDependencies.swift b/ios/Sources/GutenbergKit/Sources/EditorDependencies.swift
deleted file mode 100644
index 80f66e3b..00000000
--- a/ios/Sources/GutenbergKit/Sources/EditorDependencies.swift
+++ /dev/null
@@ -1,22 +0,0 @@
-import Foundation
-
-/// Dependencies fetched from the WordPress REST API required for the editor
-struct EditorDependencies: Sendable {
-    /// Raw block editor settings from the WordPress REST API
-    var editorSettings: String?
-
-    /// Extracts CSS styles from the editor settings JSON string
-    func extractThemeStyles() -> String? {
-        guard let editorSettings = editorSettings,
-              editorSettings != "undefined",
-              let data = editorSettings.data(using: .utf8),
-              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
-              let styles = json["styles"] as? [[String: Any]] else {
-            return nil
-        }
-
-        // Concatenate all CSS from the styles array
-        let cssArray = styles.compactMap { $0["css"] as? String }
-        return cssArray.isEmpty ? nil : cssArray.joined(separator: "\n")
-    }
-}
diff --git a/ios/Sources/GutenbergKit/Sources/EditorHTTPClient.swift b/ios/Sources/GutenbergKit/Sources/EditorHTTPClient.swift
new file mode 100644
index 00000000..6973288d
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/EditorHTTPClient.swift
@@ -0,0 +1,96 @@
+import Foundation
+import OSLog
+
+/// A protocol for making authenticated HTTP requests to the WordPress REST API.
+public protocol EditorHTTPClientProtocol: Sendable {
+    func perform(_ urlRequest: URLRequest) async throws -> (Data, HTTPURLResponse)
+    func download(_ urlRequest: URLRequest) async throws -> (URL, HTTPURLResponse)
+}
+
+/// A delegate for observing HTTP requests made by the editor.
+///
+/// Implement this protocol to inspect or log all network requests.
+public protocol EditorHTTPClientDelegate {
+    func didPerformRequest(_ request: URLRequest, response: URLResponse, data: Data)
+}
+
+/// A WordPress REST API error response.
+struct WPError: Decodable {
+    let code: String
+    let message: String
+}
+
+/// An HTTP client for making authenticated requests to the WordPress REST API.
+///
+/// This actor handles request signing, error parsing, and response validation.
+/// All requests are automatically authenticated using the provided authorization header.
+public actor EditorHTTPClient: EditorHTTPClientProtocol {
+
+    /// Errors that can occur during HTTP requests.
+    enum ClientError: Error {
+        /// The server returned a WordPress-formatted error response.
+        case wpError(WPError)
+        /// A file download failed with the given HTTP status code.
+        case downloadFailed(statusCode: Int)
+        /// An unexpected error occurred with the given response data and status code.
+        case unknown(response: Data, statusCode: Int)
+    }
+    
+    private let urlSession: URLSession
+    private let authHeader: String
+    private let delegate: EditorHTTPClientDelegate?
+    private let requestTimeout: TimeInterval
+
+    public init(
+        urlSession: URLSession,
+        authHeader: String,
+        delegate: EditorHTTPClientDelegate? = nil,
+        requestTimeout: TimeInterval = 60 // `URLRequest` default
+    ) {
+        self.urlSession = urlSession
+        self.authHeader = authHeader
+        self.delegate = delegate
+        self.requestTimeout = requestTimeout
+    }
+
+    public func perform(_ urlRequest: URLRequest) async throws -> (Data, HTTPURLResponse) {
+        var mutableRequest = urlRequest
+        mutableRequest.setValue(self.authHeader, forHTTPHeaderField: "Authorization")
+        mutableRequest.timeoutInterval = self.requestTimeout
+
+        let (data, response) = try await self.urlSession.data(for: mutableRequest)
+        self.delegate?.didPerformRequest(mutableRequest, response: response, data: data)
+
+        let httpResponse = response as! HTTPURLResponse
+
+        guard 200...299 ~= httpResponse.statusCode else {
+            Logger.http.error("📡 HTTP error fetching \(mutableRequest.url!.absoluteString): \(httpResponse.statusCode)")
+
+            if let wpError = try? JSONDecoder().decode(WPError.self, from: data) {
+                throw ClientError.wpError(wpError)
+            }
+
+            throw ClientError.unknown(response: data, statusCode: httpResponse.statusCode)
+        }
+
+        return (data, httpResponse)
+    }
+
+    public func download(_ urlRequest: URLRequest) async throws -> (URL, HTTPURLResponse) {
+        var mutableRequest = urlRequest
+        mutableRequest.addValue(self.authHeader, forHTTPHeaderField: "Authorization")
+        mutableRequest.timeoutInterval = self.requestTimeout
+
+        let (url, response) = try await self.urlSession.download(for: mutableRequest)
+
+        let httpResponse = response as! HTTPURLResponse
+
+        guard 200...299 ~= httpResponse.statusCode else {
+            Logger.http.error("📡 HTTP error fetching \(mutableRequest.url!.absoluteString): \(httpResponse.statusCode)")
+
+            throw ClientError.downloadFailed(statusCode: httpResponse.statusCode)
+        }
+
+        return (url, response as! HTTPURLResponse)
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/EditorLocalization.swift b/ios/Sources/GutenbergKit/Sources/EditorLocalization.swift
index 039f4f0b..6f11ad9a 100644
--- a/ios/Sources/GutenbergKit/Sources/EditorLocalization.swift
+++ b/ios/Sources/GutenbergKit/Sources/EditorLocalization.swift
@@ -17,6 +17,10 @@ public enum EditorLocalizableString {
     case insertPattern
     case patternsCategoryUncategorized
     case patternsCategoryAll
+
+    // MARK: - Editor Loading
+    case loadingEditor
+    case editorError
 }
 
 /// Provides localized strings for the editor.
@@ -40,6 +44,8 @@ public final class EditorLocalization {
         case .insertPattern: "Insert Pattern"
         case .patternsCategoryUncategorized: "Uncategorized"
         case .patternsCategoryAll: "All"
+        case .loadingEditor: "Loading Editor"
+        case .editorError: "Editor Error"
         }
     }
 
diff --git a/ios/Sources/GutenbergKit/Sources/EditorLogging.swift b/ios/Sources/GutenbergKit/Sources/EditorLogging.swift
index 77ff2e46..bf090330 100644
--- a/ios/Sources/GutenbergKit/Sources/EditorLogging.swift
+++ b/ios/Sources/GutenbergKit/Sources/EditorLogging.swift
@@ -1,4 +1,5 @@
 import Foundation
+import OSLog
 
 /// Protocol for logging editor-related messages.
 public protocol EditorLogging: Sendable {
@@ -6,6 +7,52 @@ public protocol EditorLogging: Sendable {
     func log(_ level: EditorLogLevel, _ message: String)
 }
 
+extension Logger {
+
+    public static let performance = OSSignposter(subsystem: "GutenbergKit", category: "performance")
+
+    /// Logs timings for performance optimization
+    public static let timing = Logger(subsystem: "GutenbergKit", category: "timing")
+    
+    /// Logs editor asset library activity
+    public static let assetLibrary = Logger(subsystem: "GutenbergKit", category: "asset-library")
+    
+    /// Logs editor HTTP activity
+    public static let http = Logger(subsystem: "GutenbergKit", category: "http")
+}
+
+public struct SignpostMonitor: Sendable {
+    private let id: OSSignpostID
+    private let logger: OSSignposter
+
+    private var subtasks: [String: OSSignpostIntervalState] = [:]
+
+    public init(for logger: OSSignposter) {
+
+        self.logger = logger
+        self.id = logger.makeSignpostID()
+    }
+
+    public mutating func startTask(_ event: StaticString = #function) {
+        self.subtasks["\(event)"] = self.logger.beginInterval(event, id: id)
+    }
+
+    public mutating func endTask(_ event: StaticString = #function) {
+        precondition(self.subtasks["\(event)"] != nil)
+        self.logger.endInterval(event, self.subtasks["\(event)"]!)
+    }
+
+    public func measure<T>(_ name: StaticString = #function, _ work: () throws -> T) rethrows -> T {
+        try self.logger.withIntervalSignpost(name, id: self.id, around: work)
+    }
+
+    public func measure<T>(_ name: StaticString = #function, _ work: @Sendable () async throws -> T) async rethrows -> T {
+        let handle = self.logger.beginInterval(name)
+        defer { self.logger.endInterval(name, handle) }
+        return try await work()
+    }
+}
+
 /// Global logger for GutenbergKit.
 ///
 /// - warning: The shared properties are nonisolated and should be set once
@@ -13,14 +60,14 @@ public protocol EditorLogging: Sendable {
 public enum EditorLogger {
     /// The shared logger instance used throughout GutenbergKit.
     public nonisolated(unsafe) static var shared: EditorLogging?
-
     /// The log level. Messages below this level are ignored.
     public nonisolated(unsafe) static var logLevel: EditorLogLevel = .error
 }
 
 func log(_ level: EditorLogLevel, _ message: @autoclosure () -> String) {
     guard level.priority >= EditorLogger.logLevel.priority,
-          let logger = EditorLogger.shared else {
+          let logger = EditorLogger.shared
+    else {
         return
     }
     logger.log(level, message())
diff --git a/ios/Sources/GutenbergKit/Sources/EditorViewController.swift b/ios/Sources/GutenbergKit/Sources/EditorViewController.swift
index b2f5e069..f684546a 100644
--- a/ios/Sources/GutenbergKit/Sources/EditorViewController.swift
+++ b/ios/Sources/GutenbergKit/Sources/EditorViewController.swift
@@ -1,61 +1,164 @@
 @preconcurrency import WebKit
 import SwiftUI
-import Combine
-import CryptoKit
+import OSLog
 
 #if canImport(UIKit)
 import UIKit
 
+// MARK: - EditorViewController Loading Process
+//
+// The EditorViewController manages the Gutenberg block editor on iOS.
+// It supports two distinct loading flows based on whether dependencies are pre-fetched or not.
+//
+// ## Loading Flow
+//
+// ```
+// ┌───────────────────────────────────────────────────────────────────────────────┐
+// │                              INITIALIZATION                                   │
+// └───────────────────────────────────────────────────────────────────────────────┘
+//                                      ▼
+// ┌───────────────────────────────────────────────────────────────────────────────┐
+// │                               viewDidLoad()                                   │
+// │  • Branch based on initialization parameters                                  │
+// └───────────────────────────────────────────────────────────────────────────────┘
+//              ┌───────────────────────┼───────────────────────┐
+//              ▼                       ▼                       ▼
+// ┌────────────────────┐  ┌────────────────────┐  ┌───────────────────────────────┐
+// │   WARMUP MODE      │  │ DEPENDENCIES       │  │ NO DEPENDENCIES               │
+// │   (isWarmupMode)   │  │ PROVIDED           │  │ (Async Flow)                  │
+// │                    │  │ (Fast Path)        │  │                               │
+// │ Load HTML without  │  │                    │  │ Spawn Task to fetch           │
+// │ any dependencies   │  │ loadEditor()       │  │ dependencies                  │
+// │ for prewarming     │  │ immediately        │  │                               │
+// └────────────────────┘  └────────────────────┘  └───────────────────────────────┘
+//                                      │                       ▼
+//                                      │          ┌───────────────────────────────┐
+//                                      │          │ prepareEditor()               │
+//                                      │          │  • Load editor dependencies   │
+//                                      │          └───────────────────────────────┘
+//                                      │                       ▼
+//                                      │          ┌───────────────────────────────┐
+//                                      └─────────►│ loadEditor()                  │
+//                                                 │  • Load editor JS into webview│
+//                                                 └───────────────────────────────┘
+//                                                             ▼
+//                                                 ┌───────────────────────────────┐
+//                                                 │   WebView Navigation          │
+//                                                 │  • JS Compiled                │
+//                                                 │  • Gutenberg initialized      │
+//                                                 │  • `onEditorLoaded` sent      │
+//                                                 └───────────────────────────────┘
+//                                                             ▼
+//                                                 ┌───────────────────────────────┐
+//                                                 │ didLoadEditor()               │
+//                                                 │  • isReady = true             │
+//                                                 │  • JS methods now safe to use │
+//                                                 └───────────────────────────────┘
+// ```
+//
+// ## Flow 1: Dependencies Provided (Fast Path)
+//
+// When `EditorDependencies` are passed to `init()`, the editor skips the async
+// dependency fetching phase entirely. This is useful when:
+// - Dependencies were pre-fetched by the host app
+// - The app wants to control caching/fetching separately
+//
+// ## Flow 2: No Dependencies (Async Flow)
+//
+// When no dependencies are provided, the controller fetches them asynchronously.
+// This is a fallback behaviour – the host app should provide the dependencies if it can,
+// because it'll be a much better user experience.
+//
 @MainActor
 public final class EditorViewController: UIViewController, GutenbergEditorControllerDelegate, UIAdaptivePresentationControllerDelegate, UIPopoverPresentationControllerDelegate, UISheetPresentationControllerDelegate {
-    public let webView: WKWebView
-    let service: EditorService
-    let assetsLibrary: EditorAssetsLibrary
 
+    public let webView: WKWebView
     public var configuration: EditorConfiguration
+
+    /// The current editor state (empty, has undo/redo history).
+    public private(set) var state = EditorState()
+
+    /// Delegate for receiving editor lifecycle and content change callbacks.
+    public weak var delegate: EditorViewControllerDelegate?
+
+    /// The fetched or provided editor dependencies (settings, assets, preload data).
     private var dependencies: EditorDependencies?
-    private var _isEditorRendered = false
-    private var _isEditorSetup = false
+    private var dependencyTaskHandle: Task<Void, Never>?
+
+    /// Error encountered while loading dependencies.
+    private var error: Error? {
+        didSet {
+            if let error {
+                self.displayError(error)
+            }
+        }
+    }
+
+    /// Indicates whether the editor JavaScript has initialized and is ready for use.
+    /// Set to `true` when the `onEditorLoaded` message is received from JavaScript.
+    /// - Important: JS `editor` APIs are only safe to call after this becomes `true`.
+    private var isReady: Bool = false
+
+    /// When `true`, loads editor HTML without dependencies for WebKit prewarming.
+    /// Used by `EditorViewController.warmup()` to reduce first-render latency.
+    private let isWarmupMode: Bool
+
+    // MARK: - Private Properties (Services)
+    private let editorService: EditorService
     private let mediaPicker: MediaPickerController?
     private let controller: GutenbergEditorController
-    private let timestampInit = CFAbsoluteTimeGetCurrent()
+    private let bundleProvider = EditorAssetBundleProvider()
 
-    public private(set) var state = EditorState()
+    // MARK: - Private Properties (UI)
 
-    public weak var delegate: EditorViewControllerDelegate?
+    /// Progress bar shown during async dependency fetching ("No Dependencies" flow).
+    private let progressView = UIEditorProgressView(loadingText: EditorLocalization.localize(.loadingEditor))
 
-    private var cancellables: [AnyCancellable] = []
+    /// Spinning indicator shown while WebKit loads and parses the editor JavaScript.
+    private let waitingView = UIActivityIndicatorView(style: .medium)
 
-    /// Stores the contextId from the most recent openMediaLibrary call
-    /// to pass back to JavaScript when media is selected
+    /// View controller that displays error information when loading fails.
+    private var errorViewController: UIHostingController<AnyView>?
+
+    /// Stores the contextId from the most recent `openMediaLibrary` JS call.
+    /// Passed back to JavaScript when media selection completes.
     private var currentMediaContextId: String?
 
-    /// Warmup mode preloads resources into memory to make the UI transition seamless when displaying the editor for the first time
-    private let isWarmupMode: Bool
+    // MARK: - Private Properties (Timing)
+
+    /// Timestamp captured at initialization for measuring first-render performance.
+    private let timestampInit = CFAbsoluteTimeGetCurrent()
 
-    /// Overlay view shown over the navigation bar when modal dialogs are open
+    /// Semi-transparent overlay shown over the navigation bar when JS modal dialogs are open.
+    /// Prevents user interaction with navigation items while a modal is displayed.
     private lazy var navigationOverlayView: UIView = {
         let view = UIView()
         view.backgroundColor = UIColor.black.withAlphaComponent(0.3)
         view.isUserInteractionEnabled = true
-        view.isHidden =  true
+        view.isHidden = true
         view.translatesAutoresizingMaskIntoConstraints = false
         return view
     }()
 
-    /// HTML Preview Manager instance for rendering pattern previews
-    private(set) lazy var htmlPreviewManager = HTMLPreviewManager(themeStyles: dependencies?.extractThemeStyles())
+    /// Renders HTML previews for block patterns in the block inserter.
+    private lazy var htmlPreviewManager: HTMLPreviewManager = {
+        guard let dependencies else {
+            preconditionFailure("Editor does not have dependencies, cannot create HTMLPreviewManager")
+        }
+
+        return HTMLPreviewManager(themeStyles: dependencies.editorSettings.themeStyles)
+    }()
 
-    /// Initalizes the editor with the initial content (Gutenberg).
     public init(
-        configuration: EditorConfiguration = .default,
+        configuration: EditorConfiguration,
+        dependencies: EditorDependencies? = nil,
         mediaPicker: MediaPickerController? = nil,
         isWarmupMode: Bool = false
     ) {
-        self.service = EditorService.shared(for: configuration.siteURL)
         self.configuration = configuration
+        self.dependencies = dependencies
+        self.editorService = EditorService(configuration: configuration)
         self.mediaPicker = mediaPicker
-        self.assetsLibrary = EditorAssetsLibrary(service: service, configuration: configuration)
         self.controller = GutenbergEditorController(configuration: configuration)
 
         // The `allowFileAccessFromFileURLs` allows the web view to access the
@@ -70,11 +173,7 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
         // This is important so they user can't select anything but text across blocks.
         config.selectionGranularity = .character
 
-        let schemeHandler = CachedAssetSchemeHandler(service: service)
-        for scheme in CachedAssetSchemeHandler.supportedURLSchemes {
-            config.setURLSchemeHandler(schemeHandler, forURLScheme: scheme)
-        }
-        config.setURLSchemeHandler(MediaFileSchemeHandler(), forURLScheme: MediaFileSchemeHandler.scheme)
+        self.bundleProvider.bind(to: config)
 
         self.webView = GBWebView(frame: .zero, configuration: config)
         self.webView.scrollView.keyboardDismissMode = .interactive
@@ -88,6 +187,7 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
         fatalError("init(coder:) has not been implemented")
     }
 
+    // MARK: - View Lifecycle (Loading Entry Point)
     public override func viewDidLoad() {
         super.viewDidLoad()
 
@@ -106,10 +206,26 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
             webView.bottomAnchor.constraint(equalTo: view.keyboardLayoutGuide.topAnchor)
         ])
 
+        // WebView starts hidden; fades in when editor is ready (see didLoadEditor())
         webView.alpha = 0
 
+        // Warmup mode - load HTML without dependencies for WebKit prewarming
         if isWarmupMode {
-            startEditorSetup()
+            self.loadEditorWithoutDependencies()
+        }
+
+        if let dependencies {
+            // FAST PATH: Dependencies were provided at init() - load immediately
+            do {
+                try self.loadEditor(dependencies: dependencies)
+            } catch {
+                self.error = error
+            }
+        } else {
+            // ASYNC FLOW: No dependencies - fetch them asynchronously
+            self.dependencyTaskHandle = Task(priority: .userInitiated) {
+                await self.prepareEditor()
+            }
         }
     }
 
@@ -123,20 +239,58 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
         removeNavigationOverlay()
     }
 
-    private func setUpEditor() {
-        let webViewConfiguration = webView.configuration
-        let userContentController = webViewConfiguration.userContentController
-        let editorInitialConfig = getEditorConfiguration()
-        userContentController.addUserScript(editorInitialConfig)
+    public override func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        self.dependencyTaskHandle?.cancel()
     }
 
-    private func loadEditor() {
-        webView.configuration.userContentController.addScriptMessageHandler(
-            EditorAssetsProvider(library: assetsLibrary),
-            contentWorld: .page,
-            name: "loadFetchedEditorAssets"
-        )
+    /// Fetches all required dependencies and then loads the editor.
+    ///
+    /// This method is the entry point for the **Async Flow** (when no dependencies were provided at init).
+    @MainActor
+    private func prepareEditor() async {
+        self.displayProgressView()
+        defer { self.hideProgressView() }
+
+        do {
+            // EditorService.prepare() fetches dependencies concurrently with progress reporting
+            let dependencies = try await self.editorService.prepare { @MainActor progress in
+                self.progressView.setProgress(progress, animated: true)
+            }
+
+            // Store dependencies for later use (e.g., HTMLPreviewManager)
+            self.dependencies = dependencies
 
+            // Continue to the shared loading path
+            try self.loadEditor(dependencies: dependencies)
+        } catch {
+            // Display error view - this sets self.error which triggers displayError()
+            self.error = error
+        }
+    }
+
+    // MARK: - Shared Loading Path: Load Editor into WebView
+
+    /// Loads the editor HTML into the WebView with the given dependencies.
+    ///
+    /// This is the **shared loading path** used by both flows after dependencies are available.
+    ///
+    /// After this method completes, WebKit will parse the HTML and execute JavaScript.
+    /// The editor will eventually emit an `onEditorLoaded` message, triggering `didLoadEditor()`.
+    ///
+    @MainActor
+    private func loadEditor(dependencies: EditorDependencies) throws {
+        self.displayActivityView()
+        defer { self.hideActivityView() }
+
+        // Set asset bundle for the URL scheme handler to serve cached plugin/theme assets
+        self.bundleProvider.set(bundle: dependencies.assetBundle)
+
+        // Build and inject editor configuration as window.GBKit
+        let editorConfig = try buildEditorConfiguration(dependencies: dependencies)
+        webView.configuration.userContentController.addUserScript(editorConfig)
+
+        // Load editor HTML - supports dev server via environment variable
         if let editorURL = ProcessInfo.processInfo.environment["GUTENBERG_EDITOR_URL"].flatMap(URL.init) {
             webView.load(URLRequest(url: editorURL))
         } else {
@@ -145,41 +299,46 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
         }
     }
 
-    private func getEditorConfiguration() -> WKUserScript {
-        let jsCode = """
-        window.GBKit = {
-            siteURL: '\(configuration.siteURL)',
-            siteApiRoot: '\(configuration.siteApiRoot)',
-            siteApiNamespace: \(Array(configuration.siteApiNamespace)),
-            namespaceExcludedPaths: \(Array(configuration.namespaceExcludedPaths)),
-            authHeader: '\(configuration.authHeader)',
-            themeStyles: \(configuration.shouldUseThemeStyles),
-            plugins: \(configuration.shouldUsePlugins),
-            enableNativeBlockInserter: \(configuration.isNativeInserterEnabled),
-            hideTitle: \(configuration.shouldHideTitle),
-            editorSettings: \(dependencies?.editorSettings ?? "undefined"),
-            locale: '\(configuration.locale)',
-            post: {
-                id: \(configuration.postID ?? -1),
-                title: '\(configuration.escapedTitle)',
-                content: '\(configuration.escapedContent)'
-            },
-            logLevel: '\(configuration.logLevel)',
-            enableNetworkLogging: \(configuration.enableNetworkLogging)
-        };
+    /// Loads the editor HTML without any dependencies (warmup mode only).
+    ///
+    /// This method is used exclusively by the warmup mechanism to preload editor resources
+    /// into WebKit's memory cache. The editor won't be functional without dependencies,
+    /// but subsequent loads will be faster because WebKit has already parsed the HTML/JS.
+    ///
+    /// - Note: Only called when `isWarmupMode` is true.
+    private func loadEditorWithoutDependencies() {
+        let indexURL = Bundle.module.url(forResource: "index", withExtension: "html", subdirectory: "Gutenberg")!
+        webView.loadFileURL(indexURL, allowingReadAccessTo: Bundle.module.resourceURL!)
+    }
 
-        localStorage.setItem('GBKit', JSON.stringify(window.GBKit));
+    /// Builds a `WKUserScript` that injects the editor configuration into the page.
+    ///
+    /// The configuration is injected as `window.GBKit` at document start, before any other
+    /// scripts run. This ensures the editor JavaScript has access to all configuration data
+    /// when it initializes.
+    ///
+    private func buildEditorConfiguration(dependencies: EditorDependencies) throws -> WKUserScript {
+        let gbkitGlobal = try GBKitGlobal(configuration: self.configuration, dependencies: dependencies)
+        let stringValue = try gbkitGlobal.toString()
 
+        let jsCode = """
+        window.GBKit = \(stringValue);
+        localStorage.setItem('GBKit', JSON.stringify(window.GBKit));
         "done";
         """
 
-        let editorScript = WKUserScript(source: jsCode, injectionTime: .atDocumentStart, forMainFrameOnly: true)
-        return editorScript
+        return WKUserScript(source: jsCode, injectionTime: .atDocumentStart, forMainFrameOnly: true)
     }
 
     /// Deletes all cached editor data for all sites
     public static func deleteAllData() throws {
-        try EditorService.deleteAllData()
+        if FileManager.default.directoryExists(at: Paths.defaultCacheRoot) {
+            try FileManager.default.removeItem(at: Paths.defaultCacheRoot)
+        }
+
+        if FileManager.default.directoryExists(at: Paths.defaultStorageRoot) {
+            try FileManager.default.removeItem(at: Paths.defaultStorageRoot)
+        }
     }
 
     // MARK: - Public API
@@ -191,7 +350,9 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
     }
 
     private func _setContent(_ content: String) {
-        guard _isEditorRendered else { return }
+        guard self.isReady else {
+            return
+        }
 
         let escapedString = content.addingPercentEncoding(withAllowedCharacters: .alphanumerics)!
         evaluate("editor.setContent('\(escapedString)');", isCritical: true)
@@ -248,18 +409,6 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
         self.configuration = newConfiguration
     }
 
-    /// Starts the editor setup process
-    public func startEditorSetup() {
-        guard !_isEditorSetup else { return }
-        _isEditorSetup = true
-
-        Task { @MainActor in
-            dependencies = await service.dependencies(for: configuration, isWarmup: isWarmupMode)
-            setUpEditor()
-            loadEditor()
-        }
-    }
-
     // MARK: - Internal (JavaScript)
 
     private func evaluate(_ javascript: String, isCritical: Bool = false) {
@@ -509,17 +658,35 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
         }
     }
 
-    // Only after this point it's safe to use JS `editor` API.
+    // MARK: - Loading Complete: Editor Ready
+
+    /// Called when the editor JavaScript emits the `onEditorLoaded` message.
+    ///
+    /// This method marks the **final step of the loading process** for both flows.
+    /// At this point:
+    /// - All dependencies have been fetched (or were provided)
+    /// - The HTML has been loaded and parsed
+    /// - The JavaScript has executed and the editor has mounted
+    ///
+    /// **Important**: Only after this method completes is it safe to call JS `editor` APIs
+    ///
     private func didLoadEditor() {
-        guard !_isEditorRendered else { return }
-        _isEditorRendered = true
+        // Guard against multiple onEditorLoaded events (e.g., from location.reload())
+        guard !self.isReady else {
+            return
+        }
+
+        self.isReady = true
 
+        // Fade in the WebView - it was hidden (alpha = 0) since viewDidLoad()
         UIView.animate(withDuration: 0.2, delay: 0.1, options: [.allowUserInteraction]) {
             self.webView.alpha = 1
         }
 
+        // Log performance timing for monitoring
         let duration = CFAbsoluteTimeGetCurrent() - timestampInit
         print("gutenbergkit-measure_editor-first-render:", duration)
+
         delegate?.editorDidLoad(self)
 
         if configuration.content.isEmpty {
@@ -599,5 +766,78 @@ private final class GutenbergEditorController: NSObject, WKNavigationDelegate, W
     }
 }
 
+//MARK: - View Transformation
+extension EditorViewController {
+
+    @MainActor
+    func displayError(_ error: Error) {
+        let view = ContentUnavailableView(
+            EditorLocalization.localize(.editorError),
+            systemImage: "exclamationmark.circle",
+            description: Text(error.localizedDescription)
+        )
+
+        self.errorViewController = UIHostingController(rootView: AnyView(view))
+        self.displayAndCenterView(errorViewController!.view)
+        self.errorViewController?.didMove(toParent: self)
+    }
+
+    @MainActor
+    func hideError() {
+        self.errorViewController?.view.removeFromSuperview()
+    }
+
+    @MainActor
+    func displayProgressView() {
+        self.progressView.layer.opacity = 0
+        self.displayAndCenterView(self.progressView)
+
+        UIView.animate(withDuration: 0.2, delay: 0.2) {
+            self.progressView.layer.opacity = 1
+        }
+    }
+
+    @MainActor
+    func hideProgressView() {
+        UIView.animate(withDuration: 0.2) {
+            self.progressView.layer.opacity = 0
+        } completion: { _ in
+            self.progressView.removeFromSuperview()
+        }
+    }
+
+    @MainActor
+    func displayActivityView() {
+        self.waitingView.layer.opacity = 0
+        self.displayAndCenterView(self.waitingView)
+        self.waitingView.startAnimating()
+
+        UIView.animate(withDuration: 0.2) {
+            self.waitingView.layer.opacity = 1
+        }
+    }
+
+    @MainActor
+    func hideActivityView() {
+        UIView.animate(withDuration: 0.2) {
+            self.waitingView.layer.opacity = 0
+        } completion: { _ in
+            self.waitingView.stopAnimating()
+            self.waitingView.removeFromSuperview()
+        }
+    }
+
+    private func displayAndCenterView(_ newView: UIView) {
+        newView.translatesAutoresizingMaskIntoConstraints = false
+        self.view.addSubview(newView)
+        self.view.bringSubviewToFront(newView)
+        NSLayoutConstraint.activate([
+            newView.centerXAnchor.constraint(equalTo: self.view.centerXAnchor),
+            newView.centerYAnchor.constraint(equalTo: self.view.centerYAnchor),
+            newView.leadingAnchor.constraint(equalTo: self.view.leadingAnchor),
+            newView.trailingAnchor.constraint(equalTo: self.view.trailingAnchor),
+        ])
+    }
+}
 
 #endif
diff --git a/ios/Sources/GutenbergKit/Sources/Extensions/Foundation+Extensions.swift b/ios/Sources/GutenbergKit/Sources/Extensions/Foundation+Extensions.swift
new file mode 100644
index 00000000..aa76bb7c
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Extensions/Foundation+Extensions.swift
@@ -0,0 +1,120 @@
+import CryptoKit
+import Foundation
+
+// MARK: - FileManager Extensions
+
+extension FileManager {
+    /// Checks whether a file exists at the given URL.
+    ///
+    /// - Parameter url: The file URL to check.
+    /// - Returns: `true` if a file exists at the URL, `false` otherwise.
+    public func fileExists(at url: URL) -> Bool {
+        return self.fileExists(atPath: url.path(percentEncoded: false))
+    }
+
+    /// Checks whether a directory exists at the given URL.
+    ///
+    /// - Parameter url: The directory URL to check.
+    /// - Returns: `true` if a directory exists at the URL, `false` otherwise.
+    ///
+    ///   Returns `false` if a file (not a directory) exists at the URL.
+    public func directoryExists(at url: URL) -> Bool {
+        var isDirectory: ObjCBool = true
+        let exists = self.fileExists(atPath: url.path(percentEncoded: false), isDirectory: &isDirectory)
+        return exists && isDirectory.boolValue
+    }
+}
+
+// MARK: - URL Extensions
+
+extension URL {
+    /// Returns the path and query components of the URL as a single string.
+    ///
+    /// If the URL has a query string, returns the path followed by `?` and the query.
+    /// Otherwise, returns just the path.
+    ///
+    /// Example: For `https://example.com/api/posts?page=1`, returns `/api/posts?page=1`.
+    var pathAndQuery: String {
+        if let query = self.query(percentEncoded: false) {
+            return self.path() + "?" + query
+        }
+
+        return self.path(percentEncoded: false)
+    }
+
+    /// Appends a raw path string to the URL without percent-encoding.
+    ///
+    /// This method handles slash normalization between the base URL and the path being appended,
+    /// ensuring exactly one slash separates them.
+    ///
+    /// - Parameter rawPath: The path to append. May or may not start with a slash.
+    /// - Returns: A new URL with the path appended.
+    func appending(rawPath: String) -> URL {
+        let urlString = self.absoluteString
+
+        if urlString.hasSuffix("/") && rawPath.hasPrefix("/") {
+            return URL(string: urlString + rawPath.trimmingPrefix("/"))!
+        }
+
+        if !urlString.hasSuffix("/") && !rawPath.hasPrefix("/") {
+            return URL(string: urlString + "/" + rawPath)!
+        }
+
+        return URL(string: urlString + rawPath)!
+    }
+
+    func replacing(scheme: String) -> URL {
+        var components = URLComponents(url: self, resolvingAgainstBaseURL: false)
+        components!.scheme = scheme
+        return components!.url!
+    }
+}
+
+// MARK: - URLRequest Extensions
+
+extension URLRequest {
+    /// Creates a URL request with the specified URL and HTTP method.
+    ///
+    /// - Parameters:
+    ///   - url: The URL for the request.
+    ///   - method: The HTTP method to use.
+    init(method: EditorHttpMethod, url: URL) {
+        var request = URLRequest(url: url)
+        request.httpMethod = method.rawValue
+        self = request
+    }
+}
+
+// MARK: - Data Extensions
+
+extension Data {
+    /// Computes a SHA-256 hash of the data and returns it as a hexadecimal string.
+    ///
+    /// - Returns: A 64-character lowercase hexadecimal string representing the SHA-256 hash.
+    func hash() -> String {
+        SHA256.hash(data: self).compactMap { String(format: "%02x", $0) }.joined()
+    }
+}
+
+// MARK: - String Extensions
+
+extension String {
+    /// Calculates SHA1 from the given string and returns its hex representation.
+      ///
+      /// ```swift
+      /// print("http://test.com".sha1)
+      /// // prints "50334ee0b51600df6397ce93ceed4728c37fee4e"
+      /// ```
+      var sha1: String {
+          guard let input = self.data(using: .utf8) else {
+              assertionFailure("Failed to generate data for the string")
+              return "" // The conversion to .utf8 should never fail
+          }
+          let digest = Insecure.SHA1.hash(data: input)
+          var output = ""
+          for byte in digest {
+              output.append(String(format: "%02x", byte))
+          }
+          return output
+      }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Extensions/String+Extensions.swift b/ios/Sources/GutenbergKit/Sources/Extensions/String+Extensions.swift
deleted file mode 100644
index d579be30..00000000
--- a/ios/Sources/GutenbergKit/Sources/Extensions/String+Extensions.swift
+++ /dev/null
@@ -1,23 +0,0 @@
-import Foundation
-import CryptoKit
-
-extension String {
-    /// Calculates SHA1 from the given string and returns its hex representation.
-      ///
-      /// ```swift
-      /// print("http://test.com".sha1)
-      /// // prints "50334ee0b51600df6397ce93ceed4728c37fee4e"
-      /// ```
-      var sha1: String {
-          guard let input = self.data(using: .utf8) else {
-              assertionFailure("Failed to generate data for the string")
-              return "" // The conversion to .utf8 should never fail
-          }
-          let digest = Insecure.SHA1.hash(data: input)
-          var output = ""
-          for byte in digest {
-              output.append(String(format: "%02x", byte))
-          }
-          return output
-      }
-}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/EditorAssetBundle.swift b/ios/Sources/GutenbergKit/Sources/Model/EditorAssetBundle.swift
new file mode 100644
index 00000000..b4d36d84
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/EditorAssetBundle.swift
@@ -0,0 +1,200 @@
+import CryptoKit
+import Foundation
+import SwiftSoup
+
+/// A cached collection of editor assets downloaded from a remote manifest.
+///
+/// An `EditorAssetBundle` represents an on-disk cache of JavaScript and CSS assets
+/// required by WordPress plugins and themes. The bundle is created by downloading
+/// all assets specified in a server-provided manifest and storing them locally.
+///
+/// Bundles are identified by their manifest checksum, ensuring that different
+/// versions of plugin/theme assets are stored separately. The `downloadDate`
+/// property allows the system to prefer newer bundles over older ones.
+///
+/// Assets are accessed via URL lookup - the bundle maintains a mapping from
+/// original remote URLs to local file paths.
+public struct EditorAssetBundle: Sendable, Equatable, Hashable {
+
+
+    /// The EditorRepresentation has the exact same format as `RemoteEditorAssetManifest.RawManifest` – what we're passing to Gutenberg
+    /// looks exactly like what it'd get if it called `/wpcom/v2/editor-assets` directly.
+    ///
+    /// The difference is that we've rewritten all of the URLs to reference local files with our custom URL scheme so they can be provided from the on-disk cache.
+    typealias EditorRepresentation = RemoteEditorAssetManifest.RawManifest
+
+    /// Errors that can occur when working with asset bundles.
+    enum Errors: Error, Equatable {
+        /// The requested asset URL is not part of this bundle's manifest.
+        case invalidRequest
+
+        /// An asset with the same key already exists in the lookup table.
+        case assetAlreadyExists(String)
+    }
+
+    /// The data structure stored on-disk
+    struct RawAssetBundle: Codable {
+        let manifest: LocalEditorAssetManifest
+        let downloadDate: Date
+    }
+
+    /// The bundle's unique identifier, derived from its manifest checksum.
+    ///
+    /// Two bundles with the same ID have identical manifests and _should_ contain identical assets. This may not be
+    /// true if a site is under development, so asset bundles should have some mechanism for being re-downloaded entirely.
+    public var id: String {
+        manifest.checksum
+    }
+
+    /// The manifest that defines which assets belong to this bundle.
+    let manifest: LocalEditorAssetManifest
+
+    /// The date this bundle was created by downloading the manifest contents.
+    ///
+    /// Used to determine which bundle is most recent when multiple bundles exist.
+    let downloadDate: Date
+
+    /// The number of assets stored in this bundle.
+    public var assetCount: Int {
+        manifest.assetUrls.count
+    }
+
+    let bundleRoot: URL
+
+    init(raw: RawAssetBundle, bundleRoot: URL) {
+        self.manifest = raw.manifest
+        self.downloadDate = raw.downloadDate
+        self.bundleRoot = bundleRoot
+    }
+
+    init(manifest: LocalEditorAssetManifest, downloadDate: Date = Date(), bundleRoot: URL) throws {
+        self.manifest = manifest
+        self.downloadDate = downloadDate
+        self.bundleRoot = bundleRoot
+    }
+
+    /// Loads a bundle from a JSON file on disk.
+    ///
+    /// - Parameter url: The file URL of the bundle's `manifest.json`.
+    /// - Throws: An error if the file cannot be read or decoded.
+    init(url: URL) throws {
+        self = try EditorAssetBundle(data:  Data(contentsOf: url), bundleRoot: url.deletingLastPathComponent())
+    }
+
+    init(data: Data, bundleRoot: URL) throws {
+        let rawBundle = try JSONDecoder().decode(RawAssetBundle.self, from: data)
+        self = EditorAssetBundle(
+            raw: rawBundle,
+            bundleRoot: bundleRoot
+        )
+    }
+
+    /// Checks whether this bundle contains cached data for the given asset URL.
+    ///
+    /// - Parameter url: The original remote URL of the asset.
+    /// - Returns: `true` if the asset is cached in this bundle, `false` otherwise.
+    public func hasAssetData(for url: URL) -> Bool {
+        FileManager.default.fileExists(at: self.assetDataPath(for: url))
+    }
+
+    /// Returns the local file path for a cached asset.
+    ///
+    /// - Parameter url: The original remote URL of the asset.
+    /// - Returns: The local file URL where the asset is stored.
+    /// - Throws: `Errors.invalidRequest` if the asset is not in this bundle.
+    public func assetDataPath(for url: URL) -> URL {
+        let path = url.path(percentEncoded: false)
+        let bundlePath = self.bundleRoot.appending(rawPath: path)
+        return bundlePath
+    }
+
+    /// Reads and returns the cached data for an asset.
+    ///
+    /// - Parameter url: The original remote URL of the asset.
+    /// - Returns: The asset's file contents.
+    /// - Throws: `Errors.invalidRequest` if the asset is not in this bundle,
+    ///   or a file system error if the file cannot be read.
+    public func assetData(for url: URL) throws -> Data {
+        let fileURL = assetDataPath(for: url)
+        return try Data(contentsOf: fileURL)
+    }
+
+    /// Reads the editor representation as a strongly-typed struct.
+    ///
+    /// The editor representation contains the rewritten script and style tags
+    /// with URLs pointing to the local cache via the custom URL scheme.
+    ///
+    /// - Throws: An error if the file doesn't exist or cannot be decoded.
+    func getEditorRepresentation() throws -> EditorRepresentation {
+        let path = self.bundleRoot.appending(path: "editor-representation.json")
+        let data = try Data(contentsOf: path)
+        return try JSONDecoder().decode(EditorRepresentation.self, from: data)
+    }
+
+    /// Reads the editor representation as a JSON-serializable dictionary.
+    ///
+    /// Use this overload when you need to pass the representation to JavaScript.
+    ///
+    /// - Throws: An error if the file doesn't exist or cannot be parsed.
+    func getEditorRepresentation() throws -> Any {
+        let path = self.bundleRoot.appending(path: "editor-representation.json")
+        let data = try Data(contentsOf: path)
+        return try JSONSerialization.jsonObject(with: data)
+    }
+
+    /// Saves the editor representation to disk.
+    ///
+    /// - Parameter representation: The processed script/style tags with rewritten URLs.
+    /// - Throws: An error if encoding or writing fails.
+    func setEditorRepresentation(_ representation: EditorRepresentation) throws {
+        let path = self.bundleRoot.appending(path: "editor-representation.json")
+        try JSONEncoder().encode(representation).write(to: path, options: .atomic)
+    }
+
+    /// Returns the bundle's manifest as JSON data for storage.
+    func dataRepresentation() throws -> Data {
+        try JSONEncoder().encode(RawAssetBundle(
+            manifest: self.manifest,
+            downloadDate: self.downloadDate
+        ))
+    }
+
+    /// Writes the bundle's JSON representation to disk.
+    ///
+    /// - Parameter path: The file URL where the bundle should be saved.
+    /// - Throws: An error if encoding fails or the file cannot be written.
+    func writeManifest(to path: URL? = nil) throws {
+        try FileManager.default.createDirectory(at: self.bundleRoot, withIntermediateDirectories: true)
+        let destination = path ?? self.bundleRoot.appendingPathComponent("manifest.json")
+        try self.dataRepresentation().write(to: destination, options: .atomic)
+    }
+
+    /// Copies the bundle to the given directoy.
+    ///
+    /// APFS makes this instant and zero-cost.
+    func copy(to destination: URL) throws -> EditorAssetBundle {
+
+        // Don't bother persisting an empty bundle
+        guard self != .empty else {
+            return .empty
+        }
+
+        if FileManager.default.directoryExists(at: destination) {
+            try FileManager.default.removeItem(at: destination)
+        }
+
+        let destinationParent = destination.deletingLastPathComponent()
+        try FileManager.default.createDirectory(at: destinationParent, withIntermediateDirectories: true)
+        try FileManager.default.copyItem(at: self.bundleRoot, to: destination)
+
+        return try EditorAssetBundle(url: destination.appending(path: "manifest.json"))
+    }
+
+    static let empty: EditorAssetBundle = EditorAssetBundle(
+        raw: RawAssetBundle(
+            manifest: .empty,
+            downloadDate: Date()
+        ),
+        bundleRoot: URL.temporaryDirectory
+    )
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/EditorAssetManifest.swift b/ios/Sources/GutenbergKit/Sources/Model/EditorAssetManifest.swift
new file mode 100644
index 00000000..869cf2b3
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/EditorAssetManifest.swift
@@ -0,0 +1,241 @@
+import Foundation
+import SwiftSoup
+
+/// A raw manifest response from the WordPress editor-assets API endpoint.
+///
+/// This struct represents the unprocessed server response containing HTML script and style
+/// tags as raw strings. It computes a checksum of the original data to detect changes.
+///
+/// Use `LocalEditorAssetManifest` for a processed version with parsed URLs.
+struct RemoteEditorAssetManifest: Codable, Equatable {
+
+    /// The JSON structure returned by the server.
+    struct RawManifest: Codable, Equatable {
+        let scripts: String
+        let styles: String
+        let allowedBlockTypes: [String]
+
+        enum CodingKeys: String, CodingKey {
+            case scripts
+            case styles
+            case allowedBlockTypes = "allowed_block_types"
+        }
+
+        static let empty = RawManifest(scripts: "", styles: "", allowedBlockTypes: [])
+    }
+
+    /// The raw HTML containing `<script>` tags from the server.
+    let scripts: String
+
+    /// The raw HTML containing `<link>` stylesheet tags from the server.
+    let styles: String
+
+    /// The list of block type identifiers allowed by the site (e.g., "core/paragraph").
+    let allowedBlockTypes: [String]
+
+    /// A SHA-256 checksum of the original JSON data.
+    ///
+    /// Used to detect when the manifest has changed and assets need to be re-downloaded.
+    let checksum: String
+
+    /// Creates a remote manifest from raw JSON data.
+    ///
+    /// - Parameter data: The JSON response from the editor-assets endpoint.
+    /// - Throws: A decoding error if the JSON is malformed.
+    init(data: Data) throws {
+        self.checksum = data.hash()
+        let rawManifest = try JSONDecoder().decode(RawManifest.self, from: data)
+        self.scripts = rawManifest.scripts
+        self.styles = rawManifest.styles
+        self.allowedBlockTypes = rawManifest.allowedBlockTypes
+    }
+}
+
+/// A processed editor asset manifest with parsed URLs ready for downloading.
+///
+/// This struct transforms a `RemoteEditorAssetManifest` by parsing the raw HTML
+/// to extract individual script and stylesheet URLs. It preserves the original
+/// HTML for later injection into the editor WebView.
+///
+/// The manifest is used to:
+/// 1. Determine which assets need to be downloaded and cached
+/// 2. Provide the raw HTML for rendering in the editor (with URL rewriting)
+/// 3. Specify which block types are allowed for this site
+public struct LocalEditorAssetManifest: Sendable, Codable, Equatable, Hashable {
+
+    /// URLs of all external scripts that need to be cached locally.
+    ///
+    /// Extracted from `<script src="...">` tags in the manifest.
+    let scripts: [URL]
+
+    /// URLs of all external stylesheets that need to be cached locally.
+    ///
+    /// Extracted from `<link rel="stylesheet" href="...">` tags in the manifest.
+    let styles: [URL]
+
+    /// The block type identifiers that can be used in the editor (e.g., "core/paragraph").
+    let allowedBlockTypes: [String]
+
+    /// The original HTML containing `<script>` tags from the server.
+    ///
+    /// Preserved because it may contain inline scripts that cannot be cached.
+    /// URLs are rewritten at render time to use the local cache.
+    let rawScripts: String
+
+    /// The original HTML containing `<link>` stylesheet tags from the server.
+    ///
+    /// Preserved because it may contain inline styles that cannot be cached.
+    /// URLs are rewritten at render time to use the local cache.
+    let rawStyles: String
+
+    /// A SHA-256 checksum used to detect when assets need to be re-downloaded.
+    let checksum: String
+
+    /// All asset URLs (scripts and styles) that need to be cached.
+    var assetUrls: [URL] {
+        scripts + styles
+    }
+
+    private init(
+        scripts: [URL],
+        styles: [URL],
+        allowedBlockTypes: [String],
+        rawScripts: String,
+        rawStyles: String,
+        checksum: String
+    ) {
+        self.scripts = scripts
+        self.styles = styles
+        self.allowedBlockTypes = allowedBlockTypes
+        self.rawScripts = rawScripts
+        self.rawStyles = rawStyles
+        self.checksum = checksum
+    }
+
+    /// Creates a local manifest by parsing a remote manifest's HTML.
+    ///
+    /// This operation involves HTML parsing and is expensive. The results
+    /// should be cached.
+    ///
+    /// - Parameter remoteManifest: The raw manifest from the server.
+    /// - Throws: An error if HTML parsing fails.
+    init(remoteManifest: RemoteEditorAssetManifest) throws {
+        self.allowedBlockTypes = remoteManifest.allowedBlockTypes
+
+        let html = """
+      <html>
+          <head>
+          \(remoteManifest.scripts)
+          \(remoteManifest.styles)
+          </head>
+          <body></body>
+      </html>
+      """
+
+        let document = try SwiftSoup.parse(html)
+        self.rawScripts = remoteManifest.scripts
+        self.rawStyles = remoteManifest.styles
+        self.checksum = remoteManifest.checksum
+
+        self.scripts = try document.select("script[src]").map {
+            Self.normalizeAssetLink(try $0.attr("src"))
+        }.compactMap { URL(string: $0) }
+
+        self.styles = try document.select(#"link[rel="stylesheet"][href]"#).map {
+            Self.normalizeAssetLink(try $0.attr("href"))
+        }.compactMap { URL(string: $0) }
+    }
+
+    /// Normalizes protocol-relative URLs (e.g., `//example.com/script.js`) to use HTTPS.
+    ///
+    /// - Parameter link: The URL string to normalize.
+    /// - Returns: The normalized URL string with an explicit scheme.
+    private static func normalizeAssetLink(_ link: String) -> String {
+        if link.starts(with: "//") {
+            return "https:\(link)"
+        }
+
+        return link
+    }
+
+    /// Renders the manifest's scripts and styles as HTML with rewritten URLs that reference the application's custom URL scheme.
+    ///
+    /// - Parameter configuration: The editor configuration specifying the site scheme.
+    /// - Returns: HTML <script> and <style> tags
+    /// - Throws: An error if HTML parsing fails.
+    func buildEditorRepresentation(
+        for configuration: EditorConfiguration
+    ) throws -> RemoteEditorAssetManifest.RawManifest {
+
+        // If this site doesn't use plugins or theme styles, there's no work to do here.
+        guard configuration.shouldUsePlugins || configuration.shouldUseThemeStyles else {
+            return .empty
+        }
+
+        let html = """
+      <html>
+          <head>\(self.rawStyles)</head>
+          <body>\(self.rawScripts)</body>
+      </html>
+      """
+        let document = try SwiftSoup.parse(html)
+
+        for script in try document.select("script[src]") {
+            if let src = try? script.attr("src") {
+                let link = self.resolveAssetLink(src, scheme: Constants.EditorAssetLibrary.urlScheme)
+                try script.attr("src", link)
+            }
+        }
+
+        for stylesheet in try document.select(#"link[rel="stylesheet"][href]"#) {
+            if let href = try? stylesheet.attr("href") {
+                let link = self.resolveAssetLink(href, scheme: Constants.EditorAssetLibrary.urlScheme)
+                try stylesheet.attr("href", link)
+            }
+        }
+
+        let scripts = try document.head()?.html() ?? ""
+        let styles = try document.body()?.html() ?? ""
+
+        return RemoteEditorAssetManifest.RawManifest(
+            scripts: scripts,
+            styles: styles,
+            allowedBlockTypes: self.allowedBlockTypes
+        )
+
+    }
+
+    /// Rewrites an asset URL to use the specified scheme.
+    ///
+    /// - Parameters:
+    ///   - link: The original asset URL string.
+    ///   - scheme: The scheme to use (e.g., "https"). Defaults to "https".
+    /// - Returns: The URL string with the new scheme, or the original if parsing fails.
+    func resolveAssetLink(_ link: String, scheme: String) -> String {
+
+        var components = URLComponents(string: link)
+
+        // If this is a nonsense link, don't try to process it further
+        if components?.host == nil || components?.path == nil {
+            return link
+        }
+
+        components?.scheme = scheme
+
+        guard let url = components?.url else {
+            return link
+        }
+
+        return url.absoluteString
+    }
+
+    /// An empty manifest for sites that don't support the editor-assets endpoint.
+    static let empty = LocalEditorAssetManifest(
+        scripts: [],
+        styles: [],
+        allowedBlockTypes: [],
+        rawScripts: "",
+        rawStyles: "",
+        checksum: "empty"
+    )
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/EditorCachePolicy.swift b/ios/Sources/GutenbergKit/Sources/Model/EditorCachePolicy.swift
new file mode 100644
index 00000000..3dc21c3f
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/EditorCachePolicy.swift
@@ -0,0 +1,104 @@
+import Foundation
+
+/// A policy that determines how cached responses should be validated and used.
+///
+/// `EditorCachePolicy` provides three caching strategies that control when cached
+/// HTTP responses are considered valid. This is used by `EditorURLCache` to decide
+/// whether to return a cached response or require a fresh network request.
+///
+/// ## Usage
+///
+/// ```swift
+/// // Never use cached responses
+/// let cache = EditorURLCache(cachePolicy: .ignore)
+///
+/// // Use cached responses if they're less than 1 hour old
+/// let cache = EditorURLCache(cachePolicy: .maxAge(3600))
+///
+/// // Always use cached responses regardless of age
+/// let cache = EditorURLCache(cachePolicy: .always)
+/// ```
+///
+/// ## Choosing a Policy
+///
+/// - Use ``ignore`` during development or when debugging to ensure fresh data.
+/// - Use ``maxAge(_:)`` for production scenarios where data freshness matters.
+/// - Use ``always`` for offline-first scenarios or when network availability is limited.
+///
+public enum EditorCachePolicy: Sendable {
+
+    /// Ignores the cache and always requires fresh data from the network.
+    ///
+    /// When this policy is active, all cached responses are considered invalid,
+    /// forcing new network requests for every operation.
+    ///
+    /// Use this policy when:
+    /// - Debugging caching issues
+    /// - Testing network behavior
+    /// - Data must always be fresh
+    ///
+    case ignore
+
+    /// Uses cached responses only if they are younger than the specified age.
+    ///
+    /// The associated `TimeInterval` value represents the maximum age in seconds
+    /// that a cached response is considered valid. Responses older than this
+    /// threshold are treated as stale and will not be used.
+    ///
+    /// - Parameter interval: The maximum age in seconds for valid cached responses.
+    ///
+    /// ## Example
+    ///
+    /// ```swift
+    /// // Cache responses for up to 5 minutes
+    /// let policy = EditorCachePolicy.maxAge(300)
+    ///
+    /// // Cache responses for up to 1 hour
+    /// let policy = EditorCachePolicy.maxAge(3600)
+    ///
+    /// // Cache responses for up to 1 day
+    /// let policy = EditorCachePolicy.maxAge(86400)
+    /// ```
+    ///
+    case maxAge(TimeInterval)
+
+    /// Always uses cached responses regardless of their age.
+    ///
+    /// When this policy is active, any cached response is considered valid,
+    /// no matter how old it is. This provides maximum cache utilization
+    /// at the expense of data freshness.
+    ///
+    /// Use this policy when:
+    /// - Operating in offline-first mode
+    /// - Network connectivity is unreliable
+    /// - Data freshness is less important than availability
+    ///
+    case always
+
+    /// Determines whether a cached response with the given storage date should be used.
+    ///
+    /// This method evaluates the cache policy against the provided dates to decide
+    /// if a cached response is still valid.
+    ///
+    /// - Parameters:
+    ///   - date: The date when the response was originally cached.
+    ///   - currentDate: The current date to compare against. Defaults to `Date.now`.
+    ///
+    /// - Returns: `true` if the cached response should be used according to this policy,
+    ///            `false` if a fresh response should be fetched instead.
+    ///
+    /// ## Behavior by Policy
+    ///
+    /// - ``ignore``: Always returns `false` - cached responses are never used.
+    /// - ``maxAge(_:)``: Returns `true` only if `date + interval > currentDate`
+    ///   (i.e., the cached response hasn't expired yet).
+    /// - ``always``: Always returns `true` - cached responses are always used.
+    ///
+    package func allowsResponseWith(date: Date, currentDate: Date = .now) -> Bool {
+        switch self {
+        case .ignore: false
+        case .maxAge(let interval): date.addingTimeInterval(interval) > currentDate
+        case .always: true
+        }
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/EditorConfiguration.swift b/ios/Sources/GutenbergKit/Sources/Model/EditorConfiguration.swift
new file mode 100644
index 00000000..e1afcad8
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/EditorConfiguration.swift
@@ -0,0 +1,386 @@
+import Foundation
+
+/// Configuration settings for initializing the Gutenberg block editor.
+///
+/// This struct contains all the parameters needed to configure the editor, including
+/// site credentials, API endpoints, feature flags, and initial content. Use
+/// `EditorConfigurationBuilder` to construct instances.
+public struct EditorConfiguration: Sendable, Hashable, Equatable {
+  /// Initial title for populating the editor
+  public let title: String
+  /// Initial content for populating the editor
+  public let content: String
+  /// ID of the post being edited
+  public let postID: Int?
+  /// Type of the post being edited
+  public let postType: String
+  /// Toggles application of theme styles
+  public let shouldUseThemeStyles: Bool
+  /// Toggles loading plugin-provided editor assets
+  public let shouldUsePlugins: Bool
+  /// Toggles visibility of the title field
+  public let shouldHideTitle: Bool
+  /// Root URL for the site
+  public let siteURL: URL
+  /// Root URL for the site API
+  public let siteApiRoot: URL
+  /// Namespaces for the site API
+  public let siteApiNamespace: [String]
+  /// Paths excluded from API namespacing
+  public let namespaceExcludedPaths: [String]
+  /// Authorization header
+  public let authHeader: String
+  /// Raw block editor settings from the WordPress REST API
+  public let editorSettings: String
+  /// Locale used for translations
+  public let locale: String
+  /// Enables the native inserter UI in the editor
+  public let isNativeInserterEnabled: Bool
+  /// Endpoint for loading editor settings
+  public let editorSettingsEndpoint: URL?
+  /// Endpoint for loading editor assets, used when enabling `shouldUsePlugins`
+  public let editorAssetsEndpoint: URL?
+  /// Logs emitted at or above this level will be printed to the debug console
+  public let logLevel: EditorLogLevel
+  /// Enables logging of all network requests/responses to the native host
+  public let enableNetworkLogging: Bool
+  /// Don't make HTTP requests
+  public let isOfflineModeEnabled: Bool
+  /// A site ID derived from the URL that can be used in file system paths
+  package let siteId: String
+
+  /// Deliberately non-public – consumers should use `EditorConfigurationBuilder` to construct a configuration
+  init(
+    title: String,
+    content: String,
+    postID: Int?,
+    postType: String,
+    shouldUseThemeStyles: Bool,
+    shouldUsePlugins: Bool,
+    shouldHideTitle: Bool,
+    siteURL: URL,
+    siteApiRoot: URL,
+    siteApiNamespace: [String],
+    namespaceExcludedPaths: [String],
+    authHeader: String,
+    editorSettings: String,
+    locale: String,
+    isNativeInserterEnabled: Bool,
+    editorSettingsEndpoint: URL?,
+    editorAssetsEndpoint: URL?,
+    logLevel: EditorLogLevel,
+    enableNetworkLogging: Bool = false,
+    isOfflineModeEnabled: Bool = false
+  ) {
+    self.title = title
+    self.content = content
+    self.postID = postID
+    self.postType = postType
+    self.shouldUseThemeStyles = shouldUseThemeStyles
+    self.shouldUsePlugins = shouldUsePlugins
+    self.shouldHideTitle = shouldHideTitle
+    self.siteURL = siteURL
+    self.siteApiRoot = siteApiRoot
+    self.siteApiNamespace = siteApiNamespace
+    self.namespaceExcludedPaths = namespaceExcludedPaths
+    self.authHeader = authHeader
+    self.editorSettings = editorSettings
+    self.locale = locale
+    self.isNativeInserterEnabled = isNativeInserterEnabled
+    self.editorSettingsEndpoint = editorSettingsEndpoint
+    self.editorAssetsEndpoint = editorAssetsEndpoint
+    self.logLevel = logLevel
+    self.enableNetworkLogging = enableNetworkLogging
+    self.isOfflineModeEnabled = isOfflineModeEnabled
+
+    // Derived Properties
+    self.siteId = self.siteURL.host(percentEncoded: false) ?? UUID().uuidString
+  }
+
+  /// Creates a builder initialized with this configuration's values.
+  ///
+  /// Use this to create a modified copy of an existing configuration.
+  public func toBuilder() -> EditorConfigurationBuilder {
+    return EditorConfigurationBuilder(
+      title: title,
+      content: content,
+      postID: postID,
+      postType: postType,
+      shouldUseThemeStyles: shouldUseThemeStyles,
+      shouldUsePlugins: shouldUsePlugins,
+      shouldHideTitle: shouldHideTitle,
+      siteURL: siteURL,
+      siteApiRoot: siteApiRoot,
+      siteApiNamespace: siteApiNamespace,
+      namespaceExcludedPaths: namespaceExcludedPaths,
+      authHeader: authHeader,
+      editorSettings: editorSettings,
+      locale: locale,
+      isNativeInserterEnabled: isNativeInserterEnabled,
+      editorSettingsEndpoint: editorSettingsEndpoint,
+      editorAssetsEndpoint: editorAssetsEndpoint,
+      logLevel: logLevel,
+      enableNetworkLogging: enableNetworkLogging,
+      isOfflineModeEnabled: isOfflineModeEnabled
+    )
+  }
+
+  package var escapedTitle: String {
+    title.addingPercentEncoding(withAllowedCharacters: .alphanumerics)!
+  }
+
+  package var escapedContent: String {
+    content.addingPercentEncoding(withAllowedCharacters: .alphanumerics)!
+  }
+}
+
+/// A builder for constructing `EditorConfiguration` instances.
+///
+/// This builder provides a fluent API for setting configuration options:
+///
+/// ```swift
+/// let config = EditorConfigurationBuilder(postType: "post", siteURL: siteURL, siteApiRoot: apiRoot)
+///     .setTitle("Hello World")
+///     .setContent("<!-- wp:paragraph --><p>Content</p><!-- /wp:paragraph -->")
+///     .setShouldUseThemeStyles(true)
+///     .build()
+/// ```
+public struct EditorConfigurationBuilder {
+  private var title: String
+  private var content: String
+  private var postID: Int?
+  private var postType: String
+  private var shouldUseThemeStyles: Bool
+  private var shouldUsePlugins: Bool
+  private var shouldHideTitle: Bool
+  private var siteURL: URL
+  private var siteApiRoot: URL
+  private var siteApiNamespace: [String]
+  private var namespaceExcludedPaths: [String]
+  private var authHeader: String
+  private var editorSettings: String
+  private var locale: String
+  private var isNativeInserterEnabled: Bool
+  private var editorSettingsEndpoint: URL?
+  private var editorAssetsEndpoint: URL?
+  private var logLevel: EditorLogLevel
+  private var enableNetworkLogging: Bool
+  private var isOfflineModeEnabled: Bool
+
+  public init(
+    title: String = "",
+    content: String = "",
+    postID: Int? = nil,
+    postType: String,
+    shouldUseThemeStyles: Bool = false,
+    shouldUsePlugins: Bool = false,
+    shouldHideTitle: Bool = false,
+    siteURL: URL,
+    siteApiRoot: URL,
+    siteApiNamespace: [String] = [],
+    namespaceExcludedPaths: [String] = [],
+    authHeader: String = "",
+    editorSettings: String = "undefined",
+    locale: String = "en",
+    isNativeInserterEnabled: Bool = false,
+    editorSettingsEndpoint: URL? = nil,
+    editorAssetsEndpoint: URL? = nil,
+    logLevel: EditorLogLevel = .error,
+    enableNetworkLogging: Bool = false,
+    isOfflineModeEnabled: Bool = false
+  ) {
+    self.title = title
+    self.content = content
+    self.postID = postID
+    self.postType = postType
+    self.shouldUseThemeStyles = shouldUseThemeStyles
+    self.shouldUsePlugins = shouldUsePlugins
+    self.shouldHideTitle = shouldHideTitle
+    self.siteURL = siteURL
+    self.siteApiRoot = siteApiRoot
+    self.siteApiNamespace = siteApiNamespace
+    self.namespaceExcludedPaths = namespaceExcludedPaths
+    self.authHeader = authHeader
+    self.editorSettings = editorSettings
+    self.locale = locale
+    self.isNativeInserterEnabled = isNativeInserterEnabled
+    self.editorSettingsEndpoint = editorSettingsEndpoint
+    self.editorAssetsEndpoint = editorAssetsEndpoint
+    self.logLevel = logLevel
+    self.enableNetworkLogging = enableNetworkLogging
+    self.isOfflineModeEnabled = isOfflineModeEnabled
+  }
+
+  public func setTitle(_ title: String) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.title = title
+    return copy
+  }
+
+  public func setContent(_ content: String) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.content = content
+    return copy
+  }
+
+  public func setPostID(_ postID: Int?) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.postID = postID
+    return copy
+  }
+
+  public func setShouldUseThemeStyles(_ shouldUseThemeStyles: Bool) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.shouldUseThemeStyles = shouldUseThemeStyles
+    return copy
+  }
+
+  public func setShouldUsePlugins(_ shouldUsePlugins: Bool) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.shouldUsePlugins = shouldUsePlugins
+    return copy
+  }
+
+  public func setShouldHideTitle(_ shouldHideTitle: Bool) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.shouldHideTitle = shouldHideTitle
+    return copy
+  }
+
+  public func setSiteUrl(_ siteUrl: URL) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.siteURL = siteUrl
+    return copy
+  }
+
+  public func setSiteApiRoot(_ siteApiRoot: URL) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.siteApiRoot = siteApiRoot
+    return copy
+  }
+
+  public func setPostType(_ type: String) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.postType = type
+    return copy
+  }
+
+  public func setSiteApiNamespace(_ siteApiNamespace: [String]) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.siteApiNamespace = siteApiNamespace
+    return copy
+  }
+
+  public func setNamespaceExcludedPaths(_ namespaceExcludedPaths: [String])
+    -> EditorConfigurationBuilder {
+    var copy = self
+    copy.namespaceExcludedPaths = namespaceExcludedPaths
+    return copy
+  }
+
+  public func setAuthHeader(_ authHeader: String) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.authHeader = authHeader
+    return copy
+  }
+
+  public func setEditorSettings(_ editorSettings: String) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.editorSettings = editorSettings
+    return copy
+  }
+
+  public func setLocale(_ locale: String) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.locale = locale
+    return copy
+  }
+
+  public func setNativeInserterEnabled(_ isNativeInserterEnabled: Bool = true)
+    -> EditorConfigurationBuilder {
+    var copy = self
+    copy.isNativeInserterEnabled = isNativeInserterEnabled
+    return copy
+  }
+
+  public func setEditorSettingsEndpoint(_ editorSettingsEndpoint: URL?)
+    -> EditorConfigurationBuilder {
+    var copy = self
+    copy.editorSettingsEndpoint = editorSettingsEndpoint
+    return copy
+  }
+
+  public func setEditorAssetsEndpoint(_ editorAssetsEndpoint: URL?) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.editorAssetsEndpoint = editorAssetsEndpoint
+    return copy
+  }
+
+  public func setLogLevel(_ logLevel: EditorLogLevel) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.logLevel = logLevel
+    return copy
+  }
+
+  public func setEnableNetworkLogging(_ enableNetworkLogging: Bool) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.enableNetworkLogging = enableNetworkLogging
+    return copy
+  }
+
+  public func setIsOfflineModeEnabled(_ isOfflineModeEnabled: Bool) -> EditorConfigurationBuilder {
+    var copy = self
+    copy.isOfflineModeEnabled = isOfflineModeEnabled
+    return copy
+  }
+
+  /// Simplify conditionally applying a configuration change
+  ///
+  /// Sample Code:
+  /// ```swift
+  ///  // Before
+  ///  let configurationBuilder = EditorConfigurationBuilder()
+  ///  if let postID = post.id {
+  ///     configurationBuilder = configurationBuilder.setPostID(postID)
+  ///  }
+  ///
+  ///  // After
+  ///  let configurationBuilder = EditorConfigurationBuilder()
+  ///     .apply(post.id, { $0.setPostID($1) } )
+  /// ```
+  public func apply<T>(
+    _ value: T?, _ closure: (EditorConfigurationBuilder, T) -> EditorConfigurationBuilder
+  ) -> Self {
+    guard let value else {
+      return self
+    }
+
+    return closure(self, value)
+  }
+
+  /// Builds an `EditorConfiguration` from the current builder state.
+  public func build() -> EditorConfiguration {
+    EditorConfiguration(
+      title: title,
+      content: content,
+      postID: postID,
+      postType: postType,
+      shouldUseThemeStyles: shouldUseThemeStyles,
+      shouldUsePlugins: shouldUsePlugins,
+      shouldHideTitle: shouldHideTitle,
+      siteURL: siteURL,
+      siteApiRoot: siteApiRoot,
+      siteApiNamespace: siteApiNamespace,
+      namespaceExcludedPaths: namespaceExcludedPaths,
+      authHeader: authHeader,
+      editorSettings: editorSettings,
+      locale: locale,
+      isNativeInserterEnabled: isNativeInserterEnabled,
+      editorSettingsEndpoint: editorSettingsEndpoint,
+      editorAssetsEndpoint: editorAssetsEndpoint,
+      logLevel: logLevel,
+      enableNetworkLogging: enableNetworkLogging,
+      isOfflineModeEnabled: isOfflineModeEnabled
+    )
+  }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/EditorDependencies.swift b/ios/Sources/GutenbergKit/Sources/Model/EditorDependencies.swift
new file mode 100644
index 00000000..69b963e4
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/EditorDependencies.swift
@@ -0,0 +1,34 @@
+import Foundation
+
+/// A collection of data fetched from the WordPress REST API required to initialize the editor.
+///
+/// This struct bundles together all the pre-fetched dependencies needed before the editor
+/// can be displayed. Fetching these dependencies ahead of time allows the editor to load
+/// quickly without blocking on network requests.
+///
+/// Dependencies include:
+/// - Editor settings (theme styles, colors, typography, etc.)
+/// - Cached plugin/theme assets (JavaScript and CSS files)
+/// - Preloaded API responses (post types, taxonomies, etc.)
+public struct EditorDependencies: Sendable, Equatable, Hashable {
+  /// Configuration and styling information for the editor.
+  public let editorSettings: EditorSettings
+
+  /// Cached JavaScript and CSS assets for plugins and themes.
+  public let assetBundle: EditorAssetBundle
+
+  /// Pre-fetched API responses to avoid network requests during editor initialization.
+  ///
+  /// This is `nil` if preloading is disabled or no preload data is available.
+  public let preloadList: EditorPreloadList?
+
+    init(
+        editorSettings: EditorSettings,
+        assetBundle: EditorAssetBundle,
+        preloadList: EditorPreloadList?
+    ) {
+        self.editorSettings = editorSettings
+        self.assetBundle = assetBundle
+        self.preloadList = preloadList
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/EditorPreloadList.swift b/ios/Sources/GutenbergKit/Sources/Model/EditorPreloadList.swift
new file mode 100644
index 00000000..7ed401d5
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/EditorPreloadList.swift
@@ -0,0 +1,134 @@
+import Foundation
+
+/// Pre-fetched API responses that are injected into the editor to avoid network requests.
+///
+/// The Gutenberg editor makes several API requests during initialization to fetch post types,
+/// theme data, and site settings. By pre-fetching these responses and injecting them as
+/// "preload data," the editor can initialize without waiting for network requests.
+///
+/// The preload list is serialized to JSON and passed to the editor's JavaScript, which uses
+/// these cached responses instead of making network calls.
+public struct EditorPreloadList: Sendable, Equatable, Hashable {
+
+    /// The ID of the post being edited, if editing an existing post.
+    let postID: Int?
+
+    /// The pre-fetched post data for the post being edited.
+    let postData: EditorURLResponse?
+
+    /// The post type identifier (e.g., "post", "page").
+    let postType: String
+
+    /// Pre-fetched data for the current post type's schema.
+    let postTypeData: EditorURLResponse
+
+    /// Pre-fetched data for all available post types.
+    let postTypesData: EditorURLResponse
+
+    /// Pre-fetched data for the active theme, if available.
+    let activeThemeData: EditorURLResponse?
+
+    /// Pre-fetched site settings schema (OPTIONS request), if available.
+    let settingsOptionsData: EditorURLResponse?
+
+    /// Creates a new preload list with the specified API responses.
+    ///
+    /// Response headers are filtered to only include headers relevant to preloading.
+    ///
+    /// - Parameters:
+    ///   - postID: The ID of the post being edited, or `nil` for new posts.
+    ///   - postData: The pre-fetched post data, or `nil` for new posts.
+    ///   - postType: The post type identifier.
+    ///   - postTypeData: Pre-fetched post type schema.
+    ///   - postTypesData: Pre-fetched list of all post types.
+    ///   - activeThemeData: Pre-fetched active theme data, or `nil` if not available.
+    ///   - settingsOptionsData: Pre-fetched settings schema, or `nil` if not available.
+    public init(
+        postID: Int? = nil,
+        postData: EditorURLResponse? = nil,
+        postType: String,
+        postTypeData: EditorURLResponse,
+        postTypesData: EditorURLResponse,
+        activeThemeData: EditorURLResponse?,
+        settingsOptionsData: EditorURLResponse?
+    ) {
+        self.postID = postID
+        self.postData = postData?.asPreloadResponse()
+        self.postType = postType
+        self.postTypeData = postTypeData.asPreloadResponse()
+        self.postTypesData = postTypesData.asPreloadResponse()
+        self.activeThemeData = activeThemeData?.asPreloadResponse()
+        self.settingsOptionsData = settingsOptionsData?.asPreloadResponse()
+    }
+
+    func build() throws -> JSON {
+        return try logExecutionTime("Build Editor Preload List") {
+            var getRequests = [
+                buildPostTypePath(type: self.postType): try self.postTypeData.toJSON(),
+                Constants.API.postTypesPath: try self.postTypesData.toJSON()
+            ]
+
+            if let postID, let postData {
+                getRequests[buildPostPath(id: postID)] = try postData.toJSON()
+            }
+
+            if let activeThemeData {
+                getRequests[Constants.API.activeThemePath] = try activeThemeData.toJSON()
+            }
+
+            var optionsRequests: [String: JSON] = [:]
+
+            if let settingsOptionsData {
+                optionsRequests[Constants.API.siteSettingsPath] = try settingsOptionsData.toJSON()
+            }
+
+            var allRequests = getRequests
+            allRequests["OPTIONS"] = .object(optionsRequests)
+            return .object(allRequests)
+        }
+    }
+
+    /// Builds the preload list as a JSON string for injection into the editor.
+    ///
+    /// The JSON structure maps API paths to their cached responses, organized by HTTP method.
+    /// GET requests are at the top level, while OPTIONS requests are nested under an "OPTIONS" key.
+    ///
+    /// - Parameter formatted: If `true`, returns pretty-printed JSON. Defaults to `false`.
+    /// Formatting JSON is very expensive, so this shouldn't be used in production.
+    /// - Returns: A JSON string representing the preload data.
+    /// - Throws: An error if JSON serialization fails when `formatted` is `true`.
+    func build(formatted: Bool = false) throws -> String {
+        return try logExecutionTime("Serialize Editor Preload List") {
+            var jsonData = try JSONEncoder().encode(self.build())
+
+            if formatted {
+                let rawData = try JSONSerialization.jsonObject(with: jsonData)
+                jsonData = try JSONSerialization.data(
+                    withJSONObject: rawData, options: [.prettyPrinted, .sortedKeys, .withoutEscapingSlashes])
+            }
+
+            return String(decoding: jsonData, as: UTF8.self)
+        }
+    }
+
+    /// Builds the API path for fetching a specific post.
+    private func buildPostPath(id: Int) -> String {
+        "/wp/v2/posts/\(id)?context=edit"
+    }
+
+    /// Builds the API path for fetching a post type's schema.
+    private func buildPostTypePath(type: String) -> String {
+        "/wp/v2/types/\(type)?context=edit"
+    }
+}
+
+extension EditorURLResponse {
+    /// Creates a copy of the response with only preload-relevant headers.
+    ///
+    /// Filters headers to only include those expected by WordPress core's preload system.
+    func asPreloadResponse() -> EditorURLResponse {
+        // These headers were chosen because they're the same as those present in WP Core
+        let headers = self.responseHeaders.filtering(keys: "Accept", "Link")
+        return EditorURLResponse(data: self.data, responseHeaders: headers)
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/EditorProgress.swift b/ios/Sources/GutenbergKit/Sources/Model/EditorProgress.swift
new file mode 100644
index 00000000..d2a8a727
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/EditorProgress.swift
@@ -0,0 +1,38 @@
+import Foundation
+
+/// Represents the progress of an editor loading operation.
+///
+/// Used to report progress during asset downloads and other long-running operations.
+/// The progress is expressed as a count of completed items out of a total.
+public struct EditorProgress: Codable, Sendable, Equatable {
+    /// The number of items that have been completed.
+    public let completed: Int
+
+    /// The total number of items for the operation.
+    public let total: Int
+
+    /// The progress as a fraction between 0.0 and 1.0.
+    ///
+    /// Returns 0 if either `completed` or `total` is zero.
+    /// The value is clamped to a maximum of 1.0.
+    public var fractionCompleted: Double {
+        guard completed != 0 && total != 0 else { return 0 }
+        return min(Double(completed) / Double(total), 1.0)
+    }
+
+    /// Creates a new progress value.
+    ///
+    /// - Parameters:
+    ///   - completed: The number of completed items.
+    ///   - total: The total number of items.
+    package init(completed: Int, total: Int) {
+        self.completed = completed
+        self.total = total
+    }
+
+    /// A progress value representing no progress (0 of 0).
+    public static let zero = EditorProgress(completed: 0, total: 0)
+}
+
+/// A callback that receives progress updates during long-running operations.
+public typealias EditorProgressCallback = @Sendable (EditorProgress) async -> Void
diff --git a/ios/Sources/GutenbergKit/Sources/Model/EditorSettings.swift b/ios/Sources/GutenbergKit/Sources/Model/EditorSettings.swift
new file mode 100644
index 00000000..5aa34559
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/EditorSettings.swift
@@ -0,0 +1,71 @@
+import Foundation
+
+/// Editor configuration and styling data fetched from the WordPress REST API.
+///
+/// This struct wraps the raw JSON response from the block editor settings endpoint,
+/// which contains theme colors, typography, spacing, and other customization options.
+/// The raw JSON is injected directly into the editor's JavaScript.
+///
+/// Theme styles are extracted separately for use in styling the editor UI.
+public struct EditorSettings: Sendable, Codable, Equatable, Hashable {
+    let jsonValue: JSON?
+
+    /// CSS styles extracted from the theme's global styles.
+    ///
+    /// Contains the concatenated CSS from all theme style entries.
+    /// Used to apply theme styling to the editor interface.
+    public let themeStyles: String
+
+    var stringValue: String
+
+    /// Creates editor settings from raw API response data.
+    ///
+    /// Parses the JSON to extract theme styles while preserving the raw string
+    /// for JavaScript injection. This operation involves JSON parsing and should
+    /// be cached.
+    ///
+    /// - Parameter data: The raw JSON data from the block editor settings endpoint.
+    init(data: Data) {
+        let json = try? JSON(data)
+        self.jsonValue = json
+
+        let encodedJSON = try? JSONEncoder().encode(json)
+        self.stringValue = String(decoding: encodedJSON ?? Data(), as: UTF8.self)
+
+        if let settings = try? JSONDecoder().decode(InternalEditorSettings.self, from: data) {
+            self.themeStyles = settings.styles.compactMap { $0.css }.joined(separator: "\n")
+        } else {
+            self.themeStyles = ""
+        }
+    }
+
+    private init(
+        jsonValue: JSON?,
+        themeStyles: String
+    ) {
+        let encodedJSON = try? JSONEncoder().encode(jsonValue)
+        self.stringValue = String(decoding: encodedJSON ?? Data(), as: UTF8.self)
+        self.jsonValue = jsonValue
+        self.themeStyles = themeStyles
+    }
+
+    /// A placeholder value for when editor settings are not available.
+    static let undefined = EditorSettings(jsonValue: nil, themeStyles: "undefined")
+}
+
+/// Internal structure for decoding the editor settings response.
+///
+/// Only decodes the fields needed to extract theme styles.
+struct InternalEditorSettings: Decodable {
+    /// A CSS style entry from the theme.
+    struct CSSStyle: Decodable {
+        /// The CSS content, if present.
+        let css: String?
+        
+        /// Whether this style is from the global styles system.
+        let isGlobalStyles: Bool
+    }
+
+    /// All style entries from the theme.
+    let styles: [CSSStyle]
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/GBKitGlobal.swift b/ios/Sources/GutenbergKit/Sources/Model/GBKitGlobal.swift
new file mode 100644
index 00000000..de3ad4e6
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/GBKitGlobal.swift
@@ -0,0 +1,114 @@
+import Foundation
+
+/// Configuration object passed to the editor's JavaScript as a global variable.
+///
+/// This struct is serialized to JSON and injected into the WebView as `window.GBKit`,
+/// providing the JavaScript code with all the information it needs to initialize
+/// the editor and communicate with the WordPress REST API.
+public struct GBKitGlobal: Sendable, Codable {
+    
+    /// The post data passed to the editor.
+    public struct Post: Sendable, Codable {
+        /// The post ID, or -1 for new posts.
+        let id: Int
+        
+        /// The post title.
+        let title: String
+        
+        /// The post content (Gutenberg block markup).
+        let content: String
+    }
+    
+    /// The site's base URL, or `nil` if offline mode is enabled.
+    let siteURL: URL?
+    
+    /// The WordPress REST API root URL, or `nil` if offline mode is enabled.
+    let siteApiRoot: URL?
+    
+    /// Namespace segments to insert into API request paths.
+    ///
+    /// Used primarily for WordPress.com sites where API requests need a site identifier.
+    /// The first namespace is inserted after the first two path segments for eligible requests.
+    ///
+    /// For example, with `["sites/123"]`, a request to `/wp/v2/posts` becomes `/wp/v2/sites/123/posts`.
+    ///
+    /// All namespaces are used to detect whether a path already contains a namespace (to avoid
+    /// double-insertion), but only the first one is used for insertion.
+    let siteApiNamespace: [String]
+    
+    /// API paths that should not have the namespace inserted.
+    ///
+    /// Paths starting with any of these prefixes will bypass the namespace insertion middleware.
+    let namespaceExcludedPaths: [String]
+    
+    /// The authorization header value for authenticated API requests.
+    let authHeader: String
+    
+    /// Whether to apply theme styles to the editor.
+    let themeStyles: Bool
+    
+    /// Whether to load plugin assets.
+    let plugins: Bool
+    
+    /// Whether to use the native block inserter instead of the web-based one.
+    let enableNativeBlockInserter: Bool
+    
+    /// Whether to hide the post title field in the editor.
+    let hideTitle: Bool
+    
+    /// The locale identifier for translations (e.g., `fr`).
+    let locale: String
+    
+    /// The post being edited.
+    let post: Post
+    
+    /// The logging level for JavaScript console output.
+    let logLevel: String
+    
+    /// Whether to log network requests in the JavaScript console.
+    let enableNetworkLogging: Bool
+    
+    let editorSettings: JSON?
+    
+    let preloadData: JSON?
+    
+    /// Creates a global configuration from an editor configuration and dependencies.
+    ///
+    /// - Parameters:
+    ///   - configuration: The editor configuration.
+    ///   - dependencies: The pre-fetched editor dependencies (unused but reserved for future use).
+    public init(
+        configuration: EditorConfiguration,
+        dependencies: EditorDependencies
+    ) throws {
+        self.siteURL = configuration.isOfflineModeEnabled ? nil : configuration.siteURL
+        self.siteApiRoot = configuration.isOfflineModeEnabled ? nil : configuration.siteApiRoot
+        self.siteApiNamespace = configuration.siteApiNamespace
+        self.namespaceExcludedPaths = configuration.namespaceExcludedPaths
+        self.authHeader = configuration.authHeader
+        self.themeStyles = configuration.shouldUseThemeStyles
+        self.plugins = configuration.shouldUsePlugins
+        self.enableNativeBlockInserter = configuration.isNativeInserterEnabled
+        self.hideTitle = configuration.shouldHideTitle
+        self.locale = configuration.locale
+        self.post = Post(
+            id: configuration.postID ?? -1,
+            title: configuration.escapedTitle,
+            content: configuration.escapedContent
+        )
+        self.logLevel = configuration.logLevel.rawValue
+        self.enableNetworkLogging = configuration.enableNetworkLogging
+        self.editorSettings = dependencies.editorSettings.jsonValue
+        self.preloadData = try dependencies.preloadList?.build()
+    }
+    
+    /// Serializes the configuration to a JSON string for injection into JavaScript.
+    ///
+    /// - Returns: A JSON string representation of this object.
+    /// - Throws: An encoding error if serialization fails.
+    public func toString() throws -> String {
+        let data = try JSONEncoder().encode(self)
+        return String(decoding: data, as: UTF8.self)
+    }
+}
+
diff --git a/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorHTTPHeaders.swift b/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorHTTPHeaders.swift
new file mode 100644
index 00000000..0b046902
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorHTTPHeaders.swift
@@ -0,0 +1,103 @@
+import Foundation
+
+/// A case-insensitive collection of HTTP headers.
+///
+/// This struct provides a type-safe way to work with HTTP headers, with case-insensitive
+/// key lookups as required by the HTTP specification. Headers can be created using
+/// dictionary literal syntax and are `Codable` for serialization.
+///
+/// Example usage:
+/// ```swift
+/// var headers: EditorHTTPHeaders = ["Content-Type": "application/json"]
+/// headers["accept"] = "text/html"  // Case-insensitive
+/// print(headers["CONTENT-TYPE"])   // "application/json"
+/// ```
+public struct EditorHTTPHeaders: Sendable, Codable, Equatable, Hashable, ExpressibleByDictionaryLiteral {
+    private var elements: [String: String]
+
+    /// Creates headers from a string dictionary.
+    ///
+    /// - Parameter elements: A dictionary of header names to values.
+    init(_ elements: [String: String] = [:]) {
+        self.elements = elements
+    }
+
+    /// Creates headers from an `HTTPURLResponse`'s `allHeaderFields` dictionary.
+    ///
+    /// Non-string keys and values are skipped.
+    ///
+    /// - Parameter elements: A dictionary typically from `HTTPURLResponse.allHeaderFields`.
+    init(_ elements: [AnyHashable: Any]) {
+        self.elements = [:]
+
+        for (key, value) in elements {
+            guard let keyString = key as? String, let valueString = value as? String else {
+                continue
+            }
+
+            self.elements[keyString] = valueString
+        }
+    }
+
+    /// Creates headers from a dictionary literal.
+    ///
+    /// - Parameter elements: Key-value pairs of header names and values.
+    public init(dictionaryLiteral elements: (String, String)...) {
+        self.elements = elements.reduce(into: [String: String](), { $0[$1.0] = $1.1 })
+    }
+
+    /// Accesses the header value for the given key using case-insensitive matching.
+    ///
+    /// When getting a value, the key is matched case-insensitively against stored headers.
+    /// When setting a value, the new key will replace the old key case-insensitively.
+    ///
+    /// - Parameter key: The header name to look up or set.
+    /// - Returns: The header value, or `nil` if no matching header exists.
+    subscript(key: String) -> String? {
+        get {
+            let lowercasedKey = key.lowercased()
+            return elements.first { $0.key.lowercased() == lowercasedKey }?.value
+        }
+        set {
+            let lowercasedKey = key.lowercased()
+            // Remove any existing key with same case-insensitive match
+            if let existingKey = elements.keys.first(where: { $0.lowercased() == lowercasedKey }) {
+                elements.removeValue(forKey: existingKey)
+            }
+            if let newValue {
+                elements[key] = newValue
+            }
+        }
+    }
+
+    /// Compares two header collections for equality using case-insensitive key matching.
+    public static func == (lhs: EditorHTTPHeaders, rhs: EditorHTTPHeaders) -> Bool {
+        guard lhs.elements.count == rhs.elements.count else { return false }
+        for (key, value) in lhs.elements {
+            guard rhs[key] == value else { return false }
+        }
+        return true
+    }
+
+    /// Returns the headers as a standard string dictionary.
+    ///
+    /// Useful for passing headers to `URLRequest` or `HTTPURLResponse` APIs.
+    public var dictionaryValue: [String: String] {
+        self.elements
+    }
+
+    func toJSON() throws -> JSON {
+        .object(elements.reduce(into: [String: JSON]()) { $0[$1.key] = .string($1.value) })
+    }
+
+    /// Returns a new headers collection containing only the specified keys.
+    ///
+    /// Key matching is case-insensitive for filtering.
+    ///
+    /// - Parameter keys: The header names to include.
+    /// - Returns: A new `EditorHTTPHeaders` containing only the matching headers.
+    public func filtering(keys: String...) -> EditorHTTPHeaders {
+        let lowercasedKeys = keys.map { $0.lowercased() }
+        return EditorHTTPHeaders(self.elements.filter { lowercasedKeys.contains($0.key.lowercased()) })
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorHttpMethod.swift b/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorHttpMethod.swift
new file mode 100644
index 00000000..053362c8
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorHttpMethod.swift
@@ -0,0 +1,9 @@
+import Foundation
+
+public enum EditorHttpMethod: String, Sendable, Codable, CaseIterable, Hashable {
+    case GET
+    case POST
+    case PUT
+    case DELETE
+    case OPTIONS
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorURLResponse.swift b/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorURLResponse.swift
new file mode 100644
index 00000000..0e1c3705
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/HTTP/EditorURLResponse.swift
@@ -0,0 +1,69 @@
+import Foundation
+
+/// An HTTP response containing body data and headers.
+///
+/// This struct encapsulates the response from an HTTP request, storing both the
+/// response body and headers. It's used throughout the editor for caching API
+/// responses and building preload data.
+///
+/// The `description` property formats the response as JSON suitable for injection
+/// into the editor's preload system.
+public struct EditorURLResponse: Sendable, Equatable, Codable, Hashable {
+
+    /// The response body data.
+    let data: Data
+
+    /// The HTTP response headers.
+    let responseHeaders: EditorHTTPHeaders
+
+    /// Creates a response from raw data and an `HTTPURLResponse`.
+    ///
+    /// - Parameters:
+    ///   - data: The response body data.
+    ///   - httpUrlResponse: The URL response containing headers.
+    init(data: Data, httpUrlResponse: HTTPURLResponse) {
+        self.data = data
+        self.responseHeaders = EditorHTTPHeaders(httpUrlResponse.allHeaderFields)
+    }
+
+    /// Creates a response from raw data and headers.
+    ///
+    /// - Parameters:
+    ///   - data: The response body data.
+    ///   - responseHeaders: The HTTP headers.
+    init(data: Data, responseHeaders: EditorHTTPHeaders) {
+        self.data = data
+        self.responseHeaders = responseHeaders
+    }
+
+    /// Creates a response from a string body and headers.
+    ///
+    /// The string is encoded as UTF-8 data.
+    ///
+    /// - Parameters:
+    ///   - string: The response body as a string.
+    ///   - responseHeaders: The HTTP headers.
+    init(string: String, responseHeaders: EditorHTTPHeaders) {
+        self.data = Data(string.utf8)
+        self.responseHeaders = responseHeaders
+    }
+
+    /// Creates a response from a tuple of data and `HTTPURLResponse`.
+    ///
+    /// Convenience initializer for working with `URLSession` results.
+    ///
+    /// - Parameter rawResponse: A tuple containing the response data and URL response.
+    init(_ rawResponse: (Data, HTTPURLResponse)) {
+        self = EditorURLResponse(data: rawResponse.0, httpUrlResponse: rawResponse.1)
+    }
+
+    func toJSON() throws -> JSON {
+        .object([
+            "body": try JSON(self.data),
+            "headers": try responseHeaders.toJSON()
+        ])
+    }
+
+    /// An empty response with an empty JSON object body and no headers.
+    static let empty: EditorURLResponse = EditorURLResponse(string: "{}", responseHeaders: [:])
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Model/JSON.swift b/ios/Sources/GutenbergKit/Sources/Model/JSON.swift
new file mode 100644
index 00000000..6435fb46
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Model/JSON.swift
@@ -0,0 +1,203 @@
+import Foundation
+
+// Originally found at https://forums.swift.org/t/support-embedding-json-like-objects-in-swift-code/38329/13
+
+public enum JSON: Sendable, Equatable, Hashable, CustomStringConvertible {
+    indirect case object([String: JSON])
+    indirect case array([JSON])
+    case number(Double)
+    case string(String)
+    case boolean(Bool)
+    case null
+
+    /// Creates a JSON value by parsing the given data.
+    ///
+    /// - Parameter data: The JSON data to parse.
+    /// - Throws: A `DecodingError` if the data is not valid JSON.
+    init(_ data: Data) throws {
+        if data == Data() {
+            self = .null
+            return
+        }
+
+        self = try JSONDecoder().decode(JSON.self, from: data)
+    }
+
+    public var description: String {
+        let data = try! JSONSerialization.data(withJSONObject: self, options: [.prettyPrinted, .withoutEscapingSlashes])
+        return String(data: data, encoding: .utf8)!
+    }
+}
+
+extension JSON: Codable {
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+
+        if container.decodeNil() {
+            self = .null
+        } else if let bool = try? container.decode(Bool.self) {
+            self = .boolean(bool)
+        } else if let int = try? container.decode(Int.self) {
+            self = .number(Double(int))
+        } else if let double = try? container.decode(Double.self) {
+            self = .number(double)
+        } else if let string = try? container.decode(String.self) {
+            self = .string(string)
+        } else if let object = try? container.decode([String: JSON].self) {
+            self = .object(object)
+        } else if let array = try? container.decode([JSON].self) {
+            self = .array(array)
+        } else {
+            throw DecodingError.dataCorruptedError(in: container, debugDescription: "Invalid JSON value")
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+
+        switch self {
+        case .object(let dict):
+            try container.encode(dict)
+        case .array(let array):
+            try container.encode(array)
+        case .number(let value):
+            try container.encode(value)
+        case .string(let value):
+            try container.encode(value)
+        case .boolean(let value):
+            try container.encode(value)
+        case .null:
+            try container.encodeNil()
+        }
+    }
+
+    /// Returns `true` if this JSON value is an object.
+    var isObject: Bool {
+        guard case .object = self else {
+            return false
+        }
+        return true
+    }
+
+    /// Returns `true` if this JSON value is an array.
+    var isArray: Bool {
+        guard case .array = self else {
+            return false
+        }
+        return true
+    }
+
+    /// Returns `true` if this JSON value is a number.
+    var isNumber: Bool {
+        guard case .number = self else {
+            return false
+        }
+        return true
+    }
+
+    /// Returns `true` if this JSON value is a string.
+    var isString: Bool {
+        guard case .string = self else {
+            return false
+        }
+        return true
+    }
+
+    /// Returns `true` if this JSON value is a boolean.
+    var isBoolean: Bool {
+        guard case .boolean = self else {
+            return false
+        }
+        return true
+    }
+
+    /// Returns `true` if this JSON value is null.
+    var isNull: Bool {
+        guard case .null = self else {
+            return false
+        }
+        return true
+    }
+
+    /// Returns the dictionary value if this is an object, or `nil` otherwise.
+    var objectValue: [String: JSON]? {
+        guard case .object(let dict) = self else {
+            return nil
+        }
+        return dict
+    }
+
+    /// Returns the array value if this is an array, or `nil` otherwise.
+    var arrayValue: [JSON]? {
+        guard case .array(let arr) = self else {
+            return nil
+        }
+        return arr
+    }
+
+    /// Returns the number if this is a number, or `nil` otherwise.
+    var numberValue: Double? {
+        guard case .number(let value) = self else {
+            return nil
+        }
+        return value
+    }
+
+    /// Returns the string value if this is a string, or `nil` otherwise.
+    var stringValue: String? {
+        guard case .string(let value) = self else {
+            return nil
+        }
+        return value
+    }
+
+    /// Returns the boolean value if this is a boolean, or `nil` otherwise.
+    var booleanValue: Bool? {
+        guard case .boolean(let value) = self else {
+            return nil
+        }
+        return value
+    }
+}
+
+extension JSON: ExpressibleByDictionaryLiteral {
+    public init(dictionaryLiteral elements: (String, JSON)...) {
+        self = .object(.init(uniqueKeysWithValues: elements))
+    }
+}
+
+extension JSON: ExpressibleByArrayLiteral {
+    public init(arrayLiteral elements: JSON...) {
+        self = .array(elements)
+    }
+}
+
+extension JSON: ExpressibleByFloatLiteral {
+    public init(floatLiteral value: FloatLiteralType) {
+        self = .number(value)
+    }
+}
+
+extension JSON: ExpressibleByIntegerLiteral {
+    public init(integerLiteral value: IntegerLiteralType) {
+        self = .number(.init(value))
+    }
+}
+
+extension JSON: ExpressibleByStringLiteral {
+    public init(stringLiteral value: StringLiteralType) {
+        self = .string(value)
+    }
+}
+
+extension JSON: ExpressibleByBooleanLiteral {
+    public init(booleanLiteral value: BooleanLiteralType) {
+        self = .boolean(value)
+    }
+}
+
+extension JSON: ExpressibleByNilLiteral {
+    public init(nilLiteral: ()) {
+        self = .null
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Paths.swift b/ios/Sources/GutenbergKit/Sources/Paths.swift
new file mode 100644
index 00000000..aed4e96b
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Paths.swift
@@ -0,0 +1,15 @@
+import Foundation
+
+public struct Paths {
+    public static let defaultStorageRoot = URL.applicationSupportDirectory.appending(path: "GutenbergKit")
+
+    public static func storageRoot(for configuration: EditorConfiguration) -> URL {
+        defaultStorageRoot.appending(path: configuration.siteId)
+    }
+
+    public static let defaultCacheRoot = URL.cachesDirectory.appending(path: "GutenbergKit")
+
+    public static func cacheRoot(for configuration: EditorConfiguration) -> URL {
+        defaultCacheRoot.appending(path: configuration.siteId)
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/RESTAPIRepository.swift b/ios/Sources/GutenbergKit/Sources/RESTAPIRepository.swift
new file mode 100644
index 00000000..a65df4d1
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/RESTAPIRepository.swift
@@ -0,0 +1,146 @@
+import CryptoKit
+import Foundation
+
+/// A caching repository for WordPress REST API resources needed by the editor.
+///
+/// `RESTAPIRepository` handles fetching and caching API responses such as editor settings,
+/// post data, theme information, and site options. Cached responses are stored on disk
+/// and returned on subsequent requests to improve loading performance.
+public struct RESTAPIRepository: Sendable {
+
+    package let httpClient: EditorHTTPClientProtocol
+    private let configuration: EditorConfiguration
+    private let cache: EditorURLCache
+
+    // Other Endpoints
+    private let editorSettingsUrl: URL
+    private let activeThemeUrl: URL
+    private let siteSettingsUrl: URL
+    private let postTypesUrl: URL
+
+    public init(
+        configuration: EditorConfiguration,
+        httpClient: EditorHTTPClientProtocol,
+        urlSession: URLSession = .shared,
+        cache: EditorURLCache
+    ) {
+        self.httpClient = httpClient
+        self.configuration = configuration
+        self.cache = cache
+
+        let apiRoot = configuration.siteApiRoot
+
+        self.editorSettingsUrl = apiRoot.appending(rawPath: Constants.API.editorSettingsPath)
+        self.activeThemeUrl = apiRoot.appending(rawPath: Constants.API.activeThemePath)
+        self.siteSettingsUrl = apiRoot.appending(rawPath: Constants.API.siteSettingsPath)
+        self.postTypesUrl = apiRoot.appending(rawPath: Constants.API.postTypesPath)
+    }
+
+    /// Clears all cached API responses.
+    public func purge() throws {
+        try self.cache.clear()
+    }
+
+    // MARK: Post
+    @discardableResult
+    public func fetchPost(id: Int) async throws -> EditorURLResponse {
+        let request = URLRequest(method: .GET, url: self.buildPostUrl(id: id))
+        let response = try await self.httpClient.perform(request)
+        return EditorURLResponse(response)
+    }
+
+    public func readPost(id: Int) throws -> EditorURLResponse? {
+        try self.cache.response(for: buildPostUrl(id: id), httpMethod: .GET)
+    }
+
+    private func buildPostUrl(id: Int) -> URL {
+        configuration.siteApiRoot
+            .appending(path: "wp/v2/posts")
+            .appendingPathComponent(String(id))
+            .appending(queryItems: [
+                URLQueryItem(name: "context", value: "edit")
+            ])
+    }
+
+    // MARK: Editor Settings
+    @discardableResult
+    public func fetchEditorSettings() async throws -> EditorSettings {
+        if !self.configuration.shouldUsePlugins && !self.configuration.shouldUseThemeStyles {
+            return .undefined
+        }
+
+        let request = URLRequest(method: .GET, url: editorSettingsUrl)
+        let response = try await self.httpClient.perform(request)
+
+        let editorSettings = EditorSettings(data: response.0)
+
+        let urlResponse = EditorURLResponse((try JSONEncoder().encode(editorSettings), response.1))
+        try self.cache.store(urlResponse, for: editorSettingsUrl, httpMethod: .GET)
+        return editorSettings
+    }
+
+    public func readEditorSettings() throws -> EditorSettings? {
+        guard let editorURLResponse = try self.cache.response(for: editorSettingsUrl, httpMethod: .GET) else {
+            return nil
+        }
+
+        return try JSONDecoder().decode(EditorSettings.self, from: editorURLResponse.data)
+    }
+
+    // MARK: GET Post Type
+    @discardableResult
+    package func fetchPostType(for type: String) async throws -> EditorURLResponse {
+        try await self.perform(method: .GET, url: self.buildPostTypeUrl(type: type))
+    }
+
+    package func readPostType(for type: String) throws -> EditorURLResponse? {
+        try self.cache.response(for: buildPostTypeUrl(type: type), httpMethod: .GET)
+    }
+
+    private func buildPostTypeUrl(type: String) -> URL {
+        configuration.siteApiRoot.appending(path: "wp/v2/types/")
+            .appending(path: type)
+            .appending(queryItems: [
+                URLQueryItem(name: "context", value: "edit")
+            ])
+    }
+
+    // MARK: GET Active Theme
+    @discardableResult
+    package func fetchActiveTheme() async throws -> EditorURLResponse {
+        try await self.perform(method: .GET, url: self.activeThemeUrl)
+    }
+
+    package func readActiveTheme() throws -> EditorURLResponse? {
+        try self.cache.response(for: self.activeThemeUrl, httpMethod: .GET)
+    }
+
+    // MARK: OPTIONS Settings
+    @discardableResult
+    package func fetchSettingsOptions() async throws -> EditorURLResponse {
+        try await self.perform(method: .OPTIONS, url: self.siteSettingsUrl)
+    }
+
+    package func readSettingsOptions() throws -> EditorURLResponse? {
+        try self.cache.response(for: self.siteSettingsUrl, httpMethod: .OPTIONS)
+    }
+
+    // MARK: Post Types
+    @discardableResult
+    package func fetchPostTypes() async throws -> EditorURLResponse {
+        try await self.perform(method: .GET, url: self.postTypesUrl)
+    }
+
+    package func readPostTypes() throws -> EditorURLResponse? {
+        try self.cache.response(for: self.postTypesUrl, httpMethod: .GET)
+    }
+
+    private func perform(method: EditorHttpMethod, url: URL) async throws -> EditorURLResponse {
+        let request = URLRequest(method: method, url: url)
+        let response = try await self.httpClient.perform(request)
+        let urlResponse = EditorURLResponse(response)
+        try self.cache.store(urlResponse, for: url, httpMethod: method)
+        return urlResponse
+    }
+
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Service/CachedAssetSchemeHandler.swift b/ios/Sources/GutenbergKit/Sources/Service/CachedAssetSchemeHandler.swift
deleted file mode 100644
index 115a3043..00000000
--- a/ios/Sources/GutenbergKit/Sources/Service/CachedAssetSchemeHandler.swift
+++ /dev/null
@@ -1,54 +0,0 @@
-import Foundation
-import WebKit
-
-class CachedAssetSchemeHandler: NSObject, WKURLSchemeHandler {
-    nonisolated static let cachedURLSchemePrefix = "gbk-cache-"
-    nonisolated static let supportedURLSchemes = ["gbk-cache-http", "gbk-cache-https"]
-
-    nonisolated static func originalHTTPURL(from url: URL) -> URL? {
-        guard let scheme = url.scheme, supportedURLSchemes.contains(scheme) else { return nil }
-
-        guard var components = URLComponents(url: url, resolvingAgainstBaseURL: true) else {
-            return nil
-        }
-
-        components.scheme = String(scheme.suffix(from: scheme.index(scheme.startIndex, offsetBy: cachedURLSchemePrefix.count)))
-        return components.url
-    }
-
-    nonisolated static func cachedURL(forWebLink link: String) -> String? {
-        if link.starts(with: "http://") || link.starts(with: "https://") {
-            return cachedURLSchemePrefix + link
-        }
-        return nil
-    }
-
-    let service: EditorService
-
-    init(service: EditorService) {
-        self.service = service
-    }
-
-    func webView(_ webView: WKWebView, start urlSchemeTask: any WKURLSchemeTask) {
-        guard let url = urlSchemeTask.request.url else {
-            urlSchemeTask.didFailWithError(URLError(.badURL))
-            return
-        }
-
-        Task {
-            do {
-                let (response, content) = try await service.getCachedAsset(from: url)
-                urlSchemeTask.didReceive(response)
-                urlSchemeTask.didReceive(content)
-                urlSchemeTask.didFinish()
-            } catch {
-                urlSchemeTask.didFailWithError(error)
-            }
-        }
-    }
-
-    func webView(_ webView: WKWebView, stop urlSchemeTask: any WKURLSchemeTask) {
-        // No-op: since we're reading from disk synchronously, there's nothing to cancel
-    }
-}
-
diff --git a/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsLibrary.swift b/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsLibrary.swift
deleted file mode 100644
index 29543b40..00000000
--- a/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsLibrary.swift
+++ /dev/null
@@ -1,21 +0,0 @@
-import Foundation
-
-/// Wrapper around EditorService to provide manifest content for the editor
-actor EditorAssetsLibrary {
-    let service: EditorService
-    let configuration: EditorConfiguration
-
-    init(service: EditorService, configuration: EditorConfiguration) {
-        self.service = service
-        self.configuration = configuration
-    }
-
-    /// Returns the editor assets manifest content as Data, ready to be sent to the web view
-    func manifestContentForEditor() async throws -> Data {
-        let jsonString = try await service.getProcessedManifest()
-        guard let data = jsonString.data(using: .utf8) else {
-            throw URLError(.cannotDecodeContentData)
-        }
-        return data
-    }
-}
diff --git a/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsManifest.swift b/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsManifest.swift
deleted file mode 100644
index 2aaed48b..00000000
--- a/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsManifest.swift
+++ /dev/null
@@ -1,106 +0,0 @@
-import Foundation
-import CryptoKit
-import SwiftSoup
-
-struct EditorAssetsManifest: Codable {
-    var scripts: String
-    var styles: String
-    var allowedBlockTypes: [String]
-
-    enum CodingKeys: String, CodingKey {
-        case scripts
-        case styles
-        case allowedBlockTypes = "allowed_block_types"
-    }
-
-    func parseAssetLinks(defaultScheme: String? = nil) throws -> [String] {
-        let html = """
-            <html>
-                <head>
-                \(scripts)
-                \(styles)
-                </head>
-                <body></body>
-            </html>
-            """
-        let document = try SwiftSoup.parse(html)
-
-        var assetLinks: [String] = []
-        assetLinks += try document.select("script[src]").map {
-            Self.resolveAssetLink(try $0.attr("src"), defaultScheme: defaultScheme)
-        }
-        assetLinks += try document.select(#"link[rel="stylesheet"][href]"#).map {
-            Self.resolveAssetLink(try $0.attr("href"), defaultScheme: defaultScheme)
-        }
-        return assetLinks
-    }
-
-    func renderForEditor(defaultScheme: String?) throws -> Data {
-        var rendered = self
-        rendered.scripts = try Self.renderForEditor(scripts: self.scripts, defaultScheme: defaultScheme)
-        rendered.styles = try Self.renderForEditor(styles: self.styles, defaultScheme: defaultScheme)
-        return try JSONEncoder().encode(rendered)
-    }
-
-    private static func renderForEditor(scripts: String, defaultScheme: String?) throws -> String {
-        let html = """
-            <html>
-                <head>
-                \(scripts)
-                </head>
-                <body></body>
-            </html>
-            """
-        let document = try SwiftSoup.parse(html)
-
-        for script in try document.select("script[src]") {
-            if let src = try? script.attr("src") {
-                let link = Self.resolveAssetLink(src, defaultScheme: defaultScheme)
-                #if canImport(UIKit)
-                let newLink = CachedAssetSchemeHandler.cachedURL(forWebLink: link) ?? link
-                #else
-                let newLink = link
-                #endif
-                try script.attr("src", newLink)
-            }
-        }
-
-        let head = document.head()!
-        return try head.html()
-    }
-
-    private static func renderForEditor(styles: String, defaultScheme: String?) throws -> String {
-        let html = """
-            <html>
-                <head>
-                \(styles)
-                </head>
-                <body></body>
-            </html>
-            """
-        let document = try SwiftSoup.parse(html)
-
-        for stylesheet in try document.select(#"link[rel="stylesheet"][href]"#) {
-            if let href = try? stylesheet.attr("href") {
-                let link = Self.resolveAssetLink(href, defaultScheme: defaultScheme)
-                #if canImport(UIKit)
-                let newLink = CachedAssetSchemeHandler.cachedURL(forWebLink: link) ?? link
-                #else
-                let newLink = link
-                #endif
-                try stylesheet.attr("href", newLink)
-            }
-        }
-
-        let head = document.head()!
-        return try head.html()
-    }
-
-    private static func resolveAssetLink(_ link: String, defaultScheme: String?) -> String {
-        if link.starts(with: "//") {
-            return "\(defaultScheme ?? "https"):\(link)"
-        }
-
-        return link
-    }
-}
diff --git a/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsProvider.swift b/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsProvider.swift
deleted file mode 100644
index b402cb95..00000000
--- a/ios/Sources/GutenbergKit/Sources/Service/EditorAssetsProvider.swift
+++ /dev/null
@@ -1,30 +0,0 @@
-import Foundation
-import WebKit
-
-class EditorAssetsProvider: NSObject, WKScriptMessageHandlerWithReply {
-    let library: EditorAssetsLibrary
-
-    init(library: EditorAssetsLibrary) {
-        self.library = library
-    }
-
-    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage, replyHandler: @escaping @MainActor @Sendable (Any?, String?) -> Void) {
-        guard let payload = message.body as? NSDictionary,
-              let asset = payload.object(forKey: "asset") as? String,
-              asset == "manifest"
-        else {
-            replyHandler(nil, "Unexpected message")
-            return
-        }
-
-        Task.detached { [library] in
-            do {
-                let data = try await library.manifestContentForEditor()
-                let dict = try JSONSerialization.jsonObject(with: data)
-                await replyHandler(dict, nil)
-            } catch {
-                await replyHandler(nil, error.localizedDescription)
-            }
-        }
-    }
-}
diff --git a/ios/Sources/GutenbergKit/Sources/Service/EditorService.swift b/ios/Sources/GutenbergKit/Sources/Service/EditorService.swift
deleted file mode 100644
index 79d81788..00000000
--- a/ios/Sources/GutenbergKit/Sources/Service/EditorService.swift
+++ /dev/null
@@ -1,524 +0,0 @@
-import Foundation
-import CryptoKit
-import SwiftSoup
-import OSLog
-
-/// Service for fetching the editor settings and other parts of the environment
-/// required to launch the editor.
-public actor EditorService {
-    internal struct State: Codable {
-        let refreshDate: Date
-    }
-
-    enum EditorServiceError: Error {
-        case invalidResponseData
-    }
-
-    @MainActor private static var instances: [String: EditorService] = [:]
-
-    private let siteURL: String
-    private let networkSession: URLSessionProtocol
-
-    private let storeURL: URL
-    private var editorSettingsFileURL: URL { storeURL.appendingPathComponent("settings.json") }
-    private var manifestOriginalFileURL: URL { storeURL.appendingPathComponent("manifest-original.json") }
-    private var manifestProcessedFileURL: URL { storeURL.appendingPathComponent("manifest-processed.json") }
-    private var stateFileURL: URL { storeURL.appendingPathComponent("state.json") }
-    private var assetsDirectoryURL: URL { storeURL.appendingPathComponent("assets", isDirectory: true) }
-
-    private var refreshTask: Task<Void, Never>?
-
-    /// Returns the shared EditorService instance for the given siteURL
-    @MainActor
-    public static func shared(for siteURL: String) -> EditorService {
-        if let existing = instances[siteURL] {
-            return existing
-        }
-        let service = EditorService(siteURL: siteURL, networkSession: URLSession.shared)
-        instances[siteURL] = service
-        return service
-    }
-
-    /// Creates a new EditorService instance for testing
-    /// - Parameters:
-    ///   - siteURL: Unique identifier for the site (used for caching)
-    ///   - storeURL: Custom store URL for testing
-    ///   - networkSession: Network session to use for network requests
-    public init(siteURL: String, storeURL: URL? = nil, networkSession: URLSessionProtocol) {
-        self.siteURL = siteURL
-        self.networkSession = networkSession
-        self.storeURL = storeURL ?? EditorService.rootURL
-            .appendingPathComponent(siteURL.sha1, isDirectory: true)
-
-        Task {
-            await scheduleAutomaticCleanup()
-        }
-    }
-
-
-    /// Schedules automatic cleanup of orphaned assets after a brief delay.
-    ///
-    /// This is safe to call during initialization because:
-    /// - No previous editor instance can be accessing orphaned files at this point
-    /// - The delay ensures initialization completes before cleanup starts
-    /// - Any errors are caught and logged, preventing initialization failures
-    private func scheduleAutomaticCleanup() {
-        Task {
-            // Brief delay to allow service initialization to complete
-            try? await Task.sleep(for: .seconds(5))
-
-            do {
-                try await cleanupOrphanedAssets()
-            } catch {
-                log(.error, "Automatic cleanup failed: \(error)")
-            }
-        }
-    }
-
-    private static var rootURL: URL {
-        URL.applicationSupportDirectory.appendingPathComponent("GutenbergKit", isDirectory: true)
-    }
-
-    /// Returns the editor dependencies for the given configuration.
-    ///
-    /// - warning: The request may take a significant amount of time the first
-    /// time you open the editor.
-    func dependencies(for configuration: EditorConfiguration, isWarmup: Bool = false) async -> EditorDependencies {
-        let startTime = CFAbsoluteTimeGetCurrent()
-
-        if !isEditorLoaded {
-            await refresh(configuration: configuration)
-        } else {
-            // Trigger a background refresh after a delay to avoid interfering with editor loading
-            Task {
-                if !isWarmup {
-                    try? await Task.sleep(for: .seconds(7))
-                }
-                if isRefreshNeeded() {
-                    log(.info, "Refresh scheduled for later")
-                    await refresh(configuration: configuration)
-                } else {
-                    log(.info, "Skipping refresh – data is fresh")
-                }
-            }
-        }
-
-        log(.info, "Prepping local dependencies")
-        var dependencies = EditorDependencies()
-        if let data = try? Data(contentsOf: editorSettingsFileURL),
-           let settings = String(data: data, encoding: .utf8) {
-            dependencies.editorSettings = settings
-        }
-        let loadTime = CFAbsoluteTimeGetCurrent() - startTime
-        log(.info, "Loaded dependencies in \(String(format: "%.3f", loadTime))s")
-
-        return dependencies
-    }
-
-    /// Returns `true` if the resources required for the editor already exist.
-    private var isEditorLoaded: Bool {
-        FileManager.default.fileExists(atPath: stateFileURL.path)
-    }
-
-    /// Refresh the editor resources.
-    func refresh(configuration: EditorConfiguration) async {
-        if let task = refreshTask {
-            return await task.value
-        }
-        let task = Task {
-            defer { refreshTask = nil }
-            await actuallyRefresh(configuration: configuration)
-        }
-        refreshTask = task
-        return await task.value
-    }
-
-    private func isRefreshNeeded() -> Bool {
-        guard let data = try? Data(contentsOf: stateFileURL),
-              let state = try? JSONDecoder().decode(State.self, from: data) else {
-            return true
-        }
-        let timeSinceLastRefresh = Date().timeIntervalSince(state.refreshDate)
-        return timeSinceLastRefresh > 30
-    }
-
-    private func actuallyRefresh(configuration: EditorConfiguration) async {
-        let startTime = CFAbsoluteTimeGetCurrent()
-        log(.info, "Starting editor resources refresh")
-
-        // Fetch settings and manifest in parallel
-        async let settingsFuture = Result {
-            try await fetchEditorSettings(configuration: configuration)
-        }
-        async let manifestFuture = Result {
-            try await fetchManifestData(configuration: configuration)
-        }
-
-        let (settingsResult, manifestResult) = await (settingsFuture, manifestFuture)
-
-        let fetchTime = CFAbsoluteTimeGetCurrent() - startTime
-        log(.info, "Fetched settings and manifest in \(String(format: "%.2f", fetchTime))s")
-
-        if case .failure(let error) = settingsResult {
-            log(.error, "Failed to fetch editor settings: \(error)")
-        }
-
-        switch manifestResult {
-        case .success(let manifest):
-            // Fetch all assets for the new manifest
-            do {
-                try await fetchAssets(manifestData: manifest)
-
-                // Only write both manifest versions to disk after all assets are successfully fetched
-                FileManager.default.createDirectoryIfNeeded(at: storeURL)
-                try saveManifest(originalData: manifest)
-                log(.info, "Saved manifest")
-            } catch {
-                log(.error, "Failed to fetch assets: \(error) – skipping the manifest")
-            }
-        case .failure(let error):
-            log(.error, "Failed to fetch manifest: \(error)")
-        }
-
-        // Save state to indicate completed refresh (even if it fails)
-        do {
-            let state = State(refreshDate: Date())
-            try JSONEncoder().encode(state).write(to: stateFileURL)
-        } catch {
-            log(.error, "Failed to save state: \(error)")
-        }
-
-        let totalTime = CFAbsoluteTimeGetCurrent() - startTime
-        log(.info, "Editor refresh completed in \(String(format: "%.2f", totalTime))s")
-    }
-
-    // MARK: – Editor Settings
-
-    /// Fetches block editor settings from the WordPress REST API
-    ///
-    /// - Returns: Raw settings data from the API
-    @discardableResult
-    private func fetchEditorSettings(configuration: EditorConfiguration) async throws -> Data {
-        let endpoint = try configuration.makeEditorSettingsEndpointURL()
-        let data = try await fetchData(for: endpoint, authHeader: configuration.authHeader)
-        do {
-            FileManager.default.createDirectoryIfNeeded(at: storeURL)
-            try data.write(to: editorSettingsFileURL)
-        } catch {
-            assertionFailure("Failed to save settings: \(error)")
-        }
-        return data
-    }
-
-    // MARK: - Assets Manifest
-
-    /// Fetches the editor assets manifest from the WordPress REST API
-    /// Does not write to disk - use this to get manifest data without persisting it
-    private func fetchManifestData(configuration: EditorConfiguration) async throws -> Data {
-        let endpoint = try configuration.makeEditorAssetsManifestEndpointURL()
-        let data = try await fetchData(for: endpoint, authHeader: configuration.authHeader)
-        return data
-    }
-
-    /// Saves both original and processed manifest to disk
-    private func saveManifest(originalData: Data) throws {
-        // Save original manifest
-        try originalData.write(to: manifestOriginalFileURL)
-
-        // Process and save processed manifest
-        let manifest = try JSONDecoder().decode(EditorAssetsManifest.self, from: originalData)
-        let siteURLScheme = URL(string: siteURL)?.scheme
-        let processedData = try manifest.renderForEditor(defaultScheme: siteURLScheme)
-        try processedData.write(to: manifestProcessedFileURL)
-    }
-
-    /// Loads the processed manifest from disk
-    private func loadProcessedManifest() throws -> String {
-        let data = try Data(contentsOf: manifestProcessedFileURL)
-        guard let jsonString = String(data: data, encoding: .utf8) else {
-            throw URLError(.cannotDecodeContentData)
-        }
-        return jsonString
-    }
-
-    /// Returns the processed manifest for use by the editor
-    func getProcessedManifest() throws -> String {
-        try loadProcessedManifest()
-    }
-
-    // MARK: - Assets
-
-    /// Removes assets that are no longer referenced in the current manifest.
-    ///
-    /// This method is safe to call at any time, but is typically called automatically
-    /// shortly after service initialization. At that point, no previous editor instance
-    /// can be referencing orphaned files, making it safe to delete them immediately.
-    func cleanupOrphanedAssets() async throws {
-        // Load current manifest to determine which assets should be retained
-        guard FileManager.default.fileExists(atPath: manifestOriginalFileURL.path) else {
-            log(.warn, "No manifest found, skipping cleanup")
-            return
-        }
-
-        let manifestData = try Data(contentsOf: manifestOriginalFileURL)
-        let manifest = try JSONDecoder().decode(EditorAssetsManifest.self, from: manifestData)
-        let currentAssetLinks = try manifest.parseAssetLinks()
-            .filter { isSupportedAsset($0) }
-
-        // Build set of expected filenames
-        let expectedFilenames = Set(currentAssetLinks.map { cachedFilename(for: $0) })
-
-        // Get all files in assets directory
-        guard FileManager.default.fileExists(atPath: assetsDirectoryURL.path) else {
-            log(.debug, "Assets directory doesn't exist, nothing to clean up")
-            return
-        }
-
-        let filesOnDisk = try FileManager.default.contentsOfDirectory(
-            at: assetsDirectoryURL,
-            includingPropertiesForKeys: [.fileSizeKey],
-            options: [.skipsHiddenFiles]
-        )
-
-        // Identify and delete orphaned files
-        var deletedCount = 0
-        var deletedSize: Int64 = 0
-
-        for fileURL in filesOnDisk {
-            let filename = fileURL.lastPathComponent
-
-            // Skip if file is referenced in current manifest
-            if expectedFilenames.contains(filename) {
-                continue
-            }
-
-            // Delete orphaned asset
-            try? FileManager.default.removeItem(at: fileURL)
-            deletedCount += 1
-            deletedSize += fileURL.fileSize
-        }
-
-        if deletedCount > 0 {
-            log(.info, "Cleaned up \(deletedCount) orphaned assets (\(deletedSize.formatted))")
-        } else {
-            log(.debug, "No orphaned assets to clean up")
-        }
-    }
-
-    /// Fetches all assets from the manifest and stores them on the device
-    private func fetchAssets(manifestData: Data) async throws {
-        let startTime = CFAbsoluteTimeGetCurrent()
-        let manifest = try JSONDecoder().decode(EditorAssetsManifest.self, from: manifestData)
-        let assetLinks = try manifest.parseAssetLinks()
-            .filter { isSupportedAsset($0) }
-
-        log(.info, "Found \(assetLinks.count) assets to fetch")
-
-        FileManager.default.createDirectoryIfNeeded(at: assetsDirectoryURL)
-
-        var assetURLs: [URL] = []
-        var lastError: Error?
-
-        // Fetch all assets in parallel
-        await withTaskGroup(of: Result<URL, Error>.self) { group in
-            for link in assetLinks {
-                group.addTask {
-                    await Result { try await self.fetchAsset(from: link) }
-                }
-            }
-
-            for await result in group {
-                switch result {
-                case .success(let url):
-                    assetURLs.append(url)
-                case .failure(let error):
-                    log(.error, "Failed to fetch asset: \(error)")
-                    lastError = error
-                }
-            }
-        }
-
-        let totalTime = CFAbsoluteTimeGetCurrent() - startTime
-        let totalSize = assetURLs.reduce(0) { $0 + $1.fileSize }
-        log(.info, "Assets loaded: \(assetURLs.count) assets, \(totalSize.formatted) in \(String(format: "%.2f", totalTime))s")
-
-        if let lastError {
-            throw lastError
-        }
-    }
-
-    /// Checks if an asset URL is supported
-    private func isSupportedAsset(_ urlString: String) -> Bool {
-        guard let url = URL(string: urlString) else {
-            log(.warn, "Malformed asset link: \(urlString)")
-            return false
-        }
-
-        guard url.scheme == "http" || url.scheme == "https" else {
-            log(.warn, "Unexpected asset link: \(urlString)")
-            return false
-        }
-
-        let supportedResourceSuffixes = [".js", ".css", ".js.map"]
-        guard supportedResourceSuffixes.contains(where: { url.lastPathComponent.hasSuffix($0) }) else {
-            log(.warn, "Unsupported asset URL: \(url)")
-            return false
-        }
-
-        return true
-    }
-
-    /// Fetches a single asset and stores it on disk
-    /// - Returns: The local file URL where the asset is stored
-    private func fetchAsset(from urlString: String) async throws -> URL {
-        guard let url = URL(string: urlString) else {
-            throw URLError(.badURL)
-        }
-
-        let localURL = assetsDirectoryURL.appendingPathComponent(cachedFilename(for: urlString))
-
-        if FileManager.default.fileExists(atPath: localURL.path) {
-            return localURL
-        }
-
-        let startTime = CFAbsoluteTimeGetCurrent()
-        let request = URLRequest(url: url)
-        let (downloadedURL, response) = try await networkSession.download(for: request, delegate: nil)
-        let downloadTime = CFAbsoluteTimeGetCurrent() - startTime
-
-        guard let status = (response as? HTTPURLResponse)?.statusCode, (200..<300).contains(status) else {
-            throw URLError(.badServerResponse)
-        }
-
-        try FileManager.default.moveItem(at: downloadedURL, to: localURL)
-
-        log(.debug, "Downloaded asset: \(url.lastPathComponent) (\(localURL.fileSize.formatted)) in \(String(format: "%.2f", downloadTime))s")
-        return localURL
-    }
-
-    /// Loads a cached asset from disk
-    func getCachedAsset(from assetsURL: URL) throws -> (URLResponse, Data) {
-        guard let httpURL = CachedAssetSchemeHandler.originalHTTPURL(from: assetsURL) else {
-            throw URLError(.badURL)
-        }
-
-        let localURL = assetsDirectoryURL.appendingPathComponent(cachedFilename(for: httpURL.absoluteString))
-
-        guard FileManager.default.fileExists(atPath: localURL.path) else {
-            throw URLError(.fileDoesNotExist)
-        }
-
-        let content = try Data(contentsOf: localURL)
-        let mimeType: String = switch httpURL.pathExtension {
-        case "js": "application/javascript"
-        case "css": "text/css"
-        default: "application/octet-stream"
-        }
-        let response = URLResponse(url: assetsURL, mimeType: mimeType, expectedContentLength: content.count, textEncodingName: nil)
-        return (response, content)
-    }
-
-    // MARK: - Helpers
-
-    /// Deletes all cached editor data for all sites
-    static func deleteAllData() throws {
-        if FileManager.default.fileExists(atPath: EditorService.rootURL.path()) {
-            try FileManager.default.removeItem(at: EditorService.rootURL)
-        }
-    }
-
-    /// Generates a cached filename from an asset URL using SHA256 hash
-    nonisolated func cachedFilename(for urlString: String) -> String {
-        let hash = urlString.sha1
-        // Preserve file extension if present
-        if let url = URL(string: urlString) {
-            let ext = url.pathExtension
-            return ext.isEmpty ? hash : "\(hash).\(ext)"
-        }
-        return hash
-    }
-
-    private func createStoreDirectoryIfNeeded() {
-        if !FileManager.default.fileExists(atPath: storeURL.path) {
-            try? FileManager.default.createDirectory(at: storeURL, withIntermediateDirectories: true)
-        }
-    }
-
-    private func fetchData(for requestURL: URL, authHeader: String) async throws -> Data {
-        var request = URLRequest(url: requestURL)
-        request.setValue(authHeader, forHTTPHeaderField: "Authorization")
-        // Prevent wordpress_logged_in cookies from being sent, which could interfere with
-        // application password authentication in the Authorization header.
-        // See: https://github.com/wordpress-mobile/GutenbergKit/commit/30ebac210924ecc8e9dee3980c101ef24b1befa6
-        request.httpShouldHandleCookies = false
-
-        let (data, response) = try await networkSession.data(for: request)
-        guard let status = (response as? HTTPURLResponse)?.statusCode,
-              (200..<300).contains(status) else {
-            throw URLError(.badServerResponse)
-        }
-        return data
-    }
-}
-
-private extension Result {
-    init(catching body: () async throws -> Success) async where Failure == Error {
-        do {
-            self = .success(try await body())
-        } catch {
-            self = .failure(error)
-        }
-    }
-}
-
-private extension URL {
-    var fileSize: Int64 {
-        (try? FileManager.default.attributesOfItem(atPath: path())[.size] as? Int64) ?? 0
-    }
-}
-
-private extension Int64 {
-    var formatted: String {
-        ByteCountFormatter.string(fromByteCount: self, countStyle: .file)
-    }
-}
-
-private extension FileManager {
-    func createDirectoryIfNeeded(at url: URL) {
-        if !fileExists(atPath: url.path) {
-            try? createDirectory(at: url, withIntermediateDirectories: true)
-        }
-    }
-}
-
-private extension EditorConfiguration {
-    /// Returns the endpoint URL for fetching the editor settings
-    func makeEditorSettingsEndpointURL() throws -> URL {
-        if let customEndpoint = editorSettingsEndpoint {
-            return customEndpoint
-        }
-        // Fall back to constructing endpoint from siteApiRoot
-        guard let baseURL = URL(string: siteApiRoot) else {
-            throw URLError(.badURL)
-        }
-        return baseURL.appendingPathComponent("/wp-block-editor/v1/settings")
-    }
-
-    /// Returns the endpoint URL for fetching the editor assets manifest
-    func makeEditorAssetsManifestEndpointURL() throws -> URL {
-        let endpoint: URL
-        if let customEndpoint = editorAssetsEndpoint {
-            endpoint = customEndpoint
-        } else {
-            // Fall back to constructing endpoint from siteApiRoot
-            guard let baseURL = URL(string: siteApiRoot) else {
-                throw URLError(.badURL)
-            }
-            endpoint = baseURL.appendingPathComponent("/wpcom/v2/editor-assets")
-        }
-
-        // Always add query parameters
-        let excludeParam = URLQueryItem(name: "exclude", value: "core,gutenberg")
-        return endpoint.appending(queryItems: [excludeParam])
-    }
-}
diff --git a/ios/Sources/GutenbergKit/Sources/Services/EditorAssetBundleProvider.swift b/ios/Sources/GutenbergKit/Sources/Services/EditorAssetBundleProvider.swift
new file mode 100644
index 00000000..b3a623d6
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Services/EditorAssetBundleProvider.swift
@@ -0,0 +1,140 @@
+import Foundation
+import OSLog
+import WebKit
+
+/// Serves cached plugin and theme assets to the editor WebView.
+///
+/// `EditorAssetBundleProvider` acts as a bridge between the WKWebView and the on-disk
+/// asset cache. It registers itself as both a script message handler (to provide the
+/// asset manifest to JavaScript) and a URL scheme handler (to serve individual cached
+/// files via the `gbk-cache-https` scheme).
+///
+/// ## Usage
+///
+/// ```swift
+/// let provider = EditorAssetBundleProvider()
+/// provider.bind(to: webViewConfiguration)
+/// provider.set(bundle: assetBundle)
+/// ```
+///
+/// The provider must be bound to the WebView configuration before loading the editor,
+/// and must have a bundle set before the editor requests assets.
+public final class EditorAssetBundleProvider: NSObject, @unchecked Sendable {
+
+    private let lock = NSLock()
+    private var bundle: EditorAssetBundle?
+
+    /// Sets the asset bundle to serve to the WebView.
+    ///
+    /// This method is thread-safe and can be called from any thread.
+    ///
+    /// - Parameter bundle: The downloaded asset bundle containing cached scripts and styles.
+    public func set(bundle: EditorAssetBundle) {
+        lock.withLock {
+            self.bundle = bundle
+        }
+    }
+
+    /// Registers this provider with a WebView configuration.
+    ///
+    /// This method registers a script message handler for the editor to request the asset
+    /// manifest, and a URL scheme handler to serve individual cached files.
+    ///
+    /// - Parameter configuration: The WebView configuration to register with.
+    @MainActor
+    public func bind(to configuration: WKWebViewConfiguration) {
+        // Register the callback that provides the cached asset manifest
+        configuration.userContentController.addScriptMessageHandler(
+            self,
+            contentWorld: .page,
+            name: "loadFetchedEditorAssets"
+        )
+
+        // Register the handler for individual cached assets
+        configuration.setURLSchemeHandler(self, forURLScheme: "gbk-cache-https")
+    }
+}
+
+extension EditorAssetBundleProvider: WKScriptMessageHandlerWithReply {
+
+    public func userContentController(
+        _ userContentController: WKUserContentController,
+        didReceive message: WKScriptMessage,
+        replyHandler: @escaping @MainActor @Sendable (Any?, String?) -> Void
+    ) {
+        logExecutionTime("Retrieved Asset Manifest") {
+            Logger.assetLibrary.info("📚 Editor requested asset manifest")
+
+            guard let payload = message.body as? NSDictionary,
+                  let asset = payload.object(forKey: "asset") as? String,
+                  asset == "manifest"
+            else {
+                replyHandler(nil, "Unexpected message")
+                return
+            }
+
+            guard let bundle else {
+                preconditionFailure("Cannot read manifest with no bundle present. This is a programmer error.")
+            }
+
+            do {
+                let reply: Any = try bundle.getEditorRepresentation()
+                replyHandler(reply, nil)
+            } catch {
+                Logger.assetLibrary.error("📚 Failed to fetch asset manifest: \(error.localizedDescription)")
+            }
+        }
+    }
+}
+
+extension EditorAssetBundleProvider: WKURLSchemeHandler {
+    public func webView(_ webView: WKWebView, start urlSchemeTask: any WKURLSchemeTask) {
+        logExecutionTime("Retrieved cached asset") {
+            var loggerMessages = ["📚 Editor requested a cached asset"]
+
+            defer {
+                Logger.assetLibrary.info("\(loggerMessages.joined(separator: "\n"))")
+            }
+
+            guard let url = urlSchemeTask.request.url else {
+                loggerMessages.append("     URL: <missing>")
+                urlSchemeTask.didFailWithError(URLError(.badURL))
+                return
+            }
+
+            loggerMessages.append("     URL: \(url)")
+
+            guard let bundle else {
+                preconditionFailure("Cannot read asset with no bundle present. This is a programmer error.")
+            }
+
+            guard bundle.hasAssetData(for: url) else {
+                loggerMessages.append("     Path: <missing>")
+
+                loggerMessages.append("     Not found – sending 404")
+                let response = HTTPURLResponse(url: url, statusCode: 404, httpVersion: nil, headerFields: nil)!
+                urlSchemeTask.didReceive(response)
+                urlSchemeTask.didFinish()
+                return
+            }
+
+            do {
+                loggerMessages.append("     Path: \(bundle.assetDataPath(for: url))")
+
+                let data = try bundle.assetData(for: url)
+                let response = HTTPURLResponse(url: url, statusCode: 200, httpVersion: "HTTP/1.1", headerFields: nil)!
+                urlSchemeTask.didReceive(response)
+                urlSchemeTask.didReceive(data)
+                urlSchemeTask.didFinish()
+            } catch {
+                loggerMessages.append("     Error: \(error.localizedDescription)")
+                urlSchemeTask.didFailWithError(error)
+            }
+
+        }
+    }
+
+    public func webView(_ webView: WKWebView, stop urlSchemeTask: any WKURLSchemeTask) {
+        // No-op: since we're reading from disk synchronously, there's nothing to cancel
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Services/EditorService.swift b/ios/Sources/GutenbergKit/Sources/Services/EditorService.swift
new file mode 100644
index 00000000..9aab6168
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Services/EditorService.swift
@@ -0,0 +1,271 @@
+import Foundation
+
+/// Coordinates downloading and caching of editor dependencies from a WordPress site.
+///
+/// `EditorService` handles fetching and caching all resources needed to display the
+/// Gutenberg block editor, including editor settings, plugin assets, and REST API data.
+/// It reports progress during the preparation phase and provides cleanup methods for
+/// managing disk space.
+///
+/// ## Usage
+///
+/// ```swift
+/// let service = EditorService(configuration: config)
+/// let dependencies = try await service.prepare { progress in
+///     print("Loading: \(progress.fractionCompleted * 100)%")
+/// }
+/// ```
+public actor EditorService {
+
+    private let configuration: EditorConfiguration
+    private let restRepository: RESTAPIRepository
+    private let assetLibrary: EditorAssetLibrary
+
+    private var progress: EditorProgress?
+    private var progressCallback: EditorProgressCallback?
+
+    enum DependencyWeights: CaseIterable {
+        case editorSettings
+        case assetBundle
+        case post
+        case postType
+        case activeTheme
+        case settingsOptions
+        case postTypes
+
+        var rawValue: Double {
+            switch self {
+            case .editorSettings: 10
+            case .assetBundle: 50
+            case .post: 10
+            case .postType: 10
+            case .activeTheme: 10
+            case .settingsOptions: 10
+            case .postTypes: 10
+            }
+        }
+    }
+
+    /// Creates an editor service for the given configuration.
+    ///
+    /// - Parameters:
+    ///   - configuration: The editor configuration specifying site credentials and settings.
+    ///   - httpClient: An optional HTTP client for making API requests. If `nil`, a default
+    ///     client is created using the configuration's auth header.
+    ///   - cachePolicy: The policy that determines when cached responses are considered valid.
+    ///     Use `.ignore` to always fetch fresh data, `.maxAge(_:)` to expire entries after
+    ///     a time interval, or `.always` (the default) to use cached data regardless of age.
+    ///     This policy applies to both API response caching and asset manifest caching.
+    ///   - storageRoot: The directory for storing downloaded asset bundles. If `nil`, uses
+    ///     a default location based on the site ID.
+    ///   - cacheRoot: The directory for caching API responses. If `nil`, uses a default
+    ///     location based on the site ID.
+    public init(
+        configuration: EditorConfiguration,
+        httpClient: EditorHTTPClient? = nil,
+        cachePolicy: EditorCachePolicy = .always,
+        storageRoot: URL? = nil,
+        cacheRoot: URL? = nil
+    ) {
+        self.configuration = configuration
+
+        let httpClient = httpClient ?? EditorHTTPClient(
+            urlSession: .shared,
+            authHeader: configuration.authHeader,
+            delegate: nil
+        )
+
+        self.restRepository = RESTAPIRepository(
+            configuration: configuration,
+            httpClient: httpClient,
+            cache: EditorURLCache(
+                cacheRoot: cacheRoot ?? Paths.cacheRoot(for: configuration),
+                cachePolicy: cachePolicy
+            ),
+        )
+
+        self.assetLibrary = EditorAssetLibrary(
+            configuration: configuration,
+            httpClient: httpClient,
+            cachePolicy: cachePolicy,
+            storageRoot: storageRoot ?? Paths.storageRoot(for: configuration)
+        )
+    }
+
+    /// Returns the number of asset bundles currently stored on disk.
+    public func fetchAssetBundleCount() async throws -> Int {
+        try await self.assetLibrary.readAssetBundles().count
+    }
+
+    /// Downloads any missing editor dependencies, reporting progress along the way.
+    ///
+    /// This method fetches editor settings, plugin assets, and preload data concurrently,
+    /// caching results for future use. If offline mode is enabled, returns empty dependencies.
+    ///
+    /// - Parameter progress: A callback invoked with progress updates during loading.
+    /// - Returns: The complete set of dependencies needed to initialize the editor.
+    /// - Throws: An error if any required resource fails to download.
+    @discardableResult
+    public func prepare(progress: @escaping EditorProgressCallback) async throws -> EditorDependencies {
+
+        if self.configuration.isOfflineModeEnabled {
+            return EditorDependencies(
+                editorSettings: .undefined,
+                assetBundle: .empty,
+                preloadList: nil
+            )
+        }
+
+        self.progress = EditorProgress(completed: 1, total: 100)
+        self.progressCallback = progress
+
+        async let settings = try prepareEditorSettings()
+        async let assetBundle = try self.prepareAssetBundle()
+        async let preloadList = try preparePreloadList()
+
+        // Automatically clean up old asset bundles
+        try await onceEvery(.seconds(86_400)) {
+            try await self.cleanup()
+        }
+
+        return try await EditorDependencies(
+            editorSettings: settings,
+            assetBundle: assetBundle,
+            preloadList: preloadList
+        )
+    }
+
+    /// Clear unused on-disk resources associated with this service's configuration.
+    ///
+    /// Calling this method will preserve the most recent cache entries, ensuring that the editor still loads quickly without continuing to use unnecessary disk space.
+    /// Use this method to regularly clean up unused editor assets.
+    public func cleanup() async throws {
+        try await self.assetLibrary.cleanup()
+    }
+
+    /// Clear all on-disk resources associated with this service's configuration, even ones that may be in-use.
+    ///
+    /// Use this method rarely, as it will require re-downloading assets before the editor is usable again.
+    public func purge() async throws {
+        try await self.assetLibrary.purge()
+        try self.restRepository.purge()
+    }
+
+    private func incrementProgress(for weight: DependencyWeights, fraction: Double = 1.0) async {
+        precondition(
+            self.progress != nil,
+            "Progress has not been initialized. This is a bug in the EditorService. Please file an issue."
+        )
+        let progress = EditorProgress(
+            completed: self.progress!.completed + Int(weight.rawValue * fraction),
+            total: self.progress!.total)
+        self.progress = progress
+        await self.progressCallback?(progress)
+    }
+
+    private func prepareEditorSettings() async throws -> EditorSettings {
+        if let settings = try restRepository.readEditorSettings() {
+            await self.incrementProgress(for: .editorSettings)
+            return settings
+        }
+
+        let settings = try await restRepository.fetchEditorSettings()
+        await self.incrementProgress(for: .editorSettings)
+        return settings
+    }
+
+    private func prepareAssetBundle() async throws -> EditorAssetBundle {
+        if let latestAssetBundle = try await self.assetLibrary.readAssetBundles().first {
+            await self.incrementProgress(for: .assetBundle)
+            return latestAssetBundle
+        }
+
+        return try await self.assetLibrary.downloadAssetBundle { progress in
+            await self.incrementProgress(for: .assetBundle, fraction: progress.fractionCompleted)
+        }
+    }
+
+    private func preparePreloadList() async throws -> EditorPreloadList {
+        async let activeTheme = try self.prepareActiveTheme()
+        async let settingsOptions = try self.prepareSettingsOptions()
+        async let postTypeData = try self.preparePost(type: configuration.postType)
+        async let postTypesData = try self.preparePostTypes()
+
+        if let postID = self.configuration.postID {
+            async let postData = try self.preparePost(id: postID)
+
+            return try await EditorPreloadList(
+                postID: postID,
+                postData: postData,
+                postType: self.configuration.postType,
+                postTypeData: postTypeData,
+                postTypesData: postTypesData,
+                activeThemeData: activeTheme,
+                settingsOptionsData: settingsOptions
+            )
+        } else {
+            return try await EditorPreloadList(
+                postType: self.configuration.postType,
+                postTypeData: postTypeData,
+                postTypesData: postTypesData,
+                activeThemeData: activeTheme,
+                settingsOptionsData: settingsOptions
+            )
+        }
+    }
+
+    private func preparePost(id: Int) async throws -> EditorURLResponse {
+        if let postData = try self.restRepository.readPost(id: id) {
+            await self.incrementProgress(for: .post)
+            return postData
+        }
+
+        let postData = try await self.restRepository.fetchPost(id: id)
+        await self.incrementProgress(for: .post)
+        return postData
+    }
+
+    private func preparePost(type: String) async throws -> EditorURLResponse {
+        if let postType = try self.restRepository.readPostType(for: type) {
+            await self.incrementProgress(for: .postType)
+            return postType
+        }
+
+        let response = try await self.restRepository.fetchPostType(for: type)
+        await self.incrementProgress(for: .postType)
+        return response
+    }
+
+    private func prepareActiveTheme() async throws -> EditorURLResponse {
+        if let activeTheme = try self.restRepository.readActiveTheme() {
+            await self.incrementProgress(for: .activeTheme)
+            return activeTheme
+        }
+
+        let response = try await self.restRepository.fetchActiveTheme()
+        await self.incrementProgress(for: .activeTheme)
+        return response
+    }
+
+    private func prepareSettingsOptions() async throws -> EditorURLResponse {
+        if let settingsOptions = try self.restRepository.readSettingsOptions() {
+            await self.incrementProgress(for: .settingsOptions)
+            return settingsOptions
+        }
+
+        let response = try await self.restRepository.fetchSettingsOptions()
+        await self.incrementProgress(for: .settingsOptions)
+        return response
+    }
+
+    private func preparePostTypes() async throws -> EditorURLResponse {
+        if let postTypes = try self.restRepository.readPostTypes() {
+            await self.incrementProgress(for: .postTypes)
+            return postTypes
+        }
+
+        let response = try await self.restRepository.fetchPostTypes()
+        await self.incrementProgress(for: .postTypes)
+        return response
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Stores/EditorAssetLibrary.swift b/ios/Sources/GutenbergKit/Sources/Stores/EditorAssetLibrary.swift
new file mode 100644
index 00000000..5c598c8e
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Stores/EditorAssetLibrary.swift
@@ -0,0 +1,242 @@
+import Foundation
+
+/// The Editor Asset Library is a site-specific repository of remote assets that can be downloaded to the local device to support plugins and theme styles.
+///
+public actor EditorAssetLibrary {
+
+    private let configuration: EditorConfiguration
+    private let httpClient: EditorHTTPClientProtocol
+    private let storageRoot: URL
+    private let cachePolicy: EditorCachePolicy
+
+    /// Creates a new `EditorAssetLibrary` instance.
+    ///
+    /// - Parameters:
+    ///   - configuration: The editor configuration containing site-specific settings.
+    ///   - httpClient: The HTTP client used to fetch remote assets.
+    ///   - cachePolicy: The policy that determines when cached asset manifests are considered valid.
+    ///     Use `.ignore` to always fetch fresh manifests, `.maxAge(_:)` to expire entries after
+    ///     a time interval, or `.always` (the default) to use cached manifests regardless of age.
+    ///   - storageRoot: The root directory where asset bundles will be stored on disk.
+    public init(
+        configuration: EditorConfiguration,
+        httpClient: EditorHTTPClientProtocol,
+        cachePolicy: EditorCachePolicy = .always,
+        storageRoot: URL
+    ) {
+        self.configuration = configuration
+        self.httpClient = httpClient
+        self.storageRoot = storageRoot
+        self.cachePolicy = cachePolicy
+    }
+
+    // MARK: - Manifest Handling
+
+    /// Retrieve the manifest for a given site configuration.
+    ///
+    /// Applications should periodically check for a new editor manifest. This can be very expensive, so this method defaults to returning an existing one on-disk.
+    ///
+    package func fetchManifest() async throws -> LocalEditorAssetManifest {
+        guard configuration.shouldUsePlugins else { return .empty }
+        let data = try await httpClient.perform(
+            URLRequest(method: .GET, url: self.editorAssetsUrl(for: self.configuration))
+        ).0
+        let remoteManifest = try RemoteEditorAssetManifest(data: data)
+
+        guard
+            let existingManifest = try self.existingBundle(forManifestChecksum: remoteManifest.checksum),
+            self.cachePolicy.allowsResponseWith(date: existingManifest.downloadDate)
+        else {
+            return try LocalEditorAssetManifest(remoteManifest: remoteManifest)
+        }
+
+        return existingManifest.manifest
+    }
+    
+    // MARK: - Bundle Handling
+    
+    /// The downloaded asset bundles for a given `EditorConfiguration`. Ordered newest to oldest.
+    ///
+    public func readAssetBundles() throws -> [EditorAssetBundle] {
+        try FileManager.default.createDirectory(at: self.storageRoot, withIntermediateDirectories: true)
+        return try FileManager.default
+            .contentsOfDirectory(at: self.storageRoot, includingPropertiesForKeys: [.isDirectoryKey])
+            .filter { $0.hasDirectoryPath }  // Only include directories
+            .filter { $0.pathExtension != "download" }  // Don't include bundles that are being downloaded
+            .map { $0.appending(path: "manifest.json") }
+            .map { try EditorAssetBundle(url: $0) }
+            .sorted { $0.downloadDate > $1.downloadDate }
+    }
+    
+    /// Fetches the latest manifest from the server and downloads all of its resources, caching them on-disk.
+    ///
+    /// - Parameter progress: An optional callback that receives progress updates as assets are downloaded.
+    /// - Returns: The downloaded `EditorAssetBundle` containing all cached assets.
+    /// - Throws: An error if the manifest cannot be fetched or assets fail to download.
+    public func downloadAssetBundle(
+        cachePolicy: EditorCachePolicy = .always,
+        progress: EditorProgressCallback? = nil
+    ) async throws -> EditorAssetBundle {
+        let manifest = try await self.fetchManifest()
+        return try await self.buildBundle(for: manifest, progress: progress)
+    }
+    
+    /// Checks whether a bundle with the given manifest checksum exists on disk.
+    ///
+    package func hasBundle(forManifestChecksum checksum: String) -> Bool {
+        FileManager.default.directoryExists(at: self.bundleRoot(for: checksum))
+    }
+    
+    /// Retrieves an existing bundle from disk if one exists for the given manifest checksum.
+    ///
+    package func existingBundle(forManifestChecksum checksum: String) throws -> EditorAssetBundle? {
+        guard self.hasBundle(forManifestChecksum: checksum) else {
+            return nil
+        }
+        
+        return try EditorAssetBundle(url: self.bundleManifestPath(for: checksum))
+    }
+    
+    // MARK: - Individual Asset Handling
+    
+    /// Downloads all of the assets for a given manifest and assembles them into a bundle.
+    ///
+    /// Assets are downloaded concurrently and stored in a temporary directory. Once all downloads
+    /// complete successfully, the bundle is atomically moved to its final location.
+    package func buildBundle(
+        for manifest: LocalEditorAssetManifest,
+        progress: EditorProgressCallback? = nil
+    ) async throws -> EditorAssetBundle {
+
+        // Don't bother building a bundle from an empty manifest
+        guard manifest != .empty else {
+            await progress?(EditorProgress(completed: 100, total: 100))
+            return .empty
+        }
+
+        var complete = 0
+        
+        let tempDirectory = URL.temporaryDirectory.appending(path: UUID().uuidString)
+
+        let bundle = try EditorAssetBundle(
+            manifest: manifest,
+            bundleRoot: tempDirectory
+        )
+
+        try bundle.writeManifest()
+
+        let editorRepresentation = try manifest.buildEditorRepresentation(for: self.configuration)
+        try bundle.setEditorRepresentation(editorRepresentation)
+
+        try await withThrowingTaskGroup { group in
+            let links = (manifest.scripts + manifest.styles).filter { self.isSupportedAsset($0) }
+            
+            for asset in links {
+                group.addTask {
+                    (asset, try await self.fetchAsset(url: asset, into: bundle))
+                }
+            }
+            
+            for try await _ in group {
+                complete += 1
+                await progress?(EditorProgress(completed: complete, total: links.count))
+            }
+        }
+
+        return try bundle.copy(to: self.bundleRoot(for: bundle))
+    }
+    
+    /// Downloads a single asset and copies it into the temporary bundle directory.
+    ///
+    private func fetchAsset(url: URL, into bundle: EditorAssetBundle) async throws -> URL {
+        let tempUrl = try await logExecutionTime("Downloading \(url.lastPathComponent)") {
+            try await httpClient.download(URLRequest(method: .GET, url: url)).0
+        }
+
+        let destinationPath = bundle.bundleRoot.appending(path: url.path(percentEncoded: false))
+        let destinationParent = destinationPath.deletingLastPathComponent()
+        
+        // Ensure the destination directory exists
+        try FileManager.default.createDirectory(at: destinationParent, withIntermediateDirectories: true)
+
+        try FileManager.default.copyItem(at: tempUrl, to: destinationPath)
+
+        return destinationPath
+    }
+    
+    /// Checks if the given `url` is eligible to be downloaded into the local bundle
+    ///
+    /// Only HTTP/HTTPS URLs with `.js`, `.css`, or `.js.map` extensions are supported.
+    private func isSupportedAsset(_ url: URL) -> Bool {
+        guard url.scheme == "http" || url.scheme == "https" else {
+            log(.warn, "Unexpected asset link: \(url)")
+            return false
+        }
+        
+        let supportedResourceSuffixes = [".js", ".css", ".js.map"]
+        guard supportedResourceSuffixes.contains(where: { url.lastPathComponent.hasSuffix($0) }) else {
+            log(.warn, "Unsupported asset URL: \(url)")
+            return false
+        }
+        
+        return true
+    }
+    
+    // MARK: - Helpers
+    private func editorAssetsUrl(for configuration: EditorConfiguration) -> URL {
+        configuration.siteApiRoot
+            .appending(path: "/wpcom/v2/editor-assets")
+            .appending(queryItems: [URLQueryItem(name: "exclude", value: "core,gutenberg")])
+    }
+    
+    /// Cleans up outdated library entries for this site.
+    ///
+    /// This method removes all asset bundles except the most recent one, freeing disk space
+    /// while ensuring the editor can still load quickly with cached assets.
+    ///
+    /// - Throws: An error if the list of bundles cannot be read, or any bundle cannot be removed.
+    public func cleanup() throws {
+        let bundles = try self.readAssetBundles().dropFirst()
+        
+        for bundle in bundles {
+            try FileManager.default.removeItem(at: self.bundleRoot(for: bundle))
+        }
+    }
+    
+    /// Erases all library entries for this site.
+    ///
+    /// This method removes all asset bundles, requiring assets to be re-downloaded
+    /// before the editor can be used again. Use sparingly.
+    ///
+    /// - Throws: An error if the storage directory cannot be removed or recreated.
+    public func purge() throws {
+        guard FileManager.default.directoryExists(at: self.storageRoot) else {
+            return
+        }
+        
+        try FileManager.default.removeItem(at: self.storageRoot)
+        try FileManager.default.createDirectory(at: self.storageRoot, withIntermediateDirectories: true)
+    }
+    
+    // MARK: - File Path Helpers
+    func bundleRoot(for bundle: EditorAssetBundle) -> URL {
+        assert(!bundle.id.isEmpty, "Bundle must have a valid ID")
+        return self.bundleRoot(for: bundle.id)
+    }
+    
+    func bundleRoot(for checksum: String) -> URL {
+        self.storageRoot.appending(path: checksum)
+    }
+    
+    func bundleManifestPath(for bundle: EditorAssetBundle) -> URL {
+        bundleManifestPath(relativeTo: self.bundleRoot(for: bundle))
+    }
+    
+    func bundleManifestPath(relativeTo path: URL) -> URL {
+        path.appending(path: "manifest.json")
+    }
+    
+    func bundleManifestPath(for checksum: String) -> URL {
+        self.bundleManifestPath(relativeTo: self.bundleRoot(for: checksum))
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Stores/EditorURLCache.swift b/ios/Sources/GutenbergKit/Sources/Stores/EditorURLCache.swift
new file mode 100644
index 00000000..2136d636
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Stores/EditorURLCache.swift
@@ -0,0 +1,187 @@
+import CryptoKit
+import Foundation
+import OSLog
+
+/// A URL-based cache for storing HTTP responses keyed by URL and HTTP method.
+///
+/// Responses are stored on disk and survive process termination. Responses are keyed by both URL and HTTP method, so GET and OPTIONS requests to the
+/// same URL are stored independently.
+public struct EditorURLCache: Sendable {
+    private let cache: URLCache
+    private let cachePolicy: EditorCachePolicy
+    private let performanceMonitor = SignpostMonitor(for: Logger.performance)
+
+    /// Creates a new URL cache.
+    ///
+    /// - Parameters:
+    ///   - cacheRoot: The directory where cached responses will be stored.
+    ///     If `nil`, the system default cache directory is used. The cache has a
+    ///     maximum disk capacity of 100 MB.
+    ///   - cachePolicy: The policy that determines when cached responses are considered valid.
+    ///     Use `.ignore` to always fetch fresh data, `.maxAge(_:)` to expire entries after
+    ///     a time interval, or `.always` (the default) to use cached data regardless of age.
+    public init(cacheRoot: URL? = nil, cachePolicy: EditorCachePolicy = .always) {
+        // About enough for 10 sites
+        self.cache = URLCache(memoryCapacity: 0, diskCapacity: 100 * 1024 * 1024, directory: cacheRoot)
+        self.cachePolicy = cachePolicy
+    }
+
+    /// Stores a response for the given URL and HTTP method.
+    ///
+    /// If a response already exists for this URL and method combination, it will be overwritten.
+    ///
+    /// - Parameters:
+    ///   - response: The response to store.
+    ///   - url: The URL to associate with the response.
+    ///   - httpMethod: The HTTP method to associate with the response.
+    /// - Throws: An error if the response cannot be stored.
+    public func store(_ response: EditorURLResponse, for url: URL, httpMethod: EditorHttpMethod) throws {
+        try self.store(response, for: url, httpMethod: httpMethod, currentDate: .now)
+    }
+
+    package func store(
+        _ response: EditorURLResponse,
+        for url: URL,
+        httpMethod: EditorHttpMethod,
+        currentDate: Date
+    ) throws {
+        let response = CachedURLResponse(
+            response: HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: response.responseHeaders.dictionaryValue
+            )!,
+            data: __fixEmptyDataBugEncode(response.data),
+            userInfo: [
+                "storageDate": currentDate
+            ],
+            storagePolicy: .allowed
+        )
+
+        self.cache.storeCachedResponse(response, for: URLRequest(method: httpMethod, url: url))
+        Thread.sleep(forTimeInterval: 0.05)  // Hack to make `URLCache` work
+    }
+
+    /// Stores the contents of a downloaded file as a cached response for the given URL and HTTP method.
+    ///
+    /// If a response already exists for this URL and method combination, it will be overwritten.
+    ///
+    /// - Parameters:
+    ///   - path: The file URL whose contents should be stored.
+    ///   - headers: The HTTP headers to associate with the response.
+    ///   - url: The URL to associate with the response.
+    ///   - httpMethod: The HTTP method to associate with the response.
+    /// - Throws: An error if the file cannot be read or the response cannot be stored.
+    public func store(
+        fileAt path: URL,
+        headers: EditorHTTPHeaders,
+        for url: URL,
+        httpMethod: EditorHttpMethod
+    ) throws {
+        try self.store(fileAt: path, headers: headers, for: url, httpMethod: httpMethod, currentDate: .now)
+    }
+
+    package func store(
+        fileAt path: URL,
+        headers: EditorHTTPHeaders,
+        for url: URL,
+        httpMethod: EditorHttpMethod,
+        currentDate: Date
+    ) throws {
+
+        let response = CachedURLResponse(
+            response: HTTPURLResponse(
+                url: url,
+                statusCode: 200,
+                httpVersion: nil,
+                headerFields: headers.dictionaryValue
+            )!,
+            data: __fixEmptyDataBugEncode(try Data(contentsOf: path)),
+            userInfo: [
+                "storageDate": currentDate
+            ],
+            storagePolicy: .allowed
+        )
+
+        self.cache.storeCachedResponse(response, for: URLRequest(method: httpMethod, url: url))
+        Thread.sleep(forTimeInterval: 0.05)  // Hack to make `URLCache` work
+    }
+
+    /// Checks whether a cached response exists for the given URL and HTTP method.
+    ///
+    /// - Parameters:
+    ///   - url: The URL to check.
+    ///   - httpMethod: The HTTP method to check.
+    /// - Returns: `true` if a cached response exists, `false` otherwise.
+    /// - Throws: An error if the check cannot be performed.
+    public func hasData(for url: URL, httpMethod: EditorHttpMethod) throws -> Bool {
+        try self.response(for: url, httpMethod: httpMethod, currentDate: .now) != nil
+    }
+
+    package func hasData(for url: URL, httpMethod: EditorHttpMethod, currentDate: Date) throws -> Bool {
+        try self.response(for: url, httpMethod: httpMethod, currentDate: currentDate) != nil
+    }
+
+    /// Retrieves the cached response for the given URL and HTTP method.
+    ///
+    /// - Parameters:
+    ///   - url: The URL to look up.
+    ///   - httpMethod: The HTTP method to look up.
+    /// - Returns: The cached response, or `nil` if no response is cached.
+    /// - Throws: An error if the response cannot be retrieved.
+    public func response(for url: URL, httpMethod: EditorHttpMethod) throws -> EditorURLResponse? {
+        try self.response(for: url, httpMethod: httpMethod, currentDate: .now)
+    }
+
+    package func response(
+        for url: URL,
+        httpMethod: EditorHttpMethod,
+        currentDate: Date
+    ) throws -> EditorURLResponse? {
+        performanceMonitor.measure { () -> EditorURLResponse? in
+            guard
+                let response = self.cache.cachedResponse(for: URLRequest(method: httpMethod, url: url)),
+                let storageDate = response.userInfo?["storageDate"] as? Date,
+                self.cachePolicy.allowsResponseWith(date: storageDate, currentDate: currentDate)
+            else {
+                return nil
+            }
+
+            let headers = EditorHTTPHeaders((response.response as! HTTPURLResponse).allHeaderFields)
+            return EditorURLResponse(
+                data: __fixEmptyDataBugDecode(response.data),
+                responseHeaders: headers
+            )
+        }
+    }
+
+    /// Removes all cached responses.
+    ///
+    /// - Throws: An error if the cache cannot be cleared.
+    public func clear() throws {
+        self.cache.removeAllCachedResponses()
+        Thread.sleep(forTimeInterval: 0.05)  // Hack to make `URLCache` work
+    }
+
+    /// Encodes data to work around a `URLCache` bug with empty data.
+    ///
+    /// `URLCache` doesn't properly store an empty `Data` object, so we use a sentinel
+    /// value to represent empty data.
+    ///
+    /// - Parameter data: The data to encode.
+    /// - Returns: The encoded data, or a sentinel value if the data is empty.
+    private func __fixEmptyDataBugEncode(_ data: Data) -> Data {
+        guard data.isEmpty else { return data }
+        return Data("__is_empty__".utf8)
+    }
+
+    /// Decodes data that was encoded with `__fixEmptyDataBugEncode`.
+    ///
+    /// - Parameter data: The data to decode.
+    /// - Returns: The original data, or empty data if the sentinel value was detected.
+    private func __fixEmptyDataBugDecode(_ data: Data) -> Data {
+        guard data.count == 12, data == Data("__is_empty__".utf8) else { return data }
+        return Data()
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Timing.swift b/ios/Sources/GutenbergKit/Sources/Timing.swift
new file mode 100644
index 00000000..d9f5a322
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Timing.swift
@@ -0,0 +1,34 @@
+import Foundation
+import OSLog
+
+let clock = ContinuousClock()
+
+/// A helper function for performance logging – makes it easy to check how long any code block takes
+///
+func logExecutionTime<T>(_ label: String, _ work: () throws -> T) rethrows -> T {
+    let startInstant = clock.now
+    defer { Logger.timing.trace("⏱️ \(label): \(clock.now - startInstant)") }
+    return try work()
+}
+
+/// A helper function for performance logging – makes it easy to check how long any code block takes
+///
+func logExecutionTime<T>(_ label: String, _ work: @Sendable () async throws -> T) async rethrows -> T {
+    let startInstant = clock.now
+    defer { Logger.timing.trace("⏱️ \(label): \(clock.now - startInstant)") }
+    return try await work()
+}
+
+public func onceEvery(
+    _ duration: ContinuousClock.Instant.Duration,
+    _ work: @Sendable () async throws -> Void,
+    handle: String = #function,
+    currentDate: Date = Date()
+) async rethrows {
+    let lastRunTimestamp = UserDefaults.standard.double(forKey: "once-every-" + handle)
+
+    if lastRunTimestamp + TimeInterval(duration.components.seconds) <= currentDate.timeIntervalSince1970 {
+        try await work()
+        UserDefaults.standard.set(Date().timeIntervalSince1970, forKey: "once-every-" + handle)
+    }
+}
diff --git a/ios/Sources/GutenbergKit/Sources/Views/EditorProgressView.swift b/ios/Sources/GutenbergKit/Sources/Views/EditorProgressView.swift
new file mode 100644
index 00000000..c7d06ddb
--- /dev/null
+++ b/ios/Sources/GutenbergKit/Sources/Views/EditorProgressView.swift
@@ -0,0 +1,114 @@
+import SwiftUI
+
+#if canImport(UIKit)
+import UIKit
+
+/// A UIKit view displaying a progress bar with a customizable label underneath.
+class UIEditorProgressView: UIView {
+
+    /// The text displayed below the progress bar.
+    var loadingText: String {
+        get { label.text ?? "" }
+        set { label.text = newValue }
+    }
+
+    private let progressView: UIProgressView = {
+        let view = UIProgressView(progressViewStyle: .default)
+        view.translatesAutoresizingMaskIntoConstraints = false
+        return view
+    }()
+
+    private let label: UILabel = {
+        let label = UILabel()
+        label.translatesAutoresizingMaskIntoConstraints = false
+        label.textAlignment = .center
+        label.font = .preferredFont(forTextStyle: .body)
+        label.adjustsFontForContentSizeCategory = true
+        label.textColor = .secondaryLabel
+        return label
+    }()
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupViews()
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupViews()
+    }
+
+    convenience init(loadingText: String) {
+        self.init(frame: .zero)
+        self.loadingText = loadingText
+    }
+
+    func setProgress(_ progress: EditorProgress, animated: Bool) {
+        progressView.setProgress(Float(progress.fractionCompleted), animated: animated)
+    }
+
+    private func setupViews() {
+        addSubview(progressView)
+        addSubview(label)
+
+        NSLayoutConstraint.activate([
+            progressView.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 16),
+            progressView.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -16),
+            progressView.centerYAnchor.constraint(equalTo: centerYAnchor, constant: 0),
+
+            label.topAnchor.constraint(equalTo: progressView.bottomAnchor, constant: 8),
+            label.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 16),
+            label.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -16),
+        ])
+    }
+}
+
+struct EditorProgressView: UIViewRepresentable {
+    typealias UIViewType = UIEditorProgressView
+
+    @Binding
+    var progress: EditorProgress
+
+    let loadingText: String
+
+    func makeUIView(context: Context) -> UIViewType {
+        UIViewType(loadingText: loadingText)
+    }
+
+    @MainActor
+    func updateUIView(_ uiView: UIViewType, context: Context) {
+        uiView.setProgress(progress, animated: true)
+    }
+}
+
+#Preview {
+    @Previewable @State
+    var editorProgress: EditorProgress = EditorProgress(completed: 1, total: 100)
+
+    Spacer()
+    EditorProgressView(progress: $editorProgress, loadingText: "Loading Editor")
+    Spacer()
+    HStack {
+        Spacer()
+        Button("-") {
+            withAnimation {
+                editorProgress = EditorProgress(
+                    completed: max(-10, editorProgress.completed - 10),
+                    total: editorProgress.total
+                )
+            }
+        }.buttonStyle(.borderedProminent)
+        Spacer()
+        Button("+") {
+            withAnimation {
+                editorProgress = EditorProgress(
+                    completed: editorProgress.completed + 10,
+                    total: editorProgress.total
+                )
+            }
+        }.buttonStyle(.borderedProminent)
+        Spacer()
+    }
+}
+
+#endif
diff --git a/ios/Tests/GutenbergKitTests/EditorConfigurationBuilderTests.swift b/ios/Tests/GutenbergKitTests/EditorConfigurationBuilderTests.swift
deleted file mode 100644
index 43a8c8f9..00000000
--- a/ios/Tests/GutenbergKitTests/EditorConfigurationBuilderTests.swift
+++ /dev/null
@@ -1,198 +0,0 @@
-import Foundation
-import Testing
-@testable import GutenbergKit
-
-@Suite("Editor Configuration Builder Tests")
-struct EditorConfigurationBuilderTests {
-
-    @Test("Editor Configuration Defaults Are Correct")
-    func testThatEditorConfigurationBuilderDefaultsAreCorrect() throws {
-        let builder = EditorConfigurationBuilder().build()
-        #expect(builder.title == "")
-        #expect(builder.content == "")
-        #expect(builder.postID == nil)
-        #expect(builder.postType == nil)
-        #expect(builder.shouldUseThemeStyles == false)
-        #expect(builder.shouldUsePlugins == false)
-        #expect(builder.shouldHideTitle == false)
-        #expect(builder.siteURL == "")
-        #expect(builder.siteApiRoot == "")
-        #expect(builder.siteApiNamespace == [])
-        #expect(builder.namespaceExcludedPaths == [])
-        #expect(builder.authHeader == "")
-        #expect(builder.locale == "en")
-        #expect(builder.editorAssetsEndpoint == nil)
-        #expect(builder.isNativeInserterEnabled == false)
-        #expect(builder.logLevel == .error)
-        #expect(builder.enableNetworkLogging == false)
-    }
-
-    @Test("Editor Configuration to Builder")
-    func testThatEditorConfigurationToBuilder() throws {
-        let configuration = EditorConfigurationBuilder()
-            .setTitle("Title")
-            .setContent("Content")
-            .setPostID(123)
-            .setPostType("Post")
-            .setShouldUseThemeStyles(true)
-            .setShouldUsePlugins(true)
-            .setShouldHideTitle(true)
-            .setSiteUrl("https://example.com")
-            .setSiteApiRoot("/wp-json")
-            .setSiteApiNamespace(["wp", "v2"])
-            .setNamespaceExcludedPaths(["jetpack"])
-            .setAuthHeader("Bearer Token")
-            .setLocale("fr")
-            .setEditorAssetsEndpoint(URL(string: "https://example.com/wp-content/plugins/gutenberg/build/"))
-            .setNativeInserterEnabled(true)
-            .setLogLevel(.debug)
-            .setEnableNetworkLogging(true)
-            .build()        // Convert to a configuration
-            .toBuilder()    // Then back to a builder (to test the configuration->builder logic)
-            .build()        // Then back to a configuration to examine the results
-
-        #expect(configuration.title == "Title")
-        #expect(configuration.content == "Content")
-        #expect(configuration.postID == 123)
-        #expect(configuration.postType == "Post")
-        #expect(configuration.shouldUseThemeStyles == true)
-        #expect(configuration.shouldUsePlugins == true)
-        #expect(configuration.shouldHideTitle == true)
-        #expect(configuration.siteURL == "https://example.com")
-        #expect(configuration.siteApiRoot == "/wp-json")
-        #expect(configuration.siteApiNamespace == ["wp", "v2"])
-        #expect(configuration.namespaceExcludedPaths == ["jetpack"])
-        #expect(configuration.authHeader == "Bearer Token")
-        #expect(configuration.locale == "fr")
-        #expect(configuration.editorAssetsEndpoint == URL(string: "https://example.com/wp-content/plugins/gutenberg/build/"))
-        #expect(configuration.isNativeInserterEnabled == true)
-        #expect(configuration.logLevel == .debug)
-        #expect(configuration.enableNetworkLogging == true)
-    }
-
-    @Test("Sets Title Correctly")
-    func editorConfigurationBuilderSetsTitleCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setTitle("Title").build().title == "Title")
-    }
-
-    @Test("Sets Content Correctly")
-    func editorConfigurationBuilderSetsContentCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setContent("Content").build().content == "Content")
-    }
-
-    @Test("Sets PostID Correctly")
-    func editorConfigurationBuilderSetsPostIDCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setPostID(nil).build().postID == nil)
-        #expect(EditorConfigurationBuilder().setPostID(123).build().postID == 123)
-    }
-
-    @Test("Sets Post Type Correctly")
-    func editorConfigurationBuilderSetsPostTypeCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setPostType(nil).build().postType == nil)
-        #expect(EditorConfigurationBuilder().setPostType("post").build().postType == "post")
-    }
-
-    @Test("Sets shouldUseThemeStyles Correctly")
-    func editorConfigurationBuilderSetsShouldUseThemeStylesCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setShouldUseThemeStyles(true).build().shouldUseThemeStyles)
-        #expect(!EditorConfigurationBuilder().setShouldUseThemeStyles(false).build().shouldUseThemeStyles)
-    }
-
-    @Test("Sets shouldUsePlugins Correctly")
-    func editorConfigurationBuilderSetsShouldUsePluginsCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setShouldUsePlugins(true).build().shouldUsePlugins)
-        #expect(!EditorConfigurationBuilder().setShouldUsePlugins(false).build().shouldUsePlugins)
-    }
-
-    @Test("Sets shouldHideTitle Correctly")
-    func editorConfigurationBuilderSetsShouldHideTitleCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setShouldHideTitle(true).build().shouldHideTitle)
-        #expect(!EditorConfigurationBuilder().setShouldHideTitle(false).build().shouldHideTitle)
-    }
-
-    @Test("Sets siteUrl Correctly")
-    func editorConfigurationBuilderSetsSiteUrlCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setSiteUrl("https://example.com").build().siteURL == "https://example.com")
-    }
-
-    @Test("Sets siteApiRoot Correctly")
-    func editorConfigurationBuilderSetsSiteApiRootCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setSiteApiRoot("https://example.com/wp-json").build().siteApiRoot == "https://example.com/wp-json")
-    }
-
-    @Test("Sets siteApiNamespace Correctly")
-    func editorConfigurationBuilderSetsApiNamespaceCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setSiteApiNamespace(["wp/v2"]).build().siteApiNamespace == ["wp/v2"])
-    }
-
-    @Test("Sets namespaceExcludedPaths Correctly")
-    func editorConfigurationBuilderSetsNamespaceExcludedPathsCorrectly() throws {
-        #expect(
-            EditorConfigurationBuilder()
-                .setNamespaceExcludedPaths(["/wp-admin", "/wp-login.php"])
-                .build()
-                .namespaceExcludedPaths
-            == ["/wp-admin", "/wp-login.php"]
-        )
-    }
-
-    @Test("Sets authHeader Correctly")
-    func editorConfigurationBuilderSetsAuthHeaderCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setAuthHeader("Bearer token").build().authHeader == "Bearer token")
-    }
-
-    @Test("Sets locale Correctly")
-    func editorConfigurationBuilderSetsLocaleCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setLocale("en").build().locale == "en")
-    }
-
-    @Test("Sets editorAssetsEndpoint Correctly")
-    func editorConfigurationBuilderSetsEditorAssetsEndpointCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setEditorAssetsEndpoint(URL(string: "https://example.com/wp-content/plugins/gutenberg/build/")).build().editorAssetsEndpoint == URL(string: "https://example.com/wp-content/plugins/gutenberg/build/"))
-    }
-
-    @Test("Sets isNativeInserterEnabled Correctly")
-    func editorConfigurationBuilderSetsNativeInserterEnabledCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setNativeInserterEnabled(true).build().isNativeInserterEnabled)
-        #expect(!EditorConfigurationBuilder().setNativeInserterEnabled(false).build().isNativeInserterEnabled)
-    }
-
-    @Test("Sets logLevel Correctly")
-    func editorConfigurationBuilderSetsLogLevelCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setLogLevel(.debug).build().logLevel == .debug)
-        #expect(EditorConfigurationBuilder().setLogLevel(.info).build().logLevel == .info)
-        #expect(EditorConfigurationBuilder().setLogLevel(.warn).build().logLevel == .warn)
-        #expect(EditorConfigurationBuilder().setLogLevel(.error).build().logLevel == .error)
-    }
-
-    @Test("Sets enableNetworkLogging Correctly")
-    func editorConfigurationBuilderSetsEnableNetworkLoggingCorrectly() throws {
-        #expect(EditorConfigurationBuilder().setEnableNetworkLogging(true).build().enableNetworkLogging)
-        #expect(!EditorConfigurationBuilder().setEnableNetworkLogging(false).build().enableNetworkLogging)
-    }
-
-    @Test("Applies values correctly")
-    func editorConfigurationBuilderAppliesValuesCorrectly() throws {
-        let string = "test"
-        let nilString: String? = nil
-
-        let int = 1
-        let nilInt: Int? = nil
-
-        #expect(EditorConfigurationBuilder().apply(string, { $0.setTitle($1) }).build().title == string)
-        #expect(EditorConfigurationBuilder().apply(nilString, { $0.setTitle($1)}).build().title == "")
-
-        #expect(EditorConfigurationBuilder().apply(int, { $0.setPostID($1) }).build().postID == int)
-        #expect(EditorConfigurationBuilder().apply(nilInt, { $0.setPostID($1)}).build().postID == nil)
-    }
-
-    @Test("apply never calls the closure if the value is nil")
-    func editorConfigurationBuilderApplyDoesNotCallClosureWithNilValue() throws {
-        let string: String? = nil
-
-        _ = EditorConfigurationBuilder().apply(string, { builder, value in
-            Issue.record("Closure was called")
-            return builder
-        })
-    }
-}
diff --git a/ios/Tests/GutenbergKitTests/EditorManifestTests.swift b/ios/Tests/GutenbergKitTests/EditorManifestTests.swift
deleted file mode 100644
index e127c265..00000000
--- a/ios/Tests/GutenbergKitTests/EditorManifestTests.swift
+++ /dev/null
@@ -1,56 +0,0 @@
-import Foundation
-import Testing
-@testable import GutenbergKit
-
-@Suite("Manifest Tests")
-struct EditorManifestTests {
-
-    @Test
-    func parseAssetLinks() throws {
-        let json = try json(named: "manifest-test-case-1")
-        let manifest = try JSONDecoder().decode(EditorAssetsManifest.self, from: json)
-
-        let links = try manifest.parseAssetLinks(defaultScheme: nil)
-        let scripts = links.filter { $0.contains(".js") }
-        let styles = links.filter { $0.contains(".css") }
-
-        #expect(scripts.count == 79)
-        #expect(styles.count == 22)
-    }
-
-    @Test
-    func editorWebViewGetsCachedLinks() throws {
-        let json = try json(named: "manifest-test-case-1")
-        let original = try JSONDecoder().decode(EditorAssetsManifest.self, from: json)
-        let forEditor = try JSONDecoder().decode(EditorAssetsManifest.self, from: original.renderForEditor(defaultScheme: nil))
-
-        #expect(try original.parseAssetLinks(defaultScheme: nil).count == forEditor.parseAssetLinks(defaultScheme: nil).count)
-
-        for link in try original.parseAssetLinks(defaultScheme: nil) {
-            #expect(link.hasPrefix("http://"))
-        }
-
-        #if canImport(UIKit)
-        for link in try forEditor.parseAssetLinks(defaultScheme: nil) {
-            #expect(link.hasPrefix("gbk-cache-http://"))
-        }
-        #else
-        for link in try forEditor.parseAssetLinks(defaultScheme: nil) {
-            #expect(link.hasPrefix("http://"))
-        }
-        #endif
-    }
-
-    @Test
-    func useDefaultScheme() throws {
-        let scriptHTML = #"<script src="//w.org/lib.js"></script>"#
-        let manifest = EditorAssetsManifest(scripts: scriptHTML, styles: "", allowedBlockTypes: [])
-        #expect(try manifest.parseAssetLinks(defaultScheme: "http") == ["http://w.org/lib.js"])
-        #expect(try manifest.parseAssetLinks(defaultScheme: "https") == ["https://w.org/lib.js"])
-    }
-
-    private func json(named name: String) throws -> Data {
-        let json = Bundle.module.url(forResource: name, withExtension: "json")!
-        return try Data(contentsOf: json)
-    }
-}
diff --git a/ios/Tests/GutenbergKitTests/EditorServiceTests.swift b/ios/Tests/GutenbergKitTests/EditorServiceTests.swift
deleted file mode 100644
index 3c432379..00000000
--- a/ios/Tests/GutenbergKitTests/EditorServiceTests.swift
+++ /dev/null
@@ -1,352 +0,0 @@
-import Foundation
-import Testing
-@testable import GutenbergKit
-
-@Suite("Editor Service Tests")
-struct EditorServiceTests {
-
-    @Test("Successfully loads editor dependencies")
-    func successfullyLoadsDependencies() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        context.session.mockSettings()
-        context.session.mockManifest(context.manifestData)
-        context.session.mockAllAssets(context.assetURLs)
-
-        let service = context.createService()
-        let configuration = context.createConfiguration()
-
-        // WHEN
-        let dependencies = await service.dependencies(for: configuration)
-
-        // THEN dependencies are loaded and editor settings are returned as is
-        #expect(dependencies.editorSettings == #"{"alignWide": true}"#)
-
-        // THEN assets are available on disk and can be loaded
-        for assetURL in context.assetURLs {
-            let cachedURL = try #require(CachedAssetSchemeHandler.cachedURL(forWebLink: assetURL))
-            let gbkURL = try #require(URL(string: cachedURL))
-            let (response, data) = try await service.getCachedAsset(from: gbkURL)
-            #expect(response.url == gbkURL)
-            #expect(!data.isEmpty)
-        }
-    }
-
-    @Test("Loads settings but not manifest when asset download fails")
-    func loadsSettingsWhenAssetFails() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        context.session.mockSettings()
-        context.session.mockManifest(context.manifestData)
-        context.session.mockAllAssets(Array(context.assetURLs[0...1]))
-        context.session.mockFailedAssets(Array(context.assetURLs[2...4]))
-
-        let service = context.createService()
-        let configuration = context.createConfiguration()
-
-        let dependencies = await service.dependencies(for: configuration)
-
-        // THEN settings are loaded
-        #expect(dependencies.editorSettings == #"{"alignWide": true}"#)
-    }
-
-    @Test("Upgrades manifest and assets when version changes")
-    func upgradesManifestOnVersionChange() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        context.session.mockSettings()
-        context.session.mockManifest(context.manifestData)
-        context.session.mockAllAssets(context.assetURLs)
-
-        let service = context.createService()
-        let configuration = context.createConfiguration()
-
-        let initialDependencies = await service.dependencies(for: configuration)
-        #expect(initialDependencies.editorSettings == #"{"alignWide": true}"#)
-
-        // WHEN new manifest is returned with updated assets
-        let upgradedContext = try TestContext(manifestResource: "manifest-test-case-3")
-        context.session.mockManifest(upgradedContext.manifestData)
-        context.session.mockAllAssets(upgradedContext.assetURLs)
-
-        // Force refresh with new manifest
-        await service.refresh(configuration: configuration)
-
-        let upgradedDependencies = await service.dependencies(for: configuration, isWarmup: true)
-
-        // THEN settings are still available
-        #expect(upgradedDependencies.editorSettings == #"{"alignWide": true}"#)
-
-        // THEN upgraded assets are available on disk
-        for assetURL in upgradedContext.assetURLs {
-            let cachedURL = try #require(CachedAssetSchemeHandler.cachedURL(forWebLink: assetURL))
-            let gbkURL = try #require(URL(string: cachedURL))
-            let (response, data) = try await service.getCachedAsset(from: gbkURL)
-            #expect(response.url == gbkURL)
-            #expect(!data.isEmpty)
-        }
-    }
-
-    @Test("Handles concurrent refresh requests correctly")
-    func concurrentRefreshRequests() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        context.session.mockSettings()
-        context.session.mockManifest(context.manifestData)
-        context.session.mockAllAssets(context.assetURLs)
-
-        let service = context.createService()
-        let configuration = context.createConfiguration()
-
-        // Trigger multiple refreshes concurrently
-        async let refresh1: Void = service.refresh(configuration: configuration)
-        async let refresh2: Void = service.refresh(configuration: configuration)
-        async let refresh3: Void = service.refresh(configuration: configuration)
-
-        _ = await (refresh1, refresh2, refresh3)
-
-        // Verify network was only called once despite 3 refresh calls
-        #expect(context.session.requestCount(for: "wp-block-editor/v1/settings") == 1)
-        #expect(context.session.requestCount(for: "wpcom/v2/editor-assets") == 1)
-    }
-
-    @Test("Successfully loads cached asset from disk")
-    func getCachedAssetSuccess() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        context.session.mockSettings()
-        context.session.mockManifest(context.manifestData)
-        context.session.mockAllAssets(context.assetURLs)
-
-        let service = context.createService()
-        let configuration = context.createConfiguration()
-
-        // Load dependencies to cache assets
-        _ = await service.dependencies(for: configuration)
-
-        // Now try to load a cached asset
-        let testAssetURL = context.assetURLs[0]
-        let cachedURL = try #require(CachedAssetSchemeHandler.cachedURL(forWebLink: testAssetURL))
-        let gbkURL = try #require(URL(string: cachedURL))
-
-        let (response, data) = try await service.getCachedAsset(from: gbkURL)
-
-        // Verify response
-        #expect(response.url == gbkURL)
-        #expect(!data.isEmpty)
-        #expect(response.mimeType == "application/javascript")
-    }
-
-    @Test("Skips refresh when data is fresh (< 30s)")
-    func refreshNotNeededWithin30Seconds() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        context.session.mockSettings()
-        context.session.mockManifest(context.manifestData)
-        context.session.mockAllAssets(context.assetURLs)
-
-        let service = context.createService()
-        let configuration = context.createConfiguration()
-
-        // Initial load
-        _ = await service.dependencies(for: configuration)
-
-        // Wait briefly to allow background refresh task to start (but not complete 30s threshold)
-        try await Task.sleep(for: .milliseconds(100))
-
-        // Second load within 30 seconds with warmup flag - should not trigger refresh
-        _ = await service.dependencies(for: configuration, isWarmup: true)
-
-        // Wait to ensure background refresh logic has time to evaluate (but not execute)
-        try await Task.sleep(for: .milliseconds(100))
-
-        // Verify network was only called once
-        #expect(context.session.requestCount(for: "wp-block-editor/v1/settings") == 1)
-        #expect(context.session.requestCount(for: "wpcom/v2/editor-assets") == 1)
-    }
-
-    @Test("Handles invalid siteApiRoot URL gracefully")
-    func invalidSiteApiRootURL() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        let service = context.createService()
-
-        // Create configuration with invalid URL
-        let configuration = EditorConfigurationBuilder()
-            .setSiteUrl("https://example.com")
-            .setSiteApiRoot("not a valid url!")
-            .setAuthHeader("Bearer test-token")
-            .build()
-
-        // Should not crash, just log error and return empty dependencies
-        let dependencies = await service.dependencies(for: configuration)
-
-        // Dependencies should be empty since refresh failed
-        #expect(dependencies.editorSettings == nil)
-    }
-
-    @Test("Returns error when cached asset doesn't exist")
-    func getCachedAssetNotFound() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        let service = context.createService()
-
-        // Try to load an asset that was never cached
-        let fakeURL = URL(string: "gbk-cache-https://example.com/missing.js")!
-
-        // Should throw file not found error
-        await #expect(throws: URLError.self) {
-            try await service.getCachedAsset(from: fakeURL)
-        }
-    }
-
-    @Test("Successfully loads processed manifest")
-    func getProcessedManifestSuccess() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        context.session.mockSettings()
-        context.session.mockManifest(context.manifestData)
-        context.session.mockAllAssets(context.assetURLs)
-
-        let service = context.createService()
-        let configuration = context.createConfiguration()
-
-        // Load dependencies to create and cache the processed manifest
-        _ = await service.dependencies(for: configuration)
-
-        // Now get the processed manifest
-        let manifest = try await service.getProcessedManifest()
-
-        // Verify manifest is valid JSON string
-        #expect(!manifest.isEmpty)
-
-        // Verify it contains gbk-cache scheme URLs (processed format)
-        #if canImport(UIKit)
-        #expect(manifest.contains("gbk-cache-https:"))
-        #endif
-
-        // Verify it contains expected asset references
-        #expect(manifest.contains("jetpack"))
-    }
-
-    @Test("Returns error when processed manifest doesn't exist")
-    func getProcessedManifestNotFound() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        let service = context.createService()
-
-        // Try to get manifest before it's been created
-        await #expect(throws: Error.self) {
-            try await service.getProcessedManifest()
-        }
-    }
-
-    @Test("Cleans up orphaned assets after upgrade")
-    func cleansUpOrphanedAssets() async throws {
-        let context = try TestContext(manifestResource: "manifest-test-case-2")
-        context.session.mockSettings()
-        context.session.mockManifest(context.manifestData)
-        context.session.mockAllAssets(context.assetURLs)
-
-        let service = context.createService()
-        let configuration = context.createConfiguration()
-
-        // Load initial v13.9 dependencies
-        _ = await service.dependencies(for: configuration)
-
-        // Verify all v13.9 assets exist on disk
-        let assetsDir = context.testDir.appendingPathComponent("assets")
-        let initialFiles = try FileManager.default.contentsOfDirectory(atPath: assetsDir.path)
-        #expect(initialFiles.count == 5) // All 5 v13.9 assets
-
-        // Upgrade to v14.0 (which removes slideshow, upgrades forms, adds ai-assistant)
-        let upgradedContext = try TestContext(manifestResource: "manifest-test-case-3")
-        context.session.mockManifest(upgradedContext.manifestData)
-        context.session.mockAllAssets(upgradedContext.assetURLs)
-        context.makeStateFileOld()
-        await service.refresh(configuration: configuration)
-
-        // Run cleanup
-        try await service.cleanupOrphanedAssets()
-
-        // Verify orphaned assets (slideshow v13.9, old versions) are deleted
-        let filesAfterCleanup = try FileManager.default.contentsOfDirectory(atPath: assetsDir.path)
-        #expect(filesAfterCleanup.count == 4) // Only 4 v14.0 assets remain
-
-        // Verify slideshow assets are gone
-        let slideshowFilename = service.cachedFilename(for: "https://example.com/wp-content/plugins/jetpack/_inc/blocks/slideshow/editor.js?ver=13.9")
-        #expect(!filesAfterCleanup.contains(slideshowFilename))
-
-        // Verify v14.0 assets are retained
-        for assetURL in upgradedContext.assetURLs {
-            let filename = service.cachedFilename(for: assetURL)
-            #expect(filesAfterCleanup.contains(filename))
-        }
-    }
-}
-
-// MARK: - Test Helpers
-
-private struct TestContext {
-    let session = MockURLSession()
-    let testDir: URL
-    let manifestData: Data
-    let assetURLs: [String]
-
-    init(manifestResource: String) throws {
-        let manifestURL = Bundle.module.url(forResource: manifestResource, withExtension: "json")!
-        self.manifestData = try Data(contentsOf: manifestURL)
-
-        let manifest = try JSONDecoder().decode(EditorAssetsManifest.self, from: manifestData)
-        self.assetURLs = try manifest.parseAssetLinks()
-
-        self.testDir = FileManager.default.temporaryDirectory
-            .appendingPathComponent(UUID().uuidString, isDirectory: true)
-        try FileManager.default.createDirectory(at: testDir, withIntermediateDirectories: true)
-    }
-
-    func createService() -> EditorService {
-        EditorService(siteURL: "https://example.com", storeURL: testDir, networkSession: session)
-    }
-
-    func createConfiguration() -> EditorConfiguration {
-        EditorConfigurationBuilder()
-            .setSiteUrl("https://example.com")
-            .setSiteApiRoot("https://example.com")
-            .setAuthHeader("Bearer test-token")
-            .build()
-    }
-
-    func makeStateFileOld() {
-        let stateFileURL = testDir.appendingPathComponent("state.json")
-        let oldDate = Date().addingTimeInterval(-31) // 31 seconds ago
-        let state = EditorService.State(refreshDate: oldDate)
-        try? JSONEncoder().encode(state).write(to: stateFileURL)
-    }
-}
-
-private extension MockURLSession {
-    func mockSettings() {
-        mockResponse(
-            for: "https://example.com/wp-block-editor/v1/settings",
-            data: """
-            {"alignWide": true}
-            """.data(using: .utf8)!,
-            statusCode: 200
-        )
-    }
-
-    func mockManifest(_ data: Data) {
-        mockResponse(
-            for: "https://example.com/wpcom/v2/editor-assets?exclude=core,gutenberg",
-            data: data,
-            statusCode: 200
-        )
-    }
-
-    func mockAllAssets(_ assetURLs: [String]) {
-        for assetURL in assetURLs {
-            mockResponse(
-                for: assetURL,
-                data: assetURL.data(using: .utf8)!,
-                statusCode: 200
-            )
-        }
-    }
-
-    func mockFailedAssets(_ assetURLs: [String]) {
-        for assetURL in assetURLs {
-            mockResponse(for: assetURL, data: Data(), statusCode: 404)
-        }
-    }
-}
diff --git a/src/utils/api-fetch.js b/src/utils/api-fetch.js
index 3ce2f551..1e6e6c81 100644
--- a/src/utils/api-fetch.js
+++ b/src/utils/api-fetch.js
@@ -19,7 +19,7 @@ import { getGBKit } from './bridge';
  * @return {void}
  */
 export function configureApiFetch() {
-	const { siteApiRoot = '' } = getGBKit();
+	const { siteApiRoot = '', preloadData = null } = getGBKit();
 
 	apiFetch.use( apiFetch.createRootURLMiddleware( siteApiRoot ) );
 	apiFetch.use( corsMiddleware );
@@ -28,7 +28,9 @@ export function configureApiFetch() {
 	apiFetch.use( filterEndpointsMiddleware );
 	apiFetch.use( mediaUploadMiddleware );
 	apiFetch.use( transformOEmbedApiResponse );
-	apiFetch.use( apiFetch.createPreloadingMiddleware( preloadData ) );
+	apiFetch.use(
+		apiFetch.createPreloadingMiddleware( preloadData ?? defaultPreloadData )
+	);
 }
 
 /**
@@ -201,13 +203,7 @@ function transformOEmbedApiResponse( options, next ) {
 	return next( options, next );
 }
 
-/**
- * Initial data to reduce initial render time. E.g., the PostTitle component
- * requires the post type data to render the title placeholder.
- *
- * @todo Provide this data from the host app
- */
-const preloadData = {
+const defaultPreloadData = {
 	'/wp/v2/types?context=view': {
 		body: {
 			post: {