@livestore/cli 0.0.0-snapshot-2ac5fd340c97c9e07fe4c5dc6d31d5132aa6557c.0

package/dist/mcp-content/features.js

@@ -0,0 +1,177 @@
+export const featuresContent = `# LiveStore Features: Production-Ready Local-First Data
+
+LiveStore provides battle-tested primitives for building collaborative, offline-capable applications with the reliability and performance of modern distributed systems.
+
+## 🏠 Local-First Architecture
+
+### Offline-First Operation
+- **Zero Latency**: All operations execute against local SQLite database
+- **Offline Capable**: Full application functionality without network connectivity
+- **Network Resilient**: Graceful degradation during connectivity issues
+- **Background Sync**: Automatic synchronization when network becomes available
+
+### Immediate Consistency
+- **Optimistic Updates**: UI updates immediately on user action
+- **Rollback on Conflict**: Automatic rollback and retry on merge conflicts
+- **Causal Consistency**: Operations maintain causal ordering across replicas
+
+## 🔄 Event-Driven Synchronization
+
+### Conflict-Free Event Model
+\`\`\`typescript
+// Events designed for conflict-free merging
+const events = {
+  todoCreated: Events.synced({
+    name: 'v1.TodoCreated',
+    schema: Schema.Struct({
+      id: Schema.String,      // Deterministic ordering
+      createdAt: Schema.Date, // Timestamp for LWW resolution
+      position: Schema.Number // Fractional indexing for reordering
+    })
+  })
+}
+\`\`\`
+
+### Sophisticated Merge Strategies
+- **Last-Write-Wins**: Timestamp-based conflict resolution
+- **Semantic Merging**: Application-specific merge logic
+- **Operational Transform**: Real-time collaborative text editing
+- **CRDT Integration**: Conflict-free replicated data types
+
+### Incremental Synchronization
+- **Delta Sync**: Only transmit changes since last synchronization
+- **Vector Clocks**: Efficient causal dependency tracking
+- **Merkle Trees**: Efficient integrity verification
+- **Batch Optimization**: Multiple events in single network round-trip
+
+## 📊 Reactive Query Engine
+
+### Real-Time Reactivity
+\`\`\`typescript
+// Queries automatically update when underlying data changes
+const activeTodos$ = queryDb(
+  tables.todos
+    .select()
+    .where({ completed: false, deletedAt: null })
+    .orderBy('position'),
+  { label: 'activeTodos' }
+)
+\`\`\`
+
+### Advanced Query Capabilities
+- **Joins & Aggregations**: Full SQL expressiveness
+- **Reactive Subscriptions**: Automatic UI updates on data changes
+- **Query Optimization**: SQLite query planner with B-tree indexes
+- **Prepared Statements**: Cached query compilation for performance
+
+### Framework Integrations
+- **React**: \`useLiveQuery()\` hook for reactive components
+- **Vue**: Composables for reactive data binding
+- **Solid**: Reactive primitives integration
+- **Svelte**: Store-based reactive updates
+
+## 🔐 End-to-End Type Safety
+
+### Schema-First Development
+\`\`\`typescript
+// Type safety from database to UI
+const todoSchema = State.SQLite.table({
+  name: 'todos',
+  columns: {
+    id: State.SQLite.text({ primaryKey: true }),
+    title: State.SQLite.text(),
+    completed: State.SQLite.boolean()
+  }
+})
+
+// Fully typed queries
+type Todo = typeof todoSchema.select.Type // { id: string, title: string, completed: boolean }
+\`\`\`
+
+### Runtime Validation
+- **Schema Validation**: All events validated against Effect schemas
+- **Migration Safety**: Type-safe schema evolution
+- **Parse Don't Validate**: Schema types flow through entire application
+
+## 🌐 Multi-Platform Support
+
+### Web Platform
+- **Origin Private File System**: Persistent storage in modern browsers
+- **SharedWorker**: Cross-tab synchronization and resource sharing
+- **IndexedDB Fallback**: Compatibility with older browsers
+- **Service Worker**: Background synchronization
+
+### Node.js Platform
+- **File System Storage**: Native SQLite database files
+- **Cluster Coordination**: Multi-process synchronization
+- **HTTP/WebSocket Sync**: Flexible transport protocols
+- **Background Jobs**: Scheduled synchronization tasks
+
+### Mobile Platforms (Expo/React Native)
+- **Native SQLite**: Platform-optimized database performance
+- **Background Sync**: Synchronization during app backgrounding
+- **Push Notifications**: Real-time update notifications
+- **Secure Storage**: Encrypted local data storage
+
+## 🚀 Performance & Scalability
+
+### Query Performance
+- **Sub-millisecond Queries**: Local SQLite performance
+- **Efficient Indexing**: Automatic index recommendations
+- **Result Set Streaming**: Large datasets loaded incrementally
+- **Query Result Caching**: Expensive computations cached
+
+### Memory Management
+- **Lazy Loading**: Data loaded on-demand
+- **Connection Pooling**: Database connections efficiently reused
+- **Event Log Compaction**: Periodic snapshots prevent unbounded growth
+- **Garbage Collection**: Automatic cleanup of obsolete data
+
+### Network Optimization
+- **Compression**: Event payloads compressed for transmission
+- **Request Batching**: Multiple operations in single request
+- **Connection Pooling**: HTTP/WebSocket connections reused
+- **Exponential Backoff**: Intelligent retry strategies
+
+## 🏗️ Developer Experience
+
+### Testing & Debugging
+\`\`\`typescript
+// Built-in testing utilities
+const testStore = createTestStore(schema)
+
+// Deterministic event replay for testing
+await testStore.replay([
+  events.todoCreated({ id: '1', title: 'Test todo' }),
+  events.todoCompleted({ id: '1' })
+])
+\`\`\`
+
+### Developer Tools
+- **Event Inspector**: Real-time event log visualization
+- **Query Profiler**: Performance analysis for slow queries  
+- **Sync Monitor**: Network synchronization health dashboard
+- **Schema Explorer**: Interactive database schema browsing
+
+### Production Monitoring
+- **Distributed Tracing**: Event propagation across replicas
+- **Performance Metrics**: Query latency and throughput monitoring
+- **Error Tracking**: Comprehensive error reporting and alerting
+- **Health Checks**: Automated system health verification
+
+## 🔒 Security & Privacy
+
+### Data Protection
+- **End-to-End Encryption**: Client-side encryption before transmission
+- **Event Signatures**: Cryptographic integrity verification
+- **Access Control**: Fine-grained permission system
+- **Audit Logging**: Comprehensive security event logging
+
+### Privacy by Design
+- **Local Data Control**: Users maintain complete data ownership
+- **Selective Sync**: Fine-grained control over data sharing
+- **Data Minimization**: Only sync necessary data
+- **GDPR Compliance**: Built-in privacy compliance features
+
+LiveStore combines the reliability of traditional databases with the performance and user experience of local-first applications, enabling you to build applications that users love while maintaining the technical rigor of distributed systems.`;
+//# sourceMappingURL=features.js.map

