@affectively/dash 5.4.1 → 5.4.5

package/dist/src/engine/vec_extension.d.ts

@@ -1,5 +0,0 @@
-import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
-type Sqlite3Module = Awaited<ReturnType<typeof sqlite3InitModule>>;
-type Database = Sqlite3Module['oo1']['OpfsDb'] | Sqlite3Module['oo1']['DB'];
-export declare function loadVectorExtension(db: Database): Promise<void>;
-export {};

package/dist/src/engine/vec_extension.js

@@ -1,10 +0,0 @@
-export async function loadVectorExtension(db) {
-    // Hypothetical API for loading WASM extension if sqlite-wasm supports it.
-    // Currently sqlite-wasm static builds don't easily support dynamic extension loading
-    // without a custom build.
-    // For this 'cutting edge' roadmap implementation, we will simulate the
-    // extension's presence or use a polyfill pattern if the raw WASM isn't present.
-    console.log("Loading sqlite-vec extension...");
-    // register native functions if possible
-    // db.createFunction(...)
-}

package/dist/src/index.d.ts

@@ -1,21 +0,0 @@
-export { dash } from './engine/sqlite.js';
-export type { CloudConfig, CloudSyncResult } from './engine/sqlite.js';
-export { liveQuery, signal, effect, computed } from './reactivity/signal.js';
-export { mcpServer } from './mcp/server.js';
-export { YjsSqliteProvider } from './sync/provider.js';
-export { backup, restore, generateKey, exportKey, importKey } from './sync/backup.js';
-export type { CloudStorageAdapter } from './sync/backup.js';
-export { HybridProvider } from './sync/hybrid-provider.js';
-export type { RelayDiscoveryConfig, RelayPerformanceConfig, RelayPrivacyConfig, ConnectionStatus, ProviderStatus, } from './sync/hybrid-provider.js';
-export { AutomergeProvider } from './sync/AutomergeProvider.js';
-export type { AutomergeProviderOptions } from './sync/AutomergeProvider.js';
-export type { AutomergeProviderConfig } from './sync/types.js';
-export { AeonDurableSyncRuntime } from './sync/AeonDurableSync.js';
-export type { AeonDurableSyncConfig } from './sync/AeonDurableSync.js';
-export { D1SyncProvider, getD1SyncProvider, resetD1SyncProvider } from './sync/d1-provider.js';
-export type { D1SyncConfig, SyncResult, SyncQueueEntry } from './sync/d1-provider.js';
-export * as firebase from './api/firebase/index.js';
-export { collection, doc, query, where, orderBy, limit, limitToLast, startAt, startAfter, endAt, endBefore, offset, Timestamp, GeoPoint, serverTimestamp, deleteField, arrayUnion, arrayRemove, increment, getDoc, getDocs, setDoc, updateDoc, deleteDoc, writeBatch, runTransaction, onSnapshot, } from './api/firebase/index.js';
-export { ref, child, set, update, remove, push, get, onDisconnect, onValue, off, } from './api/firebase/index.js';
-export { createUserWithEmailAndPassword, signInWithEmailAndPassword, signInAnonymously, signOut, getAuth, onAuthStateChanged, updateUserProfile, updateUserEmail, updateUserPassword, deleteUser, sendPasswordResetEmail, sendEmailVerification, GoogleAuthProvider, GithubAuthProvider, FacebookAuthProvider, TwitterAuthProvider, DiscordAuthProvider, TotpMultiFactorGenerator, PhoneMultiFactorGenerator, setPersistence, browserLocalPersistence, browserSessionPersistence, inMemoryPersistence, } from './api/firebase/index.js';
-export { ref as storageRef, refFromURL, child as storageChild, uploadBytes, uploadBytesResumable, uploadString, getBytes, getDownloadURL, getMetadata, updateMetadata, deleteObject, list as listFiles, listAll, } from './api/firebase/storage/index.js';

package/dist/src/index.js

