@sigx/lynx-updates 0.6.1

package/ios/UpdateStore.swift

@@ -0,0 +1,286 @@
+import Foundation
+import Lynx
+
+/// On-disk update store + state machine shared by `UpdatesBundleResolver`
+/// (startup, before any LynxView exists) and `UpdatesModule` (JS bridge).
+/// Mirror of the Android `UpdateStore` — see that file for the lifecycle
+/// description; the layouts and state.json schema are identical.
+final class UpdateStore {
+
+    static let shared = UpdateStore()
+    private init() {}
+
+    private let lock = NSRecursiveLock()
+    static let runtimeVersionPlistKey = "SigxRuntimeVersion"
+
+    /// What this process actually loaded (set by the resolver).
+    private(set) var launchedUpdateId: String?
+    /// True when this launch is a pending update's trial run.
+    private(set) var isFirstLaunchAfterUpdate = false
+    /// True when the resolver rolled back at this startup.
+    private(set) var didRollBack = false
+    private(set) var rolledBackUpdateId: String?
+
+    /// Last-attached LynxView — apply-now reload target.
+    private weak var lynxView: LynxView?
+
+    func attachView(_ view: LynxView) {
+        lock.lock(); defer { lock.unlock() }
+        lynxView = view
+    }
+
+    func currentView() -> LynxView? {
+        lock.lock(); defer { lock.unlock() }
+        return lynxView
+    }
+
+    // MARK: - Paths
+
+    var rootDir: URL {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+        return base.appendingPathComponent("sigx-updates", isDirectory: true)
+    }
+    var updatesDir: URL { rootDir.appendingPathComponent("updates", isDirectory: true) }
+    var tmpDir: URL { rootDir.appendingPathComponent("tmp", isDirectory: true) }
+    func updateDir(_ updateId: String) -> URL { updatesDir.appendingPathComponent(updateId, isDirectory: true) }
+    func bundleFile(_ updateId: String) -> URL { updateDir(updateId).appendingPathComponent("main.lynx.bundle") }
+    func updateJsonFile(_ updateId: String) -> URL { updateDir(updateId).appendingPathComponent("update.json") }
+    private var stateFile: URL { rootDir.appendingPathComponent("state.json") }
+
+    /// OTA payloads are re-downloadable — exclude from iCloud/iTunes backup.
+    private func excludeFromBackup(_ url: URL) {
+        var u = url
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = true
+        try? u.setResourceValues(values)
+    }
+
+    // MARK: - Binary identity
+
+    func installedRuntimeVersion() -> String {
+        (Bundle.main.object(forInfoDictionaryKey: Self.runtimeVersionPlistKey) as? String) ?? "unknown"
+    }
+
+    func installedBinaryVersion() -> String {
+        (Bundle.main.object(forInfoDictionaryKey: "CFBundleVersion") as? String) ?? "unknown"
+    }
+
+    // MARK: - State
+
+    struct State {
+        var installedRuntimeVersion = ""
+        var installedBinaryVersion = ""
+        var currentUpdateId: String?
+        var previousUpdateId: String?
+        var pendingUpdateId: String?
+        var pendingLaunchAttempts = 0
+        var maxLaunchAttempts = 2
+        var lastRollbackUpdateId: String?
+        var lastRollbackReason: String?
+    }
+
+    func readState() -> State? {
+        lock.lock(); defer { lock.unlock() }
+        guard let data = try? Data(contentsOf: stateFile),
+              let json = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] else {
+            return nil
+        }
+        func str(_ key: String) -> String? {
+            let v = json[key] as? String
+            return (v?.isEmpty ?? true) ? nil : v
+        }
+        var state = State()
+        state.installedRuntimeVersion = (json["installedRuntimeVersion"] as? String) ?? ""
+        state.installedBinaryVersion = (json["installedBinaryVersion"] as? String) ?? ""
+        state.currentUpdateId = str("currentUpdateId")
+        state.previousUpdateId = str("previousUpdateId")
+        state.pendingUpdateId = str("pendingUpdateId")
+        state.pendingLaunchAttempts = (json["pendingLaunchAttempts"] as? Int) ?? 0
+        state.maxLaunchAttempts = (json["maxLaunchAttempts"] as? Int) ?? 2
+        state.lastRollbackUpdateId = str("lastRollbackUpdateId")
+        state.lastRollbackReason = str("lastRollbackReason")
+        return state
+    }
+
+    /// Atomic write — the launch-attempt counter must survive a crash.
+    func writeState(_ state: State) {
+        lock.lock(); defer { lock.unlock() }
+        let json: [String: Any] = [
+            "schemaVersion": 1,
+            "installedRuntimeVersion": state.installedRuntimeVersion,
+            "installedBinaryVersion": state.installedBinaryVersion,
+            "currentUpdateId": state.currentUpdateId ?? "",
+            "previousUpdateId": state.previousUpdateId ?? "",
+            "pendingUpdateId": state.pendingUpdateId ?? "",
+            "pendingLaunchAttempts": state.pendingLaunchAttempts,
+            "maxLaunchAttempts": state.maxLaunchAttempts,
+            "lastRollbackUpdateId": state.lastRollbackUpdateId ?? "",
+            "lastRollbackReason": state.lastRollbackReason ?? "",
+        ]
+        try? FileManager.default.createDirectory(at: rootDir, withIntermediateDirectories: true)
+        excludeFromBackup(rootDir)
+        if let data = try? JSONSerialization.data(withJSONObject: json) {
+            try? data.write(to: stateFile, options: .atomic)
+        }
+    }
+
+    func freshState() -> State {
+        var state = State()
+        state.installedRuntimeVersion = installedRuntimeVersion()
+        state.installedBinaryVersion = installedBinaryVersion()
+        return state
+    }
+
+    // MARK: - Startup resolution
+
+    /// Decide which bundle this launch loads. Returns an absolute path to an
+    /// OTA bundle, or nil to use the baked resource. Mutates rollback state —
+    /// the generated host calls it exactly once per process launch.
+    func resolveStartupBundlePath() -> String? {
+        lock.lock(); defer { lock.unlock() }
+        let fm = FileManager.default
+        try? fm.removeItem(at: tmpDir)
+
+        guard var state = readState() else {
+            if fm.fileExists(atPath: stateFile.path) {
+                // Unparseable state — wipe everything, run baked.
+                try? fm.removeItem(at: rootDir)
+            }
+            return nil
+        }
+
+        // Binary-update tripwire: a store update invalidates every
+        // downloaded update — they were published for the old runtime.
+        let runtimeNow = installedRuntimeVersion()
+        let binaryNow = installedBinaryVersion()
+        if state.installedRuntimeVersion != runtimeNow || state.installedBinaryVersion != binaryNow {
+            try? fm.removeItem(at: updatesDir)
+            writeState(freshState())
+            return nil
+        }
+
+        // Pending update: crash-guarded trial launch.
+        if let pending = state.pendingUpdateId {
+            if state.pendingLaunchAttempts >= state.maxLaunchAttempts {
+                rollbackPending(&state, reason: "crash")
+            } else {
+                let bundle = bundleFile(pending)
+                let firstAttempt = state.pendingLaunchAttempts == 0
+                let intact = fm.fileExists(atPath: bundle.path) && (!firstAttempt || verifySha256(pending))
+                if intact {
+                    state.pendingLaunchAttempts += 1
+                    writeState(state)
+                    launchedUpdateId = pending
+                    isFirstLaunchAfterUpdate = firstAttempt
+                    sweepOrphans(state)
+                    return bundle.path
+                }
+                rollbackPending(&state, reason: "corrupt")
+            }
+        }
+
+        // Committed update: trusted (existence check only).
+        if let current = state.currentUpdateId {
+            let bundle = bundleFile(current)
+            if fm.fileExists(atPath: bundle.path) {
+                launchedUpdateId = current
+                sweepOrphans(state)
+                return bundle.path
+            }
+            state.currentUpdateId = nil
+            writeState(state)
+        }
+
+        sweepOrphans(state)
+        return nil
+    }
+
+    private func rollbackPending(_ state: inout State, reason: String) {
+        guard let pending = state.pendingUpdateId else { return }
+        didRollBack = true
+        rolledBackUpdateId = pending
+        try? FileManager.default.removeItem(at: updateDir(pending))
+        state.lastRollbackUpdateId = pending
+        state.lastRollbackReason = reason
+        state.pendingUpdateId = nil
+        state.pendingLaunchAttempts = 0
+        writeState(state)
+    }
+
+    private func sweepOrphans(_ state: State) {
+        let keep = Set([state.currentUpdateId, state.previousUpdateId, state.pendingUpdateId].compactMap { $0 })
+        let entries = (try? FileManager.default.contentsOfDirectory(at: updatesDir, includingPropertiesForKeys: nil)) ?? []
+        for entry in entries where !keep.contains(entry.lastPathComponent) {
+            try? FileManager.default.removeItem(at: entry)
+        }
+    }
+
+    // MARK: - Transitions
+
+    /// Stage a downloaded update to load on the next launch. Returns an error message or nil.
+    func stagePending(_ updateId: String) -> String? {
+        lock.lock(); defer { lock.unlock() }
+        guard FileManager.default.fileExists(atPath: bundleFile(updateId).path) else {
+            return "Update \(updateId) is not on disk"
+        }
+        var state = readState() ?? freshState()
+        if state.currentUpdateId == updateId { return nil }
+        state.pendingUpdateId = updateId
+        state.pendingLaunchAttempts = 0
+        writeState(state)
+        return nil
+    }
+
+    /// Arm the crash guard for an in-place reload (which bypasses the resolver).
+    func recordReloadAttempt(_ updateId: String) {
+        lock.lock(); defer { lock.unlock() }
+        var state = readState() ?? freshState()
+        if state.pendingUpdateId != updateId {
+            state.pendingUpdateId = updateId
+        }
+        state.pendingLaunchAttempts += 1
+        writeState(state)
+        launchedUpdateId = updateId
+        isFirstLaunchAfterUpdate = true
+    }
+
+    /// Commit the running pending update as healthy. Idempotent.
+    func markReady() {
+        lock.lock(); defer { lock.unlock() }
+        guard var state = readState(), let pending = state.pendingUpdateId else { return }
+        guard launchedUpdateId == pending else { return }
+        if let previous = state.previousUpdateId {
+            try? FileManager.default.removeItem(at: updateDir(previous))
+        }
+        state.previousUpdateId = state.currentUpdateId
+        state.currentUpdateId = pending
+        state.pendingUpdateId = nil
+        state.pendingLaunchAttempts = 0
+        writeState(state)
+    }
+
+    func setMaxLaunchAttempts(_ max: Int) {
+        lock.lock(); defer { lock.unlock() }
+        var state = readState() ?? freshState()
+        state.maxLaunchAttempts = Swift.min(Swift.max(max, 1), 10)
+        writeState(state)
+    }
+
+    func clearAll() {
+        lock.lock(); defer { lock.unlock() }
+        try? FileManager.default.removeItem(at: updatesDir)
+        try? FileManager.default.removeItem(at: tmpDir)
+        writeState(freshState())
+    }
+
+    // MARK: - Helpers
+
+    func verifySha256(_ updateId: String) -> Bool {
+        guard let data = try? Data(contentsOf: updateJsonFile(updateId)),
+              let json = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
+              let expected = (json["sha256"] as? String)?.lowercased(), !expected.isEmpty else {
+            return false
+        }
+        return Sha256.fileHex(bundleFile(updateId)) == expected
+    }
+}

