@zveltio/sdk 1.2.0

package/dist/local-store.js

@@ -0,0 +1,263 @@
+import { openDB } from 'idb';
+import { LamportClock, mergeLWW, toDocument, fromDocument } from './crdt.js';
+const DB_NAME = 'zveltio_local';
+const DB_VERSION = 3; // v3: CRDT Lamport clock in meta store
+export class LocalStore {
+    db = null;
+    clock = null;
+    async open() {
+        this.db = await openDB(DB_NAME, DB_VERSION, {
+            upgrade(db, oldVersion) {
+                if (oldVersion < 1) {
+                    // Store for local data (mirror of server collections)
+                    const store = db.createObjectStore('records', {
+                        keyPath: ['collection', 'id'],
+                    });
+                    store.createIndex('by-collection', 'collection');
+                    store.createIndex('by-sync-status', '_syncStatus');
+                    store.createIndex('by-updated', '_updatedAt');
+                    // Sync queue (pending operations)
+                    const queue = db.createObjectStore('sync_queue', { keyPath: 'id' });
+                    queue.createIndex('by-collection', 'collection');
+                    queue.createIndex('by-created', 'createdAt');
+                    // Metadata per collection (last sync timestamp, etc.)
+                    db.createObjectStore('meta', { keyPath: 'key' });
+                }
+                if (oldVersion < 2) {
+                    // Blobs saved offline — upload on first reconnect
+                    db.createObjectStore('offline_blobs', { keyPath: 'id' });
+                }
+                // v3: no new stores — Lamport clock stored as key in existing 'meta' store
+            },
+        });
+        // Initialize CRDT Lamport clock (persisted in meta store)
+        let clientId = (await this.db.get('meta', 'crdt_client_id'))?.value;
+        if (!clientId) {
+            clientId = crypto.randomUUID();
+            await this.db.put('meta', { key: 'crdt_client_id', value: clientId });
+        }
+        const storedLamport = (await this.db.get('meta', 'crdt_lamport'))?.value ?? 0;
+        this.clock = new LamportClock(clientId, storedLamport);
+    }
+    async persistLamport() {
+        if (!this.db || !this.clock)
+            return;
+        await this.db.put('meta', { key: 'crdt_lamport', value: this.clock.current });
+    }
+    /** Write a local record and add to sync queue */
+    async put(collection, id, data) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const existing = (await this.db.get('records', [collection, id]));
+        const lamport = this.clock ? this.clock.tick() : Date.now();
+        const clientId = this.clock?.id ?? 'unknown';
+        const crdtDoc = toDocument(data, lamport, clientId);
+        const record = {
+            id,
+            collection,
+            data,
+            _localVersion: (existing?._localVersion || 0) + 1,
+            _serverVersion: existing?._serverVersion || 0,
+            _syncStatus: 'pending',
+            _updatedAt: Date.now(),
+            _crdtDoc: crdtDoc,
+        };
+        const tx = this.db.transaction(['records', 'sync_queue'], 'readwrite');
+        // 1. Write local record
+        await tx.objectStore('records').put(record);
+        // 2. Add to sync queue
+        const queueItem = {
+            id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            collection,
+            recordId: id,
+            operation: existing ? 'update' : 'create',
+            payload: data,
+            attempts: 0,
+            createdAt: Date.now(),
+        };
+        await tx.objectStore('sync_queue').add(queueItem);
+        await tx.done;
+        await this.persistLamport();
+        return record;
+    }
+    /** Read a local record (instant, no network) */
+    async get(collection, id) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const record = (await this.db.get('records', [collection, id]));
+        if (record?._deletedAt)
+            return undefined; // Soft-deleted
+        return record;
+    }
+    /** List records from a collection (local) */
+    async list(collection) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const all = (await this.db.getAllFromIndex('records', 'by-collection', collection));
+        return all.filter((r) => !r._deletedAt);
+    }
+    /** Soft delete local and add to sync queue */
+    async delete(collection, id) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const tx = this.db.transaction(['records', 'sync_queue'], 'readwrite');
+        const existing = (await tx.objectStore('records').get([collection, id]));
+        if (existing) {
+            existing._deletedAt = Date.now();
+            existing._syncStatus = 'pending';
+            await tx.objectStore('records').put(existing);
+        }
+        const queueItem = {
+            id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            collection,
+            recordId: id,
+            operation: 'delete',
+            payload: {},
+            attempts: 0,
+            createdAt: Date.now(),
+        };
+        await tx.objectStore('sync_queue').add(queueItem);
+        await tx.done;
+    }
+    /** Returns all pending operations from sync queue */
+    async getPendingOps() {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        return this.db.getAllFromIndex('sync_queue', 'by-created');
+    }
+    /** Mark an operation as completed (remove from queue, update record status) */
+    async markSynced(queueItemId, collection, recordId, serverVersion) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const tx = this.db.transaction(['records', 'sync_queue'], 'readwrite');
+        // Remove from queue
+        await tx.objectStore('sync_queue').delete(queueItemId);
+        // Update record status
+        const record = (await tx
+            .objectStore('records')
+            .get([collection, recordId]));
+        if (record) {
+            record._serverVersion = serverVersion;
+            record._syncStatus = 'synced';
+            await tx.objectStore('records').put(record);
+        }
+        await tx.done;
+    }
+    /** Mark an operation as failed (increment attempts, save error) */
+    async markFailed(queueItemId, error) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const item = (await this.db.get('sync_queue', queueItemId));
+        if (item) {
+            item.attempts += 1;
+            item.lastAttemptAt = Date.now();
+            item.error = error;
+            await this.db.put('sync_queue', item);
+        }
+    }
+    /** Apply data from server (via WebSocket or pull) */
+    async applyServerUpdate(collection, id, data, serverVersion) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const existing = (await this.db.get('records', [collection, id]));
+        // Conflict detection: local has changes not yet confirmed by server
+        if (existing && existing._localVersion > existing._serverVersion) {
+            // CRDT field-level merge if both sides have CRDT docs
+            if (existing._crdtDoc && data.__crdt) {
+                const remoteCrdtDoc = data.__crdt;
+                const merged = mergeLWW(existing._crdtDoc, remoteCrdtDoc);
+                const mergedData = fromDocument(merged);
+                if (this.clock) {
+                    this.clock.update(Math.max(...Object.values(merged).map((f) => f.lamport)));
+                    await this.persistLamport();
+                }
+                existing.data = mergedData;
+                existing._crdtDoc = merged;
+                existing._serverVersion = serverVersion;
+                existing._syncStatus = 'synced'; // CRDT merge resolved without conflict
+                await this.db.put('records', existing);
+                return;
+            }
+            // No CRDT doc — mark as conflict for manual resolution
+            existing._conflictData = data;
+            existing._serverVersion = serverVersion;
+            existing._syncStatus = 'conflict';
+            await this.db.put('records', existing);
+            return;
+        }
+        const record = {
+            id,
+            collection,
+            data,
+            _localVersion: existing?._localVersion || 0,
+            _serverVersion: serverVersion,
+            _syncStatus: 'synced',
+            _updatedAt: Date.now(),
+        };
+        await this.db.put('records', record);
+    }
+    /** Get records with conflicts for UI resolution */
+    async getConflicts(collection) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const all = (await this.db.getAllFromIndex('records', 'by-sync-status', 'conflict'));
+        if (collection)
+            return all.filter((r) => r.collection === collection);
+        return all;
+    }
+    /** Resolve a conflict (user decides which version wins) */
+    async resolveConflict(collection, id, resolvedData) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const record = (await this.db.get('records', [collection, id]));
+        if (record) {
+            record.data = resolvedData;
+            record._syncStatus = 'pending'; // Re-sync with server
+            record._localVersion += 1;
+            await this.db.put('records', record);
+        }
+    }
+    /** Save an offline blob — returns a temporary ID 'local_blob_<UUID>' */
+    async saveBlob(blob, collection, recordId, field) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const id = `local_blob_${crypto.randomUUID()}`;
+        const item = {
+            id,
+            blob,
+            collection,
+            recordId,
+            field,
+            createdAt: Date.now(),
+        };
+        await this.db.put('offline_blobs', item);
+        return id;
+    }
+    /** Returns all pending offline blobs */
+    async getPendingBlobs() {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        return this.db.getAll('offline_blobs');
+    }
+    /** Delete an offline blob after successful upload */
+    async deleteBlob(id) {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        await this.db.delete('offline_blobs', id);
+    }
+    /** Clear all local data */
+    async clear() {
+        if (!this.db)
+            throw new Error('LocalStore not opened');
+        const tx = this.db.transaction(['records', 'sync_queue', 'meta', 'offline_blobs'], 'readwrite');
+        await tx.objectStore('records').clear();
+        await tx.objectStore('sync_queue').clear();
+        await tx.objectStore('meta').clear();
+        await tx.objectStore('offline_blobs').clear();
+        await tx.done;
+    }
+    async close() {
+        this.db?.close();
+        this.db = null;
+    }
+}

