tradeblocks-mcp 3.0.3 → 3.3.1

package/dist/{chunk-UBUC5A66.js → chunk-4HZLVUOZ.js}

@@ -2,19 +2,19 @@ import {
   REPORTING_TRADE_COLUMN_ALIASES,
   convertTatRowToReportingTrade,
   isTatFormat
-} from "./chunk-C6LL746C.js";
+} from "./chunk-2I3S2ZLT.js";
 
 // src/sync/index.ts
 import { existsSync as existsSync2 } from "fs";
 import * as fs9 from "fs/promises";
-import * as path11 from "path";
+import * as path12 from "path";
 
 // src/db/connection.ts
 import { DuckDBInstance } from "@duckdb/node-api";
 import { execFile } from "child_process";
 import * as fs4 from "fs/promises";
 import * as os from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 import { promisify } from "util";
 
 // src/db/schemas.ts
@@ -210,13 +210,17 @@ async function ensureMarketDataTables(conn) {
 
 // src/db/parquet-writer.ts
 import * as fs from "fs/promises";
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/db/market-datasets.ts
-import * as path from "path";
+import * as path2 from "path";
 
 // src/db/data-root.ts
+import path from "path";
 var KEY = "__tradeblocks_data_root__";
+function resolveDbPath(dataRoot, kind) {
+  return path.join(dataRoot, "database", `${kind}.duckdb`);
+}
 function setDataRoot(dir) {
   globalThis[KEY] = dir;
 }
@@ -238,19 +242,19 @@ var PARTITIONED_DATASETS = {
   option_quote_minutes: "option_quote_minutes"
 };
 function resolveMarketDir(dataDir) {
-  return path.join(getDataRoot(dataDir), "market");
+  return path2.join(getDataRoot(dataDir), "market");
 }
 function resolveCanonicalMarketFile(dataDir, dataset) {
-  return path.join(resolveMarketDir(dataDir), SINGLE_FILE_DATASETS[dataset]);
+  return path2.join(resolveMarketDir(dataDir), SINGLE_FILE_DATASETS[dataset]);
 }
 function resolveCanonicalMarketPartitionDir(dataDir, dataset) {
-  return path.join(resolveMarketDir(dataDir), PARTITIONED_DATASETS[dataset]);
+  return path2.join(resolveMarketDir(dataDir), PARTITIONED_DATASETS[dataset]);
 }
 function resolveCanonicalMarketPartitionPath(dataDir, dataset, date) {
-  return path.join(resolveCanonicalMarketPartitionDir(dataDir, dataset), `date=${date}`);
+  return path2.join(resolveCanonicalMarketPartitionDir(dataDir, dataset), `date=${date}`);
 }
 function resolveCanonicalMarketPartitionFile(dataDir, dataset, date) {
-  return path.join(resolveCanonicalMarketPartitionPath(dataDir, dataset, date), "data.parquet");
+  return path2.join(resolveCanonicalMarketPartitionPath(dataDir, dataset, date), "data.parquet");
 }
 function canonicalMarketTableName(dataset) {
   return `market.${dataset}`;
@@ -278,7 +282,7 @@ var DATASETS_V3 = {
 async function writeSpotPartition(conn, args) {
   const def = DATASETS_V3.spot;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { ticker: args.ticker, date: args.date },
     // order matches def.partitionKeys
     selectQuery: args.selectQuery,
@@ -289,7 +293,7 @@ async function writeSpotPartition(conn, args) {
 async function writeChainPartition(conn, args) {
   const def = DATASETS_V3.option_chain;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: args.selectQuery,
     compression: args.compression,
@@ -300,7 +304,7 @@ async function writeQuoteMinutesPartition(conn, args) {
   const def = DATASETS_V3.option_quote_minutes;
   const sortedSelect = `SELECT * FROM (${args.selectQuery}) AS q ORDER BY q.ticker, q.time`;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: sortedSelect,
     compression: args.compression,
@@ -311,7 +315,7 @@ async function writeOiDailyPartition(conn, args) {
   const def = DATASETS_V3.option_oi_daily;
   const sortedSelect = `SELECT * FROM (${args.selectQuery}) AS q ORDER BY q.ticker`;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { underlying: args.underlying, date: args.date },
     selectQuery: sortedSelect,
     compression: args.compression,
@@ -321,7 +325,7 @@ async function writeOiDailyPartition(conn, args) {
 async function writeEnrichedTickerFile(conn, args) {
   const def = DATASETS_V3.enriched;
   return writeParquetPartition(conn, {
-    baseDir: path.join(resolveMarketDir(args.dataDir), def.subdir),
+    baseDir: path2.join(resolveMarketDir(args.dataDir), def.subdir),
     partitions: { ticker: args.ticker },
     selectQuery: args.selectQuery,
     compression: args.compression,
@@ -330,7 +334,7 @@ async function writeEnrichedTickerFile(conn, args) {
 }
 async function writeEnrichedContext(conn, args) {
   const def = DATASETS_V3.enriched_context;
-  const targetPath = path.join(resolveMarketDir(args.dataDir), def.subdir, def.filename);
+  const targetPath = path2.join(resolveMarketDir(args.dataDir), def.subdir, def.filename);
   return writeParquetAtomic(conn, {
     targetPath,
     selectQuery: args.selectQuery,
@@ -352,7 +356,7 @@ async function writeParquetAtomic(conn, opts) {
   const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   try {
     await conn.run(`CREATE TEMP TABLE "${stagingName}" AS ${selectQuery}`);
-    await fs.mkdir(path2.dirname(targetPath), { recursive: true });
+    await fs.mkdir(path3.dirname(targetPath), { recursive: true });
     await conn.run(
       `COPY "${stagingName}" TO '${tempPath}' (FORMAT PARQUET, COMPRESSION ${compression})`
     );
@@ -392,7 +396,7 @@ async function writeParquetPartition(conn, opts) {
     }
   }
   const partitionSegments = Object.entries(partitions).map(([k, v]) => `${k}=${v}`);
-  const targetPath = path2.join(opts.baseDir, ...partitionSegments, filename);
+  const targetPath = path3.join(opts.baseDir, ...partitionSegments, filename);
   return writeParquetAtomic(conn, {
     targetPath,
     selectQuery: opts.selectQuery,
@@ -402,18 +406,18 @@ async function writeParquetPartition(conn, opts) {
 
 // src/db/json-adapters.ts
 import * as fs3 from "fs/promises";
-import * as path4 from "path";
+import * as path5 from "path";
 import { z } from "zod";
 
 // src/db/json-store.ts
 import * as fs2 from "fs/promises";
-import * as path3 from "path";
+import * as path4 from "path";
 function isEnoent(err) {
   return typeof err === "object" && err !== null && err.code === "ENOENT";
 }
 async function writeJsonFile(filePath, data) {
   const tmpPath = filePath + ".tmp";
-  await fs2.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs2.mkdir(path4.dirname(filePath), { recursive: true });
   await fs2.writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
   await fs2.rename(tmpPath, filePath);
 }
@@ -442,7 +446,7 @@ async function deleteJsonFile(filePath) {
 async function listJsonFiles(dirPath, suffix = ".json") {
   try {
     const entries = await fs2.readdir(dirPath, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && e.name.endsWith(suffix)).map((e) => path3.join(dirPath, e.name)).sort();
+    return entries.filter((e) => e.isFile() && e.name.endsWith(suffix)).map((e) => path4.join(dirPath, e.name)).sort();
   } catch (err) {
     if (isEnoent(err)) {
       return [];
@@ -470,7 +474,7 @@ function jsonToProfile(json) {
   };
 }
 function profilePath(blockId, strategyName, blocksDir) {
-  return path4.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
+  return path5.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
 }
 async function upsertProfileJson(profile, blocksDir) {
   const filePath = profilePath(profile.blockId, profile.strategyName, blocksDir);
@@ -492,7 +496,7 @@ async function getProfileJson(blockId, strategyName, blocksDir) {
 }
 async function listProfilesJson(blocksDir, blockId) {
   if (blockId) {
-    const profileDir = path4.join(blocksDir, blockId, "profiles");
+    const profileDir = path5.join(blocksDir, blockId, "profiles");
     const files = await listJsonFiles(profileDir);
     const profiles2 = [];
     for (const file of files) {
@@ -532,7 +536,7 @@ function jsonToSyncMeta(json) {
   };
 }
 function syncMetaPath(blockId, blocksDir) {
-  return path4.join(blocksDir, blockId, ".sync-meta.json");
+  return path5.join(blocksDir, blockId, ".sync-meta.json");
 }
 async function getSyncMetadataJson(blockId, blocksDir) {
   const filePath = syncMetaPath(blockId, blocksDir);
@@ -570,7 +574,7 @@ function marketMetaKey(source, ticker, targetTable) {
   return `${source}|${ticker}|${targetTable}`;
 }
 function marketMetaFilePath(dataDir) {
-  return path4.join(getDataRoot(dataDir), "market-meta", "sync-metadata.json");
+  return path5.join(getDataRoot(dataDir), "market-meta", "sync-metadata.json");
 }
 async function getMarketImportMetadataJson(source, ticker, targetTable, dataDir) {
   const filePath = marketMetaFilePath(dataDir);
@@ -598,7 +602,7 @@ function flatLogKey(entry) {
   return `${entry.date}|${entry.asset_class}|${entry.underlying}`;
 }
 function flatLogFilePath(dataDir) {
-  return path4.join(getDataRoot(dataDir), "market-meta", "flat-import-log.json");
+  return path5.join(getDataRoot(dataDir), "market-meta", "flat-import-log.json");
 }
 async function getFlatImportLogJson(assetClass, underlying, from, to, dataDir) {
   const filePath = flatLogFilePath(dataDir);
@@ -636,7 +640,7 @@ var EnrichmentWatermarksSchema = z.object({
   watermarks: z.record(z.string().regex(/^[A-Z0-9._-]+$/), TickerEntrySchema)
 });
 function watermarksFilePath(dataDir) {
-  return path4.join(getDataRoot(dataDir), "market-meta", "enrichment-watermarks.json");
+  return path5.join(getDataRoot(dataDir), "market-meta", "enrichment-watermarks.json");
 }
 async function loadEnrichmentWatermarks(dataDir) {
   const raw = await readJsonFile(watermarksFilePath(dataDir));
@@ -943,7 +947,7 @@ async function deleteProfile(conn, blockId, strategyName, baseDir) {
 
 // src/db/market-views.ts
 import { existsSync, readdirSync } from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 
 // src/utils/quote-parquet-projection.ts
 var describeCache = /* @__PURE__ */ new Map();
@@ -1052,12 +1056,12 @@ function hasParquetPartitions(dir, partitionKey = "date") {
     const prefix = `${partitionKey}=`;
     return readdirSync(dir).some((entry) => {
       if (!entry.startsWith(prefix)) return false;
-      const partDir = path5.join(dir, entry);
+      const partDir = path6.join(dir, entry);
       try {
         const entries = readdirSync(partDir);
         for (const sub of entries) {
           if (sub.endsWith(".parquet")) return true;
-          const nested = path5.join(partDir, sub);
+          const nested = path6.join(partDir, sub);
           try {
             if (readdirSync(nested).some((f) => f.endsWith(".parquet"))) return true;
           } catch {
@@ -1077,14 +1081,14 @@ function hasEnrichedTickerFiles(dir) {
   try {
     return readdirSync(dir).some((entry) => {
       if (!entry.startsWith("ticker=")) return false;
-      return existsSync(path5.join(dir, entry, "data.parquet"));
+      return existsSync(path6.join(dir, entry, "data.parquet"));
     });
   } catch {
     return false;
   }
 }
 function hasEnrichedContextFile(dir) {
-  return existsSync(path5.join(dir, "context", "data.parquet"));
+  return existsSync(path6.join(dir, "context", "data.parquet"));
 }
 async function createMarketParquetViews(conn, dataDir) {
   const viewsCreated = [];
@@ -1165,7 +1169,7 @@ async function createMarketParquetViews(conn, dataDir) {
     await conn.run("DROP TABLE IF EXISTS market.option_delta_index");
   } catch {
   }
-  const spotDir = path5.join(resolveMarketDir(dataDir), "spot");
+  const spotDir = path6.join(resolveMarketDir(dataDir), "spot");
   if (hasParquetPartitions(spotDir, "ticker")) {
     try {
       await conn.run("DROP VIEW  IF EXISTS market.spot");
@@ -1187,7 +1191,7 @@ async function createMarketParquetViews(conn, dataDir) {
     }
     tablesKept.push("spot");
   }
-  const enrichedDir = path5.join(resolveMarketDir(dataDir), "enriched");
+  const enrichedDir = path6.join(resolveMarketDir(dataDir), "enriched");
   if (hasEnrichedTickerFiles(enrichedDir)) {
     try {
       await conn.run("DROP VIEW  IF EXISTS market.enriched");
@@ -1220,7 +1224,7 @@ async function createMarketParquetViews(conn, dataDir) {
     }
     await conn.run(
       `CREATE OR REPLACE VIEW market.enriched_context AS
-       SELECT * FROM read_parquet('${path5.join(enrichedDir, "context", "data.parquet")}')`
+       SELECT * FROM read_parquet('${path6.join(enrichedDir, "context", "data.parquet")}')`
     );
     viewsCreated.push("enriched_context");
   } else {
@@ -1285,7 +1289,7 @@ async function createMarketParquetViews(conn, dataDir) {
 }
 
 // src/db/json-migration.ts
-import * as path6 from "path";
+import * as path7 from "path";
 function toDate2(value) {
   if (value instanceof Date) return value;
   if (typeof value === "object" && value !== null && "micros" in value) {
@@ -1362,7 +1366,7 @@ async function migrateProfiles(conn, blocksDir) {
       createdAt: createdAt.toISOString(),
       updatedAt: updatedAt.toISOString()
     };
-    const filePath = path6.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
+    const filePath = path7.join(blocksDir, blockId, "profiles", toFileSlug(strategyName) + ".json");
     await writeJsonFile(filePath, profileJson);
   }
   return rows.length;
@@ -1395,7 +1399,7 @@ async function migrateSyncMetadata(conn, blocksDir) {
   return rows.length;
 }
 async function migrateMarketImportMetadata(conn, dataDir) {
-  const existingFile = await readJsonFile(path6.join(dataDir, "market-meta", "sync-metadata.json"));
+  const existingFile = await readJsonFile(path7.join(dataDir, "market-meta", "sync-metadata.json"));
   if (existingFile !== null) return 0;
   let rows;
   try {
@@ -1422,7 +1426,7 @@ async function migrateMarketImportMetadata(conn, dataDir) {
 }
 async function migrateFlatImportLog(conn, dataDir) {
   const existingFile = await readJsonFile(
-    path6.join(dataDir, "market-meta", "flat-import-log.json")
+    path7.join(dataDir, "market-meta", "flat-import-log.json")
   );
   if (existingFile !== null) return 0;
   let rows;
@@ -1567,7 +1571,7 @@ async function tryRecoverLockByTerminatingStaleProcess(errorMessage, dbPath, for
     return false;
   }
   const normalizedDbPath = dbPath.replace(/\\/g, "/");
-  const normalizedDbDir = path7.dirname(normalizedDbPath);
+  const normalizedDbDir = path8.dirname(normalizedDbPath);
   const isTradeblocksProcess = command.includes("tradeblocks-mcp") || command.includes("/mcp-server/server/index.js") || command.includes("packages/mcp-server/server/index.js") || command.includes("\\mcp-server\\server\\index.js") || command.includes("packages\\mcp-server\\server\\index.js");
   const normalizedCommand = command.replace(/\\/g, "/");
   const targetsSameDb = normalizedCommand.includes(normalizedDbPath) || normalizedCommand.includes(normalizedDbDir);
@@ -1601,16 +1605,16 @@ function resolveMarketDbPath(dataDir) {
   const args = process.argv;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--market-db" && args[i + 1]) {
-      return path7.resolve(args[i + 1]);
+      return path8.resolve(args[i + 1]);
     }
   }
   if (process.env.MARKET_DB_PATH) {
-    return path7.resolve(process.env.MARKET_DB_PATH);
+    return path8.resolve(process.env.MARKET_DB_PATH);
   }
-  return path7.join(dataDir, "market.duckdb");
+  return path8.join(dataDir, "market.duckdb");
 }
 async function attachMarketDb(conn, marketDbPath, mode) {
-  await fs4.mkdir(path7.dirname(marketDbPath), { recursive: true });
+  await fs4.mkdir(path8.dirname(marketDbPath), { recursive: true });
   const readOnlyClause = mode === "read_only" ? " (READ_ONLY)" : "";
   const escapedPath = marketDbPath.replace(/'/g, "''");
   try {
@@ -1657,12 +1661,12 @@ async function openReadWriteConnection(dbPath, threads, memoryLimit) {
   await ensureReportingDataTable(connection);
   await ensureMutableMarketTables(connection);
   await ensureProfilesSchema(connection);
-  const dataDir = path7.dirname(dbPath);
+  const dataDir = path8.dirname(dbPath);
   const dataRoot = getDataRoot(dataDir);
   await createMarketParquetViews(connection, dataRoot);
   await ensureMarketDataTables(connection);
   try {
-    const blocksDir = (await import("./sync-EVLKB3ZJ.js")).getBlocksDir(dataRoot);
+    const blocksDir = (await import("./sync-3UBC37VW.js")).getBlocksDir(dataRoot);
     await migrateMetadataToJson(connection, dataRoot, blocksDir);
   } catch (err) {
     console.warn(
@@ -1708,7 +1712,7 @@ async function getConnection(dataDir) {
   if (connection) {
     return connection;
   }
-  const dbPath = path7.join(dataDir, "analytics.duckdb");
+  const dbPath = path8.join(dataDir, "analytics.duckdb");
   const threads = process.env.DUCKDB_THREADS || defaultThreads();
   const memoryLimit = process.env.DUCKDB_MEMORY_LIMIT || defaultMemoryLimit();
   storedDbPath = dbPath;
@@ -1785,7 +1789,7 @@ async function closeConnection() {
 async function upgradeToReadWrite(dataDir, options) {
   if (connectionMode === "read_write" && connection) return connection;
   await closeConnection();
-  const dbPath = storedDbPath || path7.join(dataDir, "analytics.duckdb");
+  const dbPath = storedDbPath || path8.join(dataDir, "analytics.duckdb");
   const threads = storedThreads || process.env.DUCKDB_THREADS || defaultThreads();
   const memoryLimit = storedMemoryLimit || process.env.DUCKDB_MEMORY_LIMIT || defaultMemoryLimit();
   if (!storedMarketDbPath) {
@@ -1885,7 +1889,7 @@ function openMarketReadOnlyConnection(baseDir) {
 }
 async function getReadOnlyConnection(dataDir) {
   if (connection) return connection;
-  const dbPath = path7.join(dataDir, "analytics.duckdb");
+  const dbPath = path8.join(dataDir, "analytics.duckdb");
   const threads = process.env.DUCKDB_THREADS || defaultThreads();
   const memoryLimit = process.env.DUCKDB_MEMORY_LIMIT || defaultMemoryLimit();
   storedDbPath = dbPath;
@@ -1912,7 +1916,7 @@ function getCurrentConnection() {
 
 // src/sync/block-sync.ts
 import * as fs8 from "fs/promises";
-import * as path10 from "path";
+import * as path11 from "path";
 
 // src/sync/hasher.ts
 import * as crypto from "crypto";
@@ -2069,11 +2073,11 @@ function marketTickerDateKey(ticker, date) {
 
 // src/utils/block-loader.ts
 import * as fs7 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // src/utils/csv-discovery.ts
 import * as fs6 from "fs/promises";
-import * as path8 from "path";
+import * as path9 from "path";
 function parseCSVLine(line) {
   const result = [];
   let current = "";
@@ -2198,7 +2202,7 @@ async function discoverCsvFiles(folderPath) {
       if (csvFile === "tradelog.csv" || csvFile === "dailylog.csv" || csvFile === "reportinglog.csv" || csvFile === mappings.reportinglog) {
         continue;
       }
-      const csvPath = path8.join(folderPath, csvFile);
+      const csvPath = path9.join(folderPath, csvFile);
       const detectedType = await detectCsvType(csvPath);
       if (detectedType) {
         if (detectedType === "tradelog" && !mappings.tradelog) {
@@ -2394,7 +2398,7 @@ function convertToDailyLogEntry(raw, blockId) {
   }
 }
 async function loadTrades(blockPath, filename = "tradelog.csv", blockId) {
-  const tradelogPath = path9.join(blockPath, filename);
+  const tradelogPath = path10.join(blockPath, filename);
   const content = await fs7.readFile(tradelogPath, "utf-8");
   const records = parseCSV(content);
   const trades = [];
@@ -2412,7 +2416,7 @@ async function loadTrades(blockPath, filename = "tradelog.csv", blockId) {
   return trades;
 }
 async function loadDailyLogs(blockPath, blockId, filename = "dailylog.csv") {
-  const dailylogPath = path9.join(blockPath, filename);
+  const dailylogPath = path10.join(blockPath, filename);
   try {
     await fs7.access(dailylogPath);
     const content = await fs7.readFile(dailylogPath, "utf-8");
@@ -2432,10 +2436,10 @@ async function loadDailyLogs(blockPath, blockId, filename = "dailylog.csv") {
 }
 async function loadBlock(baseDir, blockId) {
   const blocksDir = resolveBlocksBaseDir(baseDir);
-  const blockPath = path9.join(blocksDir, blockId);
+  const blockPath = path10.join(blocksDir, blockId);
   const { mappings } = await discoverCsvFiles(blockPath);
   const tradelogFilename = mappings.tradelog || "tradelog.csv";
-  const tradelogPath = path9.join(blockPath, tradelogFilename);
+  const tradelogPath = path10.join(blockPath, tradelogFilename);
   try {
     await fs7.access(tradelogPath);
   } catch {
@@ -2605,7 +2609,7 @@ async function listBlocks(baseDir) {
         }
         blocks.push(info);
       } else if (!stats) {
-        const blockPath = path9.join(blocksDir, blockId);
+        const blockPath = path10.join(blocksDir, blockId);
         try {
           const { mappings } = await discoverCsvFiles(blockPath);
           if (mappings.tradelog) {
@@ -2673,10 +2677,10 @@ function convertToReportingTrade(raw) {
 }
 async function loadReportingLog(baseDir, blockId) {
   const blocksDir = resolveBlocksBaseDir(baseDir);
-  const blockPath = path9.join(blocksDir, blockId);
+  const blockPath = path10.join(blocksDir, blockId);
   const { mappings } = await discoverCsvFiles(blockPath);
   const filename = mappings.reportinglog || "reportinglog.csv";
-  const reportingLogPath = path9.join(blockPath, filename);
+  const reportingLogPath = path10.join(blockPath, filename);
   try {
     await fs7.access(reportingLogPath);
   } catch {
@@ -2773,7 +2777,7 @@ async function importCsv(baseDir, options) {
   if (!blockId) {
     throw new Error("Could not derive a valid block ID from the filename or provided name");
   }
-  const blockPath = path9.join(blocksDir, blockId);
+  const blockPath = path10.join(blocksDir, blockId);
   try {
     await fs7.access(blockPath);
     throw new Error(
@@ -2786,7 +2790,7 @@ async function importCsv(baseDir, options) {
   }
   await fs7.mkdir(blockPath, { recursive: true });
   const targetFilename = csvType === "tradelog" ? "tradelog.csv" : csvType === "dailylog" ? "dailylog.csv" : "reportinglog.csv";
-  const targetPath = path9.join(blockPath, targetFilename);
+  const targetPath = path10.join(blockPath, targetFilename);
   await fs7.copyFile(csvPath, targetPath);
   let dateRange = {
     start: null,
@@ -3032,7 +3036,7 @@ function versionedHash(hash) {
   return `${hash}:${PARSE_VERSION}`;
 }
 async function syncBlockInternal(conn, blockId, blockPath) {
-  const blocksDir = path10.dirname(blockPath);
+  const blocksDir = path11.dirname(blockPath);
   try {
     const existingMetadata = await getSyncMetadata(conn, blockId, blocksDir);
     const tradelogFilename = await findTradelogFile(blockPath);
@@ -3056,12 +3060,12 @@ async function syncBlockInternal(conn, blockId, blockPath) {
         error: "No tradelog CSV found in block"
       };
     }
-    const tradelogPath = path10.join(blockPath, tradelogFilename);
+    const tradelogPath = path11.join(blockPath, tradelogFilename);
     const tradelogHash = versionedHash(await hashFileContent(tradelogPath));
     if (existingMetadata && existingMetadata.tradelog_hash === tradelogHash) {
       const optionalLogs = await findOptionalLogFiles(blockPath);
       if (optionalLogs.reportinglog) {
-        const reportinglogPath = path10.join(blockPath, optionalLogs.reportinglog);
+        const reportinglogPath = path11.join(blockPath, optionalLogs.reportinglog);
         const reportinglogHash = versionedHash(await hashFileContent(reportinglogPath));
         if (existingMetadata.reportinglog_hash !== reportinglogHash) {
         } else {
@@ -3089,7 +3093,7 @@ async function syncBlockInternal(conn, blockId, blockPath) {
       if (optionalLogs.dailylog) {
         try {
           dailylogHash = versionedHash(
-            await hashFileContent(path10.join(blockPath, optionalLogs.dailylog))
+            await hashFileContent(path11.join(blockPath, optionalLogs.dailylog))
           );
         } catch {
         }
@@ -3097,14 +3101,14 @@ async function syncBlockInternal(conn, blockId, blockPath) {
       if (optionalLogs.reportinglog) {
         try {
           reportinglogHash = versionedHash(
-            await hashFileContent(path10.join(blockPath, optionalLogs.reportinglog))
+            await hashFileContent(path11.join(blockPath, optionalLogs.reportinglog))
           );
         } catch {
         }
       }
       await conn.run("DELETE FROM trades.reporting_data WHERE block_id = $1", [blockId]);
       if (optionalLogs.reportinglog && reportinglogHash) {
-        const reportingPath = path10.join(blockPath, optionalLogs.reportinglog);
+        const reportingPath = path11.join(blockPath, optionalLogs.reportinglog);
         const reportingContent = await fs8.readFile(reportingPath, "utf-8");
         const reportingRecords = parseCSV2(reportingContent);
         const reportingTrades = [];
@@ -3182,7 +3186,7 @@ async function detectBlockChanges(conn, baseDir) {
       continue;
     const blockId = entry.name;
     folderNames.add(blockId);
-    const blockPath = path10.join(baseDir, blockId);
+    const blockPath = path11.join(baseDir, blockId);
     if (!syncedBlockIds.has(blockId)) {
       const tradelog = await findTradelogFile(blockPath);
       if (tradelog) {
@@ -3196,7 +3200,7 @@ async function detectBlockChanges(conn, baseDir) {
       continue;
     }
     try {
-      const tradelogPath = path10.join(blockPath, tradelogFilename);
+      const tradelogPath = path11.join(blockPath, tradelogFilename);
       const currentHash = versionedHash(await hashFileContent(tradelogPath));
       const metadata = await getSyncMetadata(conn, blockId, baseDir);
       if (!metadata || metadata.tradelog_hash !== currentHash) {
@@ -3204,7 +3208,7 @@ async function detectBlockChanges(conn, baseDir) {
       } else {
         const optionalLogs = await findOptionalLogFiles(blockPath);
         if (optionalLogs.reportinglog) {
-          const reportinglogPath = path10.join(blockPath, optionalLogs.reportinglog);
+          const reportinglogPath = path11.join(blockPath, optionalLogs.reportinglog);
           const reportingHash = versionedHash(await hashFileContent(reportinglogPath));
           if (metadata.reportinglog_hash !== reportingHash) {
             toSync.push(blockId);
@@ -3246,7 +3250,7 @@ function setBlocksDir(dir) {
 }
 function getBlocksDir(baseDir) {
   if (_blocksDir) return _blocksDir;
-  const nestedBlocksDir = path11.join(baseDir, "blocks");
+  const nestedBlocksDir = path12.join(baseDir, "blocks");
   return existsSync2(nestedBlocksDir) ? nestedBlocksDir : baseDir;
 }
 async function syncAllBlocks(baseDir) {
@@ -3265,7 +3269,7 @@ async function syncAllBlocks(baseDir) {
     }
   }
   for (const blockId of toSync) {
-    const blockPath = path11.join(blocksDir, blockId);
+    const blockPath = path12.join(blocksDir, blockId);
     const result = await syncBlockInternal(conn, blockId, blockPath);
     results.push(result);
     if (result.status === "error" && result.error) {
@@ -3284,7 +3288,7 @@ async function syncAllBlocks(baseDir) {
 async function syncBlock(blockId, baseDir) {
   const conn = await getConnection(baseDir);
   const blocksDir = getBlocksDir(baseDir);
-  const blockPath = path11.join(blocksDir, blockId);
+  const blockPath = path12.join(blocksDir, blockId);
   try {
     await fs9.access(blockPath);
   } catch {
@@ -3301,6 +3305,7 @@ async function syncBlock(blockId, baseDir) {
 export {
   ensureMutableMarketTables,
   ensureMarketDataTables,
+  resolveDbPath,
   setDataRoot,
   getDataRoot,
   resetDataRoot,
@@ -3388,4 +3393,4 @@ export {
   loadReportingLog,
   importCsv
 };
-//# sourceMappingURL=chunk-UBUC5A66.js.map
+//# sourceMappingURL=chunk-4HZLVUOZ.js.map