tradeblocks-mcp 3.4.0 → 3.5.0

package/dist/{chunk-TMCRS75V.js → chunk-5HBZ3TZM.js}

@@ -918,6 +918,35 @@ async function exactFileAddress(filePath) {
     await opened.handle.close();
   }
 }
+async function snapshotOpenFile(source, snapshotPath) {
+  const snapshot = await fs2.open(snapshotPath, "wx", 256);
+  const hash = createHash2("sha256");
+  let bytes = 0;
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  try {
+    while (true) {
+      const read = await source.read(buffer, 0, buffer.byteLength, bytes);
+      if (read.bytesRead === 0) break;
+      hash.update(buffer.subarray(0, read.bytesRead));
+      let written = 0;
+      while (written < read.bytesRead) {
+        const result = await snapshot.write(
+          buffer,
+          written,
+          read.bytesRead - written,
+          bytes + written
+        );
+        if (result.bytesWritten === 0) throw new Error("Unable to write inspection snapshot");
+        written += result.bytesWritten;
+      }
+      bytes += read.bytesRead;
+    }
+    await snapshot.sync();
+  } finally {
+    await snapshot.close();
+  }
+  return { address: `sha256:${hash.digest("hex")}`, bytes };
+}
 function sameCommitContent(previous, input) {
   return previous.schemaRevision === input.schemaRevision && previous.relativePath === input.relativePath && addressCanonicalJson(previous.coverage) === addressCanonicalJson(input.coverage) && addressCanonicalJson(previous.quality) === addressCanonicalJson(input.quality) && previous.file.address === input.file.address && previous.file.bytes === input.file.bytes && previous.file.rows === input.file.rows;
 }
