fix(tables): observe EOF at the exact sniff-window boundary

The stream sniffer's read loop stopped as soon as the buffered size reached the
sniff window, so a file whose size is exactly the window never triggered the
extra read that observes end-of-stream — it was judged a truncated prefix and
dropped its final newline-less row, disagreeing with the buffered callers (which
mark that size complete). Read while size <= window so the boundary case sees EOF
and `exhausted` (hence `complete`) is set correctly. Regression test added.

Author: waleedlatif1

apps/sim/lib/table/csv-delimiter-stream.ts

@@ -35,7 +35,11 @@ export async function sniffCsvDelimiterFromStream(
   let size = 0
   let exhausted = false
 
-  while (size < CSV_DELIMITER_SNIFF_BYTES) {
+  // Read until the buffered size *exceeds* the window (not just reaches it) or the stream ends.
+  // The `<=` is deliberate: a file whose size is exactly the window must still trigger one more
+  // read so EOF is observed and `exhausted` becomes true — otherwise it would be misjudged as a
+  // truncated prefix and disagree with the buffered callers (which pass complete for that size).
+  while (size <= CSV_DELIMITER_SNIFF_BYTES) {
     const next = await reader.next()
     if (next.done) {
       exhausted = true
@@ -49,9 +53,9 @@ export async function sniffCsvDelimiterFromStream(
   // Copy at most the sniff window for detection — `Buffer.concat`'s length arg truncates,
   // so an oversized final chunk can't inflate this allocation past CSV_DELIMITER_SNIFF_BYTES.
   const sample = Buffer.concat(chunks, Math.min(size, CSV_DELIMITER_SNIFF_BYTES))
-  // `exhausted` (the loop stopped on end-of-stream, never on the size cap) means the whole file
-  // fit in the window, so its last row must count even without a trailing newline. Otherwise the
-  // sample is a truncated prefix whose final line may be partial and should be dropped.
+  // `exhausted` (the loop stopped on end-of-stream, never on exceeding the window) means the whole
+  // file fit in the window, so its last row must count even without a trailing newline. Otherwise
+  // the sample is a truncated prefix whose final line may be partial and should be dropped.
   const delimiter = await detectCsvDelimiter(sample, fallback, { complete: exhausted })
 
   const stream = Readable.from(

apps/sim/lib/table/import.test.ts

@@ -6,6 +6,7 @@ import { describe, expect, it } from 'vitest'
 import { sniffCsvDelimiterFromStream } from '@/lib/table/csv-delimiter-stream'
 import {
   buildAutoMapping,
+  CSV_DELIMITER_SNIFF_BYTES,
   CsvImportValidationError,
   coerceRowsForTable,
   coerceValue,
@@ -465,6 +466,21 @@ describe('import', () => {
       expect((await collect(stream)).equals(full)).toBe(true)
     })
 
+    it('treats a file exactly the sniff-window size as complete (observes EOF at the boundary)', async () => {
+      // Header widens under comma; a single giant data row pads the file to exactly the window
+      // with no trailing newline. If the loop stopped at the boundary without seeing EOF, the row
+      // would be dropped and comma would win — so this passing proves the boundary EOF is observed.
+      const header = 'a,b;c,d;e,f\n'
+      const suffix = ';3'
+      const pad = 'x'.repeat(
+        CSV_DELIMITER_SNIFF_BYTES - header.length - '1;'.length - suffix.length
+      )
+      const full = Buffer.from(`${header}1;${pad}${suffix}`)
+      expect(full.length).toBe(CSV_DELIMITER_SNIFF_BYTES)
+      const { delimiter } = await sniffCsvDelimiterFromStream(Readable.from([full]))
+      expect(delimiter).toBe(';')
+    })
+
     it('counts the final row of a fully-buffered file with no trailing newline', async () => {
       // The whole file fits the sniff window (exhausted), so complete:true flows through and the
       // last row is scored — semicolon must win despite comma widening the header row.