package/dist/realtime.d.ts

@@ -0,0 +1,14 @@
+export declare class ZveltioRealtime {
+    private ws;
+    private listeners;
+    private baseUrl;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectTimer;
+    constructor(baseUrl: string);
+    connect(): void;
+    private attemptReconnect;
+    subscribe(collection: string, callback: (data: any) => void): () => void;
+    disconnect(): void;
+}
+//# sourceMappingURL=realtime.d.ts.map

package/dist/realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.d.ts","sourceRoot":"","sources":["../src/realtime.ts"],"names":[],"mappings":"AAAA,qBAAa,eAAe;IAC1B,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,SAAS,CAAoD;IACrE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,oBAAoB,CAAM;IAClC,OAAO,CAAC,cAAc,CAA8C;gBAExD,OAAO,EAAE,MAAM;IAK3B,OAAO,IAAI,IAAI;IAmCf,OAAO,CAAC,gBAAgB;IAQxB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG,MAAM,IAAI;IAqBxE,UAAU,IAAI,IAAI;CAQnB"}

package/dist/realtime.js

@@ -0,0 +1,82 @@
+export class ZveltioRealtime {
+    ws = null;
+    listeners = new Map();
+    baseUrl;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 10;
+    reconnectTimer = null;
+    constructor(baseUrl) {
+        // Convert http(s) to ws(s)
+        this.baseUrl = baseUrl.replace(/^http/, 'ws');
+    }
+    connect() {
+        const wsUrl = `${this.baseUrl}/api/ws`;
+        this.ws = new WebSocket(wsUrl);
+        this.ws.onopen = () => {
+            this.reconnectAttempts = 0;
+            // Re-subscribe to all existing collections using the server's expected protocol
+            const collections = [...this.listeners.keys()];
+            if (collections.length > 0) {
+                this.ws?.send(JSON.stringify({ type: 'subscribe', collections }));
+            }
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const msg = JSON.parse(event.data);
+                const collection = msg.collection;
+                const subs = this.listeners.get(collection);
+                if (subs) {
+                    subs.forEach((fn) => {
+                        try {
+                            fn(msg);
+                        }
+                        catch { /* ignore callback errors */ }
+                    });
+                }
+            }
+            catch { /* invalid JSON — ignore */ }
+        };
+        this.ws.onclose = () => {
+            this.attemptReconnect();
+        };
+        this.ws.onerror = () => {
+            this.ws?.close();
+        };
+    }
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts)
+            return;
+        // Exponential backoff: 1s, 2s, 4s, 8s, ...
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30_000);
+        this.reconnectAttempts++;
+        this.reconnectTimer = setTimeout(() => this.connect(), delay);
+    }
+    subscribe(collection, callback) {
+        if (!this.listeners.has(collection))
+            this.listeners.set(collection, new Set());
+        this.listeners.get(collection).add(callback);
+        // Send subscribe to server using correct protocol { type: 'subscribe', collections: [...] }
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({ type: 'subscribe', collections: [collection] }));
+        }
+        // Return unsubscribe function
+        return () => {
+            this.listeners.get(collection)?.delete(callback);
+            if (this.listeners.get(collection)?.size === 0) {
+                this.listeners.delete(collection);
+                if (this.ws?.readyState === WebSocket.OPEN) {
+                    this.ws.send(JSON.stringify({ type: 'unsubscribe', collections: [collection] }));
+                }
+            }
+        };
+    }
+    disconnect() {
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        this.reconnectAttempts = this.maxReconnectAttempts; // Prevent auto-reconnect
+        this.ws?.close();
+        this.ws = null;
+        this.listeners.clear();
+    }
+}

