@rigxyz/tapd 0.1.0

package/dist/chunk-RQC73B5Y.js

@@ -0,0 +1,1452 @@
+#!/usr/bin/env node
+
+// src/binding-config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+var BINDING_CONFIG_PATH = ".rig/tap-binding.local.json";
+function bindingConfigFile(rootDir) {
+  return join(rootDir, BINDING_CONFIG_PATH);
+}
+function readBindingConfig(rootDir) {
+  const path = bindingConfigFile(rootDir);
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed.bindingId !== "string" || typeof parsed.relayUrl !== "string" || typeof parsed.deviceId !== "string" || typeof parsed.token !== "string") {
+    throw new Error(`malformed binding config at ${path}`);
+  }
+  return {
+    bindingId: parsed.bindingId,
+    relayUrl: parsed.relayUrl,
+    deviceId: parsed.deviceId,
+    token: parsed.token
+  };
+}
+function writeBindingConfig(rootDir, config) {
+  const path = bindingConfigFile(rootDir);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+}
+var NotInitializedError = class extends Error {
+  constructor(rootDir) {
+    super(`not initialized \u2014 no binding config at ${rootDir}/${BINDING_CONFIG_PATH}`);
+    this.rootDir = rootDir;
+    this.name = "NotInitializedError";
+  }
+  rootDir;
+};
+
+// src/relay-client.ts
+var RelayError = class extends Error {
+  constructor(route, status, body) {
+    const bodySummary = typeof body === "object" && body !== null && "error" in body ? String(body.error) : `status ${status}`;
+    super(`relay ${route}: ${bodySummary}`);
+    this.route = route;
+    this.status = status;
+    this.body = body;
+    this.name = "RelayError";
+  }
+  route;
+  status;
+  body;
+};
+async function readJson(res) {
+  const ct = res.headers.get("content-type") ?? "";
+  if (!ct.includes("application/json")) return void 0;
+  try {
+    return await res.json();
+  } catch {
+    return void 0;
+  }
+}
+async function expectJson(route, res) {
+  const body = await readJson(res);
+  if (!res.ok) {
+    throw new RelayError(route, res.status, body);
+  }
+  return body;
+}
+async function acceptInvite(opts) {
+  const fn = opts.fetch ?? fetch;
+  const route = "POST /v1/invites/:secret/accept";
+  const headers = {
+    "content-type": "application/json",
+    "x-tap-user-id": opts.userId
+  };
+  if (opts.email) headers["x-tap-user-email"] = opts.email;
+  const res = await fn(
+    joinUrl(opts.baseUrl, `/v1/invites/${encodeURIComponent(opts.secret)}/accept`),
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(opts.request ?? {})
+    }
+  );
+  return expectJson(route, res);
+}
+async function createBinding(opts) {
+  const fn = opts.fetch ?? fetch;
+  const route = "POST /v1/bindings";
+  const headers = {
+    "content-type": "application/json",
+    "x-tap-user-id": opts.userId
+  };
+  if (opts.email) headers["x-tap-user-email"] = opts.email;
+  const res = await fn(joinUrl(opts.baseUrl, "/v1/bindings"), {
+    method: "POST",
+    headers,
+    body: JSON.stringify(opts.request)
+  });
+  return expectJson(route, res);
+}
+var RelayClient = class {
+  baseUrl;
+  bindingId;
+  token;
+  fetch;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl;
+    this.bindingId = opts.bindingId;
+    this.token = opts.token;
+    this.fetch = opts.fetch ?? fetch;
+  }
+  authHeaders(extra) {
+    return { authorization: `Bearer ${this.token}`, ...extra };
+  }
+  bindingPath(suffix) {
+    return joinUrl(
+      this.baseUrl,
+      `/v1/bindings/${encodeURIComponent(this.bindingId)}${suffix}`
+    );
+  }
+  async getBinding() {
+    const route = "GET /v1/bindings/:id";
+    const res = await this.fetch(this.bindingPath(""), {
+      headers: this.authHeaders()
+    });
+    return expectJson(route, res);
+  }
+  // ────────── objects ──────────
+  async prepareUpload(body) {
+    const route = "POST /v1/bindings/:id/objects/prepare-upload";
+    const res = await this.fetch(this.bindingPath("/objects/prepare-upload"), {
+      method: "POST",
+      headers: this.authHeaders({ "content-type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    return expectJson(route, res);
+  }
+  async completeUpload(body) {
+    const route = "POST /v1/bindings/:id/objects/complete-upload";
+    const res = await this.fetch(this.bindingPath("/objects/complete-upload"), {
+      method: "POST",
+      headers: this.authHeaders({ "content-type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    return expectJson(route, res);
+  }
+  async downloadUrl(hash) {
+    const route = "GET /v1/bindings/:id/objects/:hash/download-url";
+    const res = await this.fetch(
+      this.bindingPath(`/objects/${encodeURIComponent(hash)}/download-url`),
+      { headers: this.authHeaders() }
+    );
+    return expectJson(route, res);
+  }
+  /** PUT bytes to a presigned URL. Throws on non-2xx. */
+  async putObjectBytes(uploadUrl, bytes) {
+    const route = "PUT <uploadUrl>";
+    const res = await this.fetch(uploadUrl, {
+      method: "PUT",
+      body: new Uint8Array(bytes),
+      headers: { "content-length": String(bytes.byteLength) }
+    });
+    if (!res.ok) {
+      throw new RelayError(route, res.status, await readJson(res));
+    }
+  }
+  /** GET bytes from a presigned URL. Throws on non-2xx. */
+  async getObjectBytes(downloadUrl) {
+    const route = "GET <downloadUrl>";
+    const res = await this.fetch(downloadUrl);
+    if (!res.ok) {
+      throw new RelayError(route, res.status, await readJson(res));
+    }
+    return Buffer.from(await res.arrayBuffer());
+  }
+  // ────────── changes ──────────
+  async submitChanges(events) {
+    const route = "POST /v1/bindings/:id/changes";
+    const body = { events };
+    const res = await this.fetch(this.bindingPath("/changes"), {
+      method: "POST",
+      headers: this.authHeaders({ "content-type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    return expectJson(route, res);
+  }
+  async listChanges(opts) {
+    const route = "GET /v1/bindings/:id/changes";
+    const params = new URLSearchParams();
+    if (opts?.after) params.set("after", opts.after);
+    if (opts?.limit) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    const res = await this.fetch(
+      this.bindingPath("/changes") + (qs ? `?${qs}` : ""),
+      { headers: this.authHeaders() }
+    );
+    return expectJson(route, res);
+  }
+  // ────────── invites ──────────
+  /**
+   * Mint a new invite (owner-only). Returns the secret + a ready-to-share
+   * accept URL, exactly once. Caller must surface to the user immediately
+   * and rely on `listInvites()` later if they want to refer back without
+   * the secret.
+   */
+  async mintInvite(body) {
+    const route = "POST /v1/bindings/:id/invites";
+    const res = await this.fetch(this.bindingPath("/invites"), {
+      method: "POST",
+      headers: this.authHeaders({ "content-type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    return expectJson(route, res);
+  }
+  async listInvites() {
+    const route = "GET /v1/bindings/:id/invites";
+    const res = await this.fetch(this.bindingPath("/invites"), {
+      headers: this.authHeaders()
+    });
+    return expectJson(route, res);
+  }
+  async revokeInvite(inviteId) {
+    const route = "DELETE /v1/bindings/:id/invites/:inviteId";
+    const res = await this.fetch(
+      this.bindingPath(`/invites/${encodeURIComponent(inviteId)}`),
+      { method: "DELETE", headers: this.authHeaders() }
+    );
+    return expectJson(route, res);
+  }
+  // ────────── manifest ──────────
+  async getManifest(opts) {
+    const route = "GET /v1/bindings/:id/manifest";
+    const params = new URLSearchParams();
+    if (opts?.after) params.set("after", opts.after);
+    if (opts?.limit) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    const res = await this.fetch(
+      this.bindingPath("/manifest") + (qs ? `?${qs}` : ""),
+      { headers: this.authHeaders() }
+    );
+    return expectJson(route, res);
+  }
+};
+function joinUrl(base, suffix) {
+  const b = base.replace(/\/+$/, "");
+  const s = suffix.startsWith("/") ? suffix : `/${suffix}`;
+  return b + s;
+}
+
+// src/state-db.ts
+import { mkdirSync as mkdirSync2 } 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;
+  const bn = b.startsWith(CURSOR_PREFIX) ? safeBigInt(b.slice(CURSOR_PREFIX.length)) : null;
+  if (an === null) return false;
+  if (bn === null) return true;
+  return an > bn;
+}
+function safeBigInt(s) {
+  try {
+    return BigInt(s);
+  } catch {
+    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
+  );
+`;
+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 = ?`);
+  return {
+    getCursor() {
+      const row = stmtGetMeta.get("cursor");
+      return row?.value ?? "chg_0";
+    },
+    setCursor(cursor) {
+      const current = stmtGetMeta.get("cursor")?.value;
+      if (current && !cursorGreaterThan(cursor, current)) return;
+      stmtSetMeta.run("cursor", cursor);
+    },
+    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
+      });
+    },
+    getPath(path) {
+      const row = stmtGet.get(path);
+      if (!row) 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
+      };
+    },
+    deletePath(path) {
+      stmtDelete.run(path);
+    },
+    listPaths() {
+      return stmtListPaths.all().map((r) => r.path);
+    },
+    setMeta(key, value) {
+      stmtSetMeta.run(key, value);
+    },
+    getMeta(key) {
+      const row = stmtGetMeta.get(key);
+      return row?.value ?? null;
+    },
+    close() {
+      db.close();
+    }
+  };
+}
+
+// src/tapignore.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import ignore from "ignore";
+var BUILTIN_IGNORE_LINES = [
+  "# Secrets and machine-local",
+  ".env",
+  ".env.*",
+  "*.local.*",
+  "",
+  "# Dependencies and build output",
+  "node_modules/",
+  "dist/",
+  ".venv/",
+  "__pycache__/",
+  "*.pyc",
+  "",
+  "# Git and OS noise",
+  ".git/",
+  ".DS_Store",
+  "",
+  "# Bulky generated artifacts",
+  "*.mov",
+  "*.mp4",
+  "*.zip",
+  "*.tar.gz",
+  "*.sqlite",
+  "",
+  "# Tap conflict sidecars \u2014 local-only by default",
+  "*.conflict-from.*"
+];
+var ALWAYS_EXCLUDED_PREFIXES = [".rig/"];
+function loadIgnore(rootDir) {
+  const ig = ignore();
+  ig.add(BUILTIN_IGNORE_LINES.join("\n"));
+  const projectIgnore = join2(rootDir, ".tapignore");
+  if (existsSync2(projectIgnore)) {
+    ig.add(readFileSync2(projectIgnore, "utf8"));
+  }
+  return ig;
+}
+function isAlwaysExcluded(posixPath) {
+  for (const prefix of ALWAYS_EXCLUDED_PREFIXES) {
+    const exact = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+    if (posixPath === exact) return true;
+    if (posixPath.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+// src/walker.ts
+import { readdirSync, statSync } from "fs";
+import { join as join3, sep } from "path";
+
+// ../core/dist/index.js
+var MAX_FILE_BYTES = 100 * 1024 * 1024;
+var RESERVED_PATHS = [
+  ".rig/tap/",
+  ".rig/tap-binding.local.json"
+];
+function validateRigPath(path) {
+  if (path.length === 0) return { ok: false, reason: "empty" };
+  if (path.startsWith("/")) return { ok: false, reason: "absolute" };
+  if (path.endsWith("/")) return { ok: false, reason: "trailing_slash" };
+  if (path.includes("\\")) return { ok: false, reason: "backslash" };
+  if (/[-]/.test(path)) return { ok: false, reason: "control_char" };
+  const segments = path.split("/");
+  for (const seg of segments) {
+    if (seg.length === 0) return { ok: false, reason: "empty_segment" };
+    if (seg === "..") return { ok: false, reason: "parent_segment" };
+  }
+  for (const reserved of RESERVED_PATHS) {
+    if (path === reserved.replace(/\/$/, "") || path.startsWith(reserved)) {
+      return { ok: false, reason: "reserved" };
+    }
+  }
+  return { ok: true };
+}
+
+// src/walker.ts
+function walk(rootDir, opts) {
+  const files = [];
+  const emptyDirs = [];
+  const directoriesScanned = [];
+  const warnings = [];
+  walkDir(".");
+  return { files, emptyDirs, directoriesScanned, warnings };
+  function walkDir(rel) {
+    const abs = join3(rootDir, rel);
+    let entries;
+    try {
+      entries = readdirSync(abs, { withFileTypes: true });
+    } catch {
+      warnings.push({ path: posixOf(rel), reason: "unreadable" });
+      return false;
+    }
+    let hasVisible = false;
+    for (const ent of entries) {
+      const childRel = rel === "." ? ent.name : join3(rel, ent.name);
+      const posix = posixOf(childRel);
+      const isDir = ent.isDirectory();
+      if (isAlwaysExcluded(posix)) continue;
+      if (opts.ignore.ignores(posix + (isDir ? "/" : ""))) continue;
+      if (ent.isSymbolicLink()) {
+        warnings.push({ path: posix, reason: "symlink" });
+        continue;
+      }
+      const pathOk = validateRigPath(posix);
+      if (!pathOk.ok) {
+        warnings.push({ path: posix, reason: "invalid_path" });
+        continue;
+      }
+      if (isDir) {
+        directoriesScanned.push(posix);
+        const subHas = walkDir(childRel);
+        if (!subHas) emptyDirs.push(posix);
+        hasVisible = true;
+        continue;
+      }
+      if (ent.isFile()) {
+        let size;
+        try {
+          size = statSync(join3(abs, ent.name)).size;
+        } catch {
+          warnings.push({ path: posix, reason: "unreadable" });
+          continue;
+        }
+        if (size > MAX_FILE_BYTES) {
+          warnings.push({ path: posix, reason: "too_large" });
+          continue;
+        }
+        files.push({ path: posix, size });
+        hasVisible = true;
+      }
+    }
+    return hasVisible;
+  }
+}
+function posixOf(s) {
+  return sep === "/" ? s : s.replaceAll(sep, "/");
+}
+
+// src/hash.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+async function hashFile(absPath) {
+  const hash = createHash("sha256");
+  await new Promise((resolve, reject) => {
+    const stream = createReadStream(absPath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve());
+    stream.on("error", (err) => reject(err));
+  });
+  return `sha256:${hash.digest("hex")}`;
+}
+
+// src/init.ts
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+function sha256OfBuffer(bytes) {
+  return `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
+}
+var AlreadyInitializedError = class extends Error {
+  constructor(path) {
+    super(`already initialized \u2014 ${path} exists`);
+    this.path = path;
+    this.name = "AlreadyInitializedError";
+  }
+  path;
+};
+async function init(opts) {
+  if (readBindingConfig(opts.rootDir)) {
+    throw new AlreadyInitializedError(join4(opts.rootDir, BINDING_CONFIG_PATH));
+  }
+  const ig = loadIgnore(opts.rootDir);
+  const scan = walk(opts.rootDir, { ignore: ig });
+  const hashed = [];
+  for (const f of scan.files) {
+    const h = await hashFile(join4(opts.rootDir, f.path));
+    hashed.push({ path: f.path, size: f.size, hash: h });
+  }
+  const created = await createBinding({
+    baseUrl: opts.relayUrl,
+    request: { name: opts.bindingName, deviceLabel: opts.deviceLabel },
+    userId: opts.ownerUserId,
+    fetch: opts.fetch
+  });
+  writeBindingConfig(opts.rootDir, {
+    bindingId: created.binding.id,
+    relayUrl: opts.relayUrl,
+    deviceId: created.device.id,
+    token: created.token.secret
+  });
+  const client = new RelayClient({
+    baseUrl: opts.relayUrl,
+    bindingId: created.binding.id,
+    token: created.token.secret,
+    fetch: opts.fetch
+  });
+  const uniqueHashes = /* @__PURE__ */ new Map();
+  for (const f of hashed) {
+    if (!uniqueHashes.has(f.hash)) uniqueHashes.set(f.hash, f);
+  }
+  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 });
+    if (prep.exists) {
+      reused += 1;
+      continue;
+    }
+    const bytes = readFileSync3(join4(opts.rootDir, f.path));
+    const actual = sha256OfBuffer(bytes);
+    if (actual !== 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;
+    }
+    await client.putObjectBytes(prep.uploadUrl, bytes);
+    await client.completeUpload({ hash, size: f.size });
+    uploaded += 1;
+  }
+  const events = [
+    ...hashed.filter((f) => !mutatedDuringScan.has(f.path)).map((f) => ({
+      op: "write",
+      path: f.path,
+      hash: f.hash,
+      size: f.size
+    })),
+    ...scan.emptyDirs.map((path) => ({ op: "mkdir", path }))
+  ];
+  let cursor = "chg_0";
+  let submittedEvents = [];
+  if (events.length > 0) {
+    const submit = await client.submitChanges(events);
+    submittedEvents = submit.events;
+    cursor = submit.events[submit.events.length - 1].id;
+  }
+  const stateDb = openStateDb(
+    join4(opts.rootDir, ".rig", "tap", "state.local.db")
+  );
+  try {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const ev of submittedEvents) {
+      const state = {
+        path: ev.path,
+        lastAppliedChangeId: ev.id,
+        lastSeenHash: ev.hash,
+        // null for mkdirs
+        localDirty: false,
+        lastScanAt: now
+      };
+      stateDb.upsertPath(state);
+    }
+    stateDb.setCursor(cursor);
+    stateDb.setMeta("device_id", created.device.id);
+    stateDb.setMeta("binding_id", created.binding.id);
+  } finally {
+    stateDb.close();
+  }
+  return {
+    binding: created.binding,
+    device: created.device,
+    ownerSecret: created.token.secret,
+    uploadedHashes: uploaded,
+    reusedHashes: reused,
+    submittedEvents: submittedEvents.length,
+    warnings: scan.warnings,
+    cursor
+  };
+}
+
+// src/invite.ts
+function clientFor(rootDir, fetchImpl) {
+  const cfg = readBindingConfig(rootDir);
+  if (!cfg) throw new NotInitializedError(rootDir);
+  return new RelayClient({
+    baseUrl: cfg.relayUrl,
+    bindingId: cfg.bindingId,
+    token: cfg.token,
+    fetch: fetchImpl
+  });
+}
+async function mint(opts) {
+  const client = clientFor(opts.rootDir, opts.fetch);
+  const body = {
+    ops: opts.ops,
+    ...opts.role !== void 0 ? { role: opts.role } : {},
+    ...opts.pathGlobs ? { pathGlobs: opts.pathGlobs } : {},
+    ...opts.ttlSeconds !== void 0 ? { ttlSeconds: opts.ttlSeconds } : {},
+    ...opts.maxUses !== void 0 ? { maxUses: opts.maxUses } : {},
+    ...opts.emailConstraint ? { emailConstraint: opts.emailConstraint } : {},
+    ...opts.label ? { label: opts.label } : {}
+  };
+  return client.mintInvite(body);
+}
+async function list(opts) {
+  const client = clientFor(opts.rootDir, opts.fetch);
+  const res = await client.listInvites();
+  return res.invites;
+}
+async function revoke(opts) {
+  const client = clientFor(opts.rootDir, opts.fetch);
+  return client.revokeInvite(opts.inviteId);
+}
+
+// src/join.ts
+import { join as joinPath } from "path";
+var AlreadyJoinedError = class extends Error {
+  constructor(path) {
+    super(`already initialized \u2014 ${path} exists`);
+    this.path = path;
+    this.name = "AlreadyJoinedError";
+  }
+  path;
+};
+var InvalidInviteUrlError = class extends Error {
+  constructor(url) {
+    super(`invalid invite URL: ${url} (expected <baseUrl>/v1/invites/<secret>/accept)`);
+    this.url = url;
+    this.name = "InvalidInviteUrlError";
+  }
+  url;
+};
+function parseInviteUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new InvalidInviteUrlError(url);
+  }
+  const match = /^\/v1\/invites\/([^/]+)(?:\/accept)?\/?$/.exec(parsed.pathname);
+  if (!match) throw new InvalidInviteUrlError(url);
+  return {
+    baseUrl: `${parsed.protocol}//${parsed.host}`,
+    secret: decodeURIComponent(match[1])
+  };
+}
+async function join5(opts) {
+  if (readBindingConfig(opts.rootDir)) {
+    throw new AlreadyJoinedError(joinPath(opts.rootDir, BINDING_CONFIG_PATH));
+  }
+  const { baseUrl, secret } = parseInviteUrl(opts.inviteUrl);
+  const accepted = await acceptInvite({
+    baseUrl,
+    secret,
+    userId: opts.userId,
+    email: opts.email,
+    request: opts.deviceLabel ? { deviceLabel: opts.deviceLabel } : void 0,
+    fetch: opts.fetch
+  });
+  writeBindingConfig(opts.rootDir, {
+    bindingId: accepted.bindingId,
+    relayUrl: baseUrl,
+    deviceId: accepted.device.id,
+    token: accepted.token.secret
+  });
+  const stateDb = openStateDb(
+    joinPath(opts.rootDir, ".rig", "tap", "state.local.db")
+  );
+  try {
+    stateDb.setMeta("binding_id", accepted.bindingId);
+    stateDb.setMeta("device_id", accepted.device.id);
+  } finally {
+    stateDb.close();
+  }
+  return {
+    bindingId: accepted.bindingId,
+    device: accepted.device,
+    tokenSecret: accepted.token.secret,
+    becameMember: accepted.member !== null
+  };
+}
+
+// src/applier.ts
+import { createHash as createHash3, randomBytes } from "crypto";
+import {
+  existsSync as existsSync3,
+  lstatSync,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  renameSync,
+  rmdirSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename, dirname as dirname3, extname, join as join6, sep as sep2 } from "path";
+var STATE_KEY_CONFLICT_COUNT = "conflict_count";
+var HashMismatchError = class extends Error {
+  constructor(path, expectedHash, actualHash) {
+    super(
+      `hash mismatch at ${path}: expected ${expectedHash}, got ${actualHash}`
+    );
+    this.path = path;
+    this.expectedHash = expectedHash;
+    this.actualHash = actualHash;
+    this.name = "HashMismatchError";
+  }
+  path;
+  expectedHash;
+  actualHash;
+};
+function sha256Hex(bytes) {
+  return createHash3("sha256").update(bytes).digest("hex");
+}
+function sha256OfFile(absPath) {
+  return `sha256:${sha256Hex(readFileSync4(absPath))}`;
+}
+function conflictSidecarPath(path, ev) {
+  const dir = dirname3(path);
+  const ext = extname(path);
+  const stem = basename(path, ext);
+  const actor = ev.actorDeviceId ?? "unknown";
+  const sidecar = `${stem}.conflict-from.${actor}.${ev.id}${ext}`;
+  return dir === "." ? sidecar : `${dir}/${sidecar}`;
+}
+var SIDECAR_RE = /^(.*)\.conflict-from\.[^.]+\.(chg_\d+)(\.[^.]+)?$/;
+function parseConflictSidecar(filename) {
+  const m = SIDECAR_RE.exec(filename);
+  if (!m) return null;
+  return { stem: m[1], chgId: m[2], ext: m[3] ?? "" };
+}
+var SCAN_SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".rig"]);
+function findConflictSidecars(rootDir) {
+  const out = [];
+  walk2(".");
+  return out;
+  function walk2(rel) {
+    const abs = rel === "." ? rootDir : join6(rootDir, rel);
+    let entries;
+    try {
+      entries = readdirSync2(abs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      if (ent.isSymbolicLink()) continue;
+      const childRel = rel === "." ? ent.name : join6(rel, ent.name);
+      if (ent.isDirectory()) {
+        if (SCAN_SKIP_DIRS.has(ent.name)) continue;
+        walk2(childRel);
+        continue;
+      }
+      if (!ent.isFile()) continue;
+      const parsed = parseConflictSidecar(ent.name);
+      if (!parsed) continue;
+      const sidecarPosix = sep2 === "/" ? childRel : childRel.replaceAll(sep2, "/");
+      const dir = dirname3(sidecarPosix);
+      const original = dir === "." ? `${parsed.stem}${parsed.ext}` : `${dir}/${parsed.stem}${parsed.ext}`;
+      out.push({ path: original, sidecarPath: sidecarPosix });
+    }
+  }
+}
+function bumpConflictCount(stateDb) {
+  const current = Number.parseInt(
+    stateDb.getMeta(STATE_KEY_CONFLICT_COUNT) ?? "0",
+    10
+  );
+  stateDb.setMeta(STATE_KEY_CONFLICT_COUNT, String(current + 1));
+}
+var STATE_KEY_LAST_APPLY_ERROR = "last_apply_error";
+var STATE_KEY_LAST_APPLY_ERROR_AT = "last_apply_error_at";
+async function applyOnce(opts) {
+  const cursor = opts.stateDb.getCursor();
+  const since = await opts.client.listChanges({ after: cursor, limit: opts.limit });
+  let applied = 0;
+  let echoSkipped = 0;
+  let errored = 0;
+  const errors = [];
+  for (const ev of since.events) {
+    try {
+      const wasEcho = await applyEvent({
+        rootDir: opts.rootDir,
+        client: opts.client,
+        stateDb: opts.stateDb,
+        event: ev
+      });
+      if (wasEcho) echoSkipped += 1;
+      else applied += 1;
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      const recorded = {
+        eventId: ev.id,
+        path: ev.path,
+        op: ev.op,
+        reason
+      };
+      errors.push(recorded);
+      errored += 1;
+      opts.stateDb.setMeta(STATE_KEY_LAST_APPLY_ERROR, JSON.stringify(recorded));
+      opts.stateDb.setMeta(STATE_KEY_LAST_APPLY_ERROR_AT, (/* @__PURE__ */ new Date()).toISOString());
+      console.error(
+        `tapd apply: skipping ${ev.id} (${ev.op} ${ev.path}): ${reason}`
+      );
+    }
+    opts.stateDb.setCursor(ev.id);
+  }
+  return { applied, echoSkipped, errored, events: since.events, errors };
+}
+async function applyEvent(opts) {
+  const { rootDir, client, stateDb, event: ev } = opts;
+  const abs = join6(rootDir, ev.path);
+  switch (ev.op) {
+    case "write": {
+      if (!ev.hash) throw new Error(`write event ${ev.id} missing hash`);
+      const local = stateDb.getPath(ev.path);
+      if (local?.lastSeenHash === ev.hash && existsSync3(abs)) {
+        stateDb.upsertPath({
+          path: ev.path,
+          lastAppliedChangeId: ev.id,
+          lastSeenHash: ev.hash,
+          localDirty: false,
+          lastScanAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return true;
+      }
+      if (existsSync3(abs) && lstatSync(abs).isDirectory()) {
+        throw new Error(
+          `file_vs_dir_collision: ${ev.path} is a local directory; refusing to overwrite with a file`
+        );
+      }
+      const localDirty = existsSync3(abs) && local?.lastSeenHash != null && sha256OfFile(abs) !== local.lastSeenHash;
+      const dl = await client.downloadUrl(ev.hash);
+      const bytes = await client.getObjectBytes(dl.downloadUrl);
+      const actualHash = `sha256:${sha256Hex(bytes)}`;
+      if (actualHash !== ev.hash) {
+        throw new HashMismatchError(ev.path, ev.hash, actualHash);
+      }
+      if (localDirty) {
+        const sidecarPath = conflictSidecarPath(ev.path, ev);
+        const sidecarAbs = join6(rootDir, sidecarPath);
+        mkdirSync3(dirname3(sidecarAbs), { recursive: true });
+        const tmp2 = `${sidecarAbs}.tap-tmp.${randomBytes(6).toString("hex")}`;
+        writeFileSync2(tmp2, bytes, { mode: ev.executable ? 493 : 420 });
+        renameSync(tmp2, sidecarAbs);
+        stateDb.upsertPath({
+          path: ev.path,
+          lastAppliedChangeId: ev.id,
+          lastSeenHash: local.lastSeenHash,
+          localDirty: true,
+          lastScanAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        bumpConflictCount(stateDb);
+        return false;
+      }
+      mkdirSync3(dirname3(abs), { recursive: true });
+      const tmp = `${abs}.tap-tmp.${randomBytes(6).toString("hex")}`;
+      writeFileSync2(tmp, bytes, { mode: ev.executable ? 493 : 420 });
+      renameSync(tmp, abs);
+      stateDb.upsertPath({
+        path: ev.path,
+        lastAppliedChangeId: ev.id,
+        lastSeenHash: ev.hash,
+        localDirty: false,
+        lastScanAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return false;
+    }
+    case "delete": {
+      if (existsSync3(abs)) {
+        if (lstatSync(abs).isDirectory()) {
+          throw new Error(
+            `delete_vs_dir: ${ev.path} is a local directory; refusing recursive removal`
+          );
+        }
+        const localStateRow = stateDb.getPath(ev.path);
+        const localBytesHash = sha256OfFile(abs);
+        const localDirty = localStateRow?.lastSeenHash != null && localBytesHash !== localStateRow.lastSeenHash;
+        const localUntracked = localStateRow?.lastSeenHash == null;
+        if (localDirty || localUntracked) {
+          stateDb.upsertPath({
+            path: ev.path,
+            lastAppliedChangeId: ev.id,
+            // null so scanAndPush's `prev?.lastSeenHash === hash` check
+            // falls through and the file gets re-submitted as a write.
+            lastSeenHash: null,
+            localDirty: true,
+            lastScanAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          bumpConflictCount(stateDb);
+          return false;
+        }
+        rmSync(abs, { force: true });
+      }
+      stateDb.deletePath(ev.path);
+      return false;
+    }
+    case "mkdir": {
+      mkdirSync3(abs, { recursive: true });
+      stateDb.upsertPath({
+        path: ev.path,
+        lastAppliedChangeId: ev.id,
+        lastSeenHash: null,
+        localDirty: false,
+        lastScanAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return false;
+    }
+    case "rmdir": {
+      try {
+        rmdirSync(abs);
+      } catch {
+      }
+      stateDb.deletePath(ev.path);
+      return false;
+    }
+  }
+}
+
+// src/sse.ts
+var DEFAULT_HEARTBEAT_TIMEOUT_MS = 45e3;
+function defaultBackoff(attempt) {
+  return Math.min(3e4, 1e3 * 2 ** attempt);
+}
+function subscribe(opts) {
+  const fetchImpl = opts.fetch ?? fetch;
+  const heartbeatTimeoutMs = opts.heartbeatTimeoutMs ?? DEFAULT_HEARTBEAT_TIMEOUT_MS;
+  const backoff = opts.reconnectDelayMs ?? defaultBackoff;
+  let stopped = false;
+  let attempt = 0;
+  let activeAbort = null;
+  let reconnectTimer = null;
+  let loop;
+  const surface = (err) => {
+    if (opts.onError) opts.onError(err);
+    else console.error("tapd sse:", err.message);
+  };
+  const connect = async () => {
+    if (stopped) return;
+    const ac = new AbortController();
+    activeAbort = ac;
+    const url = `${opts.baseUrl.replace(/\/+$/, "")}/v1/bindings/${encodeURIComponent(opts.bindingId)}/stream`;
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        method: "GET",
+        headers: {
+          accept: "text/event-stream",
+          authorization: `Bearer ${opts.token}`
+        },
+        signal: ac.signal
+      });
+    } catch (err) {
+      if (stopped) return;
+      surface(asError(err, "sse_connect_failed"));
+      scheduleReconnect();
+      return;
+    }
+    if (!res.ok || !res.body) {
+      surface(new Error(`sse_bad_status:${res.status}`));
+      scheduleReconnect();
+      return;
+    }
+    attempt = 0;
+    await pumpStream(res.body, ac);
+    if (stopped) return;
+    scheduleReconnect();
+  };
+  const pumpStream = async (body, ac) => {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let lastTick = Date.now();
+    const watchdog = setInterval(() => {
+      if (Date.now() - lastTick > heartbeatTimeoutMs) {
+        surface(new Error("sse_heartbeat_timeout"));
+        ac.abort();
+      }
+    }, Math.max(1e3, heartbeatTimeoutMs / 5));
+    try {
+      while (!stopped) {
+        let result;
+        try {
+          result = await reader.read();
+        } catch (err) {
+          if (stopped) break;
+          surface(asError(err, "sse_read_failed"));
+          break;
+        }
+        if (result.done) break;
+        lastTick = Date.now();
+        buffer += decoder.decode(result.value, { stream: true });
+        let idx;
+        while ((idx = buffer.indexOf("\n\n")) >= 0) {
+          const frame = buffer.slice(0, idx);
+          buffer = buffer.slice(idx + 2);
+          await dispatchFrame(frame);
+        }
+      }
+    } finally {
+      clearInterval(watchdog);
+      try {
+        await reader.cancel();
+      } catch {
+      }
+    }
+  };
+  const dispatchFrame = async (frame) => {
+    if (frame.trim().length === 0) return;
+    let event;
+    let data;
+    for (const line of frame.split("\n")) {
+      if (line.startsWith(":")) continue;
+      if (line.startsWith("event: ")) event = line.slice(7);
+      else if (line.startsWith("data: ")) data = line.slice(6);
+    }
+    if (!event || !data) return;
+    try {
+      if (event === "subscribed" && opts.onSubscribed) {
+        opts.onSubscribed(JSON.parse(data));
+      } else if (event === "change_created") {
+        await opts.onChange(JSON.parse(data));
+      } else if (event === "heartbeat") {
+      }
+    } catch (err) {
+      surface(asError(err, `sse_handler_failed:${event}`));
+    }
+  };
+  const scheduleReconnect = () => {
+    if (stopped) return;
+    const delay = backoff(attempt++);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      void connect();
+    }, delay);
+  };
+  loop = connect();
+  return {
+    async stop() {
+      stopped = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      if (activeAbort) activeAbort.abort();
+      await loop.catch(() => {
+      });
+    }
+  };
+}
+function asError(err, fallbackName) {
+  if (err instanceof Error) return err;
+  const e = new Error(String(err));
+  e.name = fallbackName;
+  return e;
+}
+
+// src/uploader.ts
+import { createHash as createHash4 } from "crypto";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+function sha256OfBuffer2(bytes) {
+  return `sha256:${createHash4("sha256").update(bytes).digest("hex")}`;
+}
+async function computeLocalDiff(opts) {
+  const { rootDir, stateDb, ignore: ignore2 } = opts;
+  const scan = walk(rootDir, { ignore: ignore2 });
+  const writes = [];
+  for (const f of scan.files) {
+    const hash = await hashFile(join7(rootDir, f.path));
+    const prev = stateDb.getPath(f.path);
+    if (prev?.lastSeenHash === hash) continue;
+    const baseChangeId = prev?.lastAppliedChangeId ?? void 0;
+    writes.push({ path: f.path, size: f.size, hash, ...baseChangeId ? { baseChangeId } : {} });
+  }
+  const filesNow = new Set(scan.files.map((f) => f.path));
+  const dirsNow = new Set(scan.directoriesScanned);
+  const deletes = [];
+  const explicitRmdirs = [];
+  const removedPaths = /* @__PURE__ */ new Set();
+  for (const path of stateDb.listPaths()) {
+    const prev = stateDb.getPath(path);
+    if (!prev) continue;
+    const stillOnDisk = filesNow.has(path) || dirsNow.has(path);
+    if (stillOnDisk) continue;
+    const baseChangeId = prev.lastAppliedChangeId ?? void 0;
+    if (prev.lastSeenHash === null) {
+      explicitRmdirs.push({ path, ...baseChangeId ? { baseChangeId } : {} });
+    } else {
+      deletes.push({ path, ...baseChangeId ? { baseChangeId } : {} });
+    }
+    removedPaths.add(path);
+  }
+  const synthesizedRmdirs = /* @__PURE__ */ new Set();
+  for (const path of removedPaths) {
+    let parent = parentDir(path);
+    while (parent !== null) {
+      if (filesNow.has(parent) || dirsNow.has(parent)) break;
+      if (synthesizedRmdirs.has(parent)) break;
+      if (!removedPaths.has(parent)) synthesizedRmdirs.add(parent);
+      parent = parentDir(parent);
+    }
+  }
+  const synthDeepest = [...synthesizedRmdirs].sort(
+    (a, b) => b.split("/").length - a.split("/").length
+  );
+  const mkdirs = [];
+  for (const dir of scan.emptyDirs) {
+    if (stateDb.getPath(dir)) continue;
+    mkdirs.push(dir);
+  }
+  const rmdirs = [
+    ...explicitRmdirs,
+    ...synthDeepest.map((path) => ({ path }))
+  ];
+  return {
+    writes,
+    deletes,
+    mkdirs,
+    rmdirs,
+    warnings: scan.warnings.map((w) => ({ path: w.path, reason: w.reason }))
+  };
+}
+async function scanAndPush(opts) {
+  const { rootDir, client, stateDb } = opts;
+  const diff = await computeLocalDiff(opts);
+  const uniqueHashes = /* @__PURE__ */ new Map();
+  for (const w of diff.writes) if (!uniqueHashes.has(w.hash)) uniqueHashes.set(w.hash, w);
+  const mutatedPaths = /* @__PURE__ */ new Set();
+  const skipWarnings = [];
+  let uploaded = 0;
+  let reused = 0;
+  for (const [hash, f] of uniqueHashes) {
+    const prep = await client.prepareUpload({ hash, size: f.size });
+    if (prep.exists) {
+      reused += 1;
+      continue;
+    }
+    const bytes = readFileSync5(join7(rootDir, f.path));
+    const actual = sha256OfBuffer2(bytes);
+    if (actual !== hash) {
+      mutatedPaths.add(f.path);
+      skipWarnings.push({ path: f.path, reason: `mutated_during_scan:${actual}` });
+      continue;
+    }
+    await client.putObjectBytes(prep.uploadUrl, bytes);
+    await client.completeUpload({ hash, size: f.size });
+    uploaded += 1;
+  }
+  const events = [];
+  for (const w of diff.writes) {
+    if (mutatedPaths.has(w.path)) continue;
+    const repPath = (uniqueHashes.get(w.hash) ?? w).path;
+    if (mutatedPaths.has(repPath)) continue;
+    events.push({
+      op: "write",
+      path: w.path,
+      hash: w.hash,
+      size: w.size,
+      ...w.baseChangeId ? { baseChangeId: w.baseChangeId } : {}
+    });
+  }
+  for (const d of diff.deletes) {
+    events.push({
+      op: "delete",
+      path: d.path,
+      ...d.baseChangeId ? { baseChangeId: d.baseChangeId } : {}
+    });
+  }
+  for (const r of diff.rmdirs) {
+    events.push({ op: "rmdir", path: r.path, ...r.baseChangeId ? { baseChangeId: r.baseChangeId } : {} });
+  }
+  for (const path of diff.mkdirs) {
+    events.push({ op: "mkdir", path });
+  }
+  let submitted = [];
+  if (events.length > 0) {
+    const result = await client.submitChanges(events);
+    submitted = result.events;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const ev of submitted) {
+      if (ev.op === "delete" || ev.op === "rmdir") {
+        stateDb.deletePath(ev.path);
+        continue;
+      }
+      stateDb.upsertPath({
+        path: ev.path,
+        lastAppliedChangeId: ev.id,
+        lastSeenHash: ev.op === "write" ? ev.hash : null,
+        localDirty: false,
+        lastScanAt: now
+      });
+    }
+    const lastId = submitted[submitted.length - 1].id;
+    if (cursorLessThan(stateDb.getCursor(), lastId)) {
+      stateDb.setCursor(lastId);
+    }
+  }
+  return {
+    uploaded,
+    reused,
+    submitted,
+    warnings: [...diff.warnings, ...skipWarnings]
+  };
+}
+function parentDir(posix) {
+  const i = posix.lastIndexOf("/");
+  if (i < 0) return null;
+  return posix.slice(0, i);
+}
+function cursorLessThan(a, b) {
+  const prefix = "chg_";
+  const an = a.startsWith(prefix) ? BigInt(a.slice(prefix.length)) : 0n;
+  const bn = b.startsWith(prefix) ? BigInt(b.slice(prefix.length)) : 0n;
+  return an < bn;
+}
+
+// src/start.ts
+import { join as join8 } from "path";
+import chokidar from "chokidar";
+var DEFAULT_POLL_SECONDS = 3;
+var DEFAULT_DEBOUNCE_MS = 300;
+async function start(opts) {
+  const config = readBindingConfig(opts.rootDir);
+  if (!config) {
+    throw new Error(
+      `no binding config at ${opts.rootDir}/.rig/tap-binding.local.json \u2014 run \`tapd init\` first`
+    );
+  }
+  const stateDb = openStateDb(
+    join8(opts.rootDir, ".rig", "tap", "state.local.db")
+  );
+  const ignore2 = loadIgnore(opts.rootDir);
+  const client = new RelayClient({
+    baseUrl: config.relayUrl,
+    bindingId: config.bindingId,
+    token: config.token,
+    fetch: opts.fetch
+  });
+  const pollSeconds = opts.pollSeconds ?? DEFAULT_POLL_SECONDS;
+  const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  let stopped = false;
+  let pollTimer;
+  let scanTimer;
+  let sseApplyTimer;
+  let watcher;
+  let scanInFlight = Promise.resolve();
+  let sseSubscriber;
+  let applyInFlight = null;
+  let rerunRequested = false;
+  let lastApplyResult;
+  const triggerApply = () => {
+    if (applyInFlight) {
+      rerunRequested = true;
+      return applyInFlight;
+    }
+    const loop = (async () => {
+      try {
+        do {
+          rerunRequested = false;
+          try {
+            lastApplyResult = await applyOnce({
+              rootDir: opts.rootDir,
+              client,
+              stateDb
+            });
+          } catch (err) {
+            console.error("tapd apply error:", err);
+          }
+        } while (rerunRequested && !stopped);
+        return lastApplyResult;
+      } finally {
+        applyInFlight = null;
+      }
+    })();
+    applyInFlight = loop;
+    return loop;
+  };
+  const schedulePoll = () => {
+    if (stopped) return;
+    pollTimer = setTimeout(() => {
+      triggerApply().finally(() => schedulePoll());
+    }, pollSeconds * 1e3);
+  };
+  const scheduleScan = () => {
+    if (stopped) return;
+    if (scanTimer) clearTimeout(scanTimer);
+    scanTimer = setTimeout(() => {
+      scanInFlight = scanAndPush({ rootDir: opts.rootDir, client, stateDb, ignore: ignore2 }).catch((err) => {
+        console.error("tapd scan error:", err);
+      });
+    }, debounceMs);
+  };
+  const SSE_APPLY_DEBOUNCE_MS = 50;
+  const scheduleSseApply = () => {
+    if (stopped) return;
+    if (sseApplyTimer) clearTimeout(sseApplyTimer);
+    sseApplyTimer = setTimeout(() => {
+      sseApplyTimer = void 0;
+      void triggerApply();
+    }, SSE_APPLY_DEBOUNCE_MS);
+  };
+  if (!opts.noSse) {
+    sseSubscriber = subscribe({
+      baseUrl: config.relayUrl,
+      bindingId: config.bindingId,
+      token: config.token,
+      fetch: opts.fetch,
+      heartbeatTimeoutMs: opts.sseHeartbeatTimeoutMs,
+      onChange: () => scheduleSseApply(),
+      onError: (err) => {
+        console.error("tapd sse:", err.message);
+      }
+    });
+  }
+  if (!opts.noWatch) {
+    watcher = chokidar.watch(opts.rootDir, {
+      ignoreInitial: true,
+      // Ignore tap's own state files at the watcher level too — saves
+      // wakeups from sqlite WAL churn.
+      ignored: (path) => {
+        const rel = path.startsWith(opts.rootDir) ? path.slice(opts.rootDir.length).replace(/^[/\\]/, "") : path;
+        if (isAlwaysExcluded(rel)) return true;
+        return false;
+      },
+      // Reasonable defaults for laptop workloads.
+      awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+      atomic: true
+    });
+    for (const ev of ["add", "change", "unlink", "addDir", "unlinkDir"]) {
+      watcher.on(ev, () => scheduleScan());
+    }
+  }
+  await triggerApply();
+  scanInFlight = scanAndPush({ rootDir: opts.rootDir, client, stateDb, ignore: ignore2 }).catch((err) => {
+    console.error("tapd initial scan error:", err);
+  });
+  await scanInFlight;
+  schedulePoll();
+  return {
+    async stop() {
+      stopped = true;
+      if (pollTimer) clearTimeout(pollTimer);
+      if (scanTimer) clearTimeout(scanTimer);
+      if (sseApplyTimer) clearTimeout(sseApplyTimer);
+      if (sseSubscriber) await sseSubscriber.stop();
+      await Promise.allSettled([applyInFlight ?? Promise.resolve(), scanInFlight]);
+      if (watcher) await watcher.close();
+      stateDb.close();
+    },
+    async applyNow() {
+      const result = await triggerApply();
+      return result ?? {
+        applied: 0,
+        echoSkipped: 0,
+        errored: 0,
+        events: [],
+        errors: []
+      };
+    },
+    async scanNow() {
+      return scanAndPush({ rootDir: opts.rootDir, client, stateDb, ignore: ignore2 });
+    },
+    stateDb
+  };
+}
+
+export {
+  BINDING_CONFIG_PATH,
+  bindingConfigFile,
+  readBindingConfig,
+  writeBindingConfig,
+  NotInitializedError,
+  RelayError,
+  createBinding,
+  RelayClient,
+  openStateDb,
+  BUILTIN_IGNORE_LINES,
+  loadIgnore,
+  isAlwaysExcluded,
+  walk,
+  hashFile,
+  AlreadyInitializedError,
+  init,
+  mint,
+  list,
+  revoke,
+  AlreadyJoinedError,
+  InvalidInviteUrlError,
+  parseInviteUrl,
+  join5 as join,
+  STATE_KEY_CONFLICT_COUNT,
+  conflictSidecarPath,
+  findConflictSidecars,
+  applyOnce,
+  subscribe,
+  computeLocalDiff,
+  scanAndPush,
+  start
+};
+//# sourceMappingURL=chunk-RQC73B5Y.js.map