@affectively/dash 5.4.0 → 5.4.5

package/README.md

@@ -1,193 +1,12 @@
-# Dash 2.0
+# Dash
 
-**The Local-First, AI-Native Database for the Modern Web.**
+## Key Files
 
-Dash 2.0 isn't just a database; it's a complete data engine for building high-performance, intelligent web applications. It brings server-grade power to the client, enabling apps that feel instant, work offline, and understand your users.
+| File | Size |
+|------|------|
+| `package.json` | 2.3 KB |
+| `tsconfig.json` | 0.6 KB |
 
-## The "Real" Filesystem: OPFS
+## Subdirectories
 
-If you built your local-first app a year or two ago, you probably had to persist data by serializing the whole DB to IndexedDB or localStorage. It was slow and blocked the main thread.
-
-### The Shift
-
-The new standard is **SQLite over OPFS** (Origin Private File System).
-
-### Why it’s sexy
-
-It gives the browser direct, performant handle access to a virtual file system optimized for random access.
-
-### The Result
-
-You can run full ACID transactions on a **multi-gigabyte SQLite file** in the browser with **near-native desktop performance**, without ever blocking the UI thread (thanks to SharedArrayBuffer).
-
-Combined with **Zero-Copy (BYOB)** readers and **UCAN**-based Zero-Trust Auth, Dash isn't just a database—it's a local-first operating system.
-
-## Features
-
-### 🚀 Production-Grade Storage
-
-- **Stateful Serverless**: Powered by Cloudflare Durable Objects and Native SQLite.
-- **Zero-Copy IO (BYOB)**: "Bring Your Own Buffer" readers for max throughput.
-- **ACID Compliant**: Full transactional integrity in the browser.
-
-### 🧠 Hardware-Accelerated AI
-
-- **Vector Search**: Built-in vector embeddings and search.
-- **3-Tier Acceleration**:
-  1. **WebNN**: NPU acceleration (Apple Neural Engine, etc.)
-  2. **WebGPU**: High-performance GPU parallelization.
-  3. **WASM/CPU**: Universal fallback.
-- **Semantic Queries**: Find data by _meaning_ at native speeds.
-
-### 🔄 Modern Sync
-
-- **Hybrid Transport**:
-  - **WebSocket**: Supports Cloudflare Durable Object Hibernation ($0 idle cost).
-  - **WebTransport**: UDP-like high-frequency streams (perfect for cursors/games).
-- **Zero-Trust Auth (UCANs)**: Decentralized authorization via User Controlled Authorization Networks.
-- **Lens**: Bidirectional schema migrations for infinite backward compatibility.
-
-### 🎨 Graphics Ready
-
-- **Direct Buffers**: Zero-copy bindings allow piping data directly into 3D engines like Three.js.
-- **Spatial Indexing**: R-Tree support for massive 3D visualizations.
-
-### 🔥 Firebase-Compatible API
-
-- **Drop-In Replacement**: Use Firebase imports, Dash implementation. All your code works unchanged.
-- **All 4 Modules**: Firestore, Realtime Database, Auth, Cloud Storage.
-- **100% Compatible**: 150+ Firebase APIs with identical behavior.
-- **10-50x Faster**: Local-first queries at 0ms latency vs 15-25ms network round-trips.
-- **Unique Advantages**: Vector search, E2E encryption, offline-first, AI/ML built-in.
-
-```typescript
-// Before (Firebase)
-import { collection, getDocs } from 'firebase/firestore';
-
-// After (Dash - your code unchanged!)
-import { collection, getDocs } from '@affectively/dash';
-
-// Same code, 10-50x faster, fully offline ✅
-const docs = await getDocs(collection(db, 'users'));
-```
-
-**Learn more**: [Firebase Compatibility Guide](../../documentation/firebase.md)
-
-## Installation
-
-```bash
-npm install @affectively/dash
-```
-
-## Quick Start
-
-### 1. Store & Query (Standard SQL)
-
-Dash provides a familiar SQL interface with Promise-based execution.
-
-```typescript
-import { dash } from "@affectively/dash";
-
-await dash.ready();
-
-// Standard SQL execution
-await dash.execute("CREATE TABLE IF NOT EXISTS todos (id TEXT, text TEXT)");
-await dash.execute("INSERT INTO todos VALUES (?, ?)", ["1", "Buy milk"]);
-
-const rows = await dash.execute("SELECT * FROM todos");
-console.log(rows);
-```
-
-### 2. Semantic Search (AI)
-
-Store content with automatic vector embeddings and query by meaning.
-
-```typescript
-// Add an item (automatically generates and stores vector embedding)
-await dash.addWithEmbedding("1", "Buy almond milk and eggs");
-
-// Search by meaning - "breakfast ingredients" matches "eggs" and "milk"!
-const results = await dash.search("breakfast ingredients");
-// Result: [{ id: '1', content: '...', score: 0.85 }]
-```
-
-### 3. Spatial Queries (3D R-Tree)
-
-Filter items by 3D bounds for high-performance spatial lookups.
-
-```typescript
-// Query a 3D bounding box
-const items = await dash.spatialQuery({
-  minX: 0,
-  maxX: 100,
-  minY: 0,
-  maxY: 100,
-  minZ: 0,
-  maxZ: 100,
-});
-```
-
-### 4. Reactivity (Signals)
-
-Bind query results directly to your application state.
-
-```typescript
-import { liveQuery, effect } from "@affectively/dash";
-
-// This signal automatically updates whenever the 'todos' table changes
-const todos = liveQuery("SELECT * FROM todos");
-
-effect(() => {
-  console.log("Current Todos:", todos.value);
-});
-```
-
-### 5. Sync & Backup (Local-First)
-
-Enable collaboration and data safety with a single line.
-
-```typescript
-import { SyncConnection, backup } from "@affectively/dash";
-
-// 1. Peer-to-Peer Sync (WebTransport - Recommended)
-// Requires a WebTransport Relay Server (Star Topology)
-const connection = new SyncConnection({
-  type: "webtransport",
-  roomName: "my-room",
-  url: "https://relay.dash.dev/sync",
-  doc,
-});
-
-// OR: Peer-to-Peer Sync (WebRTC - Legacy)
-// Mesh Topology (Client-to-Client)
-const p2p = new SyncConnection({
-  type: "webrtc",
-  roomName: "my-room",
-  doc,
-});
-
-// 2. Encrypted Cloud Backup
-await backup("my-room", doc, mySecretKey, cloudAdapter);
-```
-
-## Architecture
-
-Dash uses `@sqlite.org/sqlite-wasm` with the OPFS backend to ensure main-thread responsiveness. Large data operations occur in the WASM heap, avoiding the serialization overhead of IndexedDB.
-
-Vector operations utilize `sqlite-vec` (WASM) for high-performance similarity search.
-
-For a deep dive into our "Stateful Serverless" Client-Relay topology using Cloudflare Durable Objects, read the [Sync Architecture Guide](./docs/SYNC_ARCHITECTURE.md).
-
-## Development
-
-```bash
-# Build the project
-npm run build
-
-# Run tests
-npm test
-```
-
-## License
-
-MIT
+- `src/`

