@affectively/dash 5.0.1 → 5.1.1

package/dist/src/sync/aeon/presence-adapter.js

@@ -0,0 +1,157 @@
+/**
+ * Presence Adapter for Dash
+ *
+ * Bridges Yjs awareness protocol with Aeon's AgentPresenceManager.
+ * Provides rich presence features: cursor tracking, active sections, roles.
+ */
+import { AgentPresenceManager, } from '@affectively/aeon';
+/**
+ * Adapter that syncs Yjs awareness with Aeon presence
+ */
+export class DashPresenceAdapter {
+    aeonPresence;
+    yjsAwareness;
+    localAgentId;
+    roomId;
+    constructor(roomId, awareness) {
+        this.roomId = roomId;
+        this.yjsAwareness = awareness;
+        this.localAgentId = `agent-${awareness.clientID}`;
+        this.aeonPresence = new AgentPresenceManager(roomId);
+        // Register local agent
+        this.aeonPresence.agentJoined(this.localAgentId, `User ${awareness.clientID}`, 'user');
+        // Bidirectional sync setup
+        this.setupYjsToAeonSync();
+        this.setupAeonToYjsSync();
+    }
+    /**
+     * Sync Yjs awareness updates to Aeon presence
+     */
+    setupYjsToAeonSync() {
+        this.yjsAwareness.on('update', ({ added, updated, removed }) => {
+            const states = this.yjsAwareness.getStates();
+            // Handle added/updated
+            for (const clientId of [...added, ...updated]) {
+                const state = states.get(clientId);
+                if (state) {
+                    const agentId = `agent-${clientId}`;
+                    if (added.includes(clientId)) {
+                        this.aeonPresence.agentJoined(agentId, state.user?.name || `User ${clientId}`, state.user?.role || 'user', state.metadata);
+                    }
+                    // Sync cursor and section if present
+                    if (state.cursor) {
+                        this.aeonPresence.updateCursor(agentId, state.cursor.x ?? 0, state.cursor.y ?? 0, state.cursor.path ?? '');
+                    }
+                    if (state.activeSection) {
+                        this.aeonPresence.updateActiveSection(agentId, state.activeSection);
+                    }
+                    // Heartbeat to keep presence alive
+                    this.aeonPresence.heartbeat(agentId);
+                }
+            }
+            // Handle removed
+            for (const clientId of removed) {
+                this.aeonPresence.agentLeft(`agent-${clientId}`);
+            }
+        });
+    }
+    /**
+     * Sync Aeon presence updates back to Yjs awareness
+     */
+    setupAeonToYjsSync() {
+        // When local presence updates via Aeon API, reflect to Yjs
+        this.aeonPresence.on('cursor_updated', ({ agentId, cursorPosition }) => {
+            if (agentId === this.localAgentId) {
+                this.yjsAwareness.setLocalStateField('cursor', cursorPosition);
+            }
+        });
+        this.aeonPresence.on('section_updated', ({ agentId, activeSection }) => {
+            if (agentId === this.localAgentId) {
+                this.yjsAwareness.setLocalStateField('activeSection', activeSection);
+            }
+        });
+    }
+    // ============================================
+    // Rich Presence API
+    // ============================================
+    /**
+     * Update local cursor position
+     */
+    updateCursor(x, y, path) {
+        this.aeonPresence.updateCursor(this.localAgentId, x, y, path);
+    }
+    /**
+     * Update local active section
+     */
+    updateActiveSection(section) {
+        this.aeonPresence.updateActiveSection(this.localAgentId, section);
+    }
+    /**
+     * Update local user info
+     */
+    updateUserInfo(name, role = 'user') {
+        this.aeonPresence.updatePresence(this.localAgentId, {
+            agentId: this.localAgentId,
+            name,
+            role,
+            status: 'online',
+        });
+        // Also sync to Yjs awareness
+        this.yjsAwareness.setLocalStateField('user', { name, role });
+    }
+    /**
+     * Get all online agents
+     */
+    getOnlineAgents() {
+        return this.aeonPresence.getOnlineAgents();
+    }
+    /**
+     * Get all agents (including offline)
+     */
+    getAllAgents() {
+        return this.aeonPresence.getAllAgents();
+    }
+    /**
+     * Get presence for specific agent
+     */
+    getPresence(agentId) {
+        return this.aeonPresence.getPresence(agentId);
+    }
+    /**
+     * Get agents in a specific section
+     */
+    getAgentsInSection(section) {
+        return this.aeonPresence.getInSection(section);
+    }
+    /**
+     * Get presence statistics
+     */
+    getStats() {
+        return this.aeonPresence.getPresenceStats();
+    }
+    /**
+     * Get local agent ID
+     */
+    getLocalAgentId() {
+        return this.localAgentId;
+    }
+    /**
+     * Subscribe to presence events
+     */
+    on(event, handler) {
+        this.aeonPresence.on(event, handler);
+    }
+    /**
+     * Unsubscribe from presence events
+     */
+    off(event, handler) {
+        this.aeonPresence.off(event, handler);
+    }
+    /**
+     * Cleanup
+     */
+    destroy() {
+        this.aeonPresence.agentLeft(this.localAgentId);
+        this.aeonPresence.destroy();
+    }
+}

