freelang-editor 11.7.4

package/src/stdlib-time.ts

@@ -0,0 +1,282 @@
+// FreeLang v9: Time + Logging + Monitoring Standard Library
+// Phase 16: Temporal ops + structured logging + metrics — AI observability
+//
+// AI 에이전트는 "언제", "얼마나", "무엇이 느렸는지" 알아야 한다.
+// Phase 16은 에이전트의 내부 관찰 시스템이다.
+
+export interface Logger {
+  name: string;
+  entries: LogEntry[];
+  level: LogLevel;
+}
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LogEntry {
+  ts: number;
+  level: LogLevel;
+  msg: string;
+  data?: any;
+}
+
+export interface Timer {
+  start: number;
+  label: string;
+  laps: Array<{ label: string; elapsed: number }>;
+}
+
+export interface Metrics {
+  name: string;
+  values: Record<string, number[]>;
+  counters: Record<string, number>;
+  timers: Record<string, number[]>;
+}
+
+const LEVEL_ORDER: Record<LogLevel, number> = { debug: 0, info: 1, warn: 2, error: 3 };
+
+export function createTimeModule() {
+  return {
+    // ── Time ──────────────────────────────────────────────────
+
+    // now -> number (current timestamp ms)
+    "now": (): number => Date.now(),
+
+    // now_ms -> number (ms since epoch, always returns number)
+    "now_ms": (): number => Date.now(),
+
+    // now_iso -> string (ISO 8601)
+    "now_iso": (): string => new Date().toISOString(),
+
+    // now_unix -> number (seconds since epoch)
+    "now_unix": (): number => Math.floor(Date.now() / 1000),
+
+    // time_diff t1 t2 -> number (ms, positive if t2 > t1)
+    "time_diff": (t1: number, t2: number): number => t2 - t1,
+
+    // time_since ts -> number (ms elapsed since ts)
+    "time_since": (ts: number): number => Date.now() - ts,
+
+    // time_ago ts -> string (human-readable: "3s ago", "2m ago", "1h ago")
+    "time_ago": (ts: number): string => {
+      const ms = Date.now() - ts;
+      if (ms < 1000) return `${ms}ms ago`;
+      if (ms < 60000) return `${Math.floor(ms / 1000)}s ago`;
+      if (ms < 3600000) return `${Math.floor(ms / 60000)}m ago`;
+      if (ms < 86400000) return `${Math.floor(ms / 3600000)}h ago`;
+      return `${Math.floor(ms / 86400000)}d ago`;
+    },
+
+    // format_date ts fmt -> string  (simple date formatting)
+    // fmt tokens: YYYY MM DD HH mm ss SSS
+    "format_date": (ts: number, fmt: string): string => {
+      const d = new Date(ts);
+      return fmt
+        .replace("YYYY", String(d.getFullYear()))
+        .replace("MM", String(d.getMonth() + 1).padStart(2, "0"))
+        .replace("DD", String(d.getDate()).padStart(2, "0"))
+        .replace("HH", String(d.getHours()).padStart(2, "0"))
+        .replace("mm", String(d.getMinutes()).padStart(2, "0"))
+        .replace("ss", String(d.getSeconds()).padStart(2, "0"))
+        .replace("SSS", String(d.getMilliseconds()).padStart(3, "0"));
+    },
+
+    // date_parts ts -> {year,month,day,hour,min,sec,ms,weekday}
+    "date_parts": (ts: number): Record<string, number> => {
+      const d = new Date(ts);
+      return {
+        year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate(),
+        hour: d.getHours(), min: d.getMinutes(), sec: d.getSeconds(),
+        ms: d.getMilliseconds(), weekday: d.getDay(),
+      };
+    },
+
+    // date_add ts unit n -> number  (unit: "ms"|"s"|"m"|"h"|"d"|"days"|"hours"|"minutes"|"months"|"years"|"weeks"|"seconds")
+    "date_add": (ts: number, unit: string, n: number): number => {
+      const u = String(unit).replace(/^:/, "");
+      const mul: Record<string, number> = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
+      if (mul[u] !== undefined) return ts + n * mul[u];
+      // verbose unit names → calendar-aware mutation
+      const d = new Date(Number(ts));
+      if (u === "days"    || u === "day")    { d.setDate(d.getDate() + Number(n)); return d.getTime(); }
+      if (u === "hours"   || u === "hour")   { d.setHours(d.getHours() + Number(n)); return d.getTime(); }
+      if (u === "minutes" || u === "minute") { d.setMinutes(d.getMinutes() + Number(n)); return d.getTime(); }
+      if (u === "months"  || u === "month")  { d.setMonth(d.getMonth() + Number(n)); return d.getTime(); }
+      if (u === "years"   || u === "year")   { d.setFullYear(d.getFullYear() + Number(n)); return d.getTime(); }
+      if (u === "seconds" || u === "second") { d.setSeconds(d.getSeconds() + Number(n)); return d.getTime(); }
+      if (u === "weeks"   || u === "week")   { d.setDate(d.getDate() + Number(n) * 7); return d.getTime(); }
+      throw new Error(`date_add: unknown unit "${unit}". Use: ms/s/m/h/d/days/hours/minutes/months/years/weeks`);
+    },
+
+    // date_parse str -> number  ("2026-04-23" | "2026-04-23T12:00:00Z" -> timestamp ms)
+    "date_parse": (str: string): number => {
+      const ts = Date.parse(str);
+      if (isNaN(ts)) throw new Error(`date_parse: invalid date string "${str}"`);
+      return ts;
+    },
+
+    // sleep_ms ms -> void  (synchronous spin-wait, short durations only)
+    "sleep_ms": (ms: number): void => {
+      const end = Date.now() + ms;
+      while (Date.now() < end) { /* spin */ }
+    },
+
+    // ── Timer ─────────────────────────────────────────────────
+
+    // timer_start label -> Timer
+    "timer_start": (label: string): Timer => ({
+      start: Date.now(),
+      label,
+      laps: [],
+    }),
+
+    // timer_lap timer label -> Timer (record a lap time)
+    "timer_lap": (timer: Timer, label: string): Timer => ({
+      ...timer,
+      laps: [...timer.laps, { label, elapsed: Date.now() - timer.start }],
+    }),
+
+    // timer_elapsed timer -> number (ms since start)
+    "timer_elapsed": (timer: Timer): number => Date.now() - timer.start,
+
+    // timer_stop timer -> {label, total_ms, laps}
+    "timer_stop": (timer: Timer): Record<string, any> => ({
+      label: timer.label,
+      total_ms: Date.now() - timer.start,
+      laps: timer.laps,
+    }),
+
+    // ── Logger ────────────────────────────────────────────────
+
+    // log_create name level -> Logger  (level = minimum level to record)
+    "log_create": (name: string, level: LogLevel = "info"): Logger => ({
+      name, entries: [], level,
+    }),
+
+    // log_entry logger level msg data? -> Logger
+    "log_entry": (logger: Logger, level: LogLevel, msg: string, data?: any): Logger => {
+      if (LEVEL_ORDER[level] < LEVEL_ORDER[logger.level]) return logger;
+      const entry: LogEntry = { ts: Date.now(), level, msg };
+      if (data !== undefined) entry.data = data;
+      return { ...logger, entries: [...logger.entries, entry] };
+    },
+
+    // log_info logger msg -> Logger
+    "log_info": (logger: Logger, msg: string): Logger => {
+      if (LEVEL_ORDER["info"] < LEVEL_ORDER[logger.level]) return logger;
+      return { ...logger, entries: [...logger.entries, { ts: Date.now(), level: "info" as LogLevel, msg }] };
+    },
+
+    // log_warn logger msg -> Logger
+    "log_warn": (logger: Logger, msg: string): Logger => {
+      if (LEVEL_ORDER["warn"] < LEVEL_ORDER[logger.level]) return logger;
+      return { ...logger, entries: [...logger.entries, { ts: Date.now(), level: "warn" as LogLevel, msg }] };
+    },
+
+    // log_error logger msg -> Logger
+    "log_error": (logger: Logger, msg: string): Logger => ({
+      ...logger,
+      entries: [...logger.entries, { ts: Date.now(), level: "error" as LogLevel, msg }],
+    }),
+
+    // log_debug logger msg -> Logger
+    "log_debug": (logger: Logger, msg: string): Logger => {
+      if (LEVEL_ORDER["debug"] < LEVEL_ORDER[logger.level]) return logger;
+      return { ...logger, entries: [...logger.entries, { ts: Date.now(), level: "debug" as LogLevel, msg }] };
+    },
+
+    // log_filter logger level -> [LogEntry]  (entries at or above level)
+    "log_filter": (logger: Logger, level: LogLevel): LogEntry[] =>
+      logger.entries.filter(e => LEVEL_ORDER[e.level] >= LEVEL_ORDER[level]),
+
+    // log_count logger level -> number
+    "log_count": (logger: Logger, level: LogLevel): number =>
+      logger.entries.filter(e => e.level === level).length,
+
+    // log_last logger n -> [LogEntry]
+    "log_last": (logger: Logger, n: number): LogEntry[] => logger.entries.slice(-n),
+
+    // log_dump logger -> void  (print all entries to stdout)
+    "log_dump": (logger: Logger): void => {
+      const pad = (s: string) => s.padEnd(5);
+      for (const e of logger.entries) {
+        const ts = new Date(e.ts).toISOString().slice(11, 23);
+        const lvl = `[${pad(e.level.toUpperCase())}]`;
+        const data = e.data !== undefined ? ` | ${JSON.stringify(e.data)}` : "";
+        console.log(`${ts} ${lvl} [${logger.name}] ${e.msg}${data}`);
+      }
+    },
+
+    // ── Metrics ───────────────────────────────────────────────
+
+    // metrics_create name -> Metrics
+    "metrics_create": (name: string): Metrics => ({
+      name, values: {}, counters: {}, timers: {},
+    }),
+
+    // metrics_record metrics key value -> Metrics
+    "metrics_record": (m: Metrics, key: string, value: number): Metrics => ({
+      ...m,
+      values: { ...m.values, [key]: [...(m.values[key] ?? []), value] },
+    }),
+
+    // metrics_inc metrics key -> Metrics  (increment counter by 1)
+    "metrics_inc": (m: Metrics, key: string): Metrics => ({
+      ...m,
+      counters: { ...m.counters, [key]: (m.counters[key] ?? 0) + 1 },
+    }),
+
+    // metrics_inc_by metrics key n -> Metrics
+    "metrics_inc_by": (m: Metrics, key: string, n: number): Metrics => ({
+      ...m,
+      counters: { ...m.counters, [key]: (m.counters[key] ?? 0) + n },
+    }),
+
+    // metrics_count metrics key -> number
+    "metrics_count": (m: Metrics, key: string): number => m.counters[key] ?? 0,
+
+    // metrics_avg metrics key -> number
+    "metrics_avg": (m: Metrics, key: string): number => {
+      const vals = m.values[key] ?? [];
+      if (vals.length === 0) return 0;
+      return vals.reduce((a, b) => a + b, 0) / vals.length;
+    },
+
+    // metrics_min metrics key -> number
+    "metrics_min": (m: Metrics, key: string): number => {
+      const vals = m.values[key] ?? [];
+      return vals.length ? Math.min(...vals) : 0;
+    },
+
+    // metrics_max metrics key -> number
+    "metrics_max": (m: Metrics, key: string): number => {
+      const vals = m.values[key] ?? [];
+      return vals.length ? Math.max(...vals) : 0;
+    },
+
+    // metrics_p95 metrics key -> number  (95th percentile)
+    "metrics_p95": (m: Metrics, key: string): number => {
+      const vals = [...(m.values[key] ?? [])].sort((a, b) => a - b);
+      if (vals.length === 0) return 0;
+      return vals[Math.floor(vals.length * 0.95)];
+    },
+
+    // metrics_summary metrics -> {key: {count, avg, min, max}}
+    "metrics_summary": (m: Metrics): Record<string, any> => {
+      const result: Record<string, any> = {};
+      for (const [key, vals] of Object.entries(m.values)) {
+        const sorted = [...vals].sort((a, b) => a - b);
+        result[key] = {
+          count: vals.length,
+          avg: vals.reduce((a, b) => a + b, 0) / vals.length,
+          min: sorted[0],
+          max: sorted[sorted.length - 1],
+          p95: sorted[Math.floor(sorted.length * 0.95)],
+        };
+      }
+      for (const [key, count] of Object.entries(m.counters)) {
+        result[`counter.${key}`] = { count };
+      }
+      return result;
+    },
+  };
+}

