@oxy.so/core 1.0.0

package/src/mixins/OxyServices.identityBackup.ts

@@ -0,0 +1,250 @@
+/**
+ * Encrypted off-device identity backup mixin (b3 Feature 1).
+ *
+ * Lets a self-custody identity store an ENCRYPTED copy of its key off-device so
+ * a lost/wiped device can be recovered from the recovery phrase alone — while the
+ * platform never sees the phrase, the derived key, or the plaintext private key.
+ *
+ * Key schedule (from the recovery phrase; see
+ * {@link RecoveryPhraseService.deriveBackupMaterial}):
+ *   seed      = mnemonicToSeed(phrase)                          // 64 bytes, UNCHANGED
+ *   backupKey = HKDF(seed, 'oxy-identity-backup-v1', 'oxy-backup-encryption-key')
+ *   lookupId  = HKDF(seed, 'oxy-identity-backup-v1', 'oxy-backup-lookup-id')   // hex
+ *
+ * The two derivations require the FULL seed, so a device compromise that leaks
+ * only the raw 32-byte private key can neither locate nor decrypt the backup.
+ *
+ * Wire shapes come from `@oxy.so/contracts` (`EncryptedBackupEnvelope`,
+ * `BackupUploadRequest`, `BackupStatusResponse`) — the API validates its
+ * request/response against the same schemas, so producer and consumer cannot
+ * drift.
+ *
+ * Encryption/derivation are cross-platform (pure `@noble/*`), but persisting a
+ * restored key is NATIVE-ONLY: `restoreFromEncryptedBackup` ends in
+ * `KeyManager.importKeyPair`, which throws on web (SecureStore does not exist
+ * there) — decryption still succeeds, only the local write is native-only.
+ */
+import type {
+  BackupStatusResponse,
+  BackupUploadRequest,
+  EncryptedBackupEnvelope,
+} from '@oxy.so/contracts';
+import type { OxyServicesBase } from '../OxyServices.base';
+import { KeyManager, IdentityAlreadyExistsError } from '../crypto/keyManager';
+import { RecoveryPhraseService, BACKUP_KDF_ENCRYPTION_INFO } from '../crypto/recoveryPhrase';
+import { encryptAead, decryptAead } from '../crypto/aead';
+
+/** Envelope/KDF version — bump only on a breaking scheme change. */
+const BACKUP_ENVELOPE_VERSION = 1;
+/** The AEAD the backup is sealed with. Pinned so a mismatched decryptor fails loudly. */
+const BACKUP_ALGORITHM = 'xchacha20poly1305' as const;
+/**
+ * Length (hex chars) of the public-key HINT stored/echoed with a backup — enough
+ * to let the owner recognise WHICH identity a backup belongs to, but only a
+ * prefix (the full key is public anyway; a prefix keeps the record minimal).
+ */
+const PUBLIC_KEY_HINT_LENGTH = 16;
+
+/** The decrypted backup payload. */
+interface BackupPayload {
+  privateKey: string;
+  publicKey: string;
+  createdAt: string;
+}
+
+/** Encode bytes as lowercase hex (cross-platform, no Buffer dependency). */
+function toHex(bytes: Uint8Array): string {
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 1) {
+    out += bytes[i].toString(16).padStart(2, '0');
+  }
+  return out;
+}
+
+/** Decode a lowercase/uppercase hex string to bytes. Throws on malformed input. */
+function fromHex(hex: string): Uint8Array {
+  if (hex.length % 2 !== 0 || /[^0-9a-fA-F]/.test(hex)) {
+    throw new Error('Malformed hex in encrypted backup envelope.');
+  }
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i += 1) {
+    out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+
+/**
+ * The AEAD associated data binds the ciphertext to its `{version, publicKeyHint}`
+ * context: the exact bytes must be reproduced at decrypt time, so a mismatched
+ * version or hint (e.g. an envelope re-stamped by a tamperer) fails the
+ * Poly1305 check. Deterministic: both sides build the SAME object literal, so
+ * `JSON.stringify` yields identical bytes.
+ */
+function buildBackupAad(version: number, publicKeyHint: string): Uint8Array {
+  return new TextEncoder().encode(JSON.stringify({ version, publicKeyHint }));
+}
+
+export function OxyServicesIdentityBackupMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+
+    /**
+     * Derive the backup key material from the recovery phrase, encrypt the
+     * identity's `{privateKey, publicKey, createdAt}` with it, and upload the
+     * ciphertext + raw `lookupId` (`POST /identity/backup`, bearer). The server
+     * stores only `sha256(lookupId)` + the ciphertext. Idempotent per user: a
+     * re-upload REPLACES the prior backup (upsert by user id).
+     *
+     * The identity is derived from the PHRASE (not read from SecureStore), so
+     * this works cross-platform and does not require an on-device key.
+     *
+     * @param phrase - The identity's BIP-39 recovery phrase.
+     * @returns The post-write backup status (`{ exists: true, publicKeyHint, createdAt }`).
+     */
+    async createEncryptedBackup(phrase: string): Promise<BackupStatusResponse> {
+      try {
+        const { backupKey, lookupId } = await RecoveryPhraseService.deriveBackupMaterial(phrase);
+        const privateKey = await RecoveryPhraseService.derivePrivateKeyFromPhrase(phrase);
+        const publicKey = KeyManager.derivePublicKey(privateKey);
+        const createdAt = new Date().toISOString();
+        const publicKeyHint = publicKey.slice(0, PUBLIC_KEY_HINT_LENGTH);
+
+        const payload: BackupPayload = { privateKey, publicKey, createdAt };
+        const plaintext = new TextEncoder().encode(JSON.stringify(payload));
+        const aad = buildBackupAad(BACKUP_ENVELOPE_VERSION, publicKeyHint);
+        const { nonce, ciphertext } = encryptAead(backupKey, plaintext, aad);
+
+        const body: BackupUploadRequest = {
+          version: BACKUP_ENVELOPE_VERSION,
+          algorithm: BACKUP_ALGORITHM,
+          kdfInfo: BACKUP_KDF_ENCRYPTION_INFO,
+          nonce: toHex(nonce),
+          ciphertext: toHex(ciphertext),
+          publicKeyHint,
+          createdAt,
+          lookupId,
+        };
+
+        return await this.makeRequest<BackupStatusResponse>(
+          'POST',
+          '/identity/backup',
+          body,
+          { cache: false },
+        );
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Whether the authenticated user has a stored encrypted backup, plus the
+     * non-sensitive hint + timestamp when one exists (`GET /identity/backup/status`,
+     * bearer). Returns no ciphertext and no locator.
+     */
+    async getBackupStatus(): Promise<BackupStatusResponse> {
+      try {
+        return await this.makeRequest<BackupStatusResponse>(
+          'GET',
+          '/identity/backup/status',
+          undefined,
+          { cache: false },
+        );
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Delete the authenticated user's stored backup (`DELETE /identity/backup`,
+     * bearer). Idempotent — deleting a non-existent backup still succeeds.
+     */
+    async deleteBackup(): Promise<{ success: boolean }> {
+      try {
+        return await this.makeRequest<{ success: boolean }>(
+          'DELETE',
+          '/identity/backup',
+          undefined,
+          { cache: false },
+        );
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Restore an identity from its encrypted off-device backup using ONLY the
+     * recovery phrase: re-derive `{backupKey, lookupId}`, fetch the envelope by
+     * `lookupId` (`GET /identity/backup/:lookupId`, PUBLIC — the 256-bit locator
+     * is the protection), decrypt + authenticate locally, then persist the key.
+     *
+     * NATIVE-ONLY persistence: `KeyManager.importKeyPair` throws on web. It also
+     * refuses to clobber a DIFFERENT existing on-device identity unless
+     * `overwrite: true` — the {@link import('../crypto/keyManager').IdentityAlreadyExistsError}
+     * propagates to the caller (never swallowed) so the UI can confirm before
+     * overwriting.
+     *
+     * @param phrase - The identity's BIP-39 recovery phrase.
+     * @param options.overwrite - Replace a different existing on-device identity.
+     * @returns The restored identity's public key.
+     * @throws if the phrase is invalid, no backup exists (404), the ciphertext
+     *   fails authentication (tamper), or an existing identity blocks the import.
+     */
+    async restoreFromEncryptedBackup(
+      phrase: string,
+      options?: { overwrite?: boolean },
+    ): Promise<string> {
+      try {
+        const { backupKey, lookupId } = await RecoveryPhraseService.deriveBackupMaterial(phrase);
+
+        const envelope = await this.makeRequest<EncryptedBackupEnvelope>(
+          'GET',
+          `/identity/backup/${encodeURIComponent(lookupId)}`,
+          undefined,
+          { cache: false },
+        );
+
+        if (envelope.algorithm !== BACKUP_ALGORITHM) {
+          throw new Error(`Unsupported backup algorithm: ${envelope.algorithm}`);
+        }
+
+        const aad = buildBackupAad(envelope.version, envelope.publicKeyHint);
+        const plaintext = decryptAead(
+          backupKey,
+          fromHex(envelope.nonce),
+          fromHex(envelope.ciphertext),
+          aad,
+        );
+        const payload = JSON.parse(new TextDecoder().decode(plaintext)) as BackupPayload;
+
+        if (!payload.privateKey || !payload.publicKey) {
+          throw new Error('Backup payload is missing key material');
+        }
+
+        const derivedFromPhrase = await RecoveryPhraseService.derivePublicKeyFromPhrase(phrase);
+        const derivedFromPrivate = KeyManager.derivePublicKey(payload.privateKey);
+        const phrasePk = derivedFromPhrase.toLowerCase();
+        const payloadPk = payload.publicKey.toLowerCase();
+        const privatePk = derivedFromPrivate.toLowerCase();
+        if (phrasePk !== payloadPk || privatePk !== payloadPk) {
+          throw new Error('Backup payload does not match the recovery phrase');
+        }
+
+        // Persist the recovered key. Native-only; refuses to clobber a different
+        // identity unless overwrite — the IdentityAlreadyExistsError propagates.
+        return await KeyManager.importKeyPair(payload.privateKey, {
+          overwrite: options?.overwrite === true,
+        });
+      } catch (error) {
+        // Preserve the typed "an identity already exists" signal so the caller
+        // can prompt for overwrite. `handleError` would flatten it to a generic
+        // Error and lose that discrimination.
+        if (error instanceof IdentityAlreadyExistsError) {
+          throw error;
+        }
+        throw this.handleError(error);
+      }
+    }
+  };
+}

package/src/mixins/OxyServices.inference.ts

@@ -0,0 +1,57 @@
+/**
+ * The inference API, reached with whatever bearer this session already holds
+ * (issue #972, workstream 15).
+ *
+ * ```typescript
+ * const models = await oxyServices.inference().listModels();
+ * ```
+ *
+ * One method, and it is a FACTORY rather than a set of inference methods on
+ * `OxyServices`. The calls themselves live once, in
+ * {@link OxyInferenceClient} — which an external developer holding only an
+ * `oxy_sk_…` machine key constructs directly, with no Oxy session anywhere in
+ * the picture. Declaring the same calls a second time here would give the
+ * ecosystem two spellings of one request, and only one of them would stay
+ * correct.
+ *
+ * This is the reasoning `createLinkedClient` is already built on: the plumbing
+ * that binds an Oxy bearer to a client belongs in core, once, rather than in
+ * each app.
+ *
+ * The credential is a FUNCTION, not the current token: a session bearer rotates
+ * on refresh and on account switch, and a client that captured one at
+ * construction would start answering 401 an hour into the process's life.
+ */
+
+import { OxyInferenceClient } from '../inference/OxyInferenceClient';
+import type { OxyServicesBase } from '../OxyServices.base';
+
+export function OxyServicesInferenceMixin<T extends typeof OxyServicesBase>(Base: T) {
+    return class extends Base {
+        /** @internal Memoized so repeated calls return one object identity. */
+        _inferenceClient: OxyInferenceClient | null = null;
+
+        /**
+         * The inference client for this session.
+         *
+         * Bound to this instance's base URL and to `getAccessToken()`, so it
+         * follows every refresh, sign-in and account switch without being
+         * rebuilt.
+         *
+         * A service-authenticated process wants a different credential and
+         * builds {@link OxyInferenceClient} directly:
+         * `new OxyInferenceClient({ credential: () => oxy.getServiceToken() })`.
+         * The mint is asynchronous and cached, which is exactly what a
+         * credential function is for.
+         */
+        inference(): OxyInferenceClient {
+            if (this._inferenceClient === null) {
+                this._inferenceClient = new OxyInferenceClient({
+                    baseURL: this.getBaseURL(),
+                    credential: () => this.getAccessToken(),
+                });
+            }
+            return this._inferenceClient;
+        }
+    };
+}

package/src/mixins/OxyServices.language.ts

@@ -0,0 +1,144 @@
+/**
+ * Language Methods Mixin
+ */
+import { normalizeLocale, getPrimaryLanguage, getLanguageMetadata, getLanguageName, getNativeLanguageName } from '../utils/languageUtils';
+import type { SupportedLanguage } from '../utils/languageUtils';
+import type { OxyServicesBase } from '../OxyServices.base';
+import { loadAsyncStorage } from '@oxy.so/protocol';
+import { logger } from '../logger';
+
+/**
+ * Cross-mixin surface consumed by the language methods. `getCurrentUser` is
+ * provided by the user mixin at runtime — both live on the composed
+ * `OxyServices` instance — but it is not visible on `OxyServicesBase` at the
+ * type level. We narrow `this` through this interface (mirroring the
+ * `OxyAuthInstance` pattern in `OxyServices.utility.ts`) instead of casting to
+ * `any`. Only the fields this mixin reads are declared, keeping it decoupled
+ * from the full `User` shape.
+ */
+interface LanguageMixinCrossAccess {
+  getCurrentUser(): Promise<{ languages?: string[] }>;
+}
+
+export function OxyServicesLanguageMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+    /**
+     * Get appropriate storage for the platform (similar to DeviceManager)
+     */
+    public async getStorage(): Promise<{
+      getItem: (key: string) => Promise<string | null>;
+      setItem: (key: string, value: string) => Promise<void>;
+      removeItem: (key: string) => Promise<void>;
+    }> {
+      const isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+      
+      if (isReactNative) {
+        try {
+          // `loadAsyncStorage` is per-platform: the RN variant statically imports
+          // @react-native-async-storage/async-storage, the default variant throws
+          // (never called outside RN because of the `isReactNative` gate above).
+          const asyncStorageModule = await loadAsyncStorage();
+          const storage = asyncStorageModule.default;
+          return {
+            getItem: storage.getItem.bind(storage),
+            setItem: storage.setItem.bind(storage),
+            removeItem: storage.removeItem.bind(storage),
+          };
+        } catch (error) {
+          logger.error('AsyncStorage not available in React Native', error, { component: 'OxyServices.language' });
+          throw new Error('AsyncStorage is required in React Native environment');
+        }
+      } else {
+        // Use localStorage for web
+        return {
+          getItem: async (key: string) => {
+            if (typeof window !== 'undefined' && window.localStorage) {
+              return localStorage.getItem(key);
+            }
+            return null;
+          },
+          setItem: async (key: string, value: string) => {
+            if (typeof window !== 'undefined' && window.localStorage) {
+              localStorage.setItem(key, value);
+            }
+          },
+          removeItem: async (key: string) => {
+            if (typeof window !== 'undefined' && window.localStorage) {
+              localStorage.removeItem(key);
+            }
+          }
+        };
+      }
+    }
+
+    /**
+     * Get the current locale from the user profile or local storage.
+     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+     * @returns The current BCP-47 locale (e.g., 'en-US') or null if not set
+     */
+    async getCurrentLanguage(storageKeyPrefix = 'oxy_session'): Promise<string | null> {
+      try {
+        // First try the authenticated user's primary account locale.
+        try {
+          const user = await (this as unknown as LanguageMixinCrossAccess).getCurrentUser();
+          const primary = getPrimaryLanguage(user);
+          if (primary) {
+            return primary;
+          }
+        } catch {
+          // Not authenticated or the profile fetch failed — fall through to the
+          // locally stored preference below.
+        }
+
+        // Fall back to the locally stored locale preference.
+        const storage = await this.getStorage();
+        const storageKey = `${storageKeyPrefix}_language`;
+        const storedLanguage = await storage.getItem(storageKey);
+        if (storedLanguage) {
+          return normalizeLocale(storedLanguage) ?? storedLanguage;
+        }
+
+        return null;
+      } catch (error) {
+        logger.warn('Failed to get current language', { component: 'OxyServices.language' }, error);
+        return null;
+      }
+    }
+
+    /**
+     * Get the current language with metadata (name, nativeName, etc.)
+     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+     * @returns Language metadata object or null if not set
+     */
+    async getCurrentLanguageMetadata(storageKeyPrefix = 'oxy_session'): Promise<SupportedLanguage | null> {
+      const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+      return getLanguageMetadata(languageCode);
+    }
+
+    /**
+     * Get the current language name (e.g., 'English')
+     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+     * @returns Language name or null if not set
+     */
+    async getCurrentLanguageName(storageKeyPrefix = 'oxy_session'): Promise<string | null> {
+      const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+      if (!languageCode) return null;
+      return getLanguageName(languageCode);
+    }
+
+    /**
+     * Get the current native language name (e.g., 'Español')
+     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+     * @returns Native language name or null if not set
+     */
+    async getCurrentNativeLanguageName(storageKeyPrefix = 'oxy_session'): Promise<string | null> {
+      const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+      if (!languageCode) return null;
+      return getNativeLanguageName(languageCode);
+    }
+  };
+}
+

package/src/mixins/OxyServices.links.ts

@@ -0,0 +1,107 @@
+/**
+ * Link Preview (unfurl) Mixin
+ *
+ * Resolves link previews ("unfurls") through the Oxy API so every Oxy app
+ * stops scraping link metadata locally. The API owns resolution and re-hosts
+ * the preview `image`/`favicon` on Oxy media (`cloud.oxy.so/<fileId>`), so
+ * consumers render the returned URLs directly with no per-app proxy.
+ *
+ * Wire shapes (`LinkPreview`, `LinkPreviewBatchResponse`) are the single source
+ * of truth in `@oxy.so/contracts`; this mixin imports them rather than
+ * redefining them so producer (oxy-api) and consumers cannot drift.
+ *
+ * Caching note: these GET/POST reads are NOT cached at the SDK layer (`cache:
+ * false`). A preview can be returned `'pending'` first and `'resolved'` on a
+ * later read, so an SDK GET cache would pin the stale `'pending'` snapshot.
+ * App-side caching (React Query / stores) owns this responsibility.
+ */
+import type { LinkPreview } from '@oxy.so/contracts';
+import type { OxyServicesBase } from '../OxyServices.base';
+import { buildUrl } from '../utils/apiUtils';
+
+/**
+ * Maximum number of URLs sent per `POST /links/previews` request. Matches the
+ * server-side batch cap (`linkPreviewBatchRequestSchema`'s `.max(50)`); larger
+ * inputs are split into multiple chunked calls and the result maps merged,
+ * mirroring how `getUsersByIds` chunks at 100.
+ */
+const LINK_PREVIEWS_CHUNK_SIZE = 50;
+
+export function OxyServicesLinksMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+
+    /**
+     * Resolve a single link preview via `GET /links/preview?url=<encoded>&wait=0|1`.
+     *
+     * @param url - The URL to unfurl. Sent percent-encoded in the query string.
+     * @param opts.wait - When `true`, asks the server to resolve synchronously
+     *   (`wait=1`) instead of returning a `'pending'` placeholder for a
+     *   first-seen URL. Defaults to `false` (`wait=0`).
+     *
+     * Not cached at the SDK layer: a `'pending'` result can become `'resolved'`
+     * on a later read, so caching here would serve the stale placeholder.
+     */
+    async getLinkPreview(url: string, opts?: { wait?: boolean }): Promise<LinkPreview> {
+      try {
+        const path = buildUrl('/links/preview', { url, wait: opts?.wait ? 1 : 0 });
+        return await this.makeRequest<LinkPreview>('GET', path, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Resolve multiple link previews via `POST /links/previews` (body `{ urls }`).
+     *
+     * Inputs are de-duplicated and split into chunks of {@link LINK_PREVIEWS_CHUNK_SIZE}
+     * (the server-side cap). Chunks run concurrently and their result maps are
+     * merged into a single result keyed by the REQUESTED url (the exact string
+     * passed in `urls`) — matching the batch contract — so a caller can always
+     * look its own input back up.
+     *
+     * `makeRequest` unwraps the API's top-level `{ data }` envelope (same as
+     * `getUsersByIds`'s `makeServiceRequest<User[]>`), so each chunk response is
+     * already the `Record<url, LinkPreview>` map — merge it directly.
+     *
+     * An empty / whitespace-only input resolves immediately with `{}` and
+     * performs no network call. A failure in any chunk surfaces (via
+     * `handleError`) rather than being swallowed.
+     */
+    async getLinkPreviews(urls: string[]): Promise<Record<string, LinkPreview>> {
+      const uniqueUrls = Array.from(
+        new Set(urls.filter((u): u is string => typeof u === 'string' && u.trim().length > 0)),
+      );
+      if (uniqueUrls.length === 0) {
+        return {};
+      }
+
+      const chunks: string[][] = [];
+      for (let i = 0; i < uniqueUrls.length; i += LINK_PREVIEWS_CHUNK_SIZE) {
+        chunks.push(uniqueUrls.slice(i, i + LINK_PREVIEWS_CHUNK_SIZE));
+      }
+
+      try {
+        const responses = await Promise.all(
+          chunks.map((chunk) =>
+            this.makeRequest<Record<string, LinkPreview>>(
+              'POST',
+              '/links/previews',
+              { urls: chunk },
+              { cache: false },
+            ),
+          ),
+        );
+
+        return responses.reduce<Record<string, LinkPreview>>(
+          (merged, response) => Object.assign(merged, response ?? {}),
+          {},
+        );
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}

package/src/mixins/OxyServices.location.ts

@@ -0,0 +1,46 @@
+/**
+ * Location Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+
+export function OxyServicesLocationMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+
+    /**
+     * Update user location
+     * @param latitude - Latitude coordinate
+     * @param longitude - Longitude coordinate
+     * @returns Location update result
+     */
+    async updateLocation(latitude: number, longitude: number): Promise<any> {
+      try {
+        return await this.makeRequest('POST', '/location', {
+          latitude,
+          longitude
+        }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get nearby users
+     * @param radius - Optional search radius in meters
+     * @returns Array of nearby users
+     */
+    async getNearbyUsers(radius?: number): Promise<any[]> {
+      try {
+        const params: any = radius ? { radius } : undefined;
+        return await this.makeRequest('GET', '/location/nearby', params, {
+          cache: false, // Don't cache location data - always get fresh data
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+