craft-native 0.0.451 → 0.0.464

package/dist/ios/templates/testing/DriverTests.swift.template

@@ -61,6 +61,8 @@ final class DriverTests: XCTestCase {
     let tabs: [String] = {{TABS}}
     let tabIdentifiers: [String: String] = {{TAB_IDENTIFIERS}}
     private var bundledJourney = false
+    private var lastTappedInput: XCUIElement?
+    private var lastBooleanTap: [String: Any]?
 
     func get(_ path: String, timeout: Double = 15) -> Data? {
         var result: Data?
@@ -293,8 +295,6 @@ final class DriverTests: XCTestCase {
         return (parts[0], parts.count > 1 ? Double(parts[1]) ?? 10 : 10)
     }
 
-    /// A switch reports "0" or "1". Any other value is not a switch state to
-    /// wait on, so the tap stands as it would for any other control.
     /// The switch answers `/exec` with 200 whatever the hook did, its first
     /// word the hook's exit code: only `exit 0` is a hook that worked.
     func hookSucceeded(_ answer: String) -> Bool {
@@ -308,16 +308,26 @@ final class DriverTests: XCTestCase {
         return fields.count >= 2 && fields[1] == "0"
     }
 
+    /// UIKit and Craft's solid toggle both publish "0" or "1", regardless
+    /// of the accessibility element type that XCTest assigns to them.
     func switchFlipped(from before: String?, to after: String?) -> Bool {
         let states: Set<String> = ["0", "1"]
-        guard let before, let after, states.contains(before), states.contains(after) else { return true }
+        // A lost accessibility value is missing evidence, not a successful tap.
+        guard let before, let after, states.contains(before), states.contains(after) else { return false }
         return before != after
     }
 
     /// Deliver one gesture; the command's observation determines success.
     func press(_ element: XCUIElement) {
+        // Resolve this before activation: a menu item can disappear as soon
+        // as its gesture completes (for example Select All).
+        let input = [.textField, .secureTextField, .textView, .searchField].contains(element.elementType)
+            ? element : nil
         if element.isHittable { element.tap() }
         else { element.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5)).tap() }
+        // A tap on a read-only text view need not open the keyboard. Only a
+        // following type command observes whether this target took focus.
+        lastTappedInput = input
     }
 
     func answerOpenPrompt() {
@@ -353,6 +363,11 @@ final class DriverTests: XCTestCase {
         let parts = line.split(separator: " ", maxSplits: 1).map(String.init)
         let command = parts[0]
         let arg = parts.count > 1 ? parts[1] : ""
+        // Context changes can move focus without going through press().
+        if ["launch", "activate", "terminate", "home", "background", "openurl", "universallink",
+            "back", "return", "tab", "tapxy", "edge", "notifications", "systemtap", "longpressid", "exec"].contains(command) {
+            lastTappedInput = nil
+        }
         if bundledJourney && ["net", "delay", "exec"].contains(command) {
             check(false, "\(command) requires a control-server journey")
             return
@@ -470,12 +485,15 @@ final class DriverTests: XCTestCase {
             if let target = poll(10, { exact(arg) }) { press(target); note("tapexact \(arg): ok") }
             else { XCTFail("Element not found"); note("FAIL tapexact \(arg): NOT FOUND") }
         case "tapid":
+            lastBooleanTap = nil
             let target = identified(arg)
             if !target.waitForExistence(timeout: 10) { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
-            else if target.elementType == .switch {
+            else if target.elementType == .switch || ["0", "1"].contains(target.value as? String ?? "") {
                 // Observe one physical gesture. Retapping could conceal a
                 // renderer or hit-testing failure (HQ agreement job 7570).
                 let before = target.value as? String
+                let enabledBefore = target.isEnabled
+                let frameBefore = target.frame
                 press(target)
                 let settle = Date().addingTimeInterval(1.5)
                 var flipped = false
@@ -483,6 +501,15 @@ final class DriverTests: XCTestCase {
                     flipped = switchFlipped(from: before, to: target.value as? String)
                     if !flipped { Thread.sleep(forTimeInterval: 0.25) }
                 } while !flipped && Date() < settle
+                let observation: [String: Any] = [
+                    "id": arg, "gestures": 1, "flipped": flipped,
+                    "enabledBefore": enabledBefore, "enabledAfter": target.isEnabled,
+                    "valueBefore": before ?? "unknown", "valueAfter": target.value as? String ?? "unknown",
+                    "frameBefore": [frameBefore.origin.x, frameBefore.origin.y, frameBefore.width, frameBefore.height],
+                ]
+                lastBooleanTap = observation
+                if let data = try? JSONSerialization.data(withJSONObject: observation, options: [.sortedKeys]),
+                   let json = String(data: data, encoding: .utf8) { note("BOOLEAN_TAP \(json)") }
                 check(flipped, "tapid \(arg) flips the switch")
             }
             else { press(target); note("tapid \(arg): ok") }
@@ -596,9 +623,20 @@ final class DriverTests: XCTestCase {
                 start.press(forDuration: 0.05, thenDragTo: app.coordinate(withNormalizedOffset: CGVector(dx: 0.8, dy: 0.5)))
                 note("back: edge swipe")
             }
-        case "type": app.typeText(arg)
+        case "type":
+            let target = lastTappedInput ?? app
+            lastTappedInput = nil
+            // A returned gesture is not proof of keyboard focus. Observe the
+            // one gesture before typing, including WebKit/cold-keyboard focus
+            // delivery. Never retap and conceal a dropped input event.
+            guard poll(15, { self.hasKeyboardFocus(target) ? target : nil }) != nil else {
+                check(false, "type into \(target.label) takes keyboard focus")
+                return
+            }
+            app.typeText(arg)
         case "return": app.typeText(XCUIKeyboardKey.return.rawValue); note("return")
         case "typeid":
+            lastTappedInput = nil
             let idParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
             let target = identified(idParts[0])
             if target.waitForExistence(timeout: 10) {
@@ -627,6 +665,7 @@ final class DriverTests: XCTestCase {
             let target = XCUIApplication(bundleIdentifier: bundle)
             check(target.wait(for: .runningForeground, timeout: seconds), "expectapp \(bundle)")
         case "field":
+            lastTappedInput = nil
             let fieldParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
             let index = Int(fieldParts[0]) ?? 0
             let fields = app.textFields.allElementsBoundByIndex + app.secureTextFields.allElementsBoundByIndex

package/dist/mobile.d.ts

@@ -6,3 +6,5 @@
  * which intentionally target Bun and must not enter a browser bundle.
  */
 export * from './api/mobile.js';
+export { matchNativePath, normalizeNativePath } from './native-routing.js';
+export type { NativePathMatch, NativeParameterConstraint, NativeRouteConstraints } from './native-routing.js';

package/dist/mobile.js

@@ -1964,6 +1964,124 @@ function getCraftMobile() {
   }
   return;
 }
+// src/native-routing.ts
+function applyNativeParameterConstraints(params, rules) {
+  if (rules === undefined)
+    return true;
+  if (!rules || typeof rules !== "object" || Array.isArray(rules))
+    return false;
+  for (const [name, rule] of Object.entries(rules)) {
+    let value = params[name];
+    if (typeof value !== "string" || !rule || typeof rule !== "object" || Array.isArray(rule))
+      return false;
+    if (Object.keys(rule).some((key) => !["pattern", "exclude", "normalize"].includes(key)))
+      return false;
+    if (rule.normalize !== undefined && rule.normalize !== "lowercase")
+      return false;
+    if (rule.normalize === "lowercase")
+      value = value.toLowerCase();
+    if (rule.exclude !== undefined) {
+      if (!Array.isArray(rule.exclude) || rule.exclude.some((item) => typeof item !== "string"))
+        return false;
+      if (rule.exclude.some((item) => (rule.normalize === "lowercase" ? item.toLowerCase() : item) === value))
+        return false;
+    }
+    if (rule.pattern !== undefined) {
+      if (typeof rule.pattern !== "string")
+        return false;
+      try {
+        const matched = new RegExp(`^(?:${rule.pattern})$`).exec(value);
+        if (!matched || matched[0] !== value)
+          return false;
+      } catch {
+        return false;
+      }
+    }
+    params[name] = value;
+  }
+  return true;
+}
+function normalizeNativePath(raw) {
+  if (typeof raw !== "string")
+    return null;
+  let path = raw;
+  const cut = path.search(/[?#]/);
+  if (cut >= 0)
+    path = path.slice(0, cut);
+  if (!path.startsWith("/"))
+    return null;
+  path = path.replace(/\/{2,}/g, "/");
+  if (path.length > 1 && path.endsWith("/"))
+    path = path.slice(0, -1);
+  return path;
+}
+function routeSegments(path) {
+  return path === "/" ? [] : path.slice(1).split("/");
+}
+function matchNativePath(nativeScreens, raw, constraints) {
+  if (constraints !== undefined && (!constraints || typeof constraints !== "object" || Array.isArray(constraints)))
+    return null;
+  const path = normalizeNativePath(raw);
+  if (path === null)
+    return null;
+  const routes = Object.entries(nativeScreens ?? {}).map(([pattern, screen]) => ({ key: pattern, pattern: normalizeNativePath(pattern), screen })).filter((route) => route.pattern !== null && !!route.screen).map((route) => ({ ...route, segments: routeSegments(route.pattern) }));
+  const wild = (segments) => segments.at(-1) === "*" ? 1 : 0;
+  const fixed = (segments) => segments.filter((s) => s !== "*" && !s.startsWith(":")).length;
+  routes.sort((a, b) => wild(a.segments) - wild(b.segments) || fixed(b.segments) - fixed(a.segments) || b.segments.length - a.segments.length || (a.pattern < b.pattern ? -1 : a.pattern > b.pattern ? 1 : 0));
+  const decode = (value) => {
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      return value;
+    }
+  };
+  const parts = routeSegments(path);
+  for (const route of routes) {
+    const params = {};
+    let matched = true;
+    for (let i = 0;i < route.segments.length; i++) {
+      const segment = route.segments[i];
+      if (segment === "*") {
+        params["*"] = parts.slice(i).join("/");
+        break;
+      }
+      if (i >= parts.length) {
+        matched = false;
+        break;
+      }
+      if (segment.startsWith(":")) {
+        if (!parts[i]) {
+          matched = false;
+          break;
+        }
+        params[segment.slice(1)] = decode(parts[i]);
+      } else if (segment !== parts[i]) {
+        matched = false;
+        break;
+      }
+    }
+    if (!matched)
+      continue;
+    if (route.segments.at(-1) !== "*" && route.segments.length !== parts.length)
+      continue;
+    if (!applyNativeParameterConstraints(params, constraints?.[route.key]))
+      continue;
+    const query = raw.indexOf("?");
+    if (query >= 0) {
+      for (const item of raw.slice(query + 1).split("#")[0].split("&")) {
+        if (!item)
+          continue;
+        const [rawKey = "", ...rest] = item.split("=");
+        const key = decode(rawKey);
+        if (!key || key in params)
+          continue;
+        params[key] = decode(rest.join("=").replace(/\+/g, " "));
+      }
+    }
+    return { path, screen: route.screen, params };
+  }
+  return null;
+}
 export {
   DEFAULT_SESSION_TOKEN_KEY,
   SESSION_EVENT,
@@ -1995,6 +2113,7 @@ export {
   lifecycle,
   liveActivities,
   location,
+  matchNativePath,
   music,
   network,
   normalizeDeepLinkURL,
@@ -2002,6 +2121,7 @@ export {
   normalizeHeartRateReading,
   normalizeHeartRateSamples,
   normalizeHeartRateState,
+  normalizeNativePath,
   normalizeNowPlaying,
   normalizeScheduledWorkout,
   notifications,

package/dist/native-notifications.d.ts

@@ -0,0 +1,17 @@
+/** Registered before notification delivery; payloads reference category ids. */
+export interface NativeNotificationCategory {
+    id: string;
+    actions: {
+        id: string;
+        title: string;
+        destructive?: boolean;
+        /** Open the app. Otherwise nativeApp handles the action in the background. */
+        foreground?: boolean;
+        authenticationRequired?: boolean;
+        textInput?: {
+            buttonTitle: string;
+            placeholder?: string;
+        };
+    }[];
+}
+export declare function nativeNotificationProblems(categories: unknown, nativeApp?: string, renderer?: string): string[];

package/dist/native-routing.d.ts

@@ -0,0 +1,26 @@
+/** Constraints on decoded named path parameters; query items cannot override them. */
+export interface NativeParameterConstraint {
+    /** A case-sensitive regular expression for the complete normalized value. */
+    pattern?: string;
+    exclude?: readonly string[];
+    /** Normalize decoded values and exclusions before case-sensitive grammar validation. */
+    normalize?: 'lowercase';
+}
+export type NativeRouteConstraints = Record<string, Record<string, NativeParameterConstraint>>;
+/** Validate and normalize the decoded parameter map before query binding. */
+export declare function applyNativeParameterConstraints(params: Record<string, string>, rules?: Record<string, NativeParameterConstraint>): boolean;
+export declare function nativeRouteConstraintProblems(screens?: Record<string, string>, constraints?: NativeRouteConstraints): string[];
+/** `/a//b/?q#h` → `/a/b`, the way the shell and the page compare paths. Null for a relative path. */
+export declare function normalizeNativePath(raw: string): string | null;
+export interface NativePathMatch {
+    path: string;
+    screen: string;
+    params: Record<string, string>;
+}
+export declare function routeSegments(path: string): string[];
+/**
+ * The native screen for a path, by the rules the shell (`CraftHybridRoutes`)
+ * and the page script apply: static segments win over `:params`, which win
+ * over a trailing `*`; query items become params under the path's own.
+ */
+export declare function matchNativePath(nativeScreens: Record<string, string> | undefined, raw: string, constraints?: NativeRouteConstraints): NativePathMatch | null;

package/dist/testing/media-cache/media-cache.kt

@@ -23,10 +23,10 @@ class DownloadProbe : android.app.Instrumentation() {
         proof.append("PASS: ").append(message).append('\n')
         android.util.Log.i("CraftMediaProbe", "PASS: $message")
     }
-    private fun keep(address: String): Boolean {
+    private fun keep(address: String, cacheKey: String? = null): Boolean {
         val done = java.util.concurrent.CountDownLatch(1)
         var ok = false
-        CraftNativeMedia.keep(targetContext, address, JSONObject(), true) {
+        CraftNativeMedia.keep(targetContext, address, JSONObject(), true, cacheKey = cacheKey) {
             latestErrorCode = it.code
             ok = (it.data as? JSONObject)?.optBoolean("ok") == true
             done.countDown()
@@ -113,6 +113,32 @@ class DownloadProbe : android.app.Instrumentation() {
                 }
                 else -> {
                     CraftNativeMedia.prune(targetContext, emptyList())
+                    val queuedKey = "account:one:lesson:8:version:a"
+                    val expired = base + "/queued.mp4?token=expired"
+                    val renewed = base + "/queued.mp4?token=renewed"
+                    val queuedIdentity = CraftNativeMedia.identity(expired, JSONObject().put("cacheKey", queuedKey))
+                    val queuedGeneration = CraftNativeMedia.generation(targetContext)
+                    targetContext.getSharedPreferences("craft.media", Context.MODE_PRIVATE).edit().putString("source:${CraftNativeMedia.digest(queuedIdentity)}", CraftNativeMedia.digest(expired + "\n")).commit()
+                    val queuedWork = androidx.work.OneTimeWorkRequestBuilder<CraftNativeMediaWorker>()
+                        .setInputData(androidx.work.workDataOf("address" to queuedIdentity, "source" to expired, "headers" to "{}", "generation" to queuedGeneration))
+                        .setInitialDelay(1, java.util.concurrent.TimeUnit.DAYS)
+                        .addTag("craft-media:generation:$queuedGeneration")
+                        .build()
+                    androidx.work.WorkManager.getInstance(targetContext).enqueueUniqueWork("craft-media:${CraftNativeMedia.digest(queuedIdentity)}:any", androidx.work.ExistingWorkPolicy.REPLACE, queuedWork).result.get()
+                    check(keep(renewed, queuedKey), "a renewed authorized source replaces expired queued work immediately")
+                    val signed = base + "/keyed.mp4?token=first"
+                    val key = "account:one:lesson:7:version:a"
+                    check(keep(signed, key), "signed URL downloads under an account/version identity")
+                    val identity = CraftNativeMedia.identity(signed, JSONObject().put("cacheKey", key))
+                    val rotated = CraftNativeMedia.identity(base + "/keyed.mp4?token=second", JSONObject().put("cacheKey", key))
+                    check(identity == rotated && CraftNativeMedia.local(targetContext, rotated) != null, "renewed signed URLs reuse the complete copy offline")
+                    check(keep(base + "/keyed.mp4?token=second", key), "renewing authorization does not redownload unchanged content")
+                    check(CraftNativeMedia.local(targetContext, CraftNativeMedia.identity(signed, JSONObject().put("cacheKey", "account:two:lesson:7:version:a"))) == null, "another account cannot address the copy")
+                    check(CraftNativeMedia.local(targetContext, CraftNativeMedia.identity(signed, JSONObject().put("cacheKey", "account:one:lesson:7:version:b"))) == null, "a new version invalidates the copy")
+                    CraftNativeMedia.prune(targetContext, listOf(rotated))
+                    check(CraftNativeMedia.local(targetContext, rotated) != null, "key-aware prune retains the authorized source")
+                    CraftNativeMedia.prune(targetContext, emptyList())
+                    check(CraftNativeMedia.local(targetContext, rotated) == null, "revocation removes the keyed copy")
                     val broken = "$base/broken.mp4"
                     check(!keep(broken), "truncated transfer fails")
                     check(CraftNativeMedia.local(targetContext, broken) == null, "truncated transfer is not playable cache")

package/dist/testing/media-cache/media-cache.swift.fixture

@@ -15,13 +15,14 @@ func wait(_ ready: () -> Bool) {
 }
 var latestTask: URLSessionTask?
 var latestErrorCode: String?
-func start(_ address: String, _ done: @escaping (Bool) -> Void) {
+func start(_ source: String, cacheKey: String? = nil, _ done: @escaping (Bool) -> Void) {
+    let address = CraftNativeMedia.identity(source, options: cacheKey.map { ["cacheKey": $0] } ?? [:])
     if let local = CraftNativeMedia.local(address) { done((CraftNativeMedia.describe(address, local)["size"] as? Int ?? 0) > 0); return }
     guard let flight = CraftNativeMedia.begin(address, { result in
         if case .success(let data) = result { done((data as? [String: Any])?["ok"] as? Bool == true) }
         else if case .failure(let error) = result { latestErrorCode = error.code; done(false) }
     }) else { return }
-    let task = URLSession.shared.downloadTask(with: URL(string: address)!) { location, response, error in
+    let task = URLSession.shared.downloadTask(with: URL(string: source)!) { location, response, error in
         let result: Result<Any, CraftNativeActionError>
         if error != nil { result = .failure(CraftNativeActionError(code: "NETWORK_ERROR", message: "Interrupted")) }
         else if let location, let response = response as? HTTPURLResponse { result = CraftNativeMedia.store(address, at: location, response: response, flight: flight) }
@@ -31,9 +32,9 @@ func start(_ address: String, _ done: @escaping (Bool) -> Void) {
     latestTask = task
     task.resume()
 }
-func keep(_ address: String) -> Bool {
+func keep(_ address: String, cacheKey: String? = nil) -> Bool {
     var result: Bool?
-    start(address) { result = $0 }
+    start(address, cacheKey: cacheKey) { result = $0 }
     wait { result != nil }
     return result!
 }
@@ -105,6 +106,19 @@ check(CraftNativeMedia.local(broken) == nil, "truncated transfer is not playable
 check(keep(broken), "same URL retries successfully")
 check(!keep(base + "/partial.mp4"), "unsolicited partial response is refused")
 check(!keep(base + "/empty.mp4"), "empty file is refused")
+let signed = base + "/keyed.mp4?token=first"
+let key = "account:one:lesson:7:version:a"
+check(keep(signed, cacheKey: key), "authorized signed URL downloads under account/version identity")
+let identity = CraftNativeMedia.identity(signed, options: ["cacheKey": key])
+let rotated = CraftNativeMedia.identity(base + "/keyed.mp4?token=second", options: ["cacheKey": key])
+check(identity == rotated && CraftNativeMedia.local(rotated) != nil, "renewing a signed URL reuses the complete cached file offline")
+check(keep(base + "/keyed.mp4?token=second", cacheKey: key), "renewed authorization does not redownload unchanged content")
+check(CraftNativeMedia.local(CraftNativeMedia.identity(signed, options: ["cacheKey": "account:two:lesson:7:version:a"])) == nil, "another account cannot address the private copy")
+check(CraftNativeMedia.local(CraftNativeMedia.identity(signed, options: ["cacheKey": "account:one:lesson:7:version:b"])) == nil, "a new prepared version invalidates the old copy")
+_ = CraftNativeMedia.prune(keep: [rotated])
+check(CraftNativeMedia.local(rotated) != nil, "key-aware prune retains the current authorized source")
+_ = CraftNativeMedia.prune(keep: [])
+check(CraftNativeMedia.local(rotated) == nil, "definitive revocation removes the keyed copy")
 let slow = base + "/slow.mp4"
 var answers = [Bool]()
 start(slow) { answers.append($0) }

package/dist/typescript/src/native-notifications.d.ts

@@ -0,0 +1,17 @@
+/** Registered before notification delivery; payloads reference category ids. */
+export interface NativeNotificationCategory {
+    id: string;
+    actions: {
+        id: string;
+        title: string;
+        destructive?: boolean;
+        /** Open the app. Otherwise nativeApp handles the action in the background. */
+        foreground?: boolean;
+        authenticationRequired?: boolean;
+        textInput?: {
+            buttonTitle: string;
+            placeholder?: string;
+        };
+    }[];
+}
+export declare function nativeNotificationProblems(categories: unknown, nativeApp?: string, renderer?: string): string[];

package/dist/typescript/src/native-routing.d.ts

@@ -0,0 +1,26 @@
+/** Constraints on decoded named path parameters; query items cannot override them. */
+export interface NativeParameterConstraint {
+    /** A case-sensitive regular expression for the complete normalized value. */
+    pattern?: string;
+    exclude?: readonly string[];
+    /** Normalize decoded values and exclusions before case-sensitive grammar validation. */
+    normalize?: 'lowercase';
+}
+export type NativeRouteConstraints = Record<string, Record<string, NativeParameterConstraint>>;
+/** Validate and normalize the decoded parameter map before query binding. */
+export declare function applyNativeParameterConstraints(params: Record<string, string>, rules?: Record<string, NativeParameterConstraint>): boolean;
+export declare function nativeRouteConstraintProblems(screens?: Record<string, string>, constraints?: NativeRouteConstraints): string[];
+/** `/a//b/?q#h` → `/a/b`, the way the shell and the page compare paths. Null for a relative path. */
+export declare function normalizeNativePath(raw: string): string | null;
+export interface NativePathMatch {
+    path: string;
+    screen: string;
+    params: Record<string, string>;
+}
+export declare function routeSegments(path: string): string[];
+/**
+ * The native screen for a path, by the rules the shell (`CraftHybridRoutes`)
+ * and the page script apply: static segments win over `:params`, which win
+ * over a trailing `*`; query items become params under the path's own.
+ */
+export declare function matchNativePath(nativeScreens: Record<string, string> | undefined, raw: string, constraints?: NativeRouteConstraints): NativePathMatch | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.451",
+  "version": "0.0.464",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",