numerical-acceleration 후속 심화: Python numpy->GPU 직결 + GpuArray.map 잔류 체이닝

GPU를 파이썬에 실제로 연결 = pyproc 정체성 완성. 실 GPU(창 모드) 실측.

GpuArray.map(expr): WGSL 표현식(x=원소)을 각 원소에 적용한 새 잔류 핸들. matmul 뒤 활성화
(max(x,0) relu 등)를 리드백 없이 잇는다. 표현식별 파이프라인 캐시.

Runtime.enableGpu() -> GpuBridge(Python numpy 직결): install()이 GPU 디바이스 확보 + 파이썬
pyprocGpu 모듈 배선. pyprocGpu.matmul(a, b)가 numpy 배열을 f32로 GPU에서 곱해 numpy로 반환
(블로킹 = JSPI run_sync, socketBridge 패턴). numpy + 실 GPU + 창 모드 필요.

gpuPythonProbe(실 GPU GREEN 4/4): 파이썬 GPU matmul == CPU numpy maxerr 0.00, 1024 f32
92배(GPU 84ms vs CPU 7682ms). map 잔류 체이닝 matmul->relu == CPU 참조 maxErr 1.19e-7.
헤드리스는 SKIP(CI 무해).

커널 최적화 판정(정직): 연구가 커널 자작 금지(naive vs 최적 600-1000배 격차, jax-js/WgPy
차용 권장) 명시 + 이 GPU 하나에서만 검증 가능 -> naive 타일드(검증 92-109배) 유지, 프로덕션
타일링/차용은 후속. 위험한 자작 커널이 정공법 아니다.

index.js/index.d.ts(GpuBridge/map/enableGpu)/run.mjs/README 2종 + 이니셔티브 원장 완결.
구조 455 + 코어 40/40 + wasiGate 10/10 + 예제 5/5 + 실 GPU 3종(4/4,5/5,4/4) 전부 green.

Author: eddmpython

README.ko.md

@@ -202,7 +202,7 @@ Pyodide  Workers
 | `Init` | OS init: `/home/web/boot.py` 오토런 + `cron.py` 틱, 전부 파일 구동 |
 | `MachineJournal` | WAL: 유휴에 스스로 체크포인트해, 강제종료된 탭도 마지막 커밋으로 부활 |
 | `MachineJail` | 권한 감옥: `permissions{net, clipboard, home, workers}`를 2단 집행. 협조 파이썬 초크포인트 + 브라우저 벽(감옥 컨텍스트의 `connect-src` CSP가 비허용 host 차단, 감옥 코드가 `import js`로 우회해도 무력) |
-| `GpuCompute` / `GpuArray` | f32 대규모 선형대수를 WebGPU 컴퓨트로 오프로드: 잔류 핸들(업로드 1회, GPU 위에서 `matmul` 체이닝, 다운로드 1회). 실 GPU에서 WASM numpy 대비 109배 실측. f32 한정(WGSL은 f64 없음), 창 있는 브라우저 + GPU 필요 |
+| `GpuCompute` / `GpuArray` / `GpuBridge` | f32 대규모 선형대수를 WebGPU 컴퓨트로 오프로드: 잔류 핸들(업로드 1회, GPU 위에서 `matmul` / `map` 체이닝, 다운로드 1회). `Runtime.enableGpu()`가 파이썬에 배선(`pyprocGpu.matmul`이 numpy 배열을). 실 GPU에서 WASM numpy 대비 109배 실측. f32 한정(WGSL은 f64 없음), 창 있는 브라우저 + GPU 필요 |
 | `bootSession` / `Session` / `openMachine` | 세션 부활 + 이동 가능한 `.pymachine` 이미지: 결정적 리플레이 + 사용자 델타, OPFS 영속(`save` / `load`) 또는 한 파일 내보내기(`exportImage` / `openMachine`) |
 | `WheelCache` | 오프라인 / 재다운로드 0 패키지 설치용 wheel / OPFS 캐시 |
 | `PyProc` | 프로세스 OS 커널: 스냅샷-fork 스폰, `map` / `mapArray` 병렬, 수명주기(`kill` / `signal` / respawn), `fork(2)`(살아있는 프로세스 복제, 변수·배열이 실린다), 흐름 IPC(`pipe` / `lock` / `semaphore` / `shm`: SAB 링버퍼 파이프, 진짜 블로킹 read + backpressure) |

