@glassly/engine 0.1.0-dev.0

package/src/utils/miniappGlobals.ts

@@ -0,0 +1,259 @@
+/**
+ * miniappGlobals — shared builder for the window.Glassly globals injected
+ * into every miniapp WebView.
+ *
+ * Miniapps run on-device, and LocalMiniappView is the single injection path;
+ * this util is the one place that builds the globals so every WebView gets the
+ * same API surface.
+ */
+
+import {Dimensions, Platform} from "react-native"
+
+export interface MiniappSafeArea {
+  top: number
+  bottom: number
+  left: number
+  right: number
+}
+
+export interface CapsuleMenuRect {
+  top: number
+  right: number
+  bottom: number
+  left: number
+  width: number
+  height: number
+}
+
+/**
+ * The capsule menu bounding rect in the WebView's own coordinate space.
+ *
+ * Keep in sync with CapsuleMenu.tsx:
+ *   - CapsuleButton height ≈ h-7.5 (30px), width ≈ 73px
+ *   - Positioned at right-2 (8px), top = theme.spacing.s2 (8px) below insets.top
+ */
+const CAPSULE_MENU_HEIGHT = 30
+const CAPSULE_MENU_WIDTH = 73
+const CAPSULE_MENU_PADDING = 8
+
+/**
+ * @param topInsetOffset  extra top offset to add when the WebView container does
+ *   NOT already pad by the safe-area inset (i.e. WebView fills edge-to-edge under
+ *   the status bar). Pass `insets.top` in that case, or 0 when the container
+ *   already applies top padding.
+ */
+export function getCapsuleMenuRect(topInsetOffset = 0): CapsuleMenuRect {
+  const screenWidth = Dimensions.get("window").width
+  const top = topInsetOffset + CAPSULE_MENU_PADDING
+  return {
+    top,
+    right: CAPSULE_MENU_PADDING,
+    bottom: top + CAPSULE_MENU_HEIGHT,
+    left: screenWidth - CAPSULE_MENU_PADDING - CAPSULE_MENU_WIDTH,
+    width: CAPSULE_MENU_WIDTH,
+    height: CAPSULE_MENU_HEIGHT,
+  }
+}
+
+export type MiniappColorScheme = "light" | "dark"
+
+export interface BuildMiniappGlobalsOptions {
+  packageName?: string
+  capabilities?: string[]
+  miniappLocal?: boolean
+  miniappDeveloperMode?: boolean
+  safeAreaInsets: MiniappSafeArea
+  /**
+   * True when the WebView container renders edge-to-edge (no top padding for
+   * the status bar). In that case the capsule menu rect needs to shift down by
+   * the top inset so its coords match where it's actually drawn on screen.
+   */
+  webviewFillsStatusBar?: boolean
+  /** Current host color scheme. Miniapps may follow this to match the phone. */
+  colorScheme?: MiniappColorScheme
+}
+
+/**
+ * Returns the JS string to inject into a miniapp WebView before its content
+ * loads. Sets window.Glassly with the standard fields miniapps read:
+ *
+ *   window.Glassly = {
+ *     platform, packageName?, capabilities, safeAreaInsets, capsuleMenu,
+ *     miniappLocal?, miniappDeveloperMode?
+ *   }
+ *
+ * Also defines a stub window.receiveNativeMessage so the miniapp can safely
+ * assign to it before the native bridge wires in.
+ */
+export function buildMiniappGlobalsScript(opts: BuildMiniappGlobalsOptions): string {
+  const capsuleTopOffset = opts.webviewFillsStatusBar ? opts.safeAreaInsets.top : 0
+  const globals: Record<string, unknown> = {
+    platform: Platform.OS,
+    capabilities: opts.capabilities ?? ["share", "open_url", "copy_clipboard", "download"],
+    safeAreaInsets: opts.safeAreaInsets,
+    capsuleMenu: getCapsuleMenuRect(capsuleTopOffset),
+  }
+  if (opts.packageName) globals.packageName = opts.packageName
+  if (opts.miniappLocal) globals.miniappLocal = true
+  if (opts.miniappDeveloperMode) globals.miniappDeveloperMode = true
+  if (opts.colorScheme) globals.colorScheme = opts.colorScheme
+
+  // CSS custom properties that mirror the capsule menu / safe-area data.
+  // Miniapp CSS (or Tailwind arbitrary values) can read these without
+  // touching JS: e.g. `style="margin-top: var(--glassly-capsule-top)"`.
+  const capsule = globals.capsuleMenu as CapsuleMenuRect
+  const insets = opts.safeAreaInsets
+  const capsuleCenter = capsule.top + capsule.height / 2
+  const cssVars: Record<string, string> = {
+    "--glassly-safe-top": `${insets.top}px`,
+    "--glassly-safe-bottom": `${insets.bottom}px`,
+    "--glassly-safe-left": `${insets.left}px`,
+    "--glassly-safe-right": `${insets.right}px`,
+    "--glassly-capsule-top": `${capsule.top}px`,
+    "--glassly-capsule-bottom": `${capsule.bottom}px`,
+    "--glassly-capsule-left": `${capsule.left}px`,
+    "--glassly-capsule-right": `${capsule.right}px`,
+    "--glassly-capsule-width": `${capsule.width}px`,
+    "--glassly-capsule-height": `${capsule.height}px`,
+    "--glassly-capsule-center-y": `${capsuleCenter}px`,
+    // Right-side gutter to reserve so content doesn't slide under the
+    // capsule: capsule width + 16px breathing room.
+    "--glassly-capsule-gutter": `${capsule.width + 16}px`,
+  }
+  const cssVarsBlock = Object.entries(cssVars)
+    .map(([k, v]) => `${k}: ${v};`)
+    .join(" ")
+
+  // Console-tap shim: wrap console.log/warn/error/info/debug so each call
+  // also forwards a `dev_log` envelope back to the phone via
+  // ReactNativeWebView.postMessage. Dev mode forwards to the laptop's
+  // `glassly-miniapp dev` terminal; non-dev mode falls back to the React
+  // Native log stream (Metro / Xcode console / adb logcat) so installed-
+  // miniapp errors are still inspectable when there's no laptop sidecar.
+  //
+  // Also tap window.onerror and window.onunhandledrejection so synchronous
+  // throws and unhandled promise rejections surface even when the bundle
+  // never gets a chance to call console.error itself.
+  const consoleTapBlock = `
+    (function() {
+      try {
+        var levels = ["log", "warn", "error", "info", "debug"];
+        var seen = new WeakSet();
+        function safeSerialize(arg) {
+          if (arg instanceof Error) return {__error: true, message: arg.message, stack: arg.stack};
+          if (arg === null || typeof arg !== "object") return arg;
+          try {
+            return JSON.parse(JSON.stringify(arg, function(k, v) {
+              if (v !== null && typeof v === "object") {
+                if (seen.has(v)) return "[Circular]";
+                seen.add(v);
+              }
+              return v;
+            }));
+          } catch (e) {
+            try { return String(arg); } catch (_) { return "[unserializable]"; }
+          }
+        }
+        levels.forEach(function(level) {
+          var original = console[level];
+          if (typeof original !== "function") return;
+          console[level] = function() {
+            try { original.apply(console, arguments); } catch (_) {}
+            try {
+              var args = Array.prototype.slice.call(arguments).map(safeSerialize);
+              if (window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === "function") {
+                window.ReactNativeWebView.postMessage(JSON.stringify({
+                  payload: {
+                    type: "dev_log",
+                    level: level,
+                    args: args,
+                    packageName: (window.Glassly && window.Glassly.packageName) || null,
+                    timestamp: Date.now()
+                  }
+                }));
+              }
+            } catch (_) { /* swallow */ }
+          };
+        });
+      } catch (_) { /* ignore */ }
+
+      // Surface synchronous errors and unhandled promise rejections via the
+      // same dev_log channel — many bundle-startup crashes never get to call
+      // console.error themselves.
+      try {
+        window.addEventListener("error", function(e) {
+          try {
+            if (window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === "function") {
+              window.ReactNativeWebView.postMessage(JSON.stringify({
+                payload: {
+                  type: "dev_log",
+                  level: "error",
+                  args: ["[window.error] " + (e.message || "unknown"), {filename: e.filename, lineno: e.lineno, colno: e.colno, stack: e.error && e.error.stack}],
+                  packageName: (window.Glassly && window.Glassly.packageName) || null,
+                  timestamp: Date.now()
+                }
+              }));
+            }
+          } catch (_) {}
+        });
+        window.addEventListener("unhandledrejection", function(e) {
+          try {
+            if (window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === "function") {
+              var reason = e.reason;
+              var serialized = reason instanceof Error
+                ? {__error: true, message: reason.message, stack: reason.stack}
+                : (typeof reason === "object" ? JSON.stringify(reason) : String(reason));
+              window.ReactNativeWebView.postMessage(JSON.stringify({
+                payload: {
+                  type: "dev_log",
+                  level: "error",
+                  args: ["[unhandledrejection]", serialized],
+                  packageName: (window.Glassly && window.Glassly.packageName) || null,
+                  timestamp: Date.now()
+                }
+              }));
+            }
+          } catch (_) {}
+        });
+      } catch (_) {}
+    })();
+  `
+
+  // Lock zoom so miniapps feel like apps, not pages: force a non-scalable
+  // viewport meta (overriding whatever the miniapp shipped) and disable
+  // double-tap-zoom via CSS. Re-applies on DOMContentLoaded in case the
+  // miniapp re-writes <head> during boot.
+  return `
+    window.Glassly = ${JSON.stringify(globals)};
+    window.receiveNativeMessage = window.receiveNativeMessage || function() {};
+    (function() {
+      try {
+        var styleEl = document.createElement("style");
+        styleEl.setAttribute("data-glassly-injected", "1");
+        styleEl.textContent =
+          ":root { ${cssVarsBlock} }" +
+          "html, body { touch-action: manipulation; -ms-content-zooming: none; }";
+        (document.head || document.documentElement).appendChild(styleEl);
+      } catch (e) { /* ignore */ }
+
+      function lockViewport() {
+        try {
+          var content = "width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no, viewport-fit=cover";
+          var existing = document.querySelector('meta[name="viewport"]');
+          if (existing) {
+            existing.setAttribute("content", content);
+          } else {
+            var meta = document.createElement("meta");
+            meta.setAttribute("name", "viewport");
+            meta.setAttribute("content", content);
+            (document.head || document.documentElement).appendChild(meta);
+          }
+        } catch (e) { /* ignore */ }
+      }
+      lockViewport();
+      document.addEventListener("DOMContentLoaded", lockViewport);
+    })();
+    ${consoleTapBlock}
+    true;
+  `
+}

