@soham20/smart-offline-sdk 0.1.3 → 0.2.0

package/package.json

@@ -1,24 +1,38 @@
 {
   "name": "@soham20/smart-offline-sdk",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Smart offline-first JavaScript SDK with intelligent caching for web applications",
-  "main": "src/index.cjs.js",
-  "module": "src/index.js",
+  "main": "./src/index.cjs.js",
+  "module": "./src/index.js",
+  "browser": "./src/index.js",
+  "types": "./src/index.d.ts",
   "exports": {
     ".": {
       "import": "./src/index.js",
-      "require": "./src/index.cjs.js"
+      "require": "./src/index.cjs.js",
+      "browser": "./src/index.js",
+      "default": "./src/index.js"
     },
     "./client": {
       "require": "./src/sdk/index.cjs"
     }
   },
+  "files": [
+    "src",
+    "smart-offline-sw.js"
+  ],
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "build": "echo \"no build step\"",
     "lint": "echo \"no lint configured\""
   },
-  "keywords": ["offline", "pwa", "service-worker", "cache", "offline-first"],
+  "keywords": [
+    "offline",
+    "pwa",
+    "service-worker",
+    "cache",
+    "offline-first"
+  ],
   "author": "Atif Sayed",
   "license": "MIT",
   "type": "module",

package/smart-offline-sw.js