@@ -1,26 +0,0 @@
-export { dash } from './engine/sqlite.js';
-export { liveQuery, signal, effect, computed } from './reactivity/signal.js';
-export { mcpServer } from './mcp/server.js';
-// Sync exports
-export { YjsSqliteProvider } from './sync/provider.js';
-export { backup, restore, generateKey, exportKey, importKey } from './sync/backup.js';
-export { HybridProvider } from './sync/hybrid-provider.js';
-export { AutomergeProvider } from './sync/AutomergeProvider.js';
-export { AeonDurableSyncRuntime } from './sync/AeonDurableSync.js';
-// D1 HTTP Sync (legacy - prefer dash.enableCloudSync())
-export { D1SyncProvider, getD1SyncProvider, resetD1SyncProvider } from './sync/d1-provider.js';
-// Firebase Compatibility API exports
-export * as firebase from './api/firebase/index.js';
-// Firestore
-export { collection, doc, query, where, orderBy, limit, limitToLast, startAt, startAfter, endAt, endBefore, offset, serverTimestamp, deleteField, arrayUnion, arrayRemove, increment, getDoc, getDocs, setDoc, updateDoc, deleteDoc, writeBatch, runTransaction, onSnapshot, } from './api/firebase/index.js';
-// Realtime Database
-export { ref, child, set, update, remove, push, get, onDisconnect, onValue, 
-// onChildAdded,
-// onChildChanged,
-// onChildRemoved,
-// onChildMoved,
-off, } from './api/firebase/index.js';
-// Authentication
-export { createUserWithEmailAndPassword, signInWithEmailAndPassword, signInAnonymously, signOut, getAuth, onAuthStateChanged, updateUserProfile, updateUserEmail, updateUserPassword, deleteUser, sendPasswordResetEmail, sendEmailVerification, GoogleAuthProvider, GithubAuthProvider, FacebookAuthProvider, TwitterAuthProvider, DiscordAuthProvider, TotpMultiFactorGenerator, PhoneMultiFactorGenerator, setPersistence, browserLocalPersistence, browserSessionPersistence, inMemoryPersistence, } from './api/firebase/index.js';
-// Storage
-export { ref as storageRef, refFromURL, child as storageChild, uploadBytes, uploadBytesResumable, uploadString, getBytes, getDownloadURL, getMetadata, updateMetadata, deleteObject, list as listFiles, listAll, } from './api/firebase/storage/index.js';

package/dist/src/mcp/server.js

@@ -1,87 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { dash } from '../engine/sqlite.js';
-export class DashMCPServer {
-    server;
-    constructor() {
-        this.server = new Server({
-            name: 'dash-local-db',
-            version: '2.0.0',
-        }, {
-            capabilities: {
-                resources: {},
-                tools: {},
-            },
-        });
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        // List Resources: Expose all tables as resources
-        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-            await dash.ready();
-            // Get all table names
-            const tables = dash.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
-            return {
-                resources: tables.map((t) => ({
-                    uri: `mcp://local/dash/${t.name}`,
-                    name: t.name,
-                    mimeType: 'application/json',
-                    description: `Table: ${t.name}`,
-                })),
-            };
-        });
-        // Read Resource: Return table content
-        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-            const uri = request.params.uri;
-            const tableName = uri.split('/').pop();
-            if (!tableName)
-                throw new Error('Invalid URI');
-            const rows = dash.execute(`SELECT * FROM ${tableName} LIMIT 100`);
-            return {
-                contents: [{
-                        uri: uri,
-                        mimeType: 'application/json',
-                        text: JSON.stringify(rows, null, 2),
-                    }],
-            };
-        });
-        // List Tools: Expose Semantic Search
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return {
-                tools: [{
-                        name: 'semantic_search',
-                        description: 'Search the Dash database using vector similarity (semantic search).',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                query: { type: 'string', description: 'The search query string.' },
-                            },
-                            required: ['query'],
-                        },
-                    }],
-            };
-        });
-        // Call Tool: Execute Semantic Search
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            if (request.params.name === 'semantic_search') {
-                const query = request.params.arguments?.query;
-                if (!query)
-                    throw new Error('Missing query argument');
-                const results = await dash.search(query);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify(results, null, 2),
-                        }],
-                };
-            }
-            throw new Error('Tool not found');
-        });
-    }
-    // Method to connect to a transport (e.g., SSE for web)
-    async connect(transport) {
-        await this.server.connect(transport);
-        console.log('Dash MCP Server Connected');
-    }
-}
-export const mcpServer = new DashMCPServer();

package/dist/src/reactivity/signal.js

