freelang-editor 11.7.4

package/src/benchmarks/bench-runner.ts

@@ -0,0 +1,85 @@
+// FreeLang v9 Phase 89: 벤치마크 프레임워크
+
+export interface BenchmarkResult {
+  name: string;
+  opsPerSec: number;
+  avgMs: number;
+  iterations: number;
+  totalMs: number;
+}
+
+export interface BenchmarkOptions {
+  iterations?: number;
+}
+
+export class BenchmarkSuite {
+  private benchmarks: Array<{
+    name: string;
+    fn: () => any;
+    opts: Required<BenchmarkOptions>;
+  }> = [];
+
+  add(name: string, fn: () => any, opts?: BenchmarkOptions): this {
+    this.benchmarks.push({
+      name,
+      fn,
+      opts: { iterations: opts?.iterations ?? 100 },
+    });
+    return this;
+  }
+
+  run(): BenchmarkResult[] {
+    const results: BenchmarkResult[] = [];
+
+    for (const bench of this.benchmarks) {
+      const { name, fn, opts } = bench;
+      const { iterations } = opts;
+
+      // warm-up (5회)
+      for (let i = 0; i < Math.min(5, iterations); i++) {
+        fn();
+      }
+
+      const start = performance.now();
+      for (let i = 0; i < iterations; i++) {
+        fn();
+      }
+      const end = performance.now();
+
+      const totalMs = end - start;
+      const avgMs = totalMs / iterations;
+      const opsPerSec = avgMs === 0 ? Infinity : 1000 / avgMs;
+
+      results.push({ name, opsPerSec, avgMs, iterations, totalMs });
+    }
+
+    return results;
+  }
+
+  toMarkdown(results?: BenchmarkResult[]): string {
+    const data = results ?? this.run();
+
+    const lines: string[] = [
+      "| name | ops/sec | avg ms | iterations | total ms |",
+      "|------|---------|--------|------------|----------|",
+    ];
+
+    for (const r of data) {
+      const ops = r.opsPerSec === Infinity ? "∞" : r.opsPerSec.toFixed(0);
+      lines.push(
+        `| ${r.name} | ${ops} | ${r.avgMs.toFixed(4)} | ${r.iterations} | ${r.totalMs.toFixed(2)} |`
+      );
+    }
+
+    return lines.join("\n");
+  }
+
+  toJSON(results?: BenchmarkResult[]): object {
+    const data = results ?? this.run();
+    return data;
+  }
+
+  findResult(results: BenchmarkResult[], name: string): BenchmarkResult | undefined {
+    return results.find((r) => r.name === name);
+  }
+}

package/src/benchmarks/bench-vm.ts

