@tursodatabase/sync 0.1.4-pre.10

package/README.md

@@ -0,0 +1,60 @@
+<p align="center">
+  <h1 align="center">Turso Sync for JavaScript</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="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">
+  <a title="Users Discord" target="_blank" href="https://tur.so/discord"><img alt="Chat with other users of Turso on Discord" src="https://img.shields.io/discord/933071162680958986?label=Discord&logo=Discord&style=social"></a>
+</p>
+
+---
+
+## About
+
+This package is for syncing local Turso databases to the Turso Cloud and back.
+
+> **⚠️ 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.
+
+## Installation
+
+```bash
+npm install @tursodatabase/sync
+```
+
+## Getting Started
+
+To sync a database hosted at [Turso Cloud](https://turso.tech):
+
+```js
+import { connect } from '@tursodatabase/sync';
+
+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
+});
+
+// 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
+```
+
+## 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.
+
+## License
+
+This project is licensed under the [MIT license](../../LICENSE.md).
+
+## Support
+
+- [GitHub Issues](https://github.com/tursodatabase/turso/issues)
+- [Documentation](https://docs.turso.tech)
+- [Discord Community](https://tur.so/discord)

package/browser.js

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

package/dist/sync_engine.d.ts

@@ -0,0 +1,15 @@
+import { Database } from '@tursodatabase/database';
+interface ConnectOpts {
+    path: string;
+    clientName?: string;
+    url: string;
+    authToken?: string;
+    encryptionKey?: string;
+}
+interface Sync {
+    sync(): Promise<void>;
+    push(): Promise<void>;
+    pull(): Promise<void>;
+}
+export declare function connect(opts: ConnectOpts): Database & Sync;
+export {};

package/dist/sync_engine.js

@@ -0,0 +1,135 @@
+"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 {
+            const response = await fetch(`${opts.url}${requestType.path}`, {
+                method: requestType.method,
+                headers: opts.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);
+    }
+}
+export async function connect(opts) {
+    const engine = new SyncEngine({ path: opts.path, clientName: opts.clientName });
+    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()); };
+    return db;
+}

package/index.js

@@ -0,0 +1,519 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const __dirname = new URL('.', import.meta.url).pathname
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./turso-sync-js.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-android-arm64')
+        const bindingPackageVersion = require('@tursodatabase/sync-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-android-arm-eabi')
+        const bindingPackageVersion = require('@tursodatabase/sync-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso-sync-js.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-win32-x64-msvc')
+        const bindingPackageVersion = require('@tursodatabase/sync-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-win32-ia32-msvc')
+        const bindingPackageVersion = require('@tursodatabase/sync-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-win32-arm64-msvc')
+        const bindingPackageVersion = require('@tursodatabase/sync-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./turso-sync-js.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@tursodatabase/sync-darwin-universal')
+      const bindingPackageVersion = require('@tursodatabase/sync-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.1.4-pre.5') {
+        throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-darwin-x64')
+        const bindingPackageVersion = require('@tursodatabase/sync-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-darwin-arm64')
+        const bindingPackageVersion = require('@tursodatabase/sync-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso-sync-js.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-freebsd-x64')
+        const bindingPackageVersion = require('@tursodatabase/sync-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-freebsd-arm64')
+        const bindingPackageVersion = require('@tursodatabase/sync-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./turso-sync-js.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/sync-linux-x64-musl')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.4-pre.5') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/sync-linux-x64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.4-pre.5') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./turso-sync-js.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/sync-linux-arm64-musl')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.4-pre.5') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/sync-linux-arm64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.4-pre.5') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./turso-sync-js.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/sync-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.4-pre.5') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/sync-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.4-pre.5') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./turso-sync-js.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/sync-linux-riscv64-musl')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.4-pre.5') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@tursodatabase/sync-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@tursodatabase/sync-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.4-pre.5') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@tursodatabase/sync-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-linux-s390x-gnu')
+        const bindingPackageVersion = require('@tursodatabase/sync-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./turso-sync-js.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-openharmony-arm64')
+        const bindingPackageVersion = require('@tursodatabase/sync-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-openharmony-x64')
+        const bindingPackageVersion = require('@tursodatabase/sync-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.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.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@tursodatabase/sync-openharmony-arm')
+        const bindingPackageVersion = require('@tursodatabase/sync-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.1.4-pre.5') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.4-pre.5 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require('./turso-sync-js.wasi.cjs')
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      loadErrors.push(err)
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      nativeBinding = require('@tursodatabase/sync-wasm32-wasi')
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err)
+      }
+    }
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+      { cause: loadErrors }
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { Database, Statement, GeneratorHolder, JsDataCompletion, JsDataPollResult, JsProtocolIo, JsProtocolRequestData, SyncEngine } = nativeBinding
+export { Database }
+export { Statement }
+export { GeneratorHolder }
+export { JsDataCompletion }
+export { JsDataPollResult }
+export { JsProtocolIo }
+export { JsProtocolRequestData }
+export { SyncEngine }

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@tursodatabase/sync",
+  "version": "0.1.4-pre.10",
+  "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",
+  "type": "module",
+  "exports": "./dist/sync_engine.js",
+  "files": [
+    "browser.js",
+    "index.js",
+    "dist/**"
+  ],
+  "types": "./dist/sync_engine.d.ts",
+  "napi": {
+    "binaryName": "turso-sync-js",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc",
+      "universal-apple-darwin",
+      "wasm32-wasip1-threads"
+    ]
+  },
+  "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"
+  },
+  "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"
+  },
+  "optionalDependencies": {
+    "@tursodatabase/sync-linux-x64-gnu": "0.1.4-pre.10",
+    "@tursodatabase/sync-win32-x64-msvc": "0.1.4-pre.10",
+    "@tursodatabase/sync-darwin-universal": "0.1.4-pre.10",
+    "@tursodatabase/sync-wasm32-wasi": "0.1.4-pre.10"
+  }
+}