package/ios/UpdatesBundleResolver.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+/// Startup bundle resolver — the host's `GeneratedBundleResolver` delegates
+/// here (declared as `ios.bundleResolverClass` in signalx-module.json).
+///
+/// Runs synchronously in `ContentView.init` BEFORE any LynxView is built,
+/// and mutates rollback state (the launch-attempt counter), so it must run
+/// exactly once per process launch — which the generated host guarantees by
+/// resolving into a stored `let`.
+enum UpdatesBundleResolver {
+
+    static func resolveStartupBundlePath() -> String? {
+        UpdateStore.shared.resolveStartupBundlePath()
+    }
+}

package/ios/UpdatesEventBus.swift

@@ -0,0 +1,59 @@
+import Foundation
+import CryptoKit
+
+/// Module → publisher event bus (the `BackgroundEventBus` pattern). The
+/// module emits download progress / foreground events here; the per-LynxView
+/// `UpdatesLifecyclePublisher` pumps them into JS via `sendGlobalEvent` on
+/// the `__sigxUpdatesEvent` channel.
+final class UpdatesEventBus {
+
+    static let shared = UpdatesEventBus()
+    static let channel = "__sigxUpdatesEvent"
+
+    typealias Payload = [String: Any]
+    typealias Listener = (Payload) -> Void
+
+    private let queue = DispatchQueue(label: "com.sigx.updates.bus")
+    private var listeners: [(token: UUID, fn: Listener)] = []
+
+    @discardableResult
+    func addListener(_ fn: @escaping Listener) -> UUID {
+        let token = UUID()
+        queue.sync { listeners.append((token, fn)) }
+        return token
+    }
+
+    func removeListener(_ token: UUID) {
+        queue.sync { listeners.removeAll { $0.token == token } }
+    }
+
+    func emit(_ payload: Payload) {
+        let snapshot = queue.sync { listeners }
+        for (_, fn) in snapshot { fn(payload) }
+    }
+
+    func emitProgress(receivedBytes: Int64, totalBytes: Int64?) {
+        var payload: Payload = ["kind": "progress", "receivedBytes": receivedBytes]
+        if let total = totalBytes, total >= 0 { payload["totalBytes"] = total }
+        emit(payload)
+    }
+
+    func emitForeground() {
+        emit(["kind": "foreground"])
+    }
+}
+
+/// Streaming SHA-256 helpers (CryptoKit).
+enum Sha256 {
+    static func fileHex(_ url: URL) -> String? {
+        guard let handle = try? FileHandle(forReadingFrom: url) else { return nil }
+        defer { try? handle.close() }
+        var hasher = SHA256()
+        while true {
+            let chunk = handle.readData(ofLength: 64 * 1024)
+            if chunk.isEmpty { break }
+            hasher.update(data: chunk)
+        }
+        return hasher.finalize().map { String(format: "%02x", $0) }.joined()
+    }
+}

