fix(tables): restore by orderKey, not position, under fractional flag

A saved position is the gappy column value, but under the flag insert reads
position as a visual rank (OFFSET) — so position-based restore misplaces rows.

- create-row redo now goes through the batch path carrying the saved orderKey
  (the single-insert API has no orderKey field); drop the now-unused single
  create mutation.
- resolveBatchInsertOrderKeys appends under the flag instead of feeding gappy
  positions to resolveInsertOrderKey; positions remain the flag-off path.

Author: TheodoreSpeaks

apps/sim/hooks/use-table-undo.ts

@@ -5,7 +5,6 @@ import {
   useAddTableColumn,
   useBatchCreateTableRows,
   useBatchUpdateTableRows,
-  useCreateTableRow,
   useDeleteColumn,
   useDeleteTableRow,
   useDeleteTableRows,
@@ -56,7 +55,6 @@ export function useTableUndo({
   const canRedo = useTableUndoStore((s) => (s.stacks[tableId]?.redo.length ?? 0) > 0)
 
   const updateRowMutation = useUpdateTableRow({ workspaceId, tableId })
-  const createRowMutation = useCreateTableRow({ workspaceId, tableId })
   const batchCreateRowsMutation = useBatchCreateTableRows({ workspaceId, tableId })
   const batchUpdateRowsMutation = useBatchUpdateTableRows({ workspaceId, tableId })
   const deleteRowMutation = useDeleteTableRow({ workspaceId, tableId })
@@ -137,11 +135,18 @@ export function useTableUndo({
             if (direction === 'undo') {
               deleteRowMutation.mutate(action.rowId)
             } else {
-              createRowMutation.mutate(
-                { data: action.data ?? {}, position: action.position },
+              // Redo via the batch path so the saved orderKey restores exact placement.
+              // The single-insert API has no orderKey field, and under the fractional-ordering
+              // flag its `position` is read as a rank — a gappy saved position misplaces.
+              batchCreateRowsMutation.mutate(
+                {
+                  rows: [action.data ?? {}],
+                  positions: [action.position],
+                  orderKeys: action.orderKey ? [action.orderKey] : undefined,
+                },
                 {
                   onSuccess: (response) => {
-                    const newRowId = extractCreatedRowId(response as Record<string, unknown>)
+                    const newRowId = response?.data?.rows?.[0]?.id
                     if (newRowId && newRowId !== action.rowId) {
                       patchUndoRowId(tableId, action.rowId, newRowId)
                     }

apps/sim/lib/table/service.ts

@@ -1307,14 +1307,21 @@ async function resolveInsertByNeighbor(
  * appends a contiguous run after the current max key. With explicit `positions`
  * (undo restore), keys each row between its pre-shift position neighbors —
  * correct because requested positions are distinct. Caller holds the lock.
+ *
+ * The explicit-`positions` path is meaningful only when `position` is
+ * authoritative (flag off): with the flag on, a saved `position` is a gappy
+ * column value, not a visual rank, so feeding it to {@link resolveInsertOrderKey}
+ * (which reads `position` as an `OFFSET` rank under the flag) would mint keys at
+ * the wrong ranks. Callers needing exact placement under the flag pass
+ * `orderKeys` (handled before this function); here we just append a run.
  */
 async function resolveBatchInsertOrderKeys(
   trx: DbTransaction,
   tableId: string,
   count: number,
   positions?: number[]
 ): Promise<string[]> {
-  if (!positions || positions.length === 0) {
+  if (!positions || positions.length === 0 || isTablesFractionalOrderingEnabled) {
     return nKeysBetween(await maxOrderKey(trx, tableId), null, count)
   }
   const keys: string[] = []