craft-native 0.0.55 → 0.0.72

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

@@ -0,0 +1,160 @@
+package {{PACKAGE_NAME}}
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.IBinder
+import android.os.Looper
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.Priority
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+object CraftLocationRecordingStore {
+    private const val PREFS = "craft_location_recording"
+    private const val FILE = "craft-location-recording.jsonl"
+
+    private fun prefs(context: Context) = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+    private fun file(context: Context) = File(context.filesDir, FILE)
+
+    @Synchronized
+    fun start(context: Context, id: String, startedAt: Long) {
+        file(context).writeText("")
+        prefs(context).edit()
+            .putString("id", id)
+            .putBoolean("active", true)
+            .putBoolean("paused", false)
+            .putLong("startedAt", startedAt)
+            .apply()
+    }
+
+    @Synchronized
+    fun setPaused(context: Context, paused: Boolean) {
+        prefs(context).edit().putBoolean("paused", paused).apply()
+    }
+
+    @Synchronized
+    fun stop(context: Context) {
+        prefs(context).edit().putBoolean("active", false).putBoolean("paused", false).apply()
+    }
+
+    fun isActive(context: Context) = prefs(context).getBoolean("active", false)
+    fun isPaused(context: Context) = prefs(context).getBoolean("paused", false)
+
+    @Synchronized
+    fun append(context: Context, location: android.location.Location) {
+        if (!isActive(context) || isPaused(context)) return
+        val json = JSONObject().apply {
+            put("latitude", location.latitude)
+            put("longitude", location.longitude)
+            put("accuracy", location.accuracy)
+            put("altitude", location.altitude)
+            put("speed", location.speed)
+            put("heading", location.bearing)
+            put("timestamp", location.time)
+        }
+        file(context).appendText("$json\n")
+    }
+
+    @Synchronized
+    fun locations(context: Context): JSONArray {
+        val result = JSONArray()
+        val source = file(context)
+        if (!source.exists()) return result
+        source.forEachLine { line ->
+            if (line.isNotBlank()) runCatching { result.put(JSONObject(line)) }
+        }
+        return result
+    }
+
+    fun state(context: Context, includeLocations: Boolean = false): JSONObject {
+        val values = prefs(context)
+        val locations = locations(context)
+        return JSONObject().apply {
+            put("id", values.getString("id", null))
+            put("active", values.getBoolean("active", false))
+            put("paused", values.getBoolean("paused", false))
+            put("startedAt", values.getLong("startedAt", 0).takeIf { it > 0 } ?: JSONObject.NULL)
+            put("sampleCount", locations.length())
+            if (includeLocations) put("locations", locations)
+        }
+    }
+}
+
+class LocationRecordingService : Service() {
+    private val client by lazy { LocationServices.getFusedLocationProviderClient(this) }
+    private var callback: LocationCallback? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        val manager = getSystemService(NotificationManager::class.java)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            manager.createNotificationChannel(NotificationChannel(CHANNEL, "Activity recording", NotificationManager.IMPORTANCE_LOW))
+        }
+        val notification = NotificationCompat.Builder(this, CHANNEL)
+            .setSmallIcon(android.R.drawable.ic_menu_mylocation)
+            .setContentTitle("Recording your activity")
+            .setContentText("WildLoop is securely saving your route")
+            .setOngoing(true)
+            .setSilent(true)
+            .build()
+        startForeground(NOTIFICATION_ID, notification)
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.action) {
+            ACTION_STOP -> {
+                stopUpdates()
+                stopSelf()
+                return START_NOT_STICKY
+            }
+            else -> startUpdates()
+        }
+        return if (CraftLocationRecordingStore.isActive(this)) START_STICKY else START_NOT_STICKY
+    }
+
+    private fun startUpdates() {
+        if (callback != null || !CraftLocationRecordingStore.isActive(this)) return
+        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) return
+        val request = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 5_000)
+            .setMinUpdateIntervalMillis(2_000)
+            .setMaxUpdateDelayMillis(10_000)
+            .build()
+        callback = object : LocationCallback() {
+            override fun onLocationResult(result: LocationResult) {
+                for (location in result.locations) CraftLocationRecordingStore.append(this@LocationRecordingService, location)
+            }
+        }
+        client.requestLocationUpdates(request, callback!!, Looper.getMainLooper())
+    }
+
+    private fun stopUpdates() {
+        callback?.let { client.removeLocationUpdates(it) }
+        callback = null
+    }
+
+    override fun onDestroy() {
+        stopUpdates()
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    companion object {
+        const val ACTION_START = "craft.location.START"
+        const val ACTION_STOP = "craft.location.STOP"
+        private const val CHANNEL = "craft_location_recording"
+        private const val NOTIFICATION_ID = 7001
+    }
+}

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