package/dist/engine/sqlite.d.ts

@@ -0,0 +1,30 @@
+export declare class DashEngine {
+    private db;
+    private readyPromise;
+    private listeners;
+    constructor();
+    private init;
+    private initializeSchema;
+    ready(): Promise<void>;
+    private tableListeners;
+    subscribe(table: string, callback: () => void): () => void;
+    private notify;
+    private notifyChanges;
+    execute(sql: string, bind?: any[]): any[];
+    addWithEmbedding(id: string, content: string, spatial?: {
+        x: number;
+        y: number;
+        z: number;
+    }): Promise<any[]>;
+    search(query: string, limit?: number): Promise<any[]>;
+    spatialQuery(bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+        minZ: number;
+        maxZ: number;
+    }): Promise<any[]>;
+    close(): void;
+}
+export declare const dash: DashEngine;

package/dist/engine/vec_extension.d.ts

@@ -0,0 +1,2 @@
+import { Database } from '@sqlite.org/sqlite-wasm';
+export declare function loadVectorExtension(db: Database): Promise<void>;

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @affectively/dash
+ *
+ * Multi-layer edge storage and CRDT sync engine —
+ * Yjs, Automerge, WebSocket, WebTransport, and WebRTC.
+ */
+export interface Dash {
+    ready: () => Promise<void>;
+    execute: (sql: string, bind?: unknown[]) => unknown[];
+    addWithEmbedding?: (id: string, content: string) => Promise<unknown[]>;
+    search?: (query: string, limit?: number) => Promise<Array<{
+        id: string;
+        content: string;
+        score: number;
+    }>>;
+}
+export interface PresenceUser {
+    userId: string;
+    role: 'user' | 'assistant' | 'monitor' | 'admin';
+    cursor?: {
+        x: number;
+        y: number;
+    };
+    editing?: string;
+    status: 'online' | 'away' | 'offline';
+    lastActivity: string;
+}
+export interface PresenceState {
+    users: PresenceUser[];
+    localUser?: PresenceUser;
+    isConnected: boolean;
+}
+export interface SyncState {
+    isOnline: boolean;
+    isSyncing: boolean;
+    lastSyncAt?: string;
+    pendingOperations: number;
+}
+export declare const dash: import("./engine/sqlite").DashEngine;
+export { mcpServer } from './mcp/server';
+export { liveQuery, signal, effect, computed } from './reactivity/signal';
+export declare function createDash(config: DashConfig): Dash;
+export declare function getPresence(): PresenceState;
+export declare class PeerSync {
+    constructor(roomName: string, options?: PeerSyncOptions);
+    connect(): Promise<void>;
+    disconnect(): void;
+    getPeers(): string[];
+}
+export declare class SynchronizerFactory {
+    static create(config: SyncConfig): PeerSync;
+}
+export interface DashConfig {
+    name: string;
+    version?: number;
+    persistence?: 'indexeddb' | 'sqlite' | 'memory';
+    sync?: {
+        enabled: boolean;
+        roomName: string;
+        signalingServers?: string[];
+    };
+}
+export interface PeerSyncOptions {
+    signalingServers?: string[];
+    password?: string;
+    enableHighFrequency?: boolean;
+}
+export interface SyncConfig {
+    roomName: string;
+    options?: PeerSyncOptions;
+}
+export { DashErrorHandler, defaultErrorHandler, withRetry, withRateLimit, withErrorHandling, type ErrorHandlerConfig, type RetryConfig, type RateLimitConfig, } from './middleware/errorHandler';
+export default dash;