@aeriondyseti/vector-memory-mcp 0.5.0 → 0.9.0-alpha.1

package/README.md

@@ -1,445 +1,149 @@
 # Vector Memory MCP Server
 
-> Replace static markdown context files with intelligent, semantically-searchable memories that understand what you're working on.
+> Semantic memory storage for AI assistants. Store decisions, patterns, and context that persists across sessions.
 
-A production-ready MCP (Model Context Protocol) server that provides semantic memory storage for AI assistants. Uses local embeddings and vector search to automatically retrieve relevant context without cloud dependencies.
-
-**Perfect for:** Software teams maintaining architectural knowledge, developers juggling multiple projects, and anyone building with AI assistants like Claude Code.
+A local-first MCP server that provides vector-based memory storage. Uses local embeddings and LanceDB for fast, private semantic search.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
-[![Bun](https://img.shields.io/badge/Bun-Required-black.svg)](https://bun.sh/)
-[![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-green.svg)](https://modelcontextprotocol.io)
+[![npm version](https://img.shields.io/npm/v/@aeriondyseti/vector-memory-mcp.svg)](https://www.npmjs.com/package/@aeriondyseti/vector-memory-mcp)
 
 ---
 
-## ✨ Features
-
-### 🔒 **Local-First & Private**
-- All embeddings generated locally (no cloud APIs)
-- Data stored in local LanceDB databases
-- Complete privacy and control over your memories
-
-### 🎯 **Intelligent Semantic Search**
-- Vector similarity with multi-factor scoring
-- Considers relevance, recency, priority, and usage frequency
-- Context-aware retrieval based on conversation flow
-
-### 📊 **Smart Memory Storage**
-- Stores memories in `~/.local/share/vector-memory-mcp/memories.db`
-- Fast LanceDB-based storage with vector search capabilities
-- Memories persist across sessions and projects
-
-### ⚡ **High Performance**
-- Sub-100ms search latency for 1000+ memories
-- Efficient storage (<10MB per 1000 memories)
-- CPU-optimized local embeddings (no GPU required)
+## Features
 
-### 🔌 **MCP Native Integration**
-- Works seamlessly with Claude Code
-- Session hooks for automatic context injection
-- Standard MCP protocol (compatible with future clients)
-
-### 🛠️ **Developer-Friendly**
-- Zero-configuration setup
-- Built with Bun for maximum performance
-- Simple MCP tools for storing and searching
-- TypeScript for type safety
+- **Local & Private** - All embeddings generated locally, data stored in local LanceDB
+- **Semantic Search** - Vector similarity search with configurable scoring
+- **Batch Operations** - Store, update, delete, and retrieve multiple memories at once
+- **Session Handoffs** - Save and restore project context between sessions
+- **MCP Native** - Standard protocol, works with any MCP-compatible client
 
 ---
 
-## 🚀 Quick Start
+## Quick Start
 
 ### Prerequisites
 
-- [Bun](https://bun.sh/) 1.0+
-- Claude Code or another MCP-compatible client
-
-> **Note:** This server requires Bun to run.
+- [Bun](https://bun.sh/) 1.0+ (recommended) or [Node.js](https://nodejs.org/) 20+
+- An MCP-compatible client (Claude Code, Claude Desktop, etc.)
 
-### Installation & Configuration
+### Install
 
-#### Option 1: Global Install (Recommended)
-
-**Install:**
+**With Bun (recommended):**
 ```bash
 bun install -g @aeriondyseti/vector-memory-mcp
 ```
 
-> **Note:** The installation automatically downloads ML models (~90MB) and verifies native dependencies. This may take a minute on first install.
+**With npm/Node.js:**
+```bash
+npm install -g @aeriondyseti/vector-memory-mcp
+```
+
+> First install downloads ML models (~90MB). This may take a minute.
+
+### Configure
+
+Add to your MCP client config (e.g., `~/.claude/settings.json`):
 
-**Configure Claude Code** - Add to `~/.claude/config.json`:
+**With Bun:**
 ```json
 {
   "mcpServers": {
-    "memory": {
+    "vector-memory": {
       "type": "stdio",
       "command": "bunx",
-      "args": [
-        "--bun",
-        "@aeriondyseti/vector-memory-mcp"
-      ],
-      "env": {}
+      "args": ["--bun", "@aeriondyseti/vector-memory-mcp"]
     }
   }
 }
 ```
 
-#### Option 2: Local Development
-
-**Install:**
-```bash
-git clone https://github.com/AerionDyseti/vector-memory-mcp.git
-cd vector-memory-mcp
-bun install
-```
-
-**Configure Claude Code** - Add to `~/.claude/config.json`:
+**With Node.js:**
 ```json
 {
   "mcpServers": {
-    "memory": {
-      "command": "bun",
-      "args": ["run", "/absolute/path/to/vector-memory-mcp/src/index.ts"]
+    "vector-memory": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@aeriondyseti/vector-memory-mcp"]
     }
   }
 }
 ```
-*Replace `/absolute/path/to/` with your actual installation path.*
 
----
-
-**What gets installed:**
-- The vector-memory-mcp package and all dependencies
-- Native binaries for ONNX Runtime (~32MB) and image processing (~10MB)
-- ML model files automatically downloaded during installation (~90MB, cached in `~/.cache/huggingface/`)
-- **Total first-time setup:** ~130MB of downloads
+### Use
 
-> 💡 **Tip:** If you need to re-download models or verify dependencies, run: `vector-memory-mcp warmup`
+Restart your MCP client. You now have access to:
 
-### Start Using It
-
-That's it! Restart Claude Code and you'll have access to memory tools:
-- `store_memory` - Save information for later recall
-- `search_memories` - Find relevant memories semantically
-- `get_memory` - Retrieve a specific memory by ID
-- `delete_memory` - Remove a memory
+| Tool | Description |
+|------|-------------|
+| `store_memories` | Save memories (accepts array) |
+| `search_memories` | Find relevant memories semantically |
+| `get_memories` | Retrieve memories by ID (accepts array) |
+| `update_memories` | Update existing memories |
+| `delete_memories` | Remove memories (accepts array) |
+| `store_handoff` | Save session context for later |
+| `get_handoff` | Restore session context |
 
 ---
 
-## 📖 Usage
-
-### Storing Memories
-
-Ask Claude Code to remember things for you:
+## Usage
 
+**Store a memory:**
 ```
 You: "Remember that we use Drizzle ORM for database access"
-Claude: [calls store_memory tool]
+Assistant: [calls store_memories]
 ```
 
-Or Claude Code can store memories directly:
-```json
-{
-  "content": "Use Drizzle ORM for type-safe database access",
-  "metadata": {
-    "tags": ["architecture", "database"],
-    "category": "tooling"
-  }
-}
-```
-
-### Searching Memories
-
-Claude Code automatically searches memories when relevant, or you can ask:
-
+**Search memories:**
 ```
 You: "What did we decide about the database?"
-Claude: [calls search_memories with query about database decisions]
-```
-
-Search parameters:
-```json
-{
-  "query": "authentication strategy",
-  "limit": 10
-}
-```
-
-### Managing Memories
-
-Retrieve a specific memory:
-```json
-{
-  "id": "memory-id-here"
-}
-```
-
-Delete a memory:
-```json
-{
-  "id": "memory-id-here"
-}
+Assistant: [calls search_memories with relevant query]
 ```
 
----
-
-## 🏗️ Architecture
-
+**Session handoffs:**
 ```
-vector-memory-mcp/
-├── src/
-│   ├── index.ts            # Entry point
-│   ├── config/             # Configuration management
-│   ├── db/                 # Database layer (LanceDB)
-│   ├── services/
-│   │   ├── embeddings.service.ts  # Embeddings via @huggingface/transformers
-│   │   └── memory.service.ts      # Core memory operations
-│   └── mcp/
-│       ├── server.ts       # MCP server setup
-│       ├── tools.ts        # MCP tool definitions
-│       └── handlers.ts     # Tool request handlers
-├── tests/
-│   ├── memory.test.ts
-│   └── embeddings.test.ts
-├── bin/
-│   └── vector-memory-mcp.js # Executable entry point
-└── package.json
+You: "Save context for next session"
+Assistant: [calls store_handoff with summary, completed items, next steps]
 ```
 
-### Technology Stack
-
-- **MCP Framework**: @modelcontextprotocol/sdk (official SDK)
-- **Vector Database**: LanceDB (fast, local, vector search)
-- **Embeddings**: [@huggingface/transformers](https://huggingface.co/docs/transformers.js) (Xenova/all-MiniLM-L6-v2, 384 dimensions)
-- **Language**: TypeScript 5.0+
-- **Runtime**: Bun 1.0+
-- **Testing**: Bun test
-
 ---
 
-## 🎨 How It Works
-
-### 1. Memory Storage
-
-```
-Claude Code calls store_memory tool
-         ↓
-Content → @huggingface/transformers → 384d vector
-         ↓
-Store in LanceDB with metadata
-         ↓
-~/.local/share/vector-memory-mcp/memories.db
-```
+## Configuration
 
-### 2. Memory Retrieval
+Environment variables:
 
-```
-Claude Code calls search_memories
-         ↓
-Query → @huggingface/transformers → 384d vector
-         ↓
-Vector search in LanceDB
-         ↓
-Vector similarity scoring
-         ↓
-Return top N relevant memories
-```
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `VECTOR_MEMORY_DB_PATH` | `.vector-memory/memories.db` | Database location |
+| `VECTOR_MEMORY_MODEL` | `Xenova/all-MiniLM-L6-v2` | Embedding model |
+| `VECTOR_MEMORY_HTTP_PORT` | `3271` | HTTP server port |
 
 ---
 
-## 🔧 Configuration
+## Development
 
-The server uses environment variables for configuration:
-
-- `VECTOR_MEMORY_DB_PATH` - Custom database path (default: `~/.local/share/vector-memory-mcp/memories.db`)
-- `VECTOR_MEMORY_MODEL` - Embedding model to use (default: `Xenova/all-MiniLM-L6-v2`)
-
-Example:
 ```bash
-export VECTOR_MEMORY_DB_PATH="/path/to/custom/memories.db"
-export VECTOR_MEMORY_MODEL="Xenova/all-MiniLM-L6-v2"
-```
-
-Or in your Claude Code config:
-```json
-{
-  "mcpServers": {
-    "memory": {
-      "command": "vector-memory-mcp",
-      "env": {
-        "VECTOR_MEMORY_DB_PATH": "/custom/path/memories.db"
-      }
-    }
-  }
-}
-```
-
----
-
-## 🧪 Development
-
-### Running Tests
-
-```bash
-# Run all tests
-bun test
-
-# Run with coverage
-bun test --coverage
-
-# Type checking
-bun run typecheck
-```
-
-### Development Mode
-
-```bash
-# Watch mode - auto-restart on file changes
-bun run dev
-
-# Run directly without building
-bun run src/index.ts
-```
-
-### Building
-
-```bash
-# Build for production
-bun run build
+git clone https://github.com/AerionDyseti/vector-memory-mcp.git
+cd vector-memory-mcp
+bun install
 
-# Output will be in dist/
+bun run test      # Run all tests
+bun run dev       # Watch mode
+bun run typecheck # Type checking
 ```
 
----
-
-## 🗺️ Roadmap
-
-### ✅ Phase 1: Foundation (Current)
-- ✅ Core database with LanceDB
-- ✅ Embedding generation with @huggingface/transformers
-- ✅ Basic MCP tools (store, search, get, delete)
-- ✅ TypeScript implementation with Drizzle ORM
-
-### 🚧 Phase 2: Enhanced Search & Scoring
-- Multi-factor scoring algorithm (similarity, recency, priority, usage frequency)
-- Configurable scoring weights
-- Priority levels for memories
-- Usage tracking and frequency-based ranking
-- Metadata filtering and advanced tagging
-
-### 📋 Phase 3: Dual-Level Memory System
-- Project-specific memories (`.memory/db` in repo)
-- Global memories (`~/.local/share/vector-memory-mcp/`)
-- Automatic precedence handling (project overrides global)
-- Project detection and context switching
-
-### 🎯 Phase 4: Smart Automation
-- Auto-detect architectural decisions
-- Capture bug fixes and solutions automatically
-- Generate session-end summaries
-- Natural language trigger detection (85%+ accuracy)
-- Continuous conversation monitoring
-
-### 🔮 Phase 5: Advanced Features
-- Memory deduplication with similarity threshold
-- Batch operations (import/export)
-- Markdown import/export
-- Memory clustering and visualization
-- Cross-project insights
-- Multi-modal memories (images, diagrams)
-- Session hooks for automatic context injection
-- Multi-CLI support (Cursor, Windsurf, etc.)
-- Smart priority suggestions
-
----
-
-## 🤝 Contributing
-
-Contributions are welcome! This project is in active development.
-
-### Areas We'd Love Help With:
-- Testing and bug reports
-- Documentation improvements
-- Performance optimizations
-- New feature ideas
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines *(coming soon)*.
-
----
-
-## 📄 License
-
-MIT License - see [LICENSE](LICENSE) for details.
-
----
-
-## 🙏 Acknowledgments
-
-- Built with [@modelcontextprotocol/sdk](https://github.com/modelcontextprotocol/typescript-sdk) - Official MCP TypeScript SDK
-- Uses [LanceDB](https://lancedb.com/) for fast, local vector search
-- Powered by [@huggingface/transformers](https://huggingface.co/docs/transformers.js) for local embeddings
-- Database layer via [Drizzle ORM](https://orm.drizzle.team/)
-- Inspired by [doobidoo's mcp-memory-service](https://github.com/doobidoo/mcp-memory-service)
-
----
-
-## 🔗 Related Projects
-
-- [Model Context Protocol](https://modelcontextprotocol.io) - Official MCP specification
-- [Claude Code](https://claude.ai/code) - AI coding assistant from Anthropic
-- [LanceDB](https://lancedb.com/) - Fast, local vector search
-- [Transformers.js](https://huggingface.co/docs/transformers.js) - Run transformers in JavaScript
-
----
-
-## 💬 Support
-
-- **Issues**: [GitHub Issues](https://github.com/AerionDyseti/vector-memory-mcp/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/AerionDyseti/vector-memory-mcp/discussions)
-- **Documentation**: Check the `docs/` directory
+See [CHANGELOG.md](CHANGELOG.md) for release history and [ROADMAP.md](ROADMAP.md) for planned features.
 
 ---
 
-## ⚡ Quick Examples
-
-### Example 1: Storing a Decision
-
-```
-You: "Remember that we decided to use Drizzle ORM for type-safe database access"
-Claude: I'll store that for you.
-  [Calls store_memory tool with content and metadata]
-  ✓ Memory stored successfully
-```
-
-### Example 2: Searching Memories
+## Contributing
 
-```
-You: "What did we decide about database tooling?"
-Claude: Let me search for that...
-  [Calls search_memories with query about database]
-  Found: "Use Drizzle ORM for type-safe database access"
-
-Based on our previous decision, we're using Drizzle ORM...
-```
+Contributions welcome! See [issues](https://github.com/AerionDyseti/vector-memory-mcp/issues) for areas we'd love help with.
 
-### Example 3: Managing Memories
+## License
 
-```
-You: "Show me what you remember about authentication"
-Claude: [Searches for authentication-related memories]
-  Found 3 memories:
-  1. "Use JWT tokens for API authentication"
-  2. "Store refresh tokens in httpOnly cookies"
-  3. "Implement rate limiting on auth endpoints"
-```
+MIT - see [LICENSE](LICENSE)
 
 ---
 
-<div align="center">
-
-**[⬆ Back to Top](#vector-memory-mcp-server)**
-
-Made with ❤️ for developers who value context continuity
-
-</div>
+Built with [MCP SDK](https://github.com/modelcontextprotocol/typescript-sdk), [LanceDB](https://lancedb.com/), and [Transformers.js](https://huggingface.co/docs/transformers.js)

package/dist/package.json

@@ -0,0 +1,73 @@
+{
+    "name": "@aeriondyseti/vector-memory-mcp",
+    "version": "0.9.0-alpha.1",
+    "description": "A zero-configuration RAG memory server for MCP clients",
+    "type": "module",
+    "main": "dist/src/index.js",
+    "bin": {
+        "vector-memory-mcp": "dist/src/index.js"
+    },
+    "files": [
+        "dist",
+        "scripts",
+        "hooks",
+        "README.md",
+        "LICENSE"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/AerionDyseti/vector-memory-mcp.git"
+    },
+    "author": "AerionDyseti",
+    "bugs": {
+        "url": "https://github.com/AerionDyseti/vector-memory-mcp/issues"
+    },
+    "homepage": "https://github.com/AerionDyseti/vector-memory-mcp#readme",
+    "scripts": {
+        "start": "node dist/src/index.js",
+        "dev": "bun run build && node dist/src/index.js",
+        "dev:watch": "bun run build && bun --watch run src/index.ts",
+        "build": "tsc",
+        "prebuild": "rm -rf dist",
+        "typecheck": "bunx tsc --noEmit",
+        "test": "bun run scripts/test-runner.ts",
+        "test:raw": "bun test --preload ./tests/preload.ts",
+        "test:quick": "bun test",
+        "test:coverage": "bun test --preload ./tests/preload.ts --coverage",
+        "test:preload": "bun run tests/preload.ts",
+        "warmup": "node dist/scripts/warmup.js",
+        "postinstall": "node dist/scripts/warmup.js",
+        "publish:check": "bun run scripts/publish.ts --dry-run",
+        "publish:npm": "bun run scripts/publish.ts",
+        "publish:alpha": "npm publish --access public --tag alpha",
+        "prepublishOnly": "bun run build"
+    },
+    "keywords": [
+        "mcp",
+        "memory",
+        "rag",
+        "embeddings",
+        "lancedb"
+    ],
+    "license": "MIT",
+    "dependencies": {
+        "@hono/node-server": "^1.19.7",
+        "@huggingface/transformers": "^3.8.0",
+        "@lancedb/lancedb": "^0.22.3",
+        "@modelcontextprotocol/sdk": "^1.0.0",
+        "arg": "^5.0.2",
+        "hono": "^4.11.3"
+    },
+    "devDependencies": {
+        "@types/bun": "latest",
+        "typescript": "^5.0.0"
+    },
+    "trustedDependencies": [
+        "onnxruntime-node",
+        "protobufjs",
+        "sharp"
+    ],
+    "overrides": {
+        "onnxruntime-node": "1.23.2"
+    }
+}

package/dist/scripts/publish.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+/**
+ * Publish script for vector-memory-mcp
+ *
+ * Prerequisites:
+ * 1. Create a granular access token at https://www.npmjs.com/settings/tokens
+ * 2. Store it: npm config set //registry.npmjs.org/:_authToken=npm_YOUR_TOKEN
+ *    Or set NPM_TOKEN environment variable
+ *
+ * Usage: bun run scripts/publish.ts [--dry-run]
+ */
+export {};
+//# sourceMappingURL=publish.d.ts.map

package/dist/scripts/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../scripts/publish.ts"],"names":[],"mappings":";AACA;;;;;;;;;GASG"}

package/dist/scripts/publish.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env bun
+/**
+ * Publish script for vector-memory-mcp
+ *
+ * Prerequisites:
+ * 1. Create a granular access token at https://www.npmjs.com/settings/tokens
+ * 2. Store it: npm config set //registry.npmjs.org/:_authToken=npm_YOUR_TOKEN
+ *    Or set NPM_TOKEN environment variable
+ *
+ * Usage: bun run scripts/publish.ts [--dry-run]
+ */
+import { $ } from "bun";
+const dryRun = process.argv.includes("--dry-run");
+async function main() {
+    // Check for authentication
+    console.log("🔐 Checking NPM authentication...");
+    try {
+        const whoami = await $ `npm whoami`.text();
+        console.log(`✅ Authenticated as: ${whoami.trim()}`);
+    }
+    catch {
+        console.error("❌ Not authenticated with NPM.");
+        console.error("   Option 1: npm login");
+        console.error("   Option 2: npm config set //registry.npmjs.org/:_authToken=npm_YOUR_TOKEN");
+        console.error("   Option 3: Set NPM_TOKEN environment variable");
+        process.exit(1);
+    }
+    // Run tests
+    console.log("🧪 Running tests...");
+    const testResult = await $ `bun run test`.quiet();
+    if (testResult.exitCode !== 0) {
+        console.error("❌ Tests failed. Aborting publish.");
+        process.exit(1);
+    }
+    console.log("✅ Tests passed");
+    // Build
+    console.log("🔨 Building...");
+    await $ `bun run build`;
+    console.log("✅ Build complete");
+    // Get version info
+    const pkg = await Bun.file("package.json").json();
+    console.log(`\n📦 Publishing ${pkg.name}@${pkg.version}...`);
+    if (dryRun) {
+        console.log("🔍 Dry run - would publish:");
+        await $ `npm publish --dry-run`;
+    }
+    else {
+        await $ `npm publish --access public`;
+        console.log(`\n✅ Published ${pkg.name}@${pkg.version}`);
+    }
+}
+main().catch((err) => {
+    console.error("❌ Publish failed:", err.message);
+    process.exit(1);
+});
+//# sourceMappingURL=publish.js.map

package/dist/scripts/publish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.js","sourceRoot":"","sources":["../../scripts/publish.ts"],"names":[],"mappings":";AACA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAElD,KAAK,UAAU,IAAI;IACjB,2BAA2B;IAC3B,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;IACjD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,CAAC,CAAA,YAAY,CAAC,IAAI,EAAE,CAAC;QAC1C,OAAO,CAAC,GAAG,CAAC,uBAAuB,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACtD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,KAAK,CAAC,+BAA+B,CAAC,CAAC;QAC/C,OAAO,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;QACxC,OAAO,CAAC,KAAK,CAAC,6EAA6E,CAAC,CAAC;QAC7F,OAAO,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACjE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,YAAY;IACZ,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;IACnC,MAAM,UAAU,GAAG,MAAM,CAAC,CAAA,cAAc,CAAC,KAAK,EAAE,CAAC;IACjD,IAAI,UAAU,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,CAAC,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACnD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAE9B,QAAQ;IACR,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAC9B,MAAM,CAAC,CAAA,eAAe,CAAC;IACvB,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;IAEhC,mBAAmB;IACnB,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,IAAI,EAAE,CAAC;IAClD,OAAO,CAAC,GAAG,CAAC,mBAAmB,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC;IAE7D,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;QAC3C,MAAM,CAAC,CAAA,uBAAuB,CAAC;IACjC,CAAC;SAAM,CAAC;QACN,MAAM,CAAC,CAAA,6BAA6B,CAAC;QACrC,OAAO,CAAC,GAAG,CAAC,iBAAiB,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,KAAK,CAAC,mBAAmB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAChD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/scripts/test-runner.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+/**
+ * Test runner wrapper that handles Bun's post-test crash gracefully.
+ *
+ * Bun crashes during native module cleanup after tests complete successfully.
+ * This wrapper captures the output, verifies tests passed, and exits cleanly.
+ */
+export {};
+//# sourceMappingURL=test-runner.d.ts.map

package/dist/scripts/test-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner.d.ts","sourceRoot":"","sources":["../../scripts/test-runner.ts"],"names":[],"mappings":";AACA;;;;;GAKG"}