@@ -2,18 +2,35 @@ package {{PACKAGE_NAME}}
 
 import android.annotation.SuppressLint
 import android.os.Bundle
+import android.content.Intent
+import android.net.Uri
+import android.webkit.WebResourceRequest
+import android.webkit.WebResourceError
+import android.webkit.WebResourceResponse
 import android.webkit.WebChromeClient
 import android.webkit.WebSettings
 import android.webkit.WebView
 import android.webkit.WebViewClient
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.WindowCompat
-import java.io.BufferedReader
-import java.io.InputStreamReader
+import androidx.webkit.WebViewAssetLoader
+import org.json.JSONObject
+import java.io.FileNotFoundException
+import java.net.URLConnection
 
 class MainActivity : AppCompatActivity() {
     private lateinit var webView: WebView
     private lateinit var craftBridge: CraftBridge
+    private val devServerUrl: String? by lazy { loadDevServerUrl() }
+    private val trustedOrigins: Set<String> by lazy { loadTrustedOrigins() }
+    private val hasBundledFallback: Boolean by lazy { configJson()?.optBoolean("hasBundledFallback", false) == true }
+    private val bundledAssetLoader: WebViewAssetLoader by lazy {
+        WebViewAssetLoader.Builder()
+            .setDomain(BUNDLED_APP_HOST)
+            .addPathHandler("/", RouteAwareAssetPathHandler())
+            .build()
+    }
+    private var loadedBundledFallback = false
 
     @SuppressLint("SetJavaScriptEnabled")
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -25,7 +42,8 @@ class MainActivity : AppCompatActivity() {
         setContentView(R.layout.activity_main)
 
         webView = findViewById(R.id.webview)
-        craftBridge = CraftBridge(this, webView)
+        craftBridge = CraftBridge(this, webView, CraftHealthConnect(this, webView))
+        handleIncomingDeepLink(intent, dispatch = false)
 
         setupWebView()
         loadContent()
@@ -36,10 +54,12 @@ class MainActivity : AppCompatActivity() {
         webView.settings.apply {
             javaScriptEnabled = true
             domStorageEnabled = true
-            allowFileAccess = true
-            allowContentAccess = true
+            allowFileAccess = false
+            allowContentAccess = false
+            allowFileAccessFromFileURLs = false
+            allowUniversalAccessFromFileURLs = false
             mediaPlaybackRequiresUserGesture = false
-            mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
+            mixedContentMode = WebSettings.MIXED_CONTENT_NEVER_ALLOW
             cacheMode = WebSettings.LOAD_DEFAULT
             setSupportZoom(false)
             builtInZoomControls = false
@@ -49,7 +69,28 @@ class MainActivity : AppCompatActivity() {
         webView.webViewClient = object : WebViewClient() {
             override fun onPageFinished(view: WebView?, url: String?) {
                 super.onPageFinished(view, url)
-                craftBridge.injectBridge()
+                if (url != null && isTrustedUrl(url)) craftBridge.injectBridge()
+            }
+
+            override fun shouldInterceptRequest(view: WebView?, request: WebResourceRequest?): WebResourceResponse? {
+                val url = request?.url ?: return null
+                return bundledAssetLoader.shouldInterceptRequest(url)
+                    ?: super.shouldInterceptRequest(view, request)
+            }
+
+            override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
+                val url = request?.url?.toString() ?: return true
+                if (isTrustedUrl(url)) return false
+                runCatching { startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url))) }
+                return true
+            }
+
+            override fun onReceivedError(view: WebView?, request: WebResourceRequest?, error: WebResourceError?) {
+                super.onReceivedError(view, request, error)
+                if (request?.isForMainFrame == true && hasBundledFallback && !loadedBundledFallback) {
+                    loadedBundledFallback = true
+                    webView.loadUrl(BUNDLED_APP_URL)
+                }
             }
         }
 
@@ -61,29 +102,97 @@ class MainActivity : AppCompatActivity() {
 
     private fun loadContent() {
         // Check for dev server URL in config
-        val devServerUrl = getDevServerUrl()
-        if (devServerUrl != null) {
-            webView.loadUrl(devServerUrl)
+        val remoteUrl = devServerUrl
+        if (remoteUrl != null) {
+            webView.loadUrl(remoteUrl)
         } else {
             // Load from assets
-            webView.loadUrl("file:///android_asset/index.html")
+            webView.loadUrl(BUNDLED_APP_URL)
+        }
+    }
+
+    private inner class RouteAwareAssetPathHandler : WebViewAssetLoader.PathHandler {
+        override fun handle(path: String): WebResourceResponse? {
+            val cleanPath = Uri.decode(path).substringBefore('?').trimStart('/')
+            if (cleanPath.split('/').any { it == ".." }) return null
+            val candidates = when {
+                cleanPath.isBlank() -> listOf("index.html")
+                cleanPath.endsWith('/') -> listOf("${cleanPath}index.html")
+                cleanPath.substringAfterLast('/').contains('.') -> listOf(cleanPath)
+                else -> listOf("${cleanPath}.html", "${cleanPath}/index.html")
+            }
+
+            for (candidate in candidates) {
+                try {
+                    val stream = assets.open(candidate)
+                    val mimeType = URLConnection.guessContentTypeFromName(candidate)
+                        ?: when (candidate.substringAfterLast('.', "").lowercase()) {
+                            "js", "mjs" -> "text/javascript"
+                            "css" -> "text/css"
+                            "json", "webmanifest" -> "application/json"
+                            "svg" -> "image/svg+xml"
+                            else -> "application/octet-stream"
+                        }
+                    val encoding = if (mimeType.startsWith("text/") || mimeType.contains("javascript") || mimeType.contains("json")) "UTF-8" else null
+                    return WebResourceResponse(mimeType, encoding, stream)
+                } catch (_: FileNotFoundException) {
+                    // Try the next clean-route candidate.
+                }
+            }
+            return null
+        }
+    }
+
+    private fun handleIncomingDeepLink(source: Intent?, dispatch: Boolean) {
+        val url = source?.data?.toString() ?: return
+        craftBridge.setInitialURL(url)
+        if (dispatch) craftBridge.dispatchDeepLink(url)
+    }
+
+    private fun configJson(): JSONObject? {
+        return try {
+            assets.open("craft.config.json").bufferedReader().use { JSONObject(it.readText()) }
+        } catch (_: Exception) {
+            null
         }
     }
 
-    private fun getDevServerUrl(): String? {
+    private fun loadDevServerUrl(): String? {
         return try {
-            val inputStream = assets.open("craft.config.json")
-            val reader = BufferedReader(InputStreamReader(inputStream))
-            val content = reader.readText()
-            reader.close()
-            // Simple JSON parsing for devServerURL
-            val regex = "\"devServerURL\"\\s*:\\s*\"([^\"]+)\"".toRegex()
-            regex.find(content)?.groupValues?.get(1)
+            configJson()?.optString("devServerURL")?.takeIf { it.isNotBlank() }
         } catch (e: Exception) {
             null
         }
     }
 
+    private fun loadTrustedOrigins(): Set<String> {
+        val origins = mutableSetOf<String>()
+        val config = configJson()
+        val configured = config?.optJSONArray("trustedOrigins")
+        if (configured != null) {
+            for (index in 0 until configured.length()) origins.add(configured.optString(index))
+        }
+        devServerUrl?.let { url ->
+            val uri = Uri.parse(url)
+            origins.add("${uri.scheme}://${uri.authority}")
+        }
+        return origins
+    }
+
+    private fun isTrustedUrl(value: String): Boolean {
+        val uri = Uri.parse(value)
+        if (uri.scheme == "https" && uri.host == BUNDLED_APP_HOST) return true
+        val origin = "${uri.scheme}://${uri.authority}"
+        val localDevelopment = uri.scheme == "http" && uri.host in setOf("localhost", "127.0.0.1", "10.0.2.2")
+        return (uri.scheme == "https" || localDevelopment) && origin in trustedOrigins
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        handleIncomingDeepLink(intent, dispatch = true)
+    }
+
     override fun onBackPressed() {
         if (webView.canGoBack()) {
             webView.goBack()
@@ -103,7 +212,19 @@ class MainActivity : AppCompatActivity() {
     }
 
     override fun onDestroy() {
+        craftBridge.close()
         webView.destroy()
         super.onDestroy()
     }
+
+    @Deprecated("Delegates the Health Connect permission contract on Android 13 and earlier")
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        if (craftBridge.onActivityResult(requestCode, resultCode, data)) return
+        super.onActivityResult(requestCode, resultCode, data)
+    }
+
+    companion object {
+        private const val BUNDLED_APP_HOST = "appassets.androidplatform.net"
+        private const val BUNDLED_APP_URL = "https://appassets.androidplatform.net/"
+    }
 }

package/dist/android/templates/build.gradle.kts.app.template

@@ -1,11 +1,12 @@
 plugins {
     id("com.android.application")
     id("org.jetbrains.kotlin.android")
+{{GOOGLE_SERVICES_PLUGIN}}
 }
 
 android {
     namespace = "{{PACKAGE_NAME}}"
-    compileSdk = {{TARGET_SDK}}
+    compileSdk = {{COMPILE_SDK}}
 
     defaultConfig {
         applicationId = "{{PACKAGE_NAME}}"
@@ -43,12 +44,21 @@ android {
     buildFeatures {
         viewBinding = true
     }
+
+    // Android's default AAPT ignore pattern drops underscore-prefixed asset
+    // directories. STX intentionally emits its browser runtime and generated
+    // styles under `_stx`, so keep those files in the APK.
+    androidResources {
+        ignoreAssetsPattern = "!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~"
+    }
 }
 
 dependencies {
     // AndroidX Core
     implementation("androidx.core:core-ktx:1.12.0")
     implementation("androidx.appcompat:appcompat:1.6.1")
+    implementation("androidx.fragment:fragment-ktx:1.6.2")
+    implementation("androidx.webkit:webkit:1.12.1")
     implementation("com.google.android.material:material:1.11.0")
     implementation("androidx.coordinatorlayout:coordinatorlayout:1.2.0")
 
@@ -69,6 +79,18 @@ dependencies {
     implementation("com.google.android.play:review:2.0.1")
     implementation("com.google.android.play:review-ktx:2.0.1")
 
+    // Native push notifications (included only when enabled)
+{{FIREBASE_MESSAGING_DEPENDENCY}}
+
+    // Android Health Connect (included only when enabled)
+{{HEALTH_CONNECT_DEPENDENCIES}}
+
+    // On-device computer vision APIs exposed by CraftBridge
+    implementation("com.google.mlkit:barcode-scanning:17.3.0")
+    implementation("com.google.mlkit:image-labeling:17.0.9")
+    implementation("com.google.mlkit:object-detection:17.0.2")
+    implementation("com.google.mlkit:text-recognition:16.0.1")
+
     // Google Play Billing (In-App Purchase)
     implementation("com.android.billingclient:billing:6.1.0")
     implementation("com.android.billingclient:billing-ktx:6.1.0")

package/dist/android/templates/build.gradle.kts.project.template

@@ -1,5 +1,6 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id("com.android.application") version "8.2.0" apply false
-    id("org.jetbrains.kotlin.android") version "1.9.20" apply false
+    id("com.android.application") version "8.9.1" apply false
+    id("org.jetbrains.kotlin.android") version "2.0.21" apply false
+{{GOOGLE_SERVICES_PLUGIN}}
 }

package/dist/android/templates/proguard-rules.pro.template

@@ -0,0 +1,9 @@
+# Preserve the JavaScript bridge contract and its annotated methods when R8
+# optimizes release builds. These classes are reached from WebView by name.
+-keepattributes RuntimeVisibleAnnotations,RuntimeInvisibleAnnotations
+-keepclassmembers class * {
+    @android.webkit.JavascriptInterface <methods>;
+}
+-keep class {{PACKAGE_NAME}}.CraftBridge { *; }
+-keep class {{PACKAGE_NAME}}.CraftHealthConnect { *; }
+-keep class {{PACKAGE_NAME}}.LocationRecordingService { *; }

package/dist/api/android-advanced.d.ts

@@ -82,7 +82,7 @@ export declare const materialYou: {
     /**
      * Get colors from a specific source.
      */
-    getColorsFromSource(source: "wallpaper" | "content"): Promise<MaterialYouColors | null>;
+    getColorsFromSource(source: 'wallpaper' | 'content'): Promise<MaterialYouColors | null>;
     /**
      * Listen for color changes.
      */
@@ -273,7 +273,7 @@ export declare const workManager: {
     /**
      * Enqueue unique work (replaces existing work with same name).
      */
-    enqueueUnique(request: WorkRequest, existingWorkPolicy: "replace" | "keep" | "append" | "update"): Promise<string>;
+    enqueueUnique(request: WorkRequest, existingWorkPolicy: 'replace' | 'keep' | 'append' | 'update'): Promise<string>;
     /**
      * Cancel work by name.
      */
@@ -684,7 +684,7 @@ export declare const playBilling: {
     /**
      * Query product details.
      */
-    getProducts(productIds: string[], productType: "inapp" | "subs"): Promise<PlayProduct[]>;
+    getProducts(productIds: string[], productType: 'inapp' | 'subs'): Promise<PlayProduct[]>;
     /**
      * Launch purchase flow.
      */
@@ -692,7 +692,7 @@ export declare const playBilling: {
         offerToken?: string;
         isOfferPersonalized?: boolean;
         oldPurchaseToken?: string;
-        replacementMode?: "charge_prorated_price" | "charge_full_price" | "without_proration" | "deferred";
+        replacementMode?: 'charge_prorated_price' | 'charge_full_price' | 'without_proration' | 'deferred';
     }): Promise<{
         success: boolean;
         purchase?: PlayPurchase;
@@ -701,7 +701,7 @@ export declare const playBilling: {
     /**
      * Get purchases.
      */
-    getPurchases(productType: "inapp" | "subs"): Promise<PlayPurchase[]>;
+    getPurchases(productType: 'inapp' | 'subs'): Promise<PlayPurchase[]>;
     /**
      * Acknowledge a purchase.
      */
@@ -734,4 +734,3 @@ declare const androidAdvanced: {
     playBilling: typeof playBilling;
 };
 export default androidAdvanced;
-//# sourceMappingURL=android-advanced.d.ts.map

package/dist/api/app.d.ts

@@ -429,4 +429,3 @@ export declare const notify: (options: NotificationOptions) => Promise<void>;
 export declare const registerShortcut: (accelerator: string, handler: ShortcutHandler) => Promise<boolean>;
 export declare const unregisterShortcut: (accelerator: string) => Promise<void>;
 export default appManager;
-//# sourceMappingURL=app.d.ts.map

package/dist/api/clipboard.d.ts

@@ -82,4 +82,3 @@ export declare const clipboard: {
     read: typeof read;
 };
 export default clipboard;
-//# sourceMappingURL=clipboard.d.ts.map

package/dist/api/crypto.d.ts

@@ -2,7 +2,7 @@
  * Craft Crypto API
  * Provides cryptographic operations through the Craft bridge
  */
-import type { CraftCryptoAPI } from '../types';
+import type { CraftCryptoAPI } from '../types.js';
 /**
  * Error type for cryptographic failures (malformed input, decode errors, etc.).
  *
@@ -76,4 +76,3 @@ export declare function hashPassword(password: string, salt?: string): Promise<{
  */
 export declare function verifyPassword(password: string, hash: string, salt: string): Promise<boolean>;
 export default crypto;
-//# sourceMappingURL=crypto.d.ts.map

package/dist/api/db.d.ts

@@ -26,7 +26,7 @@
  * ```
  */
 import { EventEmitter } from 'events';
-import type { CraftDatabaseAPI } from '../types';
+import type { CraftDatabaseAPI } from '../types.js';
 /**
  * Global emitter for `db:execute` audit events. Subscribe to log every SQL
  * statement that goes through the SDK. The event payload is `{ name, sql,
@@ -424,4 +424,3 @@ export declare class KeyValueStore {
     clear(): Promise<void>;
 }
 export default db;
-//# sourceMappingURL=db.d.ts.map

package/dist/api/dialog.d.ts

@@ -138,4 +138,3 @@ export declare const dialog: {
     showPrompt: typeof showPrompt;
 };
 export default dialog;
-//# sourceMappingURL=dialog.d.ts.map

package/dist/api/fs.d.ts

@@ -23,7 +23,7 @@
  * })
  * ```
  */
-import type { CraftFileSystemAPI } from '../types';
+import type { CraftFileSystemAPI } from '../types.js';
 /**
  * Validate a file path to prevent directory traversal attacks.
  *
@@ -128,4 +128,3 @@ export declare function _resetWatchWarningForTests(): void;
  */
 export declare function watch(path: string, callback: (event: string, filename: string) => void, options?: WatchOptions): Promise<() => void>;
 export default fs;
-//# sourceMappingURL=fs.d.ts.map

package/dist/api/gestures.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Trackpad gesture phases
+ * @description Real swipe begin/change/end from the host's `NSEvent`, rather
+ * than inferred from a phase-less `wheel` stream.
+ * @module @craft-native/api/gestures
+ */
+export type SwipeAxis = 'horizontal' | 'vertical';
+export type SwipePhase = 'begin' | 'change' | 'end';
+export interface SwipeEvent {
+    /** Which way the gesture was locked at `begin`. Never changes mid-gesture. */
+    axis: SwipeAxis;
+    phase: SwipePhase;
+    /**
+     * Points since the previous event. Positive scrolls content left — i.e.
+     * advances to the next item — matching a DOM wheel event's `deltaX`.
+     */
+    deltaX: number;
+    deltaY: number;
+    /** Points per second at release. Only meaningful on `end`. */
+    velocityX: number;
+    /**
+     * True once the fingers have lifted and the OS is coasting. The macOS host
+     * drops momentum entirely so a swipe settles at finger-up, so this is
+     * currently always `false` there; it exists for hosts that choose to forward
+     * the tail.
+     */
+    momentum: boolean;
+}
+export type SwipeListener = (swipe: SwipeEvent) => void;
+export type Unsubscribe = () => void;
+export interface GesturesAPI {
+    onSwipe: (listener: SwipeListener) => Unsubscribe;
+}
+/**
+ * Whether the host forwards real gesture phases.
+ *
+ * Note this is `true` as soon as the registry is installed, which happens in
+ * every Craft window — it does **not** promise that a swipe will ever arrive.
+ * A host that never emits leaves the registry dormant, which is deliberate:
+ * callers keep their own `wheel` fallback bound and let the native stream
+ * supersede it on the first `begin` it delivers.
+ */
+export declare function hasNativeGestures(): boolean;
+/**
+ * Subscribe to swipe phases. Returns an unsubscribe function; calling it more
+ * than once is safe.
+ *
+ * In a plain browser this is a no-op returning a no-op, so it is safe to call
+ * unconditionally.
+ *
+ * @example
+ * ```ts
+ * const off = onSwipe((swipe) => {
+ *   if (swipe.axis !== 'horizontal') return
+ *   if (swipe.phase === 'begin') beginDrag()
+ *   else if (swipe.phase === 'end') settle(swipe.velocityX)
+ *   else track(swipe.deltaX)
+ * })
+ * ```
+ */
+export declare function onSwipe(listener: SwipeListener): Unsubscribe;
+/** Namespace form, for `import { gestures } from 'craft-native'`. */
+export declare const gestures: {
+    hasNativeGestures: () => boolean;
+    onSwipe: (listener: SwipeListener) => Unsubscribe;
+};

package/dist/api/http.d.ts

@@ -3,7 +3,7 @@
  * Provides native HTTP client through the Craft bridge
  * Bypasses CORS restrictions when running in Craft
  */
-import type { CraftHttpAPI } from '../types';
+import type { CraftHttpAPI } from '../types.js';
 /**
  * Result of {@link encodeRequestBody}. `kind` lets the caller decide
  * whether to default a `Content-Type: application/json` header.
@@ -193,4 +193,3 @@ export interface WebSocketOptions {
  */
 export declare function createClient(options?: HttpClientOptions): HttpClient;
 export default http;
-//# sourceMappingURL=http.d.ts.map