@zntc/wasm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ohah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# @zntc/wasm
+
+ZNTC 의 WASM 빌드 — 브라우저 / Bun / Node 환경에서 native binary (`zntc.node`) 없이 순수 WASM 으로 트랜스파일/번들 실행.
+
+`@zntc/core` 의 NAPI 모듈을 쓸 수 없는 환경 (Edge runtime, Cloudflare Workers, 브라우저 in-page transpile 등) 용.
+
+## 설치
+
+```bash
+bun add -D @zntc/wasm
+# 또는
+npm i -D @zntc/wasm
+```
+
+WASM binary (`zntc.wasm` ~1.1MB / `zntc-bundler.wasm` ~2.0MB, gzipped 시 388KB / 675KB) 가 함께 install 됨.
+
+## 사용 예
+
+### Browser / Edge runtime
+
+```ts
+import { init, transpile } from '@zntc/wasm';
+import wasmUrl from '@zntc/wasm/zntc.wasm?url'; // Vite 전용 syntax
+
+await init(wasmUrl);
+const r = transpile('const x: number = 1;', { filename: 'input.ts' });
+console.log(r.code);
+```
+
+> Vite 가 아닌 bundler 는 `fetch(new URL('@zntc/wasm/zntc.wasm', import.meta.url))` 또는 각자의 asset import 패턴 사용.
+
+### Node.js / Bun (auto-resolve)
+
+```ts
+import { init, transpile } from '@zntc/wasm';
+
+await init(); // 동봉 zntc.wasm 자동 로드 (fs.readFileSync)
+const r = transpile('const x: number = 1;', { filename: 'input.ts' });
+```
+
+### Bundler 사용
+
+```ts
+import { bundlerLastErrorMessage, build, initBundler } from '@zntc/wasm';
+import wasmUrl from '@zntc/wasm/zntc-bundler.wasm?url';
+
+await initBundler(wasmUrl); // transpile 용 init() 와 별도
+const out = build('/main.ts', { format: 'esm', target: 'es2020' });
+if (out === null) throw new Error(bundlerLastErrorMessage());
+```
+
+`build` 는 sync 이며 실패 시 `null` 반환 — `bundlerLastErrorMessage()` 로 마지막 에러 조회.
+
+## NAPI 와 차이
+
+| 항목        | @zntc/core (NAPI) | @zntc/wasm                            |
+| ----------- | ----------------- | ------------------------------------- |
+| 환경        | Node.js / Bun     | + Browser / Edge / Workers            |
+| 속도        | 빠름 (~native)    | 50~70% (WASM 오버헤드)                |
+| binary 크기 | ~4MB (.node)      | 1.1MB + 2.0MB (gzipped 388KB + 675KB) |
+| install     | 플랫폼별 prebuilt | 단일 wasm (universal)                 |
+
+대부분의 server-side 빌드 사용 사례는 `@zntc/core` 권장. `@zntc/wasm` 은 환경 제약 시.
+
+## 관련
+
+- [@zntc/core](https://npmjs.com/package/@zntc/core) — Native (NAPI) 빌드
+- [docs/USAGE.md](https://github.com/ohah/zts/blob/main/docs/USAGE.md)
+
+## 라이센스
+
+MIT.

package/dist/index.js

@@ -0,0 +1,493 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+// ../shared/index.ts
+var ES_TARGET_BITS = {
+  es5: 268435455,
+  es2015: 117438464,
+  es2016: 117436416,
+  es2017: 117432320,
+  es2018: 16760832,
+  es2019: 16744448,
+  es2020: 16646144,
+  es2021: 16515072,
+  es2022: 12582912,
+  es2023: 8388608,
+  es2024: 8388608,
+  es2025: 0,
+  esnext: 0
+};
+function targetToUnsupported(target) {
+  if (!target)
+    return 0;
+  return ES_TARGET_BITS[target] ?? 0;
+}
+function buildOptionsJson(opts = {}, unsupportedOverride) {
+  const payload = {};
+  if (opts.target)
+    payload.target = opts.target;
+  if (unsupportedOverride !== undefined && unsupportedOverride !== 0)
+    payload.unsupported = unsupportedOverride;
+  if (opts.flow)
+    payload.flow = true;
+  if (opts.jsxInJs)
+    payload.jsxInJs = true;
+  if (opts.reactRefresh)
+    payload.reactRefresh = true;
+  if (opts.reactRefreshHookSignatures)
+    payload.reactRefreshHookSignatures = true;
+  if (opts.jsx !== undefined) {
+    payload.jsx = opts.jsx === "automatic-dev" ? "automatic_dev" : opts.jsx;
+  }
+  if (opts.jsxFactory)
+    payload.jsxFactory = opts.jsxFactory;
+  if (opts.jsxFragment)
+    payload.jsxFragment = opts.jsxFragment;
+  if (opts.jsxImportSource)
+    payload.jsxImportSource = opts.jsxImportSource;
+  if (opts.dropConsole)
+    payload.dropConsole = true;
+  if (opts.dropDebugger)
+    payload.dropDebugger = true;
+  if (opts.asciiOnly)
+    payload.asciiOnly = true;
+  if (opts.charsetUtf8)
+    payload.charsetUtf8 = true;
+  if (opts.experimentalDecorators)
+    payload.experimentalDecorators = true;
+  if (opts.emitDecoratorMetadata)
+    payload.emitDecoratorMetadata = true;
+  if (opts.useDefineForClassFields === false)
+    payload.useDefineForClassFields = false;
+  if (opts.verbatimModuleSyntax !== undefined)
+    payload.verbatimModuleSyntax = opts.verbatimModuleSyntax;
+  if (opts.tsconfigPath)
+    payload.tsconfigPath = opts.tsconfigPath;
+  if (opts.tsconfigRaw)
+    payload.tsconfigRaw = opts.tsconfigRaw;
+  if (opts.format)
+    payload.format = opts.format;
+  if (opts.quotes)
+    payload.quotes = opts.quotes;
+  if (opts.platform === "react-native")
+    payload.platform = "react_native";
+  else if (opts.platform)
+    payload.platform = opts.platform;
+  if (opts.minifyWhitespace || opts.minify)
+    payload.minifyWhitespace = true;
+  if (opts.minifyIdentifiers || opts.minify)
+    payload.minifyIdentifiers = true;
+  if (opts.minifySyntax || opts.minify)
+    payload.minifySyntax = true;
+  if (opts.sourcemap)
+    payload.sourcemap = true;
+  if (opts.sourcemapDebugIds)
+    payload.sourcemapDebugIds = true;
+  if (opts.sourcesContent === false)
+    payload.sourcesContent = false;
+  if (opts.sourceRoot)
+    payload.sourceRoot = opts.sourceRoot;
+  if (opts.define && opts.define.length > 0)
+    payload.define = opts.define;
+  if (opts.stopAfter)
+    payload.stopAfter = opts.stopAfter;
+  return JSON.stringify(payload);
+}
+
+// index.ts
+var wasm = null;
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+function createWasiImports(memory) {
+  const ok = () => 0;
+  return {
+    wasi_snapshot_preview1: {
+      fd_write(fd, iovs_ptr, iovs_len, nwritten_ptr) {
+        const mem = new DataView(memory().buffer);
+        const bytes = new Uint8Array(memory().buffer);
+        let written = 0;
+        for (let i = 0;i < iovs_len; i++) {
+          const ptr = mem.getUint32(iovs_ptr + i * 8, true);
+          const len = mem.getUint32(iovs_ptr + i * 8 + 4, true);
+          const chunk = bytes.slice(ptr, ptr + len);
+          if (fd === 2)
+            console.error(decoder.decode(chunk));
+          written += len;
+        }
+        mem.setUint32(nwritten_ptr, written, true);
+        return 0;
+      },
+      fd_read: ok,
+      fd_seek: ok,
+      fd_pwrite: ok,
+      fd_pread: ok,
+      fd_close: ok,
+      fd_fdstat_get: ok,
+      fd_fdstat_set_flags: ok,
+      fd_filestat_get: ok,
+      fd_prestat_get: () => 8,
+      fd_prestat_dir_name: ok,
+      fd_sync: ok,
+      random_get(buf_ptr, buf_len) {
+        const bytes = new Uint8Array(memory().buffer, buf_ptr, buf_len);
+        if (typeof globalThis.crypto !== "undefined") {
+          crypto.getRandomValues(bytes);
+        } else {
+          for (let i = 0;i < buf_len; i++)
+            bytes[i] = Math.random() * 256 | 0;
+        }
+        return 0;
+      },
+      clock_time_get(clock_id, _precision, ts_ptr) {
+        const mem = new DataView(memory().buffer);
+        const ns = clock_id === 0 ? BigInt(Date.now()) * 1000000n : BigInt(Math.floor(performance.now() * 1e6));
+        mem.setBigUint64(ts_ptr, ns, true);
+        return 0;
+      },
+      clock_res_get(_clock_id, ts_ptr) {
+        const mem = new DataView(memory().buffer);
+        mem.setBigUint64(ts_ptr, 1000000n, true);
+        return 0;
+      },
+      args_sizes_get(argc_ptr, argv_buf_size_ptr) {
+        const mem = new DataView(memory().buffer);
+        mem.setUint32(argc_ptr, 0, true);
+        mem.setUint32(argv_buf_size_ptr, 0, true);
+        return 0;
+      },
+      args_get: ok,
+      environ_sizes_get(envc_ptr, env_buf_size_ptr) {
+        const mem = new DataView(memory().buffer);
+        mem.setUint32(envc_ptr, 0, true);
+        mem.setUint32(env_buf_size_ptr, 0, true);
+        return 0;
+      },
+      environ_get: ok,
+      proc_exit(code) {
+        throw new Error(`zntc-wasm: proc_exit(${code})`);
+      },
+      sched_yield: ok,
+      poll_oneoff: ok,
+      path_open: () => 8,
+      path_filestat_get: () => 8,
+      path_unlink_file: ok,
+      path_create_directory: ok,
+      path_remove_directory: ok,
+      path_rename: ok,
+      path_link: ok,
+      path_symlink: ok,
+      path_readlink: () => 8
+    },
+    wasi: {
+      "thread-spawn": () => -1
+    }
+  };
+}
+function writeString(s) {
+  const bytes = encoder.encode(s);
+  const ptr = wasm.alloc(bytes.length);
+  if (ptr === 0)
+    throw new Error("zntc-wasm: alloc failed");
+  new Uint8Array(wasm.memory.buffer, ptr, bytes.length).set(bytes);
+  return [ptr, bytes.length];
+}
+function readString(ptr, len) {
+  return decoder.decode(new Uint8Array(wasm.memory.buffer, ptr, len));
+}
+async function resolveWasmSource(input, defaultFile) {
+  if (input === undefined) {
+    const fs = await import("node:fs");
+    const path = await import("node:path");
+    const url = await import("node:url");
+    const __dirname2 = path.dirname(url.fileURLToPath(import.meta.url));
+    const candidates = [path.join(__dirname2, defaultFile), path.join(__dirname2, "..", defaultFile)];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate))
+        return fs.readFileSync(candidate);
+    }
+    throw new Error(`zntc-wasm: ${defaultFile} not found near ${__dirname2}`);
+  }
+  if (input instanceof WebAssembly.Module)
+    return input;
+  if (input instanceof Response)
+    return input;
+  if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+    return input;
+  }
+  return await fetch(input);
+}
+async function instantiateWasm(source, imports) {
+  if (source instanceof WebAssembly.Module) {
+    return new WebAssembly.Instance(source, imports);
+  }
+  if (source instanceof Response) {
+    const result2 = await WebAssembly.instantiateStreaming(source, imports);
+    return result2.instance;
+  }
+  const result = await WebAssembly.instantiate(source, imports);
+  return result.instance;
+}
+async function init(input) {
+  if (wasm)
+    return;
+  const source = await resolveWasmSource(input, "zntc.wasm");
+  let memory;
+  const imports = createWasiImports(() => memory);
+  const instance = await instantiateWasm(source, imports);
+  memory = instance.exports.memory;
+  wasm = instance.exports;
+}
+function initSync(input) {
+  if (wasm)
+    return;
+  let memory;
+  const imports = createWasiImports(() => memory);
+  const mod = input instanceof WebAssembly.Module ? input : new WebAssembly.Module(input instanceof ArrayBuffer ? input : input.buffer);
+  const instance = new WebAssembly.Instance(mod, imports);
+  memory = instance.exports.memory;
+  wasm = instance.exports;
+}
+function transpile(source, options = {}) {
+  if (!wasm) {
+    throw new Error("zntc-wasm: not initialized. Call init() or initSync() first.");
+  }
+  const [srcPtr, srcLen] = writeString(source);
+  const [filePtr, fileLen] = options.filename ? writeString(options.filename) : [0, 0];
+  const optsJson = buildOptionsJson(options, targetToUnsupported(options.target));
+  const [optsPtr, optsLen] = writeString(optsJson);
+  try {
+    const packed = wasm.transpile(srcPtr, srcLen, filePtr, fileLen, optsPtr, optsLen);
+    const outPtr = Number(packed >> 32n);
+    const outLen = Number(packed & 0xffffffffn);
+    const errLen = wasm.get_error_len();
+    const errMsg = errLen === 0 ? "" : readString(wasm.get_error_ptr(), errLen);
+    if (outPtr === 0) {
+      if (outLen === 0 && errLen === 0)
+        return { code: "" };
+      throw new Error(`zntc-wasm: ${errMsg || "unknown error"}`);
+    }
+    const raw = readString(outPtr, outLen);
+    wasm.dealloc(outPtr, outLen);
+    const nullIdx = options.sourcemap ? raw.indexOf("\x00") : -1;
+    const result = nullIdx !== -1 ? { code: raw.slice(0, nullIdx), map: raw.slice(nullIdx + 1) } : { code: raw };
+    if (errMsg)
+      result.errors = errMsg;
+    return result;
+  } finally {
+    wasm.dealloc(srcPtr, srcLen);
+    if (filePtr)
+      wasm.dealloc(filePtr, fileLen);
+    wasm.dealloc(optsPtr, optsLen);
+  }
+}
+
+class VirtualFileSystem {
+  files = new Map;
+  set(path, content) {
+    const bytes = typeof content === "string" ? encoder.encode(content) : content;
+    this.files.set(path, bytes);
+  }
+  get(path) {
+    return this.files.get(path);
+  }
+  has(path) {
+    return this.files.has(path);
+  }
+  delete(path) {
+    return this.files.delete(path);
+  }
+  paths() {
+    return this.files.keys();
+  }
+  size() {
+    return this.files.size;
+  }
+  clear() {
+    this.files.clear();
+  }
+}
+var bundler = null;
+var bundlerMemory = null;
+var bundlerVfs = null;
+function readBundlerString(ptr, len) {
+  const view = new Uint8Array(bundlerMemory.buffer, ptr, len);
+  return decoder.decode(view.slice());
+}
+function packBytes(data) {
+  if (!bundler || !bundlerMemory)
+    return 0n;
+  const ptr = bundler.alloc(data.length);
+  if (ptr === 0)
+    return 0n;
+  new Uint8Array(bundlerMemory.buffer, ptr, data.length).set(data);
+  return BigInt(ptr) << 32n | BigInt(data.length);
+}
+function createBundlerImports(memory) {
+  const wasi = createWasiImports(memory);
+  return {
+    ...wasi,
+    zntc_fs: {
+      readFile(pathPtr, pathLen, _maxBytes) {
+        const path = readBundlerString(pathPtr, pathLen);
+        const data = bundlerVfs?.get(path);
+        if (!data)
+          return 0n;
+        return packBytes(data);
+      },
+      statFile(pathPtr, pathLen, outSize, outKind, outMtimeLo, outMtimeHi) {
+        const path = readBundlerString(pathPtr, pathLen);
+        const data = bundlerVfs?.get(path);
+        if (!data)
+          return 1;
+        const view = new DataView(bundlerMemory.buffer);
+        view.setBigUint64(outSize, BigInt(data.length), true);
+        new Uint8Array(bundlerMemory.buffer, outKind, 1)[0] = 0;
+        view.setBigUint64(outMtimeLo, 0n, true);
+        view.setBigUint64(outMtimeHi, 0n, true);
+        return 0;
+      },
+      access(pathPtr, pathLen) {
+        const path = readBundlerString(pathPtr, pathLen);
+        return bundlerVfs?.has(path) ? 0 : 1;
+      },
+      realpath(pathPtr, pathLen) {
+        const path = readBundlerString(pathPtr, pathLen);
+        if (!bundlerVfs?.has(path))
+          return 0n;
+        return packBytes(encoder.encode(path));
+      },
+      listDir(_pathPtr, _pathLen) {
+        return 0n;
+      },
+      hostFreeBytes(ptr, len) {
+        bundler?.dealloc(ptr, len);
+      }
+    }
+  };
+}
+async function initBundler(vfs, input) {
+  if (bundler)
+    return;
+  const source = await resolveWasmSource(input, "zntc-bundler.wasm");
+  const memory = new WebAssembly.Memory({
+    initial: 1024,
+    maximum: 65536,
+    shared: true
+  });
+  const bundlerImports = createBundlerImports(() => memory);
+  const imports = {
+    ...bundlerImports,
+    env: { memory }
+  };
+  const instance = await instantiateWasm(source, imports);
+  bundler = instance.exports;
+  bundlerMemory = memory;
+  bundlerVfs = vfs;
+}
+function bundlerVersion() {
+  if (!bundler) {
+    throw new Error("zntc-wasm: bundler not initialized. Call initBundler() first.");
+  }
+  return bundler.bundler_version();
+}
+function encodeBundleOptions(options) {
+  if (!options)
+    return { ptr: 0, len: 0 };
+  const expanded = { ...options };
+  if (expanded.minify) {
+    expanded.minifyWhitespace = expanded.minifyWhitespace ?? true;
+    expanded.minifyIdentifiers = expanded.minifyIdentifiers ?? true;
+    expanded.minifySyntax = expanded.minifySyntax ?? true;
+  }
+  delete expanded.minify;
+  if (expanded.target && expanded.unsupported == null) {
+    const bits = targetToUnsupported(expanded.target);
+    if (bits !== 0)
+      expanded.unsupported = bits;
+  }
+  delete expanded.target;
+  const optsBytes = encoder.encode(JSON.stringify(expanded));
+  const ptr = bundler.alloc(optsBytes.length);
+  if (ptr === 0)
+    throw new Error("zntc-wasm: bundler alloc failed");
+  new Uint8Array(bundlerMemory.buffer, ptr, optsBytes.length).set(optsBytes);
+  return { ptr, len: optsBytes.length };
+}
+function bundlerLastErrorMessage() {
+  if (!bundler || !bundlerMemory)
+    return "";
+  const packed = bundler.last_error_message_get();
+  if (packed === 0n)
+    return "";
+  const ptr = Number(packed >> 32n);
+  const len = Number(packed & 0xffffffffn);
+  const view = new Uint8Array(bundlerMemory.buffer, ptr, len);
+  return decoder.decode(view.slice());
+}
+function build(entryPath, options) {
+  if (!bundler || !bundlerMemory) {
+    throw new Error("zntc-wasm: bundler not initialized. Call initBundler() first.");
+  }
+  const entryBytes = encoder.encode(entryPath);
+  const entryPtr = bundler.alloc(entryBytes.length);
+  if (entryPtr === 0)
+    throw new Error("zntc-wasm: bundler alloc failed");
+  new Uint8Array(bundlerMemory.buffer, entryPtr, entryBytes.length).set(entryBytes);
+  const { ptr: optsPtr, len: optsLen } = encodeBundleOptions(options);
+  try {
+    const packed = bundler.build(entryPtr, entryBytes.length, optsPtr, optsLen);
+    if (packed === 0n)
+      return null;
+    const outPtr = Number(packed >> 32n);
+    const outLen = Number(packed & 0xffffffffn);
+    const view = new Uint8Array(bundlerMemory.buffer, outPtr, outLen);
+    const code = decoder.decode(view.slice());
+    bundler.dealloc(outPtr, outLen);
+    return { code };
+  } finally {
+    bundler.dealloc(entryPtr, entryBytes.length);
+    if (optsPtr)
+      bundler.dealloc(optsPtr, optsLen);
+  }
+}
+function buildChunks(entryPath, options) {
+  if (!bundler || !bundlerMemory) {
+    throw new Error("zntc-wasm: bundler not initialized. Call initBundler() first.");
+  }
+  const entryBytes = encoder.encode(entryPath);
+  const entryPtr = bundler.alloc(entryBytes.length);
+  if (entryPtr === 0)
+    throw new Error("zntc-wasm: bundler alloc failed");
+  new Uint8Array(bundlerMemory.buffer, entryPtr, entryBytes.length).set(entryBytes);
+  const { ptr: optsPtr, len: optsLen } = encodeBundleOptions(options);
+  try {
+    const packed = bundler.build_chunks(entryPtr, entryBytes.length, optsPtr, optsLen);
+    if (packed === 0n)
+      return null;
+    const outPtr = Number(packed >> 32n);
+    const outLen = Number(packed & 0xffffffffn);
+    const view = new Uint8Array(bundlerMemory.buffer, outPtr, outLen);
+    const json = decoder.decode(view.slice());
+    bundler.dealloc(outPtr, outLen);
+    return JSON.parse(json);
+  } finally {
+    bundler.dealloc(entryPtr, entryBytes.length);
+    if (optsPtr)
+      bundler.dealloc(optsPtr, optsLen);
+  }
+}
+export {
+  transpile,
+  initSync,
+  initBundler,
+  init,
+  bundlerVersion,
+  bundlerLastErrorMessage,
+  buildChunks,
+  build,
+  VirtualFileSystem
+};