package/ios/UpdatesLifecyclePublisher.swift

@@ -0,0 +1,48 @@
+import Foundation
+import UIKit
+import Lynx
+
+/// Per-LynxView publisher: pumps `UpdatesEventBus` payloads into JS
+/// (`__sigxUpdatesEvent`), registers the view with `UpdateStore` so
+/// `applyNow` has a reload target, and converts background→active app
+/// transitions into `foreground` events for `checkOn: ['foreground']`.
+/// Instantiated by the generated `GeneratedLifecyclePublishers.attachAll(to:)`.
+final class UpdatesLifecyclePublisher {
+
+    private weak var lynxView: LynxView?
+    private var token: UUID?
+    private var observers: [NSObjectProtocol] = []
+    private var sawBackground = false
+
+    init(lynxView: LynxView) {
+        self.lynxView = lynxView
+        UpdateStore.shared.attachView(lynxView)
+        token = UpdatesEventBus.shared.addListener { [weak self] payload in
+            guard let view = self?.lynxView else { return }
+            view.sendGlobalEvent(UpdatesEventBus.channel, withParams: [payload])
+        }
+
+        // Foreground detection: only resume-after-background counts — cold
+        // start is covered by the JS 'launch' trigger.
+        let center = NotificationCenter.default
+        observers.append(center.addObserver(
+            forName: UIApplication.didEnterBackgroundNotification, object: nil, queue: .main
+        ) { [weak self] _ in
+            self?.sawBackground = true
+        })
+        observers.append(center.addObserver(
+            forName: UIApplication.didBecomeActiveNotification, object: nil, queue: .main
+        ) { [weak self] _ in
+            guard let self, self.sawBackground else { return }
+            self.sawBackground = false
+            UpdatesEventBus.shared.emitForeground()
+        })
+    }
+
+    deinit {
+        if let token { UpdatesEventBus.shared.removeListener(token) }
+        for observer in observers {
+            NotificationCenter.default.removeObserver(observer)
+        }
+    }
+}