@@ -0,0 +1,128 @@
+// FreeLang v9 Phase 89: 바이트코드 VM 성능 측정
+
+import { BytecodeCompiler } from "../compiler";
+import { VM } from "../vm";
+import { Optimizer, constantFoldingPass, createDefaultOptimizer } from "../optimizer";
+import { ASTNode, Literal, SExpr } from "../ast";
+import { BenchmarkSuite, BenchmarkResult } from "./bench-runner";
+
+// ─── AST 헬퍼 ────────────────────────────────────────────────────────────────
+
+function lit(value: number | boolean | string | null): Literal {
+  if (typeof value === "number") return { kind: "literal", type: "number", value };
+  if (typeof value === "boolean") return { kind: "literal", type: "boolean", value };
+  if (value === null) return { kind: "literal", type: "null", value: null };
+  return { kind: "literal", type: "string", value };
+}
+
+function sexpr(op: string, ...args: ASTNode[]): SExpr {
+  return { kind: "sexpr", op, args };
+}
+
+// ─── VM 실행 헬퍼 ────────────────────────────────────────────────────────────
+
+function runVM(node: ASTNode): any {
+  const compiler = new BytecodeCompiler();
+  const vm = new VM();
+  const chunk = compiler.compile(node);
+  return vm.run(chunk);
+}
+
+function runVMOptimized(node: ASTNode): any {
+  const compiler = new BytecodeCompiler();
+  const vm = new VM();
+  const chunk = compiler.compile(node);
+  const optimizer = createDefaultOptimizer();
+  const optimized = optimizer.optimize(chunk);
+  return vm.run(optimized);
+}
+
+// ─── 벤치마크 ────────────────────────────────────────────────────────────────
+
+export function runVMBenchmarks(): BenchmarkResult[] {
+  const suite = new BenchmarkSuite();
+
+  // 1. 산술 연산 (VM)
+  const arithAST = sexpr("+", sexpr("*", lit(2), lit(3)), sexpr("-", lit(10), lit(4)));
+
+  suite.add(
+    "VM: arithmetic (+ (* 2 3) (- 10 4))",
+    () => runVM(arithAST),
+    { iterations: 1000 }
+  );
+
+  // 2. 산술 연산 (VM + 최적화)
+  suite.add(
+    "VM+opt: arithmetic (+ (* 2 3) (- 10 4))",
+    () => runVMOptimized(arithAST),
+    { iterations: 1000 }
+  );
+
+  // 3. 상수 표현식 (VM)
+  const constAST = sexpr("+", lit(100), sexpr("*", lit(3), lit(7)));
+  suite.add(
+    "VM: constant expr (+ 100 (* 3 7))",
+    () => runVM(constAST),
+    { iterations: 1000 }
+  );
+
+  // 4. 상수 표현식 (VM + 상수 폴딩)
+  suite.add(
+    "VM+const-fold: constant expr",
+    () => runVMOptimized(constAST),
+    { iterations: 1000 }
+  );
+
+  // 5. 비교 연산 (VM)
+  const compareAST = sexpr(">", sexpr("+", lit(5), lit(3)), sexpr("-", lit(10), lit(1)));
+  suite.add(
+    "VM: comparison (> (+ 5 3) (- 10 1))",
+    () => runVM(compareAST),
+    { iterations: 1000 }
+  );
+
+  return suite.run();
+}
+
+// ─── 인터프리터 vs VM 비교 ───────────────────────────────────────────────────
+
+export interface ComparisonResult {
+  operation: string;
+  interpreterOpsPerSec: number;
+  vmOpsPerSec: number;
+  speedup: number;
+}
+
+export function compareInterpreterVsVM(
+  interpreterResults: BenchmarkResult[],
+  vmResults: BenchmarkResult[]
+): ComparisonResult[] {
+  const pairs: Array<{ interp: string; vm: string; label: string }> = [
+    {
+      interp: "arithmetic: (+ (* 2 3) (- 10 4))",
+      vm: "VM: arithmetic (+ (* 2 3) (- 10 4))",
+      label: "arithmetic",
+    },
+  ];
+
+  return pairs.map(({ interp, vm, label }) => {
+    const ir = interpreterResults.find((r) => r.name === interp);
+    const vr = vmResults.find((r) => r.name === vm);
+    const iOps = ir?.opsPerSec ?? 0;
+    const vOps = vr?.opsPerSec ?? 0;
+    return {
+      operation: label,
+      interpreterOpsPerSec: iOps,
+      vmOpsPerSec: vOps,
+      speedup: iOps === 0 ? 0 : vOps / iOps,
+    };
+  });
+}
+
+// 단독 실행 시
+if (require.main === module) {
+  console.log("=== FreeLang v9 VM 벤치마크 ===\n");
+  const results = runVMBenchmarks();
+  const suite = new BenchmarkSuite();
+  console.log(suite.toMarkdown(results));
+}

package/src/browser-debug-panel.ts

