printer: accurate line-printer mechanical test (PER->PRT + faithful display)

The SAT Printer Mechanical Test (printermechanicaltest.cap) now runs to its
documented END OF DIAGNOSTIC HLT (PO=0x0BC0) and prints its real pattern
sequence: solid 0x55 ('E') lines, inverse 0xAA ('-') lines, and the shifting
graphic-set "barber-pole" exercising every character position.

Model / batch:
  - sat_batches.c: the printer-mechanical batch enters at 0x0118 and synthesizes
    the required center card into the startup input buffer (0x0670-0x0675:
    integrated subsystem, no 2nd transport, normal drum/ribbon, with end-of-test
    HLT) since the scatter-image path has no physical center card.
  - printer.c: line-printer WRITE (cmd 0x42) shares the 6-byte order block with
    the typewriter PUT but parks at the b8 request-wait with RC00 set; it is
    released there and the transfer is armed on return to alpha (line_mode appends
    a paper break per WRITE). Control orders (single-space 0x2E -> 1 break,
    triple-space 0x5A -> 3 breaks) emit paper feeds; other control PERs complete
    silently. printer_begin_output() gains a line_mode argument.

Display (wasm console):
  - main.c drain_printer(): emit the new tail AND clear the capture buffer each
    frame. Previously it only advanced a cursor, so out[] accumulated across
    frames, capped at sizeof(out)-1 within ~50 ms, and the panel froze mid-test
    (the mechanical test prints ~6.6M chars) — the apparent "hang at 0x014A".
  - ge.h: out[] 8192 -> 65536 for catch-up/fast-frame bursts.
  - console.html: drop the 80-column auto-wrap (white-space: pre, inline spans,
    no 80ch clamp) so the paper breaks lines only on the typewriter's own line
    feed and long lines scroll horizontally.

Verified: halts at 0x0BC0, uniform ~244 cyc/WRITE (no stall); 279 unit tests pass.

Author: danielinux

console/wasm/console.html

@@ -927,12 +927,18 @@
   border-radius: 3px; font: inherit; font-size: 8.5pt; padding: 0.1em 0.5em; cursor: pointer;
 }
 #tp_paper {
-  height: 13em; overflow-y: auto;
+  height: 13em; overflow: auto;
   padding: 0.6em 0.8em; margin: 0;
   background:
     repeating-linear-gradient(#f4f1e6, #f4f1e6 1.45em, #e7e3d2 1.45em, #e7e3d2 1.5em);
   color: #23241c; font-size: 10.5pt; line-height: 1.5em;
-  white-space: pre-wrap; word-break: break-word;
+  /* Continuous paper: break lines ONLY on the typewriter's own line feed (the
+   * \n the printer emits per WRITE / spacing order) — no 80-column auto-wrap.
+   * Long lines extend and scroll horizontally. */
+  white-space: pre;
+}
+#tp_paper > span {
+  display: inline;
 }
 #tp_paper .tp-prn { color: #1a1c14; }
 #tp_paper .tp-kbd { color: #6a4a1a; }          /* operator-typed, ink-ribbon brown */

console/wasm/main.c