package/ios/UpdatesModule.swift

@@ -0,0 +1,178 @@
+import Foundation
+import Lynx
+
+/// JS bridge for OTA updates.
+/// JS usage: NativeModules.Updates.downloadUpdate({...}, callback)
+class UpdatesModule: NSObject, LynxModule {
+
+    @objc static var name: String { "Updates" }
+
+    @objc static var methodLookup: [String: String] {
+        [
+            "getInstalledRuntimeVersion": NSStringFromSelector(#selector(getInstalledRuntimeVersion)),
+            "getPlatform": NSStringFromSelector(#selector(getPlatform)),
+            "getCurrentUpdate": NSStringFromSelector(#selector(getCurrentUpdate(_:))),
+            "getState": NSStringFromSelector(#selector(getState(_:))),
+            "downloadUpdate": NSStringFromSelector(#selector(downloadUpdate(_:callback:))),
+            "applyOnNextLaunch": NSStringFromSelector(#selector(applyOnNextLaunch(_:callback:))),
+            "applyNow": NSStringFromSelector(#selector(applyNow(_:callback:))),
+            "markReady": NSStringFromSelector(#selector(markReady(_:))),
+            "setRollbackOptions": NSStringFromSelector(#selector(setRollbackOptions(_:callback:))),
+            "clearUpdates": NSStringFromSelector(#selector(clearUpdates(_:))),
+        ]
+    }
+
+    private static let downloadQueue = DispatchQueue(label: "com.sigx.updates.download")
+
+    required override init() { super.init() }
+    required init(param: Any) { super.init() }
+
+    private func errorMap(_ message: String, code: String? = nil) -> [String: Any] {
+        var map: [String: Any] = ["error": message]
+        if let code { map["code"] = code }
+        return map
+    }
+
+    @objc func getInstalledRuntimeVersion() -> String {
+        UpdateStore.shared.installedRuntimeVersion()
+    }
+
+    @objc func getPlatform() -> String { "ios" }
+
+    @objc func getCurrentUpdate(_ callback: LynxCallbackBlock?) {
+        let store = UpdateStore.shared
+        var map: [String: Any] = [
+            "runtimeVersion": store.installedRuntimeVersion(),
+            // Store-shipped app version — providers receive it as
+            // UpdateCheckContext.embeddedVersion.
+            "embeddedVersion": (Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String) ?? "",
+            "isFirstLaunchAfterUpdate": store.isFirstLaunchAfterUpdate,
+            "didRollBack": store.didRollBack,
+        ]
+        if let updateId = store.launchedUpdateId {
+            map["updateId"] = updateId
+            map["isEmbedded"] = false
+            if let data = try? Data(contentsOf: store.updateJsonFile(updateId)),
+               let meta = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
+               let version = meta["version"] as? String {
+                map["version"] = version
+            }
+        } else {
+            map["isEmbedded"] = true
+        }
+        if let rolledBack = store.rolledBackUpdateId {
+            map["rolledBackUpdateId"] = rolledBack
+        }
+        callback?(map)
+    }
+
+    @objc func getState(_ callback: LynxCallbackBlock?) {
+        let store = UpdateStore.shared
+        var map: [String: Any] = ["runningUpdateId": store.launchedUpdateId ?? ""]
+        if let state = store.readState() {
+            map["currentUpdateId"] = state.currentUpdateId ?? ""
+            map["previousUpdateId"] = state.previousUpdateId ?? ""
+            map["pendingUpdateId"] = state.pendingUpdateId ?? ""
+            map["pendingLaunchAttempts"] = state.pendingLaunchAttempts
+            map["maxLaunchAttempts"] = state.maxLaunchAttempts
+            map["lastRollbackUpdateId"] = state.lastRollbackUpdateId ?? ""
+            map["lastRollbackReason"] = state.lastRollbackReason ?? ""
+        }
+        callback?(map)
+    }
+
+    @objc func downloadUpdate(_ params: [String: Any]?, callback: LynxCallbackBlock?) {
+        guard let url = params?["url"] as? String, !url.isEmpty,
+              let sha256 = params?["sha256"] as? String, !sha256.isEmpty,
+              let updateId = params?["updateId"] as? String, !updateId.isEmpty else {
+            callback?(errorMap("url, sha256 and updateId are required"))
+            return
+        }
+
+        // Refuse incompatible bundles at the door — defense in depth on top
+        // of the JS-side check.
+        let installed = UpdateStore.shared.installedRuntimeVersion()
+        if let runtimeVersion = params?["runtimeVersion"] as? String,
+           !runtimeVersion.isEmpty, runtimeVersion != installed {
+            callback?(errorMap(
+                "Update requires runtime \(runtimeVersion) but binary is \(installed)",
+                code: "E_RUNTIME_MISMATCH"))
+            return
+        }
+
+        let headers = (params?["headers"] as? [String: String]) ?? [:]
+        let manifestJson = (params?["manifestJson"] as? String) ?? "{}"
+
+        Self.downloadQueue.async {
+            let result = UpdateDownloader.download(
+                url: url, expectedSha256: sha256, updateId: updateId,
+                headers: headers, manifestJson: manifestJson)
+            if let result {
+                let code: String? = result.hasPrefix("E_DOWNLOAD_IN_PROGRESS") ? "E_DOWNLOAD_IN_PROGRESS"
+                    : result.hasPrefix("E_HASH_MISMATCH") ? "hash-mismatch"
+                    : nil
+                callback?(self.errorMap(result, code: code))
+            } else {
+                callback?(["ok": true])
+            }
+        }
+    }
+
+    @objc func applyOnNextLaunch(_ updateId: String?, callback: LynxCallbackBlock?) {
+        guard let updateId, !updateId.isEmpty else {
+            callback?(errorMap("updateId is required"))
+            return
+        }
+        if let failure = UpdateStore.shared.stagePending(updateId) {
+            callback?(errorMap(failure))
+        } else {
+            callback?(["ok": true])
+        }
+    }
+
+    @objc func applyNow(_ updateId: String?, callback: LynxCallbackBlock?) {
+        guard let updateId, !updateId.isEmpty else {
+            callback?(errorMap("updateId is required"))
+            return
+        }
+        let store = UpdateStore.shared
+        let bundle = store.bundleFile(updateId)
+        guard FileManager.default.fileExists(atPath: bundle.path) else {
+            callback?(errorMap("Update \(updateId) is not on disk"))
+            return
+        }
+        guard let view = store.currentView() else {
+            callback?(errorMap("No LynxView attached — cannot reload in place", code: "E_NO_VIEW"))
+            return
+        }
+        // Stage first so a crash mid-reload still gets crash-guarded rollback
+        // (the reload bypasses the startup resolver).
+        _ = store.stagePending(updateId)
+        store.recordReloadAttempt(updateId)
+        DispatchQueue.main.async {
+            guard let data = try? Data(contentsOf: bundle) else {
+                callback?(self.errorMap("Could not read \(bundle.path)", code: "apply-failed"))
+                return
+            }
+            view.loadTemplate(data, withURL: bundle.path)
+            // JS context is replaced — the callback never reaches the old
+            // context on success, which is the documented contract.
+        }
+    }
+
+    @objc func markReady(_ callback: LynxCallbackBlock?) {
+        UpdateStore.shared.markReady()
+        callback?(["ok": true])
+    }
+
+    @objc func setRollbackOptions(_ params: [String: Any]?, callback: LynxCallbackBlock?) {
+        let max = (params?["maxFailedLaunches"] as? Int) ?? 2
+        UpdateStore.shared.setMaxLaunchAttempts(max)
+        callback?(["ok": true])
+    }
+
+    @objc func clearUpdates(_ callback: LynxCallbackBlock?) {
+        UpdateStore.shared.clearAll()
+        callback?(["ok": true])
+    }
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@sigx/lynx-updates",
+  "version": "0.6.1",
+  "description": "OTA bundle updates for sigx-lynx — pluggable backends, update modes, crash rollback",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./signalx-module.json": "./signalx-module.json"
+  },
+  "files": [
+    "dist",
+    "ios",
+    "android",
+    "signalx-module.json"
+  ],
+  "dependencies": {
+    "@sigx/lynx-core": "^0.6.1",
+    "@sigx/lynx": "^0.6.1"
+  },
+  "devDependencies": {
+    "@typescript/native-preview": "7.0.0-dev.20260521.1",
+    "typescript": "^6.0.3"
+  },
+  "author": "Andreas Ekdahl",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/signalxjs/lynx.git",
+    "directory": "packages/lynx-updates"
+  },
+  "homepage": "https://sigx.dev/lynx/modules/updates/overview/",
+  "bugs": {
+    "url": "https://github.com/signalxjs/lynx/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "signalx",
+    "sigx",
+    "lynx",
+    "mobile",
+    "ios",
+    "android",
+    "ota",
+    "updates",
+    "codepush"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/clean.mjs dist && tsgo",
+    "dev": "tsgo --watch",
+    "clean": "node ../../scripts/clean.mjs dist .turbo"
+  }
+}

package/signalx-module.json

@@ -0,0 +1,35 @@
+{
+    "name": "Updates",
+    "package": "@sigx/lynx-updates",
+    "description": "OTA bundle updates: download, two-phase apply, crash rollback",
+    "platforms": ["android", "ios"],
+    "android": {
+        "moduleClass": "com.sigx.updates.UpdatesModule",
+        "publisherClass": "com.sigx.updates.UpdatesLifecyclePublisher",
+        "bundleResolverClass": "com.sigx.updates.UpdatesBundleResolver",
+        "activityHook": {
+            "class": "com.sigx.updates.UpdatesActivityHook",
+            "methods": ["onResume", "onPause"]
+        },
+        "sourceDir": "android",
+        "permissions": ["android.permission.INTERNET"]
+    },
+    "ios": {
+        "moduleClass": "UpdatesModule",
+        "publisherClass": "UpdatesLifecyclePublisher",
+        "bundleResolverClass": "UpdatesBundleResolver",
+        "sourceDir": "ios",
+        "methods": [
+            "getInstalledRuntimeVersion",
+            "getPlatform",
+            "getState",
+            "getCurrentUpdate",
+            "downloadUpdate",
+            "applyOnNextLaunch",
+            "applyNow",
+            "markReady",
+            "setRollbackOptions",
+            "clearUpdates"
+        ]
+    }
+}