@@ -1482,28 +1511,67 @@ var FilePartitionCommitStore = class {
    * identity, coverage, row-count, and exact-byte inspection.
    */
   async [INTERNAL_HISTORICAL_PARTITION_ADOPTION](conn, identity) {
-    const captured = JSON.parse(canonicalJsonBytes(identity).toString("utf8"));
-    validateIdentity(captured);
+    const captured = captureIdentity(identity);
     const definition = canonicalPartitionDataset(captured.dataset);
     const relativePath = canonicalRelativePath(captured);
     const targetPath = path3.resolve(this.targetPath(relativePath));
-    const before = await exactFileAddress(targetPath);
-    const inspected = await inspectCanonicalParquet(conn, targetPath, captured);
-    const after = await exactFileAddress(targetPath);
-    if (before.address !== after.address || before.bytes !== after.bytes) {
-      throw new PartitionFileIntegrityError(
-        targetPath,
-        "existing Parquet changed during semantic inspection"
-      );
-    }
-    return this.adoptExistingFileCommit({
-      dataset: captured.dataset,
-      partition: captured.partition,
-      schemaRevision: definition.schemaRevision,
-      relativePath,
-      coverage: inspected.coverage,
-      quality: { inputRows: inspected.rows, writtenRows: inspected.rows, droppedRows: 0 },
-      file: { ...after, rows: inspected.rows }
+    return this.withPartitionLock(captured, async () => {
+      const realMarketRoot = await this.validateMarketRoot();
+      const validatedTargetPath = await this.validatedTargetPath(relativePath, realMarketRoot);
+      if (validatedTargetPath !== targetPath) {
+        throw new PartitionFileIntegrityError(
+          validatedTargetPath,
+          "validated target differs from the registered path"
+        );
+      }
+      const opened = await openRegularFileNoFollow(targetPath);
+      const snapshotRoot = path3.join(this.provenanceRootDir, "inspection-snapshots");
+      await this.ensureDurableDirectory(snapshotRoot);
+      const snapshotDir = await fs2.mkdtemp(path3.join(snapshotRoot, "adopt-"));
+      const snapshotPath = path3.join(snapshotDir, "partition.parquet");
+      try {
+        const snapshotFingerprint = await snapshotOpenFile(opened.handle, snapshotPath);
+        const snapshotObserved = await exactFileAddress(snapshotPath);
+        if (snapshotObserved.address !== snapshotFingerprint.address || snapshotObserved.bytes !== snapshotFingerprint.bytes) {
+          throw new PartitionFileIntegrityError(
+            snapshotPath,
+            "inspection snapshot bytes disagree with the pinned canonical inode"
+          );
+        }
+        await partitionCommitTestFaults.get(this)?.("historical-after-snapshot");
+        const inspected = await inspectCanonicalParquet(conn, snapshotPath, captured);
+        const snapshotAfter = await exactFileAddress(snapshotPath);
+        if (snapshotAfter.address !== snapshotFingerprint.address || snapshotAfter.bytes !== snapshotFingerprint.bytes) {
+          throw new PartitionFileIntegrityError(
+            snapshotPath,
+            "inspection snapshot changed during semantic inspection"
+          );
+        }
+        const canonicalAfter = await exactOpenFileAddress(opened.handle);
+        const afterStat = await opened.handle.stat();
+        if (!afterStat.isFile() || afterStat.nlink !== 1 || !sameInode(opened.stat, afterStat) || canonicalAfter.address !== snapshotFingerprint.address || canonicalAfter.bytes !== snapshotFingerprint.bytes) {
+          throw new PartitionFileIntegrityError(
+            targetPath,
+            "canonical inode changed during historical semantic inspection"
+          );
+        }
+        await requireNamedRegularInode(targetPath, opened.stat);
+        return this.adoptExistingFileCommit(
+          {
+            dataset: captured.dataset,
+            partition: captured.partition,
+            schemaRevision: definition.schemaRevision,
+            relativePath,
+            coverage: inspected.coverage,
+            quality: { inputRows: inspected.rows, writtenRows: inspected.rows, droppedRows: 0 },
+            file: { ...snapshotFingerprint, rows: inspected.rows }
+          },
+          true
+        );
+      } finally {
+        await opened.handle.close();
+        await fs2.rm(snapshotDir, { recursive: true });
+      }
     });
   }
   /**
@@ -1512,11 +1580,11 @@ var FilePartitionCommitStore = class {
    * existing regular inode under the partition lock, then appends authority
    * only when the caller-supplied rows/coverage/fingerprint agree exactly.
    */
-  async adoptExistingFileCommit(input) {
+  async adoptExistingFileCommit(input, lockHeld = false) {
     const captured = captureInput(input);
     const targetPath = path3.resolve(this.targetPath(captured.relativePath));
     const realMarketRoot = await this.validateMarketRoot();
-    return this.withPartitionLock(captured, async () => {
+    const adopt = async () => {
       const validatedTargetPath = await this.validatedTargetPath(
         captured.relativePath,
         realMarketRoot
@@ -1609,7 +1677,8 @@ var FilePartitionCommitStore = class {
       } finally {
         await handle.close();
       }
-    });
+    };
+    return lockHeld ? adopt() : this.withPartitionLock(captured, adopt);
   }
   async publishFileCommit(input) {
     const captured = captureInput(input);
@@ -3538,7 +3607,7 @@ async function openReadWriteConnection(dbPath, threads, memoryLimit) {
   await createMarketParquetViews(connection, dataRoot);
   await ensureMarketDataTables(connection);
   try {
-    const blocksDir = (await import("./sync-4Y4BSU6S.js")).getBlocksDir(dataRoot);
+    const blocksDir = (await import("./sync-AWI764HE.js")).getBlocksDir(dataRoot);
     await migrateMetadataToJson(connection, dataRoot, blocksDir);
   } catch (err) {
     console.warn(
@@ -5338,4 +5407,4 @@ export {
   loadReportingLog,
   importCsv
 };
-//# sourceMappingURL=chunk-TMCRS75V.js.map
+//# sourceMappingURL=chunk-5HBZ3TZM.js.map