README.md

@@ -202,7 +202,7 @@ Capabilities are opt-in - turn on only what you need, and consume the capability
 | `Init` | OS init: `/home/web/boot.py` autorun plus `cron.py` ticks, all file-driven |
 | `MachineJournal` | Write-ahead log: the machine checkpoints itself while idle, so a crashed tab still boots back into its last commit |
 | `MachineJail` | Permission jail: `permissions{net, clipboard, home, workers}` enforced in two tiers, a cooperative Python chokepoint plus the browser's own wall (a `connect-src` CSP on the jail context blocks disallowed hosts even if the jailed code tries `import js`) |
-| `GpuCompute` / `GpuArray` | Offload large f32 linear algebra to WebGPU compute: a residency handle (upload once, chain `matmul` on the GPU, download once). Measured 109x vs WASM numpy on a real GPU; f32 only (WGSL has no f64), needs a windowed browser with a GPU |
+| `GpuCompute` / `GpuArray` / `GpuBridge` | Offload large f32 linear algebra to WebGPU compute: a residency handle (upload once, chain `matmul` / `map` on the GPU, download once). `Runtime.enableGpu()` wires it into Python (`pyprocGpu.matmul` on numpy arrays). Measured 109x vs WASM numpy on a real GPU; f32 only (WGSL has no f64), needs a windowed browser with a GPU |
 | `bootSession` / `Session` / `openMachine` | Session revival and portable `.pymachine` images: deterministic replay plus user delta, persisted to OPFS (`save` / `load`) or exported as one file (`exportImage` / `openMachine`) |
 | `WheelCache` | Wheel / OPFS cache for offline, zero-redownload package installs |
 | `PyProc` | Process OS kernel: snapshot-fork spawn, `map` / `mapArray` parallelism, lifecycle (`kill` / `signal` / respawn), `fork(2)` (clone a live process, its variables and arrays travel), and flow IPC (`pipe` / `lock` / `semaphore` / `shm`: SAB ring-buffer pipes with real blocking read and backpressure) |

index.d.ts

@@ -569,11 +569,23 @@ export class GpuArray {
   readonly cols: number;
   /** 이 배열(M x K) @ other(K x N) = 새 잔류 핸들(M x N). 재업로드 0. */
   matmul(other: GpuArray): GpuArray;
+  /** 원소별 변환(WGSL 표현식, x = 원소)을 적용한 새 잔류 핸들(같은 shape). 예: map("max(x, 0.0)"). matmul 뒤 활성화 체이닝. */
+  map(expr: string): GpuArray;
   /** GPU -> CPU 회수. 반환 { data: Float32Array, rows, cols }. */
   toArray(): Promise<{ data: Float32Array; rows: number; cols: number }>;
   destroy(): void;
 }
 
+/**
+ * Python numpy -> GPU 직결. Runtime.enableGpu()로 얻고 install() 후 파이썬이 pyprocGpu.matmul(a, b)로
+ * numpy 배열을 GPU에서 곱한다(블로킹 = JSPI, rt.runAsync 경로). 실 GPU + 창 모드 + numpy 필요.
+ * f64는 f32로 강등(WGSL 한계, 정밀도 손실은 계약).
+ */
+export class GpuBridge {
+  install(): Promise<{ installed: string; note: string }>;
+  destroy(): void;
+}
+
 /**
  * WebGPU 컴퓨트로 f32 대규모 선형대수 가속(수치 성능 도약 Phase 2). numpy 대체가 아니라 좁은
  * 고피크 레인: matmul 실측 109배 vs WASM numpy(실 GPU). 잔류 핸들(업로드1/체이닝/다운로드1)이
@@ -641,6 +653,8 @@ export class Runtime {
   enableDeviceFs(cfg?: DeviceFsConfig): DeviceFs;
   enableInit(cfg?: InitConfig): Init;
   enableJournal(cfg: JournalConfig): MachineJournal;
+  /** Python numpy -> GPU 직결(install()로 pyprocGpu 배선). 실 GPU + 창 모드 + numpy 필요. */
+  enableGpu(cfg?: object): GpuBridge;
   /** 디렉터리 핸들(OPFS 등)을 파이썬 경로로 마운트(기본 /home/web). 반환된 sync()로 영속화. */
   mountHome(dirHandle: FileSystemDirectoryHandle, path?: string): Promise<{ path: string; sync: () => Promise<void> }>;
   /** 탈출구(권장 안 함): 내부 Pyodide 인스턴스. */