package/dist/src/sync/aeon/schema-adapter.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Schema Adapter for Dash
+ *
+ * Bridges Aeon's SchemaVersionManager with Dash's LensEngine.
+ * Provides migration tracking, version compatibility checks, and audit trails.
+ */
+import { type SchemaVersion, type Migration, type MigrationResult } from '@affectively/aeon';
+import { LensEngine, type LensOp } from '../../schema/lens.js';
+/**
+ * Adapter that bridges Aeon versioning with Dash's Lens system
+ */
+export declare class DashSchemaAdapter {
+    private versionManager;
+    private migrationEngine;
+    private migrationTracker;
+    private lensEngine;
+    constructor(lensEngine: LensEngine);
+    /**
+     * Register a schema version with associated Lens operations
+     */
+    registerVersion(version: string, description: string, lensOps?: LensOp[], breaking?: boolean): void;
+    /**
+     * Register a migration for a version upgrade
+     */
+    registerMigration(id: string, fromVersion: string, toVersion: string, migrate: (data: unknown) => unknown, rollback?: (data: unknown) => unknown): void;
+    /**
+     * Execute a migration on data
+     */
+    executeMigration(migrationId: string, data: unknown): Promise<MigrationResult>;
+    /**
+     * Rollback a migration
+     */
+    rollbackMigration(migrationId: string, data: unknown): Promise<MigrationResult>;
+    /**
+     * Migrate data using Lens transformations
+     */
+    migrateWithLens(data: Record<string, unknown>, fromVersion: number, toVersion: number): Record<string, unknown>;
+    /**
+     * Get current version
+     */
+    getCurrentVersion(): SchemaVersion;
+    /**
+     * Get a specific version by string
+     */
+    getVersion(version: string): SchemaVersion | undefined;
+    /**
+     * Get migration by ID
+     */
+    getMigration(id: string): Migration | undefined;
+    /**
+     * Check if migration is needed
+     */
+    needsMigration(fromVersion: string, toVersion: string): boolean;
+    /**
+     * Get migration path between versions
+     */
+    getMigrationPath(fromVersion: string, toVersion: string): SchemaVersion[];
+    /**
+     * Get pending migrations
+     */
+    getPendingMigrations(): Migration[];
+    /**
+     * Get migration statistics
+     */
+    getStatistics(): {
+        engine: {
+            totalExecuted: number;
+            successful: number;
+            failed: number;
+            successRate: number;
+            totalDurationMs: number;
+            averageDurationMs: number;
+            totalAffected: number;
+        };
+        tracker: {
+            total: number;
+            applied: number;
+            failed: number;
+            pending: number;
+            rolledBack: number;
+            successRate: number;
+            totalDurationMs: number;
+            averageDurationMs: number;
+            totalItemsAffected: number;
+        };
+    };
+    /**
+     * Format version for display
+     */
+    formatVersion(version: SchemaVersion): string;
+}
+/**
+ * Create a schema adapter from an existing LensEngine
+ */
+export declare function createSchemaAdapter(lensEngine: LensEngine): DashSchemaAdapter;

package/dist/src/sync/aeon/schema-adapter.js

