craft-native 0.0.237 → 0.0.241

package/dist/browser.js

@@ -1,7 +1,28 @@
+// src/bridge/ids.ts
+function secureUUID() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  if (c && typeof c.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    c.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+  }
+  throw new Error("[Craft] No Web Crypto available; cannot generate secure IDs");
+}
+
 // src/browser/storage.ts
 async function createBrowserStorage(options) {
   const { storage, namespace, tokenKey, changed } = options;
   const prefix = `${namespace}:`;
+  const lock = options.lock === null ? undefined : options.lock ?? (typeof navigator !== "undefined" && typeof navigator.locks?.request === "function" ? (name, operation) => navigator.locks.request(name, operation) : undefined);
+  const exclusive = (operation) => lock ? lock(`${namespace}:storage`, operation) : Promise.resolve().then(operation);
+  const scopeChanged = () => Object.assign(new Error("The storage account changed"), { code: "STORAGE_SCOPE_CHANGED" });
+  const pending = new Map;
   let token = storage.getItem(tokenKey);
   let scope = token ? await options.hash(token) : "guest";
   let transitioning = false;
@@ -11,17 +32,61 @@ async function createBrowserStorage(options) {
   const key = (name) => `${prefix}account:${scope}:${name}`;
   const snapshotKey = (name) => name === "app" ? `${prefix}app` : key(`snapshot:${name}`);
   const keys = (base) => Array.from({ length: storage.length }, (_, index) => storage.key(index)).filter((value) => value !== null && value.startsWith(base));
-  const read = (name) => {
-    if (!available())
-      return null;
-    const value = storage.getItem(key(`storage:${name}`));
+  const parse = (value) => {
     if (value === null)
       return null;
     try {
       return JSON.parse(value);
     } catch {
+      throw Object.assign(new Error("Stored value is not valid JSON"), { code: "STORAGE_CORRUPT" });
+    }
+  };
+  const encode = (value) => {
+    const json = JSON.stringify(value);
+    if (json === undefined)
+      throw Object.assign(new Error("Storage requires JSON values"), { code: "INVALID_ARGUMENT" });
+    return json;
+  };
+  const capture = () => ({ token, scope, revision });
+  const requireScope = (captured) => {
+    if (!available() || captured.token !== token || captured.scope !== scope || captured.revision !== revision)
+      throw scopeChanged();
+  };
+  const read = (name) => {
+    if (!available())
       return null;
+    const address = key(`storage:${name}`);
+    const waiting = pending.get(address);
+    return parse(waiting ? waiting.json : storage.getItem(address));
+  };
+  const setSync = (name, value) => {
+    if (!available())
+      return;
+    const captured = capture();
+    const address = key(`storage:${name}`);
+    const json = value === null || value === undefined ? null : encode(value);
+    const write = () => {
+      if (json === null)
+        storage.removeItem(address);
+      else
+        storage.setItem(address, json);
+    };
+    if (!lock) {
+      write();
+      return;
     }
+    const entry = { json };
+    pending.set(address, entry);
+    exclusive(() => {
+      requireScope(captured);
+      write();
+    }).catch((error) => {
+      if (error.code !== "STORAGE_SCOPE_CHANGED")
+        console.error("Browser storage write failed", error);
+    }).finally(() => {
+      if (pending.get(address) === entry)
+        pending.delete(address);
+    });
   };
   const accountChanged = async () => {
     const next = storage.getItem(tokenKey);
@@ -32,14 +97,17 @@ async function createBrowserStorage(options) {
     const previous = scope;
     const current = ++revision;
     transitioning = true;
-    for (const name of keys(`${prefix}account:${previous}:`))
-      storage.removeItem(name);
-    for (const name of options.accountKeys ?? []) {
-      if (name !== tokenKey)
-        storage.removeItem(name);
-    }
     token = next;
+    pending.clear();
     transition = (async () => {
+      await exclusive(() => {
+        for (const name of keys(`${prefix}account:${previous}:`))
+          storage.removeItem(name);
+        for (const name of options.accountKeys ?? []) {
+          if (name !== tokenKey)
+            storage.removeItem(name);
+        }
+      });
       const nextScope = next ? await options.hash(next) : "guest";
       if (current !== revision)
         return;
@@ -51,13 +119,11 @@ async function createBrowserStorage(options) {
   };
   const secureKey = (name) => name === "auth.token" ? tokenKey : key(`credential:${name}`);
   return {
+    atomicStorage: lock !== undefined,
     scope: () => scope,
     accountChanged,
     craft: {
-      storage: { getSync: read, setSync: (name, value) => {
-        if (available())
-          storage.setItem(key(`storage:${name}`), JSON.stringify(value));
-      } },
+      storage: { getSync: read, setSync },
       secureStorage: { getSync: (name) => name === "auth.token" || available() ? storage.getItem(secureKey(name)) : null },
       snapshots: {
         get: (name) => {
@@ -97,54 +163,94 @@ async function createBrowserStorage(options) {
       }
     },
     async call(module, method, args) {
+      const captured = capture();
+      const wasAvailable = available();
       await accountChanged();
       const name = String(args[0] ?? "");
       if (module === "Storage") {
-        if (method === "get")
-          return read(name);
-        if (method === "set") {
-          storage.setItem(key(`storage:${name}`), JSON.stringify(args[1]));
-          return true;
-        }
-        if (method === "remove") {
-          storage.removeItem(key(`storage:${name}`));
-          return true;
-        }
-        if (method === "keys")
-          return keys(key("storage:")).map((item) => item.slice(key("storage:").length));
-        if (method === "clear") {
-          for (const item of keys(key("storage:")))
-            storage.removeItem(item);
-          return true;
-        }
+        if (!wasAvailable)
+          throw scopeChanged();
+        return exclusive(() => {
+          requireScope(captured);
+          const address = `${prefix}account:${captured.scope}:storage:${name}`;
+          if (method === "get")
+            return parse(storage.getItem(address));
+          if (method === "set") {
+            storage.setItem(address, encode(args[1]));
+            return true;
+          }
+          if (method === "remove") {
+            storage.removeItem(address);
+            return true;
+          }
+          if (method === "keys")
+            return keys(key("storage:")).map((item) => item.slice(key("storage:").length));
+          if (method === "clear") {
+            for (const item of keys(key("storage:")))
+              storage.removeItem(item);
+            return true;
+          }
+          if (method === "compareAndSet" || method === "setIfAbsent") {
+            if (!lock)
+              throw Object.assign(new Error("Atomic browser storage requires Web Locks"), { code: method === "setIfAbsent" ? "STORAGE_SET_IF_ABSENT_UNSUPPORTED" : "STORAGE_COMPARE_AND_SET_UNSUPPORTED" });
+            const raw = storage.getItem(address);
+            if (method === "setIfAbsent") {
+              if (raw !== null)
+                return false;
+              storage.setItem(address, encode(args[1]));
+              return true;
+            }
+            if (raw === null || !jsonEqual(parse(raw), args[1]))
+              return false;
+            storage.setItem(address, encode(args[2]));
+            return true;
+          }
+          throw Object.assign(new Error(`Unsupported browser storage operation ${method}`), { code: "UNSUPPORTED" });
+        });
       }
       if (module === "SecureStorage") {
-        if (method === "get")
-          return storage.getItem(secureKey(name));
-        if (method === "set") {
-          storage.setItem(secureKey(name), String(args[1]));
-          if (name === "auth.token")
-            await accountChanged();
-          return true;
-        }
-        if (method === "remove") {
-          storage.removeItem(secureKey(name));
-          if (name === "auth.token")
-            await accountChanged();
-          return true;
-        }
-        if (method === "clear") {
-          for (const item of keys(key("credential:")))
-            storage.removeItem(item);
-          storage.removeItem(tokenKey);
+        if (!wasAvailable)
+          throw scopeChanged();
+        const result = await exclusive(() => {
+          requireScope(captured);
+          const address = name === "auth.token" ? tokenKey : `${prefix}account:${captured.scope}:credential:${name}`;
+          if (method === "get")
+            return storage.getItem(address);
+          if (method === "set") {
+            storage.setItem(address, String(args[1]));
+            return true;
+          }
+          if (method === "remove") {
+            storage.removeItem(address);
+            return true;
+          }
+          if (method === "clear") {
+            for (const item of keys(`${prefix}account:${captured.scope}:credential:`))
+              storage.removeItem(item);
+            storage.removeItem(tokenKey);
+            return true;
+          }
+          throw Object.assign(new Error(`Unsupported browser storage operation ${module}.${method}`), { code: "UNSUPPORTED" });
+        });
+        if (method === "clear" || name === "auth.token" && (method === "set" || method === "remove"))
           await accountChanged();
-          return true;
-        }
+        return result;
       }
       throw Object.assign(new Error(`Unsupported browser storage operation ${module}.${method}`), { code: "UNSUPPORTED" });
     }
   };
 }
+function jsonEqual(left, right) {
+  if (left === right)
+    return true;
+  if (Array.isArray(left) || Array.isArray(right))
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => jsonEqual(value, right[index]));
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+    return false;
+  const a = left;
+  const b = right;
+  return Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((key) => Object.prototype.hasOwnProperty.call(b, key) && jsonEqual(a[key], b[key]));
+}
 
 // src/browser/dialogs.ts
 function showBrowserDialog(kind, options, signal) {
@@ -342,6 +448,10 @@ async function createBrowserPlatform(options = {}) {
   };
   window.addEventListener("storage", storageEvent);
   const capabilityNames = ["storage", "secureStorage", "lifecycle", "dialog", "browser", "linking", "files", "share", "device"];
+  if (persistence.atomicStorage)
+    capabilityNames.push("storageCompareAndSet", "storageSetIfAbsent");
+  if (typeof globalThis.crypto?.randomUUID === "function" || typeof globalThis.crypto?.getRandomValues === "function")
+    capabilityNames.push("crypto");
   if (navigator.clipboard)
     capabilityNames.push("clipboard");
   if ("vibrate" in navigator)
@@ -399,6 +509,8 @@ async function createBrowserPlatform(options = {}) {
           await resetAccount();
         return answer;
       }
+      if (module === "Crypto" && method === "randomUUID")
+        return secureUUID();
       if (module === "Dialog")
         return showBrowserDialog(method, first, signal);
       if (module === "Device" && method === "getInfo")

package/dist/cli.js

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

package/dist/index.cjs

@@ -77,6 +77,7 @@ __export(exports_src, {
   styles: () => styles,
   style: () => style,
   storeKit: () => storeKit,
+  storage: () => storage2,
   stat: () => stat,
   startupTask: () => startupTask,
   stageManager: () => stageManager,
@@ -309,7 +310,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.237";
+var version = "0.0.241";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -5222,6 +5223,92 @@ var secureStorage = {
     Object.keys(localStorage).filter((k) => k.startsWith("secure_")).forEach((k) => localStorage.removeItem(k));
   }
 };
+function storageHost(method) {
+  const host2 = getCraftRoot()?.storage;
+  if (typeof host2?.[method] !== "function")
+    throw Object.assign(new Error("This host does not provide native storage"), { code: "STORAGE_UNSUPPORTED" });
+  return host2;
+}
+var storage2 = {
+  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 (!storage2.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 (!storage2.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,
@@ -5231,6 +5318,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) {
@@ -5279,9 +5368,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 = {
@@ -5297,24 +5389,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;
@@ -5323,16 +5418,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];
   }
 };
@@ -5454,6 +5563,11 @@ function onCraftEvent(eventName, callback) {
   globalThis.addEventListener(eventName, listener);
   return () => globalThis.removeEventListener(eventName, listener);
 }
+function getCraftRoot() {
+  if (typeof window === "undefined")
+    return;
+  return window.craft;
+}
 function detectPlatform2() {
   if (typeof window === "undefined")
     return "linux";