@@ -1,31 +0,0 @@
-import { signal } from '@preact/signals-core';
-import { dash } from '../engine/sqlite.js';
-export function liveQuery(sql, bind) {
-    const data = signal([]);
-    const run = async () => {
-        await dash.ready();
-        try {
-            const result = dash.execute(sql, bind);
-            data.value = result;
-        }
-        catch (e) {
-            console.error('Dash LiveQuery Error:', e);
-        }
-    };
-    // Run immediately
-    run();
-    // Subscribe to database changes
-    // Parse table name naively
-    const match = sql.match(/FROM\s+([a-zA-Z0-9_]+)/i);
-    const table = match ? match[1] : null;
-    if (table) {
-        dash.subscribe(table, () => {
-            run();
-        });
-    }
-    else {
-        console.warn('Dash: Could not identify table for liveQuery', sql);
-    }
-    return data;
-}
-export { signal, effect, computed } from '@preact/signals-core';

package/dist/src/schema/lens.d.ts

@@ -1,29 +0,0 @@
-export type LensOp = {
-    kind: 'rename';
-    source: string;
-    target: string;
-} | {
-    kind: 'hoist';
-    host: string;
-    name: string;
-} | {
-    kind: 'wrap';
-    name: string;
-};
-export interface SchemaLens {
-    from: number;
-    to: number;
-    ops: LensOp[];
-}
-export declare class LensEngine {
-    private lenses;
-    private currentVersion;
-    constructor(currentVersion: number);
-    registerLens(from: number, to: number, ops: LensOp[]): void;
-    private findPath;
-    migrate(data: any, from: number, to?: number): any;
-    private normalizeOps;
-    private invertOp;
-    private applyOp;
-}
-export declare const schema: LensEngine;

package/dist/src/schema/lens.js

@@ -1,122 +0,0 @@
-// Native Bidirectional Lens Implementation
-// Inspired by Project Cambria
-export class LensEngine {
-    lenses = [];
-    currentVersion;
-    constructor(currentVersion) {
-        this.currentVersion = currentVersion;
-    }
-    registerLens(from, to, ops) {
-        this.lenses.push({ from, to, ops });
-    }
-    // Find path from V_start to V_end
-    findPath(from, to) {
-        // BFS to find shortest path
-        const queue = [{ version: from, path: [] }];
-        const visited = new Set([from]);
-        while (queue.length > 0) {
-            const { version, path } = queue.shift();
-            if (version === to)
-                return path;
-            // Find neighbors
-            // Forward lenses
-            const forward = this.lenses.filter(l => l.from === version);
-            for (const lens of forward) {
-                if (!visited.has(lens.to)) {
-                    visited.add(lens.to);
-                    queue.push({ version: lens.to, path: [...path, lens] });
-                }
-            }
-            // Reverse lenses (Implicit)
-            const backward = this.lenses.filter(l => l.to === version);
-            for (const lens of backward) {
-                if (!visited.has(lens.from)) {
-                    visited.add(lens.from);
-                    // Create synthetic reverse lens
-                    const reverseLens = {
-                        from: lens.to,
-                        to: lens.from,
-                        ops: [...lens.ops].reverse() // Ops must be reversed!
-                    };
-                    queue.push({ version: lens.from, path: [...path, reverseLens] });
-                }
-            }
-        }
-        throw new Error(`No translation path found from v${from} to v${to}`);
-    }
-    migrate(data, from, to = this.currentVersion) {
-        if (from === to)
-            return data;
-        const path = this.findPath(from, to);
-        let doc = JSON.parse(JSON.stringify(data)); // Deep clone to avoid mutation
-        for (const step of path) {
-            const isForward = step.from < step.to; // Heuristic: Assuming localized version jumps
-            // Actually we should just apply the ops in the step direction.
-            // But we need to know if the step is a "Forward Lens" or a "Reverse Lens" 
-            // because ops like 'rename' need to swap source/target if reversed.
-            // The path finding creates "synthetic" lenses for reverse steps where from > to.
-            // So we just need to apply 'step.ops' carefully. 
-            // But wait! in findPath, I just reversed the ARRAY of ops.
-            // I ALSO need to invert the OPERATORS themselves.
-            const opsToApply = this.normalizeOps(step);
-            for (const op of opsToApply) {
-                doc = this.applyOp(doc, op);
-            }
-        }
-        return doc;
-    }
-    normalizeOps(step) {
-        // If this lens was registered as from=1, to=2
-        // And we are using it as from=1, to=2. No change.
-        // If we are traversing 2->1.
-        // The findPath constructed a lens { from: 2, to: 1, ops: ops.reverse() }
-        // But the ops inside are still { kind: 'rename', source: 'old', target: 'new' }
-        // We need to invert them to { kind: 'rename', source: 'new', target: 'old' }
-        // We need to know the *registred* direction to know if inversion is needed?
-        // Actually findPath constructs a fresh object. We can check if it exists in this.lenses.
-        const registered = this.lenses.find(l => l.from === step.from && l.to === step.to);
-        if (registered) {
-            return step.ops; // Direct match, use as is
-        }
-        // Must be a reverse step constructed by findPath
-        return step.ops.map(op => this.invertOp(op));
-    }
-    invertOp(op) {
-        switch (op.kind) {
-            case 'rename': return { kind: 'rename', source: op.target, target: op.source };
-            // Invert Hoist: Wrap?
-            // Hoist: host='meta', name='key' (moves doc.meta.key -> doc.key)
-            // Inverse: Wrap (moves doc.key -> doc.meta.key)
-            // Use 'wrap' as simplified inverse of simple hoist
-            case 'hoist': return { kind: 'wrap', name: op.name }; // Simplified
-            case 'wrap': return { kind: 'hoist', host: 'container', name: op.name }; // Naive inverse
-            default: return op;
-        }
-    }
-    applyOp(doc, op) {
-        switch (op.kind) {
-            case 'rename': {
-                if (doc[op.source] !== undefined) {
-                    doc[op.target] = doc[op.source];
-                    delete doc[op.source];
-                }
-                return doc;
-            }
-            case 'hoist': {
-                // Extract property from scalar host? Or object?
-                // Assume simple object flattening: { data: { val: 1 } } -> hoist 'data', 'val' -> { val: 1 }
-                // doc[op.host][op.name] -> doc[op.name]
-                if (doc[op.host] && doc[op.host][op.name] !== undefined) {
-                    doc[op.name] = doc[op.host][op.name];
-                    delete doc[op.host][op.name];
-                    if (Object.keys(doc[op.host]).length === 0)
-                        delete doc[op.host];
-                }
-                return doc;
-            }
-            default: return doc;
-        }
-    }
-}
-export const schema = new LensEngine(1);
-// Default to v1 until configured

