transduck 0.2.5 → 0.3.1

package/README.md

@@ -2,7 +2,7 @@
 
 AI-powered translation for apps and websites. Fast. Cheap. No keys to manage.
 
-TransDuck translates your app's strings using AI, then caches them locally in DuckDB so you never pay for the same translation twice. No translation files. No key naming. No sync headaches.
+TransDuck translates your app's strings using AI, then caches them locally in LMDB so you never pay for the same translation twice. No translation files. No key naming. No sync headaches.
 
 ```typescript
 import { initialize, setLanguage, ait, aitPlural } from 'transduck';
@@ -19,7 +19,7 @@ await aitPlural('{count} night', '{count} nights', 7);   // → "7 Nächte"
 
 - **No keys to manage** — your source text is the key
 - **No translation files** — translations live in a single in-memory database file
-- **Translate once, pay once** — cached lookups take ~1.5ms, zero API costs after first call
+- **Translate once, pay once** — cached lookups take ~0.015ms, zero API costs after first call
 - **AI that understands context** — project and per-string context for accurate translations
 - **Pluralization that works everywhere** — handles Russian (4 forms), Arabic (6 forms) automatically
 - **Built for vibe coding** — AI coding tools read the docs and wrap strings with `ait()` across your project
@@ -80,7 +80,7 @@ transduck stats                           # check your translation database
 pip install transduck
 ```
 
-Works with Django, Flask, FastAPI, and Jinja. Same DuckDB database format — share translations between Python and JS.
+Works with Django, Flask, FastAPI, and Jinja. Same LMDB database format — share translations between Python and JS.
 
 ## Links
 

package/dist/cli.js