package/dist/shared/compat-engines.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Engine × Feature 지원 버전 테이블 (JS 미러).
+ *
+ * src/transformer/compat.zig의 compat_table을 거울 복사.
+ * browserslist → UnsupportedFeatures bitmask 계산에 사용.
+ *
+ * **주의**: compat.zig를 수정하면 이 파일도 함께 업데이트.
+ * 장기적으론 scripts/compat-from-kangax.ts를 확장해 자동 생성.
+ *
+ * Bit 레이아웃은 packages/shared/index.ts ES_TARGET_BITS와 동일 (0-27).
+ */
+export type Engine = 'chrome' | 'firefox' | 'safari' | 'edge' | 'node' | 'deno' | 'ios' | 'opera' | 'hermes';
+/** compat.zig의 Feature enum과 동일 순서. bit 위치 = 배열 인덱스. */
+export declare const FEATURES: readonly ["arrow", "class", "template_literal", "destructuring", "for_of", "spread", "object_extensions", "default_params", "block_scoping", "generator", "new_target", "exponentiation", "async_await", "object_spread", "optional_catch_binding", "nullish_coalescing", "optional_chaining", "logical_assignment", "class_static_block", "class_private_method", "class_private_field", "top_level_await", "hashbang", "using", "regex_sticky", "regex_dotall", "regex_named_groups", "unicode_brace_escape"];
+export type Feature = (typeof FEATURES)[number];
+/**
+ * feature × engine → 최소 지원 버전 [major, minor].
+ * 엔진에 키가 없으면 "해당 엔진에서 미지원" (compat.zig의 보수적 해석).
+ */
+export declare const SUPPORT: Partial<Record<Feature, Partial<Record<Engine, [number, number]>>>>;
+export type EngineVersion = {
+    engine: Engine;
+    major: number;
+    minor: number;
+};
+/**
+ * 엔진 목록에 대해 unsupported feature bitmask 계산.
+ * 하나라도 미지원인 feature는 set (가장 보수적).
+ */
+export declare function computeUnsupportedFromEngines(engines: EngineVersion[]): number;