package/dist/src/sync/AeonDurableSync.js

@@ -1,133 +0,0 @@
-/**
- * AeonDurableSync - Durable telemetry runtime for sync operations
- *
- * Records transport selection, discovery events, and sync protocol messages
- * using Aeon's OfflineOperationQueue, SyncProtocol, and ReplicationManager
- * with real persistence through DashStorageAdapter.
- */
-import { OfflineOperationQueue, SyncProtocol, ReplicationManager, DashStorageAdapter, InMemoryStorageAdapter, } from '@affectively/aeon';
-function createBrowserStorageBackend() {
-    return {
-        get(key) {
-            if (typeof localStorage === 'undefined') {
-                return null;
-            }
-            try {
-                return localStorage.getItem(key);
-            }
-            catch {
-                return null;
-            }
-        },
-        set(key, value) {
-            if (typeof localStorage === 'undefined') {
-                return;
-            }
-            try {
-                localStorage.setItem(key, value);
-            }
-            catch {
-                // best-effort persistence in constrained browser contexts
-            }
-        },
-        delete(key) {
-            if (typeof localStorage === 'undefined') {
-                return;
-            }
-            try {
-                localStorage.removeItem(key);
-            }
-            catch {
-                // best-effort persistence in constrained browser contexts
-            }
-        },
-    };
-}
-export class AeonDurableSyncRuntime {
-    queue;
-    protocol;
-    replication;
-    constructor(config) {
-        const prefix = config.persistenceKeyPrefix ?? `dash:aeon:${config.roomName}`;
-        const adapter = config.enabled === false
-            ? new InMemoryStorageAdapter()
-            : new DashStorageAdapter(config.storageBackend ?? createBrowserStorageBackend(), config.storageOptions ?? {});
-        this.queue = new OfflineOperationQueue({
-            persistence: {
-                adapter,
-                key: `${prefix}:offline`,
-                autoPersist: true,
-                autoLoad: true,
-            },
-        });
-        this.protocol = new SyncProtocol({
-            persistence: {
-                adapter,
-                key: `${prefix}:protocol`,
-                autoPersist: true,
-                autoLoad: true,
-            },
-        });
-        this.replication = new ReplicationManager({
-            persistence: {
-                adapter,
-                key: `${prefix}:replication`,
-                autoPersist: true,
-                autoLoad: true,
-            },
-        });
-    }
-    async initialize() {
-        try {
-            await Promise.all([
-                this.queue.loadFromPersistence(),
-                this.protocol.loadFromPersistence(),
-                this.replication.loadFromPersistence(),
-            ]);
-        }
-        catch {
-            // Persistence hydration is optional; runtime should stay operational.
-        }
-    }
-    recordTransportSelection(roomName, transport, relay) {
-        if (!transport) {
-            return;
-        }
-        try {
-            this.queue.enqueue('update', {
-                roomName,
-                event: 'transport-selected',
-                transport,
-                relay,
-                ts: Date.now(),
-            }, roomName, 'normal');
-            this.protocol.createSyncRequestMessage(roomName, relay ?? 'unknown-relay', `transport-${Date.now()}`, '0.0.0', '1.1.0', {
-                transport,
-                relay,
-            });
-        }
-        catch {
-            // Telemetry durability must never impact foreground sync operations.
-        }
-    }
-    recordDiscovery(roomName, relays) {
-        const sanitizedRelays = relays
-            .filter((relay) => typeof relay === 'string' && relay.length > 0)
-            .slice(0, 32);
-        try {
-            this.queue.enqueue('sync', {
-                roomName,
-                event: 'relay-discovery',
-                count: sanitizedRelays.length,
-                relays: sanitizedRelays,
-                ts: Date.now(),
-            }, roomName, 'low');
-        }
-        catch {
-            // Telemetry durability must never impact foreground sync operations.
-        }
-    }
-    getPendingOperations() {
-        return this.queue.getPendingCount();
-    }
-}