index.js

@@ -52,7 +52,7 @@ export { MachineJail } from "./src/capabilities/machineJail.js";
 export { bootSession, openMachine, Session } from "./src/capabilities/session.js";
 export { WheelCache } from "./src/capabilities/wheelCache.js";
 export { bootEnv, runScript } from "./src/capabilities/envManager.js";
-export { GpuCompute, GpuArray } from "./src/capabilities/gpuCompute.js";
+export { GpuCompute, GpuArray, GpuBridge } from "./src/capabilities/gpuCompute.js";
 export { PyProc, SIGNAL } from "./src/processOs/pyProc.js";
 export { MachineContainer } from "./src/processOs/machineContainer.js";
 export { JobControl } from "./src/processOs/jobControl.js";

mainPlan/numerical-acceleration/03-progress-ledger.md

@@ -4,6 +4,15 @@
 
 ## 결정 원장 (최신이 위)
 
+### 2026-07-13 후속 심화 완료: Python numpy -> GPU 직결 + map 체이닝 (gpuPythonProbe 실 GPU 4/4)
+
+- Phase 2의 후속 심화(파이썬 통합 + 원소별 op)를 실 GPU로 완성했다. **GPU가 파이썬에 실제로 연결됐다 = pyproc 정체성 완성.**
+- **`GpuArray.map(expr)`(원소별 잔류)**: WGSL 표현식(x=원소)을 각 원소에 적용한 새 잔류 핸들. matmul 뒤 활성화(`max(x,0)` relu 등)를 **리드백 없이** 잇는다. 표현식별 파이프라인 캐시.
+- **`Runtime.enableGpu()` -> `GpuBridge`(Python numpy 직결)**: install()이 GPU 디바이스 확보 + 파이썬 `pyprocGpu` 모듈 배선. `pyprocGpu.matmul(a, b)`가 numpy 배열을 f32로 GPU에서 곱해 numpy로 반환(블로킹 = JSPI run_sync, socketBridge 패턴). numpy 필요, 실 GPU + 창 모드.
+- **실측(gpuPythonProbe GREEN 4/4, 실 GPU)**: 파이썬 GPU matmul == CPU numpy **maxerr 0.00**, 1024 f32 **92배**(GPU 84ms vs CPU 7682ms). map 잔류 체이닝 matmul->relu == CPU 참조 maxErr 1.19e-7. 헤드리스는 SKIP.
+- **커널 최적화 판정(정직)**: 연구가 "커널 자작 금지"(naive vs 최적 600-1000배 격차, jax-js/WgPy 차용 권장)를 명시했고 이 GPU 하나에서만 검증 가능하므로, **naive 타일드(검증된 92-109배)를 유지하고 프로덕션 타일링/차용은 후속으로 정직하게 둔다**. 위험한 자작 커널이 정공법이 아니다.
+- **표면**: index.js/index.d.ts(GpuBridge/map/enableGpu)/run.mjs/README 2종. **Phase 2 = 개념 + src 승격 + 파이썬 통합 + 원소별 op까지 완결.** 잔여(커널 최적화 차용, GPU reduce, worker 내 GPU)는 코어 밖 선택 후속.
+
 ### 2026-07-13 Phase 2 완료 + src 승격: GpuCompute WebGPU 잔류 핸들 (실 GPU gpuMatmul 4/4 + gpuSurface 5/5)
 
 - Phase 2(프론티어, GPU)를 실 GPU로 실증하고 `GpuCompute`/`GpuArray`로 src 승격했다. **"GPU 검증 불가"는 헤드리스 한정**이었음이 드러났다.

