feat(ios): generate SupportedLocales at build time via SwiftPM plugin

Introduce a `BuildToolPlugin` that reads the JS-emitted
`supported-locales.json` manifest before `GutenbergKit` compiles and
emits an `internal enum SupportedLocales { static let all: Set<String> }`
constant. The resolver consumes the constant directly, dropping the
runtime IO that the previous commit shipped.

This mirrors the Android sibling's `:Gutenberg:generateSupportedLocales`
gradle task: a missing manifest fails the build (SwiftPM reports it as a
missing input), so a release that silently degrades every consumer to
English is unreachable in shipped artifacts. SwiftPM's incremental graph
treats the manifest as an input file, so changes from `make build`
trigger regeneration without rebuilding the whole target.

Layout:

- `ios/Plugins/SupportedLocalesPlugin/` — the plugin itself; computes the
  manifest URL via `context.package.directoryURL` and wires up a
  buildCommand against the generator tool.
- `ios/Plugins/GenerateSupportedLocales/` — small `executableTarget` the
  plugin invokes. Reads the manifest, validates it's a JSON array of
  strings, writes the Swift source. Friendly error messages for
  missing/malformed input as a backstop in case SwiftPM's prebuild check
  is bypassed.

`GutenbergKitResources.loadSupportedLocales()` is removed since it now
has no callers.

Author: jkmassel

Package.swift