@@ -0,0 +1,163 @@
+/**
+ * Schema Adapter for Dash
+ *
+ * Bridges Aeon's SchemaVersionManager with Dash's LensEngine.
+ * Provides migration tracking, version compatibility checks, and audit trails.
+ */
+import { SchemaVersionManager, MigrationEngine, MigrationTracker, } from '@affectively/aeon';
+/**
+ * Adapter that bridges Aeon versioning with Dash's Lens system
+ */
+export class DashSchemaAdapter {
+    versionManager;
+    migrationEngine;
+    migrationTracker;
+    lensEngine;
+    constructor(lensEngine) {
+        this.versionManager = new SchemaVersionManager();
+        this.migrationEngine = new MigrationEngine();
+        this.migrationTracker = new MigrationTracker();
+        this.lensEngine = lensEngine;
+    }
+    /**
+     * Register a schema version with associated Lens operations
+     */
+    registerVersion(version, description, lensOps, breaking = false) {
+        const [major, minor, patch] = version.split('.').map(Number);
+        // Register with Aeon
+        this.versionManager.registerVersion({
+            major,
+            minor,
+            patch,
+            timestamp: new Date().toISOString(),
+            description,
+            breaking,
+        });
+        // Register Lens if provided
+        if (lensOps && major > 1) {
+            this.lensEngine.registerLens(major - 1, major, lensOps);
+        }
+    }
+    /**
+     * Register a migration for a version upgrade
+     */
+    registerMigration(id, fromVersion, toVersion, migrate, rollback) {
+        const migration = {
+            id,
+            name: `${fromVersion} -> ${toVersion}`,
+            version: toVersion,
+            description: `Migrate from ${fromVersion} to ${toVersion}`,
+            timestamp: new Date().toISOString(),
+            up: migrate,
+            down: rollback,
+        };
+        this.migrationEngine.registerMigration(migration);
+    }
+    /**
+     * Execute a migration on data
+     */
+    async executeMigration(migrationId, data) {
+        const result = await this.migrationEngine.executeMigration(migrationId, data);
+        // Track the migration
+        const record = {
+            id: `record-${Date.now()}`,
+            migrationId,
+            timestamp: new Date().toISOString(),
+            version: result.migrationId,
+            direction: 'up',
+            status: result.success ? 'applied' : 'failed',
+            duration: result.duration,
+            itemsAffected: result.itemsAffected,
+            errorMessage: result.errors.length > 0 ? result.errors.join(', ') : undefined,
+            appliedBy: 'dash-schema-adapter',
+        };
+        this.migrationTracker.recordMigration(record);
+        return result;
+    }
+    /**
+     * Rollback a migration
+     */
+    async rollbackMigration(migrationId, data) {
+        const result = await this.migrationEngine.rollbackMigration(migrationId, data);
+        // Track the rollback
+        const record = {
+            id: `record-${Date.now()}`,
+            migrationId,
+            timestamp: new Date().toISOString(),
+            version: result.migrationId,
+            direction: 'down',
+            status: result.success ? 'rolled-back' : 'failed',
+            duration: result.duration,
+            itemsAffected: result.itemsAffected,
+            errorMessage: result.errors.length > 0 ? result.errors.join(', ') : undefined,
+            appliedBy: 'dash-schema-adapter',
+        };
+        this.migrationTracker.recordMigration(record);
+        return result;
+    }
+    /**
+     * Migrate data using Lens transformations
+     */
+    migrateWithLens(data, fromVersion, toVersion) {
+        return this.lensEngine.migrate(data, fromVersion, toVersion);
+    }
+    /**
+     * Get current version
+     */
+    getCurrentVersion() {
+        return this.versionManager.getCurrentVersion();
+    }
+    /**
+     * Get a specific version by string
+     */
+    getVersion(version) {
+        return this.versionManager.getVersion(version);
+    }
+    /**
+     * Get migration by ID
+     */
+    getMigration(id) {
+        return this.migrationEngine.getMigration(id);
+    }
+    /**
+     * Check if migration is needed
+     */
+    needsMigration(fromVersion, toVersion) {
+        return this.versionManager.canMigrate(fromVersion, toVersion);
+    }
+    /**
+     * Get migration path between versions
+     */
+    getMigrationPath(fromVersion, toVersion) {
+        const from = this.versionManager.parseVersion(fromVersion);
+        const to = this.versionManager.parseVersion(toVersion);
+        return this.versionManager.getMigrationPath(from, to);
+    }
+    /**
+     * Get pending migrations
+     */
+    getPendingMigrations() {
+        return this.migrationEngine.getPendingMigrations();
+    }
+    /**
+     * Get migration statistics
+     */
+    getStatistics() {
+        return {
+            engine: this.migrationEngine.getStatistics(),
+            tracker: this.migrationTracker.getStatistics(),
+        };
+    }
+    /**
+     * Format version for display
+     */
+    formatVersion(version) {
+        return `${version.major}.${version.minor}.${version.patch}`;
+    }
+}
+/**
+ * Create a schema adapter from an existing LensEngine
+ */
+export function createSchemaAdapter(lensEngine) {
+    return new DashSchemaAdapter(lensEngine);
+}

