restoreLive 실행 경계 계약을 기계 강제로 (외부 리뷰 최우선 지적 수용)

- Runtime.execSeq 상태 변이 카운터(run/runAsync/setGlobal/install/loadPackages)로
  경계 위반을 O(1) 감지. restoreLive가 위반 시 자동으로 재해시 경로 승격 = 조용히
  틀린 복원 불가능. 실측: 위반 27.4ms 안전 복원, 준수 0.69ms 즉시 경로(rehashed 플래그).
- probe를 가드 검증형으로 갱신(자동 감지 + 즉시 경로 보존), 게이트 20검사 green.
- restore()의 힙 성장 비대칭 관찰(리뷰 부수 지적)을 계약 실태 표 열린 항목으로 등록.
- README/소비 계약/타입(RestoreInfo.rehashed) 동기화.

Author: eddmpython

README.ko.md

@@ -103,7 +103,7 @@ reactive.restoreLive(cp.index, sp0);          // 라이브-차분 복원(바뀐
 console.log(rt.run("x"));                      // 1
 ```
 
-**실행 경계 계약**: `restoreLive`는 저장된 해시끼리만 비교한다(재해싱 0 = 즉시성의 근거). 그래서 파이썬을 실행했다면 복원 전에 반드시 `checkpoint()`로 경계를 닫아야 한다. 경계를 보장할 수 없으면 `restore()`(전체 복원, 안전 기준선)를 쓴다.
+**실행 경계 계약(기계 강제)**: `restoreLive`는 경계(마지막 `checkpoint()`/복원 이후 실행 없음)를 지키면 저장 해시 비교만으로 즉시 복원한다(재해싱 0, 실측 ~1ms). 경계 위반(실행·예외·전역 변이)은 상태 변이 카운터로 O(1) 자동 감지되어 재해시 경로로 승격되므로 **조용히 틀린 복원은 일어나지 않는다**(실측 ~27ms). 어느 경로였는지는 반환값 `rehashed`로 확인한다.
 
 ### 빌린 시스템콜 브리지
 

README.md

@@ -103,7 +103,7 @@ reactive.restoreLive(cp.index, sp0);          // live-diff restore (writes only
 console.log(rt.run("x"));                      // 1
 ```
 
-**Execution boundary contract**: `restoreLive` compares stored hashes only (zero re-hashing is what makes it instant). So if you ran Python, you must close that boundary with `checkpoint()` before restoring. If you cannot guarantee the boundary, use `restore()` (full restore, the safe baseline).
+**Execution boundary contract (machine-enforced)**: when the boundary holds (no execution since the last `checkpoint()`/restore), `restoreLive` compares stored hashes only and restores instantly (zero re-hashing, ~1ms measured). A boundary violation (execution, exception, global mutation) is auto-detected in O(1) via a state-mutation counter and the restore upgrades to the re-hash path, so **a silently wrong restore cannot happen** (~27ms measured). The returned `rehashed` flag tells you which path ran.
 
 ### Borrowed syscall bridge
 

docs/consuming/contract.md