mainPlan/numerical-acceleration/README.md

@@ -1,6 +1,6 @@
 # numerical-acceleration - 수치 성능 도약 (브라우저 파이썬의 마지막 큰 격차)
 
-상태: **Phase 1 + Phase 2 실증·src 승격 완료 (2026-07-13).** browser-os P1~P7 + engine-independence 사다리가 닫힌 뒤 개시. **수치 연산 속도**(numpy 86배)를 두 레인으로 뚫었다: (1) CPU 샤딩 `PyProc.matmul`(compute-bound near-linear, 종단 2.48배) (2) **WebGPU 잔류 핸들 `GpuCompute`**(f32 대규모 matmul **실 GPU 109배**). 잔여(worker+JSPI 통합, 커널 최적화, op 확장)는 코어 밖 후속 심화 = [02-phasing NEXT](02-phasing-and-wiring.md).
+상태: **Phase 1 + Phase 2 + 후속 심화 완료 (2026-07-13).** browser-os P1~P7 + engine-independence 사다리가 닫힌 뒤 개시. **수치 연산 속도**(numpy 86배)를 두 레인으로 뚫었다: (1) CPU 샤딩 `PyProc.matmul`(compute-bound near-linear, 종단 2.48배) (2) **WebGPU 잔류 핸들 `GpuCompute`/`GpuArray`**(f32 대규모 matmul **실 GPU 109배**, `map`으로 활성화 체이닝) + **`Runtime.enableGpu()`로 Python numpy 직결**(`pyprocGpu.matmul`이 numpy 배열을 GPU에서, **92배**). 잔여(커널 최적화 차용, GPU reduce, worker 내 GPU)는 코어 밖 선택 후속 = [02-phasing NEXT](02-phasing-and-wiring.md).
 
 ## 한 문장
 

src/capabilities/gpuCompute.js