package/dist/mcp-content/features.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.js","sourceRoot":"","sources":["../../src/mcp-content/features.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mPA+KoN,CAAA"}

package/dist/mcp-content/getting-started.d.ts

@@ -0,0 +1,2 @@
+export declare const gettingStartedContent = "# Getting Started with LiveStore\n\nBuild your first local-first application with LiveStore in minutes. This guide walks through creating a real-time collaborative todo app that works offline and syncs when online.\n\n## Quick Start\n\n### 1. Installation\n\n```bash\n# Install LiveStore core\nnpm install @livestore/livestore\n\n# Choose your platform adapter\nnpm install @livestore/adapter-web      # For web applications\nnpm install @livestore/adapter-node     # For Node.js applications\nnpm install @livestore/adapter-expo     # For React Native/Expo apps\n```\n\n### 2. Define Your Schema\n\nLiveStore uses an event-driven architecture where all changes are recorded as immutable events and applied to materialized SQLite tables.\n\n```typescript\n// schema.ts\nimport { Events, makeSchema, Schema, SessionIdSymbol, State } from '@livestore/livestore'\n\n// Define your state as SQLite tables\nexport const tables = {\n  todos: State.SQLite.table({\n    name: 'todos',\n    columns: {\n      id: State.SQLite.text({ primaryKey: true }),\n      text: State.SQLite.text({ default: '' }),\n      completed: State.SQLite.boolean({ default: false }),\n      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),\n      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),\n    },\n  }),\n  \n  // Client-only state (not synced)\n  uiState: State.SQLite.clientDocument({\n    name: 'uiState',\n    schema: Schema.Struct({ \n      newTodoText: Schema.String, \n      filter: Schema.Literal('all', 'active', 'completed') \n    }),\n    default: { id: SessionIdSymbol, value: { newTodoText: '', filter: 'all' } },\n  }),\n}\n\n// Define events that represent state changes\nexport const events = {\n  todoCreated: Events.synced({\n    name: 'v1.TodoCreated',\n    schema: Schema.Struct({ \n      id: Schema.String, \n      text: Schema.String,\n      createdAt: Schema.Date \n    }),\n  }),\n  todoCompleted: Events.synced({\n    name: 'v1.TodoCompleted',\n    schema: Schema.Struct({ id: Schema.String }),\n  }),\n  todoUncompleted: Events.synced({\n    name: 'v1.TodoUncompleted',\n    schema: Schema.Struct({ id: Schema.String }),\n  }),\n  todoDeleted: Events.synced({\n    name: 'v1.TodoDeleted',\n    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),\n  }),\n  \n  // UI state events (local only)\n  uiStateSet: tables.uiState.set,\n}\n\n// Materializers map events to state changes\nconst materializers = State.SQLite.materializers(events, {\n  'v1.TodoCreated': ({ id, text, createdAt }) => \n    tables.todos.insert({ id, text, completed: false, createdAt }),\n    \n  'v1.TodoCompleted': ({ id }) => \n    tables.todos.update({ completed: true }).where({ id }),\n    \n  'v1.TodoUncompleted': ({ id }) => \n    tables.todos.update({ completed: false }).where({ id }),\n    \n  'v1.TodoDeleted': ({ id, deletedAt }) => \n    tables.todos.update({ deletedAt }).where({ id }),\n})\n\nconst state = State.SQLite.makeState({ tables, materializers })\n\nexport const schema = makeSchema({ events, state })\n```\n\n### 3. Create Reactive Queries\n\nLiveStore queries automatically update your UI when underlying data changes.\n\n```typescript\n// queries.ts\nimport { queryDb } from '@livestore/livestore'\nimport { tables } from './schema.js'\n\n// Reactive query for all active todos\nexport const activeTodos$ = queryDb(\n  tables.todos\n    .select()\n    .where({ deletedAt: null, completed: false })\n    .orderBy('createdAt'),\n  { label: 'activeTodos' }\n)\n\n// Reactive query for completed todos\nexport const completedTodos$ = queryDb(\n  tables.todos\n    .select()\n    .where({ deletedAt: null, completed: true })\n    .orderBy('createdAt'),\n  { label: 'completedTodos' }\n)\n\n// UI state query\nexport const uiState$ = queryDb(\n  tables.uiState.get(),\n  { label: 'uiState' }\n)\n```\n\n### 4. Connect to Your UI Framework\n\n#### React Integration\n\n```typescript\n// TodoApp.tsx\nimport React from 'react'\nimport { useLiveQuery, dispatchEvent } from '@livestore/react'\nimport { activeTodos$, completedTodos$, uiState$ } from './queries.js'\nimport { events } from './schema.js'\n\nconst TodoApp: React.FC = () => {\n  const activeTodos = useLiveQuery(activeTodos$)\n  const completedTodos = useLiveQuery(completedTodos$)\n  const uiState = useLiveQuery(uiState$)\n  \n  const createTodo = (text: string) => {\n    const id = crypto.randomUUID()\n    dispatchEvent(events.todoCreated({ id, text, createdAt: new Date() }))\n  }\n  \n  const toggleTodo = (id: string, completed: boolean) => {\n    dispatchEvent(\n      completed \n        ? events.todoCompleted({ id })\n        : events.todoUncompleted({ id })\n    )\n  }\n  \n  const deleteTodo = (id: string) => {\n    dispatchEvent(events.todoDeleted({ id, deletedAt: new Date() }))\n  }\n  \n  return (\n    <div className=\"todo-app\">\n      <h1>Local-First Todos</h1>\n      \n      {/* Add todo form */}\n      <form onSubmit={(e) => {\n        e.preventDefault()\n        const form = e.target as HTMLFormElement\n        const input = form.elements.namedItem('todo') as HTMLInputElement\n        if (input.value.trim()) {\n          createTodo(input.value.trim())\n          input.value = ''\n        }\n      }}>\n        <input name=\"todo\" placeholder=\"What needs to be done?\" />\n        <button type=\"submit\">Add Todo</button>\n      </form>\n      \n      {/* Active todos */}\n      <div className=\"todo-list\">\n        <h2>Active ({activeTodos.length})</h2>\n        {activeTodos.map(todo => (\n          <div key={todo.id} className=\"todo-item\">\n            <input \n              type=\"checkbox\"\n              checked={false}\n              onChange={() => toggleTodo(todo.id, true)}\n            />\n            <span>{todo.text}</span>\n            <button onClick={() => deleteTodo(todo.id)}>Delete</button>\n          </div>\n        ))}\n      </div>\n      \n      {/* Completed todos */}\n      <div className=\"todo-list\">\n        <h2>Completed ({completedTodos.length})</h2>\n        {completedTodos.map(todo => (\n          <div key={todo.id} className=\"todo-item completed\">\n            <input \n              type=\"checkbox\"\n              checked={true}\n              onChange={() => toggleTodo(todo.id, false)}\n            />\n            <span>{todo.text}</span>\n            <button onClick={() => deleteTodo(todo.id)}>Delete</button>\n          </div>\n        ))}\n      </div>\n    </div>\n  )\n}\n\nexport default TodoApp\n```\n\n#### Vue Integration\n\n```vue\n<!-- TodoApp.vue -->\n<template>\n  <div class=\"todo-app\">\n    <h1>Local-First Todos</h1>\n    \n    <form @submit.prevent=\"createTodo\">\n      <input v-model=\"newTodoText\" placeholder=\"What needs to be done?\" />\n      <button type=\"submit\">Add Todo</button>\n    </form>\n    \n    <div class=\"todo-list\">\n      <h2>Active ({{ activeTodos.length }})</h2>\n      <div v-for=\"todo in activeTodos\" :key=\"todo.id\" class=\"todo-item\">\n        <input \n          type=\"checkbox\"\n          :checked=\"false\"\n          @change=\"toggleTodo(todo.id, true)\"\n        />\n        <span>{{ todo.text }}</span>\n        <button @click=\"deleteTodo(todo.id)\">Delete</button>\n      </div>\n    </div>\n  </div>\n</template>\n\n<script setup lang=\"ts\">\nimport { ref } from 'vue'\nimport { useLiveQuery, dispatchEvent } from '@livestore/vue'\nimport { activeTodos$ } from './queries.js'\nimport { events } from './schema.js'\n\nconst activeTodos = useLiveQuery(activeTodos$)\nconst newTodoText = ref('')\n\nconst createTodo = () => {\n  if (newTodoText.value.trim()) {\n    const id = crypto.randomUUID()\n    dispatchEvent(events.todoCreated({ \n      id, \n      text: newTodoText.value.trim(), \n      createdAt: new Date() \n    }))\n    newTodoText.value = ''\n  }\n}\n\nconst toggleTodo = (id: string, completed: boolean) => {\n  dispatchEvent(\n    completed \n      ? events.todoCompleted({ id })\n      : events.todoUncompleted({ id })\n  )\n}\n\nconst deleteTodo = (id: string) => {\n  dispatchEvent(events.todoDeleted({ id, deletedAt: new Date() }))\n}\n</script>\n```\n\n### 5. Initialize Your Application\n\n```typescript\n// main.ts\nimport { LiveStore } from '@livestore/livestore'\nimport { WebAdapter } from '@livestore/adapter-web'\nimport { schema } from './schema.js'\n\n// Initialize LiveStore with your schema\nconst liveStore = LiveStore.create({\n  schema,\n  adapter: WebAdapter({\n    databaseName: 'todo-app',\n    // Optional: Add sync configuration\n    sync: {\n      url: 'wss://your-sync-server.com',\n      auth: { token: 'your-auth-token' }\n    }\n  })\n})\n\n// Start your application\nconst app = document.getElementById('app')\nif (app) {\n  // Your framework-specific initialization\n  // React: createRoot(app).render(<TodoApp />)\n  // Vue: createApp(TodoApp).mount(app)\n}\n```\n\n## Advanced Features\n\n### Offline Support\n\nYour app automatically works offline. All operations execute against the local database, and changes sync when connectivity returns.\n\n```typescript\n// Check online status\nconst isOnline$ = queryDb(\n  LiveStore.connectionStatus(),\n  { label: 'connectionStatus' }\n)\n```\n\n### Real-Time Collaboration\n\nMultiple users can collaborate in real-time. Conflicts are automatically resolved using last-write-wins or custom merge strategies.\n\n```typescript\n// Custom conflict resolution\nconst materializers = State.SQLite.materializers(events, {\n  'v1.TodoTextChanged': ({ id, text, editedAt }) => \n    // Use timestamp for conflict resolution\n    tables.todos\n      .update({ text, editedAt })\n      .where({ id })\n      .and(tables.todos.column('editedAt').lt(editedAt))\n})\n```\n\n### Testing\n\n```typescript\n// todo.test.ts\nimport { createTestStore } from '@livestore/testing'\nimport { schema, events } from './schema.js'\n\ntest('creating and completing todos', async () => {\n  const store = createTestStore(schema)\n  \n  // Dispatch events\n  await store.dispatch([\n    events.todoCreated({ id: '1', text: 'Test todo', createdAt: new Date() }),\n    events.todoCompleted({ id: '1' })\n  ])\n  \n  // Query final state\n  const completedTodos = await store.query(\n    tables.todos.select().where({ completed: true })\n  )\n  \n  expect(completedTodos).toHaveLength(1)\n  expect(completedTodos[0].text).toBe('Test todo')\n})\n```\n\n## Next Steps\n\n### Production Deployment\n1. **Set up sync server**: Deploy LiveStore sync server for real-time collaboration\n2. **Configure authentication**: Add user authentication and authorization\n3. **Add monitoring**: Set up distributed tracing and performance monitoring\n4. **Optimize performance**: Add indexes and query optimization\n\n### Advanced Patterns\n- **Multi-user collaboration**: User permissions and access control\n- **Rich text editing**: Operational transforms for collaborative editing\n- **File synchronization**: Binary data and file attachment handling\n- **Schema migrations**: Evolving your data model over time\n\n### Platform-Specific Guides\n- **Web deployment**: Service workers, PWA configuration, OPFS optimization\n- **Mobile apps**: Background sync, push notifications, native storage\n- **Desktop apps**: Electron integration, native file system access\n\n## Examples Repository\n\nExplore complete working examples:\n- **TodoMVC**: Classic todo app with real-time sync\n- **Collaborative Editor**: Rich text editing with operational transforms\n- **Chat Application**: Real-time messaging with presence indicators\n- **E-commerce**: Product catalog with shopping cart and orders\n\n```bash\n# Clone examples repository\ngit clone https://github.com/livestorejs/examples.git\ncd examples/web-todomvc\nnpm install && npm run dev\n```\n\nVisit [docs.livestore.dev](https://docs.livestore.dev) for comprehensive documentation, API reference, and advanced patterns.";
+//# sourceMappingURL=getting-started.d.ts.map

