codecin 6.2.2__tar.gz → 6.3.1__tar.gz

{codecin-6.2.2 → codecin-6.3.1}/CHANGELOG.md

@@ -5,6 +5,48 @@
 
 ---
 
+## [6.3.1] - 2026-10-25
+
+一次以「终端缓存与实时输出」为主题的小版本：新增终端缓存技术，启动/编译期间
+提前键入的内容不再丢失，程序输出在执行过程中即可实时呈现，终端交互与动态特效
+更加生动流畅；同时保留完整输出缓存，管道 / 重定向 / 测试捕获行为保持不变。
+
+### 新增 (Added)
+
+#### 终端缓存技术
+
+- **输入缓存 (type-ahead)**：键盘监听 / 交互式行输入首次激活时，不再清空
+  终端里尚未被读取的残留输入，而是读入统一的键码队列 —— 用户在程序启动、
+  编译期间提前键入的字符不会丢失，`get_key` / `key_wait` / `input` /
+  `input_str` 可直接消费。
+  - Windows 端同时跳过鼠标、窗口、焦点与 key-up 事件继续读取，避免队列
+    被非按键事件卡住。
+  - 需要主动丢弃旧输入时调用 `key_flush()`：清空键码队列、解码中间态与
+    终端残留输入（Windows `FlushConsoleInputBuffer`，Unix 非阻塞排空）。
+- **输出缓存**：实时输出模式下，程序输出在逐条写往终端的同时仍完整保留在
+  执行结果中（`Result.Output`），新增 `streamed` 标记告知宿主"已实时显示、
+  不要重复打印"；API 调用方与测试仍可读取完整输出。
+- **运行前状态实时显示**：真实终端下依次输出 `Loading <文件> ...` →
+  `Loaded N instructions in X ms` → `Running ...`，编译/装载阶段不再黑屏
+  等待；`--log-level ERROR` 与管道输出保持干净。
+- **演示程序**：新增 `examples/terminal_cache_demo.cin`，覆盖打字机/旋转指示器/
+  进度条实时动画、动画期间提前输入的文字与原始键码读取，以及 `key_flush()`
+  显式清理；直接运行 `codecin examples/terminal_cache_demo.cin` 即可体验。
+
+### 变更 (Changed)
+
+- **执行与输出时效性优化**：Python CLI 与 AOT 产物（VM 后端及生成的原生
+  后端）在真实终端下改为边执行边写标准输出，`print` / 终端绘制类特效不再
+  等整个程序结束后一次性出现；管道 / 重定向 / 测试捕获仍保持"缓冲 + 结束
+  回传"，输出字节与旧版本完全一致。
+- **原生 ABI 扩展**：`codecin_run_v2` 的 `flags` 新增 bit1 = 实时输出请求；
+  结果缓冲 36 字节头中 `offset 2` 由保留字节改为 `streamed` 标志（`offset 3`
+  仍为保留字节），布局与长度不变。
+- 版本号提升至 **6.3.1**（`codecin/__init__.py` 单一真源，
+  `codecin/native/engine/version_gen.go` 同步）。
+
+---
+
 ## [6.2.2] - 2026-10-24
 
 一次以「注册服务与输入设备」为主题的小版本：`registry` 服务端由 Go 迁移到