@@ -0,0 +1,220 @@
+// Phase Y-2-C: 브라우저 디버그 패널
+// 에러 발생 시 콜스택 + 변수를 시각적으로 표시
+
+export interface DebugPanelAPI {
+  lastError: any;
+  callStack: any[];
+  variables: Record<string, any>;
+  showError(): string;
+  expandCallStack(level: number): any;
+  inspectVariable(name: string): any;
+  printConsole(): void;
+  toggle(): void;
+  clear(): void;
+}
+
+export class BrowserDebugPanel {
+  private static panelElement: HTMLElement | null = null;
+  private static context: any = null;
+
+  static init(context: any) {
+    BrowserDebugPanel.context = context;
+
+    // 1. window.__FL_DEBUG 객체 생성
+    const debugAPI: DebugPanelAPI = {
+      lastError: null,
+      callStack: [],
+      variables: {},
+
+      showError(): string {
+        const err = context.lastError;
+        if (!err) return "No error";
+        return `${err.message}\n  at ${err.file}:${err.line}:${err.col}`;
+      },
+
+      expandCallStack(level: number): any {
+        const err = context.lastError;
+        if (!err || !err.callStack[level]) return null;
+        return err.callStack[level];
+      },
+
+      inspectVariable(name: string): any {
+        const err = context.lastError;
+        if (!err || !err.variables) return null;
+        return err.variables[name];
+      },
+
+      printConsole(): void {
+        const err = context.lastError;
+        if (!err) {
+          console.log("[FL] No error captured");
+          return;
+        }
+        console.group("[FL Error] " + err.message);
+        console.log("Location:", `${err.file}:${err.line}:${err.col}`);
+        console.log("Call Stack:", err.callStack);
+        console.log("Variables:", err.variables);
+        if (err.hint) console.log("Hint:", err.hint);
+        console.groupEnd();
+      },
+
+      toggle(): void {
+        if (BrowserDebugPanel.panelElement) {
+          const body = BrowserDebugPanel.panelElement.querySelector(".fl-error-body") as HTMLElement;
+          if (body) {
+            body.style.display = body.style.display === "none" ? "block" : "none";
+          }
+        }
+      },
+
+      clear(): void {
+        context.lastError = null;
+        if (BrowserDebugPanel.panelElement) {
+          BrowserDebugPanel.panelElement.style.display = "none";
+        }
+      },
+    };
+
+    (window as any).__FL_DEBUG = debugAPI;
+
+    // 2. 패널 HTML 주입
+    BrowserDebugPanel.injectPanel();
+
+    // 3. 에러 후크 설정
+    BrowserDebugPanel.setupErrorHandler(context, debugAPI);
+  }
+
+  private static injectPanel() {
+    const panelHTML = `
+      <div id="fl-debug-panel" style="
+        position: fixed;
+        bottom: 0;
+        right: 0;
+        width: 400px;
+        max-height: 300px;
+        background: #1e1e1e;
+        color: #d4d4d4;
+        border: 1px solid #404040;
+        border-radius: 4px 4px 0 0;
+        font-family: 'Courier New', monospace;
+        font-size: 12px;
+        z-index: 99999;
+        display: none;
+        overflow-y: auto;
+        box-shadow: 0 -2px 8px rgba(0,0,0,0.3);
+      ">
+        <div class="fl-error-header" style="
+          padding: 8px 12px;
+          background: #d32f2f;
+          color: white;
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          border-bottom: 1px solid #404040;
+        ">
+          <span id="fl-error-title" style="font-weight: bold;">FL Error</span>
+          <div>
+            <button onclick="window.__FL_DEBUG.toggle()" style="
+              background: none;
+              border: none;
+              color: white;
+              cursor: pointer;
+              font-size: 14px;
+              margin: 0 4px;
+            ">−</button>
+            <button onclick="window.__FL_DEBUG.clear()" style="
+              background: none;
+              border: none;
+              color: white;
+              cursor: pointer;
+              font-size: 14px;
+              margin: 0 4px;
+            ">✕</button>
+          </div>
+        </div>
+        <div class="fl-error-body" style="
+          padding: 12px;
+          display: none;
+        ">
+          <div id="fl-message" style="margin-bottom: 10px; white-space: pre-wrap;"></div>
+          <div id="fl-stack" style="margin-bottom: 10px;">
+            <div style="color: #4fc3f7; margin-bottom: 4px;">Call Stack:</div>
+            <div id="fl-stack-items" style="margin-left: 8px;"></div>
+          </div>
+          <div id="fl-vars">
+            <div style="color: #4fc3f7; margin-bottom: 4px;">Variables:</div>
+            <div id="fl-vars-items" style="margin-left: 8px;"></div>
+          </div>
+          <div id="fl-hint" style="margin-top: 10px; color: #ffeb3b;"></div>
+        </div>
+      </div>
+    `;
+
+    document.body.insertAdjacentHTML("beforeend", panelHTML);
+    BrowserDebugPanel.panelElement = document.getElementById("fl-debug-panel");
+  }
+
+  private static setupErrorHandler(context: any, debugAPI: DebugPanelAPI) {
+    // 에러 발생 시 패널 업데이트하는 인터셉터 설정
+    const originalEval = (window as any).__FL_eval || (context.variables?.get as any);
+
+    // context.lastError가 변경될 때 패널 업데이트
+    const updatePanel = () => {
+      const err = context.lastError;
+      if (!err) return;
+
+      const panel = BrowserDebugPanel.panelElement;
+      if (!panel) return;
+
+      // 패널 표시
+      panel.style.display = "block";
+
+      // 제목
+      const title = panel.querySelector("#fl-error-title") as HTMLElement;
+      if (title) {
+        title.textContent = `✖ ${err.code || "Error"}: ${err.message.split("\n")[0]}`;
+      }
+
+      // 메시지
+      const message = panel.querySelector("#fl-message") as HTMLElement;
+      if (message) {
+        message.textContent = err.message;
+      }
+
+      // 콜스택
+      const stackItems = panel.querySelector("#fl-stack-items") as HTMLElement;
+      if (stackItems && err.callStack) {
+        stackItems.innerHTML = err.callStack
+          .map(
+            (frame: any, i: number) =>
+              `<div>${i + 1}. <span style="color: #4fc3f7;">${frame.name}</span> (line ${frame.line})</div>`
+          )
+          .join("");
+      }
+
+      // 변수
+      const varItems = panel.querySelector("#fl-vars-items") as HTMLElement;
+      if (varItems && err.variables) {
+        varItems.innerHTML = Object.entries(err.variables)
+          .slice(0, 5)
+          .map(
+            ([k, v]: [string, any]) =>
+              `<div><span style="color: #ce9178;">${k}</span>: ${
+                typeof v === "string" ? `"${v.slice(0, 30)}"` : String(v).slice(0, 30)
+              }</div>`
+          )
+          .join("");
+      }
+
+      // 힌트
+      const hint = panel.querySelector("#fl-hint") as HTMLElement;
+      if (hint && err.hint) {
+        hint.innerHTML = `<strong>💡 Hint:</strong> ${err.hint}`;
+      }
+    };
+
+    // 주기적으로 패널 업데이트 (또는 에러 발생 시마다)
+    // 간단하게 setInterval로 업데이트
+    setInterval(updatePanel, 500);
+  }
+}