package/dist/mcp-content/getting-started.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getting-started.d.ts","sourceRoot":"","sources":["../../src/mcp-content/getting-started.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,4oXAmZ4F,CAAA"}

package/dist/mcp-content/getting-started.js

@@ -0,0 +1,405 @@
+export const gettingStartedContent = `# Getting Started with LiveStore
+
+Build your first local-first application with LiveStore in minutes. This guide walks through creating a real-time collaborative todo app that works offline and syncs when online.
+
+## Quick Start
+
+### 1. Installation
+
+\`\`\`bash
+# Install LiveStore core
+npm install @livestore/livestore
+
+# Choose your platform adapter
+npm install @livestore/adapter-web      # For web applications
+npm install @livestore/adapter-node     # For Node.js applications
+npm install @livestore/adapter-expo     # For React Native/Expo apps
+\`\`\`
+
+### 2. Define Your Schema
+
+LiveStore uses an event-driven architecture where all changes are recorded as immutable events and applied to materialized SQLite tables.
+
+\`\`\`typescript
+// schema.ts
+import { Events, makeSchema, Schema, SessionIdSymbol, State } from '@livestore/livestore'
+
+// Define your state as SQLite tables
+export const tables = {
+  todos: State.SQLite.table({
+    name: 'todos',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      text: State.SQLite.text({ default: '' }),
+      completed: State.SQLite.boolean({ default: false }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  // Client-only state (not synced)
+  uiState: State.SQLite.clientDocument({
+    name: 'uiState',
+    schema: Schema.Struct({ 
+      newTodoText: Schema.String, 
+      filter: Schema.Literal('all', 'active', 'completed') 
+    }),
+    default: { id: SessionIdSymbol, value: { newTodoText: '', filter: 'all' } },
+  }),
+}
+
+// Define events that represent state changes
+export const events = {
+  todoCreated: Events.synced({
+    name: 'v1.TodoCreated',
+    schema: Schema.Struct({ 
+      id: Schema.String, 
+      text: Schema.String,
+      createdAt: Schema.Date 
+    }),
+  }),
+  todoCompleted: Events.synced({
+    name: 'v1.TodoCompleted',
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoUncompleted: Events.synced({
+    name: 'v1.TodoUncompleted',
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoDeleted: Events.synced({
+    name: 'v1.TodoDeleted',
+    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
+  }),
+  
+  // UI state events (local only)
+  uiStateSet: tables.uiState.set,
+}
+
+// Materializers map events to state changes
+const materializers = State.SQLite.materializers(events, {
+  'v1.TodoCreated': ({ id, text, createdAt }) => 
+    tables.todos.insert({ id, text, completed: false, createdAt }),
+    
+  'v1.TodoCompleted': ({ id }) => 
+    tables.todos.update({ completed: true }).where({ id }),
+    
+  'v1.TodoUncompleted': ({ id }) => 
+    tables.todos.update({ completed: false }).where({ id }),
+    
+  'v1.TodoDeleted': ({ id, deletedAt }) => 
+    tables.todos.update({ deletedAt }).where({ id }),
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+\`\`\`
+
+### 3. Create Reactive Queries
+
+LiveStore queries automatically update your UI when underlying data changes.
+
+\`\`\`typescript
+// queries.ts
+import { queryDb } from '@livestore/livestore'
+import { tables } from './schema.js'
+
+// Reactive query for all active todos
+export const activeTodos$ = queryDb(
+  tables.todos
+    .select()
+    .where({ deletedAt: null, completed: false })
+    .orderBy('createdAt'),
+  { label: 'activeTodos' }
+)
+
+// Reactive query for completed todos
+export const completedTodos$ = queryDb(
+  tables.todos
+    .select()
+    .where({ deletedAt: null, completed: true })
+    .orderBy('createdAt'),
+  { label: 'completedTodos' }
+)
+
+// UI state query
+export const uiState$ = queryDb(
+  tables.uiState.get(),
+  { label: 'uiState' }
+)
+\`\`\`
+
+### 4. Connect to Your UI Framework
+
+#### React Integration
+
+\`\`\`typescript
+// TodoApp.tsx
+import React from 'react'
+import { useLiveQuery, dispatchEvent } from '@livestore/react'
+import { activeTodos$, completedTodos$, uiState$ } from './queries.js'
+import { events } from './schema.js'
+
+const TodoApp: React.FC = () => {
+  const activeTodos = useLiveQuery(activeTodos$)
+  const completedTodos = useLiveQuery(completedTodos$)
+  const uiState = useLiveQuery(uiState$)
+  
+  const createTodo = (text: string) => {
+    const id = crypto.randomUUID()
+    dispatchEvent(events.todoCreated({ id, text, createdAt: new Date() }))
+  }
+  
+  const toggleTodo = (id: string, completed: boolean) => {
+    dispatchEvent(
+      completed 
+        ? events.todoCompleted({ id })
+        : events.todoUncompleted({ id })
+    )
+  }
+  
+  const deleteTodo = (id: string) => {
+    dispatchEvent(events.todoDeleted({ id, deletedAt: new Date() }))
+  }
+  
+  return (
+    <div className="todo-app">
+      <h1>Local-First Todos</h1>
+      
+      {/* Add todo form */}
+      <form onSubmit={(e) => {
+        e.preventDefault()
+        const form = e.target as HTMLFormElement
+        const input = form.elements.namedItem('todo') as HTMLInputElement
+        if (input.value.trim()) {
+          createTodo(input.value.trim())
+          input.value = ''
+        }
+      }}>
+        <input name="todo" placeholder="What needs to be done?" />
+        <button type="submit">Add Todo</button>
+      </form>
+      
+      {/* Active todos */}
+      <div className="todo-list">
+        <h2>Active ({activeTodos.length})</h2>
+        {activeTodos.map(todo => (
+          <div key={todo.id} className="todo-item">
+            <input 
+              type="checkbox"
+              checked={false}
+              onChange={() => toggleTodo(todo.id, true)}
+            />
+            <span>{todo.text}</span>
+            <button onClick={() => deleteTodo(todo.id)}>Delete</button>
+          </div>
+        ))}
+      </div>
+      
+      {/* Completed todos */}
+      <div className="todo-list">
+        <h2>Completed ({completedTodos.length})</h2>
+        {completedTodos.map(todo => (
+          <div key={todo.id} className="todo-item completed">
+            <input 
+              type="checkbox"
+              checked={true}
+              onChange={() => toggleTodo(todo.id, false)}
+            />
+            <span>{todo.text}</span>
+            <button onClick={() => deleteTodo(todo.id)}>Delete</button>
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+}
+
+export default TodoApp
+\`\`\`
+
+#### Vue Integration
+
+\`\`\`vue
+<!-- TodoApp.vue -->
+<template>
+  <div class="todo-app">
+    <h1>Local-First Todos</h1>
+    
+    <form @submit.prevent="createTodo">
+      <input v-model="newTodoText" placeholder="What needs to be done?" />
+      <button type="submit">Add Todo</button>
+    </form>
+    
+    <div class="todo-list">
+      <h2>Active ({{ activeTodos.length }})</h2>
+      <div v-for="todo in activeTodos" :key="todo.id" class="todo-item">
+        <input 
+          type="checkbox"
+          :checked="false"
+          @change="toggleTodo(todo.id, true)"
+        />
+        <span>{{ todo.text }}</span>
+        <button @click="deleteTodo(todo.id)">Delete</button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { useLiveQuery, dispatchEvent } from '@livestore/vue'
+import { activeTodos$ } from './queries.js'
+import { events } from './schema.js'
+
+const activeTodos = useLiveQuery(activeTodos$)
+const newTodoText = ref('')
+
+const createTodo = () => {
+  if (newTodoText.value.trim()) {
+    const id = crypto.randomUUID()
+    dispatchEvent(events.todoCreated({ 
+      id, 
+      text: newTodoText.value.trim(), 
+      createdAt: new Date() 
+    }))
+    newTodoText.value = ''
+  }
+}
+
+const toggleTodo = (id: string, completed: boolean) => {
+  dispatchEvent(
+    completed 
+      ? events.todoCompleted({ id })
+      : events.todoUncompleted({ id })
+  )
+}
+
+const deleteTodo = (id: string) => {
+  dispatchEvent(events.todoDeleted({ id, deletedAt: new Date() }))
+}
+</script>
+\`\`\`
+
+### 5. Initialize Your Application
+
+\`\`\`typescript
+// main.ts
+import { LiveStore } from '@livestore/livestore'
+import { WebAdapter } from '@livestore/adapter-web'
+import { schema } from './schema.js'
+
+// Initialize LiveStore with your schema
+const liveStore = LiveStore.create({
+  schema,
+  adapter: WebAdapter({
+    databaseName: 'todo-app',
+    // Optional: Add sync configuration
+    sync: {
+      url: 'wss://your-sync-server.com',
+      auth: { token: 'your-auth-token' }
+    }
+  })
+})
+
+// Start your application
+const app = document.getElementById('app')
+if (app) {
+  // Your framework-specific initialization
+  // React: createRoot(app).render(<TodoApp />)
+  // Vue: createApp(TodoApp).mount(app)
+}
+\`\`\`
+
+## Advanced Features
+
+### Offline Support
+
+Your app automatically works offline. All operations execute against the local database, and changes sync when connectivity returns.
+
+\`\`\`typescript
+// Check online status
+const isOnline$ = queryDb(
+  LiveStore.connectionStatus(),
+  { label: 'connectionStatus' }
+)
+\`\`\`
+
+### Real-Time Collaboration
+
+Multiple users can collaborate in real-time. Conflicts are automatically resolved using last-write-wins or custom merge strategies.
+
+\`\`\`typescript
+// Custom conflict resolution
+const materializers = State.SQLite.materializers(events, {
+  'v1.TodoTextChanged': ({ id, text, editedAt }) => 
+    // Use timestamp for conflict resolution
+    tables.todos
+      .update({ text, editedAt })
+      .where({ id })
+      .and(tables.todos.column('editedAt').lt(editedAt))
+})
+\`\`\`
+
+### Testing
+
+\`\`\`typescript
+// todo.test.ts
+import { createTestStore } from '@livestore/testing'
+import { schema, events } from './schema.js'
+
+test('creating and completing todos', async () => {
+  const store = createTestStore(schema)
+  
+  // Dispatch events
+  await store.dispatch([
+    events.todoCreated({ id: '1', text: 'Test todo', createdAt: new Date() }),
+    events.todoCompleted({ id: '1' })
+  ])
+  
+  // Query final state
+  const completedTodos = await store.query(
+    tables.todos.select().where({ completed: true })
+  )
+  
+  expect(completedTodos).toHaveLength(1)
+  expect(completedTodos[0].text).toBe('Test todo')
+})
+\`\`\`
+
+## Next Steps
+
+### Production Deployment
+1. **Set up sync server**: Deploy LiveStore sync server for real-time collaboration
+2. **Configure authentication**: Add user authentication and authorization
+3. **Add monitoring**: Set up distributed tracing and performance monitoring
+4. **Optimize performance**: Add indexes and query optimization
+
+### Advanced Patterns
+- **Multi-user collaboration**: User permissions and access control
+- **Rich text editing**: Operational transforms for collaborative editing
+- **File synchronization**: Binary data and file attachment handling
+- **Schema migrations**: Evolving your data model over time
+
+### Platform-Specific Guides
+- **Web deployment**: Service workers, PWA configuration, OPFS optimization
+- **Mobile apps**: Background sync, push notifications, native storage
+- **Desktop apps**: Electron integration, native file system access
+
+## Examples Repository
+
+Explore complete working examples:
+- **TodoMVC**: Classic todo app with real-time sync
+- **Collaborative Editor**: Rich text editing with operational transforms
+- **Chat Application**: Real-time messaging with presence indicators
+- **E-commerce**: Product catalog with shopping cart and orders
+
+\`\`\`bash
+# Clone examples repository
+git clone https://github.com/livestorejs/examples.git
+cd examples/web-todomvc
+npm install && npm run dev
+\`\`\`
+
+Visit [docs.livestore.dev](https://docs.livestore.dev) for comprehensive documentation, API reference, and advanced patterns.`;
+//# sourceMappingURL=getting-started.js.map

