fix(edit): keep multi-digit cell typing in the same field

R1 caret after a cell write sat on exclusive end p+w (next field start), so onSelectionChange cleared Ap and the next key jumped fields. Clamp caret to [p, p+w), treat Ap ownership as [p, p+w], and mark Ap from the planned field index instead of re-deriving it from the caret.

Author: hqyyqh

src/client/services/cardCellEditGuard.ts

@@ -176,14 +176,24 @@ export function createCardCellEditGuard(deps: CardCellEditGuardDeps) {
             return;
         }
         if (nav.mode === 'Ap') {
-            // Stay Ap while caret remains in the same field
+            // Stay Ap while caret remains in the same logical cell.
+            // R1 places caret at the right edge; exclusive end p+w is also the next
+            // field start — treat [p, p+w] inclusive so multi-digit typing does not jump.
             const card = getCardIfCellLine(editor.document, nav.line);
             if (!card) {
                 clearNav();
                 return;
             }
-            const fi = cellModel.fieldIndexAt(editor.document.lineAt(nav.line).text, card, sel.startChar);
-            if (fi !== nav.fieldIndex) clearNav();
+            const f = card[nav.fieldIndex];
+            if (!f) {
+                clearNav();
+                return;
+            }
+            const col = sel.startChar;
+            if (col >= f.p && col <= f.p + f.w) {
+                return;
+            }
+            clearNav();
             return;
         }
         // mode A: keep if still full/keep-separator on same field
@@ -217,6 +227,7 @@ export function createCardCellEditGuard(deps: CardCellEditGuardDeps) {
         newText: string;
         selStart: number;
         selEnd: number;
+        fieldIndex?: number;
         markAp?: boolean;
         markA?: { fieldIndex: number; keepSeparator: boolean };
         clearNav?: boolean;
@@ -297,6 +308,7 @@ export function createCardCellEditGuard(deps: CardCellEditGuardDeps) {
             newText: result.line,
             selStart: result.caretCol,
             selEnd: result.caretCol,
+            fieldIndex,
             markAp: true,
         };
     }

src/core/edit/cardCellModel.ts

@@ -113,18 +113,25 @@ export function writeCellR1(line: string, card: CardField[], fieldIndex: number,
 /**
  * Caret column after an R1/L1 write — after the last non-space in the cell,
  * or at field start if empty (ready to type).
+ *
+ * Always returns a column in [p, p+w) so the caret stays owned by this field.
+ * R1 values sit against the right edge; exclusive end p+w is the next field's
+ * start and must not be used (would make the next keystroke jump fields).
  */
 export function caretAfterCellValue(line: string, card: CardField[], fieldIndex: number): number {
     if (!card || fieldIndex < 0 || fieldIndex >= card.length) return 0;
     const f = card[fieldIndex];
+    if (f.w <= 0) return f.p;
     const padded = padLineToCard(line, card);
     const slice = padded.slice(f.p, f.p + f.w);
     const val = slice.trim();
     if (!val) return f.p;
     const idx = slice.lastIndexOf(val[val.length - 1]);
-    // last char of value occurrence from the right: find end of trimEnd content
+    // Exclusive end of trimEnd content relative to cell
     const end = slice.length - (slice.match(/\s*$/)?.[0].length || 0);
-    return f.p + Math.max(end, idx + 1);
+    const exclusive = f.p + Math.max(end, idx + 1);
+    // Clamp to last column of this cell (inclusive ownership for fieldIndexAt)
+    return Math.min(exclusive, f.p + f.w - 1);
 }
 
 export function fieldIndexAt(_line: string, card: CardField[], col: number): number {

src/extension.ts

@@ -4004,10 +4004,11 @@ async function handleCardCellDelete(direction) {
     } else if (plan.markA) {
         guard.markA(editor.document, plan.lineNum, plan.markA.fieldIndex, plan.markA.keepSeparator);
     } else if (plan.markAp) {
-        const card = guard.getCardIfCellLine(editor.document, plan.lineNum);
-        const fi = card
-            ? cardCellModel.fieldIndexAt(plan.newText, card, plan.selStart)
-            : (guard.getNav()?.fieldIndex ?? 0);
+        // Prefer plan.fieldIndex — caret may sit on exclusive cell end (next field start)
+        const fi =
+            typeof plan.fieldIndex === 'number' && plan.fieldIndex >= 0
+                ? plan.fieldIndex
+                : (guard.getNav()?.fieldIndex ?? 0);
         if (fi >= 0) guard.markAp(editor.document, plan.lineNum, fi);
     }
     vscode.commands.executeCommand('setContext', 'lsdyna.cellEditActive', guard.shouldCellEditActive(editor));

test/client/services/cardCellEditGuard.test.js

@@ -106,4 +106,80 @@ describe('cardCellEditGuard', () => {
             null,
         );
     });
+
+    it('multi-key type stays in same field (A then Ap append)', () => {
+        let line = buildLine('1', '12345', '67890');
+        let document = fakeDoc(['*NODE', line]);
+        const guard = createCardCellEditGuard({
+            getCardFieldsForLine: () => CARD3,
+            isLsdynaDocument: () => true,
+            isKeywordLineText: (t) => /^\s*\*/.test(t),
+            isProtectEnabled: () => true,
+        });
+        guard.markA(document, 1, 1, true);
+
+        // First key: full-cell write
+        let plan = guard.planType(
+            document,
+            { start: { line: 1, character: 11 }, end: { line: 1, character: 20 }, isEmpty: false },
+            '1',
+        );
+        assert.ok(plan);
+        assert.strictEqual(readCellValue(plan.newText, CARD3, 1), '1');
+        assert.strictEqual(plan.fieldIndex, 1);
+        line = plan.newText;
+        document = fakeDoc(['*NODE', line]);
+        document.version = 2;
+        guard.markAp(document, 1, plan.fieldIndex);
+
+        // Caret after value must remain owned by field 1
+        let caret = plan.caret;
+        assert.ok(caret >= 10 && caret < 20, `caret ${caret}`);
+
+        // Simulate selection change after edit (Ap must not clear on right-edge caret)
+        guard.onSelectionChange({
+            document,
+            selection: {
+                start: { line: 1, character: caret },
+                end: { line: 1, character: caret },
+                isEmpty: true,
+            },
+            selections: [{ start: { line: 1, character: caret }, end: { line: 1, character: caret }, isEmpty: true }],
+        });
+        assert.ok(guard.getNav(), 'Ap nav must survive selection change at value end');
+        assert.strictEqual(guard.getNav().mode, 'Ap');
+        assert.strictEqual(guard.getNav().fieldIndex, 1);
+
+        // Second / third keys: append in same field
+        for (const ch of ['2', '3']) {
+            plan = guard.planType(
+                document,
+                {
+                    start: { line: 1, character: caret },
+                    end: { line: 1, character: caret },
+                    isEmpty: true,
+                },
+                ch,
+            );
+            assert.ok(plan, `planType for '${ch}'`);
+            assert.strictEqual(plan.fieldIndex, 1);
+            line = plan.newText;
+            caret = plan.caret;
+            document = fakeDoc(['*NODE', line]);
+            document.version = (document.version || 2) + 1;
+            guard.markAp(document, 1, plan.fieldIndex);
+            guard.onSelectionChange({
+                document,
+                selection: {
+                    start: { line: 1, character: caret },
+                    end: { line: 1, character: caret },
+                    isEmpty: true,
+                },
+                selections: [{ start: { line: 1, character: caret }, end: { line: 1, character: caret }, isEmpty: true }],
+            });
+        }
+        assert.strictEqual(readCellValue(line, CARD3, 1), '123');
+        assert.strictEqual(readCellValue(line, CARD3, 2), '67890');
+        assert.strictEqual(guard.getNav().fieldIndex, 1);
+    });
 });

