@tn3270/gui 0.0.0-stage → 0.1.0

package/app/keypadBoot.js

@@ -0,0 +1,501 @@
+// packages/frontend/dist/keypad.js
+var pfRow = (from) => Array.from({ length: 12 }, (_, i) => ({
+  label: `PF${from + i}`,
+  action: { kind: "pf", n: from + i },
+  name: `PF${from + i}`
+}));
+var KEYPAD_KEYS = Object.freeze([
+  ...pfRow(13),
+  ...pfRow(1),
+  { label: "PA1", action: { kind: "pa", n: 1 }, name: "PA1" },
+  { label: "PA2", action: { kind: "pa", n: 2 }, name: "PA2" },
+  { label: "PA3", action: { kind: "pa", n: 3 }, name: "PA3" },
+  { label: "Home", action: { kind: "home" }, name: "Home" },
+  { label: "^", action: { kind: "up" }, name: "Cursor up" },
+  { label: "Ins", action: { kind: "toggleInsert" }, name: "Insert mode" },
+  { label: "Dup", action: { kind: "dup" }, name: "Dup" },
+  { label: "Reset", action: { kind: "reset" }, name: "Reset" },
+  { label: "Attn", action: { kind: "attn" }, name: "Attention" },
+  { label: "SysRq", action: { kind: "sysreq" }, name: "System Request" },
+  { label: "Clear", action: { kind: "clear" }, name: "Clear" },
+  { label: "<", action: { kind: "left" }, name: "Cursor left" },
+  { label: "v", action: { kind: "down" }, name: "Cursor down" },
+  { label: ">", action: { kind: "right" }, name: "Cursor right" },
+  { label: "FldMk", action: { kind: "fieldMark" }, name: "Field Mark" },
+  { label: "Enter", action: { kind: "enter" }, name: "Enter" },
+  { label: "ErEOF", action: { kind: "eraseEOF" }, name: "Erase EOF" },
+  { label: "ErInp", action: { kind: "eraseInput" }, name: "Erase Input" },
+  { label: "Tab", action: { kind: "tab" }, name: "Tab" },
+  { label: "BkTab", action: { kind: "backTab" }, name: "Back Tab" },
+  { label: "Del", action: { kind: "delete" }, name: "Delete" },
+  { label: "BkSp", action: { kind: "backspace" }, name: "Backspace" },
+  // The 47th key, and the only one on this row past `BkSp`: row 4 ended at column 36, so this
+  // takes 42 for a right edge of 48 -- inside 72, and NO NEW ROW, which is what keeps the Electron
+  // window the same size and leaves the two non-keypad goldens byte-identical.
+  { label: "NewLn", action: { kind: "newline" }, name: "Newline" },
+  // The 48th key, and the FIRST whose action `applyAction` throws on -- see the note on
+  // `KeypadKey.action`, which this key made it necessary to rewrite. A transfer needs arguments,
+  // so the button opens a form; the front end intercepts it exactly as it intercepts Ctrl-T.
+  //
+  // `NewLn` ended at 48, so this takes 48 for a right edge of 54 -- still inside 72 and still NO
+  // NEW ROW, so the Electron window keeps its size and only the keypad golden moves. The gap at
+  // column 18 is NOT free space: it separates the Tab/BkTab clusters deliberately.
+  { label: "Xfer", action: { kind: "transferForm" }, name: "File Transfer" }
+]);
+
+// packages/frontend/dist/bindings.js
+var BINDING_INTENT = Object.freeze([
+  {
+    key: "Enter",
+    action: { kind: "enter" },
+    terminal: "\r",
+    note: 'the Enter AID -- EXCEPT while disconnected, when it RECONNECTS to the same host instead of sending anything. VM prints "Press Enter or Clear to continue" as a LOGOFF drops the line, and both keys used to do nothing at all. A deliberate divergence: x3270 binds no key to `Reconnect()`. See `applyAction`, and the OIA, which says so'
+  },
+  {
+    key: "Ctrl-C",
+    action: { kind: "clear" },
+    terminal: "",
+    note: "the Clear AID, not an interrupt: it dismisses VM's MORE... state. Also RECONNECTS while disconnected, exactly as Enter does -- VM names both keys"
+  },
+  {
+    key: "Ctrl-]",
+    action: { kind: "quit" },
+    terminal: "",
+    note: "the way out, because Ctrl-C is Clear. Say so on startup."
+  },
+  { key: "Ctrl-R", action: { kind: "reset" }, terminal: "" },
+  { key: "Ctrl-U", action: { kind: "eraseInput" }, terminal: "" },
+  { key: "Tab", action: { kind: "tab" }, terminal: "	" },
+  { key: "Shift-Tab", action: { kind: "backTab" }, terminal: "\x1B[Z" },
+  { key: "Backspace", action: { kind: "backspace" }, terminal: "\x7F" },
+  { key: "Delete", action: { kind: "delete" }, terminal: "\x1B[3~" },
+  {
+    key: "End",
+    action: { kind: "eraseEOF" },
+    terminal: "\x1B[4~",
+    note: "vt220 Select/End, bound to EraseEOF as a CHOICE following c3270 -- not a terminfo-derived mapping"
+  },
+  { key: "F1", action: { kind: "pf", n: 1 }, terminal: "\x1BOP" },
+  { key: "F3", action: { kind: "pf", n: 3 }, terminal: "\x1BOR" },
+  {
+    key: "F12",
+    action: { kind: "pf", n: 12 },
+    terminal: "\x1B[24~",
+    note: "the function keys are irregular: F7-F11 are 18/19/20/21/23~, with no 22~"
+  },
+  {
+    key: "Shift-F1",
+    action: { kind: "pf", n: 13 },
+    terminal: "\x1B[1;2P",
+    note: "Shift+F(n) is PF(n+12), the c3270 convention"
+  },
+  {
+    key: "Alt-1",
+    action: { kind: "pa", n: 1 },
+    terminal: "\x1B1",
+    note: 'the PA keys have no terminal equivalent, so ESC-digit, as c3270 does. The GUI matches e.code (Digit1), NOT e.key: on macOS Option-1 reports key "\xA1".'
+  },
+  { key: "Alt-2", action: { kind: "pa", n: 2 }, terminal: "\x1B2" },
+  { key: "Alt-3", action: { kind: "pa", n: 3 }, terminal: "\x1B3" },
+  {
+    key: "Ctrl-A",
+    action: { kind: "attn" },
+    terminal: "
",
+    note: "c3270's own default (Common/fb-c3270:83). A Telnet BREAK, not an AID."
+  },
+  {
+    key: "Insert",
+    action: { kind: "toggleInsert" },
+    terminal: "\x1B[2~",
+    note: "x3270's Toggle(insertMode) (fb-x3270:210); `tput kich1` measured \\x1b[2~"
+  },
+  {
+    key: "Ctrl-D",
+    action: { kind: "dup" },
+    terminal: "",
+    note: "c3270's own binding (Common/fb-c3270:186, and :88 in its _WIN32 keymap). Writes EBCDIC 0x1c and then TABS to the next unprotected field: kybd.c:1435 suppresses `key_Character`'s auto-skip for a keyboard Dup, but `Dup_action` moves the cursor itself at kybd.c:2790, so the tab happens exactly ONCE. The manual says so outright (p. 7-12, \"a Tab key operation to be performed\")"
+  },
+  {
+    key: "Ctrl-F",
+    action: { kind: "fieldMark" },
+    terminal: "",
+    note: "c3270's own binding (Common/fb-c3270:187, and :93 in its _WIN32 keymap). Writes EBCDIC 0x1e and auto-skips normally, as any typed character does -- the Dup suppression above is specific to EBC_dup"
+  },
+  {
+    key: "Ctrl-K",
+    action: { kind: "toggleKeypad" },
+    terminal: "\v",
+    note: "shows the keypad (GUI, browser) or the special-keys overlay (TUI). ALSO c3270's own: `Ctrl<Key>k: Keypad()` at Common/fb-c3270:191. Its _WIN32 keymap spells the same command Alt-K (:48), which would be ESC k in a terminal and so is not bound there; the canvas front ends accept both. NOT a 3270 key -- `applyAction` throws on it and each front end owns its own display"
+  },
+  {
+    key: "Ctrl-B",
+    action: { kind: "toggleKeyboard" },
+    note: "opens the FULL 122-key 3279 keyboard -- THE CANVAS FRONT ENDS ONLY, which is why this row gives NO `terminal` sequence. The TUI renders the keypad as a LIST because it cannot draw a keyboard inside 24x80, so `buildTable` deliberately leaves 0x02 unmapped and this entry documents an intent two of the four front ends honour. Stating a sequence here would be a lie the table's own test catches, since that test demands every `terminal` resolve in the terminal keymap. NOT c3270's either: it binds no such key in either keymap, so the spelling is ours. Invisible to the TUI overlay, which looks chords up BY ACTION from KEYPAD_KEYS -- a table this kind may never appear in, since a button for it would toggle the surface it is drawn on"
+  },
+  {
+    key: "Alt-M",
+    action: { kind: "geometryMenu" },
+    note: "opens the MODEL/OVERSIZE chooser -- the GUI's Model menu, the browser's picker overlay -- whose choice applies at the next connect. THE CANVAS FRONT ENDS ONLY, which is why this row gives NO `terminal` sequence, as Ctrl-B's does not: the TUI changes size by being RESIZED and model only by flag, so there is no chooser for a sequence to open, and Alt-M would be ESC m there besides. Matched on e.code (KeyM), NOT e.key: on macOS Option-M reports key \"\xB5\", the Alt-K trap again. NOT c3270's: it binds no such key. NOT a 3270 key -- `applyAction` throws on it and each front end owns its own display"
+  },
+  {
+    key: "Ctrl-T",
+    action: { kind: "transferForm" },
+    terminal: "",
+    note: "opens the IND$FILE transfer form (TUI). NOT c3270's -- it binds NO transfer key at all, in either half of Common/fb-c3270, so there is no reference spelling to match and 0x14 is free in both. NOT a 3270 key -- `applyAction` throws on it, because a transfer needs arguments and each front end owns its own dialog"
+  },
+  {
+    key: "Ctrl-Shift-C",
+    action: { kind: "requestCopy" },
+    note: "copies the selected cells. NO `terminal` sequence, and for a stronger reason than Ctrl-B's: the TUI has neither a cell selection nor a clipboard of any kind -- no OSC 52, no selection state over the screen -- so there is nothing for a sequence to do, where Ctrl-B at least names a surface the TUI draws differently. A CANVAS-FRONT-END binding, and Cmd-Shift-C is its macOS spelling: this table names ONE key per action, so the pair is asserted directly in canvas/test/keys.test.ts. THE SHIFTED FORM IS DELIBERATE -- plain Ctrl-C is the Clear AID and stays Clear on every platform, which is why canvas/src/keys.ts matches this chord BEFORE its case-folded Ctrl table. NOT a 3270 key -- `applyAction` throws on it, because only the renderer knows which cells were dragged"
+  },
+  // Sequence-less on purpose: two encodings each. See the header note on DECCKM.
+  { key: "Up", action: { kind: "up" } },
+  { key: "Down", action: { kind: "down" } },
+  { key: "Left", action: { kind: "left" } },
+  { key: "Right", action: { kind: "right" } },
+  { key: "Home", action: { kind: "home" } }
+]);
+
+// packages/frontend/dist/keypadView.js
+var byLabel = (label) => {
+  const key = KEYPAD_KEYS.find((k) => k.label === label);
+  if (key === void 0)
+    throw new Error(`no keypad key labelled ${label}`);
+  return key;
+};
+var pfRange = (from) => Array.from({ length: 12 }, (_, i) => byLabel(`PF${from + i}`));
+var KEYPAD_BLOCKS = Object.freeze([
+  // PF13-24 ABOVE PF1-12. That is `KEYPAD_KEYS`' own order -- it opens `pfRow(0, 13)` then
+  // `pfRow(1, 1)` -- and its header cites c3270 for the same arrangement
+  // (`Common/c3270/keypad.labels:2` and `:4`). Reversing it here would be a silent relearn for
+  // anyone used to the shipped keypad, which is why the test pins the first label of each row
+  // rather than just the count.
+  { id: "pf-high", title: "PF13-24", keys: pfRange(13) },
+  { id: "pf-low", title: "PF1-12", keys: pfRange(1) },
+  {
+    // The INTERRUPT keys: each one reaches the host OUTSIDE the ordinary read-modified exchange.
+    // PA1-3 and Clear go as short-read AIDs; `SysRq` is Telnet IAC AO on a TN3270E session that
+    // agreed the SYSREQ function and a TEST REQUEST READ on a classic one (`actions.ts:109-120`
+    // records both forms); and `Attn` is TELNET BREAK.
+    //
+    // `Attn` IS `IAC BREAK` AND NOT `IAC IP`. Stated this loudly because the first version of
+    // this comment said IP, and because the two are a real pair of Telnet commands that a reader
+    // can plausibly swap. MEASURED: `Telnet.sendAttn()` is `Uint8Array.of(T.IAC, T.BREAK)` with
+    // the trace label `'Attn (IAC BREAK)'` (`core/src/telnet.ts:225-230`), both it and
+    // `Session.sendAttn()` (`core/src/session.ts:1616`) carry the docstring "The 3270 Attn key is
+    // Telnet BREAK (RFC 1576 §8), not an AID", three tests assert the exact two bytes
+    // (`core/test/telnet.test.ts:448`, `core/test/session.test.ts:493`,
+    // `cli/test/runner.test.ts:373`) and a fourth pins that it never reaches `sendAID`
+    // (`frontend/test/actions.test.ts:120`, with the `sendAID` assertion at `:128`), and `T.IP` is
+    // referenced NOWHERE in this repository (`grep -rn 'T\.IP\b' packages/*/src` -> no hits). IP
+    // is not a loose synonym for BREAK: they are two distinct Telnet commands, and a reader who
+    // swaps them has the wrong byte on the wire.
+    //
+    // BUT THAT IS OURS, NOT x3270's, AND WE DIVERGE FROM IT. An earlier draft of this comment
+    // claimed x3270 "draws the same distinction", with `net_break` for Attn and `IAC IP` behind a
+    // separate `Interrupt()` action. x3270 does close to the OPPOSITE, read from
+    // `Common/kybd.c:978-1002`: `Attn_action`'s docstring is "ATTN key, per RFC 2355. Sends IP,
+    // regardless." and its FIRST branch is `if (IN_E) { if (net_bound()) net_interrupt(0); ... }`.
+    // `net_break` is only the `IN_3270` fallthrough for a CLASSIC session. And `Interrupt_action`
+    // is not a separate key at all any more: its docstring ends "This is now the same as the Attn
+    // action" (`:1008`), so x3270 says the two have CONVERGED.
+    //
+    // A PA1-BEFORE-BREAK CLAIM WAS ALSO DRAFTED HERE AND IS REMOVED, BECAUSE IT IS NOT TRUE OF
+    // THE VERSION THIS PROJECT CITES. A newer upstream `Attn_action` does send
+    // `ctlr_read_modified(AID_PA1, false)` before `net_break(0)`, commented "This is what PCOMM
+    // does in plain TN3270 mode" -- but that line does not exist in SUITE3270 4.5, which is the
+    // tree in `~/src/suite3270-4.5` that every other citation in this repo is measured against
+    // (`grep -rn 'ctlr_read_modified(AID_PA1' Common/*.c` -> zero hits there; the `IN_3270` arm is
+    // a bare `net_break(0)`). Mixing versions is how a wrong wire constant gets in: cite the tree
+    // we build and test against, and if a newer one diverges say WHICH version did what.
+    //
+    // ## FINDING: OUR ATTN DIVERGES FROM x3270 IN TN3270E MODE, AND IS UNTESTED THERE
+    //
+    // `Session.sendAttn()` (`core/src/session.ts:1617-1620`) is three lines with NO branch on
+    // `inTn3270e()`: it calls `Telnet.sendAttn()`, which sends `{IAC, BREAK}` unconditionally. So
+    // on a TN3270E session x3270 sends IP and we send BREAK. No test covers Attn in E mode --
+    // the only three are classic (cited above) -- and nothing else in the repo records this.
+    //
+    // THE ASYMMETRY WITH `sysreq()` IS THE REASON TO THINK THIS IS AN OVERSIGHT RATHER THAN A
+    // DECISION: `sysreq()` sits IMMEDIATELY ABOVE `sendAttn()` in the same file (`:1596`), it
+    // branches on `inTn3270e()` as its first act, and its docstring opens "TWO COMPLETELY
+    // DIFFERENT THINGS ON THE WIRE, chosen by whether the session is TN3270E" and cites x3270's
+    // `IN_E` split for exactly that. The neighbouring key got the branch; this one did not, and
+    // no comment anywhere says it was considered.
+    //
+    // DELIBERATELY NOT FIXED HERE. Changing what `Attn` puts on the wire is protocol work, it is
+    // outside a keypad-presentation feature, and it wants a live TN3270E witness this project
+    // does not have -- both of its live hosts answer `IAC WILL TN3270E` with DONT, measured three
+    // times (`session.ts`, on `sysreq`). Recorded rather than silently repaired or silently
+    // ignored. `actions.ts:108` is a bare `case 'attn': session.sendAttn(); break;` with no wire
+    // note, which is why the citation for this half points at core and not at the dispatch.
+    //
+    // None of the six is the ordinary "submit this screen" that `Enter` is, which is why `Enter`
+    // is not in this block despite also being an AID. `Reset` is the odd one, and it is here
+    // deliberately: `Keyboard.reset()` (`core/src/keyboard.ts:434`) only calls `oia.reset()`, and
+    // the input-inhibit state it clears is the state a host error and the AID keys leave you in.
+    //
+    // THAT IS AN AFFINITY, NOT A RULE, and the stronger version of it is false: `Enter` and all
+    // 24 PF keys raise `SystemWait` through the same `sendAID` path from OTHER blocks
+    // (`session.ts:1553`), the three operator-error inhibits come from typing into a protected or
+    // numeric field rather than from any key here, and `Attn` -- which IS in this block -- does
+    // not touch the OIA at all (`session.ts:1617-1620` goes straight to the Telnet layer). Reset
+    // is grouped with the keys whose kind of trouble it answers; it is not claimed that this
+    // block is the only way to need it.
+    id: "attention",
+    title: "Attention",
+    keys: ["PA1", "PA2", "PA3", "Attn", "SysRq", "Clear", "Reset"].map(byLabel)
+  },
+  {
+    // Everything that MOVES THE CURSOR without altering the buffer. `NewLn` is a cursor move in
+    // 3270 terms and nothing else: `Keyboard.newline()` (`core/src/keyboard.ts:348`) is documented
+    // "first unprotected cell at or after the start of the next line" and its whole body assigns
+    // `s.cursor`. It belongs here, not beside `Enter`, which its name invites a reader to assume.
+    //
+    // The four arrows are `^ v < >` because that is what `KEYPAD_KEYS` labels them, and the
+    // labels are the button text. `keypad.ts` records why they exist at all: c3270's keypad has
+    // no cursor callbacks, but a keypad drivable by MOUSE ALONE needs them or a mouse user could
+    // never move the cursor -- which is exactly the DOM keypad's case too.
+    id: "cursor",
+    title: "Cursor",
+    keys: ["Home", "^", "v", "<", ">", "Tab", "BkTab", "NewLn"].map(byLabel)
+  },
+  {
+    // Everything that CHANGES THE BUFFER locally, with no transmission to the host. `Dup` and
+    // `FldMk` are here because they are TYPED CHARACTERS and not AIDs -- see the note on the
+    // `Action` union in `keymap.ts` -- so a user hunting them under "Attention" beside PA1 would
+    // be looking in the wrong place.
+    //
+    // `Ins` toggles a mode rather than editing, and it is the mode that decides what `Dup` and
+    // `FldMk` write into -- the only two keys here that go through `writeControl`
+    // (`core/src/keyboard.ts:127` and `:165`). NOT "what every other key in this block does",
+    // which an earlier draft of this comment claimed: `insertMode` is read in exactly two places,
+    // `type()` (`keyboard.ts:74`) and `writeControl()` (`:223`), and `Del` (`:413`), `BkSp`
+    // (`:398`), `ErEOF` (`:369`) and `ErInp` (`:393`) never read it. Four of the six are
+    // unaffected by the toggle, so `Ins` earns its place here by editing the buffer like the
+    // rest and not by governing them.
+    id: "editing",
+    title: "Editing",
+    keys: ["Ins", "Del", "BkSp", "ErEOF", "ErInp", "Dup", "FldMk"].map(byLabel)
+  },
+  {
+    // The two keys that SUBMIT OR START SOMETHING: `Enter` transmits the modified fields, `Xfer`
+    // starts a file transfer. Both reach the host, neither is an interrupt, which is what keeps
+    // them out of the `attention` block.
+    //
+    // `Xfer` IS THE ONE KEY IN THIS TABLE WHOSE ACTION `applyAction` REFUSES -- `actions.ts:57`,
+    // "applyAction does not handle transferForm: the front end owns its own dialog" -- so a
+    // button wired straight through to `applyAction` is a button that only throws. Whoever
+    // renders this block must give it the same treatment that front end already gives Ctrl-T,
+    // and THAT DIFFERS BY FRONT END rather than being one rule: the Electron GUI opens a
+    // window (`gui/src/main.ts:924`) and the TUI opens an overlay (`tui/src/app.ts:672`), but
+    // the web gateway deliberately REJECTS it with an error frame naming the kind
+    // (`web/src/protocol.ts:146`), because a browser-initiated transfer would write to the
+    // gateway's filesystem and not the operator's. The web keypad therefore still shows the
+    // button -- the rejection is the feedback, and `protocol.ts` says so in as many words.
+    id: "send",
+    title: "Send",
+    keys: ["Enter", "Xfer"].map(byLabel)
+  }
+]);
+function tooltipFor(key) {
+  const wanted = JSON.stringify(key.action);
+  const note = BINDING_INTENT.find((b) => JSON.stringify(b.action) === wanted)?.note;
+  if (note === void 0)
+    return key.name;
+  if (note.startsWith(key.name))
+    return note;
+  return `${key.name} -- ${note}`;
+}
+
+// packages/canvas/dist/keypadUi.js
+function createKeypadUi(deps) {
+  for (const block of KEYPAD_BLOCKS) {
+    const section = deps.create("div");
+    deps.setAttr(section, "class", "keypad-block");
+    deps.setAttr(section, "id", `keypad-${block.id}`);
+    const heading = deps.create("h2");
+    deps.setText(heading, block.title);
+    deps.append(section, heading);
+    const keys = deps.create("div");
+    deps.setAttr(keys, "class", "keypad-keys");
+    for (const key of block.keys) {
+      const button = deps.create("button");
+      deps.setAttr(button, "type", "button");
+      deps.setAttr(button, "data-label", key.label);
+      deps.setText(button, key.label);
+      deps.setTitle(button, tooltipFor(key));
+      deps.onClick(button, () => {
+        deps.sendAction(key.action);
+      });
+      deps.append(keys, button);
+    }
+    deps.append(section, keys);
+    deps.append(deps.root, section);
+  }
+}
+
+// packages/canvas/dist/keys.js
+function layoutCharacter(e) {
+  if (e.getModifierState?.("AltGraph") !== true)
+    return null;
+  if ([...e.key].length === 1)
+    return { kind: "type", text: e.key };
+  return null;
+}
+var NAMED = Object.freeze({
+  Enter: { kind: "enter" },
+  ArrowLeft: { kind: "left" },
+  ArrowRight: { kind: "right" },
+  ArrowUp: { kind: "up" },
+  ArrowDown: { kind: "down" },
+  Home: { kind: "home" },
+  Backspace: { kind: "backspace" },
+  Delete: { kind: "delete" },
+  // vt220 Select/End bound to EraseEOF, following c3270 -- a CHOICE, not a derivation.
+  End: { kind: "eraseEOF" },
+  // x3270's Toggle(insertMode), fb-x3270:210.
+  Insert: { kind: "toggleInsert" }
+});
+var MODIFIERS = /* @__PURE__ */ new Set([
+  "Shift",
+  "Control",
+  "Alt",
+  "Meta",
+  "CapsLock",
+  "AltGraph",
+  "NumLock",
+  "ScrollLock"
+]);
+var CTRL = Object.freeze({
+  c: { kind: "clear" },
+  r: { kind: "reset" },
+  u: { kind: "eraseInput" },
+  "]": { kind: "quit" },
+  a: { kind: "attn" },
+  d: { kind: "dup" },
+  f: { kind: "fieldMark" },
+  k: { kind: "toggleKeypad" },
+  // The full 122-key keyboard, 2026-10-22. Free in both mappers -- the taken chords are
+  // C R U ] A D F K T -- and claiming it also suppresses Firefox's bookmarks sidebar, which is
+  // correct: `renderer.ts` calls `preventDefault` only for keys we claimed, so claiming it is
+  // what makes it ours. Intercepted CLIENT-SIDE in both DOM front ends, exactly as `toggleKeypad`
+  // is, and the gateway returns before `applyAction` for it -- see `web/src/main.ts`.
+  b: { kind: "toggleKeyboard" },
+  /**
+   * Ctrl-T, the transfer form -- `BINDING_INTENT`'s own spelling, now that the GUI has a dialog.
+   *
+   * THE GUI HAD THIS CHORD DEAD WHILE THE WINDOW WORKED, which is how this was found: a real
+   * Electron run with `TN3270_GUI_KEYS=Ctrl+T` printed `keys: sent Ctrl+T` and NO `action:` line
+   * at all, where a click on the `Xfer` keypad button opened the window fine. The keypad route
+   * went through `KEYPAD_KEYS` and never through this table, so the one that was missing was also
+   * the one no harness drove.
+   *
+   * ACCEPTED BY THE WEB FRONT END TOO, since this mapper is shared, and that is safe rather than
+   * merely tolerable: `protocol.ts:129-131` REJECTS the kind at decode with a per-client `error`
+   * frame, and `web/src/main.ts:151-154` answers a decode failure on that one socket without
+   * touching the session or the process. The browser could already produce this kind from the
+   * `Xfer` button it draws today, so this adds a second route to an answer that already exists --
+   * no new failure mode, and the refusal names its reason. When stage 4 gives the gateway a
+   * transfer path that rejection becomes an interception, and this entry needs no change.
+   */
+  t: { kind: "transferForm" }
+});
+var PA_CODES = Object.freeze({
+  Digit1: { kind: "pa", n: 1 },
+  Digit2: { kind: "pa", n: 2 },
+  Digit3: { kind: "pa", n: 3 }
+});
+function actionForKey(e) {
+  if (MODIFIERS.has(e.key))
+    return null;
+  if (e.shiftKey && !e.altKey && e.ctrlKey !== e.metaKey && e.code === "KeyC") {
+    return { kind: "requestCopy" };
+  }
+  if (e.ctrlKey && !e.altKey && !e.metaKey) {
+    return CTRL[e.key.toLowerCase()] ?? null;
+  }
+  if (e.altKey && !e.ctrlKey && !e.metaKey) {
+    if (e.code === "KeyK")
+      return { kind: "toggleKeypad" };
+    if (e.code === "KeyM")
+      return { kind: "geometryMenu" };
+    return PA_CODES[e.code] ?? layoutCharacter(e);
+  }
+  if (e.metaKey || e.altKey)
+    return layoutCharacter(e);
+  if (e.key === "Tab")
+    return e.shiftKey ? { kind: "backTab" } : { kind: "tab" };
+  const fn = /^F(\d{1,2})$/.exec(e.key);
+  if (fn !== null) {
+    const n = Number(fn[1]);
+    if (n < 1 || n > 12)
+      return null;
+    return { kind: "pf", n: e.shiftKey ? n + 12 : n };
+  }
+  const named = NAMED[e.key];
+  if (named !== void 0)
+    return named;
+  if ([...e.key].length === 1)
+    return { kind: "type", text: e.key };
+  return null;
+}
+
+// packages/canvas/dist/forwardKeys.js
+function isEditableTarget(target) {
+  const tag = typeof target?.tagName === "string" ? target.tagName : "";
+  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT" || target?.isContentEditable === true;
+}
+function forwardKeys(deps) {
+  deps.on("keydown", (raw) => {
+    const e = raw;
+    if (isEditableTarget(e.target))
+      return;
+    const action = actionForKey(e);
+    if (action === null)
+      return;
+    e.preventDefault();
+    deps.sendAction(action);
+  });
+}
+
+// packages/gui/dist/keypadBoot.js
+var root = document.getElementById("keys");
+if (root === null) {
+  throw new Error("keypad window: #keys is missing from keypad.html");
+}
+var bridge = window.tn3270keypad;
+if (bridge === void 0) {
+  throw new Error("keypad window: the tn3270keypad bridge is absent (preload failed to load?)");
+}
+createKeypadUi({
+  root,
+  create: (tag) => document.createElement(tag),
+  append: (parent, child) => {
+    parent.appendChild(child);
+  },
+  setText: (el, text) => {
+    el.textContent = text;
+  },
+  setTitle: (el, title) => {
+    el.title = title;
+  },
+  setAttr: (el, name, value) => {
+    el.setAttribute(name, value);
+  },
+  onClick: (el, fn) => {
+    el.addEventListener("click", fn);
+  },
+  sendAction: (action) => {
+    bridge.sendAction(action);
+  }
+});
+forwardKeys({
+  on: (type, handler) => {
+    window.addEventListener(type, handler);
+  },
+  sendAction: (action) => {
+    bridge.sendAction(action);
+  }
+});
+//# sourceMappingURL=keypadBoot.js.map