package/dist/src/sync/AutomergeProvider.js

@@ -1,153 +0,0 @@
-/**
- * AutomergeProvider - Automerge sync over WebSocket relay
- *
- * Mirrors HybridProvider's transport selection and discovery logic
- * but uses Automerge's built-in sync protocol instead of Yjs.
- * The relay server is CRDT-agnostic — it relays opaque binary frames.
- *
- * @automerge/automerge is dynamically imported so users who only use
- * Yjs never pay the bundle cost.
- */
-export class AutomergeProvider {
-    config;
-    _doc;
-    _onChange;
-    _ws = null;
-    _syncState = null;
-    _automerge = null;
-    _ready;
-    _destroyed = false;
-    _reconnectTimer = null;
-    _reconnectDelayMs = 1000;
-    _maxReconnectDelayMs = 30_000;
-    constructor(doc, config, options) {
-        this._doc = doc;
-        this.config = config;
-        this._onChange = options?.onChange;
-        this._ready = this.initialize();
-    }
-    async initialize() {
-        const am = await import('@automerge/automerge');
-        this._automerge = am;
-        this._syncState = am.initSyncState();
-        this.connectWebSocket();
-    }
-    getRelayUrl() {
-        if (this.config.websocket?.url) {
-            return toWsUrl(this.config.websocket.url);
-        }
-        if (this.config.webtransport?.url) {
-            return toWsUrl(this.config.webtransport.url);
-        }
-        return null;
-    }
-    connectWebSocket() {
-        if (this._destroyed)
-            return;
-        const relayUrl = this.getRelayUrl();
-        if (!relayUrl)
-            return;
-        const separator = relayUrl.includes('?') ? '&' : '?';
-        const params = new URLSearchParams({ room: this.config.roomName });
-        if (this.config.apiKey) {
-            params.set('apiKey', this.config.apiKey);
-        }
-        const url = `${relayUrl}${separator}${params.toString()}`;
-        try {
-            this._ws = new WebSocket(url);
-            this._ws.binaryType = 'arraybuffer';
-        }
-        catch {
-            this.scheduleReconnect();
-            return;
-        }
-        this._ws.addEventListener('open', () => {
-            this._reconnectDelayMs = 1000;
-            this.sendSyncMessage();
-        });
-        this._ws.addEventListener('message', (event) => {
-            this.handleMessage(event.data);
-        });
-        this._ws.addEventListener('close', () => {
-            this._ws = null;
-            this.scheduleReconnect();
-        });
-        this._ws.addEventListener('error', () => {
-            // close event will follow and trigger reconnect
-        });
-    }
-    scheduleReconnect() {
-        if (this._destroyed || this._reconnectTimer)
-            return;
-        this._reconnectTimer = setTimeout(() => {
-            this._reconnectTimer = null;
-            this.connectWebSocket();
-        }, this._reconnectDelayMs);
-        this._reconnectDelayMs = Math.min(this._reconnectDelayMs * 2, this._maxReconnectDelayMs);
-    }
-    sendSyncMessage() {
-        const am = this._automerge;
-        if (!am || !this._ws || this._ws.readyState !== WebSocket.OPEN)
-            return;
-        const [nextSyncState, message] = am.generateSyncMessage(this._doc, this._syncState);
-        this._syncState = nextSyncState;
-        if (message) {
-            this._ws.send(message);
-        }
-    }
-    handleMessage(data) {
-        const am = this._automerge;
-        if (!am)
-            return;
-        const message = new Uint8Array(data);
-        const [nextDoc, nextSyncState] = am.receiveSyncMessage(this._doc, this._syncState, message);
-        this._doc = nextDoc;
-        this._syncState = nextSyncState;
-        this._onChange?.(this._doc);
-        // After receiving, we may need to send our own changes
-        this.sendSyncMessage();
-    }
-    /**
-     * Update the local document. Required because Automerge documents are immutable —
-     * after calling Automerge.change(), pass the new doc here to sync it.
-     */
-    updateDoc(newDoc) {
-        this._doc = newDoc;
-        this.sendSyncMessage();
-    }
-    get doc() {
-        return this._doc;
-    }
-    get ready() {
-        return this._ready;
-    }
-    get roomName() {
-        return this.config.roomName;
-    }
-    get connected() {
-        return this._ws !== null && this._ws.readyState === WebSocket.OPEN;
-    }
-    disconnect() {
-        if (this._reconnectTimer) {
-            clearTimeout(this._reconnectTimer);
-            this._reconnectTimer = null;
-        }
-        if (this._ws) {
-            this._ws.close();
-            this._ws = null;
-        }
-    }
-    async destroy() {
-        this._destroyed = true;
-        this.disconnect();
-    }
-}
-function toWsUrl(url) {
-    if (url.startsWith('wss://') || url.startsWith('ws://'))
-        return url;
-    if (url.startsWith('https://'))
-        return `wss://${url.slice('https://'.length)}`;
-    if (url.startsWith('http://'))
-        return `ws://${url.slice('http://'.length)}`;
-    return url;
-}

