@blinkdotnew/sdk 0.16.0 → 0.17.0

package/README.md

@@ -705,12 +705,20 @@ try {
 // Upload files (returns public URL directly)
 const { publicUrl } = await blink.storage.upload(
   file,
-  'path/to/file.jpg',
+  'path/to/file',
   {
     upsert: true,
     onProgress: (percent) => console.log(`${percent}%`)
   }
 )
+// If file is PNG, final path will be: path/to/file.png
+
+// 💡 Pro tip: Use the actual filename (file.name) in your path to avoid confusion
+const { publicUrl } = await blink.storage.upload(
+  file,
+  `uploads/${file.name}`, // Uses actual filename with correct extension
+  { upsert: true }
+)
 
 // Remove files
 await blink.storage.remove('file1.jpg', 'file2.jpg')

package/dist/index.d.mts

@@ -1050,6 +1050,7 @@ interface BlinkAnalytics {
     setUserId(userId: string | null): void;
     setUserEmail(email: string | null): void;
     clearAttribution(): void;
+    destroy(): void;
 }
 declare class BlinkAnalyticsImpl implements BlinkAnalytics {
     private httpClient;
@@ -1071,6 +1072,10 @@ declare class BlinkAnalyticsImpl implements BlinkAnalytics {
      * Disable analytics tracking
      */
     disable(): void;
+    /**
+     * Cleanup analytics instance (remove from global tracking)
+     */
+    destroy(): void;
     /**
      * Enable analytics tracking
      */
@@ -1141,23 +1146,48 @@ declare class BlinkStorageImpl implements BlinkStorage {
      * Upload a file to project storage
      *
      * @param file - File, Blob, or Buffer to upload
-     * @param path - Destination path within project storage
+     * @param path - Destination path within project storage (extension will be auto-corrected to match file type)
      * @param options - Upload options including upsert and progress callback
      * @returns Promise resolving to upload response with public URL
      *
      * @example
      * ```ts
+     * // Extension automatically corrected to match actual file type
      * const { publicUrl } = await blink.storage.upload(
-     *   fileInput.files[0],
-     *   `avatars/${user.id}.png`,
-     *   {
-     *     upsert: true,
-     *     onProgress: pct => console.log(`${pct}%`)
-     *   }
+     *   pngFile,
+     *   `avatars/${user.id}`, // No extension needed!
+     *   { upsert: true }
      * );
+     * // If file is PNG, final path will be: avatars/user123.png
+     *
+     * // Or with extension (will be corrected if wrong)
+     * const { publicUrl } = await blink.storage.upload(
+     *   pngFile,
+     *   `avatars/${user.id}.jpg`, // Wrong extension
+     *   { upsert: true }
+     * );
+     * // Final path will be: avatars/user123.png (auto-corrected!)
      * ```
      */
     upload(file: File | Blob | Buffer, path: string, options?: StorageUploadOptions): Promise<StorageUploadResponse>;
+    /**
+     * Detect file type from actual file content and correct path extension
+     * This ensures the path extension always matches the actual file type
+     */
+    private detectFileTypeAndCorrectPath;
+    /**
+     * Get the first few bytes of a file to analyze its signature
+     */
+    private getFileSignature;
+    /**
+     * Detect file type from file signature (magic numbers)
+     * This is the most reliable way to detect actual file type
+     */
+    private detectFileTypeFromSignature;
+    /**
+     * Get file extension from MIME type as fallback
+     */
+    private getExtensionFromMimeType;
     /**
      * Get a download URL for a file that triggers browser download
      *

package/dist/index.d.ts

@@ -1050,6 +1050,7 @@ interface BlinkAnalytics {
     setUserId(userId: string | null): void;
     setUserEmail(email: string | null): void;
     clearAttribution(): void;
+    destroy(): void;
 }
 declare class BlinkAnalyticsImpl implements BlinkAnalytics {
     private httpClient;
@@ -1071,6 +1072,10 @@ declare class BlinkAnalyticsImpl implements BlinkAnalytics {
      * Disable analytics tracking
      */
     disable(): void;
+    /**
+     * Cleanup analytics instance (remove from global tracking)
+     */
+    destroy(): void;
     /**
      * Enable analytics tracking
      */
@@ -1141,23 +1146,48 @@ declare class BlinkStorageImpl implements BlinkStorage {
      * Upload a file to project storage
      *
      * @param file - File, Blob, or Buffer to upload
-     * @param path - Destination path within project storage
+     * @param path - Destination path within project storage (extension will be auto-corrected to match file type)
      * @param options - Upload options including upsert and progress callback
      * @returns Promise resolving to upload response with public URL
      *
      * @example
      * ```ts
+     * // Extension automatically corrected to match actual file type
      * const { publicUrl } = await blink.storage.upload(
-     *   fileInput.files[0],
-     *   `avatars/${user.id}.png`,
-     *   {
-     *     upsert: true,
-     *     onProgress: pct => console.log(`${pct}%`)
-     *   }
+     *   pngFile,
+     *   `avatars/${user.id}`, // No extension needed!
+     *   { upsert: true }
      * );
+     * // If file is PNG, final path will be: avatars/user123.png
+     *
+     * // Or with extension (will be corrected if wrong)
+     * const { publicUrl } = await blink.storage.upload(
+     *   pngFile,
+     *   `avatars/${user.id}.jpg`, // Wrong extension
+     *   { upsert: true }
+     * );
+     * // Final path will be: avatars/user123.png (auto-corrected!)
      * ```
      */
     upload(file: File | Blob | Buffer, path: string, options?: StorageUploadOptions): Promise<StorageUploadResponse>;
+    /**
+     * Detect file type from actual file content and correct path extension
+     * This ensures the path extension always matches the actual file type
+     */
+    private detectFileTypeAndCorrectPath;
+    /**
+     * Get the first few bytes of a file to analyze its signature
+     */
+    private getFileSignature;
+    /**
+     * Detect file type from file signature (magic numbers)
+     * This is the most reliable way to detect actual file type
+     */
+    private detectFileTypeFromSignature;
+    /**
+     * Get file extension from MIME type as fallback
+     */
+    private getExtensionFromMimeType;
     /**
      * Get a download URL for a file that triggers browser download
      *

package/dist/index.js

@@ -1817,20 +1817,27 @@ var BlinkStorageImpl = class {
    * Upload a file to project storage
    * 
    * @param file - File, Blob, or Buffer to upload
-   * @param path - Destination path within project storage
+   * @param path - Destination path within project storage (extension will be auto-corrected to match file type)
    * @param options - Upload options including upsert and progress callback
    * @returns Promise resolving to upload response with public URL
    * 
    * @example
    * ```ts
+   * // Extension automatically corrected to match actual file type
    * const { publicUrl } = await blink.storage.upload(
-   *   fileInput.files[0],
-   *   `avatars/${user.id}.png`,
-   *   {
-   *     upsert: true,
-   *     onProgress: pct => console.log(`${pct}%`)
-   *   }
+   *   pngFile,
+   *   `avatars/${user.id}`, // No extension needed!
+   *   { upsert: true }
+   * );
+   * // If file is PNG, final path will be: avatars/user123.png
+   * 
+   * // Or with extension (will be corrected if wrong)
+   * const { publicUrl } = await blink.storage.upload(
+   *   pngFile,
+   *   `avatars/${user.id}.jpg`, // Wrong extension
+   *   { upsert: true }
    * );
+   * // Final path will be: avatars/user123.png (auto-corrected!)
    * ```
    */
   async upload(file, path, options = {}) {
@@ -1851,10 +1858,12 @@ var BlinkStorageImpl = class {
       if (fileSize > maxSize) {
         throw new BlinkStorageError(`File size (${Math.round(fileSize / 1024 / 1024)}MB) exceeds maximum allowed size (50MB)`);
       }
+      const { correctedPath, detectedContentType } = await this.detectFileTypeAndCorrectPath(file, path);
       const response = await this.httpClient.uploadFile(
         `/api/storage/${this.httpClient.projectId}/upload`,
         file,
-        path,
+        correctedPath,
+        // Use corrected path with proper extension
         {
           upsert: options.upsert,
           onProgress: options.onProgress
@@ -1887,6 +1896,132 @@ var BlinkStorageImpl = class {
       );
     }
   }
+  /**
+   * Detect file type from actual file content and correct path extension
+   * This ensures the path extension always matches the actual file type
+   */
+  async detectFileTypeAndCorrectPath(file, originalPath) {
+    try {
+      const fileSignature = await this.getFileSignature(file);
+      const detectedType = this.detectFileTypeFromSignature(fileSignature);
+      let detectedContentType = detectedType.mimeType;
+      let detectedExtension = detectedType.extension;
+      if (!detectedContentType && file instanceof File && file.type) {
+        detectedContentType = file.type;
+        detectedExtension = this.getExtensionFromMimeType(file.type);
+      }
+      if (!detectedContentType) {
+        detectedContentType = "application/octet-stream";
+        detectedExtension = "bin";
+      }
+      const pathParts = originalPath.split("/");
+      const fileName = pathParts[pathParts.length - 1];
+      const directory = pathParts.slice(0, -1).join("/");
+      if (!fileName) {
+        throw new Error("Invalid path: filename cannot be empty");
+      }
+      const nameWithoutExt = fileName.includes(".") ? fileName.substring(0, fileName.lastIndexOf(".")) : fileName;
+      const correctedFileName = `${nameWithoutExt}.${detectedExtension}`;
+      const correctedPath = directory ? `${directory}/${correctedFileName}` : correctedFileName;
+      return {
+        correctedPath,
+        detectedContentType
+      };
+    } catch (error) {
+      console.warn("File type detection failed, using original path:", error);
+      return {
+        correctedPath: originalPath,
+        detectedContentType: "application/octet-stream"
+      };
+    }
+  }
+  /**
+   * Get the first few bytes of a file to analyze its signature
+   */
+  async getFileSignature(file) {
+    const bytesToRead = 12;
+    if (typeof Buffer !== "undefined" && file instanceof Buffer) {
+      return new Uint8Array(file.slice(0, bytesToRead));
+    }
+    if (file instanceof File || file instanceof Blob) {
+      const slice = file.slice(0, bytesToRead);
+      const arrayBuffer = await slice.arrayBuffer();
+      return new Uint8Array(arrayBuffer);
+    }
+    throw new Error("Unsupported file type for signature detection");
+  }
+  /**
+   * Detect file type from file signature (magic numbers)
+   * This is the most reliable way to detect actual file type
+   */
+  detectFileTypeFromSignature(signature) {
+    const hex = Array.from(signature).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const signatures = {
+      // Images
+      "ffd8ff": { mimeType: "image/jpeg", extension: "jpg" },
+      "89504e47": { mimeType: "image/png", extension: "png" },
+      "47494638": { mimeType: "image/gif", extension: "gif" },
+      "52494646": { mimeType: "image/webp", extension: "webp" },
+      // RIFF (WebP container)
+      "424d": { mimeType: "image/bmp", extension: "bmp" },
+      "49492a00": { mimeType: "image/tiff", extension: "tiff" },
+      "4d4d002a": { mimeType: "image/tiff", extension: "tiff" },
+      // Documents
+      "25504446": { mimeType: "application/pdf", extension: "pdf" },
+      "504b0304": { mimeType: "application/zip", extension: "zip" },
+      // Also used by docx, xlsx
+      "d0cf11e0": { mimeType: "application/msword", extension: "doc" },
+      // Audio
+      "494433": { mimeType: "audio/mpeg", extension: "mp3" },
+      "664c6143": { mimeType: "audio/flac", extension: "flac" },
+      "4f676753": { mimeType: "audio/ogg", extension: "ogg" },
+      // Video
+      "000000": { mimeType: "video/mp4", extension: "mp4" },
+      // ftyp box
+      "1a45dfa3": { mimeType: "video/webm", extension: "webm" },
+      // Text
+      "efbbbf": { mimeType: "text/plain", extension: "txt" }
+      // UTF-8 BOM
+    };
+    for (const [sig, type] of Object.entries(signatures)) {
+      if (hex.startsWith(sig)) {
+        return type;
+      }
+    }
+    if (hex.startsWith("52494646") && hex.substring(16, 24) === "57454250") {
+      return { mimeType: "image/webp", extension: "webp" };
+    }
+    if (hex.substring(8, 16) === "66747970") {
+      return { mimeType: "video/mp4", extension: "mp4" };
+    }
+    return { mimeType: "", extension: "" };
+  }
+  /**
+   * Get file extension from MIME type as fallback
+   */
+  getExtensionFromMimeType(mimeType) {
+    const mimeToExt = {
+      "image/jpeg": "jpg",
+      "image/png": "png",
+      "image/gif": "gif",
+      "image/webp": "webp",
+      "image/bmp": "bmp",
+      "image/svg+xml": "svg",
+      "application/pdf": "pdf",
+      "text/plain": "txt",
+      "text/html": "html",
+      "text/css": "css",
+      "application/javascript": "js",
+      "application/json": "json",
+      "audio/mpeg": "mp3",
+      "audio/wav": "wav",
+      "audio/ogg": "ogg",
+      "video/mp4": "mp4",
+      "video/webm": "webm",
+      "application/zip": "zip"
+    };
+    return mimeToExt[mimeType] || "bin";
+  }
   /**
    * Get a download URL for a file that triggers browser download
    * 
@@ -3163,6 +3298,15 @@ var BlinkRealtimeChannel = class {
       } catch (err) {
       }
     };
+    const originalTimeout = timeout;
+    const cleanupTimeout = setTimeout(() => {
+      if (this.websocket) {
+        this.websocket.removeEventListener("message", handleResponse);
+      }
+      reject(new BlinkRealtimeError("Message send timeout - no response from server"));
+    }, 1e4);
+    queuedMessage.timeout = cleanupTimeout;
+    clearTimeout(originalTimeout);
     this.websocket.addEventListener("message", handleResponse);
     this.websocket.send(message);
   }
@@ -3579,6 +3723,15 @@ var BlinkAnalyticsImpl = class {
     this.enabled = false;
     this.clearTimer();
   }
+  /**
+   * Cleanup analytics instance (remove from global tracking)
+   */
+  destroy() {
+    this.disable();
+    if (typeof window !== "undefined") {
+      window.__blinkAnalyticsInstances?.delete(this);
+    }
+  }
   /**
    * Enable analytics tracking
    */
@@ -3745,19 +3898,37 @@ var BlinkAnalyticsImpl = class {
     }
   }
   setupRouteChangeListener() {
-    const originalPushState = history.pushState;
-    const originalReplaceState = history.replaceState;
-    history.pushState = (...args) => {
-      originalPushState.apply(history, args);
-      this.log("pageview");
-    };
-    history.replaceState = (...args) => {
-      originalReplaceState.apply(history, args);
-      this.log("pageview");
-    };
-    window.addEventListener("popstate", () => {
-      this.log("pageview");
-    });
+    if (!window.__blinkAnalyticsSetup) {
+      const originalPushState = history.pushState;
+      const originalReplaceState = history.replaceState;
+      const analyticsInstances = /* @__PURE__ */ new Set();
+      window.__blinkAnalyticsInstances = analyticsInstances;
+      history.pushState = (...args) => {
+        originalPushState.apply(history, args);
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      };
+      history.replaceState = (...args) => {
+        originalReplaceState.apply(history, args);
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      };
+      window.addEventListener("popstate", () => {
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      });
+      window.__blinkAnalyticsSetup = true;
+    }
+    window.__blinkAnalyticsInstances?.add(this);
   }
   setupUnloadListener() {
     window.addEventListener("pagehide", () => {

package/dist/index.mjs

@@ -1815,20 +1815,27 @@ var BlinkStorageImpl = class {
    * Upload a file to project storage
    * 
    * @param file - File, Blob, or Buffer to upload
-   * @param path - Destination path within project storage
+   * @param path - Destination path within project storage (extension will be auto-corrected to match file type)
    * @param options - Upload options including upsert and progress callback
    * @returns Promise resolving to upload response with public URL
    * 
    * @example
    * ```ts
+   * // Extension automatically corrected to match actual file type
    * const { publicUrl } = await blink.storage.upload(
-   *   fileInput.files[0],
-   *   `avatars/${user.id}.png`,
-   *   {
-   *     upsert: true,
-   *     onProgress: pct => console.log(`${pct}%`)
-   *   }
+   *   pngFile,
+   *   `avatars/${user.id}`, // No extension needed!
+   *   { upsert: true }
+   * );
+   * // If file is PNG, final path will be: avatars/user123.png
+   * 
+   * // Or with extension (will be corrected if wrong)
+   * const { publicUrl } = await blink.storage.upload(
+   *   pngFile,
+   *   `avatars/${user.id}.jpg`, // Wrong extension
+   *   { upsert: true }
    * );
+   * // Final path will be: avatars/user123.png (auto-corrected!)
    * ```
    */
   async upload(file, path, options = {}) {
@@ -1849,10 +1856,12 @@ var BlinkStorageImpl = class {
       if (fileSize > maxSize) {
         throw new BlinkStorageError(`File size (${Math.round(fileSize / 1024 / 1024)}MB) exceeds maximum allowed size (50MB)`);
       }
+      const { correctedPath, detectedContentType } = await this.detectFileTypeAndCorrectPath(file, path);
       const response = await this.httpClient.uploadFile(
         `/api/storage/${this.httpClient.projectId}/upload`,
         file,
-        path,
+        correctedPath,
+        // Use corrected path with proper extension
         {
           upsert: options.upsert,
           onProgress: options.onProgress
@@ -1885,6 +1894,132 @@ var BlinkStorageImpl = class {
       );
     }
   }
+  /**
+   * Detect file type from actual file content and correct path extension
+   * This ensures the path extension always matches the actual file type
+   */
+  async detectFileTypeAndCorrectPath(file, originalPath) {
+    try {
+      const fileSignature = await this.getFileSignature(file);
+      const detectedType = this.detectFileTypeFromSignature(fileSignature);
+      let detectedContentType = detectedType.mimeType;
+      let detectedExtension = detectedType.extension;
+      if (!detectedContentType && file instanceof File && file.type) {
+        detectedContentType = file.type;
+        detectedExtension = this.getExtensionFromMimeType(file.type);
+      }
+      if (!detectedContentType) {
+        detectedContentType = "application/octet-stream";
+        detectedExtension = "bin";
+      }
+      const pathParts = originalPath.split("/");
+      const fileName = pathParts[pathParts.length - 1];
+      const directory = pathParts.slice(0, -1).join("/");
+      if (!fileName) {
+        throw new Error("Invalid path: filename cannot be empty");
+      }
+      const nameWithoutExt = fileName.includes(".") ? fileName.substring(0, fileName.lastIndexOf(".")) : fileName;
+      const correctedFileName = `${nameWithoutExt}.${detectedExtension}`;
+      const correctedPath = directory ? `${directory}/${correctedFileName}` : correctedFileName;
+      return {
+        correctedPath,
+        detectedContentType
+      };
+    } catch (error) {
+      console.warn("File type detection failed, using original path:", error);
+      return {
+        correctedPath: originalPath,
+        detectedContentType: "application/octet-stream"
+      };
+    }
+  }
+  /**
+   * Get the first few bytes of a file to analyze its signature
+   */
+  async getFileSignature(file) {
+    const bytesToRead = 12;
+    if (typeof Buffer !== "undefined" && file instanceof Buffer) {
+      return new Uint8Array(file.slice(0, bytesToRead));
+    }
+    if (file instanceof File || file instanceof Blob) {
+      const slice = file.slice(0, bytesToRead);
+      const arrayBuffer = await slice.arrayBuffer();
+      return new Uint8Array(arrayBuffer);
+    }
+    throw new Error("Unsupported file type for signature detection");
+  }
+  /**
+   * Detect file type from file signature (magic numbers)
+   * This is the most reliable way to detect actual file type
+   */
+  detectFileTypeFromSignature(signature) {
+    const hex = Array.from(signature).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const signatures = {
+      // Images
+      "ffd8ff": { mimeType: "image/jpeg", extension: "jpg" },
+      "89504e47": { mimeType: "image/png", extension: "png" },
+      "47494638": { mimeType: "image/gif", extension: "gif" },
+      "52494646": { mimeType: "image/webp", extension: "webp" },
+      // RIFF (WebP container)
+      "424d": { mimeType: "image/bmp", extension: "bmp" },
+      "49492a00": { mimeType: "image/tiff", extension: "tiff" },
+      "4d4d002a": { mimeType: "image/tiff", extension: "tiff" },
+      // Documents
+      "25504446": { mimeType: "application/pdf", extension: "pdf" },
+      "504b0304": { mimeType: "application/zip", extension: "zip" },
+      // Also used by docx, xlsx
+      "d0cf11e0": { mimeType: "application/msword", extension: "doc" },
+      // Audio
+      "494433": { mimeType: "audio/mpeg", extension: "mp3" },
+      "664c6143": { mimeType: "audio/flac", extension: "flac" },
+      "4f676753": { mimeType: "audio/ogg", extension: "ogg" },
+      // Video
+      "000000": { mimeType: "video/mp4", extension: "mp4" },
+      // ftyp box
+      "1a45dfa3": { mimeType: "video/webm", extension: "webm" },
+      // Text
+      "efbbbf": { mimeType: "text/plain", extension: "txt" }
+      // UTF-8 BOM
+    };
+    for (const [sig, type] of Object.entries(signatures)) {
+      if (hex.startsWith(sig)) {
+        return type;
+      }
+    }
+    if (hex.startsWith("52494646") && hex.substring(16, 24) === "57454250") {
+      return { mimeType: "image/webp", extension: "webp" };
+    }
+    if (hex.substring(8, 16) === "66747970") {
+      return { mimeType: "video/mp4", extension: "mp4" };
+    }
+    return { mimeType: "", extension: "" };
+  }
+  /**
+   * Get file extension from MIME type as fallback
+   */
+  getExtensionFromMimeType(mimeType) {
+    const mimeToExt = {
+      "image/jpeg": "jpg",
+      "image/png": "png",
+      "image/gif": "gif",
+      "image/webp": "webp",
+      "image/bmp": "bmp",
+      "image/svg+xml": "svg",
+      "application/pdf": "pdf",
+      "text/plain": "txt",
+      "text/html": "html",
+      "text/css": "css",
+      "application/javascript": "js",
+      "application/json": "json",
+      "audio/mpeg": "mp3",
+      "audio/wav": "wav",
+      "audio/ogg": "ogg",
+      "video/mp4": "mp4",
+      "video/webm": "webm",
+      "application/zip": "zip"
+    };
+    return mimeToExt[mimeType] || "bin";
+  }
   /**
    * Get a download URL for a file that triggers browser download
    * 
@@ -3161,6 +3296,15 @@ var BlinkRealtimeChannel = class {
       } catch (err) {
       }
     };
+    const originalTimeout = timeout;
+    const cleanupTimeout = setTimeout(() => {
+      if (this.websocket) {
+        this.websocket.removeEventListener("message", handleResponse);
+      }
+      reject(new BlinkRealtimeError("Message send timeout - no response from server"));
+    }, 1e4);
+    queuedMessage.timeout = cleanupTimeout;
+    clearTimeout(originalTimeout);
     this.websocket.addEventListener("message", handleResponse);
     this.websocket.send(message);
   }
@@ -3577,6 +3721,15 @@ var BlinkAnalyticsImpl = class {
     this.enabled = false;
     this.clearTimer();
   }
+  /**
+   * Cleanup analytics instance (remove from global tracking)
+   */
+  destroy() {
+    this.disable();
+    if (typeof window !== "undefined") {
+      window.__blinkAnalyticsInstances?.delete(this);
+    }
+  }
   /**
    * Enable analytics tracking
    */
@@ -3743,19 +3896,37 @@ var BlinkAnalyticsImpl = class {
     }
   }
   setupRouteChangeListener() {
-    const originalPushState = history.pushState;
-    const originalReplaceState = history.replaceState;
-    history.pushState = (...args) => {
-      originalPushState.apply(history, args);
-      this.log("pageview");
-    };
-    history.replaceState = (...args) => {
-      originalReplaceState.apply(history, args);
-      this.log("pageview");
-    };
-    window.addEventListener("popstate", () => {
-      this.log("pageview");
-    });
+    if (!window.__blinkAnalyticsSetup) {
+      const originalPushState = history.pushState;
+      const originalReplaceState = history.replaceState;
+      const analyticsInstances = /* @__PURE__ */ new Set();
+      window.__blinkAnalyticsInstances = analyticsInstances;
+      history.pushState = (...args) => {
+        originalPushState.apply(history, args);
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      };
+      history.replaceState = (...args) => {
+        originalReplaceState.apply(history, args);
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      };
+      window.addEventListener("popstate", () => {
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      });
+      window.__blinkAnalyticsSetup = true;
+    }
+    window.__blinkAnalyticsInstances?.add(this);
   }
   setupUnloadListener() {
     window.addEventListener("pagehide", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blinkdotnew/sdk",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Blink TypeScript SDK for client-side applications - Zero-boilerplate CRUD + auth + AI + analytics + notifications for modern SaaS/AI apps",
   "keywords": [
     "blink",