@independo/capacitor-inderun 1.1.0-dev.1 → 1.1.0-dev.11

package/dist/web.js

@@ -10,13 +10,27 @@ export class IndeRunWeb extends WebPlugin {
     startingStreams = new Set();
     pendingCancels = new Map();
     async configure(options) {
-        if (!options?.openAI) {
-            throw createUnavailable("Capacitor web execution requires OpenAI provider registration. Configure with openAI bootstrap options before calling run(request).").toContractError();
+        // The web SDK requires at least one provider, not specifically the cloud one. Held
+        // here as well as there so the failure is an `Unavailable` contract error rather than
+        // a raw SDK throw, which is what the facade's callers expect.
+        if (!options?.openAI && !options?.systemModel && !options?.onnx) {
+            throw createUnavailable("Capacitor web execution requires at least one provider registration. Configure with openAI, systemModel and/or onnx bootstrap options before calling run(request).").toContractError();
         }
         try {
-            const webOptions = {
-                openAI: compactOpenAIOptions(options)
-            };
+            // The SDK's own option type, not a hand-written copy of it: an upstream rename
+            // then fails at the type level instead of silently dropping a field. This is
+            // deliberately the *outbound* shape only — `ConfigureOptions` stays a narrower,
+            // JSON-serializable subset, because it has to cross the native bridge hop.
+            const webOptions = {};
+            if (options.openAI !== undefined) {
+                webOptions.openAI = compactOpenAIOptions(options.openAI);
+            }
+            if (options.systemModel !== undefined) {
+                webOptions.systemModel = compactSystemModelOptions(options.systemModel);
+            }
+            if (options.onnx !== undefined) {
+                webOptions.onnx = compactOnnxOptions(options.onnx);
+            }
             if (options.allowDirectOpenAIEndpoint !== undefined) {
                 webOptions.allowDirectOpenAIEndpoint = options.allowDirectOpenAIEndpoint;
             }
@@ -37,6 +51,20 @@ export class IndeRunWeb extends WebPlugin {
             throw toIndeRunException(error).toContractError();
         }
     }
+    async checkCapabilities() {
+        if (!this.engine) {
+            throw createUnavailable("Capacitor IndeRun has not been configured. Configure providers before calling checkCapabilities().").toContractError();
+        }
+        try {
+            // Deliberately uncast: the engine's snapshots are assigned straight into the
+            // bridge's own `ProviderCapabilitySnapshot`, so the two declarations staying
+            // identical is a compile error rather than a convention. See definitions.ts.
+            return { providers: await this.engine.checkCapabilities() };
+        }
+        catch (error) {
+            throw toIndeRunException(error).toContractError();
+        }
+    }
     /**
      * The web path deliberately round-trips through `notifyListeners` rather than
      * handing the engine's `StreamRun` straight back.
@@ -101,8 +129,17 @@ export class IndeRunWeb extends WebPlugin {
         }
     }
 }
-function compactOpenAIOptions(options) {
-    const openAI = options.openAI;
+/**
+ * Assigns only the fields the caller actually set. `exactOptionalPropertyTypes` makes
+ * this incremental style mandatory rather than cosmetic: assigning `undefined` to an
+ * optional property is an error, and an explicit `undefined` on the wire is not the same
+ * thing as an absent key to the provider that reads it.
+ *
+ * `id`, `healthCheckTimeoutMs` and `healthCheckCacheMs` are deliberately not bridged —
+ * all optional, and the bridge has no reason to expose provider-tuning knobs it cannot
+ * also offer on native.
+ */
+function compactOpenAIOptions(openAI) {
     const result = {
         model: openAI.model
     };
@@ -120,3 +157,25 @@ function compactOpenAIOptions(options) {
     }
     return result;
 }
+function compactSystemModelOptions(systemModel) {
+    const result = {};
+    if (systemModel.id !== undefined) {
+        result.id = systemModel.id;
+    }
+    if (systemModel.timeoutMs !== undefined) {
+        result.timeoutMs = systemModel.timeoutMs;
+    }
+    return result;
+}
+function compactOnnxOptions(onnx) {
+    const result = {
+        modelPackage: onnx.modelPackage
+    };
+    if (onnx.id !== undefined) {
+        result.id = onnx.id;
+    }
+    if (onnx.timeoutMs !== undefined) {
+        result.timeoutMs = onnx.timeoutMs;
+    }
+    return result;
+}

package/ios/Sources/IndeRunCapacitorPlugin/IndeRunCapacitorBridge.swift

@@ -49,6 +49,22 @@ struct CapacitorCancelStreamOptions: Codable {
     let reason: String?
 }
 
+/// IndeRunCore's `ProviderCapabilitySnapshot` is `Sendable` but not `Codable`, even
+/// though both of its members are. This mirror exists only to get it through
+/// `JSONEncoder`; see the upstream follow-up asking for `Codable` (and a schema) on
+/// the snapshot itself.
+private struct EncodableCapabilitySnapshot: Encodable {
+    let providerId: String
+    let descriptor: ProviderDescriptor
+    let capabilities: ProviderDynamicCapabilities
+}
+
+/// A Capacitor plugin method must resolve an object, never a top-level array, so the
+/// snapshots travel wrapped. `IndeRunCapacitor` unwraps them on the JS side.
+private struct CapabilitiesEnvelope: Encodable {
+    let providers: [EncodableCapabilitySnapshot]
+}
+
 /// Called with an already-encoded event/error for one run. The plugin turns these
 /// into `notifyListeners` calls; taking them as closures keeps the pump testable
 /// without Capacitor.
@@ -82,6 +98,16 @@ final class IndeRunCapacitorBridge {
         return try encode(result)
     }
 
+    func checkCapabilities() async throws -> JSObject {
+        guard let registry = configuredRegistry, let hostServices = configuredHostServices else {
+            throw createUnavailable(message: "Capacitor IndeRun has not been configured. Configure providers before calling checkCapabilities().")
+        }
+
+        // IndeRun is a stateless coordinator; new per call is intentional — registry is cached above.
+        let engine = IndeRun(registry: registry, hostServices: hostServices)
+        return try encode(capabilities: await engine.checkCapabilities())
+    }
+
     func startStream(
         options: JSObject,
         onEvent: @escaping StreamEventSink,
@@ -173,6 +199,24 @@ final class IndeRunCapacitorBridge {
         try encodeObject(handle)
     }
 
+    /// The descriptor's enums carry explicit raw values (`in_process`, not `inProcess`),
+    /// and JSONEncoder omits nil optionals — so an unset `streamingAvailable` arrives as
+    /// an absent key rather than a null, which is what lets the JS side read absence as
+    /// "inherit `descriptor.supports.streaming`".
+    func encode(capabilities: [ProviderCapabilitySnapshot]) throws -> JSObject {
+        try encodeObject(
+            CapabilitiesEnvelope(
+                providers: capabilities.map {
+                    EncodableCapabilitySnapshot(
+                        providerId: $0.providerId,
+                        descriptor: $0.descriptor,
+                        capabilities: $0.capabilities
+                    )
+                }
+            )
+        )
+    }
+
     private func makeRegistry(openAI: OpenAIProviderBootstrapOptions?) throws -> ProviderRegistry {
         let registry = ProviderRegistry()
         try registry.register(AppleFoundationModelsProvider())
@@ -222,10 +266,26 @@ final class IndeRunCapacitorBridge {
     private func encodeObject<T: Encodable>(_ value: T) throws -> JSObject {
         let data = try JSONEncoder().encode(value)
         let object = try JSONSerialization.jsonObject(with: data, options: [])
+
+        #if canImport(Capacitor)
+        // Capacitor's JSObject is [String: any JSValue], and a plain `as?` cast cannot
+        // produce one: JSONSerialization hands back NSDictionary/NSArray values, which do
+        // not conform to JSValue, so anything with a nested object or array — a TaskResult's
+        // `output`, a stream event's `payload`, the providers array — failed the cast and
+        // surfaced as "Capacitor bridge failed to encode a JSON object". JSTypes coerces the
+        // tree recursively, which is what the cast was standing in for.
+        guard let dictionary = object as? [AnyHashable: Any],
+              let coerced = JSTypes.coerceDictionaryToJSObject(dictionary) else {
+            throw createInternal(message: "Capacitor bridge failed to encode a JSON object.")
+        }
+        return coerced
+        #else
+        // Standalone builds alias JSObject to [String: Any], where the cast is exact.
         guard let dictionary = object as? JSObject else {
             throw createInternal(message: "Capacitor bridge failed to encode a JSON object.")
         }
         return dictionary
+        #endif
     }
 
     func mapAuthMode(_ value: String?) -> OpenAIAuthMode {

package/ios/Sources/IndeRunCapacitorPlugin/IndeRunCapacitorPlugin.swift

@@ -10,6 +10,7 @@ public final class IndeRunCapacitorPlugin: CAPPlugin, CAPBridgedPlugin {
     public let pluginMethods: [CAPPluginMethod] = [
         CAPPluginMethod(name: "configure", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "run", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkCapabilities", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "startStream", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "cancelStream", returnType: CAPPluginReturnPromise)
     ]
@@ -25,7 +26,7 @@ public final class IndeRunCapacitorPlugin: CAPPlugin, CAPBridgedPlugin {
 
     @objc func configure(_ call: CAPPluginCall) {
         do {
-            try implementation.configure(options: call.options)
+            try implementation.configure(options: call.jsObjectRepresentation)
             call.resolve()
         } catch let error as IndeRunException {
             let contractError = error.toContractError()
@@ -42,7 +43,7 @@ public final class IndeRunCapacitorPlugin: CAPPlugin, CAPBridgedPlugin {
     @objc func run(_ call: CAPPluginCall) {
         Task {
             do {
-                let result = try await implementation.run(requestObject: call.options)
+                let result = try await implementation.run(requestObject: call.jsObjectRepresentation)
                 call.resolve(result)
             } catch let error as IndeRunException {
                 let contractError = error.toContractError()
@@ -57,6 +58,26 @@ public final class IndeRunCapacitorPlugin: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
+    /// Reports every registered provider's static declaration and live availability
+    /// without executing a task. Availability changes between calls — a local model can
+    /// unload, cloud credentials can expire — so callers must not cache it across a run.
+    @objc func checkCapabilities(_ call: CAPPluginCall) {
+        Task {
+            do {
+                call.resolve(try await implementation.checkCapabilities())
+            } catch let error as IndeRunException {
+                let contractError = error.toContractError()
+                let details = try? implementation.encode(error: contractError)
+                call.reject(contractError.message, contractError.errorClass.rawValue, error, details)
+            } catch {
+                let normalized = toIndeRunException(error)
+                let contractError = normalized.toContractError()
+                let details = try? implementation.encode(error: contractError)
+                call.reject(contractError.message, contractError.errorClass.rawValue, normalized, details)
+            }
+        }
+    }
+
     /// Resolves with the run handle. Only validation and route-selection failures
     /// reject here; a provider failure, a cancellation, or completion all arrive as
     /// the single terminal event on `indeRunStreamEvent`.
@@ -69,7 +90,7 @@ public final class IndeRunCapacitorPlugin: CAPPlugin, CAPBridgedPlugin {
             guard let self else { return }
             do {
                 let handle = try await self.implementation.startStream(
-                    options: call.options,
+                    options: call.jsObjectRepresentation,
                     onEvent: { [weak self] streamId, event in
                         self?.notifyListeners(
                             "indeRunStreamEvent",
@@ -103,7 +124,7 @@ public final class IndeRunCapacitorPlugin: CAPPlugin, CAPBridgedPlugin {
     /// is a no-op by contract, not an error.
     @objc func cancelStream(_ call: CAPPluginCall) {
         do {
-            try implementation.cancelStream(options: call.options)
+            try implementation.cancelStream(options: call.jsObjectRepresentation)
             call.resolve()
         } catch let error as IndeRunException {
             let contractError = error.toContractError()

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorBridgeTests.swift

@@ -1,6 +1,7 @@
 import XCTest
 import Foundation
 import IndeRunContracts
+import IndeRunCore
 @testable import IndeRunCapacitorPlugin
 
 final class IndeRunCapacitorBridgeTests: XCTestCase {
@@ -86,6 +87,22 @@ final class IndeRunCapacitorBridgeTests: XCTestCase {
         XCTAssertEqual(options.allowDirectOpenAIEndpoint, true)
     }
 
+    /// `systemModel` and `onnx` are web-only bootstrap keys, like
+    /// `allowDirectOpenAIEndpoint`. Native registers its own on-device provider, so it must
+    /// ignore them rather than fail to decode the options object that carries them.
+    func testIgnoresTheWebOnlyProviderBootstrapKeys() throws {
+        let json: [String: Any] = [
+            "openAI": ["model": "gpt-5.2", "auth": "none"],
+            "systemModel": ["id": "local.system-model.web", "timeoutMs": 30_000],
+            "onnx": ["modelPackage": ["id": "demo", "format": "onnx"]]
+        ]
+        let data = try JSONSerialization.data(withJSONObject: json)
+        let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+
+        XCTAssertEqual(options.openAI?.model, "gpt-5.2")
+        XCTAssertEqual(options.openAI?.auth, "none")
+    }
+
     // MARK: - encode(error:)
 
     func testEncodesIndeRunErrorRequiredFieldsOnly() throws {
@@ -134,6 +151,223 @@ final class IndeRunCapacitorBridgeTests: XCTestCase {
         XCTAssertEqual(encoded["runId"] as? String, "run_abc")
     }
 
+    /// A routing refusal carries its plan diagnostics on `details`, and since inderun 0.3.0
+    /// it does so on iOS too, not just on the web SDK. The shape is nested — a
+    /// `rejectedProviders` array of objects each carrying its own `reasons` array — and it
+    /// crosses as `[String: JSONAny]`. This is the data a provider-refusal UI reads, so a
+    /// regression would be invisible until a demo showed an empty table.
+    func testEncodesNestedRoutePlanDiagnosticsInDetails() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let error = IndeRunError(
+            details: [
+                "failureCode": JSONAny("CapabilityMismatch"),
+                "rejectedProviders": JSONAny([
+                    [
+                        "providerId": "apple.foundation-models",
+                        "reasons": [["code": "capability_unavailable", "message": "Apple Intelligence unavailable."]]
+                    ],
+                    [
+                        "providerId": "openai",
+                        "reasons": [["code": "privacy_constraint", "message": "local_required forbids cloud."]]
+                    ]
+                ])
+            ],
+            errorClass: .CapabilityMismatch,
+            message: "No eligible provider can stream this request.",
+            providerId: nil,
+            retryable: nil,
+            retryAfterMs: nil,
+            runId: nil,
+            schemaVersion: .the10
+        )
+
+        let encoded = try bridge.encode(error: error)
+        let details = try XCTUnwrap(encoded["details"] as? [String: Any])
+        XCTAssertEqual(details["failureCode"] as? String, "CapabilityMismatch")
+
+        let rejected = try XCTUnwrap(details["rejectedProviders"] as? [[String: Any]])
+        XCTAssertEqual(rejected.count, 2)
+        XCTAssertEqual(rejected[0]["providerId"] as? String, "apple.foundation-models")
+
+        let reasons = try XCTUnwrap(rejected[0]["reasons"] as? [[String: Any]])
+        XCTAssertEqual(reasons[0]["code"] as? String, "capability_unavailable")
+        XCTAssertEqual(
+            (try XCTUnwrap(rejected[1]["reasons"] as? [[String: Any]]))[0]["code"] as? String,
+            "privacy_constraint"
+        )
+    }
+
+    // MARK: - encode(capabilities:)
+
+    private func makeSnapshot(
+        providerId: String,
+        type: ProviderDescriptor.ProviderType,
+        transport: ProviderDescriptor.TransportType,
+        streamingStyle: ProviderDescriptor.StreamingStyle? = nil,
+        streaming: Bool,
+        cancel: ProviderDescriptor.CancelSemantics,
+        limits: ProviderDescriptor.ResourceLimits? = nil,
+        privacy: ProviderDescriptor.PrivacyDescriptor? = nil,
+        capabilities: ProviderDynamicCapabilities
+    ) -> ProviderCapabilitySnapshot {
+        ProviderCapabilitySnapshot(
+            providerId: providerId,
+            descriptor: ProviderDescriptor(
+                id: providerId,
+                type: type,
+                transport: transport,
+                streamingStyle: streamingStyle,
+                supports: ProviderDescriptor.SupportsCapabilities(
+                    run: true,
+                    streaming: streaming,
+                    realtime: false,
+                    tools: false,
+                    reasoningEvents: false,
+                    structuredOutput: false,
+                    multimodal: false
+                ),
+                cancel: cancel,
+                tasks: ["text_to_text"],
+                limits: limits,
+                privacy: privacy
+            ),
+            capabilities: capabilities
+        )
+    }
+
+    func testEncodesCapabilitySnapshotsInsideTheProvidersEnvelope() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [
+            makeSnapshot(
+                providerId: "openai",
+                type: .cloud,
+                transport: .http,
+                streamingStyle: .tokens,
+                streaming: true,
+                cancel: .hard,
+                limits: ProviderDescriptor.ResourceLimits(maxInputTokens: 128_000, maxOutputTokens: 4_096),
+                privacy: ProviderDescriptor.PrivacyDescriptor(dataLeavesDevice: true, regions: ["us"]),
+                capabilities: ProviderDynamicCapabilities(available: true)
+            )
+        ])
+
+        let providers = try XCTUnwrap(encoded["providers"] as? [[String: Any]])
+        XCTAssertEqual(providers.count, 1)
+        XCTAssertEqual(providers[0]["providerId"] as? String, "openai")
+
+        let descriptor = try XCTUnwrap(providers[0]["descriptor"] as? [String: Any])
+        XCTAssertEqual(descriptor["id"] as? String, "openai")
+        XCTAssertEqual(descriptor["type"] as? String, "cloud")
+        XCTAssertEqual(descriptor["transport"] as? String, "http")
+        XCTAssertEqual(descriptor["streamingStyle"] as? String, "tokens")
+        XCTAssertEqual(descriptor["cancel"] as? String, "hard")
+        XCTAssertEqual(descriptor["tasks"] as? [String], ["text_to_text"])
+
+        let supports = try XCTUnwrap(descriptor["supports"] as? [String: Any])
+        XCTAssertEqual(supports["run"] as? Bool, true)
+        XCTAssertEqual(supports["streaming"] as? Bool, true)
+        XCTAssertEqual(supports["multimodal"] as? Bool, false)
+
+        let limits = try XCTUnwrap(descriptor["limits"] as? [String: Any])
+        XCTAssertEqual(limits["maxInputTokens"] as? Int, 128_000)
+        XCTAssertNil(limits["maxImageBytes"])
+
+        let privacy = try XCTUnwrap(descriptor["privacy"] as? [String: Any])
+        XCTAssertEqual(privacy["dataLeavesDevice"] as? Bool, true)
+        XCTAssertEqual(privacy["regions"] as? [String], ["us"])
+    }
+
+    /// `in_process` is the one descriptor constant a future upstream rename to Swift
+    /// casing would silently corrupt on the wire, since the JS union spells it out.
+    func testEncodesTheInProcessTransportWithItsWireSpelling() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [
+            makeSnapshot(
+                providerId: "local.onnx.genai.apple",
+                type: .local,
+                transport: .inProcess,
+                streaming: false,
+                cancel: .soft,
+                capabilities: ProviderDynamicCapabilities(available: false, reason: "No model package.")
+            )
+        ])
+
+        let providers = try XCTUnwrap(encoded["providers"] as? [[String: Any]])
+        let descriptor = try XCTUnwrap(providers[0]["descriptor"] as? [String: Any])
+        XCTAssertEqual(descriptor["transport"] as? String, "in_process")
+        XCTAssertNil(descriptor["streamingStyle"])
+
+        let capabilities = try XCTUnwrap(providers[0]["capabilities"] as? [String: Any])
+        XCTAssertEqual(capabilities["available"] as? Bool, false)
+        XCTAssertEqual(capabilities["reason"] as? String, "No model package.")
+    }
+
+    /// Absence means "inherit the static declaration". A null would be a third state
+    /// consumers do not have, so the unset optionals must not reach the wire at all.
+    func testOmitsUnsetDynamicCapabilityFlagsRatherThanEncodingNull() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [
+            makeSnapshot(
+                providerId: "apple.foundation-models",
+                type: .local,
+                transport: .systemService,
+                streamingStyle: .snapshots,
+                streaming: true,
+                cancel: .soft,
+                capabilities: ProviderDynamicCapabilities(available: true)
+            )
+        ])
+
+        let providers = try XCTUnwrap(encoded["providers"] as? [[String: Any]])
+        let descriptor = try XCTUnwrap(providers[0]["descriptor"] as? [String: Any])
+        XCTAssertEqual(descriptor["transport"] as? String, "system_service")
+        XCTAssertEqual(descriptor["streamingStyle"] as? String, "snapshots")
+        XCTAssertNil(descriptor["limits"])
+        XCTAssertNil(descriptor["privacy"])
+
+        let capabilities = try XCTUnwrap(providers[0]["capabilities"] as? [String: Any])
+        XCTAssertNil(capabilities["streamingAvailable"])
+        XCTAssertNil(capabilities["streamingUnavailableReason"])
+        XCTAssertNil(capabilities["cancellationAvailable"])
+        XCTAssertNil(capabilities["reason"])
+    }
+
+    func testEncodesStreamingTakenAwayAtRuntime() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [
+            makeSnapshot(
+                providerId: "openai",
+                type: .cloud,
+                transport: .http,
+                streamingStyle: .tokens,
+                streaming: true,
+                cancel: .hard,
+                capabilities: ProviderDynamicCapabilities(
+                    available: true,
+                    streamingAvailable: false,
+                    streamingUnavailableReason: "Host has no streaming HTTP client.",
+                    cancellationAvailable: true
+                )
+            )
+        ])
+
+        let providers = try XCTUnwrap(encoded["providers"] as? [[String: Any]])
+        let capabilities = try XCTUnwrap(providers[0]["capabilities"] as? [String: Any])
+        XCTAssertEqual(capabilities["streamingAvailable"] as? Bool, false)
+        XCTAssertEqual(
+            capabilities["streamingUnavailableReason"] as? String,
+            "Host has no streaming HTTP client."
+        )
+        XCTAssertEqual(capabilities["cancellationAvailable"] as? Bool, true)
+    }
+
+    func testEncodesAnEmptyRegistryAsAnEmptyProvidersArray() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [])
+
+        XCTAssertEqual(try XCTUnwrap(encoded["providers"] as? [[String: Any]]).count, 0)
+    }
+
     // MARK: - mapAuthMode
 
     func testMapAuthModeNoneString() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@independo/capacitor-inderun",
-  "version": "1.1.0-dev.1",
-  "description": "Thin Capacitor bridge for IndeRun across web, iOS, and Android.",
+  "version": "1.1.0-dev.11",
+  "description": "On-device AI with cloud fallback for Capacitor apps. Apple Foundation Models on iOS, ML Kit GenAI (Gemini Nano) on Android, an OpenAI-compatible endpoint as fallback — one API, with streaming and cancellation.",
   "license": "MIT",
   "homepage": "https://github.com/independo-gmbh/capacitor-inderun#readme",
   "repository": {
@@ -13,9 +13,21 @@
   },
   "keywords": [
     "capacitor",
-    "plugin",
+    "capacitor-plugin",
+    "ionic",
     "inderun",
-    "ai"
+    "ai",
+    "llm",
+    "on-device",
+    "on-device-ai",
+    "local-llm",
+    "offline",
+    "cloud-fallback",
+    "streaming",
+    "openai",
+    "gemini-nano",
+    "ml-kit",
+    "foundation-models"
   ],
   "engines": {
     "node": ">=24"
@@ -58,18 +70,18 @@
   },
   "dependencies": {
     "@capacitor/core": "^8.0.0",
-    "@independo/inderun-contracts": "0.3.0-dev.14",
-    "@independo/inderun-web": "0.3.0-dev.14"
+    "@independo/inderun-contracts": "0.3.0",
+    "@independo/inderun-web": "0.3.0"
   },
   "devDependencies": {
     "@saithodev/semantic-release-backmerge": "^4.0.1",
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/git": "^11.0.1",
     "@types/node": "^24.13.2",
     "conventional-changelog-conventionalcommits": "^9.3.1",
     "semantic-release": "^25.0.5",
     "typescript": "^7.0.2",
-    "vitest": "^3.2.6"
+    "vitest": "^5.0.2"
   },
   "peerDependencies": {
     "@capacitor/core": "^8.0.0"