{codecin-6.2.2/codecin.egg-info → codecin-6.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecin
-Version: 6.2.2
+Version: 6.3.1
 Summary: Code CIN - 高级语言与运行时 (CIN/PL/ASM 工具链 + Go 原生 VM + ARM64/RISC-V/FP/Vector 指令集)
 Author: ByUsi Studio, 北啊呢
 License-Expression: MIT
@@ -76,12 +76,10 @@ cvm env
 安装后的包无需修改源码即可导入：
 
 ```cin
-import "hello"                  // 包入口 (pic.toml 的 entry)
-import "hello/util.cin"         // 包内文件
+import "hello"
+import "hello/util.cin"
 ```
 
-完整设计、格式与验收标准见 [V6.2.0-PLAN.md](V6.2.0-PLAN.md)。
-
 ## 文档
 
 **官方文档站**位于独立仓库

{codecin-6.2.2 → codecin-6.3.1}/README.md

@@ -58,12 +58,10 @@ cvm env
 安装后的包无需修改源码即可导入：
 
 ```cin
-import "hello"                  // 包入口 (pic.toml 的 entry)
-import "hello/util.cin"         // 包内文件
+import "hello"
+import "hello/util.cin"
 ```
 
-完整设计、格式与验收标准见 [V6.2.0-PLAN.md](V6.2.0-PLAN.md)。
-
 ## 文档
 
 **官方文档站**位于独立仓库

{codecin-6.2.2 → codecin-6.3.1}/codecin/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "6.2.2"
+__version__ = "6.3.1"
 __author__ = "ByUsi Studio"
 
 from .config import Config

{codecin-6.2.2 → codecin-6.3.1}/codecin/cli.py

@@ -8,6 +8,7 @@ import argparse
 import contextlib
 import os
 import sys
+import time
 from typing import List, Optional
 
 from . import __version__
@@ -36,6 +37,14 @@ HELP_INTRO = f"""{Colors.colorize(f'Code CIN v{__version__}', Colors.CYAN, True)
 """
 
 
+def _stdout_is_tty() -> bool:
+    """stdout 是否为真实终端 (仅此时打印运行前进度状态)。"""
+    try:
+        return bool(sys.stdout is not None and sys.stdout.isatty())
+    except (OSError, ValueError, AttributeError):
+        return False
+
+
 def build_parser() -> argparse.ArgumentParser:
     """参数表单一来源 (与 Config 字段一一对应)。"""
     p = argparse.ArgumentParser(
@@ -446,6 +455,13 @@ def main(argv: Optional[List[str]] = None) -> int:
     if ns.build_exe is not None:
         return _run_aot_build(ns, console, program_file, config)
 
+    # 运行前进度/状态只在真实终端且未静音 (log-level ERROR) 时显示,
+    # 管道/重定向与"保持示例输出干净"的场景不受影响。
+    tty = _stdout_is_tty() and config.log_level.upper() not in ('ERROR', 'CRITICAL')
+    if tty:
+        console.print(Colors.colorize(
+            f"Loading {os.path.basename(program_file)} ...", Colors.CYAN))
+    load_started = time.perf_counter()
     try:
         from .cpu import CPU
         cpu = CPU(config, program_file, crom_file=crom_file)
@@ -460,6 +476,12 @@ def main(argv: Optional[List[str]] = None) -> int:
                 console.print_exception()
         return 1
 
+    if tty:
+        console.print(Colors.colorize(
+            f"Loaded {len(cpu.instructions)} instructions in "
+            f"{(time.perf_counter() - load_started) * 1000:.1f} ms",
+            Colors.GREEN))
+
     try:
         # 管道/重定向输入预读到 input_buffer: 让 input() 在原生与解释器路径下
         # 都能读到 `"42" | codecin t.cin` 这样的标准输入 (交互 TTY 不预读)。
@@ -477,6 +499,9 @@ def main(argv: Optional[List[str]] = None) -> int:
             if config.compile_only:
                 return 0
 
+        if tty:
+            console.print(Colors.colorize("Running ...", Colors.CYAN))
+            sys.stdout.flush()  # 状态行先落盘, 程序实时输出紧随其后
         cpu.run()
     except KeyboardInterrupt:
         pass

{codecin-6.2.2 → codecin-6.3.1}/codecin/cpu.py

@@ -33,6 +33,14 @@ NATIVE_HINT = (
     "或 codecin/native/build.sh (Linux/Termux/macOS), 然后重试。")
 
 
+def _stdout_is_tty() -> bool:
+    """stdout 是否为真实终端 (决定是否请求实时输出)。"""
+    try:
+        return bool(sys.stdout is not None and sys.stdout.isatty())
+    except (OSError, ValueError, AttributeError):
+        return False
+
+
 class CPU:
     def __init__(self, config, filename: Optional[str] = None,
                  crom_file: Optional[str] = None,
@@ -184,6 +192,13 @@ class CPU:
         bytecode = encode_program(self.instructions, self.entry_pc, all_labels)
         segments = self.memory.snapshot_segments()
         import time as _time
+        # 真实终端 + 非捕获模式: 请求原生引擎边执行边输出 (输出缓存仍会回传)。
+        stream = (not self._capture_output) and _stdout_is_tty()
+        if stream:
+            try:
+                sys.stdout.flush()  # 先落盘 Python 侧日志, 保证输出顺序
+            except (OSError, ValueError):
+                pass
         t0 = _time.perf_counter()
         result = engine.run_v2(
             bytecode=bytecode,
@@ -197,6 +212,7 @@ class CPU:
             args=list(self.config.program_args),
             seed=self.config.seed,
             sandbox=self.config.sandbox_mode,
+            stream_output=stream,
         )
         elapsed = _time.perf_counter() - t0
         if result is None:
@@ -211,7 +227,11 @@ class CPU:
 
         self._apply_native_state(result)
         if result.get('output'):
-            self._emit_text(result['output'])
+            if result.get('streamed'):
+                # 终端已实时显示; 这里只把完整输出放进缓存供调用方读取
+                self.output_buffer.append(result['output'])
+            else:
+                self._emit_text(result['output'])
         if result.get('error'):
             raise ExecutionError(result['error'])
         return False

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/aot/aot.go

@@ -54,13 +54,17 @@ func Main(bytecode, segFile []byte) int {
 		MemSize:  int64(memSize),
 		Input:    in,
 		MaxSteps: maxSteps,
+		// AOT 产物在真实终端下边跑边输出; 管道/重定向保持结束一次性打印。
+		StreamOutput: true,
 	})
 	if res == nil {
 		fmt.Fprintln(os.Stderr, "runtime error: no result")
 		return 1
 	}
 	engine.ConsoleInit()
-	fmt.Print(res.Output)
+	if !res.Streamed { // 实时模式下输出已写到终端, Output 只是缓存
+		fmt.Print(res.Output)
+	}
 	if res.Status == engine.StatusError ||
 		res.Status == engine.StatusUnsupported {
 		msg := res.ErrMsg

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/engine/keyboard.go

@@ -80,12 +80,17 @@ var keyOutSink = func(s string) {
 }
 
 // keyEnsure 惰性启用键盘监听; 可重复调用 (恢复后再次调用会重新启用)。
-// 返回是否"本次调用刚激活" (真实终端首次启用), 供 VM 切换直写输出。
+// 返回是否"本次调用刚激活" (真实终端首次启用), 供 VM 切换实时输出。
+// 激活时把终端里已经键入、尚未被程序读取的字符读入队列 (type-ahead 缓存),
+// 不丢弃 —— 用户在程序启动/编译期间敲下的输入不会丢失。
 func keyEnsure() bool {
 	keyMu.Lock()
 	defer keyMu.Unlock()
 	if !keyReady && !keyForcedOff {
 		keyReady = keyEnablePlatform()
+		if keyReady {
+			keyDrainLocked()
+		}
 		return keyReady
 	}
 	return false
@@ -155,6 +160,7 @@ func (vm *vmState) keyGet() uint64 {
 }
 
 // keyFlush SYS 118: key_flush() 清空键码队列与解码中间态 -> 0
+// 同时丢弃终端里尚未读取的输入缓存, 避免下一次轮询又把旧键读回来。
 func (vm *vmState) keyFlush() uint64 {
 	if keyEnsure() {
 		vm.enterDirectOut()
@@ -168,6 +174,9 @@ func (vm *vmState) keyFlush() uint64 {
 	keyU8N = 0
 	keyU8Acc = 0
 	keyResetPlatform()
+	if keyReady {
+		keyFlushPlatform()
+	}
 	return 0
 }
 

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/engine/keyboard_other.go

@@ -31,15 +31,7 @@ func keyEnablePlatform() bool {
 	if ttyIoctl(ttySetAttr, &raw) != nil {
 		return false
 	}
-	// 清空激活前残留的输入缓存 (如启动命令时敲下的回车)。
-	// 已是非阻塞 (VMIN=0/VTIME=0): read 无输入时立即返回 0, 不会卡住。
-	var b [64]byte
-	for {
-		n, err := syscall.Read(0, b[:])
-		if n <= 0 || err != nil {
-			break
-		}
-	}
+	
 	return true
 }
 
@@ -53,6 +45,18 @@ func keyRestorePlatform() {
 // keyResetPlatform 重置平台侧解码中间态 (key_flush 调用; Unix 无)。
 func keyResetPlatform() {}
 
+// keyFlushPlatform 丢弃内核输入队列里尚未读取的字节 (key_flush)。
+// 仅在 raw 模式 (VMIN=0/VTIME=0) 下调用, read 无输入时立即返回 0。
+func keyFlushPlatform() {
+	var b [64]byte
+	for {
+		n, err := syscall.Read(0, b[:])
+		if n <= 0 || err != nil {
+			break
+		}
+	}
+}
+
 // keyNext 非阻塞读 stdin 并经转义序列状态机解码。
 func keyNext() (uint64, bool) {
 	for {

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/engine/keyboard_stub.go

@@ -11,4 +11,7 @@ func keyRestorePlatform() {}
 // keyResetPlatform 重置平台侧解码中间态 (key_flush 调用; stub 无)。
 func keyResetPlatform() {}
 
+// keyFlushPlatform 丢弃平台侧残留输入 (stub 无)。
+func keyFlushPlatform() {}
+
 func keyNext() (uint64, bool) { return 0, false }

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/engine/keyboard_test.go

@@ -178,8 +178,8 @@ func TestKeyHitAndDrainGuard(t *testing.T) {
 	}
 }
 
-// TestEnterDirectOutStreamsBuffer 直写模式: 激活时先落盘已缓冲输出,
-// 之后 outWrite 逐条直写且不进缓冲 (Result.Output 保持为空, 不双打)。
+// TestEnterDirectOutStreamsBuffer 实时输出模式: 激活时先把已缓冲输出落盘,
+// 之后 outWrite 逐条直写, 同时缓冲保留完整缓存 (Result.Output 仍可读取)。
 func TestEnterDirectOutStreamsBuffer(t *testing.T) {
 	resetKeyState()
 	defer resetKeyState()
@@ -191,21 +191,21 @@ func TestEnterDirectOutStreamsBuffer(t *testing.T) {
 	vm := newHostVM(4096)
 	vm.outWrite("A")
 	if vm.out.String() != "A" {
-		t.Fatalf("直写激活前输出应留在缓冲, 实际 %q", vm.out.String())
+		t.Fatalf("实时输出激活前输出应留在缓冲, 实际 %q", vm.out.String())
 	}
 	vm.enterDirectOut()
 	if len(got) != 1 || got[0] != "A" {
 		t.Fatalf("激活时应把已缓冲输出落盘, 实际 %v", got)
 	}
-	if vm.out.Len() != 0 || !vm.outDirect {
-		t.Fatal("激活后缓冲应清空且置直写标志")
+	if vm.out.String() != "A" || !vm.outDirect {
+		t.Fatalf("激活后应保留输出缓存且置实时标志, 实际 %q", vm.out.String())
 	}
 	vm.outWrite("B")
 	if len(got) != 2 || got[1] != "B" {
 		t.Fatalf("激活后输出应逐条直写, 实际 %v", got)
 	}
-	if vm.out.Len() != 0 {
-		t.Fatalf("直写模式下不应再进缓冲, 实际 %q", vm.out.String())
+	if vm.out.String() != "AB" {
+		t.Fatalf("实时模式下仍应缓存完整输出, 实际 %q", vm.out.String())
 	}
 	if vm.outCount != 2 {
 		t.Fatalf("outCount 应累计 2, 实际 %d", vm.outCount)

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/engine/keyboard_windows.go

@@ -52,8 +52,8 @@ var (
 	keySurrogate rune // UTF-16 高代理缓存 (与下一事件低代理组合)
 )
 
-// keyEnablePlatform 校验 stdin 为真实控制台后启用, 并清空启动前残留的
-// 输入缓存 (如启动命令时敲下的回车), 避免程序一激活就吃到旧键。
+// keyEnablePlatform 校验 stdin 为真实控制台后启用。启动前已键入的字符
+// 不再丢弃: keyEnsure 会立即把它们读入键码队列 (终端输入缓存)。
 func keyEnablePlatform() bool {
 	h := consoleHandle()
 	if h == 0 {
@@ -71,7 +71,6 @@ func keyEnablePlatform() bool {
 	raw |= cmExtendedFlags
 	raw &^= cmQuickEdit
 	_, _, _ = procSetConsoleMode.Call(h, uintptr(raw))
-	_, _, _ = procFlushInputBuf.Call(h)
 	return true
 }
 
@@ -87,6 +86,13 @@ func keyRestorePlatform() {
 // keyResetPlatform 重置平台侧解码中间态 (key_flush 调用)。
 func keyResetPlatform() { keySurrogate = 0 }
 
+// keyFlushPlatform 丢弃控制台输入缓冲里尚未读取的残留事件 (key_flush)。
+func keyFlushPlatform() {
+	if h := consoleHandle(); h != 0 {
+		_, _, _ = procFlushInputBuf.Call(h)
+	}
+}
+
 func consoleHandle() uintptr {
 	h, _, _ := procGetStdHandle.Call(stdInputHandle)
 	return h
@@ -105,27 +111,33 @@ var vkKeycode = map[uint16]uint64{
 // keyNext 非阻塞取下一个已解码键码 (PeekConsoleInputW 先行探测, 不会阻塞)。
 // INPUT_RECORD/KEY_EVENT_RECORD 按固定偏移手工解码
 // (sizeof(INPUT_RECORD)=20; keyDown@4 repeat@8 vk@10 char@14 state@16)。
+// 鼠标/窗口/焦点事件与 key-up 事件直接丢弃并继续读, 直到取到按键或队列为空。
 func keyNext() (uint64, bool) {
 	h := consoleHandle()
 	if h == 0 {
 		return 0, false
 	}
-	var buf [20]byte
-	var n uint32
-	r, _, _ := procPeekInput.Call(h, uintptr(unsafe.Pointer(&buf[0])), 1,
-		uintptr(unsafe.Pointer(&n)))
-	if r == 0 || n == 0 {
-		return 0, false
-	}
-	r, _, _ = procReadInput.Call(h, uintptr(unsafe.Pointer(&buf[0])), 1,
-		uintptr(unsafe.Pointer(&n)))
-	if r == 0 || n == 0 {
-		return 0, false
-	}
-	if le16(buf[0:2]) != evtKeyEvent {
-		return 0, false // 鼠标/窗口/焦点等事件: 已读出并丢弃
+	for {
+		var buf [20]byte
+		var n uint32
+		r, _, _ := procPeekInput.Call(h, uintptr(unsafe.Pointer(&buf[0])), 1,
+			uintptr(unsafe.Pointer(&n)))
+		if r == 0 || n == 0 {
+			return 0, false
+		}
+		r, _, _ = procReadInput.Call(h, uintptr(unsafe.Pointer(&buf[0])), 1,
+			uintptr(unsafe.Pointer(&n)))
+		if r == 0 || n == 0 {
+			return 0, false
+		}
+		if le16(buf[0:2]) != evtKeyEvent {
+			continue // 鼠标/窗口/焦点等事件: 已读出并丢弃
+		}
+		if code, ok := decodeKeyEvent(buf[4:20]); ok {
+			return code, true
+		}
+		// key-up / 修饰键 / 代理对中间态: 继续读下一个事件
 	}
-	return decodeKeyEvent(buf[4:20])
 }
 
 func le16(b []byte) uint16 { return uint16(b[0]) | uint16(b[1])<<8 }

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/engine/native.go

@@ -85,6 +85,12 @@ func NewNativeRuntime(memSize, sp, heapBase int64, segments []MemSeg,
 // SetInput 设置 stdin 重定向数据 (IN 指令使用)。
 func (r *NativeRuntime) SetInput(data []byte) { r.vm.inData = data }
 
+// SetStreamOutput 请求实时输出 (AOT 产物): 真实终端下逐条直写 stdout,
+// 同时保留完整缓存 (Finish 不会再打印缓存, 避免重复)。
+func (r *NativeRuntime) SetStreamOutput(on bool) {
+	r.vm.outDirect = on && stdoutIsTerminal()
+}
+
 // SetSandbox 打开沙箱宿主调用限制。
 func (r *NativeRuntime) SetSandbox(on bool) { r.vm.sandbox = on }
 
@@ -620,7 +626,7 @@ func (r *NativeRuntime) Finish(ok bool) int {
 			r.errMsg = "output limit exceeded (16 MiB)"
 		}
 	}
-	if r.vm.out.Len() > 0 {
+	if r.vm.out.Len() > 0 && !r.vm.outDirect {
 		fmt.Print(r.vm.out.String())
 	}
 	if ok {

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/engine/version_gen.go

@@ -4,4 +4,4 @@
 package engine
 
 // BuildVersion 是 Code CIN 的版本号 (被 codecin_version() 与日志使用)。
-const BuildVersion = "6.2.2"
+const BuildVersion = "6.3.1"

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/engine/vm.go

@@ -57,7 +57,7 @@ type vmState struct {
 	out       strings.Builder
 	outOver   bool // 输出超过 maxOutputBytes (截断并置错误)
 	outCount  int  // 两种模式的累计输出字节 (16 MiB 限额依据)
-	outDirect bool // 键盘监听激活 (真实终端): 输出直写 stdout, 不进缓冲
+	outDirect bool // 实时输出模式: 逐条直写 stdout, 同时保留缓冲 (Result.Output 缓存)
 	sysIdx    int
 	rng       *rand.Rand
 	inData    []byte
@@ -144,10 +144,9 @@ func (vm *vmState) outWrite(s string) {
 	}
 	vm.outCount += len(s)
 	if vm.outDirect {
-		keyOutSink(s)
-		return
+		keyOutSink(s) // 实时可见
 	}
-	vm.out.WriteString(s)
+	vm.out.WriteString(s) // 同时缓存: 调用方仍可通过 Result.Output 读取完整输出
 }
 
 // outByte 追加单字节输出 (同上限)。
@@ -161,16 +160,15 @@ func (vm *vmState) outByte(b byte) {
 	}
 	vm.outCount++
 	if vm.outDirect {
-		keyOutSink(string(b))
-		return
+		keyOutSink(string(b)) // 实时可见
 	}
-	vm.out.WriteByte(b)
+	vm.out.WriteByte(b) // 同时缓存
 }
 
-// enterDirectOut 键盘监听激活时切换直写模式: 先把已缓冲输出落到终端
-// (激活前的提示先显示), 之后输出逐条直写 stdout, 不再等程序结束一次性回传。
-// 非终端 (管道/测试捕获) 永远不会激活, 不会走到这里。
-// 激活后 vm.out 恒空 -> Result.Output 为空 -> Python 侧不再打印 (不双打)。
+// enterDirectOut 切换到实时输出模式: 先把已缓冲输出落到终端 (激活前的提示
+// 先显示), 之后输出逐条直写 stdout, 不再等程序结束。缓冲保留, 因此
+// Result.Output 仍包含完整输出 (输出缓存), 调用方依据 Streamed 跳过重复打印。
+// 非终端 (管道/测试捕获) 不会主动切换; 键盘监听激活时也可能走到这里。
 func (vm *vmState) enterDirectOut() {
 	if vm.outDirect {
 		return
@@ -178,7 +176,6 @@ func (vm *vmState) enterDirectOut() {
 	vm.outDirect = true
 	if vm.out.Len() > 0 {
 		keyOutSink(vm.out.String())
-		vm.out.Reset()
 	}
 }
 
@@ -199,6 +196,7 @@ type Result struct {
 	Vec      [32][4]float64
 	Flags    struct{ N, Z, C, V bool }
 	Output   string
+	Streamed bool // 输出已实时写到终端 (Output 仅为缓存, 调用方不要再打印)
 	ErrMsg   string
 	Segments []MemSeg // 脏页合并段 (稀疏内存回传)
 	MemSize  int64
@@ -216,6 +214,9 @@ type RunOptions struct {
 	MaxSteps int64
 	Sandbox  bool  // 沙箱: 屏蔽宿主能力系统调用
 	Seed     int64 // 随机种子; 0 = 时间随机
+	// StreamOutput 请求实时输出: 真实终端下边执行边写 stdout,
+	// 同时保留完整输出缓存 (Result.Output)。非终端忽略此请求。
+	StreamOutput bool
 }
 
 func decodeBytecode(bc []byte) ([]instruction, int, bool) {
@@ -318,6 +319,8 @@ func RunV2(opts *RunOptions) *Result {
 	if opts.Seed != 0 {
 		vm.rng.Seed(opts.Seed)
 	}
+	// 真实终端才启用实时输出; 管道/重定向/测试捕获保持"结束一次性回传"。
+	vm.outDirect = opts.StreamOutput && stdoutIsTerminal()
 	vm.dirtyBits = make([]uint64,
 		(uint64(memSize)+(1<<(dirtyPageShift+6))-1)>>(dirtyPageShift+6))
 	// 初始段视为已写内容: 数据段通常会被改写, 直接并入脏位图, 免去逐字节 touch。
@@ -341,16 +344,17 @@ func RunV2(opts *RunOptions) *Result {
 			}
 		}
 		r := &Result{
-			Status:  status,
-			Pc:      vm.pc,
-			Sp:      vm.sp,
-			HeapPtr: vm.heapPtr,
-			Steps:   vm.steps,
-			Regs:    vm.regs,
-			Vec:     vm.vec,
-			Output:  vm.out.String(),
-			ErrMsg:  errMsg,
-			MemSize: memSize,
+			Status:   status,
+			Pc:       vm.pc,
+			Sp:       vm.sp,
+			HeapPtr:  vm.heapPtr,
+			Steps:    vm.steps,
+			Regs:     vm.regs,
+			Vec:      vm.vec,
+			Output:   vm.out.String(),
+			Streamed: vm.outDirect,
+			ErrMsg:   errMsg,
+			MemSize:  memSize,
 		}
 		r.Flags.N, r.Flags.Z, r.Flags.C, r.Flags.V = vm.flags.N, vm.flags.Z, vm.flags.C, vm.flags.V
 		r.Segments = vm.dirtySegments()
@@ -1055,14 +1059,15 @@ func (vm *vmState) prepareQueryInput() {
 // flushOut 在阻塞读标准输入前, 把已缓冲输出冲刷到真实终端。
 // 仅在 stdout 为终端时生效 (交互提示可见); 管道/重定向/测试捕获保持
 // 纯缓冲语义 —— 输出仍随 Result.Output 一次性回传, 字节序列不变。
-// 冲刷后 vm.out 清空, 回传结果里不再包含这部分 (不重复打印)。
+// 冲刷后保持实时模式且不清空缓存: 后续输出继续直写, Result.Output 仍是
+// 完整缓存 (Result.Streamed=true, Python 侧据此不重复打印)。
 func (vm *vmState) flushOut() {
 	if vm.outDirect || vm.out.Len() == 0 || !stdoutIsTerminal() {
 		return
 	}
 	consoleInit()
 	keyOutSink(vm.out.String())
-	vm.out.Reset()
+	vm.outDirect = true
 }
 
 // ---------------- SYS ----------------

{codecin-6.2.2 → codecin-6.3.1}/codecin/native/main.go

@@ -25,7 +25,7 @@ import (
 //   err_len u16 | err ...
 
 // v2 结果缓冲布局 (与 codecin/native.py _parse_result_v2 严格一致):
-//   status u8 | NZCV 标志 u8 (bit0=N bit1=Z bit2=C bit3=V) | 2B pad
+//   status u8 | NZCV 标志 u8 (bit0=N bit1=Z bit2=C bit3=V) | streamed u8 | pad u8
 //   pc u64  sp u64  heap_ptr u64  steps u64
 //   regs 33×u64
 //   vec  32×4×f64
@@ -158,6 +158,7 @@ func marshalResultV2(res *engine.Result) unsafe.Pointer {
 
 	var status byte
 	var flg byte
+	var streamed byte
 	pc, sp, heap, steps := uint64(0), uint64(0), uint64(0), uint64(0)
 	var regs [33]uint64
 	var vec [32][4]float64
@@ -184,6 +185,9 @@ func marshalResultV2(res *engine.Result) unsafe.Pointer {
 		if res.Flags.V {
 			flg |= 8
 		}
+		if res.Streamed {
+			streamed = 1
+		}
 	}
 
 	segsBytes := 0
@@ -195,6 +199,7 @@ func marshalResultV2(res *engine.Result) unsafe.Pointer {
 
 	buf[0] = status
 	buf[1] = flg
+	buf[2] = streamed
 	pos := 4
 	binary.LittleEndian.PutUint64(buf[pos:], pc)
 	binary.LittleEndian.PutUint64(buf[pos+8:], sp)
@@ -276,13 +281,14 @@ func codecin_run_v2(reqPtr unsafe.Pointer, reqLen C.int,
 	}
 
 	opts := &engine.RunOptions{
-		Entry:    int64(entry),
-		SP:       int64(sp),
-		HeapBase: int64(heapBase),
-		MemSize:  int64(memSize),
-		MaxSteps: int64(maxSteps),
-		Seed:     int64(seed),
-		Sandbox:  flags&1 != 0,
+		Entry:        int64(entry),
+		SP:           int64(sp),
+		HeapBase:     int64(heapBase),
+		MemSize:      int64(memSize),
+		MaxSteps:     int64(maxSteps),
+		Seed:         int64(seed),
+		Sandbox:      flags&1 != 0,
+		StreamOutput: flags&2 != 0,
 	}
 	pos := 0
 	bcLen := readU32(&pos)