craft-native 0.0.237 → 0.0.238

package/dist/ios/templates/CraftRecordingArchive.swift

@@ -0,0 +1,85 @@
+import CryptoKit
+import Foundation
+import Darwin
+
+/// Immutable completed recordings and durable acknowledgement tombstones.
+/// IDs are opaque values; their SHA-256, never caller path text, names a file.
+enum CraftRecordingArchive {
+    typealias Writer = (Data, URL) throws -> Void
+    static func writeAtomically(_ data: Data, _ url: URL) throws {
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+        let temporary = url.deletingLastPathComponent().appendingPathComponent(".craft-atomic-" + UUID().uuidString)
+        defer { try? FileManager.default.removeItem(at: temporary) }
+        try data.write(to: temporary, options: .withoutOverwriting)
+        let file = try FileHandle(forWritingTo: temporary)
+        do { try file.synchronize(); try file.close() }
+        catch { try? file.close(); throw error }
+        try FileManager.default.setAttributes([.protectionKey: FileProtectionType.completeUntilFirstUserAuthentication], ofItemAtPath: temporary.path)
+        var protected = temporary
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = true
+        try protected.setResourceValues(values)
+        let result = temporary.path.withCString { source in url.path.withCString { destination in Darwin.rename(source, destination) } }
+        if result != 0 { throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno)) }
+    }
+
+    private static func url(_ directory: URL, _ kind: String, _ id: String, acknowledged: Bool = false) -> URL {
+        let digest = SHA256.hash(data: Data(id.utf8)).map { String(format: "%02x", $0) }.joined()
+        return directory.appendingPathComponent("craft-\(kind)-\(acknowledged ? "ack" : "completed")-\(digest).json")
+    }
+    static func startId(_ options: [String: Any], directory: URL, kind: String, currentId: String?) throws -> String {
+        let id: String
+        if options.keys.contains("recordingId") {
+            guard let requested = options["recordingId"] as? String,
+                  !requested.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+                throw CraftNativeActionError(code: "INVALID_ARGUMENT", message: "recordingId must be a nonempty recording ID")
+            }
+            id = requested
+        } else { id = UUID().uuidString }
+        let acknowledged = try isAcknowledged(directory, kind, id)
+        if id == currentId || acknowledged || FileManager.default.fileExists(atPath: url(directory, kind, id).path) {
+            throw CraftNativeActionError(code: "RECORDING_CONFLICT", message: "Recording IDs cannot be reused")
+        }
+        return id
+    }
+    static func isAcknowledged(_ directory: URL, _ kind: String, _ id: String) throws -> Bool {
+        let marker = url(directory, kind, id, acknowledged: true)
+        guard FileManager.default.fileExists(atPath: marker.path) else { return false }
+        guard try Data(contentsOf: marker) == Data(id.utf8) else {
+            throw CraftNativeActionError(code: "RECORDING_STORAGE_ERROR", message: "Invalid recording acknowledgement")
+        }
+        return true
+    }
+    static func read(_ directory: URL, _ kind: String, _ id: String) throws -> [String: Any]? {
+        if try isAcknowledged(directory, kind, id) {
+            try acknowledge(directory, kind, id)
+            throw CraftNativeActionError(code: "RECORDING_NOT_FOUND", message: "This recording has been acknowledged")
+        }
+        let source = url(directory, kind, id)
+        guard FileManager.default.fileExists(atPath: source.path) else { return nil }
+        let data = try Data(contentsOf: source)
+        guard let value = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+              value["id"] as? String == id, value["active"] as? Bool == false,
+              value[kind == "location" ? "locations" : "samples"] is [[String: Any]] else {
+            throw CraftNativeActionError(code: "RECORDING_STORAGE_ERROR", message: "Invalid completed recording archive")
+        }
+        return value
+    }
+    static func save(_ directory: URL, _ kind: String, _ state: [String: Any], samples: [[String: Any]], writer: Writer = writeAtomically) throws {
+        guard let id = state["id"] as? String else { return }
+        if try isAcknowledged(directory, kind, id) { try acknowledge(directory, kind, id); return }
+        if try read(directory, kind, id) != nil { return }
+        var completed = state
+        completed["active"] = false
+        completed["paused"] = false
+        completed["sampleCount"] = samples.count
+        completed[kind == "location" ? "locations" : "samples"] = samples
+        try writer(JSONSerialization.data(withJSONObject: completed), url(directory, kind, id))
+    }
+    static func acknowledge(_ directory: URL, _ kind: String, _ id: String) throws {
+        let marker = url(directory, kind, id, acknowledged: true)
+        if try !isAcknowledged(directory, kind, id) { try writeAtomically(Data(id.utf8), marker) }
+        let archive = url(directory, kind, id)
+        if FileManager.default.fileExists(atPath: archive.path) { try FileManager.default.removeItem(at: archive) }
+    }
+}

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

