@rigxyz/tapd 0.4.0 → 0.5.0

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

@@ -159,7 +159,14 @@ var RelayClient = class {
     );
     return expectJson(route, res);
   }
-  /** PUT bytes to a presigned URL. Throws on non-2xx. */
+  /**
+   * PUT bytes to a presigned URL. Throws on non-2xx — except 409, which
+   * means the content-addressed object is already stored (same hash = same
+   * bytes). That's idempotent success, not a conflict: two files with
+   * identical content (e.g. several empty files), or an initial upload that
+   * overlaps the daemon's first scan, race to PUT the same key. Treating
+   * 409 as fatal aborts the whole push and wedges sync at "N pending".
+   */
   async putObjectBytes(uploadUrl, bytes) {
     const route = "PUT <uploadUrl>";
     const res = await this.fetch(uploadUrl, {
@@ -167,6 +174,7 @@ var RelayClient = class {
       body: new Uint8Array(bytes),
       headers: { "content-length": String(bytes.byteLength) }
     });
+    if (res.status === 409) return;
     if (!res.ok) {
       throw new RelayError(route, res.status, await readJson(res));
     }
@@ -285,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;
@@ -303,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 = [
@@ -425,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;
 }
@@ -560,11 +583,35 @@ 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
+async function mapPool(items, limit, fn) {
+  let next = 0;
+  let failed = false;
+  const worker = async () => {
+    while (!failed) {
+      const idx = next++;
+      if (idx >= items.length) break;
+      const item = items[idx];
+      try {
+        await fn(item);
+      } catch (err) {
+        failed = true;
+        throw err;
+      }
+    }
+  };
+  const n = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: n }, worker));
+}
+
+// src/init.ts
 function sha256OfBuffer(bytes) {
   return `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
 }
+var UPLOAD_CONCURRENCY = 8;
 var AlreadyInitializedError = class extends Error {
   constructor(path) {
     super(`already initialized \u2014 ${path} exists`);
@@ -609,27 +656,27 @@ async function init(opts) {
   const mutatedDuringScan = /* @__PURE__ */ new Set();
   let uploaded = 0;
   let reused = 0;
-  for (const [hash, f] of uniqueHashes) {
-    const prep = await client.prepareUpload({ hash, size: f.size });
+  await mapPool([...uniqueHashes.values()], UPLOAD_CONCURRENCY, async (f) => {
+    const prep = await client.prepareUpload({ hash: f.hash, size: f.size });
     if (prep.exists) {
       reused += 1;
-      continue;
+      return;
     }
-    const bytes = readFileSync3(join4(opts.rootDir, f.path));
+    const bytes = readFileSync4(join4(opts.rootDir, f.path));
     const actual = sha256OfBuffer(bytes);
-    if (actual !== hash) {
+    if (actual !== f.hash) {
       mutatedDuringScan.add(f.path);
       scan.warnings.push({
         path: f.path,
         reason: "invalid_path"
         // closest existing warning kind; semantics are file-mutated-mid-scan
       });
-      continue;
+      return;
     }
     await client.putObjectBytes(prep.uploadUrl, bytes);
-    await client.completeUpload({ hash, size: f.size });
+    await client.completeUpload({ hash: f.hash, size: f.size });
     uploaded += 1;
-  }
+  });
   const events = [
     ...hashed.filter((f) => !mutatedDuringScan.has(f.path)).map((f) => ({
       op: "write",
@@ -786,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_-]*$/;
@@ -875,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" };
   }
@@ -966,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) {
@@ -1063,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;
   }
@@ -1115,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";
@@ -1141,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);
@@ -1274,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,
@@ -1288,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,
@@ -1601,8 +1648,9 @@ 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) {
   return `sha256:${createHash4("sha256").update(bytes).digest("hex")}`;
 }
@@ -1674,23 +1722,23 @@ async function scanAndPush(opts) {
   const skipWarnings = [];
   let uploaded = 0;
   let reused = 0;
-  for (const [hash, f] of uniqueHashes) {
-    const prep = await client.prepareUpload({ hash, size: f.size });
+  await mapPool([...uniqueHashes.values()], UPLOAD_CONCURRENCY2, async (f) => {
+    const prep = await client.prepareUpload({ hash: f.hash, size: f.size });
     if (prep.exists) {
       reused += 1;
-      continue;
+      return;
     }
-    const bytes = readFileSync7(join8(rootDir, f.path));
+    const bytes = readFileSync8(join8(rootDir, f.path));
     const actual = sha256OfBuffer2(bytes);
-    if (actual !== hash) {
+    if (actual !== f.hash) {
       mutatedPaths.add(f.path);
       skipWarnings.push({ path: f.path, reason: `mutated_during_scan:${actual}` });
-      continue;
+      return;
     }
     await client.putObjectBytes(prep.uploadUrl, bytes);
-    await client.completeUpload({ hash, size: f.size });
+    await client.completeUpload({ hash: f.hash, size: f.size });
     uploaded += 1;
-  }
+  });
   const events = [];
   for (const w of diff.writes) {
     if (mutatedPaths.has(w.path)) continue;
@@ -1989,4 +2037,4 @@ export {
   scanAndPush,
   start
 };
-//# sourceMappingURL=chunk-YPZ2UNI5.js.map
+//# sourceMappingURL=chunk-XMYPUAYD.js.map