@hasna/economy 0.2.25 → 0.2.27

package/dist/index.js

@@ -1037,9 +1037,7 @@ function queryAgentBreakdown(db, period = "all") {
   }
   return [...groups.values()].sort((a, b) => b.api_equivalent_usd - a.api_equivalent_usd);
 }
-function labelForPath(projectPath, projectName) {
-  if (projectName && projectName.trim() !== "")
-    return projectName;
+function pathProjectLabel(projectPath) {
   if (!projectPath)
     return "";
   const segments = projectPath.split("/").filter(Boolean);
@@ -1048,12 +1046,45 @@ function labelForPath(projectPath, projectName) {
     if (projectPrefix.test(seg))
       return seg;
   }
-  const generic = new Set(["web", "app", "apps", "packages", "src", "lib", "server", "client", "api", "frontend", "backend"]);
+  const generic = new Set([
+    "web",
+    "app",
+    "apps",
+    "packages",
+    "src",
+    "lib",
+    "server",
+    "client",
+    "api",
+    "frontend",
+    "backend",
+    "home",
+    "users",
+    "workspace",
+    "workspaces",
+    "hasna"
+  ]);
   for (let i = segments.length - 1;i >= 0; i--) {
     if (!generic.has(segments[i].toLowerCase()))
       return segments[i];
   }
-  return segments[segments.length - 1] ?? projectPath;
+  return null;
+}
+function isRepoLikeLabel(label) {
+  return /^(open|skill|hook|service|connect|platform|agent|tool|iapp|project|scaffold|capp)-/.test(label) || label.includes("-");
+}
+function labelForPath(projectPath, projectName) {
+  const pathLabel = pathProjectLabel(projectPath);
+  if (pathLabel && (!projectName || projectName.trim() === "" || isRepoLikeLabel(pathLabel)))
+    return pathLabel;
+  if (projectName && projectName.trim() !== "")
+    return projectName;
+  if (pathLabel)
+    return pathLabel;
+  return projectPath;
+}
+function groupKeyForPath(projectPath, projectName) {
+  return labelForPath(projectPath, projectName).trim().toLowerCase();
 }
 function queryProjectBreakdown(db, period = "all") {
   const requestWhere = requestPeriodWhere(period);
@@ -1068,14 +1099,15 @@ function queryProjectBreakdown(db, period = "all") {
     const label = labelForPath(s.project_path, s.project_name);
     if (!label)
       continue;
-    const g = groups.get(label) ?? { sessionIds: [], samplePath: s.project_path };
+    const key = groupKeyForPath(s.project_path, s.project_name);
+    const g = groups.get(key) ?? { label, sessionIds: [], samplePath: s.project_path };
     g.sessionIds.push(s.id);
     if (!g.samplePath)
       g.samplePath = s.project_path;
-    groups.set(label, g);
+    groups.set(key, g);
   }
   const result = [];
-  for (const [label, g] of groups.entries()) {
+  for (const g of groups.values()) {
     const placeholders = g.sessionIds.map(() => "?").join(",");
     const reqStats = placeholders.length ? db.prepare(`
           SELECT
@@ -1106,7 +1138,7 @@ function queryProjectBreakdown(db, period = "all") {
     const lastActive = [reqStats.last_active, sessionOnlyStats.last_active].filter(Boolean).sort().at(-1) ?? "";
     result.push({
       project_path: g.samplePath,
-      project_name: label,
+      project_name: g.label,
       sessions: totalSessions,
       requests: reqStats.requests + sessionOnlyStats.requests,
       total_tokens: reqStats.total_tokens + sessionOnlyStats.total_tokens,
@@ -1438,17 +1470,21 @@ function listMachineRegistry(db) {
 }
 function dedupeRequests(db) {
   const dupes = db.prepare(`
-    SELECT source_request_id, agent, MIN(id) as keep_id, COUNT(*) as cnt
+    SELECT source_request_id, agent, COALESCE(machine_id, '') as machine_id, MIN(id) as keep_id, COUNT(*) as cnt
     FROM requests
     WHERE source_request_id != '' AND source_request_id IS NOT NULL
-    GROUP BY source_request_id, agent
+    GROUP BY source_request_id, agent, COALESCE(machine_id, '')
     HAVING cnt > 1
   `).all();
   let removed = 0;
   for (const row of dupes) {
     const result = db.prepare(`
-      DELETE FROM requests WHERE source_request_id = ? AND agent = ? AND id != ?
-    `).run(row.source_request_id, row.agent, row.keep_id);
+      DELETE FROM requests
+      WHERE source_request_id = ?
+        AND agent = ?
+        AND COALESCE(machine_id, '') = ?
+        AND id != ?
+    `).run(row.source_request_id, row.agent, row.machine_id, row.keep_id);
     removed += result.changes;
   }
   return removed;
@@ -1731,10 +1767,303 @@ async function syncOpenProjectsRegistry(db, listActiveProjects) {
   }
   return { imported, skipped };
 }
+// src/lib/peer-sync.ts
+init_database();
+import { Database as BunDatabase } from "bun:sqlite";
+import { existsSync as existsSync3 } from "fs";
+
+// src/lib/package-metadata.ts
+import { readFileSync as readFileSync2 } from "fs";
+var cachedMetadata = null;
+function getPackageMetadata() {
+  if (cachedMetadata)
+    return cachedMetadata;
+  const raw = readFileSync2(new URL("../../package.json", import.meta.url), "utf8");
+  const parsed = JSON.parse(raw);
+  cachedMetadata = {
+    name: parsed.name ?? "@hasna/economy",
+    version: parsed.version ?? "0.0.0"
+  };
+  return cachedMetadata;
+}
+var packageMetadata = getPackageMetadata();
+
+// src/lib/peer-sync.ts
+var GENERIC_PEER_TABLES = [
+  "usage_snapshots",
+  "subscriptions",
+  "billing_daily",
+  "savings_daily",
+  "budgets",
+  "goals",
+  "model_pricing",
+  "machines"
+];
+function quoteIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function tableExists(db, table) {
+  const row = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(table);
+  return Boolean(row);
+}
+function tableColumns(db, table) {
+  if (!tableExists(db, table))
+    return [];
+  return db.prepare(`PRAGMA table_info(${quoteIdent(table)})`).all();
+}
+function commonColumns(source, target, table) {
+  const sourceCols = new Set(tableColumns(source, table).map((c) => c.name));
+  return tableColumns(target, table).map((c) => c.name).filter((c) => sourceCols.has(c));
+}
+function primaryKeyColumns(db, table) {
+  return tableColumns(db, table).filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk).map((c) => c.name);
+}
+function selectRows(source, table, columns) {
+  if (columns.length === 0)
+    return [];
+  const select = columns.map(quoteIdent).join(", ");
+  return source.prepare(`SELECT ${select} FROM ${quoteIdent(table)}`).all();
+}
+function rowByKey(target, table, keyColumns, row) {
+  if (keyColumns.length === 0)
+    return null;
+  if (keyColumns.some((c) => row[c] == null))
+    return null;
+  const where = keyColumns.map((c) => `${quoteIdent(c)} = ?`).join(" AND ");
+  return target.prepare(`SELECT * FROM ${quoteIdent(table)} WHERE ${where}`).get(...keyColumns.map((c) => row[c]));
+}
+function hasId(target, table, id) {
+  return target.prepare(`SELECT id, machine_id FROM ${quoteIdent(table)} WHERE id = ?`).get(id);
+}
+function shouldReplace(source, existing) {
+  if (!existing)
+    return true;
+  const sourceUpdated = source["updated_at"];
+  const existingUpdated = existing["updated_at"];
+  if (typeof sourceUpdated === "string" && typeof existingUpdated === "string" && existingUpdated !== "") {
+    return sourceUpdated >= existingUpdated;
+  }
+  return true;
+}
+function normalizeRow(row, columns, sourceMachine, now) {
+  const next = { ...row };
+  if (columns.includes("machine_id") && (!next["machine_id"] || next["machine_id"] === "")) {
+    next["machine_id"] = sourceMachine;
+  }
+  if (columns.includes("updated_at") && (!next["updated_at"] || next["updated_at"] === "")) {
+    next["updated_at"] = next["timestamp"] ?? next["started_at"] ?? next["created_at"] ?? now;
+  }
+  if (columns.includes("synced_at") && next["synced_at"] == null)
+    next["synced_at"] = "";
+  if (columns.includes("attribution_tag") && next["attribution_tag"] == null)
+    next["attribution_tag"] = "";
+  return next;
+}
+function insertOrReplace(target, table, columns, row) {
+  const colSql = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  target.prepare(`
+    INSERT OR REPLACE INTO ${quoteIdent(table)} (${colSql})
+    VALUES (${placeholders})
+  `).run(...columns.map((c) => row[c] ?? null));
+}
+function collisionId(target, table, machine, originalId) {
+  const base = `${machine || "peer"}:${originalId}`;
+  const baseRow = hasId(target, table, base);
+  if (!baseRow || String(baseRow["machine_id"] ?? "") === machine)
+    return base;
+  for (let i = 2;; i++) {
+    const candidate = `${base}:${i}`;
+    const row = hasId(target, table, candidate);
+    if (!row || String(row["machine_id"] ?? "") === machine)
+      return candidate;
+  }
+}
+function mergeIdentityTable(target, source, table, sourceMachine, now, sessionIdMap) {
+  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
+  const columns = commonColumns(source, target, table);
+  const rows = selectRows(source, table, columns);
+  const idMap = new Map;
+  for (const raw of rows) {
+    const row = normalizeRow(raw, columns, sourceMachine, now);
+    const originalId = String(row["id"] ?? "");
+    if (!originalId) {
+      stats.skipped++;
+      continue;
+    }
+    const machine = String(row["machine_id"] ?? "");
+    const directExisting = hasId(target, table, originalId);
+    if (directExisting && String(directExisting["machine_id"] ?? "") !== machine) {
+      row["id"] = collisionId(target, table, machine, originalId);
+      stats.collisions++;
+    }
+    if (table === "requests" && sessionIdMap) {
+      const originalSessionId = String(row["session_id"] ?? "");
+      row["session_id"] = sessionIdMap.get(originalSessionId) ?? originalSessionId;
+    }
+    const existing = hasId(target, table, String(row["id"]));
+    idMap.set(originalId, String(row["id"]));
+    if (existing && !shouldReplace(row, existing)) {
+      stats.skipped++;
+      continue;
+    }
+    insertOrReplace(target, table, columns, row);
+    if (existing)
+      stats.updated++;
+    else
+      stats.inserted++;
+  }
+  return { stats, idMap };
+}
+function mergeProjects(target, source) {
+  const table = "projects";
+  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
+  const columns = commonColumns(source, target, table);
+  const rows = selectRows(source, table, columns);
+  for (const raw of rows) {
+    const row = { ...raw };
+    const path = String(row["path"] ?? "");
+    const id = String(row["id"] ?? "");
+    if (!path || !id) {
+      stats.skipped++;
+      continue;
+    }
+    const existingByPath = target.prepare(`SELECT * FROM projects WHERE path = ?`).get(path);
+    if (existingByPath) {
+      row["id"] = existingByPath["id"] ?? id;
+      insertOrReplace(target, table, columns, row);
+      stats.updated++;
+      continue;
+    }
+    const existingById = target.prepare(`SELECT * FROM projects WHERE id = ?`).get(id);
+    if (existingById && String(existingById["path"] ?? "") !== path) {
+      row["id"] = `peer:${id}`;
+      stats.collisions++;
+      while (target.prepare(`SELECT id FROM projects WHERE id = ?`).get(row["id"])) {
+        row["id"] = `peer:${String(row["id"])}`;
+      }
+    }
+    insertOrReplace(target, table, columns, row);
+    stats.inserted++;
+  }
+  return stats;
+}
+function mergeGenericTable(target, source, table, sourceMachine, now) {
+  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
+  const columns = commonColumns(source, target, table);
+  const keyColumns = primaryKeyColumns(target, table).filter((c) => columns.includes(c));
+  const rows = selectRows(source, table, columns);
+  for (const raw of rows) {
+    const row = normalizeRow(raw, columns, sourceMachine, now);
+    const existing = rowByKey(target, table, keyColumns, row);
+    if (existing && !shouldReplace(row, existing)) {
+      stats.skipped++;
+      continue;
+    }
+    insertOrReplace(target, table, columns, row);
+    if (existing)
+      stats.updated++;
+    else
+      stats.inserted++;
+  }
+  return stats;
+}
+function detectSourceMachine(source, fallback) {
+  if (fallback && fallback.trim())
+    return fallback.trim();
+  const counts = new Map;
+  for (const table of ["sessions", "requests", "usage_snapshots"]) {
+    if (!tableExists(source, table))
+      continue;
+    const rows = source.prepare(`
+      SELECT machine_id, COUNT(*) as cnt
+      FROM ${quoteIdent(table)}
+      WHERE machine_id != '' AND machine_id IS NOT NULL
+      GROUP BY machine_id
+    `).all();
+    for (const row of rows) {
+      counts.set(row.machine_id, (counts.get(row.machine_id) ?? 0) + row.cnt);
+    }
+  }
+  let best = "";
+  let bestCount = -1;
+  for (const [machine, count] of counts.entries()) {
+    if (count > bestCount) {
+      best = machine;
+      bestCount = count;
+    }
+  }
+  return best || "peer";
+}
+function ensureMachineRegistry(target, machine, now) {
+  if (!machine)
+    return;
+  target.prepare(`
+    INSERT INTO machines (machine_id, hostname, last_seen_at, last_push_at, last_pull_at, economy_version, updated_at)
+    VALUES (?, ?, ?, NULL, ?, ?, ?)
+    ON CONFLICT(machine_id) DO UPDATE SET
+      hostname = COALESCE(NULLIF(machines.hostname, ''), excluded.hostname),
+      last_seen_at = CASE
+        WHEN machines.last_seen_at IS NULL OR machines.last_seen_at < excluded.last_seen_at THEN excluded.last_seen_at
+        ELSE machines.last_seen_at
+      END,
+      last_pull_at = excluded.last_pull_at,
+      economy_version = excluded.economy_version,
+      updated_at = excluded.updated_at
+  `).run(machine, machine, now, now, packageMetadata.version, now);
+}
+function openSourceDatabase(path) {
+  try {
+    return new BunDatabase(path, { readonly: true });
+  } catch {
+    return new BunDatabase(path);
+  }
+}
+function mergePeerDatabase(target, sourcePath, opts = {}) {
+  if (!existsSync3(sourcePath))
+    throw new Error(`source database does not exist: ${sourcePath}`);
+  const source = openSourceDatabase(sourcePath);
+  const now = opts.now ?? new Date().toISOString();
+  const sourceMachine = detectSourceMachine(source, opts.sourceMachine);
+  const tables = [];
+  try {
+    target.exec("PRAGMA foreign_keys = OFF");
+    target.exec("BEGIN IMMEDIATE");
+    try {
+      tables.push(mergeProjects(target, source));
+      const sessionMerge = mergeIdentityTable(target, source, "sessions", sourceMachine, now);
+      tables.push(sessionMerge.stats);
+      tables.push(mergeIdentityTable(target, source, "requests", sourceMachine, now, sessionMerge.idMap).stats);
+      for (const table of GENERIC_PEER_TABLES) {
+        tables.push(mergeGenericTable(target, source, table, sourceMachine, now));
+      }
+      ensureMachineRegistry(target, sourceMachine, now);
+      target.exec("COMMIT");
+    } catch (err) {
+      target.exec("ROLLBACK");
+      throw err;
+    } finally {
+      target.exec("PRAGMA foreign_keys = ON");
+    }
+  } finally {
+    source.close();
+  }
+  const deduped = dedupeRequests(target);
+  const rowsWritten = tables.reduce((sum, table) => sum + table.inserted + table.updated, 0);
+  const collisions = tables.reduce((sum, table) => sum + table.collisions, 0);
+  return {
+    source_path: sourcePath,
+    source_machine: sourceMachine,
+    rows_written: rowsWritten,
+    collisions,
+    deduped,
+    tables: tables.filter((t) => t.inserted || t.updated || t.skipped || t.collisions)
+  };
+}
 // src/ingest/claude.ts
 init_database();
 init_pricing();
-import { readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join3, basename } from "path";
 
@@ -1903,7 +2232,7 @@ async function ingestTakumi(db, verbose = false, projectsDir = TAKUMI_PROJECTS_D
   return ingestJsonlProjects(db, projectsDir, "takumi", verbose);
 }
 async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false) {
-  if (!existsSync3(projectsDir)) {
+  if (!existsSync4(projectsDir)) {
     if (verbose)
       console.log(`${agentName} projects dir not found:`, projectsDir);
     return { files: 0, requests: 0, sessions: 0 };
@@ -1932,7 +2261,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
         continue;
       let lines;
       try {
-        lines = readFileSync2(filePath, "utf-8").split(`
+        lines = readFileSync3(filePath, "utf-8").split(`
 `).filter((l) => l.trim());
       } catch {
         continue;
@@ -2051,10 +2380,10 @@ function supportsClaudeDataResidencyPricing(model) {
 // src/ingest/codex.ts
 init_database();
 init_pricing();
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4, basename as basename2 } from "path";
-import { Database as BunDatabase } from "bun:sqlite";
+import { Database as BunDatabase2 } from "bun:sqlite";
 var DEFAULT_CODEX_DB_PATH = join4(homedir3(), ".codex", "state_5.sqlite");
 var DEFAULT_CODEX_CONFIG_PATH = join4(homedir3(), ".codex", "config.toml");
 var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
@@ -2066,10 +2395,10 @@ function codexConfigPath() {
 }
 function readCodexModel() {
   const configPath = codexConfigPath();
-  if (!existsSync4(configPath))
+  if (!existsSync5(configPath))
     return "gpt-5-codex";
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     const match = content.match(/^model\s*=\s*"([^"]+)"/m);
     return match?.[1] ?? "gpt-5-codex";
   } catch {
@@ -2087,13 +2416,32 @@ function buildThreadQuery(codexDb) {
     FROM threads WHERE tokens_used > 0
   `;
 }
+function openCodexDb(dbPath, verbose) {
+  let lastError;
+  for (const readonly of [true, false]) {
+    let codexDb = null;
+    try {
+      codexDb = readonly ? new BunDatabase2(dbPath, { readonly: true }) : new BunDatabase2(dbPath);
+      codexDb.prepare("PRAGMA schema_version").get();
+      return codexDb;
+    } catch (error) {
+      lastError = error;
+      codexDb?.close();
+    }
+  }
+  if (verbose) {
+    const message = lastError instanceof Error ? lastError.message : String(lastError);
+    console.log("Codex DB unreadable:", dbPath, message);
+  }
+  return null;
+}
 function readTokenEvents(rolloutPath) {
-  if (!rolloutPath || !existsSync4(rolloutPath))
+  if (!rolloutPath || !existsSync5(rolloutPath))
     return [];
   const fallbackUsages = new Map;
   let fallbackTimestamp;
   let aggregate = null;
-  for (const line of readFileSync3(rolloutPath, "utf-8").split(`
+  for (const line of readFileSync4(rolloutPath, "utf-8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -2165,7 +2513,7 @@ function fallbackEvents(totalTokens) {
 }
 async function ingestCodex(db, verbose = false) {
   const dbPath = codexDbPath();
-  if (!existsSync4(dbPath)) {
+  if (!existsSync5(dbPath)) {
     if (verbose)
       console.log("Codex DB not found:", dbPath);
     return { sessions: 0, requests: 0 };
@@ -2176,7 +2524,9 @@ async function ingestCodex(db, verbose = false) {
   let requests = 0;
   const account = await resolveAccountForAgent("codex");
   try {
-    codexDb = new BunDatabase(dbPath, { readonly: true });
+    codexDb = openCodexDb(dbPath, verbose);
+    if (!codexDb)
+      return { sessions: 0, requests: 0 };
     const threads = codexDb.prepare(buildThreadQuery(codexDb)).all();
     for (const thread of threads) {
       const model = thread.model ?? readCodexModel();
@@ -2246,7 +2596,7 @@ async function ingestCodex(db, verbose = false) {
 // src/ingest/gemini.ts
 init_database();
 init_pricing();
-import { readdirSync as readdirSync3, readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, existsSync as existsSync6, statSync as statSync3 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join5, basename as basename3 } from "path";
 var DEFAULT_GEMINI_TMP_DIR = join5(homedir4(), ".gemini", "tmp");
@@ -2267,7 +2617,7 @@ function numberField(...values) {
 function listProjectDirs(...roots) {
   const dirs = new Set;
   for (const root of roots) {
-    if (!existsSync5(root))
+    if (!existsSync6(root))
       continue;
     try {
       for (const entry of readdirSync3(root, { withFileTypes: true })) {
@@ -2285,15 +2635,15 @@ function projectRoot(projectDir, chatData) {
     return chatData.project_path;
   const rootFile = join5(projectDir, ".project_root");
   try {
-    if (existsSync5(rootFile))
-      return readFileSync4(rootFile, "utf-8").trim();
+    if (existsSync6(rootFile))
+      return readFileSync5(rootFile, "utf-8").trim();
   } catch {}
   return "";
 }
 async function ingestGemini(db, verbose) {
   const tmpDir = geminiTmpDir();
   const historyDir = geminiHistoryDir();
-  if (!existsSync5(tmpDir) && !existsSync5(historyDir)) {
+  if (!existsSync6(tmpDir) && !existsSync6(historyDir)) {
     if (verbose)
       console.log("Gemini tmp/history dirs not found:", tmpDir, historyDir);
     return { sessions: 0, requests: 0 };
@@ -2306,7 +2656,7 @@ async function ingestGemini(db, verbose) {
   const projectDirs = listProjectDirs(tmpDir, historyDir);
   for (const projectDir of projectDirs) {
     const chatsDir = join5(projectDir, "chats");
-    if (!existsSync5(chatsDir))
+    if (!existsSync6(chatsDir))
       continue;
     let chatFiles = [];
     try {
@@ -2327,7 +2677,7 @@ async function ingestGemini(db, verbose) {
         continue;
       let chatData;
       try {
-        chatData = JSON.parse(readFileSync4(filePath, "utf-8"));
+        chatData = JSON.parse(readFileSync5(filePath, "utf-8"));
       } catch {
         continue;
       }
@@ -2430,6 +2780,7 @@ export {
   queryAccountBreakdown,
   openDatabase,
   normalizeModelName,
+  mergePeerDatabase,
   listSubscriptions,
   listProjects,
   listModelPricing,

package/dist/ingest/codex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/ingest/codex.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AA6C7D,iBAAS,cAAc,IAAI,MAAM,CAUhC;AAoFD,wBAAsB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA4FhH;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/ingest/codex.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AA6C7D,iBAAS,cAAc,IAAI,MAAM,CAUhC;AAwGD,wBAAsB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,UAAQ,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CA8FhH;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/lib/peer-sync.d.ts

@@ -0,0 +1,21 @@
+import type { SqliteAdapter as Database } from '@hasna/cloud';
+export interface PeerTableMergeStats {
+    table: string;
+    inserted: number;
+    updated: number;
+    skipped: number;
+    collisions: number;
+}
+export interface PeerMergeResult {
+    source_path: string;
+    source_machine: string;
+    rows_written: number;
+    collisions: number;
+    deduped: number;
+    tables: PeerTableMergeStats[];
+}
+export declare function mergePeerDatabase(target: Database, sourcePath: string, opts?: {
+    sourceMachine?: string;
+    now?: string;
+}): PeerMergeResult;
+//# sourceMappingURL=peer-sync.d.ts.map

package/dist/lib/peer-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer-sync.d.ts","sourceRoot":"","sources":["../../src/lib/peer-sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAA;AAc7D,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,mBAAmB,EAAE,CAAA;CAC9B;AAwQD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,QAAQ,EAChB,UAAU,EAAE,MAAM,EAClB,IAAI,GAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAClD,eAAe,CA0CjB"}