package/dist/src/sync/hybrid-provider.d.ts

@@ -1,6 +1,10 @@
 import * as Y from 'yjs';
 import { Observable } from 'lib0/observable';
 import * as awarenessProtocol from 'y-protocols/awareness';
+import { type AeonConfig } from './aeon/config.js';
+import { DashDeltaAdapter } from './aeon/delta-adapter.js';
+import { DashPresenceAdapter } from './aeon/presence-adapter.js';
+import { DashOfflineAdapter } from './aeon/offline-adapter.js';
 export declare class HybridProvider extends Observable<string> {
     private doc;
     private ws;
@@ -11,8 +15,13 @@ export declare class HybridProvider extends Observable<string> {
     awareness: awarenessProtocol.Awareness;
     private writer;
     private highFrequencyMode;
-    constructor(url: string, roomName: string, doc: Y.Doc, { awareness }?: {
-        awareness?: awarenessProtocol.Awareness | undefined;
+    private aeonConfig;
+    private deltaAdapter;
+    private presenceAdapter;
+    private offlineAdapter;
+    constructor(url: string, roomName: string, doc: Y.Doc, { awareness, aeonConfig, }?: {
+        awareness?: awarenessProtocol.Awareness;
+        aeonConfig?: AeonConfig;
     });
     private connect;
     private connectWebSocket;
@@ -25,6 +34,29 @@ export declare class HybridProvider extends Observable<string> {
     private onDocUpdate;
     private onAwarenessUpdate;
     destroy(): void;
+    /**
+     * Get the delta adapter for compression stats
+     */
+    getDeltaAdapter(): DashDeltaAdapter | null;
+    /**
+     * Get the presence adapter for rich presence features
+     */
+    getPresenceAdapter(): DashPresenceAdapter | null;
+    /**
+     * Get the offline adapter for queue management
+     */
+    getOfflineAdapter(): DashOfflineAdapter | null;
+    /**
+     * Get Aeon configuration
+     */
+    getAeonConfig(): AeonConfig;
+    /**
+     * Process offline queue when back online
+     */
+    processOfflineQueue(): Promise<{
+        synced: number;
+        failed: number;
+    }>;
     /**
      * Get comprehensive connection status
      */
@@ -57,6 +89,10 @@ export declare class HybridProvider extends Observable<string> {
      * Get full provider status for debugging
      */
     getProviderStatus(): ProviderStatus;
+    /**
+     * Get Aeon-specific status
+     */
+    getAeonStatus(): AeonStatus;
 }
 export interface ConnectionStatus {
     connected: boolean;
@@ -104,4 +140,33 @@ export interface ProviderStatus {
         states: AwarenessState[];
     };
     document: DocumentState;
+    aeon: AeonStatus;
+}
+export interface AeonStatus {
+    enabled: {
+        deltaSync: boolean;
+        richPresence: boolean;
+        offlineQueue: boolean;
+    };
+    delta: {
+        totalOperations: number;
+        totalFull: number;
+        totalDelta: number;
+        totalOriginalSize: number;
+        totalDeltaSize: number;
+        averageReductionPercent: number;
+    } | null;
+    offline: {
+        pending: number;
+        syncing: number;
+        failed: number;
+        synced: number;
+        totalOperations: number;
+    } | null;
+    presence: {
+        total: number;
+        online: number;
+        away: number;
+        offline: number;
+    } | null;
 }