@zveltio/sdk 1.2.0

package/dist/sync-manager.d.ts

@@ -0,0 +1,73 @@
+import type { ZveltioClient } from './client.js';
+export type CRDTConflictResolution = 'lww' | 'custom';
+export interface SyncManagerConfig {
+    /** Sync interval in ms (default: 5000) */
+    syncInterval?: number;
+    /** Max retry attempts per operation (default: 5) */
+    maxRetries?: number;
+    /** Exponential backoff base in ms (default: 1000) */
+    backoffBase?: number;
+    /** Callback for conflicts (default: server-wins) */
+    onConflict?: (local: any, server: any) => any;
+    /** CRDT conflict resolution strategy: 'lww' (field-level LWW merge) or 'custom' (onConflict cb). Default: 'lww' */
+    conflictResolution?: CRDTConflictResolution;
+}
+export declare class SyncManager {
+    private store;
+    private client;
+    private realtime;
+    private config;
+    private syncTimer;
+    private isOnline;
+    private isSyncing;
+    private listeners;
+    constructor(client: ZveltioClient, config?: SyncManagerConfig);
+    start(realtimeUrl?: string): Promise<void>;
+    /**
+     * Returns a local-first collection proxy:
+     * - list/get reads LOCAL (instant)
+     * - create/update/delete writes LOCAL + queues sync
+     * - subscribe receives realtime updates
+     */
+    collection(name: string): {
+        /** List records — reads LOCAL instantly */
+        list: () => Promise<{
+            _syncStatus: "synced" | "pending" | "conflict";
+            id: string;
+        }[]>;
+        /** Get one record — reads LOCAL instantly */
+        get: (id: string) => Promise<{
+            _syncStatus: "synced" | "pending" | "conflict";
+            id: string;
+        } | null>;
+        /** Create — writes LOCAL + queues sync */
+        create: (data: Record<string, any>) => Promise<{
+            _syncStatus: "synced" | "pending" | "conflict";
+            id: string;
+        }>;
+        /** Update — writes LOCAL + queues sync */
+        update: (id: string, data: Record<string, any>) => Promise<{
+            _syncStatus: "synced" | "pending" | "conflict";
+            id: string;
+        }>;
+        /** Delete — soft delete LOCAL + queues sync */
+        delete: (id: string) => Promise<void>;
+        /** Subscribe la changes (realtime + local writes) */
+        subscribe: (callback: (records: any[]) => void) => () => void;
+        /** Get pending conflicts for UI resolution */
+        getConflicts: () => Promise<import("./local-store.js").LocalRecord[]>;
+        /** Resolve a conflict manually */
+        resolveConflict: (id: string, resolvedData: Record<string, any>) => Promise<void>;
+    };
+    /** Force sync now (non-blocking) */
+    syncNow(): Promise<void>;
+    private notifyListeners;
+    /** Status: pending operations count, conflicts count */
+    getStatus(): Promise<{
+        pending: number;
+        conflicts: number;
+        isOnline: boolean;
+    }>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=sync-manager.d.ts.map

package/dist/sync-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-manager.d.ts","sourceRoot":"","sources":["../src/sync-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,MAAM,MAAM,sBAAsB,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC;IAC9C,mHAAmH;IACnH,kBAAkB,CAAC,EAAE,sBAAsB,CAAC;CAC7C;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,SAAS,CAAyD;gBAE9D,MAAM,EAAE,aAAa,EAAE,MAAM,GAAE,iBAAsB;IAY3D,KAAK,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiChD;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM;QAEnB,2CAA2C;;;;;QAU3C,6CAA6C;kBAC7B,MAAM;;;;QAUtB,0CAA0C;uBACrB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;QAYxC,0CAA0C;qBACvB,MAAM,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;QAapD,+CAA+C;qBAC5B,MAAM;QAMzB,qDAAqD;8BAC/B,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,IAAI;QAoD9C,8CAA8C;;QAK9C,kCAAkC;8BAE5B,MAAM,gBACI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;IASvC,oCAAoC;IAC9B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YA8GhB,eAAe;IAmB7B,wDAAwD;IAClD,SAAS,IAAI,OAAO,CAAC;QACzB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,OAAO,CAAC;KACnB,CAAC;IAUI,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAK5B"}

package/dist/sync-manager.js

@@ -0,0 +1,293 @@
+import { LocalStore } from './local-store.js';
+import { mergeLWW, fromDocument } from './crdt.js';
+export class SyncManager {
+    store;
+    client;
+    realtime = null;
+    config;
+    syncTimer = null;
+    isOnline = true;
+    isSyncing = false;
+    listeners = new Map();
+    constructor(client, config = {}) {
+        this.store = new LocalStore();
+        this.client = client;
+        this.config = {
+            syncInterval: config.syncInterval ?? 5000,
+            maxRetries: config.maxRetries ?? 5,
+            backoffBase: config.backoffBase ?? 1000,
+            onConflict: config.onConflict ?? ((_local, server) => server),
+            conflictResolution: config.conflictResolution ?? 'lww',
+        };
+    }
+    async start(realtimeUrl) {
+        await this.store.open();
+        // Online/offline detection
+        if (typeof window !== 'undefined') {
+            window.addEventListener('online', () => {
+                this.isOnline = true;
+                this.syncNow(); // Sync immediately on reconnect
+            });
+            window.addEventListener('offline', () => {
+                this.isOnline = false;
+            });
+            this.isOnline = navigator.onLine;
+        }
+        // Realtime: receives push updates from server
+        if (realtimeUrl) {
+            const { ZveltioRealtime } = await import('./realtime.js');
+            this.realtime = new ZveltioRealtime(realtimeUrl);
+            this.realtime.connect();
+            // Subscriptions are per-collection via collection()
+        }
+        // Periodic sync
+        this.syncTimer = setInterval(() => this.syncNow(), this.config.syncInterval);
+        // Initial sync
+        await this.syncNow();
+    }
+    /**
+     * Returns a local-first collection proxy:
+     * - list/get reads LOCAL (instant)
+     * - create/update/delete writes LOCAL + queues sync
+     * - subscribe receives realtime updates
+     */
+    collection(name) {
+        return {
+            /** List records — reads LOCAL instantly */
+            list: async () => {
+                const records = await this.store.list(name);
+                return records.map((r) => ({
+                    id: r.id,
+                    ...r.data,
+                    _syncStatus: r._syncStatus,
+                }));
+            },
+            /** Get one record — reads LOCAL instantly */
+            get: async (id) => {
+                const record = await this.store.get(name, id);
+                if (!record)
+                    return null;
+                return {
+                    id: record.id,
+                    ...record.data,
+                    _syncStatus: record._syncStatus,
+                };
+            },
+            /** Create — writes LOCAL + queues sync */
+            create: async (data) => {
+                const id = data.id || crypto.randomUUID();
+                const record = await this.store.put(name, id, data);
+                this.notifyListeners(name);
+                this.syncNow(); // Trigger sync immediately (non-blocking)
+                return {
+                    id: record.id,
+                    ...record.data,
+                    _syncStatus: record._syncStatus,
+                };
+            },
+            /** Update — writes LOCAL + queues sync */
+            update: async (id, data) => {
+                const existing = await this.store.get(name, id);
+                const merged = { ...(existing?.data || {}), ...data };
+                const record = await this.store.put(name, id, merged);
+                this.notifyListeners(name);
+                this.syncNow();
+                return {
+                    id: record.id,
+                    ...record.data,
+                    _syncStatus: record._syncStatus,
+                };
+            },
+            /** Delete — soft delete LOCAL + queues sync */
+            delete: async (id) => {
+                await this.store.delete(name, id);
+                this.notifyListeners(name);
+                this.syncNow();
+            },
+            /** Subscribe la changes (realtime + local writes) */
+            subscribe: (callback) => {
+                if (!this.listeners.has(name))
+                    this.listeners.set(name, new Set());
+                this.listeners.get(name).add(callback);
+                // Subscribe to realtime server push
+                let unsubRealtime;
+                if (this.realtime) {
+                    unsubRealtime = this.realtime.subscribe(name, async (event) => {
+                        // Apply update from server to local store
+                        if (event.event === 'record.created' ||
+                            event.event === 'record.updated') {
+                            try {
+                                const serverRecord = await this.client
+                                    .collection(name)
+                                    .get(event.record_id);
+                                await this.store.applyServerUpdate(name, event.record_id, serverRecord, Date.now());
+                                this.notifyListeners(name);
+                            }
+                            catch {
+                                /* offline or error — ignore, periodic sync will resolve */
+                            }
+                        }
+                        else if (event.event === 'record.deleted') {
+                            await this.store.delete(name, event.record_id);
+                            this.notifyListeners(name);
+                        }
+                    });
+                }
+                // Emit current state immediately
+                this.store.list(name).then((records) => {
+                    callback(records.map((r) => ({
+                        id: r.id,
+                        ...r.data,
+                        _syncStatus: r._syncStatus,
+                    })));
+                });
+                // Return unsubscribe function
+                return () => {
+                    this.listeners.get(name)?.delete(callback);
+                    unsubRealtime?.();
+                };
+            },
+            /** Get pending conflicts for UI resolution */
+            getConflicts: async () => {
+                return this.store.getConflicts(name);
+            },
+            /** Resolve a conflict manually */
+            resolveConflict: async (id, resolvedData) => {
+                await this.store.resolveConflict(name, id, resolvedData);
+                this.notifyListeners(name);
+                this.syncNow();
+            },
+        };
+    }
+    /** Force sync now (non-blocking) */
+    async syncNow() {
+        if (!this.isOnline || this.isSyncing)
+            return;
+        this.isSyncing = true;
+        try {
+            // Step 1: Upload offline blobs BEFORE syncing records
+            const pendingBlobs = await this.store.getPendingBlobs();
+            for (const blobItem of pendingBlobs) {
+                try {
+                    const file = new File([blobItem.blob], `offline_${blobItem.id}`, {
+                        type: blobItem.blob.type,
+                    });
+                    const result = (await this.client.storage.upload(file));
+                    const url = result?.url || result?.publicUrl || result?.path || '';
+                    if (!url)
+                        continue; // Upload returned without URL — skip
+                    // Replace local_blob_* reference with real URL in record
+                    const record = await this.store.get(blobItem.collection, blobItem.recordId);
+                    if (record && record.data[blobItem.field] === blobItem.id) {
+                        await this.store.put(blobItem.collection, blobItem.recordId, {
+                            ...record.data,
+                            [blobItem.field]: url,
+                        });
+                    }
+                    await this.store.deleteBlob(blobItem.id);
+                }
+                catch {
+                    // Offline or upload error — skip, retry at next sync cycle
+                }
+            }
+            const pending = await this.store.getPendingOps();
+            for (const op of pending) {
+                if (op.attempts >= this.config.maxRetries)
+                    continue; // Skip exhausted operations
+                try {
+                    const serverVersion = Date.now();
+                    // Attach CRDT doc to payload if available
+                    const localRecord = await this.store.get(op.collection, op.recordId);
+                    const crdtPayload = localRecord?._crdtDoc
+                        ? { ...op.payload, __crdt: localRecord._crdtDoc }
+                        : op.payload;
+                    switch (op.operation) {
+                        case 'create':
+                            await this.client
+                                .collection(op.collection)
+                                .create({ id: op.recordId, ...crdtPayload });
+                            break;
+                        case 'update':
+                            await this.client
+                                .collection(op.collection)
+                                .update(op.recordId, crdtPayload);
+                            break;
+                        case 'delete':
+                            await this.client.collection(op.collection).delete(op.recordId);
+                            break;
+                    }
+                    await this.store.markSynced(op.id, op.collection, op.recordId, serverVersion);
+                    this.notifyListeners(op.collection);
+                }
+                catch (err) {
+                    // Conflict from server (409) — apply conflict resolution
+                    if (err.message?.includes('409')) {
+                        try {
+                            const serverRecord = await this.client
+                                .collection(op.collection)
+                                .get(op.recordId);
+                            const localRecord = await this.store.get(op.collection, op.recordId);
+                            // CRDT LWW merge if both sides have CRDT docs and strategy is 'lww'
+                            if (this.config.conflictResolution === 'lww' &&
+                                localRecord?._crdtDoc &&
+                                serverRecord.__crdt) {
+                                const merged = mergeLWW(localRecord._crdtDoc, serverRecord.__crdt);
+                                const resolvedData = fromDocument(merged);
+                                await this.store.resolveConflict(op.collection, op.recordId, resolvedData);
+                            }
+                            else {
+                                const resolved = this.config.onConflict(localRecord?.data, serverRecord);
+                                await this.store.resolveConflict(op.collection, op.recordId, resolved);
+                            }
+                        }
+                        catch {
+                            /* fallback: server wins — ignore error */
+                        }
+                    }
+                    else {
+                        // Exponential backoff
+                        await this.store.markFailed(op.id, err.message || 'Unknown error');
+                    }
+                }
+            }
+        }
+        finally {
+            this.isSyncing = false;
+        }
+    }
+    async notifyListeners(collection) {
+        const callbacks = this.listeners.get(collection);
+        if (!callbacks?.size)
+            return;
+        const records = await this.store.list(collection);
+        const mapped = records.map((r) => ({
+            id: r.id,
+            ...r.data,
+            _syncStatus: r._syncStatus,
+        }));
+        callbacks.forEach((cb) => {
+            try {
+                cb(mapped);
+            }
+            catch {
+                /* ignore callback errors */
+            }
+        });
+    }
+    /** Status: pending operations count, conflicts count */
+    async getStatus() {
+        const pending = await this.store.getPendingOps();
+        const conflicts = await this.store.getConflicts();
+        return {
+            pending: pending.length,
+            conflicts: conflicts.length,
+            isOnline: this.isOnline,
+        };
+    }
+    async stop() {
+        if (this.syncTimer)
+            clearInterval(this.syncTimer);
+        this.realtime?.disconnect();
+        await this.store.close();
+    }
+}

package/dist/tests/local-store.test.d.ts

@@ -0,0 +1,2 @@
+import './setup';
+//# sourceMappingURL=local-store.test.d.ts.map

package/dist/tests/local-store.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-store.test.d.ts","sourceRoot":"","sources":["../../src/tests/local-store.test.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,CAAC"}

package/dist/tests/local-store.test.js

@@ -0,0 +1,76 @@
+import './setup';
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { LocalStore } from '../local-store.js';
+describe('LocalStore — conflict detection', () => {
+    let store;
+    beforeEach(async () => {
+        store = new LocalStore();
+        await store.open();
+        // Reset DB state — fake-indexeddb is a module-level singleton shared across
+        // test files within the same Bun process (src/ and dist/ runs both use it).
+        // Without clearing, dist/ tests find records left by src/ tests and
+        // _localVersion is wrong (e.g. 2 instead of 1 for a fresh put).
+        await store.clear();
+    });
+    afterEach(async () => {
+        await store.close();
+    });
+    it('no conflict when record is clean (no local edits)', async () => {
+        // Simulate a record that arrived from server with no local edits
+        await store.applyServerUpdate('posts', 'rec-1', { title: 'Hello' }, 1);
+        const rec = await store.get('posts', 'rec-1');
+        expect(rec?._syncStatus).toBe('synced');
+        expect(rec?._conflictData).toBeUndefined();
+    });
+    it('detects conflict when server update races a pending local write', async () => {
+        // 1. Client writes locally (status=pending, localVersion=1, serverVersion=0)
+        await store.put('posts', 'rec-2', { title: 'Draft' });
+        const before = await store.get('posts', 'rec-2');
+        expect(before?._syncStatus).toBe('pending');
+        expect(before?._localVersion).toBe(1);
+        expect(before?._serverVersion).toBe(0);
+        // 2. Server pushes an update
+        await store.applyServerUpdate('posts', 'rec-2', { title: 'Server Title' }, 3);
+        const after = await store.get('posts', 'rec-2');
+        expect(after?._syncStatus).toBe('conflict');
+        expect(after?._conflictData).toEqual({ title: 'Server Title' });
+        // Local data is NOT overwritten so user can compare both versions
+        expect(after?.data).toEqual({ title: 'Draft' });
+    });
+    it('detects conflict when localVersion > serverVersion regardless of syncStatus (CLAUDE.md scenario)', async () => {
+        // Reproduce: _localVersion=2, _serverVersion=1, _syncStatus='synced'
+        // Step 1: server sends version 1 → _localVersion=0, _serverVersion=1
+        await store.applyServerUpdate('posts', 'rec-3', { title: 'Original' }, 1);
+        // Step 2: two local edits → _localVersion=2, _serverVersion=1
+        await store.put('posts', 'rec-3', { title: 'Edit 1' }); // localVersion=1
+        await store.put('posts', 'rec-3', { title: 'Edit 2' }); // localVersion=2
+        // Step 3: forcibly mark as 'synced' while localVersion(2) > serverVersion(1)
+        // (simulate the race: sync ACK arrived for v1 but client already at v2)
+        const pending = await store.get('posts', 'rec-3');
+        expect(pending?._localVersion).toBe(2);
+        expect(pending?._serverVersion).toBe(1);
+        // Patch syncStatus to 'synced' without advancing serverVersion — the race condition
+        const queueItems = await store.getPendingOps();
+        // Use markSynced for the first op only — server confirmed v1, client is at v2
+        if (queueItems[0]) {
+            await store.markSynced(queueItems[0].id, 'posts', 'rec-3', 1);
+        }
+        const raceState = await store.get('posts', 'rec-3');
+        // After markSynced: _serverVersion=1, _localVersion=2 → still dirty
+        expect(raceState?._localVersion).toBeGreaterThan(raceState?._serverVersion ?? 0);
+        // Step 4: server pushes a concurrent update
+        await store.applyServerUpdate('posts', 'rec-3', { title: 'Concurrent Server Edit' }, 5);
+        const conflict = await store.get('posts', 'rec-3');
+        expect(conflict?._syncStatus).toBe('conflict');
+        expect(conflict?._conflictData).toEqual({ title: 'Concurrent Server Edit' });
+    });
+    it('applies cleanly when server version is newer and no local edits', async () => {
+        await store.applyServerUpdate('posts', 'rec-4', { title: 'v1' }, 1);
+        await store.applyServerUpdate('posts', 'rec-4', { title: 'v2' }, 2);
+        const rec = await store.get('posts', 'rec-4');
+        expect(rec?._syncStatus).toBe('synced');
+        expect(rec?.data).toEqual({ title: 'v2' });
+        expect(rec?._serverVersion).toBe(2);
+        expect(rec?._conflictData).toBeUndefined();
+    });
+});

package/dist/tests/setup.d.ts

@@ -0,0 +1,2 @@
+import 'fake-indexeddb/auto';
+//# sourceMappingURL=setup.d.ts.map

package/dist/tests/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/tests/setup.ts"],"names":[],"mappings":"AAEA,OAAO,qBAAqB,CAAC"}

package/dist/tests/setup.js

@@ -0,0 +1,3 @@
+// Replaces global indexedDB with a synchronous in-memory implementation.
+// Must be the first import in every test file that uses LocalStore.
+import 'fake-indexeddb/auto';

package/dist/types/index.d.ts

@@ -0,0 +1,39 @@
+export interface ZveltioConfig {
+    baseUrl: string;
+    apiKey?: string;
+    onUnauthorized?: () => void;
+}
+export interface QueryOptions {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    order?: 'asc' | 'desc';
+    filter?: Record<string, any>;
+    search?: string;
+}
+export interface QueryResponse<T = any> {
+    records: T[];
+    pagination: {
+        total: number;
+        page: number;
+        limit: number;
+        pages: number;
+    };
+}
+export interface SingleResponse<T = any> {
+    record: T;
+}
+export interface CreateResponse<T = any> {
+    record: T;
+}
+export interface DeleteResponse {
+    success: boolean;
+    id: string;
+}
+export interface RealtimeMessage {
+    event: 'insert' | 'update' | 'delete';
+    collection: string;
+    data: any;
+    timestamp: string;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,GAAG;IACpC,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,UAAU,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;CACH;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,GAAG;IACrC,MAAM,EAAE,CAAC,CAAC;CACX;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,GAAG;IACrC,MAAM,EAAE,CAAC,CAAC;CACX;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,GAAG,CAAC;IACV,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@zveltio/sdk",
+  "version": "1.2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./extension": {
+      "types": "./dist/extension/index.d.ts",
+      "import": "./dist/extension/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test --preload ./src/tests/setup.ts"
+  },
+  "dependencies": {
+    "idb": "^8.0.0"
+  },
+  "devDependencies": {
+    "fake-indexeddb": "^6.2.5",
+    "hono": "^4.12.5",
+    "typescript": "^5.4.0"
+  }
+}