package/src/browser-entry.ts

@@ -0,0 +1,79 @@
+// FreeLang v11 — Browser Entry Point
+// Node.js 의존성 없이 브라우저에서 FL 코드 실행
+
+import { Interpreter } from "./interpreter";
+import { createDataModule } from "./stdlib-data";
+import { createCollectionModule } from "./stdlib-collection";
+import { createTimeModule } from "./stdlib-time";
+import { createCacheModule } from "./stdlib-cache";
+import { createAgentModule } from "./stdlib-agent";
+import { createValidationModule } from "./stdlib-validation";
+import { createStatsModule } from "./stdlib-stats";
+import { createMatrixModule } from "./stdlib-matrix";
+import { createBrowserModule } from "./stdlib-browser";
+import { BrowserDebugPanel } from "./browser-debug-panel";
+
+function createBrowserInterpreter() {
+  const interp = new Interpreter();
+
+  // 브라우저 안전 stdlib 등록
+  interp.registerModule(createDataModule());
+  interp.registerModule(createCollectionModule());
+  interp.registerModule(createTimeModule());
+  interp.registerModule(createCacheModule());
+  interp.registerModule(createAgentModule());
+  interp.registerModule(createValidationModule());
+  interp.registerModule(createStatsModule());
+  interp.registerModule(createMatrixModule());
+
+  // 브라우저 전용 stdlib 등록 (DOM, Fetch, Storage 등)
+  interp.registerModule(createBrowserModule(
+    (name, args) => interp.callUserFunction(name, args)
+  ));
+
+  // Phase Y-2-C: 브라우저 디버그 패널 초기화
+  BrowserDebugPanel.init(interp.context);
+
+  return interp;
+}
+
+// FL 코드 실행
+function evaluate(code: string): any {
+  const interp = createBrowserInterpreter();
+  try {
+    const ctx = interp.run(code);
+    return ctx.lastValue;
+  } catch (e: any) {
+    throw new Error(`FreeLang error: ${e.message}`);
+  }
+}
+
+// 페이지 내 <script type="text/freelang"> 자동 실행
+function autoRun() {
+  const scripts = document.querySelectorAll<HTMLScriptElement>('script[type="text/freelang"]');
+  scripts.forEach((el) => {
+    try {
+      evaluate(el.textContent ?? "");
+    } catch (e: any) {
+      console.error("[FreeLang]", e.message);
+    }
+  });
+}
+
+// window.FreeLang 전역 노출
+const FreeLang = { evaluate, createInterpreter: createBrowserInterpreter, version: "v11" };
+
+declare global {
+  interface Window { FreeLang: typeof FreeLang; }
+}
+
+if (typeof window !== "undefined") {
+  window.FreeLang = FreeLang;
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", autoRun);
+  } else {
+    autoRun();
+  }
+}
+
+export { FreeLang, evaluate };