package/dist/schema-watcher.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Schema Watcher (P6 — End-to-End Type Safety)
+ *
+ * Watches the Zveltio engine for DDL schema changes via WebSocket and
+ * regenerates a TypeScript types file whenever a collection is created,
+ * updated, or deleted.
+ *
+ * Usage (in `zveltio dev --watch`):
+ *   import { watchSchema } from '@zveltio/sdk/schema-watcher';
+ *   await watchSchema('http://localhost:3000', './src/zveltio-types.d.ts');
+ */
+export interface CollectionField {
+    name: string;
+    type: string;
+    required?: boolean;
+}
+export interface CollectionSchema {
+    name: string;
+    display_name?: string;
+    fields: CollectionField[];
+}
+export interface WatchSchemaOptions {
+    /** API token for the engine (admin key) */
+    apiKey?: string;
+    /** Reconnect delay in ms (default: 3000) */
+    reconnectDelay?: number;
+    /** Called after each successful type regeneration */
+    onUpdate?: (collections: CollectionSchema[]) => void;
+    /** Called on connection errors */
+    onError?: (err: Error) => void;
+}
+/**
+ * Start watching the engine's WebSocket for schema changes and regenerate
+ * TypeScript types at `outputPath` whenever the schema changes.
+ *
+ * Returns a cleanup function that closes the WebSocket.
+ */
+export declare function watchSchema(engineUrl: string, outputPath: string, options?: WatchSchemaOptions): Promise<() => void>;
+/** One-shot type generation without watching. */
+export declare function generateTypes(engineUrl: string, outputPath: string, apiKey?: string): Promise<void>;
+//# sourceMappingURL=schema-watcher.d.ts.map

