fix(tables): keep the final row when sniffing a complete CSV

detectCsvDelimiter always trimmed to the last newline, so a complete file with
no trailing newline lost its final data row from scoring — leaving the header
alone and letting a header-widening separator beat the real one. It now takes a
`complete` flag: the trim runs only for truncated prefixes, where a mid-record
cut must be dropped. The stream sniffer passes it from `exhausted`, and the
buffered callers (client preview, parseFileRows) pass it when the sample covers
the whole file.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/tables/components/import-csv-dialog/import-csv-dialog.tsx

@@ -127,9 +127,12 @@ async function parseCsvPreview(file: File, fallbackDelimiter: CsvDelimiter) {
     const lastNewline = bytes.lastIndexOf(0x0a)
     if (lastNewline > 0) bytes = bytes.subarray(0, lastNewline + 1)
   }
+  // The sniff sample is the whole file only when nothing was sliced off and it fits the window;
+  // otherwise it's a truncated prefix whose last line may be partial.
   const delimiter = await detectCsvDelimiter(
     bytes.subarray(0, CSV_DELIMITER_SNIFF_BYTES),
-    fallbackDelimiter
+    fallbackDelimiter,
+    { complete: !sliced && bytes.length <= CSV_DELIMITER_SNIFF_BYTES }
   )
   return parseCsvBuffer(bytes, delimiter)
 }

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

@@ -48,8 +48,12 @@ 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))
-  const delimiter = await detectCsvDelimiter(sample, fallback)
+  // `exhausted` means the whole file fit in the window, so its last row must count even
+  // without a trailing newline; otherwise the sample is a prefix and its tail may be partial.
+  const capped = Math.min(size, CSV_DELIMITER_SNIFF_BYTES)
+  const sample = Buffer.concat(chunks, capped)
+  const complete = exhausted && size <= CSV_DELIMITER_SNIFF_BYTES
+  const delimiter = await detectCsvDelimiter(sample, fallback, { complete })
 
   const stream = Readable.from(
     (async function* replay() {

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

@@ -426,6 +426,15 @@ describe('import', () => {
       expect(await detectCsvDelimiter('a;b;c\n1;2;3\n4;5;')).toBe(';')
     })
 
+    it('keeps the final row of a complete file that has no trailing newline', async () => {
+      // Without complete:true the trim would drop the only distinguishing data row, leaving the
+      // header alone and letting comma (which merely widens the header) win over semicolon.
+      const csv = 'a,b;c,d;e,f\n1;2;3'
+      expect(await detectCsvDelimiter(csv, ',', { complete: true })).toBe(';')
+      // A truncated prefix (complete:false, the default) still drops the partial tail.
+      expect(await detectCsvDelimiter(csv)).toBe(',')
+    })
+
     it('returns the fallback for empty input', async () => {
       expect(await detectCsvDelimiter('', ';')).toBe(';')
     })
@@ -456,6 +465,15 @@ describe('import', () => {
       expect((await collect(stream)).equals(full)).toBe(true)
     })
 
+    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.
+      const full = Buffer.from('a,b;c,d;e,f\n1;2;3')
+      const { delimiter, stream } = await sniffCsvDelimiterFromStream(Readable.from([full]))
+      expect(delimiter).toBe(';')
+      expect((await collect(stream)).equals(full)).toBe(true)
+    })
+
     it('detects and replays exactly when a single chunk far exceeds the sniff window', async () => {
       // One >1 MiB chunk arrives before the size check — detection must still cap its copy
       // and the replay must emit the original bytes unchanged.

apps/sim/lib/table/import.ts

@@ -127,20 +127,24 @@ export function decodeCsvText(input: Buffer | Uint8Array | string): string {
  * produce a valid table.
  *
  * All callers funnel through here, so the sample is prepared identically for
- * every import path: a possibly-partial trailing line (from slicing a fixed byte
- * window out of a larger file) is dropped before parsing so a mid-record cut
- * can't skew the counts.
+ * every import path: when the sample is a prefix sliced out of a larger file, a
+ * possibly-partial trailing line is dropped before parsing so a mid-record cut
+ * can't skew the counts. Pass `complete: true` when the sample is the entire file
+ * (nothing was sliced off) so a final row with no trailing newline still counts —
+ * dropping it would silently discard the only distinguishing data row of a tiny
+ * file and let a header-widening separator win.
  */
 export async function detectCsvDelimiter(
   input: Buffer | Uint8Array | string,
-  fallback: CsvDelimiter = ','
+  fallback: CsvDelimiter = ',',
+  { complete = false }: { complete?: boolean } = {}
 ): Promise<CsvDelimiter> {
   const { parse } = await import('csv-parse/sync')
   const decoded = decodeCsvText(input)
-  // Drop a partial final line when the sample is a prefix of a larger file; keep the
-  // whole thing when it's a single line (no newline) so a tiny full file still parses.
+  // Drop a partial final line only when the sample is a truncated prefix; keep every row when
+  // the sample is the whole file (or a single line) so a trailing-newline-less last row counts.
   const lastNewline = decoded.lastIndexOf('\n')
-  const text = lastNewline > 0 ? decoded.slice(0, lastNewline + 1) : decoded
+  const text = !complete && lastNewline > 0 ? decoded.slice(0, lastNewline + 1) : decoded
   if (text.trim() === '') return fallback
 
   let best: { delimiter: CsvDelimiter; fields: number; score: number } | null = null
@@ -648,7 +652,8 @@ export async function parseFileRows(
   if (ext === 'csv' || ext === 'tsv' || contentType === 'text/csv') {
     const delimiter = await detectCsvDelimiter(
       buffer.subarray(0, CSV_DELIMITER_SNIFF_BYTES),
-      ext === 'tsv' ? '\t' : ','
+      ext === 'tsv' ? '\t' : ',',
+      { complete: buffer.length <= CSV_DELIMITER_SNIFF_BYTES }
     )
     return parseCsvBuffer(buffer, delimiter)
   }