package/src/browser-stubs/child-process-stubs.ts

@@ -0,0 +1,6 @@
+export const execSync = () => "";
+export const execFileSync = () => "";
+export const spawnSync = () => ({ stdout: { toString: () => "" }, stderr: { toString: () => "" }, status: 0 });
+export const spawn = () => ({ on: () => {}, stdout: { on: () => {} }, stderr: { on: () => {} } });
+export const exec = (_: any, cb: any) => cb(null, "", "");
+export default { execSync, execFileSync, spawnSync, spawn, exec };

package/src/browser-stubs/crypto-stubs.ts

@@ -0,0 +1,15 @@
+export const randomUUID = () => crypto.randomUUID();
+export const randomBytes = (n: number) => { const b = new Uint8Array(n); crypto.getRandomValues(b); return { toString: (enc: string) => Array.from(b).map(x => x.toString(16).padStart(2,"0")).join("") }; };
+export const createHash = (alg: string) => ({ update: (d: string) => ({ digest: (enc: string) => btoa(d) }) });
+export const createHmac = (alg: string, key: string) => ({ update: (d: string) => ({ digest: (enc: string) => btoa(key + d) }) });
+export const timingSafeEqual = (a: any, b: any) => String(a) === String(b);
+// RSA — 브라우저 stub (실제 RS256은 Node 환경 한정. 브라우저에서 호출 시 throw)
+const rsaUnsupported = () => { throw new Error("RSA primitives unavailable in browser stub"); };
+export const generateKeyPairSync: any = rsaUnsupported;
+export const createSign: any = rsaUnsupported;
+export const createVerify: any = rsaUnsupported;
+export const createPublicKey: any = rsaUnsupported;
+export const scryptSync: any = () => { throw new Error("scryptSync unavailable in browser stub"); };
+export type KeyObject = any;
+export default { randomUUID, randomBytes, createHash, createHmac, timingSafeEqual,
+  generateKeyPairSync, createSign, createVerify, createPublicKey, scryptSync };