@@ -28,8 +28,22 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
   c[row * d.n + col] = sum;
 }`;
 
+// 원소별 WGSL 템플릿(EXPR = 소비자 표현식, x = 원소). matmul 뒤 활성화 등 잔류 체이닝용.
+// 예: map("max(x, 0.0)")(relu), map("x * 2.0 + 1.0"), map("1.0 / (1.0 + exp(-x))")(sigmoid).
+const ELEMENTWISE_WGSL = `
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read_write> c: array<f32>;
+@group(0) @binding(2) var<uniform> len: u32;
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let i = gid.x;
+  if (i >= len) { return; }
+  let x = a[i];
+  c[i] = __EXPR__;
+}`;
+
 export class GpuCompute {
-  constructor(device) { this._device = device; this._matmul = null; }
+  constructor(device) { this._device = device; this._matmul = null; this._elementwise = new Map(); }
 
   // WebGPU 디바이스를 확보한다(async). 어댑터가 없으면(헤드리스) 실행 가능한 에러.
   static async create() {
@@ -54,6 +68,17 @@ export class GpuCompute {
     return this._matmul;
   }
 
+  // 원소별 파이프라인(표현식별 캐시). expr는 소비자 WGSL 표현식(x = 원소).
+  _elementwisePipeline(expr) {
+    let p = this._elementwise.get(expr);
+    if (!p) {
+      const module = this._device.createShaderModule({ code: ELEMENTWISE_WGSL.replace("__EXPR__", expr) });
+      p = this._device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main" } });
+      this._elementwise.set(expr, p);
+    }
+    return p;
+  }
+
   // f32 배열을 GPU에 올린다(잔류 시작). data = Float32Array(길이 rows*cols). 반환 = 잔류 핸들.
   array(data, rows, cols) {
     if (!(data instanceof Float32Array)) throw new Error("gpuArray: data는 Float32Array다(WGSL은 f64 없음 = f32만).");
@@ -92,6 +117,26 @@ export class GpuArray {
     return new GpuArray(this._gc, cBuf, M, N);
   }
 
+  // 원소별 변환: 각 원소 x에 WGSL 표현식 expr를 적용한 새 잔류 핸들(같은 shape). 재업로드 0.
+  // 잔류 체이닝의 핵심: m.matmul(w).map("max(x, 0.0)")처럼 matmul 뒤 활성화를 리드백 없이 잇는다.
+  map(expr) {
+    if (typeof expr !== "string" || !expr.length) throw new Error("GpuArray.map: expr는 WGSL 표현식 문자열(x = 원소). 예: \"max(x, 0.0)\"");
+    const device = this._gc._device, len = this.rows * this.cols;
+    const cBuf = device.createBuffer({ size: len * 4, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC });
+    const nBuf = device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: true });
+    new Uint32Array(nBuf.getMappedRange()).set([len, 0, 0, 0]); nBuf.unmap();
+    const pipeline = this._gc._elementwisePipeline(expr);
+    const bind = device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries: [
+      { binding: 0, resource: { buffer: this.buffer } }, { binding: 1, resource: { buffer: cBuf } }, { binding: 2, resource: { buffer: nBuf } },
+    ] });
+    const enc = device.createCommandEncoder();
+    const pass = enc.beginComputePass(); pass.setPipeline(pipeline); pass.setBindGroup(0, bind);
+    pass.dispatchWorkgroups(Math.ceil(len / 64)); pass.end();
+    device.queue.submit([enc.finish()]);
+    nBuf.destroy();
+    return new GpuArray(this._gc, cBuf, this.rows, this.cols);
+  }
+
   // GPU -> CPU 회수(리드백 1복사). 반환 { data: Float32Array, rows, cols }.
   async toArray() {
     const device = this._gc._device, size = this.rows * this.cols * 4;
@@ -107,3 +152,49 @@ export class GpuArray {
 
   destroy() { this.buffer.destroy(); }
 }
+
+// Python numpy -> GPU 직결(pyproc 정체성 완성). Runtime의 파이썬이 numpy 배열을 f32로 GPU에서
+// matmul한다: pyprocGpu.matmul(a, b). 블로킹은 JSPI(run_sync)라 rt.runAsync 경로에서 동작한다
+// (socketBridge/machineContainer와 같은 패턴). 실 GPU + 창 모드 필요(navigator.gpu는 메인 스레드).
+// numpy 필요(rt.loadPackages(["numpy"])). f64는 f32로 강등(WGSL 한계) - 정밀도 손실은 계약이다.
+const GPU_BOOTSTRAP = `
+import sys as _pyprocSysG, types as _pyprocTypesG
+import numpy as _pyprocNumpyG
+from pyodide.ffi import to_js as _pyprocToJsG, run_sync as _pyprocRunSyncG
+
+_pyprocGpuMod = _pyprocTypesG.ModuleType('pyprocGpu')
+
+def _pyprocGpuMatmul(a, b):
+    a = _pyprocNumpyG.ascontiguousarray(a, dtype=_pyprocNumpyG.float32)
+    b = _pyprocNumpyG.ascontiguousarray(b, dtype=_pyprocNumpyG.float32)
+    res = _pyprocRunSyncG(_pyprocGpuMatmulBridge(
+        _pyprocToJsG(a.tobytes()), a.shape[0], a.shape[1],
+        _pyprocToJsG(b.tobytes()), b.shape[0], b.shape[1]))
+    return _pyprocNumpyG.frombuffer(bytes(res.to_py()), dtype=_pyprocNumpyG.float32).reshape(a.shape[0], b.shape[1])
+
+_pyprocGpuMod.matmul = _pyprocGpuMatmul
+_pyprocSysG.modules['pyprocGpu'] = _pyprocGpuMod
+`;
+
+export class GpuBridge {
+  constructor(rt) { this._rt = rt; this._gc = null; }
+
+  // GPU 디바이스 확보 + 파이썬 pyprocGpu 모듈 배선. 어댑터 부재(헤드리스) 시 실행 가능한 에러.
+  async install() {
+    this._gc = await GpuCompute.create();
+    const gc = this._gc;
+    // 파이썬이 부를 브리지(JSPI가 서스펜드하는 async): f32 바이트를 받아 GPU matmul 후 결과 바이트.
+    const bridge = async (aU8, aRows, aCols, bU8, bRows, bCols) => {
+      const A = new Float32Array(aU8.slice().buffer), B = new Float32Array(bU8.slice().buffer);
+      const ga = gc.array(A, aRows, aCols), gb = gc.array(B, bRows, bCols), gout = ga.matmul(gb);
+      const r = await gout.toArray();
+      ga.destroy(); gb.destroy(); gout.destroy();
+      return new Uint8Array(r.data.buffer);
+    };
+    this._rt.setGlobal("_pyprocGpuMatmulBridge", bridge);
+    this._rt.run(GPU_BOOTSTRAP);
+    return { installed: "pyprocGpu", note: "블로킹은 JSPI(run_sync)라 rt.runAsync 경로에서. numpy 필요" };
+  }
+
+  destroy() { if (this._gc) this._gc.destroy(); }
+}

src/runtime/runtime.js

@@ -13,6 +13,7 @@ import { Terminal } from "../capabilities/terminal.js";
 import { DeviceFs } from "../capabilities/deviceFs.js";
 import { Init } from "../capabilities/init.js";
 import { MachineJournal } from "../capabilities/machineJournal.js";
+import { GpuBridge } from "../capabilities/gpuCompute.js";
 
 export { MemoryCapability, PAGE_SIZE } from "./memoryCapability.js";
 export { checkEnvironment } from "./preflight.js";
@@ -137,6 +138,8 @@ export class Runtime {
   enableDeviceFs(cfg = {}) { return new DeviceFs(this, cfg); }
   enableInit(cfg = {}) { return new Init(this, cfg); }
   enableJournal(cfg = {}) { return new MachineJournal(this, cfg); }
+  // Python numpy -> GPU 직결(install()로 pyprocGpu 모듈 배선). 실 GPU + 창 모드 + numpy 필요.
+  enableGpu(cfg = {}) { return new GpuBridge(this); }
 
   // 영속 디스크: OPFS 등 디렉터리 핸들을 파이썬 파일시스템 경로로 마운트한다.
   // 파이썬 open()이 진짜 지속 파일을 읽고 쓴다. 변경 반영은 반환된 sync() 호출(핸들은 소비자 제공).

tests/attempts/gpuCompute/README.md

@@ -21,6 +21,8 @@ PYPROC_HEADED=1 node tests/browser/run.mjs tests/attempts/gpuCompute/gpuMatmulPr
 | 질문 | probe | 게이트 |
 |---|---|---|
 | WGSL matmul이 정확하고 numpy보다 빠른가 | [gpuMatmulProbe.html](gpuMatmulProbe.html) | (실 GPU) 결과 == CPU 참조(f32 허용오차) + GPU 종단이 WASM numpy 대비 >= 10배. 어댑터 없으면 SKIP |
+| 승격 계약(GpuCompute/GpuArray 잔류)이 정확한가 | [gpuSurfaceProbe.html](gpuSurfaceProbe.html) | array->matmul->toArray == CPU 참조 + 잔류 체이닝 (A@B)@C 정확 + 차원 에러 |
+| Python numpy가 GPU를 쓰고 map 체이닝이 되나 | [gpuPythonProbe.html](gpuPythonProbe.html) | enableGpu -> pyprocGpu.matmul(numpy)==CPU numpy + 속도 + GpuArray.map(matmul->relu)==CPU 참조 |
 
 승격 조건(G2 실 GPU GREEN): worker 소유 GPUDevice + JSPI 잔류 핸들로 `GpuCompute`/`gpuArray` 능력 승격. G2 실패(전송비 이득 초과) 시 examples/문서 패턴으로 강등(정직한 조건부).
 
@@ -29,4 +31,5 @@ PYPROC_HEADED=1 node tests/browser/run.mjs tests/attempts/gpuCompute/gpuMatmulPr
 | 날짜 | probe | 환경 | 핵심 수치 | 결론 | 판정 |
 |---|---|---|---|---|---|
 | 2026-07-13 | gpuMatmulProbe | Edge **창 모드(실 GPU)** + 자가 호스팅 경로 | 정확성 GPU matmul == CPU 참조 **maxErr 3.58e-7**(f32), 대형 1024 f32 GPU 종단(업로드+연산+리드백) **65.9ms**, WASM numpy 단일워커 7221ms = **GPU 109.6배**. GREEN 4/4(헤드리스는 SKIP) | **Phase 2 개념 성립**: naive 타일드 WGSL matmul로도 109배(최적화 커널 WgPy 340배). f32 정밀도 정확, 종단 전송비 포함해도 압도. GPU 벽(f64 없음, 창 모드 필요)은 정직한 경계 | 승격 -> `GpuCompute`/`gpuArray` 잔류 핸들 능력 |
-| 2026-07-13 | gpuSurfaceProbe | Edge **창 모드(실 GPU)** | 승격 계약 `GpuCompute`/`GpuArray` 검증: create -> `array(f32)` -> `matmul` -> `toArray` == CPU 참조 **maxErr 2.38e-7**, **잔류 체이닝 (A@B)@C == 참조 maxErr 2.68e-7**(중간 리드백 0 = 재업로드 없음), 차원 불일치 명시적 에러, 대형 잔류 matmul **37.1ms**. GREEN 5/5(헤드리스 SKIP) | **Phase 2 src 승격 완료.** 잔류 핸들 모델(업로드1/GPU 체이닝/다운로드1)이 실 GPU에서 정확·동작. 셰이더 1회 컴파일 캐시 | 승격 -> `GpuCompute`/`GpuArray`. 후속: worker+JSPI 통합, 커널 최적화(타일링/차용), reduce/elementwise op |
+| 2026-07-13 | gpuSurfaceProbe | Edge **창 모드(실 GPU)** | 승격 계약 `GpuCompute`/`GpuArray` 검증: create -> `array(f32)` -> `matmul` -> `toArray` == CPU 참조 **maxErr 2.38e-7**, **잔류 체이닝 (A@B)@C == 참조 maxErr 2.68e-7**(중간 리드백 0 = 재업로드 없음), 차원 불일치 명시적 에러, 대형 잔류 matmul **37.1ms**. GREEN 5/5(헤드리스 SKIP) | **Phase 2 src 승격 완료.** 잔류 핸들 모델(업로드1/GPU 체이닝/다운로드1)이 실 GPU에서 정확·동작. 셰이더 1회 컴파일 캐시 | 승격 -> `GpuCompute`/`GpuArray` |
+| 2026-07-13 | gpuPythonProbe | Edge **창 모드(실 GPU)** + 자가 호스팅 | **Python numpy -> GPU 직결(pyproc 정체성 완성)** + map 체이닝. `Runtime.enableGpu().install()` -> 파이썬 `pyprocGpu.matmul(numpy a, b)`(JSPI run_sync)가 GPU에서 곱해 numpy로 반환 == CPU numpy **maxerr 0.00**, 1024 f32 **92배**(GPU 84ms vs CPU 7682ms). **GpuArray.map 잔류 체이닝**: matmul -> relu(`max(x,0)`) 리드백 없이 == CPU 참조 maxErr 1.19e-7. GREEN 4/4(헤드리스 SKIP) | **후속 심화 완료**: 파이썬이 GPU를 쓴다(numpy 배열 한 줄로 92배). map으로 matmul 뒤 활성화를 리드백 없이 잇는다 | 승격 -> `GpuBridge`(enableGpu) + `GpuArray.map`. 커널 최적화(자작 금지 = jax-js/WgPy 차용)는 후속 |