@rigxyz/tapd 0.4.1 → 0.5.0

package/dist/{chunk-JBX2ZRMD.js → chunk-XMYPUAYD.js}

@@ -293,9 +293,8 @@ function joinUrl(base, suffix) {
 }
 
 // src/state-db.ts
-import { mkdirSync as mkdirSync2 } from "fs";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync } from "fs";
 import { dirname as dirname2 } from "path";
-import Database from "better-sqlite3";
 var CURSOR_PREFIX = "chg_";
 function cursorGreaterThan(a, b) {
   const an = a.startsWith(CURSOR_PREFIX) ? safeBigInt(a.slice(CURSOR_PREFIX.length)) : null;
@@ -311,93 +310,109 @@ function safeBigInt(s) {
     return null;
   }
 }
-var SCHEMA = `
-  CREATE TABLE IF NOT EXISTS paths (
-    path TEXT PRIMARY KEY,
-    last_applied_change_id TEXT,
-    last_seen_hash TEXT,
-    local_dirty INTEGER NOT NULL DEFAULT 0,
-    last_scan_at TEXT
-  );
-
-  CREATE TABLE IF NOT EXISTS meta (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-  );
-`;
+var pendingFlushers = /* @__PURE__ */ new Set();
+var exitHookInstalled = false;
+function installExitHook() {
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  process.once("exit", () => {
+    for (const flush of pendingFlushers) {
+      try {
+        flush();
+      } catch {
+      }
+    }
+  });
+}
+function loadStore(dbPath) {
+  try {
+    const parsed = JSON.parse(readFileSync2(dbPath, "utf8"));
+    if (parsed && parsed.version === 1 && parsed.meta && parsed.paths) {
+      return { version: 1, meta: parsed.meta, paths: parsed.paths };
+    }
+  } catch {
+  }
+  return { version: 1, meta: {}, paths: {} };
+}
 function openStateDb(dbPath) {
   mkdirSync2(dirname2(dbPath), { recursive: true });
-  const db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
-  db.exec(SCHEMA);
-  const stmtUpsert = db.prepare(`
-    INSERT INTO paths (path, last_applied_change_id, last_seen_hash, local_dirty, last_scan_at)
-    VALUES (@path, @last_applied_change_id, @last_seen_hash, @local_dirty, @last_scan_at)
-    ON CONFLICT(path) DO UPDATE SET
-      last_applied_change_id = excluded.last_applied_change_id,
-      last_seen_hash         = excluded.last_seen_hash,
-      local_dirty            = excluded.local_dirty,
-      last_scan_at           = excluded.last_scan_at
-  `);
-  const stmtGet = db.prepare(`SELECT * FROM paths WHERE path = ?`);
-  const stmtDelete = db.prepare(`DELETE FROM paths WHERE path = ?`);
-  const stmtListPaths = db.prepare(`SELECT path FROM paths`);
-  const stmtSetMeta = db.prepare(`
-    INSERT INTO meta (key, value) VALUES (?, ?)
-    ON CONFLICT(key) DO UPDATE SET value = excluded.value
-  `);
-  const stmtGetMeta = db.prepare(`SELECT value FROM meta WHERE key = ?`);
+  const store = loadStore(dbPath);
+  let dirty = false;
+  let timer = null;
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (!dirty) return;
+    const tmp = `${dbPath}.tmp`;
+    writeFileSync2(tmp, JSON.stringify(store), "utf8");
+    renameSync(tmp, dbPath);
+    dirty = false;
+  };
+  const schedule = () => {
+    dirty = true;
+    if (timer) return;
+    timer = setTimeout(flush, 100);
+    timer.unref?.();
+  };
+  pendingFlushers.add(flush);
+  installExitHook();
   return {
     getCursor() {
-      const row = stmtGetMeta.get("cursor");
-      return row?.value ?? "chg_0";
+      return store.meta.cursor ?? "chg_0";
     },
     setCursor(cursor) {
-      const current = stmtGetMeta.get("cursor")?.value;
+      const current = store.meta.cursor;
       if (current && !cursorGreaterThan(cursor, current)) return;
-      stmtSetMeta.run("cursor", cursor);
+      store.meta.cursor = cursor;
+      schedule();
     },
     upsertPath(state) {
-      stmtUpsert.run({
-        path: state.path,
-        last_applied_change_id: state.lastAppliedChangeId,
-        last_seen_hash: state.lastSeenHash,
-        local_dirty: state.localDirty ? 1 : 0,
-        last_scan_at: state.lastScanAt
-      });
+      store.paths[state.path] = {
+        lastAppliedChangeId: state.lastAppliedChangeId,
+        lastSeenHash: state.lastSeenHash,
+        localDirty: state.localDirty,
+        lastScanAt: state.lastScanAt
+      };
+      schedule();
     },
     getPath(path) {
-      const row = stmtGet.get(path);
-      if (!row) return null;
+      const r = store.paths[path];
+      if (!r) return null;
       return {
-        path: row.path,
-        lastAppliedChangeId: row.last_applied_change_id,
-        lastSeenHash: row.last_seen_hash,
-        localDirty: row.local_dirty !== 0,
-        lastScanAt: row.last_scan_at
+        path,
+        lastAppliedChangeId: r.lastAppliedChangeId,
+        lastSeenHash: r.lastSeenHash,
+        localDirty: r.localDirty,
+        lastScanAt: r.lastScanAt
       };
     },
     deletePath(path) {
-      stmtDelete.run(path);
+      if (path in store.paths) {
+        delete store.paths[path];
+        schedule();
+      }
     },
     listPaths() {
-      return stmtListPaths.all().map((r) => r.path);
+      return Object.keys(store.paths);
     },
     setMeta(key, value) {
-      stmtSetMeta.run(key, value);
+      store.meta[key] = value;
+      schedule();
     },
     getMeta(key) {
-      const row = stmtGetMeta.get(key);
-      return row?.value ?? null;
+      return store.meta[key] ?? null;
     },
     close() {
-      db.close();
+      flush();
+      pendingFlushers.delete(flush);
     }
   };
 }
 
 // src/tapignore.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { join as join2 } from "path";
 import ignore from "ignore";
 var BUILTIN_IGNORE_LINES = [
@@ -433,7 +448,7 @@ function loadIgnore(rootDir) {
   ig.add(BUILTIN_IGNORE_LINES.join("\n"));
   const projectIgnore = join2(rootDir, ".tapignore");
   if (existsSync2(projectIgnore)) {
-    ig.add(readFileSync2(projectIgnore, "utf8"));
+    ig.add(readFileSync3(projectIgnore, "utf8"));
   }
   return ig;
 }
@@ -568,7 +583,7 @@ async function hashFile(absPath) {
 
 // src/init.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { join as join4 } from "path";
 
 // src/pool.ts
@@ -647,7 +662,7 @@ async function init(opts) {
       reused += 1;
       return;
     }
-    const bytes = readFileSync3(join4(opts.rootDir, f.path));
+    const bytes = readFileSync4(join4(opts.rootDir, f.path));
     const actual = sha256OfBuffer(bytes);
     if (actual !== f.hash) {
       mutatedDuringScan.add(f.path);
@@ -818,10 +833,10 @@ import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   realpathSync,
   statSync as statSync2,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "fs";
 import { dirname as dirname3, isAbsolute, join as join6, relative } from "path";
 var NAME_RE = /^[a-z0-9][a-z0-9_-]*$/;
@@ -907,14 +922,14 @@ var MOUNT_FILE_SUFFIX = ".local.json";
 function writeImportMount(rootDir, name, mount) {
   const path = importMountFile(rootDir, name);
   mkdirSync3(dirname3(path), { recursive: true });
-  writeFileSync2(path, JSON.stringify(mount, null, 2) + "\n", { mode: 384 });
+  writeFileSync3(path, JSON.stringify(mount, null, 2) + "\n", { mode: 384 });
 }
 function readImportMount(rootDir, name) {
   const file = importMountFile(rootDir, name);
   if (!existsSync3(file)) return { ok: false, reason: "missing_token_file" };
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync4(file, "utf8"));
+    parsed = JSON.parse(readFileSync5(file, "utf8"));
   } catch {
     return { ok: false, reason: "malformed_json" };
   }
@@ -998,7 +1013,7 @@ function pathsOverlap(a, b) {
 }
 
 // src/import-invite.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, rmSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6, rmSync } from "fs";
 import { dirname as dirname4, join as joinPath2 } from "path";
 var ImportValidationFailed = class extends Error {
   constructor(reason) {
@@ -1095,7 +1110,7 @@ function readRawMount(rootDir, name) {
   const file = importMountFile(rootDir, name);
   if (!existsSync4(file)) return null;
   try {
-    return JSON.parse(readFileSync5(file, "utf8"));
+    return JSON.parse(readFileSync6(file, "utf8"));
   } catch {
     return null;
   }
@@ -1147,11 +1162,11 @@ import {
   lstatSync,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
-  renameSync,
+  readFileSync as readFileSync7,
+  renameSync as renameSync2,
   rmdirSync,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { basename, dirname as dirname5, extname, join as join7, sep as sep2 } from "path";
 var STATE_KEY_CONFLICT_COUNT = "conflict_count";
@@ -1173,7 +1188,7 @@ function sha256Hex(bytes) {
   return createHash3("sha256").update(bytes).digest("hex");
 }
 function sha256OfFile(absPath) {
-  return `sha256:${sha256Hex(readFileSync6(absPath))}`;
+  return `sha256:${sha256Hex(readFileSync7(absPath))}`;
 }
 function conflictSidecarPath(path, ev) {
   const dir = dirname5(path);
@@ -1306,8 +1321,8 @@ async function applyEvent(opts) {
         const sidecarAbs = join7(rootDir, sidecarPath);
         mkdirSync4(dirname5(sidecarAbs), { recursive: true });
         const tmp2 = `${sidecarAbs}.tap-tmp.${randomBytes(6).toString("hex")}`;
-        writeFileSync3(tmp2, bytes, { mode: ev.executable ? 493 : 420 });
-        renameSync(tmp2, sidecarAbs);
+        writeFileSync4(tmp2, bytes, { mode: ev.executable ? 493 : 420 });
+        renameSync2(tmp2, sidecarAbs);
         stateDb.upsertPath({
           path: ev.path,
           lastAppliedChangeId: ev.id,
@@ -1320,8 +1335,8 @@ async function applyEvent(opts) {
       }
       mkdirSync4(dirname5(abs), { recursive: true });
       const tmp = `${abs}.tap-tmp.${randomBytes(6).toString("hex")}`;
-      writeFileSync3(tmp, bytes, { mode: ev.executable ? 493 : 420 });
-      renameSync(tmp, abs);
+      writeFileSync4(tmp, bytes, { mode: ev.executable ? 493 : 420 });
+      renameSync2(tmp, abs);
       stateDb.upsertPath({
         path: ev.path,
         lastAppliedChangeId: ev.id,
@@ -1633,7 +1648,7 @@ async function startSubscription(opts) {
 
 // src/uploader.ts
 import { createHash as createHash4 } from "crypto";
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { join as join8 } from "path";
 var UPLOAD_CONCURRENCY2 = 8;
 function sha256OfBuffer2(bytes) {
@@ -1713,7 +1728,7 @@ async function scanAndPush(opts) {
       reused += 1;
       return;
     }
-    const bytes = readFileSync7(join8(rootDir, f.path));
+    const bytes = readFileSync8(join8(rootDir, f.path));
     const actual = sha256OfBuffer2(bytes);
     if (actual !== f.hash) {
       mutatedPaths.add(f.path);
@@ -2022,4 +2037,4 @@ export {
   scanAndPush,
   start
 };
-//# sourceMappingURL=chunk-JBX2ZRMD.js.map
+//# sourceMappingURL=chunk-XMYPUAYD.js.map