package/src/stdlib-timer.ts

@@ -0,0 +1,134 @@
+// FreeLang v11: Timer Standard Library
+// Provides periodic and one-time timers
+// Essential for periodic tasks like checkpoint and WAL rotation
+
+type TimerCallback = () => void;
+
+// Global timer registry
+const timerRegistry: Map<number, NodeJS.Timer> = new Map();
+let nextTimerId = 2000; // Start from 2000 to avoid conflicts
+
+/**
+ * Create the timer module for FreeLang
+ * Provides: set_interval, clear_interval, set_timeout, clear_timeout
+ *
+ * Note: Callbacks are function names that will be looked up and invoked
+ * by the interpreter environment
+ */
+export function createTimerModule(interpreter: any) {
+  return {
+    // set_interval fn ms -> number (fn: function name string, ms: interval)
+    "set_interval": (fnName: string | any, ms: number): number => {
+      try {
+        const isFnObj = fnName && typeof fnName === "object" && fnName.body !== undefined;
+        if (typeof fnName !== "string" && !isFnObj) {
+          throw new Error(`Function name must be string or function, got ${typeof fnName}`);
+        }
+        if (typeof ms !== "number" || ms < 1) {
+          throw new Error(`Interval must be positive number, got ${ms}`);
+        }
+
+        const timerId = nextTimerId++;
+
+        const callback = () => {
+          try {
+            if (isFnObj) {
+              interpreter.callFunction(fnName, []);
+            } else {
+              interpreter.callUserFunction(fnName as string, []);
+            }
+          } catch (err: any) {
+            const label = isFnObj ? "<fn>" : fnName;
+            console.error(`set_interval callback error for '${label}':`, err.message);
+          }
+        };
+
+        const nodeTimer = setInterval(callback, ms);
+        timerRegistry.set(timerId, nodeTimer);
+        return timerId;
+      } catch (err: any) {
+        throw new Error(`set_interval failed: ${err.message}`);
+      }
+    },
+
+    // clear_interval timerId -> boolean (stop periodic timer)
+    "clear_interval": (timerId: number): boolean => {
+      try {
+        const nodeTimer = timerRegistry.get(timerId);
+        if (nodeTimer === undefined) {
+          return false; // Timer not found
+        }
+        clearInterval(nodeTimer);
+        timerRegistry.delete(timerId);
+        return true;
+      } catch (err: any) {
+        throw new Error(`clear_interval failed: ${err.message}`);
+      }
+    },
+
+    // set_timeout fn ms -> number (fn: function name string, ms: delay)
+    "set_timeout": (fnName: string, ms: number): number => {
+      try {
+        if (typeof fnName !== "string") {
+          throw new Error(`Function name must be string, got ${typeof fnName}`);
+        }
+        if (typeof ms !== "number" || ms < 1) {
+          throw new Error(`Timeout must be positive number, got ${ms}`);
+        }
+
+        const timerId = nextTimerId++;
+
+        // Create a wrapper that calls the FreeLang function once
+        const callback = () => {
+          try {
+            interpreter.callUserFunction(fnName, []);
+          } catch (err: any) {
+            console.error(`set_timeout callback error for '${fnName}':`, err.message);
+          }
+          // Auto-cleanup after execution
+          timerRegistry.delete(timerId);
+        };
+
+        const nodeTimer = setTimeout(callback, ms);
+        timerRegistry.set(timerId, nodeTimer);
+        return timerId;
+      } catch (err: any) {
+        throw new Error(`set_timeout failed: ${err.message}`);
+      }
+    },
+
+    // clear_timeout timerId -> boolean (cancel one-time timer)
+    "clear_timeout": (timerId: number): boolean => {
+      try {
+        const nodeTimer = timerRegistry.get(timerId);
+        if (nodeTimer === undefined) {
+          return false; // Timer not found
+        }
+        clearTimeout(nodeTimer);
+        timerRegistry.delete(timerId);
+        return true;
+      } catch (err: any) {
+        throw new Error(`clear_timeout failed: ${err.message}`);
+      }
+    },
+
+    // timer_count -> number (returns count of active timers)
+    "timer_count": (): number => {
+      return timerRegistry.size;
+    },
+
+    // timer_clear_all -> boolean (clear all active timers)
+    "timer_clear_all": (): boolean => {
+      try {
+        for (const nodeTimer of timerRegistry.values()) {
+          clearInterval(nodeTimer);
+          clearTimeout(nodeTimer);
+        }
+        timerRegistry.clear();
+        return true;
+      } catch (err: any) {
+        throw new Error(`timer_clear_all failed: ${err.message}`);
+      }
+    },
+  };
+}