package/src/utils/permissions/MediaLibraryPermissions.ts

@@ -0,0 +1,161 @@
+import {Platform} from "react-native"
+import {check, request, PERMISSIONS, RESULTS} from "react-native-permissions"
+
+import CrustModule from "@glassly/crust"
+
+import {deriveGalleryDisplayName} from "./galleryDisplayName"
+
+export interface MediaLibrarySaveReceipt {
+  success: boolean
+  platform: "ios" | "android" | "unknown"
+  uri?: string
+  identifier?: string
+  error?: string
+}
+
+/**
+ * MediaLibraryPermissions - Handles save-only permissions for camera roll
+ *
+ * Platform behavior:
+ * - iOS: Uses PHOTO_LIBRARY (read-write) so we can manage the Glassly album
+ * - Android 10+ (API 29+): No permission needed to save your own files to MediaStore
+ * - Android 9-: Uses WRITE_EXTERNAL_STORAGE (legacy)
+ */
+export class MediaLibraryPermissions {
+  /** Limited iOS access cannot see historical, unselected assets for duplicate reconciliation. */
+  static async hasLimitedAccess(): Promise<boolean> {
+    if (Platform.OS !== "ios") return false
+    try {
+      return (await check(PERMISSIONS.IOS.PHOTO_LIBRARY)) === RESULTS.LIMITED
+    } catch (error) {
+      console.error("[MediaLibrary] Error checking limited-library access:", error)
+      // Conservatively block legacy reconciliation when the scope cannot be verified.
+      return true
+    }
+  }
+
+  /**
+   * Check if we have permission to save to the camera roll
+   * Note: On Android 10+, this always returns true since no permission is needed
+   */
+  static async checkPermission(): Promise<boolean> {
+    try {
+      if (Platform.OS === "ios") {
+        const status = await check(PERMISSIONS.IOS.PHOTO_LIBRARY)
+        return status === RESULTS.GRANTED || status === RESULTS.LIMITED
+      }
+
+      if (Platform.OS === "android") {
+        // Android 10+ (API 29+): No permission needed to save your own files
+        if (Platform.Version >= 29) {
+          return true
+        }
+        // Android 9 and below: Check legacy write permission
+        const status = await check(PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE)
+        return status === RESULTS.GRANTED
+      }
+
+      return false
+    } catch (error) {
+      console.error("[MediaLibrary] Error checking permission:", error)
+      // On error, assume we can try (Android 10+ doesn't need permission anyway)
+      return Platform.OS === "android" && Platform.Version >= 29
+    }
+  }
+
+  /**
+   * Request permission to save to the camera roll
+   * Note: On Android 10+, this always returns true since no permission is needed
+   */
+  static async requestPermission(): Promise<boolean> {
+    try {
+      if (Platform.OS === "ios") {
+        const status = await request(PERMISSIONS.IOS.PHOTO_LIBRARY)
+        return status === RESULTS.GRANTED || status === RESULTS.LIMITED
+      }
+
+      if (Platform.OS === "android") {
+        // Android 10+ (API 29+): No permission needed to save your own files
+        if (Platform.Version >= 29) {
+          return true
+        }
+        // Android 9 and below: Request legacy write permission
+        const status = await request(PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE)
+        return status === RESULTS.GRANTED
+      }
+
+      return false
+    } catch (error) {
+      console.error("[MediaLibrary] Error requesting permission:", error)
+      // On error, assume we can try (Android 10+ doesn't need permission anyway)
+      return Platform.OS === "android" && Platform.Version >= 29
+    }
+  }
+
+  /**
+   * Save a file to the photo library in a glasses-specific location (Glassly album on iOS;
+   * Pictures/Glassly or Movies/Glassly on Android 10+).
+   * On Android 10+, this works without any permission.
+   *
+   * IMPORTANT: This method sets the DATE_TAKEN (Android) or creation date (iOS)
+   * metadata to the original capture time, so gallery apps show the correct date.
+   * Also saves files in chronological order for proper "date added" ordering.
+   *
+   * @param filePath - Path to the file to save
+   * @param creationTime - Optional creation/capture time in milliseconds (Unix timestamp)
+   */
+  static async saveToLibrary(filePath: string, creationTime?: number): Promise<boolean> {
+    return (await this.saveToLibraryWithReceipt(filePath, creationTime)).success
+  }
+
+  /** Save and return the durable MediaStore/PhotoKit identifier used as the export receipt. */
+  static async saveToLibraryWithReceipt(filePath: string, creationTime?: number): Promise<MediaLibrarySaveReceipt> {
+    const platform = Platform.OS === "ios" || Platform.OS === "android" ? Platform.OS : "unknown"
+    try {
+      // On Android 10+, we can save without permission
+      // On iOS and older Android, check permission first
+      if (!(Platform.OS === "android" && Platform.Version >= 29)) {
+        const hasPermission = await this.checkPermission()
+        if (!hasPermission) {
+          // Try requesting permission one more time
+          const granted = await this.requestPermission()
+          if (!granted) {
+            console.warn("[MediaLibrary] No permission to save to library - photos saved to app storage only")
+            return {success: false, platform, error: "permission denied"}
+          }
+        }
+      }
+
+      // Remove file:// prefix if present
+      const cleanPath = filePath.replace("file://", "")
+      const displayName = deriveGalleryDisplayName(cleanPath)
+
+      // Use native module to save with proper DATE_TAKEN / creation date metadata
+      // This ensures gallery apps show the correct capture date, not the sync date
+      const result = await CrustModule.saveToGalleryWithDate(cleanPath, creationTime, displayName)
+
+      if (result.success) {
+        if (creationTime) {
+          const captureDate = new Date(creationTime)
+          console.log(
+            `[MediaLibrary] Saved to camera roll with DATE_TAKEN: ${cleanPath} (captured: ${captureDate.toISOString()})`,
+          )
+        } else {
+          console.log(`[MediaLibrary] Saved to camera roll: ${cleanPath}`)
+        }
+        return {
+          success: true,
+          platform,
+          uri: result.uri,
+          identifier: result.identifier,
+        }
+      } else {
+        console.error(`[MediaLibrary] Failed to save to library: ${result.error}`)
+        return {success: false, platform, error: result.error || "native export failed"}
+      }
+    } catch (error) {
+      console.error("[MediaLibrary] Error saving to library:", error)
+      return {success: false, platform, error: error instanceof Error ? error.message : String(error)}
+    }
+  }
+}