@@ -18,7 +18,7 @@ export async function runInit(opts) {
     const config = {
         project: { name: opts.name, context: opts.context },
         languages: { source: opts.sourceLang.toUpperCase(), targets: opts.targetLangs.map(l => l.toUpperCase()) },
-        storage: { path: './translations.duckdb' },
+        storage: { path: './translations.lmdb' },
     };
     if (providerChoice === 2) {
         config.backend = {
@@ -46,7 +46,7 @@ export async function runInit(opts) {
     }
     const configPath = join(opts.dir, 'transduck.yaml');
     writeFileSync(configPath, yamlStringify(config));
-    const dbPath = join(opts.dir, 'translations.duckdb');
+    const dbPath = join(opts.dir, 'translations.lmdb');
     const store = new TranslationStore(dbPath);
     await store.initialize();
     store.close();
@@ -454,7 +454,7 @@ export async function runStats(opts) {
 }
 // CLI entry point
 const program = new Command();
-program.name('transduck').description('AI-native translation tool').version('0.2.5');
+program.name('transduck').description('AI-native translation tool').version('0.3.1');
 program.command('init')
     .description('Initialize a new transduck project')
     .action(async () => {

package/dist/storage.d.ts

@@ -23,18 +23,23 @@ interface Stats {
 }
 export declare class TranslationStore {
     private dbPath;
-    private instance;
-    private conn;
+    private db;
     constructor(dbPath: string);
-    private getConn;
-    private convertRow;
-    query(sql: string, params?: string[]): Promise<Record<string, unknown>[]>;
     initialize(): Promise<void>;
+    private getDb;
     lookup(params: LookupParams): Promise<string | null>;
     insert(params: InsertParams): Promise<void>;
     lookupPlural(params: LookupParams): Promise<Record<string, string>>;
     insertPlural(params: InsertPluralParams): Promise<void>;
     stats(): Promise<Stats>;
+    /**
+     * Count entries matching optional filters.
+     */
+    count(targetLang?: string, failedOnly?: boolean): number;
+    /**
+     * Delete entries matching optional filters. Returns count deleted.
+     */
+    clear(targetLang?: string, failedOnly?: boolean): Promise<number>;
     close(): void;
 }
 export {};

package/dist/storage.js

@@ -1,178 +1,162 @@
-import { DuckDBInstance, DuckDBResultReader } from '@duckdb/node-api';
-const SCHEMA_V2 = `
-CREATE TABLE IF NOT EXISTS translations (
-    source_text          TEXT NOT NULL,
-    source_lang          TEXT NOT NULL,
-    target_lang          TEXT NOT NULL,
-    project_context_hash TEXT NOT NULL,
-    string_context_hash  TEXT NOT NULL,
-    plural_category      TEXT NOT NULL DEFAULT '',
-    translated_text      TEXT NOT NULL,
-    model                TEXT NOT NULL,
-    status               TEXT NOT NULL DEFAULT 'translated',
-    created_at           TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY(source_text, source_lang, target_lang, project_context_hash, string_context_hash, plural_category)
-);
-`;
-const MIGRATION_V1_TO_V2 = `
-CREATE TABLE translations_v2 (
-    source_text          TEXT NOT NULL,
-    source_lang          TEXT NOT NULL,
-    target_lang          TEXT NOT NULL,
-    project_context_hash TEXT NOT NULL,
-    string_context_hash  TEXT NOT NULL,
-    plural_category      TEXT NOT NULL DEFAULT '',
-    translated_text      TEXT NOT NULL,
-    model                TEXT NOT NULL,
-    status               TEXT NOT NULL DEFAULT 'translated',
-    created_at           TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY(source_text, source_lang, target_lang, project_context_hash, string_context_hash, plural_category)
-);
-INSERT INTO translations_v2
-    SELECT source_text, source_lang, target_lang, project_context_hash,
-           string_context_hash, '' as plural_category, translated_text,
-           model, status, created_at
-    FROM translations;
-DROP TABLE translations;
-ALTER TABLE translations_v2 RENAME TO translations;
-`;
-const CHECK_PLURAL_COLUMN = `
-SELECT column_name FROM information_schema.columns
-WHERE table_name = 'translations' AND column_name = 'plural_category'
-`;
-const LOOKUP_SQL = `
-SELECT translated_text FROM translations
-WHERE source_text = $1 AND source_lang = $2 AND target_lang = $3
-  AND project_context_hash = $4 AND string_context_hash = $5
-  AND plural_category = '' AND status = 'translated'
-`;
-const INSERT_SQL = `
-INSERT INTO translations
-    (source_text, source_lang, target_lang, project_context_hash,
-     string_context_hash, plural_category, translated_text, model, status)
-VALUES ($1, $2, $3, $4, $5, '', $6, $7, $8)
-ON CONFLICT DO NOTHING
-`;
-const LOOKUP_PLURAL_SQL = `
-SELECT plural_category, translated_text FROM translations
-WHERE source_text = $1 AND source_lang = $2 AND target_lang = $3
-  AND project_context_hash = $4 AND string_context_hash = $5
-  AND plural_category != '' AND status = 'translated'
-`;
-const INSERT_PLURAL_SQL = `
-INSERT INTO translations
-    (source_text, source_lang, target_lang, project_context_hash,
-     string_context_hash, plural_category, translated_text, model, status)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-ON CONFLICT DO NOTHING
-`;
+import { open } from 'lmdb';
+import { createHash } from 'crypto';
+// 1 GB default map size — plenty for translation caches
+const DEFAULT_MAP_SIZE = 1024 * 1024 * 1024;
+function contentHash(sourceText, projectContextHash, stringContextHash) {
+    return createHash('sha256')
+        .update(sourceText + '\x00' + projectContextHash + '\x00' + stringContextHash)
+        .digest('hex');
+}
+function makeKey(sourceLang, targetLang, chash, pluralCategory) {
+    return `${sourceLang}|${targetLang}|${chash}|${pluralCategory}`;
+}
+function parseKey(key) {
+    const parts = key.split('|');
+    return {
+        sourceLang: parts[0],
+        targetLang: parts[1],
+        contentHash: parts[2],
+        pluralCategory: parts[3] ?? '',
+    };
+}
 export class TranslationStore {
     dbPath;
-    instance = null;
-    conn = null;
+    db = null;
     constructor(dbPath) {
         this.dbPath = dbPath;
     }
-    async getConn() {
-        if (!this.conn)
-            throw new Error('Store not initialized');
-        return this.conn;
-    }
-    convertRow(row) {
-        const converted = {};
-        for (const [key, value] of Object.entries(row)) {
-            if (typeof value === 'bigint') {
-                converted[key] = Number(value);
-            }
-            else {
-                converted[key] = value;
-            }
-        }
-        return converted;
-    }
-    async query(sql, params = []) {
-        const conn = await this.getConn();
-        let result;
-        if (params.length === 0) {
-            result = await conn.run(sql);
-        }
-        else {
-            const stmt = await conn.prepare(sql);
-            for (let i = 0; i < params.length; i++) {
-                stmt.bindVarchar(i + 1, params[i]);
-            }
-            result = await stmt.run();
-        }
-        const reader = new DuckDBResultReader(result);
-        await reader.readAll();
-        return [...reader.getRowObjects()].map(row => this.convertRow(row));
-    }
     async initialize() {
-        this.instance = await DuckDBInstance.create(this.dbPath);
-        this.conn = await this.instance.connect();
-        // Check if table exists
-        const tables = await this.query("SELECT table_name FROM information_schema.tables WHERE table_name = 'translations'");
-        if (tables.length === 0) {
-            // Fresh database — create v2 schema
-            await this.conn.run(SCHEMA_V2);
-            return;
-        }
-        // Table exists — check if it has plural_category (v2)
-        const hasPlural = await this.query(CHECK_PLURAL_COLUMN);
-        if (hasPlural.length === 0) {
-            // Migrate from v1 to v2
-            await this.conn.run(MIGRATION_V1_TO_V2);
-        }
+        this.db = open({
+            path: this.dbPath,
+            mapSize: DEFAULT_MAP_SIZE,
+            // Use msgpack (default) for efficient storage
+        });
+    }
+    getDb() {
+        if (!this.db)
+            throw new Error('Store not initialized');
+        return this.db;
     }
     async lookup(params) {
-        const rows = await this.query(LOOKUP_SQL, [
-            params.sourceText, params.sourceLang, params.targetLang,
-            params.projectContextHash, params.stringContextHash,
-        ]);
-        return rows.length > 0 ? rows[0].translated_text : null;
+        const db = this.getDb();
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const key = makeKey(params.sourceLang, params.targetLang, chash, '');
+        const entry = db.get(key);
+        if (entry && entry.status === 'translated') {
+            return entry.translated_text;
+        }
+        return null;
     }
     async insert(params) {
-        await this.query(INSERT_SQL, [
-            params.sourceText, params.sourceLang, params.targetLang,
-            params.projectContextHash, params.stringContextHash,
-            params.translatedText, params.model, params.status,
-        ]);
+        const db = this.getDb();
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const key = makeKey(params.sourceLang, params.targetLang, chash, '');
+        // ON CONFLICT DO NOTHING — only insert if key doesn't exist
+        if (db.get(key) !== undefined)
+            return;
+        await db.put(key, {
+            source_text: params.sourceText,
+            translated_text: params.translatedText,
+            model: params.model,
+            status: params.status,
+            created_at: new Date().toISOString(),
+            project_context_hash: params.projectContextHash,
+            string_context_hash: params.stringContextHash,
+        });
     }
     async lookupPlural(params) {
-        const rows = await this.query(LOOKUP_PLURAL_SQL, [
-            params.sourceText, params.sourceLang, params.targetLang,
-            params.projectContextHash, params.stringContextHash,
-        ]);
+        const db = this.getDb();
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const prefix = makeKey(params.sourceLang, params.targetLang, chash, '');
         const result = {};
-        for (const row of rows) {
-            result[row.plural_category] = row.translated_text;
+        for (const { key, value } of db.getRange({ start: prefix })) {
+            const keyStr = key;
+            if (!keyStr.startsWith(prefix))
+                break;
+            const parsed = parseKey(keyStr);
+            // Skip regular entries (empty plural_category)
+            if (!parsed.pluralCategory)
+                continue;
+            if (value.status === 'translated') {
+                result[parsed.pluralCategory] = value.translated_text;
+            }
         }
         return result;
     }
     async insertPlural(params) {
-        await this.query(INSERT_PLURAL_SQL, [
-            params.sourceText, params.sourceLang, params.targetLang,
-            params.projectContextHash, params.stringContextHash,
-            params.pluralCategory, params.translatedText, params.model, params.status,
-        ]);
+        const db = this.getDb();
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const key = makeKey(params.sourceLang, params.targetLang, chash, params.pluralCategory);
+        // ON CONFLICT DO NOTHING
+        if (db.get(key) !== undefined)
+            return;
+        await db.put(key, {
+            source_text: params.sourceText,
+            translated_text: params.translatedText,
+            model: params.model,
+            status: params.status,
+            created_at: new Date().toISOString(),
+            project_context_hash: params.projectContextHash,
+            string_context_hash: params.stringContextHash,
+        });
     }
     async stats() {
-        const totalRows = await this.query("SELECT count(*) as c FROM translations WHERE status = 'translated'");
-        const failedRows = await this.query("SELECT count(*) as c FROM translations WHERE status = 'failed'");
-        const langRows = await this.query("SELECT target_lang, count(*) as c FROM translations WHERE status = 'translated' GROUP BY target_lang");
+        const db = this.getDb();
+        let totalTranslations = 0;
+        let totalFailed = 0;
         const byLanguage = {};
-        for (const row of langRows) {
-            byLanguage[row.target_lang] = Number(row.c);
+        for (const { key, value } of db.getRange({})) {
+            const parsed = parseKey(key);
+            if (value.status === 'translated') {
+                totalTranslations++;
+                byLanguage[parsed.targetLang] = (byLanguage[parsed.targetLang] ?? 0) + 1;
+            }
+            else if (value.status === 'failed') {
+                totalFailed++;
+            }
+        }
+        return { totalTranslations, totalFailed, byLanguage };
+    }
+    /**
+     * Count entries matching optional filters.
+     */
+    count(targetLang, failedOnly) {
+        const db = this.getDb();
+        let n = 0;
+        for (const { key, value } of db.getRange({})) {
+            const parsed = parseKey(key);
+            if (targetLang && parsed.targetLang !== targetLang)
+                continue;
+            if (failedOnly && value.status !== 'failed')
+                continue;
+            n++;
         }
-        return {
-            totalTranslations: Number(totalRows[0].c),
-            totalFailed: Number(failedRows[0].c),
-            byLanguage,
-        };
+        return n;
+    }
+    /**
+     * Delete entries matching optional filters. Returns count deleted.
+     */
+    async clear(targetLang, failedOnly) {
+        const db = this.getDb();
+        const toDelete = [];
+        for (const { key, value } of db.getRange({})) {
+            const keyStr = key;
+            const parsed = parseKey(keyStr);
+            if (targetLang && parsed.targetLang !== targetLang)
+                continue;
+            if (failedOnly && value.status !== 'failed')
+                continue;
+            toDelete.push(keyStr);
+        }
+        for (const k of toDelete) {
+            await db.remove(k);
+        }
+        return toDelete.length;
     }
     close() {
-        // @duckdb/node-api handles cleanup via GC
-        this.conn = null;
-        this.instance = null;
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transduck",
-  "version": "0.2.5",
+  "version": "0.3.1",
   "description": "AI-native translation tool using source text as keys",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,16 +24,16 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@duckdb/node-api": "^1.5.0-r.1",
     "commander": "^12.0.0",
+    "lmdb": "^3.5.2",
     "openai": "^4.0.0",
     "yaml": "^2.0.0"
   },
   "devDependencies": {
+    "@testing-library/react": "^16.0.0",
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
-    "@testing-library/react": "^16.0.0",
     "jsdom": "^25.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
@@ -41,15 +41,23 @@
     "vitest": "^2.0.0"
   },
   "peerDependencies": {
-    "react": ">=18.0.0",
-    "react-dom": ">=18.0.0",
+    "@anthropic-ai/claude-agent-sdk": ">=0.1.0",
     "@anthropic-ai/sdk": ">=0.30.0",
-    "@anthropic-ai/claude-agent-sdk": ">=0.1.0"
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
   },
   "peerDependenciesMeta": {
-    "react": { "optional": true },
-    "react-dom": { "optional": true },
-    "@anthropic-ai/sdk": { "optional": true },
-    "@anthropic-ai/claude-agent-sdk": { "optional": true }
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    }
   }
 }

package/src/cli.ts

@@ -31,7 +31,7 @@ export async function runInit(opts: InitOptions): Promise<string> {
   const config: Record<string, any> = {
     project: { name: opts.name, context: opts.context },
     languages: { source: opts.sourceLang.toUpperCase(), targets: opts.targetLangs.map(l => l.toUpperCase()) },
-    storage: { path: './translations.duckdb' },
+    storage: { path: './translations.lmdb' },
   };
 
   if (providerChoice === 2) {
@@ -60,7 +60,7 @@ export async function runInit(opts: InitOptions): Promise<string> {
   const configPath = join(opts.dir, 'transduck.yaml');
   writeFileSync(configPath, yamlStringify(config));
 
-  const dbPath = join(opts.dir, 'translations.duckdb');
+  const dbPath = join(opts.dir, 'translations.lmdb');
   const store = new TranslationStore(dbPath);
   await store.initialize();
   store.close();
@@ -562,7 +562,7 @@ export async function runStats(opts: StatsOptions): Promise<string> {
 // CLI entry point
 const program = new Command();
 
-program.name('transduck').description('AI-native translation tool').version('0.2.5');
+program.name('transduck').description('AI-native translation tool').version('0.3.1');
 
 program.command('init')
   .description('Initialize a new transduck project')

package/src/storage.ts

@@ -1,79 +1,8 @@
-import { DuckDBInstance, DuckDBResultReader } from '@duckdb/node-api';
-import type { DuckDBConnection } from '@duckdb/node-api';
-
-const SCHEMA_V2 = `
-CREATE TABLE IF NOT EXISTS translations (
-    source_text          TEXT NOT NULL,
-    source_lang          TEXT NOT NULL,
-    target_lang          TEXT NOT NULL,
-    project_context_hash TEXT NOT NULL,
-    string_context_hash  TEXT NOT NULL,
-    plural_category      TEXT NOT NULL DEFAULT '',
-    translated_text      TEXT NOT NULL,
-    model                TEXT NOT NULL,
-    status               TEXT NOT NULL DEFAULT 'translated',
-    created_at           TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY(source_text, source_lang, target_lang, project_context_hash, string_context_hash, plural_category)
-);
-`;
-
-const MIGRATION_V1_TO_V2 = `
-CREATE TABLE translations_v2 (
-    source_text          TEXT NOT NULL,
-    source_lang          TEXT NOT NULL,
-    target_lang          TEXT NOT NULL,
-    project_context_hash TEXT NOT NULL,
-    string_context_hash  TEXT NOT NULL,
-    plural_category      TEXT NOT NULL DEFAULT '',
-    translated_text      TEXT NOT NULL,
-    model                TEXT NOT NULL,
-    status               TEXT NOT NULL DEFAULT 'translated',
-    created_at           TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY(source_text, source_lang, target_lang, project_context_hash, string_context_hash, plural_category)
-);
-INSERT INTO translations_v2
-    SELECT source_text, source_lang, target_lang, project_context_hash,
-           string_context_hash, '' as plural_category, translated_text,
-           model, status, created_at
-    FROM translations;
-DROP TABLE translations;
-ALTER TABLE translations_v2 RENAME TO translations;
-`;
-
-const CHECK_PLURAL_COLUMN = `
-SELECT column_name FROM information_schema.columns
-WHERE table_name = 'translations' AND column_name = 'plural_category'
-`;
-
-const LOOKUP_SQL = `
-SELECT translated_text FROM translations
-WHERE source_text = $1 AND source_lang = $2 AND target_lang = $3
-  AND project_context_hash = $4 AND string_context_hash = $5
-  AND plural_category = '' AND status = 'translated'
-`;
-
-const INSERT_SQL = `
-INSERT INTO translations
-    (source_text, source_lang, target_lang, project_context_hash,
-     string_context_hash, plural_category, translated_text, model, status)
-VALUES ($1, $2, $3, $4, $5, '', $6, $7, $8)
-ON CONFLICT DO NOTHING
-`;
-
-const LOOKUP_PLURAL_SQL = `
-SELECT plural_category, translated_text FROM translations
-WHERE source_text = $1 AND source_lang = $2 AND target_lang = $3
-  AND project_context_hash = $4 AND string_context_hash = $5
-  AND plural_category != '' AND status = 'translated'
-`;
-
-const INSERT_PLURAL_SQL = `
-INSERT INTO translations
-    (source_text, source_lang, target_lang, project_context_hash,
-     string_context_hash, plural_category, translated_text, model, status)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-ON CONFLICT DO NOTHING
-`;
+import { open, type Database, type RootDatabase } from 'lmdb';
+import { createHash } from 'crypto';
+
+// 1 GB default map size — plenty for translation caches
+const DEFAULT_MAP_SIZE = 1024 * 1024 * 1024;
 
 export interface LookupParams {
   sourceText: string;
@@ -96,134 +25,184 @@ export interface InsertPluralParams extends LookupParams {
   status: string;
 }
 
+interface StoredEntry {
+  source_text: string;
+  translated_text: string;
+  model: string;
+  status: string;
+  created_at: string;
+  project_context_hash: string;
+  string_context_hash: string;
+}
+
 interface Stats {
   totalTranslations: number;
   totalFailed: number;
   byLanguage: Record<string, number>;
 }
 
+function contentHash(sourceText: string, projectContextHash: string, stringContextHash: string): string {
+  return createHash('sha256')
+    .update(sourceText + '\x00' + projectContextHash + '\x00' + stringContextHash)
+    .digest('hex');
+}
+
+function makeKey(sourceLang: string, targetLang: string, chash: string, pluralCategory: string): string {
+  return `${sourceLang}|${targetLang}|${chash}|${pluralCategory}`;
+}
+
+function parseKey(key: string): { sourceLang: string; targetLang: string; contentHash: string; pluralCategory: string } {
+  const parts = key.split('|');
+  return {
+    sourceLang: parts[0],
+    targetLang: parts[1],
+    contentHash: parts[2],
+    pluralCategory: parts[3] ?? '',
+  };
+}
+
 export class TranslationStore {
   private dbPath: string;
-  private instance: DuckDBInstance | null = null;
-  private conn: DuckDBConnection | null = null;
+  private db: RootDatabase<StoredEntry, string> | null = null;
 
   constructor(dbPath: string) {
     this.dbPath = dbPath;
   }
 
-  private async getConn(): Promise<DuckDBConnection> {
-    if (!this.conn) throw new Error('Store not initialized');
-    return this.conn;
-  }
-
-  private convertRow(row: Record<string, unknown>): Record<string, unknown> {
-    const converted: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(row)) {
-      if (typeof value === 'bigint') {
-        converted[key] = Number(value);
-      } else {
-        converted[key] = value;
-      }
-    }
-    return converted;
-  }
-
-  async query(sql: string, params: string[] = []): Promise<Record<string, unknown>[]> {
-    const conn = await this.getConn();
-    let result;
-    if (params.length === 0) {
-      result = await conn.run(sql);
-    } else {
-      const stmt = await conn.prepare(sql);
-      for (let i = 0; i < params.length; i++) {
-        stmt.bindVarchar(i + 1, params[i]);
-      }
-      result = await stmt.run();
-    }
-    const reader = new DuckDBResultReader(result);
-    await reader.readAll();
-    return [...reader.getRowObjects()].map(row => this.convertRow(row));
-  }
-
   async initialize(): Promise<void> {
-    this.instance = await DuckDBInstance.create(this.dbPath);
-    this.conn = await this.instance.connect();
-
-    // Check if table exists
-    const tables = await this.query(
-      "SELECT table_name FROM information_schema.tables WHERE table_name = 'translations'"
-    );
-
-    if (tables.length === 0) {
-      // Fresh database — create v2 schema
-      await this.conn.run(SCHEMA_V2);
-      return;
-    }
+    this.db = open<StoredEntry, string>({
+      path: this.dbPath,
+      mapSize: DEFAULT_MAP_SIZE,
+      // Use msgpack (default) for efficient storage
+    });
+  }
 
-    // Table exists — check if it has plural_category (v2)
-    const hasPlural = await this.query(CHECK_PLURAL_COLUMN);
-    if (hasPlural.length === 0) {
-      // Migrate from v1 to v2
-      await this.conn.run(MIGRATION_V1_TO_V2);
-    }
+  private getDb(): RootDatabase<StoredEntry, string> {
+    if (!this.db) throw new Error('Store not initialized');
+    return this.db;
   }
 
   async lookup(params: LookupParams): Promise<string | null> {
-    const rows = await this.query(LOOKUP_SQL, [
-      params.sourceText, params.sourceLang, params.targetLang,
-      params.projectContextHash, params.stringContextHash,
-    ]);
-    return rows.length > 0 ? (rows[0].translated_text as string) : null;
+    const db = this.getDb();
+    const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+    const key = makeKey(params.sourceLang, params.targetLang, chash, '');
+    const entry = db.get(key);
+    if (entry && entry.status === 'translated') {
+      return entry.translated_text;
+    }
+    return null;
   }
 
   async insert(params: InsertParams): Promise<void> {
-    await this.query(INSERT_SQL, [
-      params.sourceText, params.sourceLang, params.targetLang,
-      params.projectContextHash, params.stringContextHash,
-      params.translatedText, params.model, params.status,
-    ]);
+    const db = this.getDb();
+    const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+    const key = makeKey(params.sourceLang, params.targetLang, chash, '');
+    // ON CONFLICT DO NOTHING — only insert if key doesn't exist
+    if (db.get(key) !== undefined) return;
+    await db.put(key, {
+      source_text: params.sourceText,
+      translated_text: params.translatedText,
+      model: params.model,
+      status: params.status,
+      created_at: new Date().toISOString(),
+      project_context_hash: params.projectContextHash,
+      string_context_hash: params.stringContextHash,
+    });
   }
 
   async lookupPlural(params: LookupParams): Promise<Record<string, string>> {
-    const rows = await this.query(LOOKUP_PLURAL_SQL, [
-      params.sourceText, params.sourceLang, params.targetLang,
-      params.projectContextHash, params.stringContextHash,
-    ]);
+    const db = this.getDb();
+    const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+    const prefix = makeKey(params.sourceLang, params.targetLang, chash, '');
     const result: Record<string, string> = {};
-    for (const row of rows) {
-      result[row.plural_category as string] = row.translated_text as string;
+
+    for (const { key, value } of db.getRange({ start: prefix })) {
+      const keyStr = key as string;
+      if (!keyStr.startsWith(prefix)) break;
+      const parsed = parseKey(keyStr);
+      // Skip regular entries (empty plural_category)
+      if (!parsed.pluralCategory) continue;
+      if (value.status === 'translated') {
+        result[parsed.pluralCategory] = value.translated_text;
+      }
     }
     return result;
   }
 
   async insertPlural(params: InsertPluralParams): Promise<void> {
-    await this.query(INSERT_PLURAL_SQL, [
-      params.sourceText, params.sourceLang, params.targetLang,
-      params.projectContextHash, params.stringContextHash,
-      params.pluralCategory, params.translatedText, params.model, params.status,
-    ]);
+    const db = this.getDb();
+    const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+    const key = makeKey(params.sourceLang, params.targetLang, chash, params.pluralCategory);
+    // ON CONFLICT DO NOTHING
+    if (db.get(key) !== undefined) return;
+    await db.put(key, {
+      source_text: params.sourceText,
+      translated_text: params.translatedText,
+      model: params.model,
+      status: params.status,
+      created_at: new Date().toISOString(),
+      project_context_hash: params.projectContextHash,
+      string_context_hash: params.stringContextHash,
+    });
   }
 
   async stats(): Promise<Stats> {
-    const totalRows = await this.query("SELECT count(*) as c FROM translations WHERE status = 'translated'");
-    const failedRows = await this.query("SELECT count(*) as c FROM translations WHERE status = 'failed'");
-    const langRows = await this.query(
-      "SELECT target_lang, count(*) as c FROM translations WHERE status = 'translated' GROUP BY target_lang"
-    );
+    const db = this.getDb();
+    let totalTranslations = 0;
+    let totalFailed = 0;
     const byLanguage: Record<string, number> = {};
-    for (const row of langRows) {
-      byLanguage[row.target_lang as string] = Number(row.c);
+
+    for (const { key, value } of db.getRange({})) {
+      const parsed = parseKey(key as string);
+      if (value.status === 'translated') {
+        totalTranslations++;
+        byLanguage[parsed.targetLang] = (byLanguage[parsed.targetLang] ?? 0) + 1;
+      } else if (value.status === 'failed') {
+        totalFailed++;
+      }
     }
-    return {
-      totalTranslations: Number(totalRows[0].c),
-      totalFailed: Number(failedRows[0].c),
-      byLanguage,
-    };
+
+    return { totalTranslations, totalFailed, byLanguage };
+  }
+
+  /**
+   * Count entries matching optional filters.
+   */
+  count(targetLang?: string, failedOnly?: boolean): number {
+    const db = this.getDb();
+    let n = 0;
+    for (const { key, value } of db.getRange({})) {
+      const parsed = parseKey(key as string);
+      if (targetLang && parsed.targetLang !== targetLang) continue;
+      if (failedOnly && value.status !== 'failed') continue;
+      n++;
+    }
+    return n;
+  }
+
+  /**
+   * Delete entries matching optional filters. Returns count deleted.
+   */
+  async clear(targetLang?: string, failedOnly?: boolean): Promise<number> {
+    const db = this.getDb();
+    const toDelete: string[] = [];
+    for (const { key, value } of db.getRange({})) {
+      const keyStr = key as string;
+      const parsed = parseKey(keyStr);
+      if (targetLang && parsed.targetLang !== targetLang) continue;
+      if (failedOnly && value.status !== 'failed') continue;
+      toDelete.push(keyStr);
+    }
+    for (const k of toDelete) {
+      await db.remove(k);
+    }
+    return toDelete.length;
   }
 
   close(): void {
-    // @duckdb/node-api handles cleanup via GC
-    this.conn = null;
-    this.instance = null;
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
   }
 }

package/tests/ait.test.ts

@@ -15,7 +15,7 @@ function makeConfig(tmpDir: string): TransduckConfig {
     projectContext: 'A test site',
     sourceLang: 'EN',
     targetLangs: ['DE', 'ES'],
-    storagePath: join(tmpDir, 'test.duckdb'),
+    storagePath: join(tmpDir, 'test.lmdb'),
     provider: 'openai',
     apiKeyEnv: 'OPENAI_API_KEY',
     tokenEnv: 'CLAUDE_CODE_OAUTH_TOKEN',

package/tests/backend.test.ts

@@ -8,7 +8,7 @@ function makeConfig(): TransduckConfig {
     projectContext: 'A travel site about Mallorca',
     sourceLang: 'EN',
     targetLangs: ['DE'],
-    storagePath: '/tmp/test.duckdb',
+    storagePath: '/tmp/test.lmdb',
     provider: 'openai',
     apiKeyEnv: 'OPENAI_API_KEY',
     tokenEnv: 'CLAUDE_CODE_OAUTH_TOKEN',

package/tests/cli.test.ts

@@ -27,7 +27,7 @@ languages:
   targets:
     - DE
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   api_key_env: OPENAI_API_KEY
   model: gpt-4.1-mini
@@ -55,7 +55,7 @@ describe('CLI functions', () => {
     });
     const { existsSync } = await import('fs');
     expect(existsSync(join(tmpDir, 'transduck.yaml'))).toBe(true);
-    expect(existsSync(join(tmpDir, 'translations.duckdb'))).toBe(true);
+    expect(existsSync(join(tmpDir, 'translations.lmdb'))).toBe(true);
   });
 
   it('stats on empty db shows zero', async () => {
@@ -68,7 +68,7 @@ describe('CLI functions', () => {
 
   it('translate returns cached with vars interpolated', async () => {
     const configPath = writeConfig(tmpDir);
-    const dbPath = join(tmpDir, 'translations.duckdb');
+    const dbPath = join(tmpDir, 'translations.lmdb');
 
     // Pre-populate the DB
     const store = new TranslationStore(dbPath);
@@ -91,7 +91,7 @@ describe('CLI functions', () => {
 
   it('translate-plural returns cached plural form', async () => {
     const configPath = writeConfig(tmpDir);
-    const dbPath = join(tmpDir, 'translations.duckdb');
+    const dbPath = join(tmpDir, 'translations.lmdb');
 
     // Pre-populate the DB with plural forms
     const store = new TranslationStore(dbPath);
@@ -132,7 +132,7 @@ describe('CLI functions', () => {
 
   it('warm handles plural entries', async () => {
     const configPath = writeConfig(tmpDir);
-    const dbPath = join(tmpDir, 'translations.duckdb');
+    const dbPath = join(tmpDir, 'translations.lmdb');
 
     // Pre-populate some plural forms so warm skips them
     const store = new TranslationStore(dbPath);
@@ -202,7 +202,7 @@ describe('CLI functions', () => {
     writeFileSync(join(srcDir, 'app.py'), 'ait("Hello")\n');
 
     // Pre-populate the DB so warm skips
-    const dbPath = join(tmpDir, 'translations.duckdb');
+    const dbPath = join(tmpDir, 'translations.lmdb');
     const store = new TranslationStore(dbPath);
     await store.initialize();
     await store.insert({

package/tests/config.test.ts

@@ -19,7 +19,7 @@ languages:
     - DE
     - ES
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   api_key_env: OPENAI_API_KEY
   model: gpt-4.1-mini
@@ -60,7 +60,7 @@ describe('loadConfig', () => {
     const configPath = join(tmpDir, 'transduck.yaml');
     writeFileSync(configPath, VALID_YAML);
     const cfg = loadConfig(configPath);
-    expect(cfg.storagePath).toBe(join(tmpDir, 'translations.duckdb'));
+    expect(cfg.storagePath).toBe(join(tmpDir, 'translations.lmdb'));
   });
 
   it('discovers config from TRANSDUCK_CONFIG env var', () => {

package/tests/handler.test.ts

@@ -21,7 +21,7 @@ languages:
   targets:
     - DE
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   api_key_env: OPENAI_API_KEY
   model: gpt-4.1-mini
@@ -48,7 +48,7 @@ describe('handleTranslationRequest', () => {
     const { createHash } = await import('crypto');
     const hash = (t: string) => createHash('sha256').update(t).digest('hex');
 
-    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    const store = new TranslationStore(join(tmpDir, 'translations.lmdb'));
     await store.initialize();
     await store.insert({
       sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
@@ -83,7 +83,7 @@ describe('handleTranslationRequest', () => {
     const { createHash } = await import('crypto');
     const hash = (t: string) => createHash('sha256').update(t).digest('hex');
 
-    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    const store = new TranslationStore(join(tmpDir, 'translations.lmdb'));
     await store.initialize();
     await store.insert({
       sourceText: 'Book', sourceLang: 'EN', targetLang: 'DE',
@@ -106,7 +106,7 @@ describe('handleTranslationRequest', () => {
     const { createHash } = await import('crypto');
     const hash = (t: string) => createHash('sha256').update(t).digest('hex');
 
-    const store = new TranslationStore(join(tmpDir, 'translations.duckdb'));
+    const store = new TranslationStore(join(tmpDir, 'translations.lmdb'));
     await store.initialize();
     const sourceKey = '{count} item\x00{count} items';
     await store.insertPlural({

package/tests/providers.test.ts

@@ -20,7 +20,7 @@ function makeConfig(overrides: Partial<TransduckConfig> = {}): TransduckConfig {
     projectContext: 'A test site',
     sourceLang: 'EN',
     targetLangs: ['DE'],
-    storagePath: '/tmp/test.duckdb',
+    storagePath: '/tmp/test.lmdb',
     provider: 'openai',
     apiKeyEnv: 'OPENAI_API_KEY',
     tokenEnv: 'CLAUDE_CODE_OAUTH_TOKEN',
@@ -207,7 +207,7 @@ languages:
   source: EN
   targets: [DE]
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   api_key_env: OPENAI_API_KEY
   model: gpt-4.1-mini
@@ -230,7 +230,7 @@ languages:
   source: EN
   targets: [DE]
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   provider: claude_api
   api_key_env: ANTHROPIC_API_KEY
@@ -255,7 +255,7 @@ languages:
   source: EN
   targets: [DE]
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   provider: claude_code
   token_env: CLAUDE_CODE_OAUTH_TOKEN
@@ -277,7 +277,7 @@ languages:
   source: EN
   targets: [DE]
 storage:
-  path: ./translations.duckdb
+  path: ./translations.lmdb
 backend:
   provider: claude_code
 `);

package/tests/storage.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { createHash } from 'crypto';
 import { join } from 'path';
 import { mkdtempSync } from 'fs';
@@ -14,13 +14,17 @@ describe('TranslationStore', () => {
 
   beforeEach(async () => {
     const tmpDir = mkdtempSync(join(tmpdir(), 'transduck-test-'));
-    store = new TranslationStore(join(tmpDir, 'test.duckdb'));
+    store = new TranslationStore(join(tmpDir, 'test.lmdb'));
     await store.initialize();
   });
 
-  it('creates table on initialize', async () => {
-    const result = await store.query('SELECT count(*) as c FROM translations');
-    expect(result[0].c).toBe(0);
+  afterEach(() => {
+    store.close();
+  });
+
+  it('starts empty', async () => {
+    const stats = await store.stats();
+    expect(stats.totalTranslations).toBe(0);
   });
 
   it('inserts and looks up translation', async () => {
@@ -195,68 +199,32 @@ describe('TranslationStore', () => {
     await store.insertPlural(entry); // should not throw
   });
 
-  // --- Migration ---
-
-  it('migrates v1 schema to v2', async () => {
-    // Create a fresh store with v1 schema
-    const tmpDir = mkdtempSync(join(tmpdir(), 'transduck-migration-'));
-    const dbPath = join(tmpDir, 'migrate.duckdb');
-
-    // Manually create v1 schema (no plural_category column)
-    const { DuckDBInstance } = await import('@duckdb/node-api');
-    const instance = await DuckDBInstance.create(dbPath);
-    const conn = await instance.connect();
-    await conn.run(`
-      CREATE TABLE translations (
-        source_text          TEXT NOT NULL,
-        source_lang          TEXT NOT NULL,
-        target_lang          TEXT NOT NULL,
-        project_context_hash TEXT NOT NULL,
-        string_context_hash  TEXT NOT NULL,
-        translated_text      TEXT NOT NULL,
-        model                TEXT NOT NULL,
-        status               TEXT NOT NULL DEFAULT 'translated',
-        created_at           TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY(source_text, source_lang, target_lang, project_context_hash, string_context_hash)
-      )
-    `);
-    // Insert a v1 row
-    await conn.run(`
-      INSERT INTO translations (source_text, source_lang, target_lang, project_context_hash, string_context_hash, translated_text, model, status)
-      VALUES ('Hello', 'EN', 'DE', '${hash('ctx')}', '${hash('')}', 'Hallo', 'gpt-4.1-mini', 'translated')
-    `);
-
-    // Close the raw connection
-    // (DuckDB node-api handles cleanup via GC, just null out)
+  // --- Count and clear ---
 
-    // Now open with TranslationStore — should migrate
-    const migratedStore = new TranslationStore(dbPath);
-    await migratedStore.initialize();
-
-    // Old data should still be accessible
-    const result = await migratedStore.lookup({
+  it('counts and clears entries', async () => {
+    await store.insert({
       sourceText: 'Hello', sourceLang: 'EN', targetLang: 'DE',
       projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'Hallo', model: 'gpt-4.1-mini', status: 'translated',
     });
-    expect(result).toBe('Hallo');
-
-    // Plural methods should work
-    await migratedStore.insertPlural({
-      sourceText: 'test\x00tests',
-      sourceLang: 'EN', targetLang: 'DE',
+    await store.insert({
+      sourceText: 'Bad', sourceLang: 'EN', targetLang: 'DE',
       projectContextHash: hash('ctx'), stringContextHash: hash(''),
-      pluralCategory: 'other',
-      translatedText: 'Tests',
-      model: 'gpt-4.1-mini', status: 'translated',
+      translatedText: 'schlecht', model: 'gpt-4.1-mini', status: 'failed',
     });
-
-    const pluralResult = await migratedStore.lookupPlural({
-      sourceText: 'test\x00tests',
-      sourceLang: 'EN', targetLang: 'DE',
+    await store.insert({
+      sourceText: 'Hello', sourceLang: 'EN', targetLang: 'ES',
       projectContextHash: hash('ctx'), stringContextHash: hash(''),
+      translatedText: 'Hola', model: 'gpt-4.1-mini', status: 'translated',
     });
-    expect(pluralResult).toEqual({ other: 'Tests' });
 
-    migratedStore.close();
+    expect(store.count()).toBe(3);
+    expect(store.count('DE')).toBe(2);
+    expect(store.count(undefined, true)).toBe(1);
+    expect(store.count('DE', true)).toBe(1);
+
+    const deleted = await store.clear('DE', true);
+    expect(deleted).toBe(1);
+    expect(store.count()).toBe(2);
   });
 });