@@ -53,6 +53,7 @@ final class DriverTests: XCTestCase {
     let control = ProcessInfo.processInfo.environment["CRAFT_TEST_CONTROL"] ?? {{CONTROL_URL}}
     let app = XCUIApplication(bundleIdentifier: {{BUNDLE_ID}})
     let tabs: [String] = {{TABS}}
+    let tabIdentifiers: [String: String] = {{TAB_IDENTIFIERS}}
     private var bundledJourney = false
 
     func get(_ path: String, timeout: Double = 15) -> Data? {
@@ -140,9 +141,15 @@ final class DriverTests: XCTestCase {
 
     /// The native tab bar's button: Craft's floating bar is not a UITabBar, and
     /// XCUITest calls its buttons not hittable, so it is the button with this
-    /// label in the bottom fifth of the window.
+    /// label in the bottom fifth of the window. A configured stable identifier
+    /// keeps dynamic captions from changing the tab's native identity.
     func tabButton(_ name: String) -> XCUIElement? {
         let height = app.windows.firstMatch.frame.height
+        if let identifier = tabIdentifiers[name] {
+            let candidate = app.buttons.matching(NSPredicate(format: "identifier == %@", identifier)).firstMatch
+            if candidate.exists && candidate.frame.minY > height * 0.8 && candidate.frame.maxY <= height + 1 && candidate.frame.width > 0 { return candidate }
+            return nil
+        }
         let matches = app.buttons.matching(NSPredicate(format: "label == %@", name))
         for index in 0..<min(matches.count, 10) {
             let candidate = matches.element(boundBy: index)

package/dist/mobile-testing.js

@@ -8,6 +8,35 @@ import { existsSync } from "fs";
 import { mkdir, mkdtemp, rm } from "fs/promises";
 import { homedir, tmpdir } from "os";
 import { isAbsolute, join } from "path";
+
+// src/android-adb.ts
+async function requireAndroidEmulatorRoot(adb, serial, timeoutMs = 60000) {
+  if (!/^emulator-\d+$/.test(serial))
+    throw new Error("An explicit disposable Android emulator serial is required");
+  const deadline = Date.now() + timeoutMs;
+  async function run(args) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+      throw new Error("Android root reconnect deadline exceeded");
+    const child = Bun.spawn([adb, "-s", serial, ...args], { stdout: "pipe", stderr: "pipe", timeout: remaining });
+    const [code, stdout, stderr] = await Promise.all([child.exited, new Response(child.stdout).text(), new Response(child.stderr).text()]);
+    return { code, output: `${stdout}
+${stderr}`.trim() };
+  }
+  const root = await run(["root"]);
+  if (root.code !== 0 && !/^adb: unable to connect for root: closed$/.test(root.output)) {
+    throw new Error(`adb root failed (${root.code}): ${root.output}`);
+  }
+  const connected = await run(["wait-for-device"]);
+  if (connected.code !== 0)
+    throw new Error(`Android root reconnect failed (${connected.code}): ${connected.output}`);
+  const identity = await run(["shell", "id", "-u"]);
+  if (identity.code !== 0 || identity.output !== "0") {
+    throw new Error(`Storage fault tests require a rootable disposable AOSP emulator: ${identity.output}`);
+  }
+}
+
+// src/mobile-media-testing.ts
 async function verifyMobileMediaCache(options) {
   if (options.platform !== "ios" && options.platform !== "android")
     throw new Error("Choose ios or android");
@@ -207,10 +236,7 @@ ${await Bun.file(join(fixtures, "media-cache.kt")).text()}`);
           throw new Error(result);
         print(result);
       };
-      await run([adb, "-s", serial, "root"]);
-      await run([adb, "-s", serial, "wait-for-device"]);
-      if ((await run([adb, "-s", serial, "shell", "id", "-u"])).trim() !== "0")
-        throw new Error("Storage fault tests require a rootable disposable AOSP emulator");
+      await requireAndroidEmulatorRoot(adb, serial);
       await run([adb, "-s", serial, "shell", "run-as", packageName, "mkdir", "-p", "files/craft-media"]);
       const cache = `/data/user/0/${packageName}/files/craft-media`;
       const owner = (await run([adb, "-s", serial, "shell", "stat", "-c", "%u:%g", cache])).trim();

package/dist/mobile.js

@@ -355,6 +355,107 @@ var secureStorage = {
     Object.keys(localStorage).filter((k) => k.startsWith("secure_")).forEach((k) => localStorage.removeItem(k));
   }
 };
+function storageHost(method) {
+  const host = getCraftRoot()?.storage;
+  if (typeof host?.[method] !== "function")
+    throw Object.assign(new Error("This host does not provide native storage"), { code: "STORAGE_UNSUPPORTED" });
+  return host;
+}
+var crypto = {
+  async randomUUID() {
+    const root = getCraftRoot();
+    if (!root)
+      return secureUUID();
+    const caps = root.capabilities;
+    const advertised = Array.isArray(caps) ? caps.includes("crypto") : caps?.crypto === true;
+    if (!advertised || typeof root.crypto?.randomUUID !== "function")
+      throw Object.assign(new Error("This host does not provide secure UUIDs"), { code: "CRYPTO_UNSUPPORTED" });
+    const id = await root.crypto.randomUUID();
+    if (typeof id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id))
+      throw Object.assign(new Error("The host returned an invalid secure UUID"), { code: "CRYPTO_INVALID_RESPONSE" });
+    return id;
+  }
+};
+var storage = {
+  supportsSetIfAbsent() {
+    const root = getCraftRoot();
+    const caps = root?.capabilities;
+    const supported = Array.isArray(caps) ? caps.includes("storageSetIfAbsent") : caps?.storageSetIfAbsent === true;
+    return supported && typeof root?.storage?.setIfAbsent === "function";
+  },
+  supportsCompareAndSet() {
+    const root = getCraftRoot();
+    const caps = root?.capabilities;
+    const supported = Array.isArray(caps) ? caps.includes("storageCompareAndSet") : caps?.storageCompareAndSet === true;
+    return supported && typeof root?.storage?.compareAndSet === "function";
+  },
+  async get(key) {
+    return storageHost("get").get(key);
+  },
+  async set(key, value) {
+    return storageHost("set").set(key, value);
+  },
+  async remove(key) {
+    return storageHost("remove").remove(key);
+  },
+  async clear() {
+    return storageHost("clear").clear();
+  },
+  async keys() {
+    return storageHost("keys").keys();
+  },
+  async setIfAbsent(key, value) {
+    if (!storage.supportsSetIfAbsent())
+      throw Object.assign(new Error("This app build cannot atomically register an intent"), { code: "STORAGE_SET_IF_ABSENT_UNSUPPORTED" });
+    if (typeof key !== "string" || !key.trim() || JSON.stringify(value) === undefined)
+      throw Object.assign(new Error("setIfAbsent needs a key and JSON value"), { code: "INVALID_ARGUMENT" });
+    return storageHost("setIfAbsent").setIfAbsent(key, value);
+  },
+  async compareAndSet(key, expectedValue, nextValue) {
+    if (!storage.supportsCompareAndSet())
+      throw Object.assign(new Error("This app build cannot atomically checkpoint existing storage"), { code: "STORAGE_COMPARE_AND_SET_UNSUPPORTED" });
+    if (typeof key !== "string" || !key.trim() || JSON.stringify(expectedValue) === undefined || JSON.stringify(nextValue) === undefined)
+      throw Object.assign(new Error("compareAndSet needs a key and JSON values"), { code: "INVALID_ARGUMENT" });
+    return storageHost("compareAndSet").compareAndSet(key, expectedValue, nextValue);
+  }
+};
+function recordingOwnershipSupported(namespace) {
+  const root = getCraftRoot();
+  const flag = namespace === "location" ? "locationRecordingOwnership" : "heartRateRecordingOwnership";
+  const caps = root?.capabilities;
+  const advertised = Array.isArray(caps) ? caps.includes(flag) : caps?.[flag] === true;
+  return advertised && ["pauseRecording", "resumeRecording", "stopRecording", "readRecording", "getRecordingState", "acknowledgeRecording"].every((method) => typeof root?.[namespace]?.[method] === "function");
+}
+function recordingIntentSupported(namespace) {
+  const root = getCraftRoot();
+  const flag = namespace === "location" ? "locationRecordingIntentIdentity" : "heartRateRecordingIntentIdentity";
+  const caps = root?.capabilities;
+  const advertised = Array.isArray(caps) ? caps.includes(flag) : caps?.[flag] === true;
+  return advertised && recordingOwnershipSupported(namespace) && typeof root?.[namespace]?.startRecording === "function";
+}
+function validateRecordingStart(namespace, options) {
+  if (!Object.prototype.hasOwnProperty.call(options, "recordingId"))
+    return;
+  if (typeof options.recordingId !== "string" || !options.recordingId.trim())
+    throw Object.assign(new Error("recordingId must be a nonempty recording ID"), { code: "INVALID_ARGUMENT" });
+  if (!recordingIntentSupported(namespace))
+    throw Object.assign(new Error("This app build cannot start the persisted recording intent"), { code: "RECORDING_INTENT_IDENTITY_UNSUPPORTED" });
+}
+function verifyRecordingStart(options, result) {
+  if (options.recordingId !== undefined && result.id !== options.recordingId)
+    throw Object.assign(new Error("The native recording does not match the persisted intent"), { code: "RECORDING_CONFLICT" });
+  return result;
+}
+function validateRecordingOwnership(namespace, options) {
+  if (!options || !Object.prototype.hasOwnProperty.call(options, "expectedId"))
+    return;
+  if (typeof options.expectedId !== "string" || !options.expectedId.trim())
+    throw Object.assign(new Error("expectedId must be a nonempty recording ID"), { code: "INVALID_ARGUMENT" });
+  if ((getCraftRoot() || namespace === "heartRate") && !recordingOwnershipSupported(namespace))
+    throw Object.assign(new Error("This app build cannot enforce recording ownership"), { code: "RECORDING_OWNERSHIP_UNSUPPORTED" });
+  if (namespace === "location" && !getCraftRoot() && options.expectedId !== webLocationRecording.id)
+    throw Object.assign(new Error("The active location recording has changed"), { code: "RECORDING_CONFLICT" });
+}
 var webLocationRecording = {
   id: null,
   active: false,
@@ -364,6 +465,8 @@ var webLocationRecording = {
 };
 var webLocationRecordingWatchId = null;
 var location = {
+  supportsRecordingOwnership: () => recordingOwnershipSupported("location"),
+  supportsRecordingIntentIdentity: () => recordingIntentSupported("location"),
   async getCurrentPosition(options = {}) {
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location) {
@@ -412,9 +515,12 @@ var location = {
     navigator.geolocation.clearWatch(watchId);
   },
   async startRecording(options = {}) {
+    validateRecordingStart("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.startRecording)
-      return craft.location.startRecording(options);
+      return verifyRecordingStart(options, await craft.location.startRecording(options));
+    if (webLocationRecording.active)
+      throw Object.assign(new Error("A location recording is already active"), { code: "RECORDING_ALREADY_ACTIVE" });
     if (webLocationRecordingWatchId !== null)
       navigator.geolocation.clearWatch(webLocationRecordingWatchId);
     webLocationRecording = {
@@ -430,24 +536,27 @@ var location = {
     }, options);
     return { ...webLocationRecording, sampleCount: 0 };
   },
-  async pauseRecording() {
+  async pauseRecording(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.pauseRecording)
-      return craft.location.pauseRecording();
+      return craft.location.pauseRecording(options);
     webLocationRecording.paused = true;
     return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
   },
-  async resumeRecording() {
+  async resumeRecording(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.resumeRecording)
-      return craft.location.resumeRecording();
+      return craft.location.resumeRecording(options);
     webLocationRecording.paused = false;
     return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
   },
-  async stopRecording() {
+  async stopRecording(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.stopRecording)
-      return craft.location.stopRecording();
+      return craft.location.stopRecording(options);
     if (webLocationRecordingWatchId !== null) {
       location.clearWatch(webLocationRecordingWatchId);
       webLocationRecordingWatchId = null;
@@ -456,16 +565,30 @@ var location = {
     webLocationRecording.paused = false;
     return { ...webLocationRecording, locations: [...webLocationRecording.locations] };
   },
-  async getRecordingState() {
+  async getRecordingState(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.getRecordingState)
-      return craft.location.getRecordingState();
+      return craft.location.getRecordingState(options);
     return { ...webLocationRecording, sampleCount: webLocationRecording.locations.length };
   },
-  async readRecording() {
+  async acknowledgeRecording(options) {
+    if (!options || !Object.prototype.hasOwnProperty.call(options, "expectedId"))
+      throw Object.assign(new Error("Acknowledgement needs expectedId"), { code: "INVALID_ARGUMENT" });
+    validateRecordingOwnership("location", options);
+    const craft = getCraftMobile();
+    if (craft?.location?.acknowledgeRecording)
+      return craft.location.acknowledgeRecording(options);
+    if (webLocationRecording.active)
+      throw Object.assign(new Error("The recording is still active"), { code: "RECORDING_ALREADY_ACTIVE" });
+    webLocationRecording = { id: null, active: false, paused: false, startedAt: null, locations: [] };
+    return true;
+  },
+  async readRecording(options) {
+    validateRecordingOwnership("location", options);
     const craft = getCraftMobile();
     if (typeof window !== "undefined" && craft?.location?.readRecording)
-      return craft.location.readRecording();
+      return craft.location.readRecording(options);
     return [...webLocationRecording.locations];
   }
 };
@@ -1023,6 +1146,8 @@ async function heartRateCall(method, fallback, normalize, ...args) {
 }
 var noRecording = () => normalizeHeartRateRecording({});
 var heartRate = {
+  supportsRecordingOwnership: () => recordingOwnershipSupported("heartRate"),
+  supportsRecordingIntentIdentity: () => recordingIntentSupported("heartRate"),
   isAvailable() {
     return typeof nativeHeartRate()?.getState === "function";
   },
@@ -1037,12 +1162,37 @@ var heartRate = {
   connect: (id) => heartRateCall("connect", noHeartRate, normalizeHeartRateState, id),
   reconnect: () => heartRateCall("reconnect", noHeartRate, normalizeHeartRateState),
   disconnect: (options = {}) => heartRateCall("disconnect", noHeartRate, normalizeHeartRateState, options),
-  startRecording: () => heartRateCall("startRecording", noRecording, normalizeHeartRateRecording),
-  pauseRecording: () => heartRateCall("pauseRecording", noRecording, normalizeHeartRateRecording),
-  resumeRecording: () => heartRateCall("resumeRecording", noRecording, normalizeHeartRateRecording),
-  stopRecording: () => heartRateCall("stopRecording", () => ({ ...noRecording(), samples: [] }), (value) => ({ ...normalizeHeartRateRecording(value), samples: normalizeHeartRateSamples(hrRecord(value).samples) })),
-  getRecordingState: () => heartRateCall("getRecordingState", noRecording, normalizeHeartRateRecording),
-  readRecording: (options = {}) => heartRateCall("readRecording", () => [], normalizeHeartRateSamples, options),
+  async startRecording(options) {
+    const supplied = options ?? {};
+    validateRecordingStart("heartRate", supplied);
+    return verifyRecordingStart(supplied, await heartRateCall("startRecording", noRecording, normalizeHeartRateRecording, ...options === undefined ? [] : [options]));
+  },
+  async pauseRecording(options) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("pauseRecording", noRecording, normalizeHeartRateRecording, ...options === undefined ? [] : [options]);
+  },
+  async resumeRecording(options) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("resumeRecording", noRecording, normalizeHeartRateRecording, ...options === undefined ? [] : [options]);
+  },
+  async stopRecording(options) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("stopRecording", () => ({ ...noRecording(), samples: [] }), (value) => ({ ...normalizeHeartRateRecording(value), samples: normalizeHeartRateSamples(hrRecord(value).samples) }), ...options === undefined ? [] : [options]);
+  },
+  async getRecordingState(options) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("getRecordingState", noRecording, normalizeHeartRateRecording, ...options === undefined ? [] : [options]);
+  },
+  async acknowledgeRecording(options) {
+    if (!options || !Object.prototype.hasOwnProperty.call(options, "expectedId"))
+      throw Object.assign(new Error("Acknowledgement needs expectedId"), { code: "INVALID_ARGUMENT" });
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("acknowledgeRecording", () => false, (value) => value === true, options);
+  },
+  async readRecording(options = {}) {
+    validateRecordingOwnership("heartRate", options);
+    return heartRateCall("readRecording", () => [], normalizeHeartRateSamples, options);
+  },
   onReading: (callback) => hrSubscribe(heartRateWatch.readings, callback),
   onDevice: (callback) => hrSubscribe(heartRateWatch.devices, callback),
   onState: (callback) => hrSubscribe(heartRateWatch.states, callback)
@@ -1646,6 +1796,7 @@ export {
   watchConnectivity,
   tabBar,
   symbols,
+  storage,
   statusBar,
   splash,
   speech,
@@ -1679,6 +1830,7 @@ export {
   dialog,
   device,
   deepLinks,
+  crypto,
   crashReporter,
   contextMenu,
   chrome,

package/package.json

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