@@ -201,7 +201,7 @@ private function streamAndMerge(string $table, array $key, array $hashCols): arr
         $hashExpr = $this->buildHashExpression($hashCols);
         $pkCols   = $this->quoteCols($key);
         $pkSelect = implode(', ', $pkCols);
-        $orderBy  = implode(', ', $pkCols);
+        [$orderBy, $numeric] = $this->keyOrder($table, $key);
         $q        = $this->tableName($table);
 
         $srcPdo  = $this->source->getPdo();
@@ -239,7 +239,7 @@ private function streamAndMerge(string $table, array $key, array $hashCols): arr
                     $insertPKs[] = Arr::only($srcRow, $key);
                     $srcRow = $src->fetch();
                 } else {
-                    $cmp = $this->comparePK($srcRow, $tgtRow, $key);
+                    $cmp = $this->comparePK($srcRow, $tgtRow, $key, $numeric);
                     if ($cmp < 0) {
                         $insertPKs[] = Arr::only($srcRow, $key);
                         $srcRow = $src->fetch();
@@ -333,25 +333,115 @@ public function buildHashExpression(array $columns): string
 
     /**
      * Compare two PK tuples for merge-sort ordering.
-     * Returns < 0 if $a < $b, 0 if equal, > 0 if $a > $b.
+     *
+     * Must order keys exactly as the hash query's ORDER BY does, or the merge
+     * falls out of step and reports rows both sides have as an insert and a
+     * delete. `$numeric` names the key columns compared as numbers (see
+     * keyOrder()); every other column compares byte by byte. Without it, a
+     * value that looks numeric is compared as a number — fine for an integer
+     * key, wrong for a text key holding '9' and '10'.
+     *
+     * @param string[]|null $numeric
      */
-    public function comparePK(array $a, array $b, array $key): int
+    public function comparePK(array $a, array $b, array $key, ?array $numeric = null): int
     {
         foreach ($key as $col) {
             $av = $a[$col] ?? '';
             $bv = $b[$col] ?? '';
-            if (is_numeric($av) && is_numeric($bv)) {
-                $cmp = $av <=> $bv;
-            } else {
-                $cmp = strcmp((string) $av, (string) $bv);
-            }
+            $asNumber = $numeric === null ? is_numeric($av) && is_numeric($bv) : in_array($col, $numeric, true);
+            $cmp = $asNumber ? $av <=> $bv : strcmp((string) $av, (string) $bv);
             if ($cmp !== 0) {
                 return $cmp;
             }
         }
         return 0;
     }
 
+    /**
+     * The hash query's ORDER BY, and which key columns comparePK() treats as
+     * numbers — chosen together so the database and the merge agree.
+     *
+     * A numeric key sorts natively and compares as a number. Anything else
+     * sorts by the bytes of its text, which is what strcmp() compares: under
+     * a linguistic collation (en_US, utf8mb4_0900_ai_ci) the database puts
+     * 'a' before 'B' where strcmp() puts 'B' first. A uuid keeps its native
+     * order, which is already its hex text's, so its index still serves.
+     *
+     * @return array{0: string, 1: string[]}
+     */
+    private function keyOrder(string $table, array $key): array
+    {
+        $kinds   = $this->keyKinds($table, $key);
+        $numeric = [];
+        $terms   = [];
+        foreach ($key as $col) {
+            $quoted = $this->quoteIdentifier($col);
+            $kind   = $kinds[$col] ?? 'text';
+            if ($kind === 'number') {
+                $numeric[] = $col;
+                $terms[]   = $quoted;
+            } elseif ($kind === 'uuid') {
+                $terms[] = $quoted;
+            } else {
+                $terms[] = match ($this->driver) {
+                    'pgsql'  => "({$quoted})::text COLLATE \"C\"",
+                    'mysql'  => "CAST({$quoted} AS BINARY)",
+                    default  => "CAST({$quoted} AS TEXT) COLLATE BINARY",
+                };
+            }
+        }
+        return [implode(', ', $terms), $numeric];
+    }
+
+    /**
+     * 'number', 'uuid' or 'text' for each key column, from the source's
+     * catalog. A column it cannot classify is 'text', the order that is
+     * always consistent with strcmp().
+     *
+     * @return array<string, string>
+     */
+    private function keyKinds(string $table, array $key): array
+    {
+        $kinds = [];
+        try {
+            if ($this->driver === 'pgsql') {
+                $rows = $this->source->select(
+                    "SELECT a.attname AS name, t.typcategory AS category, t.typname AS type
+                       FROM pg_attribute a
+                       JOIN pg_type d ON d.oid = a.atttypid
+                       -- A domain sorts as its base type.
+                       JOIN pg_type t ON t.oid = CASE WHEN d.typtype = 'd' THEN d.typbasetype ELSE d.oid END
+                      WHERE a.attrelid = to_regclass(?) AND a.attnum > 0 AND NOT a.attisdropped",
+                    [$this->tableName($table)]
+                );
+                foreach ($rows as $row) {
+                    $row = (array) $row;
+                    $kinds[$row['name']] = $row['category'] === 'N' ? 'number' : ($row['type'] === 'uuid' ? 'uuid' : 'text');
+                }
+            } elseif ($this->driver === 'mysql') {
+                $rows = $this->source->select(
+                    'SELECT COLUMN_NAME AS name, DATA_TYPE AS type FROM information_schema.COLUMNS
+                      WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?',
+                    [$table]
+                );
+                $numberTypes = ['tinyint', 'smallint', 'mediumint', 'int', 'integer', 'bigint', 'decimal', 'numeric', 'float', 'double', 'real', 'year'];
+                foreach ($rows as $row) {
+                    $row = array_change_key_case((array) $row, CASE_LOWER);
+                    $kinds[$row['name']] = in_array(strtolower($row['type']), $numberTypes, true) ? 'number' : 'text';
+                }
+            } else {
+                foreach ($this->source->select('PRAGMA table_info(' . $this->quoteIdentifier($table) . ')') as $row) {
+                    $row = (array) $row;
+                    // SQLite's own affinity rules: a declared type naming INT, REAL, FLOA, DOUB, NUM or DEC.
+                    $kinds[$row['name']] = preg_match('/INT|REAL|FLOA|DOUB|NUM|DEC/i', (string) $row['type']) ? 'number' : 'text';
+                }
+            }
+        } catch (\Throwable $e) {
+            Logger::info("Could not read key column types for `$table`; ordering keys as text: " . $e->getMessage());
+        }
+        return array_intersect_key($kinds, array_flip($key));
+    }
+
     /**
      * Fetch full rows for a batch of PKs, ordered by PK for deterministic output.
      *
 
@@ -439,6 +439,39 @@ public function testComparePKComposite(): void
         $this->assertEquals(0, $merge->comparePK(['a' => '1', 'b' => '1'], ['a' => '1', 'b' => '1'], ['a', 'b']));
     }
 
+    /**
+     * A text key holding numbers sorts as text in the database ('10' before
+     * '9'). The merge compared any numeric-looking pair as numbers, fell out
+     * of step, and reported rows both sides have as a delete and an insert.
+     */
+    public function testATextKeyHoldingNumbersIsMatchedAsText(): void
+    {
+        $ddl = 'CREATE TABLE t (code TEXT PRIMARY KEY, v INTEGER)';
+        $src = $this->createConnection('txtnum_src', $ddl, ["INSERT INTO t VALUES ('10', 1), ('9', 2), ('a', 3)"]);
+        $tgt = $this->createConnection('txtnum_tgt', $ddl, ["INSERT INTO t VALUES ('9', 2), ('a', 3)"]);
+
+        $diffs = (new StreamingMergeDiff($src, $tgt, 'sqlite'))->getDiff('t', ['code'], ['code', 'v'], ['code', 'v']);
+
+        $this->assertCount(1, $diffs, 'only the row the target lacks');
+        $this->assertInstanceOf(InsertData::class, $diffs[0]);
+        $this->assertSame('10', (string) $diffs[0]->diff['keys']['code']);
+    }
+
+    public function testComparePKFollowsTheKeyTypeWhenGiven(): void
+    {
+        $merge = new StreamingMergeDiff(
+            $this->createConnection('pkt_src', 'CREATE TABLE t (id TEXT PRIMARY KEY)'),
+            $this->createConnection('pkt_tgt', 'CREATE TABLE t (id TEXT PRIMARY KEY)'),
+            'sqlite'
+        );
+
+        // A text key compares byte by byte, as the database sorts it…
+        $this->assertLessThan(0, $merge->comparePK(['id' => '10'], ['id' => '9'], ['id'], []));
+        $this->assertLessThan(0, $merge->comparePK(['id' => 'B'], ['id' => 'a'], ['id'], []));
+        // …a numeric one as a number.
+        $this->assertGreaterThan(0, $merge->comparePK(['id' => '10'], ['id' => '9'], ['id'], ['id']));
+    }
+
     // ── Test: buildHashExpression generates valid SQL ──────────────────────
 
     public function testBuildHashExpressionSQLite(): void
 
@@ -154,6 +154,54 @@ public function testMemoryDoesNotGrowWithTheTable(string $driver): void
         $this->assertLessThan(25, $grew, sprintf('peak memory grew %.1f MB over %d rows a side', $grew, $rows));
     }
 
+    /**
+     * The merge walks both tables in key order, so its comparison must agree
+     * with the server's ORDER BY. A text key under a linguistic collation
+     * (PostgreSQL's en_US, MySQL's utf8mb4_0900_ai_ci) sorts 'a' before 'B',
+     * where a byte comparison puts 'B' first, and '10' sorts before '9' as
+     * text but after it as a number. Either way the merge fell out of step and
+     * reported rows both sides have as a DELETE and an INSERT — harmless to
+     * the row, but an ON DELETE CASCADE child went with it.
+     *
+     * @dataProvider drivers
+     */
+    public function testTextKeysAreMatchedHoweverTheServerSortsThem(string $driver): void
+    {
+        $this->server($driver);
+        $collate = '';
+        if ($driver === 'pgsql') {
+            // The database default may be C, which sorts as bytes and hides the bug.
+            $icu = $this->admin->query("SELECT 1 FROM pg_collation WHERE collname = 'und-x-icu'")->fetchColumn();
+            $collate = $icu ? ' COLLATE "und-x-icu"' : '';
+        }
+        $type = $driver === 'pgsql' ? "text$collate" : 'varchar(20)';
+        $conns = [];
+        foreach (['s' => "('a',1),('B',2),('c',3),('9',4),('10',5),('apple',6),('Cherry',7),('e',8),('f',9)",
+                  't' => "('B',2),('c',3),('9',4),('Cherry',70),('e',8),('f',9),('zz',10)"] as $side => $rows) {
+            $db = "dbdiff_sm_text_{$side}";
+            $this->driver === 'pgsql'
+                ? $this->admin->exec("DROP DATABASE IF EXISTS $db WITH (FORCE)")
+                : $this->admin->exec("DROP DATABASE IF EXISTS `$db`");
+            $this->admin->exec($this->driver === 'pgsql' ? "CREATE DATABASE $db" : "CREATE DATABASE `$db`");
+            $this->created[] = $db;
+            $this->capsule->addConnection($this->config + ['database' => $db], $db);
+            $conn = $this->capsule->getConnection($db);
+            $conn->unprepared("CREATE TABLE t (code $type PRIMARY KEY, v int); INSERT INTO t VALUES $rows;");
+            $conns[] = $conn;
+        }
+
+        $diffs = (new StreamingMergeDiff($conns[0], $conns[1], $driver))->getDiff('t', ['code'], ['code', 'v'], ['code', 'v']);
+        $keys = function (string $class) use ($diffs): array {
+            $k = array_map(fn($d) => (string) $d->diff['keys']['code'], array_filter($diffs, fn($d) => $d instanceof $class));
+            sort($k);
+            return array_values($k);
+        };
+
+        $this->assertSame(['10', 'a', 'apple'], $keys(InsertData::class), 'rows only the source has');
+        $this->assertSame(['zz'], $keys(DeleteData::class), 'rows only the target has');
+        $this->assertSame(['Cherry'], $keys(UpdateData::class), 'rows that differ');
+    }
+
     // ── helpers ──────────────────────────────────────────────────────────────
 
     private function merge(Connection $src, Connection $tgt): array