package/dist/shared/index.d.ts

@@ -0,0 +1,185 @@
+/**
+ * @zntc/shared — Types and utilities shared by @zntc/core and @zntc/wasm.
+ */
+export type Target = 'es5' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'es2023' | 'es2024' | 'es2025' | 'esnext';
+export type Platform = 'browser' | 'node' | 'neutral' | 'react-native';
+export interface TranspileOptions {
+    /** File path (used for extension detection, default: "input.ts"). */
+    filename?: string;
+    /** Generate a source map. */
+    sourcemap?: boolean;
+    /** Source map Debug ID (Sentry-compatible). */
+    sourcemapDebugIds?: boolean;
+    /** Include the original source in the source map (default: true). */
+    sourcesContent?: boolean;
+    /** Minify whitespace. */
+    minifyWhitespace?: boolean;
+    /** Minify identifiers. */
+    minifyIdentifiers?: boolean;
+    /** Minify syntax. */
+    minifySyntax?: boolean;
+    /** Full minification (whitespace + identifiers + syntax). */
+    minify?: boolean;
+    /** JSX runtime. `'preserve'` emits JSX unchanged — only TypeScript annotations
+     * are stripped. Use this to delegate JSX handling to a downstream tool (e.g.
+     * @vitejs/plugin-react, @preact/preset-vite, vite-plugin-solid). Equivalent to
+     * tsc `"jsx": "preserve"`. */
+    jsx?: 'classic' | 'automatic' | 'automatic-dev' | 'preserve';
+    /** classic-mode JSX factory (default: "React.createElement"). */
+    jsxFactory?: string;
+    /** classic-mode Fragment factory (default: "React.Fragment"). */
+    jsxFragment?: string;
+    /** automatic-mode import source (default: "react"). */
+    jsxImportSource?: string;
+    /** Allow JSX in .js files as well. */
+    jsxInJs?: boolean;
+    /**
+     * React Fast Refresh transform — registers components via
+     * `$RefreshReg$(_c, "Name")`. Equivalent to the SWC builtin
+     * `jsc.transform.react.refresh: true` / babel-plugin-react-refresh component
+     * registration. Used by loaders (rspack-loader, webpack/vite plugin) when
+     * enabled on the single-file transpile path.
+     *
+     * The default behavior is Metro-compatible (registration only, no hook
+     * signatures). The babel/SWC-equivalent hook signature emit is opt-in via
+     * `reactRefreshHookSignatures: true`. Defining the HMR runtime
+     * ($RefreshReg$/$RefreshSig$) is the consumer's responsibility.
+     */
+    reactRefresh?: boolean;
+    /**
+     * On top of `reactRefresh: true`, adds hook signature emit
+     * (`var _s = $RefreshSig$();` + `_s(Component, "sig")`). Equivalent to
+     * babel-plugin-react-refresh. Default false — preserves the Metro policy
+     * (no signatures).
+     *
+     * When enabled, the transformer scans hook calls inside function bodies to
+     * build the signature string, then emits a `_s(Comp, "sig")` call right after
+     * component registration. RN HMR keeps the default (false), so it is
+     * unaffected.
+     */
+    reactRefreshHookSignatures?: boolean;
+    /** Remove console.* calls. */
+    dropConsole?: boolean;
+    /** Remove debugger statements. */
+    dropDebugger?: boolean;
+    /** Escape non-ASCII to \uXXXX. */
+    asciiOnly?: boolean;
+    /** Do not escape non-ASCII. */
+    charsetUtf8?: boolean;
+    /** Strip Flow types. */
+    flow?: boolean;
+    /** legacy decorator transform. */
+    experimentalDecorators?: boolean;
+    /** decorator metadata emit */
+    emitDecoratorMetadata?: boolean;
+    /** Transform class fields → `constructor` this.x = v (default: true). */
+    useDefineForClassFields?: boolean;
+    /** verbatimModuleSyntax (TS 5.0+): when true, unused value imports are not elided. */
+    verbatimModuleSyntax?: boolean;
+    /**
+     * Path to tsconfig.json (file or directory). When set, compilerOptions are
+     * auto-loaded and merged. Fields set explicitly via JS options take
+     * precedence — only unspecified fields are filled from the tsconfig values.
+     * e.g. "./tsconfig.json" or "./project-dir".
+     */
+    tsconfigPath?: string;
+    /**
+     * Inline tsconfig JSON string (same meaning as esbuild's `tsconfigRaw`).
+     * When set, both `tsconfigPath` and autodiscovery are ignored — raw is the
+     * single source of truth. The Zig-side `tsconfig_merge` applies
+     * compilerOptions such as jsx/target/decorators directly.
+     */
+    tsconfigRaw?: string;
+    /** Module format. */
+    format?: 'esm' | 'cjs';
+    /** String quote style. */
+    quotes?: 'double' | 'single' | 'preserve';
+    /** Target platform. */
+    platform?: Platform;
+    /** ES downlevel target. */
+    target?: Target;
+    /**
+     * browserslist query (e.g. "last 2 versions", ">1%, not dead").
+     * Takes precedence over target when set. Resolved only in the core package
+     * (depends on browserslist).
+     */
+    browserslist?: string | string[];
+    /** The source map's sourceRoot field (default: empty string). */
+    sourceRoot?: string;
+    /**
+     * Identifier substitution pairs. `value` is raw JSON (strings must include
+     * the surrounding quotes).
+     * e.g. `[{ key: "process.env.NODE_ENV", value: "\"production\"" }]`
+     */
+    define?: Array<{
+        key: string;
+        value: string;
+    }>;
+    /**
+     * Pipeline early-exit point — for debug/profile. When set, all stages after
+     * the given phase are skipped and empty output is returned. Useful combined
+     * with `profile` to measure a specific phase's cost in isolation.
+     *
+     * - "scan": Scanner token drain only
+     * - "parse": after Parser AST construction
+     * - "semantic": after the Semantic analyzer
+     * - "transform": after the Transformer
+     * - "codegen": full run (same as the default behavior)
+     */
+    stopAfter?: 'scan' | 'parse' | 'semantic' | 'transform' | 'codegen';
+}
+export interface TranspileResult {
+    /** Transformed JavaScript code. */
+    code: string;
+    /** Source map JSON (when sourcemap: true). */
+    map?: string;
+    /**
+     * Full error text rendered in the same format as the CLI when semantic
+     * errors are present. tsc-compatible policy: code is still returned even
+     * when there are errors. Playgrounds/IDEs parse this field to display
+     * markers.
+     */
+    errors?: string;
+}
+export declare const ES_TARGET_BITS: Record<string, number>;
+export declare function targetToUnsupported(target?: Target): number;
+/**
+ * Narrows whether `value` is a plain object (non-null, not an array).
+ * Use this to narrow a value of unknown shape — such as a `JSON.parse` result
+ * or a dynamic config object — to `Record<string, unknown>`. Shared across
+ * functional config / workspace entries / tsconfigRaw validation, etc.
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Pre-validates user-supplied `tsconfigRaw` input.
+ *
+ * NAPI (`napi_entry.zig` / `transpile.zig`) silently falls back to an empty
+ * TsConfig on raw parse failure, so an invalid raw passed through looks to the
+ * user as if the option were ignored. Called from both the CLI and JS API
+ * entry points so they uniformly throw the same explicit error
+ * (`failed to parse --tsconfig-raw: ...`). No-op when undefined.
+ */
+export declare function validateTsConfigRaw(raw: string | undefined): void;
+/**
+ * Serializes TranspileOptions into Zig `ConfigOptionsDto` JSON.
+ *
+ * - Default values are omitted (minimizes payload size).
+ * - enum keys match the Zig enum name (e.g. "react-native" → "react_native").
+ * - The browserslist resolution result can be injected as the
+ *   `unsupportedOverride` number. When set, it takes precedence over the
+ *   `target`-based fallback on the Zig side.
+ * - `define` is serialized as a `[{ key, value }]` array (compatible with Zig
+ *   DefineEntry).
+ */
+export declare function buildOptionsJson(opts?: TranspileOptions, unsupportedOverride?: number): string;
+export type { Engine, EngineVersion, Feature } from './compat-engines';
+export { computeUnsupportedFromEngines, FEATURES } from './compat-engines';
+import type { EngineVersion } from './compat-engines';
+/** browserslist result string ("chrome 100", "ios_saf 14.5") → EngineVersion. */
+export declare function parseBrowserslistEntry(entry: string): EngineVersion | null;
+/**
+ * browserslist result string array → unsupported bitmask.
+ * Unmappable engines (samsung, kaios, etc.) are ignored (engines ZNTC does not
+ * target).
+ */
+export declare function browserslistToUnsupported(entries: string[]): number;