package/dist/src/sync/aeon/config.d.ts

@@ -1,21 +0,0 @@
-/**
- * Aeon Integration Configuration
- *
- * Configuration for Aeon sync features in Dash.
- * All features enabled by default.
- */
-export interface AeonConfig {
-    /** Enable delta sync optimization (70-80% bandwidth reduction) */
-    enableDeltaSync: boolean;
-    /** Enable rich presence tracking (cursors, sections, activity) */
-    enableRichPresence: boolean;
-    /** Enable offline operation queuing */
-    enableOfflineQueue: boolean;
-    /** Bytes threshold before falling back to full sync instead of delta */
-    deltaThreshold: number;
-    /** Maximum operations to hold in offline queue */
-    maxOfflineQueueSize: number;
-    /** Maximum retries for failed offline operations */
-    maxOfflineRetries: number;
-}
-export declare const defaultAeonConfig: AeonConfig;

package/dist/src/sync/aeon/config.js

@@ -1,14 +0,0 @@
-/**
- * Aeon Integration Configuration
- *
- * Configuration for Aeon sync features in Dash.
- * All features enabled by default.
- */
-export const defaultAeonConfig = {
-    enableDeltaSync: true,
-    enableRichPresence: true,
-    enableOfflineQueue: true,
-    deltaThreshold: 1000,
-    maxOfflineQueueSize: 1000,
-    maxOfflineRetries: 3,
-};