package/dist/schema-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-watcher.d.ts","sourceRoot":"","sources":["../src/schema-watcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,gBAAgB,EAAE,KAAK,IAAI,CAAC;IACrD,kCAAkC;IAClC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAC;CAChC;AA4GD;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,MAAM,IAAI,CAAC,CAyErB;AAED,iDAAiD;AACjD,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAKf"}

package/dist/schema-watcher.js

@@ -0,0 +1,182 @@
+/**
+ * Schema Watcher (P6 — End-to-End Type Safety)
+ *
+ * Watches the Zveltio engine for DDL schema changes via WebSocket and
+ * regenerates a TypeScript types file whenever a collection is created,
+ * updated, or deleted.
+ *
+ * Usage (in `zveltio dev --watch`):
+ *   import { watchSchema } from '@zveltio/sdk/schema-watcher';
+ *   await watchSchema('http://localhost:3000', './src/zveltio-types.d.ts');
+ */
+const TYPE_MAP = {
+    text: 'string',
+    textarea: 'string',
+    richtext: 'string',
+    email: 'string',
+    url: 'string',
+    slug: 'string',
+    color: 'string',
+    phone: 'string',
+    password: 'string',
+    uuid: 'string',
+    enum: 'string',
+    tags: 'string[]',
+    integer: 'number',
+    float: 'number',
+    number: 'number',
+    boolean: 'boolean',
+    date: 'string',
+    datetime: 'string',
+    json: 'Record<string, unknown>',
+    file: 'string',
+    image: 'string',
+    location: '{ lat: number; lng: number }',
+    geometry: 'GeoJSON.Geometry',
+    vector: 'number[]',
+    m2o: 'string',
+    o2m: 'string[]',
+    m2m: 'string[]',
+};
+function fieldToType(field) {
+    return TYPE_MAP[field.type] ?? 'unknown';
+}
+function collectionToInterface(col) {
+    const lines = [`export interface ${toPascalCase(col.name)} {`];
+    lines.push(`  id: string;`);
+    lines.push(`  created_at: string;`);
+    lines.push(`  updated_at: string;`);
+    for (const field of col.fields) {
+        const tsType = fieldToType(field);
+        const optional = field.required ? '' : '?';
+        lines.push(`  ${field.name}${optional}: ${tsType};`);
+    }
+    lines.push(`}`);
+    return lines.join('\n');
+}
+function generateTypesFile(collections) {
+    const header = `// Auto-generated by @zveltio/sdk schema-watcher
+// Do not edit manually — changes will be overwritten on schema updates.
+// Generated at: ${new Date().toISOString()}
+
+`;
+    const interfaces = collections.map(collectionToInterface).join('\n\n');
+    const collectionNames = collections.map((c) => `'${c.name}'`).join(' | ');
+    const collectionMap = collections
+        .map((c) => `  ${c.name}: ${toPascalCase(c.name)};`)
+        .join('\n');
+    const clientType = `
+export type CollectionName = ${collectionNames || 'never'};
+
+export interface CollectionTypeMap {
+${collectionMap}
+}
+
+/** Pass this to createZveltioClient<ZveltioSchema>() for full type inference */
+export type ZveltioSchema = CollectionTypeMap;
+`;
+    return header + interfaces + clientType;
+}
+function toPascalCase(str) {
+    return str
+        .split('_')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+async function fetchCollections(engineUrl, apiKey) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (apiKey)
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    const res = await fetch(`${engineUrl}/api/collections`, { headers });
+    if (!res.ok)
+        throw new Error(`Failed to fetch collections: ${res.status}`);
+    const data = await res.json();
+    return data.collections || [];
+}
+async function writeTypes(outputPath, content) {
+    // Use Bun.file in Bun runtime, fall back to dynamic import of fs in Node
+    if (typeof Bun !== 'undefined') {
+        await Bun.write(outputPath, content);
+    }
+    else {
+        const { writeFile } = await import('node:fs/promises');
+        await writeFile(outputPath, content, 'utf8');
+    }
+}
+/**
+ * Start watching the engine's WebSocket for schema changes and regenerate
+ * TypeScript types at `outputPath` whenever the schema changes.
+ *
+ * Returns a cleanup function that closes the WebSocket.
+ */
+export async function watchSchema(engineUrl, outputPath, options = {}) {
+    const { apiKey, reconnectDelay = 3000, onUpdate, onError } = options;
+    // Generate initial types on startup
+    try {
+        const collections = await fetchCollections(engineUrl, apiKey);
+        const content = generateTypesFile(collections);
+        await writeTypes(outputPath, content);
+        console.log(`[zveltio] ✓ Types generated at ${outputPath} (${collections.length} collections)`);
+        onUpdate?.(collections);
+    }
+    catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        console.warn(`[zveltio] Could not generate initial types:`, e.message);
+        onError?.(e);
+    }
+    const wsUrl = engineUrl.replace(/^http/, 'ws') + '/api/ws';
+    let ws = null;
+    let stopped = false;
+    function connect() {
+        if (stopped)
+            return;
+        ws = new WebSocket(wsUrl);
+        ws.onopen = () => {
+            console.log('[zveltio] Schema watcher connected.');
+            // Subscribe to all schema change events
+            ws.send(JSON.stringify({ type: 'subscribe', channel: 'schema' }));
+        };
+        ws.onmessage = async (event) => {
+            try {
+                const msg = JSON.parse(event.data);
+                const isSchemaChange = msg.event === 'schema:changed' ||
+                    msg.type === 'schema:changed' ||
+                    ['create_collection', 'drop_collection', 'add_field', 'drop_field'].includes(msg.event);
+                if (!isSchemaChange)
+                    return;
+                const collections = await fetchCollections(engineUrl, apiKey);
+                const content = generateTypesFile(collections);
+                await writeTypes(outputPath, content);
+                const changed = msg.collection ?? msg.data?.collection ?? '?';
+                console.log(`[zveltio] ✓ Types updated — ${changed} changed (${collections.length} total)`);
+                onUpdate?.(collections);
+            }
+            catch (err) {
+                // Non-fatal: keep watching
+            }
+        };
+        ws.onclose = () => {
+            if (!stopped) {
+                console.log(`[zveltio] Schema watcher disconnected. Reconnecting in ${reconnectDelay}ms…`);
+                setTimeout(connect, reconnectDelay);
+            }
+        };
+        ws.onerror = (event) => {
+            const err = new Error('WebSocket error');
+            onError?.(err);
+        };
+    }
+    connect();
+    return () => {
+        stopped = true;
+        ws?.close();
+        console.log('[zveltio] Schema watcher stopped.');
+    };
+}
+/** One-shot type generation without watching. */
+export async function generateTypes(engineUrl, outputPath, apiKey) {
+    const collections = await fetchCollections(engineUrl, apiKey);
+    const content = generateTypesFile(collections);
+    await writeTypes(outputPath, content);
+    console.log(`[zveltio] ✓ Types generated at ${outputPath} (${collections.length} collections)`);
+}