package/src/utils/permissions/galleryDisplayName.ts

@@ -0,0 +1,28 @@
+const CAPTURE_FOLDER_PATTERN = /^(IMG|VID)_/
+
+/**
+ * Derive a unique MediaStore display name for camera-roll saves.
+ *
+ * Capture downloads use folder layout `IMG_xxx/base.jpg` (or `VID_xxx/base.mp4`).
+ * Using the leaf filename (`base.jpg`) causes MediaStore collisions on Android.
+ */
+export function deriveGalleryDisplayName(filePath: string): string {
+  const cleanPath = filePath.replace("file://", "")
+  const lastSlash = cleanPath.lastIndexOf("/")
+  if (lastSlash < 0) {
+    return cleanPath
+  }
+
+  const fileName = cleanPath.substring(lastSlash + 1)
+  const parentDir = cleanPath.substring(0, lastSlash)
+  const parentSlash = parentDir.lastIndexOf("/")
+  const parentName = parentSlash < 0 ? parentDir : parentDir.substring(parentSlash + 1)
+
+  if (!CAPTURE_FOLDER_PATTERN.test(parentName)) {
+    return fileName
+  }
+
+  const isVideo = /\.(mp4|mov|m4v|avi)(\.|$)/i.test(fileName)
+  const extension = isVideo ? "mp4" : "jpg"
+  return `${parentName}.${extension}`
+}