package/dist/wasm/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @zntc/wasm — ZNTC TypeScript 트랜스파일러 WASM 바인딩
+ *
+ * @example
+ * ```ts
+ * import { init, transpile } from "@zntc/wasm";
+ * await init();
+ * const result = transpile("const x: number = 1;", { target: "es5" });
+ * console.log(result.code);
+ * ```
+ */
+export type { Target, Platform, TranspileOptions, TranspileResult } from '../shared/index';
+import type { Target, TranspileOptions, TranspileResult } from '../shared/index';
+export declare function init(input?: URL | string | Request | Response | BufferSource | WebAssembly.Module): Promise<void>;
+export declare function initSync(input: WebAssembly.Module | BufferSource): void;
+export declare function transpile(source: string, options?: TranspileOptions): TranspileResult;
+export declare class VirtualFileSystem {
+    private files;
+    set(path: string, content: string | Uint8Array): void;
+    get(path: string): Uint8Array | undefined;
+    has(path: string): boolean;
+    delete(path: string): boolean;
+    paths(): IterableIterator<string>;
+    size(): number;
+    clear(): void;
+}
+export declare function initBundler(vfs: VirtualFileSystem, input?: URL | string | Request | Response | BufferSource | WebAssembly.Module): Promise<void>;
+export declare function bundlerVersion(): number;
+export interface BundleResult {
+    code: string;
+}
+export interface BundleOptionsInput {
+    format?: 'esm' | 'cjs' | 'iife' | 'umd' | 'amd';
+    platform?: 'browser' | 'node' | 'neutral' | 'react-native';
+    external?: string[];
+    minify?: boolean;
+    minifyWhitespace?: boolean;
+    minifyIdentifiers?: boolean;
+    minifySyntax?: boolean;
+    codeSplitting?: boolean;
+    preserveModules?: boolean;
+    target?: Target;
+    unsupported?: number;
+    jsx?: 'classic' | 'automatic' | 'automatic-dev';
+    jsxFactory?: string;
+    jsxFragment?: string;
+    jsxImportSource?: string;
+    flow?: boolean;
+    jsxInJs?: boolean;
+    experimentalDecorators?: boolean;
+    emitDecoratorMetadata?: boolean;
+    useDefineForClassFields?: boolean;
+    charsetUtf8?: boolean;
+    keepNames?: boolean;
+    sourcemap?: boolean;
+}
+export declare function bundlerLastErrorMessage(): string;
+export declare function build(entryPath: string, options?: BundleOptionsInput): BundleResult | null;
+export interface OutputChunk {
+    path: string;
+    code: string;
+}
+export declare function buildChunks(entryPath: string, options?: BundleOptionsInput): OutputChunk[] | null;

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@zntc/wasm",
+  "version": "0.1.0",
+  "description": "ZNTC native transpiler & compiler — WASM build",
+  "keywords": [
+    "browser",
+    "bundler",
+    "compiler",
+    "deno",
+    "javascript",
+    "transpiler",
+    "typescript",
+    "wasm",
+    "webassembly",
+    "workers",
+    "zntc"
+  ],
+  "homepage": "https://ohah.github.io/zntc",
+  "bugs": {
+    "url": "https://github.com/ohah/zntc/issues"
+  },
+  "license": "MIT",
+  "author": "ohah",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ohah/zntc.git",
+    "directory": "packages/wasm"
+  },
+  "files": [
+    "dist/",
+    "zntc.wasm",
+    "zntc-bundler.wasm"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/wasm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/wasm/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./zntc.wasm": "./zntc.wasm",
+    "./zntc-bundler.wasm": "./zntc-bundler.wasm"
+  },
+  "scripts": {
+    "build:wasm": "cd ../.. && zig build wasm && zig build wasm-bundler",
+    "build:js": "bun build index.ts --outdir dist --format esm --target browser --external 'node:*'",
+    "build:dts": "bun x tsc -b",
+    "build": "bun run build:wasm && cp ../../zig-out/bin/zntc.wasm . && cp ../../zig-out/bin/zntc-bundler.wasm . && bun run build:js && bun run build:dts",
+    "test": "bun test --timeout 10000",
+    "prepublishOnly": "bun run build && bunx publint --strict --level error ."
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  }
+}