@tursodatabase/sync 0.1.5 → 0.2.0-pre.1

package/README.md

@@ -1,9 +1,9 @@
 <p align="center">
-  <h1 align="center">Turso Sync for JavaScript</h1>
+  <h1 align="center">Turso Database for JavaScript in Node</h1>
 </p>
 
 <p align="center">
-  <a title="JavaScript" target="_blank" href="https://www.npmjs.com/package/@tursodatabase/sync"><img alt="npm" src="https://img.shields.io/npm/v/@tursodatabase/sync"></a>
+  <a title="JavaScript" target="_blank" href="https://www.npmjs.com/package/@tursodatabase/database"><img alt="npm" src="https://img.shields.io/npm/v/@tursodatabase/database"></a>
   <a title="MIT" target="_blank" href="https://github.com/tursodatabase/turso/blob/main/LICENSE.md"><img src="http://img.shields.io/badge/license-MIT-orange.svg?style=flat-square"></a>
 </p>
 <p align="center">
@@ -14,40 +14,105 @@
 
 ## About
 
-This package is for syncing local Turso databases to the Turso Cloud and back.
+This package is the Turso embedded database library for JavaScript in Node.
 
 > **⚠️ Warning:** This software is ALPHA, only use for development, testing, and experimentation. We are working to make it production ready, but do not use it for critical data right now.
 
+## Features
+
+- **SQLite compatible:** SQLite query language and file format support ([status](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)).
+- **In-process**: No network overhead, runs directly in your Node.js process
+- **TypeScript support**: Full TypeScript definitions included
+- **Cross-platform**: Supports Linux (x86 and arm64), macOS, Windows (browser is supported in the separate package `@tursodatabase/database-browser` package)
+
 ## Installation
 
 ```bash
-npm install @tursodatabase/sync
+npm install @tursodatabase/database
 ```
 
 ## Getting Started
 