package/dist/svelte.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Svelte 5 runes integration with SyncManager.
+ *
+ * Usage in Svelte 5 components:
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   import { SyncManager } from '@zveltio/sdk';
+ *   import { useSyncCollection, useSyncStatus } from '@zveltio/sdk/svelte';
+ *
+ *   let todos = $state<any[]>([]);
+ *   const unsub = useSyncCollection(sync, 'todos', (records) => { todos = records; });
+ *
+ *   let status = $state({ pending: 0, conflicts: 0, isOnline: true });
+ *   const unsubStatus = useSyncStatus(sync, (s) => { status = s; });
+ *
+ *   onDestroy(() => { unsub(); unsubStatus(); });
+ * </script>
+ * ```
+ */
+import type { SyncManager } from './sync-manager.js';
+/**
+ * Subscribe to a collection via SyncManager.
+ * Calls `setter` immediately with current state and on each update.
+ * Returns the unsubscribe function.
+ */
+export declare function useSyncCollection(sync: SyncManager, collection: string, setter: (records: any[]) => void): () => void;
+/**
+ * Subscribe to sync status (pending, conflicts, isOnline).
+ * Calls `setter` immediately and on each sync cycle.
+ * Returns the cleanup function.
+ */
+export declare function useSyncStatus(sync: SyncManager, setter: (status: {
+    pending: number;
+    conflicts: number;
+    isOnline: boolean;
+}) => void, intervalMs?: number): () => void;
+//# sourceMappingURL=svelte.d.ts.map

package/dist/svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte.d.ts","sourceRoot":"","sources":["../src/svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,IAAI,GAC/B,MAAM,IAAI,CAGZ;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,CAAC,MAAM,EAAE;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB,KAAK,IAAI,EACV,UAAU,SAAO,GAChB,MAAM,IAAI,CAeZ"}

package/dist/svelte.js

@@ -0,0 +1,48 @@
+/**
+ * Svelte 5 runes integration with SyncManager.
+ *
+ * Usage in Svelte 5 components:
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   import { SyncManager } from '@zveltio/sdk';
+ *   import { useSyncCollection, useSyncStatus } from '@zveltio/sdk/svelte';
+ *
+ *   let todos = $state<any[]>([]);
+ *   const unsub = useSyncCollection(sync, 'todos', (records) => { todos = records; });
+ *
+ *   let status = $state({ pending: 0, conflicts: 0, isOnline: true });
+ *   const unsubStatus = useSyncStatus(sync, (s) => { status = s; });
+ *
+ *   onDestroy(() => { unsub(); unsubStatus(); });
+ * </script>
+ * ```
+ */
+/**
+ * Subscribe to a collection via SyncManager.
+ * Calls `setter` immediately with current state and on each update.
+ * Returns the unsubscribe function.
+ */
+export function useSyncCollection(sync, collection, setter) {
+    const col = sync.collection(collection);
+    return col.subscribe(setter);
+}
+/**
+ * Subscribe to sync status (pending, conflicts, isOnline).
+ * Calls `setter` immediately and on each sync cycle.
+ * Returns the cleanup function.
+ */
+export function useSyncStatus(sync, setter, intervalMs = 2000) {
+    // Emit immediately
+    sync.getStatus().then(setter);
+    // Periodic poll (SyncManager doesn't have event system for status)
+    const timer = setInterval(() => {
+        sync
+            .getStatus()
+            .then(setter)
+            .catch(() => {
+            /* ignore */
+        });
+    }, intervalMs);
+    return () => clearInterval(timer);
+}