package/dist/mcp-content/getting-started.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getting-started.js","sourceRoot":"","sources":["../../src/mcp-content/getting-started.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8HAmZyF,CAAA"}

package/dist/mcp-content/overview.d.ts

@@ -0,0 +1,2 @@
+export declare const overviewContent = "# LiveStore: Local-First Data Platform\n\nLiveStore is a production-ready local-first data platform that combines the immediate responsiveness of local SQLite databases with the collaborative power of real-time synchronization. Built on distributed systems principles from Martin Kleppmann's research, LiveStore enables applications that work seamlessly offline and sync reliably when online.\n\n## Core Philosophy\n\n**Local-First Principles**: Your data lives primarily on your device, not in the cloud. Applications respond immediately to user actions without network round-trips, providing the smooth experience users expect from native applications.\n\n**Collaborative by Design**: Real-time collaboration isn't an afterthought \u2013 it's built into the foundation. Multiple users can work together seamlessly with automatic conflict resolution and eventual consistency guarantees.\n\n**Reliability Through Event Sourcing**: All changes are captured as immutable events, providing a complete audit trail and enabling powerful features like undo/redo, time travel debugging, and deterministic testing.\n\n## What Makes LiveStore Different\n\n### \uD83D\uDCBE Local SQLite Performance\n- **Sub-millisecond queries** from local SQLite database\n- **Complex joins and aggregations** with full SQL expressiveness\n- **Reactive queries** that automatically update your UI\n- **ACID transactions** for data integrity\n\n### \uD83C\uDF10 Distributed Systems Reliability\n- **Conflict-free synchronization** using CRDT-inspired merge strategies\n- **Causal consistency** with vector clocks and event ordering\n- **Network partition tolerance** \u2013 works offline, syncs when online\n- **Eventually consistent** convergence across all replicas\n\n### \uD83D\uDD10 End-to-End Type Safety\n- **Schema-first development** with Effect-based validation\n- **Compile-time query validation** prevents runtime errors  \n- **Automatic TypeScript generation** from schema definitions\n- **Runtime safety** with comprehensive input validation\n\n### \uD83C\uDFD7\uFE0F Framework Agnostic\n- **React, Vue, Solid, Svelte** \u2013 use with any frontend framework\n- **Web, Node.js, React Native** \u2013 deploy anywhere JavaScript runs\n- **Consistent API** across all platforms and frameworks\n\n## Real-World Use Cases\n\n### \uD83D\uDCDD Collaborative Applications\n- **Document editors** with real-time collaboration (Google Docs-style)\n- **Project management** tools with team coordination\n- **Design tools** with multiplayer editing capabilities\n- **Chat applications** with offline message queuing\n\n### \uD83D\uDCF1 Mobile-First Applications  \n- **Field service apps** that work in areas with poor connectivity\n- **Healthcare applications** with sensitive data that must stay local\n- **Educational apps** for students in low-connectivity environments\n- **Financial apps** requiring immediate transaction feedback\n\n### \uD83C\uDFEE Enterprise Applications\n- **CRM systems** with offline sales capability\n- **Inventory management** with real-time stock updates\n- **Customer service** tools with offline case management\n- **Analytics dashboards** with local data caching\n\n## Architecture at a Glance\n\n```mermaid\ngraph TB\n    UI[UI Framework] --> Queries[Reactive Queries]\n    UI --> Events[Event Dispatch]\n    \n    Events --> EventLog[Event Log]\n    EventLog --> Materializers[Materializers]\n    Materializers --> SQLite[SQLite Database]\n    Queries --> SQLite\n    \n    EventLog --> Sync[Sync Engine]\n    Sync --> Network[Network Layer]\n    Network --> Server[Sync Server]\n    \n    Server --> OtherClients[Other Clients]\n    OtherClients --> Server\n    Server --> Network\n```\n\n1. **UI Layer**: Framework-specific bindings (React, Vue, etc.)\n2. **Query Layer**: Reactive SQL queries with automatic UI updates\n3. **Event Layer**: Immutable event log with schema validation\n4. **Materialization**: Events applied to SQLite tables via materializers\n5. **Synchronization**: Conflict-free replication across devices/users\n6. **Storage**: Local SQLite database for immediate data access\n\n## Key Technical Innovations\n\n### Event-Driven State Management\nUnlike traditional ORMs that hide change tracking, LiveStore makes all state changes explicit through events. This provides:\n- **Deterministic state updates** that can be tested and debugged\n- **Conflict resolution** through event reordering and semantic merging\n- **Time travel** capabilities for debugging and feature development\n- **Audit trails** for compliance and data governance\n\n### Sophisticated Conflict Resolution\nLiveStore handles conflicts intelligently using multiple strategies:\n- **Last-Write-Wins**: Simple timestamp-based resolution\n- **Semantic Merging**: Application-specific conflict resolution logic  \n- **Operational Transforms**: For real-time collaborative text editing\n- **CRDT Integration**: Conflict-free data types for specific use cases\n\n### Performance Optimization\n- **Query compilation caching** for repeated queries\n- **Reactive dependency tracking** to minimize unnecessary updates\n- **Incremental synchronization** to reduce network overhead\n- **Background processing** to keep the UI thread responsive\n\n## Production Ready\n\nLiveStore is designed for production applications with enterprise-grade requirements:\n\n- **Security**: End-to-end encryption, event signatures, access control\n- **Observability**: Distributed tracing, performance monitoring, health checks\n- **Scalability**: Horizontal scaling, connection pooling, data partitioning\n- **Reliability**: Automatic retries, circuit breakers, graceful degradation\n\nWhether you're building a simple todo app or a complex collaborative platform, LiveStore provides the foundation for applications that users love \u2013 fast, reliable, and always available.\n\n**Ready to get started?** Check out our [Getting Started Guide](./getting-started) or explore our [Example Applications](https://github.com/livestorejs/examples).";
+//# sourceMappingURL=overview.d.ts.map

package/dist/mcp-content/overview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overview.d.ts","sourceRoot":"","sources":["../../src/mcp-content/overview.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,y4LAsHuI,CAAA"}