@@ -15,6 +15,9 @@ let SDK_CONFIG = {
   maxResourceSize: Infinity,
   networkQuality: "auto", // 'auto' | 'fast' | 'slow'
   significance: {}, // { urlPattern: 'high' | 'normal' | 'low' }
+  weights: { frequency: 1, recency: 1, size: 1 },
+  customPriorityFn: null,
+  enableDetailedLogs: false
 };
 
 /**
@@ -24,12 +27,66 @@ self.addEventListener("message", (event) => {
   if (event.data && event.data.type === "INIT_CONFIG") {
     SDK_CONFIG = event.data.payload;
 
+    // Deserialize custom priority function if provided
+    if (SDK_CONFIG.customPriorityFn && typeof SDK_CONFIG.customPriorityFn === 'string') {
+      try {
+        SDK_CONFIG.customPriorityFn = eval(`(${SDK_CONFIG.customPriorityFn})`);
+      } catch (e) {
+        console.error('[SmartOffline] Failed to parse customPriorityFn:', e);
+        SDK_CONFIG.customPriorityFn = null;
+      }
+    }
+
     if (SDK_CONFIG.debug) {
       console.log("[SmartOffline] Config received:", SDK_CONFIG);
     }
   }
 });
 
+/**
+ * Log cache events to IndexedDB
+ */
+function logEvent(type, url, reason, metadata = {}) {
+  if (!SDK_CONFIG.enableDetailedLogs) return;
+
+  const request = indexedDB.open("smart-offline-logs", 1);
+
+  request.onupgradeneeded = () => {
+    const db = request.result;
+    if (!db.objectStoreNames.contains("logs")) {
+      db.createObjectStore("logs", { autoIncrement: true });
+    }
+  };
+
+  request.onsuccess = () => {
+    const db = request.result;
+    const tx = db.transaction("logs", "readwrite");
+    const store = tx.objectStore("logs");
+
+    store.add({
+      type,
+      url,
+      reason,
+      metadata,
+      timestamp: Date.now(),
+      date: new Date().toISOString()
+    });
+  };
+
+  // Also send to main thread
+  self.clients.matchAll().then(clients => {
+    clients.forEach(client => {
+      client.postMessage({
+        type: `CACHE_${type.toUpperCase()}`,
+        url,
+        reason,
+        metadata,
+        timestamp: Date.now()
+      });
+    });
+  });
+}
+
 /**
  * -------- Usage Tracking (IndexedDB) --------
  * Tracks frequency + recency per URL
@@ -86,9 +143,19 @@ function getUsage(url) {
 }
 
 /**
- * Decide priority based on real usage and developer-tuned config
+ * Decide priority based on real usage and developer-tuned config with weights
  */
 function isHighPriority(usage, url) {
+  // Custom priority function override
+  if (SDK_CONFIG.customPriorityFn && typeof SDK_CONFIG.customPriorityFn === 'function') {
+    try {
+      const score = SDK_CONFIG.customPriorityFn(usage, url, SDK_CONFIG);
+      return score > 50; // Scores above 50 are high priority
+    } catch (e) {
+      console.error('[SmartOffline] Custom priority function error:', e);
+    }
+  }
+
   // Manual significance override
   for (const pattern in SDK_CONFIG.significance) {
     if (url.includes(pattern)) {
@@ -101,10 +168,25 @@ function isHighPriority(usage, url) {
 
   if (!usage) return false;
 
-  const frequent = usage.count >= SDK_CONFIG.frequencyThreshold;
-  const recent = Date.now() - usage.lastAccessed <= SDK_CONFIG.recencyThreshold;
-
-  return frequent || recent;
+  // Weighted priority calculation
+  const weights = SDK_CONFIG.weights || { frequency: 1, recency: 1, size: 1 };
+  
+  // Frequency score (0-100)
+  const frequencyScore = Math.min(100, (usage.count / SDK_CONFIG.frequencyThreshold) * 100);
+  
+  // Recency score (0-100)
+  const timeSinceAccess = Date.now() - usage.lastAccessed;
+  const recencyScore = Math.max(0, 100 - (timeSinceAccess / SDK_CONFIG.recencyThreshold) * 100);
+  
+  // Weighted total
+  const totalWeight = weights.frequency + weights.recency;
+  const weightedScore = (
+    (frequencyScore * weights.frequency) + 
+    (recencyScore * weights.recency)
+  ) / totalWeight;
+  
+  // High priority if weighted score > 50
+  return weightedScore > 50;
 }
 
 /**
@@ -182,6 +264,11 @@ self.addEventListener("fetch", (event) => {
         const contentLength = response.headers.get("content-length");
         const size = contentLength ? parseInt(contentLength, 10) : 0;
         if (size > SDK_CONFIG.maxResourceSize) {
+          logEvent('skip', request.url, 'size_limit_exceeded', { 
+            size, 
+            limit: SDK_CONFIG.maxResourceSize 
+          });
+          
           if (SDK_CONFIG.debug) {
             console.log(
               `[SmartOffline] Skipped caching (size ${size} > ${SDK_CONFIG.maxResourceSize}):`,
@@ -193,8 +280,15 @@ self.addEventListener("fetch", (event) => {
 
         // Network quality aware caching
         const netQuality = getEffectiveNetworkQuality();
-        if (netQuality === "slow" && !isHighPriority(null, request.url)) {
-          // On slow network, skip caching low priority resources proactively
+        const usage = await getUsage(request.url);
+        const highPriority = isHighPriority(usage, request.url);
+        
+        if (netQuality === "slow" && !highPriority) {
+          logEvent('skip', request.url, 'slow_network_low_priority', { 
+            networkQuality: netQuality,
+            priority: 'low'
+          });
+          
           if (SDK_CONFIG.debug) {
             console.log(
               `[SmartOffline] Skipped caching (slow network, not high priority):`,
@@ -207,6 +301,11 @@ self.addEventListener("fetch", (event) => {
         const clone = response.clone();
         caches.open(CACHE_NAME).then((cache) => {
           cache.put(request.url, clone);
+          logEvent('cache', request.url, 'network_fetch_success', {
+            type: isAPI ? 'API' : 'PAGE',
+            size,
+            priority: highPriority ? 'high' : 'normal'
+          });
         });
 
         if (SDK_CONFIG.debug) {
@@ -218,25 +317,33 @@ self.addEventListener("fetch", (event) => {
 
         return response;
       })
-      .catch(() => {
+      .catch(async () => {
         // Offline / network failure
         trackUsage(request.url);
 
-        return getUsage(request.url).then((usage) => {
-          const highPriority = isHighPriority(usage, request.url);
+        const usage = await getUsage(request.url);
+        const highPriority = isHighPriority(usage, request.url);
+        const cached = await caches.match(request.url);
+
+        if (cached) {
+          logEvent('serve', request.url, 'offline_cache_hit', {
+            priority: highPriority ? 'high' : 'normal',
+            usage: usage ? { count: usage.count, lastAccessed: usage.lastAccessed } : null
+          });
 
           if (SDK_CONFIG.debug) {
             console.log(
-              `[SmartOffline] ${
-                highPriority ? "HIGH" : "NORMAL"
-              } priority:`,
+              `[SmartOffline] Served from cache (${highPriority ? "HIGH" : "NORMAL"} priority):`,
               request.url
             );
           }
+        } else {
+          logEvent('error', request.url, 'cache_miss_offline', {
+            priority: highPriority ? 'high' : 'normal'
+          });
+        }
 
-          // v1 behavior: both return cache, but priority is decided & logged
-          return caches.match(request.url);
-        });
+        return cached;
       })
   );
 });

package/src/index.cjs.js

@@ -1,8 +1,16 @@
 /**
  * SmartOffline SDK (CommonJS version)
  */
+const eventListeners = {
+  cache: [],
+  skip: [],
+  serve: [],
+  clear: [],
+  error: []
+};
+
 function init(config = {}) {
-  if (typeof navigator === 'undefined' || !("serviceWorker" in navigator)) {
+  if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
     console.warn("Service Workers not supported");
     return;
   }
@@ -16,11 +24,34 @@ function init(config = {}) {
     maxResourceSize: config.maxResourceSize ?? Infinity,
     networkQuality: config.networkQuality ?? "auto",
     significance: config.significance ?? {},
+    weights: {
+      frequency: config.weights?.frequency ?? 1,
+      recency: config.weights?.recency ?? 1,
+      size: config.weights?.size ?? 1
+    },
+    customPriorityFn: config.customPriorityFn ? config.customPriorityFn.toString() : null,
+    enableDetailedLogs: config.enableDetailedLogs ?? false
   };
 
+  if (config.onCacheEvent) {
+    eventListeners.cache.push(config.onCacheEvent);
+    eventListeners.skip.push(config.onCacheEvent);
+    eventListeners.serve.push(config.onCacheEvent);
+    eventListeners.clear.push(config.onCacheEvent);
+    eventListeners.error.push(config.onCacheEvent);
+  }
+
   navigator.serviceWorker.register("/smart-offline-sw.js").then(() => {
     console.log("Smart Offline Service Worker registered");
 
+    navigator.serviceWorker.addEventListener('message', (event) => {
+      if (event.data && event.data.type) {
+        const eventType = event.data.type.replace('CACHE_', '').toLowerCase();
+        const listeners = eventListeners[eventType] || [];
+        listeners.forEach(fn => fn(event.data));
+      }
+    });
+
     navigator.serviceWorker.ready.then(() => {
       if (navigator.serviceWorker.controller) {
         navigator.serviceWorker.controller.postMessage({
@@ -42,14 +73,64 @@ function init(config = {}) {
         });
 
         if (sdkConfig.debug) {
-          console.log("[SmartOffline] Config sent after controllerchange:", sdkConfig);
+          console.log(
+            "[SmartOffline] Config sent after controllerchange:",
+            sdkConfig,
+          );
         }
       }
     });
   });
 }
 
-const SmartOffline = { init };
+function on(eventType, callback) {
+  if (eventListeners[eventType]) {
+    eventListeners[eventType].push(callback);
+  }
+}
+
+function off(eventType, callback) {
+  if (eventListeners[eventType]) {
+    const index = eventListeners[eventType].indexOf(callback);
+    if (index > -1) {
+      eventListeners[eventType].splice(index, 1);
+    }
+  }
+}
+
+async function getCacheLogs() {
+  const db = await openDB('smart-offline-logs', 1);
+  const tx = db.transaction('logs', 'readonly');
+  const store = tx.objectStore('logs');
+  return new Promise((resolve) => {
+    const request = store.getAll();
+    request.onsuccess = () => resolve(request.result || []);
+    request.onerror = () => resolve([]);
+  });
+}
+
+async function clearCacheLogs() {
+  const db = await openDB('smart-offline-logs', 1);
+  const tx = db.transaction('logs', 'readwrite');
+  const store = tx.objectStore('logs');
+  store.clear();
+}
+
+function openDB(name, version) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(name, version);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains('logs')) {
+        db.createObjectStore('logs', { autoIncrement: true });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+const SmartOffline = { init, on, off, getCacheLogs, clearCacheLogs };
 
 module.exports = { SmartOffline };
 module.exports.default = SmartOffline;

package/src/index.d.ts

@@ -0,0 +1,76 @@
+export interface UsageData {
+  url: string;
+  count: number;
+  lastAccessed: number;
+}
+
+export interface CacheWeights {
+  /** Weight for frequency score (default: 1) */
+  frequency?: number;
+  /** Weight for recency score (default: 1) */
+  recency?: number;
+  /** Weight for size consideration (default: 1) */
+  size?: number;
+}
+
+export interface CacheEvent {
+  type: 'CACHE_CACHE' | 'CACHE_SKIP' | 'CACHE_SERVE' | 'CACHE_CLEAR' | 'CACHE_ERROR';
+  url: string;
+  reason: string;
+  metadata?: any;
+  timestamp: number;
+}
+
+export type CustomPriorityFunction = (
+  usage: UsageData | null, 
+  url: string, 
+  config: SmartOfflineConfig
+) => number; // Return 0-100, >50 is high priority
+
+export interface SmartOfflineConfig {
+  /** Array of page URL patterns to cache */
+  pages?: string[];
+  /** Array of API URL patterns to cache */
+  apis?: string[];
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Number of accesses before resource is considered "frequent" (default: 3) */
+  frequencyThreshold?: number;
+  /** Milliseconds within which resource is considered "recent" (default: 24h) */
+  recencyThreshold?: number;
+  /** Max bytes to cache per resource; larger resources skipped (default: Infinity) */
+  maxResourceSize?: number;
+  /** Network quality setting: 'auto' | 'fast' | 'slow' (default: 'auto') */
+  networkQuality?: "auto" | "fast" | "slow";
+  /** Manual priority overrides by URL pattern */
+  significance?: Record<string, "high" | "normal" | "low">;
+  /** Weights for priority calculation (default: all 1) */
+  weights?: CacheWeights;
+  /** Custom priority function for complete control */
+  customPriorityFn?: CustomPriorityFunction;
+  /** Enable detailed event logging to IndexedDB */
+  enableDetailedLogs?: boolean;
+  /** Callback for all cache events */
+  onCacheEvent?: (event: CacheEvent) => void;
+}
+
+export interface CacheLog {
+  type: string;
+  url: string;
+  reason: string;
+  metadata?: any;
+  timestamp: number;
+  date: string;
+}
+
+export interface SmartOfflineSDK {
+  init(config?: SmartOfflineConfig): void;
+  on(eventType: 'cache' | 'skip' | 'serve' | 'clear' | 'error', callback: (event: CacheEvent) => void): void;
+  off(eventType: 'cache' | 'skip' | 'serve' | 'clear' | 'error', callback: (event: CacheEvent) => void): void;
+  getCacheLogs(): Promise<CacheLog[]>;
+  clearCacheLogs(): Promise<void>;
+}
+
+export declare const SmartOffline: SmartOfflineSDK;
+export default SmartOffline;
+

package/src/index.js

@@ -7,7 +7,20 @@
  * - maxResourceSize: max bytes to cache per resource; larger resources skipped (default Infinity)
  * - networkQuality: 'auto' | 'fast' | 'slow' — affects caching aggressiveness (default 'auto')
  * - significance: { [urlPattern]: 'high' | 'normal' | 'low' } — manual priority overrides
+ * - weights: { frequency: number, recency: number, size: number } — priority weights (default all 1)
+ * - customPriorityFn: (usage, url, config) => number — custom priority function (0-100)
+ * - onCacheEvent: (event) => void — callback for cache events (cache, skip, serve, clear)
  */
+
+// Event listener registry
+const eventListeners = {
+  cache: [],
+  skip: [],
+  serve: [],
+  clear: [],
+  error: []
+};
+
 function init(config = {}) {
   if (!("serviceWorker" in navigator)) {
     console.warn("Service Workers not supported");
@@ -23,11 +36,38 @@ function init(config = {}) {
     maxResourceSize: config.maxResourceSize ?? Infinity,
     networkQuality: config.networkQuality ?? "auto",
     significance: config.significance ?? {},
+    
+    // New features
+    weights: {
+      frequency: config.weights?.frequency ?? 1,
+      recency: config.weights?.recency ?? 1,
+      size: config.weights?.size ?? 1
+    },
+    customPriorityFn: config.customPriorityFn ? config.customPriorityFn.toString() : null,
+    enableDetailedLogs: config.enableDetailedLogs ?? false
   };
 
-  navigator.serviceWorker.register("/smart-offline-sw.js").then(() => {
+  // Register event listener if provided
+  if (config.onCacheEvent) {
+    eventListeners.cache.push(config.onCacheEvent);
+    eventListeners.skip.push(config.onCacheEvent);
+    eventListeners.serve.push(config.onCacheEvent);
+    eventListeners.clear.push(config.onCacheEvent);
+    eventListeners.error.push(config.onCacheEvent);
+  }
+
+  navigator.serviceWorker.register("/smart-offline-sw.js").then((registration) => {
     console.log("Smart Offline Service Worker registered");
 
+    // Listen for messages from SW
+    navigator.serviceWorker.addEventListener('message', (event) => {
+      if (event.data && event.data.type) {
+        const eventType = event.data.type.replace('CACHE_', '').toLowerCase();
+        const listeners = eventListeners[eventType] || [];
+        listeners.forEach(fn => fn(event.data));
+      }
+    });
+
     navigator.serviceWorker.ready.then(() => {
       if (navigator.serviceWorker.controller) {
         navigator.serviceWorker.controller.postMessage({
@@ -51,7 +91,7 @@ function init(config = {}) {
         if (sdkConfig.debug) {
           console.log(
             "[SmartOffline] Config sent after controllerchange:",
-            sdkConfig
+            sdkConfig,
           );
         }
       }
@@ -59,7 +99,63 @@ function init(config = {}) {
   });
 }
 
-const SmartOffline = { init };
+// API for managing event listeners
+function on(eventType, callback) {
+  if (eventListeners[eventType]) {
+    eventListeners[eventType].push(callback);
+  }
+}
+
+function off(eventType, callback) {
+  if (eventListeners[eventType]) {
+    const index = eventListeners[eventType].indexOf(callback);
+    if (index > -1) {
+      eventListeners[eventType].splice(index, 1);
+    }
+  }
+}
+
+// API to get cache logs
+async function getCacheLogs() {
+  const db = await openDB('smart-offline-logs', 1);
+  const tx = db.transaction('logs', 'readonly');
+  const store = tx.objectStore('logs');
+  return new Promise((resolve) => {
+    const request = store.getAll();
+    request.onsuccess = () => resolve(request.result || []);
+    request.onerror = () => resolve([]);
+  });
+}
+
+// API to clear cache logs
+async function clearCacheLogs() {
+  const db = await openDB('smart-offline-logs', 1);
+  const tx = db.transaction('logs', 'readwrite');
+  const store = tx.objectStore('logs');
+  store.clear();
+}
+
+function openDB(name, version) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(name, version);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains('logs')) {
+        db.createObjectStore('logs', { autoIncrement: true });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+
+const SmartOffline = { 
+  init, 
+  on, 
+  off, 
+  getCacheLogs, 
+  clearCacheLogs 
+};
 
-export { SmartOffline };       // ✅ named export
-export default SmartOffline;  // ✅ default export
+export { SmartOffline }; // ✅ named export
+export default SmartOffline; // ✅ default export

package/CONTRIBUTING.md

@@ -1,5 +0,0 @@
-# Contributing
-
-- Fork the repo and open a PR.
-- Run tests with `npm test`.
-- Follow the code style in existing files.

package/PROJECT_ANALYSIS.md

@@ -1,94 +0,0 @@
-# SmartOffline SDK — Project Analysis
-
-Date: 2026-01-22
-
----
-
-## Project Summary
-
-SmartOffline is a JavaScript SDK that enables offline-first behavior by registering a Service Worker which caches configured pages and API responses. The repository includes a demo, basic tests, and a Node-style test SDK.
-
-Key locations:
-
-- `smart-offline-sw.js` — Service Worker implementing caching, usage tracking, and priority logic.
-- `src/index.js` — Browser SDK entry (`SmartOffline.init`) that registers the SW and sends configuration.
-- `src/usageTracker.js` — IndexedDB-based usage tracker (client-side helper).
-- `src/sdk/index.js` — Small Node test client (`HackvisionClient`) used by tests/examples.
-- `demo/` — Demo page and sample API (`demo/index.html`, `demo/api/profile.json`).
-- `tests/` — `tests/basic.test.js` (Jest) covering the test client.
-
----
-
-## Features That Work (Implemented)
-
-- Service Worker registration via `SmartOffline.init()` (browser).
-- SW intercepts `GET` requests for configured pages and APIs and caches successful network responses.
-- Offline fallback: SW serves cached responses when fetch fails.
-- Usage tracking in IndexedDB (stores `count` and `lastAccessed` per URL) implemented both in `smart-offline-sw.js` and `src/usageTracker.js`.
-- Priority determination (high/normal) based on frequency and recency thresholds.
-- Demo implementation showing SDK usage and an API example.
-- Node test client (`HackvisionClient.echo`) and unit test (`jest`) pass.
-- CI workflow exists to run tests (.github/workflows/ci.yml).
-- Package published as `@soham20/smart-offline-sdk` (v0.1.1).
-
----
-
-## Issues & Gaps (Needs Attention)
-
-- README contains unresolved merge markers. Clean and add clear quickstarts for browser and Node.
-- `package.json` declares `"type": "commonjs"` but `src/index.js` uses ESM-style `export` (module mismatch). This may confuse Node consumers and bundlers.
-- No build/bundling step: source files are published directly. This reduces compatibility across consumers (CJS/ESM/browser UMD). No `dist/` artifacts.
-- Service Worker behavior is not covered by automated integration tests (typical but recommended to add Playwright/Puppeteer tests for offline behavior).
-- Inconsistent public API surface: demo uses `SmartOffline.init()` while package `main` points to `src/sdk/index.js` (Node test client). Clarify and add a top-level entry that documents both browser and Node exports.
-- Privacy/consent: usage tracking stores per-URL usage in IndexedDB — document privacy implications and provide opt-out.
-- No cache eviction / quota management — cache can grow without limits.
-
----
-
-## Short-Term Recommendations (Actionable)
-
-1. Fix `README.md` (remove merge markers) and add clear Quickstart sections for browser and Node usage.
-2. Standardize module format:
-   - Option A: Build ESM + CJS bundles (Rollup) and set `main`/`module`/`exports` in `package.json`.
-   - Option B: Convert `src/index.js` to CommonJS `module.exports` if targeting Node-only.
-3. Add a build step that outputs `dist/` bundles (UMD for browsers, ESM and CJS for Node). Update `package.json` scripts (`build`, `prepublishOnly`).
-4. Add integration tests (Playwright) that:
-   - Serve demo, register SW, fetch a resource online, go offline, and verify cached response is served.
-5. Add cache size management (LRU or simple max-entries) using usage metrics in IndexedDB.
-6. Document the usage tracking behavior and add opt-out configuration (e.g., `trackUsage: false`).
-
----
-
-## Mid/Large-Term Enhancements (Future)
-
-- Prefetching & background sync for high-priority resources.
-- Configurable stale-while-revalidate and TTL per resource.
-- TypeScript conversion + publishing type definitions.
-- Expose a small diagnostics API so apps can query cache status and usage stats.
-- Publish a UMD browser bundle and host on a CDN for direct `<script>` usage.
-- Telemetry (opt-in) and analytics for adoption + cache effectiveness metrics.
-
----
-
-## Suggested Next Steps (I can implement)
-
-- Patch `README.md` to a clean quickstart (browser + Node).
-- Add a small build setup (Rollup) to produce `dist/` artifacts and update `package.json`.
-- Add a Playwright integration test for offline cache validation.
-
-If you want, I can: (pick one or more)
-
-- Fix the `README.md` now.
-- Add a minimal Rollup build and update `package.json`.
-- Add a Playwright test and a small local server script to run it.
-
----
-
-## Notes & Observations
-
-- The published package name changed from `hackvision2026-sdk` (spam-detected) to scoped `@soham20/smart-offline-sdk`, which is preferable.
-- Tests pass (`npm test`). The test target is small (echo), so expand tests to include SDK behavior where feasible.
-
----
-
-_Generated by repository scan on 2026-01-22._

package/jest.config.js

@@ -1,9 +0,0 @@
-/** @type {import('jest').Config} */
-const config = {
-  testEnvironment: 'node',
-  transform: {},
-  moduleFileExtensions: ['js', 'cjs', 'mjs', 'json'],
-  testMatch: ['**/tests/**/*.test.cjs'],
-};
-
-export default config;