craft-native 0.0.115 → 0.0.119

package/dist/android/templates/MainActivityNative.kt.template

@@ -3,13 +3,17 @@ package {{PACKAGE_NAME}}
 import android.content.ClipData
 import android.content.ClipboardManager
 import android.content.Context
+import android.content.Intent
 import android.graphics.BitmapFactory
 import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.Typeface
 import android.graphics.drawable.GradientDrawable
+import android.net.Uri
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.os.VibrationEffect
 import android.os.Vibrator
 import android.text.Editable
@@ -39,6 +43,7 @@ import androidx.javascriptengine.JavaScriptSandbox
 import androidx.javascriptengine.Message
 import androidx.javascriptengine.MessagePort
 import androidx.javascriptengine.MessagePortClient
+import com.google.common.util.concurrent.ListenableFuture
 import org.json.JSONArray
 import org.json.JSONObject
 import java.net.URL
@@ -46,6 +51,8 @@ import java.util.concurrent.Executors
 import java.util.concurrent.Future
 import java.util.UUID
 
+private const val CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS = 30_000L
+
 private class CraftNativeScrollView(context: Context) : FrameLayout(context) {
     val content = LinearLayout(context)
     private val vertical = ScrollView(context)
@@ -87,6 +94,9 @@ class MainActivity : AppCompatActivity() {
         val flatListOwners = mutableMapOf<String, String>()
         val flatListOwnerByView = mutableMapOf<CraftNativeFlatList, String>()
         val mutations = CraftNativeMutationDocument()
+        val capabilityScope = UUID.randomUUID().toString()
+        val pendingCapabilities = mutableSetOf<String>()
+        val capabilityTimeouts = mutableMapOf<String, Runnable>()
         var active = true
 
         fun close() {
@@ -100,7 +110,16 @@ class MainActivity : AppCompatActivity() {
     private var sandbox: JavaScriptSandbox? = null
     private val screens = mutableListOf<Screen>()
     private var bundle = ""
+    private lateinit var config: JSONObject
+    private lateinit var capabilities: CraftNativeCapabilities
+    private val capabilityHandler = Handler(Looper.getMainLooper())
     private var hapticsEnabled = false
+    private var clipboardEnabled = false
+    internal var nativeAppState = "inactive"
+        private set
+    private var deliveredInitialDeepLink = false
+    private var initialDeepLink: Uri? = null
+    private var initialDeepLinkClaimed = false
     private var defaultTextColor = Color.WHITE
     private var useMessagePorts = false
     private val imageExecutor = Executors.newFixedThreadPool(2)
@@ -110,14 +129,19 @@ class MainActivity : AppCompatActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        initialDeepLink = savedInstanceState?.getString("craft.initialDeepLink")?.let(Uri::parse) ?: intent?.data
+        initialDeepLinkClaimed = savedInstanceState?.getBoolean("craft.initialDeepLinkClaimed", false) ?: false
+        deliveredInitialDeepLink = savedInstanceState?.getBoolean("craft.deliveredInitialDeepLink", false) ?: false
         setContentView(R.layout.activity_main)
         root = findViewById(R.id.native_root)
-        val config = runCatching {
+        config = runCatching {
             assets.open("craft.config.json").bufferedReader().use {
                 JSONObject(it.readText())
             }
         }.getOrDefault(JSONObject())
         hapticsEnabled = config.optBoolean("enableHaptics", false)
+        clipboardEnabled = config.optBoolean("enableClipboard", false)
+        capabilities = CraftNativeCapabilities(this, config)
         val background = color(config.optString("backgroundColor", "#1a1a2e"), Color.BLACK)
         root.setBackgroundColor(background)
         defaultTextColor = if (Color.luminance(background) < 0.5) Color.WHITE else Color.BLACK
@@ -131,29 +155,45 @@ class MainActivity : AppCompatActivity() {
             showError("Native STX requires Android JavaScriptSandbox, which is unavailable on this device.")
             return
         }
-        val connection = JavaScriptSandbox.createConnectedInstanceAsync(this)
-        connection.addListener({
-            try {
-                val engine = connection.get()
-                if (isDestroyed) {
-                    engine.close()
-                    return@addListener
-                }
-                useMessagePorts = engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_MESSAGE_PORTS)
-                    && engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_PROMISE_RETURN)
-                if (!useMessagePorts && !engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_CONSOLE_MESSAGING)) {
-                    engine.close()
-                    showError("Native STX requires JavaScript message ports or console messaging, unavailable on this device.")
-                    return@addListener
-                }
-                Log.i(TAG, "Native STX bridge: ${if (useMessagePorts) "message ports" else "console callback"}")
-                sandbox = engine
-                openScreen(null)
-            } catch (error: Exception) {
-                Log.e(TAG, "JavaScriptSandbox connection failed", error)
-                showError("Native STX JavaScript engine could not start: ${error.message}")
+        val connection = synchronized(SANDBOX_LOCK) {
+            sharedSandboxConnection ?: sharedSandbox?.let { existing ->
+                sandbox = existing
+                null
+            } ?: JavaScriptSandbox.createConnectedInstanceAsync(applicationContext).also {
+                sharedSandboxConnection = it
             }
-        }, ContextCompat.getMainExecutor(this))
+        }
+        if (connection == null) {
+            sandbox?.let(::attachSandbox)
+        } else {
+            connection.addListener({
+                try {
+                    val engine = connection.get()
+                    synchronized(SANDBOX_LOCK) {
+                        sharedSandbox = engine
+                    }
+                    if (!isDestroyed) {
+                        sandbox = engine
+                        attachSandbox(engine)
+                    }
+                } catch (error: Exception) {
+                    synchronized(SANDBOX_LOCK) { sharedSandboxConnection = null }
+                    Log.e(TAG, "JavaScriptSandbox connection failed", error)
+                    if (!isDestroyed) showError("Native STX JavaScript engine could not start: ${error.message}")
+                }
+            }, ContextCompat.getMainExecutor(this))
+        }
+    }
+
+    private fun attachSandbox(engine: JavaScriptSandbox) {
+        useMessagePorts = engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_MESSAGE_PORTS)
+            && engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_PROMISE_RETURN)
+        if (!useMessagePorts && !engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_CONSOLE_MESSAGING)) {
+            showError("Native STX requires JavaScript message ports or console messaging, unavailable on this device.")
+            return
+        }
+        Log.i(TAG, "Native STX bridge: ${if (useMessagePorts) "message ports" else "console callback"}")
+        openScreen(null)
     }
 
     private fun openScreen(route: String?, params: JSONObject = JSONObject()) {
@@ -170,13 +210,13 @@ class MainActivity : AppCompatActivity() {
         val port = if (useMessagePorts) {
             isolate.createMessageChannel("craft", executor, MessagePortClient { message ->
                 val current = screen ?: return@MessagePortClient
-                if (current.active && message.type == Message.TYPE_STRING) receive(current, message.string)
+                if (current.active && message.type == Message.TYPE_STRING) receiveSafely(current, message.string)
             })
         } else {
             isolate.setConsoleCallback(executor, JavaScriptConsoleCallback { entry ->
                 val current = screen ?: return@JavaScriptConsoleCallback
                 if (current.active && entry.message.startsWith(prefix)) {
-                    receive(current, entry.message.removePrefix(prefix))
+                    receiveSafely(current, entry.message.removePrefix(prefix))
                 }
             })
             null
@@ -194,7 +234,12 @@ class MainActivity : AppCompatActivity() {
               const port = await android.getNamedPort('craft');
               $routePrelude
               globalThis.__stxNativeBridge = {
+                platform: 'android',
                 mutationProtocolVersion: 1,
+                capabilityProtocolVersion: $CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION,
+                capabilityTimeoutMs: $CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS,
+                capabilities: ${capabilities.names()},
+                initialAppState: ${JSONObject.quote(nativeAppState)},
                 postMessage: function(value) { port.postMessage(value); },
                 onMessage: function(callback) { port.onmessage = function(event) { callback(event.data); }; }
               };
@@ -202,7 +247,12 @@ class MainActivity : AppCompatActivity() {
         """.trimIndent() else """
             $routePrelude
             globalThis.__stxNativeBridge = {
+              platform: 'android',
               mutationProtocolVersion: 1,
+              capabilityProtocolVersion: $CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION,
+              capabilityTimeoutMs: $CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS,
+              capabilities: ${capabilities.names()},
+              initialAppState: ${JSONObject.quote(nativeAppState)},
               postMessage: function(value) { console.log(${JSONObject.quote(prefix)} + value); },
               onMessage: function(callback) { globalThis.__stxNativeCallback = callback; }
             };
@@ -214,7 +264,18 @@ class MainActivity : AppCompatActivity() {
                 setup.get()
                 val load = isolate.evaluateJavaScriptAsync(bundle)
                 load.addListener({
-                    try { load.get() } catch (error: Exception) {
+                    try {
+                        load.get()
+                        val launchLink = initialDeepLink
+                        if (!deliveredInitialDeepLink
+                            && config.optBoolean("enableDeepLinks")
+                            && launchLink != null
+                            && screens.lastOrNull() === activeScreen
+                        ) {
+                            deliveredInitialDeepLink = true
+                            send(activeScreen, "DEEP_LINK", deepLinkData(launchLink).put("initial", true))
+                        }
+                    } catch (error: Exception) {
                         Log.e(TAG, "Native STX bundle failed", error)
                         if (activeScreen.active) showError("Native STX bundle failed: ${error.message}")
                     }
@@ -232,9 +293,17 @@ class MainActivity : AppCompatActivity() {
         root.addView(screen.view)
     }
 
+    override fun onSaveInstanceState(outState: Bundle) {
+        outState.putString("craft.initialDeepLink", initialDeepLink?.toString())
+        outState.putBoolean("craft.initialDeepLinkClaimed", initialDeepLinkClaimed)
+        outState.putBoolean("craft.deliveredInitialDeepLink", deliveredInitialDeepLink)
+        super.onSaveInstanceState(outState)
+    }
+
     private fun receive(screen: Screen, raw: String) {
         val message = runCatching { JSONObject(raw) }.getOrNull() ?: return
         val payload = message.optJSONObject("payload") ?: JSONObject()
+        Log.d(TAG, "Native STX ${message.optString("type")} (${raw.length} chars) for ${screen.route ?: "home"}")
         when (message.optString("type")) {
             "RENDER" -> payload.optJSONObject("document")?.let { render(screen, it) }
             "MUTATE" -> try {
@@ -270,6 +339,26 @@ class MainActivity : AppCompatActivity() {
             }
             "NAVIGATE_BACK" -> if (screens.lastOrNull() === screen) back()
             "API_REQUEST" -> answerAPI(screen, message, payload)
+            "API_CANCEL" -> {
+                val id = payload.optString("requestId")
+                if (id.isNotBlank()) {
+                    val token = "${screen.capabilityScope}/$id"
+                    screen.pendingCapabilities.remove(token)
+                    screen.capabilityTimeouts.remove(token)?.let(capabilityHandler::removeCallbacks)
+                    capabilities.cancel(token)
+                }
+            }
+        }
+    }
+
+    private fun receiveSafely(screen: Screen, raw: String) {
+        try {
+            receive(screen, raw)
+        }
+        catch (error: Exception) {
+            val route = screen.route ?: "home"
+            Log.e(TAG, "Native STX message failed for $route", error)
+            if (screen.active) showError("Native STX message failed for $route: ${error.message}")
         }
     }
 
@@ -728,34 +817,118 @@ class MainActivity : AppCompatActivity() {
         val id = message.optString("id")
         if (id.isBlank()) return
         val args = payload.optJSONArray("args") ?: JSONArray()
-        val response = JSONObject().put("requestId", id)
-        val result = when (payload.optString("module") to payload.optString("method")) {
-            "Device" to "getInfo" -> response.put("data", JSONObject()
+        val token = "${screen.capabilityScope}/$id"
+        screen.pendingCapabilities.add(token)
+        val timeout = Runnable {
+            if (!screen.active || !screen.pendingCapabilities.remove(token)) return@Runnable
+            screen.capabilityTimeouts.remove(token)
+            capabilities.cancel(token)
+            send(screen, "API_ERROR", JSONObject()
+                .put("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION)
+                .put("requestId", id)
+                .put("code", "TIMEOUT")
+                .put("message", "Native API request timed out"), id)
+        }
+        screen.capabilityTimeouts[token] = timeout
+        capabilityHandler.postDelayed(timeout, CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS)
+        capabilities.perform(
+            token,
+            payload.optInt("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION),
+            payload.optString("module"),
+            payload.optString("method"),
+            args,
+        ) { result ->
+            if (!screen.active || !screen.pendingCapabilities.remove(token)) return@perform
+            screen.capabilityTimeouts.remove(token)?.let(capabilityHandler::removeCallbacks)
+            val response = JSONObject()
+                .put("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION)
+                .put("requestId", id)
+            if (result.code == null) response.put("data", result.data ?: JSONObject.NULL)
+            else response.put("code", result.code).put("message", result.message ?: "Native API failed")
+            send(screen, if (result.code == null) "API_RESPONSE" else "API_ERROR", response, id)
+        }
+    }
+
+    internal fun performImmediateCapability(module: String, method: String, args: JSONArray): CraftNativeCapabilityResult =
+        when (module to method) {
+            "Device" to "getInfo" -> CraftNativeCapabilityResult(data = JSONObject()
                 .put("platform", "android")
                 .put("osVersion", Build.VERSION.RELEASE)
                 .put("model", Build.MODEL)
-                .put("manufacturer", Build.MANUFACTURER))
-            "Clipboard" to "write" -> {
+                .put("manufacturer", Build.MANUFACTURER)
+                .put("deviceId", android.provider.Settings.Secure.getString(contentResolver, android.provider.Settings.Secure.ANDROID_ID))
+                .put("isTablet", resources.configuration.smallestScreenWidthDp >= 600)
+                .put("screen", JSONObject()
+                    .put("width", resources.displayMetrics.widthPixels / resources.displayMetrics.density)
+                    .put("height", resources.displayMetrics.heightPixels / resources.displayMetrics.density)
+                    .put("scale", resources.displayMetrics.density)))
+            "Clipboard" to "write" -> if (!clipboardEnabled) {
+                CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Clipboard is disabled")
+            } else if (args.opt(0) !is String) {
+                CraftNativeCapabilityResult(code = "INVALID_ARGUMENT", message = "Clipboard.write needs text")
+            } else {
                 val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-                clipboard.setPrimaryClip(ClipData.newPlainText("", args.optString(0)))
-                response.put("data", JSONObject().put("ok", true))
+                clipboard.setPrimaryClip(ClipData.newPlainText("", args.getString(0)))
+                CraftNativeCapabilityResult(data = true)
             }
-            "Clipboard" to "read" -> {
+            "Clipboard" to "read" -> if (!clipboardEnabled) {
+                CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Clipboard is disabled")
+            } else {
                 val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-                response.put("data", clipboard.primaryClip?.getItemAt(0)?.coerceToText(this)?.toString() ?: "")
+                CraftNativeCapabilityResult(data = clipboard.primaryClip?.getItemAt(0)?.coerceToText(this)?.toString() ?: "")
             }
-            "Haptics" to "impact" -> {
-                if (!hapticsEnabled) response.put("code", "CAPABILITY_DISABLED")
-                    .put("message", "Haptics are disabled")
-                else {
-                    val vibrator = getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
-                    vibrator.vibrate(VibrationEffect.createOneShot(30, VibrationEffect.DEFAULT_AMPLITUDE))
-                    response.put("data", JSONObject().put("ok", true))
-                }
+            "Haptics" to "impact" -> if (!hapticsEnabled) {
+                CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Haptics are disabled")
+            } else {
+                val vibrator = getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+                vibrator.vibrate(VibrationEffect.createOneShot(30, VibrationEffect.DEFAULT_AMPLITUDE))
+                CraftNativeCapabilityResult(data = true)
             }
-            else -> response.put("code", "UNKNOWN_ACTION").put("message", "Unsupported native API")
+            else -> CraftNativeCapabilityResult(code = "UNKNOWN_ACTION", message = "Unsupported native API")
         }
-        send(screen, if (result.has("code")) "API_ERROR" else "API_RESPONSE", result, id)
+
+    internal fun deepLinkData(uri: android.net.Uri): JSONObject = JSONObject()
+        .put("url", uri.toString())
+        .put("scheme", uri.scheme ?: "")
+        .put("host", uri.host ?: "")
+        .put("path", uri.path ?: "")
+        .put("query", uri.query ?: "")
+        .put("queryParams", JSONObject().apply {
+            uri.queryParameterNames.forEach { name -> put(name, uri.getQueryParameter(name) ?: "") }
+        })
+
+    private fun publish(type: String, payload: JSONObject) {
+        screens.lastOrNull()?.takeIf { it.active }?.let { send(it, type, payload) }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        nativeAppState = "active"
+        publish("APP_STATE", JSONObject().put("state", nativeAppState))
+    }
+
+    override fun onPause() {
+        nativeAppState = "inactive"
+        publish("APP_STATE", JSONObject().put("state", nativeAppState))
+        super.onPause()
+    }
+
+    override fun onStop() {
+        nativeAppState = "background"
+        publish("APP_STATE", JSONObject().put("state", nativeAppState))
+        super.onStop()
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        intent.data?.let { publish("DEEP_LINK", deepLinkData(it).put("initial", false)) }
+    }
+
+    internal fun consumeInitialDeepLink(): Uri? {
+        if (initialDeepLinkClaimed) return null
+        initialDeepLinkClaimed = true
+        return initialDeepLink
     }
 
     private fun send(screen: Screen, type: String, payload: JSONObject, correlationId: String? = null) {
@@ -804,6 +977,10 @@ class MainActivity : AppCompatActivity() {
     }
 
     private fun closeScreen(screen: Screen) {
+        screen.capabilityTimeouts.values.forEach(capabilityHandler::removeCallbacks)
+        screen.capabilityTimeouts.clear()
+        screen.pendingCapabilities.forEach(capabilities::cancel)
+        screen.pendingCapabilities.clear()
         releaseViewState(screen, retainedViews(screen).toList())
         screen.controls.clear()
         screen.handlers.clear()
@@ -833,9 +1010,14 @@ class MainActivity : AppCompatActivity() {
         imageJobs.values.forEach { it.cancel(true) }
         imageJobs.clear()
         imageExecutor.shutdownNow()
-        sandbox?.close()
+        capabilities.close()
         super.onDestroy()
     }
 
-    companion object { private const val TAG = "CraftNativeAndroid" }
+    companion object {
+        private const val TAG = "CraftNativeAndroid"
+        private val SANDBOX_LOCK = Any()
+        private var sharedSandbox: JavaScriptSandbox? = null
+        private var sharedSandboxConnection: ListenableFuture<JavaScriptSandbox>? = null
+    }
 }

package/dist/api/mobile.d.ts

@@ -352,7 +352,7 @@ export declare const camera: {
 /**
  * Biometric type.
  */
-export type BiometricType = 'faceId' | 'touchId' | 'fingerprint' | 'face' | 'iris';
+export type BiometricType = 'faceId' | 'touchId' | 'fingerprint' | 'face' | 'iris' | 'none';
 /**
  * Biometric authentication API.
  *
@@ -433,6 +433,15 @@ export declare const secureStorage: {
      * @param key - Storage key
      */
     delete(key: string): Promise<void>;
+    /**
+     * Remove a securely stored value using the legacy native contract.
+     *
+     * New code may use {@link delete}; this alias keeps older native screens
+     * and the public `craft.d.ts` contract working across bridge versions.
+     *
+     * @param key - Storage key
+     */
+    remove(key: string): Promise<void>;
     /**
      * Clear all securely stored values.
      */
@@ -621,6 +630,12 @@ export interface NotificationOptions {
 export type BridgeNotification = Omit<NotificationOptions, 'scheduleAt'> & {
     delay?: number;
 };
+/** A local notification waiting for delivery. */
+export interface PendingLocalNotification {
+    id: string;
+    title: string;
+    body: string;
+}
 /**
  * The bridges' spelling of a notification: `scheduleAt` becomes `delay`.
  *
@@ -668,6 +683,14 @@ export declare const notifications: {
      * @param options - Notification options with scheduleAt
      */
     schedule(options: NotificationOptions): Promise<void>;
+    /**
+     * Cancel one scheduled notification.
+     */
+    cancel(id: string): Promise<void>;
+    /**
+     * Read notifications that have not fired yet.
+     */
+    pending(): Promise<PendingLocalNotification[]>;
     /**
      * Cancel all scheduled notifications.
      */
@@ -687,6 +710,34 @@ export declare const keepAwake: {
     enable(): Promise<void>;
     disable(): Promise<void>;
 };
+export interface SpeechOptions {
+    /** Speaking rate, 0.5 to 2. 1 is the voice's normal pace. */
+    rate?: number;
+    /** BCP-47 language tag, such as 'en-US'. Defaults to the device's language. */
+    language?: string;
+    /** Stop whatever is being said first. Defaults to true; false queues behind it. */
+    interrupt?: boolean;
+}
+/**
+ * Short spoken cues: "Rest, 15 seconds. Up next: Dead Bug".
+ *
+ * Inside a Craft app this is native text-to-speech, which ducks the person's
+ * music rather than stopping it and, on iOS, plays with the silent switch on.
+ * In a browser it falls back to the Web Speech API, which does neither, and
+ * where there is no speech at all it answers `false` rather than throwing, so
+ * a cue never breaks the flow around it.
+ */
+export declare const speech: {
+    isAvailable(): boolean;
+    /**
+     * Speak `text`. Resolves when the utterance ends: `true` when it was
+     * spoken, `false` when it was stopped, interrupted or could not be spoken.
+     * Rejects with code `INVALID_ARGUMENT` when `text` is empty.
+     */
+    speak(text: string, options?: SpeechOptions): Promise<boolean>;
+    /** Stop speaking at once. Every pending `speak()` resolves `false`. */
+    stop(): Promise<void>;
+};
 export declare const deepLinks: {
     getInitialURL(): Promise<string | null>;
     /**
@@ -852,6 +903,7 @@ declare const mobile: {
     lifecycle: typeof lifecycle;
     notifications: typeof notifications;
     keepAwake: typeof keepAwake;
+    speech: typeof speech;
     deepLinks: typeof deepLinks;
     network: typeof network;
     appReview: typeof appReview;

package/dist/cli.js

@@ -3303,7 +3303,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.115";
+var version = "0.0.119";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -310,7 +310,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.115";
+var version = "0.0.119";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -5072,6 +5072,17 @@ var secureStorage = {
       throw new Error("Craft secure storage bridge is unavailable");
     localStorage.removeItem(`secure_${key}`);
   },
+  async remove(key) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.secureStorage) {
+      if (typeof craft.secureStorage.remove === "function")
+        return craft.secureStorage.remove(key);
+      return craft.secureStorage.delete(key);
+    }
+    if (typeof window !== "undefined" && window.craft)
+      throw new Error("Craft secure storage bridge is unavailable");
+    localStorage.removeItem(`secure_${key}`);
+  },
   async clear() {
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.secureStorage) {
@@ -5271,6 +5282,20 @@ var notifications = {
     }
     throw new Error("Scheduled notifications not available in web");
   },
+  async cancel(id) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.notifications) {
+      return craft.notifications.cancel(id);
+    }
+    throw new Error("Scheduled notifications not available in web");
+  },
+  async pending() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.notifications) {
+      return craft.notifications.pending();
+    }
+    return [];
+  },
   async cancelAll() {
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.notifications) {
@@ -5284,6 +5309,7 @@ var notifications = {
     }
   }
 };
+var speakingOnTheWeb = new Set;
 function detectPlatform2() {
   if (typeof window === "undefined")
     return "linux";

package/dist/index.js

@@ -58,7 +58,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.115";
+var version = "0.0.119";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -4832,6 +4832,17 @@ var secureStorage = {
       throw new Error("Craft secure storage bridge is unavailable");
     localStorage.removeItem(`secure_${key}`);
   },
+  async remove(key) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.secureStorage) {
+      if (typeof craft.secureStorage.remove === "function")
+        return craft.secureStorage.remove(key);
+      return craft.secureStorage.delete(key);
+    }
+    if (typeof window !== "undefined" && window.craft)
+      throw new Error("Craft secure storage bridge is unavailable");
+    localStorage.removeItem(`secure_${key}`);
+  },
   async clear() {
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.secureStorage) {
@@ -5031,6 +5042,20 @@ var notifications = {
     }
     throw new Error("Scheduled notifications not available in web");
   },
+  async cancel(id) {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.notifications) {
+      return craft.notifications.cancel(id);
+    }
+    throw new Error("Scheduled notifications not available in web");
+  },
+  async pending() {
+    const craft = getCraftMobile();
+    if (typeof window !== "undefined" && craft?.notifications) {
+      return craft.notifications.pending();
+    }
+    return [];
+  },
   async cancelAll() {
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.notifications) {
@@ -5044,6 +5069,7 @@ var notifications = {
     }
   }
 };
+var speakingOnTheWeb = new Set;
 function detectPlatform2() {
   if (typeof window === "undefined")
     return "linux";

package/dist/ios/src/index.d.ts

@@ -66,6 +66,22 @@ export interface CraftConfig {
     teamId?: string;
     urlSchemes?: string[];
     trustedOrigins?: string[];
+    /**
+     * The domains the app's web view treats as its own (WKAppBoundDomains, at
+     * most 10). Service workers only run in an iOS web view on these, so a site
+     * that works offline in Safari works offline in the app. Unset, they are the
+     * hosts of `trustedOrigins` and the dev server: the origins the bridge is
+     * already injected into, and once any are declared iOS keeps script
+     * injection to them. `[]` declares none.
+     */
+    appBoundDomains?: string[];
+    /**
+     * Also refuse to load anything but the app-bound domains in the web view
+     * (WKWebViewConfiguration.limitsNavigationsToAppBoundDomains). Off by
+     * default: links elsewhere already open in Safari, and embedded players and
+     * maps in iframes keep loading.
+     */
+    limitNavigationsToAppBoundDomains?: boolean;
     associatedDomains?: string[];
     appGroups?: string[];
     appIconPath?: string;
@@ -148,6 +164,8 @@ export declare function renderAppearance(config: Pick<CraftConfig, 'appearance'
 };
 export declare function renderUsageDescriptions(config: CraftConfig): string;
 export declare function renderOrientations(config: CraftConfig): string;
+/** WKAppBoundDomains: the configured domains plus the dev server's host, at most 10. */
+export declare function renderAppBoundDomains(config: CraftConfig): string;
 export declare function renderUrlTypes(config: CraftConfig): string;
 export declare function renderBackgroundModes(config: CraftConfig): string;
 export declare function renderEntitlements(config: CraftConfig): string;