fix(safari): latin-1 origin decoding, NULL key skip, count fast-path

- Decode originEncASCII via decodeLatin1 so high-byte records preserve
  their ISO-8859-1 meaning instead of being interpreted as UTF-8.
  Matches the pattern in chromium/extract_storage.go.
- Skip ItemTable rows where key is NULL — SQLite's UNIQUE constraint
  permits multiple NULLs, and silently lowering them to empty strings
  would collide with legitimate empty-string keys.
- countLocalStorage now walks origin dirs and runs SELECT COUNT(key)
  per localstorage.sqlite3 instead of fully decoding every value.
  COUNT(key) naturally excludes NULLs, keeping count and extract
  symmetric.

Addresses Copilot review feedback on #582.

Author: moonD4rk

browser/safari/extract_storage.go

@@ -82,12 +82,43 @@ func extractLocalStorage(root string) ([]types.StorageEntry, error) {
 	return entries, nil
 }
 
+// countLocalStorage sums ItemTable row counts across every origin DB under root without
+// parsing origin files or decoding values — CountEntries callers only need the total, not the
+// URLs or plaintext. COUNT(key) naturally excludes NULL keys, matching the same skip rule
+// applied by readLocalStorageFile, so count and extract stay in sync.
 func countLocalStorage(root string) (int, error) {
-	entries, err := extractLocalStorage(root)
+	dirs, err := findOriginDataDirs(root)
 	if err != nil {
 		return 0, err
 	}
-	return len(entries), nil
+	total := 0
+	for _, od := range dirs {
+		dbPath := filepath.Join(od, webkitLocalStorageSubdir, webkitLocalStorageDB)
+		n, err := countLocalStorageFile(dbPath)
+		if err != nil {
+			log.Debugf("safari localstorage: count %s: %v", dbPath, err)
+			continue
+		}
+		total += n
+	}
+	return total, nil
+}
+
+func countLocalStorageFile(path string) (int, error) {
+	dsn := "file:" + path + "?mode=ro&immutable=1"
+	db, err := sql.Open("sqlite", dsn)
+	if err != nil {
+		return 0, fmt.Errorf("open %s: %w", path, err)
+	}
+	defer db.Close()
+	if err := db.Ping(); err != nil {
+		return 0, fmt.Errorf("ping %s: %w", path, err)
+	}
+	var count int
+	if err := db.QueryRow(`SELECT COUNT(key) FROM ItemTable`).Scan(&count); err != nil {
+		return 0, fmt.Errorf("count ItemTable: %w", err)
+	}
+	return count, nil
 }
 
 // findOriginDataDirs returns <root>/<h1>/<h2>/ paths that contain both an "origin" file and
@@ -206,14 +237,24 @@ func readOriginString(data []byte, pos int) (string, int, error) {
 	pos += length
 	switch enc {
 	case originEncASCII:
-		return string(chunk), pos, nil
+		return decodeLatin1(chunk), pos, nil
 	case originEncUTF16:
 		return decodeUTF16LE(chunk), pos, nil
 	default:
-		return string(chunk), pos, nil
+		return decodeLatin1(chunk), pos, nil
 	}
 }
 