-To sync a database hosted at [Turso Cloud](https://turso.tech):
+### In-Memory Database
+
+```javascript
+import { connect } from '@tursodatabase/database';
+
+// Create an in-memory database
+const db = await connect(':memory:');
+
+// Create a table
+await db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');
+
+// Insert data
+const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+await insert.run('Alice', 'alice@example.com');
+await insert.run('Bob', 'bob@example.com');
+
+// Query data
+const users = await db.prepare('SELECT * FROM users').all();
+console.log(users);
+// Output: [
+//   { id: 1, name: 'Alice', email: 'alice@example.com' },
+//   { id: 2, name: 'Bob', email: 'bob@example.com' }
+// ]
+```
+
+### File-Based Database
+
+```javascript
+import { connect } from '@tursodatabase/database';
 
-```js
-import { connect } from '@tursodatabase/sync';
+// Create or open a database file
+const db = await connect('my-database.db');
 
-const db = await connect({
-    path: 'local.db',                // path used as a prefix for local files created by sync-engine
-    url: 'https://<db>.turso.io',    // URL of the remote database: turso db show <db>
-    authToken: '...',                // auth token issued from the Turso Cloud: turso db tokens create <db>
-    clientName: 'turso-sync-example' // arbitrary client name
+// Create a table
+await db.exec(`
+  CREATE TABLE IF NOT EXISTS posts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    content TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+`);
+
+// Insert a post
+const insertPost = db.prepare('INSERT INTO posts (title, content) VALUES (?, ?)');
+const result = await insertPost.run('Hello World', 'This is my first blog post!');
+
+console.log(`Inserted post with ID: ${result.lastInsertRowid}`);
+```
+
+### Transactions
+
+```javascript
+import { connect } from '@tursodatabase/database';
+
+const db = await connect('transactions.db');
+
+// Using transactions for atomic operations
+const transaction = db.transaction(async (users) => {
+  const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+  for (const user of users) {
+    await insert.run(user.name, user.email);
+  }
 });
 
-// db has same functions as Database class from @tursodatabase/database package but adds few more methods for sync:
-await db.pull(); // pull changes from the remote
-await db.push(); // push changes to the remote
-await db.sync(); // pull & push changes
+// Execute transaction
+await transaction([
+  { name: 'Alice', email: 'alice@example.com' },
+  { name: 'Bob', email: 'bob@example.com' }
+]);
 ```
 
+## API Reference
+
+For complete API documentation, see [JavaScript API Reference](../../../../docs/javascript-api-reference.md).
+
 ## Related Packages
 
-* The [@tursodatabase/database](https://www.npmjs.com/package/@tursodatabase/database) package provides the Turso in-memory database, compatible with SQLite.
 * The [@tursodatabase/serverless](https://www.npmjs.com/package/@tursodatabase/serverless) package provides a serverless driver with the same API.
+* The [@tursodatabase/sync](https://www.npmjs.com/package/@tursodatabase/sync) package provides bidirectional sync between a local Turso database and Turso Cloud. 
 
 ## License
 
@@ -57,4 +122,4 @@ This project is licensed under the [MIT license](../../LICENSE.md).
 
 - [GitHub Issues](https://github.com/tursodatabase/turso/issues)
 - [Documentation](https://docs.turso.tech)
-- [Discord Community](https://tur.so/discord)
+- [Discord Community](https://tur.so/discord)

package/dist/promise.d.ts

@@ -0,0 +1,30 @@
+import { DatabasePromise, DatabaseOpts, NativeDatabase } from "@tursodatabase/database-common";
+import { ProtocolIo, SyncOpts, RunOpts, DatabaseRowMutation, DatabaseRowStatement, DatabaseRowTransformResult } from "@tursodatabase/sync-common";
+declare class Database extends DatabasePromise {
+    runOpts: RunOpts;
+    engine: any;
+    io: ProtocolIo;
+    constructor(db: NativeDatabase, io: ProtocolIo, runOpts: RunOpts, engine: any, opts?: DatabaseOpts);
+    sync(): Promise<void>;
+    pull(): Promise<void>;
+    push(): Promise<void>;
+    checkpoint(): Promise<void>;
+    stats(): Promise<{
+        operations: number;
+        mainWal: number;
+        revertWal: number;
+        lastPullUnixTime: number;
+        lastPushUnixTime: number | null;
+    }>;
+    close(): Promise<void>;
+}
+/**
+ * Creates a new database connection asynchronously.
+ *
+ * @param {string} path - Path to the database file.
+ * @param {Object} opts - Options for database behavior.
+ * @returns {Promise<Database>} - A promise that resolves to a Database instance.
+ */
+declare function connect(opts: SyncOpts): Promise<Database>;
+export { connect, Database, DatabaseRowMutation, DatabaseRowStatement, DatabaseRowTransformResult };
+//# sourceMappingURL=promise.d.ts.map

package/dist/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../promise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAC9F,OAAO,EAAE,UAAU,EAAO,QAAQ,EAAE,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAwCvJ,cAAM,QAAS,SAAQ,eAAe;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,GAAG,CAAC;IACZ,EAAE,EAAE,UAAU,CAAC;gBACH,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAE,YAAiB;IAMhG,IAAI;IAGJ,IAAI;IAGJ,IAAI;IAGJ,UAAU;IAGV,KAAK,IAAI,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IAG9H,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAGxC;AAED;;;;;;GAMG;AACH,iBAAe,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuBxD;AAED,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,CAAA"}

package/dist/promise.js

@@ -0,0 +1,102 @@
+import { DatabasePromise } from "@tursodatabase/database-common";
+import { run } from "@tursodatabase/sync-common";
+import { SyncEngine } from "#index";
+import { promises } from "node:fs";
+let NodeIO = {
+    async read(path) {
+        try {
+            return await promises.readFile(path);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    },
+    async write(path, data) {
+        const unix = Math.floor(Date.now() / 1000);
+        const nonce = Math.floor(Math.random() * 1000000000);
+        const tmp = `${path}.tmp.${unix}.${nonce}`;
+        await promises.writeFile(tmp, new Uint8Array(data));
+        try {
+            await promises.rename(tmp, path);
+        }
+        catch (err) {
+            await promises.unlink(tmp);
+            throw err;
+        }
+    }
+};
+function memoryIO() {
+    let values = new Map();
+    return {
+        async read(path) {
+            return values.get(path);
+        },
+        async write(path, data) {
+            values.set(path, data);
+        }
+    };
+}
+;
+class Database extends DatabasePromise {
+    runOpts;
+    engine;
+    io;
+    constructor(db, io, runOpts, engine, opts = {}) {
+        super(db, opts);
+        this.runOpts = runOpts;
+        this.engine = engine;
+        this.io = io;
+    }
+    async sync() {
+        await run(this.runOpts, this.io, this.engine, this.engine.sync());
+    }
+    async pull() {
+        await run(this.runOpts, this.io, this.engine, this.engine.pull());
+    }
+    async push() {
+        await run(this.runOpts, this.io, this.engine, this.engine.push());
+    }
+    async checkpoint() {
+        await run(this.runOpts, this.io, this.engine, this.engine.checkpoint());
+    }
+    async stats() {
+        return (await run(this.runOpts, this.io, this.engine, this.engine.stats()));
+    }
+    async close() {
+        this.engine.close();
+    }
+}
+/**
+ * Creates a new database connection asynchronously.
+ *
+ * @param {string} path - Path to the database file.
+ * @param {Object} opts - Options for database behavior.
+ * @returns {Promise<Database>} - A promise that resolves to a Database instance.
+ */
+async function connect(opts) {
+    const engine = new SyncEngine({
+        path: opts.path,
+        clientName: opts.clientName,
+        tablesIgnore: opts.tablesIgnore,
+        useTransform: opts.transform != null,
+        tracing: opts.tracing,
+        protocolVersion: 1
+    });
+    const runOpts = {
+        url: opts.url,
+        headers: {
+            ...(opts.authToken != null && { "Authorization": `Bearer ${opts.authToken}` }),
+            ...(opts.encryptionKey != null && { "x-turso-encryption-key": opts.encryptionKey })
+        },
+        preemptionMs: 1,
+        transform: opts.transform,
+    };
+    let io = opts.path == ':memory:' ? memoryIO() : NodeIO;
+    await run(runOpts, io, engine, engine.init());
+    const nativeDb = engine.open();
+    return new Database(nativeDb, io, runOpts, engine, {});
+}
+export { connect, Database };

package/dist/promise.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=promise.test.d.ts.map

package/dist/promise.test.d.ts.map

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

package/dist/promise.test.js

@@ -0,0 +1,259 @@
+import { unlinkSync } from "node:fs";
+import { expect, test } from 'vitest';
+import { connect } from './promise.js';
+const localeCompare = (a, b) => a.x.localeCompare(b.x);
+test('select-after-push', async () => {
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("CREATE TABLE IF NOT EXISTS t(x)");
+        await db.exec("DELETE FROM t");
+        await db.push();
+        await db.close();
+    }
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("INSERT INTO t VALUES (1), (2), (3)");
+        await db.push();
+    }
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        const rows = await db.prepare('SELECT * FROM t').all();
+        expect(rows).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }]);
+    }
+});
+test('select-without-push', async () => {
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("CREATE TABLE IF NOT EXISTS t(x)");
+        await db.exec("DELETE FROM t");
+        await db.push();
+        await db.close();
+    }
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("INSERT INTO t VALUES (1), (2), (3)");
+    }
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        const rows = await db.prepare('SELECT * FROM t').all();
+        expect(rows).toEqual([]);
+    }
+});
+test('merge-non-overlapping-keys', async () => {
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("CREATE TABLE IF NOT EXISTS q(x TEXT PRIMARY KEY, y)");
+        await db.exec("DELETE FROM q");
+        await db.push();
+        await db.close();
+    }
+    const db1 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    await db1.exec("INSERT INTO q VALUES ('k1', 'value1'), ('k2', 'value2')");
+    const db2 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    await db2.exec("INSERT INTO q VALUES ('k3', 'value3'), ('k4', 'value4'), ('k5', 'value5')");
+    await Promise.all([db1.push(), db2.push()]);
+    await Promise.all([db1.pull(), db2.pull()]);
+    const rows1 = await db1.prepare('SELECT * FROM q').all();
+    const rows2 = await db1.prepare('SELECT * FROM q').all();
+    const expected = [{ x: 'k1', y: 'value1' }, { x: 'k2', y: 'value2' }, { x: 'k3', y: 'value3' }, { x: 'k4', y: 'value4' }, { x: 'k5', y: 'value5' }];
+    expect(rows1.sort(localeCompare)).toEqual(expected.sort(localeCompare));
+    expect(rows2.sort(localeCompare)).toEqual(expected.sort(localeCompare));
+});
+test('last-push-wins', async () => {
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("CREATE TABLE IF NOT EXISTS q(x TEXT PRIMARY KEY, y)");
+        await db.exec("DELETE FROM q");
+        await db.push();
+        await db.close();
+    }
+    const db1 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    await db1.exec("INSERT INTO q VALUES ('k1', 'value1'), ('k2', 'value2'), ('k4', 'value4')");
+    const db2 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    await db2.exec("INSERT INTO q VALUES ('k1', 'value3'), ('k2', 'value4'), ('k3', 'value5')");
+    await db2.push();
+    await db1.push();
+    await Promise.all([db1.pull(), db2.pull()]);
+    const rows1 = await db1.prepare('SELECT * FROM q').all();
+    const rows2 = await db1.prepare('SELECT * FROM q').all();
+    const expected = [{ x: 'k1', y: 'value1' }, { x: 'k2', y: 'value2' }, { x: 'k3', y: 'value5' }, { x: 'k4', y: 'value4' }];
+    expect(rows1.sort(localeCompare)).toEqual(expected.sort(localeCompare));
+    expect(rows2.sort(localeCompare)).toEqual(expected.sort(localeCompare));
+});
+test('last-push-wins-with-delete', async () => {
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("CREATE TABLE IF NOT EXISTS q(x TEXT PRIMARY KEY, y)");
+        await db.exec("DELETE FROM q");
+        await db.push();
+        await db.close();
+    }
+    const db1 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    await db1.exec("INSERT INTO q VALUES ('k1', 'value1'), ('k2', 'value2'), ('k4', 'value4')");
+    await db1.exec("DELETE FROM q");
+    const db2 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    await db2.exec("INSERT INTO q VALUES ('k1', 'value3'), ('k2', 'value4'), ('k3', 'value5')");
+    await db2.push();
+    await db1.push();
+    await Promise.all([db1.pull(), db2.pull()]);
+    const rows1 = await db1.prepare('SELECT * FROM q').all();
+    const rows2 = await db1.prepare('SELECT * FROM q').all();
+    const expected = [{ x: 'k3', y: 'value5' }];
+    expect(rows1).toEqual(expected);
+    expect(rows2).toEqual(expected);
+});
+test('constraint-conflict', async () => {
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("CREATE TABLE IF NOT EXISTS u(x TEXT PRIMARY KEY, y UNIQUE)");
+        await db.exec("DELETE FROM u");
+        await db.push();
+        await db.close();
+    }
+    const db1 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    await db1.exec("INSERT INTO u VALUES ('k1', 'value1')");
+    const db2 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    await db2.exec("INSERT INTO u VALUES ('k2', 'value1')");
+    await db1.push();
+    await expect(async () => await db2.push()).rejects.toThrow('SQLite error: UNIQUE constraint failed: u.y');
+});
+test('checkpoint', async () => {
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("CREATE TABLE IF NOT EXISTS q(x TEXT PRIMARY KEY, y)");
+        await db.exec("DELETE FROM q");
+        await db.push();
+        await db.close();
+    }
+    const db1 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+    for (let i = 0; i < 1000; i++) {
+        await db1.exec(`INSERT INTO q VALUES ('k${i}', 'v${i}')`);
+    }
+    expect((await db1.stats()).mainWal).toBeGreaterThan(4096 * 1000);
+    await db1.checkpoint();
+    expect((await db1.stats()).mainWal).toBe(0);
+    let revertWal = (await db1.stats()).revertWal;
+    expect(revertWal).toBeLessThan(4096 * 1000 / 100);
+    for (let i = 0; i < 1000; i++) {
+        await db1.exec(`UPDATE q SET y = 'u${i}' WHERE x = 'k${i}'`);
+    }
+    await db1.checkpoint();
+    expect((await db1.stats()).revertWal).toBe(revertWal);
+});
+test('persistence', async () => {
+    {
+        const db = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL });
+        await db.exec("CREATE TABLE IF NOT EXISTS q(x TEXT PRIMARY KEY, y)");
+        await db.exec("DELETE FROM q");
+        await db.push();
+        await db.close();
+    }
+    const path = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        {
+            const db1 = await connect({ path: path, url: process.env.VITE_TURSO_DB_URL });
+            await db1.exec(`INSERT INTO q VALUES ('k1', 'v1')`);
+            await db1.exec(`INSERT INTO q VALUES ('k2', 'v2')`);
+            await db1.close();
+        }
+        {
+            const db2 = await connect({ path: path, url: process.env.VITE_TURSO_DB_URL });
+            await db2.exec(`INSERT INTO q VALUES ('k3', 'v3')`);
+            await db2.exec(`INSERT INTO q VALUES ('k4', 'v4')`);
+            const rows = await db2.prepare('SELECT * FROM q').all();
+            const expected = [{ x: 'k1', y: 'v1' }, { x: 'k2', y: 'v2' }, { x: 'k3', y: 'v3' }, { x: 'k4', y: 'v4' }];
+            expect(rows).toEqual(expected);
+            await db2.close();
+        }
+        {
+            const db3 = await connect({ path: path, url: process.env.VITE_TURSO_DB_URL });
+            await db3.push();
+            await db3.close();
+        }
+        {
+            const db4 = await connect({ path: path, url: process.env.VITE_TURSO_DB_URL });
+            const rows = await db4.prepare('SELECT * FROM q').all();
+            const expected = [{ x: 'k1', y: 'v1' }, { x: 'k2', y: 'v2' }, { x: 'k3', y: 'v3' }, { x: 'k4', y: 'v4' }];
+            expect(rows).toEqual(expected);
+            await db4.close();
+        }
+    }
+    finally {
+        unlinkSync(path);
+        unlinkSync(`${path}-wal`);
+        unlinkSync(`${path}-info`);
+        unlinkSync(`${path}-changes`);
+        try {
+            unlinkSync(`${path}-revert`);
+        }
+        catch (e) { }
+    }
+});
+test('transform', async () => {
+    {
+        const db = await connect({
+            path: ':memory:',
+            url: process.env.VITE_TURSO_DB_URL,
+        });
+        await db.exec("CREATE TABLE IF NOT EXISTS counter(key TEXT PRIMARY KEY, value INTEGER)");
+        await db.exec("DELETE FROM counter");
+        await db.exec("INSERT INTO counter VALUES ('1', 0)");
+        await db.push();
+        await db.close();
+    }
+    const transform = (m) => ({
+        operation: 'rewrite',
+        stmt: {
+            sql: `UPDATE counter SET value = value + ? WHERE key = ?`,
+            values: [m.after.value - m.before.value, m.after.key]
+        }
+    });
+    const db1 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL, transform: transform });
+    const db2 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL, transform: transform });
+    await db1.exec("UPDATE counter SET value = value + 1 WHERE key = '1'");
+    await db2.exec("UPDATE counter SET value = value + 1 WHERE key = '1'");
+    await Promise.all([db1.push(), db2.push()]);
+    await Promise.all([db1.pull(), db2.pull()]);
+    const rows1 = await db1.prepare('SELECT * FROM counter').all();
+    const rows2 = await db2.prepare('SELECT * FROM counter').all();
+    expect(rows1).toEqual([{ key: '1', value: 2 }]);
+    expect(rows2).toEqual([{ key: '1', value: 2 }]);
+});
+test('transform-many', async () => {
+    {
+        const db = await connect({
+            path: ':memory:',
+            url: process.env.VITE_TURSO_DB_URL,
+        });
+        await db.exec("CREATE TABLE IF NOT EXISTS counter(key TEXT PRIMARY KEY, value INTEGER)");
+        await db.exec("DELETE FROM counter");
+        await db.exec("INSERT INTO counter VALUES ('1', 0)");
+        await db.push();
+        await db.close();
+    }
+    const transform = (m) => ({
+        operation: 'rewrite',
+        stmt: {
+            sql: `UPDATE counter SET value = value + ? WHERE key = ?`,
+            values: [m.after.value - m.before.value, m.after.key]
+        }
+    });
+    const db1 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL, transform: transform });
+    const db2 = await connect({ path: ':memory:', url: process.env.VITE_TURSO_DB_URL, transform: transform });
+    for (let i = 0; i < 1002; i++) {
+        await db1.exec("UPDATE counter SET value = value + 1 WHERE key = '1'");
+    }
+    for (let i = 0; i < 1001; i++) {
+        await db2.exec("UPDATE counter SET value = value + 1 WHERE key = '1'");
+    }
+    let start = performance.now();
+    await Promise.all([db1.push(), db2.push()]);
+    console.info('push', performance.now() - start);
+    start = performance.now();
+    await Promise.all([db1.pull(), db2.pull()]);
+    console.info('pull', performance.now() - start);
+    const rows1 = await db1.prepare('SELECT * FROM counter').all();
+    const rows2 = await db2.prepare('SELECT * FROM counter').all();
+    expect(rows1).toEqual([{ key: '1', value: 1001 + 1002 }]);
+    expect(rows2).toEqual([{ key: '1', value: 1001 + 1002 }]);
+});

package/index.js

@@ -74,23 +74,33 @@ function requireNative() {
   } else if (process.platform === 'android') {
     if (process.arch === 'arm64') {
       try {
-        return require('./turso-sync-js.android-arm64.node')
+        return require('./sync.android-arm64.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-android-arm64')
+        const binding = require('@tursodatabase/sync-android-arm64')
+        const bindingPackageVersion = require('@tursodatabase/sync-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
     } else if (process.arch === 'arm') {
       try {
-        return require('./turso-sync-js.android-arm-eabi.node')
+        return require('./sync.android-arm-eabi.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-android-arm-eabi')
+        const binding = require('@tursodatabase/sync-android-arm-eabi')
+        const bindingPackageVersion = require('@tursodatabase/sync-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
@@ -100,34 +110,49 @@ function requireNative() {
   } else if (process.platform === 'win32') {
     if (process.arch === 'x64') {
       try {
-        return require('./turso-sync-js.win32-x64-msvc.node')
+        return require('./sync.win32-x64-msvc.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-win32-x64-msvc')
+        const binding = require('@tursodatabase/sync-win32-x64-msvc')
+        const bindingPackageVersion = require('@tursodatabase/sync-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
     } else if (process.arch === 'ia32') {
       try {
-        return require('./turso-sync-js.win32-ia32-msvc.node')
+        return require('./sync.win32-ia32-msvc.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-win32-ia32-msvc')
+        const binding = require('@tursodatabase/sync-win32-ia32-msvc')
+        const bindingPackageVersion = require('@tursodatabase/sync-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
     } else if (process.arch === 'arm64') {
       try {
-        return require('./turso-sync-js.win32-arm64-msvc.node')
+        return require('./sync.win32-arm64-msvc.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-win32-arm64-msvc')
+        const binding = require('@tursodatabase/sync-win32-arm64-msvc')
+        const bindingPackageVersion = require('@tursodatabase/sync-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
@@ -136,34 +161,49 @@ function requireNative() {
     }
   } else if (process.platform === 'darwin') {
     try {
-      return require('./turso-sync-js.darwin-universal.node')
+      return require('./sync.darwin-universal.node')
     } catch (e) {
       loadErrors.push(e)
     }
     try {
-      return require('@tursodatabase/sync-darwin-universal')
+      const binding = require('@tursodatabase/sync-darwin-universal')
+      const bindingPackageVersion = require('@tursodatabase/sync-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
     } catch (e) {
       loadErrors.push(e)
     }
     if (process.arch === 'x64') {
       try {
-        return require('./turso-sync-js.darwin-x64.node')
+        return require('./sync.darwin-x64.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-darwin-x64')
+        const binding = require('@tursodatabase/sync-darwin-x64')
+        const bindingPackageVersion = require('@tursodatabase/sync-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
     } else if (process.arch === 'arm64') {
       try {
-        return require('./turso-sync-js.darwin-arm64.node')
+        return require('./sync.darwin-arm64.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-darwin-arm64')
+        const binding = require('@tursodatabase/sync-darwin-arm64')
+        const bindingPackageVersion = require('@tursodatabase/sync-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
@@ -173,23 +213,33 @@ function requireNative() {
   } else if (process.platform === 'freebsd') {
     if (process.arch === 'x64') {
       try {
-        return require('./turso-sync-js.freebsd-x64.node')
+        return require('./sync.freebsd-x64.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-freebsd-x64')
+        const binding = require('@tursodatabase/sync-freebsd-x64')
+        const bindingPackageVersion = require('@tursodatabase/sync-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
     } else if (process.arch === 'arm64') {
       try {
-        return require('./turso-sync-js.freebsd-arm64.node')
+        return require('./sync.freebsd-arm64.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-freebsd-arm64')
+        const binding = require('@tursodatabase/sync-freebsd-arm64')
+        const bindingPackageVersion = require('@tursodatabase/sync-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
@@ -200,23 +250,33 @@ function requireNative() {
     if (process.arch === 'x64') {
       if (isMusl()) {
         try {
-          return require('./turso-sync-js.linux-x64-musl.node')
+          return require('./sync.linux-x64-musl.node')
         } catch (e) {
           loadErrors.push(e)
         }
         try {
-          return require('@tursodatabase/sync-linux-x64-musl')
+          const binding = require('@tursodatabase/sync-linux-x64-musl')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
         } catch (e) {
           loadErrors.push(e)
         }
       } else {
         try {
-          return require('./turso-sync-js.linux-x64-gnu.node')
+          return require('./sync.linux-x64-gnu.node')
         } catch (e) {
           loadErrors.push(e)
         }
         try {
-          return require('@tursodatabase/sync-linux-x64-gnu')
+          const binding = require('@tursodatabase/sync-linux-x64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
         } catch (e) {
           loadErrors.push(e)
         }
@@ -224,23 +284,33 @@ function requireNative() {
     } else if (process.arch === 'arm64') {
       if (isMusl()) {
         try {
-          return require('./turso-sync-js.linux-arm64-musl.node')
+          return require('./sync.linux-arm64-musl.node')
         } catch (e) {
           loadErrors.push(e)
         }
         try {
-          return require('@tursodatabase/sync-linux-arm64-musl')
+          const binding = require('@tursodatabase/sync-linux-arm64-musl')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
         } catch (e) {
           loadErrors.push(e)
         }
       } else {
         try {
-          return require('./turso-sync-js.linux-arm64-gnu.node')
+          return require('./sync.linux-arm64-gnu.node')
         } catch (e) {
           loadErrors.push(e)
         }
         try {
-          return require('@tursodatabase/sync-linux-arm64-gnu')
+          const binding = require('@tursodatabase/sync-linux-arm64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
         } catch (e) {
           loadErrors.push(e)
         }
@@ -248,23 +318,33 @@ function requireNative() {
     } else if (process.arch === 'arm') {
       if (isMusl()) {
         try {
-          return require('./turso-sync-js.linux-arm-musleabihf.node')
+          return require('./sync.linux-arm-musleabihf.node')
         } catch (e) {
           loadErrors.push(e)
         }
         try {
-          return require('@tursodatabase/sync-linux-arm-musleabihf')
+          const binding = require('@tursodatabase/sync-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
         } catch (e) {
           loadErrors.push(e)
         }
       } else {
         try {
-          return require('./turso-sync-js.linux-arm-gnueabihf.node')
+          return require('./sync.linux-arm-gnueabihf.node')
         } catch (e) {
           loadErrors.push(e)
         }
         try {
-          return require('@tursodatabase/sync-linux-arm-gnueabihf')
+          const binding = require('@tursodatabase/sync-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
         } catch (e) {
           loadErrors.push(e)
         }
@@ -272,46 +352,66 @@ function requireNative() {
     } else if (process.arch === 'riscv64') {
       if (isMusl()) {
         try {
-          return require('./turso-sync-js.linux-riscv64-musl.node')
+          return require('./sync.linux-riscv64-musl.node')
         } catch (e) {
           loadErrors.push(e)
         }
         try {
-          return require('@tursodatabase/sync-linux-riscv64-musl')
+          const binding = require('@tursodatabase/sync-linux-riscv64-musl')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
         } catch (e) {
           loadErrors.push(e)
         }
       } else {
         try {
-          return require('./turso-sync-js.linux-riscv64-gnu.node')
+          return require('./sync.linux-riscv64-gnu.node')
         } catch (e) {
           loadErrors.push(e)
         }
         try {
-          return require('@tursodatabase/sync-linux-riscv64-gnu')
+          const binding = require('@tursodatabase/sync-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
         } catch (e) {
           loadErrors.push(e)
         }
       }
     } else if (process.arch === 'ppc64') {
       try {
-        return require('./turso-sync-js.linux-ppc64-gnu.node')
+        return require('./sync.linux-ppc64-gnu.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-linux-ppc64-gnu')
+        const binding = require('@tursodatabase/sync-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@tursodatabase/sync-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
     } else if (process.arch === 's390x') {
       try {
-        return require('./turso-sync-js.linux-s390x-gnu.node')
+        return require('./sync.linux-s390x-gnu.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-linux-s390x-gnu')
+        const binding = require('@tursodatabase/sync-linux-s390x-gnu')
+        const bindingPackageVersion = require('@tursodatabase/sync-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
@@ -321,34 +421,49 @@ function requireNative() {
   } else if (process.platform === 'openharmony') {
     if (process.arch === 'arm64') {
       try {
-        return require('./turso-sync-js.linux-arm64-ohos.node')
+        return require('./sync.openharmony-arm64.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-linux-arm64-ohos')
+        const binding = require('@tursodatabase/sync-openharmony-arm64')
+        const bindingPackageVersion = require('@tursodatabase/sync-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
     } else if (process.arch === 'x64') {
       try {
-        return require('./turso-sync-js.linux-x64-ohos.node')
+        return require('./sync.openharmony-x64.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-linux-x64-ohos')
+        const binding = require('@tursodatabase/sync-openharmony-x64')
+        const bindingPackageVersion = require('@tursodatabase/sync-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
     } else if (process.arch === 'arm') {
       try {
-        return require('./turso-sync-js.linux-arm-ohos.node')
+        return require('./sync.openharmony-arm.node')
       } catch (e) {
         loadErrors.push(e)
       }
       try {
-        return require('@tursodatabase/sync-linux-arm-ohos')
+        const binding = require('@tursodatabase/sync-openharmony-arm')
+        const bindingPackageVersion = require('@tursodatabase/sync-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.1.5' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
       } catch (e) {
         loadErrors.push(e)
       }
@@ -364,7 +479,7 @@ nativeBinding = requireNative()
 
 if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
   try {
-    nativeBinding = require('./turso-sync-js.wasi.cjs')
+    nativeBinding = require('./sync.wasi.cjs')
   } catch (err) {
     if (process.env.NAPI_RS_FORCE_WASI) {
       loadErrors.push(err)
@@ -393,14 +508,13 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { Database, Statement, GeneratorHolder, JsDataCompletion, JsDataPollResult, JsProtocolIo, JsProtocolRequestData, SyncEngine, DatabaseChangeTypeJs, SyncEngineProtocolVersion } = nativeBinding
+const { Database, Statement, GeneratorHolder, JsDataCompletion, JsProtocolIo, JsProtocolRequestBytes, SyncEngine, DatabaseChangeTypeJs, SyncEngineProtocolVersion } = nativeBinding
 export { Database }
 export { Statement }
 export { GeneratorHolder }
 export { JsDataCompletion }
-export { JsDataPollResult }
 export { JsProtocolIo }
-export { JsProtocolRequestData }
+export { JsProtocolRequestBytes }
 export { SyncEngine }
 export { DatabaseChangeTypeJs }
 export { SyncEngineProtocolVersion }

package/package.json

@@ -1,70 +1,59 @@
 {
   "name": "@tursodatabase/sync",
-  "version": "0.1.5",
+  "version": "0.2.0-pre.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/tursodatabase/turso"
   },
-  "description": "Sync engine for the Turso database library",
-  "module": "./dist/sync_engine.js",
-  "main": "./dist/sync_engine.js",
+  "license": "MIT",
+  "module": "./dist/promise.js",
+  "main": "./dist/promise.js",
   "type": "module",
-  "exports": "./dist/sync_engine.js",
+  "exports": {
+    ".": "./dist/promise.js",
+    "./compat": "./dist/compat.js"
+  },
   "files": [
-    "browser.js",
     "index.js",
-    "dist/**"
+    "dist/**",
+    "README.md"
   ],
-  "types": "./dist/sync_engine.d.ts",
+  "packageManager": "yarn@4.9.2",
+  "devDependencies": {
+    "@napi-rs/cli": "^3.1.5",
+    "@types/node": "^24.3.1",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "napi-build": "napi build --platform --release --esm --manifest-path ../../Cargo.toml --output-dir .",
+    "napi-dirs": "napi create-npm-dirs",
+    "napi-artifacts": "napi artifacts --output-dir .",
+    "tsc-build": "npm exec tsc",
+    "build": "npm run napi-build && npm run tsc-build",
+    "test": "VITE_TURSO_DB_URL=http://b--a--a.localhost:10000 vitest --run",
+    "prepublishOnly": "npm run napi-dirs && npm run napi-artifacts && napi prepublish -t npm"
+  },
   "napi": {
-    "binaryName": "turso-sync-js",
+    "binaryName": "sync",
     "targets": [
       "x86_64-unknown-linux-gnu",
       "x86_64-pc-windows-msvc",
       "universal-apple-darwin",
-      "aarch64-unknown-linux-gnu",
-      "wasm32-wasip1-threads"
+      "aarch64-unknown-linux-gnu"
     ]
   },
-  "license": "MIT",
-  "devDependencies": {
-    "@napi-rs/cli": "^3.0.4",
-    "@napi-rs/wasm-runtime": "^1.0.1",
-    "@types/node": "^24.2.0",
-    "ava": "^6.0.1",
-    "typescript": "^5.9.2"
-  },
-  "ava": {
-    "timeout": "3m"
-  },
-  "engines": {
-    "node": ">= 10"
-  },
-  "scripts": {
-    "artifacts": "napi artifacts",
-    "build": "npm exec tsc && napi build --platform --release --esm",
-    "build:debug": "npm exec tsc && napi build --platform",
-    "prepublishOnly": "npm exec tsc && napi prepublish -t npm",
-    "test": "true",
-    "universal": "napi universalize",
-    "version": "napi version"
+  "dependencies": {
+    "@tursodatabase/database-common": "^0.2.0-pre.1",
+    "@tursodatabase/sync-common": "^0.2.0-pre.1"
   },
-  "packageManager": "yarn@4.9.2",
   "imports": {
-    "#entry-point": {
-      "types": "./index.d.ts",
-      "browser": "./browser.js",
-      "node": "./index.js"
-    }
-  },
-  "dependencies": {
-    "@tursodatabase/database": "~0.1.4-pre.5"
+    "#index": "./index.js"
   },
   "optionalDependencies": {
-    "@tursodatabase/sync-linux-x64-gnu": "0.1.5",
-    "@tursodatabase/sync-win32-x64-msvc": "0.1.5",
-    "@tursodatabase/sync-darwin-universal": "0.1.5",
-    "@tursodatabase/sync-linux-arm64-gnu": "0.1.5",
-    "@tursodatabase/sync-wasm32-wasi": "0.1.5"
+    "@tursodatabase/sync-linux-x64-gnu": "0.2.0-pre.1",
+    "@tursodatabase/sync-win32-x64-msvc": "0.2.0-pre.1",
+    "@tursodatabase/sync-darwin-universal": "0.2.0-pre.1",
+    "@tursodatabase/sync-linux-arm64-gnu": "0.2.0-pre.1"
   }
 }

package/browser.js

@@ -1 +0,0 @@
-export * from '@tursodatabase/sync-wasm32-wasi'

package/dist/sync_engine.d.ts

@@ -1,24 +0,0 @@
-import { DatabaseRowMutationJs, DatabaseRowStatementJs } from '#entry-point';
-import { Database } from '@tursodatabase/database';
-interface ConnectOpts {
-    path: string;
-    clientName?: string;
-    url: string;
-    authToken?: string;
-    encryptionKey?: string;
-    tablesIgnore?: string[];
-    transform?: (arg: DatabaseRowMutationJs) => DatabaseRowStatementJs | null;
-    enableTracing?: string;
-}
-interface Sync {
-    sync(): Promise<void>;
-    push(): Promise<void>;
-    pull(): Promise<void>;
-    checkpoint(): Promise<void>;
-    stats(): Promise<{
-        operations: number;
-        wal: number;
-    }>;
-}
-export declare function connect(opts: ConnectOpts): Database & Sync;
-export { Database, Sync };

package/dist/sync_engine.js

@@ -1,152 +0,0 @@
-"use strict";
-import { SyncEngine } from '#entry-point';
-import { Database } from '@tursodatabase/database';
-const GENERATOR_RESUME_IO = 0;
-const GENERATOR_RESUME_DONE = 1;
-function trackPromise(p) {
-    let status = { promise: null, finished: false };
-    status.promise = p.finally(() => status.finished = true);
-    return status;
-}
-function timeoutMs(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-async function read(opts, path) {
-    if (opts.isMemory) {
-        return opts.value;
-    }
-    if (typeof window === 'undefined') {
-        const { promises } = await import('node:fs');
-        try {
-            return await promises.readFile(path);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                return null;
-            }
-            throw error;
-        }
-    }
-    else {
-        const data = localStorage.getItem(path);
-        if (data != null) {
-            return new TextEncoder().encode(data);
-        }
-        else {
-            return null;
-        }
-    }
-}
-async function write(opts, path, content) {
-    if (opts.isMemory) {
-        opts.value = content;
-        return;
-    }
-    const data = new Uint8Array(content);
-    if (typeof window === 'undefined') {
-        const { promises } = await import('node:fs');
-        const unix = Math.floor(Date.now() / 1000);
-        const nonce = Math.floor(Math.random() * 1000000000);
-        const tmp = `${path}.tmp.${unix}.${nonce}`;
-        await promises.writeFile(tmp, data);
-        await promises.rename(tmp, path);
-    }
-    else {
-        localStorage.setItem(path, new TextDecoder().decode(data));
-    }
-}
-async function process(opts, request) {
-    const requestType = request.request();
-    const completion = request.completion();
-    if (requestType.type == 'Http') {
-        try {
-            let headers = opts.headers;
-            if (requestType.headers != null && requestType.headers.length > 0) {
-                headers = { ...opts.headers };
-                for (let header of requestType.headers) {
-                    headers[header[0]] = header[1];
-                }
-            }
-            const response = await fetch(`${opts.url}${requestType.path}`, {
-                method: requestType.method,
-                headers: headers,
-                body: requestType.body != null ? new Uint8Array(requestType.body) : null,
-            });
-            completion.status(response.status);
-            const reader = response.body.getReader();
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    completion.done();
-                    break;
-                }
-                completion.push(value);
-            }
-        }
-        catch (error) {
-            completion.poison(`fetch error: ${error}`);
-        }
-    }
-    else if (requestType.type == 'FullRead') {
-        try {
-            const metadata = await read(opts.metadata, requestType.path);
-            if (metadata != null) {
-                completion.push(metadata);
-            }
-            completion.done();
-        }
-        catch (error) {
-            completion.poison(`metadata read error: ${error}`);
-        }
-    }
-    else if (requestType.type == 'FullWrite') {
-        try {
-            await write(opts.metadata, requestType.path, requestType.content);
-            completion.done();
-        }
-        catch (error) {
-            completion.poison(`metadata write error: ${error}`);
-        }
-    }
-}
-async function run(opts, engine, generator) {
-    let tasks = [];
-    while (generator.resume(null) !== GENERATOR_RESUME_DONE) {
-        for (let request = engine.protocolIo(); request != null; request = engine.protocolIo()) {
-            tasks.push(trackPromise(process(opts, request)));
-        }
-        const tasksRace = tasks.length == 0 ? Promise.resolve() : Promise.race([timeoutMs(opts.preemptionMs), ...tasks.map(t => t.promise)]);
-        await Promise.all([engine.ioLoopAsync(), tasksRace]);
-        tasks = tasks.filter(t => !t.finished);
-    }
-    return generator.take();
-}
-export async function connect(opts) {
-    const engine = new SyncEngine({
-        path: opts.path,
-        clientName: opts.clientName,
-        tablesIgnore: opts.tablesIgnore,
-        transform: opts.transform,
-        enableTracing: opts.enableTracing
-    });
-    const httpOpts = {
-        url: opts.url,
-        headers: {
-            ...(opts.authToken != null && { "Authorization": `Bearer ${opts.authToken}` }),
-            ...(opts.encryptionKey != null && { "x-turso-encryption-key": opts.encryptionKey })
-        },
-        metadata: opts.path == ':memory:' ? { isMemory: true, value: null } : { isMemory: false },
-        preemptionMs: 1,
-    };
-    await run(httpOpts, engine, engine.init());
-    const nativeDb = engine.open();
-    const db = Database.create();
-    db.initialize(nativeDb, opts.path, false);
-    db.sync = async function () { await run(httpOpts, engine, engine.sync()); };
-    db.pull = async function () { await run(httpOpts, engine, engine.pull()); };
-    db.push = async function () { await run(httpOpts, engine, engine.push()); };
-    db.checkpoint = async function () { await run(httpOpts, engine, engine.checkpoint()); };
-    db.stats = async function () { return (await run(httpOpts, engine, engine.stats())); };
-    return db;
-}
-export { Database };