@@ -30,7 +30,18 @@ let package = Package(
             dependencies: ["SwiftSoup", "SVGView", "GutenbergKitResources"],
             path: "ios/Sources/GutenbergKit",
             exclude: ["Gutenberg"],
-            packageAccess: false
+            packageAccess: false,
+            plugins: ["SupportedLocalesPlugin"]
+        ),
+        .executableTarget(
+            name: "GenerateSupportedLocales",
+            path: "ios/Plugins/GenerateSupportedLocales"
+        ),
+        .plugin(
+            name: "SupportedLocalesPlugin",
+            capability: .buildTool(),
+            dependencies: ["GenerateSupportedLocales"],
+            path: "ios/Plugins/SupportedLocalesPlugin"
         ),
         .target(
             name: "GutenbergKitHTTP",

ios/Plugins/GenerateSupportedLocales/GenerateSupportedLocales.swift

@@ -0,0 +1,71 @@
+import Foundation
+
+/// Reads `supported-locales.json` (a JSON array of locale tags emitted by the
+/// Vite build) and writes a Swift source file declaring an
+/// `internal enum SupportedLocales { static let all: Set<String> }` constant.
+///
+/// Invoked by `SupportedLocalesPlugin` as a buildCommand; not intended to be
+/// run directly.
+@main
+struct GenerateSupportedLocales {
+    static func main() {
+        let args = CommandLine.arguments
+        guard args.count == 3 else {
+            fail("usage: GenerateSupportedLocales <manifest.json> <output.swift>")
+        }
+
+        let manifestURL = URL(fileURLWithPath: args[1])
+        let outputURL = URL(fileURLWithPath: args[2])
+
+        guard FileManager.default.fileExists(atPath: manifestURL.path) else {
+            fail(
+                "missing supported-locales manifest at \(manifestURL.path). "
+                + "Run `make build` to regenerate it."
+            )
+        }
+
+        let data: Data
+        do {
+            data = try Data(contentsOf: manifestURL)
+        } catch {
+            fail("could not read \(manifestURL.path): \(error.localizedDescription)")
+        }
+
+        let locales: [String]
+        do {
+            locales = try JSONDecoder().decode([String].self, from: data)
+        } catch {
+            fail(
+                "manifest at \(manifestURL.path) is not a JSON array of strings: "
+                + "\(error.localizedDescription)"
+            )
+        }
+
+        let entries = Set(locales).sorted()
+            .map { "        \"\($0)\"" }
+            .joined(separator: ",\n")
+
+        let source = """
+            // Generated by SupportedLocalesPlugin from supported-locales.json.
+            // Do not edit.
+
+            internal enum SupportedLocales {
+                static let all: Set<String> = [
+            \(entries)
+                ]
+            }
+
+            """
+
+        do {
+            try source.write(to: outputURL, atomically: true, encoding: .utf8)
+        } catch {
+            fail("could not write \(outputURL.path): \(error.localizedDescription)")
+        }
+    }
+
+    private static func fail(_ message: String) -> Never {
+        FileHandle.standardError.write(Data("error: \(message)\n".utf8))
+        exit(1)
+    }
+}

ios/Plugins/SupportedLocalesPlugin/SupportedLocalesPlugin.swift

@@ -0,0 +1,39 @@
+import Foundation
+import PackagePlugin
+
+/// Generates `SupportedLocales.swift` from the JS-emitted manifest before
+/// `GutenbergKit` is compiled.
+///
+/// The Vite build writes `dist/supported-locales.json` and `make
+/// copy-dist-ios` copies it to
+/// `ios/Sources/GutenbergKitResources/Gutenberg/supported-locales.json`.
+/// This plugin reads that file at build time and emits an
+/// `internal enum SupportedLocales { static let all: Set<String> }`
+/// constant the resolver can use without runtime IO.
+///
+/// A missing manifest fails the build with a message pointing at `make
+/// build`, so the silent-fall-through-to-English failure mode is unreachable
+/// in shipped artifacts.
+@main
+struct SupportedLocalesPlugin: BuildToolPlugin {
+    func createBuildCommands(context: PluginContext, target: Target) throws -> [Command] {
+        let manifestURL = context.package.directoryURL
+            .appending(path: "ios/Sources/GutenbergKitResources/Gutenberg/supported-locales.json")
+        let outputURL = context.pluginWorkDirectoryURL
+            .appending(path: "SupportedLocales.swift")
+        let tool = try context.tool(named: "GenerateSupportedLocales")
+
+        return [
+            .buildCommand(
+                displayName: "Generate SupportedLocales.swift",
+                executable: tool.url,
+                arguments: [
+                    manifestURL.path(percentEncoded: false),
+                    outputURL.path(percentEncoded: false),
+                ],
+                inputFiles: [manifestURL],
+                outputFiles: [outputURL]
+            )
+        ]
+    }
+}

ios/Sources/GutenbergKit/Sources/Model/LocaleResolver.swift

@@ -1,5 +1,4 @@
 import Foundation
-import GutenbergKitResources
 
 /// Resolves an arbitrary locale tag to one of the bundles GutenbergKit
 /// actually ships translations for.
@@ -27,16 +26,23 @@ import GutenbergKitResources
 /// (e.g. `de-DE-u-ca-gregory`) are ignored — the editor doesn't vary
 /// translations by calendar or numbering system.
 ///
-/// The supported set is read from a manifest emitted by the JS build, so
-/// it stays in sync with what the bundle actually ships.
+/// The supported set is generated at build time from the JS build manifest
+/// (see `SupportedLocalesPlugin`), so the resolver and the shipped bundles
+/// cannot drift.
 struct LocaleResolver {
     static let `default` = LocaleResolver()
 
     private let supportedLocales: Set<String>
 
     init(supportedLocales: [String]? = nil) {
-        let source = supportedLocales ?? GutenbergKitResources.loadSupportedLocales()
-        self.supportedLocales = Set(source.map { Self.normalize($0) })
+        if let supportedLocales {
+            self.supportedLocales = Set(supportedLocales.map(Self.normalize))
+        } else {
+            // The build-time-generated set is already lowercase-with-dashes
+            // (JS emits the manifest in that form), so no normalisation is
+            // needed for the default path.
+            self.supportedLocales = SupportedLocales.all
+        }
     }
 
     /// Resolves a string locale tag against the shipped translation bundles.

ios/Sources/GutenbergKitResources/Sources/GutenbergKitResources.swift

@@ -27,30 +27,6 @@ public enum GutenbergKitResources {
         return url
     }
 
-    /// Loads the list of locale tags for which the bundle ships translations.
-    ///
-    /// The list is generated at JS build time by scanning `src/translations/`,
-    /// so it is the single source of truth for "what do we actually ship?".
-    /// Returns an empty array when the manifest is missing — callers should
-    /// treat that as "no shipped translations" and fall back to the default
-    /// locale rather than crashing.
-    ///
-    /// - Returns: The shipped locale tags (e.g. `["ar", "de", "pt-br", "zh-cn"]`).
-    public static func loadSupportedLocales() -> [String] {
-        guard let url = Bundle.module.url(
-            forResource: "supported-locales",
-            withExtension: "json",
-            subdirectory: "Gutenberg"
-        ) else {
-            return []
-        }
-        guard let data = try? Data(contentsOf: url),
-              let locales = try? JSONDecoder().decode([String].self, from: data) else {
-            return []
-        }
-        return locales
-    }
-
     /// Loads the Gutenberg CSS from the bundled assets.
     ///
     /// Scans the `Gutenberg/assets/` directory for the Vite-generated

ios/Tests/GutenbergKitTests/Model/LocaleResolverTests.swift

@@ -1,5 +1,4 @@
 import Foundation
-import GutenbergKitResources
 import Testing
 
 @testable import GutenbergKit
@@ -118,15 +117,15 @@ struct LocaleResolverTests {
 
   // MARK: - Exhaustive coverage of the shipped manifest
 
-  // The default resolver reads the manifest emitted by `make build`. Tests
-  // run after `make build` (see Makefile), so the list reflects what the
-  // bundle actually ships. Each parameterised case asserts the round-trip
-  // contract: a shipped tag must resolve to itself — no normalisation
-  // tricks, no accidental fallbacks.
+  // `SupportedLocales.all` is generated at build time by
+  // `SupportedLocalesPlugin` from the JS-emitted manifest, so the set
+  // reflects what the bundle actually ships. Each parameterised case
+  // asserts the round-trip contract: a shipped tag must resolve to
+  // itself — no normalisation tricks, no accidental fallbacks.
 
-  static let shippedLocales = GutenbergKitResources.loadSupportedLocales()
+  static let shippedLocales = Array(SupportedLocales.all).sorted()
 
-  @Test("Manifest is non-empty (run `make build` first)")
+  @Test("SupportedLocales.all is non-empty (plugin should fail the build otherwise)")
   func manifestPresent() {
     #expect(!Self.shippedLocales.isEmpty)
   }