+// decodeLatin1 converts ISO-8859-1 bytes to a valid UTF-8 Go string. Latin-1 byte values map
+// 1:1 to Unicode code points U+0000–U+00FF. Mirrors the helper in chromium/extract_storage.go.
+func decodeLatin1(b []byte) string {
+	runes := make([]rune, len(b))
+	for i, c := range b {
+		runes[i] = rune(c)
+	}
+	return string(runes)
+}
+
 func formatOriginURL(ep originEndpoint) string {
 	url := ep.scheme + "://" + ep.host
 	if ep.port != 0 {
@@ -253,6 +294,13 @@ func readLocalStorageFile(path string) ([]localStorageItem, error) {
 			log.Debugf("safari localstorage: scan row in %s: %v", path, err)
 			continue
 		}
+		if !key.Valid {
+			// NULL keys would collide with legitimate empty-string keys in the output and are
+			// not meaningful localStorage entries. The UNIQUE constraint in ItemTable still
+			// permits multiple NULL rows in SQLite, so we filter them here.
+			log.Debugf("safari localstorage: skip row with NULL key in %s", path)
+			continue
+		}
 		items = append(items, localStorageItem{
 			key:   key.String,
 			value: decodeLocalStorageValue(value),

browser/safari/extract_storage_test.go

@@ -1,13 +1,15 @@
 package safari
 
 import (
+	"database/sql"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	_ "modernc.org/sqlite"
 )
 
 // ---------------------------------------------------------------------------
@@ -35,6 +37,26 @@ func TestReadOriginBlock_NonDefaultPort(t *testing.T) {
 	assert.Equal(t, "https://example.com:8443", formatOriginURL(top))
 }
 
+func TestReadOriginBlock_Latin1HighByte(t *testing.T) {
+	// WebKit stores scheme/host records with encoding byte 0x01 = Latin-1. Verify high-byte
+	// bytes decode as Latin-1 (é = 0xE9) rather than being passed through as invalid UTF-8.
+	data := []byte{
+		0x04, 0x00, 0x00, 0x00, 0x01, 'h', 't', 't', 'p', // scheme "http"
+		0x04, 0x00, 0x00, 0x00, 0x01, 'c', 'a', 'f', 0xe9, // host "café" (Latin-1)
+		0x00, // port default
+	}
+	ep, _, err := readOriginBlock(data, 0)
+	require.NoError(t, err)
+	assert.Equal(t, "http", ep.scheme)
+	assert.Equal(t, "café", ep.host)
+}
+
+func TestDecodeLatin1(t *testing.T) {
+	assert.Equal(t, "café", decodeLatin1([]byte{'c', 'a', 'f', 0xe9}))
+	assert.Equal(t, "hello", decodeLatin1([]byte("hello")))
+	assert.Empty(t, decodeLatin1(nil))
+}
+
 func TestReadOriginFile_FramePreferred(t *testing.T) {
 	dir := t.TempDir()
 	originPath := filepath.Join(dir, "origin")
@@ -250,3 +272,46 @@ func TestCountLocalStorage_DirMissing(t *testing.T) {
 	require.Error(t, err)
 	assert.Equal(t, 0, count)
 }
+
+// ---------------------------------------------------------------------------
+// NULL-key handling — readLocalStorageFile / countLocalStorageFile both skip NULL keys,
+// keeping count and extract in sync.
+// ---------------------------------------------------------------------------
+
+func TestReadLocalStorageFile_SkipsNullKey(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "ls.sqlite3")
+	writeLocalStorageDB(t, dbPath, []testLocalStorageItem{
+		{Key: "real", Value: "keeper"},
+	}, true /*addNullKey*/)
+
+	items, err := readLocalStorageFile(dbPath)
+	require.NoError(t, err)
+	require.Len(t, items, 1)
+	assert.Equal(t, "real", items[0].key)
+	assert.Equal(t, "keeper", items[0].value)
+}
+
+func TestCountLocalStorageFile_SkipsNullKey(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "ls.sqlite3")
+	writeLocalStorageDB(t, dbPath, []testLocalStorageItem{
+		{Key: "k1", Value: "v1"},
+		{Key: "k2", Value: "v2"},
+	}, true /*addNullKey*/)
+
+	count, err := countLocalStorageFile(dbPath)
+	require.NoError(t, err)
+	assert.Equal(t, 2, count, "NULL keys are excluded from count to match extract's skip rule")
+}
+
+func TestCountLocalStorageFile_MissingTable(t *testing.T) {
+	// Real Safari has origin dirs with LocalStorage/localstorage.sqlite3 but no ItemTable yet
+	// (seen during live verification). countLocalStorageFile must surface the error so the
+	// caller can log-and-skip rather than counting 0 silently.
+	dbPath := filepath.Join(t.TempDir(), "empty.sqlite3")
+	db, err := sql.Open("sqlite", dbPath)
+	require.NoError(t, err)
+	require.NoError(t, db.Close())
+
+	_, err = countLocalStorageFile(dbPath)
+	require.Error(t, err)
+}

browser/safari/testutil_test.go

@@ -230,6 +230,34 @@ func splitTestOriginURL(u string) (scheme, host string, port uint16) {
 	return scheme, rest, 0
 }
 
+// writeLocalStorageDB creates a minimal localstorage.sqlite3 at path with ItemTable populated
+// from items. When addNullKey is true, a NULL-key row is inserted first to exercise the
+// skip-NULL-key logic in readLocalStorageFile / countLocalStorageFile. This is a direct-DB
+// variant of buildTestLocalStorageDir — use it when the test targets one DB, not the full
+// Origins nesting.
+func writeLocalStorageDB(t *testing.T, path string, items []testLocalStorageItem, addNullKey bool) {
+	t.Helper()
+	db, err := sql.Open("sqlite", path)
+	require.NoError(t, err)
+	_, err = db.Exec(`CREATE TABLE ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL)`)
+	require.NoError(t, err)
+	if addNullKey {
+		_, err = db.Exec(
+			`INSERT INTO ItemTable (key, value) VALUES (NULL, ?)`,
+			encodeUTF16LE("null-key-sentinel"),
+		)
+		require.NoError(t, err)
+	}
+	for _, item := range items {
+		_, err = db.Exec(
+			`INSERT INTO ItemTable (key, value) VALUES (?, ?)`,
+			item.Key, encodeUTF16LE(item.Value),
+		)
+		require.NoError(t, err)
+	}
+	require.NoError(t, db.Close())
+}
+
 // encodeUTF16LE is the inverse of extract_storage.go's decodeUTF16LE — it mirrors
 // the WebKit encoding so test fixtures round-trip through the extractor.
 func encodeUTF16LE(s string) []byte {