From d9cfc05367c7c32daf914d866e2a903fae0cc92e Mon Sep 17 00:00:00 2001
From: Dennis Decoene <DDecoene@users.noreply.github.com>
Date: Sun, 12 Jul 2026 11:13:23 +0200
Subject: [PATCH 1/4] =?UTF-8?q?feat(#59):=20field-bound=20@=20SAY=20GET=20?=
 =?UTF-8?q?=E2=80=94=20fields=20shadow=20memvars,=20rowid=20captured=20at?=
 =?UTF-8?q?=20GET?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/interpreter/Executor.ts    |  35 ++++++++++-
 src/shared/types.ts            |   9 +++
 tests/FormFieldBinding.test.ts | 107 +++++++++++++++++++++++++++++++++
 tests/Session.test.ts          |  28 ++++-----
 4 files changed, 163 insertions(+), 16 deletions(-)
 create mode 100644 tests/FormFieldBinding.test.ts

diff --git a/src/interpreter/Executor.ts b/src/interpreter/Executor.ts
index fdac08d..f15283a 100644
--- a/src/interpreter/Executor.ts
+++ b/src/interpreter/Executor.ts
@@ -557,8 +557,39 @@ export class Executor implements IndexCommandsHost {
     const row = Number(this.evalExpr(rowE));
     const col = Number(this.evalExpr(colE));
     const text = String(this.evalExpr(textE));
-    this.pendingForm.push({ row, col, label: text, varName });
-    return { output: [] };
+    const out: OutputLine[] = [];
+
+    // Field binding: a GET whose name matches a column of the active table edits
+    // the current record (dBASE III behavior — fields shadow memory variables;
+    // this is why the m_ prefix convention exists). Capturing the rowid here means
+    // form-submit writes by rowid, like grid-edit — pointer motion between here
+    // and submit cannot retarget the write.
+    if (this.area.table) {
+      const cols = await this.db.getStructure(this.area.table);
+      const match = cols.find(c => c.name.toUpperCase() === varName.toUpperCase());
+      if (match) {
+        const cur = await this.fetchCurrentRow();
+        if (!cur) throw new Error(`GET ${match.name}: no current record`);
+        const field: FormField = {
+          row, col, label: text, varName: match.name,
+          target: {
+            kind: 'field', column: match.name, table: this.area.table,
+            db: this.area.db ?? '', rowid: Number(cur._rowid),
+          },
+          value: String(cur[match.name] ?? ''),
+        };
+        const info = this.columnMetaStore?.getColumnType(this.metaDb, this.area.table, match.name);
+        if (info?.lookup) {
+          const options = await resolveLookup(this.db, info.lookup);
+          if (options) field.options = options;
+          else out.push({ text: `** Warning: lookup for ${match.name} could not be resolved — free entry`, cls: 'warn' });
+        }
+        this.pendingForm.push(field);
+        return { output: out };
+      }
+    }
+    this.pendingForm.push({ row, col, label: text, varName, target: { kind: 'var' }, value: '' });
+    return { output: out };
   }
 
   private doRead(): ExecResult {
diff --git a/src/shared/types.ts b/src/shared/types.ts
index 9801959..ed458f0 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -13,7 +13,16 @@ export interface FormField {
   row: number;
   col: number;
   label: string;
+  /** The submit key. For a field-bound GET this is the column name. */
   varName: string;
+  /** What form-submit writes. Absent (legacy INPUT/@SAY paths) means 'var'. */
+  target?:
+    | { kind: 'var' }
+    | { kind: 'field'; column: string; table: string; db: string; rowid: number };
+  /** Prefill. Field GETs carry the record's value; var GETs stay '' (unchanged UX). */
+  value?: string;
+  /** Resolved lookup options — render a <select>. Absent = free text. */
+  options?: import('./cellValidation').LookupOption[];
 }
 
 export interface OutputLine {
diff --git a/tests/FormFieldBinding.test.ts b/tests/FormFieldBinding.test.ts
new file mode 100644
index 0000000..10a2cbb
--- /dev/null
+++ b/tests/FormFieldBinding.test.ts
@@ -0,0 +1,107 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { Session } from '../server/Session';
+import type { ServerMessage } from '../src/shared/types';
+import fs from 'fs';
+import path from 'path';
+
+let dbCounter = 0;
+function uniqueDb() { return `test_formbind_${Date.now()}_${++dbCounter}`; }
+
+afterEach(() => {
+  const dataDir = path.join(process.cwd(), 'data');
+  if (fs.existsSync(dataDir)) {
+    fs.readdirSync(dataDir)
+      .filter(f => f.toLowerCase().startsWith('test_formbind_'))
+      .forEach(f => fs.unlinkSync(path.join(dataDir, f)));
+  }
+});
+
+async function setup() {
+  const sent: ServerMessage[] = [];
+  const session = new Session((m) => sent.push(m));
+  const run = async (text: string) => {
+    sent.length = 0;
+    await session.handleMessage({ type: 'command', text });
+    const out = sent.filter(m => m.type === 'output') as any[];
+    return out.flatMap(o => o.lines).map((l: any) => l.text).join('\n');
+  };
+  await run(`USE DATABASE ${uniqueDb()}`);
+  await run('CREATE TABLE EMPLOYEES (EMPID CHAR(4), NAME CHAR(30), SCHEDID CHAR(4) LOOKUP ("S001","S002"))');
+  await run('USE EMPLOYEES');
+  return { session, sent, run };
+}
+
+/** Run a multi-line block as one command (the terminal sends blocks whole). */
+async function runBlock(session: Session, sent: ServerMessage[], src: string) {
+  sent.length = 0;
+  await session.handleMessage({ type: 'command', text: src });
+}
+
+describe('field-bound @ SAY GET', () => {
+  it('binds a GET whose name matches a column: field target, prefill, options', async () => {
+    const { session, sent, run } = await setup();
+    await run('APPEND RECORD');
+    await run('REPLACE EMPID WITH "E001", NAME WITH "Ada", SCHEDID WITH "S001"');
+
+    await runBlock(session, sent, '@ 4, 5 SAY "Name: " GET NAME\n@ 5, 5 SAY "Sched: " GET SCHEDID\nREAD');
+    const form = sent.find(m => m.type === 'form-open') as any;
+    expect(form).toBeDefined();
+    const nameField = form.fields.find((f: any) => f.varName === 'NAME');
+    expect(nameField.target.kind).toBe('field');
+    expect(nameField.target.column).toBe('NAME');
+    expect(typeof nameField.target.rowid).toBe('number');
+    expect(nameField.value).toBe('Ada');
+    const schedField = form.fields.find((f: any) => f.varName === 'SCHEDID');
+    expect(schedField.options).toEqual([
+      { value: 'S001', label: 'S001' },
+      { value: 'S002', label: 'S002' },
+    ]);
+    expect(schedField.value).toBe('S001');
+  });
+
+  it('fields shadow memory variables: an existing var of the same name loses', async () => {
+    const { session, sent, run } = await setup();
+    await run('APPEND RECORD');
+    await run('STORE "not-the-field" TO NAME');
+    await runBlock(session, sent, '@ 4, 5 SAY "Name: " GET NAME\nREAD');
+    const form = sent.find(m => m.type === 'form-open') as any;
+    expect(form.fields[0].target.kind).toBe('field');
+  });
+
+  it('falls back to a memory variable when no column matches', async () => {
+    const { session, sent, run } = await setup();
+    await run('APPEND RECORD');
+    await runBlock(session, sent, '@ 4, 5 SAY "Id: " GET M_EMP\nREAD');
+    const form = sent.find(m => m.type === 'form-open') as any;
+    expect(form.fields[0].target.kind).toBe('var');
+    expect(form.fields[0].value).toBe('');
+  });
+
+  it('is a variable GET when no table is in use', async () => {
+    const sent: ServerMessage[] = [];
+    const session = new Session((m) => sent.push(m));
+    await session.handleMessage({ type: 'command', text: '@ 4, 5 SAY "X: " GET WHATEVER\nREAD' });
+    const form = sent.find(m => m.type === 'form-open') as any;
+    expect(form.fields[0].target.kind).toBe('var');
+  });
+
+  it('errors on a field-bound GET with no current record', async () => {
+    const { session, sent } = await setup();  // table is empty
+    await runBlock(session, sent, '@ 4, 5 SAY "Name: " GET NAME\nREAD');
+    const out = sent.filter(m => m.type === 'output') as any[];
+    expect(out.flatMap(o => o.lines).map((l: any) => l.text).join('\n'))
+      .toMatch(/GET NAME: no current record/);
+    expect(sent.find(m => m.type === 'form-open')).toBeUndefined();
+  });
+
+  it('degrades a dead lookup on a field GET: no options, warn line, form still opens', async () => {
+    const { session, sent, run } = await setup();
+    await run('ALTER TABLE EMPLOYEES ADD BADCOL CHAR LOOKUP GHOST.X');
+    await run('APPEND RECORD');
+    await runBlock(session, sent, '@ 4, 5 SAY "B: " GET BADCOL\nREAD');
+    const form = sent.find(m => m.type === 'form-open') as any;
+    expect(form.fields[0].options).toBeUndefined();
+    const out = sent.filter(m => m.type === 'output') as any[];
+    expect(out.flatMap(o => o.lines).map((l: any) => l.text).join('\n')).toMatch(/lookup for BADCOL/i);
+  });
+});
diff --git a/tests/Session.test.ts b/tests/Session.test.ts
index e00fd82..fb74e3e 100644
--- a/tests/Session.test.ts
+++ b/tests/Session.test.ts
@@ -170,11 +170,11 @@ describe('Session', () => {
     const prog = [
       'STORE 0 TO i',
       'DO WHILE i < 2',
-      '  STORE "" TO val',
-      '  @ 1,1 SAY "Value:" GET val',
+      '  STORE "" TO m_val',
+      '  @ 1,1 SAY "Value:" GET m_val',
       '  READ',
       '  APPEND RECORD',
-      '  REPLACE val WITH val',
+      '  REPLACE val WITH m_val',
       '  STORE i + 1 TO i',
       'ENDDO',
       'LIST',
@@ -186,15 +186,15 @@ describe('Session', () => {
     // First iteration should pause at READ and send form-open
     expect(sent.find(m => m.type === 'form-open')).toBeDefined();
 
-    // Submit first value (Lexer uppercases variable names → 'VAL')
+    // Submit first value (Lexer uppercases variable names → 'M_VAL')
     sent.length = 0;
-    await session.handleMessage({ type: 'form-submit', values: { VAL: 'alpha' } });
+    await session.handleMessage({ type: 'form-submit', values: { M_VAL: 'alpha' } });
     // Should pause again for second iteration
     expect(sent.find(m => m.type === 'form-open')).toBeDefined();
 
     // Submit second value
     sent.length = 0;
-    await session.handleMessage({ type: 'form-submit', values: { VAL: 'beta' } });
+    await session.handleMessage({ type: 'form-submit', values: { M_VAL: 'beta' } });
     // Loop done — LIST output (across all output messages) should contain both values
     const allText = sent
       .filter(m => m.type === 'output')
@@ -215,8 +215,8 @@ describe('Session', () => {
     await session.handleMessage({
       type: 'save-program', name: 'test_abort_prog',
       content: [
-        'STORE "" TO val',
-        '@ 1,1 SAY "Value:" GET val',
+        'STORE "" TO m_val',
+        '@ 1,1 SAY "Value:" GET m_val',
         'READ',
         'APPEND RECORD',
         'REPLACE val WITH "resumed"',
@@ -239,7 +239,7 @@ describe('Session', () => {
 
     // A stale form-submit must NOT resume the abandoned program.
     sent.length = 0;
-    await session.handleMessage({ type: 'form-submit', values: { VAL: 'resumed' } });
+    await session.handleMessage({ type: 'form-submit', values: { M_VAL: 'resumed' } });
 
     // No record should have been appended — the program was abandoned.
     sent.length = 0;
@@ -386,13 +386,13 @@ describe('Session', () => {
       'STORE "1" TO choice',
       'DO CASE',
       '  CASE choice == "1"',
-      '    STORE "" TO val',
-      '    @ 1,1 SAY "Value:" GET val',
+      '    STORE "" TO m_val',
+      '    @ 1,1 SAY "Value:" GET m_val',
       '    READ',
       '    APPEND RECORD',
-      '    REPLACE val WITH val',
+      '    REPLACE val WITH m_val',
       '  OTHERWISE',
-      '    STORE "unreached" TO val',
+      '    STORE "unreached" TO m_val',
       'ENDCASE',
       'LIST',
     ].join('\n');
@@ -403,7 +403,7 @@ describe('Session', () => {
 
     // Submit the form — the APPEND + REPLACE after READ must still run
     sent.length = 0;
-    await session.handleMessage({ type: 'form-submit', values: { VAL: 'gamma' } });
+    await session.handleMessage({ type: 'form-submit', values: { M_VAL: 'gamma' } });
     const allText = sent
       .filter(m => m.type === 'output')
       .flatMap((m: any) => m.lines.map((l: any) => l.text))

From 777b8d3bcd614b3737b8d835da9b01172c1a5db4 Mon Sep 17 00:00:00 2001
From: Dennis Decoene <DDecoene@users.noreply.github.com>
Date: Sun, 12 Jul 2026 11:24:45 +0200
Subject: [PATCH 2/4] feat(#59): form-submit writes field targets by rowid,
 all-or-nothing, form-error on rejection

---
 server/Session.ts              | 53 ++++++++++++++++++--
 src/shared/types.ts            |  1 +
 tests/FormFieldBinding.test.ts | 91 ++++++++++++++++++++++++++++++++++
 3 files changed, 140 insertions(+), 5 deletions(-)

diff --git a/server/Session.ts b/server/Session.ts
index ac38137..acb4f2d 100644
--- a/server/Session.ts
+++ b/server/Session.ts
@@ -18,6 +18,11 @@ export class Session {
   // Whether pendingContinuation was captured while a program (DO <name>) was
   // running — its resumption must re-enter program scope (e.g. silent STORE).
   private pendingFromProgram = false;
+  // The field list of the form currently awaiting submit. form-submit resolves
+  // write targets from THIS, never from the client's message — a forged
+  // form-submit cannot redirect a write to an arbitrary column (same reasoning
+  // as grid-edit's authoritative re-check).
+  private pendingFormFields: import('../src/shared/types.js').FormField[] | null = null;
 
   private dirty = false;
 
@@ -48,12 +53,48 @@ export class Session {
           break;
 
         case 'form-submit': {
-          // Always store what the form collected. A bare `INPUT "…" TO var` at the
-          // REPL leaves no continuation (there is no following statement), and
-          // gating the assignment on one silently discarded the typed value. (#50)
+          const fields = this.pendingFormFields ?? [];
+          type FieldTarget = Extract<NonNullable<import('../src/shared/types.js').FormField['target']>, { kind: 'field' }>;
+          const fieldByName = new Map<string, FieldTarget>();
+          for (const f of fields) {
+            if (f.target?.kind === 'field') fieldByName.set(f.varName, f.target);
+          }
+          // Variables first — and always. A bare `INPUT "…" TO var` at the REPL
+          // leaves no continuation, and gating the assignment on one silently
+          // discarded the typed value (#50). Keys that are not field targets of
+          // THIS form are variables, whatever the client claims.
           for (const [k, v] of Object.entries(msg.values)) {
-            this.executor.setVar(k, v);
+            if (!fieldByName.has(k)) this.executor.setVar(k, v);
+          }
+          // Field writes are all-or-nothing: validate every value (declared type
+          // + freshly-resolved lookup membership) before writing any.
+          const errors: { varName: string; message: string }[] = [];
+          const writes: { table: string; column: string; rowid: number; value: string }[] = [];
+          for (const [varName, t] of fieldByName) {
+            const value = msg.values[varName] ?? '';
+            let meta = columnMetaStore.getColumnType(t.db, t.table, t.column);
+            if (meta?.lookup) {
+              const options = await resolveLookup(this.bridge, meta.lookup);
+              meta = { ...meta, options: options ?? undefined };
+            }
+            const err = validateCellValue(t.column, value, meta);
+            if (err) errors.push({ varName, message: err });
+            else writes.push({ table: t.table, column: t.column, rowid: t.rowid, value });
           }
+          if (errors.length) {
+            // Keep pendingFormFields AND pendingContinuation intact: the client
+            // keeps the form open and resubmits corrected values.
+            this.send({ type: 'form-error', errors });
+            break;
+          }
+          this.pendingFormFields = null;
+          for (const w of writes) {
+            await this.bridge.exec(
+              `UPDATE ${q(w.table)} SET ${q(w.column)} = ? WHERE rowid = ?`,
+              [w.value, w.rowid]
+            );
+          }
+          this.send({ type: 'view-terminal' });
           if (this.pendingContinuation !== null) {
             const cont = this.pendingContinuation;
             const fromProgram = this.pendingFromProgram;
@@ -66,7 +107,6 @@ export class Session {
               if (fromProgram) this.executor.exitProgram();
             }
           } else {
-            this.send({ type: 'view-terminal' });
             this.sendStatus();
           }
           break;
@@ -164,6 +204,7 @@ export class Session {
         }
 
         case 'grid-exit':
+          this.pendingFormFields = null;
           this.send({ type: 'view-terminal' });
           if (this.pendingContinuation) {
             const cont = this.pendingContinuation;
@@ -187,6 +228,7 @@ export class Session {
           if (this.pendingContinuation !== null) {
             const wasProgram = this.pendingFromProgram;
             this.pendingContinuation = null;
+            this.pendingFormFields = null;
             this.pendingFromProgram = false;
             this.executor.resetProgramDepth();
             if (wasProgram) {
@@ -309,6 +351,7 @@ export class Session {
     if (result.action === 'FORM_READY' && result.formFields) {
       this.pendingContinuation = result.continuation ?? null;
       this.pendingFromProgram = this.executor.isInProgram();
+      this.pendingFormFields = result.formFields;
       this.send({ type: 'form-open', fields: result.formFields });
       return true;
     }
diff --git a/src/shared/types.ts b/src/shared/types.ts
index ed458f0..47f524d 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -161,6 +161,7 @@ export type ServerMessage =
   | { type: 'clear' }
   | { type: 'report-preview'; html: string }
   | { type: 'error'; message: string }
+  | { type: 'form-error'; errors: { varName: string; message: string }[] }
   | { type: 'catalog'; catalog: Catalog }
   | { type: 'data-changed'; db: string; table: string }
   | { type: 'csv-download'; filename: string; content: string }
diff --git a/tests/FormFieldBinding.test.ts b/tests/FormFieldBinding.test.ts
index 10a2cbb..dfdea37 100644
--- a/tests/FormFieldBinding.test.ts
+++ b/tests/FormFieldBinding.test.ts
@@ -105,3 +105,94 @@ describe('field-bound @ SAY GET', () => {
     expect(out.flatMap(o => o.lines).map((l: any) => l.text).join('\n')).toMatch(/lookup for BADCOL/i);
   });
 });
+
+describe('form-submit with field targets', () => {
+  it('writes submitted field values to the record and resumes', async () => {
+    const { session, sent, run } = await setup();
+    await run('APPEND RECORD');
+    await runBlock(session, sent, '@ 4, 5 SAY "Name: " GET NAME\n@ 5, 5 SAY "Sched: " GET SCHEDID\nREAD');
+    expect(sent.find(m => m.type === 'form-open')).toBeDefined();
+
+    sent.length = 0;
+    await session.handleMessage({ type: 'form-submit', values: { NAME: 'Grace', SCHEDID: 'S002' } });
+    expect(sent.find(m => m.type === 'view-terminal')).toBeDefined();
+    const listing = await run('LIST');
+    expect(listing).toContain('Grace');
+    expect(listing).toContain('S002');
+  });
+
+  it('rejects the whole submit when one field is off-list: form-error, nothing written', async () => {
+    const { session, sent, run } = await setup();
+    await run('APPEND RECORD');
+    await runBlock(session, sent, '@ 4, 5 SAY "Name: " GET NAME\n@ 5, 5 SAY "Sched: " GET SCHEDID\nREAD');
+
+    sent.length = 0;
+    await session.handleMessage({ type: 'form-submit', values: { NAME: 'Grace', SCHEDID: 'BOGUS' } });
+    const err = sent.find(m => m.type === 'form-error') as any;
+    expect(err).toBeDefined();
+    expect(err.errors).toEqual([
+      { varName: 'SCHEDID', message: 'SCHEDID: "BOGUS" is not one of the allowed values' },
+    ]);
+    expect(sent.find(m => m.type === 'view-terminal')).toBeUndefined();
+    // All-or-nothing: NAME was valid but must NOT have been written.
+    expect(await run('LIST')).not.toContain('Grace');
+  });
+
+  it('a corrected resubmit after form-error succeeds (state was retained)', async () => {
+    const { session, sent, run } = await setup();
+    await run('APPEND RECORD');
+    await runBlock(session, sent, '@ 4, 5 SAY "Sched: " GET SCHEDID\nREAD');
+
+    await session.handleMessage({ type: 'form-submit', values: { SCHEDID: 'BOGUS' } });
+    sent.length = 0;
+    await session.handleMessage({ type: 'form-submit', values: { SCHEDID: 'S001' } });
+    expect(sent.find(m => m.type === 'form-error')).toBeUndefined();
+    expect(await run('LIST')).toContain('S001');
+  });
+
+  it('a forged form-submit naming a column the form never offered cannot write it', async () => {
+    const { session, sent, run } = await setup();
+    await run('APPEND RECORD');
+    // The form only offers the variable M_X — EMPID is NOT a field of this form.
+    await runBlock(session, sent, '@ 4, 5 SAY "X: " GET M_X\nREAD');
+
+    await session.handleMessage({ type: 'form-submit', values: { M_X: 'ok', EMPID: 'HAX' } });
+    // EMPID lands in a memory variable at worst — never in the table.
+    expect(await run('LIST')).not.toContain('HAX');
+  });
+
+  it('field type validation applies too (DATE column gets a real date)', async () => {
+    const { session, sent, run } = await setup();
+    await run('ALTER TABLE EMPLOYEES ADD HIRED DATE');
+    await run('APPEND RECORD');
+    await runBlock(session, sent, '@ 4, 5 SAY "Hired: " GET HIRED\nREAD');
+
+    sent.length = 0;
+    await session.handleMessage({ type: 'form-submit', values: { HIRED: '2026-02-30' } });
+    const err = sent.find(m => m.type === 'form-error') as any;
+    expect(err.errors[0].message).toMatch(/not a real date/);
+  });
+
+  it('Escape (grid-exit) writes nothing and clears the retained fields', async () => {
+    const { session, sent, run } = await setup();
+    await run('APPEND RECORD');
+    await runBlock(session, sent, '@ 4, 5 SAY "Name: " GET NAME\nREAD');
+
+    await session.handleMessage({ type: 'grid-exit' });
+    expect(await run('LIST')).not.toContain('Grace');
+    // A form-submit arriving after the cancel must not write the field either.
+    await session.handleMessage({ type: 'form-submit', values: { NAME: 'Grace' } });
+    expect(await run('LIST')).not.toContain('Grace');
+  });
+
+  it('bare INPUT still stores its value (the #50 regression stays fixed)', async () => {
+    const sent: ServerMessage[] = [];
+    const session = new Session((m) => sent.push(m));
+    await session.handleMessage({ type: 'command', text: 'INPUT "Name? " TO who' });
+    await session.handleMessage({ type: 'form-submit', values: { WHO: 'Ada' } });
+    sent.length = 0;
+    await session.handleMessage({ type: 'command', text: '? who' });
+    const out = sent.find(m => m.type === 'output') as any;
+    expect(out.lines.map((l: any) => l.text).join('\n')).toContain('Ada');
+  });
+});

From d550788d4ec7d50712e27102ffe4b46fd3928577 Mon Sep 17 00:00:00 2001
From: Dennis Decoene <DDecoene@users.noreply.github.com>
Date: Sun, 12 Jul 2026 11:32:42 +0200
Subject: [PATCH 3/4] feat(#59): form selects for lookup GETs, prefill from
 record, form-error display

---
 src/styles/main.css      |  2 +
 src/terminal/Terminal.ts | 12 ++++--
 src/ui/FormLayout.ts     | 93 +++++++++++++++++++++++++++++-----------
 3 files changed, 80 insertions(+), 27 deletions(-)

diff --git a/src/styles/main.css b/src/styles/main.css
index 530a953..e8cd341 100644
--- a/src/styles/main.css
+++ b/src/styles/main.css
@@ -287,6 +287,8 @@ select.cell-ed { min-width: 110px; }
   padding: 1px 5px; outline: none; min-width: 120px;
 }
 .f-get:focus { border-color: #0088ff; background: #001c35; }
+select.f-get { min-width: 140px; }
+.f-get.f-invalid { border-color: #cc0000; background: #2a0000; }
 
 /* ── Program Editor ─────────────────────────────────────────────────────── */
 #editor-view {
diff --git a/src/terminal/Terminal.ts b/src/terminal/Terminal.ts
index 2afd2df..06dd701 100644
--- a/src/terminal/Terminal.ts
+++ b/src/terminal/Terminal.ts
@@ -117,8 +117,13 @@ export class Terminal {
       this.openForm(m.fields);
     });
 
+    ws.on('form-error', (msg) => {
+      this.form?.showErrors((msg as any).errors);
+    });
+
     ws.on('view-terminal', () => {
-      this.showTerminal();
+      if (this.form) this.closeForm();
+      else this.showTerminal();
     });
 
     ws.on('program-open', (msg) => {
@@ -260,8 +265,9 @@ export class Terminal {
       (values) => {
         const obj: Record<string, string> = {};
         values.forEach((v, k) => { obj[k] = v; });
+        // The form stays open until the server answers: view-terminal closes
+        // it, form-error keeps it up with the offending fields outlined.
         this.ws.send({ type: 'form-submit', values: obj });
-        this.closeForm();
       },
       () => {
         this.ws.send({ type: 'grid-exit' });
@@ -269,7 +275,7 @@ export class Terminal {
         this.printLine('READ cancelled', 'warn');
       }
     );
-    this.form.render(fields, new Map());
+    this.form.render(fields);
   }
 
   private closeForm() {
diff --git a/src/ui/FormLayout.ts b/src/ui/FormLayout.ts
index 9f113b9..fb7ef0c 100644
--- a/src/ui/FormLayout.ts
+++ b/src/ui/FormLayout.ts
@@ -4,10 +4,12 @@ import type { FormField } from '../shared/types';
 const CW = 8.4;
 const CH = 21;
 
+type GetControl = HTMLInputElement | HTMLSelectElement;
+
 export class FormLayout {
   private canvas: HTMLElement;
   private footer: HTMLElement;
-  private getInputs: Map<string, HTMLInputElement> = new Map();
+  private getInputs: Map<string, GetControl> = new Map();
   private onSubmit: (values: Map<string, string>) => void;
   private onCancel: () => void;
   private boundKey: (e: KeyboardEvent) => void;
@@ -23,7 +25,7 @@ export class FormLayout {
     this.boundKey = this.handleKey.bind(this);
   }
 
-  render(fields: FormField[], vars: Map<string, unknown>) {
+  render(fields: FormField[]) {
     this.canvas.innerHTML = '';
     this.getInputs.clear();
 
@@ -42,17 +44,38 @@ export class FormLayout {
 
       if (f.varName) {
         const labelWidth = f.label.length * CW + 8;
-        const inp = document.createElement('input');
-        inp.type = 'text';
-        inp.className = 'f-get';
-        inp.value = String(vars.get(f.varName) ?? '');
-        inp.dataset.var = f.varName;
-        inp.style.left = (x + labelWidth) + 'px';
-        inp.style.top  = y + 'px';
-        inp.setAttribute('autocomplete', 'off');
-        inp.setAttribute('spellcheck', 'false');
-        this.canvas.appendChild(inp);
-        this.getInputs.set(f.varName, inp);
+        let ctl: GetControl;
+        if (f.options && f.options.length) {
+          // A resolved lookup renders as a dropdown — the picker IS the
+          // client-side validation; the server still re-checks on submit.
+          const sel = document.createElement('select');
+          sel.className = 'f-get';
+          const blank = document.createElement('option');
+          blank.value = ''; blank.textContent = '';
+          sel.appendChild(blank);
+          for (const o of f.options) {
+            const op = document.createElement('option');
+            op.value = o.value;
+            op.textContent = o.label === o.value ? o.value : `${o.label} (${o.value})`;
+            sel.appendChild(op);
+          }
+          sel.value = f.value ?? '';
+          ctl = sel;
+        } else {
+          const inp = document.createElement('input');
+          inp.type = 'text';
+          inp.className = 'f-get';
+          inp.value = f.value ?? '';
+          inp.setAttribute('autocomplete', 'off');
+          inp.setAttribute('spellcheck', 'false');
+          ctl = inp;
+        }
+        ctl.dataset.var = f.varName;
+        ctl.style.left = (x + labelWidth) + 'px';
+        ctl.style.top  = y + 'px';
+        ctl.addEventListener('input', () => this.clearError(ctl));
+        this.canvas.appendChild(ctl);
+        this.getInputs.set(f.varName, ctl);
       }
     });
 
@@ -60,20 +83,42 @@ export class FormLayout {
     this.focusFirst();
   }
 
+  /** Server rejected the submit: outline the offending controls, keep the form. */
+  showErrors(errors: { varName: string; message: string }[]) {
+    // Clear every prior mark first — a field valid in this attempt must not
+    // keep a stale outline from an earlier rejection the user never touched.
+    this.getInputs.forEach(ctl => this.clearError(ctl));
+    for (const { varName, message } of errors) {
+      const ctl = this.getInputs.get(varName);
+      if (!ctl) continue;
+      ctl.classList.add('f-invalid');
+      ctl.title = message;
+    }
+    this.footer.textContent = errors.map(e => e.message).join('  ·  ');
+    const first = errors[0] && this.getInputs.get(errors[0].varName);
+    first?.focus();
+  }
+
+  private clearError(ctl: GetControl) {
+    ctl.classList.remove('f-invalid');
+    ctl.removeAttribute('title');
+  }
+
   unmount() {
     document.removeEventListener('keydown', this.boundKey, true);
     this.canvas.innerHTML = '';
     this.getInputs.clear();
+    this.footer.textContent = '';
   }
 
   private focusFirst() {
-    const first = this.canvas.querySelector<HTMLInputElement>('input.f-get');
+    const first = this.canvas.querySelector<HTMLElement>('.f-get');
     first?.focus();
   }
 
   private collect(): Map<string, string> {
     const values = new Map<string, string>();
-    this.getInputs.forEach((inp, varName) => values.set(varName, inp.value));
+    this.getInputs.forEach((ctl, varName) => values.set(varName, ctl.value));
     return values;
   }
 
@@ -86,13 +131,13 @@ export class FormLayout {
     }
     if (e.key === 'Enter') {
       const target = e.target as HTMLElement;
-      if (target.tagName === 'INPUT') {
+      if (target.tagName === 'INPUT' || target.tagName === 'SELECT') {
         e.preventDefault(); e.stopPropagation();
-        // Move to next input, or submit if on last
-        const inputs = Array.from(this.canvas.querySelectorAll<HTMLInputElement>('input.f-get'));
-        const idx = inputs.indexOf(target as HTMLInputElement);
-        if (idx >= 0 && idx < inputs.length - 1) {
-          inputs[idx + 1].focus();
+        // Move to next control, or submit if on last
+        const ctls = Array.from(this.canvas.querySelectorAll<HTMLElement>('.f-get'));
+        const idx = ctls.indexOf(target);
+        if (idx >= 0 && idx < ctls.length - 1) {
+          ctls[idx + 1].focus();
         } else {
           this.submit();
         }
@@ -101,8 +146,8 @@ export class FormLayout {
   }
 
   private submit() {
-    const values = this.collect();
-    this.unmount();
-    this.onSubmit(values);
+    // Do NOT unmount here: the server validates and either sends view-terminal
+    // (Terminal closes the form) or form-error (the form stays for correction).
+    this.onSubmit(this.collect());
   }
 }

From e89122ede183a5adc1d818f4eab0a0e972173314 Mon Sep 17 00:00:00 2001
From: Dennis Decoene <DDecoene@users.noreply.github.com>
Date: Sun, 12 Jul 2026 11:41:22 +0200
Subject: [PATCH 4/4] docs: field-bound @ SAY GET documented, promotes LOOKUP
 to full (#59)

Both BROWSE and forms now declare, enforce, and render LOOKUP end to
end, so this is the PR that adds the full command-table entry and
the field-binding precedence note to the README.
---
 CHANGELOG.md | 13 +++++++++++--
 CLAUDE.md    | 17 +++++++++++++----
 README.md    | 17 ++++++++++++-----
 3 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bdc601d..1bdfffd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,8 +27,17 @@ Versions follow [Semantic Versioning](https://semver.org/) — minor bump per su
   warning rather than locking the column. BROWSE renders a lookup column as a dropdown —
   `DISPLAY` labels shown while editing, the stored code shown once committed, matching
   `LIST`/report output.
-  **Forms (`@ SAY GET`) do not honor `LOOKUP` yet** — that ships in #59, which is when the
-  full feature is documented in the README command reference.
+- **Field-bound `@ SAY GET`** (#59). `@ r,c SAY "…" GET <name>` now binds directly to the
+  active table's column when one matches — dBASE III's actual behavior — instead of only
+  ever collecting into a memory variable. Fields take precedence over a memory variable of
+  the same name (why the `m_` prefix convention exists). A field-bound `GET` needs a current
+  record and prefills from it; a lookup column renders the same picker BROWSE does. `READ`'s
+  submit validates every field-bound value (declared type + lookup membership) before
+  writing any of them — a rejection sends a new `form-error` message that keeps the form
+  open with the bad fields outlined, rather than silently discarding the valid ones.
+  Writes target the row captured at `GET` time, mirroring how `grid-edit` already writes by
+  rowid. This is the PR that promotes `LOOKUP` to the README command reference in full —
+  both BROWSE and forms now declare, enforce, and render it end to end.
 
 ## [1.2.0] — 2026-07-09 — TIME columns, WEEK()/DATEADD(), BROWSE cell validation, Overtime demo
 
diff --git a/CLAUDE.md b/CLAUDE.md
index a31b516..3ebabc1 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -197,7 +197,7 @@ WebBase-III supports **unlimited work areas** (no DOS 10-area limit). Cross-area
 
 Declared types are recorded per `(database, table, column)` in `server/ColumnMetaStore.ts`, because SQLite only keeps a storage affinity: `TIME`/`DATE`/`CHAR` are all `TEXT`, `LOGICAL`/`INT` are both `INTEGER`, and a `NUM(p,s)` qualifier is lost entirely.
 
-#### `LOOKUP` column qualifier (BROWSE/REPLACE done; forms in progress — v1.3.0)
+#### `LOOKUP` column qualifier (v1.3.0)
 
 Any column may add a `LOOKUP` clause after its type, constraining it to a set of legal
 values — a WebBase-III extension with no dBASE III ancestor (dBASE III+ only had
@@ -220,9 +220,18 @@ matching `LIST`/report output — only the edit-mode dropdown shows `DISPLAY` la
 `REPLACE` and `grid-edit` both enforce membership, re-resolving fresh at write time (not
 trusting a client-held list) so a value that just became legal or just stopped being legal
 is judged correctly; an unresolvable lookup degrades to free entry with a warning rather
-than locking the column. **Forms (`@ SAY GET`) do not honor `LOOKUP` yet** — that lands in
-a follow-up PR (#59, field-bound `GET`) before this section is promoted to the README
-command reference.
+than locking the column.
+
+`@ r,c SAY "…" GET <name>` binds to the active table's column when one matches — dBASE III's
+actual behavior, and why the field takes precedence over a memory variable of the same name
+(the `m_` prefix convention exists for this reason). A field-bound `GET` requires a current
+record (`APPEND RECORD` first — `** Error: GET <field>: no current record` otherwise),
+prefills from the record, and renders a picker when the column has a resolvable lookup.
+`READ`'s submit is all-or-nothing across every field-bound `GET` in the form: every value is
+validated (declared type + lookup membership) before any is written, and a rejection sends a
+`form-error` message that keeps the form open with the offending fields outlined — Escape
+still writes nothing. Writes target the rowid captured at `GET` time (`fetchCurrentRow`),
+mirroring `grid-edit`, so pointer motion between `GET` and submit can't retarget the write.
 
 #### Cell validation (`BROWSE`)
 
diff --git a/README.md b/README.md
index ffaf3e1..2beb9d5 100644
--- a/README.md
+++ b/README.md
@@ -266,13 +266,20 @@ value that just became legal, or just stopped being legal, is judged correctly 
 stale cached list). A lookup that can't be resolved (source table dropped, empty, or over
 1000 distinct values) degrades to free entry with a warning instead of locking the column.
 
+Forms pick it up too: `@ r,c SAY "…" GET <name>` binds to the active table's column when
+one matches — a field takes precedence over a memory variable of the same name, which is
+why programs use an `m_` prefix for scratch variables. A field-bound `GET` needs a current
+record (`APPEND RECORD` first) and prefills from it; if the column has a lookup, the form
+renders the same picker BROWSE does. `READ` validates every field-bound value before
+writing any of them — a rejection keeps the form open with the bad field outlined instead
+of silently dropping the others.
+
 > **Deviation from dBASE III:** `LOOKUP` has no dBASE III ancestor — dBASE III+ only offered
 > `PICTURE "@M a,b,c"`, a literal value list cycled with the spacebar, with no table-driven
 > form and no display label. This is a WebBase-III extension, in the same spirit as
-> unlimited work areas and `alias.field` dot notation.
->
-> Forms (`@ SAY GET`) don't offer a `LOOKUP` picker yet — only BROWSE and `REPLACE` enforce
-> it today.
+> unlimited work areas and `alias.field` dot notation. Field-bound `GET` *is* authentic
+> dBASE III behavior — WebBase-III's own memory-variable-only forms were the deviation,
+> now corrected.
 
 > **CSV format (`COPY TO` / `APPEND FROM`):** Unlike dBASE III's headerless,
 > positional `DELIMITED`/`SDF` formats, WebBase-III uses modern **header-based CSV**
@@ -348,7 +355,7 @@ stale cached list). A lookup that can't be resolved (source table dropped, empty
 | `? <expr>[, <expr>...]` | Evaluate expression(s) and print the result (numbers right-justified; bare `?` prints a blank line; `??` also accepted) |
 | `STORE <val> TO <var>` | Assign a variable |
 | `INPUT "prompt" TO <var>` | Collect keyboard input |
-| `@ r,c SAY "text" GET <var>` | Define a form field |
+| `@ r,c SAY "text" GET <var>` | Define a form field; a name matching a column of the active table binds that column (lookup columns render a picker) |
 | `READ` | Display the form and wait for submit |
 
 ### Control flow