package/src/utils/speakerEmbedding.ts

@@ -0,0 +1,58 @@
+/**
+ * Speaker-embedding vector math shared by the profile store (centroids) and
+ * the enrollment flow (consistency checks). Embeddings travel as base64
+ * Float32Array little-endian — the same encoding the native SpeakerIdEngine
+ * produces and consumes over the bridge.
+ */
+import {Buffer} from "buffer"
+
+export function embeddingToBase64(embedding: Float32Array): string {
+  return Buffer.from(new Uint8Array(embedding.buffer, embedding.byteOffset, embedding.byteLength)).toString("base64")
+}
+
+export function embeddingFromBase64(base64: string): Float32Array {
+  const bytes = Buffer.from(base64, "base64")
+  // Copy into a fresh buffer: Buffer views can be offset into a shared pool,
+  // and Float32Array requires 4-byte alignment.
+  const copy = new Uint8Array(bytes.length)
+  copy.set(bytes)
+  return new Float32Array(copy.buffer, 0, Math.floor(copy.length / 4))
+}
+
+export function l2Normalize(v: Float32Array): Float32Array {
+  let sum = 0
+  for (let i = 0; i < v.length; i++) sum += v[i] * v[i]
+  const norm = Math.sqrt(sum)
+  if (norm === 0) return new Float32Array(v.length)
+  const out = new Float32Array(v.length)
+  for (let i = 0; i < v.length; i++) out[i] = v[i] / norm
+  return out
+}
+
+/** Cosine similarity. Returns 0 for mismatched dims or zero vectors. */
+export function cosineSimilarity(a: Float32Array, b: Float32Array): number {
+  if (a.length !== b.length || a.length === 0) return 0
+  let dot = 0
+  let na = 0
+  let nb = 0
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i]
+    na += a[i] * a[i]
+    nb += b[i] * b[i]
+  }
+  if (na === 0 || nb === 0) return 0
+  return dot / (Math.sqrt(na) * Math.sqrt(nb))
+}
+
+/** Element-wise mean of same-dim vectors, L2-normalized (profile centroid). */
+export function meanEmbedding(vectors: Float32Array[]): Float32Array {
+  if (vectors.length === 0) return new Float32Array(0)
+  const dim = vectors[0].length
+  const sum = new Float32Array(dim)
+  for (const v of vectors) {
+    if (v.length !== dim) continue
+    for (let i = 0; i < dim; i++) sum[i] += v[i]
+  }
+  for (let i = 0; i < dim; i++) sum[i] /= vectors.length
+  return l2Normalize(sum)
+}