package/src/stdlib-totp.ts

@@ -0,0 +1,110 @@
+// FreeLang v11: TOTP (Time-Based One-Time Password) — RFC 6238 / RFC 4226
+//
+// dclub-auth IdP의 2단계 인증 기반시설.
+// HMAC-SHA1 + 30초 step + 6 digits + ±1 step clock skew window.
+// 외부 npm 0개 — Node 표준 crypto 만 사용.
+//
+// 표준 호환:
+//   - Google Authenticator, Authy, 1Password 등 모든 RFC 6238 클라이언트와 호환
+//   - otpauth:// URI 표준 (Key URI Format) 사용
+
+import { createHmac, randomBytes, timingSafeEqual } from "crypto";
+
+// ── Base32 (RFC 4648, no padding for TOTP) ────────────────────────
+const BASE32_ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+function base32Encode(buf: Buffer): string {
+  let bits = 0, value = 0, output = "";
+  for (let i = 0; i < buf.length; i++) {
+    value = (value << 8) | buf[i];
+    bits += 8;
+    while (bits >= 5) {
+      output += BASE32_ALPHA[(value >>> (bits - 5)) & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) output += BASE32_ALPHA[(value << (5 - bits)) & 31];
+  return output;
+}
+
+function base32Decode(str: string): Buffer {
+  const clean = str.replace(/=+$/, "").toUpperCase();
+  let bits = 0, value = 0;
+  const out: number[] = [];
+  for (let i = 0; i < clean.length; i++) {
+    const idx = BASE32_ALPHA.indexOf(clean[i]);
+    if (idx === -1) throw new Error(`invalid base32 char: ${clean[i]}`);
+    value = (value << 5) | idx;
+    bits += 5;
+    if (bits >= 8) {
+      out.push((value >>> (bits - 8)) & 0xff);
+      bits -= 8;
+    }
+  }
+  return Buffer.from(out);
+}
+
+// ── HOTP / TOTP core (RFC 4226 §5.3) ──────────────────────────────
+function hotp(secret: Buffer, counter: number, digits: number = 6): string {
+  // counter as 8-byte big-endian
+  const ctrBuf = Buffer.alloc(8);
+  // JS bitwise is 32-bit; for 64-bit counter split into high/low
+  const high = Math.floor(counter / 0x100000000);
+  const low = counter >>> 0;
+  ctrBuf.writeUInt32BE(high, 0);
+  ctrBuf.writeUInt32BE(low, 4);
+
+  const hmac = createHmac("sha1", secret).update(ctrBuf).digest();
+  const offset = hmac[hmac.length - 1] & 0x0f;
+  const truncated = ((hmac[offset] & 0x7f) << 24)
+                  | ((hmac[offset + 1] & 0xff) << 16)
+                  | ((hmac[offset + 2] & 0xff) << 8)
+                  |  (hmac[offset + 3] & 0xff);
+  const code = truncated % Math.pow(10, digits);
+  return code.toString().padStart(digits, "0");
+}
+
+function totpCounter(unixSeconds: number, step: number = 30): number {
+  return Math.floor(unixSeconds / step);
+}
+
+export function createTotpModule() {
+  return {
+    // totp_secret_generate bytes -> string (base32, default 20 bytes = 160 bits = 32 chars)
+    "totp_secret_generate": (bytes: number = 20): string => {
+      const buf = randomBytes(bytes);
+      return base32Encode(buf);
+    },
+
+    // totp_now secret_b32 -> string (현재 시각의 6자리 코드, 디버그·등록용)
+    "totp_now": (secretB32: string): string => {
+      const secret = base32Decode(secretB32);
+      const counter = totpCounter(Math.floor(Date.now() / 1000));
+      return hotp(secret, counter, 6);
+    },
+
+    // totp_verify secret_b32 code window_steps -> boolean
+    // window=1 → 현재 ±1 step (총 90초 윈도우) 허용 (시계 오차 보정)
+    "totp_verify": (secretB32: string, code: string, window: number = 1): boolean => {
+      try {
+        if (!/^\d+$/.test(code)) return false;
+        const secret = base32Decode(secretB32);
+        const now = totpCounter(Math.floor(Date.now() / 1000));
+        const expected = Buffer.from(code);
+        for (let i = -window; i <= window; i++) {
+          const candidate = Buffer.from(hotp(secret, now + i, code.length));
+          if (candidate.length === expected.length && timingSafeEqual(candidate, expected)) {
+            return true;
+          }
+        }
+        return false;
+      } catch { return false; }
+    },
+
+    // totp_uri label issuer secret_b32 -> string (otpauth://totp/... QR 코드 표준)
+    "totp_uri": (label: string, issuer: string, secretB32: string): string => {
+      const enc = (s: string) => encodeURIComponent(s);
+      return `otpauth://totp/${enc(issuer)}:${enc(label)}?secret=${secretB32}&issuer=${enc(issuer)}&algorithm=SHA1&digits=6&period=30`;
+    },
+  };
+}

package/src/stdlib-type-predicates.ts

@@ -0,0 +1,136 @@
+// FreeLang v11: 타입 Predicate 통일 정의 (Phase B, 2026-04-25)
+//
+// 목적:
+// - 타입 체크 함수가 여러 파일에 분산되어 single source of truth 부재였던 문제 해결
+// - 표준 이름과 alias 매핑을 한 곳에 명시 → audit/문서/IDE 자동완성에 활용
+// - 실제 등록은 여전히 eval-builtins.ts에서 case 패턴으로 수행 (호환성 유지)
+//
+// 향후 점진적 리팩토링:
+// - eval-builtins.ts에서 이 모듈을 import해서 등록 자동화
+// - 새 predicate 추가 시 이 파일만 수정하면 됨
+//
+// 사용처:
+// - linter / lsp-server: "function?"는 "fn?"의 alias임을 인식
+// - error-formatter: "did you mean ___?" 후보 풀
+// - codegen: cg-native-dispatch가 표준 이름만 인식해도 alias가 자동 변환
+
+/** 표준 predicate 정의 — 각 항목에 표준 이름 + 구현 + alias 목록 */
+export interface PredicateDef {
+  name: string;       // 표준 이름 (canonical)
+  aliases: string[];  // 같은 의미의 다른 이름들
+  test: (v: any) => boolean;
+  doc: string;        // 한 줄 설명
+}
+
+export const TYPE_PREDICATES: PredicateDef[] = [
+  {
+    name: "null?",
+    aliases: ["nil?"],
+    test: (v) => v === null || v === undefined,
+    doc: "값이 null 또는 undefined인지",
+  },
+  {
+    name: "some?",
+    aliases: ["not-nil?"],
+    test: (v) => v !== null && v !== undefined,
+    doc: "값이 nil이 아닌지 — (not (nil? x)) 단축형",
+  },
+  {
+    name: "nil-or-empty?",
+    aliases: [],
+    test: (v) => v === null || v === undefined || (v && v.length === 0),
+    doc: "nil이거나 빈 배열·문자열인지",
+  },
+  {
+    name: "empty?",
+    aliases: [],
+    test: (v) =>
+      Array.isArray(v) ? v.length === 0
+      : typeof v === "string" ? v.length === 0
+      : (v === null || v === undefined),
+    doc: "빈 배열·문자열·nil",
+  },
+  {
+    name: "string?",
+    aliases: [],
+    test: (v) => typeof v === "string",
+    doc: "문자열 타입",
+  },
+  {
+    name: "number?",
+    aliases: [],
+    test: (v) => typeof v === "number",
+    doc: "숫자 타입 (int/float)",
+  },
+  {
+    name: "boolean?",
+    aliases: ["bool?"],
+    test: (v) => typeof v === "boolean",
+    doc: "참/거짓 타입",
+  },
+  {
+    name: "list?",
+    aliases: ["array?"],
+    test: (v) => Array.isArray(v),
+    doc: "배열(리스트) 타입",
+  },
+  {
+    name: "map?",
+    aliases: [],
+    test: (v) => v !== null && typeof v === "object" && !Array.isArray(v),
+    doc: "맵(객체) 타입",
+  },
+  {
+    name: "fn?",
+    aliases: ["function?"],
+    test: (v) => typeof v === "function",
+    doc: "함수 타입",
+  },
+  {
+    name: "zero?",
+    aliases: [],
+    test: (v) => v === 0,
+    doc: "정확히 0",
+  },
+  {
+    name: "true?",
+    aliases: [],
+    test: (v) => v === true,
+    doc: "정확히 true",
+  },
+  {
+    name: "false?",
+    aliases: [],
+    test: (v) => v === false,
+    doc: "정확히 false",
+  },
+];
+
+/** 모든 predicate 이름 (표준 + alias) — IDE 자동완성·linter용 */
+export const ALL_PREDICATE_NAMES: string[] = TYPE_PREDICATES.flatMap(
+  (p) => [p.name, ...p.aliases]
+);
+
+/** alias → canonical 이름 매핑 */
+export const ALIAS_TO_CANONICAL: Record<string, string> = (() => {
+  const m: Record<string, string> = {};
+  for (const p of TYPE_PREDICATES) {
+    m[p.name] = p.name;
+    for (const alias of p.aliases) m[alias] = p.name;
+  }
+  return m;
+})();
+
+/** 이름으로 predicate 정의 조회 (alias도 인식) */
+export function getPredicate(name: string): PredicateDef | null {
+  const canonical = ALIAS_TO_CANONICAL[name];
+  if (!canonical) return null;
+  return TYPE_PREDICATES.find((p) => p.name === canonical) ?? null;
+}
+
+/** 표준 predicate 직접 호출 — 동적 dispatch 필요 시 */
+export function evalPredicate(name: string, value: any): boolean | null {
+  const p = getPredicate(name);
+  if (!p) return null;
+  return p.test(value);
+}