package/src/browser-stubs/misc-stubs.ts

@@ -0,0 +1,4 @@
+export default {};
+export const createInterface = () => ({ question: () => {}, close: () => {} });
+export const EventEmitter = class { on() {} emit() {} off() {} };
+export const Socket = class { on() {} write() {} destroy() {} };

package/src/browser-stubs/node-stubs.ts

@@ -0,0 +1,17 @@
+// Node.js 모듈 브라우저 스텁 — 빌드 에러 방지용
+export const readFileSync = () => "";
+export const writeFileSync = () => {};
+export const appendFileSync = () => {};
+export const existsSync = () => false;
+export const mkdirSync = () => {};
+export const readdirSync = () => [];
+export const statSync = () => ({});
+export const openSync = () => 0;
+export const closeSync = () => {};
+export const writeSync = () => 0;
+export const readSync = () => 0;
+export const fsyncSync = () => {};
+export const createReadStream = () => ({});
+export const createWriteStream = () => ({});
+export const unlinkSync = () => {};
+export default { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync };

package/src/browser-stubs/path-stubs.ts

@@ -0,0 +1,6 @@
+export const join = (...parts: string[]) => parts.join("/");
+export const resolve = (...parts: string[]) => parts.join("/");
+export const dirname = (p: string) => p.split("/").slice(0, -1).join("/");
+export const basename = (p: string) => p.split("/").pop() ?? "";
+export const extname = (p: string) => { const b = basename(p); const i = b.lastIndexOf("."); return i < 0 ? "" : b.slice(i); };
+export default { join, resolve, dirname, basename, extname };

package/src/bytecode.ts

@@ -0,0 +1,41 @@
+// FreeLang v9 Phase 83: 바이트코드 명령어 정의
+
+export enum OpCode {
+  PUSH_CONST,    // 스택에 상수 푸시 (arg: 상수 풀 인덱스)
+  PUSH_VAR,      // 변수 값 로드 (arg: 변수 이름)
+  SET_VAR,       // 변수 저장 (arg: 변수 이름)
+  CALL,          // N개 인자로 함수 호출 (arg: 인자 수)
+  RETURN,        // 함수 반환
+  JUMP,          // 무조건 점프 (arg: 목적지 인덱스)
+  JUMP_IF_FALSE, // 조건 점프 (arg: 목적지 인덱스)
+  POP,           // 스택 팝
+  DUP,           // 스택 최상단 복제
+  ADD,           // 덧셈
+  SUB,           // 뺄셈
+  MUL,           // 곱셈
+  DIV,           // 나눗셈
+  MOD,           // 나머지
+  EQ,            // 동등 비교
+  LT,            // 미만
+  GT,            // 초과
+  LE,            // 이하
+  GE,            // 이상
+  NEQ,           // 불일치
+  AND,           // 논리 AND
+  OR,            // 논리 OR
+  NOT,           // 논리 NOT
+  MAKE_LIST,     // N개 스택 값으로 배열 생성 (arg: 개수)
+  GET_FIELD,     // 객체 필드 접근 (arg: 필드명)
+  HALT,          // 프로그램 종료
+}
+
+export interface Instruction {
+  op: OpCode;
+  arg?: number | string | null; // 인자 (인덱스, 이름, 상수값)
+}
+
+export interface Chunk {
+  instructions: Instruction[];
+  constants: any[];  // 상수 풀
+  name: string;      // 청크 이름 (함수명 등)
+}