package/src/utils/storage/index.ts

@@ -0,0 +1,2 @@
+export {storage, StorageValueNotFoundError} from "./storage"
+export {printDirectory} from "./zip"

package/src/utils/storage/storage.ts

@@ -0,0 +1,101 @@
+// @ts-nocheck
+import {createMMKV, type MMKV} from "react-native-mmkv"
+import {result as Res, Result} from "typesafe-ts"
+
+/**
+ * Thrown by load() when the key has no stored value. Callers that treat a
+ * missing key as an expected state (e.g. first run) should branch on
+ * `instanceof StorageValueNotFoundError` rather than matching the message.
+ */
+export class StorageValueNotFoundError extends Error {
+  constructor(key: string) {
+    super(`No value found for ${key}`)
+    this.name = "StorageValueNotFoundError"
+  }
+}
+
+class MMKVStorage {
+  private _store?: MMKV
+
+  private get store(): MMKV {
+    if (!this._store) {
+      this._store = createMMKV()
+    }
+    return this._store
+  }
+
+  public save(key: string, value: unknown): Result<void, Error> {
+    return this.saveString(key, JSON.stringify(value))
+  }
+
+  public load<T>(key: string): Result<T, Error> {
+    return Res.try(() => {
+      const loadedString = this.store.getString(key) ?? ""
+      if (loadedString === "") {
+        throw new StorageValueNotFoundError(key)
+      }
+      const value = JSON.parse(loadedString) as T
+      return value
+    })
+  }
+
+  private saveString(key: string, value: string): Result<void, Error> {
+    this.store.set(key, value)
+    return Res.ok(undefined)
+  }
+
+  public getAllKeys(): string[] {
+    return this.store.getAllKeys()
+  }
+
+  public removeMultiple(keys: string[]): Result<void, Error> {
+    let success = true
+    for (const key of keys) {
+      const res = this.store.remove(key)
+      if (!res) {
+        success = false
+      }
+    }
+    if (!success) {
+      console.error("Failed to remove one or more keys")
+      return Res.error(new Error("Failed to remove one or more keys"))
+    }
+    return Res.ok(undefined)
+  }
+
+  public loadSubKeys(key: string): Result<Record<string, unknown>, Error> {
+    return Res.try(() => {
+      // return the key value pair of any keys that start with the given key and contain a colon:
+      const keys = this.store.getAllKeys()
+
+      const subKeys = keys.filter((k) => k.startsWith(key) && k.includes(":"))
+
+      if (subKeys.length === 0) {
+        throw new Error(`No subkeys found for ${key}`)
+      }
+
+      let subKeysObject: Record<string, unknown> = {}
+
+      for (const subKey of subKeys) {
+        const res = this.load(subKey)
+        if (res.is_ok()) {
+          subKeysObject[subKey] = res.value
+        }
+      }
+
+      return subKeysObject
+    })
+  }
+
+  public remove(key: string): Result<void, Error> {
+    this.store.remove(key)
+    return Res.ok(undefined)
+  }
+
+  public clearAll(): Result<void, Error> {
+    this.store.clearAll()
+    return Res.ok(undefined)
+  }
+}
+
+export const storage = new MMKVStorage()

package/src/utils/storage/zip.ts

@@ -0,0 +1,13 @@
+import {Directory} from "expo-file-system"
+
+export function printDirectory(directory: Directory, indent: number = 0) {
+  console.log(`${" ".repeat(indent)} + ${directory.name}`)
+  const contents = directory.list()
+  for (const item of contents) {
+    if (item instanceof Directory) {
+      printDirectory(item, indent + 2)
+    } else {
+      console.log(`${" ".repeat(indent + 2)} - ${item.name} (${item.size} bytes)`)
+    }
+  }
+}

package/src/utils/timers/index.ts

@@ -0,0 +1,2 @@
+import {BgTimer, throttle, debounce} from "./timers"
+export {BgTimer, throttle, debounce}