@@ -49,14 +49,22 @@ EM_JS(void, printer_emit, (const char *text), {
 /* Bytes the machine has already printed and echoed to the chat panel. */
 static int printer_echoed = 0;
 
-/* Push any newly-captured printer output to the JS chat transcript. */
+/* Push any newly-captured printer output to the JS chat transcript, then
+ * RECLAIM the capture buffer. The JS side keeps its own scrolling transcript,
+ * so the emulator-side out[] is only a per-frame staging buffer: if we merely
+ * advanced a cursor (the old behaviour) out[] would accumulate across frames
+ * and cap at sizeof(out)-1 within ~50 ms of real-time printing, after which
+ * printer_capture_char drops everything and the panel freezes mid-test (the
+ * line-printer mechanical test alone prints millions of characters). Emitting
+ * the new tail and clearing each frame keeps the stream flowing without bound. */
 static void drain_printer(void) {
     int olen = printer_output_len(ge);
-    if (olen <= printer_echoed)
-        return;
-    /* printer_output() is NUL-terminated; emit only the new tail. */
-    printer_emit(printer_output(ge) + printer_echoed);
-    printer_echoed = olen;
+    if (olen > printer_echoed)
+        printer_emit(printer_output(ge) + printer_echoed);
+    if (olen > 0) {
+        printer_output_clear(ge);
+        printer_echoed = 0;
+    }
 }
 
 /* Feed one operator-keyboard byte (two-way chat input). Exposed to JS. */

ge.h

@@ -604,7 +604,11 @@ struct ge {
      */
     struct ge_integrated_printer {
         int      present;
-        char     out[8192];     /* captured printed characters (ring/append) */
+        char     out[65536];    /* captured printed chars; per-frame staging only
+                                 * (the wasm console drains+clears each frame, the
+                                 * CLI reads it at end). Sized for a catch-up
+                                 * frame's burst so fast/backgrounded printing
+                                 * doesn't overflow before the drain. */
         int      out_len;
         uint8_t  kbd[256];      /* operator keyboard input queue */
         int      kbd_head, kbd_tail;
@@ -617,6 +621,7 @@ struct ge {
         int      out_active;
         int      out_remaining;
         int      out_total;
+        int      out_line_mode;
         uint8_t  out_saved_so;
     } integrated_printer;
 

printer.c

@@ -69,13 +69,43 @@ struct printer_ctx {
 
 #define STDIO_STATUS_ADDR 0x0030
 #define STDIO_COUNT_ADDR  0x0032
+#define LP_CMD_SINGLE_SPACE 0x2E
+#define LP_CMD_TRIPLE_SPACE 0x5A
 
 static void store16(struct ge *ge, uint16_t addr, uint16_t value)
 {
     ge_mem_store8(ge, addr, (uint8_t)(value >> 8));
     ge_mem_store8(ge, (uint16_t)(addr + 1), (uint8_t)value);
 }
 
+static void printer_capture_char(struct ge_integrated_printer *p, char c)
+{
+    if (p->out_len >= (int)sizeof(p->out) - 1)
+        return;
+    p->out[p->out_len++] = c;
+    p->out[p->out_len] = '\0';
+}
+
+static void printer_capture_breaks(struct ge_integrated_printer *p, int count)
+{
+    for (int i = 0; i < count; i++)
+        printer_capture_char(p, '\n');
+}
+
+static void printer_capture_control(struct ge_integrated_printer *p, uint8_t cmd)
+{
+    switch (cmd) {
+        case LP_CMD_SINGLE_SPACE:
+            printer_capture_breaks(p, 1);
+            break;
+        case LP_CMD_TRIPLE_SPACE:
+            printer_capture_breaks(p, 3);
+            break;
+        default:
+            break;
+    }
+}
+
 static int kbd_ready(const struct ge_integrated_printer *p)
 {
     return p->kbd_head != p->kbd_tail;
@@ -188,9 +218,12 @@ static int printer_on_clock(struct ge *ge, void *opaque)
              * the stolen cycles clobbered, and end the line. */
             ge->RC02 = 0;
             ge->rSO  = p->out_saved_so;
+            if (p->out_line_mode)
+                printer_capture_breaks(p, 1);
             store16(ge, STDIO_COUNT_ADDR, (uint16_t)p->out_total);
             store16(ge, STDIO_STATUS_ADDR, 1);
             p->out_active = 0;
+            p->out_line_mode = 0;
         }
         return 0;
     }
@@ -217,7 +250,7 @@ static int printer_on_clock(struct ge *ge, void *opaque)
                          ge->mem[(uint16_t)(base + 5)];
         ctx->per_pending = 0;
         if (IS_OUTPUT_CMD(cmd) && len >= 1 && len <= PRINT_LEN_MAX)
-            printer_begin_output(ge, buf, len);
+            printer_begin_output(ge, buf, len, cmd == LP_CMD_WRITE);
         else if (cmd == KBD_CMD_LINE && len >= 1 && len <= PRINT_LEN_MAX)
             service_input_line(ge, buf, len);
         else if (cmd == KBD_CMD_CHAR && len >= 1 && len <= PRINT_LEN_MAX)
@@ -250,6 +283,8 @@ static int printer_on_clock(struct ge *ge, void *opaque)
                             cmd != KBD_CMD_CHAR &&
                             !write_ready;
         if (write_ready || input_ready || control_ready) {
+            if (control_ready)
+                printer_capture_control(p, cmd);
             ge->PUC2 = 1;   /* channel-2 unit ready -> DU97 completes the PER */
             ge->RC00 = 1;   /* CPU-active request   -> rSO=b8 routed into rSA */
             ctx->stall = 0;
@@ -281,6 +316,10 @@ static int printer_on_clock(struct ge *ge, void *opaque)
      * such as funktionalcpu's banner/report. Complete it via the native path so
      * the CPU resumes, but emit nothing: real printed text comes only from an
      * armed output transfer, not from heuristically scraping the order block. */
+    if (ctx->per_pending) {
+        uint8_t cmd = ge->mem[(uint16_t)(ctx->per_base + 1)];
+        printer_capture_control(p, cmd);
+    }
     ge->PUC2 = 1;   /* channel-2 unit ready  -> DU97 = 1 (PUC2 ^ L2.3) */
     ge->RC00 = 1;   /* CPU-active request    -> NA_knot routes rSO=b8 into rSA */
     ctx->stall = 0; /* one-shot; rSO leaves b8 next cycle */
@@ -304,9 +343,7 @@ static void printer_sink(struct ge *ge, struct ge_channel *ch, uint8_t c)
     struct ge_integrated_printer *p = &ge->integrated_printer;
     (void)ch;
 
-    if (p->out_len < (int)sizeof(p->out) - 1)
-        p->out[p->out_len++] = ge_glyph(c);
-    p->out[p->out_len] = '\0';
+    printer_capture_char(p, ge_glyph(c));
 }
 
 int printer_register(struct ge *ge)
@@ -333,12 +370,13 @@ int printer_register(struct ge *ge)
     return ge_register_peri(ge, &ctx->peri);
 }
 
-void printer_begin_output(struct ge *ge, uint16_t buffer, int length)
+void printer_begin_output(struct ge *ge, uint16_t buffer, int length, int line_mode)
 {
     ge->rV4 = buffer;
     ge->integrated_printer.out_active    = 1;
     ge->integrated_printer.out_remaining = length;
     ge->integrated_printer.out_total     = length;
+    ge->integrated_printer.out_line_mode = line_mode;
     ge->integrated_printer.out_saved_so  = ge->rSO;  /* resume here when done */
 }
 

printer.h

@@ -36,9 +36,11 @@ int printer_register(struct ge *ge);
 /* Begin a channel-2 OUTPUT transfer: print `length` characters starting at
  * memory address `buffer`. The printer then requests a channel-2 cycle per
  * character (RC02 + rSI state 0x02) so the machine's microcode drains the buffer
- * to the printer, ending the line when done. (Seam for the org-phase PER hook;
- * also used directly by tests.) */
-void printer_begin_output(struct ge *ge, uint16_t buffer, int length);
+ * to the printer. `line_mode` appends a paper break when the transfer ends;
+ * this is used by the line printer's WRITE order but not by the console
+ * typewriter PUT path. (Seam for the org-phase PER hook; also used directly by
+ * tests.) */
+void printer_begin_output(struct ge *ge, uint16_t buffer, int length, int line_mode);
 
 /* Push one operator-keyboard byte into the input queue (two-way chat). */
 void printer_feed_key(struct ge *ge, uint8_t c);

sat_batches.c

@@ -22,6 +22,12 @@ struct sat_batch_def {
     struct sat_batch_info info;
     const struct sat_source *sources;
     int nsources;
+    uint16_t image_entry;
+};
+
+struct sat_image_patch {
+    uint16_t addr;
+    uint8_t value;
 };
 
 static const struct sat_source src_cpu_functional[] = {
@@ -36,6 +42,30 @@ static const struct sat_source src_printer_mech[] = {
     { "printermechanicaltest.cap", SAT_SRC_AS_IS },
 };
 
+/* Printer Mechanic Test startup: the deck issues PER 0x00,0x0126, whose order
+ * block is {00,40,00,4F,06,70} — a 79-byte "read unchanged" into 0x0670.
+ * In the real SAT stack that record comes from the required center card. The
+ * current scatter-image path has no physical center card, so synthesize the
+ * default raw reader bytes the diagnostic expects:
+ *   col1 integrated, col2 no 2nd transport, col4 normal drum, col5 normal
+ *   ribbon, col6 WITH END OF TEST HLT. The remaining bytes are left zero.
+ *
+ * Confidence:
+ *   - 0x0673 / 0x0674 are directly tested by the deck as 0x01 (normal drum /
+ *     ribbon path).
+ *   - 0x0675 follows the manual's center-card column 6. Under the raw-reader
+ *     low-byte model, a 9-punch collapses to 0x00, so WITH END OF TEST HLT is
+ *     represented here as 0x00.
+ *   - columns not yet evidenced by the code remain zero until more manual
+ *     evidence is recovered. */
+static const struct sat_image_patch printer_mech_center_card[] = {
+    { 0x0670, 0x01 }, /* column 1: integrated subsystem */
+    { 0x0671, 0x01 }, /* column 2: 2nd transport absent */
+    { 0x0673, 0x01 }, /* column 4: normal drum */
+    { 0x0674, 0x01 }, /* column 5: normal ribbon */
+    { 0x0675, 0x00 }, /* column 6: with END OF TEST HLT */
+};
+
 static const struct sat_source src_control_program[] = {
     { "control-program-cr.cap", SAT_SRC_SERIAL_LOADER_PLUS_BODY },
 };
@@ -60,42 +90,50 @@ static const struct sat_batch_def sat_batches[] = {
         { "cpu-functional", "CPU Functional Test",
           "SAT step 1: the functional CPU deck staged through the scatter-image path.",
           SAT_BATCH_IMAGE },
-        src_cpu_functional, (int)(sizeof(src_cpu_functional) / sizeof(src_cpu_functional[0]))
+        src_cpu_functional, (int)(sizeof(src_cpu_functional) / sizeof(src_cpu_functional[0])),
+        0x0000
     },
     {
         { "card-reader-a", "Reading Test Channel A",
           "SAT step 2: the captured card-reader test deck.", SAT_BATCH_IMAGE },
-        src_reader_a, (int)(sizeof(src_reader_a) / sizeof(src_reader_a[0]))
+        src_reader_a, (int)(sizeof(src_reader_a) / sizeof(src_reader_a[0])),
+        0x0000
     },
     {
         { "printer-mechanical", "Printer Mechanical Test",
-          "SAT step 3: the line-printer deck staged through the scatter-image path.",
+          "SAT step 3: the line-printer deck staged through the scatter-image path, "
+          "with the required center card synthesized into the startup input buffer.",
           SAT_BATCH_IMAGE },
-        src_printer_mech, (int)(sizeof(src_printer_mech) / sizeof(src_printer_mech[0]))
+        src_printer_mech, (int)(sizeof(src_printer_mech) / sizeof(src_printer_mech[0])),
+        0x0118
     },
     {
         { "control-program-cr", "Control Program CR",
           "Control-program utility deck with the serial Hollerith loader kept.",
           SAT_BATCH_READER },
-        src_control_program, (int)(sizeof(src_control_program) / sizeof(src_control_program[0]))
+        src_control_program, (int)(sizeof(src_control_program) / sizeof(src_control_program[0])),
+        0x0000
     },
     {
         { "ls600-controller-sat", "LS600 Controller SAT Batch",
           "Sequencer Program followed by LS600 Controller Test, prepared per the SAT notes.",
           SAT_BATCH_READER },
-        src_ls600_controller, (int)(sizeof(src_ls600_controller) / sizeof(src_ls600_controller[0]))
+        src_ls600_controller, (int)(sizeof(src_ls600_controller) / sizeof(src_ls600_controller[0])),
+        0x0000
     },
     {
         { "ls600-transcoder-sat", "LS600 Transcoder SAT Batch",
           "Sequencer Program followed by LS600 Transcoder Test, prepared per the SAT notes.",
           SAT_BATCH_READER },
-        src_ls600_transcoder, (int)(sizeof(src_ls600_transcoder) / sizeof(src_ls600_transcoder[0]))
+        src_ls600_transcoder, (int)(sizeof(src_ls600_transcoder) / sizeof(src_ls600_transcoder[0])),
+        0x0000
     },
     {
         { "ls600-doe-sat", "LS600 D.O.E. SAT Batch",
           "Sequencer Program followed by the LS600 D.O.E. deck, prepared per the SAT notes.",
           SAT_BATCH_READER },
-        src_ls600_doe, (int)(sizeof(src_ls600_doe) / sizeof(src_ls600_doe[0]))
+        src_ls600_doe, (int)(sizeof(src_ls600_doe) / sizeof(src_ls600_doe[0])),
+        0x0000
     },
 };
 
@@ -174,6 +212,20 @@ static const struct sat_batch_def *sat_batch_def_find(const char *id)
     return NULL;
 }
 
+static void sat_apply_image_patches(const struct sat_batch_def *def, unsigned char *image)
+{
+    const struct sat_image_patch *patches = NULL;
+    size_t npatches = 0;
+
+    if (strcmp(def->info.id, "printer-mechanical") == 0) {
+        patches = printer_mech_center_card;
+        npatches = sizeof(printer_mech_center_card) / sizeof(printer_mech_center_card[0]);
+    }
+
+    for (size_t i = 0; i < npatches; i++)
+        image[patches[i].addr] = patches[i].value;
+}
+
 static void sat_note(char *note, size_t note_sz, const struct sat_batch_def *def)
 {
     if (!note || note_sz == 0)
@@ -218,7 +270,8 @@ int sat_batch_prepare_image(const char *root, const char *id,
     if (rc < 0)
         return -1;
 
-    *entry = (uint16_t)*lo;
+    sat_apply_image_patches(def, image);
+    *entry = def->image_entry ? def->image_entry : (uint16_t)*lo;
     sat_note(note, note_sz, def);
     return 0;
 }

tests/printer.c

@@ -224,7 +224,7 @@ UTEST(printer, channel2_output_driven)
     g.mem_written[buf + 1] = 1;
 
     ge_start(&g);
-    printer_begin_output(&g, buf, 2);
+    printer_begin_output(&g, buf, 2, 0);
 
     /* Run enough cycles for the 2 transfers + the end cycle; it self-terminates. */
     for (int i = 0; i < 6; i++)
@@ -326,6 +326,32 @@ UTEST(printer, output_per_prints_and_halts_when_polled)
     ge_deinit(&g);
 }
 
+UTEST(printer, line_printer_write_ends_with_newline)
+{
+    struct ge g;
+    uint16_t buf = 0x0200;
+    ge_init(&g);
+
+    g.mem[buf + 0] = 0x55;  /* E */
+    g.mem[buf + 1] = 0x55;  /* E */
+
+    ge_clear(&g);
+    printer_register(&g);
+    printer_begin_output(&g, buf, 2, 1);
+
+    for (int i = 0; i < 80; i++) {
+        if (ge_run_cycle(&g))
+            break;
+    }
+
+    ASSERT_EQ(printer_output_len(&g), 3);
+    ASSERT_EQ(printer_output(&g)[0], 'E');
+    ASSERT_EQ(printer_output(&g)[1], 'E');
+    ASSERT_EQ(printer_output(&g)[2], '\n');
+
+    ge_deinit(&g);
+}
+
 UTEST(printer, input_line_waits_for_keyboard_and_fills_buffer)
 {
     struct ge g;