test/core/edit/cardCellModel.test.js

@@ -124,6 +124,23 @@ describe('cardCellModel', () => {
         });
     });
 
+    describe('caretAfterCellValue', () => {
+        it('stays inside the field (never exclusive end = next field start)', () => {
+            const line = writeCellR1(buildLine('1', 'x', '9'), CARD3, 1, '12');
+            const caret = caretAfterCellValue(line, CARD3, 1);
+            // Field 1 is [10, 20); next field starts at 20
+            assert.ok(caret >= 10 && caret < 20, `caret ${caret} must be in [10, 20)`);
+            assert.strictEqual(fieldIndexAt(line, CARD3, caret), 1);
+        });
+
+        it('full-width value still owns last column of cell', () => {
+            const line = writeCellR1(buildLine('1', 'x', '9'), CARD3, 1, '1234567890');
+            const caret = caretAfterCellValue(line, CARD3, 1);
+            assert.strictEqual(caret, 19);
+            assert.strictEqual(fieldIndexAt(line, CARD3, caret), 1);
+        });
+    });
+
     describe('in-cell edit', () => {
         it('append insert builds value with R1 (S2 path)', () => {
             let line = buildLine('1', '12345', '67890');
@@ -136,6 +153,19 @@ describe('cardCellModel', () => {
             assert.strictEqual(readCellValue(r.line, CARD3, 2), '67890');
         });
 
+        it('multi-digit append stays in same field (no jump to next)', () => {
+            let line = writeCellR1(buildLine('1', '12345', '67890'), CARD3, 1, '1');
+            for (const ch of ['2', '3', '4']) {
+                const caret = caretAfterCellValue(line, CARD3, 1);
+                assert.strictEqual(fieldIndexAt(line, CARD3, caret), 1);
+                const r = applyInCellInsert(line, CARD3, 1, caret, ch);
+                assert.ok(r);
+                line = r.line;
+            }
+            assert.strictEqual(readCellValue(line, CARD3, 1), '1234');
+            assert.strictEqual(readCellValue(line, CARD3, 2), '67890');
+        });
+
         it('backspace on Ap shortens value without eating next field', () => {
             let line = writeCellR1(buildLine('1', 'x', '9'), CARD3, 1, '12');
             const r = applyInCellDelete(