@@ -33,7 +33,7 @@ subpath export: `pyproc/runtime`, `pyproc/reactive`, `pyproc/syscall-bridge`, `p
 
 - 타입은 동봉된 `index.d.ts`가 계약이다.
 - 엔진 내부(`HEAPU8`, `Runtime.raw` 등)를 직접 만지지 않는다. `raw`는 탈출구이고 계약 밖이다.
-- **restoreLive 실행 경계 계약**: 파이썬을 실행했다면 복원 전에 `checkpoint()`로 경계를 닫는다. 전제를 보장할 수 없으면 `restore()`(전체 복원)를 쓴다.
+- **restoreLive 실행 경계 계약(기계 강제)**: 경계를 지키면 즉시 복원(재해싱 0), 위반은 자동 감지되어 재해시 경로로 승격된다(조용한 오염 없음). 반환값 `rehashed`로 경로 확인. 즉시성이 필요하면 복원 전 `checkpoint()`로 경계를 닫아라.
 
 ## 방향과 경계
 

index.d.ts

@@ -22,6 +22,8 @@ export interface CheckpointInfo {
 export interface RestoreInfo {
   pagesWritten: number;
   mbWritten: number;
+  /** 이번 복원이 재해시 경로였는지. 경계 위반이 자동 감지되면 true. */
+  rehashed: boolean;
 }
 
 export interface SyscallBridgeConfig {
@@ -73,7 +75,7 @@ export class MemoryCapability {
 export class ReactiveController {
   checkpoint(): CheckpointInfo;
   restore(j: number, savedSP: number | null): void;
-  /** opts.rehash: 실행 경계 계약이 깨졌을 수 있으면(예외로 더러워진 힙) 현재 힙을 재해시해 비교. */
+  /** 경계 위반(마지막 checkpoint/restore 이후 실행·변이)은 자동 감지되어 재해시 경로로 복원된다. opts.rehash는 강제 재해시. */
   restoreLive(j: number, savedSP: number | null, opts?: { rehash?: boolean }): RestoreInfo;
   timeTravel(j: number, savedSP: number | null, opts?: { rehash?: boolean }): RestoreInfo;
   stackSave(): number | null;

mainPlan/web-python-runtime/01-architecture.md

@@ -44,11 +44,12 @@ pyproc의 코어는 새 이론이 아니라 codaro `tests/_attempts`에서 브
 
 | 항목 | 계약 | 실제 | 상태 |
 |---|---|---|---|
-| restoreLive 실행 경계 | 복원 전 마지막 실행을 `checkpoint()`로 닫아야 한다(재해싱 0이 즉시성의 근거) | 계약을 어기면 stale 해시 비교로 0페이지 복원(조용한 오동작). 코드 주석·README 사용례로 계약 명문화 + 브라우저 게이트가 계약 준수 경로를 기계 검증(2026-07-11, restoreLive 0.84ms 실측) | 문서 + 게이트로 고정. 위반 감지 가드는 attempts 후보 |
+| restoreLive 실행 경계 | 경계 준수 시 즉시(재해싱 0), 위반 시에도 조용한 오염 없음 | **기계 강제(2026-07-11)**: Runtime.execSeq(상태 변이 카운터)로 위반을 O(1) 감지해 자동 재해시 승격. 반환값 `rehashed`로 경로 확인, 게이트 상시 검증 | 해소 (외부 리뷰 지적 반영) |
 | 페이지 해시 soundness | 실질적 sound(누락 확률 무시 가능) | 이중 32비트(실효 64비트, ~2^-64)로 승격. 비용 1.54배, 30MB 힙 14.3ms 실측 | 해소 (attempts/reactiveSoundness 졸업, 2026-07-11) |
 | syscallBridge | input/HTTP/subprocess를 실제로 빌린다 | v1 실배선: input(동기 + JSPI `run_sync`), urllib(동기 XHR, proxyUrl 옵션), subprocess(`["python","-c",code]`, 자식 워커, runAsync 경로). 저수준 socket·requests 계열은 미배선 | v1 해소 (attempts/syscallBridge 졸업, 2026-07-11). 잔여는 local-parity 축 |
 | PyProc 오류 경로 | 부팅·행·죽음이 유한 시간에 귀결 | 부팅 실패 reject + `map(.., {taskTimeoutMs})` 행 수렴 + kill/스냅샷 respawn(302ms 실측). 남은 것: 협조적 취소(SIGINT) | 해소 (attempts/processLifecycle 졸업, 2026-07-11). 취소는 후보 |
 | Pyodide 스냅샷 API | 스냅샷-fork | `_makeSnapshot`/`_loadSnapshot`은 Pyodide 밑줄(실험) API. 버전 핀(v314.0.2)으로만 안전 | 버전 올릴 때 최우선 재검증 항목 |
+| restore()의 힙 성장 처리 | 두 복원 경로의 성장 처리 동등 | restore()(전체 복원)는 base 범위 밖 성장 페이지를 되돌리지 않고, restoreLive는 명시 처리한다(비대칭). 다음 checkpoint의 성장분 루프가 체인을 다시 정합시키므로 실해는 없을 가능성이 높으나 미실측 | 열림(외부 리뷰 관찰). runtimeParity probe 후보 |
 
 ## 프론티어 (정직한 벽 = WASM dlopen)
 

mainPlan/web-python-runtime/03-progress-ledger.md

@@ -4,6 +4,12 @@
 
 ## 결정 원장 (최신이 위)
 
+### 2026-07-11 외부 리뷰 대응: restoreLive 경계 계약을 기계 강제로
+
+- 외부 코드 리뷰의 최우선 지적("sound를 파는 라이브러리에서 soundness 전제가 강제되지 않는다") 수용. `Runtime.execSeq`(상태 변이 카운터: run/runAsync/setGlobal/install/loadPackages)로 경계 위반을 **O(1) 감지**해 restoreLive가 자동으로 재해시 경로로 승격. 실측: 위반 시 27.4ms 안전 복원, 준수 시 0.69ms 즉시 경로 유지(`rehashed` 플래그로 확인).
+- 리뷰의 다른 지적 중 SIGINT 부재·버전 관문·OPFS 경제성은 리뷰 시점 이후 이미 해소됐음을 확인. "리액티브 과설계" 우려는 dartlab의 독립 재발명이 수요 반증. restore()의 힙 성장 비대칭 관찰은 계약 실태 표에 열린 항목으로 등록(probe 후보).
+- 릴리즈 0.0.4(버전만. 태그 폐지 정책 확정: 표식은 package.json 하나, npm 퍼블리시 개시 시 태그를 절차의 자동 산출물로 재도입).
+
 ### 2026-07-11 dartlab 흡수 완주 + parity 승격 5종 (게이트 20검사)
 
 - 한 턴에 승격 5종: `restoreLive({rehash})`(예외 안전 복원), `AsgiServer`(소켓 0 dispatch 3.4ms), `Terminal`(+examples/terminal.html), `interrupt(pid)`(SIGINT 517ms 수렴, respawn 0), `saveBase/loadBase`(OPFS 영속, 30MB 쓰기 256ms/읽기 46ms).

src/capabilities/reactive.js

@@ -3,25 +3,27 @@
 // WASM은 mprotect/dirty-page가 없어 실행 경계마다 완전 해시로 델타를 재구성한다.
 // 완전 해시(Uint32 워드)가 sound의 열쇠 - 샘플링은 불완전 델타 -> 복원 크래시.
 //
-// 실행 경계 계약 (소비자가 지켜야 하는 규율):
-//   restoreLive()는 "마지막 checkpoint()/restore() 이후 파이썬 실행이 없었다"를 전제한다.
-//   저장된 liveIdx 해시가 현재 힙을 대변한다고 믿고 재해싱 없이 비교하기 때문이다(그래서 즉시).
-//   실행을 했다면 반드시 checkpoint()로 경계를 닫고 나서 복원하라. 전제를 보장할 수 없으면
-//   restore()(전체 복원, 안전 기준선)를 쓴다. 이 계약은 README 사용례와 함께 유지한다.
+// 실행 경계 계약 (기계 강제, 2026-07-11부터):
+//   restoreLive()의 즉시성(재해싱 0)은 "마지막 checkpoint()/restore() 이후 실행 없음"이 전제다.
+//   이 전제를 Runtime.execSeq(상태 변이 카운터)로 O(1) 감지한다. 경계가 깨져 있으면(실행·예외·
+//   setGlobal 등) 조용한 오염 대신 자동으로 재해시 경로로 승격해 복원한다. 반환값 rehashed로
+//   어느 경로였는지 알 수 있고, opts.rehash로 강제할 수도 있다.
 import { PAGE_SIZE as PAGE } from "../runtime/memoryCapability.js";
 
 // Runtime.enableReactive()가 이 컨트롤러를 만든다. 소비자는 checkpoint/restore만 쓴다.
 export class ReactiveController {
   constructor(rt) {
-    this._mem = rt.memory;
+    this._rt = rt; this._mem = rt.memory;
     this.base = null; this.deltas = []; this.hashes = []; this.liveIdx = -1; this.prevHashes = null;
+    this._seqAt = -1; // 마지막 checkpoint/restore 시점의 Runtime.execSeq (경계 위반 감지)
   }
   // 현재 힙 상태를 체크포인트로 저장. 첫 호출=base 통째, 이후=바뀐 페이지 델타.
   checkpoint() {
     const mem = this._mem, hashes = mem.pageHashes();
     if (this.base === null) {
       this.base = mem.sliceAll(); this.deltas.push(new Map());
       this.hashes.push(hashes); this.prevHashes = hashes; this.liveIdx = 0;
+      this._seqAt = this._rt.execSeq; // 경계 닫힘
       return { index: 0, changedPages: 0, deltaBytes: this.base.length, kind: "base" };
     }
     // 해시 배열은 페이지당 2워드 interleave(실효 64비트). 두 워드 모두 같아야 "안 바뀜".
@@ -32,6 +34,7 @@ export class ReactiveController {
     for (let p = this.prevHashes.length / 2; p < hashes.length / 2; p++) delta.set(p, mem.slicePage(p)); // 성장분
     this.deltas.push(delta); this.hashes.push(hashes); this.prevHashes = hashes;
     this.liveIdx = this.deltas.length - 1;
+    this._seqAt = this._rt.execSeq; // 경계 닫힘
     let bytes = 0; for (const b of delta.values()) bytes += b.length;
     return { index: this.deltas.length - 1, changedPages: delta.size, deltaBytes: bytes, kind: "delta" };
   }
@@ -45,6 +48,7 @@ export class ReactiveController {
     for (let k = 1; k <= j; k++) for (const [p, b] of this.deltas[k]) mem.writePage(p, b);
     mem.stackRestore(savedSP);
     this.liveIdx = j; this.prevHashes = this.hashes[j];
+    this._seqAt = this._rt.execSeq;
   }
   // 라이브-차분 복원: 저장 해시 비교만(재해싱 0) -> 다른 페이지만 write. 인접 시간여행 즉시.
   // 전제는 파일 상단의 "실행 경계 계약" 참조. 성장 처리: 현재 힙이 목표보다 크면 목표 범위
@@ -53,7 +57,9 @@ export class ReactiveController {
   // 저장 해시 대신 현재 힙을 재해시해 비교한다(dartlab 노트북 런타임에서 흡수, 2026-07-11).
   restoreLive(j, savedSP, opts = {}) {
     const mem = this._mem, targetH = this.hashes[j];
-    const liveH = opts.rehash ? mem.pageHashes() : this.hashes[this.liveIdx];
+    // 경계 위반(마지막 checkpoint/restore 이후 상태 변이) 감지 시 자동으로 재해시 경로 승격.
+    const rehash = !!opts.rehash || this._rt.execSeq !== this._seqAt;
+    const liveH = rehash ? mem.pageHashes() : this.hashes[this.liveIdx];
     const nLive = liveH.length / 2, nTarget = targetH.length / 2; // 페이지당 2워드 interleave
     let written = 0, wroteBytes = 0;
     for (let p = 0; p < nLive; p++) {
@@ -66,7 +72,8 @@ export class ReactiveController {
     }
     mem.stackRestore(savedSP);
     this.liveIdx = j; this.prevHashes = this.hashes[j];
-    return { pagesWritten: written, mbWritten: +(wroteBytes / 1048576).toFixed(2) };
+    this._seqAt = this._rt.execSeq;
+    return { pagesWritten: written, mbWritten: +(wroteBytes / 1048576).toFixed(2), rehashed: rehash };
   }
   timeTravel(j, savedSP, opts = {}) { return this.restoreLive(j, savedSP, opts); }
 

src/runtime/runtime.js

@@ -33,16 +33,18 @@ export class Runtime {
     this._py = py;
     this.memory = new MemoryCapability(py);
     this._micropip = null;
+    this.execSeq = 0; // 상태 변이 카운터. 리액티브가 실행 경계 위반을 O(1)로 감지하는 근거.
   }
-  run(code) { return this._py.runPython(code); }
-  runAsync(code) { return this._py.runPythonAsync(code); }
-  setGlobal(name, value) { this._py.globals.set(name, value); }
+  run(code) { this.execSeq++; return this._py.runPython(code); }
+  runAsync(code) { this.execSeq++; return this._py.runPythonAsync(code); }
+  setGlobal(name, value) { this.execSeq++; this._py.globals.set(name, value); }
   getGlobal(name) { return this._py.globals.get(name); }
   async install(pkg) {
+    this.execSeq++;
     if (!this._micropip) { await this._py.loadPackage("micropip"); this._micropip = this._py.pyimport("micropip"); }
     await this._micropip.install(pkg);
   }
-  async loadPackages(pkgs) { await this._py.loadPackage(pkgs); }
+  async loadPackages(pkgs) { this.execSeq++; await this._py.loadPackage(pkgs); }
 
   // Layer 1 능력 등록(opt-in). 소비자는 능력 계약만 받고 엔진 내부는 만지지 않는다.
   enableReactive() { return new ReactiveController(this); }

tests/attempts/runtimeParity/exceptionRestoreProbe.html

@@ -25,16 +25,19 @@ <h1>probe: 예외로 더러워진 힙의 안전 복원 (dartlab 흡수)</h1>
     try { rt.run("x = 999\nraise ValueError('boom')"); } catch (e) {}
     check("전제: 예외 후 힙은 더럽다(x==999)", rt.run("x") === 999);
 
-    // 결함 재현: 저장 해시 신뢰 복원은 stale 비교라 오염을 못 본다
-    reactive.restoreLive(cp.index, sp0);
-    check("결함 재현: rehash 없는 restoreLive는 오염 잔존(x==999)", rt.run("x") === 999);
-
-    // 흡수한 해법: 현재 힙 재해시 후 복원
-    try { rt.run("x = 555\nraise ValueError('boom2')"); } catch (e) {}
+    // 기계 가드: 경계 위반을 execSeq로 감지해 자동 재해시 승격 -> 옵션 없이도 안전
     const t0 = performance.now();
-    const r = reactive.restoreLive(cp.index, sp0, { rehash: true });
-    timings.rehashRestoreMs = +(performance.now() - t0).toFixed(1);
-    check("해법: restoreLive({rehash})가 x==1 복원", rt.run("x") === 1, `${timings.rehashRestoreMs}ms, ${r.pagesWritten}p`);
+    const r = reactive.restoreLive(cp.index, sp0);
+    timings.autoRehashMs = +(performance.now() - t0).toFixed(1);
+    check("가드: 경계 위반 자동 감지 + 재해시 복원(x==1)", rt.run("x") === 1 && r.rehashed === true, `${timings.autoRehashMs}ms, ${r.pagesWritten}p`);
+
+    // 경계를 지키면 즉시 경로 유지(재해싱 0)
+    rt.run("x = 5");
+    reactive.checkpoint();
+    const t1 = performance.now();
+    const r2 = reactive.restoreLive(cp.index, sp0);
+    timings.fastPathMs = +(performance.now() - t1).toFixed(2);
+    check("경계 준수 시 즉시 경로 유지(rehashed=false)", r2.rehashed === false && rt.run("x") === 1, `${timings.fastPathMs}ms`);
 
     // 복원 뒤 인터프리터 연속 실행(파이썬이 멀쩡한가)
     check("복원 후 연속 실행", rt.run("x + 41") === 42);

tests/browser/gate.html

@@ -57,8 +57,8 @@ <h1>pyproc 브라우저 게이트</h1>
       check("restore: 전체 복원으로 x === 1", rt.run("x") === 1);
 
       try { rt.run("x = 555\nraise ValueError('boom')"); } catch (e) {} // 예외 = 경계 없는 오염
-      reactive.restoreLive(cp.index, sp0, { rehash: true });
-      check("restoreLive({rehash}): 예외 오염 복원", rt.run("x") === 1);
+      const rr1 = reactive.restoreLive(cp.index, sp0); // 옵션 없이: 가드가 자동 재해시 승격
+      check("restoreLive 가드: 경계 위반 자동 감지 복원", rt.run("x") === 1 && rr1.rehashed === true);
 
       // base의 OPFS 영속: 내보내고 되읽은 base로도 복원이 성립해야 한다
       const opfsRoot = await navigator.storage.getDirectory();